@berthojoris/mcp-mysql-server 1.40.6 → 1.42.0

package/dist/tools/toolArgumentValidation.js

@@ -2,6 +2,108 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateToolArguments = validateToolArguments;
 const inputValidation_js_1 = require("../validation/inputValidation.js");
+const validatePlanSeedDataArgs = (args) => {
+    const errors = [];
+    if (!Array.isArray(args.target_tables) || args.target_tables.length === 0) {
+        errors.push("target_tables must be a non-empty array");
+    }
+    else {
+        for (const table of args.target_tables) {
+            const validation = (0, inputValidation_js_1.validateTableName)(table);
+            if (!validation.valid) {
+                errors.push(`Invalid target table '${table}': ${validation.error}`);
+            }
+        }
+    }
+    if (args.database !== undefined) {
+        const validation = (0, inputValidation_js_1.validateValue)(args.database);
+        if (!validation.valid)
+            errors.push(validation.error || "Invalid database name");
+    }
+    validateRowsPerTable(args.rows_per_table, errors);
+    return errors.length ? { valid: false, errors } : { valid: true };
+};
+const validateRowsPerTable = (rowsPerTable, errors) => {
+    if (rowsPerTable === undefined)
+        return;
+    if (typeof rowsPerTable === "number") {
+        if (!Number.isFinite(rowsPerTable) || rowsPerTable < 0) {
+            errors.push("rows_per_table must be a non-negative number");
+        }
+        return;
+    }
+    if (typeof rowsPerTable === "object" && rowsPerTable !== null && !Array.isArray(rowsPerTable)) {
+        for (const [table, count] of Object.entries(rowsPerTable)) {
+            const tableValidation = (0, inputValidation_js_1.validateTableName)(table);
+            if (!tableValidation.valid)
+                errors.push(`Invalid rows_per_table key '${table}': ${tableValidation.error}`);
+            if (typeof count !== "number" || !Number.isFinite(count) || count < 0) {
+                errors.push(`rows_per_table.${table} must be a non-negative number`);
+            }
+        }
+        return;
+    }
+    errors.push("rows_per_table must be a number or object map");
+};
+const validateTableList = (value, key, errors) => {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value)) {
+        errors.push(`${key} must be an array`);
+        return;
+    }
+    for (const table of value) {
+        const validation = (0, inputValidation_js_1.validateTableName)(table);
+        if (!validation.valid)
+            errors.push(`Invalid ${key} table '${table}': ${validation.error}`);
+    }
+};
+const validateInferSeedRulesArgs = (args) => {
+    const errors = [];
+    if (args.database !== undefined) {
+        const validation = (0, inputValidation_js_1.validateValue)(args.database);
+        if (!validation.valid)
+            errors.push(validation.error || "Invalid database name");
+    }
+    validateTableList(args.tables, "tables", errors);
+    if (args.domain !== undefined && !["auto", "generic", "ecommerce", "pos", "crm"].includes(args.domain)) {
+        errors.push("domain must be one of auto, generic, ecommerce, pos, crm");
+    }
+    if (args.sample_size !== undefined && (!Number.isFinite(Number(args.sample_size)) || Number(args.sample_size) < 0)) {
+        errors.push("sample_size must be a non-negative number");
+    }
+    if (args.max_tables !== undefined && (!Number.isFinite(Number(args.max_tables)) || Number(args.max_tables) < 1)) {
+        errors.push("max_tables must be a positive number");
+    }
+    return errors.length ? { valid: false, errors } : { valid: true };
+};
+const validateSeedFromTemplateArgs = (args) => {
+    const errors = [];
+    if (!args.template || !["ecommerce", "pos", "crm"].includes(args.template)) {
+        errors.push("template must be one of ecommerce, pos, crm");
+    }
+    if (args.database !== undefined) {
+        const validation = (0, inputValidation_js_1.validateValue)(args.database);
+        if (!validation.valid)
+            errors.push(validation.error || "Invalid database name");
+    }
+    if (args.scale !== undefined && !["small", "medium", "large"].includes(args.scale)) {
+        errors.push("scale must be one of small, medium, large");
+    }
+    validateTableList(args.include, "include", errors);
+    validateTableList(args.exclude, "exclude", errors);
+    validateRowsPerTable(args.rows_per_table, errors);
+    return errors.length ? { valid: false, errors } : { valid: true };
+};
+const validatePlanIdArgs = (args) => {
+    if (!args.plan_id || typeof args.plan_id !== "string") {
+        return { valid: false, errors: ["plan_id is required"] };
+    }
+    if (!/^seed_plan_[A-Za-z0-9_]+$/.test(args.plan_id)) {
+        return { valid: false, errors: ["plan_id has invalid format"] };
+    }
+    return { valid: true };
+};
 function validateToolArguments(name, args) {
     if (!args)
         return { valid: true };
@@ -19,8 +121,23 @@ function validateToolArguments(name, args) {
             case "execute_write_query":
             case "execute_ddl":
                 return (0, inputValidation_js_1.validateQuery)({ query: args?.query || "" });
+            case "export_query_to_csv":
+                return (0, inputValidation_js_1.validateQuery)({
+                    query: args?.query || "",
+                    params: args?.params,
+                });
             case "bulk_insert":
                 return (0, inputValidation_js_1.validateBulkInsert)(args);
+            case "plan_seed_data":
+                return validatePlanSeedDataArgs(args);
+            case "generate_seed_preview":
+            case "execute_seed_plan":
+            case "validate_seed_integrity":
+                return validatePlanIdArgs(args);
+            case "infer_seed_rules":
+                return validateInferSeedRulesArgs(args);
+            case "seed_from_template":
+                return validateSeedFromTemplateArgs(args);
             case "list_tables":
             case "get_schema_erd":
             case "get_schema_rag_context":

package/dist/tools/utilityTools.d.ts

@@ -1,3 +1,17 @@
+interface RuntimeToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema?: any;
+    input_schema?: any;
+    output_schema?: any;
+}
+interface ListAllToolsOptions {
+    tools?: RuntimeToolDefinition[];
+    enabledToolNames?: string[];
+    accessProfile?: any;
+    serverName?: string;
+    serverVersion?: string;
+}
 export declare class UtilityTools {
     private db;
     constructor();
@@ -41,7 +55,7 @@ export declare class UtilityTools {
     /**
      * Lists all available tools in this MySQL MCP server
      */
-    listAllTools(): Promise<{
+    listAllTools(params?: ListAllToolsOptions): Promise<{
         status: string;
         data?: any;
         error?: string;
@@ -58,3 +72,4 @@ export declare class UtilityTools {
         error?: string;
     }>;
 }
+export {};

package/dist/tools/utilityTools.js

@@ -295,33 +295,96 @@ class UtilityTools {
     /**
      * Lists all available tools in this MySQL MCP server
      */
-    async listAllTools() {
+    async listAllTools(params) {
         try {
-            // Read manifest.json to get tool definitions
-            const manifestPath = path_1.default.resolve(__dirname, "..", "..", "manifest.json");
-            if (!fs_1.default.existsSync(manifestPath)) {
-                return {
-                    status: "error",
-                    error: "manifest.json not found in project root.",
-                };
+            let source = "runtime";
+            let serverName = params?.serverName || "mysql-mcp-server";
+            let serverVersion = params?.serverVersion || "unknown";
+            let toolDefinitions = params?.tools || [];
+            if (toolDefinitions.length === 0) {
+                const manifestPath = path_1.default.resolve(__dirname, "..", "..", "manifest.json");
+                if (!fs_1.default.existsSync(manifestPath)) {
+                    return {
+                        status: "error",
+                        error: "Runtime tool catalog was not supplied and manifest.json was not found.",
+                    };
+                }
+                const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, "utf-8"));
+                source = "manifest_fallback";
+                serverName = manifest.name || serverName;
+                serverVersion = manifest.version || serverVersion;
+                toolDefinitions = manifest.tools || [];
             }
-            const manifestContent = fs_1.default.readFileSync(manifestPath, "utf-8");
-            const manifest = JSON.parse(manifestContent);
-            const tools = manifest.tools.map((tool) => ({
+            const enabledToolNames = new Set(params?.enabledToolNames || toolDefinitions.map((tool) => tool.name));
+            const tools = toolDefinitions.map((tool) => ({
                 name: tool.name,
                 description: tool.description,
-                input_schema: tool.input_schema,
-                output_schema: tool.output_schema
+                enabled: enabledToolNames.has(tool.name),
+                input_schema: tool.inputSchema || tool.input_schema || {},
+                output_schema: tool.output_schema || { type: "object" },
             }));
             return {
                 status: "success",
                 data: {
+                    source,
                     total_tools: tools.length,
-                    server_name: manifest.name,
-                    server_version: manifest.version,
-                    server_description: manifest.description,
-                    tools: tools
-                }
+                    enabled_tools: tools.filter((tool) => tool.enabled).length,
+                    disabled_tools: tools.filter((tool) => !tool.enabled).length,
+                    server_name: serverName,
+                    server_version: serverVersion,
+                    access_profile: params?.accessProfile,
+                    agent_guidance: {
+                        recommended_first_calls: [
+                            "describe_connection",
+                            "list_databases",
+                            "list_tables",
+                            "get_schema_rag_context",
+                        ],
+                        workflows: {
+                            explore_schema: [
+                                "describe_connection",
+                                "list_tables",
+                                "get_database_summary",
+                                "get_schema_rag_context",
+                            ],
+                            inspect_table: [
+                                "read_table_schema",
+                                "get_column_statistics",
+                                "read_records",
+                            ],
+                            run_safe_query: [
+                                "get_schema_rag_context",
+                                "run_select_query with dry_run=true",
+                                "run_select_query",
+                            ],
+                            export_data: [
+                                "export_table_to_csv for simple table exports",
+                                "export_query_to_csv for SELECT query exports",
+                            ],
+                            modify_data: [
+                                "begin_transaction",
+                                "execute_in_transaction",
+                                "commit_transaction or rollback_transaction",
+                            ],
+                            seed_relational_data: [
+                                "infer_seed_rules or seed_from_template when domain/sample-based rules are useful",
+                                "plan_seed_data",
+                                "generate_seed_preview",
+                                "execute_seed_plan with dry_run=false and confirm_token after user approval",
+                                "validate_seed_integrity",
+                            ],
+                        },
+                        selection_rules: [
+                            "Use get_schema_rag_context before generating SQL to reduce token usage.",
+                            "Use run_select_query only for SELECT statements.",
+                            "Use execute_write_query for INSERT, UPDATE, and DELETE.",
+                            "Use execute_ddl only for CREATE, ALTER, DROP, TRUNCATE, and RENAME.",
+                            "Use seed_operations for relational dummy data instead of manually chaining bulk_insert across foreign keys.",
+                            "Prefer structured tools over raw SQL when possible.",
+                        ],
+                    },
+                    tools,
+                },
             };
         }
         catch (error) {