feat(core): Add support for boolean metadata attributes in FunctionalTranslator

langchain-core/src/structured_query/base.ts

@@ -100,7 +100,7 @@ export class BasicTranslator<
         this.allowedComparators.indexOf(func as Comparator) === -1
       ) {
         throw new Error(
-          `Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(
+          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(
             ", "
           )}`
         );

langchain-core/src/structured_query/functional.ts

@@ -17,8 +17,8 @@ import { castValue, isFilterEmpty } from "./utils.js";
  * the result of a comparison operation.
  */
 type ValueType = {
-  eq: string | number;
-  ne: string | number;
+  eq: string | number | boolean;
+  ne: string | number | boolean;
   lt: string | number;
   lte: string | number;
   gt: string | number;
@@ -65,7 +65,29 @@ export class FunctionalTranslator extends BaseTranslator {
   formatFunction(): string {
     throw new Error("Not implemented");
   }
-
+
+  /**
+   * Returns the allowed comparators for a given data type.
+   * @param input The input value to get the allowed comparators for.
+   * @returns An array of allowed comparators for the input data type.
+   */
+  getAllowedComparatorsForType(inputType: string): Comparator[] {
+    switch (inputType) {
+      case "string": {
+        return [Comparators.eq, Comparators.ne, Comparators.gt, Comparators.gte, Comparators.lt, Comparators.lte];
+      }
+      case "number": {
+        return [Comparators.eq, Comparators.ne, Comparators.gt, Comparators.gte, Comparators.lt, Comparators.lte];
+      }
+      case "boolean": {
+        return [Comparators.eq, Comparators.ne];
+      }
+      default: {
+        throw new Error(`Unsupported data type: ${inputType}`);
+      }
+    }
+  }
+
   /**
    * Returns a function that performs a comparison based on the provided
    * comparator.
@@ -159,6 +181,9 @@ export class FunctionalTranslator extends BaseTranslator {
     const { comparator, attribute, value } = comparison;
     const undefinedTrue = [Comparators.ne];
     if (this.allowedComparators.includes(comparator)) {
+      if (!this.getAllowedComparatorsForType(typeof value).includes(comparator)) {
+        throw new Error(`'${comparator}' comparator not allowed to be used with ${typeof value}`);
+      }
       const comparatorFunction = this.getComparatorFunction(comparator);
       return (document: Document) => {
         const documentValue = document.metadata[attribute];

langchain-core/src/structured_query/ir.ts

@@ -82,7 +82,7 @@ export type VisitorOperationResult = {
  */
 export type VisitorComparisonResult = {
   [attr: string]: {
-    [comparator: string]: string | number;
+    [comparator: string]: string | number | boolean;
   };
 };
 
@@ -155,7 +155,7 @@ export class Comparison extends FilterDirective {
   constructor(
     public comparator: Comparator,
     public attribute: string,
-    public value: string | number
+    public value: string | number | boolean
   ) {
     super();
   }

langchain-core/src/structured_query/tests/functional.test.ts

@@ -0,0 +1,310 @@
+import { test, expect } from "@jest/globals";
+import { Document } from "../../documents/document.js";
+import { FunctionalTranslator } from "../functional.js";
+import { Comparators, Visitor } from "../ir.js";
+
+describe("FunctionalTranslator", () => {
+  const translator = new FunctionalTranslator();
+
+  describe("getAllowedComparatorsForType", () => {
+    test("string", () => {
+      expect(translator.getAllowedComparatorsForType("string")).toEqual([
+        Comparators.eq,
+        Comparators.ne,
+        Comparators.gt,
+        Comparators.gte,
+        Comparators.lt,
+        Comparators.lte,
+      ]);
+    });
+    test("number", () => {
+      expect(translator.getAllowedComparatorsForType("number")).toEqual([
+        Comparators.eq,
+        Comparators.ne,
+        Comparators.gt,
+        Comparators.gte,
+        Comparators.lt,
+        Comparators.lte,
+      ]);
+    });
+    test("boolean", () => {
+      expect(translator.getAllowedComparatorsForType("boolean")).toEqual([
+        Comparators.eq,
+        Comparators.ne,
+      ]);
+    });
+    test("unsupported", () => {
+      expect(() =>
+        translator.getAllowedComparatorsForType("unsupported")
+      ).toThrow("Unsupported data type: unsupported");
+    });
+  });
+
+  describe("visitComparison", () => {
+    describe("returns true or false for valid comparisons", () => {
+      const attributesByType = {
+        string: "stringValue",
+        number: "numberValue",
+        boolean: "booleanValue",
+      };
+
+      const inputValuesByAttribute: { [key in string]: string | number | boolean } = {
+        stringValue: "value",
+        numberValue: 1,
+        booleanValue: true,
+      };
+
+      // documents that will match against the comparison
+      const validDocumentsByComparator: { [key in string]: Document<Record<string, unknown>>[] } = {
+        [Comparators.eq]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.ne]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "not-value",
+              numberValue: 0,
+              booleanValue: false,
+            },
+          }),
+        ],
+        [Comparators.gt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.gte]: [
+          // test for greater than
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+          // test for equal to
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.lt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "val",
+              numberValue: 0,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.lte]: [
+          // test for less than
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "val",
+              numberValue: 0,
+              booleanValue: true,
+            },
+          }),
+          // test for equal to
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+      };
+
+      // documents that will not match against the comparison
+      const invalidDocumentsByComparator: { [key in string]: Document<Record<string, unknown>>[] } = {
+        [Comparators.eq]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "not-value",
+              numberValue: 0,
+              booleanValue: false,
+            },
+          }),
+        ],
+        [Comparators.ne]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.gt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "value",
+              numberValue: 1,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.gte]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "val",
+              numberValue: 0,
+              booleanValue: false,
+            },
+          }),
+        ],
+        [Comparators.lt]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+        ],
+        [Comparators.lte]: [
+          new Document({
+            pageContent: "",
+            metadata: {
+              stringValue: "valueee",
+              numberValue: 2,
+              booleanValue: true,
+            },
+          }),
+        ],
+      };
+
+      const stringComparators = translator.getAllowedComparatorsForType("string");
+      for (const comparator of stringComparators) {
+        const attribute = attributesByType.string;
+        const value = inputValuesByAttribute[attribute];
+        const validDocuments = validDocumentsByComparator[comparator];
+        for (const validDocument of validDocuments) {
+          test(`${value} -> ${comparator} -> ${validDocument.metadata[attribute]}`, () => {
+            const comparison = translator.visitComparison({
+              attribute,
+              comparator,
+              value,
+              exprName: "Comparison",
+              accept: (visitor: Visitor) => visitor,
+            });
+            const result = comparison(validDocument);
+            expect(result).toBeTruthy();
+          });
+        }
+
+        const invalidDocuments = invalidDocumentsByComparator[comparator];
+        for (const invalidDocument of invalidDocuments) {
+          test(`${value} -> ${comparator} -> ${invalidDocument.metadata[attribute]}`, () => {
+            const comparison = translator.visitComparison({
+              attribute,
+              comparator,
+              value,
+              exprName: "Comparison",
+              accept: (visitor: Visitor) => visitor,
+            });
+            const result = comparison(invalidDocument);
+            expect(result).toBeFalsy();
+          });
+        }
+      }
+
+      const numberComparators = translator.getAllowedComparatorsForType("number");
+      for (const comparator of numberComparators) {
+        const attribute = attributesByType.number;
+        const value = inputValuesByAttribute[attribute];
+        const validDocuments = validDocumentsByComparator[comparator];
+        for (const validDocument of validDocuments) {
+          test(`${value} -> ${comparator} -> ${validDocument.metadata[attribute]}`, () => {
+            const comparison = translator.visitComparison({
+              attribute,
+              comparator,
+              value,
+              exprName: "Comparison",
+              accept: (visitor: Visitor) => visitor,
+            });
+            const result = comparison(validDocument);
+            expect(result).toBeTruthy();
+          });
+        }
+
+        const invalidDocuments = invalidDocumentsByComparator[comparator];
+        for (const invalidDocument of invalidDocuments) {
+          test(`${value} -> ${comparator} -> ${invalidDocument.metadata[attribute]}`, () => {
+            const comparison = translator.visitComparison({
+              attribute,
+              comparator,
+              value,
+              exprName: "Comparison",
+              accept: (visitor: Visitor) => visitor,
+            });
+            const result = comparison(invalidDocument);
+            expect(result).toBeFalsy();
+          });
+        }
+      }
+
+      const booleanComparators = translator.getAllowedComparatorsForType("boolean");
+      for (const comparator of booleanComparators) {
+        const attribute = attributesByType.boolean;
+        const value = inputValuesByAttribute[attribute];
+        const validDocuments = validDocumentsByComparator[comparator];
+        for (const validDocument of validDocuments) {
+          test(`${value} -> ${comparator} -> ${validDocument.metadata[attribute]}`, () => {
+            const comparison = translator.visitComparison({
+              attribute,
+              comparator,
+              value,
+              exprName: "Comparison",
+              accept: (visitor: Visitor) => visitor,
+            });
+            const result = comparison(validDocument);
+            expect(result).toBeTruthy();
+          });
+        }
+        const invalidDocuments = invalidDocumentsByComparator[comparator];
+        for (const invalidDocument of invalidDocuments) {
+          test(`${value} -> ${comparator} -> ${invalidDocument.metadata[attribute]}`, () => {
+            const comparison = translator.visitComparison({
+              attribute,
+              comparator,
+              value,
+              exprName: "Comparison",
+              accept: (visitor: Visitor) => visitor,
+            });
+            const result = comparison(invalidDocument);
+            expect(result).toBeFalsy();
+          });
+        }
+      }
+    });
+  });
+});