@berthojoris/mcp-mysql-server 1.36.0 → 1.37.0

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to the MySQL MCP Server will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.37.0] - 2026-03-06
+
+### Removed
+- **Documentation Categories**: Removed `import_export` and `data_migration` categories from documentation to reduce bundle size
+- **Import/Export Category** (6 tools): `export_query_to_json`, `export_table_to_json`, `export_table_to_sql`, `import_from_csv`, `import_from_json`, `safe_export_table`
+- **Data Migration Category** (5 tools): `clone_table`, `compare_table_structure`, `copy_table_data`, `move_table_data`, `sync_table_data`
+
+### Changed
+- Updated DOCUMENTATIONS.md to remove Data Export and Data Import sections (117 → 106 tools, 21 → 19 categories)
+- Updated README.md with new tool count (106 tools) and removed categories from Documentation Categories table
+- Updated package description to remove "data import/export" reference
+- Bumped package version to `1.37.0`
+
 ## [1.36.0] - 2026-03-05
 
 ### Removed

package/DOCUMENTATIONS.md

@@ -1,8 +1,8 @@
 # MySQL MCP Server - Documentation
 
-**Last Updated:** 2026-03-05 00:00:00
-**Version:** 1.36.0
-**Total Tools:** 117
+**Last Updated:** 2026-03-06 00:00:00
+**Version:** 1.37.0
+**Total Tools:** 106
 
 Comprehensive documentation for the MySQL MCP Server. For quick start, see [README.md](README.md).
 
@@ -221,21 +221,13 @@ Tool enabled = (Has Permission) AND (Has Category OR No categories specified)
 - `configure_cache` - Configure cache settings
 - `clear_cache` - Clear cached results
 
-### 18. Data Export (4 tools)
-- `export_table_to_csv` - Export table to CSV
-- `export_table_to_json` - Export table to JSON
-- `safe_export_table` - Export with PII masking
-
-### 19. Utilities (4 tools)
+### 18. Utilities (4 tools)
 - `test_connection` - Test connectivity
 - `describe_connection` - Connection info
 - `read_changelog` - Read changelog
 - `invalidate_table_cache` - Clear table cache
 
-### 20. Data Import (1 tool)
-- `import_from_json` - Import data from JSON file
-
-### 21. Schema Migrations (9 tools)
+### 19. Schema Migrations (9 tools)
 - `init_migrations_table` - Initialize migrations tracking table
 - `create_migration` - Create a new migration
 - `apply_migrations` - Apply pending migrations

package/README.md

@@ -4,7 +4,7 @@
 
 **A production-ready Model Context Protocol (MCP) server for MySQL database integration with AI agents**
 
