@berthojoris/mcp-mysql-server 1.7.0 → 1.9.0

package/dist/index.d.ts

@@ -19,6 +19,8 @@ export declare class MySQLMCP {
     private maintenanceTools;
     private processTools;
     private backupRestoreTools;
+    private migrationTools;
+    private schemaVersioningTools;
     private security;
     private featureConfig;
     constructor(permissionsConfig?: string);
@@ -400,6 +402,184 @@ export declare class MySQLMCP {
         error?: string;
         queryLog?: string;
     }>;
+    copyTableData(params: {
+        source_table: string;
+        target_table: string;
+        column_mapping?: Record<string, string>;
+        filters?: any[];
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    moveTableData(params: {
+        source_table: string;
+        target_table: string;
+        column_mapping?: Record<string, string>;
+        filters?: any[];
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    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;
+    }>;
+    compareTableStructure(params: {
+        table1: string;
+        table2: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    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;
+    }>;
+    /**
+     * 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

@@ -20,6 +20,8 @@ const constraintTools_1 = require("./tools/constraintTools");
 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");
@@ -47,6 +49,8 @@ class MySQLMCP {
         this.maintenanceTools = new maintenanceTools_1.MaintenanceTools(this.security);
         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) {
@@ -359,6 +363,135 @@ class MySQLMCP {
         }
         return await this.backupRestoreTools.getDatabaseSchema(params);
     }
+    // Data Migration Tools
+    async copyTableData(params) {
+        const check = this.checkToolEnabled("copyTableData");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.migrationTools.copyTableData(params);
+    }
+    async moveTableData(params) {
+        const check = this.checkToolEnabled("moveTableData");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.migrationTools.moveTableData(params);
+    }
+    async cloneTable(params) {
+        const check = this.checkToolEnabled("cloneTable");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.migrationTools.cloneTable(params);
+    }
+    async compareTableStructure(params) {
+        const check = this.checkToolEnabled("compareTableStructure");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.migrationTools.compareTableStructure(params);
+    }
+    async syncTableData(params) {
+        const check = this.checkToolEnabled("syncTableData");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        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 {