@zintrust/core 0.1.41 → 0.1.43

package/src/orm/SchemaStatemenWriter.js

@@ -0,0 +1,78 @@
+import { appConfig } from '../config/index.js';
+import { Env } from '../config/env.js';
+import { SignedRequest } from '../security/SignedRequest.js';
+const seenStatementIds = new Set();
+const MAX_SEEN_STATEMENT_IDS = Math.max(1, Env.getInt('SQL_WRITER_MAX_SEEN_STATEMENT_IDS', 50_000));
+const rememberStatementId = (statementId) => {
+    if (seenStatementIds.has(statementId))
+        return false;
+    seenStatementIds.add(statementId);
+    // Bound memory growth in long-lived processes.
+    if (seenStatementIds.size > MAX_SEEN_STATEMENT_IDS) {
+        seenStatementIds.clear();
+        seenStatementIds.add(statementId);
+    }
+    return true;
+};
+export const SchemaWriter = async (sql) => {
+    // START LEARNING MODE: If ZT_D1_LEARN_FILE is set, save the statement to JSONL
+    const learnFile = Env.get('ZT_D1_LEARN_FILE', '');
+    const useSqlWriter = Env.getBool('SQL_WRITER', false);
+    if (learnFile === '')
+        return;
+    if (!(appConfig.isDevelopment() || useSqlWriter))
+        return;
+    const statementId = await SignedRequest.sha256Hex(sql);
+    if (!rememberStatementId(statementId))
+        return;
+    try {
+        const fs = (await import('../node-singletons/fs.js')).fsPromises;
+        const line = JSON.stringify({ statementId, sql }) + '\n';
+        await fs.appendFile(learnFile, line, 'utf-8');
+    }
+    catch {
+        // Best effort; ignore errors during learning to avoid crashing app
+    }
+    // END LEARNING MODE
+};
+export const StatementRegistryBuild = Object.freeze({
+    /**
+     * Convert a JSONL capture file into a registry map.
+     *
+     * Input line shape: { statementId, sql }
+     * Output shape: { [statementId]: sql }
+     */
+    fromJsonl(jsonlText) {
+        const out = {};
+        const lines = jsonlText.split(/\r?\n/);
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed === '')
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed.statementId !== 'string' || parsed.statementId.trim() === '')
+                    continue;
+                if (typeof parsed.sql !== 'string' || parsed.sql.trim() === '')
+                    continue;
+                out[parsed.statementId] = parsed.sql;
+            }
+            catch {
+                // Ignore malformed lines
+            }
+        }
+        return out;
+    },
+    /** Merge registries, with `next` winning on collisions. */
+    merge(base, next) {
+        if (base === undefined)
+            return next ?? {};
+        if (next === undefined)
+            return base;
+        return { ...base, ...next };
+    },
+    /** Serialize a registry map as JSON suitable for `ZT_D1_STATEMENTS_JSON`. */
+    toStatementsJson(registry) {
+        return JSON.stringify(registry);
+    },
+});

package/src/orm/adapters/D1Adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"D1Adapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/D1Adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EACV,cAAc,EAEd,gBAAgB,EAEjB,MAAM,sBAAsB,CAAC;AAU9B;;GAEG;AACH,eAAO,MAAM,SAAS;IACpB;;OAEG;oBAEa,cAAc,GAAG,gBAAgB;EAkHjD,CAAC;AAEH,eAAe,SAAS,CAAC"}
+{"version":3,"file":"D1Adapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/D1Adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,KAAK,EACV,cAAc,EAEd,gBAAgB,EAEjB,MAAM,sBAAsB,CAAC;AAyD9B;;GAEG;AACH,eAAO,MAAM,SAAS;IACpB;;OAEG;oBAEa,cAAc,GAAG,gBAAgB;EAkIjD,CAAC;AAEH,eAAe,SAAS,CAAC"}

package/src/orm/adapters/D1Adapter.js

