@berthojoris/mcp-mysql-server 1.6.3 → 1.8.0

package/dist/mcp-server.js

@@ -1866,6 +1866,508 @@ const TOOLS = [
             },
         },
     },
+    // Backup and Restore Tools
+    {
+        name: "backup_table",
+        description: "Backup a single table to SQL dump format including structure and optionally data.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to backup",
+                },
+                include_data: {
+                    type: "boolean",
+                    description: "Include table data in the backup (default: true)",
+                },
+                include_drop: {
+                    type: "boolean",
+                    description: "Include DROP TABLE IF EXISTS statement (default: true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "backup_database",
+        description: "Backup entire database or selected tables to SQL dump format.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                include_data: {
+                    type: "boolean",
+                    description: "Include table data in the backup (default: true)",
+                },
+                include_drop: {
+                    type: "boolean",
+                    description: "Include DROP TABLE IF EXISTS statements (default: true)",
+                },
+                tables: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: specific tables to backup (default: all tables)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+        },
+    },
+    {
+        name: "restore_from_sql",
+        description: "Restore database from SQL dump content. Executes SQL statements from the provided dump. Requires 'ddl' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sql_dump: {
+                    type: "string",
+                    description: "SQL dump content to restore",
+                },
+                stop_on_error: {
+                    type: "boolean",
+                    description: "Stop execution on first error (default: true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["sql_dump"],
+        },
+    },
+    {
+        name: "get_create_table_statement",
+        description: "Get the CREATE TABLE statement for a specific table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "get_database_schema",
+        description: "Get complete database schema including tables, views, procedures, functions, and triggers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+                include_views: {
+                    type: "boolean",
+                    description: "Include views in schema (default: true)",
+                },
+                include_procedures: {
+                    type: "boolean",
+                    description: "Include stored procedures in schema (default: true)",
+                },
+                include_functions: {
+                    type: "boolean",
+                    description: "Include functions in schema (default: true)",
+                },
+                include_triggers: {
+                    type: "boolean",
+                    description: "Include triggers in schema (default: true)",
+                },
+            },
+        },
+    },
+    // Extended Data Export Tools (JSON, SQL)
+    {
+        name: "export_table_to_json",
+        description: "Export table data to JSON format with optional filtering, pagination, and sorting.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to export",
+                },
+                filters: {
+                    type: "array",
+                    description: "Array of filter conditions",
+                    items: {
+                        type: "object",
+                        properties: {
+                            field: { type: "string" },
+                            operator: {
+                                type: "string",
+                                enum: ["eq", "neq", "gt", "gte", "lt", "lte", "like", "in"],
+                            },
+                            value: {},
+                        },
+                        required: ["field", "operator", "value"],
+                    },
+                },
+                pagination: {
+                    type: "object",
+                    properties: {
+                        page: { type: "number" },
+                        limit: { type: "number" },
+                    },
+                },
+                sorting: {
+                    type: "object",
+                    properties: {
+                        field: { type: "string" },
+                        direction: { type: "string", enum: ["asc", "desc"] },
+                    },
+                },
+                pretty: {
+                    type: "boolean",
+                    description: "Pretty print JSON output (default: true)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    {
+        name: "export_query_to_json",
+        description: "Export the results of a SELECT query to JSON format.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "SQL SELECT query to execute and export",
+                },
+                params: {
+                    type: "array",
+                    description: "Optional array of parameters for parameterized queries",
+                    items: {},
+                },
+                pretty: {
+                    type: "boolean",
+                    description: "Pretty print JSON output (default: true)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "export_table_to_sql",
+        description: "Export table data to SQL INSERT statements with optional CREATE TABLE.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to export",
+                },
+                filters: {
+                    type: "array",
+                    description: "Array of filter conditions",
+                    items: {
+                        type: "object",
+                        properties: {
+                            field: { type: "string" },
+                            operator: {
+                                type: "string",
+                                enum: ["eq", "neq", "gt", "gte", "lt", "lte", "like", "in"],
+                            },
+                            value: {},
+                        },
+                        required: ["field", "operator", "value"],
+                    },
+                },
+                include_create_table: {
+                    type: "boolean",
+                    description: "Include CREATE TABLE statement (default: false)",
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Number of rows per INSERT statement (default: 100)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name"],
+        },
+    },
+    // Data Import Tools
+    {
+        name: "import_from_csv",
+        description: "Import data from CSV string into a table. Requires 'create' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to import into",
+                },
+                csv_data: {
+                    type: "string",
+                    description: "CSV data as a string",
+                },
+                has_headers: {
+                    type: "boolean",
+                    description: "CSV has header row (default: true)",
+                },
+                column_mapping: {
+                    type: "object",
+                    description: "Optional: map CSV columns to table columns {csv_col: table_col}",
+                    additionalProperties: { type: "string" },
+                },
+                skip_errors: {
+                    type: "boolean",
+                    description: "Continue on row errors (default: false)",
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Number of rows per batch insert (default: 100)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            required: ["table_name", "csv_data"],
+        },
+    },
+    {
+        name: "import_from_json",
+        description: "Import data from JSON array string into a table. Requires 'create' permission.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                table_name: {
+                    type: "string",
+                    description: "Name of the table to import into",
+                },
+                json_data: {
+                    type: "string",
+                    description: "JSON array of objects as a string",
+                },
+                column_mapping: {
+                    type: "object",
+                    description: "Optional: map JSON keys to table columns {json_key: table_col}",
+                    additionalProperties: { type: "string" },
+                },
+                skip_errors: {
+                    type: "boolean",
+                    description: "Continue on row errors (default: false)",
+                },
+                batch_size: {
+                    type: "number",
+                    description: "Number of rows per batch insert (default: 100)",
+                },
+                database: {
+                    type: "string",
+                    description: "Optional: specific database name",
+                },
+            },
+            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"],
+        },
+    },
 ];
 // Create the MCP server
 const server = new index_js_1.Server({
@@ -2155,6 +2657,55 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "show_replication_status":
                 result = await mysqlMCP.showReplicationStatus((args || {}));
                 break;
+            // Backup and Restore Tools
+            case "backup_table":
+                result = await mysqlMCP.backupTable((args || {}));
+                break;
+            case "backup_database":
+                result = await mysqlMCP.backupDatabase((args || {}));
+                break;
+            case "restore_from_sql":
+                result = await mysqlMCP.restoreFromSql((args || {}));
+                break;
+            case "get_create_table_statement":
+                result = await mysqlMCP.getCreateTableStatement((args || {}));
+                break;
+            case "get_database_schema":
+                result = await mysqlMCP.getDatabaseSchema((args || {}));
+                break;
+            // Extended Data Export Tools
+            case "export_table_to_json":
+                result = await mysqlMCP.exportTableToJSON((args || {}));
+                break;
+            case "export_query_to_json":
+                result = await mysqlMCP.exportQueryToJSON((args || {}));
+                break;
+            case "export_table_to_sql":
+                result = await mysqlMCP.exportTableToSql((args || {}));
+                break;
+            // Data Import Tools
+            case "import_from_csv":
+                result = await mysqlMCP.importFromCSV((args || {}));
+                break;
+            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;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tools/backupRestoreTools.d.ts

@@ -0,0 +1,91 @@
+import SecurityLayer from '../security/securityLayer';
+/**
+ * Backup and Restore Tools for MySQL MCP Server
+ * Provides database backup (SQL dump generation) and restore functionality
+ */
+export declare class BackupRestoreTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Validate database access
+     */
+    private validateDatabaseAccess;
+    /**
+     * Escape string value for SQL
+     */
+    private escapeValue;
+    /**
+     * Get CREATE TABLE statement for a table
+     */
+    getCreateTableStatement(params: {
+        table_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Backup a single table to SQL dump format
+     */
+    backupTable(params: {
+        table_name: string;
+        include_data?: boolean;
+        include_drop?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Backup entire database schema and optionally data
+     */
+    backupDatabase(params: {
+        include_data?: boolean;
+        include_drop?: boolean;
+        tables?: string[];
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Restore database from SQL dump
+     * Executes SQL statements from the provided SQL dump string
+     */
+    restoreFromSql(params: {
+        sql_dump: string;
+        stop_on_error?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Parse SQL dump into individual statements
+     */
+    private parseSqlStatements;
+    /**
+     * Get database schema overview (all CREATE statements)
+     */
+    getDatabaseSchema(params: {
+        database?: string;
+        include_views?: boolean;
+        include_procedures?: boolean;
+        include_functions?: boolean;
+        include_triggers?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+}