@chidchanun/bcp 0.1.25 → 0.1.26

package/packages/client/src/database.mjs

@@ -0,0 +1,236 @@
+// packages/client/src/database.ts
+var MYSQL_MODULE_SPECIFIER = "mysql2/promise";
+var BcpDatabase = class {
+  options;
+  poolPromise = null;
+  constructor(options = {}) {
+    this.options = {
+      ...options
+    };
+  }
+  async query(sql, parameters) {
+    assertSql(sql);
+    const pool = await this.getPool();
+    const [rows] = await pool.query(
+      sql,
+      parameters
+    );
+    return rows;
+  }
+  async execute(sql, parameters) {
+    assertSql(sql);
+    const pool = await this.getPool();
+    const [result] = await pool.execute(
+      sql,
+      parameters
+    );
+    return result;
+  }
+  async transaction(callback) {
+    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 = {
+      query: async (sql, parameters) => {
+        assertSql(sql);
+        const [rows] = await connection.query(
+          sql,
+          parameters
+        );
+        return rows;
+      },
+      execute: async (sql, parameters) => {
+        assertSql(sql);
+        const [result] = await connection.execute(
+          sql,
+          parameters
+        );
+        return result;
+      }
+    };
+    try {
+      const result = await callback(
+        transactionDatabase
+      );
+      await connection.commit();
+      return result;
+    } catch (error) {
+      try {
+        await connection.rollback();
+      } catch {
+      }
+      throw error;
+    } finally {
+      connection.release();
+    }
+  }
+  async close() {
+    const pendingPool = this.poolPromise;
+    this.poolPromise = null;
+    if (!pendingPool) {
+      return;
+    }
+    const pool = await pendingPool;
+    await pool.end();
+  }
+  getPool() {
+    if (!this.poolPromise) {
+      this.poolPromise = createMysqlPool(
+        resolveDatabaseOptions(
+          this.options
+        )
+      );
+    }
+    return this.poolPromise;
+  }
+};
+function createDatabase(options = {}) {
+  return new BcpDatabase(
+    options
+  );
+}
+function resolveDatabaseOptions(options = {}, environment = process.env) {
+  const driver = options.driver ?? normalizeDriver(
+    environment.DB_DRIVER ?? "mysql"
+  );
+  if (driver !== "mysql") {
+    throw new Error(
+      `BCP Database: unsupported database driver "${driver}".`
+    );
+  }
+  return {
+    driver,
+    host: nonEmpty(
+      options.host ?? environment.DB_HOST
+    ) ?? "localhost",
+    port: resolvePositiveInteger(
+      options.port ?? environment.DB_PORT,
+      3306,
+      "DB_PORT"
+    ),
+    user: nonEmpty(
+      options.user ?? environment.DB_USER
+    ) ?? "root",
+    password: String(
+      options.password ?? environment.DB_PASSWORD ?? ""
+    ),
+    database: nonEmpty(
+      options.database ?? environment.DB_NAME
+    ) ?? "bcp_app",
+    connectionLimit: resolvePositiveInteger(
+      options.connectionLimit ?? environment.DB_CONNECTION_LIMIT,
+      10,
+      "DB_CONNECTION_LIMIT"
+    ),
+    waitForConnections: options.waitForConnections ?? resolveBoolean(
+      environment.DB_WAIT_FOR_CONNECTIONS,
+      true,
+      "DB_WAIT_FOR_CONNECTIONS"
+    ),
+    queueLimit: resolveNonNegativeInteger(
+      options.queueLimit ?? environment.DB_QUEUE_LIMIT,
+      0,
+      "DB_QUEUE_LIMIT"
+    ),
+    charset: nonEmpty(
+      options.charset ?? environment.DB_CHARSET
+    ) ?? "utf8mb4"
+  };
+}
+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
+      }
+    );
+  }
+  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 normalizeDriver(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "mysql") {
+    return "mysql";
+  }
+  throw new Error(
+    `BCP Database: unsupported database driver "${value}".`
+  );
+}
+function nonEmpty(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized || null;
+}
+function resolvePositiveInteger(value, fallback, label) {
+  if (value === void 0 || value === null || value === "") {
+    return fallback;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(
+      `BCP Database: ${label} must be a positive integer.`
+    );
+  }
+  return parsed;
+}
+function resolveNonNegativeInteger(value, fallback, label) {
+  if (value === void 0 || value === null || value === "") {
+    return fallback;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(
+      `BCP Database: ${label} must be a non-negative integer.`
+    );
+  }
+  return parsed;
+}
+function resolveBoolean(value, fallback, label) {
+  if (value === void 0 || value === null || value === "") {
+    return fallback;
+  }
+  if (value === true || value === "1" || value === "true") {
+    return true;
+  }
+  if (value === false || value === "0" || value === "false") {
+    return false;
+  }
+  throw new Error(
+    `BCP Database: ${label} must be true/false or 1/0.`
+  );
+}
+function assertSql(sql) {
+  if (typeof sql !== "string" || sql.trim() === "") {
+    throw new TypeError(
+      "BCP Database: SQL must be a non-empty string."
+    );
+  }
+}
+export {
+  BcpDatabase,
+  createDatabase,
+  db,
+  resolveDatabaseOptions
+};

