@zintrust/db-mysql 0.1.19 → 0.1.21

package/README.md

@@ -34,3 +34,7 @@ DB_CONNECTION=mysql
 
 - https://zintrust.com/adapters
 - https://zintrust.com/database-advanced
+
+## License
+
+This package and its dependencies are MIT licensed, permitting free commercial use.

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export type DatabaseConfig = {
 export type QueryResult = {
     rows: Record<string, unknown>[];
     rowCount: number;
+    lastInsertId?: string | number | bigint;
 };
 export interface IDatabaseAdapter {
     connect(): Promise<void>;
@@ -21,6 +22,7 @@ export interface IDatabaseAdapter {
     ping(): Promise<void>;
     transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T>;
     rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]>;
+    ensureMigrationsTable?(): Promise<void>;
     getType(): string;
     isConnected(): boolean;
     getPlaceholder(index: number): string;

package/dist/index.js

@@ -1,29 +1,113 @@
 import { ErrorFactory, FeatureFlags, Logger, QueryBuilder } from '@zintrust/core';
-function connect(state, config) {
-    if (config.host === 'error') {
-        throw ErrorFactory.createConnectionError('Failed to connect to MySQL: Error: Connection failed');
+function isMissingEsmPackage(error, packageName) {
+    if (error === null || typeof error !== 'object')
+        return false;
+    const maybe = error;
+    if (maybe.code === 'ERR_MODULE_NOT_FOUND') {
+        return typeof maybe.message === 'string' && maybe.message.includes(packageName);
     }
-    state.connected = true;
-    Logger.info(`✓ MySQL connected (${config.host}:${config.port})`);
+    if (typeof maybe.message === 'string') {
+        return (maybe.message.includes(`Cannot find package '${packageName}'`) ||
+            maybe.message.includes(`Cannot find module '${packageName}'`));
+    }
+    return false;
 }
-function disconnect(state) {
-    state.connected = false;
-    Logger.info('✓ MySQL disconnected');
+async function loadMysql() {
+    return (await import('mysql2/promise'));
 }
-function ensureConnected(state) {
-    if (!state.connected)
+function getConnectionParams(config) {
+    return {
+        host: config.host ?? 'localhost',
+        port: config.port ?? 3306,
+        database: config.database ?? 'mysql',
+        user: config.username ?? 'root',
+        password: config.password ?? '',
+    };
+}
+function ensurePool(state) {
+    if (!state.connected || state.pool === undefined) {
         throw ErrorFactory.createConnectionError('Database not connected');
+    }
+    return state.pool;
+}
+function normalizeQueryResult(raw) {
+    // mysql2/promise returns:
+    // - SELECT: RowDataPacket[]
+    // - INSERT/UPDATE: ResultSetHeader
+    // We normalize to the framework's { rows, rowCount }.
+    if (Array.isArray(raw)) {
+        return {
+            rows: raw,
+            rowCount: raw.length,
+        };
+    }
+    if (raw !== null && typeof raw === 'object') {
+        const maybe = raw;
+        const affectedRows = typeof maybe.affectedRows === 'number' && Number.isFinite(maybe.affectedRows)
+            ? maybe.affectedRows
+            : 0;
+        const insertId = (typeof maybe.insertId === 'number' ||
+            typeof maybe.insertId === 'string' ||
+            typeof maybe.insertId === 'bigint') &&
+            maybe.insertId !== 0 // Only return if valid ID
+            ? maybe.insertId
+            : undefined;
+        return { rows: [], rowCount: affectedRows, lastInsertId: insertId };
+    }
+    return { rows: [], rowCount: 0 };
+}
+async function connect(state, config) {
+    if (state.connected)
+        return;
+    try {
+        const mysql = await loadMysql();
+        const { host, port, database, user, password } = getConnectionParams(config);
+        state.pool = mysql.createPool({
+            host,
+            port,
+            database,
+            user,
+            password,
+            waitForConnections: true,
+            connectionLimit: 10,
+            namedPlaceholders: false,
+        });
+        // Probe.
+        await state.pool.execute('SELECT 1');
+        state.connected = true;
+        Logger.info(`✓ MySQL connected (${host}:${port})`);
+    }
+    catch (error) {
+        if (isMissingEsmPackage(error, 'mysql2')) {
+            throw ErrorFactory.createConfigError("MySQL adapter requires the 'mysql2' package (run `npm install mysql2` or `zin add db:mysql`).");
+        }
+        throw ErrorFactory.createTryCatchError('Failed to connect to MySQL', error);
+    }
+}
+async function disconnect(state) {
+    if (!state.connected)
+        return;
+    const pool = state.pool;
+    state.connected = false;
+    state.pool = undefined;
+    try {
+        if (pool !== undefined)
+            await pool.end();
+    }
+    finally {
+        Logger.info('✓ MySQL disconnected');
+    }
 }
 async function rawQuery(state, sql, parameters) {
     if (!FeatureFlags.isRawQueryEnabled()) {
         throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
     }
-    ensureConnected(state);
+    const pool = ensurePool(state);
     try {
         Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
-        if (sql.includes('INVALID')) {
-            throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
-        }
+        const [rows] = await pool.execute(sql, parameters ?? []);
+        if (Array.isArray(rows))
+            return rows;
         return [];
     }
     catch (error) {
@@ -35,9 +119,15 @@ function createMySqlAdapter(config) {
     const adapter = {
         connect: async () => connect(state, config),
         disconnect: async () => disconnect(state),
-        query: async () => {
-            ensureConnected(state);
-            return { rows: [], rowCount: 0 };
+        query: async (sql, parameters) => {
+            const pool = ensurePool(state);
+            try {
+                const [rows] = await pool.execute(sql, parameters);
+                return normalizeQueryResult(rows);
+            }
+            catch (error) {
+                throw ErrorFactory.createTryCatchError(`MySQL query failed: ${sql}`, error);
+            }
         },
         queryOne: async (sql, parameters) => {
             const result = await adapter.query(sql, parameters);
@@ -47,17 +137,55 @@ function createMySqlAdapter(config) {
             await adapter.query(QueryBuilder.create('').select('1').toSQL(), []);
         },
         transaction: async (callback) => {
-            ensureConnected(state);
+            const pool = ensurePool(state);
+            const conn = await pool.getConnection();
+            const txAdapter = {
+                ...adapter,
+                query: async (sql, parameters) => {
+                    try {
+                        const [rows] = await conn.execute(sql, parameters);
+                        return normalizeQueryResult(rows);
+                    }
+                    catch (error) {
+                        throw ErrorFactory.createTryCatchError(`MySQL query failed: ${sql}`, error);
+                    }
+                },
+                queryOne: async (sql, parameters) => {
+                    const res = await txAdapter.query(sql, parameters);
+                    return res.rows[0] ?? null;
+                },
+            };
             try {
-                await adapter.query('START TRANSACTION', []);
-                const result = await callback(adapter);
-                await adapter.query('COMMIT', []);
+                await conn.beginTransaction();
+                const result = await callback(txAdapter);
+                await conn.commit();
                 return result;
             }
             catch (error) {
-                await adapter.query('ROLLBACK', []);
+                try {
+                    await conn.rollback();
+                }
+                catch {
+                    // ignore rollback errors
+                }
                 throw ErrorFactory.createTryCatchError('MySQL transaction failed', error);
             }
+            finally {
+                conn.release();
+            }
+        },
+        ensureMigrationsTable: async () => {
+            await adapter.query(`CREATE TABLE IF NOT EXISTS migrations (
+            id BIGINT PRIMARY KEY AUTO_INCREMENT,
+            name VARCHAR(255) NOT NULL,
+            scope VARCHAR(255) NOT NULL DEFAULT 'global',
+            service VARCHAR(255) NOT NULL DEFAULT '',
+            batch INTEGER NOT NULL,
+            status VARCHAR(255) NOT NULL,
+            applied_at DATETIME NULL,
+            created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(name, scope, service)
+          )`, []);
         },
         getType: () => 'mysql',
         isConnected: () => state.connected,

package/dist/register.js

@@ -1,8 +1,32 @@
-import { MySQLAdapter } from './index.js';
+// Prefer production build output shape first.
+// Dev (tsx) fallback when running directly from src.
+const adapterModule = (await (async () => {
+    try {
+        return (await import('./index.js'));
+    }
+    catch {
+        return (await import('./index'));
+    }
+})());
 export function registerMySqlAdapter(registry) {
-    registry.register('mysql', (config) => MySQLAdapter.create(config));
+    registry.register('mysql', (config) => adapterModule.MySQLAdapter.create(config));
 }
-const core = (await import('@zintrust/core'));
-if (core.DatabaseAdapterRegistry !== undefined) {
-    registerMySqlAdapter(core.DatabaseAdapterRegistry);
+const globalWithRegistry = globalThis;
+const globalRegistry = globalWithRegistry.__zintrust_db_adapter_registry__ ??
+    (globalWithRegistry.__zintrust_db_adapter_registry__ = new Map());
+registerMySqlAdapter({
+    register: (driver, factory) => {
+        globalRegistry.set(driver, factory);
+    },
+});
+// Side-effect registration when used as a published package.
+// In monorepo/dev setups, @zintrust/core may not be resolvable; ignore if missing.
+try {
+    const core = (await import('@zintrust/core'));
+    if (core.DatabaseAdapterRegistry !== undefined) {
+        registerMySqlAdapter(core.DatabaseAdapterRegistry);
+    }
+}
+catch {
+    // no-op
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/db-mysql",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.1.19"
+    "@zintrust/core": "^0.1.21"
   },
   "publishConfig": {
     "access": "public"
@@ -30,5 +30,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "mysql2": "^3.16.0"
   }
 }