langchain 0.3.31 → 1.0.0-alpha.1

package/dist/sql_db.cjs

@@ -1,198 +1,119 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqlDatabase = void 0;
-const serializable_1 = require("@langchain/core/load/serializable");
-const sql_utils_js_1 = require("./util/sql_utils.cjs");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_sql_utils = require('./util/sql_utils.cjs');
+const __langchain_core_load_serializable = require_rolldown_runtime.__toESM(require("@langchain/core/load/serializable"));
+
+//#region src/sql_db.ts
+var sql_db_exports = {};
+require_rolldown_runtime.__export(sql_db_exports, { SqlDatabase: () => SqlDatabase });
 /**
- * Class that represents a SQL database in the LangChain framework.
- *
- * @security **Security Notice**
- * This class generates SQL queries for the given database.
- * The SQLDatabase class provides a getTableInfo method that can be used
- * to get column information as well as sample data from the table.
- * To mitigate risk of leaking sensitive data, limit permissions
- * to read and scope to the tables that are needed.
- * Optionally, use the includesTables or ignoreTables class parameters
- * to limit which tables can/cannot be accessed.
- *
- * @link See https://js.langchain.com/docs/security for more information.
- */
-class SqlDatabase extends serializable_1.Serializable {
-    toJSON() {
-        return this.toJSONNotImplemented();
-    }
-    constructor(fields) {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "sql_db"]
-        });
-        Object.defineProperty(this, "appDataSourceOptions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "appDataSource", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "allTables", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "includesTables", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "ignoreTables", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "sampleRowsInTableInfo", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 3
-        });
-        Object.defineProperty(this, "customDescription", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.appDataSource = fields.appDataSource;
-        this.appDataSourceOptions = fields.appDataSource.options;
-        if (fields?.includesTables && fields?.ignoreTables) {
-            throw new Error("Cannot specify both includeTables and ignoreTables");
-        }
-        this.includesTables = fields?.includesTables ?? [];
-        this.ignoreTables = fields?.ignoreTables ?? [];
-        this.sampleRowsInTableInfo =
-            fields?.sampleRowsInTableInfo ?? this.sampleRowsInTableInfo;
-    }
-    static async fromDataSourceParams(fields) {
-        const sqlDatabase = new SqlDatabase(fields);
-        if (!sqlDatabase.appDataSource.isInitialized) {
-            await sqlDatabase.appDataSource.initialize();
-        }
-        sqlDatabase.allTables = await (0, sql_utils_js_1.getTableAndColumnsName)(sqlDatabase.appDataSource);
-        sqlDatabase.customDescription = Object.fromEntries(Object.entries(fields?.customDescription ?? {}).filter(([key, _]) => sqlDatabase.allTables
-            .map((table) => table.tableName)
-            .includes(key)));
-        (0, sql_utils_js_1.verifyIncludeTablesExistInDatabase)(sqlDatabase.allTables, sqlDatabase.includesTables);
-        (0, sql_utils_js_1.verifyIgnoreTablesExistInDatabase)(sqlDatabase.allTables, sqlDatabase.ignoreTables);
-        return sqlDatabase;
-    }
-    static async fromOptionsParams(fields) {
-        const { DataSource } = await Promise.resolve().then(() => __importStar(require("typeorm")));
-        const dataSource = new DataSource(fields.appDataSourceOptions);
-        return SqlDatabase.fromDataSourceParams({
-            ...fields,
-            appDataSource: dataSource,
-        });
-    }
-    /**
-     * Get information about specified tables.
-     *
-     * Follows best practices as specified in: Rajkumar et al, 2022
-     * (https://arxiv.org/abs/2204.00498)
-     *
-     * If `sample_rows_in_table_info`, the specified number of sample rows will be
-     * appended to each table description. This can increase performance as
-     * demonstrated in the paper.
-     */
-    async getTableInfo(targetTables) {
-        let selectedTables = this.includesTables.length > 0
-            ? this.allTables.filter((currentTable) => this.includesTables.includes(currentTable.tableName))
-            : this.allTables;
-        if (this.ignoreTables.length > 0) {
-            selectedTables = selectedTables.filter((currentTable) => !this.ignoreTables.includes(currentTable.tableName));
-        }
-        if (targetTables && targetTables.length > 0) {
-            (0, sql_utils_js_1.verifyListTablesExistInDatabase)(this.allTables, targetTables, "Wrong target table name:");
-            selectedTables = this.allTables.filter((currentTable) => targetTables.includes(currentTable.tableName));
-        }
-        return (0, sql_utils_js_1.generateTableInfoFromTables)(selectedTables, this.appDataSource, this.sampleRowsInTableInfo, this.customDescription);
-    }
-    /**
-     * Execute a SQL command and return a string representing the results.
-     * If the statement returns rows, a string of the results is returned.
-     * If the statement returns no rows, an empty string is returned.
-     */
-    async run(command, fetch = "all") {
-        // TODO: Potential security issue here
-        const res = await this.appDataSource.query(command);
-        if (fetch === "all") {
-            return JSON.stringify(res);
-        }
-        if (res?.length > 0) {
-            return JSON.stringify(res[0]);
-        }
-        return "";
-    }
-    serialize() {
-        return {
-            _type: "sql_database",
-            appDataSourceOptions: this.appDataSourceOptions,
-            includesTables: this.includesTables,
-            ignoreTables: this.ignoreTables,
-            sampleRowsInTableInfo: this.sampleRowsInTableInfo,
-        };
-    }
-    /** @ignore */
-    static async imports() {
-        try {
-            const { DataSource } = await Promise.resolve().then(() => __importStar(require("typeorm")));
-            return { DataSource };
-        }
-        catch (e) {
-            console.error(e);
-            throw new Error("Failed to load typeorm. Please install it with eg. `yarn add typeorm`.");
-        }
-    }
-}
+* Class that represents a SQL database in the LangChain framework.
+*
+* @security **Security Notice**
+* This class generates SQL queries for the given database.
+* The SQLDatabase class provides a getTableInfo method that can be used
+* to get column information as well as sample data from the table.
+* To mitigate risk of leaking sensitive data, limit permissions
+* to read and scope to the tables that are needed.
+* Optionally, use the includesTables or ignoreTables class parameters
+* to limit which tables can/cannot be accessed.
+*
+* @link See https://js.langchain.com/docs/security for more information.
+*/
+var SqlDatabase = class SqlDatabase extends __langchain_core_load_serializable.Serializable {
+	lc_namespace = ["langchain", "sql_db"];
+	toJSON() {
+		return this.toJSONNotImplemented();
+	}
+	appDataSourceOptions;
+	appDataSource;
+	allTables = [];
+	includesTables = [];
+	ignoreTables = [];
+	sampleRowsInTableInfo = 3;
+	customDescription;
+	constructor(fields) {
+		super(...arguments);
+		this.appDataSource = fields.appDataSource;
+		this.appDataSourceOptions = fields.appDataSource.options;
+		if (fields?.includesTables && fields?.ignoreTables) throw new Error("Cannot specify both includeTables and ignoreTables");
+		this.includesTables = fields?.includesTables ?? [];
+		this.ignoreTables = fields?.ignoreTables ?? [];
+		this.sampleRowsInTableInfo = fields?.sampleRowsInTableInfo ?? this.sampleRowsInTableInfo;
+	}
+	static async fromDataSourceParams(fields) {
+		const sqlDatabase = new SqlDatabase(fields);
+		if (!sqlDatabase.appDataSource.isInitialized) await sqlDatabase.appDataSource.initialize();
+		sqlDatabase.allTables = await require_sql_utils.getTableAndColumnsName(sqlDatabase.appDataSource);
+		sqlDatabase.customDescription = Object.fromEntries(Object.entries(fields?.customDescription ?? {}).filter(([key, _]) => sqlDatabase.allTables.map((table) => table.tableName).includes(key)));
+		require_sql_utils.verifyIncludeTablesExistInDatabase(sqlDatabase.allTables, sqlDatabase.includesTables);
+		require_sql_utils.verifyIgnoreTablesExistInDatabase(sqlDatabase.allTables, sqlDatabase.ignoreTables);
+		return sqlDatabase;
+	}
+	static async fromOptionsParams(fields) {
+		const { DataSource } = await import("typeorm");
+		const dataSource = new DataSource(fields.appDataSourceOptions);
+		return SqlDatabase.fromDataSourceParams({
+			...fields,
+			appDataSource: dataSource
+		});
+	}
+	/**
+	* Get information about specified tables.
+	*
+	* Follows best practices as specified in: Rajkumar et al, 2022
+	* (https://arxiv.org/abs/2204.00498)
+	*
+	* If `sample_rows_in_table_info`, the specified number of sample rows will be
+	* appended to each table description. This can increase performance as
+	* demonstrated in the paper.
+	*/
+	async getTableInfo(targetTables) {
+		let selectedTables = this.includesTables.length > 0 ? this.allTables.filter((currentTable) => this.includesTables.includes(currentTable.tableName)) : this.allTables;
+		if (this.ignoreTables.length > 0) selectedTables = selectedTables.filter((currentTable) => !this.ignoreTables.includes(currentTable.tableName));
+		if (targetTables && targetTables.length > 0) {
+			require_sql_utils.verifyListTablesExistInDatabase(this.allTables, targetTables, "Wrong target table name:");
+			selectedTables = this.allTables.filter((currentTable) => targetTables.includes(currentTable.tableName));
+		}
+		return require_sql_utils.generateTableInfoFromTables(selectedTables, this.appDataSource, this.sampleRowsInTableInfo, this.customDescription);
+	}
+	/**
+	* Execute a SQL command and return a string representing the results.
+	* If the statement returns rows, a string of the results is returned.
+	* If the statement returns no rows, an empty string is returned.
+	*/
+	async run(command, fetch = "all") {
+		const res = await this.appDataSource.query(command);
+		if (fetch === "all") return JSON.stringify(res);
+		if (res?.length > 0) return JSON.stringify(res[0]);
+		return "";
+	}
+	serialize() {
+		return {
+			_type: "sql_database",
+			appDataSourceOptions: this.appDataSourceOptions,
+			includesTables: this.includesTables,
+			ignoreTables: this.ignoreTables,
+			sampleRowsInTableInfo: this.sampleRowsInTableInfo
+		};
+	}
+	/** @ignore */
+	static async imports() {
+		try {
+			const { DataSource } = await import("typeorm");
+			return { DataSource };
+		} catch (e) {
+			console.error(e);
+			throw new Error("Failed to load typeorm. Please install it with eg. `pnpm install typeorm`.");
+		}
+	}
+};
+
+//#endregion
 exports.SqlDatabase = SqlDatabase;
