@zintrust/core 0.1.0

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

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

package/src/orm/ConnectionManager.js

@@ -0,0 +1,401 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * Persistent Connection Manager for Zintrust Framework
+ * Handles database connections across different runtime environments
+ * Supports: PostgreSQL, MySQL, SQL Server with connection pooling for Lambda
+ */
+import { Env } from '../config/env';
+import { Logger } from '../config/logger';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+let instance;
+/**
+ * Close a specific connection
+ */
+const closeConnection = async (conn) => {
+    if (conn !== undefined &&
+        conn !== null &&
+        typeof conn === 'object' &&
+        'close' in conn &&
+        typeof conn.close === 'function') {
+        await conn.close();
+    }
+};
+/**
+ * Test if connection is still alive
+ */
+const testConnection = async (config, _conn) => {
+    try {
+        if (config.adapter === 'postgresql' || config.adapter === 'mysql') {
+            // SELECT 1 for PostgreSQL/MySQL
+            await new Promise((resolve, reject) => {
+                const timeout = globalThis.setTimeout(() => reject(ErrorFactory.createConnectionError('Connection test timeout')), 5000);
+                try {
+                    // In real implementation, query the connection
+                    resolve(true);
+                }
+                finally {
+                    clearTimeout(timeout);
+                }
+            });
+        }
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createConnectionError('Connection test failed:', error);
+        return false;
+    }
+};
+/**
+ * Update connection usage metrics
+ */
+const updateConnectionUsage = (connectionPool, id) => {
+    const entry = connectionPool.find((c) => c.id === id);
+    if (entry !== undefined) {
+        entry.lastUsedAt = Date.now();
+        entry.queryCount++;
+        entry.isActive = true;
+    }
+};
+/**
+ * Create new database connection
+ */
+const createConnection = async (config, id) => {
+    Logger.info(`Creating ${config.adapter} connection (${id}) to ${config.host}:${config.port}`);
+    // Connection creation would be adapter-specific
+    // This is a placeholder for the actual implementation
+    return {
+        id,
+        adapter: config.adapter,
+        query: async (_sql, _params) => {
+            throw ErrorFactory.createDatabaseError(`Query execution not implemented for ${config.adapter}`);
+        },
+        close: async () => {
+            Logger.info(`Connection ${id} closed`);
+        },
+    };
+};
+/**
+ * Create Aurora Data API connection
+ */
+const createAuroraDataApiConnection = () => ({
+    execute: async (_sql, _params) => {
+        // Call Aurora Data API via AWS SDK
+        // Requires proper IAM permissions
+        throw ErrorFactory.createConfigError('Aurora Data API not implemented yet');
+    },
+    batch: async (_statements) => {
+        // Execute batch statements
+        throw ErrorFactory.createConfigError('Aurora Data API batch not implemented yet');
+    },
+});
+/**
+ * Get healthy existing connection if available
+ */
+const getHealthyExistingConnection = async (config, state, id) => {
+    if (!state.connections.has(id))
+        return null;
+    const conn = state.connections.get(id);
+    if (conn !== undefined && conn !== null && (await testConnection(config, conn))) {
+        updateConnectionUsage(state.connectionPool, id);
+        return conn;
+    }
+    state.connections.delete(id);
+    state.connectionPool = state.connectionPool.filter((c) => c.id !== id);
+    return null;
+};
+/**
+ * Find an idle connection in the pool
+ */
+const findIdleConnection = (state) => {
+    const idleConnections = state.connectionPool.filter((c) => !c.isActive);
+    if (idleConnections.length === 0)
+        return null;
+    const lru = idleConnections.reduce((prev, current) => (prev.lastUsedAt < current.lastUsedAt ? prev : current), idleConnections[0]);
+    updateConnectionUsage(state.connectionPool, lru.id);
+    return state.connections.get(lru.id);
+};
+/**
+ * Wait for a connection to become available
+ */
+const waitForIdleConnection = async (state) => {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timeoutId;
+        const checkInterval = setInterval(() => {
+            const idle = state.connectionPool.find((c) => !c.isActive);
+            if (idle !== undefined) {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                updateConnectionUsage(state.connectionPool, idle.id);
+                resolve(state.connections.get(idle.id));
+            }
+        }, 100);
+        const cleanup = () => {
+            clearInterval(checkInterval);
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+                timeoutId = undefined;
+            }
+        };
+        // Node: allow process to exit; other runtimes may not support unref()
+        if (isUnrefableTimer(checkInterval)) {
+            checkInterval.unref();
+        }
+        // eslint-disable-next-line no-restricted-syntax
+        timeoutId = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(ErrorFactory.createConnectionError('Connection pool exhausted - timeout waiting for available connection'));
+        }, 30000);
+        if (isUnrefableTimer(timeoutId)) {
+            timeoutId.unref();
+        }
+    });
+};
+function isUnrefableTimer(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return 'unref' in value && typeof value.unref === 'function';
+}
+/**
+ * Get or reuse a connection when at max capacity
+ */
+const getOrReuseConnection = async (state) => {
+    const idle = findIdleConnection(state);
+    if (idle !== null)
+        return idle;
+    return waitForIdleConnection(state);
+};
+/**
+ * Periodically clean up idle connections
+ */
+const startIdleConnectionCleanup = (state, idleTimeout) => {
+    if (state.cleanupInterval) {
+        clearInterval(state.cleanupInterval);
+    }
+    state.cleanupInterval = setInterval(() => {
+        const now = Date.now();
+        const toRemove = [];
+        for (const poolEntry of state.connectionPool) {
+            if (!poolEntry.isActive && now - poolEntry.lastUsedAt > idleTimeout) {
+                toRemove.push(poolEntry.id);
+            }
+        }
+        for (const id of toRemove) {
+            const conn = state.connections.get(id);
+            closeConnection(conn).catch((err) => Logger.error(`Failed to close idle connection ${id}:`, err));
+            state.connections.delete(id);
+            state.connectionPool = state.connectionPool.filter((c) => c.id !== id);
+            Logger.info(`Removed idle connection: ${id}`);
+        }
+    }, 300000); // Every 5 minutes
+};
+/**
+ * Create and register a new connection
+ */
+const createNewConnection = async (config, state, id) => {
+    const connection = await createConnection(config, id);
+    state.connections.set(id, connection);
+    state.connectionPool.push({
+        id,
+        adapter: config.adapter,
+        createdAt: Date.now(),
+        lastUsedAt: Date.now(),
+        isActive: true,
+        queryCount: 0,
+    });
+    return connection;
+};
+/**
+ * Close all connections (graceful shutdown)
+ */
+const closeAllConnections = async (state) => {
+    if (state.cleanupInterval) {
+        clearInterval(state.cleanupInterval);
+        state.cleanupInterval = undefined;
+    }
+    for (const [id, conn] of state.connections.entries()) {
+        try {
+            await closeConnection(conn);
+        }
+        catch (error) {
+            ErrorFactory.createConnectionError(`Failed to close connection ${id}:`, error);
+        }
+    }
+    state.connections.clear();
+    state.connectionPool = [];
+};
+/**
+ * Get connection pool statistics
+ */
+const getPoolStatistics = (state) => {
+    const active = state.connectionPool.filter((c) => c.isActive).length;
+    const idle = state.connectionPool.filter((c) => !c.isActive).length;
+    return {
+        total: state.connectionPool.length,
+        active,
+        idle,
+        queued: 0,
+    };
+};
+/**
+ * ConnectionManager implementation
+ * Refactored to Functional Object pattern
+ */
+const ConnectionManagerImpl = {
+    /**
+     * Create a new connection manager instance
+     */
+    create(config) {
+        const state = {
+            connections: new Map(),
+            connectionPool: [],
+        };
+        const maxConnections = config.maxConnections ?? 10;
+        const idleTimeout = config.idleTimeout ?? 900000; // 15 minutes
+        // Cleanup idle connections every 5 minutes
+        startIdleConnectionCleanup(state, idleTimeout);
+        return {
+            /**
+             * Get or create database connection
+             */
+            async getConnection(id = 'default') {
+                const existing = await getHealthyExistingConnection(config, state, id);
+                if (existing !== null)
+                    return existing;
+                if (state.connectionPool.length < maxConnections) {
+                    return createNewConnection(config, state, id);
+                }
+                return getOrReuseConnection(state);
+            },
+            /**
+             * Release connection back to pool (but keep persistent)
+             */
+            async releaseConnection(connectionId = 'default') {
+                const poolEntry = state.connectionPool.find((c) => c.id === connectionId);
+                if (poolEntry !== undefined) {
+                    poolEntry.isActive = false;
+                    poolEntry.lastUsedAt = Date.now();
+                }
+            },
+            /**
+             * Close all connections (graceful shutdown)
+             */
+            async closeAll() {
+                return closeAllConnections(state);
+            },
+            /**
+             * Get connection pool statistics
+             */
+            getPoolStats() {
+                return getPoolStatistics(state);
+            },
+            /**
+             * Enable RDS Proxy for connection pooling
+             */
+            async enableRdsProxy(endpoint) {
+                config.enableRdsProxy = true;
+                config.rdsProxyEndpoint = endpoint;
+                config.host = endpoint;
+                Logger.info(`RDS Proxy enabled: ${endpoint}`);
+            },
+            /**
+             * Use Aurora Data API for serverless queries (no persistent connection)
+             */
+            async getAuroraDataApiConnection() {
+                return createAuroraDataApiConnection();
+            },
+        };
+    },
+};
+/**
+ * Manages database connections across Lambda warm invocations
+ * Reuses connections to reduce cold start impact and connection overhead
+ * Sealed namespace object following Pattern 2
+ *
+ * @see FRAMEWORK_REFACTOR_FUNCTION_PATTERN.md for Pattern 2 details
+ */
+export const ConnectionManager = Object.freeze({
+    /**
+     * Get or create singleton instance
+     */
+    getInstance(config) {
+        if (instance === undefined && config !== undefined) {
+            instance = ConnectionManagerImpl.create(config);
+        }
+        if (instance === undefined) {
+            throw ErrorFactory.createConfigError('ConnectionManager not initialized. Call getInstance(config) first.');
+        }
+        return instance;
+    },
+    /**
+     * Get or create database connection
+     */
+    async getConnection(id = 'default') {
+        return this.getInstance().getConnection(id);
+    },
+    /**
+     * Release connection back to pool (but keep persistent)
+     */
+    async releaseConnection(connectionId = 'default') {
+        return this.getInstance().releaseConnection(connectionId);
+    },
+    /**
+     * Close all connections (graceful shutdown)
+     */
+    async closeAll() {
+        return this.getInstance().closeAll();
+    },
+    /**
+     * Get connection pool statistics
+     */
+    getPoolStats() {
+        return this.getInstance().getPoolStats();
+    },
+    /**
+     * Enable RDS Proxy for connection pooling
+     */
+    async enableRdsProxy(endpoint) {
+        return this.getInstance().enableRdsProxy(endpoint);
+    },
+    /**
+     * Use Aurora Data API for serverless queries (no persistent connection)
+     */
+    async getAuroraDataApiConnection() {
+        return this.getInstance().getAuroraDataApiConnection();
+    },
+});
+/**
+ * Get database credentials from AWS Secrets Manager
+ */
+export async function getDatabaseSecret(_secretName) {
+    // Would use AWS SDK to fetch from Secrets Manager
+    throw ErrorFactory.createConfigError('Secrets Manager integration not implemented');
+}
+/**
+ * Get database credentials from environment variables
+ */
+export function getDatabaseCredentialsFromEnv() {
+    return {
+        username: Env.DB_USERNAME,
+        password: Env.DB_PASSWORD,
+        host: Env.DB_HOST,
+        port: Env.DB_PORT,
+        database: Env.DB_DATABASE,
+    };
+}
+/**
+ * Secrets Manager for retrieving database credentials securely
+ * Sealed namespace object following Pattern 2
+ *
+ * @see FRAMEWORK_REFACTOR_FUNCTION_PATTERN.md for Pattern 2 details
+ */
+export const SecretsHelper = Object.freeze({
+    getDatabaseSecret,
+    getDatabaseCredentialsFromEnv,
+});