@@ -5,8 +5,44 @@ import { Cloudflare } from '../../config/cloudflare.js';
 import { FeatureFlags } from '../../config/features.js';
 import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { isObject } from '../../helper/index.js';
 import { AdaptersEnum } from '../../migrations/enum/index.js';
 import { QueryBuilder } from '../QueryBuilder.js';
+const isRecord = (value) => isObject(value);
+const toNumber = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    return null;
+};
+const toInsertId = (value) => {
+    if (typeof value === 'number' || typeof value === 'string' || typeof value === 'bigint') {
+        return value;
+    }
+    return undefined;
+};
+const isMutatingSql = (sql) => {
+    const normalized = sql.trimStart().toLowerCase();
+    return (normalized.startsWith('insert') ||
+        normalized.startsWith('update') ||
+        normalized.startsWith('delete') ||
+        normalized.startsWith('create') ||
+        normalized.startsWith('drop') ||
+        normalized.startsWith('alter') ||
+        normalized.startsWith('replace'));
+};
+const extractMeta = (value) => {
+    if (!isRecord(value))
+        return { changes: 0 };
+    const changes = toNumber(value['changes']) ??
+        toNumber(value['rows_written']) ??
+        toNumber(value['rows_read']) ??
+        0;
+    const lastInsertId = toInsertId(value['lastRowId']) ??
+        toInsertId(value['last_row_id']) ??
+        toInsertId(value['lastInsertRowid']) ??
+        toInsertId(value['last_insert_rowid']);
+    return { changes, lastInsertId };
+};
 /**
  * Get D1 binding from config or global environment
  */
