@chidchanun/bcp 0.2.2 → 0.2.4

package/packages/cli/src/args.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 export type CliCommand =
   | "dev"
   | "build"
+  | "package"
   | "start"
   | "routes"
   | "update"
@@ -417,6 +418,7 @@ export function parseCliArgs(
     if (
       argument === "dev" ||
       argument === "build" ||
+      argument === "package" ||
       argument === "start" ||
       argument === "routes" ||
       argument === "update" ||

package/packages/cli/src/bootstrap.ts

@@ -520,6 +520,7 @@ function resolveEnvironmentMode(
 
     if (
         command === "build" ||
+        command === "package" ||
         command === "start"
     ) {
         return "production";

package/packages/cli/src/database-migrations.ts

@@ -4,8 +4,10 @@ import {
     pathToFileURL,
 } from "node:url";
 
-import type {
-    TransactionDatabase,
+import {
+    resolveDatabaseOptions,
+    type DatabaseDriver,
+    type TransactionDatabase,
 } from "../../client/src/database.js";
 
 export type DatabaseMigrationAction =
@@ -35,6 +37,7 @@ export interface DatabaseMigrationCommandOptions {
     action: DatabaseMigrationAction;
     name?: string;
     database?: MigrationDatabase;
+    driver?: DatabaseDriver;
     now?: Date;
 }
 
@@ -65,6 +68,12 @@ interface MigrationModule {
     ) => Promise<void> | void;
 }
 
+interface MigrationDialect {
+    createTableSql: string;
+    insertMigrationSql: string;
+    deleteMigrationSql: string;
+}
+
 const MIGRATION_DIRECTORY =
     "migrations";
 const MIGRATION_TABLE =
@@ -105,8 +114,15 @@ export async function runDatabaseMigrationCommand(
         );
     }
 
+    const dialect =
+        getMigrationDialect(
+            options.driver ??
+            resolveDatabaseOptions().driver
+        );
+
     await ensureMigrationTable(
-        database
+        database,
+        dialect
     );
 
     if (
@@ -129,14 +145,16 @@ export async function runDatabaseMigrationCommand(
     ) {
         await migratePending(
             rootDirectory,
-            database
+            database,
+            dialect
         );
         return;
     }
 
     await rollbackLatestBatch(
         rootDirectory,
-        database
+        database,
+        dialect
     );
 }
 
@@ -197,13 +215,13 @@ export function createMigrationFile(
         `export async function up(\n` +
         `    db: TransactionDatabase\n` +
         `): Promise<void> {\n` +
-        `    // Write the forward migration here.\n` +
+        `    // Write provider-compatible forward SQL here.\n` +
         `    void db;\n` +
         `}\n\n` +
         `export async function down(\n` +
         `    db: TransactionDatabase\n` +
         `): Promise<void> {\n` +
-        `    // Write the rollback migration here.\n` +
+        `    // Write provider-compatible rollback SQL here.\n` +
         `    void db;\n` +
         `}\n`;
 
@@ -363,7 +381,8 @@ export async function getMigrationStatus(
 
 async function migratePending(
     rootDirectory: string,
-    database: MigrationDatabase
+    database: MigrationDatabase,
+    dialect: MigrationDialect
 ): Promise<void> {
     const files =
         listMigrationFiles(
@@ -421,11 +440,11 @@ async function migratePending(
 
         await database.transaction(
             async (transaction) => {
-                await module.up?.(
+                await module.up(
                     transaction
                 );
                 await transaction.execute(
-                    `INSERT INTO ${MIGRATION_TABLE} (name, batch) VALUES (?, ?)`,
+                    dialect.insertMigrationSql,
                     [
                         migration.name,
                         batch,
@@ -442,7 +461,8 @@ async function migratePending(
 
 async function rollbackLatestBatch(
     rootDirectory: string,
-    database: MigrationDatabase
+    database: MigrationDatabase,
+    dialect: MigrationDialect
 ): Promise<void> {
     const applied =
         await readAppliedMigrations(
@@ -520,11 +540,11 @@ async function rollbackLatestBatch(
 
         await database.transaction(
             async (transaction) => {
-                await module.down?.(
+                await module.down(
                     transaction
                 );
                 await transaction.execute(
-                    `DELETE FROM ${MIGRATION_TABLE} WHERE name = ?`,
+                    dialect.deleteMigrationSql,
                     [
                         record.name,
                     ]
@@ -539,15 +559,11 @@ async function rollbackLatestBatch(
 }
 
 async function ensureMigrationTable(
-    database: MigrationDatabase
+    database: MigrationDatabase,
+    dialect: MigrationDialect
 ): Promise<void> {
     await database.execute(
-        `CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (` +
-        `id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, ` +
-        `name VARCHAR(255) NOT NULL UNIQUE, ` +
-        `batch INT UNSIGNED NOT NULL, ` +
-        `applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP` +
-        `) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`
+        dialect.createTableSql
     );
 }
 
@@ -561,6 +577,60 @@ async function readAppliedMigrations(
     );
 }
 
+function getMigrationDialect(
+    driver: DatabaseDriver
+): MigrationDialect {
+    if (
+        driver === "postgresql"
+    ) {
+        return {
+            createTableSql:
+                `CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (` +
+                `id BIGSERIAL PRIMARY KEY, ` +
+                `name VARCHAR(255) NOT NULL UNIQUE, ` +
+                `batch INTEGER NOT NULL, ` +
+                `applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP` +
+                `)`,
+            insertMigrationSql:
+                `INSERT INTO ${MIGRATION_TABLE} (name, batch) VALUES ($1, $2)`,
+            deleteMigrationSql:
+                `DELETE FROM ${MIGRATION_TABLE} WHERE name = $1`,
+        };
+    }
+
+    if (
+        driver === "sqlite"
+    ) {
+        return {
+            createTableSql:
+                `CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (` +
+                `id INTEGER PRIMARY KEY AUTOINCREMENT, ` +
+                `name TEXT NOT NULL UNIQUE, ` +
+                `batch INTEGER NOT NULL, ` +
+                `applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP` +
+                `)`,
+            insertMigrationSql:
+                `INSERT INTO ${MIGRATION_TABLE} (name, batch) VALUES (?, ?)`,
+            deleteMigrationSql:
+                `DELETE FROM ${MIGRATION_TABLE} WHERE name = ?`,
+        };
+    }
+
+    return {
+        createTableSql:
+            `CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (` +
+            `id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, ` +
+            `name VARCHAR(255) NOT NULL UNIQUE, ` +
+            `batch INT UNSIGNED NOT NULL, ` +
+            `applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP` +
+            `) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`,
+        insertMigrationSql:
+            `INSERT INTO ${MIGRATION_TABLE} (name, batch) VALUES (?, ?)`,
+        deleteMigrationSql:
+            `DELETE FROM ${MIGRATION_TABLE} WHERE name = ?`,
+    };
+}
+
 async function loadMigrationModule(
     migration: LoadedMigration
 ): Promise<Required<MigrationModule>> {
@@ -595,7 +665,7 @@ async function loadMigrationModule(
             module.up,
         down:
             module.down,
-    };
+    } as Required<MigrationModule>;
 }
 
 function normalizeMigrationName(

package/packages/cli/src/index.ts

@@ -51,6 +51,11 @@ switch (cliOptions.command) {
     break;
   }
 
+  case "package": {
+    await runPackage();
+    break;
+  }
+
   case "start": {
     await runStart();
     break;
@@ -356,6 +361,57 @@ async function runBuild() {
   console.log("");
 }
 
+async function runPackage(): Promise<void> {
+  process.env.NODE_ENV =
+    "production";
+
+  await runBuild();
+
+  const rootDirectory =
+    resolveProjectRoot(
+      cliOptions.rootDirectory
+    );
+  const {
+    packageApplication,
+  } =
+    await import(
+      "./application-packaging.js"
+    );
+  const result =
+    packageApplication({
+      rootDirectory,
+      frameworkVersion:
+        FRAMEWORK_VERSION,
+    });
+
+  console.log(
+    "[BCP Package] Application package created."
+  );
+  console.log(
+    `[BCP Package] Output: ${result.outputDirectory}`
+  );
+  console.log(
+    `[BCP Package] Target: ${result.packageManifest.target}`
+  );
+  console.log(
+    `[BCP Package] Files: ${result.packageManifest.files.length}`
+  );
+  console.log(
+    `[BCP Package] Install: ${result.packageManifest.install.command}`
+  );
+  console.log(
+    `[BCP Package] Start: ${result.packageManifest.runtime.startCommand}`
+  );
+
+  for (const warning of result.warnings) {
+    console.warn(
+      `[BCP Package] Warning: ${warning}`
+    );
+  }
+
+  console.log("");
+}
+
 async function runStart() {
   process.env.NODE_ENV =
     "production";
@@ -866,6 +922,7 @@ Usage:
 Commands:
   dev                Start the development server
   build              Create optimized client assets and standalone server.mjs
+  package            Build and create a production deployment package
   start              Start the standalone production build
   routes             Print discovered page and API routes
   update [target]    Update BCP Framework (default target: latest)
@@ -890,12 +947,13 @@ Options:
   -v, --version         Show version
 
 Config precedence:
-  dev/build: CLI > BCP_* environment > bcp.config.ts > defaults
-  start:     CLI > runtime BCP_* environment > frozen build config
+  dev/build/package: CLI > BCP_* environment > bcp.config.ts > defaults
+  start:             CLI > runtime BCP_* environment > frozen build config
 
 Examples:
   bcp dev
   bcp build
+  bcp package
   bcp start
   bcp routes
   bcp generate page dashboard/users

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

@@ -0,0 +1,291 @@
+import type {
+    DatabaseAdapter,
+    DatabaseParameters,
+    ResolvedDatabaseOptions,
+    TransactionDatabase,
+} from "./database.js";
+
+interface MysqlExecutor {
+    query(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<[unknown, unknown]>;
+    execute(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<[unknown, unknown]>;
+}
+
+interface MysqlConnection extends MysqlExecutor {
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    release(): void;
+}
+
+interface MysqlPool extends MysqlExecutor {
+    getConnection(): Promise<MysqlConnection>;
+    end(): Promise<void>;
+}
+
+interface MysqlModule {
+    createPool(
+        options: Record<string, unknown>
+    ): MysqlPool;
+}
+
+const MYSQL_MODULE_SPECIFIER =
+    "mysql2/promise";
+
+export function createMysqlDatabaseAdapter(
+    options: ResolvedDatabaseOptions
+): DatabaseAdapter {
+    return new MysqlDatabaseAdapter(
+        options
+    );
+}
+
+class MysqlDatabaseAdapter
+implements DatabaseAdapter {
+    readonly driver = "mysql";
+
+    private readonly options:
+        ResolvedDatabaseOptions;
+
+    private poolPromise:
+        Promise<MysqlPool> | null =
+        null;
+
+    constructor(
+        options: ResolvedDatabaseOptions
+    ) {
+        this.options =
+            options;
+    }
+
+    async connect(): Promise<void> {
+        if (!this.poolPromise) {
+            this.poolPromise =
+                createMysqlPool(
+                    this.options
+                );
+        }
+
+        await this.poolPromise;
+    }
+
+    async query<T = unknown>(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<T> {
+        assertSql(
+            sql
+        );
+
+        const pool =
+            await this.getPool();
+        const [rows] =
+            await pool.query(
+                sql,
+                parameters
+            );
+
+        return rows as T;
+    }
+
+    async execute<T = unknown>(
+        sql: string,
+        parameters?: DatabaseParameters
+    ): Promise<T> {
+        assertSql(
+            sql
+        );
+
+        const pool =
+            await this.getPool();
+        const [result] =
+            await pool.execute(
+                sql,
+                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.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
+                );
+
+            await connection.commit();
+
+            return result;
+        } catch (error) {
+            try {
+                await connection.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:
+            MysqlPool;
+
+        try {
+            pool =
+                await pendingPool;
+        } catch {
+            return;
+        }
+
+        await pool.end();
+    }
+
+    private async getPool():
+        Promise<MysqlPool> {
+        await this.connect();
+
+        return this.poolPromise as
+            Promise<MysqlPool>;
+    }
+}
+
+async function createMysqlPool(
+    options: ResolvedDatabaseOptions
+): 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,
+            }
+        );
+    }
+
+    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: 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."
+        );
+    }
+}