@zintrust/core 0.1.28 → 0.1.30

package/src/orm/Database.js

@@ -0,0 +1,350 @@
+/**
+ * Database Manager
+ * Central database connection management and query execution
+ */
+import Logger from '../config/logger.js';
+import { OpenTelemetry } from '../observability/OpenTelemetry.js';
+import { Env } from '../config/env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { EventEmitter } from '../node-singletons/events.js';
+import { D1Adapter } from './adapters/D1Adapter.js';
+import { D1RemoteAdapter } from './adapters/D1RemoteAdapter.js';
+import { MySQLAdapter } from './adapters/MySQLAdapter.js';
+import { PostgreSQLAdapter } from './adapters/PostgreSQLAdapter.js';
+import { SQLiteAdapter } from './adapters/SQLiteAdapter.js';
+import { SQLServerAdapter } from './adapters/SQLServerAdapter.js';
+import { DatabaseAdapterRegistry } from './DatabaseAdapterRegistry.js';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Database Manager
+ * Refactored to Functional Object pattern
+ */
+/**
+ * Create appropriate adapter based on driver
+ */
+const createAdapter = (cfg) => {
+    const registered = DatabaseAdapterRegistry.get(cfg.driver);
+    if (registered !== undefined) {
+        return registered(cfg);
+    }
+    switch (cfg.driver) {
+        case 'postgresql':
+            return PostgreSQLAdapter.create(cfg);
+        case 'mysql':
+            return MySQLAdapter.create(cfg);
+        case 'sqlserver':
+            return SQLServerAdapter.create(cfg);
+        case 'd1':
+            return D1Adapter.create(cfg);
+        case 'd1-remote':
+            return D1RemoteAdapter.create(cfg);
+        case 'sqlite':
+        default:
+            return SQLiteAdapter.create(cfg);
+    }
+};
+/**
+ * Initialize write and read adapters
+ */
+const initializeAdapters = (dbConfig) => {
+    const writeAdapter = createAdapter(dbConfig);
+    const readAdapters = [];
+    if (dbConfig.readHosts !== undefined && dbConfig.readHosts.length > 0) {
+        for (const host of dbConfig.readHosts) {
+            readAdapters.push(createAdapter({ ...dbConfig, host }));
+        }
+    }
+    else {
+        readAdapters.push(writeAdapter);
+    }
+    return { writeAdapter, readAdapters };
+};
+/**
+ * Execute a query with events and timing
+ */
+const executeQuery = async (adapter, eventEmitter, sql, parameters, method) => {
+    eventEmitter.emit('before-query', sql, parameters);
+    const startTime = Date.now();
+    const result = await adapter[method](sql, parameters);
+    const duration = Date.now() - startTime;
+    eventEmitter.emit('after-query', sql, parameters, duration);
+    return result.rows;
+};
+const executeFullQuery = async (adapter, eventEmitter, sql, parameters) => {
+    eventEmitter.emit('before-query', sql, parameters);
+    const startTime = Date.now();
+    const result = await adapter.query(sql, parameters);
+    const duration = Date.now() - startTime;
+    eventEmitter.emit('after-query', sql, parameters, duration);
+    return result;
+};
+const executeQueryOne = async (adapter, eventEmitter, sql, parameters) => {
+    eventEmitter.emit('before-query', sql, parameters);
+    const startTime = Date.now();
+    const result = await adapter.queryOne(sql, parameters);
+    const duration = Date.now() - startTime;
+    eventEmitter.emit('after-query', sql, parameters, duration);
+    return result;
+};
+const installDbMetricsIfEnabled = (dbConfig, eventEmitter) => {
+    if (Env.getBool('METRICS_ENABLED', false) === false)
+        return null;
+    let observeDbQueryPromise = null;
+    const ensureObserveDbQuery = async () => {
+        if (observeDbQueryPromise !== null)
+            return observeDbQueryPromise;
+        observeDbQueryPromise = import('../observability/PrometheusMetrics.js')
+            .then((m) => m.PrometheusMetrics.observeDbQuery)
+            .catch(() => null);
+        return observeDbQueryPromise;
+    };
+    const handler = (_sql, _params, durationMs) => {
+        void ensureObserveDbQuery().then((observe) => {
+            if (observe === null)
+                return;
+            void observe({ driver: dbConfig.driver, durationMs });
+        });
+    };
+    eventEmitter.on('after-query', handler);
+    // Return cleanup function
+    return () => {
+        eventEmitter.off('after-query', handler);
+    };
+};
+const installDbTracingIfEnabled = (dbConfig, eventEmitter) => {
+    if (Env.getBool('OTEL_ENABLED', false) === false)
+        return null;
+    const handler = (_sql, _params, durationMs) => {
+        OpenTelemetry.recordDbQuerySpan({ driver: dbConfig.driver, durationMs });
+    };
+    eventEmitter.on('after-query', handler);
+    // Return cleanup function
+    return () => {
+        eventEmitter.off('after-query', handler);
+    };
+};
+/**
+ * Create connect/disconnect handlers
+ */
+const createConnectionHandlers = (writeAdapter, readAdapters, connected, connectInFlight) => {
+    return {
+        async connect() {
+            if (connected.value)
+                return;
+            const inFlight = connectInFlight.value;
+            if (inFlight !== undefined) {
+                await inFlight;
+                return;
+            }
+            connectInFlight.value = (async () => {
+                await writeAdapter.connect();
+                await Promise.all(readAdapters
+                    .filter((adapter) => adapter !== writeAdapter)
+                    .map(async (adapter) => adapter.connect()));
+                connected.value = true;
+            })();
+            try {
+                await connectInFlight.value;
+            }
+            finally {
+                connectInFlight.value = undefined;
+            }
+        },
+        async disconnect() {
+            if (connectInFlight.value !== undefined) {
+                await connectInFlight.value.catch(() => {
+                    // ignore
+                });
+            }
+            await writeAdapter.disconnect();
+            await Promise.all(readAdapters
+                .filter((adapter) => adapter !== writeAdapter)
+                .map(async (adapter) => adapter.disconnect()));
+            connected.value = false;
+        },
+    };
+};
+/**
+ * Create query handlers
+ */
+const createQueryHandlers = (writeAdapter, _readAdapters, eventEmitter, connected, db, getAdapter) => {
+    return {
+        async query(sql, parameters = [], isRead = false) {
+            if (connected.value === false)
+                await db.connect();
+            const adapter = getAdapter(isRead);
+            const registry = DatabaseAdapterRegistry.list();
+            // Validate that database adapters are registered
+            if (registry.length === 0) {
+                throw ErrorFactory.createConfigError('No database adapters are registered. Call DatabaseAdapterRegistry.register() during startup to register database adapters.');
+            }
+            Logger.debug('Using DB adapter', {
+                type: adapter?.getType?.(),
+                hasRegistry: registry,
+            });
+            return executeQuery(adapter, eventEmitter, sql, parameters, 'query');
+        },
+        async queryOne(sql, parameters = [], isRead = false) {
+            if (connected.value === false)
+                await db.connect();
+            const adapter = getAdapter(isRead);
+            // Validate that database adapters are registered
+            if (DatabaseAdapterRegistry.list().length === 0) {
+                throw ErrorFactory.createConfigError('No database adapters are registered. Call DatabaseAdapterRegistry.register() during startup to register database adapters.');
+            }
+            return executeQueryOne(adapter, eventEmitter, sql, parameters);
+        },
+        async execute(sql, parameters = [], isRead = false) {
+            if (connected.value === false)
+                await db.connect();
+            const adapter = getAdapter(isRead);
+            // Validate that database adapters are registered
+            if (DatabaseAdapterRegistry.list().length === 0) {
+                throw ErrorFactory.createConfigError('No database adapters are registered. Call DatabaseAdapterRegistry.register() during startup to register database adapters.');
+            }
+            return executeFullQuery(adapter, eventEmitter, sql, parameters);
+        },
+        async transaction(callback) {
+            if (connected.value === false)
+                await db.connect();
+            // Validate that database adapters are registered
+            if (DatabaseAdapterRegistry.list().length === 0) {
+                throw ErrorFactory.createConfigError('No database adapters are registered. Call DatabaseAdapterRegistry.register() during startup to register database adapters.');
+            }
+            return writeAdapter.transaction(async () => callback(db));
+        },
+    };
+};
+const setupDbInstrumentation = (dbConfig, eventEmitter) => {
+    const cleanupFunctions = [];
+    const metricsCleanup = installDbMetricsIfEnabled(dbConfig, eventEmitter);
+    const tracingCleanup = installDbTracingIfEnabled(dbConfig, eventEmitter);
+    if (metricsCleanup)
+        cleanupFunctions.push(metricsCleanup);
+    if (tracingCleanup)
+        cleanupFunctions.push(tracingCleanup);
+    return cleanupFunctions;
+};
+const applyQueryHandlers = (db, queryHandlers) => {
+    db.query = queryHandlers.query;
+    db.queryOne = queryHandlers.queryOne;
+    db.execute = queryHandlers.execute;
+    db.transaction = queryHandlers.transaction;
+};
+const createDbFacade = (input) => {
+    const { dbConfig, writeAdapter, eventEmitter, connected, getAdapter, connectionHandlers, queryHandlers, cleanupFunctions, } = input;
+    const db = {
+        connect: connectionHandlers.connect,
+        disconnect: connectionHandlers.disconnect,
+        isConnected() {
+            return connected.value;
+        },
+        query: queryHandlers.query,
+        queryOne: queryHandlers.queryOne,
+        execute: queryHandlers.execute,
+        transaction: queryHandlers.transaction,
+        table(name) {
+            return QueryBuilder.create(name, db);
+        },
+        onBeforeQuery: (h) => eventEmitter.on('before-query', h),
+        onAfterQuery: (h) => eventEmitter.on('after-query', h),
+        offBeforeQuery: (h) => eventEmitter.off('before-query', h),
+        offAfterQuery: (h) => eventEmitter.off('after-query', h),
+        getAdapterInstance(isRead = false) {
+            return getAdapter(isRead);
+        },
+        getType() {
+            return writeAdapter.getType();
+        },
+        getConfig() {
+            return { ...dbConfig };
+        },
+        dispose() {
+            // Clean up event listeners to prevent memory leaks
+            for (const cleanup of cleanupFunctions) {
+                cleanup();
+            }
+            cleanupFunctions.length = 0;
+        },
+    };
+    return db;
+};
+const createDatabaseInstance = (dbConfig) => {
+    const eventEmitter = new EventEmitter();
+    const connected = { value: false };
+    const connectInFlight = { value: undefined };
+    let readIndex = 0;
+    const { writeAdapter, readAdapters } = initializeAdapters(dbConfig);
+    const cleanupFunctions = setupDbInstrumentation(dbConfig, eventEmitter);
+    const getAdapter = (isRead = false) => {
+        if (isRead === false || readAdapters.length === 0) {
+            return writeAdapter;
+        }
+        const adapter = readAdapters[readIndex];
+        if (adapter === undefined)
+            return writeAdapter;
+        readIndex = (readIndex + 1) % readAdapters.length;
+        return adapter;
+    };
+    const connectionHandlers = createConnectionHandlers(writeAdapter, readAdapters, connected, connectInFlight);
+    // Create temporary handlers with db as undefined, then update after db is created
+    let queryHandlers = createQueryHandlers(writeAdapter, readAdapters, eventEmitter, connected, {}, getAdapter);
+    const db = createDbFacade({
+        dbConfig,
+        writeAdapter,
+        eventEmitter,
+        connected,
+        getAdapter,
+        connectionHandlers,
+        queryHandlers,
+        cleanupFunctions,
+    });
+    // Update handlers with actual db reference for circular dependency
+    queryHandlers = createQueryHandlers(writeAdapter, readAdapters, eventEmitter, connected, db, getAdapter);
+    applyQueryHandlers(db, queryHandlers);
+    return db;
+};
+export const Database = Object.freeze({
+    /**
+     * Create a new database instance
+     */
+    create(config) {
+        const dbConfig = config ?? { driver: 'sqlite', database: ':memory:' };
+        return createDatabaseInstance(dbConfig);
+    },
+});
+const databaseInstances = new Map();
+export const useEnsureDbConnected = async (config = undefined, connectionName = 'default') => {
+    const db = useDatabase(config, connectionName);
+    if (!db.isConnected()) {
+        await db.connect();
+    }
+    return db;
+};
+export function useDatabase(config, connection = 'default') {
+    if (databaseInstances.has(connection) === false) {
+        if (config === undefined) {
+            throw ErrorFactory.createConfigError(`Database connection '${connection}' is not registered. ` +
+                `Call useDatabase(config, '${connection}') during startup to register it.`);
+        }
+        databaseInstances.set(connection, Database.create(config));
+    }
+    const instance = databaseInstances.get(connection);
+    if (instance === undefined) {
+        throw ErrorFactory.createConfigError(`Failed to initialize database instance: ${connection}`);
+    }
+    return instance;
+}
+export async function resetDatabase() {
+    const promises = Array.from(databaseInstances.values()).map(async (instance) => {
+        try {
+            await instance.disconnect();
+            instance.dispose();
+        }
+        catch {
+            // Ignore errors during disconnect
+        }
+    });
+    await Promise.all(promises);
+    databaseInstances.clear();
+}

