@zintrust/core 0.1.40 → 0.1.42

package/src/orm/QueryBuilder.js

@@ -36,6 +36,7 @@ const escapeIdentifier = (id, dialect) => {
 };
 const SAFE_IDENTIFIER_PATH = /^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*$/;
 const SAFE_IDENTIFIER = /^[A-Za-z_]\w*$/;
+const SAFE_FUNCTION_CALL = /^[A-Za-z_]\w*\(\)$/;
 const assertSafeIdentifierPath = (id, label) => {
     const trimmed = id.trim();
     if (trimmed.length === 0) {
@@ -54,6 +55,20 @@ const assertSafeIdentifier = (id, label) => {
         throw ErrorFactory.createDatabaseError(`Unsafe SQL identifier for ${label}`);
     }
 };
+const isRawValue = (value) => typeof value === 'object' &&
+    value !== null &&
+    '__raw' in value &&
+    typeof value.__raw === 'string';
+const assertSafeRawExpression = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        throw ErrorFactory.createDatabaseError('Empty raw SQL expression');
+    }
+    if (SAFE_IDENTIFIER_PATH.test(trimmed) || SAFE_FUNCTION_CALL.test(trimmed)) {
+        return trimmed;
+    }
+    throw ErrorFactory.createDatabaseError('Unsafe raw SQL expression');
+};
 const normalizeOrderDirection = (direction) => {
     if (direction === undefined || direction === null)
         return 'ASC';
@@ -370,7 +385,9 @@ const compileInsert = (tableName, values, dialect) => {
             parameters.push(item[key]);
         }
     }
