@berthojoris/mcp-mysql-server 1.4.15 → 1.5.0

package/dist/cache/queryCache.js

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryCache = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Default cache configuration
+ */
+const DEFAULT_CONFIG = {
+    enabled: true,
+    ttlMs: 60000, // 1 minute default TTL
+    maxSize: 100, // Maximum 100 cached queries
+    maxMemoryMB: 50, // Maximum 50MB memory usage
+};
+/**
+ * LRU Query Cache with TTL support
+ * Implements an in-memory cache for query results to improve performance
+ */
+class QueryCache {
+    constructor() {
+        this.cache = new Map();
+        this.config = { ...DEFAULT_CONFIG };
+        this.stats = { totalHits: 0, totalMisses: 0 };
+        this.accessOrder = [];
+        // Load config from environment if available
+        this.loadConfigFromEnv();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!QueryCache.instance) {
+            QueryCache.instance = new QueryCache();
+        }
+        return QueryCache.instance;
+    }
+    /**
+     * Load cache configuration from environment variables
+     */
+    loadConfigFromEnv() {
+        if (process.env.CACHE_ENABLED !== undefined) {
+            this.config.enabled = process.env.CACHE_ENABLED === "true";
+        }
+        if (process.env.CACHE_TTL_MS) {
+            const ttl = parseInt(process.env.CACHE_TTL_MS, 10);
+            if (!isNaN(ttl) && ttl > 0) {
+                this.config.ttlMs = ttl;
+            }
+        }
+        if (process.env.CACHE_MAX_SIZE) {
+            const maxSize = parseInt(process.env.CACHE_MAX_SIZE, 10);
+            if (!isNaN(maxSize) && maxSize > 0) {
+                this.config.maxSize = maxSize;
+            }
+        }
+        if (process.env.CACHE_MAX_MEMORY_MB) {
+            const maxMemory = parseInt(process.env.CACHE_MAX_MEMORY_MB, 10);
+            if (!isNaN(maxMemory) && maxMemory > 0) {
+                this.config.maxMemoryMB = maxMemory;
+            }
+        }
+    }
+    /**
+     * Generate a unique hash for a query and its parameters
+     */
+    generateHash(sql, params) {
+        const normalized = sql.trim().toLowerCase();
+        let paramsStr = "";
+        if (params) {
+            try {
+                paramsStr = JSON.stringify(params);
+            }
+            catch {
+                // Handle circular references or non-serializable values
+                paramsStr = params
+                    .map((p) => {
+                    if (p === null)
+                        return "null";
+                    if (p === undefined)
+                        return "undefined";
+                    if (typeof p === "object") {
+                        try {
+                            return JSON.stringify(p);
+                        }
+                        catch {
+                            return String(p);
+                        }
+                    }
+                    return String(p);
+                })
+                    .join(",");
+            }
+        }
+        const combined = `${normalized}:${paramsStr}`;
+        return crypto_1.default.createHash("md5").update(combined).digest("hex");
+    }
+    /**
+     * Check if a query result is cached and valid
+     */
+    get(sql, params) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        const hash = this.generateHash(sql, params);
+        const entry = this.cache.get(hash);
+        if (!entry) {
+            this.stats.totalMisses++;
+            return null;
+        }
+        // Check if entry has expired
+        const now = Date.now();
+        if (now - entry.timestamp > this.config.ttlMs) {
+            this.cache.delete(hash);
+            this.removeFromAccessOrder(hash);
+            this.stats.totalMisses++;
+            return null;
+        }
+        // Update hit count and access order
+        entry.hitCount++;
+        this.updateAccessOrder(hash);
+        this.stats.totalHits++;
+        // Return a deep copy to prevent mutation of cached data
+        return {
+            ...entry,
+            data: JSON.parse(JSON.stringify(entry.data)),
+        };
+    }
+    /**
+     * Cache a query result
+     */
+    set(sql, params, data) {
+        if (!this.config.enabled) {
+            return;
+        }
+        // Only cache SELECT queries
+        const normalizedSql = sql.trim().toUpperCase();
+        if (!normalizedSql.startsWith("SELECT")) {
+            return;
+        }
+        const hash = this.generateHash(sql, params);
+        // Check if we need to evict entries
+        this.evictIfNeeded();
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            hitCount: 0,
+            queryHash: hash,
+            sql,
+            params,
+        };
+        this.cache.set(hash, entry);
+        this.updateAccessOrder(hash);
+    }
+    /**
+     * Invalidate cache entries matching a pattern
+     * Used when data is modified (INSERT, UPDATE, DELETE)
+     */
+    invalidate(pattern) {
+        let invalidatedCount = 0;
+        if (!pattern) {
+            // Clear all cache
+            invalidatedCount = this.cache.size;
+            this.cache.clear();
+            this.accessOrder = [];
+            return invalidatedCount;
+        }
+        const regex = typeof pattern === "string" ? new RegExp(pattern, "i") : pattern;
+        for (const [hash, entry] of this.cache.entries()) {
+            if (regex.test(entry.sql)) {
+                this.cache.delete(hash);
+                this.removeFromAccessOrder(hash);
+                invalidatedCount++;
+            }
+        }
+        return invalidatedCount;
+    }
+    /**
+     * Escape special regex characters in a string
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    /**
+     * Invalidate cache entries related to a specific table
+     */
+    invalidateTable(tableName) {
+        // Escape special regex characters in table name to prevent regex injection
+        const escapedTableName = this.escapeRegex(tableName);
+        // Match table name in various SQL patterns
+        const patterns = [
+            new RegExp(`\\bFROM\\s+[\`"']?${escapedTableName}[\`"']?\\b`, "i"),
+            new RegExp(`\\bJOIN\\s+[\`"']?${escapedTableName}[\`"']?\\b`, "i"),
+            new RegExp(`\\b${escapedTableName}\\b`, "i"),
+        ];
+        let invalidatedCount = 0;
+        for (const [hash, entry] of this.cache.entries()) {
+            for (const pattern of patterns) {
+                if (pattern.test(entry.sql)) {
+                    this.cache.delete(hash);
+                    this.removeFromAccessOrder(hash);
+                    invalidatedCount++;
+                    break;
+                }
+            }
+        }
+        return invalidatedCount;
+    }
+    /**
+     * Evict least recently used entries if cache is full
+     */
+    evictIfNeeded() {
+        // Check size limit
+        while (this.cache.size >= this.config.maxSize &&
+            this.accessOrder.length > 0) {
+            const lruHash = this.accessOrder.shift();
+            if (lruHash) {
+                this.cache.delete(lruHash);
+            }
+        }
+        // Check memory limit (approximate) - recalculate each iteration
+        const maxMemoryBytes = this.config.maxMemoryMB * 1024 * 1024;
+        while (this.estimateMemoryUsage() > maxMemoryBytes &&
+            this.accessOrder.length > 0) {
+            const lruHash = this.accessOrder.shift();
+            if (lruHash) {
+                this.cache.delete(lruHash);
+            }
+        }
+        // Also evict expired entries
+        const now = Date.now();
+        const expiredHashes = [];
+        for (const [hash, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.config.ttlMs) {
+                expiredHashes.push(hash);
+            }
+        }
+        // Delete after iteration to avoid modifying map during iteration
+        for (const hash of expiredHashes) {
+            this.cache.delete(hash);
+            this.removeFromAccessOrder(hash);
+        }
+    }
+    /**
+     * Update access order for LRU tracking
+     */
+    updateAccessOrder(hash) {
+        this.removeFromAccessOrder(hash);
+        this.accessOrder.push(hash);
+    }
+    /**
+     * Remove hash from access order
+     */
+    removeFromAccessOrder(hash) {
+        const index = this.accessOrder.indexOf(hash);
+        if (index > -1) {
+            this.accessOrder.splice(index, 1);
+        }
+    }
+    /**
+     * Estimate memory usage of the cache
+     */
+    estimateMemoryUsage() {
+        let totalSize = 0;
+        for (const [, entry] of this.cache.entries()) {
+            totalSize += JSON.stringify(entry).length * 2; // UTF-16 encoding
+        }
+        return totalSize;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const totalRequests = this.stats.totalHits + this.stats.totalMisses;
+        return {
+            totalHits: this.stats.totalHits,
+            totalMisses: this.stats.totalMisses,
+            hitRate: totalRequests > 0 ? this.stats.totalHits / totalRequests : 0,
+            currentSize: this.cache.size,
+            maxSize: this.config.maxSize,
+            ttlMs: this.config.ttlMs,
+            enabled: this.config.enabled,
+        };
+    }
+    /**
+     * Get current cache configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update cache configuration
+     */
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+        // If cache is disabled, clear it
+        if (!this.config.enabled) {
+            this.clear();
+        }
+    }
+    /**
+     * Enable caching
+     */
+    enable() {
+        this.config.enabled = true;
+    }
+    /**
+     * Disable caching
+     */
+    disable() {
+        this.config.enabled = false;
+        this.clear();
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        this.accessOrder = [];
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats.totalHits = 0;
+        this.stats.totalMisses = 0;
+    }
+    /**
+     * Get all cached entries (for debugging)
+     */
+    getAllEntries() {
+        return Array.from(this.cache.values());
+    }
+}
+exports.QueryCache = QueryCache;
+exports.default = QueryCache;

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;