package/src/orm/DatabaseAdapter.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Database Adapter Interface
+ * Defines contract for different database implementations
+ */
+import type { SupportedDriver } from '../migrations/enum';
+/**
+ * Minimal D1 Database interface for type safety
+ */
+export interface ID1Database {
+    prepare(sql: string): {
+        bind(...values: unknown[]): {
+            all<T = unknown>(): Promise<{
+                results?: T[];
+                success: boolean;
+                error?: string;
+            }>;
+            first<T = unknown>(): Promise<T | null>;
+            run(): Promise<{
+                success: boolean;
+                error?: string;
+            }>;
+        };
+    };
+}
+export interface DatabaseConfig {
+    d1?: ID1Database;
+    driver: SupportedDriver;
+    database?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    synchronize?: boolean;
+    logging?: boolean;
+    readHosts?: string[];
+}
+export interface QueryResult {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    lastInsertId?: string | number | bigint;
+}
+export interface IDatabaseAdapter {
+    /**
+     * Connect to database
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Execute a query
+     */
+    query(sql: string, parameters: unknown[]): Promise<QueryResult>;
+    /**
+     * Execute a query and return first result
+     */
+    queryOne(sql: string, parameters: unknown[]): Promise<Record<string, unknown> | null>;
+    /**
+     * Lightweight connection probe.
+     *
+     * This should be safe to call from health/readiness endpoints.
+     */
+    ping(): Promise<void>;
+    /**
+     * Execute multiple queries in transaction
+     */
+    transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T>;
+    /**
+     * Execute raw SQL query (only available when USE_RAW_QRY=true)
+     * WARNING: Bypasses QueryBuilder safety. Use parameterized queries.
+     */
+    rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]>;
+    /**
+     * Ensure the migrations tracking table exists.
+     *
+     * This intentionally lives on the adapter so higher-level framework code
+     * doesn't embed DDL SQL.
+     */
+    ensureMigrationsTable?(): Promise<void>;
+    /**
+     * Best-effort schema reset for development workflows.
+     *
+     * For SQL databases, this typically means dropping user tables.
+     */
+    resetSchema?(): Promise<void>;
+    /**
+     * Get database type
+     */
+    getType(): SupportedDriver;
+    /**
+     * Check connection status
+     */
+    isConnected(): boolean;
+    /**
+     * Get placeholder for parameterized query
+     */
+    getPlaceholder(index: number): string;
+}
+/**
+ * Base Adapter Utilities
+ * Refactored to Functional Object pattern
+ */
+export declare const BaseAdapter: Readonly<{
+    /**
+     * Sanitize parameter value
+     */
+    sanitize(value: unknown): string;
+    /**
+     * Build parameterized query (for adapters that need it)
+     */
+    buildParameterizedQuery(sql: string, parameters: unknown[], getPlaceholder?: (index: number) => string): {
+        sql: string;
+        parameters: unknown[];
+    };
+}>;
+//# sourceMappingURL=DatabaseAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseAdapter.d.ts","sourceRoot":"","sources":["../../../src/orm/DatabaseAdapter.ts"],"names":[],"mappings":"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"}

