@chidchanun/bcp 0.2.2 → 0.2.3

package/packages/client/src/database.mjs

@@ -1,15 +1,29 @@
-// packages/client/src/database.ts
+// packages/client/src/database-mysql.ts
 var MYSQL_MODULE_SPECIFIER = "mysql2/promise";
-var BcpDatabase = class {
+function createMysqlDatabaseAdapter(options) {
+  return new MysqlDatabaseAdapter(
+    options
+  );
+}
+var MysqlDatabaseAdapter = class {
+  driver = "mysql";
   options;
   poolPromise = null;
-  constructor(options = {}) {
-    this.options = {
-      ...options
-    };
+  constructor(options) {
+    this.options = options;
+  }
+  async connect() {
+    if (!this.poolPromise) {
+      this.poolPromise = createMysqlPool(
+        this.options
+      );
+    }
+    await this.poolPromise;
   }
   async query(sql, parameters) {
-    assertSql(sql);
+    assertSql(
+      sql
+    );
     const pool = await this.getPool();
     const [rows] = await pool.query(
       sql,
@@ -18,7 +32,9 @@ var BcpDatabase = class {
     return rows;
   }
   async execute(sql, parameters) {
-    assertSql(sql);
+    assertSql(
+      sql
+    );
     const pool = await this.getPool();
     const [result] = await pool.execute(
       sql,
@@ -27,17 +43,17 @@ var BcpDatabase = class {
     return result;
   }
   async transaction(callback) {
-    if (typeof callback !== "function") {
-      throw new TypeError(
-        "BCP Database: transaction callback must be a function."
-      );
-    }
+    assertTransactionCallback(
+      callback
+    );
     const pool = await this.getPool();
     const connection = await pool.getConnection();
     await connection.beginTransaction();
     const transactionDatabase = {
       query: async (sql, parameters) => {
-        assertSql(sql);
+        assertSql(
+          sql
+        );
         const [rows] = await connection.query(
           sql,
           parameters
@@ -45,7 +61,9 @@ var BcpDatabase = class {
         return rows;
       },
       execute: async (sql, parameters) => {
-        assertSql(sql);
+        assertSql(
+          sql
+        );
         const [result] = await connection.execute(
           sql,
           parameters
@@ -69,62 +87,612 @@ var BcpDatabase = class {
       connection.release();
     }
   }
-  async close() {
+  async disconnect() {
     const pendingPool = this.poolPromise;
     this.poolPromise = null;
     if (!pendingPool) {
       return;
     }
-    const pool = await pendingPool;
+    let pool;
+    try {
+      pool = await pendingPool;
+    } catch {
+      return;
+    }
     await pool.end();
   }
-  getPool() {
+  async getPool() {
+    await this.connect();
+    return this.poolPromise;
+  }
+};
+async function createMysqlPool(options) {
+  let mysqlModule;
+  try {
+    mysqlModule = await import(MYSQL_MODULE_SPECIFIER);
+  } 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
+      }
+    );
+  }
+  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
+  });
+}
+function assertSql(sql) {
+  if (typeof sql !== "string" || sql.trim() === "") {
+    throw new TypeError(
+      "BCP Database: SQL must be a non-empty string."
+    );
+  }
+}
+function assertTransactionCallback(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError(
+      "BCP Database: transaction callback must be a function."
+    );
+  }
+}
+
+// packages/client/src/database-postgresql.ts
+var POSTGRESQL_MODULE_SPECIFIER = "pg";
+function createPostgresqlDatabaseAdapter(options) {
+  return new PostgresqlDatabaseAdapter(
+    options
+  );
+}
+var PostgresqlDatabaseAdapter = class {
+  driver = "postgresql";
+  options;
+  poolPromise = null;
+  constructor(options) {
+    this.options = options;
+  }
+  async connect() {
     if (!this.poolPromise) {
-      this.poolPromise = createMysqlPool(
-        resolveDatabaseOptions(
-          this.options
-        )
+      this.poolPromise = createPostgresqlPool(
+        this.options
+      );
+    }
+    await this.poolPromise;
+  }
+  async query(sql, parameters) {
+    assertSql2(
+      sql
+    );
+    const pool = await this.getPool();
+    const result = await pool.query(
+      sql,
+      normalizePostgresqlParameters(
+        parameters
+      )
+    );
+    return result.rows;
+  }
+  async execute(sql, parameters) {
+    assertSql2(
+      sql
+    );
+    const pool = await this.getPool();
+    const result = await pool.query(
+      sql,
+      normalizePostgresqlParameters(
+        parameters
+      )
+    );
+    return result;
+  }
+  async transaction(callback) {
+    assertTransactionCallback2(
+      callback
+    );
+    const pool = await this.getPool();
+    const connection = await pool.connect();
+    await connection.query(
+      "BEGIN"
+    );
+    const transactionDatabase = {
+      query: async (sql, parameters) => {
+        assertSql2(
+          sql
+        );
+        const result = await connection.query(
+          sql,
+          normalizePostgresqlParameters(
+            parameters
+          )
+        );
+        return result.rows;
+      },
+      execute: async (sql, parameters) => {
+        assertSql2(
+          sql
+        );
+        const result = await connection.query(
+          sql,
+          normalizePostgresqlParameters(
+            parameters
+          )
+        );
+        return result;
+      }
+    };
+    try {
+      const result = await callback(
+        transactionDatabase
+      );
+      await connection.query(
+        "COMMIT"
       );
+      return result;
+    } catch (error) {
+      try {
+        await connection.query(
+          "ROLLBACK"
+        );
+      } catch {
+      }
+      throw error;
+    } finally {
+      connection.release();
+    }
+  }
+  async disconnect() {
+    const pendingPool = this.poolPromise;
+    this.poolPromise = null;
+    if (!pendingPool) {
+      return;
+    }
+    let pool;
+    try {
+      pool = await pendingPool;
+    } catch {
+      return;
     }
+    await pool.end();
+  }
+  async getPool() {
+    await this.connect();
     return this.poolPromise;
   }
 };
+async function createPostgresqlPool(options) {
+  let postgresqlModule;
+  try {
+    postgresqlModule = await import(POSTGRESQL_MODULE_SPECIFIER);
+  } 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 = 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) {
+  if (parameters === void 0) {
+    return void 0;
+  }
+  if (Array.isArray(
+    parameters
+  )) {
+    return parameters;
+  }
+  throw new TypeError(
+    "BCP Database: PostgreSQL parameters must be an array. Use $1, $2, ... placeholders."
+  );
+}
+function assertSql2(sql) {
+  if (typeof sql !== "string" || sql.trim() === "") {
+    throw new TypeError(
+      "BCP Database: SQL must be a non-empty string."
+    );
+  }
+}
+function assertTransactionCallback2(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError(
+      "BCP Database: transaction callback must be a function."
+    );
+  }
+}
+
+// packages/client/src/database-sqlite.ts
+import fs from "node:fs";
+import path from "node:path";
+import {
+  fileURLToPath
+} from "node:url";
+var SQLITE_MODULE_SPECIFIER = "better-sqlite3";
+function createSqliteDatabaseAdapter(options) {
+  return new SqliteDatabaseAdapter(
+    options
+  );
+}
+var SqliteDatabaseAdapter = class {
+  driver = "sqlite";
+  options;
+  databasePromise = null;
+  operationTail = Promise.resolve();
+  constructor(options) {
+    this.options = options;
+  }
+  async connect() {
+    await this.getDatabase();
+  }
+  async query(sql, parameters) {
+    return this.runExclusive(
+      async () => {
+        const database = await this.getDatabase();
+        return runSqliteQuery(
+          database,
+          sql,
+          parameters
+        );
+      }
+    );
+  }
+  async execute(sql, parameters) {
+    return this.runExclusive(
+      async () => {
+        const database = await this.getDatabase();
+        return runSqliteExecute(
+          database,
+          sql,
+          parameters
+        );
+      }
+    );
+  }
+  async transaction(callback) {
+    return this.runExclusive(
+      async () => {
+        const database = await this.getDatabase();
+        database.exec(
+          "BEGIN"
+        );
+        const transactionDatabase = {
+          query: async (sql, parameters) => runSqliteQuery(
+            database,
+            sql,
+            parameters
+          ),
+          execute: async (sql, parameters) => runSqliteExecute(
+            database,
+            sql,
+            parameters
+          )
+        };
+        try {
+          const result = await callback(
+            transactionDatabase
+          );
+          database.exec(
+            "COMMIT"
+          );
+          return result;
+        } catch (error) {
+          try {
+            database.exec(
+              "ROLLBACK"
+            );
+          } catch {
+          }
+          throw error;
+        }
+      }
+    );
+  }
+  async disconnect() {
+    await this.runExclusive(
+      async () => {
+        const pendingDatabase = this.databasePromise;
+        this.databasePromise = null;
+        if (!pendingDatabase) {
+          return;
+        }
+        let database;
+        try {
+          database = await pendingDatabase;
+        } catch {
+          return;
+        }
+        database.close();
+      }
+    );
+  }
+  getDatabase() {
+    if (!this.databasePromise) {
+      this.databasePromise = createSqliteDatabase(
+        this.options
+      );
+    }
+    return this.databasePromise;
+  }
+  runExclusive(operation) {
+    const result = this.operationTail.then(
+      operation,
+      operation
+    );
+    this.operationTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+};
+async function createSqliteDatabase(options) {
+  let sqliteModule;
+  try {
+    sqliteModule = await import(SQLITE_MODULE_SPECIFIER);
+  } 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(database, sql, parameters) {
+  assertSql3(
+    sql
+  );
+  const statement = database.prepare(
+    sql
+  );
+  return callStatement(
+    statement.all.bind(
+      statement
+    ),
+    parameters
+  );
+}
+function runSqliteExecute(database, sql, parameters) {
+  assertSql3(
+    sql
+  );
+  const statement = database.prepare(
+    sql
+  );
+  return callStatement(
+    statement.run.bind(
+      statement
+    ),
+    parameters
+  );
+}
+function callStatement(operation, parameters) {
+  if (parameters === void 0) {
+    return operation();
+  }
+  if (isParameterArray(
+    parameters
+  )) {
+    return operation(
+      ...parameters
+    );
+  }
+  return operation(
+    parameters
+  );
+}
+function isParameterArray(value) {
+  return Array.isArray(
+    value
+  );
+}
+function resolveSqliteFilename(value) {
+  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 assertSql3(sql) {
+  if (typeof sql !== "string" || sql.trim() === "") {
+    throw new TypeError(
+      "BCP Database: SQL must be a non-empty string."
+    );
+  }
+}
+
+// packages/client/src/database.ts
+var BcpDatabase = class {
+  options;
+  adapterPromise = null;
+  constructor(options = {}) {
+    this.options = {
+      ...options
+    };
+  }
+  async connect() {
+    await this.getAdapter();
+  }
+  async query(sql, parameters) {
+    assertSql4(
+      sql
+    );
+    const adapter = await this.getAdapter();
+    return adapter.query(
+      sql,
+      parameters
+    );
+  }
+  async execute(sql, parameters) {
+    assertSql4(
+      sql
+    );
+    const adapter = await this.getAdapter();
+    return adapter.execute(
+      sql,
+      parameters
+    );
+  }
+  async transaction(callback) {
+    assertTransactionCallback3(
+      callback
+    );
+    const adapter = await this.getAdapter();
+    return adapter.transaction(
+      callback
+    );
+  }
+  async disconnect() {
+    await this.close();
+  }
+  async close() {
+    const pendingAdapter = this.adapterPromise;
+    this.adapterPromise = null;
+    if (!pendingAdapter) {
+      return;
+    }
+    let adapter;
+    try {
+      adapter = await pendingAdapter;
+    } catch {
+      return;
+    }
+    await adapter.disconnect();
+  }
+  async getAdapter() {
+    if (!this.adapterPromise) {
+      this.adapterPromise = initializeDatabaseAdapter(
+        this.options
+      );
+    }
+    try {
+      return await this.adapterPromise;
+    } catch (error) {
+      this.adapterPromise = null;
+      throw error;
+    }
+  }
+};
 function createDatabase(options = {}) {
   return new BcpDatabase(
     options
   );
 }
 function resolveDatabaseOptions(options = {}, environment = process.env) {
-  const driver = options.driver ?? normalizeDriver(
-    environment.DB_DRIVER ?? "mysql"
+  const url = nonEmpty(
+    options.url ?? environment.DATABASE_URL
+  ) ?? void 0;
+  const driver = normalizeDriver(
+    String(
+      options.driver ?? environment.DB_DRIVER ?? inferDriverFromDatabaseUrl(
+        url
+      ) ?? "mysql"
+    )
+  );
+  const defaults = getDriverDefaults(
+    driver
   );
-  if (driver !== "mysql") {
-    throw new Error(
-      `BCP Database: unsupported database driver "${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: nonEmpty(
       options.user ?? environment.DB_USER
-    ) ?? "root",
+    ) ?? defaults.user,
     password: String(
       options.password ?? environment.DB_PASSWORD ?? ""
     ),
     database: nonEmpty(
       options.database ?? environment.DB_NAME
-    ) ?? "bcp_app",
+    ) ?? defaults.database,
     connectionLimit: resolvePositiveInteger(
       options.connectionLimit ?? environment.DB_CONNECTION_LIMIT,
-      10,
+      defaults.connectionLimit,
       "DB_CONNECTION_LIMIT"
     ),
     waitForConnections: options.waitForConnections ?? resolveBoolean(
@@ -139,43 +707,113 @@ function resolveDatabaseOptions(options = {}, environment = process.env) {
     ),
     charset: nonEmpty(
       options.charset ?? environment.DB_CHARSET
-    ) ?? "utf8mb4"
+    ) ?? defaults.charset
   };
 }
 var db = createDatabase();
-async function createMysqlPool(options) {
-  let mysqlModule;
-  try {
-    mysqlModule = await import(MYSQL_MODULE_SPECIFIER);
-  } 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) {
+  let adapter;
+  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(value) {
   const normalized = value.trim().toLowerCase();
   if (normalized === "mysql") {
     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) {
+  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) {
+  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) {
   if (typeof value !== "string") {
     return null;
@@ -221,13 +859,27 @@ function resolveBoolean(value, fallback, label) {
     `BCP Database: ${label} must be true/false or 1/0.`
   );
 }
-function assertSql(sql) {
+function assertSql4(sql) {
   if (typeof sql !== "string" || sql.trim() === "") {
     throw new TypeError(
       "BCP Database: SQL must be a non-empty string."
     );
   }
 }
+function assertTransactionCallback3(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError(
+      "BCP Database: transaction callback must be a function."
+    );
+  }
+}
+function assertDatabaseAdapter(adapter) {
+  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."
+    );
+  }
+}
 export {
   BcpDatabase,
   createDatabase,