langchain 0.0.131 → 0.0.132

package/dist/retrievers/self_query/supabase.js

@@ -2,6 +2,11 @@ import { Comparators, Operators, } from "../../chains/query_constructor/ir.js";
 import { BaseTranslator } from "./base.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);
@@ -28,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: {
@@ -53,6 +65,14 @@ 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 (isString(value)) {
@@ -69,6 +89,13 @@ export class SupabaseTranslator extends BaseTranslator {
         }
         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) {
@@ -87,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)) {
@@ -111,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;
@@ -129,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)) {
@@ -139,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 {};
@@ -146,6 +201,14 @@ 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 (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {
             return undefined;

package/dist/retrievers/self_query/supabase_utils.cjs

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertObjectFilterToStructuredQuery = exports.ProxyParamsDuplicator = void 0;
 const ir_js_1 = require("../../chains/query_constructor/ir.cjs");
+/**
+ * Utility class used to duplicate parameters for a proxy object,
+ * specifically designed to work with `SupabaseFilter` objects. It
+ * contains methods to handle different types of operations such as "or",
+ * "filter", "in", "contains", "textSearch", "match", "not", and default
+ * operations.
+ */
 class ProxyParamsDuplicator {
     constructor() {
         Object.defineProperty(this, "duplicationAllowedOps", {
@@ -33,6 +40,12 @@ class ProxyParamsDuplicator {
             value: []
         });
     }
+    /**
+     * Creates a proxy handler for a `SupabaseFilter` object. The handler
+     * intercepts get operations and applies specific logic based on the
+     * property being accessed.
+     * @returns A proxy handler for a `SupabaseFilter` object.
+     */
     buildProxyHandler() {
         const proxyHandler = {
             get: (target, prop, receiver) => {
@@ -87,6 +100,11 @@ class ProxyParamsDuplicator {
         };
         return proxyHandler;
     }
+    /**
+     * Removes type annotations from a value string.
+     * @param value The value string to clean.
+     * @returns The cleaned value string.
+     */
     removeType(value) {
         let cleanedValue = value;
         if (cleanedValue.includes("::float")) {
@@ -97,16 +115,38 @@ class ProxyParamsDuplicator {
         }
         return cleanedValue;
     }
+    /**
+     * Adds a default operation clause to the values array.
+     * @param prop The operation property.
+     * @param column The column to apply the operation to.
+     * @param value The value for the operation.
+     */
     addDefaultOpClause(prop, column, value) {
         this.values.push([this.removeType(column), `${String(prop)}.${value}`]);
     }
+    /**
+     * Adds an 'or' clause to the values array.
+     * @param filters The filters for the 'or' clause.
+     * @param foreignTable Optional foreign table for the 'or' clause.
+     */
     addOrClause(filters, { foreignTable } = {}) {
         const key = foreignTable ? `${foreignTable}.or` : "or";
         this.values.push([this.removeType(key), `(${filters})`]);
     }
+    /**
+     * Adds a 'filter' clause to the values array.
+     * @param column The column to apply the filter to.
+     * @param operator The operator for the filter.
+     * @param value The value for the filter.
+     */
     addFilterClause(column, operator, value) {
         this.values.push([this.removeType(column), `${operator}.${value}`]);
     }
+    /**
+     * Adds an 'in' clause to the values array.
+     * @param column The column to apply the 'in' clause to.
+     * @param values The values for the 'in' clause.
+     */
     addInClause(column, values) {
         const cleanedValues = values
             .map((s) => {
@@ -118,6 +158,11 @@ class ProxyParamsDuplicator {
             .join(",");
         this.values.push([this.removeType(column), `in.(${cleanedValues})`]);
     }
+    /**
+     * Adds a 'contains' clause to the values array.
+     * @param column The column to apply the 'contains' clause to.
+     * @param value The value for the 'contains' clause.
+     */
     addContainsClause(column, value) {
         if (typeof value === "string") {
             this.values.push([this.removeType(column), `cs.${value}`]);
@@ -132,6 +177,13 @@ class ProxyParamsDuplicator {
             ]);
         }
     }
+    /**
+     * Adds a 'textSearch' clause to the values array.
+     * @param column The column to apply the 'textSearch' clause to.
+     * @param query The query for the 'textSearch' clause.
+     * @param config Optional configuration for the 'textSearch' clause.
+     * @param type Optional type for the 'textSearch' clause.
+     */
     addTextSearchClause(column, query, { config, type, } = {}) {
         let typePart = "";
         if (type === "plain") {
@@ -149,20 +201,41 @@ class ProxyParamsDuplicator {
             `${typePart}fts${configPart}.${query}`,
         ]);
     }
+    /**
+     * Adds a 'not' clause to the values array.
+     * @param column The column to apply the 'not' clause to.
+     * @param operator The operator for the 'not' clause.
+     * @param value The value for the 'not' clause.
+     */
     addNotClause(column, operator, value) {
         this.values.push([column, `not.${operator}.${value}`]);
     }
+    /**
+     * Adds a 'match' clause to the values array.
+     * @param query The query for the 'match' clause.
+     */
     addMatchClause(query) {
         Object.entries(query).forEach(([column, value]) => {
             this.values.push([column, `eq.${value}`]);
         });
     }
+    /**
+     * Returns the flattened parameters as a string.
+     * @returns The flattened parameters as a string.
+     */
     flattenedParams() {
         const mapped = this.values.map(([k, v]) => `${k}.${v}`);
         if (mapped.length === 1)
             return mapped[0];
         return `and(${mapped.join(",")})`;
     }
+    /**
+     * Gets flattened parameters from a `SupabaseFilter` and a
+     * `SupabaseFilterRPCCall`.
+     * @param rpc The `SupabaseFilter` object.
+     * @param filter The `SupabaseFilterRPCCall` object.
+     * @returns The flattened parameters as a string.
+     */
     static getFlattenedParams(rpc, filter) {
         const proxiedDuplicator = new ProxyParamsDuplicator();
         const proxiedRpc = new Proxy(rpc, proxiedDuplicator.buildProxyHandler());
@@ -171,6 +244,11 @@ class ProxyParamsDuplicator {
     }
 }
 exports.ProxyParamsDuplicator = ProxyParamsDuplicator;
+/**
+ * Converts a `SupabaseMetadata` object into a `StructuredQuery` object.
+ * The function creates a new `StructuredQuery` object and uses the
+ * `Operation` and `Comparison` classes to build the query.
+ */
 function convertObjectFilterToStructuredQuery(objFilter) {
     return new ir_js_1.StructuredQuery("", new ir_js_1.Operation(ir_js_1.Operators.and, Object.entries(objFilter).map(([column, value]) => new ir_js_1.Comparison(ir_js_1.Comparators.eq, column, value))));
 }

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

@@ -1,24 +1,102 @@
 import { StructuredQuery } from "../../chains/query_constructor/ir.js";
 import type { SupabaseFilter, SupabaseFilterRPCCall, SupabaseMetadata } from "../../vectorstores/supabase.js";
+/**
+ * Utility class used to duplicate parameters for a proxy object,
+ * specifically designed to work with `SupabaseFilter` objects. It
+ * contains methods to handle different types of operations such as "or",
+ * "filter", "in", "contains", "textSearch", "match", "not", and default
+ * operations.
+ */
 export declare class ProxyParamsDuplicator {
     duplicationAllowedOps: string[];
     values: [string, string][];
+    /**
+     * Creates a proxy handler for a `SupabaseFilter` object. The handler
+     * intercepts get operations and applies specific logic based on the
+     * property being accessed.
+     * @returns A proxy handler for a `SupabaseFilter` object.
+     */
     buildProxyHandler(): ProxyHandler<SupabaseFilter>;
+    /**
+     * Removes type annotations from a value string.
+     * @param value The value string to clean.
+     * @returns The cleaned value string.
+     */
     removeType(value: string): string;
+    /**
+     * Adds a default operation clause to the values array.
+     * @param prop The operation property.
+     * @param column The column to apply the operation to.
+     * @param value The value for the operation.
+     */
     addDefaultOpClause(prop: string, column: string, value: unknown): void;
+    /**
+     * Adds an 'or' clause to the values array.
+     * @param filters The filters for the 'or' clause.
+     * @param foreignTable Optional foreign table for the 'or' clause.
+     */
     addOrClause(filters: string, { foreignTable }?: {
         foreignTable?: string;
     }): void;
+    /**
+     * Adds a 'filter' clause to the values array.
+     * @param column The column to apply the filter to.
+     * @param operator The operator for the filter.
+     * @param value The value for the filter.
+     */
     addFilterClause(column: string, operator: string, value: unknown): void;
+    /**
+     * Adds an 'in' clause to the values array.
+     * @param column The column to apply the 'in' clause to.
+     * @param values The values for the 'in' clause.
+     */
     addInClause(column: string, values: unknown[]): void;
+    /**
+     * Adds a 'contains' clause to the values array.
+     * @param column The column to apply the 'contains' clause to.
+     * @param value The value for the 'contains' clause.
+     */
     addContainsClause(column: string, value: unknown): void;
+    /**
+     * Adds a 'textSearch' clause to the values array.
+     * @param column The column to apply the 'textSearch' clause to.
+     * @param query The query for the 'textSearch' clause.
+     * @param config Optional configuration for the 'textSearch' clause.
+     * @param type Optional type for the 'textSearch' clause.
+     */
     addTextSearchClause(column: string, query: string[], { config, type, }?: {
         config?: string;
         type?: "plain" | "phrase" | "websearch";
     }): void;
+    /**
+     * Adds a 'not' clause to the values array.
+     * @param column The column to apply the 'not' clause to.
+     * @param operator The operator for the 'not' clause.
+     * @param value The value for the 'not' clause.
+     */
     addNotClause(column: string, operator: string, value: unknown): void;
+    /**
+     * Adds a 'match' clause to the values array.
+     * @param query The query for the 'match' clause.
+     */
     addMatchClause(query: Record<string, unknown>): void;
+    /**
+     * Returns the flattened parameters as a string.
+     * @returns The flattened parameters as a string.
+     */
     flattenedParams(): string;
+    /**
+     * Gets flattened parameters from a `SupabaseFilter` and a
+     * `SupabaseFilterRPCCall`.
+     * @param rpc The `SupabaseFilter` object.
+     * @param filter The `SupabaseFilterRPCCall` object.
+     * @returns The flattened parameters as a string.
+     */
     static getFlattenedParams(rpc: SupabaseFilter, filter: SupabaseFilterRPCCall): string;
 }
+/**
+ * Converts a `SupabaseMetadata` object into a `StructuredQuery` object.
+ * The function creates a new `StructuredQuery` object and uses the
+ * `Operation` and `Comparison` classes to build the query.
+ */
 export declare function convertObjectFilterToStructuredQuery(objFilter: SupabaseMetadata): StructuredQuery;

package/dist/retrievers/self_query/supabase_utils.js

@@ -1,4 +1,11 @@
 import { Comparators, Comparison, Operation, Operators, StructuredQuery, } from "../../chains/query_constructor/ir.js";
+/**
+ * Utility class used to duplicate parameters for a proxy object,
+ * specifically designed to work with `SupabaseFilter` objects. It
+ * contains methods to handle different types of operations such as "or",
+ * "filter", "in", "contains", "textSearch", "match", "not", and default
+ * operations.
+ */
 export class ProxyParamsDuplicator {
     constructor() {
         Object.defineProperty(this, "duplicationAllowedOps", {
@@ -30,6 +37,12 @@ export class ProxyParamsDuplicator {
             value: []
         });
     }
+    /**
+     * Creates a proxy handler for a `SupabaseFilter` object. The handler
+     * intercepts get operations and applies specific logic based on the
+     * property being accessed.
+     * @returns A proxy handler for a `SupabaseFilter` object.
+     */
     buildProxyHandler() {
         const proxyHandler = {
             get: (target, prop, receiver) => {
@@ -84,6 +97,11 @@ export class ProxyParamsDuplicator {
         };
         return proxyHandler;
     }
+    /**
+     * Removes type annotations from a value string.
+     * @param value The value string to clean.
+     * @returns The cleaned value string.
+     */
     removeType(value) {
         let cleanedValue = value;
         if (cleanedValue.includes("::float")) {
@@ -94,16 +112,38 @@ export class ProxyParamsDuplicator {
         }
         return cleanedValue;
     }
+    /**
+     * Adds a default operation clause to the values array.
+     * @param prop The operation property.
+     * @param column The column to apply the operation to.
+     * @param value The value for the operation.
+     */
     addDefaultOpClause(prop, column, value) {
         this.values.push([this.removeType(column), `${String(prop)}.${value}`]);
     }
+    /**
+     * Adds an 'or' clause to the values array.
+     * @param filters The filters for the 'or' clause.
+     * @param foreignTable Optional foreign table for the 'or' clause.
+     */
     addOrClause(filters, { foreignTable } = {}) {
         const key = foreignTable ? `${foreignTable}.or` : "or";
         this.values.push([this.removeType(key), `(${filters})`]);
     }
+    /**
+     * Adds a 'filter' clause to the values array.
+     * @param column The column to apply the filter to.
+     * @param operator The operator for the filter.
+     * @param value The value for the filter.
+     */
     addFilterClause(column, operator, value) {
         this.values.push([this.removeType(column), `${operator}.${value}`]);
     }
+    /**
+     * Adds an 'in' clause to the values array.
+     * @param column The column to apply the 'in' clause to.
+     * @param values The values for the 'in' clause.
+     */
     addInClause(column, values) {
         const cleanedValues = values
             .map((s) => {
@@ -115,6 +155,11 @@ export class ProxyParamsDuplicator {
             .join(",");
         this.values.push([this.removeType(column), `in.(${cleanedValues})`]);
     }
+    /**
+     * Adds a 'contains' clause to the values array.
+     * @param column The column to apply the 'contains' clause to.
+     * @param value The value for the 'contains' clause.
+     */
     addContainsClause(column, value) {
         if (typeof value === "string") {
             this.values.push([this.removeType(column), `cs.${value}`]);
@@ -129,6 +174,13 @@ export class ProxyParamsDuplicator {
             ]);
         }
     }
+    /**
+     * Adds a 'textSearch' clause to the values array.
+     * @param column The column to apply the 'textSearch' clause to.
+     * @param query The query for the 'textSearch' clause.
+     * @param config Optional configuration for the 'textSearch' clause.
+     * @param type Optional type for the 'textSearch' clause.
+     */
     addTextSearchClause(column, query, { config, type, } = {}) {
         let typePart = "";
         if (type === "plain") {
@@ -146,20 +198,41 @@ export class ProxyParamsDuplicator {
             `${typePart}fts${configPart}.${query}`,
         ]);
     }
+    /**
+     * Adds a 'not' clause to the values array.
+     * @param column The column to apply the 'not' clause to.
+     * @param operator The operator for the 'not' clause.
+     * @param value The value for the 'not' clause.
+     */
     addNotClause(column, operator, value) {
         this.values.push([column, `not.${operator}.${value}`]);
     }
+    /**
+     * Adds a 'match' clause to the values array.
+     * @param query The query for the 'match' clause.
+     */
     addMatchClause(query) {
         Object.entries(query).forEach(([column, value]) => {
             this.values.push([column, `eq.${value}`]);
         });
     }
+    /**
+     * Returns the flattened parameters as a string.
+     * @returns The flattened parameters as a string.
+     */
     flattenedParams() {
         const mapped = this.values.map(([k, v]) => `${k}.${v}`);
         if (mapped.length === 1)
             return mapped[0];
         return `and(${mapped.join(",")})`;
     }
+    /**
+     * Gets flattened parameters from a `SupabaseFilter` and a
+     * `SupabaseFilterRPCCall`.
+     * @param rpc The `SupabaseFilter` object.
+     * @param filter The `SupabaseFilterRPCCall` object.
+     * @returns The flattened parameters as a string.
+     */
     static getFlattenedParams(rpc, filter) {
         const proxiedDuplicator = new ProxyParamsDuplicator();
         const proxiedRpc = new Proxy(rpc, proxiedDuplicator.buildProxyHandler());
@@ -167,6 +240,11 @@ export class ProxyParamsDuplicator {
         return proxiedDuplicator.flattenedParams();
     }
 }
+/**
+ * Converts a `SupabaseMetadata` object into a `StructuredQuery` object.
+ * The function creates a new `StructuredQuery` object and uses the
+ * `Operation` and `Comparison` classes to build the query.
+ */
 export function convertObjectFilterToStructuredQuery(objFilter) {
     return new StructuredQuery("", new Operation(Operators.and, Object.entries(objFilter).map(([column, value]) => new Comparison(Comparators.eq, column, value))));
 }

package/dist/retrievers/self_query/utils.cjs

@@ -1,11 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
+/**
+ * Checks if the provided argument is an object and not an array.
+ */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isObject(obj) {
     return obj && typeof obj === "object" && !Array.isArray(obj);
 }
 exports.isObject = isObject;
+/**
+ * Checks if a provided filter is empty. The filter can be a function, an
+ * object, a string, or undefined.
+ */
 function isFilterEmpty(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 filter) {
@@ -21,16 +28,26 @@ filter) {
     return isObject(filter) && Object.keys(filter).length === 0;
 }
 exports.isFilterEmpty = isFilterEmpty;
+/**
+ * Checks if the provided value is an integer.
+ */
 function isInt(value) {
     const numberValue = parseFloat(value);
     return !Number.isNaN(numberValue) && numberValue % 1 === 0;
 }
 exports.isInt = isInt;
+/**
+ * Checks if the provided value is a floating-point number.
+ */
 function isFloat(value) {
     const numberValue = parseFloat(value);
     return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
 }
 exports.isFloat = isFloat;
+/**
+ * Checks if the provided value is a string that cannot be parsed into a
+ * number.
+ */
 function isString(value) {
     return typeof value === "string" && Number.isNaN(parseFloat(value));
 }

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

@@ -1,5 +1,22 @@
+/**
+ * Checks if the provided argument is an object and not an array.
+ */
 export declare function isObject(obj: any): obj is object;
+/**
+ * Checks if a provided filter is empty. The filter can be a function, an
+ * object, a string, or undefined.
+ */
 export declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;
+/**
+ * Checks if the provided value is an integer.
+ */
 export declare function isInt(value: unknown): boolean;
+/**
+ * Checks if the provided value is a floating-point number.
+ */
 export declare function isFloat(value: unknown): boolean;
+/**
+ * Checks if the provided value is a string that cannot be parsed into a
+ * number.
+ */
 export declare function isString(value: unknown): boolean;

package/dist/retrievers/self_query/utils.js

@@ -1,7 +1,14 @@
+/**
+ * Checks if the provided argument is an object and not an array.
+ */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isObject(obj) {
     return obj && typeof obj === "object" && !Array.isArray(obj);
 }
+/**
+ * Checks if a provided filter is empty. The filter can be a function, an
+ * object, a string, or undefined.
+ */
 export function isFilterEmpty(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 filter) {
@@ -16,14 +23,24 @@ filter) {
     }
     return isObject(filter) && Object.keys(filter).length === 0;
 }
+/**
+ * Checks if the provided value is an integer.
+ */
 export function isInt(value) {
     const numberValue = parseFloat(value);
     return !Number.isNaN(numberValue) && numberValue % 1 === 0;
 }
+/**
+ * Checks if the provided value is a floating-point number.
+ */
 export function isFloat(value) {
     const numberValue = parseFloat(value);
     return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
 }
+/**
+ * Checks if the provided value is a string that cannot be parsed into a
+ * number.
+ */
 export function isString(value) {
     return typeof value === "string" && Number.isNaN(parseFloat(value));
 }