@zintrust/core 0.4.17 → 0.4.19

package/src/orm/adapters/SQLiteAdapter.js

@@ -0,0 +1,225 @@
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * SQLite Database Adapter
+ * Production Implementation
+ */
+import { databaseConfig } from '../../config/database.js';
+import { FeatureFlags } from '../../config/features.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { AdaptersEnum } from '../../migrations/enum/index.js';
+import fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+import { performance } from '../../node-singletons/perf-hooks.js';
+import { QueryBuilder } from '../QueryBuilder.js';
+const SAFE_SQLITE_IDENTIFIER = /^[A-Za-z_]\w*$/;
+const toSqliteIdentifier = (value) => {
+    if (!SAFE_SQLITE_IDENTIFIER.test(value)) {
+        throw ErrorFactory.createDatabaseError('Unsafe sqlite identifier');
+    }
+    return value;
+};
+const quoteSqliteIdentifier = (id) => {
+    // Safe due to SAFE_SQLITE_IDENTIFIER allowlist.
+    return `"${id}"`;
+};
+function isMissingEsmPackage(error, packageName) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const maybe = error;
+    const code = typeof maybe.code === 'string' ? maybe.code : '';
+    const message = typeof maybe.message === 'string' ? maybe.message : '';
+    // Some runners/wrappers preserve `code` but sanitize/omit the message.
+    if (code === 'ERR_MODULE_NOT_FOUND' && message.length === 0)
+        return true;
+    if (code === 'ERR_MODULE_NOT_FOUND' && message.includes(`'${packageName}'`))
+        return true;
+    if (message.includes(`Cannot find package '${packageName}'`))
+        return true;
+    return false;
+}
+async function importSqliteDatabaseConstructor() {
+    try {
+        // Avoid a literal dynamic import so bundlers (e.g. Wrangler/esbuild) don't
+        // try to bundle the native sqlite driver into non-Node targets.
+        const pkg = globalThis
+            .__zintrustSqliteDriver;
+        const mod = (await import(pkg ?? 'better-sqlite3'));
+        const ctor = mod.default;
+        if (typeof ctor === 'function')
+            return ctor;
+        // Some CJS packages may not present a `default` export under certain loaders.
+        return mod;
+    }
+    catch (error) {
+        if (isMissingEsmPackage(error, 'better-sqlite3')) {
+            throw ErrorFactory.createConfigError("SQLite adapter requires the 'better-sqlite3' package (run `zin add db:sqlite` or `zin plugin install db:sqlite`).");
+        }
+        throw ErrorFactory.createTryCatchError('Failed to load SQLite driver', { cause: error });
+    }
+}
+function normalizeFilename(database) {
+    const value = (database ?? '').trim();
+    return value.length > 0 ? value : ':memory:';
+}
+function isSelectQuery(sql) {
+    return sql.trimStart().toLowerCase().startsWith('select');
+}
+function requireDb(db) {
+    if (db === null)
+        throw ErrorFactory.createConnectionError('Database not connected');
+    return db;
+}
+function executeQuery(db, sql, parameters) {
+    const start = performance.now();
+    const stmt = db.prepare(sql);
+    if (isSelectQuery(sql)) {
+        const rows = stmt.all(parameters);
+        if (databaseConfig.logging.enabled) {
+            Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
+        }
+        return { rows, rowCount: rows.length };
+    }
+    const info = stmt.run(parameters);
+    if (databaseConfig.logging.enabled) {
+        Logger.debug('SQLite query executed', { durationMs: performance.now() - start, sql });
+    }
+    return { rows: [], rowCount: info.changes, lastInsertId: info.lastInsertRowid };
+}
+function executeRawQuery(db, sql, parameters) {
+    const stmt = db.prepare(sql);
+    if (isSelectQuery(sql))
+        return stmt.all(parameters);
+    stmt.run(parameters);
+    return [];
+}
+async function connectSQLite(state) {
+    if (state.db !== null)
+        return;
+    const filename = normalizeFilename(state.config.database);
+    // Ensure file-backed sqlite DB directories exist (e.g. .zintrust/dbs/*.sqlite).
+    if (filename !== ':memory:') {
+        try {
+            fs.mkdirSync(path.dirname(filename), { recursive: true });
+        }
+        catch (error) {
+            throw ErrorFactory.createTryCatchError('Failed to create SQLite database directory', {
+                filename,
+                cause: error,
+            });
+        }
+    }
+    const SqliteDatabaseCtor = await importSqliteDatabaseConstructor();
+    state.db = new SqliteDatabaseCtor(filename);
+    // Enable WAL mode for better concurrency
+    state.db.pragma('journal_mode = WAL');
+    Logger.info(`✓ SQLite connected (${filename})`);
+}
+async function disconnectSQLite(state) {
+    if (state.db === null)
+        return;
+    state.db.close();
+    state.db = null;
+    Logger.info('✓ SQLite disconnected');
+}
+async function querySQLite(state, sql, parameters) {
+    const currentDb = requireDb(state.db);
+    try {
+        return executeQuery(currentDb, sql, parameters);
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Query failed', { sql, parameters, cause: error });
+    }
+}
+async function rawQuerySQLite(state, sql, parameters) {
+    if (!FeatureFlags.isRawQueryEnabled()) {
+        throw ErrorFactory.createConfigError('Raw SQL queries are disabled');
+    }
+    const currentDb = requireDb(state.db);
+    Logger.warn(`Raw SQL Query executed: ${sql}`);
+    try {
+        return executeRawQuery(currentDb, sql, parameters);
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Raw query failed', { sql, parameters, cause: error });
+    }
+}
+async function transactionSQLite(state, adapter, callback) {
+    const currentDb = requireDb(state.db);
+    await adapter.query('BEGIN', []);
+    try {
+        const result = await callback(adapter, currentDb);
+        await adapter.query('COMMIT', []);
+        return result;
+    }
+    catch (error) {
+        await adapter.query('ROLLBACK', []);
+        throw ErrorFactory.createTryCatchError('Transaction failed', { cause: error });
+    }
+}
+function createSQLiteAdapter(config) {
+    const state = { db: null, config };
+    const adapter = {
+        async connect() {
+            await connectSQLite(state);
+        },
+        async disconnect() {
+            await disconnectSQLite(state);
+        },
+        async query(sql, parameters = []) {
+            return querySQLite(state, sql, parameters);
+        },
+        async queryOne(sql, parameters = []) {
+            const result = await adapter.query(sql, parameters);
+            return result.rows[0] ?? null;
+        },
+        async ping() {
+            await adapter.query(QueryBuilder.create('').select('1').toSQL(), []);
+        },
+        async transaction(callback) {
+            return transactionSQLite(state, adapter, callback);
+        },
+        async rawQuery(sql, parameters = []) {
+            return rawQuerySQLite(state, sql, parameters);
+        },
+        async ensureMigrationsTable() {
+            await adapter.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)
+        )`, []);
+        },
+        async resetSchema() {
+            // Best-effort for SQLite.
+            await adapter.query('PRAGMA foreign_keys = OFF', []);
+            const tables = (await adapter.query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'", []));
+            await Promise.all(tables.rows.map(async (t) => {
+                const name = typeof t.name === 'string' ? t.name : '';
+                if (name.length === 0)
+                    return;
+                const tableName = toSqliteIdentifier(name);
+                await adapter.query(`DROP TABLE IF EXISTS ${quoteSqliteIdentifier(tableName)}`, []);
+            }));
+            await adapter.query('PRAGMA foreign_keys = ON', []);
+        },
+        getType() {
+            return AdaptersEnum.sqlite;
+        },
+        isConnected() {
+            return Boolean(state.db);
+        },
+        getPlaceholder(_index) {
+            return '?';
+        },
+    };
+    return adapter;
+}
+export const SQLiteAdapter = Object.freeze({
+    create: createSQLiteAdapter,
+});

package/src/orm/adapters/SqlProxyAdapterUtils.d.ts

@@ -0,0 +1,19 @@
+import { type RemoteSignedJsonSettings } from '../../common/RemoteSignedJson';
+export type ProxySettings = {
+    baseUrl: string;
+    keyId?: string;
+    secret?: string;
+    timeoutMs: number;
+    signaturePathPrefixToStrip?: string;
+};
+export type SignedProxyConfig = {
+    settings: ProxySettings;
+    missingUrlMessage: string;
+    missingCredentialsMessage: string;
+    messages: RemoteSignedJsonSettings['messages'];
+};
+export declare const buildSignedSettings: (config: SignedProxyConfig) => RemoteSignedJsonSettings;
+export declare const ensureSignedSettings: (config: SignedProxyConfig) => RemoteSignedJsonSettings;
+export declare const requestSignedProxy: <T>(config: SignedProxyConfig, path: string, payload: Record<string, unknown>) => Promise<T>;
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+//# sourceMappingURL=SqlProxyAdapterUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SqlProxyAdapterUtils.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SqlProxyAdapterUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAM3F,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,aAAa,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,yBAAyB,EAAE,MAAM,CAAC;IAClC,QAAQ,EAAE,wBAAwB,CAAC,UAAU,CAAC,CAAC;CAChD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,iBAAiB,KAAG,wBAiB/D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,QAAQ,iBAAiB,KAAG,wBAYhE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,CAAC,EACxC,QAAQ,iBAAiB,EACzB,MAAM,MAAM,EACZ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC/B,OAAO,CAAC,CAAC,CAGX,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAoB,CAAC"}

package/src/orm/adapters/SqlProxyAdapterUtils.js

@@ -0,0 +1,36 @@
+import { RemoteSignedJson } from '../../common/RemoteSignedJson.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { isObject } from '../../helper/index.js';
+import { resolveSigningPrefix } from '../adapters/ProxySigningPath.js';
+import { normalizeSigningCredentials } from '../../proxy/SigningService.js';
+export const buildSignedSettings = (config) => {
+    const creds = normalizeSigningCredentials({
+        keyId: config.settings.keyId ?? '',
+        secret: config.settings.secret ?? '',
+    });
+    return {
+        baseUrl: config.settings.baseUrl,
+        keyId: creds.keyId,
+        secret: creds.secret,
+        timeoutMs: config.settings.timeoutMs,
+        signaturePathPrefixToStrip: config.settings.signaturePathPrefixToStrip ?? resolveSigningPrefix(config.settings.baseUrl),
+        missingUrlMessage: config.missingUrlMessage,
+        missingCredentialsMessage: config.missingCredentialsMessage,
+        messages: config.messages,
+    };
+};
+export const ensureSignedSettings = (config) => {
+    const signedSettings = buildSignedSettings(config);
+    if (signedSettings.baseUrl.trim() === '') {
+        throw ErrorFactory.createConfigError(config.missingUrlMessage);
+    }
+    if (signedSettings.keyId.trim() === '' || signedSettings.secret.trim() === '') {
+        throw ErrorFactory.createConfigError(config.missingCredentialsMessage);
+    }
+    return signedSettings;
+};
+export const requestSignedProxy = async (config, path, payload) => {
+    const signedSettings = ensureSignedSettings(config);
+    return RemoteSignedJson.request(signedSettings, path, payload);
+};
+export const isRecord = (value) => isObject(value);

package/src/orm/adapters/SqlProxyHttpAdapterShared.d.ts

@@ -0,0 +1,30 @@
+import { type ProxySettings, type SignedProxyConfig } from '../adapters/SqlProxyAdapterUtils';
+export type ProxyMode = 'sql' | 'registry';
+export type ProxySettingsBuildInput = {
+    urlKey: string;
+    hostKey?: string;
+    portKey?: string;
+    defaultHost?: string;
+    defaultPort?: number;
+    keyIdKey: string;
+    secretKey: string;
+    timeoutKey: string;
+    sharedKeyIdKey?: string;
+    sharedSecretKey?: string;
+    sharedTimeoutKey?: string;
+};
+export declare const SqlProxyHttpAdapterShared: Readonly<{
+    buildProxySettingsFromEnv: (input: ProxySettingsBuildInput) => ProxySettings;
+    buildStandardSignedProxyConfig: (input: {
+        settings: ProxySettings;
+        label: string;
+        urlKey: string;
+        keyIdKey: string;
+        secretKey: string;
+    }) => SignedProxyConfig;
+    ensureSignedProxyConfig: (signed: SignedProxyConfig) => void;
+    requestProxy: <T>(signed: SignedProxyConfig, path: string, payload: Record<string, unknown>) => Promise<T>;
+    resolveProxyModeFromEnv: (envKey: string) => ProxyMode;
+    createProxyNotReachableCliError: (label: string, baseUrl: string, error: unknown) => Error;
+}>;
+//# sourceMappingURL=SqlProxyHttpAdapterShared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SqlProxyHttpAdapterShared.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SqlProxyHttpAdapterShared.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACvB,MAAM,oCAAoC,CAAC;AAG5C,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,UAAU,CAAC;AAE3C,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAmFF,eAAO,MAAM,yBAAyB;uCA9DI,uBAAuB,KAAG,aAAa;4CAalC;QAC7C,QAAQ,EAAE,aAAa,CAAC;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;KACnB,KAAG,iBAAiB;sCAmBoB,iBAAiB,KAAG,IAAI;mBAIrC,CAAC,UACnB,iBAAiB,QACnB,MAAM,WACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC/B,OAAO,CAAC,CAAC,CAAC;sCAI4B,MAAM,KAAG,SAAS;6CAIX,MAAM,WAAW,MAAM,SAAS,OAAO,KAAG,KAAK;EAe7F,CAAC"}

package/src/orm/adapters/SqlProxyHttpAdapterShared.js

@@ -0,0 +1,64 @@
+import { Env } from '../../config/env.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ensureSignedSettings, requestSignedProxy, } from '../adapters/SqlProxyAdapterUtils.js';
+import { resolveSqlProxyMode } from '../adapters/SqlProxyRegistryMode.js';
+const resolveBaseUrl = (input) => {
+    const explicit = Env.get(input.urlKey, '').trim();
+    if (explicit !== '')
+        return explicit;
+    if (input.hostKey === undefined ||
+        input.portKey === undefined ||
+        input.defaultPort === undefined) {
+        return '';
+    }
+    const defaultHost = input.defaultHost ?? '127.0.0.1';
+    const rawHost = Env.get(input.hostKey, defaultHost);
+    const host = typeof rawHost === 'string' && rawHost.trim() !== '' ? rawHost : defaultHost;
+    const port = Env.getInt(input.portKey, input.defaultPort);
+    return `http://${host}:${port}`;
+};
+const buildProxySettingsFromEnv = (input) => {
+    const baseUrl = resolveBaseUrl(input);
+    const keyId = Env.get(input.keyIdKey, Env.get(input.sharedKeyIdKey ?? 'ZT_PROXY_KEY_ID', ''));
+    const secret = Env.get(input.secretKey, Env.get(input.sharedSecretKey ?? 'ZT_PROXY_SECRET', ''));
+    const timeoutMs = Env.getInt(input.timeoutKey, Env.getInt(input.sharedTimeoutKey ?? 'ZT_PROXY_TIMEOUT_MS', 30000));
+    return { baseUrl, keyId, secret, timeoutMs };
+};
+const buildStandardSignedProxyConfig = (input) => {
+    const { settings, label } = input;
+    const prefix = `${label} proxy`;
+    return {
+        settings,
+        missingUrlMessage: `${label} proxy URL is missing (${input.urlKey})`,
+        missingCredentialsMessage: `${label} proxy signing credentials are missing (${input.keyIdKey} / ${input.secretKey})`,
+        messages: {
+            unauthorized: `${prefix} unauthorized`,
+            forbidden: `${prefix} forbidden`,
+            rateLimited: `${prefix} rate limited`,
+            rejected: `${prefix} rejected request`,
+            error: `${prefix} error`,
+            timedOut: `${prefix} request timed out`,
+        },
+    };
+};
+const ensureSignedProxyConfig = (signed) => {
+    ensureSignedSettings(signed);
+};
+const requestProxy = async (signed, path, payload) => {
+    return requestSignedProxy(signed, path, payload);
+};
+const resolveProxyModeFromEnv = (envKey) => {
+    return resolveSqlProxyMode(envKey);
+};
+const createProxyNotReachableCliError = (label, baseUrl, error) => {
+    const msg = error instanceof Error ? error.message : String(error);
+    return ErrorFactory.createCliError(`${label} is enabled but the proxy server is not reachable at ${baseUrl}. Start the proxy stack (e.g. \`zin cp up\` or \`docker compose -f docker-compose.proxy.yml up -d\`) and re-run \`zin migrate\`.`, { error: msg, baseUrl });
+};
+export const SqlProxyHttpAdapterShared = Object.freeze({
+    buildProxySettingsFromEnv,
+    buildStandardSignedProxyConfig,
+    ensureSignedProxyConfig,
+    requestProxy,
+    resolveProxyModeFromEnv,
+    createProxyNotReachableCliError,
+});