package/src/orm/DatabaseAdapter.js

@@ -0,0 +1,57 @@
+/**
+ * Database Adapter Interface
+ * Defines contract for different database implementations
+ */
+/**
+ * Base Adapter Utilities
+ * Refactored to Functional Object pattern
+ */
+export const BaseAdapter = Object.freeze({
+    /**
+     * Sanitize parameter value
+     */
+    sanitize(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${value.replaceAll("'", "''")}'`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        // Support BigInt explicitly to avoid JSON.stringify errors and driver issues
+        if (typeof value === 'bigint') {
+            return String(value);
+        }
+        // Dates should be passed as ISO strings
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        // Buffer / Uint8Array -> base64 string
+        // Some DB adapters expect binary types; returning base64-encoded string is a safe default
+        // and prevents JSON.stringify(BigInt) errors when objects include BigInt.
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+            return `'${value.toString('base64')}'`;
+        }
+        if (value instanceof Uint8Array) {
+            return `'${Buffer.from(value).toString('base64')}'`;
+        }
+        // For objects, convert to JSON string representation
+        return `'${JSON.stringify(value).replaceAll("'", "''")}'`;
+    },
+    /**
+     * Build parameterized query (for adapters that need it)
+     */
+    buildParameterizedQuery(sql, parameters, getPlaceholder = () => '?') {
+        let paramIndex = 0;
+        const processedSql = sql.replaceAll('?', () => {
+            paramIndex++;
+            return getPlaceholder(paramIndex);
+        });
+        return { sql: processedSql, parameters };
+    },
+});

