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

package/dist/engine.d.ts

@@ -1,27 +1,30 @@
 import { Connector, IpAddressTypes } from "@google-cloud/cloud-sql-connector";
 import knex from "knex";
-export interface PostgresEngineArgs {
-    ipType?: IpAddressTypes;
-    user?: string;
-    password?: string;
-    iamAccountEmail?: string;
+
+//#region src/engine.d.ts
+interface PostgresEngineArgs {
+  ipType?: IpAddressTypes;
+  user?: string;
+  password?: string;
+  iamAccountEmail?: string;
 }
-export interface VectorStoreTableArgs {
-    schemaName?: string;
-    contentColumn?: string;
-    embeddingColumn?: string;
-    metadataColumns?: Column[];
-    metadataJsonColumn?: string;
-    idColumn?: string | Column;
-    overwriteExisting?: boolean;
-    storeMetadata?: boolean;
+interface VectorStoreTableArgs {
+  schemaName?: string;
+  contentColumn?: string;
+  embeddingColumn?: string;
+  embeddingColumnType?: "vector" | "halfvec" | "bit" | "sparsevec";
+  metadataColumns?: Column[];
+  metadataJsonColumn?: string;
+  idColumn?: string | Column;
+  overwriteExisting?: boolean;
+  storeMetadata?: boolean;
 }
-export declare class Column {
-    name: string;
-    dataType: string;
-    nullable: boolean;
-    constructor(name: string, dataType: string, nullable?: boolean);
-    private postInitilization;
+declare class Column {
+  name: string;
+  dataType: string;
+  nullable: boolean;
+  constructor(name: string, dataType: string, nullable?: boolean);
+  private postInitilization;
 }
 /**
  * Cloud SQL shared connection pool
@@ -53,64 +56,83 @@ export declare class Column {
  * <br />
  *
  */
-export declare class PostgresEngine {
-    private static _createKey;
-    pool: knex.Knex;
-    static connector: Connector;
-    constructor(key: symbol, pool: knex.Knex);
-    /**
-     * @param projectId Required - GCP Project ID
-     * @param region Required - Postgres Instance Region
-     * @param instance Required - Postgres Instance name
-     * @param database Required - Database name
-     * @param ipType Optional - IP address type. Defaults to IPAddressType.PUBLIC
-     * @param user Optional - Postgres user name. Defaults to undefined
-     * @param password Optional - Postgres user password. Defaults to undefined
-     * @param iamAccountEmail Optional - IAM service account email. Defaults to undefined
-     * @returns PostgresEngine instance
-     */
-    static fromInstance(projectId: string, region: string, instance: string, database: string, { ipType, user, password, iamAccountEmail, }?: PostgresEngineArgs): Promise<PostgresEngine>;
-    /**
-     * Create a PostgresEngine instance from an Knex instance.
-     *
-     * @param engine knex instance
-     * @returns PostgresEngine instance from a knex instance
-     */
-    static fromPool(engine: knex.Knex): Promise<PostgresEngine>;
-    /**
-     * Create a PostgresEngine instance from arguments.
-     *
-     * @param url URL use to connect to a database
-     * @param poolConfig Optional - Configuration pool to use in the Knex configuration
-     * @returns PostgresEngine instance
-     */
-    static fromConnectionString(url: string | knex.Knex.StaticConnectionConfig, poolConfig?: knex.Knex.PoolConfig): Promise<PostgresEngine>;
-    /**
-     * Create a table for saving of vectors to be used with PostgresVectorStore.
-     *
-     * @param tableName Postgres database table name. Parameter is not escaped. Do not use with end user input.
-     * @param vectorSize Vector size for the embedding model to be used.
-     * @param schemaName The schema name to store Postgres database table. Default: "public". Parameter is not escaped. Do not use with end user input.
-     * @param contentColumn Name of the column to store document content. Default: "content".
-     * @param embeddingColumn Name of the column to store vector embeddings. Default: "embedding".
-     * @param metadataColumns Optional - A list of Columns to create for custom metadata. Default: [].
-     * @param metadataJsonColumn Optional - The column to store extra metadata in JSON format. Default: "langchain_metadata".
-     * @param idColumn Optional - Column to store ids. Default: "langchain_id" column name with data type UUID.
-     * @param overwriteExisting Whether to drop existing table. Default: False.
-     * @param storeMetadata Whether to store metadata in the table. Default: True.
-     */
-    initVectorstoreTable(tableName: string, vectorSize: number, { schemaName, contentColumn, embeddingColumn, metadataColumns, metadataJsonColumn, idColumn, overwriteExisting, storeMetadata, }?: VectorStoreTableArgs): Promise<void>;
-    /**
-     * Create a Cloud SQL table to store chat history.
-     *
-     * @param tableName Table name to store chat history
-     * @param schemaName Schema name to store chat history table
-     */
-    initChatHistoryTable(tableName: string, schemaName?: string): Promise<void>;
-    /**
-     *  Dispose of connection pool
-     */
-    closeConnection(): Promise<void>;
-    testConnection(): knex.Knex.Raw<any>;
+declare class PostgresEngine {
+  private static _createKey;
+  pool: knex.Knex;
+  static connector: Connector;
+  constructor(key: symbol, pool: knex.Knex);
+  /**
+   * @param projectId Required - GCP Project ID
+   * @param region Required - Postgres Instance Region
+   * @param instance Required - Postgres Instance name
+   * @param database Required - Database name
+   * @param ipType Optional - IP address type. Defaults to IPAddressType.PUBLIC
+   * @param user Optional - Postgres user name. Defaults to undefined
+   * @param password Optional - Postgres user password. Defaults to undefined
+   * @param iamAccountEmail Optional - IAM service account email. Defaults to undefined
+   * @returns PostgresEngine instance
+   */
+  static fromInstance(projectId: string, region: string, instance: string, database: string, {
+    ipType,
+    user,
+    password,
+    iamAccountEmail
+  }?: PostgresEngineArgs): Promise<PostgresEngine>;
+  /**
+   * Create a PostgresEngine instance from an Knex instance.
+   *
+   * @param engine knex instance
+   * @returns PostgresEngine instance from a knex instance
+   */
+  static fromPool(engine: knex.Knex): Promise<PostgresEngine>;
+  /**
+   * Create a PostgresEngine instance from arguments.
+   *
+   * @param url URL use to connect to a database
+   * @param poolConfig Optional - Configuration pool to use in the Knex configuration
+   * @returns PostgresEngine instance
+   */
+  static fromConnectionString(url: string | knex.Knex.StaticConnectionConfig, poolConfig?: knex.Knex.PoolConfig): Promise<PostgresEngine>;
+  /**
+   * Create a table for saving of vectors to be used with PostgresVectorStore.
+   *
+   * @param tableName Postgres database table name. Parameter is not escaped. Do not use with end user input.
+   * @param vectorSize Vector size for the embedding model to be used.
+   * @param schemaName The schema name to store Postgres database table. Default: "public". Parameter is not escaped. Do not use with end user input.
+   * @param contentColumn Name of the column to store document content. Default: "content".
+   * @param embeddingColumn Name of the column to store vector embeddings. Default: "embedding".
+   * @param embeddingColumnType Type of the embedding column ("vector" | "halfvec" | "bit" | "sparsevec"). Default: "vector". More info on HNSW-supported types: https://github.com/pgvector/pgvector#hnsw
+   * @param metadataColumns Optional - A list of Columns to create for custom metadata. Default: [].
+   * @param metadataJsonColumn Optional - The column to store extra metadata in JSON format. Default: "langchain_metadata".
+   * @param idColumn Optional - Column to store ids. Default: "langchain_id" column name with data type UUID.
+   * @param overwriteExisting Whether to drop existing table. Default: False.
+   * @param storeMetadata Whether to store metadata in the table. Default: True.
+   */
+  initVectorstoreTable(tableName: string, vectorSize: number, {
+    schemaName,
+    contentColumn,
+    embeddingColumn,
+    embeddingColumnType,
+    metadataColumns,
+    metadataJsonColumn,
+    idColumn,
+    overwriteExisting,
+    storeMetadata
+  }?: VectorStoreTableArgs): Promise<void>;
+  /**
+   * Create a Cloud SQL table to store chat history.
+   *
+   * @param tableName Table name to store chat history
+   * @param schemaName Schema name to store chat history table
+   */
+  initChatHistoryTable(tableName: string, schemaName?: string): Promise<void>;
+  /**
+   *  Dispose of connection pool
+   */
+  closeConnection(): Promise<void>;
+  // Just to test the connection to the database
+  testConnection(): knex.Knex.Raw<any>;
 }
-export default PostgresEngine;
+//#endregion
+export { Column, PostgresEngine, PostgresEngineArgs, VectorStoreTableArgs };
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.js

@@ -1,244 +1,196 @@
-import { AuthTypes, Connector, IpAddressTypes, } from "@google-cloud/cloud-sql-connector";
+import { getIAMPrincipalEmail } from "./utils/utils.js";
+import { AuthTypes, Connector, IpAddressTypes } from "@google-cloud/cloud-sql-connector";
 import { GoogleAuth } from "google-auth-library";
 import knex from "knex";
-import { getIAMPrincipalEmail } from "./utils/utils.js";
-export class Column {
-    constructor(name, dataType, nullable = true) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "dataType", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "nullable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = name;
-        this.dataType = dataType;
-        this.nullable = nullable;
-        this.postInitilization();
-    }
-    postInitilization() {
-        if (typeof this.name !== "string") {
-            throw Error("Column name must be type string");
-        }
-        if (typeof this.dataType !== "string") {
-            throw Error("Column data_type must be type string");
-        }
-    }
-}
+
+//#region src/engine.ts
+var Column = class {
+	name;
+	dataType;
+	nullable;
+	constructor(name, dataType, nullable = true) {
+		this.name = name;
+		this.dataType = dataType;
+		this.nullable = nullable;
+		this.postInitilization();
+	}
+	postInitilization() {
+		if (typeof this.name !== "string") throw Error("Column name must be type string");
+		if (typeof this.dataType !== "string") throw Error("Column data_type must be type string");
+	}
+};
 const USER_AGENT = "langchain-google-cloud-sql-pg-js";
 /**
- * Cloud SQL shared connection pool
- *
- * Setup:
- * Install `@langchain/google-cloud-sql-pg`
- *
- * <details open>
- * <summary><strong>Instantiate</strong></summary>
- *
- * ```typescript
- * import { Column, PostgresEngine, PostgresEngineArgs } from "@langchain/google-cloud-sql-pg";
- *
- * const pgArgs: PostgresEngineArgs = {
- *    user: "db-user",
- *    password: "password"
- *}
- *
- * const engine: PostgresEngine = await PostgresEngine.fromInstance(
- *  "project-id",
- *  "region",
- *  "instance-name",
- *  "database-name",
- *  pgArgs
- * );
- * ```
- * </details>
- *
- * <br />
- *
- */
-export class PostgresEngine {
-    constructor(key, pool) {
-        Object.defineProperty(this, "pool", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        if (key !== PostgresEngine._createKey) {
-            throw Error("Only create class through 'create' method!");
-        }
-        this.pool = pool;
-    }
-    /**
-     * @param projectId Required - GCP Project ID
-     * @param region Required - Postgres Instance Region
-     * @param instance Required - Postgres Instance name
-     * @param database Required - Database name
-     * @param ipType Optional - IP address type. Defaults to IPAddressType.PUBLIC
-     * @param user Optional - Postgres user name. Defaults to undefined
-     * @param password Optional - Postgres user password. Defaults to undefined
-     * @param iamAccountEmail Optional - IAM service account email. Defaults to undefined
-     * @returns PostgresEngine instance
-     */
-    static async fromInstance(projectId, region, instance, database, { ipType = IpAddressTypes.PUBLIC, user, password, iamAccountEmail, } = {}) {
-        let dbUser;
-        let enableIAMAuth;
-        if ((!user && password) || (user && !password)) {
-            // XOR for strings
-            throw Error("Only one of 'user' or 'password' were specified. Either " +
-                "both should be specified to use basic user/password " +
-                "authentication or neither for IAM DB authentication.");
-        }
-        // User and password are given so we use the basic auth
-        if (user !== undefined && password !== undefined) {
-            enableIAMAuth = false;
-            dbUser = user;
-        }
-        else {
-            enableIAMAuth = true;
-            if (iamAccountEmail !== undefined) {
-                dbUser = iamAccountEmail;
-            }
-            else {
-                // Get application default credentials
-                const auth = new GoogleAuth({
-                    scopes: "https://www.googleapis.com/auth/cloud-platform",
-                });
-                // dbUser should be the iam principal email by passing the credentials obtained
-                dbUser = await getIAMPrincipalEmail(auth);
-            }
-        }
-        PostgresEngine.connector = new Connector({ userAgent: USER_AGENT });
-        const clientOpts = await PostgresEngine.connector.getOptions({
-            instanceConnectionName: `${projectId}:${region}:${instance}`,
-            ipType,
-            authType: enableIAMAuth ? AuthTypes.IAM : AuthTypes.PASSWORD,
-        });
-        const dbConfig = {
-            client: "pg",
-            connection: {
-                ...clientOpts,
-                ...(password ? { password } : {}),
-                user: dbUser,
-                database,
-            },
-        };
-        const engine = knex(dbConfig);
-        return new PostgresEngine(PostgresEngine._createKey, engine);
-    }
-    /**
-     * Create a PostgresEngine instance from an Knex instance.
-     *
-     * @param engine knex instance
-     * @returns PostgresEngine instance from a knex instance
-     */
-    static async fromPool(engine) {
-        return new PostgresEngine(PostgresEngine._createKey, engine);
-    }
-    /**
-     * Create a PostgresEngine instance from arguments.
-     *
-     * @param url URL use to connect to a database
-     * @param poolConfig Optional - Configuration pool to use in the Knex configuration
-     * @returns PostgresEngine instance
-     */
-    static async fromConnectionString(url, poolConfig) {
-        const driver = "postgresql+asyncpg";
-        if (typeof url === "string" && !url.startsWith(driver)) {
-            throw Error("Driver must be type 'postgresql+asyncpg'");
-        }
-        const dbConfig = {
-            client: "pg",
-            connection: url,
-            acquireConnectionTimeout: 1000000,
-            pool: {
-                ...poolConfig,
-                acquireTimeoutMillis: 600000,
-            },
-        };
-        const engine = knex(dbConfig);
-        return new PostgresEngine(PostgresEngine._createKey, engine);
-    }
-    /**
-     * Create a table for saving of vectors to be used with PostgresVectorStore.
-     *
-     * @param tableName Postgres database table name. Parameter is not escaped. Do not use with end user input.
-     * @param vectorSize Vector size for the embedding model to be used.
-     * @param schemaName The schema name to store Postgres database table. Default: "public". Parameter is not escaped. Do not use with end user input.
-     * @param contentColumn Name of the column to store document content. Default: "content".
-     * @param embeddingColumn Name of the column to store vector embeddings. Default: "embedding".
-     * @param metadataColumns Optional - A list of Columns to create for custom metadata. Default: [].
-     * @param metadataJsonColumn Optional - The column to store extra metadata in JSON format. Default: "langchain_metadata".
-     * @param idColumn Optional - Column to store ids. Default: "langchain_id" column name with data type UUID.
-     * @param overwriteExisting Whether to drop existing table. Default: False.
-     * @param storeMetadata Whether to store metadata in the table. Default: True.
-     */
-    async initVectorstoreTable(tableName, vectorSize, { schemaName = "public", contentColumn = "content", embeddingColumn = "embedding", metadataColumns = [], metadataJsonColumn = "langchain_metadata", idColumn = "langchain_id", overwriteExisting = false, storeMetadata = true, } = {}) {
-        await this.pool.raw("CREATE EXTENSION IF NOT EXISTS vector");
-        if (overwriteExisting) {
-            await this.pool.schema
-                .withSchema(schemaName)
-                .dropTableIfExists(tableName);
-        }
-        const idDataType = typeof idColumn === "string" ? "UUID" : idColumn.dataType;
-        const idColumnName = typeof idColumn === "string" ? idColumn : idColumn.name;
-        let query = `CREATE TABLE ${schemaName}.${tableName}(
+* Cloud SQL shared connection pool
+*
+* Setup:
+* Install `@langchain/google-cloud-sql-pg`
+*
+* <details open>
+* <summary><strong>Instantiate</strong></summary>
+*
+* ```typescript
+* import { Column, PostgresEngine, PostgresEngineArgs } from "@langchain/google-cloud-sql-pg";
+*
+* const pgArgs: PostgresEngineArgs = {
+*    user: "db-user",
+*    password: "password"
+*}
+*
+* const engine: PostgresEngine = await PostgresEngine.fromInstance(
+*  "project-id",
+*  "region",
+*  "instance-name",
+*  "database-name",
+*  pgArgs
+* );
+* ```
+* </details>
+*
+* <br />
+*
+*/
+var PostgresEngine = class PostgresEngine {
+	static _createKey = Symbol("key");
+	pool;
+	static connector;
+	constructor(key, pool) {
+		if (key !== PostgresEngine._createKey) throw Error("Only create class through 'create' method!");
+		this.pool = pool;
+	}
+	/**
+	* @param projectId Required - GCP Project ID
+	* @param region Required - Postgres Instance Region
+	* @param instance Required - Postgres Instance name
+	* @param database Required - Database name
+	* @param ipType Optional - IP address type. Defaults to IPAddressType.PUBLIC
+	* @param user Optional - Postgres user name. Defaults to undefined
+	* @param password Optional - Postgres user password. Defaults to undefined
+	* @param iamAccountEmail Optional - IAM service account email. Defaults to undefined
+	* @returns PostgresEngine instance
+	*/
+	static async fromInstance(projectId, region, instance, database, { ipType = IpAddressTypes.PUBLIC, user, password, iamAccountEmail } = {}) {
+		let dbUser;
+		let enableIAMAuth;
+		if (!user && password || user && !password) throw Error("Only one of 'user' or 'password' were specified. Either both should be specified to use basic user/password authentication or neither for IAM DB authentication.");
+		if (user !== void 0 && password !== void 0) {
+			enableIAMAuth = false;
+			dbUser = user;
+		} else {
+			enableIAMAuth = true;
+			if (iamAccountEmail !== void 0) dbUser = iamAccountEmail;
+			else {
+				const auth = new GoogleAuth({ scopes: "https://www.googleapis.com/auth/cloud-platform" });
+				dbUser = await getIAMPrincipalEmail(auth);
+			}
+		}
+		PostgresEngine.connector = new Connector({ userAgent: USER_AGENT });
+		const clientOpts = await PostgresEngine.connector.getOptions({
+			instanceConnectionName: `${projectId}:${region}:${instance}`,
+			ipType,
+			authType: enableIAMAuth ? AuthTypes.IAM : AuthTypes.PASSWORD
+		});
+		const dbConfig = {
+			client: "pg",
+			connection: {
+				...clientOpts,
+				...password ? { password } : {},
+				user: dbUser,
+				database
+			}
+		};
+		const engine = knex(dbConfig);
+		return new PostgresEngine(PostgresEngine._createKey, engine);
+	}
+	/**
+	* Create a PostgresEngine instance from an Knex instance.
+	*
+	* @param engine knex instance
+	* @returns PostgresEngine instance from a knex instance
+	*/
+	static async fromPool(engine) {
+		return new PostgresEngine(PostgresEngine._createKey, engine);
+	}
+	/**
+	* Create a PostgresEngine instance from arguments.
+	*
+	* @param url URL use to connect to a database
+	* @param poolConfig Optional - Configuration pool to use in the Knex configuration
+	* @returns PostgresEngine instance
+	*/
+	static async fromConnectionString(url, poolConfig) {
+		const driver = "postgresql+asyncpg";
+		if (typeof url === "string" && !url.startsWith(driver)) throw Error("Driver must be type 'postgresql+asyncpg'");
+		const dbConfig = {
+			client: "pg",
+			connection: url,
+			acquireConnectionTimeout: 1e6,
+			pool: {
+				...poolConfig,
+				acquireTimeoutMillis: 6e5
+			}
+		};
+		const engine = knex(dbConfig);
+		return new PostgresEngine(PostgresEngine._createKey, engine);
+	}
+	/**
+	* Create a table for saving of vectors to be used with PostgresVectorStore.
+	*
+	* @param tableName Postgres database table name. Parameter is not escaped. Do not use with end user input.
+	* @param vectorSize Vector size for the embedding model to be used.
+	* @param schemaName The schema name to store Postgres database table. Default: "public". Parameter is not escaped. Do not use with end user input.
+	* @param contentColumn Name of the column to store document content. Default: "content".
+	* @param embeddingColumn Name of the column to store vector embeddings. Default: "embedding".
+	* @param embeddingColumnType Type of the embedding column ("vector" | "halfvec" | "bit" | "sparsevec"). Default: "vector". More info on HNSW-supported types: https://github.com/pgvector/pgvector#hnsw
+	* @param metadataColumns Optional - A list of Columns to create for custom metadata. Default: [].
+	* @param metadataJsonColumn Optional - The column to store extra metadata in JSON format. Default: "langchain_metadata".
+	* @param idColumn Optional - Column to store ids. Default: "langchain_id" column name with data type UUID.
+	* @param overwriteExisting Whether to drop existing table. Default: False.
+	* @param storeMetadata Whether to store metadata in the table. Default: True.
+	*/
+	async initVectorstoreTable(tableName, vectorSize, { schemaName = "public", contentColumn = "content", embeddingColumn = "embedding", embeddingColumnType = "vector", metadataColumns = [], metadataJsonColumn = "langchain_metadata", idColumn = "langchain_id", overwriteExisting = false, storeMetadata = true } = {}) {
+		await this.pool.raw("CREATE EXTENSION IF NOT EXISTS vector");
+		if (overwriteExisting) await this.pool.schema.withSchema(schemaName).dropTableIfExists(tableName);
+		const idDataType = typeof idColumn === "string" ? "UUID" : idColumn.dataType;
+		const idColumnName = typeof idColumn === "string" ? idColumn : idColumn.name;
+		let query = `CREATE TABLE ${schemaName}.${tableName}(
       ${idColumnName} ${idDataType} PRIMARY KEY,
       ${contentColumn} TEXT NOT NULL,
-      ${embeddingColumn} vector(${vectorSize}) NOT NULL`;
-        for (const column of metadataColumns) {
-            const nullable = !column.nullable ? "NOT NULL" : "";
-            query += `,\n ${column.name} ${column.dataType} ${nullable}`;
-        }
-        if (storeMetadata) {
-            query += `,\n${metadataJsonColumn} JSON`;
-        }
-        query += `\n);`;
-        await this.pool.raw(query);
-    }
-    /**
-     * Create a Cloud SQL table to store chat history.
-     *
-     * @param tableName Table name to store chat history
-     * @param schemaName Schema name to store chat history table
-     */
-    async initChatHistoryTable(tableName, schemaName = "public") {
-        await this.pool.raw(`CREATE TABLE IF NOT EXISTS ${schemaName}.${tableName}(
+      ${embeddingColumn} ${embeddingColumnType}(${vectorSize}) NOT NULL`;
+		for (const column of metadataColumns) {
+			const nullable = !column.nullable ? "NOT NULL" : "";
+			query += `,\n ${column.name} ${column.dataType} ${nullable}`;
+		}
+		if (storeMetadata) query += `,\n${metadataJsonColumn} JSON`;
+		query += `\n);`;
+		await this.pool.raw(query);
+	}
+	/**
+	* Create a Cloud SQL table to store chat history.
+	*
+	* @param tableName Table name to store chat history
+	* @param schemaName Schema name to store chat history table
+	*/
+	async initChatHistoryTable(tableName, schemaName = "public") {
+		await this.pool.raw(`CREATE TABLE IF NOT EXISTS ${schemaName}.${tableName}(
       id SERIAL PRIMARY KEY,
       session_id TEXT NOT NULL,
       data JSONB NOT NULL,
       type TEXT NOT NULL);`);
-    }
-    /**
-     *  Dispose of connection pool
-     */
-    async closeConnection() {
-        await this.pool.destroy();
-        if (PostgresEngine.connector !== undefined) {
-            PostgresEngine.connector.close();
-        }
-    }
-    // Just to test the connection to the database
-    testConnection() {
-        const now = this.pool.raw("SELECT NOW() as currentTimestamp");
-        return now;
-    }
-}
-Object.defineProperty(PostgresEngine, "_createKey", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Symbol("key")
-});
-export default PostgresEngine;
+	}
+	/**
+	*  Dispose of connection pool
+	*/
+	async closeConnection() {
+		await this.pool.destroy();
+		if (PostgresEngine.connector !== void 0) PostgresEngine.connector.close();
+	}
+	testConnection() {
+		const now = this.pool.raw("SELECT NOW() as currentTimestamp");
+		return now;
+	}
+};
+
+//#endregion
+export { Column, PostgresEngine };
+//# sourceMappingURL=engine.js.map