-**Last Updated:** 2026-03-05 00:00:00
+**Last Updated:** 2026-03-06 00:00:00
 
 [![npm version](https://img.shields.io/npm/v/@berthojoris/mcp-mysql-server)](https://www.npmjs.com/package/@berthojoris/mcp-mysql-server)
 [![npm downloads](https://img.shields.io/npm/dm/@berthojoris/mcp-mysql-server)](https://www.npmjs.com/package/@berthojoris/mcp-mysql-server)
@@ -264,8 +264,6 @@ Use documentation categories to fine-tune which tools are exposed (Layer 2):
 | `cache_management` | Manage query cache and optimization | `clear_cache, configure_cache_settings, get_cache_config, get_cache_stats, invalidate_cache_for_table` |
 | `query_optimization` | Analyze and optimize SQL queries | `analyze_query, get_optimization_hints` |
 | `backup_restore` | Create backups and restore databases | `backup_database, backup_table, get_create_table_statement, get_database_schema, restore_from_sql` |
-| `import_export` | Import and export data in various formats | `export_query_to_json, export_table_to_json, export_table_to_sql, import_from_csv, import_from_json, safe_export_table` |
-| `data_migration` | Migrate data between databases or systems | `clone_table, compare_table_structure, copy_table_data, move_table_data, sync_table_data` |
 | `schema_migrations` | Version control for database schema changes | `apply_migrations, create_migration, generate_migration_from_diff, get_migration_status, get_schema_version, init_migrations_table, reset_failed_migration, rollback_migration, validate_migrations` |
 | `analysis` | Data analysis and reporting tools | `get_column_statistics, get_database_summary, get_schema_erd, get_schema_rag_context` |
 
@@ -273,7 +271,7 @@ Use documentation categories to fine-tune which tools are exposed (Layer 2):
   <summary>Copy/paste list (comma-separated, no spaces)</summary>
 
 ```text
-database_discovery,crud_operations,bulk_operations,custom_queries,schema_management,utilities,transaction_management,stored_procedures,views_management,triggers_management,functions_management,index_management,constraint_management,table_maintenance,server_management,performance_monitoring,cache_management,query_optimization,backup_restore,import_export,data_migration,schema_migrations,analysis
+database_discovery,crud_operations,bulk_operations,custom_queries,schema_management,utilities,transaction_management,stored_procedures,views_management,triggers_management,functions_management,index_management,constraint_management,table_maintenance,server_management,performance_monitoring,cache_management,query_optimization,backup_restore,schema_migrations,analysis
 ```
 
 </details>
@@ -284,7 +282,7 @@ Full category → tool mapping (and examples) lives in **[DOCUMENTATIONS.md →
 
 ## Available Tools
 
-The server exposes **117 tools** organized into categories (CRUD, schema, migrations, and perf/monitoring).
+The server exposes **106 tools** organized into categories (CRUD, schema, migrations, and perf/monitoring).
 
 - Complete list of tools: **[DOCUMENTATIONS.md → Complete Tools Reference](DOCUMENTATIONS.md#🔧-complete-tools-reference)**
 

package/dist/config/featureConfig.d.ts

@@ -14,7 +14,7 @@ export declare enum ToolCategory {
     PROCEDURE = "procedure"
 }
 /**
- * Documentation categories from README (21 categories)
+ * Documentation categories from README (19 categories)
  * More intuitive and matches user mental model
  */
 export declare enum DocCategory {
@@ -37,8 +37,6 @@ export declare enum DocCategory {
     CACHE_MANAGEMENT = "cache_management",
     QUERY_OPTIMIZATION = "query_optimization",
     BACKUP_RESTORE = "backup_restore",
-    IMPORT_EXPORT = "import_export",
-    DATA_MIGRATION = "data_migration",
     SCHEMA_MIGRATIONS = "schema_migrations",
     ANALYSIS = "analysis"
 }

package/dist/config/featureConfig.js

@@ -24,7 +24,7 @@ var ToolCategory;
     ToolCategory["PROCEDURE"] = "procedure";
 })(ToolCategory || (exports.ToolCategory = ToolCategory = {}));
 /**
- * Documentation categories from README (21 categories)
+ * Documentation categories from README (19 categories)
  * More intuitive and matches user mental model
  */
 var DocCategory;
@@ -48,8 +48,6 @@ var DocCategory;
     DocCategory["CACHE_MANAGEMENT"] = "cache_management";
     DocCategory["QUERY_OPTIMIZATION"] = "query_optimization";
     DocCategory["BACKUP_RESTORE"] = "backup_restore";
-    DocCategory["IMPORT_EXPORT"] = "import_export";
-    DocCategory["DATA_MIGRATION"] = "data_migration";
     DocCategory["SCHEMA_MIGRATIONS"] = "schema_migrations";
     DocCategory["ANALYSIS"] = "analysis";
 })(DocCategory || (exports.DocCategory = DocCategory = {}));
@@ -331,19 +329,6 @@ exports.toolDocCategoryMap = {
     restoreFromSql: DocCategory.BACKUP_RESTORE,
     getCreateTableStatement: DocCategory.BACKUP_RESTORE,
     getDatabaseSchema: DocCategory.BACKUP_RESTORE,
-    // Import/Export
-    exportTableToJSON: DocCategory.IMPORT_EXPORT,
-    exportQueryToJSON: DocCategory.IMPORT_EXPORT,
-    exportTableToSql: DocCategory.IMPORT_EXPORT,
-    safe_export_table: DocCategory.IMPORT_EXPORT,
-    importFromCSV: DocCategory.IMPORT_EXPORT,
-    importFromJSON: DocCategory.IMPORT_EXPORT,
-    // Data Migration
-    copyTableData: DocCategory.DATA_MIGRATION,
-    moveTableData: DocCategory.DATA_MIGRATION,
-    cloneTable: DocCategory.DATA_MIGRATION,
-    compareTableStructure: DocCategory.DATA_MIGRATION,
-    syncTableData: DocCategory.DATA_MIGRATION,
     // Schema Migrations
     initMigrationsTable: DocCategory.SCHEMA_MIGRATIONS,
     createMigration: DocCategory.SCHEMA_MIGRATIONS,
@@ -390,18 +375,14 @@ const legacyToDocCategoryMap = {
     create: [
         DocCategory.CRUD_OPERATIONS,
         DocCategory.BULK_OPERATIONS,
-        DocCategory.IMPORT_EXPORT,
-        DocCategory.DATA_MIGRATION,
     ],
     update: [
         DocCategory.CRUD_OPERATIONS,
         DocCategory.BULK_OPERATIONS,
-        DocCategory.DATA_MIGRATION,
     ],
     delete: [
         DocCategory.CRUD_OPERATIONS,
         DocCategory.BULK_OPERATIONS,
-        DocCategory.DATA_MIGRATION,
     ],
     execute: [DocCategory.CUSTOM_QUERIES, DocCategory.SERVER_MANAGEMENT],
     ddl: [
@@ -412,7 +393,6 @@ const legacyToDocCategoryMap = {
         DocCategory.CONSTRAINT_MANAGEMENT,
         DocCategory.TABLE_MAINTENANCE,
         DocCategory.BACKUP_RESTORE,
-        DocCategory.DATA_MIGRATION,
         DocCategory.SCHEMA_MIGRATIONS,
     ],
     utility: [
@@ -422,7 +402,6 @@ const legacyToDocCategoryMap = {
         DocCategory.CACHE_MANAGEMENT,
         DocCategory.QUERY_OPTIMIZATION,
         DocCategory.BACKUP_RESTORE,
-        DocCategory.IMPORT_EXPORT,
     ],
     transaction: [DocCategory.TRANSACTION_MANAGEMENT],
     procedure: [DocCategory.STORED_PROCEDURES, DocCategory.FUNCTIONS_MANAGEMENT],

package/dist/index.d.ts

@@ -321,49 +321,6 @@ export declare class MySQLMCP {
         data?: any;
         error?: 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;
-    }>;
-    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;
-    }>;
-    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;
-    }>;
     /**
      * Initialize the migrations tracking table
      */

package/dist/index.js

@@ -346,29 +346,6 @@ class MySQLMCP {
         }
         return await this.dataExportTools.exportTableToCSV(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);
-    }
-    // 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);
-    }
     // ==========================================
     // Schema Versioning and Migrations Tools
     // ==========================================

package/dist/mcp-server.js

@@ -484,33 +484,6 @@ const TOOLS = [
             required: ["query"],
         },
     },
-    {
-        name: "safe_export_table",
-        description: "🔒 SECURITY: Exports table data to CSV with automatic PII/sensitive data masking. Redacts emails, credit cards, passwords, etc. Use this instead of export_table_to_csv when handling sensitive data or sharing exports externally.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                table_name: {
-                    type: "string",
-                    description: "Name of the table to export",
-                },
-                masking_profile: {
-                    type: "string",
-                    enum: ["soft", "partial", "strict"],
-                    description: "Masking profile to apply (default: strict). strict=redact all PII/secrets, partial=partial mask PII, soft=mask secrets only.",
-                },
-                limit: {
-                    type: "number",
-                    description: "Maximum number of rows to export (default: 1000, max: 10000)",
-                },
-                include_headers: {
-                    type: "boolean",
-                    description: "Whether to include CSV headers (default: true)",
-                },
-            },
-            required: ["table_name"],
-        },
-    },
     {
         name: "repair_query",
         description: "🔧 Diagnoses SQL query errors and suggests fixes. Analyzes syntax errors, missing columns/tables, and logic issues. Provide the query and optional error message to get repair recommendations. Use when a query fails or needs debugging.",
@@ -2145,386 +2118,6 @@ const TOOLS = [
             },
         },
     },
