@langchain/google-cloud-sql-pg 0.0.2 → 1.0.0

package/dist/loader.cjs

@@ -1,246 +1,163 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresLoader = void 0;
-const base_1 = require("@langchain/core/document_loaders/base");
-const utils_js_1 = require("./utils/utils.cjs");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_utils = require('./utils/utils.cjs');
+const __langchain_core_document_loaders_base = require_rolldown_runtime.__toESM(require("@langchain/core/document_loaders/base"));
+
+//#region src/loader.ts
 const DEFAULT_METADATA_COL = "langchain_metadata";
-function parseDocFromRow(contentColumns, metadataColumns, row, metadataJsonColumn = DEFAULT_METADATA_COL, formatter = utils_js_1.textFormatter) {
-    const pageContent = formatter(row, contentColumns);
-    const metadata = {};
-    if (metadataJsonColumn && row[metadataJsonColumn]) {
-        Object.entries(row[metadataJsonColumn]).forEach(([k, v]) => {
-            metadata[k] = v;
-        });
-    }
-    metadataColumns.forEach((column) => {
-        if (column in row && column !== metadataJsonColumn) {
-            metadata[column] = row[column];
-        }
-    });
-    return { pageContent, metadata };
+function parseDocFromRow(contentColumns, metadataColumns, row, metadataJsonColumn = DEFAULT_METADATA_COL, formatter = require_utils.textFormatter) {
+	const pageContent = formatter(row, contentColumns);
+	const metadata = {};
+	if (metadataJsonColumn && row[metadataJsonColumn]) Object.entries(row[metadataJsonColumn]).forEach(([k, v]) => {
+		metadata[k] = v;
+	});
+	metadataColumns.forEach((column) => {
+		if (column in row && column !== metadataJsonColumn) metadata[column] = row[column];
+	});
+	return {
+		pageContent,
+		metadata
+	};
 }
 /**
- * Google Cloud SQL for PostgreSQL vector store integration.
- *
- * Setup:
- * Install`@langchain/google-cloud-sql-pg`
- *
- * ```bash
- * npm install @langchain/google-cloud-sql-pg
- * ```
- *
- * <details open >
- * <summary><strong>Use with Table Name < /strong></summary >
- *
- * ```typescript
- * import { PostgresEngine, PostgresLoader } from "@langchain/google-cloud-sql-pg";
- *
- * const documentLoaderArgs: PostgresLoaderOptions = {
- *   tableName: "test_table_custom",
- *   contentColumns: [ "fruit_name", "variety"],
- *   metadataColumns: ["fruit_id", "quantity_in_stock", "price_per_unit", "organic"],
- *   format: "text"
- * };
- *
- * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);
- *
- * const documents = await documentLoaderInstance.load();
- * ```
- * </details>
- *
- * <br />
- *
- * <details open >
- * <summary><strong>Use with Query < /strong></summary >
- *
- * ```typescript
- * import { PostgresEngine, PostgresLoader } from "@langchain/google-cloud-sql-pg";
- *
- * const documentLoaderArgs: PostgresLoaderOptions = {
- *   query: "SELECT * FROM my_table WHERE organic = true;",
- *   contentColumns: [ "fruit_name", "variety"],
- *   metadataColumns: ["fruit_id", "quantity_in_stock", "price_per_unit", "organic"],
- *   format: "text"
- * };
- *
- * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);
- *
- * for await (const doc of documentLoaderInstance.lazyLoad()) {
- *   console.log(doc);
- *   break; // break based on required condition
- * }
- * ```
- * </details>
- *
- * <br />
- */
-class PostgresLoader extends base_1.BaseDocumentLoader {
-    constructor(engine, options) {
-        super();
-        Object.defineProperty(this, "engine", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "tableName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "schemaName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "contentColumns", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "metadataColumns", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "format", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "formatter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "query", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "metadataJsonColumn", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.engine = engine;
-        this.contentColumns = options.contentColumns;
-        this.metadataColumns = options.metadataColumns;
-        this.query = options.query;
-        this.formatter = options.formatter;
-        this.metadataJsonColumn = options.metadataJsonColumn;
-    }
-    static async initialize(engine, { schemaName = "public", tableName, contentColumns, metadataColumns, format, query, formatter, metadataJsonColumn, }) {
-        if (tableName && query) {
-            throw new Error("Only one of 'table_name' or 'query' should be specified.");
-        }
-        if (!tableName && !query) {
-            throw new Error("At least one of the parameters 'table_name' or 'query' needs to be provided");
-        }
-        if (format && formatter) {
-            throw new Error("Only one of 'format' or 'formatter' should be specified.");
-        }
-        if (format && !["csv", "text", "json", "yaml"].includes(format)) {
-            throw new Error("format must be type: 'csv', 'text', 'json', 'yaml'");
-        }
-        let formatFunc = formatter;
-        if (formatFunc === undefined) {
-            if (format === "csv") {
-                formatFunc = utils_js_1.csvFormatter;
-            }
-            else if (format === "yaml") {
-                formatFunc = utils_js_1.yamlFormatter;
-            }
-            else if (format === "json") {
-                formatFunc = utils_js_1.jsonFormatter;
-            }
-            else {
-                formatFunc = utils_js_1.textFormatter;
-            }
-        }
-        let queryStmt = query;
-        if (!queryStmt) {
-            queryStmt = `SELECT * FROM "${schemaName}"."${tableName}"`;
-        }
-        let result;
-        try {
-            result = await engine.pool.raw(queryStmt);
-        }
-        catch (error) {
-            if (typeof error === "string") {
-                throw Error(error);
-            }
-        }
-        const columnNames = result.fields.map((field) => field.name);
-        const contentColumnNames = contentColumns || [columnNames[0]];
-        const metadataColumnNames = metadataColumns ||
-            columnNames.filter((col) => !contentColumnNames.includes(col));
-        if (metadataJsonColumn && !columnNames.includes(metadataJsonColumn)) {
-            throw new Error(`Column ${metadataJsonColumn} not found in query result ${columnNames}.`);
-        }
-        let jsonColumnName = metadataJsonColumn;
-        if (!jsonColumnName && columnNames.includes(DEFAULT_METADATA_COL)) {
-            jsonColumnName = DEFAULT_METADATA_COL;
-        }
-        const allNames = [
-            ...(contentColumnNames || []),
-            ...(metadataColumnNames || []),
-        ];
-        allNames.forEach((name) => {
-            if (!columnNames.includes(name)) {
-                throw new Error(`Column ${name} not found in query result ${columnNames}.`);
-            }
-        });
-        return new PostgresLoader(engine, {
-            contentColumns: contentColumnNames,
-            metadataColumns: metadataColumnNames,
-            query: queryStmt,
-            formatter: formatFunc,
-            metadataJsonColumn: jsonColumnName,
-        });
-    }
-    async load() {
-        const documents = [];
-        for await (const doc of this.lazyLoad()) {
-            documents.push(doc);
-        }
-        return documents;
-    }
-    async *lazyLoad() {
-        const { query, contentColumns, metadataColumns, formatter, metadataJsonColumn, } = this;
-        try {
-            if (!query) {
-                throw new Error("Query is undefined");
-            }
-            const result = await this.engine.pool.raw(query);
-            for (const row of result.rows) {
-                const rowData = {};
-                const columnNames = [
-                    ...(contentColumns || []),
-                    ...(metadataColumns || []),
-                ];
-                if (metadataJsonColumn) {
-                    columnNames.push(metadataJsonColumn);
-                }
-                columnNames.forEach((column) => {
-                    rowData[column] = row[column];
-                });
-                yield parseDocFromRow(contentColumns || [], metadataColumns || [], rowData, metadataJsonColumn, formatter);
-            }
-        }
-        catch (error) {
-            if (typeof error === "string") {
-                throw Error(error);
-            }
-        }
-    }
-}
+* Google Cloud SQL for PostgreSQL vector store integration.
+*
+* Setup:
+* Install`@langchain/google-cloud-sql-pg`
+*
+* ```bash
+* npm install @langchain/google-cloud-sql-pg
+* ```
+*
+* <details open >
+* <summary><strong>Use with Table Name < /strong></summary >
+*
+* ```typescript
+* import { PostgresEngine, PostgresLoader } from "@langchain/google-cloud-sql-pg";
+*
+* const documentLoaderArgs: PostgresLoaderOptions = {
+*   tableName: "test_table_custom",
+*   contentColumns: [ "fruit_name", "variety"],
+*   metadataColumns: ["fruit_id", "quantity_in_stock", "price_per_unit", "organic"],
+*   format: "text"
+* };
+*
+* const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);
+*
+* const documents = await documentLoaderInstance.load();
+* ```
+* </details>
+*
+* <br />
+*
+* <details open >
+* <summary><strong>Use with Query < /strong></summary >
+*
+* ```typescript
+* import { PostgresEngine, PostgresLoader } from "@langchain/google-cloud-sql-pg";
+*
+* const documentLoaderArgs: PostgresLoaderOptions = {
+*   query: "SELECT * FROM my_table WHERE organic = true;",
+*   contentColumns: [ "fruit_name", "variety"],
+*   metadataColumns: ["fruit_id", "quantity_in_stock", "price_per_unit", "organic"],
+*   format: "text"
+* };
+*
+* const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);
+*
+* for await (const doc of documentLoaderInstance.lazyLoad()) {
+*   console.log(doc);
+*   break; // break based on required condition
+* }
+* ```
+* </details>
+*
+* <br />
+*/
+var PostgresLoader = class PostgresLoader extends __langchain_core_document_loaders_base.BaseDocumentLoader {
+	engine;
+	tableName;
+	schemaName;
+	contentColumns;
+	metadataColumns;
+	format;
+	formatter;
+	query;
+	metadataJsonColumn;
+	constructor(engine, options) {
+		super();
+		this.engine = engine;
+		this.contentColumns = options.contentColumns;
+		this.metadataColumns = options.metadataColumns;
+		this.query = options.query;
+		this.formatter = options.formatter;
+		this.metadataJsonColumn = options.metadataJsonColumn;
+	}
+	static async initialize(engine, { schemaName = "public", tableName, contentColumns, metadataColumns, format, query, formatter, metadataJsonColumn }) {
+		if (tableName && query) throw new Error("Only one of 'table_name' or 'query' should be specified.");
+		if (!tableName && !query) throw new Error("At least one of the parameters 'table_name' or 'query' needs to be provided");
+		if (format && formatter) throw new Error("Only one of 'format' or 'formatter' should be specified.");
+		if (format && ![
+			"csv",
+			"text",
+			"json",
+			"yaml"
+		].includes(format)) throw new Error("format must be type: 'csv', 'text', 'json', 'yaml'");
+		let formatFunc = formatter;
+		if (formatFunc === void 0) if (format === "csv") formatFunc = require_utils.csvFormatter;
+		else if (format === "yaml") formatFunc = require_utils.yamlFormatter;
+		else if (format === "json") formatFunc = require_utils.jsonFormatter;
+		else formatFunc = require_utils.textFormatter;
+		let queryStmt = query;
+		if (!queryStmt) queryStmt = `SELECT * FROM "${schemaName}"."${tableName}"`;
+		let result;
+		try {
+			result = await engine.pool.raw(queryStmt);
+		} catch (error) {
+			if (typeof error === "string") throw Error(error);
+		}
+		const columnNames = result.fields.map((field) => field.name);
+		const contentColumnNames = contentColumns || [columnNames[0]];
+		const metadataColumnNames = metadataColumns || columnNames.filter((col) => !contentColumnNames.includes(col));
+		if (metadataJsonColumn && !columnNames.includes(metadataJsonColumn)) throw new Error(`Column ${metadataJsonColumn} not found in query result ${columnNames}.`);
+		let jsonColumnName = metadataJsonColumn;
+		if (!jsonColumnName && columnNames.includes(DEFAULT_METADATA_COL)) jsonColumnName = DEFAULT_METADATA_COL;
+		const allNames = [...contentColumnNames || [], ...metadataColumnNames || []];
+		allNames.forEach((name) => {
+			if (!columnNames.includes(name)) throw new Error(`Column ${name} not found in query result ${columnNames}.`);
+		});
+		return new PostgresLoader(engine, {
+			contentColumns: contentColumnNames,
+			metadataColumns: metadataColumnNames,
+			query: queryStmt,
+			formatter: formatFunc,
+			metadataJsonColumn: jsonColumnName
+		});
+	}
+	async load() {
+		const documents = [];
+		for await (const doc of this.lazyLoad()) documents.push(doc);
+		return documents;
+	}
+	async *lazyLoad() {
+		const { query, contentColumns, metadataColumns, formatter, metadataJsonColumn } = this;
+		try {
+			if (!query) throw new Error("Query is undefined");
+			const result = await this.engine.pool.raw(query);
+			for (const row of result.rows) {
+				const rowData = {};
+				const columnNames = [...contentColumns || [], ...metadataColumns || []];
+				if (metadataJsonColumn) columnNames.push(metadataJsonColumn);
+				columnNames.forEach((column) => {
+					rowData[column] = row[column];
+				});
+				yield parseDocFromRow(contentColumns || [], metadataColumns || [], rowData, metadataJsonColumn, formatter);
+			}
+		} catch (error) {
+			if (typeof error === "string") throw Error(error);
+		}
+	}
+};
+
+//#endregion
 exports.PostgresLoader = PostgresLoader;
+//# sourceMappingURL=loader.cjs.map

package/dist/loader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.cjs","names":["contentColumns: string[]","metadataColumns: string[]","row: Row","metadataJsonColumn: string | null","formatter: (row: Row, contentColumns: string[]) => string","textFormatter","metadata: { [key: string]: string }","BaseDocumentLoader","engine: PostgresEngine","options: PostgresLoaderOptions","csvFormatter","yamlFormatter","jsonFormatter","field: { name: string }","col: string","documents: Document[]","rowData: Row"],"sources":["../src/loader.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport PostgresEngine from \"./engine.js\";\nimport {\n  textFormatter,\n  csvFormatter,\n  yamlFormatter,\n  jsonFormatter,\n} from \"./utils/utils.js\";\n\nconst DEFAULT_METADATA_COL = \"langchain_metadata\";\ntype Row = { [key: string]: string };\n\n// Options for PostgresLoader\nexport interface PostgresLoaderOptions {\n  tableName?: string;\n  schemaName?: string;\n  contentColumns?: string[];\n  metadataColumns?: string[];\n  format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n  formatter?: (row: Row, contentColumns: string[]) => string;\n  query?: string;\n  metadataJsonColumn?: string | null;\n}\n\nfunction parseDocFromRow(\n  contentColumns: string[],\n  metadataColumns: string[],\n  row: Row,\n  metadataJsonColumn: string | null = DEFAULT_METADATA_COL,\n  formatter: (row: Row, contentColumns: string[]) => string = textFormatter\n): Document {\n  const pageContent = formatter(row, contentColumns);\n  const metadata: { [key: string]: string } = {};\n\n  if (metadataJsonColumn && row[metadataJsonColumn]) {\n    Object.entries(row[metadataJsonColumn]).forEach(([k, v]) => {\n      metadata[k] = v;\n    });\n  }\n\n  metadataColumns.forEach((column) => {\n    if (column in row && column !== metadataJsonColumn) {\n      metadata[column] = row[column];\n    }\n  });\n\n  return { pageContent, metadata };\n}\n\n/**\n * Google Cloud SQL for PostgreSQL vector store integration.\n *\n * Setup:\n * Install`@langchain/google-cloud-sql-pg`\n *\n * ```bash\n * npm install @langchain/google-cloud-sql-pg\n * ```\n *\n * <details open >\n * <summary><strong>Use with Table Name < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   tableName: \"test_table_custom\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * const documents = await documentLoaderInstance.load();\n * ```\n * </details>\n *\n * <br />\n *\n * <details open >\n * <summary><strong>Use with Query < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   query: \"SELECT * FROM my_table WHERE organic = true;\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * for await (const doc of documentLoaderInstance.lazyLoad()) {\n *   console.log(doc);\n *   break; // break based on required condition\n * }\n * ```\n * </details>\n *\n * <br />\n */\nexport class PostgresLoader extends BaseDocumentLoader {\n  private engine: PostgresEngine;\n\n  tableName?: string;\n\n  schemaName?: string;\n\n  contentColumns?: string[];\n\n  metadataColumns?: string[];\n\n  format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n\n  formatter?: (row: Row, contentColumns: string[]) => string;\n\n  query?: string;\n\n  metadataJsonColumn?: string | null;\n\n  constructor(engine: PostgresEngine, options: PostgresLoaderOptions) {\n    super();\n    this.engine = engine;\n    this.contentColumns = options.contentColumns;\n    this.metadataColumns = options.metadataColumns;\n    this.query = options.query;\n    this.formatter = options.formatter;\n    this.metadataJsonColumn = options.metadataJsonColumn;\n  }\n\n  static async initialize(\n    engine: PostgresEngine,\n    {\n      schemaName = \"public\",\n      tableName,\n      contentColumns,\n      metadataColumns,\n      format,\n      query,\n      formatter,\n      metadataJsonColumn,\n    }: PostgresLoaderOptions\n  ): Promise<PostgresLoader> {\n    if (tableName && query) {\n      throw new Error(\n        \"Only one of 'table_name' or 'query' should be specified.\"\n      );\n    }\n    if (!tableName && !query) {\n      throw new Error(\n        \"At least one of the parameters 'table_name' or 'query' needs to be provided\"\n      );\n    }\n    if (format && formatter) {\n      throw new Error(\n        \"Only one of 'format' or 'formatter' should be specified.\"\n      );\n    }\n\n    if (format && ![\"csv\", \"text\", \"json\", \"yaml\"].includes(format)) {\n      throw new Error(\"format must be type: 'csv', 'text', 'json', 'yaml'\");\n    }\n\n    let formatFunc = formatter;\n    if (formatFunc === undefined) {\n      if (format === \"csv\") {\n        formatFunc = csvFormatter;\n      } else if (format === \"yaml\") {\n        formatFunc = yamlFormatter;\n      } else if (format === \"json\") {\n        formatFunc = jsonFormatter;\n      } else {\n        formatFunc = textFormatter;\n      }\n    }\n\n    let queryStmt = query;\n    if (!queryStmt) {\n      queryStmt = `SELECT * FROM \"${schemaName}\".\"${tableName}\"`;\n    }\n\n    let result;\n    try {\n      result = await engine.pool.raw(queryStmt);\n    } catch (error) {\n      if (typeof error === \"string\") {\n        throw Error(error);\n      }\n    }\n    const columnNames = result.fields.map(\n      (field: { name: string }) => field.name\n    );\n\n    const contentColumnNames = contentColumns || [columnNames[0]];\n    const metadataColumnNames =\n      metadataColumns ||\n      columnNames.filter((col: string) => !contentColumnNames.includes(col));\n\n    if (metadataJsonColumn && !columnNames.includes(metadataJsonColumn)) {\n      throw new Error(\n        `Column ${metadataJsonColumn} not found in query result ${columnNames}.`\n      );\n    }\n    let jsonColumnName = metadataJsonColumn;\n    if (!jsonColumnName && columnNames.includes(DEFAULT_METADATA_COL)) {\n      jsonColumnName = DEFAULT_METADATA_COL;\n    }\n\n    const allNames = [\n      ...(contentColumnNames || []),\n      ...(metadataColumnNames || []),\n    ];\n    allNames.forEach((name) => {\n      if (!columnNames.includes(name)) {\n        throw new Error(\n          `Column ${name} not found in query result ${columnNames}.`\n        );\n      }\n    });\n\n    return new PostgresLoader(engine, {\n      contentColumns: contentColumnNames,\n      metadataColumns: metadataColumnNames,\n      query: queryStmt,\n      formatter: formatFunc,\n      metadataJsonColumn: jsonColumnName,\n    });\n  }\n\n  async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n    for await (const doc of this.lazyLoad()) {\n      documents.push(doc);\n    }\n    return documents;\n  }\n\n  async *lazyLoad(): AsyncGenerator<Document> {\n    const {\n      query,\n      contentColumns,\n      metadataColumns,\n      formatter,\n      metadataJsonColumn,\n    } = this;\n    try {\n      if (!query) {\n        throw new Error(\"Query is undefined\");\n      }\n      const result = await this.engine.pool.raw(query);\n\n      for (const row of result.rows) {\n        const rowData: Row = {};\n        const columnNames = [\n          ...(contentColumns || []),\n          ...(metadataColumns || []),\n        ];\n        if (metadataJsonColumn) {\n          columnNames.push(metadataJsonColumn);\n        }\n        columnNames.forEach((column) => {\n          rowData[column] = row[column];\n        });\n\n        yield parseDocFromRow(\n          contentColumns || [],\n          metadataColumns || [],\n          rowData,\n          metadataJsonColumn,\n          formatter\n        );\n      }\n    } catch (error) {\n      if (typeof error === \"string\") {\n        throw Error(error);\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/loader.d.cts

@@ -0,0 +1,101 @@
+import { PostgresEngine } from "./engine.cjs";
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#region src/loader.d.ts
+type Row = {
+  [key: string]: string;
+};
+// Options for PostgresLoader
+interface PostgresLoaderOptions {
+  tableName?: string;
+  schemaName?: string;
+  contentColumns?: string[];
+  metadataColumns?: string[];
+  format?: "text" | "json" | "yaml" | "csv";
+  formatter?: (row: Row, contentColumns: string[]) => string;
+  query?: string;
+  metadataJsonColumn?: string | null;
+}
+/**
+ * Google Cloud SQL for PostgreSQL vector store integration.
+ *
+ * Setup:
+ * Install`@langchain/google-cloud-sql-pg`
+ *
+ * ```bash
+ * npm install @langchain/google-cloud-sql-pg
+ * ```
+ *
+ * <details open >
+ * <summary><strong>Use with Table Name < /strong></summary >
+ *
+ * ```typescript
+ * import { PostgresEngine, PostgresLoader } from "@langchain/google-cloud-sql-pg";
+ *
+ * const documentLoaderArgs: PostgresLoaderOptions = {
+ *   tableName: "test_table_custom",
+ *   contentColumns: [ "fruit_name", "variety"],
+ *   metadataColumns: ["fruit_id", "quantity_in_stock", "price_per_unit", "organic"],
+ *   format: "text"
+ * };
+ *
+ * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);
+ *
+ * const documents = await documentLoaderInstance.load();
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details open >
+ * <summary><strong>Use with Query < /strong></summary >
+ *
+ * ```typescript
+ * import { PostgresEngine, PostgresLoader } from "@langchain/google-cloud-sql-pg";
+ *
+ * const documentLoaderArgs: PostgresLoaderOptions = {
+ *   query: "SELECT * FROM my_table WHERE organic = true;",
+ *   contentColumns: [ "fruit_name", "variety"],
+ *   metadataColumns: ["fruit_id", "quantity_in_stock", "price_per_unit", "organic"],
+ *   format: "text"
+ * };
+ *
+ * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);
+ *
+ * for await (const doc of documentLoaderInstance.lazyLoad()) {
+ *   console.log(doc);
+ *   break; // break based on required condition
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ */
+declare class PostgresLoader extends BaseDocumentLoader {
+  private engine;
+  tableName?: string;
+  schemaName?: string;
+  contentColumns?: string[];
+  metadataColumns?: string[];
+  format?: "text" | "json" | "yaml" | "csv";
+  formatter?: (row: Row, contentColumns: string[]) => string;
+  query?: string;
+  metadataJsonColumn?: string | null;
+  constructor(engine: PostgresEngine, options: PostgresLoaderOptions);
+  static initialize(engine: PostgresEngine, {
+    schemaName,
+    tableName,
+    contentColumns,
+    metadataColumns,
+    format,
+    query,
+    formatter,
+    metadataJsonColumn
+  }: PostgresLoaderOptions): Promise<PostgresLoader>;
+  load(): Promise<Document[]>;
+  lazyLoad(): AsyncGenerator<Document>;
+}
+//#endregion
+export { PostgresLoader, PostgresLoaderOptions };
+//# sourceMappingURL=loader.d.cts.map

package/dist/loader.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.cts","names":["Document","BaseDocumentLoader","PostgresEngine","Row","PostgresLoaderOptions","PostgresLoader","schemaName","tableName","contentColumns","metadataColumns","format","query","formatter","metadataJsonColumn","Promise","AsyncGenerator"],"sources":["../src/loader.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport PostgresEngine from \"./engine.js\";\ntype Row = {\n    [key: string]: string;\n};\n// Options for PostgresLoader\nexport interface PostgresLoaderOptions {\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n}\n/**\n * Google Cloud SQL for PostgreSQL vector store integration.\n *\n * Setup:\n * Install`@langchain/google-cloud-sql-pg`\n *\n * ```bash\n * npm install @langchain/google-cloud-sql-pg\n * ```\n *\n * <details open >\n * <summary><strong>Use with Table Name < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   tableName: \"test_table_custom\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * const documents = await documentLoaderInstance.load();\n * ```\n * </details>\n *\n * <br />\n *\n * <details open >\n * <summary><strong>Use with Query < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   query: \"SELECT * FROM my_table WHERE organic = true;\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * for await (const doc of documentLoaderInstance.lazyLoad()) {\n *   console.log(doc);\n *   break; // break based on required condition\n * }\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class PostgresLoader extends BaseDocumentLoader {\n    private engine;\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n    constructor(engine: PostgresEngine, options: PostgresLoaderOptions);\n    static initialize(engine: PostgresEngine, { schemaName, tableName, contentColumns, metadataColumns, format, query, formatter, metadataJsonColumn }: PostgresLoaderOptions): Promise<PostgresLoader>;\n    load(): Promise<Document[]>;\n    lazyLoad(): AsyncGenerator<Document>;\n}\nexport {};\n"],"mappings":";;;;;KAGKG,GAAAA;;AADoC,CAAA;AAKzC;AAiEqBE,UAjEJD,qBAAAA,CAiEkB;EAAA,SAAA,CAAA,EAAA,MAAA;EAAA,UAObD,CAAAA,EAAAA,MAAAA;EAAG,cAGDD,CAAAA,EAAAA,MAAAA,EAAAA;EAAc,eAAWE,CAAAA,EAAAA,MAAAA,EAAAA;EAAqB,MACxCF,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,KAAAA;EAAc,SAAII,CAAAA,EAAAA,CAAAA,GAAAA,EAtE1BH,GAsE0BG,EAAAA,cAAAA,EAAAA,MAAAA,EAAAA,EAAAA,GAAAA,MAAAA;EAAU,KAAEC,CAAAA,EAAAA,MAAAA;EAAS,kBAAEC,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;;;;;;;;;;;;;;AAXT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzCH,cAAAA,SAAuBJ,kBAAAA;;;;;;;oBAOtBE;;;sBAGED,yBAAyBE;4BACnBF;;;;;;;;;KAA0HE,wBAAwBU,QAAQT;UAC5KS,QAAQd;cACJe,eAAef"}

