@berthojoris/mcp-mysql-server 1.7.0 → 1.9.0

package/dist/mcp-server.js

@@ -2181,6 +2181,383 @@ const TOOLS = [
             required: ["table_name", "json_data"],
         },
     },
+    // Data Migration Tools
+    {
+        name: "copy_table_data",
+        description: "Copy data from one table to another with optional column mapping and filtering. Requires 'create' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                source_table: {
+                    type: "string",
+                    description: "Name of the source table to copy from",
+                },
+                target_table: {
+                    type: "string",
+                    description: "Name of the target table to copy to",
+                },
+                column_mapping: {
+                    type: "object",
+                    description: "Optional: map source columns to target columns {source_col: target_col}",
+                    additionalProperties: { type: "string" },
+                },
+                filters: {
+                    type: "array",
+                    description: "Optional: array of filter conditions for source data",
+                    items: {
+                        type: "object",
+                        properties: {
+                            field: { type: "string" },
+                            operator: {
+                                type: "string",
+                                enum: ["eq", "neq", "gt", "gte", "lt", "lte", "like", "in"],
+                            },
+                            value: {},
+                        },
+                        required: ["field", "operator", "value"],
+                    },
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Number of rows per batch insert (default: 1000)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["source_table", "target_table"],
+        },
+    },
+    {
+        name: "move_table_data",
+        description: "Move data from one table to another (copy then delete from source). Requires 'create' and 'delete' permissions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                source_table: {
+                    type: "string",
+                    description: "Name of the source table to move from",
+                },
+                target_table: {
+                    type: "string",
+                    description: "Name of the target table to move to",
+                },
+                column_mapping: {
+                    type: "object",
+                    description: "Optional: map source columns to target columns {source_col: target_col}",
+                    additionalProperties: { type: "string" },
+                },
+                filters: {
+                    type: "array",
+                    description: "Optional: array of filter conditions for source data",
+                    items: {
+                        type: "object",
+                        properties: {
+                            field: { type: "string" },
+                            operator: {
+                                type: "string",
+                                enum: ["eq", "neq", "gt", "gte", "lt", "lte", "like", "in"],
+                            },
+                            value: {},
+                        },
+                        required: ["field", "operator", "value"],
+                    },
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Number of rows per batch (default: 1000)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["source_table", "target_table"],
+        },
+    },
+    {
+        name: "clone_table",
+        description: "Clone a table structure with optional data. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                source_table: {
+                    type: "string",
+                    description: "Name of the source table to clone",
+                },
+                new_table_name: {
+                    type: "string",
+                    description: "Name of the new table to create",
+                },
+                include_data: {
+                    type: "boolean",
+                    description: "Include table data in the clone (default: false)",
+                },
+                include_indexes: {
+                    type: "boolean",
+                    description: "Include indexes in the clone (default: true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["source_table", "new_table_name"],
+        },
+    },
+    {
+        name: "compare_table_structure",
+        description: "Compare the structure of two tables and identify differences in columns, types, and indexes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table1: {
+                    type: "string",
+                    description: "Name of the first table",
+                },
+                table2: {
+                    type: "string",
+                    description: "Name of the second table",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table1", "table2"],
+        },
+    },
+    {
+        name: "sync_table_data",
+        description: "Synchronize data between two tables based on a key column. Supports insert-only, update-only, or upsert modes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                source_table: {
+                    type: "string",
+                    description: "Name of the source table",
+                },
+                target_table: {
+                    type: "string",
+                    description: "Name of the target table",
+                },
+                key_column: {
+                    type: "string",
+                    description: "Primary key or unique column to match records",
+                },
+                columns_to_sync: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: specific columns to sync (default: all columns)",
+                },
+                sync_mode: {
+                    type: "string",
+                    enum: ["insert_only", "update_only", "upsert"],
+                    description: "Sync mode: insert_only (new records), update_only (existing), upsert (both). Default: upsert",
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Number of rows per batch (default: 1000)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["source_table", "target_table", "key_column"],
+        },
+    },
+    // Schema Versioning and Migrations Tools
+    {
+        name: "init_migrations_table",
+        description: "Initialize the migrations tracking table (_schema_migrations) for schema versioning. Creates the table if it doesn't exist.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "create_migration",
+        description: "Create a new migration entry with up and down SQL. The migration will be stored as pending until applied. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name of the migration (e.g., 'add_users_table', 'add_email_column')",
+                },
+                up_sql: {
+                    type: "string",
+                    description: "SQL statements to apply the migration (can contain multiple statements separated by semicolons)",
+                },
+                down_sql: {
+                    type: "string",
+                    description: "SQL statements to rollback the migration (optional but recommended)",
+                },
+                description: {
+                    type: "string",
+                    description: "Optional description of what this migration does",
+                },
+                version: {
+                    type: "string",
+                    description: "Optional: custom version string (14 chars, e.g., '20240115120000'). Auto-generated if not provided.",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["name", "up_sql"],
+        },
+    },
+    {
+        name: "apply_migrations",
+        description: "Apply all pending migrations or up to a specific version. Executes migrations in version order. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                target_version: {
+                    type: "string",
+                    description: "Optional: apply migrations up to this version (inclusive)",
+                },
+                dry_run: {
+                    type: "boolean",
+                    description: "If true, show what would be applied without executing (default: false)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "rollback_migration",
+        description: "Rollback applied migrations. Can rollback by steps or to a specific version. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                target_version: {
+                    type: "string",
+                    description: "Optional: rollback to this version (exclusive - this version will remain applied)",
+                },
+                steps: {
+                    type: "number",
+                    description: "Number of migrations to rollback (default: 1). Ignored if target_version is specified.",
+                },
+                dry_run: {
+                    type: "boolean",
+                    description: "If true, show what would be rolled back without executing (default: false)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "get_migration_status",
+        description: "Get migration history and status. Shows all migrations with their current status, execution times, and any errors.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                version: {
+                    type: "string",
+                    description: "Optional: get status of a specific version",
+                },
+                status: {
+                    type: "string",
+                    enum: ["pending", "applied", "failed", "rolled_back"],
+                    description: "Optional: filter by status",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of migrations to return (default: 50)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "get_schema_version",
+        description: "Get the current schema version (the last successfully applied migration).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "validate_migrations",
+        description: "Validate all migrations for issues such as duplicate versions, missing down_sql, checksum mismatches, or blocked migrations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "reset_failed_migration",
+        description: "Reset a failed migration back to pending status so it can be retried. Only works for migrations in 'failed' status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                version: {
+                    type: "string",
+                    description: "Version of the failed migration to reset",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["version"],
+        },
+    },
+    {
+        name: "generate_migration_from_diff",
+        description: "Generate a migration by comparing two table structures. Creates up_sql to transform table2 to match table1, and down_sql to revert. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table1: {
+                    type: "string",
+                    description: "Source table (the structure to match)",
+                },
+                table2: {
+                    type: "string",
+                    description: "Target table (the table to be modified)",
+                },
+                migration_name: {
+                    type: "string",
+                    description: "Name for the generated migration",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table1", "table2", "migration_name"],
+        },
+    },
 ];
 // Create the MCP server
 const server = new index_js_1.Server({
@@ -2503,6 +2880,50 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "import_from_json":
                 result = await mysqlMCP.importFromJSON((args || {}));
                 break;
+            // Data Migration Tools
+            case "copy_table_data":
+                result = await mysqlMCP.copyTableData((args || {}));
+                break;
+            case "move_table_data":
+                result = await mysqlMCP.moveTableData((args || {}));
+                break;
+            case "clone_table":
+                result = await mysqlMCP.cloneTable((args || {}));
+                break;
+            case "compare_table_structure":
+                result = await mysqlMCP.compareTableStructure((args || {}));
+                break;
+            case "sync_table_data":
+                result = await mysqlMCP.syncTableData((args || {}));
+                break;
+            // Schema Versioning and Migrations Tools
+            case "init_migrations_table":
+                result = await mysqlMCP.initMigrationsTable((args || {}));
+                break;
+            case "create_migration":
+                result = await mysqlMCP.createMigration((args || {}));
+                break;
+            case "apply_migrations":
+                result = await mysqlMCP.applyMigrations((args || {}));
+                break;
+            case "rollback_migration":
+                result = await mysqlMCP.rollbackMigration((args || {}));
+                break;
+            case "get_migration_status":
+                result = await mysqlMCP.getMigrationStatus((args || {}));
+                break;
+            case "get_schema_version":
+                result = await mysqlMCP.getSchemaVersion((args || {}));
+                break;
+            case "validate_migrations":
+                result = await mysqlMCP.validateMigrations((args || {}));
+                break;
+            case "reset_failed_migration":
+                result = await mysqlMCP.resetFailedMigration((args || {}));
+                break;
+            case "generate_migration_from_diff":
+                result = await mysqlMCP.generateMigrationFromDiff((args || {}));
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tools/migrationTools.d.ts

@@ -0,0 +1,96 @@
+import SecurityLayer from "../security/securityLayer";
+/**
+ * Data Migration Tools for MySQL MCP Server
+ * Provides utilities for copying, moving, and transforming data between tables
+ */
+export declare class MigrationTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Validate database access
+     */
+    private validateDatabaseAccess;
+    /**
+     * Escape string value for SQL
+     */
+    private escapeValue;
+    /**
+     * Copy data from one table to another within the same database
+     */
+    copyTableData(params: {
+        source_table: string;
+        target_table: string;
+        column_mapping?: Record<string, string>;
+        where_clause?: string;
+        truncate_target?: boolean;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Move data from one table to another (copy + delete from source)
+     */
+    moveTableData(params: {
+        source_table: string;
+        target_table: string;
+        column_mapping?: Record<string, string>;
+        where_clause?: string;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Clone a table structure (with or without data)
+     */
+    cloneTable(params: {
+        source_table: string;
+        new_table_name: string;
+        include_data?: boolean;
+        include_indexes?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Compare structure of two tables
+     */
+    compareTableStructure(params: {
+        table1: string;
+        table2: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Sync data between two tables based on a key column
+     */
+    syncTableData(params: {
+        source_table: string;
+        target_table: string;
+        key_column: string;
+        columns_to_sync?: string[];
+        sync_mode?: "insert_only" | "update_only" | "upsert";
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+}