@zintrust/db-mysql 1.7.2 → 1.8.7

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.7.2",
-  "buildDate": "2026-05-01T06:34:21.111Z",
+  "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": "549bf22e",
-    "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": "1800d331b56eb2d1f456a9cdd8eee5dfbd62c927d5f3f6a3c9e64e7a0c2d2c31"
+      "sha256": "877f2f95488505148da95707ccacbf08fa042744ab5255bef016687a220a2c95"
     },
     "register.d.ts": {
       "size": 180,

package/dist/index.js

@@ -129,6 +129,7 @@ async function connect(state, config) {
                 database,
                 user,
                 password,
+                ssl: tlsEnabled ? {} : undefined,
                 waitForConnections: true,
                 connectionLimit: 10,
                 namedPlaceholders: false,

package/package.json

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