package/dist/loader.d.ts

@@ -1,18 +1,21 @@
+import { PostgresEngine } from "./engine.js";
 import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-import PostgresEngine from "./engine.js";
+
+//#region src/loader.d.ts
 type Row = {
-    [key: string]: string;
+  [key: string]: string;
 };
-export interface PostgresLoaderOptions {
-    tableName?: string;
-    schemaName?: string;
-    contentColumns?: string[];
-    metadataColumns?: string[];
-    format?: "text" | "json" | "yaml" | "csv";
-    formatter?: (row: Row, contentColumns: string[]) => string;
-    query?: string;
-    metadataJsonColumn?: string | null;
+// Options for PostgresLoader
+interface PostgresLoaderOptions {
+  tableName?: string;
+  schemaName?: string;
+  contentColumns?: string[];
+  metadataColumns?: string[];
+  format?: "text" | "json" | "yaml" | "csv";
+  formatter?: (row: Row, contentColumns: string[]) => string;
+  query?: string;
+  metadataJsonColumn?: string | null;
 }
 /**
  * Google Cloud SQL for PostgreSQL vector store integration.
@@ -69,19 +72,30 @@ export interface PostgresLoaderOptions {
  *
  * <br />
  */
-export declare class PostgresLoader extends BaseDocumentLoader {
-    private engine;
-    tableName?: string;
-    schemaName?: string;
-    contentColumns?: string[];
-    metadataColumns?: string[];
-    format?: "text" | "json" | "yaml" | "csv";
-    formatter?: (row: Row, contentColumns: string[]) => string;
-    query?: string;
-    metadataJsonColumn?: string | null;
-    constructor(engine: PostgresEngine, options: PostgresLoaderOptions);
-    static initialize(engine: PostgresEngine, { schemaName, tableName, contentColumns, metadataColumns, format, query, formatter, metadataJsonColumn, }: PostgresLoaderOptions): Promise<PostgresLoader>;
-    load(): Promise<Document[]>;
-    lazyLoad(): AsyncGenerator<Document>;
+declare class PostgresLoader extends BaseDocumentLoader {
+  private engine;
+  tableName?: string;
+  schemaName?: string;
+  contentColumns?: string[];
+  metadataColumns?: string[];
+  format?: "text" | "json" | "yaml" | "csv";
+  formatter?: (row: Row, contentColumns: string[]) => string;
+  query?: string;
+  metadataJsonColumn?: string | null;
+  constructor(engine: PostgresEngine, options: PostgresLoaderOptions);
+  static initialize(engine: PostgresEngine, {
+    schemaName,
+    tableName,
+    contentColumns,
+    metadataColumns,
+    format,
+    query,
+    formatter,
+    metadataJsonColumn
+  }: PostgresLoaderOptions): Promise<PostgresLoader>;
+  load(): Promise<Document[]>;
+  lazyLoad(): AsyncGenerator<Document>;
 }
-export {};
+//#endregion
+export { PostgresLoader, PostgresLoaderOptions };
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","names":["Document","BaseDocumentLoader","PostgresEngine","Row","PostgresLoaderOptions","PostgresLoader","schemaName","tableName","contentColumns","metadataColumns","format","query","formatter","metadataJsonColumn","Promise","AsyncGenerator"],"sources":["../src/loader.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport PostgresEngine from \"./engine.js\";\ntype Row = {\n    [key: string]: string;\n};\n// Options for PostgresLoader\nexport interface PostgresLoaderOptions {\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n}\n/**\n * Google Cloud SQL for PostgreSQL vector store integration.\n *\n * Setup:\n * Install`@langchain/google-cloud-sql-pg`\n *\n * ```bash\n * npm install @langchain/google-cloud-sql-pg\n * ```\n *\n * <details open >\n * <summary><strong>Use with Table Name < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   tableName: \"test_table_custom\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * const documents = await documentLoaderInstance.load();\n * ```\n * </details>\n *\n * <br />\n *\n * <details open >\n * <summary><strong>Use with Query < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   query: \"SELECT * FROM my_table WHERE organic = true;\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * for await (const doc of documentLoaderInstance.lazyLoad()) {\n *   console.log(doc);\n *   break; // break based on required condition\n * }\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class PostgresLoader extends BaseDocumentLoader {\n    private engine;\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n    constructor(engine: PostgresEngine, options: PostgresLoaderOptions);\n    static initialize(engine: PostgresEngine, { schemaName, tableName, contentColumns, metadataColumns, format, query, formatter, metadataJsonColumn }: PostgresLoaderOptions): Promise<PostgresLoader>;\n    load(): Promise<Document[]>;\n    lazyLoad(): AsyncGenerator<Document>;\n}\nexport {};\n"],"mappings":";;;;;KAGKG,GAAAA;;AADoC,CAAA;AAKzC;AAiEqBE,UAjEJD,qBAAAA,CAiEkB;EAAA,SAAA,CAAA,EAAA,MAAA;EAAA,UAObD,CAAAA,EAAAA,MAAAA;EAAG,cAGDD,CAAAA,EAAAA,MAAAA,EAAAA;EAAc,eAAWE,CAAAA,EAAAA,MAAAA,EAAAA;EAAqB,MACxCF,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,KAAAA;EAAc,SAAII,CAAAA,EAAAA,CAAAA,GAAAA,EAtE1BH,GAsE0BG,EAAAA,cAAAA,EAAAA,MAAAA,EAAAA,EAAAA,GAAAA,MAAAA;EAAU,KAAEC,CAAAA,EAAAA,MAAAA;EAAS,kBAAEC,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;;;;;;;;;;;;;;AAXT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzCH,cAAAA,SAAuBJ,kBAAAA;;;;;;;oBAOtBE;;;sBAGED,yBAAyBE;4BACnBF;;;;;;;;;KAA0HE,wBAAwBU,QAAQT;UAC5KS,QAAQd;cACJe,eAAef"}