mysql-orm-lite 1.0.0

package/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const connectionManager = require('./lib/connectionManager');
+const crud = require('./lib/crud');
+const TransactionCRUD = require('./lib/TransactionCRUD');
+const transactionManager = require('./lib/transactionManager');
+
+module.exports = {
+    // Connection Management
+    connectionManager,
+
+    // CRUD Operations (Non-transactional)
+    find: crud.find,
+    findCount: crud.findCount,
+    insert: crud.insert,
+    update: crud.update,
+    delete: crud.delete,
+
+    // Query Builder - Full names
+    buildAndExecuteSelectQuery: crud.buildAndExecuteSelectQuery,
+    buildAndExecuteUpdateQuery: crud.buildAndExecuteUpdateQuery,
+    buildAndExecuteDeleteQuery: crud.buildAndExecuteDeleteQuery,
+
+    // Query Builder - Alternative shorter names
+    select: crud.select,
+    findWhere: crud.findWhere,
+    query: crud.query,
+    updateWhere: crud.updateWhere,
+    updateQuery: crud.updateQuery,
+    deleteWhere: crud.deleteWhere,
+    remove: crud.remove,
+
+    // Transaction Support
+    TransactionCRUD,
+    transactionManager,
+
+    // Utility exports
+    utils: crud.utils,
+
+    // Convenience method to create transaction
+    createTransaction: () => new TransactionCRUD()
+};

package/lib/TransactionCRUD.js

