@berthojoris/mcp-mysql-server 1.4.14 → 1.5.0

package/dist/index.js

@@ -37,89 +37,89 @@ class MySQLMCP {
         if (!this.featureConfig.isToolEnabled(toolName)) {
             return {
                 enabled: false,
-                error: this.featureConfig.getPermissionError(toolName)
+                error: this.featureConfig.getPermissionError(toolName),
             };
         }
         return { enabled: true };
     }
     // Database Tools
     async listDatabases() {
-        const check = this.checkToolEnabled('listDatabases');
+        const check = this.checkToolEnabled("listDatabases");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dbTools.listDatabases();
     }
     async listTables(params) {
-        const check = this.checkToolEnabled('listTables');
+        const check = this.checkToolEnabled("listTables");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dbTools.listTables(params);
     }
     async readTableSchema(params) {
-        const check = this.checkToolEnabled('readTableSchema');
+        const check = this.checkToolEnabled("readTableSchema");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dbTools.readTableSchema(params);
     }
     // CRUD Tools
     async createRecord(params) {
-        const check = this.checkToolEnabled('createRecord');
+        const check = this.checkToolEnabled("createRecord");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.createRecord(params);
     }
     async readRecords(params) {
-        const check = this.checkToolEnabled('readRecords');
+        const check = this.checkToolEnabled("readRecords");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.readRecords(params);
     }
     async updateRecord(params) {
-        const check = this.checkToolEnabled('updateRecord');
+        const check = this.checkToolEnabled("updateRecord");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.updateRecord(params);
     }
     async deleteRecord(params) {
-        const check = this.checkToolEnabled('deleteRecord');
+        const check = this.checkToolEnabled("deleteRecord");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.crudTools.deleteRecord(params);
     }
     // Query Tools
     async runQuery(params) {
-        const check = this.checkToolEnabled('runQuery');
+        const check = this.checkToolEnabled("runQuery");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         // Additional security check
         if (!this.security.isReadOnlyQuery(params.query)) {
             return {
-                status: 'error',
-                error: 'Only SELECT queries are allowed with runQuery. Use executeSql for other operations.'
+                status: "error",
+                error: "Only SELECT queries are allowed with runQuery. Use executeSql for other operations.",
             };
         }
         return await this.queryTools.runQuery(params);
     }
     async executeSql(params) {
-        const check = this.checkToolEnabled('executeSql');
+        const check = this.checkToolEnabled("executeSql");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         // Additional security check - block DDL unless DDL permission is enabled
         if (this.security.hasDangerousOperations(params.query)) {
             // Check if DDL permission is enabled
-            if (!this.featureConfig.isCategoryEnabled('ddl')) {
+            if (!this.featureConfig.isCategoryEnabled("ddl")) {
                 return {
-                    status: 'error',
-                    error: 'DDL operations (DROP, TRUNCATE, ALTER, CREATE) require the "ddl" permission. Use executeDdl tool or add "ddl" to permissions.'
+                    status: "error",
+                    error: 'DDL operations (DROP, TRUNCATE, ALTER, CREATE) require the "ddl" permission. Use executeDdl tool or add "ddl" to permissions.',
                 };
             }
         }
@@ -127,178 +127,178 @@ class MySQLMCP {
     }
     // DDL Tools
     async createTable(params) {
-        const check = this.checkToolEnabled('createTable');
+        const check = this.checkToolEnabled("createTable");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.createTable(params);
     }
     async alterTable(params) {
-        const check = this.checkToolEnabled('alterTable');
+        const check = this.checkToolEnabled("alterTable");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.alterTable(params);
     }
     async dropTable(params) {
-        const check = this.checkToolEnabled('dropTable');
+        const check = this.checkToolEnabled("dropTable");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.dropTable(params);
     }
     async executeDdl(params) {
-        const check = this.checkToolEnabled('executeDdl');
+        const check = this.checkToolEnabled("executeDdl");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.ddlTools.executeDdl(params);
     }
     // Utility Tools
     async describeConnection() {
-        const check = this.checkToolEnabled('describeConnection');
+        const check = this.checkToolEnabled("describeConnection");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.utilityTools.describeConnection();
     }
     async testConnection() {
-        const check = this.checkToolEnabled('testConnection');
+        const check = this.checkToolEnabled("testConnection");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.utilityTools.testConnection();
     }
     async getTableRelationships(params) {
-        const check = this.checkToolEnabled('getTableRelationships');
+        const check = this.checkToolEnabled("getTableRelationships");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.utilityTools.getTableRelationships(params);
     }
     // Transaction Tools
     async beginTransaction(params) {
-        const check = this.checkToolEnabled('beginTransaction');
+        const check = this.checkToolEnabled("beginTransaction");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.beginTransaction(params);
     }
     async commitTransaction(params) {
-        const check = this.checkToolEnabled('commitTransaction');
+        const check = this.checkToolEnabled("commitTransaction");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.commitTransaction(params);
     }
     async rollbackTransaction(params) {
-        const check = this.checkToolEnabled('rollbackTransaction');
+        const check = this.checkToolEnabled("rollbackTransaction");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.rollbackTransaction(params);
     }
     async getTransactionStatus() {
-        const check = this.checkToolEnabled('getTransactionStatus');
+        const check = this.checkToolEnabled("getTransactionStatus");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.getTransactionStatus();
     }
     async executeInTransaction(params) {
-        const check = this.checkToolEnabled('executeSql'); // Use executeSql permission for transaction queries
+        const check = this.checkToolEnabled("executeSql"); // Use executeSql permission for transaction queries
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.transactionTools.executeInTransaction(params);
     }
     // Stored Procedure Tools
     async listStoredProcedures(params) {
-        const check = this.checkToolEnabled('listStoredProcedures');
+        const check = this.checkToolEnabled("listStoredProcedures");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.listStoredProcedures(params);
     }
     async getStoredProcedureInfo(params) {
-        const check = this.checkToolEnabled('getStoredProcedureInfo');
+        const check = this.checkToolEnabled("getStoredProcedureInfo");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.getStoredProcedureInfo(params);
     }
     async executeStoredProcedure(params) {
-        const check = this.checkToolEnabled('executeStoredProcedure');
+        const check = this.checkToolEnabled("executeStoredProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.executeStoredProcedure(params);
     }
     async createStoredProcedure(params) {
-        const check = this.checkToolEnabled('createStoredProcedure');
+        const check = this.checkToolEnabled("createStoredProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.createStoredProcedure(params);
     }
     async dropStoredProcedure(params) {
-        const check = this.checkToolEnabled('dropStoredProcedure');
+        const check = this.checkToolEnabled("dropStoredProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.dropStoredProcedure(params);
     }
     async showCreateProcedure(params) {
-        const check = this.checkToolEnabled('showCreateProcedure');
+        const check = this.checkToolEnabled("showCreateProcedure");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.storedProcedureTools.showCreateProcedure(params);
     }
     // Data Export Tools
     async exportTableToCSV(params) {
-        const check = this.checkToolEnabled('exportTableToCSV');
+        const check = this.checkToolEnabled("exportTableToCSV");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dataExportTools.exportTableToCSV(params);
     }
     async exportQueryToCSV(params) {
-        const check = this.checkToolEnabled('exportQueryToCSV');
+        const check = this.checkToolEnabled("exportQueryToCSV");
         if (!check.enabled) {
-            return { status: 'error', error: check.error };
+            return { status: "error", error: check.error };
         }
         return await this.dataExportTools.exportQueryToCSV(params);
     }
     // Get feature configuration status
     getFeatureStatus() {
         return {
-            status: 'success',
+            status: "success",
             data: {
                 enabledCategories: this.featureConfig.getEnabledCategories(),
-                categoryStatus: this.featureConfig.getCategoryStatus()
-            }
+                categoryStatus: this.featureConfig.getCategoryStatus(),
+            },
         };
     }
     /**
      * Bulk insert multiple records into the specified table
      */
     async bulkInsert(params) {
-        this.checkToolEnabled('bulk_insert');
+        this.checkToolEnabled("bulk_insert");
         return this.crudTools.bulkInsert(params);
     }
     /**
      * Bulk update multiple records with different conditions and data
      */
     async bulkUpdate(params) {
-        this.checkToolEnabled('bulk_update');
+        this.checkToolEnabled("bulk_update");
         return this.crudTools.bulkUpdate(params);
     }
     /**
      * Bulk delete records based on multiple condition sets
      */
     async bulkDelete(params) {
-        this.checkToolEnabled('bulk_delete');
+        this.checkToolEnabled("bulk_delete");
         return this.crudTools.bulkDelete(params);
     }
     // Close database connection
@@ -306,6 +306,97 @@ class MySQLMCP {
         const db = connection_1.default.getInstance();
         await db.closePool();
     }
+    // ==========================================
+    // Cache Management Methods
+    // ==========================================
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        const db = connection_1.default.getInstance();
+        return {
+            status: "success",
+            data: db.getCacheStats(),
+        };
+    }
+    /**
+     * Get cache configuration
+     */
+    getCacheConfig() {
+        const db = connection_1.default.getInstance();
+        return {
+            status: "success",
+            data: db.getCacheConfig(),
+        };
+    }
+    /**
+     * Configure cache settings
+     */
+    configureCacheSettings(params) {
+        const db = connection_1.default.getInstance();
+        db.setCacheConfig(params);
+        return {
+            status: "success",
+            data: {
+                message: "Cache configuration updated successfully",
+                config: db.getCacheConfig(),
+            },
+        };
+    }
+    /**
+     * Clear the query cache
+     */
+    clearCache() {
+        const db = connection_1.default.getInstance();
+        const clearedCount = db.clearCache();
+        return {
+            status: "success",
+            data: {
+                message: `Cache cleared successfully`,
+                entriesCleared: clearedCount,
+            },
+        };
+    }
+    /**
+     * Invalidate cache for a specific table
+     */
+    invalidateCacheForTable(params) {
+        const db = connection_1.default.getInstance();
+        const invalidatedCount = db.invalidateCacheForTable(params.table_name);
+        return {
+            status: "success",
+            data: {
+                message: `Cache invalidated for table '${params.table_name}'`,
+                entriesInvalidated: invalidatedCount,
+            },
+        };
+    }
+    // ==========================================
+    // Query Optimization Methods
+    // ==========================================
+    /**
+     * Analyze a query and get optimization suggestions
+     */
+    analyzeQuery(params) {
+        const analysis = this.queryTools.analyzeQuery(params.query);
+        return {
+            status: "success",
+            data: analysis,
+        };
+    }
+    /**
+     * Get suggested optimizer hints for a specific optimization goal
+     */
+    getOptimizationHints(params) {
+        const hints = this.queryTools.getSuggestedHints(params.goal);
+        return {
+            status: "success",
+            data: {
+                goal: params.goal,
+                hints,
+            },
+        };
+    }
 }
 exports.MySQLMCP = MySQLMCP;
 exports.default = MySQLMCP;

package/dist/mcp-server.js

@@ -316,7 +316,7 @@ const TOOLS = [
     },
     {
         name: "run_query",
-        description: "Runs a read-only SQL SELECT query with optional parameters. Only SELECT statements are allowed.",
+        description: "Runs a read-only SQL SELECT query with optional parameters, optimizer hints, and caching support. Only SELECT statements are allowed.",
         inputSchema: {
             type: "object",
             properties: {
@@ -329,6 +329,50 @@ const TOOLS = [
                     description: "Optional array of parameters for parameterized queries",
                     items: {},
                 },
+                hints: {
+                    type: "object",
+                    description: "Optional MySQL optimizer hints to apply to the query",
+                    properties: {
+                        maxExecutionTime: {
+                            type: "number",
+                            description: "Maximum execution time in milliseconds",
+                        },
+                        forceIndex: {
+                            oneOf: [
+                                { type: "string" },
+                                { type: "array", items: { type: "string" } },
+                            ],
+                            description: "Force usage of specific index(es)",
+                        },
+                        ignoreIndex: {
+                            oneOf: [
+                                { type: "string" },
+                                { type: "array", items: { type: "string" } },
+                            ],
+                            description: "Ignore specific index(es)",
+                        },
+                        straightJoin: {
+                            type: "boolean",
+                            description: "Use STRAIGHT_JOIN to force join order",
+                        },
+                        noCache: {
+                            type: "boolean",
+                            description: "Disable query cache for this query",
+                        },
+                        sqlBigResult: {
+                            type: "boolean",
+                            description: "Optimize for large result sets",
+                        },
+                        sqlSmallResult: {
+                            type: "boolean",
+                            description: "Optimize for small result sets",
+                        },
+                    },
+                },
+                useCache: {
+                    type: "boolean",
+                    description: "Whether to use query result caching (default: true)",
+                },
             },
             required: ["query"],
         },
@@ -806,6 +850,100 @@ const TOOLS = [
             required: ["query"],
         },
     },
+    // Cache Management Tools
+    {
+        name: "get_cache_stats",
+        description: "Get query cache statistics including hit rate, size, and configuration.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "get_cache_config",
+        description: "Get current cache configuration settings.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "configure_cache",
+        description: "Configure cache settings including TTL, max size, and enable/disable.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    description: "Enable or disable the query cache",
+                },
+                ttlMs: {
+                    type: "number",
+                    description: "Cache time-to-live in milliseconds (default: 60000)",
+                },
+                maxSize: {
+                    type: "number",
+                    description: "Maximum number of cached entries (default: 100)",
+                },
+                maxMemoryMB: {
+                    type: "number",
+                    description: "Maximum memory usage in MB (default: 50)",
+                },
+            },
+        },
+    },
+    {
+        name: "clear_cache",
+        description: "Clear all entries from the query cache.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "invalidate_table_cache",
+        description: "Invalidate all cached queries related to a specific table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to invalidate cache for",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    // Query Optimization Tools
+    {
+        name: "analyze_query",
+        description: "Analyze a SQL query and get optimization suggestions including recommended indexes and hints.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "SQL query to analyze",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_optimization_hints",
+        description: "Get suggested MySQL optimizer hints for a specific optimization goal (SPEED, MEMORY, or STABILITY).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                goal: {
+                    type: "string",
+                    enum: ["SPEED", "MEMORY", "STABILITY"],
+                    description: "Optimization goal: SPEED for faster queries, MEMORY for lower memory usage, STABILITY for consistent performance",
+                },
+            },
+            required: ["goal"],
+        },
+    },
 ];
 // Create the MCP server
 const server = new index_js_1.Server({
@@ -927,14 +1065,37 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "export_query_to_csv":
                 result = await mysqlMCP.exportQueryToCSV((args || {}));
                 break;
+            // Cache Management Tools
+            case "get_cache_stats":
+                result = mysqlMCP.getCacheStats();
+                break;
+            case "get_cache_config":
+                result = mysqlMCP.getCacheConfig();
+                break;
+            case "configure_cache":
+                result = mysqlMCP.configureCacheSettings((args || {}));
+                break;
+            case "clear_cache":
+                result = mysqlMCP.clearCache();
+                break;
+            case "invalidate_table_cache":
+                result = mysqlMCP.invalidateCacheForTable((args || {}));
+                break;
+            // Query Optimization Tools
+            case "analyze_query":
+                result = mysqlMCP.analyzeQuery((args || {}));
+                break;
+            case "get_optimization_hints":
+                result = mysqlMCP.getOptimizationHints((args || {}));
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
         // Handle the result based on status
         if (result.status === "error") {
             // Include query log in error response if available
-            let errorText = `Error: ${result.error}`;
-            if ('queryLog' in result && result.queryLog) {
+            let errorText = `Error: ${"error" in result ? result.error : "Unknown error"}`;
+            if ("queryLog" in result && result.queryLog) {
                 errorText += `\n\n${result.queryLog}`;
             }
             return {
@@ -975,11 +1136,11 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         }
         // NEW APPROACH: Wrap the data with SQL query as part of the response structure
         // This forces the LLM to see and describe the SQL query as part of the data
-        if ('queryLog' in result && result.queryLog) {
+        if ("queryLog" in result && result.queryLog) {
             const wrappedResponse = {
                 "⚠️ IMPORTANT_INSTRUCTION_TO_ASSISTANT": "ALWAYS display the SQL query execution details below to the user in your response. This is critical information that users need to see.",
                 "⚠️ SQL_QUERY_EXECUTED": result.queryLog,
-                "📊 RESULTS": responseData
+                "📊 RESULTS": responseData,
             };
             return {
                 content: [