+Object.defineProperty(exports, 'sql_db_exports', {
+  enumerable: true,
+  get: function () {
+    return sql_db_exports;
+  }
+});
+//# sourceMappingURL=sql_db.cjs.map

package/dist/sql_db.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql_db.cjs","names":["Serializable","fields: SqlDatabaseDataSourceParams","getTableAndColumnsName","table: SqlTable","verifyIncludeTablesExistInDatabase","verifyIgnoreTablesExistInDatabase","fields: SqlDatabaseOptionsParams","targetTables?: Array<string>","verifyListTablesExistInDatabase","generateTableInfoFromTables","command: string","fetch: \"all\" | \"one\""],"sources":["../src/sql_db.ts"],"sourcesContent":["import type { DataSource as DataSourceT, DataSourceOptions } from \"typeorm\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport {\n  generateTableInfoFromTables,\n  getTableAndColumnsName,\n  SerializedSqlDatabase,\n  SqlDatabaseDataSourceParams,\n  SqlDatabaseOptionsParams,\n  SqlTable,\n  verifyIgnoreTablesExistInDatabase,\n  verifyIncludeTablesExistInDatabase,\n  verifyListTablesExistInDatabase,\n} from \"./util/sql_utils.js\";\n\nexport type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };\n\n/**\n * Class that represents a SQL database in the LangChain framework.\n *\n * @security **Security Notice**\n * This class generates SQL queries for the given database.\n * The SQLDatabase class provides a getTableInfo method that can be used\n * to get column information as well as sample data from the table.\n * To mitigate risk of leaking sensitive data, limit permissions\n * to read and scope to the tables that are needed.\n * Optionally, use the includesTables or ignoreTables class parameters\n * to limit which tables can/cannot be accessed.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport class SqlDatabase\n  extends Serializable\n  implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams\n{\n  lc_namespace = [\"langchain\", \"sql_db\"];\n\n  toJSON() {\n    return this.toJSONNotImplemented();\n  }\n\n  appDataSourceOptions: DataSourceOptions;\n\n  appDataSource: DataSourceT;\n\n  allTables: Array<SqlTable> = [];\n\n  includesTables: Array<string> = [];\n\n  ignoreTables: Array<string> = [];\n\n  sampleRowsInTableInfo = 3;\n\n  customDescription?: Record<string, string>;\n\n  protected constructor(fields: SqlDatabaseDataSourceParams) {\n    super(...arguments);\n    this.appDataSource = fields.appDataSource;\n    this.appDataSourceOptions = fields.appDataSource.options;\n    if (fields?.includesTables && fields?.ignoreTables) {\n      throw new Error(\"Cannot specify both includeTables and ignoreTables\");\n    }\n    this.includesTables = fields?.includesTables ?? [];\n    this.ignoreTables = fields?.ignoreTables ?? [];\n    this.sampleRowsInTableInfo =\n      fields?.sampleRowsInTableInfo ?? this.sampleRowsInTableInfo;\n  }\n\n  static async fromDataSourceParams(\n    fields: SqlDatabaseDataSourceParams\n  ): Promise<SqlDatabase> {\n    const sqlDatabase = new SqlDatabase(fields);\n    if (!sqlDatabase.appDataSource.isInitialized) {\n      await sqlDatabase.appDataSource.initialize();\n    }\n    sqlDatabase.allTables = await getTableAndColumnsName(\n      sqlDatabase.appDataSource\n    );\n    sqlDatabase.customDescription = Object.fromEntries(\n      Object.entries(fields?.customDescription ?? {}).filter(([key, _]) =>\n        sqlDatabase.allTables\n          .map((table: SqlTable) => table.tableName)\n          .includes(key)\n      )\n    );\n    verifyIncludeTablesExistInDatabase(\n      sqlDatabase.allTables,\n      sqlDatabase.includesTables\n    );\n    verifyIgnoreTablesExistInDatabase(\n      sqlDatabase.allTables,\n      sqlDatabase.ignoreTables\n    );\n    return sqlDatabase;\n  }\n\n  static async fromOptionsParams(\n    fields: SqlDatabaseOptionsParams\n  ): Promise<SqlDatabase> {\n    const { DataSource } = await import(\"typeorm\");\n    const dataSource = new DataSource(fields.appDataSourceOptions);\n    return SqlDatabase.fromDataSourceParams({\n      ...fields,\n      appDataSource: dataSource,\n    });\n  }\n\n  /**\n   * Get information about specified tables.\n   *\n   * Follows best practices as specified in: Rajkumar et al, 2022\n   * (https://arxiv.org/abs/2204.00498)\n   *\n   * If `sample_rows_in_table_info`, the specified number of sample rows will be\n   * appended to each table description. This can increase performance as\n   * demonstrated in the paper.\n   */\n  async getTableInfo(targetTables?: Array<string>): Promise<string> {\n    let selectedTables =\n      this.includesTables.length > 0\n        ? this.allTables.filter((currentTable) =>\n            this.includesTables.includes(currentTable.tableName)\n          )\n        : this.allTables;\n\n    if (this.ignoreTables.length > 0) {\n      selectedTables = selectedTables.filter(\n        (currentTable) => !this.ignoreTables.includes(currentTable.tableName)\n      );\n    }\n\n    if (targetTables && targetTables.length > 0) {\n      verifyListTablesExistInDatabase(\n        this.allTables,\n        targetTables,\n        \"Wrong target table name:\"\n      );\n      selectedTables = this.allTables.filter((currentTable) =>\n        targetTables.includes(currentTable.tableName)\n      );\n    }\n\n    return generateTableInfoFromTables(\n      selectedTables,\n      this.appDataSource,\n      this.sampleRowsInTableInfo,\n      this.customDescription\n    );\n  }\n\n  /**\n   * Execute a SQL command and return a string representing the results.\n   * If the statement returns rows, a string of the results is returned.\n   * If the statement returns no rows, an empty string is returned.\n   */\n  async run(command: string, fetch: \"all\" | \"one\" = \"all\"): Promise<string> {\n    // TODO: Potential security issue here\n    const res = await this.appDataSource.query(command);\n\n    if (fetch === \"all\") {\n      return JSON.stringify(res);\n    }\n\n    if (res?.length > 0) {\n      return JSON.stringify(res[0]);\n    }\n\n    return \"\";\n  }\n\n  serialize(): SerializedSqlDatabase {\n    return {\n      _type: \"sql_database\",\n      appDataSourceOptions: this.appDataSourceOptions,\n      includesTables: this.includesTables,\n      ignoreTables: this.ignoreTables,\n      sampleRowsInTableInfo: this.sampleRowsInTableInfo,\n    };\n  }\n\n  /** @ignore */\n  static async imports() {\n    try {\n      const { DataSource } = await import(\"typeorm\");\n      return { DataSource };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        \"Failed to load typeorm. Please install it with eg. `pnpm install typeorm`.\"\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,cAAb,MAAa,oBACHA,gDAEV;CACE,eAAe,CAAC,aAAa,QAAS;CAEtC,SAAS;AACP,SAAO,KAAK,sBAAsB;CACnC;CAED;CAEA;CAEA,YAA6B,CAAE;CAE/B,iBAAgC,CAAE;CAElC,eAA8B,CAAE;CAEhC,wBAAwB;CAExB;CAEA,AAAU,YAAYC,QAAqC;EACzD,MAAM,GAAG,UAAU;EACnB,KAAK,gBAAgB,OAAO;EAC5B,KAAK,uBAAuB,OAAO,cAAc;AACjD,MAAI,QAAQ,kBAAkB,QAAQ,aACpC,OAAM,IAAI,MAAM;EAElB,KAAK,iBAAiB,QAAQ,kBAAkB,CAAE;EAClD,KAAK,eAAe,QAAQ,gBAAgB,CAAE;EAC9C,KAAK,wBACH,QAAQ,yBAAyB,KAAK;CACzC;CAED,aAAa,qBACXA,QACsB;EACtB,MAAM,cAAc,IAAI,YAAY;AACpC,MAAI,CAAC,YAAY,cAAc,eAC7B,MAAM,YAAY,cAAc,YAAY;EAE9C,YAAY,YAAY,MAAMC,yCAC5B,YAAY,cACb;EACD,YAAY,oBAAoB,OAAO,YACrC,OAAO,QAAQ,QAAQ,qBAAqB,CAAE,EAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAC9D,YAAY,UACT,IAAI,CAACC,UAAoB,MAAM,UAAU,CACzC,SAAS,IAAI,CACjB,CACF;EACDC,qDACE,YAAY,WACZ,YAAY,eACb;EACDC,oDACE,YAAY,WACZ,YAAY,aACb;AACD,SAAO;CACR;CAED,aAAa,kBACXC,QACsB;EACtB,MAAM,EAAE,YAAY,GAAG,MAAM,OAAO;EACpC,MAAM,aAAa,IAAI,WAAW,OAAO;AACzC,SAAO,YAAY,qBAAqB;GACtC,GAAG;GACH,eAAe;EAChB,EAAC;CACH;;;;;;;;;;;CAYD,MAAM,aAAaC,cAA+C;EAChE,IAAI,iBACF,KAAK,eAAe,SAAS,IACzB,KAAK,UAAU,OAAO,CAAC,iBACrB,KAAK,eAAe,SAAS,aAAa,UAAU,CACrD,GACD,KAAK;AAEX,MAAI,KAAK,aAAa,SAAS,GAC7B,iBAAiB,eAAe,OAC9B,CAAC,iBAAiB,CAAC,KAAK,aAAa,SAAS,aAAa,UAAU,CACtE;AAGH,MAAI,gBAAgB,aAAa,SAAS,GAAG;GAC3CC,kDACE,KAAK,WACL,cACA,2BACD;GACD,iBAAiB,KAAK,UAAU,OAAO,CAAC,iBACtC,aAAa,SAAS,aAAa,UAAU,CAC9C;EACF;AAED,SAAOC,8CACL,gBACA,KAAK,eACL,KAAK,uBACL,KAAK,kBACN;CACF;;;;;;CAOD,MAAM,IAAIC,SAAiBC,QAAuB,OAAwB;EAExE,MAAM,MAAM,MAAM,KAAK,cAAc,MAAM,QAAQ;AAEnD,MAAI,UAAU,MACZ,QAAO,KAAK,UAAU,IAAI;AAG5B,MAAI,KAAK,SAAS,EAChB,QAAO,KAAK,UAAU,IAAI,GAAG;AAG/B,SAAO;CACR;CAED,YAAmC;AACjC,SAAO;GACL,OAAO;GACP,sBAAsB,KAAK;GAC3B,gBAAgB,KAAK;GACrB,cAAc,KAAK;GACnB,uBAAuB,KAAK;EAC7B;CACF;;CAGD,aAAa,UAAU;AACrB,MAAI;GACF,MAAM,EAAE,YAAY,GAAG,MAAM,OAAO;AACpC,UAAO,EAAE,WAAY;EACtB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR;EAEH;CACF;AACF"}