-    const sql = `INSERT INTO ${escapeIdentifier(tableName, dialect)} (${colsSql}) VALUES ${placeholders}`;
+    const baseSql = `INSERT INTO ${escapeIdentifier(tableName, dialect)} (${colsSql}) VALUES ${placeholders}`;
+    const wantsReturning = dialect === 'postgresql' && items.length === 1;
+    const sql = wantsReturning ? `${baseSql} RETURNING id` : baseSql;
     return { sql, parameters };
 };
 const compileUpdate = (tableName, values, conditions, dialect) => {
@@ -384,8 +401,20 @@ const compileUpdate = (tableName, values, conditions, dialect) => {
     assertSafeIdentifierPath(tableName, 'table name');
     for (const key of keys)
         assertSafeIdentifier(key, 'update column');
-    const setSql = keys.map((k) => `${escapeIdentifier(k, dialect)} = ?`).join(', ');
-    const setParams = keys.map((k) => values[k]);
+    const setParts = [];
+    const setParams = [];
+    for (const key of keys) {
+        const value = values[key];
+        if (isRawValue(value)) {
+            const rawSql = assertSafeRawExpression(value.__raw);
+            setParts.push(`${escapeIdentifier(key, dialect)} = ${rawSql}`);
+        }
+        else {
+            setParts.push(`${escapeIdentifier(key, dialect)} = ?`);
+            setParams.push(value);
+        }
+    }
+    const setSql = setParts.join(', ');
     const where = compileWhere(conditions, dialect);
     const sql = `UPDATE ${escapeIdentifier(tableName, dialect)} SET ${setSql}${where.sql}`;
     return { sql, parameters: [...setParams, ...where.parameters] };
@@ -479,6 +508,7 @@ function attachWhereMethods(builder, state) {
     };
     builder.andWhere = (column, operator, value) => builder.where(column, operator, value);
     builder.orWhere = (column, operator, value) => builder.where(column, operator, value);
+    builder.whereNull = (column) => builder.where(column, 'IS', null);
     builder.whereIn = (column, values) => {
         builder.where(column, 'IN', values);
         return builder;

package/src/orm/SchemaCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SchemaCompiler.d.ts","sourceRoot":"","sources":["../../../src/orm/SchemaCompiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAoB,OAAO,EAAE,MAAM,aAAa,CAAC;AA4I7D,eAAO,MAAM,cAAc;oBAEnB,SAAS,UACL,OAAO,SACR;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;kBAMI,SAAS,SAAS,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;EAM5D,CAAC"}
+{"version":3,"file":"SchemaCompiler.d.ts","sourceRoot":"","sources":["../../../src/orm/SchemaCompiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAoB,OAAO,EAAE,MAAM,aAAa,CAAC;AA+I7D,eAAO,MAAM,cAAc;oBAEnB,SAAS,UACL,OAAO,SACR;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;kBAMI,SAAS,SAAS,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;EAM5D,CAAC"}

package/src/orm/SchemaCompiler.js

@@ -80,7 +80,7 @@ function getColumnTypeSql(driver, def) {
         return specialSql;
     return 'TEXT';
 }
-function getDefaultValueSql(table, def) {
+function getDefaultValueSql(driver, table, def) {
     if (def.default === undefined)
         return null;
     const dv = def.default;
@@ -88,8 +88,11 @@ function getDefaultValueSql(table, def) {
         return 'DEFAULT NULL';
     if (typeof dv === 'number' && Number.isFinite(dv))
         return `DEFAULT ${dv}`;
-    if (typeof dv === 'boolean')
+    if (typeof dv === 'boolean') {
+        if (driver === 'postgresql')
+            return `DEFAULT ${dv ? 'true' : 'false'}`;
         return `DEFAULT ${dv ? 1 : 0}`;
+    }
     if (typeof dv === 'string') {
         const escaped = dv.replaceAll("'", "''");
         return `DEFAULT '${escaped}'`;
@@ -113,7 +116,7 @@ function columnSql(driver, table, def) {
         parts.push('UNIQUE');
     if (isPrimary)
         parts.push('PRIMARY KEY');
-    const defaultVal = getDefaultValueSql(table, def);
+    const defaultVal = getDefaultValueSql(driver, table, def);
     if (defaultVal !== null)
         parts.push(defaultVal);
     return parts.join(' ');

package/src/orm/SchemaStatemenWriter.d.ts

@@ -0,0 +1,15 @@
+export declare const SchemaWriter: (sql: string) => Promise<void>;
+export declare const StatementRegistryBuild: Readonly<{
+    /**
+     * Convert a JSONL capture file into a registry map.
+     *
+     * Input line shape: { statementId, sql }
+     * Output shape: { [statementId]: sql }
+     */
+    fromJsonl(jsonlText: string): Record<string, string>;
+    /** Merge registries, with `next` winning on collisions. */
+    merge(base: Record<string, string> | undefined, next: Record<string, string> | undefined): Record<string, string>;
+    /** Serialize a registry map as JSON suitable for `ZT_D1_STATEMENTS_JSON`. */
+    toStatementsJson(registry: Record<string, string>): string;
+}>;
+//# sourceMappingURL=SchemaStatemenWriter.d.ts.map

package/src/orm/SchemaStatemenWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaStatemenWriter.d.ts","sourceRoot":"","sources":["../../../src/orm/SchemaStatemenWriter.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,YAAY,GAAU,KAAK,MAAM,KAAG,OAAO,CAAC,IAAI,CAmB5D,CAAC;AAEF,eAAO,MAAM,sBAAsB;IACjC;;;;;OAKG;yBACkB,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBpD,2DAA2D;gBAEnD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,QAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GACvC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMzB,6EAA6E;+BAClD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;EAG1D,CAAC"}

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;AA+I1F,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,16 +5,47 @@
  */
 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);
+        const path = parsed.pathname.endsWith('/') ? parsed.pathname.slice(0, -1) : parsed.pathname;
+        if (path === '' || path === '/')
+            return undefined;
+        return path;
+    }
+    catch {
+        return undefined;
+    }
+};
 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'),
-        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 = {
@@ -22,8 +53,9 @@ const createRemoteConfig = () => {
         keyId: settings.keyId,
         secret: settings.secret,
         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',
@@ -35,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);
@@ -73,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,
@@ -89,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/MongoDBProxyAdapter.d.ts

@@ -0,0 +1,3 @@
+import type { IDatabaseAdapter } from '../DatabaseAdapter';
+export declare function createMongoDBProxyAdapter(): IDatabaseAdapter;
+//# sourceMappingURL=MongoDBProxyAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MongoDBProxyAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/MongoDBProxyAdapter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AA6D1E,wBAAgB,yBAAyB,IAAI,gBAAgB,CA4F5D"}