package/src/orm/Database.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Database Manager
+ * Central database connection management and query execution
+ */
+import { DatabaseConfig, IDatabaseAdapter } from './DatabaseAdapter';
+import { IQueryBuilder } from './QueryBuilder';
+export interface IDatabase {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    query(sql: string, parameters?: unknown[], isRead?: boolean): Promise<unknown[]>;
+    queryOne(sql: string, parameters?: unknown[], isRead?: boolean): Promise<unknown>;
+    transaction<T>(callback: (db: IDatabase) => Promise<T>): Promise<T>;
+    table(name: string): IQueryBuilder;
+    onBeforeQuery(handler: (query: string, params: unknown[]) => void): void;
+    onAfterQuery(handler: (query: string, params: unknown[], duration: number) => void): void;
+    offBeforeQuery(handler: (query: string, params: unknown[]) => void): void;
+    offAfterQuery(handler: (query: string, params: unknown[], duration: number) => void): void;
+    getAdapterInstance(isRead?: boolean): IDatabaseAdapter;
+    getType(): string;
+    getConfig(): DatabaseConfig;
+}
+export declare const Database: Readonly<{
+    /**
+     * Create a new database instance
+     */
+    create(config?: DatabaseConfig): IDatabase;
+}>;
+export declare function useDatabase(config?: DatabaseConfig, connection?: string): IDatabase;
+export declare function resetDatabase(): Promise<void>;
+//# sourceMappingURL=Database.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Database.d.ts","sourceRoot":"","sources":["../../../src/orm/Database.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAgB,MAAM,mBAAmB,CAAC;AAEhE,MAAM,WAAW,SAAS;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,WAAW,IAAI,OAAO,CAAC;IACvB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACjF,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClF,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACpE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC;IACnC,aAAa,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IACzE,YAAY,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1F,cAAc,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1E,aAAa,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC3F,kBAAkB,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;IACvD,OAAO,IAAI,MAAM,CAAC;IAClB,SAAS,IAAI,cAAc,CAAC;CAC7B;AA6ED,eAAO,MAAM,QAAQ;IACnB;;OAEG;oBACa,cAAc,GAAG,SAAS;EAwE1C,CAAC;AAIH,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,UAAU,SAAY,GAAG,SAAS,CAStF;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAUnD"}

