mysql-orm-lite 1.0.0 → 2.0.0

package/README.md

@@ -355,6 +355,7 @@ Build and execute a SELECT query.
 | `having` | string | HAVING clause |
 | `limit` | number | LIMIT value |
 | `offset` | number | OFFSET value |
+| `forUpdate` | boolean | Append FOR UPDATE for row-level locking (default: false) |
 
 ```javascript
 // Simple select
@@ -683,6 +684,7 @@ The `TransactionCRUD` class provides all CRUD methods available in the main API:
 | Method | Description |
 |--------|-------------|
 | `find(query, params?)` | Execute SELECT query |
+| `findForUpdate(options)` | Execute locked SELECT (FOR UPDATE) |
 | `insert(table, data)` | Insert record |
 | `update(table, data, whereClause)` | Update records |
 | `delete(whereClause, table)` | Delete records |
@@ -704,6 +706,7 @@ The `TransactionCRUD` class provides all CRUD methods available in the main API:
 | `updateQuery(options)` | `buildAndExecuteUpdateQuery` |
 | `deleteWhere(options)` | `buildAndExecuteDeleteQuery` |
 | `remove(options)` | `buildAndExecuteDeleteQuery` |
+| `findForUpdate(options)` | `buildAndExecuteSelectQuery` (with forUpdate: true) |
 
 #### Complete Transaction Example
 

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+import connectionManager from './lib/connectionManager';
+import TransactionCRUD from './lib/TransactionCRUD';
+import transactionManager from './lib/transactionManager';
+export { connectionManager, transactionManager, TransactionCRUD };
+export declare const find: (query: string, params?: any[], dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+export declare const findCount: (query: string, params?: any[], dbConfig?: import("./types").DbConfig) => Promise<number>;
+export declare const insert: (table: string, data: Record<string, any>, dbConfig?: import("./types").DbConfig, debug?: boolean, isIgnore?: boolean) => Promise<any>;
+export declare const update: (table: string, data: Record<string, any>, query: string, dbConfig?: import("./types").DbConfig, debug?: boolean) => Promise<number>;
+export declare const _delete: (query: string, table?: string, dbConfig?: import("./types").DbConfig) => Promise<number>;
+export { _delete as delete };
+export declare const buildAndExecuteSelectQuery: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+export declare const buildAndExecuteUpdateQuery: (options: import("./types").UpdateOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+export declare const buildAndExecuteDeleteQuery: (options: import("./types").DeleteOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+export declare const select: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+export declare const findWhere: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+export declare const query: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+export declare const updateWhere: (options: import("./types").UpdateOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+export declare const updateQuery: (options: import("./types").UpdateOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+export declare const deleteWhere: (options: import("./types").DeleteOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+export declare const remove: (options: import("./types").DeleteOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+export declare const utils: {
+    handleConnectionError(err: any): Error;
+    logQueryPerformance(query: string, startTime: number, params?: any[]): number;
+    executeQuery({ query, params, dbConfig, operation }: {
+        query: string;
+        params?: any[];
+        dbConfig?: import("./types").DbConfig;
+        operation?: string;
+    }): Promise<any>;
+    validateUpdateParams(table: string, data: Record<string, any>, query: string): string[];
+    prepareUpdateParams(data: Record<string, any>): {
+        setFields: string[];
+        params: any[];
+    };
+    _buildWhereClause(conditions: import("./types").WhereConditions): {
+        clause: string;
+        params: any[];
+    };
+    _buildSelectQuery(options: import("./types").SelectOptions): {
+        query: string;
+        params: any[];
+    };
+    _buildUpdateQuery(options: import("./types").UpdateOptions): {
+        query: string;
+        params: any[];
+    };
+    _buildDeleteQuery(options: import("./types").DeleteOptions): {
+        query: string;
+        params: any[];
+    };
+};
+export declare const createTransaction: () => TransactionCRUD;
+declare const _default: {
+    connectionManager: {
+        init: (config: import("./types").DbConfig, customLogger?: import("./types").Logger) => void;
+        setLogger: (customLogger: import("./types").Logger) => void;
+        getPool: (dbConfig?: import("./types").DbConfig) => Promise<import("mysql2/promise").Pool>;
+        closePool: (config: import("./types").DbConfig) => Promise<void>;
+        closeAllPools: () => Promise<void>;
+        getLogger: () => import("./types").Logger;
+    };
+    transactionManager: {
+        setInstance: (instance: TransactionCRUD) => void;
+        getInstance: () => TransactionCRUD | null;
+        clearInstance: () => void;
+        hasActiveTransaction: () => boolean;
+    };
+    TransactionCRUD: typeof TransactionCRUD;
+    find: (query: string, params?: any[], dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+    findCount: (query: string, params?: any[], dbConfig?: import("./types").DbConfig) => Promise<number>;
+    insert: (table: string, data: Record<string, any>, dbConfig?: import("./types").DbConfig, debug?: boolean, isIgnore?: boolean) => Promise<any>;
+    update: (table: string, data: Record<string, any>, query: string, dbConfig?: import("./types").DbConfig, debug?: boolean) => Promise<number>;
+    delete: (query: string, table?: string, dbConfig?: import("./types").DbConfig) => Promise<number>;
+    buildAndExecuteSelectQuery: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+    buildAndExecuteUpdateQuery: (options: import("./types").UpdateOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+    buildAndExecuteDeleteQuery: (options: import("./types").DeleteOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+    select: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+    findWhere: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+    query: (options: import("./types").SelectOptions, dbConfig?: import("./types").DbConfig) => Promise<any[]>;
+    updateWhere: (options: import("./types").UpdateOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+    updateQuery: (options: import("./types").UpdateOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+    deleteWhere: (options: import("./types").DeleteOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+    remove: (options: import("./types").DeleteOptions, dbConfig?: import("./types").DbConfig) => Promise<number>;
+    utils: {
+        handleConnectionError(err: any): Error;
+        logQueryPerformance(query: string, startTime: number, params?: any[]): number;
+        executeQuery({ query, params, dbConfig, operation }: {
+            query: string;
+            params?: any[];
+            dbConfig?: import("./types").DbConfig;
+            operation?: string;
+        }): Promise<any>;
+        validateUpdateParams(table: string, data: Record<string, any>, query: string): string[];
+        prepareUpdateParams(data: Record<string, any>): {
+            setFields: string[];
+            params: any[];
+        };
+        _buildWhereClause(conditions: import("./types").WhereConditions): {
+            clause: string;
+            params: any[];
+        };
+        _buildSelectQuery(options: import("./types").SelectOptions): {
+            query: string;
+            params: any[];
+        };
+        _buildUpdateQuery(options: import("./types").UpdateOptions): {
+            query: string;
+            params: any[];
+        };
+        _buildDeleteQuery(options: import("./types").DeleteOptions): {
+            query: string;
+            params: any[];
+        };
+    };
+    createTransaction: () => TransactionCRUD;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransaction = exports.utils = exports.remove = exports.deleteWhere = exports.updateQuery = exports.updateWhere = exports.query = exports.findWhere = exports.select = exports.buildAndExecuteDeleteQuery = exports.buildAndExecuteUpdateQuery = exports.buildAndExecuteSelectQuery = exports.delete = exports._delete = exports.update = exports.insert = exports.findCount = exports.find = exports.TransactionCRUD = exports.transactionManager = exports.connectionManager = void 0;
+const connectionManager_1 = __importDefault(require("./lib/connectionManager"));
+exports.connectionManager = connectionManager_1.default;
+const crud = __importStar(require("./lib/crud"));
+const TransactionCRUD_1 = __importDefault(require("./lib/TransactionCRUD"));
+exports.TransactionCRUD = TransactionCRUD_1.default;
+const transactionManager_1 = __importDefault(require("./lib/transactionManager"));
+exports.transactionManager = transactionManager_1.default;
+// CRUD Operations (Non-transactional)
+exports.find = crud.find;
+exports.findCount = crud.findCount;
+exports.insert = crud.insert;
+exports.update = crud.update;
+exports._delete = crud.delete;
+exports.delete = exports._delete;
+// Query Builder - Full names
+exports.buildAndExecuteSelectQuery = crud.buildAndExecuteSelectQuery;
+exports.buildAndExecuteUpdateQuery = crud.buildAndExecuteUpdateQuery;
+exports.buildAndExecuteDeleteQuery = crud.buildAndExecuteDeleteQuery;
+// Query Builder - Alternative shorter names
+exports.select = crud.select;
+exports.findWhere = crud.findWhere;
+exports.query = crud.query;
+exports.updateWhere = crud.updateWhere;
+exports.updateQuery = crud.updateQuery;
+exports.deleteWhere = crud.deleteWhere;
+exports.remove = crud.remove;
+// Utility exports
+exports.utils = crud.utils;
+// Convenience method to create transaction
+const createTransaction = () => new TransactionCRUD_1.default();
+exports.createTransaction = createTransaction;
+// Default export for CJS compatibility and convenience
+exports.default = {
+    connectionManager: connectionManager_1.default,
+    transactionManager: transactionManager_1.default,
+    TransactionCRUD: TransactionCRUD_1.default,
+    find: exports.find,
+    findCount: exports.findCount,
+    insert: exports.insert,
+    update: exports.update,
+    delete: exports._delete,
+    buildAndExecuteSelectQuery: exports.buildAndExecuteSelectQuery,
+    buildAndExecuteUpdateQuery: exports.buildAndExecuteUpdateQuery,
+    buildAndExecuteDeleteQuery: exports.buildAndExecuteDeleteQuery,
+    select: exports.select,
+    findWhere: exports.findWhere,
+    query: exports.query,
+    updateWhere: exports.updateWhere,
+    updateQuery: exports.updateQuery,
+    deleteWhere: exports.deleteWhere,
+    remove: exports.remove,
+    utils: exports.utils,
+    createTransaction: exports.createTransaction
+};

package/dist/lib/TransactionCRUD.d.ts

@@ -0,0 +1,42 @@
+import { DbConfig, SelectOptions, UpdateOptions, DeleteOptions } from '../types';
+declare class TransactionCRUD {
+    private connection;
+    private transactionActive;
+    debug: boolean;
+    constructor();
+    /**
+     * Initialize a transaction
+     * @param dbConfig - Database configuration (optional)
+     */
+    init(dbConfig?: DbConfig): Promise<any>;
+    /**
+     * Execute a query within the transaction
+     */
+    executeQuery(query: string, params?: any[], operation?: string): Promise<any>;
+    /**
+     * Commit the transaction
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollback the transaction
+     */
+    rollback(): Promise<void>;
+    private _cleanup;
+    find(query: string, params?: any[]): Promise<any[]>;
+    insert(table: string, data: Record<string, any>): Promise<any>;
+    update(table: string, data: Record<string, any>, query: string): Promise<number>;
+    delete(query: string, table?: string): Promise<number>;
+    buildAndExecuteSelectQuery(options: SelectOptions): Promise<any[]>;
+    buildAndExecuteUpdateQuery(options: UpdateOptions): Promise<number>;
+    buildAndExecuteDeleteQuery(options: DeleteOptions): Promise<number>;
+    select(options: SelectOptions): Promise<any[]>;
+    findWhere(options: SelectOptions): Promise<any[]>;
+    findForUpdate(options: SelectOptions): Promise<any[]>;
+    query(options: SelectOptions): Promise<any[]>;
+    updateWhere(options: UpdateOptions): Promise<number>;
+    updateQuery(options: UpdateOptions): Promise<number>;
+    deleteWhere(options: DeleteOptions): Promise<number>;
+    remove(options: DeleteOptions): Promise<number>;
+}
+export default TransactionCRUD;
+export { TransactionCRUD };

package/dist/lib/TransactionCRUD.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionCRUD = void 0;
+const connectionManager_1 = __importDefault(require("./connectionManager"));
+const crud_1 = require("./crud");
+class TransactionCRUD {
+    connection = null;
+    transactionActive = false;
+    debug = false;
+    constructor() {
+        this.connection = null;
+        this.transactionActive = false;
+        this.debug = false;
+    }
+    /**
+     * Initialize a transaction
+     * @param dbConfig - Database configuration (optional)
+     */
+    async init(dbConfig) {
+        const logger = connectionManager_1.default.getLogger();
+        try {
+            const pool = await connectionManager_1.default.getPool(dbConfig);
+            this.connection = await pool.getConnection();
+            await this.connection.beginTransaction();
+            this.transactionActive = true;
+            logger.info('Transaction initialized successfully');
+            return this.connection;
+        }
+        catch (error) {
+            logger.error('Failed to initialize transaction:', error);
+            if (this.connection) {
+                this.connection.release();
+                this.connection = null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Execute a query within the transaction
+     */
+    async executeQuery(query, params = [], operation = 'TRANS_QUERY') {
+        if (!this.connection || !this.transactionActive) {
+            throw new Error('No active transaction. Call init() first.');
+        }
+        const logger = connectionManager_1.default.getLogger();
+        const startTime = Date.now();
+        try {
+            const [results] = await this.connection.query(query, params);
+            const duration = Date.now() - startTime;
+            if (duration > 1000) {
+                logger.warn(`[TRANS] Slow Query (${duration}ms): ${query}`);
+            }
+            return results;
+        }
+        catch (error) {
+            logger.error(`${operation} Failed: ${error.message}`);
+            logger.error(`Query: ${query}`);
+            throw error;
+        }
+    }
+    /**
+     * Commit the transaction
+     */
+    async commit() {
+        if (!this.connection || !this.transactionActive) {
+            throw new Error('No active transaction to commit');
+        }
+        const logger = connectionManager_1.default.getLogger();
+        try {
+            await this.connection.commit();
+            logger.info('Transaction committed');
+        }
+        catch (error) {
+            logger.error('Commit failed, rolling back...', error);
+            await this.rollback();
+            throw error;
+        }
+        finally {
+            this._cleanup();
+        }
+    }
+    /**
+     * Rollback the transaction
+     */
+    async rollback() {
+        if (!this.connection)
+            return;
+        const logger = connectionManager_1.default.getLogger();
+        try {
+            await this.connection.rollback();
+            logger.info('Transaction rolled back');
+        }
+        catch (error) {
+            logger.error('Rollback failed:', error);
+        }
+        finally {
+            this._cleanup();
+        }
+    }
+    _cleanup() {
+        if (this.connection) {
+            this.connection.release();
+            this.connection = null;
+        }
+        this.transactionActive = false;
+    }
+    // CRUD Methods
+    async find(query, params = []) {
+        return await this.executeQuery(query, params, 'TRANS_FIND');
+    }
+    async insert(table, data) {
+        if (!table || !data)
+            throw new Error('Invalid table or data');
+        const fields = Object.keys(data);
+        const values = Object.values(data);
+        const placeholders = fields.map(() => '?').join(', ');
+        const sql = `INSERT INTO ${table} (${fields.join(', ')}) VALUES (${placeholders})`;
+        const result = await this.executeQuery(sql, values, 'TRANS_INSERT');
+        return result.insertId;
+    }
+    async update(table, data, query) {
+        if (!query || !query.toLowerCase().includes('where'))
+            throw new Error('Update requires WHERE');
+        const { setFields, params } = crud_1.utils.prepareUpdateParams(data);
+        const sql = `UPDATE ${table} SET ${setFields.join(', ')} ${query}`;
+        const result = await this.executeQuery(sql, params, 'TRANS_UPDATE');
+        return result.affectedRows;
+    }
+    async delete(query, table) {
+        if (!query || !query.toLowerCase().includes('where'))
+            throw new Error('Delete requires WHERE');
+        const sql = table ? `DELETE FROM ${table} ${query}` : query;
+        const result = await this.executeQuery(sql, [], 'TRANS_DELETE');
+        return result.affectedRows;
+    }
+    async buildAndExecuteSelectQuery(options) {
+        const logger = connectionManager_1.default.getLogger();
+        try {
+            const { query, params } = crud_1.utils._buildSelectQuery(options);
+            return await this.executeQuery(query, params, 'TRANS_BUILD_SELECT');
+        }
+        catch (err) {
+            logger.error('buildAndExecuteSelectQuery failed:', err);
+            throw err;
+        }
+    }
+    async buildAndExecuteUpdateQuery(options) {
+        const logger = connectionManager_1.default.getLogger();
+        try {
+            const { query, params } = crud_1.utils._buildUpdateQuery(options);
+            const result = await this.executeQuery(query, params, 'TRANS_BUILD_UPDATE');
+            return result.affectedRows;
+        }
+        catch (err) {
+            logger.error('buildAndExecuteUpdateQuery failed:', err);
+            throw err;
+        }
+    }
+    async buildAndExecuteDeleteQuery(options) {
+        const logger = connectionManager_1.default.getLogger();
+        try {
+            const { query, params } = crud_1.utils._buildDeleteQuery(options);
+            const result = await this.executeQuery(query, params, 'TRANS_BUILD_DELETE');
+            return result.affectedRows;
+        }
+        catch (err) {
+            logger.error('buildAndExecuteDeleteQuery failed:', err);
+            throw err;
+        }
+    }
+    // Alternative shorter method names (aliases)
+    async select(options) {
+        return this.buildAndExecuteSelectQuery(options);
+    }
+    async findWhere(options) {
+        return this.buildAndExecuteSelectQuery(options);
+    }
+    async findForUpdate(options) {
+        options.forUpdate = true;
+        return this.buildAndExecuteSelectQuery(options);
+    }
+    async query(options) {
+        return this.buildAndExecuteSelectQuery(options);
+    }
+    async updateWhere(options) {
+        return this.buildAndExecuteUpdateQuery(options);
+    }
+    async updateQuery(options) {
+        return this.buildAndExecuteUpdateQuery(options);
+    }
+    async deleteWhere(options) {
+        return this.buildAndExecuteDeleteQuery(options);
+    }
+    async remove(options) {
+        return this.buildAndExecuteDeleteQuery(options);
+    }
+}
+exports.TransactionCRUD = TransactionCRUD;
+exports.default = TransactionCRUD;

package/dist/lib/connectionManager.d.ts

@@ -0,0 +1,36 @@
+import * as mysql from 'mysql2/promise';
+import { DbConfig, Logger } from '../types';
+declare const connectionManager: {
+    /**
+     * Initialize with default config and optional logger
+     * @param config - Database configuration
+     * @param customLogger - Custom logger (optional)
+     */
+    init: (config: DbConfig, customLogger?: Logger) => void;
+    /**
+     * Set custom logger
+     * @param customLogger - Logger with info, error, warn methods
+     */
+    setLogger: (customLogger: Logger) => void;
+    /**
+     * Get or create a connection pool
+     * @param dbConfig - Database configuration (optional)
+     * @returns MySQL connection pool
+     */
+    getPool: (dbConfig?: DbConfig) => Promise<mysql.Pool>;
+    /**
+     * Close a specific pool
+     * @param config - Database configuration
+     */
+    closePool: (config: DbConfig) => Promise<void>;
+    /**
+     * Close all pools (call on application shutdown)
+     */
+    closeAllPools: () => Promise<void>;
+    /**
+     * Get logger instance
+     */
+    getLogger: () => Logger;
+};
+export default connectionManager;
+export { connectionManager };

package/dist/lib/connectionManager.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionManager = void 0;
+const mysql = __importStar(require("mysql2/promise"));
+// Default logger
+const defaultLogger = {
+    info: (...args) => console.log('[INFO]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args),
+    warn: (...args) => console.warn('[WARN]', ...args)
+};
+const pools = new Map();
+let logger = defaultLogger;
+let defaultConfig = null;
+const getPoolKey = (config) => {
+    return `${config.host}:${config.port || 3306}:${config.user}:${config.database}`;
+};
+const connectionManager = {
+    /**
+     * Initialize with default config and optional logger
+     * @param config - Database configuration
+     * @param customLogger - Custom logger (optional)
+     */
+    init: (config, customLogger) => {
+        if (!config || !config.database) {
+            throw new Error('Valid database configuration required');
+        }
+        defaultConfig = config;
+        if (customLogger) {
+            logger = customLogger;
+        }
+        logger.info('Connection manager initialized');
+    },
+    /**
+     * Set custom logger
+     * @param customLogger - Logger with info, error, warn methods
+     */
+    setLogger: (customLogger) => {
+        logger = customLogger;
+    },
+    /**
+     * Get or create a connection pool
+     * @param dbConfig - Database configuration (optional)
+     * @returns MySQL connection pool
+     */
+    getPool: async (dbConfig) => {
+        const conf = dbConfig || defaultConfig;
+        if (!conf || !conf.database) {
+            throw new Error('Database configuration missing. Call connectionManager.init() first or provide dbConfig');
+        }
+        const key = getPoolKey(conf);
+        if (pools.has(key)) {
+            return pools.get(key);
+        }
+        try {
+            logger.info(`Creating new connection pool for ${key}`);
+            const pool = mysql.createPool({
+                host: conf.host,
+                user: conf.user,
+                password: conf.password,
+                database: conf.database,
+                port: conf.port || 3306,
+                waitForConnections: true,
+                connectionLimit: conf.connectionLimit || 10,
+                queueLimit: 0,
+                enableKeepAlive: true,
+                keepAliveInitialDelay: 0
+            });
+            pools.set(key, pool);
+            return pool;
+        }
+        catch (error) {
+            logger.error('Failed to create connection pool:', error);
+            throw error;
+        }
+    },
+    /**
+     * Close a specific pool
+     * @param config - Database configuration
+     */
+    closePool: async (config) => {
+        const key = getPoolKey(config);
+        if (pools.has(key)) {
+            const pool = pools.get(key);
+            await pool.end();
+            pools.delete(key);
+            logger.info(`Closed connection pool for ${key}`);
+        }
+    },
+    /**
+     * Close all pools (call on application shutdown)
+     */
+    closeAllPools: async () => {
+        for (const [key, pool] of pools.entries()) {
+            try {
+                await pool.end();
+                logger.info(`Closed connection pool for ${key}`);
+            }
+            catch (error) {
+                logger.error(`Error closing pool ${key}:`, error);
+            }
+        }
+        pools.clear();
+    },
+    /**
+     * Get logger instance
+     */
+    getLogger: () => logger
+};
+exports.connectionManager = connectionManager;
+exports.default = connectionManager;