package/src/orm/adapters/SqlProxyRegistryMode.d.ts

@@ -0,0 +1,12 @@
+export type SqlProxyMode = 'sql' | 'registry';
+export declare const resolveSqlProxyMode: (envKey: string) => SqlProxyMode;
+export declare const createStatementId: (sql: string) => Promise<string>;
+export declare const createStatementPayload: (sql: string, parameters: unknown[]) => Promise<{
+    statementId: string;
+    params: unknown[];
+}>;
+export declare const getExecMetaWithLastRowId: (value: unknown) => {
+    changes: number;
+    lastRowId?: number | string | bigint;
+};
+//# sourceMappingURL=SqlProxyRegistryMode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SqlProxyRegistryMode.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SqlProxyRegistryMode.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,UAAU,CAAC;AAE9C,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,KAAG,YAGpD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,KAAK,MAAM,KAAG,OAAO,CAAC,MAAM,CAEnE,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,KAAK,MAAM,EACX,YAAY,OAAO,EAAE,KACpB,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAGpD,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,OAAO,OAAO,KACb;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;CAOzD,CAAC"}

package/src/orm/adapters/SqlProxyRegistryMode.js

@@ -0,0 +1,24 @@
+import { Env } from '../../config/env.js';
+import { isRecord } from '../adapters/SqlProxyAdapterUtils.js';
+import { SignedRequest } from '../../security/SignedRequest.js';
+export const resolveSqlProxyMode = (envKey) => {
+    const raw = Env.get(envKey, 'sql').trim().toLowerCase();
+    return raw === 'registry' ? 'registry' : 'sql';
+};
+export const createStatementId = async (sql) => {
+    return SignedRequest.sha256Hex(sql);
+};
+export const createStatementPayload = async (sql, parameters) => {
+    const statementId = await createStatementId(sql);
+    return { statementId, params: parameters };
+};
+export const getExecMetaWithLastRowId = (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 };
+};

