@berthojoris/mcp-mysql-server 1.40.7 → 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 };
@@ -26,6 +128,16 @@ function validateToolArguments(name, args) {
                 });
             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.js

@@ -366,12 +366,20 @@ class UtilityTools {
                                 "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.",
                         ],
                     },

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "name": "mysql-mcp",
   "description": "A Model Context Protocol for MySQL database interaction",
-  "version": "1.40.7",
+  "version": "1.42.0",
   "tools": [
     {
       "name": "list_databases",
@@ -532,6 +532,368 @@
         "type": "object"
       }
     },
+    {
+      "name": "plan_seed_data",
+      "description": "🌱 RELATIONAL SEEDER: Analyzes target tables, foreign keys, constraints, and row counts to build a safe parent-first seed plan. Use this before generating preview or inserting dummy relational data.",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "database": {
+            "type": "string",
+            "description": "Optional: specific connected database name"
+          },
+          "target_tables": {
+            "type": "array",
+            "description": "Target tables to seed",
+            "minItems": 1,
+            "items": {
+              "type": "string"
+            }
+          },
+          "rows_per_table": {
+            "oneOf": [
+              {
+                "type": "number",
+                "minimum": 0
+              },
+              {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "number",
+                  "minimum": 0
+                }
+              }
+            ],
+            "description": "Rows to create for target tables, either a single number or table-to-count map (default: 10)"
+          },
+          "include_dependencies": {
+            "type": "boolean",
+            "description": "Include parent tables required by foreign keys (default: true)"
+          },
+          "include_children": {
+            "type": "boolean",
+            "description": "Include child tables that reference included tables for nested relational seeding (default: false)"
+          },
+          "child_rows_per_parent": {
+            "type": "number",
+            "description": "Rows to create in child tables for each parent row (default: 2)",
+            "minimum": 1,
+            "maximum": 20
+          },
+          "respect_existing_data": {
+            "type": "boolean",
+            "description": "Reuse existing parent records when possible instead of creating new parent rows (default: true)"
+          },
+          "strategy": {
+            "type": "string",
+            "enum": [
+              "append"
+            ],
+            "description": "Seed strategy (currently append)"
+          },
+          "random_seed": {
+            "type": "number",
+            "description": "Deterministic seed for repeatable preview and execution (default: 42)"
+          },
+          "max_rows_per_table": {
+            "type": "number",
+            "description": "Safety cap for generated rows per table (default: 1000)",
+            "minimum": 1,
+            "maximum": 10000
+          },
+          "max_related_tables": {
+            "type": "number",
+            "description": "Safety cap for dependency/child expansion (default: 25)",
+            "minimum": 1,
+            "maximum": 100
+          },
+          "seed_rules": {
+            "type": "object",
+            "description": "Optional generator overrides keyed by table.column or column name",
+            "additionalProperties": true
+          },
+          "require_confirmation": {
+            "type": "boolean",
+            "description": "Require confirm_token for non-dry-run execution (default: true)"
+          }
+        },
+        "required": [
+          "target_tables"
+        ]
+      },
+      "output_schema": {
+        "type": "object"
+      }
+    },
+    {
+      "name": "generate_seed_preview",
+      "description": "🌱 RELATIONAL SEEDER: Generates deterministic dummy row previews from a seed plan without writing to the database. Shows symbolic foreign-key placeholders for review before execution.",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "plan_id": {
+            "type": "string",
+            "description": "Seed plan ID returned by plan_seed_data"
+          },
+          "locale": {
+            "type": "string",
+            "description": "Optional locale hint for generated values (default: en_US)"
+          },
+          "realistic": {
+            "type": "boolean",
+            "description": "Whether to prefer realistic generated values (default: true)"
+          },
+          "max_preview_rows_per_table": {
+            "type": "number",
+            "description": "Maximum preview rows per table (default: 3)",
+            "minimum": 1,
+            "maximum": 25
+          },
+          "email_domain": {
+            "type": "string",
+            "description": "Safe email domain for generated emails (default: example.test)"
+          }
+        },
+        "required": [
+          "plan_id"
+        ]
+      },
+      "output_schema": {
+        "type": "object"
+      }
+    },
+    {
+      "name": "execute_seed_plan",
+      "description": "🌱 RELATIONAL SEEDER: Executes a confirmed seed plan with dry-run enabled by default, production-name guard, transaction rollback on errors, and foreign-key ID resolution.",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "plan_id": {
+            "type": "string",
+            "description": "Seed plan ID returned by plan_seed_data"
+          },
+          "dry_run": {
+            "type": "boolean",
+            "description": "If true, returns execution preview without inserting rows (default: true)"
+          },
+          "use_transaction": {
+            "type": "boolean",
+            "description": "Use a transaction and rollback on error (default: true)"
+          },
+          "batch_size": {
+            "type": "number",
+            "description": "Reserved batch-size hint for large plans (default: 1 for ID-safe inserts)",
+            "minimum": 1,
+            "maximum": 10000
+          },
+          "on_error": {
+            "type": "string",
+            "enum": [
+              "rollback",
+              "stop"
+            ],
+            "description": "Error behavior (default: rollback)"
+          },
+          "confirm_token": {
+            "type": "string",
+            "description": "Confirmation token returned by plan_seed_data; required when dry_run is false"
+          },
+          "allow_production": {
+            "type": "boolean",
+            "description": "Allow writes to production-like database names (default: false)"
+          },
+          "email_domain": {
+            "type": "string",
+            "description": "Safe email domain for generated emails (default: example.test)"
+          }
+        },
+        "required": [
+          "plan_id"
+        ]
+      },
+      "output_schema": {
+        "type": "object"
+      }
+    },
+    {
+      "name": "validate_seed_integrity",
+      "description": "🌱 RELATIONAL SEEDER: Validates seed results with FK orphan checks, required-column checks, unique-collision checks, and inserted row-count checks.",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "plan_id": {
+            "type": "string",
+            "description": "Seed plan ID returned by plan_seed_data"
+          },
+          "tables": {
+            "type": "array",
+            "description": "Optional table subset to validate",
+            "items": {
+              "type": "string"
+            }
+          },
+          "check_foreign_keys": {
+            "type": "boolean",
+            "description": "Check foreign key integrity (default: true)"
+          },
+          "check_orphans": {
+            "type": "boolean",
+            "description": "Alias for check_foreign_keys"
+          },
+          "check_required_columns": {
+            "type": "boolean",
+            "description": "Check NOT NULL required columns (default: true)"
+          },
+          "check_unique_collisions": {
+            "type": "boolean",
+            "description": "Check unique index collisions (default: true)"
+          },
+          "check_row_counts": {
+            "type": "boolean",
+            "description": "Check inserted row counts when execution metadata is available (default: true)"
+          }
+        },
+        "required": [
+          "plan_id"
+        ]
+      },
+      "output_schema": {
+        "type": "object"
+      }
+    },
+    {
+      "name": "infer_seed_rules",
+      "description": "🌱 ADVANCED SEEDER: Infers safe seed generator rules from schema metadata, sample row patterns, unique constraints, and optional ecommerce/POS/CRM domain presets without returning raw PII samples.",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "database": {
+            "type": "string",
+            "description": "Optional: specific connected database name"
+          },
+          "tables": {
+            "type": "array",
+            "description": "Optional table subset to analyze; defaults to schema tables up to max_tables",
+            "items": {
+              "type": "string"
+            }
+          },
+          "domain": {
+            "type": "string",
+            "enum": [
+              "auto",
+              "generic",
+              "ecommerce",
+              "pos",
+              "crm"
+            ],
+            "description": "Optional domain preset for better business-like dummy data (default: auto)"
+          },
+          "sample_size": {
+            "type": "number",
+            "description": "Number of sample rows per table used to infer ranges and enum-like choices (default: 25, max: 100)",
+            "minimum": 0,
+            "maximum": 100
+          },
+          "max_tables": {
+            "type": "number",
+            "description": "Maximum number of tables to analyze when tables is omitted (default: 50)",
+            "minimum": 1,
+            "maximum": 200
+          }
+        }
+      },
+      "output_schema": {
+        "type": "object"
+      }
+    },
+    {
+      "name": "seed_from_template",
+      "description": "🌱 TEMPLATE SEEDER: Creates a plan-first FK-aware seed workflow from ecommerce, POS, or CRM templates. It detects matching tables, applies domain rules, and returns a seed plan for preview/execution.",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "database": {
+            "type": "string",
+            "description": "Optional: specific connected database name"
+          },
+          "template": {
+            "type": "string",
+            "enum": [
+              "ecommerce",
+              "pos",
+              "crm"
+            ],
+            "description": "Business seed template to apply"
+          },
+          "scale": {
+            "type": "string",
+            "enum": [
+              "small",
+              "medium",
+              "large"
+            ],
+            "description": "Template size preset (default: small)"
+          },
+          "include": {
+            "type": "array",
+            "description": "Optional concrete table list to seed instead of auto-detected template matches",
+            "items": {
+              "type": "string"
+            }
+          },
+          "exclude": {
+            "type": "array",
+            "description": "Optional table names to ignore during template matching",
+            "items": {
+              "type": "string"
+            }
+          },
+          "rows_per_table": {
+            "oneOf": [
+              {
+                "type": "number",
+                "minimum": 0
+              },
+              {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "number",
+                  "minimum": 0
+                }
+              }
+            ],
+            "description": "Optional row-count override for the generated plan"
+          },
+          "include_dependencies": {
+            "type": "boolean",
+            "description": "Include parent tables required by foreign keys (default: true)"
+          },
+          "include_children": {
+            "type": "boolean",
+            "description": "Include child tables that reference included template tables (default: false)"
+          },
+          "respect_existing_data": {
+            "type": "boolean",
+            "description": "Reuse existing parent records when possible instead of creating new parent rows (default: true)"
+          },
+          "random_seed": {
+            "type": "number",
+            "description": "Deterministic seed for repeatable preview and execution"
+          },
+          "require_confirmation": {
+            "type": "boolean",
+            "description": "Require confirm_token for non-dry-run execution (default: true)"
+          }
+        },
+        "required": [
+          "template"
+        ]
+      },
+      "output_schema": {
+        "type": "object"
+      }
+    },
     {
       "name": "run_select_query",
       "description": "⚡ PRIMARY TOOL FOR SELECT QUERIES. Executes read-only SELECT statements with parameterization, optimizer hints, query caching, and dry-run mode. Supports complex queries with JOINs, subqueries, and aggregations. ⚠️ ONLY for SELECT - use execute_write_query for INSERT/UPDATE/DELETE, use execute_ddl for CREATE/ALTER/DROP.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@berthojoris/mcp-mysql-server",
-  "version": "1.40.7",
+  "version": "1.42.0",
   "description": "Model Context Protocol server for MySQL database integration with dynamic per-project permissions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",