@berthojoris/mcp-mysql-server 1.4.15 → 1.6.0

package/dist/config/featureConfig.js

@@ -21,59 +21,68 @@ var ToolCategory;
     ToolCategory["DDL"] = "ddl";
     ToolCategory["UTILITY"] = "utility";
     ToolCategory["TRANSACTION"] = "transaction";
-    ToolCategory["PROCEDURE"] = "procedure"; // Stored procedure operations (CREATE, EXECUTE, DROP procedures)
+    ToolCategory["PROCEDURE"] = "procedure";
 })(ToolCategory || (exports.ToolCategory = ToolCategory = {}));
 /**
  * Map of tool names to their categories
  */
 exports.toolCategoryMap = {
     // Database tools
-    'listDatabases': ToolCategory.LIST,
-    'listTables': ToolCategory.LIST,
-    'readTableSchema': ToolCategory.LIST,
+    listDatabases: ToolCategory.LIST,
+    listTables: ToolCategory.LIST,
+    readTableSchema: ToolCategory.LIST,
     // CRUD tools
-    'createRecord': ToolCategory.CREATE,
-    'readRecords': ToolCategory.READ,
-    'updateRecord': ToolCategory.UPDATE,
-    'deleteRecord': ToolCategory.DELETE,
+    createRecord: ToolCategory.CREATE,
+    readRecords: ToolCategory.READ,
+    updateRecord: ToolCategory.UPDATE,
+    deleteRecord: ToolCategory.DELETE,
     // Bulk operations
-    'bulkInsert': ToolCategory.CREATE,
-    'bulkUpdate': ToolCategory.UPDATE,
-    'bulkDelete': ToolCategory.DELETE,
+    bulkInsert: ToolCategory.CREATE,
+    bulkUpdate: ToolCategory.UPDATE,
+    bulkDelete: ToolCategory.DELETE,
     // Query tools
-    'runQuery': ToolCategory.READ,
-    'executeSql': ToolCategory.EXECUTE,
+    runQuery: ToolCategory.READ,
+    executeSql: ToolCategory.EXECUTE,
     // DDL tools
-    'createTable': ToolCategory.DDL,
-    'alterTable': ToolCategory.DDL,
-    'dropTable': ToolCategory.DDL,
-    'executeDdl': ToolCategory.DDL,
+    createTable: ToolCategory.DDL,
+    alterTable: ToolCategory.DDL,
+    dropTable: ToolCategory.DDL,
+    executeDdl: ToolCategory.DDL,
     // Utility tools
-    'describeConnection': ToolCategory.UTILITY,
-    'testConnection': ToolCategory.UTILITY,
-    'getTableRelationships': ToolCategory.UTILITY,
-    'exportTableToCSV': ToolCategory.UTILITY,
-    'exportQueryToCSV': ToolCategory.UTILITY,
+    describeConnection: ToolCategory.UTILITY,
+    testConnection: ToolCategory.UTILITY,
+    getTableRelationships: ToolCategory.UTILITY,
+    exportTableToCSV: ToolCategory.UTILITY,
+    exportQueryToCSV: ToolCategory.UTILITY,
     // Transaction tools
-    'beginTransaction': ToolCategory.TRANSACTION,
-    'commitTransaction': ToolCategory.TRANSACTION,
-    'rollbackTransaction': ToolCategory.TRANSACTION,
-    'getTransactionStatus': ToolCategory.TRANSACTION,
-    'executeInTransaction': ToolCategory.TRANSACTION,
+    beginTransaction: ToolCategory.TRANSACTION,
+    commitTransaction: ToolCategory.TRANSACTION,
+    rollbackTransaction: ToolCategory.TRANSACTION,
+    getTransactionStatus: ToolCategory.TRANSACTION,
+    executeInTransaction: ToolCategory.TRANSACTION,
     // Stored procedure tools
-    'listStoredProcedures': ToolCategory.LIST,
-    'getStoredProcedureInfo': ToolCategory.LIST,
-    'executeStoredProcedure': ToolCategory.PROCEDURE,
-    'createStoredProcedure': ToolCategory.PROCEDURE,
-    'dropStoredProcedure': ToolCategory.PROCEDURE,
-    'showCreateProcedure': ToolCategory.LIST
+    listStoredProcedures: ToolCategory.LIST,
+    getStoredProcedureInfo: ToolCategory.LIST,
+    executeStoredProcedure: ToolCategory.PROCEDURE,
+    createStoredProcedure: ToolCategory.PROCEDURE,
+    dropStoredProcedure: ToolCategory.PROCEDURE,
+    showCreateProcedure: ToolCategory.LIST,
+    // Cache management tools
+    getCacheStats: ToolCategory.UTILITY,
+    getCacheConfig: ToolCategory.UTILITY,
+    configureCacheSettings: ToolCategory.UTILITY,
+    clearCache: ToolCategory.UTILITY,
+    invalidateCacheForTable: ToolCategory.UTILITY,
+    // Query optimization tools
+    analyzeQuery: ToolCategory.UTILITY,
+    getOptimizationHints: ToolCategory.UTILITY,
 };
 /**
  * Class to manage feature configuration based on runtime or environment variables
  */
 class FeatureConfig {
     constructor(configStr) {
-        this.originalConfigString = configStr || process.env.MCP_CONFIG || '';
+        this.originalConfigString = configStr || process.env.MCP_CONFIG || "";
         this.enabledCategories = this.parseConfig(configStr);
     }
     /**
@@ -81,14 +90,14 @@ class FeatureConfig {
      */
     parseConfig(configStr) {
         // Priority: 1. Provided config, 2. Environment variable, 3. Enable all
-        const config = configStr || process.env.MCP_CONFIG || '';
+        const config = configStr || process.env.MCP_CONFIG || "";
         // If config is empty, enable all features
         if (!config.trim()) {
             return new Set(Object.values(ToolCategory));
         }
         // Parse comma-separated list
-        const categories = config.split(',').map(c => c.trim().toLowerCase());
-        const validCategories = categories.filter(c => Object.values(ToolCategory).includes(c));
+        const categories = config.split(",").map((c) => c.trim().toLowerCase());
+        const validCategories = categories.filter((c) => Object.values(ToolCategory).includes(c));
         return new Set(validCategories);
     }
     /**
@@ -119,47 +128,49 @@ class FeatureConfig {
             return `Unknown tool '${toolName}'. This tool is not recognized by the MCP server.`;
         }
         const isAllPermissions = !this.originalConfigString.trim();
-        const currentPermissions = isAllPermissions ? 'all' : this.originalConfigString;
+        const currentPermissions = isAllPermissions
+            ? "all"
+            : this.originalConfigString;
         const actionDescriptions = {
-            [ToolCategory.LIST]: 'list databases and tables',
-            [ToolCategory.READ]: 'read data from tables',
-            [ToolCategory.CREATE]: 'create new records',
-            [ToolCategory.UPDATE]: 'update existing records',
-            [ToolCategory.DELETE]: 'delete records',
-            [ToolCategory.EXECUTE]: 'execute custom SQL queries',
-            [ToolCategory.DDL]: 'create, alter, or drop tables (schema changes)',
-            [ToolCategory.UTILITY]: 'use utility functions',
-            [ToolCategory.TRANSACTION]: 'manage database transactions',
-            [ToolCategory.PROCEDURE]: 'manage stored procedures'
+            [ToolCategory.LIST]: "list databases and tables",
+            [ToolCategory.READ]: "read data from tables",
+            [ToolCategory.CREATE]: "create new records",
+            [ToolCategory.UPDATE]: "update existing records",
+            [ToolCategory.DELETE]: "delete records",
+            [ToolCategory.EXECUTE]: "execute custom SQL queries",
+            [ToolCategory.DDL]: "create, alter, or drop tables (schema changes)",
+            [ToolCategory.UTILITY]: "use utility functions",
+            [ToolCategory.TRANSACTION]: "manage database transactions",
+            [ToolCategory.PROCEDURE]: "manage stored procedures",
         };
         const toolDescriptions = {
-            'createTable': 'create new tables',
-            'alterTable': 'modify table structure',
-            'dropTable': 'delete tables',
-            'executeDdl': 'execute DDL statements',
-            'createRecord': 'insert new records',
-            'updateRecord': 'update existing records',
-            'deleteRecord': 'delete records',
-            'bulkInsert': 'insert multiple records in batches',
-            'bulkUpdate': 'update multiple records in batches',
-            'bulkDelete': 'delete multiple records in batches',
-            'executeSql': 'execute custom SQL statements',
-            'runQuery': 'run SELECT queries',
-            'beginTransaction': 'start database transactions',
-            'commitTransaction': 'commit database transactions',
-            'rollbackTransaction': 'rollback database transactions',
-            'executeInTransaction': 'execute queries within transactions',
-            'createStoredProcedure': 'create stored procedures',
-            'dropStoredProcedure': 'delete stored procedures',
-            'executeStoredProcedure': 'execute stored procedures',
-            'exportTableToCSV': 'export table data to CSV',
-            'exportQueryToCSV': 'export query results to CSV'
+            createTable: "create new tables",
+            alterTable: "modify table structure",
+            dropTable: "delete tables",
+            executeDdl: "execute DDL statements",
+            createRecord: "insert new records",
+            updateRecord: "update existing records",
+            deleteRecord: "delete records",
+            bulkInsert: "insert multiple records in batches",
+            bulkUpdate: "update multiple records in batches",
+            bulkDelete: "delete multiple records in batches",
+            executeSql: "execute custom SQL statements",
+            runQuery: "run SELECT queries",
+            beginTransaction: "start database transactions",
+            commitTransaction: "commit database transactions",
+            rollbackTransaction: "rollback database transactions",
+            executeInTransaction: "execute queries within transactions",
+            createStoredProcedure: "create stored procedures",
+            dropStoredProcedure: "delete stored procedures",
+            executeStoredProcedure: "execute stored procedures",
+            exportTableToCSV: "export table data to CSV",
+            exportQueryToCSV: "export query results to CSV",
         };
         const toolDescription = toolDescriptions[toolName] || actionDescriptions[category];
         const requiredPermission = category;
-        return `Permission denied: Cannot ${toolDescription}. ` +
+        return (`Permission denied: Cannot ${toolDescription}. ` +
             `This action requires '${requiredPermission}' permission, but your current MCP configuration only allows: ${currentPermissions}. ` +
-            `To enable this feature, update your MCP server configuration to include '${requiredPermission}' in the permissions list.`;
+            `To enable this feature, update your MCP server configuration to include '${requiredPermission}' in the permissions list.`);
     }
     /**
      * Check if a category is enabled

package/dist/db/connection.d.ts

@@ -1,12 +1,17 @@
-import mysql from 'mysql2/promise';
+import mysql from "mysql2/promise";
 declare class DatabaseConnection {
     private static instance;
     private pool;
     private activeTransactions;
+    private queryCache;
     private constructor();
     static getInstance(): DatabaseConnection;
     getConnection(): Promise<mysql.PoolConnection>;
-    query<T>(sql: string, params?: any[]): Promise<T>;
+    query<T>(sql: string, params?: any[], useCache?: boolean): Promise<T>;
+    /**
+     * Invalidate cache entries when write operations occur
+     */
+    private invalidateCacheForWriteOperation;
     testConnection(): Promise<{
         connected: boolean;
         latency: number;
@@ -20,6 +25,20 @@ declare class DatabaseConnection {
     getQueryLogs(): import("./queryLogger").QueryLog[];
     getLastQueryLog(): import("./queryLogger").QueryLog | undefined;
     getFormattedQueryLogs(count?: number): string;
+    getCacheStats(): import("../cache/queryCache").CacheStats;
+    getCacheConfig(): import("../cache/queryCache").CacheConfig;
+    setCacheConfig(config: {
+        enabled?: boolean;
+        ttlMs?: number;
+        maxSize?: number;
+        maxMemoryMB?: number;
+    }): void;
+    clearCache(): number;
+    invalidateCache(pattern?: string | RegExp): number;
+    invalidateCacheForTable(tableName: string): number;
+    enableCache(): void;
+    disableCache(): void;
+    resetCacheStats(): void;
     executeInTransaction<T>(transactionId: string, sql: string, params?: any[]): Promise<T>;
 }
 export default DatabaseConnection;

package/dist/db/connection.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const promise_1 = __importDefault(require("mysql2/promise"));
 const config_1 = require("../config/config");
 const queryLogger_1 = require("./queryLogger");
+const queryCache_1 = require("../cache/queryCache");
 class DatabaseConnection {
     constructor() {
         this.pool = promise_1.default.createPool({
@@ -16,9 +17,10 @@ class DatabaseConnection {
             database: config_1.dbConfig.database,
             waitForConnections: true,
             connectionLimit: 10,
-            queueLimit: 0
+            queueLimit: 0,
         });
         this.activeTransactions = new Map();
+        this.queryCache = queryCache_1.QueryCache.getInstance();
     }
     static getInstance() {
         if (!DatabaseConnection.instance) {
@@ -34,20 +36,54 @@ class DatabaseConnection {
             throw new Error(`Failed to get database connection: ${error}`);
         }
     }
-    async query(sql, params) {
+    async query(sql, params, useCache = true) {
+        const normalizedSql = sql.trim().toUpperCase();
+        const isSelectQuery = normalizedSql.startsWith("SELECT");
+        // Check cache for SELECT queries
+        if (useCache && isSelectQuery) {
+            const cachedEntry = this.queryCache.get(sql, params);
+            if (cachedEntry) {
+                // Log cache hit
+                queryLogger_1.QueryLogger.log(sql, params, 0, "success", undefined, true);
+                return cachedEntry.data;
+            }
+        }
         const startTime = Date.now();
         try {
             const [results] = await this.pool.query(sql, params);
             const duration = Date.now() - startTime;
-            queryLogger_1.QueryLogger.log(sql, params, duration, 'success');
+            queryLogger_1.QueryLogger.log(sql, params, duration, "success");
+            // Cache SELECT query results
+            if (useCache && isSelectQuery) {
+                this.queryCache.set(sql, params, results);
+            }
+            // Invalidate cache for write operations
+            if (!isSelectQuery) {
+                this.invalidateCacheForWriteOperation(sql);
+            }
             return results;
         }
         catch (error) {
             const duration = Date.now() - startTime;
-            queryLogger_1.QueryLogger.log(sql, params, duration, 'error', error.message);
+            queryLogger_1.QueryLogger.log(sql, params, duration, "error", error.message);
             throw new Error(`Query execution failed: ${error}`);
         }
     }
+    /**
+     * Invalidate cache entries when write operations occur
+     */
+    invalidateCacheForWriteOperation(sql) {
+        // Extract table name from INSERT, UPDATE, DELETE statements
+        const insertMatch = sql.match(/INSERT\s+INTO\s+[\`"']?(\w+)[\`"']?/i);
+        const updateMatch = sql.match(/UPDATE\s+[\`"']?(\w+)[\`"']?/i);
+        const deleteMatch = sql.match(/DELETE\s+FROM\s+[\`"']?(\w+)[\`"']?/i);
+        const truncateMatch = sql.match(/TRUNCATE\s+(?:TABLE\s+)?[\`"']?(\w+)[\`"']?/i);
+        const dropMatch = sql.match(/DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?[\`"']?(\w+)[\`"']?/i);
+        const match = insertMatch || updateMatch || deleteMatch || truncateMatch || dropMatch;
+        if (match && match[1]) {
+            this.queryCache.invalidateTable(match[1]);
+        }
+    }
     async testConnection() {
         const startTime = Date.now();
         try {
@@ -96,7 +132,7 @@ class DatabaseConnection {
                 connection.release();
             }
             catch (rollbackError) {
-                console.error('Failed to rollback after commit error:', rollbackError);
+                console.error("Failed to rollback after commit error:", rollbackError);
             }
             this.activeTransactions.delete(transactionId);
             throw new Error(`Failed to commit transaction: ${error}`);
@@ -133,6 +169,36 @@ class DatabaseConnection {
     getFormattedQueryLogs(count = 1) {
         return queryLogger_1.QueryLogger.formatLogs(queryLogger_1.QueryLogger.getLastLogs(count));
     }
+    // Cache Management Methods
+    getCacheStats() {
+        return this.queryCache.getStats();
+    }
+    getCacheConfig() {
+        return this.queryCache.getConfig();
+    }
+    setCacheConfig(config) {
+        this.queryCache.setConfig(config);
+    }
+    clearCache() {
+        const previousSize = this.queryCache.getStats().currentSize;
+        this.queryCache.clear();
+        return previousSize;
+    }
+    invalidateCache(pattern) {
+        return this.queryCache.invalidate(pattern);
+    }
+    invalidateCacheForTable(tableName) {
+        return this.queryCache.invalidateTable(tableName);
+    }
+    enableCache() {
+        this.queryCache.enable();
+    }
+    disableCache() {
+        this.queryCache.disable();
+    }
+    resetCacheStats() {
+        this.queryCache.resetStats();
+    }
     async executeInTransaction(transactionId, sql, params) {
         const connection = this.activeTransactions.get(transactionId);
         if (!connection) {
@@ -142,12 +208,12 @@ class DatabaseConnection {
         try {
             const [results] = await connection.query(sql, params);
             const duration = Date.now() - startTime;
-            queryLogger_1.QueryLogger.log(sql, params, duration, 'success');
+            queryLogger_1.QueryLogger.log(sql, params, duration, "success");
             return results;
         }
         catch (error) {
             const duration = Date.now() - startTime;
-            queryLogger_1.QueryLogger.log(sql, params, duration, 'error', error.message);
+            queryLogger_1.QueryLogger.log(sql, params, duration, "error", error.message);
             throw new Error(`Query execution in transaction failed: ${error}`);
         }
     }

package/dist/db/queryLogger.d.ts

@@ -3,8 +3,9 @@ export interface QueryLog {
     params?: any[];
     duration: number;
     timestamp: string;
-    status: 'success' | 'error';
+    status: "success" | "error";
     error?: string;
+    cacheHit?: boolean;
 }
 export declare class QueryLogger {
     private static logs;
@@ -27,7 +28,7 @@ export declare class QueryLogger {
     /**
      * Log a query execution
      */
-    static log(sql: string, params: any[] | undefined, duration: number, status: 'success' | 'error', error?: string): void;
+    static log(sql: string, params: any[] | undefined, duration: number, status: "success" | "error", error?: string, cacheHit?: boolean): void;
     /**
      * Get all logged queries (returns shallow copy of array)
      */

package/dist/db/queryLogger.js

@@ -8,34 +8,38 @@ class QueryLogger {
     static safeStringify(value, maxLength = 100) {
         try {
             if (value === null)
-                return 'null';
+                return "null";
             if (value === undefined)
-                return 'undefined';
-            if (typeof value === 'string') {
-                return value.length > maxLength ? value.substring(0, maxLength) + '...' : value;
+                return "undefined";
+            if (typeof value === "string") {
+                return value.length > maxLength
+                    ? value.substring(0, maxLength) + "..."
+                    : value;
             }
-            if (typeof value === 'number' || typeof value === 'boolean') {
+            if (typeof value === "number" || typeof value === "boolean") {
                 return String(value);
             }
-            if (typeof value === 'bigint') {
-                return value.toString() + 'n';
+            if (typeof value === "bigint") {
+                return value.toString() + "n";
             }
             if (Array.isArray(value)) {
                 if (value.length === 0)
-                    return '[]';
-                const items = value.slice(0, 3).map(v => this.safeStringify(v, 30));
+                    return "[]";
+                const items = value.slice(0, 3).map((v) => this.safeStringify(v, 30));
                 return value.length > 3
-                    ? `[${items.join(', ')}, ... +${value.length - 3} more]`
-                    : `[${items.join(', ')}]`;
+                    ? `[${items.join(", ")}, ... +${value.length - 3} more]`
+                    : `[${items.join(", ")}]`;
             }
-            if (typeof value === 'object') {
+            if (typeof value === "object") {
                 const str = JSON.stringify(value);
-                return str.length > maxLength ? str.substring(0, maxLength) + '...}' : str;
+                return str.length > maxLength
+                    ? str.substring(0, maxLength) + "...}"
+                    : str;
             }
             return String(value);
         }
         catch (error) {
-            return '[Unstringifiable]';
+            return "[Unstringifiable]";
         }
     }
     /**
@@ -44,7 +48,8 @@ class QueryLogger {
     static truncateSQL(sql) {
         if (sql.length <= this.MAX_SQL_LENGTH)
             return sql;
-        return sql.substring(0, this.MAX_SQL_LENGTH) + `... [truncated ${sql.length - this.MAX_SQL_LENGTH} chars]`;
+        return (sql.substring(0, this.MAX_SQL_LENGTH) +
+            `... [truncated ${sql.length - this.MAX_SQL_LENGTH} chars]`);
     }
     /**
      * Create a memory-safe copy of parameters
@@ -60,20 +65,25 @@ class QueryLogger {
         }
         catch (error) {
             // If JSON serialization fails, create safe string representations
-            return limitedParams.map(p => this.safeStringify(p, 50));
+            return limitedParams.map((p) => this.safeStringify(p, 50));
         }
     }
     /**
      * Log a query execution
      */
-    static log(sql, params, duration, status, error) {
+    static log(sql, params, duration, status, error, cacheHit) {
         const log = {
             sql: this.truncateSQL(sql),
             params: this.sanitizeParams(params),
             duration,
             timestamp: new Date().toISOString(),
             status,
-            error: error ? (error.length > 200 ? error.substring(0, 200) + '...' : error) : undefined
+            cacheHit: cacheHit,
+            error: error
+                ? error.length > 200
+                    ? error.substring(0, 200) + "..."
+                    : error
+                : undefined,
         };
         this.logs.push(log);
         // Keep only the last MAX_LOGS entries
@@ -113,9 +123,9 @@ class QueryLogger {
     static formatSQL(sql) {
         // Add line breaks for better readability
         return sql
-            .replace(/\s+/g, ' ') // Normalize whitespace
-            .replace(/\b(SELECT|FROM|WHERE|JOIN|LEFT JOIN|RIGHT JOIN|INNER JOIN|OUTER JOIN|GROUP BY|ORDER BY|HAVING|LIMIT|UNION|INSERT INTO|UPDATE|DELETE FROM|SET|VALUES|CREATE|ALTER|DROP|TRUNCATE|BEGIN|COMMIT|ROLLBACK|CALL)\b/gi, '\n$1')
-            .replace(/,\s*/g, ',\n  ') // Add line breaks after commas
+            .replace(/\s+/g, " ") // Normalize whitespace
+            .replace(/\b(SELECT|FROM|WHERE|JOIN|LEFT JOIN|RIGHT JOIN|INNER JOIN|OUTER JOIN|GROUP BY|ORDER BY|HAVING|LIMIT|UNION|INSERT INTO|UPDATE|DELETE FROM|SET|VALUES|CREATE|ALTER|DROP|TRUNCATE|BEGIN|COMMIT|ROLLBACK|CALL)\b/gi, "\n$1")
+            .replace(/,\s*/g, ",\n  ") // Add line breaks after commas
             .trim();
     }
     /**
@@ -124,61 +134,72 @@ class QueryLogger {
      */
     static formatLogs(logs) {
         if (logs.length === 0)
-            return '';
-        return logs.map((log, index) => {
+            return "";
+        return logs
+            .map((log, index) => {
             // Format the SQL for better readability
             const formattedSQL = this.formatSQL(log.sql);
             // Format parameters
-            let paramStr = '';
+            let paramStr = "";
             if (log.params && log.params.length > 0) {
                 try {
                     const paramsJson = JSON.stringify(log.params, null, 2);
-                    paramStr = paramsJson.length > this.MAX_PARAM_LENGTH
-                        ? `\n📋 Parameters:\n${paramsJson.substring(0, this.MAX_PARAM_LENGTH)}...`
-                        : `\n📋 Parameters:\n${paramsJson}`;
+                    paramStr =
+                        paramsJson.length > this.MAX_PARAM_LENGTH
+                            ? `\n📋 Parameters:\n${paramsJson.substring(0, this.MAX_PARAM_LENGTH)}...`
+                            : `\n📋 Parameters:\n${paramsJson}`;
                 }
                 catch (error) {
-                    paramStr = '\n📋 Parameters: [Error serializing]';
+                    paramStr = "\n📋 Parameters: [Error serializing]";
                 }
             }
             // Format error if present
-            const errorStr = log.error ? `\n❌ Error: ${log.error}` : '';
+            const errorStr = log.error ? `\n❌ Error: ${log.error}` : "";
             // Format status with emoji for better visibility
-            const statusEmoji = log.status === 'success' ? '✅' : '❌';
-            const statusText = log.status === 'success' ? 'SUCCESS' : 'ERROR';
+            const statusEmoji = log.status === "success" ? "✅" : "❌";
+            const statusText = log.status === "success" ? "SUCCESS" : "ERROR";
+            // Format cache hit indicator
+            const cacheStr = log.cacheHit
+                ? "\n💾 Cache: HIT (served from cache)"
+                : "";
+            const cacheLabel = log.cacheHit ? " [CACHED]" : "";
             // Build the formatted log entry with clear visual hierarchy
             return `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-${statusEmoji} SQL Query #${index + 1} - ${statusText} 
+${statusEmoji} SQL Query #${index + 1} - ${statusText}${cacheLabel}
 ⏱️  Execution Time: ${log.duration}ms
-🕐 Timestamp: ${log.timestamp}
+🕐 Timestamp: ${log.timestamp}${cacheStr}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 📝 SQL Query:
 ${formattedSQL}${paramStr}${errorStr}`;
-        }).join('\n\n');
+        })
+            .join("\n\n");
     }
     /**
      * Get logs as compact formatted string (for backward compatibility)
      */
     static formatLogsCompact(logs) {
         if (logs.length === 0)
-            return '';
-        return logs.map((log, index) => {
-            let paramStr = '';
+            return "";
+        return logs
+            .map((log, index) => {
+            let paramStr = "";
             if (log.params && log.params.length > 0) {
                 try {
                     const paramsJson = JSON.stringify(log.params);
-                    paramStr = paramsJson.length > this.MAX_PARAM_LENGTH
-                        ? ` | Params: ${paramsJson.substring(0, this.MAX_PARAM_LENGTH)}...`
-                        : ` | Params: ${paramsJson}`;
+                    paramStr =
+                        paramsJson.length > this.MAX_PARAM_LENGTH
+                            ? ` | Params: ${paramsJson.substring(0, this.MAX_PARAM_LENGTH)}...`
+                            : ` | Params: ${paramsJson}`;
                 }
                 catch (error) {
-                    paramStr = ' | Params: [Error serializing]';
+                    paramStr = " | Params: [Error serializing]";
                 }
             }
-            const errorStr = log.error ? ` | Error: ${log.error}` : '';
+            const errorStr = log.error ? ` | Error: ${log.error}` : "";
             return `[${index + 1}] ${log.timestamp} | ${log.sql}${paramStr} | Duration: ${log.duration}ms | Status: ${log.status}${errorStr}`;
-        }).join('\n');
+        })
+            .join("\n");
     }
 }
 exports.QueryLogger = QueryLogger;