@zintrust/db-mysql 1.8.0 → 1.8.8

package/dist/MySqlWorkersDurableObjectAdapter.d.ts

@@ -0,0 +1,4 @@
+import type { IDatabaseAdapter } from './index.js';
+export declare const MySqlWorkersDurableObjectAdapter: Readonly<{
+    create(_config: unknown): IDatabaseAdapter;
+}>;

package/dist/MySqlWorkersDurableObjectAdapter.js

@@ -0,0 +1,178 @@
+import { ErrorFactory, Logger } from '@zintrust/core';
+import { CREATE_MIGRATIONS_TABLE_SQL, MYSQL_PLACEHOLDER, MYSQL_TYPE } from './common.js';
+const getDoTimeoutMs = () => {
+    const globalEnv = globalThis.env;
+    const raw = globalEnv?.['MYSQL_DO_TIMEOUT_MS'] ?? globalEnv?.['DO_REQUEST_TIMEOUT_MS'];
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 15000;
+};
+const createTimeoutSignal = (timeoutMs) => {
+    if (timeoutMs <= 0)
+        return undefined;
+    const timeout = AbortSignal.timeout;
+    return typeof timeout === 'function' ? timeout(timeoutMs) : undefined;
+};
+const createSendQueryFunction = (getStub, connect) => {
+    return async (sql, params, method) => {
+        await connect();
+        const stub = getStub();
+        const executePath = 'http://do/execute'; //NOSONAR
+        const queryPath = 'http://do/query'; //NOSONAR
+        const payload = JSON.stringify({
+            command: sql,
+            sql,
+            params,
+            method,
+        });
+        const timeoutMs = getDoTimeoutMs();
+        const send = async (path) => {
+            const startedAt = Date.now();
+            try {
+                const response = await stub.fetch(path, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: payload,
+                    signal: createTimeoutSignal(timeoutMs),
+                });
+                Logger.debug('[MySqlWorkersDurableObjectAdapter] DO request completed', {
+                    path,
+                    status: response.status,
+                    durationMs: Date.now() - startedAt,
+                    timeoutMs,
+                    sqlPreview: sql.slice(0, 80),
+                });
+                return response;
+            }
+            catch (error) {
+                Logger.error('[MySqlWorkersDurableObjectAdapter] DO request failed', {
+                    path,
+                    durationMs: Date.now() - startedAt,
+                    timeoutMs,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (error instanceof Error && error.name === 'AbortError') {
+                    throw ErrorFactory.createGeneralError(`MySQL DO request timed out after ${timeoutMs}ms (${path})`, error);
+                }
+                throw error;
+            }
+        };
+        let response = await send(executePath);
+        if (!response.ok && (response.status === 404 || response.status === 405)) {
+            response = await send(queryPath);
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            let errDetail;
+            try {
+                errDetail = JSON.parse(text);
+            }
+            catch {
+                errDetail = { error: text };
+            }
+            const msg = errDetail.error ||
+                errDetail.message ||
+                response.statusText;
+            throw ErrorFactory.createGeneralError(`DO Query Failed: ${msg}`);
+        }
+        const json = (await response.json());
+        if (json !== null && typeof json === 'object' && 'result' in json) {
+            return json.result;
+        }
+        return json;
+    };
+};
+const createConnectionManager = (getNamespace) => {
+    let connected = false;
+    const getStub = () => {
+        const namespace = getNamespace();
+        if (!namespace) {
+            throw ErrorFactory.createConfigError('MYSQL_POOL binding not found. Cannot connect to Durable Object pool.');
+        }
+        const id = namespace.idFromName('default');
+        return namespace.get(id);
+    };
+    const connect = async () => {
+        if (connected)
+            return;
+        try {
+            const stub = getStub();
+            const health = 'http://do/health'; //NOSONAR
+            const timeoutMs = getDoTimeoutMs();
+            const res = await stub.fetch(health, {
+                method: 'POST',
+                signal: createTimeoutSignal(timeoutMs),
+            });
+            if (!res.ok) {
+                throw ErrorFactory.createGeneralError(`DO health check failed: ${res.status}`);
+            }
+            const body = (await res.json());
+            if (!body.connected) {
+                Logger.info('[MySqlWorkersDurableObjectAdapter] DO not connected yet, will init on first query');
+            }
+            connected = true;
+        }
+        catch (err) {
+            Logger.error('[MySqlWorkersDurableObjectAdapter] Connection failed', err);
+            throw ErrorFactory.createGeneralError('Failed to connect to MySQL DO', err);
+        }
+    };
+    const sendQuery = createSendQueryFunction(getStub, connect);
+    return {
+        connect,
+        sendQuery,
+        disconnect: () => {
+            connected = false;
+        },
+        isConnected: () => connected,
+    };
+};
+export const MySqlWorkersDurableObjectAdapter = Object.freeze({
+    create(_config) {
+        const connectionManager = createConnectionManager(() => {
+            const globalEnv = globalThis.env;
+            return globalEnv?.['MYSQL_POOL'];
+        });
+        return {
+            async connect() {
+                return connectionManager.connect();
+            },
+            async disconnect() {
+                connectionManager.disconnect();
+            },
+            async query(sql, parameters = []) {
+                return connectionManager.sendQuery(sql, parameters, 'query');
+            },
+            async queryOne(sql, parameters = []) {
+                const result = await connectionManager.sendQuery(sql, parameters, 'query');
+                if (result.rows.length === 0)
+                    return null;
+                return result.rows[0];
+            },
+            async rawQuery(sql, parameters) {
+                const result = await connectionManager.sendQuery(sql, parameters || [], 'query');
+                return result.rows;
+            },
+            async ping() {
+                await connectionManager.connect();
+                await connectionManager.sendQuery('SELECT 1', [], 'query');
+            },
+            async transaction(_callback) {
+                throw ErrorFactory.createGeneralError('Transactions are not yet supported in MySqlWorkersDurableObjectAdapter');
+            },
+            getType() {
+                return MYSQL_TYPE;
+            },
+            isConnected() {
+                return connectionManager.isConnected();
+            },
+            getPlaceholder(_index) {
+                return MYSQL_PLACEHOLDER;
+            },
+            async ensureMigrationsTable() {
+                await connectionManager.sendQuery(CREATE_MIGRATIONS_TABLE_SQL, [], 'query');
+            },
+        };
+    },
+});

package/dist/build-manifest.json

@@ -1,15 +1,15 @@
 {
   "name": "@zintrust/db-mysql",
-  "version": "1.8.0",
-  "buildDate": "2026-05-04T17:51:11.876Z",
+  "version": "1.6.0",
+  "buildDate": "2026-05-01T05:25:51.958Z",
   "buildEnvironment": {
-    "node": "v20.20.2",
-    "platform": "linux",
-    "arch": "x64"
+    "node": "v22.22.1",
+    "platform": "darwin",
+    "arch": "arm64"
   },
   "git": {
-    "commit": "b1d6ed34",
-    "branch": "master"
+    "commit": "ef4e9bec",
+    "branch": "release"
   },
   "package": {
     "engines": {
@@ -23,6 +23,18 @@
     ]
   },
   "files": {
+    "MySqlWorkersDurableObjectAdapter.d.ts": {
+      "size": 170,
+      "sha256": "ed336493205ab6e060ad2ad6737a0aab9a0c41dfcdee8d5cd89f18b8ffb58f7e"
+    },
+    "MySqlWorkersDurableObjectAdapter.js": {
+      "size": 6810,
+      "sha256": "775b5e5efb6aa58be1a83ea9c54c182a44060f70ab1e293fae20998d35766447"
+    },
+    "build-manifest.json": {
+      "size": 1678,
+      "sha256": "7e3b42382b430baf50c0278598ec13ebc1fea1091baa9b76207715f684825a22"
+    },
     "common.d.ts": {
       "size": 615,
       "sha256": "fafe13a87e5239d41b537dcdf23d7fc84c25d7b34207d272f149cbadfebfb417"
@@ -37,7 +49,7 @@
     },
     "index.js": {
       "size": 10003,
-      "sha256": "2668120e3d8df5958e5229f654f6b2ff067aef9737b4d5d1326f9f42583a1aad"
+      "sha256": "877f2f95488505148da95707ccacbf08fa042744ab5255bef016687a220a2c95"
     },
     "register.d.ts": {
       "size": 180,

package/dist/index.js

@@ -4,6 +4,66 @@ const getInjectedMysqlModule = () => {
     const globalAny = globalThis;
     return globalAny.__zintrustMysqlModule;
 };
+const getNodeMysqlSslConfig = (tlsEnabled) => {
+    if (!tlsEnabled) {
+        return false;
+    }
+    return {
+        rejectUnauthorized: false,
+        minVersion: 'TLSv1.2',
+    };
+};
+const getSocketTimeoutMs = (config) => {
+    if (typeof config.socketTimeoutMs === 'number' && config.socketTimeoutMs > 0) {
+        return config.socketTimeoutMs;
+    }
+    return 30000;
+};
+const createWorkersPool = async ({ mysql, host, port, database, user, password, tlsEnabled, timeoutMs, }) => {
+    if (!Cloudflare.isCloudflareSocketsEnabled()) {
+        throw ErrorFactory.createConfigError('Cloudflare sockets are disabled. Set ENABLE_CLOUDFLARE_SOCKETS=true to use MySQL sockets on Workers.');
+    }
+    const createSocket = await loadCloudflareSocketFactory();
+    return mysql.createPool({
+        host,
+        port,
+        database,
+        user,
+        password,
+        waitForConnections: true,
+        connectionLimit: 10,
+        namedPlaceholders: false,
+        disableEval: true,
+        stream: () => createSocket({ host, port, tls: tlsEnabled, timeoutMs }),
+    });
+};
+const createNodePool = (mysql, host, port, database, user, password, nodeMysqlSslConfig) => {
+    return mysql.createPool({
+        host,
+        port,
+        database,
+        user,
+        password,
+        ssl: nodeMysqlSslConfig,
+        waitForConnections: true,
+        connectionLimit: 10,
+        namedPlaceholders: false,
+    });
+};
+const describeDriverError = (error) => {
+    if (error === null || typeof error !== 'object') {
+        return undefined;
+    }
+    const details = error;
+    const parts = [
+        typeof details.code === 'string' ? `code=${details.code}` : undefined,
+        typeof details.errno === 'number' ? `errno=${details.errno}` : undefined,
+        typeof details.sqlState === 'string' ? `sqlState=${details.sqlState}` : undefined,
+        typeof details.sqlMessage === 'string' ? `sqlMessage=${details.sqlMessage}` : undefined,
+        typeof details.fatal === 'boolean' ? `fatal=${details.fatal}` : undefined,
+    ].filter((part) => part !== undefined);
+    return parts.length > 0 ? parts.join(', ') : undefined;
+};
 function isMissingEsmPackage(error, packageName) {
     if (error === null || typeof error !== 'object')
         return false;
@@ -97,42 +157,23 @@ async function connect(state, config) {
         const { host, port, database, user, password } = getConnectionParams(config);
         const isWorkersRuntime = Cloudflare.getWorkersEnv() !== null;
         const tlsEnabled = Boolean(config.ssl);
-        let timeoutMs;
-        if (typeof config.socketTimeoutMs === 'number' && config.socketTimeoutMs > 0) {
-            timeoutMs = config.socketTimeoutMs;
-        }
-        else {
-            timeoutMs = 30000; // default 30s
-        }
+        const nodeMysqlSslConfig = getNodeMysqlSslConfig(tlsEnabled);
+        Logger.info(`[db-mysql] Effective connection params: host=${host}, port=${port}, database=${database}, user=${user}, password_len=${password.length}, ssl=${tlsEnabled}`);
+        const timeoutMs = getSocketTimeoutMs(config);
         if (isWorkersRuntime) {
-            if (!Cloudflare.isCloudflareSocketsEnabled()) {
-                throw ErrorFactory.createConfigError('Cloudflare sockets are disabled. Set ENABLE_CLOUDFLARE_SOCKETS=true to use MySQL sockets on Workers.');
-            }
-            const createSocket = await loadCloudflareSocketFactory();
-            state.pool = mysql.createPool({
+            state.pool = await createWorkersPool({
+                mysql,
                 host,
                 port,
                 database,
                 user,
                 password,
-                waitForConnections: true,
-                connectionLimit: 10,
-                namedPlaceholders: false,
-                disableEval: true,
-                stream: () => createSocket({ host, port, tls: tlsEnabled, timeoutMs }),
+                tlsEnabled,
+                timeoutMs,
             });
         }
         else {
-            state.pool = mysql.createPool({
-                host,
-                port,
-                database,
-                user,
-                password,
-                waitForConnections: true,
-                connectionLimit: 10,
-                namedPlaceholders: false,
-            });
+            state.pool = createNodePool(mysql, host, port, database, user, password, nodeMysqlSslConfig);
         }
         // Probe.
         await state.pool.execute('SELECT 1');
@@ -143,6 +184,13 @@ async function connect(state, config) {
         if (isMissingEsmPackage(error, 'mysql2')) {
             throw ErrorFactory.createConfigError("MySQL adapter requires the 'mysql2' package (run `npm install mysql2` or `zin add db:mysql`).");
         }
+        const driverError = describeDriverError(error);
+        if (driverError !== undefined) {
+            Logger.error(`[db-mysql] MySQL driver error: ${driverError}`);
+        }
+        if (error instanceof Error && typeof error.stack === 'string' && error.stack.trim() !== '') {
+            Logger.error(`[db-mysql] MySQL driver stack: ${error.stack}`);
+        }
         throw ErrorFactory.createTryCatchError('Failed to connect to MySQL', error);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/db-mysql",
-  "version": "1.8.0",
+  "version": "1.8.8",
   "description": "MySQL and MariaDB database adapter for ZinTrust.",
   "private": false,
   "type": "module",
@@ -42,4 +42,4 @@
   "dependencies": {
     "mysql2": "^3.22.3"
   }
-}
+}