@berthojoris/mcp-mysql-server 1.6.2 → 1.7.0

package/dist/index.js

@@ -19,6 +19,7 @@ const indexTools_1 = require("./tools/indexTools");
 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 securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -45,6 +46,7 @@ class MySQLMCP {
         this.constraintTools = new constraintTools_1.ConstraintTools(this.security);
         this.maintenanceTools = new maintenanceTools_1.MaintenanceTools(this.security);
         this.processTools = new processTools_1.ProcessTools(this.security);
+        this.backupRestoreTools = new backupRestoreTools_1.BackupRestoreTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
@@ -284,6 +286,79 @@ class MySQLMCP {
         }
         return await this.dataExportTools.exportQueryToCSV(params);
     }
+    // Extended Data Export Tools (JSON, SQL)
+    async exportTableToJSON(params) {
+        const check = this.checkToolEnabled("exportTableToJSON");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.dataExportTools.exportTableToJSON(params);
+    }
+    async exportQueryToJSON(params) {
+        const check = this.checkToolEnabled("exportQueryToJSON");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.dataExportTools.exportQueryToJSON(params);
+    }
+    async exportTableToSql(params) {
+        const check = this.checkToolEnabled("exportTableToSql");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.dataExportTools.exportTableToSql(params);
+    }
+    // Data Import Tools
+    async importFromCSV(params) {
+        const check = this.checkToolEnabled("importFromCSV");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.dataExportTools.importFromCSV(params);
+    }
+    async importFromJSON(params) {
+        const check = this.checkToolEnabled("importFromJSON");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.dataExportTools.importFromJSON(params);
+    }
+    // Backup and Restore Tools
+    async backupTable(params) {
+        const check = this.checkToolEnabled("backupTable");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.backupRestoreTools.backupTable(params);
+    }
+    async backupDatabase(params) {
+        const check = this.checkToolEnabled("backupDatabase");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.backupRestoreTools.backupDatabase(params);
+    }
+    async restoreFromSql(params) {
+        const check = this.checkToolEnabled("restoreFromSql");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.backupRestoreTools.restoreFromSql(params);
+    }
+    async getCreateTableStatement(params) {
+        const check = this.checkToolEnabled("getCreateTableStatement");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.backupRestoreTools.getCreateTableStatement(params);
+    }
+    async getDatabaseSchema(params) {
+        const check = this.checkToolEnabled("getDatabaseSchema");
+        if (!check.enabled) {
+            return { status: "error", error: check.error };
+        }
+        return await this.backupRestoreTools.getDatabaseSchema(params);
+    }
     // Get feature configuration status
     getFeatureStatus() {
         return {

package/dist/mcp-server.js

@@ -1866,6 +1866,321 @@ 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"],
+        },
+    },
 ];
 // Create the MCP server
 const server = new index_js_1.Server({
@@ -2155,6 +2470,39 @@ 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;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/security/securityLayer.js

@@ -12,17 +12,22 @@ class SecurityLayer {
         this.featureConfig = featureConfig || new featureConfig_js_1.FeatureConfig();
         // Define dangerous SQL keywords that should ALWAYS be blocked (critical security threats)
         // These are blocked even with 'execute' permission
+        // Note: Avoid blocking common table/column names like "user" or "password"
         this.dangerousKeywords = [
             "GRANT",
             "REVOKE",
             "INTO OUTFILE",
             "INTO DUMPFILE",
             "LOAD DATA",
-            "MYSQL",
+            "LOAD_FILE",
+            "INFORMATION_SCHEMA.USER_PRIVILEGES",
+            "MYSQL.USER",
+            "MYSQL.DB",
             "PERFORMANCE_SCHEMA",
-            "SYS",
-            "USER",
-            "PASSWORD",
+            "CREATE USER",
+            "DROP USER",
+            "ALTER USER",
+            "SET PASSWORD",
         ];
         // Define basic allowed SQL operations
         this.allowedOperations = ["SELECT", "INSERT", "UPDATE", "DELETE"];

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;
+    }>;
+}