package/src/orm/DatabaseAdapterRegistry.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseConfig, IDatabaseAdapter } from './DatabaseAdapter';
+export type AdapterFactory = (config: DatabaseConfig) => IDatabaseAdapter;
+declare function register(driver: DatabaseConfig['driver'], factory: AdapterFactory): void;
+declare function get(driver: DatabaseConfig['driver']): AdapterFactory | undefined;
+declare function has(driver: DatabaseConfig['driver']): boolean;
+declare function list(): Array<DatabaseConfig['driver']>;
+export declare const DatabaseAdapterRegistry: Readonly<{
+    register: typeof register;
+    get: typeof get;
+    has: typeof has;
+    list: typeof list;
+}>;
+export {};
+//# sourceMappingURL=DatabaseAdapterRegistry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseAdapterRegistry.d.ts","sourceRoot":"","sources":["../../../src/orm/DatabaseAdapterRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7E,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,cAAc,KAAK,gBAAgB,CAAC;AAc1E,iBAAS,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAEjF;AAED,iBAAS,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,cAAc,GAAG,SAAS,CAEzE;AAED,iBAAS,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,OAAO,CAEtD;AAED,iBAAS,IAAI,IAAI,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAE/C;AAED,eAAO,MAAM,uBAAuB;;;;;EAKlC,CAAC"}