package/src/orm/Database.js

@@ -0,0 +1,163 @@
+/**
+ * Database Manager
+ * Central database connection management and query execution
+ */
+import { ErrorFactory } from '../exceptions/ZintrustError';
+import { EventEmitter } from '../node-singletons/events';
+import { D1Adapter } from './adapters/D1Adapter';
+import { MySQLAdapter } from './adapters/MySQLAdapter';
+import { PostgreSQLAdapter } from './adapters/PostgreSQLAdapter';
+import { SQLiteAdapter } from './adapters/SQLiteAdapter';
+import { SQLServerAdapter } from './adapters/SQLServerAdapter';
+import { QueryBuilder } from './QueryBuilder';
+/**
+ * Database Manager
+ * Refactored to Functional Object pattern
+ */
+/**
+ * Create appropriate adapter based on driver
+ */
+const createAdapter = (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 '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 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;
+};
+export const Database = Object.freeze({
+    /**
+     * Create a new database instance
+     */
+    create(config) {
+        const dbConfig = config ?? { driver: 'sqlite', database: ':memory:' };
+        const eventEmitter = new EventEmitter();
+        let connected = false;
+        let readIndex = 0;
+        const { writeAdapter, readAdapters } = initializeAdapters(dbConfig);
+        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 db = {
+            async connect() {
+                await writeAdapter.connect();
+                await Promise.all(readAdapters
+                    .filter((adapter) => adapter !== writeAdapter)
+                    .map(async (adapter) => adapter.connect()));
+                connected = true;
+            },
+            async disconnect() {
+                await writeAdapter.disconnect();
+                await Promise.all(readAdapters
+                    .filter((adapter) => adapter !== writeAdapter)
+                    .map(async (adapter) => adapter.disconnect()));
+                connected = false;
+            },
+            isConnected() {
+                return connected;
+            },
+            async query(sql, parameters = [], isRead = false) {
+                if (connected === false)
+                    throw ErrorFactory.createConnectionError('Database not connected. Call connect() first.');
+                return executeQuery(getAdapter(isRead), eventEmitter, sql, parameters, 'query');
+            },
+            async queryOne(sql, parameters = [], isRead = false) {
+                if (connected === false)
+                    throw ErrorFactory.createConnectionError('Database not connected. Call connect() first.');
+                return executeQueryOne(getAdapter(isRead), eventEmitter, sql, parameters);
+            },
+            async transaction(callback) {
+                return writeAdapter.transaction(async () => callback(db));
+            },
+            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 };
+            },
+        };
+        return db;
+    },
+});
+const databaseInstances = new Map();
+export function useDatabase(config, connection = 'default') {
+    if (databaseInstances.has(connection) === false) {
+        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();
+        }
+        catch {
+            // Ignore errors during disconnect
+        }
+    });
+    await Promise.all(promises);
+    databaseInstances.clear();
+}