package/packages/client/src/server.ts

@@ -46,23 +46,45 @@ export {
     type UploadErrorCode,
 } from "../../server/src/upload.js";
 
+export {
+    storeMultipartFile,
+
+    type MultipartStorageFileInfo,
+    type MultipartStorageUploadOptions,
+    type StoredMultipartFile,
+} from "../../server/src/upload-stream.js";
+
 export {
     createLocalStorage,
+    getStorageCapabilities,
     normalizeStorageKey,
+    putStorageStream,
+    readStorageStream,
     StorageError,
     storeUploadedFile,
 
     type LocalStorageOptions,
     type StorageAdapter,
+    type StorageAdapterCapabilities,
     type StorageErrorCode,
     type StorageObjectMetadata,
     type StoragePutOptions,
+    type StoragePutStreamOptions,
+    type StorageReadableStream,
     type StorageReadOptions,
     type StorageWriteValue,
     type StoredUploadedObject,
     type StoreUploadedFileOptions,
 } from "../../server/src/storage.js";
 
+export {
+    createS3Storage,
+
+    type S3StorageAdapter,
+    type S3StorageMultipartOptions,
+    type S3StorageOptions,
+} from "../../server/src/storage-s3.js";
+
 export {
     createStorageResponse,
     isStorageRangeError,

package/packages/server/src/file-delivery.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 
 import {
+    readStorageStream,
     StorageError,
     type StorageAdapter,
     type StorageObjectMetadata,
@@ -144,11 +145,10 @@ export async function createStorageResponse(
         const body =
             method === "HEAD"
                 ? null
-                : toResponseBody(
-                    await storage.read(
-                        key,
-                        range
-                    )
+                : await readStorageStream(
+                    storage,
+                    key,
+                    range
                 );
 
         return new Response(
@@ -171,10 +171,9 @@ export async function createStorageResponse(
     const body =
         method === "HEAD"
             ? null
-            : toResponseBody(
-                await storage.read(
-                    key
-                )
+            : await readStorageStream(
+                storage,
+                key
             );
 
     return new Response(
@@ -602,21 +601,6 @@ function stripEntityLengthHeaders(
     );
 }
 
-function toResponseBody(
-    bytes: Uint8Array
-): ArrayBuffer {
-    const body =
-        new Uint8Array(
-            bytes.byteLength
-        );
-
-    body.set(
-        bytes
-    );
-
-    return body.buffer;
-}
-
 export function isStorageRangeError(
     error: unknown
 ): error is StorageError {