@berthojoris/mcp-mysql-server 1.4.15 → 1.5.0

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;

package/dist/index.d.ts

@@ -55,7 +55,7 @@ export declare class MySQLMCP {
         };
         sorting?: {
             field: string;
-            direction: 'asc' | 'desc';
+            direction: "asc" | "desc";
         };
     }): Promise<{
         status: string;
@@ -95,6 +95,7 @@ export declare class MySQLMCP {
         data?: any[];
         error?: string;
         queryLog?: string;
+        optimizedQuery?: string;
     }>;
     executeSql(params: {
         query: string;
@@ -214,7 +215,7 @@ export declare class MySQLMCP {
         procedure_name: string;
         parameters?: Array<{
             name: string;
-            mode: 'IN' | 'OUT' | 'INOUT';
+            mode: "IN" | "OUT" | "INOUT";
             data_type: string;
         }>;
         body: string;
@@ -251,7 +252,7 @@ export declare class MySQLMCP {
         };
         sorting?: {
             field: string;
-            direction: 'asc' | 'desc';
+            direction: "asc" | "desc";
         };
         include_headers?: boolean;
     }): Promise<{
@@ -317,5 +318,77 @@ export declare class MySQLMCP {
         error?: string;
     }>;
     close(): Promise<void>;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        status: string;
+        data: import("./cache/queryCache").CacheStats;
+    };
+    /**
+     * Get cache configuration
+     */
+    getCacheConfig(): {
+        status: string;
+        data: import("./cache/queryCache").CacheConfig;
+    };
+    /**
+     * Configure cache settings
+     */
+    configureCacheSettings(params: {
+        enabled?: boolean;
+        ttlMs?: number;
+        maxSize?: number;
+        maxMemoryMB?: number;
+    }): {
+        status: string;
+        data: {
+            message: string;
+            config: import("./cache/queryCache").CacheConfig;
+        };
+    };
+    /**
+     * Clear the query cache
+     */
+    clearCache(): {
+        status: string;
+        data: {
+            message: string;
+            entriesCleared: number;
+        };
+    };
+    /**
+     * Invalidate cache for a specific table
+     */
+    invalidateCacheForTable(params: {
+        table_name: string;
+    }): {
+        status: string;
+        data: {
+            message: string;
+            entriesInvalidated: number;
+        };
+    };
+    /**
+     * Analyze a query and get optimization suggestions
+     */
+    analyzeQuery(params: {
+        query: string;
+    }): {
+        status: string;
+        data: import("./optimization/queryOptimizer").QueryAnalysis;
+    };
+    /**
+     * Get suggested optimizer hints for a specific optimization goal
+     */
+    getOptimizationHints(params: {
+        goal: "SPEED" | "MEMORY" | "STABILITY";
+    }): {
+        status: string;
+        data: {
+            goal: "SPEED" | "MEMORY" | "STABILITY";
+            hints: import("./optimization/queryOptimizer").QueryHints;
+        };
+    };
 }
 export default MySQLMCP;