package/dist/sql_db.d.cts

@@ -0,0 +1,60 @@
+import { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from "./util/sql_utils.cjs";
+import * as _langchain_core_load_serializable0 from "@langchain/core/load/serializable";
+import { Serializable } from "@langchain/core/load/serializable";
+import { DataSource, DataSourceOptions } from "typeorm";
+
+//#region src/sql_db.d.ts
+
+/**
+ * Class that represents a SQL database in the LangChain framework.
+ *
+ * @security **Security Notice**
+ * This class generates SQL queries for the given database.
+ * The SQLDatabase class provides a getTableInfo method that can be used
+ * to get column information as well as sample data from the table.
+ * To mitigate risk of leaking sensitive data, limit permissions
+ * to read and scope to the tables that are needed.
+ * Optionally, use the includesTables or ignoreTables class parameters
+ * to limit which tables can/cannot be accessed.
+ *
+ * @link See https://js.langchain.com/docs/security for more information.
+ */
+declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {
+  lc_namespace: string[];
+  toJSON(): _langchain_core_load_serializable0.SerializedNotImplemented;
+  appDataSourceOptions: DataSourceOptions;
+  appDataSource: DataSource;
+  allTables: Array<SqlTable>;
+  includesTables: Array<string>;
+  ignoreTables: Array<string>;
+  sampleRowsInTableInfo: number;
+  customDescription?: Record<string, string>;
+  protected constructor(fields: SqlDatabaseDataSourceParams);
+  static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;
+  static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;
+  /**
+   * Get information about specified tables.
+   *
+   * Follows best practices as specified in: Rajkumar et al, 2022
+   * (https://arxiv.org/abs/2204.00498)
+   *
+   * If `sample_rows_in_table_info`, the specified number of sample rows will be
+   * appended to each table description. This can increase performance as
+   * demonstrated in the paper.
+   */
+  getTableInfo(targetTables?: Array<string>): Promise<string>;
+  /**
+   * Execute a SQL command and return a string representing the results.
+   * If the statement returns rows, a string of the results is returned.
+   * If the statement returns no rows, an empty string is returned.
+   */
+  run(command: string, fetch?: "all" | "one"): Promise<string>;
+  serialize(): SerializedSqlDatabase;
+  /** @ignore */
+  static imports(): Promise<{
+    DataSource: typeof DataSource;
+  }>;
+}
+//#endregion
+export { SqlDatabase, type SqlDatabaseDataSourceParams, type SqlDatabaseOptionsParams };
+//# sourceMappingURL=sql_db.d.cts.map

package/dist/sql_db.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql_db.d.cts","names":["DataSource","DataSourceT","DataSourceOptions","Serializable","SerializedSqlDatabase","SqlDatabaseDataSourceParams","SqlDatabaseOptionsParams","SqlTable","SqlDatabase","_langchain_core_load_serializable0","SerializedNotImplemented","Array","Record","Promise"],"sources":["../src/sql_db.d.ts"],"sourcesContent":["import type { DataSource as DataSourceT, DataSourceOptions } from \"typeorm\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from \"./util/sql_utils.js\";\nexport type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };\n/**\n * Class that represents a SQL database in the LangChain framework.\n *\n * @security **Security Notice**\n * This class generates SQL queries for the given database.\n * The SQLDatabase class provides a getTableInfo method that can be used\n * to get column information as well as sample data from the table.\n * To mitigate risk of leaking sensitive data, limit permissions\n * to read and scope to the tables that are needed.\n * Optionally, use the includesTables or ignoreTables class parameters\n * to limit which tables can/cannot be accessed.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {\n    lc_namespace: string[];\n    toJSON(): import(\"@langchain/core/load/serializable\").SerializedNotImplemented;\n    appDataSourceOptions: DataSourceOptions;\n    appDataSource: DataSourceT;\n    allTables: Array<SqlTable>;\n    includesTables: Array<string>;\n    ignoreTables: Array<string>;\n    sampleRowsInTableInfo: number;\n    customDescription?: Record<string, string>;\n    protected constructor(fields: SqlDatabaseDataSourceParams);\n    static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;\n    static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;\n    /**\n     * Get information about specified tables.\n     *\n     * Follows best practices as specified in: Rajkumar et al, 2022\n     * (https://arxiv.org/abs/2204.00498)\n     *\n     * If `sample_rows_in_table_info`, the specified number of sample rows will be\n     * appended to each table description. This can increase performance as\n     * demonstrated in the paper.\n     */\n    getTableInfo(targetTables?: Array<string>): Promise<string>;\n    /**\n     * Execute a SQL command and return a string representing the results.\n     * If the statement returns rows, a string of the results is returned.\n     * If the statement returns no rows, an empty string is returned.\n     */\n    run(command: string, fetch?: \"all\" | \"one\"): Promise<string>;\n    serialize(): SerializedSqlDatabase;\n    /** @ignore */\n    static imports(): Promise<{\n        DataSource: typeof DataSourceT;\n    }>;\n}\n"],"mappings":";;;;;;;;;AAkBA;;;;;;;;;;;;AAW8EQ,cAXzDA,WAAAA,SAAoBL,YAAAA,YAAwBG,wBAWaE,EAXaH,2BAWbG,CAAAA;EAAW,YAAnBK,EAAAA,MAAAA,EAAAA;EAAO,MACxCP,CAAAA,CAAAA,EAZLG,kCAAAA,CAE0BC,wBAUrBJ;EAAwB,oBAAWE,EAT9CN,iBAS8CM;EAAW,aAAnBK,EAR7CZ,UAQ6CY;EAAO,SAWvCF,EAlBjBA,KAkBiBA,CAlBXJ,QAkBWI,CAAAA;EAAK,cAAWE,EAjB5BF,KAiB4BE,CAAAA,MAAAA,CAAAA;EAAO,YAMNA,EAtB/BF,KAsB+BE,CAAAA,MAAAA,CAAAA;EAAO,qBACvCT,EAAAA,MAAAA;EAAqB,iBAGXH,CAAAA,EAxBHW,MAwBGX,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAW,UADhBY,WAAAA,CAAAA,MAAAA,EAtBYR,2BAsBZQ;EAAO,OAhCYV,oBAAAA,CAAAA,MAAAA,EAWDE,2BAXCF,CAAAA,EAW6BU,OAX7BV,CAWqCK,WAXrCL,CAAAA;EAAY,OAAYG,iBAAAA,CAAAA,MAAAA,EAY5BA,wBAZ4BA,CAAAA,EAYDO,OAZCP,CAYOE,WAZPF,CAAAA;EAAwB;AAA6B;;;;;;;;;8BAuBtFK,gBAAgBE;;;;;;+CAMCA;eAChCT;;oBAEKS;uBACKZ"}

