@berthojoris/mcp-mysql-server 1.6.3 → 1.7.0

package/DOCUMENTATIONS.md

@@ -8,24 +8,26 @@ This file contains detailed documentation for all features of the MySQL MCP Serv
 
 1. [DDL Operations](#🏗️-ddl-operations)
 2. [Data Export Tools](#📤-data-export-tools)
-3. [Transaction Management](#💰-transaction-management)
-4. [Stored Procedures](#🔧-stored-procedures)
-5. [Views Management](#👁️-views-management) - NEW!
-6. [Triggers Management](#⚡-triggers-management) - NEW!
-7. [Functions Management](#🔢-functions-management) - NEW!
-8. [Index Management](#📇-index-management) - NEW!
-9. [Constraint Management](#🔗-constraint-management) - NEW!
-10. [Table Maintenance](#🔧-table-maintenance) - NEW!
-11. [Process & Server Management](#📊-process--server-management) - NEW!
-12. [Usage Examples](#📋-usage-examples)
-13. [Query Logging & Automatic SQL Display](#📝-query-logging--automatic-sql-display)
-14. [Security Features](#🔒-security-features)
-15. [Query Result Caching](#💾-query-result-caching)
-16. [Query Optimization Hints](#🎯-query-optimization-hints)
-17. [Bulk Operations](#🚀-bulk-operations)
-18. [Troubleshooting](#🛠️-troubleshooting)
-19. [License](#📄-license)
-20. [Roadmap](#🗺️-roadmap)
+3. [Data Import Tools](#📥-data-import-tools) - NEW!
+4. [Database Backup & Restore](#💾-database-backup--restore) - NEW!
+5. [Transaction Management](#💰-transaction-management)
+6. [Stored Procedures](#🔧-stored-procedures)
+7. [Views Management](#👁️-views-management)
+8. [Triggers Management](#⚡-triggers-management)
+9. [Functions Management](#🔢-functions-management)
+10. [Index Management](#📇-index-management)
+11. [Constraint Management](#🔗-constraint-management)
+12. [Table Maintenance](#🔧-table-maintenance)
+13. [Process & Server Management](#📊-process--server-management)
+14. [Usage Examples](#📋-usage-examples)
+15. [Query Logging & Automatic SQL Display](#📝-query-logging--automatic-sql-display)
+16. [Security Features](#🔒-security-features)
+17. [Query Result Caching](#💾-query-result-caching)
+18. [Query Optimization Hints](#🎯-query-optimization-hints)
+19. [Bulk Operations](#🚀-bulk-operations)
+20. [Troubleshooting](#🛠️-troubleshooting)
+21. [License](#📄-license)
+22. [Roadmap](#🗺️-roadmap)
 
 ---
 
@@ -248,6 +250,237 @@ Both tools support:
 
 ---
 
+## 📥 Data Import Tools
+
+The MySQL MCP Server provides tools to import data from various formats into your database tables.
+
+### Data Import Tools Overview
+
+| Tool | Description | Permission |
+|------|-------------|------------|
+| `import_from_csv` | Import data from CSV string | `create` |
+| `import_from_json` | Import data from JSON array | `create` |
+
+### Import from CSV
+
+Import data from a CSV string into a table with optional column mapping and error handling.
+
+```json
+{
+  "tool": "import_from_csv",
+  "arguments": {
+    "table_name": "users",
+    "csv_data": "name,email,age\nJohn,john@example.com,30\nJane,jane@example.com,25",
+    "has_headers": true,
+    "skip_errors": false,
+    "batch_size": 100
+  }
+}
+```
+
+**With Column Mapping:**
+```json
+{
+  "tool": "import_from_csv",
+  "arguments": {
+    "table_name": "users",
+    "csv_data": "full_name,mail\nJohn Doe,john@example.com",
+    "has_headers": true,
+    "column_mapping": {
+      "full_name": "name",
+      "mail": "email"
+    }
+  }
+}
+```
+
+### Import from JSON
+
+Import data from a JSON array string into a table.
+
+```json
+{
+  "tool": "import_from_json",
+  "arguments": {
+    "table_name": "products",
+    "json_data": "[{\"name\":\"Widget\",\"price\":9.99},{\"name\":\"Gadget\",\"price\":19.99}]",
+    "skip_errors": false,
+    "batch_size": 100
+  }
+}
+```
+
+### Import Response
+
+```json
+{
+  "status": "success",
+  "data": {
+    "message": "Import completed successfully",
+    "rows_imported": 150,
+    "rows_failed": 0
+  }
+}
+```
+
+### Import Best Practices
+
+1. **Validate data format** - Ensure CSV/JSON is well-formed before importing
+2. **Use batch_size** - Adjust batch size for optimal performance (default: 100)
+3. **Enable skip_errors** - For large imports, set `skip_errors: true` to continue on individual row failures
+4. **Column mapping** - Use when source column names don't match table columns
+
+---
+
+## 💾 Database Backup & Restore
+
+Enterprise-grade backup and restore functionality for MySQL databases.
+
+### Backup & Restore Tools Overview
+
+| Tool | Description | Permission |
+|------|-------------|------------|
+| `backup_table` | Backup single table to SQL dump | `utility` |
+| `backup_database` | Backup entire database to SQL dump | `utility` |
+| `restore_from_sql` | Restore from SQL dump content | `ddl` |
+| `get_create_table_statement` | Get CREATE TABLE statement | `list` |
+| `get_database_schema` | Get complete database schema | `list` |
+
+### Backup Single Table
+
+```json
+{
+  "tool": "backup_table",
+  "arguments": {
+    "table_name": "users",
+    "include_data": true,
+    "include_drop": true
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "status": "success",
+  "data": {
+    "table_name": "users",
+    "sql_dump": "-- MySQL Dump...\nDROP TABLE IF EXISTS `users`;\nCREATE TABLE...\nINSERT INTO...",
+    "row_count": 1500,
+    "include_data": true,
+    "include_drop": true
+  }
+}
+```
+
+### Backup Entire Database
+
+```json
+{
+  "tool": "backup_database",
+  "arguments": {
+    "include_data": true,
+    "include_drop": true
+  }
+}
+```
+
+**Backup Specific Tables:**
+```json
+{
+  "tool": "backup_database",
+  "arguments": {
+    "tables": ["users", "orders", "products"],
+    "include_data": true
+  }
+}
+```
+
+### Restore from SQL Dump
+
+```json
+{
+  "tool": "restore_from_sql",
+  "arguments": {
+    "sql_dump": "DROP TABLE IF EXISTS `users`;\nCREATE TABLE `users` (...);",
+    "stop_on_error": true
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "status": "success",
+  "data": {
+    "message": "Restore completed successfully",
+    "statements_executed": 25,
+    "statements_failed": 0
+  }
+}
+```
+
+### Get Database Schema
+
+Get a complete overview of all database objects:
+
+```json
+{
+  "tool": "get_database_schema",
+  "arguments": {
+    "include_views": true,
+    "include_procedures": true,
+    "include_functions": true,
+    "include_triggers": true
+  }
+}
+```
+
+### Export to JSON Format
+
+```json
+{
+  "tool": "export_table_to_json",
+  "arguments": {
+    "table_name": "users",
+    "pretty": true,
+    "filters": [
+      { "field": "status", "operator": "eq", "value": "active" }
+    ]
+  }
+}
+```
+
+### Export to SQL INSERT Statements
+
+```json
+{
+  "tool": "export_table_to_sql",
+  "arguments": {
+    "table_name": "products",
+    "include_create_table": true,
+    "batch_size": 100
+  }
+}
+```
+
+### Backup Best Practices
+
+1. **Regular backups** - Schedule regular database backups
+2. **Test restores** - Periodically test your backup restoration process
+3. **Include structure** - Always include `include_drop: true` for clean restores
+4. **Schema-only backups** - Use `include_data: false` for structure-only backups
+5. **Selective backups** - Use `tables` array to backup only critical tables
+
+### Backup Safety Features
+
+- **Transactional integrity** - Backups include transaction markers
+- **Foreign key handling** - `SET FOREIGN_KEY_CHECKS=0` included in dumps
+- **Binary data support** - Proper escaping for BLOB and binary columns
+- **Character encoding** - UTF-8 encoding preserved in exports
+
+---
+
 ## 💰 Transaction Management
 
 The MySQL MCP Server provides full ACID transaction support, allowing you to group multiple database operations into atomic units.
@@ -1860,8 +2093,8 @@ MIT License - see [LICENSE](LICENSE) file for details.
 - ✅ **Process Management** - Server processes, status, and query analysis - **COMPLETED!**
 
 ### Enterprise Features
-- [ ] **Database backup and restore tools**
-- [ ] **Data export/import utilities** (CSV, JSON, SQL dumps)
+- [x] **Database backup and restore tools** - **COMPLETED!**
+- [x] **Data export/import utilities** (CSV, JSON, SQL dumps) - **COMPLETED!**
 - [ ] **Performance monitoring and metrics**
 - [ ] **Connection pool monitoring**
 - [ ] **Audit logging and compliance**
@@ -1884,9 +2117,9 @@ MIT License - see [LICENSE](LICENSE) file for details.
 - [ ] **Database health checks** - Comprehensive system health monitoring
 
 #### **Phase 2: Data Management** 📊
-- [ ] **Database backup and restore tools** - Essential for production data safety
+- [x] **Database backup and restore tools** - Essential for production data safety - **COMPLETED!**
 - [ ] **Data migration utilities** - Move data between databases and environments
-- [ ] **Enhanced export/import** - Support for JSON, XML, Excel formats
+- [x] **Enhanced export/import** - Support for JSON, SQL dump formats - **COMPLETED!**
 - [ ] **Query history & analytics** - Track and analyze database usage patterns
 
 #### **Phase 3: Enterprise Features** 🏢
@@ -1914,9 +2147,10 @@ MIT License - see [LICENSE](LICENSE) file for details.
 | Table Maintenance | High | Low | 7 | ✅ COMPLETED |
 | Process Management | High | Medium | 8 | ✅ COMPLETED |
 | Query Optimization | Medium | Medium | 9 | ✅ COMPLETED |
-| Database Backup/Restore | High | High | 10 | Pending |
-| Performance Monitoring | High | Medium | 11 | Pending |
-| Data Migration | High | High | 12 | Pending |
+| Database Backup/Restore | High | High | 10 | ✅ COMPLETED |
+| Data Export/Import (JSON, SQL) | High | Medium | 11 | ✅ COMPLETED |
+| Performance Monitoring | High | Medium | 12 | Pending |
+| Data Migration | High | High | 13 | Pending |
 | PostgreSQL Adapter | High | High | 13 | Pending |
 | Audit Logging | Medium | Low | 14 | Pending |
 | Schema Versioning | Medium | Medium | 15 | Pending |

package/README.md

@@ -11,7 +11,7 @@ A fully-featured **Model Context Protocol (MCP)** server for MySQL database inte
 
 - ✅ **Full MCP Protocol Support** - Works with Claude Desktop, Cline, Windsurf, and any MCP-compatible AI agent
 - 🔐 **Secure by Default** - Parameterized queries, SQL injection protection, permission-based access control
-- 🛠️ **85 Powerful Tools** - Complete database operations (CRUD, DDL, queries, schema inspection, transactions, stored procedures, bulk operations)
+- 🛠️ **95 Powerful Tools** - Complete database operations (CRUD, DDL, queries, schema inspection, transactions, stored procedures, bulk operations, backup/restore, import/export)
 - 🎛️ **Dynamic Per-Project Permissions** - Each AI agent can have different access levels
 - 🗃️ **DDL Support** - Create, alter, and drop tables (when explicitly enabled)
 - 💎 **Transaction Support** - Full ACID transaction management (BEGIN, COMMIT, ROLLBACK)
@@ -463,7 +463,7 @@ After (DDL enabled):
 
 ## 🛠️ Available Tools
 
-The MCP server provides **85 powerful tools**:
+The MCP server provides **95 powerful tools**:
 
 ### Database Discovery (4 tools)
 
@@ -635,6 +635,26 @@ The MCP server provides **85 powerful tools**:
 | `analyze_query` | Analyze query and get optimization suggestions |
 | `get_optimization_hints` | Get optimizer hints for SPEED, MEMORY, or STABILITY goals |
 
+### Database Backup & Restore (5 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `backup_table` | Backup single table to SQL dump format | `utility` permission |
+| `backup_database` | Backup entire database to SQL dump | `utility` permission |
+| `restore_from_sql` | Restore database from SQL dump content | `ddl` permission |
+| `get_create_table_statement` | Get CREATE TABLE statement for a table | `list` permission |
+| `get_database_schema` | Get complete database schema (tables, views, procedures, functions, triggers) | `list` permission |
+
+### Data Import/Export (5 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `export_table_to_json` | Export table data to JSON format | `utility` permission |
+| `export_query_to_json` | Export query results to JSON format | `utility` permission |
+| `export_table_to_sql` | Export table data to SQL INSERT statements | `utility` permission |
+| `import_from_csv` | Import data from CSV string into a table | `create` permission |
+| `import_from_json` | Import data from JSON array into a table | `create` permission |
+
 ---
 
 ## 📚 Detailed Documentation
@@ -642,7 +662,9 @@ The MCP server provides **85 powerful tools**:
 For comprehensive documentation on all features, please see **[DOCUMENTATIONS.md](DOCUMENTATIONS.md)** which includes:
 
 - 🗃️ **DDL Operations** - Create, alter, and drop tables
-- 📤 **Data Export Tools** - Export data to CSV format
+- 📤 **Data Export Tools** - Export data to CSV, JSON, and SQL formats
+- 📥 **Data Import Tools** - Import data from CSV and JSON sources
+- 💾 **Database Backup & Restore** - Full backup/restore with SQL dumps
 - 💎 **Transaction Management** - ACID transactions with BEGIN, COMMIT, ROLLBACK
 - 🔧 **Stored Procedures** - Create and execute stored procedures with IN/OUT/INOUT parameters
 - 📋 **Usage Examples** - Real-world examples for all tools

package/dist/config/featureConfig.js

@@ -129,6 +129,18 @@ exports.toolCategoryMap = {
     getServerInfo: ToolCategory.LIST,
     showBinaryLogs: ToolCategory.LIST,
     showReplicationStatus: ToolCategory.LIST,
+    // Backup and restore tools
+    backupTable: ToolCategory.UTILITY,
+    backupDatabase: ToolCategory.UTILITY,
+    restoreFromSql: ToolCategory.DDL,
+    getCreateTableStatement: ToolCategory.LIST,
+    getDatabaseSchema: ToolCategory.LIST,
+    // Extended data export/import tools
+    exportTableToJSON: ToolCategory.UTILITY,
+    exportQueryToJSON: ToolCategory.UTILITY,
+    exportTableToSql: ToolCategory.UTILITY,
+    importFromCSV: ToolCategory.CREATE,
+    importFromJSON: ToolCategory.CREATE,
 };
 /**
  * Class to manage feature configuration based on runtime or environment variables
@@ -218,6 +230,18 @@ class FeatureConfig {
             executeStoredProcedure: "execute stored procedures",
             exportTableToCSV: "export table data to CSV",
             exportQueryToCSV: "export query results to CSV",
+            // Backup and restore
+            backupTable: "backup table to SQL dump",
+            backupDatabase: "backup database to SQL dump",
+            restoreFromSql: "restore database from SQL dump",
+            getCreateTableStatement: "get CREATE TABLE statement",
+            getDatabaseSchema: "get database schema overview",
+            // Extended export/import
+            exportTableToJSON: "export table data to JSON",
+            exportQueryToJSON: "export query results to JSON",
+            exportTableToSql: "export table data to SQL INSERT statements",
+            importFromCSV: "import data from CSV",
+            importFromJSON: "import data from JSON",
         };
         const toolDescription = toolDescriptions[toolName] || actionDescriptions[category];
         const requiredPermission = category;

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export declare class MySQLMCP {
     private constraintTools;
     private maintenanceTools;
     private processTools;
+    private backupRestoreTools;
     private security;
     private featureConfig;
     constructor(permissionsConfig?: string);
@@ -278,6 +279,127 @@ export declare class MySQLMCP {
         error?: string;
         queryLog?: string;
     }>;
+    exportTableToJSON(params: {
+        table_name: string;
+        filters?: any[];
+        pagination?: {
+            page: number;
+            limit: number;
+        };
+        sorting?: {
+            field: string;
+            direction: "asc" | "desc";
+        };
+        pretty?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    exportQueryToJSON(params: {
+        query: string;
+        params?: any[];
+        pretty?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    exportTableToSql(params: {
+        table_name: string;
+        filters?: any[];
+        include_create_table?: boolean;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    importFromCSV(params: {
+        table_name: string;
+        csv_data: string;
+        has_headers?: boolean;
+        column_mapping?: Record<string, string>;
+        skip_errors?: boolean;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    importFromJSON(params: {
+        table_name: string;
+        json_data: string;
+        column_mapping?: Record<string, string>;
+        skip_errors?: boolean;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    backupTable(params: {
+        table_name: string;
+        include_data?: boolean;
+        include_drop?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    backupDatabase(params: {
+        include_data?: boolean;
+        include_drop?: boolean;
+        tables?: string[];
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    restoreFromSql(params: {
+        sql_dump: string;
+        stop_on_error?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    getCreateTableStatement(params: {
+        table_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    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;
+    }>;
     getFeatureStatus(): {
         status: string;
         data: {

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 {