@chidchanun/bcp 0.2.2 → 0.2.4

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

@@ -0,0 +1,445 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+    fileURLToPath,
+} from "node:url";
+
+import type {
+    DatabaseAdapter,
+    DatabaseParameters,
+    ResolvedDatabaseOptions,
+    TransactionDatabase,
+} from "./database.js";
+
+interface SqliteRunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}
+
+interface SqliteStatement {
+    all(
+        ...parameters: unknown[]
+    ): unknown[];
+    run(
+        ...parameters: unknown[]
+    ): SqliteRunResult;
+}
+
+interface SqliteDatabase {
+    prepare(
+        sql: string
+    ): SqliteStatement;
+    exec(
+        sql: string
+    ): unknown;
+    close(): void;
+}
+
+interface SqliteDatabaseConstructor {
+    new (
+        filename: string
+    ): SqliteDatabase;
+}
+
+interface SqliteModule {
+    default?: SqliteDatabaseConstructor;
+}
+
+const SQLITE_MODULE_SPECIFIER =
+    "better-sqlite3";
+
+export function createSqliteDatabaseAdapter(
+    options: ResolvedDatabaseOptions
+): DatabaseAdapter {
+    return new SqliteDatabaseAdapter(
+        options
+    );
+}
+
+class SqliteDatabaseAdapter
+implements DatabaseAdapter {
+    readonly driver = "sqlite";
+
+    private readonly options:
+        ResolvedDatabaseOptions;
+
+    private databasePromise:
+        Promise<SqliteDatabase> | null =
+        null;
+
+    private operationTail:
+        Promise<void> =
+        Promise.resolve();
+
+    constructor(
+        options: ResolvedDatabaseOptions
+    ) {
+        this.options =
+            options;
+    }
+
+    async connect(): Promise<void> {
+        await this.getDatabase();
+    }
+
+    async query<T = unknown>(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<T> {
+        return this.runExclusive(
+            async () => {
+                const database =
+                    await this.getDatabase();
+
+                return runSqliteQuery<T>(
+                    database,
+                    sql,
+                    parameters
+                );
+            }
+        );
+    }
+
+    async execute<T = unknown>(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<T> {
+        return this.runExclusive(
+            async () => {
+                const database =
+                    await this.getDatabase();
+
+                return runSqliteExecute<T>(
+                    database,
+                    sql,
+                    parameters
+                );
+            }
+        );
+    }
+
+    async transaction<T>(
+        callback: (
+            database: TransactionDatabase
+        ) => Promise<T>
+    ): Promise<T> {
+        return this.runExclusive(
+            async () => {
+                const database =
+                    await this.getDatabase();
+
+                database.exec(
+                    "BEGIN"
+                );
+
+                const transactionDatabase:
+                    TransactionDatabase = {
+                    query: async <R = unknown>(
+                        sql: string,
+                        parameters?: DatabaseParameters
+                    ): Promise<R> =>
+                        runSqliteQuery<R>(
+                            database,
+                            sql,
+                            parameters
+                        ),
+                    execute: async <R = unknown>(
+                        sql: string,
+                        parameters?: DatabaseParameters
+                    ): Promise<R> =>
+                        runSqliteExecute<R>(
+                            database,
+                            sql,
+                            parameters
+                        ),
+                };
+
+                try {
+                    const result =
+                        await callback(
+                            transactionDatabase
+                        );
+
+                    database.exec(
+                        "COMMIT"
+                    );
+
+                    return result;
+                } catch (error) {
+                    try {
+                        database.exec(
+                            "ROLLBACK"
+                        );
+                    } catch {
+                        // Preserve the original transaction error.
+                    }
+
+                    throw error;
+                }
+            }
+        );
+    }
+
+    async disconnect(): Promise<void> {
+        await this.runExclusive(
+            async () => {
+                const pendingDatabase =
+                    this.databasePromise;
+
+                this.databasePromise =
+                    null;
+
+                if (!pendingDatabase) {
+                    return;
+                }
+
+                let database:
+                    SqliteDatabase;
+
+                try {
+                    database =
+                        await pendingDatabase;
+                } catch {
+                    return;
+                }
+
+                database.close();
+            }
+        );
+    }
+
+    private getDatabase():
+        Promise<SqliteDatabase> {
+        if (!this.databasePromise) {
+            this.databasePromise =
+                createSqliteDatabase(
+                    this.options
+                );
+        }
+
+        return this.databasePromise;
+    }
+
+    private runExclusive<T>(
+        operation: () => Promise<T>
+    ): Promise<T> {
+        const result =
+            this.operationTail.then(
+                operation,
+                operation
+            );
+
+        this.operationTail =
+            result.then(
+                () => undefined,
+                () => undefined
+            );
+
+        return result;
+    }
+}
+
+async function createSqliteDatabase(
+    options: ResolvedDatabaseOptions
+): Promise<SqliteDatabase> {
+    let sqliteModule:
+        SqliteModule;
+
+    try {
+        sqliteModule =
+            await import(
+                SQLITE_MODULE_SPECIFIER
+            ) as unknown as SqliteModule;
+    } catch (error) {
+        throw new Error(
+            "BCP Database: SQLite requires the optional dependency better-sqlite3. Install it with `npm install better-sqlite3` or create the app with the SQLite preset.",
+            {
+                cause:
+                    error,
+            }
+        );
+    }
+
+    const Database =
+        sqliteModule.default;
+
+    if (
+        typeof Database !==
+        "function"
+    ) {
+        throw new Error(
+            "BCP Database: better-sqlite3 did not expose a compatible database constructor."
+        );
+    }
+
+    const filename =
+        resolveSqliteFilename(
+            options.url ??
+            options.database
+        );
+
+    if (
+        filename !== ":memory:"
+    ) {
+        const resolvedFilename =
+            path.resolve(
+                filename
+            );
+
+        fs.mkdirSync(
+            path.dirname(
+                resolvedFilename
+            ),
+            {
+                recursive: true,
+            }
+        );
+
+        return new Database(
+            resolvedFilename
+        );
+    }
+
+    return new Database(
+        filename
+    );
+}
+
+function runSqliteQuery<T>(
+    database: SqliteDatabase,
+    sql: string,
+    parameters?: DatabaseParameters
+): T {
+    assertSql(
+        sql
+    );
+
+    const statement =
+        database.prepare(
+            sql
+        );
+
+    return callStatement(
+        statement.all.bind(
+            statement
+        ),
+        parameters
+    ) as T;
+}
+
+function runSqliteExecute<T>(
+    database: SqliteDatabase,
+    sql: string,
+    parameters?: DatabaseParameters
+): T {
+    assertSql(
+        sql
+    );
+
+    const statement =
+        database.prepare(
+            sql
+        );
+
+    return callStatement(
+        statement.run.bind(
+            statement
+        ),
+        parameters
+    ) as T;
+}
+
+function callStatement<T>(
+    operation: (
+        ...parameters: unknown[]
+    ) => T,
+    parameters?: DatabaseParameters
+): T {
+    if (
+        parameters === undefined
+    ) {
+        return operation();
+    }
+
+    if (
+        isParameterArray(
+            parameters
+        )
+    ) {
+        return operation(
+            ...parameters
+        );
+    }
+
+    return operation(
+        parameters
+    );
+}
+
+function isParameterArray(
+    value: DatabaseParameters
+): value is readonly unknown[] {
+    return Array.isArray(
+        value
+    );
+}
+
+function resolveSqliteFilename(
+    value: string
+): string {
+    const normalized =
+        value.trim();
+
+    if (
+        normalized === "" ||
+        normalized === ":memory:"
+    ) {
+        return normalized ||
+            ":memory:";
+    }
+
+    if (
+        normalized.startsWith(
+            "file:"
+        )
+    ) {
+        return fileURLToPath(
+            normalized
+        );
+    }
+
+    if (
+        normalized.startsWith(
+            "sqlite://"
+        )
+    ) {
+        return normalized.slice(
+            "sqlite://".length
+        );
+    }
+
+    if (
+        normalized.startsWith(
+            "sqlite:"
+        )
+    ) {
+        return normalized.slice(
+            "sqlite:".length
+        );
+    }
+
+    return normalized;
+}
+
+function assertSql(
+    sql: string
+): void {
+    if (
+        typeof sql !== "string" ||
+        sql.trim() === ""
+    ) {
+        throw new TypeError(
+            "BCP Database: SQL must be a non-empty string."
+        );
+    }
+}