package/src/orm/DatabaseAdapterRegistry.js

@@ -0,0 +1,21 @@
+const globalWithRegistry = globalThis;
+const registry = globalWithRegistry.__zintrust_db_adapter_registry__ ??
+    (globalWithRegistry.__zintrust_db_adapter_registry__ = new Map());
+function register(driver, factory) {
+    registry.set(driver, factory);
+}
+function get(driver) {
+    return registry.get(driver);
+}
+function has(driver) {
+    return registry.has(driver);
+}
+function list() {
+    return Array.from(registry.keys());
+}
+export const DatabaseAdapterRegistry = Object.freeze({
+    register,
+    get,
+    has,
+    list,
+});

package/src/orm/DatabaseRuntimeRegistration.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Runtime database registration
+ *
+ * Bridges config-layer database connection definitions into ORM connection
+ * instances that can be selected via `useDatabase(undefined, name)`.
+ */
+import type { DatabaseConfigShape } from '../config/type';
+/**
+ * Register all connections from runtime config.
+ *
+ * Behavior:
+ * - Every entry in `config.connections` is registered under its key.
+ * - The connection named by `config.default` is ALSO registered as 'default'
+ *   (so callers can keep using `useDatabase()` / models without explicit connection).
+ */
+export declare function registerDatabasesFromRuntimeConfig(config: DatabaseConfigShape): void;
+//# sourceMappingURL=DatabaseRuntimeRegistration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseRuntimeRegistration.d.ts","sourceRoot":"","sources":["../../../src/orm/DatabaseRuntimeRegistration.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,mBAAmB,EAGpB,MAAM,cAAc,CAAC;AAwDtB;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAWpF"}