-    // 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"],
-        },
-    },
     // Schema Versioning and Migrations Tools
     {
         name: "init_migrations_table",
@@ -3330,17 +2923,6 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case "explain_query":
                 result = await mysqlMCP.explainQuery((args || {}));
                 break;
-            // Extended Data Export Tools
-            case "export_table_to_json":
-                result = await mysqlMCP.exportTableToJSON((args || {}));
-                break;
-            case "safe_export_table":
-                result = await mysqlMCP.safeExportTable((args || {}));
-                break;
-            // Data Import Tools
-            case "import_from_json":
-                result = await mysqlMCP.importFromJSON((args || {}));
-                break;
             // Schema Versioning and Migrations Tools
             case "init_migrations_table":
                 result = await mysqlMCP.initMigrationsTable((args || {}));
@@ -3527,8 +3109,6 @@ function validateToolArguments(name, args) {
                         return { valid: false, errors: [validation.error || 'Invalid table name'] };
                 }
                 return { valid: true };
-            case "import_from_json":
-                return (0, inputValidation_js_1.validateImportFromJSON)(args);
             default:
                 return { valid: true }; // For tools without specific validation
         }

package/dist/tools/dataExportTools.d.ts

@@ -26,54 +26,4 @@ export declare class DataExportTools {
         data?: any;
         error?: string;
     }>;
