mysql-orm-lite 1.0.1 → 2.1.0

package/{lib/connectionManager.js → src/lib/connectionManager.ts}

@@ -1,28 +1,28 @@
-'use strict';
-const mysql = require('mysql2/promise');
+import * as mysql from 'mysql2/promise';
+import { DbConfig, Logger } from '../types';
 
 // Default logger
-const defaultLogger = {
-    info: (...args) => console.log('[INFO]', ...args),
-    error: (...args) => console.error('[ERROR]', ...args),
-    warn: (...args) => console.warn('[WARN]', ...args)
+const defaultLogger: Logger = {
+    info: (...args: any[]) => console.log('[INFO]', ...args),
+    error: (...args: any[]) => console.error('[ERROR]', ...args),
+    warn: (...args: any[]) => console.warn('[WARN]', ...args)
 };
 
-const pools = new Map();
-let logger = defaultLogger;
-let defaultConfig = null;
+const pools = new Map<string, mysql.Pool>();
+let logger: Logger = defaultLogger;
+let defaultConfig: DbConfig | null = null;
 
-const getPoolKey = (config) => {
+const getPoolKey = (config: DbConfig): string => {
     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)
+     * @param config - Database configuration
+     * @param customLogger - Custom logger (optional)
      */
-    init: (config, customLogger) => {
+    init: (config: DbConfig, customLogger?: Logger) => {
         if (!config || !config.database) {
             throw new Error('Valid database configuration required');
         }
@@ -35,18 +35,18 @@ const connectionManager = {
 
     /**
      * Set custom logger
-     * @param {Object} customLogger - Logger with info, error, warn methods
+     * @param customLogger - Logger with info, error, warn methods
      */
-    setLogger: (customLogger) => {
+    setLogger: (customLogger: Logger) => {
         logger = customLogger;
     },
 
     /**
      * Get or create a connection pool
-     * @param {Object} dbConfig - Database configuration (optional)
-     * @returns {Promise<Pool>} MySQL connection pool
+     * @param dbConfig - Database configuration (optional)
+     * @returns MySQL connection pool
      */
-    getPool: async (dbConfig) => {
+    getPool: async (dbConfig?: DbConfig): Promise<mysql.Pool> => {
         const conf = dbConfig || defaultConfig;
         if (!conf || !conf.database) {
             throw new Error('Database configuration missing. Call connectionManager.init() first or provide dbConfig');
@@ -54,7 +54,7 @@ const connectionManager = {
 
         const key = getPoolKey(conf);
         if (pools.has(key)) {
-            return pools.get(key);
+            return pools.get(key)!;
         }
 
         try {
@@ -81,12 +81,12 @@ const connectionManager = {
 
     /**
      * Close a specific pool
-     * @param {Object} config - Database configuration
+     * @param config - Database configuration
      */
-    closePool: async (config) => {
+    closePool: async (config: DbConfig) => {
         const key = getPoolKey(config);
         if (pools.has(key)) {
-            const pool = pools.get(key);
+            const pool = pools.get(key)!;
             await pool.end();
             pools.delete(key);
             logger.info(`Closed connection pool for ${key}`);
@@ -111,7 +111,42 @@ const connectionManager = {
     /**
      * Get logger instance
      */
-    getLogger: () => logger
+    getLogger: (): Logger => logger,
+
+    /**
+     * Get connection pool statistics
+     * @param dbConfig - Optional database configuration
+     * @returns Connection pool stats
+     */
+    getPoolStats: async (dbConfig?: DbConfig) => {
+        const conf = dbConfig || defaultConfig;
+        if (!conf || !conf.database) {
+            throw new Error('Database configuration missing');
+        }
+
+        const key = getPoolKey(conf);
+        const pool = pools.get(key);
+
+        if (!pool) {
+            return {
+                activeConnections: 0,
+                idleConnections: 0,
+                totalConnections: 0,
+                waitingRequests: 0
+            };
+        }
+
+        // Access pool internals (mysql2 specific)
+        const poolInfo = (pool as any).pool;
+
+        return {
+            activeConnections: poolInfo?._acquiringConnections?.length || 0,
+            idleConnections: poolInfo?._freeConnections?.length || 0,
+            totalConnections: poolInfo?._allConnections?.length || 0,
+            waitingRequests: poolInfo?._connectionQueue?.length || 0
+        };
+    }
 };
 
-module.exports = connectionManager;
+export default connectionManager;
+export { connectionManager };

package/{lib/crud.js → src/lib/crud.ts}

@@ -1,9 +1,10 @@
-'use strict';
-const connectionManager = require('./connectionManager');
+import connectionManager from './connectionManager';
+import performanceMonitor from './performanceMonitor';
+import { DbConfig, SelectOptions, UpdateOptions, DeleteOptions, WhereConditions } from '../types';
 
-const utils = {
-    handleConnectionError(err) {
-        const errorMessages = {
+export const utils = {
+    handleConnectionError(err: any): Error {
+        const errorMessages: Record<string, string> = {
             PROTOCOL_CONNECTION_LOST: 'Database connection was closed.',
             ER_CON_COUNT_ERROR: 'Database has too many connections.',
             ECONNREFUSED: 'Database connection was refused.',
@@ -12,7 +13,7 @@ const utils = {
         return new Error(errorMessages[err.code] || err.message);
     },
 
-    logQueryPerformance(query, startTime, params = []) {
+    logQueryPerformance(query: string, startTime: number, params: any[] = []): number {
         const logger = connectionManager.getLogger();
         const duration = Date.now() - startTime;
         if (duration > 1000) {
@@ -25,16 +26,20 @@ const utils = {
         return duration;
     },
 
-    async executeQuery({ query, params = [], dbConfig, operation = 'query' }) {
+    async executeQuery({ query, params = [], dbConfig, operation = 'query' }: { query: string; params?: any[]; dbConfig?: DbConfig; operation?: string }): Promise<any> {
         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);
+            const duration = this.logQueryPerformance(query, startTime, params);
+
+            // Record in performance monitor if enabled
+            performanceMonitor.recordQuery(query, duration, params);
+
             return results;
-        } catch (error) {
+        } catch (error: any) {
             logger.error(`${operation} Error: ${error.message}`);
             logger.error(`Query: ${query}`);
             if (params.length) logger.error('Parameters:', JSON.stringify(params));
@@ -42,8 +47,8 @@ const utils = {
         }
     },
 
-    validateUpdateParams(table, data, query) {
-        const errors = [];
+    validateUpdateParams(table: string, data: Record<string, any>, query: string): string[] {
+        const errors: string[] = [];
         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');
 
@@ -56,9 +61,9 @@ const utils = {
         return errors;
     },
 
-    prepareUpdateParams(data) {
-        const setFields = [];
-        const params = [];
+    prepareUpdateParams(data: Record<string, any>): { setFields: string[]; params: any[] } {
+        const setFields: string[] = [];
+        const params: any[] = [];
 
         for (const [key, value] of Object.entries(data)) {
             if (value === undefined) continue;
@@ -79,13 +84,13 @@ const utils = {
         return { setFields, params };
     },
 
-    _buildWhereClause(conditions) {
-        const params = [];
-        const buildCondition = (key, value) => {
+    _buildWhereClause(conditions: WhereConditions): { clause: string; params: any[] } {
+        const params: any[] = [];
+        const buildCondition = (key: string, value: any): string => {
             const column = key;
             if (value === null) return `${column} IS NULL`;
             if (typeof value === 'object' && !Array.isArray(value)) {
-                return Object.entries(value).map(([op, val]) => {
+                return Object.entries(value).map(([op, val]: [string, any]) => {
                     switch (op) {
                         case '$eq': params.push(val); return `${column} = ?`;
                         case '$ne': params.push(val); return `${column} != ?`;
@@ -117,7 +122,7 @@ const utils = {
             return `${column} = ?`;
         };
 
-        const walk = (cond) => {
+        const walk = (cond: any): string => {
             if (!cond || typeof cond !== 'object') return '';
             if (Array.isArray(cond)) return cond.map(walk).join(' AND ');
 
@@ -132,7 +137,7 @@ const utils = {
         return { clause, params };
     },
 
-    _buildSelectQuery(options) {
+    _buildSelectQuery(options: SelectOptions): { query: string; params: any[] } {
         let { table, fields = '*', joins = [], where, orderBy, limit, offset, groupBy, having, alias, forUpdate = false } = options;
 
         if (fields && Array.isArray(fields) && fields.length > 0) {
@@ -142,7 +147,7 @@ const utils = {
         }
 
         let query = `SELECT ${fields} FROM ${table}${alias ? ' ' + alias : ''}`;
-        const allParams = [];
+        const allParams: any[] = [];
 
         for (const join of joins) {
             let { type = 'INNER', table: joinTable, alias, on } = join;
@@ -174,7 +179,7 @@ const utils = {
         return { query, params: allParams };
     },
 
-    _buildUpdateQuery(options) {
+    _buildUpdateQuery(options: UpdateOptions): { query: string; params: any[] } {
         const { table, data, where } = options;
         const { setFields, params } = this.prepareUpdateParams(data);
 
@@ -194,12 +199,12 @@ const utils = {
         return { query, params: allParams };
     },
 
-    _buildDeleteQuery(options) {
+    _buildDeleteQuery(options: DeleteOptions): { query: string; params: any[] } {
         const { table, where } = options;
         if (!table) throw new Error('Table name is required for delete');
 
         let query = `DELETE FROM ${table}`;
-        const allParams = [];
+        const allParams: any[] = [];
 
         if (where) {
             const { clause, params: whereParams } = this._buildWhereClause(where);
@@ -218,18 +223,18 @@ const utils = {
 };
 
 // Public API
-exports.find = async function (query, params = [], dbConfig) {
+export const find = async function (query: string, params: any[] = [], dbConfig?: DbConfig): Promise<any[]> {
     if (!query) return [];
     return await utils.executeQuery({ query, params, dbConfig, operation: 'find' });
 };
 
-exports.findCount = async function (query, params = [], dbConfig) {
+export const findCount = async function (query: string, params: any[] = [], dbConfig?: DbConfig): Promise<number> {
     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) {
+export const insert = async function (table: string, data: Record<string, any>, dbConfig?: DbConfig, debug = false, isIgnore = false): Promise<any> {
     if (!table || !data || typeof data !== 'object') throw new Error('Invalid table or data');
 
     const logger = connectionManager.getLogger();
@@ -248,7 +253,7 @@ exports.insert = async function (table, data, dbConfig, debug = false, isIgnore
     return result.insertId;
 };
 
-exports.update = async function (table, data, query, dbConfig, debug = false) {
+export const update = async function (table: string, data: Record<string, any>, query: string, dbConfig?: DbConfig, debug = false): Promise<number> {
     const errors = utils.validateUpdateParams(table, data, query);
     if (errors.length > 0) throw new Error(`Validation failed: ${errors.join(', ')}`);
 
@@ -265,7 +270,7 @@ exports.update = async function (table, data, query, dbConfig, debug = false) {
     return result.affectedRows;
 };
 
-exports.delete = async function (query, table, dbConfig) {
+export const _delete = async function (query: string, table?: string, dbConfig?: DbConfig): Promise<number> {
     if (!query || !query.toLowerCase().includes('where')) throw new Error('Invalid query or missing WHERE clause');
 
     const logger = connectionManager.getLogger();
@@ -275,31 +280,198 @@ exports.delete = async function (query, table, dbConfig) {
     return result.affectedRows;
 };
 
-// Query Builder Methods - Multiple naming options for flexibility
-exports.buildAndExecuteSelectQuery = async function (options, dbConfig) {
+export { _delete as delete };
+
+// Bulk Operations
+export const bulkInsert = async function (
+    table: string,
+    records: Record<string, any>[],
+    options?: { batchSize?: number; ignore?: boolean },
+    dbConfig?: DbConfig
+): Promise<{ totalInserted: number; batches: number; firstInsertId?: number; lastInsertId?: number }> {
+    if (!table || !records || !Array.isArray(records) || records.length === 0) {
+        throw new Error('Table name and records are required for bulk insert');
+    }
+
+    const batchSize = options?.batchSize || 1000;
+    const isIgnore = options?.ignore || false;
+    const logger = connectionManager.getLogger();
+
+    // Validate all records have the same fields
+    const fields = Object.keys(records[0]);
+    for (const record of records) {
+        const recordFields = Object.keys(record);
+        if (recordFields.length !== fields.length || !recordFields.every(f => fields.includes(f))) {
+            throw new Error('All records must have the same fields for bulk insert');
+        }
+    }
+
+    let totalInserted = 0;
+    let firstInsertId: number | undefined;
+    let lastInsertId: number | undefined;
+    const batches = Math.ceil(records.length / batchSize);
+
+    for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const values: any[] = [];
+        const placeholders: string[] = [];
+
+        for (const record of batch) {
+            const recordValues = fields.map(field => record[field]);
+            values.push(...recordValues);
+            placeholders.push(`(${fields.map(() => '?').join(', ')})`);
+        }
+
+        const sql = isIgnore
+            ? `INSERT IGNORE INTO ${table} (${fields.join(', ')}) VALUES ${placeholders.join(', ')}`
+            : `INSERT INTO ${table} (${fields.join(', ')}) VALUES ${placeholders.join(', ')}`;
+
+        const result = await utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'bulkInsert' });
+
+        totalInserted += result.affectedRows || 0;
+
+        if (i === 0 && result.insertId) {
+            firstInsertId = result.insertId;
+        }
+        if (result.insertId) {
+            lastInsertId = result.insertId + (result.affectedRows || 1) - 1;
+        }
+    }
+
+    logger.info(`Bulk inserted ${totalInserted} records into ${table} in ${batches} batches`);
+
+    return {
+        totalInserted,
+        batches,
+        firstInsertId,
+        lastInsertId
+    };
+};
+
+export const upsert = async function (
+    table: string,
+    data: Record<string, any>,
+    options: { conflictKey: string | string[]; updateFields?: string[] },
+    dbConfig?: DbConfig
+): Promise<{ action: 'inserted' | 'updated'; affectedRows: number; insertId?: number }> {
+    if (!table || !data || !options.conflictKey) {
+        throw new Error('Table, data, and conflictKey are required for upsert');
+    }
+
+    const fields = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = fields.map(() => '?').join(', ');
+
+    // Determine which fields to update on duplicate key
+    const conflictKeys = Array.isArray(options.conflictKey) ? options.conflictKey : [options.conflictKey];
+    const updateFields = options.updateFields || fields.filter(f => !conflictKeys.includes(f));
+
+    if (updateFields.length === 0) {
+        throw new Error('No fields to update on duplicate key');
+    }
+
+    // Build UPDATE clause
+    const updateClause = updateFields.map(field => `${field} = VALUES(${field})`).join(', ');
+
+    const sql = `INSERT INTO ${table} (${fields.join(', ')}) VALUES (${placeholders}) ON DUPLICATE KEY UPDATE ${updateClause}`;
+
+    const result = await utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'upsert' });
+
+    // affectedRows = 1 means inserted, 2 means updated, 0 means no change
+    const action: 'inserted' | 'updated' = result.affectedRows === 1 ? 'inserted' : 'updated';
+
+    return {
+        action,
+        affectedRows: result.affectedRows,
+        insertId: result.insertId
+    };
+};
+
+export const bulkUpsert = async function (
+    table: string,
+    records: Record<string, any>[],
+    options: { conflictKey: string | string[]; updateFields?: string[]; batchSize?: number },
+    dbConfig?: DbConfig
+): Promise<{ totalAffected: number; batches: number }> {
+    if (!table || !records || records.length === 0) {
+        throw new Error('Table name and records are required for bulk upsert');
+    }
+
+    const batchSize = options?.batchSize || 1000;
+    const logger = connectionManager.getLogger();
+
+    // Validate all records have the same fields
+    const fields = Object.keys(records[0]);
+    for (const record of records) {
+        const recordFields = Object.keys(record);
+        if (recordFields.length !== fields.length || !recordFields.every(f => fields.includes(f))) {
+            throw new Error('All records must have the same fields for bulk upsert');
+        }
+    }
+
+    // Determine which fields to update on duplicate key
+    const conflictKeys = Array.isArray(options.conflictKey) ? options.conflictKey : [options.conflictKey];
+    const updateFields = options.updateFields || fields.filter(f => !conflictKeys.includes(f));
+
+    if (updateFields.length === 0) {
+        throw new Error('No fields to update on duplicate key');
+    }
+
+    const updateClause = updateFields.map(field => `${field} = VALUES(${field})`).join(', ');
+
+    let totalAffected = 0;
+    const batches = Math.ceil(records.length / batchSize);
+
+    for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const values: any[] = [];
+        const placeholders: string[] = [];
+
+        for (const record of batch) {
+            const recordValues = fields.map(field => record[field]);
+            values.push(...recordValues);
+            placeholders.push(`(${fields.map(() => '?').join(', ')})`);
+        }
+
+        const sql = `INSERT INTO ${table} (${fields.join(', ')}) VALUES ${placeholders.join(', ')} ON DUPLICATE KEY UPDATE ${updateClause}`;
+
+        const result = await utils.executeQuery({ query: sql, params: values, dbConfig, operation: 'bulkUpsert' });
+        totalAffected += result.affectedRows || 0;
+    }
+
+    logger.info(`Bulk upsert affected ${totalAffected} records in ${table} in ${batches} batches`);
+
+    return {
+        totalAffected,
+        batches
+    };
+};
+
+// Query Builder Methods
+export const buildAndExecuteSelectQuery = async function (options: SelectOptions, dbConfig?: DbConfig): Promise<any[]> {
     const { query, params } = utils._buildSelectQuery(options);
     return await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteSelectQuery' });
 };
 
-exports.buildAndExecuteUpdateQuery = async function (options, dbConfig) {
+export const buildAndExecuteUpdateQuery = async function (options: UpdateOptions, dbConfig?: DbConfig): Promise<number> {
     const { query, params } = utils._buildUpdateQuery(options);
-    return await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteUpdateQuery' });
+    const result = await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteUpdateQuery' });
+    return result.affectedRows;
 };
 
-exports.buildAndExecuteDeleteQuery = async function (options, dbConfig) {
+export const buildAndExecuteDeleteQuery = async function (options: DeleteOptions, dbConfig?: DbConfig): Promise<number> {
     const { query, params } = utils._buildDeleteQuery(options);
-    return await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteDeleteQuery' });
+    const result = await utils.executeQuery({ query, params, dbConfig, operation: 'buildAndExecuteDeleteQuery' });
+    return result.affectedRows;
 };
 
-// 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;
+// Aliases
+export const select = buildAndExecuteSelectQuery;
+export const findWhere = buildAndExecuteSelectQuery;
+export const query = buildAndExecuteSelectQuery;
 
-exports.deleteWhere = exports.buildAndExecuteDeleteQuery;
-exports.remove = exports.buildAndExecuteDeleteQuery;
+export const updateWhere = buildAndExecuteUpdateQuery;
+export const updateQuery = buildAndExecuteUpdateQuery;
 
-exports.utils = utils;
+export const deleteWhere = buildAndExecuteDeleteQuery;
+export const remove = buildAndExecuteDeleteQuery;

package/src/lib/performanceMonitor.ts

@@ -0,0 +1,147 @@
+import { QueryMetric, PerformanceStats, ConnectionPoolStats } from '../types';
+
+class PerformanceMonitor {
+    private enabled: boolean = false;
+    private queries: QueryMetric[] = [];
+    private startTime: number = 0;
+    private queryCountByType = {
+        SELECT: 0,
+        INSERT: 0,
+        UPDATE: 0,
+        DELETE: 0,
+        OTHER: 0
+    };
+
+    /**
+     * Enable performance monitoring
+     */
+    enable(): void {
+        this.enabled = true;
+        this.startTime = Date.now();
+        console.log('[Performance Monitor] Enabled');
+    }
+
+    /**
+     * Disable performance monitoring
+     */
+    disable(): void {
+        this.enabled = false;
+        console.log('[Performance Monitor] Disabled');
+    }
+
+    /**
+     * Check if monitoring is enabled
+     */
+    isEnabled(): boolean {
+        return this.enabled;
+    }
+
+    /**
+     * Record a query execution
+     */
+    recordQuery(query: string, duration: number, params?: any[]): void {
+        if (!this.enabled) return;
+
+        const type = this.detectQueryType(query);
+
+        const metric: QueryMetric = {
+            query,
+            duration,
+            timestamp: Date.now(),
+            type,
+            params
+        };
+
+        this.queries.push(metric);
+        this.queryCountByType[type]++;
+
+        // Keep only last 1000 queries to prevent memory issues
+        if (this.queries.length > 1000) {
+            this.queries.shift();
+        }
+    }
+
+    /**
+     * Detect query type from SQL string
+     */
+    private detectQueryType(query: string): QueryMetric['type'] {
+        const normalized = query.trim().toUpperCase();
+
+        if (normalized.startsWith('SELECT')) return 'SELECT';
+        if (normalized.startsWith('INSERT')) return 'INSERT';
+        if (normalized.startsWith('UPDATE')) return 'UPDATE';
+        if (normalized.startsWith('DELETE')) return 'DELETE';
+
+        return 'OTHER';
+    }
+
+    /**
+     * Get current performance statistics
+     */
+    getStats(): PerformanceStats {
+        const totalQueries = this.queries.length;
+        const totalDuration = this.queries.reduce((sum, q) => sum + q.duration, 0);
+        const averageQueryTime = totalQueries > 0 ? totalDuration / totalQueries : 0;
+
+        const slowestQueries = [...this.queries]
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, 10);
+
+        return {
+            enabled: this.enabled,
+            totalQueries,
+            averageQueryTime: Math.round(averageQueryTime * 100) / 100,
+            slowestQueries,
+            queryCountByType: { ...this.queryCountByType },
+            startTime: this.startTime,
+            uptime: this.startTime > 0 ? Date.now() - this.startTime : 0
+        };
+    }
+
+    /**
+     * Get slowest queries
+     */
+    getSlowQueries(limit: number = 10): QueryMetric[] {
+        return [...this.queries]
+            .sort((a, b) => b.duration - a.duration)
+            .slice(0, limit);
+    }
+
+    /**
+     * Reset all collected metrics
+     */
+    reset(): void {
+        this.queries = [];
+        this.queryCountByType = {
+            SELECT: 0,
+            INSERT: 0,
+            UPDATE: 0,
+            DELETE: 0,
+            OTHER: 0
+        };
+        this.startTime = Date.now();
+        console.log('[Performance Monitor] Reset');
+    }
+
+    /**
+     * Get queries executed in the last N milliseconds
+     */
+    getRecentQueries(milliseconds: number = 60000): QueryMetric[] {
+        const cutoff = Date.now() - milliseconds;
+        return this.queries.filter(q => q.timestamp >= cutoff);
+    }
+
+    /**
+     * Get queries per second
+     */
+    getQueriesPerSecond(): number {
+        const uptime = this.startTime > 0 ? (Date.now() - this.startTime) / 1000 : 0;
+        return uptime > 0 ? this.queries.length / uptime : 0;
+    }
+}
+
+// Singleton instance
+const performanceMonitor = new PerformanceMonitor();
+
+export default performanceMonitor;
+export { performanceMonitor, PerformanceMonitor };