package/src/orm/adapters/SqlServerProxyAdapter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SQL Server Proxy Adapter (HTTP)
+ */
+import type { IDatabaseAdapter } from '../DatabaseAdapter';
+export declare function createSqlServerProxyAdapter(): IDatabaseAdapter;
+//# sourceMappingURL=SqlServerProxyAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SqlServerProxyAdapter.d.ts","sourceRoot":"","sources":["../../../../src/orm/adapters/SqlServerProxyAdapter.ts"],"names":[],"mappings":"AACA;;GAEG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,sBAAsB,CAAC;AA2P1E,wBAAgB,2BAA2B,IAAI,gBAAgB,CAK9D"}

package/src/orm/adapters/SqlServerProxyAdapter.js

@@ -0,0 +1,171 @@
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * SQL Server Proxy Adapter (HTTP)
+ */
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { AdaptersEnum } from '../../migrations/enum/index.js';
+import { QueryBuilder } from '../QueryBuilder.js';
+import { ensureSignedSettings, isRecord, } from '../adapters/SqlProxyAdapterUtils.js';
+import { SqlProxyHttpAdapterShared } from '../adapters/SqlProxyHttpAdapterShared.js';
+import { createStatementPayload, getExecMetaWithLastRowId, } from '../adapters/SqlProxyRegistryMode.js';
+const resolveProxyMode = () => {
+    return SqlProxyHttpAdapterShared.resolveProxyModeFromEnv('SQLSERVER_PROXY_MODE');
+};
+const buildProxySettings = () => {
+    return SqlProxyHttpAdapterShared.buildProxySettingsFromEnv({
+        urlKey: 'SQLSERVER_PROXY_URL',
+        hostKey: 'SQLSERVER_PROXY_HOST',
+        portKey: 'SQLSERVER_PROXY_PORT',
+        defaultHost: '127.0.0.1',
+        defaultPort: 8793,
+        keyIdKey: 'SQLSERVER_PROXY_KEY_ID',
+        secretKey: 'SQLSERVER_PROXY_SECRET',
+        timeoutKey: 'SQLSERVER_PROXY_TIMEOUT_MS',
+        sharedTimeoutKey: 'ZT_PROXY_TIMEOUT_MS',
+    });
+};
+const buildSignedProxyConfig = (settings) => {
+    return SqlProxyHttpAdapterShared.buildStandardSignedProxyConfig({
+        settings,
+        label: 'SQL Server',
+        urlKey: 'SQLSERVER_PROXY_URL',
+        keyIdKey: 'SQLSERVER_PROXY_KEY_ID',
+        secretKey: 'SQLSERVER_PROXY_SECRET',
+    });
+};
+const isQueryResponse = (value) => isRecord(value) && Array.isArray(value['rows']) && typeof value['rowCount'] === 'number';
+const isQueryOneResponse = (value) => isRecord(value) && 'row' in value;
+const requestProxy = async (signed, path, payload) => SqlProxyHttpAdapterShared.requestProxy(signed, path, payload);
+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 };
+    }
+    if (isQueryOneResponse(out)) {
+        const row = out.row ?? null;
+        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.signed, '/zin/sqlserver/statement', await createStatementPayload(sql, parameters))
+        : await requestProxy(state.signed, '/zin/sqlserver/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.signed, '/zin/sqlserver/queryOne', {
+            sql,
+            params: parameters,
+        });
+        return out.row ?? null;
+    }
+    const out = await requestProxy(state.signed, '/zin/sqlserver/statement', await createStatementPayload(sql, parameters));
+    if (isQueryOneResponse(out))
+        return out.row ?? null;
+    if (isQueryResponse(out))
+        return out.rows[0] ?? null;
+    return null;
+};
+const createPing = (query) => async () => {
+    await query(QueryBuilder.create('').select('1').toSQL(), []);
+};
+const createTransaction = (state, getAdapter) => async (callback) => {
+    if (state.inTransaction) {
+        throw ErrorFactory.createGeneralError('Transaction already in progress');
+    }
+    requireConnected(state);
+    state.inTransaction = true;
+    try {
+        const adapter = getAdapter();
+        await adapter.query('BEGIN TRANSACTION', []);
+        const result = await callback(adapter);
+        await adapter.query('COMMIT', []);
+        return result;
+    }
+    catch (error) {
+        try {
+            await getAdapter().query('ROLLBACK', []);
+        }
+        catch {
+            void 0;
+        }
+        throw error;
+    }
+    finally {
+        state.inTransaction = false;
+    }
+};
+const createRawQuery = (query) => async (sql, parameters) => {
+    const result = await query(sql, parameters ?? []);
+    return result.rows;
+};
+const createAdapter = (state) => {
+    const query = createQuery(state);
+    const queryOne = createQueryOne(state);
+    const adapter = {
+        async connect() {
+            ensureSignedSettings(state.signed);
+            state.connected = true;
+        },
+        async disconnect() {
+            state.connected = false;
+            state.inTransaction = false;
+        },
+        query,
+        queryOne,
+        ping: createPing(query),
+        transaction: createTransaction(state, () => adapter),
+        rawQuery: createRawQuery(query),
+        async ensureMigrationsTable() {
+            requireConnected(state);
+            try {
+                await query(`IF OBJECT_ID(N'migrations', N'U') IS NULL
+BEGIN
+  CREATE TABLE migrations (
+    id INT IDENTITY(1,1) PRIMARY KEY,
+    name NVARCHAR(255) NOT NULL,
+    scope NVARCHAR(255) NOT NULL DEFAULT 'global',
+    service NVARCHAR(255) NOT NULL DEFAULT '',
+    batch INT NOT NULL,
+    status NVARCHAR(255) NOT NULL,
+    applied_at DATETIME2 NULL,
+    created_at DATETIME2 NOT NULL DEFAULT SYSUTCDATETIME(),
+    CONSTRAINT UQ_migrations_name_scope_service UNIQUE (name, scope, service)
+  );
+END`, []);
+            }
+            catch (error) {
+                throw SqlProxyHttpAdapterShared.createProxyNotReachableCliError('SQL Server proxy', state.settings.baseUrl, error);
+            }
+        },
+        getType() {
+            return AdaptersEnum.sqlserver;
+        },
+        isConnected() {
+            return state.connected;
+        },
+        getPlaceholder(index) {
+            return `@param${index}`;
+        },
+    };
+    return adapter;
+};
+export function createSqlServerProxyAdapter() {
+    const settings = buildProxySettings();
+    const signed = buildSignedProxyConfig(settings);
+    const state = { connected: false, inTransaction: false, settings, signed };
+    return createAdapter(state);
+}