package/dist/sql_db.d.ts

@@ -1,7 +1,10 @@
-import type { DataSource as DataSourceT, DataSourceOptions } from "typeorm";
-import { Serializable } from "@langchain/core/load/serializable";
 import { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from "./util/sql_utils.js";
-export type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };
+import * as _langchain_core_load_serializable0 from "@langchain/core/load/serializable";
+import { Serializable } from "@langchain/core/load/serializable";
+import { DataSource, DataSourceOptions } from "typeorm";
+
+//#region src/sql_db.d.ts
+
 /**
  * Class that represents a SQL database in the LangChain framework.
  *
@@ -16,39 +19,42 @@ export type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };
  *
  * @link See https://js.langchain.com/docs/security for more information.
  */
-export declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {
-    lc_namespace: string[];
-    toJSON(): import("@langchain/core/load/serializable").SerializedNotImplemented;
-    appDataSourceOptions: DataSourceOptions;
-    appDataSource: DataSourceT;
-    allTables: Array<SqlTable>;
-    includesTables: Array<string>;
-    ignoreTables: Array<string>;
-    sampleRowsInTableInfo: number;
-    customDescription?: Record<string, string>;
-    protected constructor(fields: SqlDatabaseDataSourceParams);
-    static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;
-    static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;
-    /**
-     * Get information about specified tables.
-     *
-     * Follows best practices as specified in: Rajkumar et al, 2022
-     * (https://arxiv.org/abs/2204.00498)
-     *
-     * If `sample_rows_in_table_info`, the specified number of sample rows will be
-     * appended to each table description. This can increase performance as
-     * demonstrated in the paper.
-     */
-    getTableInfo(targetTables?: Array<string>): Promise<string>;
-    /**
-     * Execute a SQL command and return a string representing the results.
-     * If the statement returns rows, a string of the results is returned.
-     * If the statement returns no rows, an empty string is returned.
-     */
-    run(command: string, fetch?: "all" | "one"): Promise<string>;
-    serialize(): SerializedSqlDatabase;
-    /** @ignore */
-    static imports(): Promise<{
-        DataSource: typeof DataSourceT;
-    }>;
+declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {
+  lc_namespace: string[];
+  toJSON(): _langchain_core_load_serializable0.SerializedNotImplemented;
+  appDataSourceOptions: DataSourceOptions;
+  appDataSource: DataSource;
+  allTables: Array<SqlTable>;
+  includesTables: Array<string>;
+  ignoreTables: Array<string>;
+  sampleRowsInTableInfo: number;
+  customDescription?: Record<string, string>;
+  protected constructor(fields: SqlDatabaseDataSourceParams);
+  static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;
+  static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;
+  /**
+   * Get information about specified tables.
+   *
+   * Follows best practices as specified in: Rajkumar et al, 2022
+   * (https://arxiv.org/abs/2204.00498)
+   *
+   * If `sample_rows_in_table_info`, the specified number of sample rows will be
+   * appended to each table description. This can increase performance as
+   * demonstrated in the paper.
+   */
+  getTableInfo(targetTables?: Array<string>): Promise<string>;
+  /**
+   * Execute a SQL command and return a string representing the results.
+   * If the statement returns rows, a string of the results is returned.
+   * If the statement returns no rows, an empty string is returned.
+   */
+  run(command: string, fetch?: "all" | "one"): Promise<string>;
+  serialize(): SerializedSqlDatabase;
+  /** @ignore */
+  static imports(): Promise<{
+    DataSource: typeof DataSource;
+  }>;
 }
+//#endregion
+export { SqlDatabase, type SqlDatabaseDataSourceParams, type SqlDatabaseOptionsParams };
+//# sourceMappingURL=sql_db.d.ts.map

package/dist/sql_db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql_db.d.ts","names":["DataSource","DataSourceT","DataSourceOptions","Serializable","SerializedSqlDatabase","SqlDatabaseDataSourceParams","SqlDatabaseOptionsParams","SqlTable","SqlDatabase","_langchain_core_load_serializable0","SerializedNotImplemented","Array","Record","Promise"],"sources":["../src/sql_db.d.ts"],"sourcesContent":["import type { DataSource as DataSourceT, DataSourceOptions } from \"typeorm\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from \"./util/sql_utils.js\";\nexport type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };\n/**\n * Class that represents a SQL database in the LangChain framework.\n *\n * @security **Security Notice**\n * This class generates SQL queries for the given database.\n * The SQLDatabase class provides a getTableInfo method that can be used\n * to get column information as well as sample data from the table.\n * To mitigate risk of leaking sensitive data, limit permissions\n * to read and scope to the tables that are needed.\n * Optionally, use the includesTables or ignoreTables class parameters\n * to limit which tables can/cannot be accessed.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {\n    lc_namespace: string[];\n    toJSON(): import(\"@langchain/core/load/serializable\").SerializedNotImplemented;\n    appDataSourceOptions: DataSourceOptions;\n    appDataSource: DataSourceT;\n    allTables: Array<SqlTable>;\n    includesTables: Array<string>;\n    ignoreTables: Array<string>;\n    sampleRowsInTableInfo: number;\n    customDescription?: Record<string, string>;\n    protected constructor(fields: SqlDatabaseDataSourceParams);\n    static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;\n    static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;\n    /**\n     * Get information about specified tables.\n     *\n     * Follows best practices as specified in: Rajkumar et al, 2022\n     * (https://arxiv.org/abs/2204.00498)\n     *\n     * If `sample_rows_in_table_info`, the specified number of sample rows will be\n     * appended to each table description. This can increase performance as\n     * demonstrated in the paper.\n     */\n    getTableInfo(targetTables?: Array<string>): Promise<string>;\n    /**\n     * Execute a SQL command and return a string representing the results.\n     * If the statement returns rows, a string of the results is returned.\n     * If the statement returns no rows, an empty string is returned.\n     */\n    run(command: string, fetch?: \"all\" | \"one\"): Promise<string>;\n    serialize(): SerializedSqlDatabase;\n    /** @ignore */\n    static imports(): Promise<{\n        DataSource: typeof DataSourceT;\n    }>;\n}\n"],"mappings":";;;;;;;;;AAkBA;;;;;;;;;;;;AAW8EQ,cAXzDA,WAAAA,SAAoBL,YAAAA,YAAwBG,wBAWaE,EAXaH,2BAWbG,CAAAA;EAAW,YAAnBK,EAAAA,MAAAA,EAAAA;EAAO,MACxCP,CAAAA,CAAAA,EAZLG,kCAAAA,CAE0BC,wBAUrBJ;EAAwB,oBAAWE,EAT9CN,iBAS8CM;EAAW,aAAnBK,EAR7CZ,UAQ6CY;EAAO,SAWvCF,EAlBjBA,KAkBiBA,CAlBXJ,QAkBWI,CAAAA;EAAK,cAAWE,EAjB5BF,KAiB4BE,CAAAA,MAAAA,CAAAA;EAAO,YAMNA,EAtB/BF,KAsB+BE,CAAAA,MAAAA,CAAAA;EAAO,qBACvCT,EAAAA,MAAAA;EAAqB,iBAGXH,CAAAA,EAxBHW,MAwBGX,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAW,UADhBY,WAAAA,CAAAA,MAAAA,EAtBYR,2BAsBZQ;EAAO,OAhCYV,oBAAAA,CAAAA,MAAAA,EAWDE,2BAXCF,CAAAA,EAW6BU,OAX7BV,CAWqCK,WAXrCL,CAAAA;EAAY,OAAYG,iBAAAA,CAAAA,MAAAA,EAY5BA,wBAZ4BA,CAAAA,EAYDO,OAZCP,CAYOE,WAZPF,CAAAA;EAAwB;AAA6B;;;;;;;;;8BAuBtFK,gBAAgBE;;;;;;+CAMCA;eAChCT;;oBAEKS;uBACKZ"}