@@ -0,0 +1,208 @@
+'use strict';
+const connectionManager = require('./connectionManager');
+const crudUtils = require('./crud').utils;
+
+class TransactionCRUD {
+    constructor() {
+        this.connection = null;
+        this.transactionActive = false;
+        this.debug = false;
+    }
+
+    /**
+     * Initialize a transaction
+     * @param {Object} dbConfig - Database configuration (optional)
+     */
+    async init(dbConfig) {
+        const logger = connectionManager.getLogger();
+        try {
+            const pool = await connectionManager.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.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.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.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 } = crudUtils.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.getLogger();
+        try {
+            const { query, params } = crudUtils._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.getLogger();
+        try {
+            const { query, params } = crudUtils._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.getLogger();
+        try {
+            const { query, params } = crudUtils._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 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);
+    }
+}
+
+module.exports = TransactionCRUD;

package/lib/connectionManager.js

@@ -0,0 +1,117 @@
+'use strict';
+const mysql = 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 {Object} config - Database configuration
+     * @param {Object} 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 {Object} customLogger - Logger with info, error, warn methods
+     */
+    setLogger: (customLogger) => {
+        logger = customLogger;
+    },
+
+    /**
+     * Get or create a connection pool
+     * @param {Object} dbConfig - Database configuration (optional)
+     * @returns {Promise<Pool>} 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 {Object} 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
+};
+
+module.exports = connectionManager;

package/lib/crud.js

@@ -0,0 +1,301 @@
+'use strict';
+const connectionManager = require('./connectionManager');
+
+const utils = {
+    handleConnectionError(err) {
+        const errorMessages = {
+            PROTOCOL_CONNECTION_LOST: 'Database connection was closed.',
+            ER_CON_COUNT_ERROR: 'Database has too many connections.',
+            ECONNREFUSED: 'Database connection was refused.',
+            POOL_CLOSED: 'Connection pool was closed'
+        };
+        return new Error(errorMessages[err.code] || err.message);
+    },
+
+    logQueryPerformance(query, startTime, params = []) {
+        const logger = connectionManager.getLogger();
+        const duration = Date.now() - startTime;
+        if (duration > 1000) {
+            logger.warn(' Slow Query ================================================================== ');
+            logger.warn(` Execution Time: ${duration}ms`);
+            logger.warn(` Query: ${query}`);
+            if (params.length) logger.warn(` Parameters: ${JSON.stringify(params)}`);
+            logger.warn(' =========================================================================== ');
+        }
+        return duration;
+    },
+
+    async executeQuery({ query, params = [], dbConfig, operation = 'query' }) {
+        const startTime = Date.now();
+        const logger = connectionManager.getLogger();
+
+        try {
+            const pool = await connectionManager.getPool(dbConfig);
+            const [results] = await pool.query(query, params);
+            this.logQueryPerformance(query, startTime, params);
+            return results;
+        } catch (error) {
+            logger.error(`${operation} Error: ${error.message}`);
+            logger.error(`Query: ${query}`);
+            if (params.length) logger.error('Parameters:', JSON.stringify(params));
+            throw error;
+        }
+    },
+
+    validateUpdateParams(table, data, query) {
+        const errors = [];
+        if (!table || typeof table !== 'string') errors.push('Invalid table name');
+        else if (!/^[a-zA-Z0-9_]+$/.test(table)) errors.push('Table name contains invalid characters');
+
+        if (!data || typeof data !== 'object' || Array.isArray(data)) errors.push('Data must be a non-null object');
+        else if (Object.keys(data).length === 0) errors.push('Data object cannot be empty');
+
+        if (!query || typeof query !== 'string') errors.push('Invalid WHERE clause');
+        else if (!query.toLowerCase().includes('where')) errors.push('WHERE clause is required for security');
+
+        return errors;
+    },
+
+    prepareUpdateParams(data) {
+        const setFields = [];
+        const params = [];
+
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined) continue;
+
+            if (value && typeof value === 'object' && value.__raw) {
+                setFields.push(`${key} = ${value.value}`);
+                continue;
+            }
+
+            if (value === null) {
+                setFields.push(`${key} = NULL`);
+            } else {
+                setFields.push(`${key} = ?`);
+                params.push(value);
+            }
+        }
+
+        return { setFields, params };
+    },
+
+    _buildWhereClause(conditions) {
+        const params = [];
+        const buildCondition = (key, value) => {
+            const column = key;
+            if (value === null) return `${column} IS NULL`;
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                return Object.entries(value).map(([op, val]) => {
+                    switch (op) {
+                        case '$eq': params.push(val); return `${column} = ?`;
+                        case '$ne': params.push(val); return `${column} != ?`;
+                        case '$gt': params.push(val); return `${column} > ?`;
+                        case '$gte': params.push(val); return `${column} >= ?`;
+                        case '$lt': params.push(val); return `${column} < ?`;
+                        case '$lte': params.push(val); return `${column} <= ?`;
+                        case '$in':
+                            if (!val.length) return 'FALSE';
+                            params.push(...val);
+                            return `${column} IN (${val.map(() => '?').join(', ')})`;
+                        case '$notIn':
+                        case '$nIn':
+                        case '$nin':
+                            if (!val.length) return 'TRUE';
+                            params.push(...val);
+                            return `${column} NOT IN (${val.map(() => '?').join(', ')})`;
+                        case '$like':
+                            params.push(val); return `${column} LIKE ?`;
+                        case '$between':
+                            if (val.length !== 2) throw new Error('$between requires [min, max]');
+                            params.push(val[0], val[1]);
+                            return `${column} BETWEEN ? AND ?`;
+                        default: throw new Error(`Unsupported operator: ${op}`);
+                    }
+                }).join(' AND ');
+            }
+            params.push(value);
+            return `${column} = ?`;
+        };
+
+        const walk = (cond) => {
+            if (!cond || typeof cond !== 'object') return '';
+            if (Array.isArray(cond)) return cond.map(walk).join(' AND ');
+
+            if ('$and' in cond) return `(${cond.$and.map(walk).join(' AND ')})`;
+            if ('$or' in cond) return `(${cond.$or.map(walk).join(' OR ')})`;
+            if ('$not' in cond) return `(NOT ${walk(cond.$not)})`;
+
+            return Object.entries(cond).map(([k, v]) => buildCondition(k, v)).join(' AND ');
+        };
+
+        const clause = walk(conditions);
+        return { clause, params };
+    },
+
+    _buildSelectQuery(options) {
+        let { table, fields = '*', joins = [], where, orderBy, limit, offset, groupBy, having, alias } = options;
+
+        if (fields && Array.isArray(fields) && fields.length > 0) {
+            fields = fields.filter(field => field && field.trim() !== '').join(', ');
+        } else if (fields && Array.isArray(fields)) {
+            fields = '*';
+        }
+
+        let query = `SELECT ${fields} FROM ${table}${alias ? ' ' + alias : ''}`;
+        const allParams = [];
+
+        for (const join of joins) {
+            let { type = 'INNER', table: joinTable, alias, on } = join;
+            const onClause = Array.isArray(on) ? on.join(' AND ') : on;
+            query += ` ${type.toUpperCase()} JOIN ${joinTable}${alias ? ' ' + alias : ''} ON ${onClause}`;
+        }
+
+        if (where) {
+            const { clause, params } = this._buildWhereClause(where);
+            if (clause) {
+                query += ` WHERE ${clause}`;
+                allParams.push(...params);
+            }
+        }
+
+        if (groupBy) query += ` GROUP BY ${groupBy}`;
+        if (having) query += ` HAVING ${having}`;
+        if (orderBy) query += ` ORDER BY ${orderBy}`;
+
+        if (typeof limit === 'number' && limit && limit > 0) {
+            query += ` LIMIT ${limit}`;
+            if (typeof offset === 'number') query += ` OFFSET ${offset}`;
+        }
+
+        return { query, params: allParams };
+    },
+
+    _buildUpdateQuery(options) {
+        const { table, data, where } = options;
+        const { setFields, params } = this.prepareUpdateParams(data);
+
+        if (setFields.length === 0) throw new Error('No valid fields to update');
+
+        let query = `UPDATE ${table} SET ${setFields.join(', ')}`;
+        const allParams = [...params];
+
+        if (where) {
+            const { clause, params: whereParams } = this._buildWhereClause(where);
+            if (clause) {
+                query += ` WHERE ${clause}`;
+                allParams.push(...whereParams);
+            }
+        }
+
+        return { query, params: allParams };
+    },
+
+    _buildDeleteQuery(options) {
+        const { table, where } = options;
+        if (!table) throw new Error('Table name is required for delete');
+
+        let query = `DELETE FROM ${table}`;
+        const allParams = [];
+
+        if (where) {
+            const { clause, params: whereParams } = this._buildWhereClause(where);
+            if (clause) {
+                query += ` WHERE ${clause}`;
+                allParams.push(...whereParams);
+            } else {
+                throw new Error('DELETE requires a valid WHERE clause for safety');
+            }
+        } else {
+            throw new Error('DELETE requires a WHERE clause for safety');
+        }
+
+        return { query, params: allParams };
+    }
+};
+
+// Public API
+exports.find = async function (query, params = [], dbConfig) {
+    if (!query) return [];
+    return await utils.executeQuery({ query, params, dbConfig, operation: 'find' });
+};
+
+exports.findCount = async function (query, params = [], dbConfig) {
+    if (!query) return 0;
+    const results = await utils.executeQuery({ query, params, dbConfig, operation: 'findCount' });
+    return results && results[0] ? results[0].count : 0;
+};
+
+exports.insert = async function (table, data, dbConfig, debug = false, isIgnore = false) {
+    if (!table || !data || typeof data !== 'object') throw new Error('Invalid table or data');
+
+    const logger = connectionManager.getLogger();
+    const fields = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = fields.map(() => '?').join(', ');
+    const sql = isIgnore
+        ? `INSERT IGNORE INTO ${table} (${fields.join(', ')}) VALUES (${placeholders})`
+        : `INSERT INTO ${table} (${fields.join(', ')}) VALUES (${placeholders})`;
+
+    const result = await utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'insert' });
+
+    if (debug) {
+        logger.info({ operation: 'INSERT', table, insertId: result.insertId });
+    }
+    return result.insertId;
+};
+
+exports.update = async function (table, data, query, dbConfig, debug = false) {
+    const errors = utils.validateUpdateParams(table, data, query);
+    if (errors.length > 0) throw new Error(`Validation failed: ${errors.join(', ')}`);
+
+    const logger = connectionManager.getLogger();
+    const { setFields, params } = utils.prepareUpdateParams(data);
+    if (setFields.length === 0) throw new Error('No valid fields to update');
+
+    const sql = `UPDATE ${table} SET ${setFields.join(', ')} ${query}`;
+    const result = await utils.executeQuery({ query: sql, params, dbConfig, operation: 'update' });
+
+    if (debug) {
+        logger.info({ operation: 'UPDATE', table, affectedRows: result.affectedRows });
+    }
+    return result.affectedRows;
+};
+
+exports.delete = async function (query, table, dbConfig) {
+    if (!query || !query.toLowerCase().includes('where')) throw new Error('Invalid query or missing WHERE clause');
+
+    const logger = connectionManager.getLogger();
+    const sql = table ? `DELETE FROM ${table} ${query}` : query;
+    const result = await utils.executeQuery({ query: sql, params: [], dbConfig, operation: 'delete' });
+    logger.info(`Deleted ${result.affectedRows} records from ${table || 'custom query'}`);
+    return result.affectedRows;
+};
+
+// Query Builder Methods - Multiple naming options for flexibility
+exports.buildAndExecuteSelectQuery = async function (options, dbConfig) {
+    const { query, params } = utils._buildSelectQuery(options);
+    return await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteSelectQuery' });
+};
+
+exports.buildAndExecuteUpdateQuery = async function (options, dbConfig) {
+    const { query, params } = utils._buildUpdateQuery(options);
+    return await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteUpdateQuery' });
+};
+
+exports.buildAndExecuteDeleteQuery = async function (options, dbConfig) {
+    const { query, params } = utils._buildDeleteQuery(options);
+    return await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteDeleteQuery' });
+};
+
+// Alternative shorter method names (aliases)
+exports.select = exports.buildAndExecuteSelectQuery;
+exports.findWhere = exports.buildAndExecuteSelectQuery;
+exports.query = exports.buildAndExecuteSelectQuery;
+
+exports.updateWhere = exports.buildAndExecuteUpdateQuery;
+exports.updateQuery = exports.buildAndExecuteUpdateQuery;
+
+exports.deleteWhere = exports.buildAndExecuteDeleteQuery;
+exports.remove = exports.buildAndExecuteDeleteQuery;
+
+exports.utils = utils;

package/lib/transactionManager.js

@@ -0,0 +1,21 @@
+'use strict';
+
+let transactionInstance = null;
+
+module.exports = {
+    setInstance: (instance) => {
+        transactionInstance = instance;
+    },
+
+    getInstance: () => {
+        return transactionInstance || null;
+    },
+
+    clearInstance: () => {
+        transactionInstance = null;
+    },
+
+    hasActiveTransaction: () => {
+        return transactionInstance !== null && transactionInstance.transactionActive;
+    }
+};