@chidchanun/bcp 0.2.1 → 0.2.3

package/packages/client/src/database.ts

@@ -1,7 +1,21 @@
-export type DatabaseDriver = "mysql";
-
-export interface DatabaseOptions {
+import {
+    createMysqlDatabaseAdapter,
+} from "./database-mysql.js";
+import {
+    createPostgresqlDatabaseAdapter,
+} from "./database-postgresql.js";
+import {
+    createSqliteDatabaseAdapter,
+} from "./database-sqlite.js";
+
+export type DatabaseDriver =
+    | "mysql"
+    | "postgresql"
+    | "sqlite";
+
+export interface DatabaseConnectionOptions {
     driver?: DatabaseDriver;
+    url?: string;
     host?: string;
     port?: number;
     user?: string;
@@ -28,44 +42,62 @@ export interface TransactionDatabase {
     ): Promise<T>;
 }
 
-interface MysqlExecutor {
-    query(
+export interface ResolvedDatabaseOptions
+extends Required<
+    Omit<
+        DatabaseConnectionOptions,
+        "url"
+    >
+> {
+    url?: string;
+}
+
+export interface DatabaseAdapter {
+    readonly driver: string;
+    connect(): Promise<void>;
+    query<T = unknown>(
         sql: string,
         parameters?: DatabaseParameters
-    ): Promise<[unknown, unknown]>;
-    execute(
+    ): Promise<T>;
+    execute<T = unknown>(
         sql: string,
         parameters?: DatabaseParameters
-    ): Promise<[unknown, unknown]>;
+    ): Promise<T>;
+    transaction<T>(
+        callback: (
+            database: TransactionDatabase
+        ) => Promise<T>
+    ): Promise<T>;
+    disconnect(): Promise<void>;
 }
 
-interface MysqlConnection extends MysqlExecutor {
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    release(): void;
-}
+export type DatabaseAdapterFactory =
+    () =>
+        | DatabaseAdapter
+        | Promise<DatabaseAdapter>;
 
-interface MysqlPool extends MysqlExecutor {
-    getConnection(): Promise<MysqlConnection>;
-    end(): Promise<void>;
+export interface DatabaseOptions
+extends DatabaseConnectionOptions {
+    adapter?:
+        | DatabaseAdapter
+        | DatabaseAdapterFactory;
 }
 
-interface MysqlModule {
-    createPool(
-        options: Record<string, unknown>
-    ): MysqlPool;
+interface DriverDefaults {
+    host: string;
+    port: number;
+    user: string;
+    database: string;
+    connectionLimit: number;
+    charset: string;
 }
 
-const MYSQL_MODULE_SPECIFIER =
-    "mysql2/promise";
-
 export class BcpDatabase {
     private readonly options:
         DatabaseOptions;
 
-    private poolPromise:
-        Promise<MysqlPool> | null =
+    private adapterPromise:
+        Promise<DatabaseAdapter> | null =
         null;
 
     constructor(
@@ -76,38 +108,42 @@ export class BcpDatabase {
         };
     }
 
+    async connect(): Promise<void> {
+        await this.getAdapter();
+    }
+
     async query<T = unknown>(
         sql: string,
         parameters?: DatabaseParameters
     ): Promise<T> {
-        assertSql(sql);
-
-        const pool =
-            await this.getPool();
-        const [rows] =
-            await pool.query(
-                sql,
-                parameters
-            );
+        assertSql(
+            sql
+        );
+
+        const adapter =
+            await this.getAdapter();
 
-        return rows as T;
+        return adapter.query<T>(
+            sql,
+            parameters
+        );
     }
 
     async execute<T = unknown>(
         sql: string,
         parameters?: DatabaseParameters
     ): Promise<T> {
-        assertSql(sql);
-
-        const pool =
-            await this.getPool();
-        const [result] =
-            await pool.execute(
-                sql,
-                parameters
-            );
+        assertSql(
+            sql
+        );
+
+        const adapter =
+            await this.getAdapter();
 
-        return result as T;
+        return adapter.execute<T>(
+            sql,
+            parameters
+        );
     }
 
     async transaction<T>(
@@ -115,104 +151,63 @@ export class BcpDatabase {
             database: TransactionDatabase
         ) => Promise<T>
     ): Promise<T> {
-        if (
-            typeof callback !==
-            "function"
-        ) {
-            throw new TypeError(
-                "BCP Database: transaction callback must be a function."
-            );
-        }
-
-        const pool =
-            await this.getPool();
-        const connection =
-            await pool.getConnection();
-
-        await connection.beginTransaction();
-
-        const transactionDatabase:
-            TransactionDatabase = {
-            query: async <R = unknown>(
-                sql: string,
-                parameters?: DatabaseParameters
-            ): Promise<R> => {
-                assertSql(sql);
-
-                const [rows] =
-                    await connection.query(
-                        sql,
-                        parameters
-                    );
-
-                return rows as R;
-            },
-            execute: async <R = unknown>(
-                sql: string,
-                parameters?: DatabaseParameters
-            ): Promise<R> => {
-                assertSql(sql);
-
-                const [result] =
-                    await connection.execute(
-                        sql,
-                        parameters
-                    );
-
-                return result as R;
-            },
-        };
-
-        try {
-            const result =
-                await callback(
-                    transactionDatabase
-                );
+        assertTransactionCallback(
+            callback
+        );
 
-            await connection.commit();
+        const adapter =
+            await this.getAdapter();
 
-            return result;
-        } catch (error) {
-            try {
-                await connection.rollback();
-            } catch {
-                // Preserve the original transaction error.
-            }
+        return adapter.transaction(
+            callback
+        );
+    }
 
-            throw error;
-        } finally {
-            connection.release();
-        }
+    async disconnect(): Promise<void> {
+        await this.close();
     }
 
     async close(): Promise<void> {
-        const pendingPool =
-            this.poolPromise;
+        const pendingAdapter =
+            this.adapterPromise;
 
-        this.poolPromise =
+        this.adapterPromise =
             null;
 
-        if (!pendingPool) {
+        if (!pendingAdapter) {
             return;
         }
 
-        const pool =
-            await pendingPool;
+        let adapter:
+            DatabaseAdapter;
+
+        try {
+            adapter =
+                await pendingAdapter;
+        } catch {
+            return;
+        }
 
-        await pool.end();
+        await adapter.disconnect();
     }
 
-    private getPool(): Promise<MysqlPool> {
-        if (!this.poolPromise) {
-            this.poolPromise =
-                createMysqlPool(
-                    resolveDatabaseOptions(
-                        this.options
-                    )
+    private async getAdapter():
+        Promise<DatabaseAdapter> {
+        if (!this.adapterPromise) {
+            this.adapterPromise =
+                initializeDatabaseAdapter(
+                    this.options
                 );
         }
 
-        return this.poolPromise;
+        try {
+            return await this.adapterPromise;
+        } catch (error) {
+            this.adapterPromise =
+                null;
+
+            throw error;
+        }
     }
 }
 
@@ -225,38 +220,50 @@ export function createDatabase(
 }
 
 export function resolveDatabaseOptions(
-    options: DatabaseOptions = {},
+    options: DatabaseConnectionOptions = {},
     environment: NodeJS.ProcessEnv =
         process.env
-): Required<DatabaseOptions> {
+): ResolvedDatabaseOptions {
+    const url =
+        nonEmpty(
+            options.url ??
+            environment.DATABASE_URL
+        ) ??
+        undefined;
     const driver =
-        options.driver ??
         normalizeDriver(
-            environment.DB_DRIVER ??
-            "mysql"
+            String(
+                options.driver ??
+                environment.DB_DRIVER ??
+                inferDriverFromDatabaseUrl(
+                    url
+                ) ??
+                "mysql"
+            )
         );
-
-    if (
-        driver !== "mysql"
-    ) {
-        throw new Error(
-            `BCP Database: unsupported database driver "${driver}".`
+    const defaults =
+        getDriverDefaults(
+            driver
         );
-    }
 
     return {
         driver,
+        ...(url
+            ? {
+                url,
+            }
+            : {}),
         host:
             nonEmpty(
                 options.host ??
                 environment.DB_HOST
             ) ??
-            "localhost",
+            defaults.host,
         port:
             resolvePositiveInteger(
                 options.port ??
                 environment.DB_PORT,
-                3306,
+                defaults.port,
                 "DB_PORT"
             ),
         user:
@@ -264,7 +271,7 @@ export function resolveDatabaseOptions(
                 options.user ??
                 environment.DB_USER
             ) ??
-            "root",
+            defaults.user,
         password:
             String(
                 options.password ??
@@ -276,12 +283,12 @@ export function resolveDatabaseOptions(
                 options.database ??
                 environment.DB_NAME
             ) ??
-            "bcp_app",
+            defaults.database,
         connectionLimit:
             resolvePositiveInteger(
                 options.connectionLimit ??
                 environment.DB_CONNECTION_LIMIT,
-                10,
+                defaults.connectionLimit,
                 "DB_CONNECTION_LIMIT"
             ),
         waitForConnections:
@@ -303,54 +310,67 @@ export function resolveDatabaseOptions(
                 options.charset ??
                 environment.DB_CHARSET
             ) ??
-            "utf8mb4",
+            defaults.charset,
     };
 }
 
 export const db =
     createDatabase();
 
-async function createMysqlPool(
-    options: Required<DatabaseOptions>
-): Promise<MysqlPool> {
-    let mysqlModule:
-        MysqlModule;
-
-    try {
-        mysqlModule =
-            await import(
-                MYSQL_MODULE_SPECIFIER
-            ) as unknown as MysqlModule;
-    } catch (error) {
-        throw new Error(
-            "BCP Database: MySQL requires the optional dependency mysql2. Install it with `npm install mysql2` or create the app with the MySQL preset.",
-            {
-                cause:
-                    error,
+async function initializeDatabaseAdapter(
+    options: DatabaseOptions
+): Promise<DatabaseAdapter> {
+    let adapter:
+        DatabaseAdapter;
+
+    if (options.adapter) {
+        adapter =
+            typeof options.adapter ===
+            "function"
+                ? await options.adapter()
+                : options.adapter;
+    } else {
+        const resolvedOptions =
+            resolveDatabaseOptions(
+                options
+            );
+
+        switch (
+            resolvedOptions.driver
+        ) {
+            case "postgresql": {
+                adapter =
+                    createPostgresqlDatabaseAdapter(
+                        resolvedOptions
+                    );
+                break;
             }
-        );
+
+            case "sqlite": {
+                adapter =
+                    createSqliteDatabaseAdapter(
+                        resolvedOptions
+                    );
+                break;
+            }
+
+            default: {
+                adapter =
+                    createMysqlDatabaseAdapter(
+                        resolvedOptions
+                    );
+                break;
+            }
+        }
     }
 
-    return mysqlModule.createPool({
-        host:
-            options.host,
-        port:
-            options.port,
-        user:
-            options.user,
-        password:
-            options.password,
-        database:
-            options.database,
-        waitForConnections:
-            options.waitForConnections,
-        connectionLimit:
-            options.connectionLimit,
-        queueLimit:
-            options.queueLimit,
-        charset:
-            options.charset,
-    });
+    assertDatabaseAdapter(
+        adapter
+    );
+
+    await adapter.connect();
+
+    return adapter;
 }
 
 function normalizeDriver(
@@ -367,11 +387,121 @@ function normalizeDriver(
         return "mysql";
     }
 
+    if (
+        normalized === "postgresql" ||
+        normalized === "postgres" ||
+        normalized === "pg"
+    ) {
+        return "postgresql";
+    }
+
+    if (
+        normalized === "sqlite" ||
+        normalized === "sqlite3"
+    ) {
+        return "sqlite";
+    }
+
     throw new Error(
         `BCP Database: unsupported database driver "${value}".`
     );
 }
 
+function inferDriverFromDatabaseUrl(
+    value: string | undefined
+): DatabaseDriver | null {
+    if (!value) {
+        return null;
+    }
+
+    if (
+        /^postgres(?:ql)?:\/\//i.test(
+            value
+        )
+    ) {
+        return "postgresql";
+    }
+
+    if (
+        /^mysql:\/\//i.test(
+            value
+        )
+    ) {
+        return "mysql";
+    }
+
+    if (
+        value === ":memory:" ||
+        /^(?:sqlite|file):/i.test(
+            value
+        ) ||
+        /\.(?:sqlite|sqlite3|db)$/i.test(
+            value
+        )
+    ) {
+        return "sqlite";
+    }
+
+    return null;
+}
+
+function getDriverDefaults(
+    driver: DatabaseDriver
+): DriverDefaults {
+    if (
+        driver === "postgresql"
+    ) {
+        return {
+            host:
+                "localhost",
+            port:
+                5432,
+            user:
+                "postgres",
+            database:
+                "bcp_app",
+            connectionLimit:
+                10,
+            charset:
+                "utf8",
+        };
+    }
+
+    if (
+        driver === "sqlite"
+    ) {
+        return {
+            host:
+                "",
+            port:
+                0,
+            user:
+                "",
+            database:
+                "./data/bcp.sqlite",
+            connectionLimit:
+                1,
+            charset:
+                "utf8",
+        };
+    }
+
+    return {
+        host:
+            "localhost",
+        port:
+            3306,
+        user:
+            "root",
+        database:
+            "bcp_app",
+        connectionLimit:
+            10,
+        charset:
+            "utf8mb4",
+    };
+}
+
 function nonEmpty(
     value: unknown
 ): string | null {
@@ -490,3 +620,38 @@ function assertSql(
         );
     }
 }
+
+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."
+        );
+    }
+}
+
+function assertDatabaseAdapter(
+    adapter: DatabaseAdapter
+): void {
+    if (
+        !adapter ||
+        typeof adapter !== "object" ||
+        typeof adapter.driver !== "string" ||
+        adapter.driver.trim() === "" ||
+        typeof adapter.connect !== "function" ||
+        typeof adapter.query !== "function" ||
+        typeof adapter.execute !== "function" ||
+        typeof adapter.transaction !== "function" ||
+        typeof adapter.disconnect !== "function"
+    ) {
+        throw new TypeError(
+            "BCP Database: adapter must implement driver, connect, query, execute, transaction and disconnect."
+        );
+    }
+}