@berthojoris/mcp-mysql-server 1.40.7 → 1.42.0

package/dist/mcp-server.js

@@ -18,7 +18,7 @@ const toolArgumentValidation_js_1 = require("./tools/toolArgumentValidation.js")
 const permissions = process.env.MCP_PERMISSIONS || process.env.MCP_CONFIG || "";
 const categories = process.env.MCP_CATEGORIES || "";
 const SERVER_NAME = "mysql-mcp-server";
-const SERVER_VERSION = "1.40.7";
+const SERVER_VERSION = "1.42.0";
 // Declare the MySQL MCP instance (will be initialized in main())
 let mysqlMCP;
 // Define all available tools with their schemas
@@ -406,6 +406,293 @@ const TOOLS = [
             required: ["table_name", "condition_sets"],
         },
     },
+    {
+        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.",
+        inputSchema: {
+            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"],
+        },
+    },
+    {
+        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.",
+        inputSchema: {
+            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"],
+        },
+    },
+    {
+        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.",
+        inputSchema: {
+            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"],
+        },
+    },
+    {
+        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.",
+        inputSchema: {
+            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"],
+        },
+    },
+    {
+        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.",
+        inputSchema: {
+            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,
+                },
+            },
+        },
+    },
+    {
+        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.",
+        inputSchema: {
+            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"],
+        },
+    },
     {
         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.",
@@ -2048,6 +2335,24 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "bulk_delete":
                 result = await mysqlMCP.bulkDelete((args || {}));
                 break;
+            case "plan_seed_data":
+                result = await mysqlMCP.planSeedData(args || {});
+                break;
+            case "generate_seed_preview":
+                result = await mysqlMCP.generateSeedPreview(args || {});
+                break;
+            case "execute_seed_plan":
+                result = await mysqlMCP.executeSeedPlan(args || {});
+                break;
+            case "validate_seed_integrity":
+                result = await mysqlMCP.validateSeedIntegrity(args || {});
+                break;
+            case "infer_seed_rules":
+                result = await mysqlMCP.inferSeedRules(args || {});
+                break;
+            case "seed_from_template":
+                result = await mysqlMCP.seedFromTemplate(args || {});
+                break;
             // Query Tools
             case "run_select_query":
                 result = await mysqlMCP.runSelectQuery((args || {}));

package/dist/tools/relationalSeederTools.d.ts

@@ -0,0 +1,207 @@
+import SecurityLayer from "../security/securityLayer";
+type RowsPerTable = number | Record<string, number>;
+type SeedDomain = "auto" | "generic" | "ecommerce" | "pos" | "crm";
+type SeedTemplate = "ecommerce" | "pos" | "crm";
+type TemplateScale = "small" | "medium" | "large";
+interface SeedRule {
+    generator?: string;
+    values?: any[];
+    value?: any;
+    min?: number;
+    max?: number;
+    start?: string;
+    end?: string;
+    prefix?: string;
+    pattern?: string;
+    domain?: string;
+    nullable?: boolean;
+    source?: string;
+}
+interface TableRequirement {
+    table: string;
+    rows_to_create: number;
+    reason: string;
+    existing_rows: number;
+}
+interface SeedPlan {
+    plan_id: string;
+    database: string;
+    dependency_order: string[];
+    tables_required: TableRequirement[];
+    constraints_detected: {
+        foreign_keys: string[];
+        unique: string[];
+        required_columns: string[];
+    };
+    seed_rules: Record<string, SeedRule>;
+    warnings: string[];
+    requires_confirmation: boolean;
+    confirm_token: string;
+    random_seed: number;
+    options: {
+        strategy: string;
+        respect_existing_data: boolean;
+        include_dependencies: boolean;
+        include_children: boolean;
+        child_rows_per_parent: number;
+        max_rows_per_table: number;
+    };
+}
+interface PlanSeedDataParams {
+    database?: string;
+    target_tables: string[];
+    rows_per_table?: RowsPerTable;
+    include_dependencies?: boolean;
+    include_children?: boolean;
+    child_rows_per_parent?: number;
+    respect_existing_data?: boolean;
+    strategy?: "append";
+    random_seed?: number;
+    max_rows_per_table?: number;
+    max_related_tables?: number;
+    seed_rules?: Record<string, SeedRule>;
+    require_confirmation?: boolean;
+}
+interface GenerateSeedPreviewParams {
+    plan_id: string;
+    locale?: string;
+    realistic?: boolean;
+    max_preview_rows_per_table?: number;
+    email_domain?: string;
+}
+interface ExecuteSeedPlanParams {
+    plan_id: string;
+    dry_run?: boolean;
+    use_transaction?: boolean;
+    batch_size?: number;
+    on_error?: "rollback" | "stop";
+    confirm_token?: string;
+    allow_production?: boolean;
+    email_domain?: string;
+}
+interface ValidateSeedIntegrityParams {
+    plan_id: string;
+    tables?: string[];
+    check_foreign_keys?: boolean;
+    check_orphans?: boolean;
+    check_required_columns?: boolean;
+    check_unique_collisions?: boolean;
+    check_row_counts?: boolean;
+}
+interface InferSeedRulesParams {
+    database?: string;
+    tables?: string[];
+    domain?: SeedDomain;
+    sample_size?: number;
+    max_tables?: number;
+}
+interface SeedFromTemplateParams {
+    database?: string;
+    template: SeedTemplate;
+    scale?: TemplateScale;
+    include?: string[];
+    exclude?: string[];
+    rows_per_table?: RowsPerTable;
+    include_dependencies?: boolean;
+    include_children?: boolean;
+    respect_existing_data?: boolean;
+    random_seed?: number;
+    require_confirmation?: boolean;
+}
+export declare class RelationalSeederTools {
+    private static planCounter;
+    private db;
+    private security;
+    private plans;
+    constructor(security: SecurityLayer);
+    planSeedData(params: PlanSeedDataParams): Promise<{
+        status: string;
+        data?: SeedPlan;
+        error?: string;
+    }>;
+    generateSeedPreview(params: GenerateSeedPreviewParams): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    executeSeedPlan(params: ExecuteSeedPlanParams): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    validateSeedIntegrity(params: ValidateSeedIntegrityParams): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    inferSeedRules(params: InferSeedRulesParams): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    seedFromTemplate(params: SeedFromTemplateParams): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    private resolveDatabase;
+    private loadSchema;
+    private groupForeignKeys;
+    private topologicalSort;
+    private calculateRowsToCreate;
+    private buildInferredSeedRules;
+    private inferRuleForColumn;
+    private detectConstraints;
+    private buildPreview;
+    private buildRowsForTable;
+    private resolveForeignKeyTuple;
+    private generateValue;
+    private preloadExistingParentIds;
+    private ensureIdMapForTable;
+    private loadExistingKeyTuples;
+    private insertRow;
+    private trackInsertedKeys;
+    private countForeignKeyOrphans;
+    private countNullValues;
+    private findUniqueCollisions;
+    private getValidationRowCount;
+    private getRequiredColumns;
+    private shouldSkipColumn;
+    private isIntegerColumn;
+    private isNumberColumn;
+    private isBooleanColumn;
+    private extractEnumValues;
+    private isForeignKeyColumn;
+    private keySignature;
+    private formatForeignKey;
+    private tupleFromRow;
+    private storeTuples;
+    private buildTupleWhereClause;
+    private getSelectableTables;
+    private loadSampleRows;
+    private refineRulesFromSamples;
+    private isSensitiveColumn;
+    private canUseChoiceFromSamples;
+    private inferPatternFromSamples;
+    private detectDomainFromTables;
+    private getDomainRule;
+    private detectTemplateTables;
+    private getTemplateKeywords;
+    private getScaleRows;
+    private buildTemplateRules;
+    private requirementsToInsertMap;
+    private countResolvedForeignKeys;
+    private getExplicitOrDefaultRows;
+    private assertIdentifier;
+    private getStoredPlan;
+    private createPlanId;
+    private createConfirmToken;
+    private isProductionLikeDatabase;
+    private clampNumber;
+    private makeRng;
+    private hashString;
+    private truncate;
+    private pickPersonName;
+    private formatDate;
+}
+export {};