package/src/orm/DatabaseRuntimeRegistration.js

@@ -0,0 +1,73 @@
+/**
+ * Runtime database registration
+ *
+ * Bridges config-layer database connection definitions into ORM connection
+ * instances that can be selected via `useDatabase(undefined, name)`.
+ */
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { useDatabase } from './Database.js';
+const toOrmConfig = (cfg) => {
+    switch (cfg.driver) {
+        case 'sqlite':
+            return { driver: 'sqlite', database: cfg.database };
+        case 'd1':
+            return { driver: 'd1' };
+        case 'd1-remote':
+            return { driver: 'd1-remote' };
+        case 'postgresql':
+            return {
+                driver: 'postgresql',
+                host: cfg.host,
+                port: cfg.port,
+                database: cfg.database,
+                username: cfg.username,
+                password: cfg.password,
+                readHosts: cfg.readHosts,
+            };
+        case 'mysql':
+            return {
+                driver: 'mysql',
+                host: cfg.host,
+                port: cfg.port,
+                database: cfg.database,
+                username: cfg.username,
+                password: cfg.password,
+                readHosts: cfg.readHosts,
+            };
+        case 'sqlserver':
+            return {
+                driver: 'sqlserver',
+                host: cfg.host,
+                port: cfg.port,
+                database: cfg.database,
+                username: cfg.username,
+                password: cfg.password,
+                readHosts: cfg.readHosts,
+            };
+        default:
+            // Exhaustive check (kept for future driver additions)
+            return cfg;
+    }
+};
+const registerConnections = (connections) => {
+    for (const [name, runtimeCfg] of Object.entries(connections)) {
+        // Register instance by name; a later call without config may now resolve.
+        useDatabase(toOrmConfig(runtimeCfg), name);
+    }
+};
+/**
+ * Register all connections from runtime config.
+ *
+ * Behavior:
+ * - Every entry in `config.connections` is registered under its key.
+ * - The connection named by `config.default` is ALSO registered as 'default'
+ *   (so callers can keep using `useDatabase()` / models without explicit connection).
+ */
+export function registerDatabasesFromRuntimeConfig(config) {
+    registerConnections(config.connections);
+    const defaultCfg = config.connections[config.default];
+    if (defaultCfg === undefined) {
+        throw ErrorFactory.createConfigError(`Database default connection not configured: ${String(config.default ?? '')}`);
+    }
+    useDatabase(toOrmConfig(defaultCfg), 'default');
+}