package/src/orm/maintenance/SqliteMaintenance.d.ts

@@ -0,0 +1,5 @@
+import type { IDatabase } from '../Database';
+export declare const SqliteMaintenance: Readonly<{
+    dropAllTables(db: IDatabase): Promise<void>;
+}>;
+//# sourceMappingURL=SqliteMaintenance.d.ts.map

package/src/orm/maintenance/SqliteMaintenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteMaintenance.d.ts","sourceRoot":"","sources":["../../../../src/orm/maintenance/SqliteMaintenance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAQ/C,eAAO,MAAM,iBAAiB;sBACJ,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;EAWjD,CAAC"}

package/src/orm/maintenance/SqliteMaintenance.js

@@ -0,0 +1,14 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const supportsResetSchema = (adapter) => typeof adapter.resetSchema === 'function';
+export const SqliteMaintenance = Object.freeze({
+    async dropAllTables(db) {
+        if (db.getType() !== 'sqlite') {
+            throw ErrorFactory.createDatabaseError('dropAllTables is only supported for sqlite');
+        }
+        const adapter = db.getAdapterInstance(false);
+        if (!supportsResetSchema(adapter)) {
+            throw ErrorFactory.createDatabaseError('SQLite adapter does not support resetSchema()');
+        }
+        await adapter.resetSchema();
+    },
+});