langchain 0.0.130 → 0.0.132

package/dist/retrievers/self_query/supabase.cjs

@@ -4,6 +4,12 @@ exports.SupabaseTranslator = void 0;
 const ir_js_1 = require("../../chains/query_constructor/ir.cjs");
 const base_js_1 = require("./base.cjs");
 const utils_js_1 = require("./utils.cjs");
+const supabase_utils_js_1 = require("./supabase_utils.cjs");
+/**
+ * A specialized translator designed to work with Supabase, extending the
+ * BaseTranslator class. It translates structured queries into a format
+ * that can be understood by the Supabase database.
+ */
 class SupabaseTranslator extends base_js_1.BaseTranslator {
     constructor() {
         super(...arguments);
@@ -30,6 +36,13 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
     formatFunction() {
         throw new Error("Not implemented");
     }
+    /**
+     * Returns a function that applies the appropriate comparator operation on
+     * the attribute and value provided. The function returned is used to
+     * filter data in a Supabase database.
+     * @param comparator The comparator to be used in the operation.
+     * @returns A function that applies the comparator operation on the attribute and value provided.
+     */
     getComparatorFunction(comparator) {
         switch (comparator) {
             case ir_js_1.Comparators.eq: {
@@ -55,19 +68,37 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
             }
         }
     }
+    /**
+     * Builds a column name based on the attribute and value provided. The
+     * column name is used in filtering data in a Supabase database.
+     * @param attr The attribute to be used in the column name.
+     * @param value The value to be used in the column name.
+     * @param includeType Whether to include the data type in the column name.
+     * @returns The built column name.
+     */
     buildColumnName(attr, value, includeType = true) {
         let column = "";
-        if (typeof value === "string") {
+        if ((0, utils_js_1.isString)(value)) {
             column = `metadata->>${attr}`;
         }
-        else if (typeof value === "number") {
+        else if ((0, utils_js_1.isInt)(value)) {
             column = `metadata->${attr}${includeType ? "::int" : ""}`;
         }
+        else if ((0, utils_js_1.isFloat)(value)) {
+            column = `metadata->${attr}${includeType ? "::float" : ""}`;
+        }
         else {
             throw new Error("Data type not supported");
         }
         return column;
     }
+    /**
+     * Visits an operation and returns a string representation of it. This is
+     * used in translating a structured query into a format that can be
+     * understood by Supabase.
+     * @param operation The operation to be visited.
+     * @returns A string representation of the operation.
+     */
     visitOperationAsString(operation) {
         const { args } = operation;
         if (!args) {
@@ -86,6 +117,13 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
         }, [])
             .join(",");
     }
+    /**
+     * Visits an operation and returns a function that applies the operation
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param operation The operation to be visited.
+     * @returns A function that applies the operation on a Supabase database.
+     */
     visitOperation(operation) {
         const { operator, args } = operation;
         if (this.allowedOperators.includes(operator)) {
@@ -110,6 +148,13 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
             throw new Error("Operator not allowed");
         }
     }
+    /**
+     * Visits a comparison and returns a string representation of it. This is
+     * used in translating a structured query into a format that can be
+     * understood by Supabase.
+     * @param comparison The comparison to be visited.
+     * @returns A string representation of the comparison.
+     */
     visitComparisonAsString(comparison) {
         let { value } = comparison;
         const { comparator: _comparator, attribute } = comparison;
@@ -128,6 +173,13 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
         }
         return `${this.buildColumnName(attribute, value, false)}.${comparator}.${value}}`;
     }
+    /**
+     * Visits a comparison and returns a function that applies the comparison
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param comparison The comparison to be visited.
+     * @returns A function that applies the comparison on a Supabase database.
+     */
     visitComparison(comparison) {
         const { comparator, attribute, value } = comparison;
         if (this.allowedComparators.includes(comparator)) {
@@ -138,6 +190,13 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
             throw new Error("Comparator not allowed");
         }
     }
+    /**
+     * Visits a structured query and returns a function that applies the query
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param query The structured query to be visited.
+     * @returns A function that applies the query on a Supabase database.
+     */
     visitStructuredQuery(query) {
         if (!query.filter) {
             return {};
@@ -145,10 +204,15 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
         const filterFunction = query.filter?.accept(this);
         return { filter: filterFunction ?? {} };
     }
+    /**
+     * Merges two filters into one. The merged filter can be used to filter
+     * data in a Supabase database.
+     * @param defaultFilter The default filter to be merged.
+     * @param generatedFilter The generated filter to be merged.
+     * @param mergeType The type of merge to be performed. It can be 'and', 'or', or 'replace'.
+     * @returns The merged filter.
+     */
     mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
-        if (mergeType === "or") {
-            throw new Error("Supabase self-query filter does not support merging two filters with the OR operator");
-        }
         if ((0, utils_js_1.isFilterEmpty)(defaultFilter) && (0, utils_js_1.isFilterEmpty)(generatedFilter)) {
             return undefined;
         }
@@ -164,8 +228,28 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
             }
             return defaultFilter;
         }
-        if (mergeType === "and") {
-            return (rpc) => generatedFilter(defaultFilter(rpc));
+        let myDefaultFilter = defaultFilter;
+        if ((0, utils_js_1.isObject)(defaultFilter)) {
+            const { filter } = this.visitStructuredQuery((0, supabase_utils_js_1.convertObjectFilterToStructuredQuery)(defaultFilter));
+            // just in case the built filter is empty somehow
+            if ((0, utils_js_1.isFilterEmpty)(filter)) {
+                if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+                    return undefined;
+                }
+                return generatedFilter;
+            }
+            myDefaultFilter = filter;
+        }
+        // After this point, myDefaultFilter will always be SupabaseFilterRPCCall
+        if (mergeType === "or") {
+            return (rpc) => {
+                const defaultFlattenedParams = supabase_utils_js_1.ProxyParamsDuplicator.getFlattenedParams(rpc, myDefaultFilter);
+                const generatedFlattenedParams = supabase_utils_js_1.ProxyParamsDuplicator.getFlattenedParams(rpc, generatedFilter);
+                return rpc.or(`${defaultFlattenedParams},${generatedFlattenedParams}`);
+            };
+        }
+        else if (mergeType === "and") {
+            return (rpc) => generatedFilter(myDefaultFilter(rpc));
         }
         else {
             throw new Error("Unknown merge type");

package/dist/retrievers/self_query/supabase.d.ts

@@ -1,6 +1,10 @@
 import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "../../chains/query_constructor/ir.js";
-import { SupabaseFilterRPCCall, SupabaseVectorStore } from "../../vectorstores/supabase.js";
+import type { SupabaseFilterRPCCall, SupabaseMetadata, SupabaseVectorStore } from "../../vectorstores/supabase.js";
 import { BaseTranslator } from "./base.js";
+/**
+ * Represents the possible values that can be used in a comparison in a
+ * structured query. It can be a string or a number.
+ */
 type ValueType = {
     eq: string | number;
     ne: string | number;
@@ -9,19 +13,82 @@ type ValueType = {
     gt: string | number;
     gte: string | number;
 };
+/**
+ * A specialized translator designed to work with Supabase, extending the
+ * BaseTranslator class. It translates structured queries into a format
+ * that can be understood by the Supabase database.
+ */
 export declare class SupabaseTranslator<T extends SupabaseVectorStore> extends BaseTranslator<T> {
     VisitOperationOutput: SupabaseFilterRPCCall;
     VisitComparisonOutput: SupabaseFilterRPCCall;
     allowedOperators: Operator[];
     allowedComparators: Comparator[];
     formatFunction(): string;
+    /**
+     * Returns a function that applies the appropriate comparator operation on
+     * the attribute and value provided. The function returned is used to
+     * filter data in a Supabase database.
+     * @param comparator The comparator to be used in the operation.
+     * @returns A function that applies the comparator operation on the attribute and value provided.
+     */
     getComparatorFunction<C extends Comparator>(comparator: Comparator): (attr: string, value: ValueType[C]) => SupabaseFilterRPCCall;
+    /**
+     * Builds a column name based on the attribute and value provided. The
+     * column name is used in filtering data in a Supabase database.
+     * @param attr The attribute to be used in the column name.
+     * @param value The value to be used in the column name.
+     * @param includeType Whether to include the data type in the column name.
+     * @returns The built column name.
+     */
     buildColumnName(attr: string, value: string | number, includeType?: boolean): string;
+    /**
+     * Visits an operation and returns a string representation of it. This is
+     * used in translating a structured query into a format that can be
+     * understood by Supabase.
+     * @param operation The operation to be visited.
+     * @returns A string representation of the operation.
+     */
     visitOperationAsString(operation: Operation): string;
+    /**
+     * Visits an operation and returns a function that applies the operation
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param operation The operation to be visited.
+     * @returns A function that applies the operation on a Supabase database.
+     */
     visitOperation(operation: Operation): this["VisitOperationOutput"];
+    /**
+     * Visits a comparison and returns a string representation of it. This is
+     * used in translating a structured query into a format that can be
+     * understood by Supabase.
+     * @param comparison The comparison to be visited.
+     * @returns A string representation of the comparison.
+     */
     visitComparisonAsString(comparison: Comparison): string;
+    /**
+     * Visits a comparison and returns a function that applies the comparison
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param comparison The comparison to be visited.
+     * @returns A function that applies the comparison on a Supabase database.
+     */
     visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
+    /**
+     * Visits a structured query and returns a function that applies the query
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param query The structured query to be visited.
+     * @returns A function that applies the query on a Supabase database.
+     */
     visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
-    mergeFilters(defaultFilter: SupabaseFilterRPCCall | undefined, generatedFilter: SupabaseFilterRPCCall | undefined, mergeType?: string): SupabaseFilterRPCCall | undefined;
+    /**
+     * Merges two filters into one. The merged filter can be used to filter
+     * data in a Supabase database.
+     * @param defaultFilter The default filter to be merged.
+     * @param generatedFilter The generated filter to be merged.
+     * @param mergeType The type of merge to be performed. It can be 'and', 'or', or 'replace'.
+     * @returns The merged filter.
+     */
+    mergeFilters(defaultFilter: SupabaseFilterRPCCall | SupabaseMetadata | undefined, generatedFilter: SupabaseFilterRPCCall | undefined, mergeType?: string): SupabaseFilterRPCCall | SupabaseMetadata | undefined;
 }
 export {};

package/dist/retrievers/self_query/supabase.js

@@ -1,6 +1,12 @@
 import { Comparators, Operators, } from "../../chains/query_constructor/ir.js";
 import { BaseTranslator } from "./base.js";
-import { isFilterEmpty } from "./utils.js";
+import { isFilterEmpty, isFloat, isInt, isObject, isString } from "./utils.js";
+import { ProxyParamsDuplicator, convertObjectFilterToStructuredQuery, } from "./supabase_utils.js";
+/**
+ * A specialized translator designed to work with Supabase, extending the
+ * BaseTranslator class. It translates structured queries into a format
+ * that can be understood by the Supabase database.
+ */
 export class SupabaseTranslator extends BaseTranslator {
     constructor() {
         super(...arguments);
@@ -27,6 +33,13 @@ export class SupabaseTranslator extends BaseTranslator {
     formatFunction() {
         throw new Error("Not implemented");
     }
+    /**
+     * Returns a function that applies the appropriate comparator operation on
+     * the attribute and value provided. The function returned is used to
+     * filter data in a Supabase database.
+     * @param comparator The comparator to be used in the operation.
+     * @returns A function that applies the comparator operation on the attribute and value provided.
+     */
     getComparatorFunction(comparator) {
         switch (comparator) {
             case Comparators.eq: {
@@ -52,19 +65,37 @@ export class SupabaseTranslator extends BaseTranslator {
             }
         }
     }
+    /**
+     * Builds a column name based on the attribute and value provided. The
+     * column name is used in filtering data in a Supabase database.
+     * @param attr The attribute to be used in the column name.
+     * @param value The value to be used in the column name.
+     * @param includeType Whether to include the data type in the column name.
+     * @returns The built column name.
+     */
     buildColumnName(attr, value, includeType = true) {
         let column = "";
-        if (typeof value === "string") {
+        if (isString(value)) {
             column = `metadata->>${attr}`;
         }
-        else if (typeof value === "number") {
+        else if (isInt(value)) {
             column = `metadata->${attr}${includeType ? "::int" : ""}`;
         }
+        else if (isFloat(value)) {
+            column = `metadata->${attr}${includeType ? "::float" : ""}`;
+        }
         else {
             throw new Error("Data type not supported");
         }
         return column;
     }
+    /**
+     * Visits an operation and returns a string representation of it. This is
+     * used in translating a structured query into a format that can be
+     * understood by Supabase.
+     * @param operation The operation to be visited.
+     * @returns A string representation of the operation.
+     */
     visitOperationAsString(operation) {
         const { args } = operation;
         if (!args) {
@@ -83,6 +114,13 @@ export class SupabaseTranslator extends BaseTranslator {
         }, [])
             .join(",");
     }
+    /**
+     * Visits an operation and returns a function that applies the operation
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param operation The operation to be visited.
+     * @returns A function that applies the operation on a Supabase database.
+     */
     visitOperation(operation) {
         const { operator, args } = operation;
         if (this.allowedOperators.includes(operator)) {
@@ -107,6 +145,13 @@ export class SupabaseTranslator extends BaseTranslator {
             throw new Error("Operator not allowed");
         }
     }
+    /**
+     * Visits a comparison and returns a string representation of it. This is
+     * used in translating a structured query into a format that can be
+     * understood by Supabase.
+     * @param comparison The comparison to be visited.
+     * @returns A string representation of the comparison.
+     */
     visitComparisonAsString(comparison) {
         let { value } = comparison;
         const { comparator: _comparator, attribute } = comparison;
@@ -125,6 +170,13 @@ export class SupabaseTranslator extends BaseTranslator {
         }
         return `${this.buildColumnName(attribute, value, false)}.${comparator}.${value}}`;
     }
+    /**
+     * Visits a comparison and returns a function that applies the comparison
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param comparison The comparison to be visited.
+     * @returns A function that applies the comparison on a Supabase database.
+     */
     visitComparison(comparison) {
         const { comparator, attribute, value } = comparison;
         if (this.allowedComparators.includes(comparator)) {
@@ -135,6 +187,13 @@ export class SupabaseTranslator extends BaseTranslator {
             throw new Error("Comparator not allowed");
         }
     }
+    /**
+     * Visits a structured query and returns a function that applies the query
+     * on a Supabase database. This is used in translating a structured query
+     * into a format that can be understood by Supabase.
+     * @param query The structured query to be visited.
+     * @returns A function that applies the query on a Supabase database.
+     */
     visitStructuredQuery(query) {
         if (!query.filter) {
             return {};
@@ -142,10 +201,15 @@ export class SupabaseTranslator extends BaseTranslator {
         const filterFunction = query.filter?.accept(this);
         return { filter: filterFunction ?? {} };
     }
+    /**
+     * Merges two filters into one. The merged filter can be used to filter
+     * data in a Supabase database.
+     * @param defaultFilter The default filter to be merged.
+     * @param generatedFilter The generated filter to be merged.
+     * @param mergeType The type of merge to be performed. It can be 'and', 'or', or 'replace'.
+     * @returns The merged filter.
+     */
     mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
-        if (mergeType === "or") {
-            throw new Error("Supabase self-query filter does not support merging two filters with the OR operator");
-        }
         if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {
             return undefined;
         }
@@ -161,8 +225,28 @@ export class SupabaseTranslator extends BaseTranslator {
             }
             return defaultFilter;
         }
-        if (mergeType === "and") {
-            return (rpc) => generatedFilter(defaultFilter(rpc));
+        let myDefaultFilter = defaultFilter;
+        if (isObject(defaultFilter)) {
+            const { filter } = this.visitStructuredQuery(convertObjectFilterToStructuredQuery(defaultFilter));
+            // just in case the built filter is empty somehow
+            if (isFilterEmpty(filter)) {
+                if (isFilterEmpty(generatedFilter)) {
+                    return undefined;
+                }
+                return generatedFilter;
+            }
+            myDefaultFilter = filter;
+        }
+        // After this point, myDefaultFilter will always be SupabaseFilterRPCCall
+        if (mergeType === "or") {
+            return (rpc) => {
+                const defaultFlattenedParams = ProxyParamsDuplicator.getFlattenedParams(rpc, myDefaultFilter);
+                const generatedFlattenedParams = ProxyParamsDuplicator.getFlattenedParams(rpc, generatedFilter);
+                return rpc.or(`${defaultFlattenedParams},${generatedFlattenedParams}`);
+            };
+        }
+        else if (mergeType === "and") {
+            return (rpc) => generatedFilter(myDefaultFilter(rpc));
         }
         else {
             throw new Error("Unknown merge type");