@@ -43,11 +79,25 @@ export const D1Adapter = Object.freeze({
                 }
                 try {
                     const stmt = db.prepare(sql);
+                    if (isMutatingSql(sql)) {
+                        const runResult = await stmt.bind(...parameters).run();
+                        const runRecord = runResult;
+                        const meta = extractMeta(runRecord.meta);
+                        return {
+                            rows: [],
+                            rowCount: meta.changes,
+                            lastInsertId: meta.lastInsertId,
+                        };
+                    }
                     const result = await stmt.bind(...parameters).all();
-                    const rows = result.results ?? [];
+                    const rawResult = result;
+                    const rows = rawResult.results ?? [];
+                    const metaValue = rawResult.meta;
+                    const meta = extractMeta(metaValue);
                     return {
                         rows,
-                        rowCount: rows.length,
+                        rowCount: rows.length > 0 ? rows.length : meta.changes,
+                        lastInsertId: meta.lastInsertId,
                     };
                 }
                 catch (error) {

package/src/orm/adapters/D1RemoteAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"D1RemoteAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/D1RemoteAdapter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AA2J1F,eAAO,MAAM,eAAe;oBACV,cAAc,GAAG,gBAAgB;EA+EjD,CAAC;AAEH,eAAe,eAAe,CAAC"}
+{"version":3,"file":"D1RemoteAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/D1RemoteAdapter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AA2T1F,eAAO,MAAM,eAAe;oBACV,cAAc,GAAG,gBAAgB;EAgBjD,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/orm/adapters/D1RemoteAdapter.js

@@ -5,10 +5,15 @@
  */
 import { RemoteSignedJson } from '../../common/RemoteSignedJson.js';
 import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { AdaptersEnum } from '../../migrations/enum/index.js';
+import { isRecord } from '../adapters/SqlProxyAdapterUtils.js';
+import { createStatementId } from '../adapters/SqlProxyRegistryMode.js';
 import { QueryBuilder } from '../QueryBuilder.js';
-import { SignedRequest } from '../../security/SignedRequest.js';
+import { SchemaWriter } from '../SchemaStatemenWriter.js';
+import { isMutatingSql } from '../../proxy/isMutatingSql.js';
+let warnedFallbackCredentials = false;
 const resolveSigningPrefix = (baseUrl) => {
     try {
         const parsed = new URL(baseUrl);
@@ -22,11 +27,25 @@ const resolveSigningPrefix = (baseUrl) => {
     }
 };
 const createRemoteConfig = () => {
+    const directKeyId = Env.get('D1_REMOTE_KEY_ID', '').trim();
+    const directSecret = Env.get('D1_REMOTE_SECRET', '').trim();
+    // Intentionally pass empty values when missing so RemoteSignedJson's credential normalizer
+    // derives the fallback keyId/secret (APP_NAME/APP_KEY) in a consistent, safe way.
+    const keyId = directKeyId === '' ? '' : directKeyId;
+    const secret = directSecret === '' ? '' : directSecret;
+    if (directKeyId === '' || directSecret === '') {
+        if (!warnedFallbackCredentials) {
+            warnedFallbackCredentials = true;
+            Logger.warn('D1_REMOTE_KEY_ID / D1_REMOTE_SECRET missing; using fallback signing credentials (APP_NAME / APP_KEY).');
+        }
+    }
+    const envName = (Env.get('NODE_ENV', 'development') || 'development').trim().toLowerCase();
+    const defaultMode = envName === 'production' ? 'registry' : 'sql';
     const settings = {
         baseUrl: Env.get('D1_REMOTE_URL'),
-        keyId: Env.get('D1_REMOTE_KEY_ID'),
-        secret: Env.get('D1_REMOTE_SECRET', Env.APP_KEY),
-        mode: Env.get('D1_REMOTE_MODE', 'registry') ?? 'registry',
+        keyId,
+        secret,
+        mode: Env.get('D1_REMOTE_MODE', defaultMode) ?? defaultMode,
         timeoutMs: Env.getInt('ZT_PROXY_TIMEOUT_MS', Env.REQUEST_TIMEOUT),
     };
     const remote = {
@@ -36,7 +55,7 @@ const createRemoteConfig = () => {
         timeoutMs: settings.timeoutMs,
         signaturePathPrefixToStrip: resolveSigningPrefix(settings.baseUrl),
         missingUrlMessage: 'D1 remote proxy URL is missing (D1_REMOTE_URL)',
-        missingCredentialsMessage: 'D1 remote signing credentials are missing (D1_REMOTE_KEY_ID / D1_REMOTE_SECRET)',
+        missingCredentialsMessage: 'D1 remote signing credentials are missing (D1_REMOTE_KEY_ID / D1_REMOTE_SECRET). Fallbacks: APP_NAME and APP_KEY.',
         messages: {
             unauthorized: 'D1 remote proxy unauthorized',
             forbidden: 'D1 remote proxy forbidden',
@@ -48,33 +67,33 @@ const createRemoteConfig = () => {
     };
     return { mode: settings.mode, remote };
 };
-const isMutatingSql = (sql) => {
-    const s = sql.trimStart().toLowerCase();
-    return (s.startsWith('insert') ||
-        s.startsWith('update') ||
-        s.startsWith('delete') ||
-        s.startsWith('create') ||
-        s.startsWith('drop') ||
-        s.startsWith('alter') ||
-        s.startsWith('replace'));
-};
 const createStatementPayload = async (sql, parameters) => {
-    const statementId = await SignedRequest.sha256Hex(sql);
+    const statementId = await createStatementId(sql);
+    await SchemaWriter(sql);
     return { statementId, params: parameters };
 };
-const isRecord = (value) => typeof value === 'object' && value !== null;
 const isQueryResponse = (value) => isRecord(value) &&
     Array.isArray(value['rows']) &&
     typeof value['rowCount'] === 'number' &&
     value['rows'].every((r) => isRecord(r));
 const isQueryOneResponse = (value) => isRecord(value) && 'row' in value && (value['row'] === null || isRecord(value['row']));
-const getExecChanges = (value) => {
+const getExecMeta = (value) => {
     if (!isRecord(value) || typeof value['ok'] !== 'boolean')
-        return 0;
+        return { changes: 0 };
     const meta = value['meta'];
-    if (!isRecord(meta) || typeof meta['changes'] !== 'number')
-        return 0;
-    return meta['changes'];
+    if (!isRecord(meta))
+        return { changes: 0 };
+    const changes = typeof meta['changes'] === 'number' ? meta['changes'] : 0;
+    const lastRowIdCandidate = meta['lastRowId'] ??
+        meta['last_row_id'] ??
+        meta['lastInsertRowid'] ??
+        meta['last_insert_rowid'];
+    const lastRowId = typeof lastRowIdCandidate === 'number' ||
+        typeof lastRowIdCandidate === 'string' ||
+        typeof lastRowIdCandidate === 'bigint'
+        ? lastRowIdCandidate
+        : undefined;
+    return { changes, lastRowId };
 };
 const queryRegistry = async (settings, sql, parameters) => {
     const payload = await createStatementPayload(sql, parameters);
@@ -86,15 +105,18 @@ const queryRegistry = async (settings, sql, parameters) => {
         const row = out.row;
         return { rows: row ? [row] : [], rowCount: row ? 1 : 0 };
     }
-    return { rows: [], rowCount: getExecChanges(out) };
+    const meta = getExecMeta(out);
+    return { rows: [], rowCount: meta.changes, lastInsertId: meta.lastRowId };
 };
 const querySqlMode = async (settings, sql, parameters) => {
+    await SchemaWriter(sql);
     if (isMutatingSql(sql)) {
         const out = await RemoteSignedJson.request(settings, '/zin/d1/exec', {
             sql,
             params: parameters,
         });
-        return { rows: [], rowCount: getExecChanges(out) };
+        const meta = getExecMeta(out);
+        return { rows: [], rowCount: meta.changes, lastInsertId: meta.lastRowId };
     }
     const out = await RemoteSignedJson.request(settings, '/zin/d1/query', {
         sql,
@@ -102,75 +124,101 @@ const querySqlMode = async (settings, sql, parameters) => {
     });
     return { rows: out.rows, rowCount: out.rowCount };
 };
+const requireConnected = (getConnected) => {
+    if (!getConnected())
+        throw ErrorFactory.createConnectionError('Database not connected');
+};
+const createConnectMethod = (setConnected) => async () => {
+    setConnected(true);
+    return Promise.resolve(); // NOSONAR
+};
+const createDisconnectMethod = (setConnected) => async () => {
+    setConnected(false);
+    return Promise.resolve(); // NOSONAR
+};
+const createQueryMethod = (getConnected, mode, remote) => async (sql, parameters) => {
+    requireConnected(getConnected);
+    if (mode === 'registry') {
+        return queryRegistry(remote, sql, parameters);
+    }
+    return querySqlMode(remote, sql, parameters);
+};
+const createQueryOneMethod = (getConnected, mode, remote) => async (sql, parameters) => {
+    requireConnected(getConnected);
+    if (mode === 'registry') {
+        const payload = await createStatementPayload(sql, parameters);
+        const out = await RemoteSignedJson.request(remote, '/zin/d1/statement', payload);
+        if (isQueryOneResponse(out))
+            return out.row;
+        if (isQueryResponse(out))
+            return out.rows[0] ?? null;
+        return null;
+    }
+    await SchemaWriter(sql);
+    const out = await RemoteSignedJson.request(remote, '/zin/d1/queryOne', {
+        sql,
+        params: parameters,
+    });
+    return out.row;
+};
+const createPingMethod = (getConnected, methods) => async () => {
+    requireConnected(getConnected);
+    const sql = QueryBuilder.create('').select('1').toSQL();
+    await methods.queryOne(sql, []);
+};
+const createTransactionMethod = (getConnected, methods) => async (callback) => {
+    requireConnected(getConnected);
+    try {
+        return await callback(methods);
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Transaction failed', error);
+    }
+};
+const createEnsureMigrationsTableMethod = (getConnected, methods) => async () => {
+    requireConnected(getConnected);
+    // D1 is SQLite under the hood; this schema matches the core migrator's expectations.
+    // Note: d1-remote migrations are expected to run in SQL mode (the CLI enforces this).
+    await methods.query(`CREATE TABLE IF NOT EXISTS migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        scope TEXT NOT NULL DEFAULT 'global',
+        service TEXT NOT NULL DEFAULT '',
+        batch INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        applied_at TEXT NULL,
+        created_at TEXT NOT NULL,
+        UNIQUE(name, scope, service)
+      )`, []);
+};
+const createRawQueryMethod = (methods) => async (sql, parameters = []) => {
+    const out = await methods.query(sql, parameters);
+    return out.rows;
+};
+const createAdapterMethods = (getConnected, setConnected, mode, remote) => {
+    const methods = {};
+    methods.connect = createConnectMethod(setConnected);
+    methods.disconnect = createDisconnectMethod(setConnected);
+    methods.query = createQueryMethod(getConnected, mode, remote);
+    methods.queryOne = createQueryOneMethod(getConnected, mode, remote);
+    methods.ping = createPingMethod(getConnected, methods);
+    methods.transaction = createTransactionMethod(getConnected, methods);
+    methods.ensureMigrationsTable = createEnsureMigrationsTableMethod(getConnected, methods);
+    methods.rawQuery = createRawQueryMethod(methods);
+    methods.getType = () => AdaptersEnum.d1Remote;
+    methods.isConnected = () => getConnected();
+    methods.getPlaceholder = (_index) => '?';
+    return methods;
+};
+const createAdapter = (getConnected, setConnected, mode, remote) => createAdapterMethods(getConnected, setConnected, mode, remote);
 export const D1RemoteAdapter = Object.freeze({
     create(_config) {
         let connected = false;
         const { mode, remote } = createRemoteConfig();
-        return {
-            // eslint-disable-next-line @typescript-eslint/require-await
-            async connect() {
-                connected = true;
-            },
-            // eslint-disable-next-line @typescript-eslint/require-await
-            async disconnect() {
-                connected = false;
-            },
-            async query(sql, parameters) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                if (mode === 'registry') {
-                    return queryRegistry(remote, sql, parameters);
-                }
-                return querySqlMode(remote, sql, parameters);
-            },
-            async queryOne(sql, parameters) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                if (mode === 'registry') {
-                    const payload = await createStatementPayload(sql, parameters);
-                    const out = await RemoteSignedJson.request(remote, '/zin/d1/statement', payload);
-                    if (isQueryOneResponse(out))
-                        return out.row;
-                    if (isQueryResponse(out))
-                        return out.rows[0] ?? null;
-                    return null;
-                }
-                const out = await RemoteSignedJson.request(remote, '/zin/d1/queryOne', {
-                    sql,
-                    params: parameters,
-                });
-                return out.row;
-            },
-            async ping() {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                const sql = QueryBuilder.create('').select('1').toSQL();
-                await this.queryOne(sql, []);
-            },
-            async transaction(callback) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                try {
-                    return await callback(this);
-                }
-                catch (error) {
-                    throw ErrorFactory.createTryCatchError('Transaction failed', error);
-                }
-            },
-            async rawQuery(sql, parameters = []) {
-                const out = await this.query(sql, parameters);
-                return out.rows;
-            },
-            getType() {
-                return AdaptersEnum.d1Remote;
-            },
-            isConnected() {
-                return connected;
-            },
-            getPlaceholder(_index) {
-                return '?';
-            },
-        };
+        const getConnected = () => connected;
+        return createAdapter(getConnected, (value) => {
+            connected = value;
+        }, mode, remote);
     },
 });
 export default D1RemoteAdapter;

package/src/orm/adapters/MySQLProxyAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MySQLProxyAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/MySQLProxyAdapter.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAuF1F,eAAO,MAAM,iBAAiB;oBACZ,cAAc,GAAG,gBAAgB;EAqFjD,CAAC;AAEH,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"MySQLProxyAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/MySQLProxyAdapter.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAkBH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAiN1F,eAAO,MAAM,iBAAiB;oBACZ,cAAc,GAAG,gBAAgB;EAajD,CAAC;AAEH,eAAe,iBAAiB,CAAC"}

package/src/orm/adapters/MySQLProxyAdapter.js

@@ -8,8 +8,9 @@ import { Env } from '../../config/env.js';
 import { Logger } from '../../config/logger.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { AdaptersEnum } from '../../migrations/enum/index.js';
-import { QueryBuilder } from '../QueryBuilder.js';
 import { ensureSignedSettings, isRecord, requestSignedProxy, } from '../adapters/SqlProxyAdapterUtils.js';
+import { createStatementPayload, getExecMetaWithLastRowId, resolveSqlProxyMode, } from '../adapters/SqlProxyRegistryMode.js';
+import { QueryBuilder } from '../QueryBuilder.js';
 const buildProxySettings = () => {
     const baseUrl = Env.MYSQL_PROXY_URL;
     const keyId = Env.MYSQL_PROXY_KEY_ID ?? '';
@@ -32,16 +33,6 @@ const buildSignedProxyConfig = (settings) => ({
 });
 const isQueryResponse = (value) => isRecord(value) && Array.isArray(value['rows']) && typeof value['rowCount'] === 'number';
 const isQueryOneResponse = (value) => isRecord(value) && 'row' in value;
-const getExecMeta = (value) => {
-    if (!isRecord(value) || typeof value['ok'] !== 'boolean')
-        return { changes: 0 };
-    const meta = value['meta'];
-    if (!isRecord(meta))
-        return { changes: 0 };
-    const changes = typeof meta['changes'] === 'number' ? meta['changes'] : 0;
-    const lastRowId = meta['lastRowId'];
-    return { changes, lastRowId: lastRowId };
-};
 const requestProxy = async (settings, path, payload) => {
     const signedProxyConfig = buildSignedProxyConfig(settings);
     try {
@@ -59,85 +50,113 @@ const requestProxy = async (settings, path, payload) => {
         throw error;
     }
 };
+const resolveProxyMode = () => {
+    return resolveSqlProxyMode('MYSQL_PROXY_MODE');
+};
+const requireConnected = (state) => {
+    if (!state.connected)
+        throw ErrorFactory.createConnectionError('Database not connected');
+};
+const toQueryResult = (out) => {
+    if (isQueryResponse(out)) {
+        return {
+            rows: out.rows,
+            rowCount: out.rowCount,
+            lastInsertId: out.lastInsertId,
+        };
+    }
+    if (isQueryOneResponse(out)) {
+        const row = out.row;
+        return { rows: row ? [row] : [], rowCount: row ? 1 : 0 };
+    }
+    const meta = getExecMetaWithLastRowId(out);
+    return { rows: [], rowCount: meta.changes, lastInsertId: meta.lastRowId };
+};
+const createQuery = (state) => async (sql, parameters) => {
+    requireConnected(state);
+    const mode = resolveProxyMode();
+    const out = mode === 'registry'
+        ? await requestProxy(state.settings, '/zin/mysql/statement', await createStatementPayload(sql, parameters))
+        : await requestProxy(state.settings, '/zin/mysql/query', {
+            sql,
+            params: parameters,
+        });
+    return toQueryResult(out);
+};
+const createQueryOne = (state) => async (sql, parameters) => {
+    requireConnected(state);
+    const mode = resolveProxyMode();
+    if (mode !== 'registry') {
+        const out = await requestProxy(state.settings, '/zin/mysql/queryOne', {
+            sql,
+            params: parameters,
+        });
+        return out.row ?? null;
+    }
+    const out = await requestProxy(state.settings, '/zin/mysql/statement', await createStatementPayload(sql, parameters));
+    if (isQueryOneResponse(out))
+        return out.row ?? null;
+    if (isQueryResponse(out))
+        return out.rows[0] ?? null;
+    return null;
+};
+const createPing = (queryOne) => async () => {
+    await queryOne(QueryBuilder.create('').select('1').toSQL(), []);
+};
+const createTransaction = (state, getAdapter) => async (callback) => {
+    requireConnected(state);
+    try {
+        return await callback(getAdapter());
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('MySQL proxy transaction failed', error);
+    }
+};
+const createRawQuery = (state, query) => async (sql, parameters = []) => {
+    requireConnected(state);
+    const out = await query(sql, parameters);
+    return out.rows;
+};
+const createAdapter = (state) => {
+    const query = createQuery(state);
+    const queryOne = createQueryOne(state);
+    const ping = createPing(queryOne);
+    const adapter = {
+        async connect() {
+            ensureSignedSettings(buildSignedProxyConfig(state.settings));
+            state.connected = true;
+        },
+        async disconnect() {
+            state.connected = false;
+        },
+        query,
+        queryOne,
+        ping,
+        transaction: createTransaction(state, () => adapter),
+        rawQuery: createRawQuery(state, query),
+        getType() {
+            return AdaptersEnum.mysql;
+        },
+        isConnected() {
+            return state.connected;
+        },
+        getPlaceholder(_index) {
+            return '?';
+        },
+    };
+    return adapter;
+};
 export const MySQLProxyAdapter = Object.freeze({
     create(_config) {
-        let connected = false;
         const settings = buildProxySettings();
+        const state = { connected: false, settings };
         Logger.info('[MySQLProxyAdapter] Created with runtime settings', {
             baseUrl: settings.baseUrl,
             timeoutMs: settings.timeoutMs,
             hasKeyId: (settings.keyId ?? '').trim() !== '',
             hasSecret: (settings.secret ?? '').trim() !== '',
         });
-        return {
-            async connect() {
-                ensureSignedSettings(buildSignedProxyConfig(settings));
-                connected = true;
-            },
-            async disconnect() {
-                connected = false;
-            },
-            async query(sql, parameters) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                const out = await requestProxy(settings, '/zin/mysql/query', {
-                    sql,
-                    params: parameters,
-                });
-                if (isQueryResponse(out)) {
-                    return {
-                        rows: out.rows,
-                        rowCount: out.rowCount,
-                        lastInsertId: out.lastInsertId,
-                    };
-                }
-                if (isQueryOneResponse(out)) {
-                    const row = out.row;
-                    return { rows: row ? [row] : [], rowCount: row ? 1 : 0 };
-                }
-                const meta = getExecMeta(out);
-                return { rows: [], rowCount: meta.changes, lastInsertId: meta.lastRowId };
-            },
-            async queryOne(sql, parameters) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                const out = await requestProxy(settings, '/zin/mysql/queryOne', {
-                    sql,
-                    params: parameters,
-                });
-                return out.row ?? null;
-            },
-            async ping() {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                await this.queryOne(QueryBuilder.create('').select('1').toSQL(), []);
-            },
-            async transaction(callback) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                try {
-                    return await callback(this);
-                }
-                catch (error) {
-                    throw ErrorFactory.createTryCatchError('MySQL proxy transaction failed', error);
-                }
-            },
-            async rawQuery(sql, parameters = []) {
-                if (!connected)
-                    throw ErrorFactory.createConnectionError('Database not connected');
-                const out = await this.query(sql, parameters);
-                return out.rows;
-            },
-            getType() {
-                return AdaptersEnum.mysql;
-            },
-            isConnected() {
-                return connected;
-            },
-            getPlaceholder(_index) {
-                return '?';
-            },
-        };
+        return createAdapter(state);
     },
 });
 export default MySQLProxyAdapter;

package/src/orm/adapters/PostgreSQLProxyAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PostgreSQLProxyAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/PostgreSQLProxyAdapter.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAkH1F,eAAO,MAAM,sBAAsB;oBACjB,cAAc,GAAG,gBAAgB;EA+DjD,CAAC;AAEH,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"PostgreSQLProxyAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/PostgreSQLProxyAdapter.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAaH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AAiH1F,eAAO,MAAM,sBAAsB;oBACjB,cAAc,GAAG,gBAAgB;EAwFjD,CAAC;AAEH,eAAe,sBAAsB,CAAC"}