-    /**
-     * Export table data to JSON format
-     */
-    exportTableToJSON(params: {
-        table_name: string;
-        filters?: FilterCondition[];
-        pagination?: Pagination;
-        sorting?: Sorting;
-        pretty?: boolean;
-        database?: string;
-    }): Promise<{
-        status: string;
-        data?: any;
-        error?: string;
-    }>;
-    /**
-     * Import data from CSV 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;
-    }>;
-    /**
-     * Parse CSV string into array of arrays
-     */
-    private parseCSV;
-    /**
-     * Import data from JSON 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;
-    }>;
 }

package/dist/tools/dataExportTools.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataExportTools = void 0;
 const connection_1 = __importDefault(require("../db/connection"));
 const config_1 = require("../config/config");
-const inputValidation_1 = require("../validation/inputValidation");
 class DataExportTools {
     constructor(security) {
         this.db = connection_1.default.getInstance();
@@ -222,428 +221,5 @@ class DataExportTools {
             };
         }
     }
-    /**
-     * Export table data to JSON format
-     */
-    async exportTableToJSON(params) {
-        try {
-            const { table_name, filters = [], pagination, sorting, pretty = true, database, } = params;
-            // Validate database access
-            const dbValidation = this.validateDatabaseAccess(database);
-            if (!dbValidation.valid) {
-                return { status: "error", error: dbValidation.error };
-            }
-            // Validate table name
-            const tableValidation = this.security.validateIdentifier(table_name);
-            if (!tableValidation.valid) {
-                return { status: "error", error: tableValidation.error };
-            }
-            // Build WHERE clause
-            let whereClause = "";
-            const whereParams = [];
-            if (filters && filters.length > 0) {
-                const whereConditions = [];
-                for (const filter of filters) {
-                    const fieldValidation = this.security.validateIdentifier(filter.field);
-                    if (!fieldValidation.valid) {
-                        return {
-                            status: "error",
-                            error: `Invalid field name: ${filter.field}`,
-                        };
-                    }
-                    const fieldName = this.security.escapeIdentifier(filter.field);
-                    switch (filter.operator) {
-                        case "eq":
-                            whereConditions.push(`${fieldName} = ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "neq":
-                            whereConditions.push(`${fieldName} != ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "gt":
-                            whereConditions.push(`${fieldName} > ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "gte":
-                            whereConditions.push(`${fieldName} >= ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "lt":
-                            whereConditions.push(`${fieldName} < ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "lte":
-                            whereConditions.push(`${fieldName} <= ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "like":
-                            whereConditions.push(`${fieldName} LIKE ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "in":
-                            if (Array.isArray(filter.value)) {
-                                const placeholders = filter.value.map(() => "?").join(", ");
-                                whereConditions.push(`${fieldName} IN (${placeholders})`);
-                                whereParams.push(...filter.value);
-                            }
-                            else {
-                                return {
-                                    status: "error",
-                                    error: "IN operator requires an array of values",
-                                };
-                            }
-                            break;
-                        default:
-                            return {
-                                status: "error",
-                                error: `Unsupported operator: ${filter.operator}`,
-                            };
-                    }
-                }
-                if (whereConditions.length > 0) {
-                    whereClause = "WHERE " + whereConditions.join(" AND ");
-                }
-            }
-            // Build ORDER BY clause
-            let orderByClause = "";
-            if (sorting) {
-                const fieldValidation = this.security.validateIdentifier(sorting.field);
-                if (!fieldValidation.valid) {
-                    return {
-                        status: "error",
-                        error: `Invalid sort field name: ${sorting.field}`,
-                    };
-                }
-                const fieldName = this.security.escapeIdentifier(sorting.field);
-                const direction = sorting.direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
-                orderByClause = `ORDER BY ${fieldName} ${direction}`;
-            }
-            // Build LIMIT clause
-            let limitClause = "";
-            if (pagination) {
-                const offset = (pagination.page - 1) * pagination.limit;
-                limitClause = `LIMIT ${offset}, ${pagination.limit}`;
-            }
-            // Construct and execute query
-            const escapedTableName = this.security.escapeIdentifier(table_name);
-            const query = `SELECT * FROM ${escapedTableName} ${whereClause} ${orderByClause} ${limitClause}`;
-            const results = await this.db.query(query, whereParams);
-            // Generate JSON
-            const json = pretty
-                ? JSON.stringify(results, null, 2)
-                : JSON.stringify(results);
-            return {
-                status: "success",
-                data: {
-                    json: json,
-                    row_count: results.length,
-                    table_name: table_name,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                status: "error",
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * Import data from CSV string
-     */
-    async importFromCSV(params) {
-        try {
-            const { table_name, csv_data, has_headers = true, column_mapping, skip_errors = false, batch_size = 100, database, } = params;
-            // Validate database access
-            const dbValidation = this.validateDatabaseAccess(database);
-            if (!dbValidation.valid) {
-                return { status: "error", error: dbValidation.error };
-            }
-            // Validate table name
-            const tableValidation = this.security.validateIdentifier(table_name);
-            if (!tableValidation.valid) {
-                return { status: "error", error: tableValidation.error };
-            }
-            // Parse CSV
-            const rows = this.parseCSV(csv_data);
-            if (rows.length === 0) {
-                return { status: "error", error: "CSV data is empty" };
-            }
-            let headers;
-            let dataRows;
-            if (has_headers) {
-                headers = rows[0];
-                dataRows = rows.slice(1);
-            }
-            else {
-                // If no headers, we need column_mapping or use column indexes
-                if (!column_mapping) {
-                    return {
-                        status: "error",
-                        error: "Column mapping is required when CSV has no headers",
-                    };
-                }
-                headers = Object.keys(column_mapping);
-                dataRows = rows;
-            }
-            // Apply column mapping if provided
-            const finalHeaders = column_mapping
-                ? headers.map((h) => column_mapping[h] || h)
-                : headers;
-            // Validate all column names
-            for (const col of finalHeaders) {
-                const colValidation = this.security.validateIdentifier(col);
-                if (!colValidation.valid) {
-                    return { status: "error", error: `Invalid column name: ${col}` };
-                }
-            }
-            const escapedTableName = this.security.escapeIdentifier(table_name);
-            const escapedColumns = finalHeaders
-                .map((c) => this.security.escapeIdentifier(c))
-                .join(", ");
-            let successCount = 0;
-            let errorCount = 0;
-            const errors = [];
-            let queryCount = 0;
-            // Insert in batches
-            for (let i = 0; i < dataRows.length; i += batch_size) {
-                const batch = dataRows.slice(i, i + batch_size);
-                try {
-                    const values = batch
-                        .map((row) => {
-                        const rowValues = row.map((val) => {
-                            if (val === "" || val === null || val === undefined)
-                                return "NULL";
-                            return this.escapeValue(val);
-                        });
-                        return `(${rowValues.join(", ")})`;
-                    })
-                        .join(", ");
-                    const query = `INSERT INTO ${escapedTableName} (${escapedColumns}) VALUES ${values}`;
-                    await this.db.query(query);
-                    queryCount++;
-                    successCount += batch.length;
-                }
-                catch (error) {
-                    if (skip_errors) {
-                        // Try inserting rows one by one
-                        for (let j = 0; j < batch.length; j++) {
-                            try {
-                                const rowValues = batch[j].map((val) => {
-                                    if (val === "" || val === null || val === undefined)
-                                        return "NULL";
-                                    return this.escapeValue(val);
-                                });
-                                const query = `INSERT INTO ${escapedTableName} (${escapedColumns}) VALUES (${rowValues.join(", ")})`;
-                                await this.db.query(query);
-                                queryCount++;
-                                successCount++;
-                            }
-                            catch (rowError) {
-                                errorCount++;
-                                errors.push({
-                                    row: i + j + (has_headers ? 2 : 1),
-                                    error: rowError.message,
-                                });
-                            }
-                        }
-                    }
-                    else {
-                        return {
-                            status: "error",
-                            error: `Import failed at row ${i + 1}: ${error.message}`,
-                            data: { rows_imported: successCount },
-                        };
-                    }
-                }
-            }
-            return {
-                status: errorCount > 0 ? "partial" : "success",
-                data: {
-                    message: errorCount > 0
-                        ? `Import completed with ${errorCount} errors`
-                        : "Import completed successfully",
-                    rows_imported: successCount,
-                    rows_failed: errorCount,
-                    errors: errors.length > 0 ? errors.slice(0, 10) : undefined,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                status: "error",
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * Parse CSV string into array of arrays
-     */
-    parseCSV(csv) {
-        const rows = [];
-        const lines = csv.split(/\r?\n/);
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            const row = [];
-            let current = "";
-            let inQuotes = false;
-            for (let i = 0; i < line.length; i++) {
-                const char = line[i];
-                const nextChar = line[i + 1];
-                if (inQuotes) {
-                    if (char === '"' && nextChar === '"') {
-                        current += '"';
-                        i++; // Skip next quote
-                    }
-                    else if (char === '"') {
-                        inQuotes = false;
-                    }
-                    else {
-                        current += char;
-                    }
-                }
-                else {
-                    if (char === '"') {
-                        inQuotes = true;
-                    }
-                    else if (char === ",") {
-                        row.push(current);
-                        current = "";
-                    }
-                    else {
-                        current += char;
-                    }
-                }
-            }
-            row.push(current);
-            rows.push(row);
-        }
-        return rows;
-    }
-    /**
-     * Import data from JSON string
-     */
-    async importFromJSON(params) {
-        // Validate input parameters using the new validation function
-        const validation = (0, inputValidation_1.validateImportFromJSON)(params);
-        if (!validation.valid) {
-            return {
-                status: "error",
-                error: `Validation failed: ${validation.errors?.join(', ') || 'Invalid parameters'}`
-            };
-        }
-        try {
-            const { table_name, json_data, column_mapping, skip_errors = false, batch_size = 100, database, } = params;
-            // Validate database access
-            const dbValidation = this.validateDatabaseAccess(database);
-            if (!dbValidation.valid) {
-                return { status: "error", error: dbValidation.error };
-            }
-            // Validate table name using security layer
-            const tableValidation = this.security.validateIdentifier(table_name);
-            if (!tableValidation.valid) {
-                return { status: "error", error: tableValidation.error };
-            }
-            // Parse JSON - this should already be validated by validateImportFromJSON
-            let data;
-            try {
-                data = JSON.parse(json_data);
-            }
-            catch (e) {
-                return { status: "error", error: "Invalid JSON data" };
-            }
-            if (!Array.isArray(data)) {
-                return {
-                    status: "error",
-                    error: "JSON data must be an array of objects",
-                };
-            }
-            if (data.length === 0) {
-                return { status: "error", error: "JSON data is empty" };
-            }
-            // Get columns from first object
-            let columns = Object.keys(data[0]);
-            // Apply column mapping if provided
-            if (column_mapping) {
-                columns = columns.map((c) => column_mapping[c] || c);
-            }
-            // Validate all column names
-            for (const col of columns) {
-                const colValidation = this.security.validateIdentifier(col);
-                if (!colValidation.valid) {
-                    return { status: "error", error: `Invalid column name: ${col}` };
-                }
-            }
-            const escapedTableName = this.security.escapeIdentifier(table_name);
-            const originalColumns = Object.keys(data[0]);
-            const escapedColumns = columns
-                .map((c) => this.security.escapeIdentifier(c))
-                .join(", ");
-            let successCount = 0;
-            let errorCount = 0;
-            const errors = [];
-            let queryCount = 0;
-            // Insert in batches
-            for (let i = 0; i < data.length; i += batch_size) {
-                const batch = data.slice(i, i + batch_size);
-                try {
-                    const values = batch
-                        .map((row) => {
-                        const rowValues = originalColumns.map((col) => this.escapeValue(row[col]));
-                        return `(${rowValues.join(", ")})`;
-                    })
-                        .join(", ");
-                    const query = `INSERT INTO ${escapedTableName} (${escapedColumns}) VALUES ${values}`;
-                    await this.db.query(query);
-                    queryCount++;
-                    successCount += batch.length;
-                }
-                catch (error) {
-                    if (skip_errors) {
-                        // Try inserting rows one by one
-                        for (let j = 0; j < batch.length; j++) {
-                            try {
-                                const rowValues = originalColumns.map((col) => this.escapeValue(batch[j][col]));
-                                const query = `INSERT INTO ${escapedTableName} (${escapedColumns}) VALUES (${rowValues.join(", ")})`;
-                                await this.db.query(query);
-                                queryCount++;
-                                successCount++;
-                            }
-                            catch (rowError) {
-                                errorCount++;
-                                errors.push({ row: i + j + 1, error: rowError.message });
-                            }
-                        }
-                    }
-                    else {
-                        return {
-                            status: "error",
-                            error: `Import failed at row ${i + 1}: ${error.message}`,
-                            data: { rows_imported: successCount },
-                        };
-                    }
-                }
-            }
-            return {
-                status: errorCount > 0 ? "partial" : "success",
-                data: {
-                    message: errorCount > 0
-                        ? `Import completed with ${errorCount} errors`
-                        : "Import completed successfully",
-                    rows_imported: successCount,
-                    rows_failed: errorCount,
-                    errors: errors.length > 0 ? errors.slice(0, 10) : undefined,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                status: "error",
-                error: error.message,
-            };
-        }
-    }
 }
 exports.DataExportTools = DataExportTools;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@berthojoris/mcp-mysql-server",
-  "version": "1.36.0",
-  "description": "Model Context Protocol server for MySQL database integration with dynamic per-project permissions, backup/restore, data import/export, and data migration capabilities",
+  "version": "1.37.0",
+  "description": "Model Context Protocol server for MySQL database integration with dynamic per-project permissions, backup/restore, and schema migration capabilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "commonjs",