@berthojoris/mcp-mysql-server 1.8.0 → 1.9.1

package/dist/index.d.ts

@@ -20,6 +20,7 @@ export declare class MySQLMCP {
     private processTools;
     private backupRestoreTools;
     private migrationTools;
+    private schemaVersioningTools;
     private security;
     private featureConfig;
     constructor(permissionsConfig?: string);
@@ -463,6 +464,122 @@ export declare class MySQLMCP {
         error?: string;
         queryLog?: string;
     }>;
+    /**
+     * Initialize the migrations tracking table
+     */
+    initMigrationsTable(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Create a new migration
+     */
+    createMigration(params: {
+        name: string;
+        up_sql: string;
+        down_sql?: string;
+        description?: string;
+        version?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Apply pending migrations
+     */
+    applyMigrations(params: {
+        target_version?: string;
+        dry_run?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Rollback migrations
+     */
+    rollbackMigration(params: {
+        target_version?: string;
+        steps?: number;
+        dry_run?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Get migration status and history
+     */
+    getMigrationStatus(params: {
+        version?: string;
+        status?: "pending" | "applied" | "failed" | "rolled_back";
+        limit?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Get current schema version
+     */
+    getSchemaVersion(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Validate migrations for issues
+     */
+    validateMigrations(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Reset a failed migration to pending status
+     */
+    resetFailedMigration(params: {
+        version: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Generate a migration from table structure differences
+     */
+    generateMigrationFromDiff(params: {
+        table1: string;
+        table2: string;
+        migration_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
     getFeatureStatus(): {
         status: string;
         data: {

package/dist/index.js

@@ -21,6 +21,7 @@ const maintenanceTools_1 = require("./tools/maintenanceTools");
 const processTools_1 = require("./tools/processTools");
 const backupRestoreTools_1 = require("./tools/backupRestoreTools");
 const migrationTools_1 = require("./tools/migrationTools");
+const schemaVersioningTools_1 = require("./tools/schemaVersioningTools");
 const securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -49,6 +50,7 @@ class MySQLMCP {
         this.processTools = new processTools_1.ProcessTools(this.security);
         this.backupRestoreTools = new backupRestoreTools_1.BackupRestoreTools(this.security);
         this.migrationTools = new migrationTools_1.MigrationTools(this.security);
+        this.schemaVersioningTools = new schemaVersioningTools_1.SchemaVersioningTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -397,6 +399,99 @@ class MySQLMCP {
         }
         return await this.migrationTools.syncTableData(params);
     }
+    // ==========================================
+    // Schema Versioning and Migrations Tools
+    // ==========================================
+    /**
+     * Initialize the migrations tracking table
+     */
+    async initMigrationsTable(params) {
+        const check = this.checkToolEnabled("initMigrationsTable");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.initMigrationsTable(params);
+    }
+    /**
+     * Create a new migration
+     */
+    async createMigration(params) {
+        const check = this.checkToolEnabled("createMigration");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.createMigration(params);
+    }
+    /**
+     * Apply pending migrations
+     */
+    async applyMigrations(params) {
+        const check = this.checkToolEnabled("applyMigrations");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.applyMigrations(params);
+    }
+    /**
+     * Rollback migrations
+     */
+    async rollbackMigration(params) {
+        const check = this.checkToolEnabled("rollbackMigration");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.rollbackMigration(params);
+    }
+    /**
+     * Get migration status and history
+     */
+    async getMigrationStatus(params) {
+        const check = this.checkToolEnabled("getMigrationStatus");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.getMigrationStatus(params);
+    }
+    /**
+     * Get current schema version
+     */
+    async getSchemaVersion(params) {
+        const check = this.checkToolEnabled("getSchemaVersion");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.getSchemaVersion(params);
+    }
+    /**
+     * Validate migrations for issues
+     */
+    async validateMigrations(params) {
+        const check = this.checkToolEnabled("validateMigrations");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.validateMigrations(params);
+    }
+    /**
+     * Reset a failed migration to pending status
+     */
+    async resetFailedMigration(params) {
+        const check = this.checkToolEnabled("resetFailedMigration");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.resetFailedMigration(params);
+    }
+    /**
+     * Generate a migration from table structure differences
+     */
+    async generateMigrationFromDiff(params) {
+        const check = this.checkToolEnabled("generateMigrationFromDiff");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.schemaVersioningTools.generateMigrationFromDiff(params);
+    }
     // Get feature configuration status
     getFeatureStatus() {
         return {

package/dist/mcp-server.js

@@ -2368,6 +2368,196 @@ const TOOLS = [
             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({
@@ -2706,6 +2896,34 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             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/schemaVersioningTools.d.ts

@@ -0,0 +1,147 @@
+import SecurityLayer from "../security/securityLayer";
+/**
+ * Schema Versioning and Migrations Tools for MySQL MCP Server
+ * Provides utilities for managing database schema versions and migrations
+ */
+export declare class SchemaVersioningTools {
+    private db;
+    private security;
+    private migrationsTable;
+    constructor(security: SecurityLayer);
+    /**
+     * Validate database access
+     */
+    private validateDatabaseAccess;
+    /**
+     * Generate a migration version based on timestamp
+     */
+    private generateVersion;
+    /**
+     * Escape string value for SQL
+     */
+    private escapeValue;
+    /**
+     * Initialize the migrations tracking table if it doesn't exist
+     */
+    initMigrationsTable(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Create a new migration entry
+     */
+    createMigration(params: {
+        name: string;
+        up_sql: string;
+        down_sql?: string;
+        description?: string;
+        version?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Generate a simple checksum for SQL content
+     */
+    private generateChecksum;
+    /**
+     * Apply pending migrations
+     */
+    applyMigrations(params: {
+        target_version?: string;
+        dry_run?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Split SQL content into individual statements
+     */
+    private splitSqlStatements;
+    /**
+     * Rollback the last applied migration or to a specific version
+     */
+    rollbackMigration(params: {
+        target_version?: string;
+        steps?: number;
+        dry_run?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Get migration history and status
+     */
+    getMigrationStatus(params: {
+        version?: string;
+        status?: "pending" | "applied" | "failed" | "rolled_back";
+        limit?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Get the current schema version
+     */
+    getSchemaVersion(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Validate pending migrations (check for conflicts or issues)
+     */
+    validateMigrations(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Mark a failed migration as resolved (reset to pending status)
+     */
+    resetFailedMigration(params: {
+        version: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Generate a migration from table comparison
+     */
+    generateMigrationFromDiff(params: {
+        table1: string;
+        table2: string;
+        migration_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+}