@berthojoris/mcp-mysql-server 1.16.4 → 1.18.0

package/dist/index.d.ts

@@ -31,9 +31,13 @@ export declare class MySQLMCP {
     private schemaDesignTools;
     private securityAuditTools;
     private indexRecommendationTools;
+    private testDataTools;
+    private schemaPatternTools;
+    private queryVisualizationTools;
+    private forecastingTools;
     private security;
     private featureConfig;
-    constructor(permissionsConfig?: string, categoriesConfig?: string, presetName?: string);
+    constructor(permissionsConfig?: string, categoriesConfig?: string);
     private checkToolEnabled;
     listDatabases(): Promise<{
         status: string;
@@ -619,17 +623,12 @@ export declare class MySQLMCP {
         status: string;
         data: {
             config: {
-                preset?: {
-                    name: string;
-                    description: string;
-                };
                 permissions: string;
                 categories: string;
                 filteringMode: string;
                 enabledLegacy: import("./config/featureConfig").ToolCategory[];
                 enabledDoc: import("./config/featureConfig").DocCategory[];
             };
-            preset: import("./config/featureConfig").PermissionPreset | undefined;
             filteringMode: string;
             enabledCategories: import("./config/featureConfig").ToolCategory[];
             categoryStatus: Record<import("./config/featureConfig").ToolCategory, boolean>;
@@ -643,13 +642,9 @@ export declare class MySQLMCP {
      */
     isToolEnabled(toolName: string): boolean;
     /**
-     * Expose resolved access profile (preset + merged permissions/categories)
+     * Expose resolved access profile (resolved permissions/categories)
      */
     getAccessProfile(): {
-        preset?: {
-            name: string;
-            description: string;
-        };
         permissions: string;
         categories: string;
         filteringMode: string;
@@ -1314,7 +1309,9 @@ export declare class MySQLMCP {
                 column_name: string;
                 pattern_type: string;
                 description: string;
-                metrics?: Record<string, any>;
+                metrics? /**
+                 * Get current schema version
+                 */: Record<string, any>;
                 recommendations?: string[];
             }>;
             summary: {
@@ -1512,5 +1509,55 @@ export declare class MySQLMCP {
         };
         error?: string;
     }>;
+    generateTestData(params: {
+        table_name: string;
+        row_count: number;
+        batch_size?: number;
+        include_nulls?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    analyzeSchemaPatterns(params?: {
+        scope?: "database" | "table";
+        table_name?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    visualizeQuery(params: {
+        query: string;
+        include_explain_json?: boolean;
+        format?: "mermaid" | "json" | "both";
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    predictQueryPerformance(params: {
+        query: string;
+        row_growth_multiplier?: number;
+        per_table_row_growth?: Record<string, number>;
+        include_explain_json?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    forecastDatabaseGrowth(params?: {
+        horizon_days?: number;
+        growth_rate_percent_per_day?: number;
+        growth_rate_percent_per_month?: number;
+        per_table_growth_rate_percent_per_day?: Record<string, number>;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
 }
 export default MySQLMCP;

package/dist/index.js

@@ -32,6 +32,10 @@ const documentationGeneratorTools_1 = require("./tools/documentationGeneratorToo
 const schemaDesignTools_1 = require("./tools/schemaDesignTools");
 const securityAuditTools_1 = require("./tools/securityAuditTools");
 const indexRecommendationTools_1 = require("./tools/indexRecommendationTools");
+const testDataTools_1 = require("./tools/testDataTools");
+const schemaPatternTools_1 = require("./tools/schemaPatternTools");
+const queryVisualizationTools_1 = require("./tools/queryVisualizationTools");
+const forecastingTools_1 = require("./tools/forecastingTools");
 const securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -40,8 +44,8 @@ const featureConfig_1 = require("./config/featureConfig");
  * A secure interface for AI models to interact with MySQL databases
  */
 class MySQLMCP {
-    constructor(permissionsConfig, categoriesConfig, presetName) {
-        this.featureConfig = new featureConfig_1.FeatureConfig(permissionsConfig, categoriesConfig, presetName);
+    constructor(permissionsConfig, categoriesConfig) {
+        this.featureConfig = new featureConfig_1.FeatureConfig(permissionsConfig, categoriesConfig);
         this.security = new securityLayer_1.default(this.featureConfig);
         this.dbTools = new databaseTools_1.DatabaseTools();
         this.crudTools = new crudTools_1.CrudTools(this.security);
@@ -72,6 +76,10 @@ class MySQLMCP {
         this.schemaDesignTools = new schemaDesignTools_1.SchemaDesignTools(this.security);
         this.securityAuditTools = new securityAuditTools_1.SecurityAuditTools();
         this.indexRecommendationTools = new indexRecommendationTools_1.IndexRecommendationTools(this.security);
+        this.testDataTools = new testDataTools_1.TestDataTools(this.security);
+        this.schemaPatternTools = new schemaPatternTools_1.SchemaPatternTools(this.security);
+        this.queryVisualizationTools = new queryVisualizationTools_1.QueryVisualizationTools(this.security);
+        this.forecastingTools = new forecastingTools_1.ForecastingTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -572,7 +580,6 @@ class MySQLMCP {
             status: "success",
             data: {
                 config: snapshot,
-                preset: this.featureConfig.getActivePreset(),
                 filteringMode: this.featureConfig.getFilteringMode(),
                 enabledCategories: this.featureConfig.getEnabledCategories(),
                 categoryStatus: this.featureConfig.getCategoryStatus(),
@@ -589,7 +596,7 @@ class MySQLMCP {
         return this.featureConfig.isToolEnabled(toolName);
     }
     /**
-     * Expose resolved access profile (preset + merged permissions/categories)
+     * Expose resolved access profile (resolved permissions/categories)
      */
     getAccessProfile() {
         return this.featureConfig.getConfigSnapshot();
@@ -1155,6 +1162,39 @@ class MySQLMCP {
             return { status: "error", error: check.error };
         return await this.indexRecommendationTools.recommendIndexes(params);
     }
+    // ==========================================
+    // PHASE 3: AI Enhancement Tools (Data Gen + Patterns + Visualization + Forecasting)
+    // ==========================================
+    async generateTestData(params) {
+        const check = this.checkToolEnabled("generateTestData");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.testDataTools.generateTestData(params);
+    }
+    async analyzeSchemaPatterns(params) {
+        const check = this.checkToolEnabled("analyzeSchemaPatterns");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.schemaPatternTools.analyzeSchemaPatterns(params);
+    }
+    async visualizeQuery(params) {
+        const check = this.checkToolEnabled("visualizeQuery");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.queryVisualizationTools.visualizeQuery(params);
+    }
+    async predictQueryPerformance(params) {
+        const check = this.checkToolEnabled("predictQueryPerformance");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.forecastingTools.predictQueryPerformance(params);
+    }
+    async forecastDatabaseGrowth(params) {
+        const check = this.checkToolEnabled("forecastDatabaseGrowth");
+        if (!check.enabled)
+            return { status: "error", error: check.error };
+        return await this.forecastingTools.forecastDatabaseGrowth(params);
+    }
 }
 exports.MySQLMCP = MySQLMCP;
 exports.default = MySQLMCP;

package/dist/mcp-server.js

@@ -10,7 +10,6 @@ const index_js_2 = require("./index.js");
 // Layer 2 (Categories): MCP_CATEGORIES (optional, for fine-grained control)
 const permissions = process.env.MCP_PERMISSIONS || process.env.MCP_CONFIG || "";
 const categories = process.env.MCP_CATEGORIES || "";
-const preset = process.env.MCP_PRESET || process.env.MCP_PERMISSION_PRESET || "";
 // Declare the MySQL MCP instance (will be initialized in main())
 let mysqlMCP;
 // Define all available tools with their schemas
@@ -2992,6 +2991,141 @@ const TOOLS = [
             },
         },
     },
+    // ==========================================
+    // PHASE 3: AI Enhancement Tools (Data Gen + Patterns + Visualization + Forecasting)
+    // ==========================================
+    {
+        name: "generate_test_data",
+        description: "Generates synthetic test data as SQL INSERT statements for a given table (does not execute). Attempts FK-aware value selection for referential integrity.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Target table to generate INSERT statements for",
+                },
+                row_count: {
+                    type: "number",
+                    description: "Number of rows to generate (max 5000)",
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Rows per INSERT statement (default 100, max 1000)",
+                },
+                include_nulls: {
+                    type: "boolean",
+                    description: "Whether generated values may include NULLs when columns are nullable (default true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "row_count"],
+        },
+    },
+    {
+        name: "analyze_schema_patterns",
+        description: "Analyzes the schema for common patterns and anti-patterns (missing PKs, wide tables, unindexed FKs, EAV-like tables, etc.) and returns recommendations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scope: {
+                    type: "string",
+                    enum: ["database", "table"],
+                    description: "Analysis scope (default: database unless table_name provided)",
+                },
+                table_name: {
+                    type: "string",
+                    description: "Optional: specific table to analyze (implies table scope)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "visualize_query",
+        description: "Creates a visual representation of a read-only SQL query as a Mermaid flowchart, based on EXPLAIN FORMAT=JSON and lightweight SQL parsing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Read-only SQL query to visualize",
+                },
+                include_explain_json: {
+                    type: "boolean",
+                    description: "Include full EXPLAIN JSON in the response (default true)",
+                },
+                format: {
+                    type: "string",
+                    enum: ["mermaid", "json", "both"],
+                    description: "Output format (default: both)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "predict_query_performance",
+        description: "Predicts how EXPLAIN-estimated scan volume/cost could change under table growth assumptions (heuristic).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Read-only SQL query to analyze",
+                },
+                row_growth_multiplier: {
+                    type: "number",
+                    description: "Default multiplicative growth factor to apply to table row estimates (default 2)",
+                },
+                per_table_row_growth: {
+                    type: "object",
+                    description: "Optional per-table growth overrides: { tableName: factor }",
+                    additionalProperties: { type: "number" },
+                },
+                include_explain_json: {
+                    type: "boolean",
+                    description: "Include full EXPLAIN JSON in the response (default false)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "forecast_database_growth",
+        description: "Forecasts database/table growth based on current INFORMATION_SCHEMA sizes and user-supplied growth rate assumptions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                horizon_days: {
+                    type: "number",
+                    description: "Forecast horizon in days (default 30, max 3650)",
+                },
+                growth_rate_percent_per_day: {
+                    type: "number",
+                    description: "Base daily growth rate percent applied to all tables unless overridden (e.g., 0.5)",
+                },
+                growth_rate_percent_per_month: {
+                    type: "number",
+                    description: "Base monthly growth rate percent (converted to daily compound rate)",
+                },
+                per_table_growth_rate_percent_per_day: {
+                    type: "object",
+                    description: "Optional per-table daily growth rate percent overrides: { tableName: percentPerDay }",
+                    additionalProperties: { type: "number" },
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
     // Smart Data Discovery
     {
         name: "smart_search",
@@ -3179,7 +3313,7 @@ const TOOLS = [
 // Create the MCP server
 const server = new index_js_1.Server({
     name: "mysql-mcp-server",
-    version: "1.12.0",
+    version: "1.17.0",
 }, {
     capabilities: {
         tools: {},
@@ -3652,6 +3786,24 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "recommend_indexes":
                 result = await mysqlMCP.recommendIndexes((args || {}));
                 break;
+            // ==========================================
+            // PHASE 3: AI Enhancement Tools (Data Gen + Patterns + Visualization + Forecasting)
+            // ==========================================
+            case "generate_test_data":
+                result = await mysqlMCP.generateTestData((args || {}));
+                break;
+            case "analyze_schema_patterns":
+                result = await mysqlMCP.analyzeSchemaPatterns((args || {}));
+                break;
+            case "visualize_query":
+                result = await mysqlMCP.visualizeQuery((args || {}));
+                break;
+            case "predict_query_performance":
+                result = await mysqlMCP.predictQueryPerformance((args || {}));
+                break;
+            case "forecast_database_growth":
+                result = await mysqlMCP.forecastDatabaseGrowth((args || {}));
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -3735,15 +3887,9 @@ async function main() {
     await server.connect(transport);
     // Initialize the MySQL MCP instance AFTER transport is connected
     // This ensures the database connection pool is created when the server is ready
-    mysqlMCP = new index_js_2.MySQLMCP(permissions, categories, preset);
+    mysqlMCP = new index_js_2.MySQLMCP(permissions, categories);
     // Log the effective filtering configuration to stderr
     const accessProfile = mysqlMCP.getAccessProfile();
-    if (accessProfile.preset) {
-        console.error(`Preset: ${accessProfile.preset.name} (${accessProfile.preset.description})`);
-    }
-    else if (preset) {
-        console.error(`Preset requested but not recognized: ${preset}`);
-    }
     console.error(`Permissions (resolved): ${accessProfile.permissions}`);
     if (accessProfile.categories) {
         console.error(`Categories (resolved): ${accessProfile.categories}`);

package/dist/security/securityLayer.js

@@ -11,9 +11,8 @@ class SecurityLayer {
     constructor(featureConfig) {
         this.ajv = new ajv_1.default();
         this.featureConfig = featureConfig || new featureConfig_js_1.FeatureConfig();
-        // Initialize masking layer from environment variable
-        const maskingProfile = process.env.MCP_MASKING_PROFILE || "none";
-        this.masking = new maskingLayer_js_1.MaskingLayer(maskingProfile);
+        // Masking is intentionally not configurable via environment variables.
+        this.masking = new maskingLayer_js_1.MaskingLayer("none");
         // Define dangerous SQL keywords that should ALWAYS be blocked (critical security threats)
         // These are blocked even with 'execute' permission
         // Note: Avoid blocking common table/column names like "user" or "password"

package/dist/tools/forecastingTools.d.ts

@@ -0,0 +1,36 @@
+import { SecurityLayer } from "../security/securityLayer";
+export declare class ForecastingTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    private validateDatabaseAccess;
+    private extractExplainNodes;
+    /**
+     * Predict how query cost/scan volume might change under table growth assumptions.
+     * This is heuristic-based and uses EXPLAIN FORMAT=JSON estimates.
+     */
+    predictQueryPerformance(params: {
+        query: string;
+        row_growth_multiplier?: number;
+        per_table_row_growth?: Record<string, number>;
+        include_explain_json?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Forecast database/table growth based on current sizes and user-supplied growth rate assumptions.
+     */
+    forecastDatabaseGrowth(params?: {
+        horizon_days?: number;
+        growth_rate_percent_per_day?: number;
+        growth_rate_percent_per_month?: number;
+        per_table_growth_rate_percent_per_day?: Record<string, number>;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}