@chidchanun/bcp 0.2.2 → 0.2.3

package/packages/client/src/database-postgresql.ts

@@ -0,0 +1,355 @@
+import type {
+    DatabaseAdapter,
+    DatabaseParameters,
+    ResolvedDatabaseOptions,
+    TransactionDatabase,
+} from "./database.js";
+
+interface PostgresqlQueryResult {
+    rows: unknown[];
+    rowCount: number | null;
+    command?: string;
+}
+
+interface PostgresqlExecutor {
+    query(
+        sql: string,
+        parameters?: readonly unknown[]
+    ): Promise<PostgresqlQueryResult>;
+}
+
+interface PostgresqlConnection
+extends PostgresqlExecutor {
+    release(): void;
+}
+
+interface PostgresqlPool
+extends PostgresqlExecutor {
+    connect(): Promise<PostgresqlConnection>;
+    end(): Promise<void>;
+}
+
+interface PostgresqlPoolConstructor {
+    new (
+        options: Record<string, unknown>
+    ): PostgresqlPool;
+}
+
+interface PostgresqlModule {
+    Pool?: PostgresqlPoolConstructor;
+    default?: {
+        Pool?: PostgresqlPoolConstructor;
+    };
+}
+
+const POSTGRESQL_MODULE_SPECIFIER =
+    "pg";
+
+export function createPostgresqlDatabaseAdapter(
+    options: ResolvedDatabaseOptions
+): DatabaseAdapter {
+    return new PostgresqlDatabaseAdapter(
+        options
+    );
+}
+
+class PostgresqlDatabaseAdapter
+implements DatabaseAdapter {
+    readonly driver = "postgresql";
+
+    private readonly options:
+        ResolvedDatabaseOptions;
+
+    private poolPromise:
+        Promise<PostgresqlPool> | null =
+        null;
+
+    constructor(
+        options: ResolvedDatabaseOptions
+    ) {
+        this.options =
+            options;
+    }
+
+    async connect(): Promise<void> {
+        if (!this.poolPromise) {
+            this.poolPromise =
+                createPostgresqlPool(
+                    this.options
+                );
+        }
+
+        await this.poolPromise;
+    }
+
+    async query<T = unknown>(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<T> {
+        assertSql(
+            sql
+        );
+
+        const pool =
+            await this.getPool();
+        const result =
+            await pool.query(
+                sql,
+                normalizePostgresqlParameters(
+                    parameters
+                )
+            );
+
+        return result.rows as T;
+    }
+
+    async execute<T = unknown>(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<T> {
+        assertSql(
+            sql
+        );
+
+        const pool =
+            await this.getPool();
+        const result =
+            await pool.query(
+                sql,
+                normalizePostgresqlParameters(
+                    parameters
+                )
+            );
+
+        return result as T;
+    }
+
+    async transaction<T>(
+        callback: (
+            database: TransactionDatabase
+        ) => Promise<T>
+    ): Promise<T> {
+        assertTransactionCallback(
+            callback
+        );
+
+        const pool =
+            await this.getPool();
+        const connection =
+            await pool.connect();
+
+        await connection.query(
+            "BEGIN"
+        );
+
+        const transactionDatabase:
+            TransactionDatabase = {
+            query: async <R = unknown>(
+                sql: string,
+                parameters?: DatabaseParameters
+            ): Promise<R> => {
+                assertSql(
+                    sql
+                );
+
+                const result =
+                    await connection.query(
+                        sql,
+                        normalizePostgresqlParameters(
+                            parameters
+                        )
+                    );
+
+                return result.rows as R;
+            },
+            execute: async <R = unknown>(
+                sql: string,
+                parameters?: DatabaseParameters
+            ): Promise<R> => {
+                assertSql(
+                    sql
+                );
+
+                const result =
+                    await connection.query(
+                        sql,
+                        normalizePostgresqlParameters(
+                            parameters
+                        )
+                    );
+
+                return result as R;
+            },
+        };
+
+        try {
+            const result =
+                await callback(
+                    transactionDatabase
+                );
+
+            await connection.query(
+                "COMMIT"
+            );
+
+            return result;
+        } catch (error) {
+            try {
+                await connection.query(
+                    "ROLLBACK"
+                );
+            } catch {
+                // Preserve the original transaction error.
+            }
+
+            throw error;
+        } finally {
+            connection.release();
+        }
+    }
+
+    async disconnect(): Promise<void> {
+        const pendingPool =
+            this.poolPromise;
+
+        this.poolPromise =
+            null;
+
+        if (!pendingPool) {
+            return;
+        }
+
+        let pool:
+            PostgresqlPool;
+
+        try {
+            pool =
+                await pendingPool;
+        } catch {
+            return;
+        }
+
+        await pool.end();
+    }
+
+    private async getPool():
+        Promise<PostgresqlPool> {
+        await this.connect();
+
+        return this.poolPromise as
+            Promise<PostgresqlPool>;
+    }
+}
+
+async function createPostgresqlPool(
+    options: ResolvedDatabaseOptions
+): Promise<PostgresqlPool> {
+    let postgresqlModule:
+        PostgresqlModule;
+
+    try {
+        postgresqlModule =
+            await import(
+                POSTGRESQL_MODULE_SPECIFIER
+            ) as unknown as PostgresqlModule;
+    } catch (error) {
+        throw new Error(
+            "BCP Database: PostgreSQL requires the optional dependency pg. Install it with `npm install pg` or create the app with the PostgreSQL preset.",
+            {
+                cause:
+                    error,
+            }
+        );
+    }
+
+    const Pool =
+        postgresqlModule.Pool ??
+        postgresqlModule.default?.Pool;
+
+    if (
+        typeof Pool !==
+        "function"
+    ) {
+        throw new Error(
+            "BCP Database: pg did not expose a compatible Pool constructor."
+        );
+    }
+
+    const poolOptions:
+        Record<string, unknown> =
+        options.url
+            ? {
+                connectionString:
+                    options.url,
+                max:
+                    options.connectionLimit,
+            }
+            : {
+                host:
+                    options.host,
+                port:
+                    options.port,
+                user:
+                    options.user,
+                password:
+                    options.password,
+                database:
+                    options.database,
+                max:
+                    options.connectionLimit,
+            };
+
+    return new Pool(
+        poolOptions
+    );
+}
+
+function normalizePostgresqlParameters(
+    parameters: DatabaseParameters | undefined
+): readonly unknown[] | undefined {
+    if (
+        parameters === undefined
+    ) {
+        return undefined;
+    }
+
+    if (
+        Array.isArray(
+            parameters
+        )
+    ) {
+        return parameters;
+    }
+
+    throw new TypeError(
+        "BCP Database: PostgreSQL parameters must be an array. Use $1, $2, ... placeholders."
+    );
+}
+
+function assertSql(
+    sql: string
+): void {
+    if (
+        typeof sql !== "string" ||
+        sql.trim() === ""
+    ) {
+        throw new TypeError(
+            "BCP Database: SQL must be a non-empty string."
+        );
+    }
+}
+
+function assertTransactionCallback(
+    callback: unknown
+): asserts callback is (
+    database: TransactionDatabase
+) => Promise<unknown> {
+    if (
+        typeof callback !==
+        "function"
+    ) {
+        throw new TypeError(
+            "BCP Database: transaction callback must be a function."
+        );
+    }
+}