@berthojoris/mcp-mysql-server 1.2.6 → 1.4.0

package/README.md

@@ -157,12 +157,14 @@ The MCP server provides **30 powerful tools**:
 | `drop_table` | Delete tables | `ddl` permission |
 | `execute_ddl` | Execute raw DDL SQL (CREATE, ALTER, DROP, TRUNCATE, RENAME) | `ddl` permission |
 
-### Utilities (2 tools)
+### Utilities (4 tools)
 
 | Tool | Description |
 |------|-------------|
 | `test_connection` | Test database connectivity and measure latency |
 | `describe_connection` | Get current connection information |
+| `export_table_to_csv` | Export table data to CSV format with optional filtering, pagination, and sorting |
+| `export_query_to_csv` | Export the results of a SELECT query to CSV format |
 
 ### Transaction Management (5 tools)
 
@@ -281,6 +283,120 @@ You can have different databases with different permissions in the same AI agent
 
 ---
 
+## 🚫 Permission Error Handling
+
+The MySQL MCP Server provides clear, user-friendly error messages when operations are attempted without proper permissions. This helps users understand exactly what permissions are needed and how to enable them.
+
+### Error Message Format
+
+When a tool is called without the required permission, you'll receive a detailed error message like:
+
+```
+❌ Permission denied: Cannot use tool 'create_table'. This tool requires 'ddl' permission.
+
+Current permissions: list,read,utility
+To enable this tool, add 'ddl' to your permissions configuration.
+
+Example configuration:
+"args": ["mysql://user:pass@host:3306/db", "list,read,utility,ddl"]
+
+Tool description: Create new tables with columns and indexes
+```
+
+### Common Permission Error Examples
+
+#### Creating Tables Without DDL Permission
+
+**User prompt:** *"Create a new table called 'products'"*
+
+**Error response when DDL not enabled:**
+```
+❌ Permission denied: Cannot use tool 'create_table'. This tool requires 'ddl' permission.
+
+Current permissions: list,read,utility
+To enable this tool, add 'ddl' to your permissions configuration.
+
+Example configuration:
+"args": ["mysql://user:pass@host:3306/db", "list,read,utility,ddl"]
+
+Tool description: Create new tables with columns and indexes
+```
+
+#### Inserting Data Without Create Permission
+
+**User prompt:** *"Add a new user to the users table"*
+
+**Error response when CREATE not enabled:**
+```
+❌ Permission denied: Cannot use tool 'create_record'. This tool requires 'create' permission.
+
+Current permissions: list,read,utility
+To enable this tool, add 'create' to your permissions configuration.
+
+Example configuration:
+"args": ["mysql://user:pass@host:3306/db", "list,read,utility,create"]
+
+Tool description: Insert new records with automatic SQL generation
+```
+
+#### Updating Data Without Update Permission
+
+**User prompt:** *"Update the email for user ID 123"*
+
+**Error response when UPDATE not enabled:**
+```
+❌ Permission denied: Cannot use tool 'update_record'. This tool requires 'update' permission.
+
+Current permissions: list,read,utility
+To enable this tool, add 'update' to your permissions configuration.
+
+Example configuration:
+"args": ["mysql://user:pass@host:3306/db", "list,read,utility,update"]
+
+Tool description: Update existing records based on conditions
+```
+
+### Permission Error Benefits
+
+1. **🎯 Clear Guidance** - Exact permission needed and how to add it
+2. **📋 Current State** - Shows what permissions are currently active
+3. **💡 Example Configuration** - Ready-to-use configuration example
+4. **📖 Tool Context** - Explains what the tool does
+5. **🔒 Security** - Prevents unauthorized operations while being helpful
+
+### Troubleshooting Permission Errors
+
+If you encounter permission errors:
+
+1. **Check your configuration** - Verify the permissions string in your MCP configuration
+2. **Add required permission** - Add the missing permission to your configuration
+3. **Restart your AI agent** - Changes require a restart to take effect
+4. **Test with a simple operation** - Verify the permission is working
+
+**Example fix for DDL operations:**
+
+Before (DDL disabled):
+```json
+{
+  "args": [
+    "mysql://user:pass@localhost:3306/db",
+    "list,read,utility"
+  ]
+}
+```
+
+After (DDL enabled):
+```json
+{
+  "args": [
+    "mysql://user:pass@localhost:3306/db",
+    "list,read,utility,ddl"
+  ]
+}
+```
+
+---
+
 ## 🏗️ DDL Operations
 
 DDL (Data Definition Language) operations allow AI to create, modify, and delete tables.
@@ -366,6 +482,140 @@ DDL operations are **disabled by default** for safety. Add `ddl` to permissions
 
 ---
 
+## 📤 Data Export Tools
+
+The MySQL MCP Server provides powerful data export capabilities, allowing AI agents to export database content in CSV format for analysis, reporting, and data sharing.
+
+### Data Export Tools Overview
+
+- **`export_table_to_csv`** - Export all or filtered data from a table to CSV format
+- **`export_query_to_csv`** - Export the results of a custom SELECT query to CSV format
+
+Both tools support:
+- Filtering data with conditions
+- Pagination for large datasets
+- Sorting results
+- Optional column headers
+- Proper CSV escaping for special characters
+
+### Data Export Tool Examples
+
+#### Export Table to CSV
+
+**User prompt:** *"Export the first 100 users ordered by registration date to CSV"*
+
+**AI will execute:**
+```json
+{
+  "tool": "export_table_to_csv",
+  "arguments": {
+    "table_name": "users",
+    "sorting": {
+      "field": "registration_date",
+      "direction": "desc"
+    },
+    "pagination": {
+      "page": 1,
+      "limit": 100
+    },
+    "include_headers": true
+  }
+}
+```
+
+#### Export Filtered Data to CSV
+
+**User prompt:** *"Export all users from the marketing department to CSV"*
+
+**AI will execute:**
+```json
+{
+  "tool": "export_table_to_csv",
+  "arguments": {
+    "table_name": "users",
+    "filters": [
+      {
+        "field": "department",
+        "operator": "eq",
+        "value": "marketing"
+      }
+    ],
+    "include_headers": true
+  }
+}
+```
+
+#### Export Query Results to CSV
+
+**User prompt:** *"Export a report of total sales by product category to CSV"*
+
+**AI will execute:**
+```json
+{
+  "tool": "export_query_to_csv",
+  "arguments": {
+    "query": "SELECT category, SUM(sales_amount) as total_sales FROM sales GROUP BY category ORDER BY total_sales DESC",
+    "include_headers": true
+  }
+}
+```
+
+### Data Export Best Practices
+
+1. ✅ **Use filtering** - Export only the data you need to reduce file size
+2. ✅ **Implement pagination** - For large datasets, use pagination to avoid memory issues
+3. ✅ **Include headers** - Make CSV files more understandable with column headers
+4. ✅ **Test with small datasets first** - Verify export format before processing large amounts of data
+5. ✅ **Use proper permissions** - Data export tools require `utility` permission
+
+### Common Data Export Patterns
+
+**Pattern 1: Simple Table Export**
+```json
+{
+  "tool": "export_table_to_csv",
+  "arguments": {
+    "table_name": "products",
+    "include_headers": true
+  }
+}
+```
+
+**Pattern 2: Filtered and Sorted Export**
+```json
+{
+  "tool": "export_table_to_csv",
+  "arguments": {
+    "table_name": "orders",
+    "filters": [
+      {
+        "field": "order_date",
+        "operator": "gte",
+        "value": "2023-01-01"
+      }
+    ],
+    "sorting": {
+      "field": "order_date",
+      "direction": "desc"
+    },
+    "include_headers": true
+  }
+}
+```
+
+**Pattern 3: Complex Query Export**
+```json
+{
+  "tool": "export_query_to_csv",
+  "arguments": {
+    "query": "SELECT u.name, u.email, COUNT(o.id) as order_count FROM users u LEFT JOIN orders o ON u.id = o.user_id GROUP BY u.id HAVING order_count > 5",
+    "include_headers": true
+  }
+}
+```
+
+---
+
 ## 💰 Transaction Management
 
 The MySQL MCP Server provides full ACID transaction support, allowing you to group multiple database operations into atomic units.
@@ -1148,6 +1398,45 @@ MIT License - see [LICENSE](LICENSE) file for details.
 - [ ] Oracle Database adapter
 - [ ] SQL Server adapter
 
+### Recommended Implementation Order
+
+#### **Phase 1: Performance & Monitoring** 🚀
+- [ ] **Query result caching** - Dramatically improve response times for repeated queries
+- [ ] **Performance metrics** - Track query execution times and database performance
+- [ ] **Connection pool monitoring** - Monitor database connection health and usage
+- [ ] **Database health checks** - Comprehensive system health monitoring
+
+#### **Phase 2: Data Management** 📊
+- [ ] **Database backup and restore tools** - Essential for production data safety
+- [ ] **Data migration utilities** - Move data between databases and environments
+- [ ] **Enhanced export/import** - Support for JSON, XML, Excel formats
+- [ ] **Query history & analytics** - Track and analyze database usage patterns
+
+#### **Phase 3: Enterprise Features** 🏢
+- [ ] **Audit logging and compliance** - Track all database operations for security
+- [ ] **Schema versioning and migrations** - Version control for database schema changes
+- [ ] **Query optimization** - Automatic query analysis and optimization suggestions
+- [ ] **Advanced security features** - Enhanced access control and monitoring
+
+#### **Phase 4: Multi-Database Support** 🌐
+- [ ] **PostgreSQL adapter** - Extend support to PostgreSQL databases
+- [ ] **MongoDB adapter** - Add NoSQL document database support
+- [ ] **SQLite adapter** - Support for lightweight embedded databases
+- [ ] **Database-agnostic operations** - Unified API across different database types
+
+#### **Implementation Priority Matrix**
+
+| Feature | Impact | Effort | Priority |
+|---------|--------|--------|----------|
+| Query Result Caching | High | Medium | 1 |
+| Database Backup/Restore | High | High | 2 |
+| Performance Monitoring | High | Medium | 3 |
+| Data Migration | High | High | 4 |
+| Query Optimization | Medium | Medium | 5 |
+| PostgreSQL Adapter | High | High | 6 |
+| Audit Logging | Medium | Low | 7 |
+| Schema Versioning | Medium | Medium | 8 |
+
 ---
 
 **Made with ❤️ for the AI community**

package/dist/config/featureConfig.d.ts

@@ -22,6 +22,7 @@ export declare const toolCategoryMap: Record<string, ToolCategory>;
  */
 export declare class FeatureConfig {
     private enabledCategories;
+    private originalConfigString;
     constructor(configStr?: string);
     /**
      * Parse MCP_CONFIG from provided string or environment variables
@@ -35,6 +36,10 @@ export declare class FeatureConfig {
      * Check if a specific tool is enabled
      */
     isToolEnabled(toolName: string): boolean;
+    /**
+     * Get detailed permission error message for a specific tool
+     */
+    getPermissionError(toolName: string): string;
     /**
      * Check if a category is enabled
      */

package/dist/config/featureConfig.js

@@ -36,6 +36,10 @@ exports.toolCategoryMap = {
     'readRecords': ToolCategory.READ,
     'updateRecord': ToolCategory.UPDATE,
     'deleteRecord': ToolCategory.DELETE,
+    // Bulk operations
+    'bulkInsert': ToolCategory.CREATE,
+    'bulkUpdate': ToolCategory.UPDATE,
+    'bulkDelete': ToolCategory.DELETE,
     // Query tools
     'runQuery': ToolCategory.READ,
     'executeSql': ToolCategory.EXECUTE,
@@ -48,6 +52,8 @@ exports.toolCategoryMap = {
     'describeConnection': ToolCategory.UTILITY,
     'testConnection': ToolCategory.UTILITY,
     'getTableRelationships': ToolCategory.UTILITY,
+    'exportTableToCSV': ToolCategory.UTILITY,
+    'exportQueryToCSV': ToolCategory.UTILITY,
     // Transaction tools
     'beginTransaction': ToolCategory.TRANSACTION,
     'commitTransaction': ToolCategory.TRANSACTION,
@@ -67,6 +73,7 @@ exports.toolCategoryMap = {
  */
 class FeatureConfig {
     constructor(configStr) {
+        this.originalConfigString = configStr || process.env.MCP_CONFIG || '';
         this.enabledCategories = this.parseConfig(configStr);
     }
     /**
@@ -88,6 +95,7 @@ class FeatureConfig {
      * Update configuration at runtime
      */
     setConfig(configStr) {
+        this.originalConfigString = configStr;
         this.enabledCategories = this.parseConfig(configStr);
     }
     /**
@@ -102,6 +110,57 @@ class FeatureConfig {
         }
         return this.enabledCategories.has(category);
     }
+    /**
+     * Get detailed permission error message for a specific tool
+     */
+    getPermissionError(toolName) {
+        const category = exports.toolCategoryMap[toolName];
+        if (!category) {
+            return `Unknown tool '${toolName}'. This tool is not recognized by the MCP server.`;
+        }
+        const isAllPermissions = !this.originalConfigString.trim();
+        const currentPermissions = isAllPermissions ? 'all' : this.originalConfigString;
+        const actionDescriptions = {
+            [ToolCategory.LIST]: 'list databases and tables',
+            [ToolCategory.READ]: 'read data from tables',
+            [ToolCategory.CREATE]: 'create new records',
+            [ToolCategory.UPDATE]: 'update existing records',
+            [ToolCategory.DELETE]: 'delete records',
+            [ToolCategory.EXECUTE]: 'execute custom SQL queries',
+            [ToolCategory.DDL]: 'create, alter, or drop tables (schema changes)',
+            [ToolCategory.UTILITY]: 'use utility functions',
+            [ToolCategory.TRANSACTION]: 'manage database transactions',
+            [ToolCategory.PROCEDURE]: 'manage stored procedures'
+        };
+        const toolDescriptions = {
+            'createTable': 'create new tables',
+            'alterTable': 'modify table structure',
+            'dropTable': 'delete tables',
+            'executeDdl': 'execute DDL statements',
+            'createRecord': 'insert new records',
+            'updateRecord': 'update existing records',
+            'deleteRecord': 'delete records',
+            'bulkInsert': 'insert multiple records in batches',
+            'bulkUpdate': 'update multiple records in batches',
+            'bulkDelete': 'delete multiple records in batches',
+            'executeSql': 'execute custom SQL statements',
+            'runQuery': 'run SELECT queries',
+            'beginTransaction': 'start database transactions',
+            'commitTransaction': 'commit database transactions',
+            'rollbackTransaction': 'rollback database transactions',
+            'executeInTransaction': 'execute queries within transactions',
+            'createStoredProcedure': 'create stored procedures',
+            'dropStoredProcedure': 'delete stored procedures',
+            'executeStoredProcedure': 'execute stored procedures',
+            'exportTableToCSV': 'export table data to CSV',
+            'exportQueryToCSV': 'export query results to CSV'
+        };
+        const toolDescription = toolDescriptions[toolName] || actionDescriptions[category];
+        const requiredPermission = category;
+        return `Permission denied: Cannot ${toolDescription}. ` +
+            `This action requires '${requiredPermission}' permission, but your current MCP configuration only allows: ${currentPermissions}. ` +
+            `To enable this feature, update your MCP server configuration to include '${requiredPermission}' in the permissions list.`;
+    }
     /**
      * Check if a category is enabled
      */

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export declare class MySQLMCP {
     private ddlTools;
     private transactionTools;
     private storedProcedureTools;
+    private dataExportTools;
     private security;
     private featureConfig;
     constructor(permissionsConfig?: string);
@@ -224,6 +225,32 @@ export declare class MySQLMCP {
         data?: any;
         error?: string;
     }>;
+    exportTableToCSV(params: {
+        table_name: string;
+        filters?: any[];
+        pagination?: {
+            page: number;
+            limit: number;
+        };
+        sorting?: {
+            field: string;
+            direction: 'asc' | 'desc';
+        };
+        include_headers?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    exportQueryToCSV(params: {
+        query: string;
+        params?: any[];
+        include_headers?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
     getFeatureStatus(): {
         status: string;
         data: {

package/dist/index.js

@@ -11,6 +11,7 @@ const utilityTools_1 = require("./tools/utilityTools");
 const ddlTools_1 = require("./tools/ddlTools");
 const transactionTools_1 = require("./tools/transactionTools");
 const storedProcedureTools_1 = require("./tools/storedProcedureTools");
+const dataExportTools_1 = require("./tools/dataExportTools");
 const securityLayer_1 = __importDefault(require("./security/securityLayer"));
 const connection_1 = __importDefault(require("./db/connection"));
 const featureConfig_1 = require("./config/featureConfig");
@@ -29,13 +30,14 @@ class MySQLMCP {
         this.ddlTools = new ddlTools_1.DdlTools();
         this.transactionTools = new transactionTools_1.TransactionTools();
         this.storedProcedureTools = new storedProcedureTools_1.StoredProcedureTools(this.security);
+        this.dataExportTools = new dataExportTools_1.DataExportTools(this.security);
     }
     // Helper method to check if tool is enabled
     checkToolEnabled(toolName) {
         if (!this.featureConfig.isToolEnabled(toolName)) {
             return {
                 enabled: false,
-                error: `Tool '${toolName}' is disabled in the current configuration. Enabled categories: ${this.featureConfig.getEnabledCategories().join(', ')}`
+                error: this.featureConfig.getPermissionError(toolName)
             };
         }
         return { enabled: true };
@@ -253,6 +255,21 @@ class MySQLMCP {
         }
         return await this.storedProcedureTools.showCreateProcedure(params);
     }
+    // Data Export Tools
+    async exportTableToCSV(params) {
+        const check = this.checkToolEnabled('exportTableToCSV');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.dataExportTools.exportTableToCSV(params);
+    }
+    async exportQueryToCSV(params) {
+        const check = this.checkToolEnabled('exportQueryToCSV');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.dataExportTools.exportQueryToCSV(params);
+    }
     // Get feature configuration status
     getFeatureStatus() {
         return {

package/dist/mcp-server.js

@@ -692,11 +692,85 @@ const TOOLS = [
             required: ['procedure_name'],
         },
     },
+    // Data Export Tools
+    {
+        name: 'export_table_to_csv',
+        description: 'Export table data to CSV 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: {
+                                description: 'Value to compare against (can be string, number, boolean, or array for "in" operator)'
+                            },
+                        },
+                        required: ['field', 'operator', 'value'],
+                    },
+                },
+                pagination: {
+                    type: 'object',
+                    properties: {
+                        page: { type: 'number', description: 'Page number (starting from 1)' },
+                        limit: { type: 'number', description: 'Number of records per page' },
+                    },
+                },
+                sorting: {
+                    type: 'object',
+                    properties: {
+                        field: { type: 'string', description: 'Field name to sort by' },
+                        direction: { type: 'string', enum: ['asc', 'desc'] },
+                    },
+                },
+                include_headers: {
+                    type: 'boolean',
+                    description: 'Whether to include column headers in the CSV output',
+                },
+            },
+            required: ['table_name'],
+        },
+    },
+    {
+        name: 'export_query_to_csv',
+        description: 'Export the results of a SELECT query to CSV 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: {},
+                },
+                include_headers: {
+                    type: 'boolean',
+                    description: 'Whether to include column headers in the CSV output',
+                },
+            },
+            required: ['query'],
+        },
+    },
 ];
 // Create the MCP server
 const server = new index_js_1.Server({
     name: 'mysql-mcp-server',
-    version: '1.0.0',
+    version: '1.3.0',
 }, {
     capabilities: {
         tools: {},
@@ -806,6 +880,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case 'show_create_procedure':
                 result = await mysqlMCP.showCreateProcedure(args);
                 break;
+            // Data Export Tools
+            case 'export_table_to_csv':
+                result = await mysqlMCP.exportTableToCSV(args);
+                break;
+            case 'export_query_to_csv':
+                result = await mysqlMCP.exportQueryToCSV(args);
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -857,6 +938,19 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         };
     }
     catch (error) {
+        // Check if this is a permission error
+        if (error.message && error.message.includes('Permission denied')) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Handle other errors with generic message
         return {
             content: [
                 {

package/dist/tools/dataExportTools.d.ts

@@ -0,0 +1,33 @@
+import { FilterCondition, Pagination, Sorting } from '../validation/schemas';
+import SecurityLayer from '../security/securityLayer';
+export declare class DataExportTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Export table data to CSV format
+     */
+    exportTableToCSV(params: {
+        table_name: string;
+        filters?: FilterCondition[];
+        pagination?: Pagination;
+        sorting?: Sorting;
+        include_headers?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Export query results to CSV format
+     */
+    exportQueryToCSV(params: {
+        query: string;
+        params?: any[];
+        include_headers?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}

package/dist/tools/dataExportTools.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataExportTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+class DataExportTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    /**
+     * Export table data to CSV format
+     */
+    async exportTableToCSV(params) {
+        try {
+            const { table_name, filters = [], pagination, sorting, include_headers = true } = params;
+            // 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) {
+                    // Validate field name
+                    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 the query
+            const escapedTableName = this.security.escapeIdentifier(table_name);
+            const query = `SELECT * FROM ${escapedTableName} ${whereClause} ${orderByClause} ${limitClause}`;
+            // Execute query
+            const results = await this.db.query(query, whereParams);
+            // If no results, return empty CSV
+            if (results.length === 0) {
+                return {
+                    status: 'success',
+                    data: {
+                        csv: include_headers ? '' : '',
+                        row_count: 0
+                    }
+                };
+            }
+            // Generate CSV
+            let csv = '';
+            // Add headers if requested
+            if (include_headers) {
+                const headers = Object.keys(results[0]).join(',');
+                csv += headers + '\n';
+            }
+            // Add data rows
+            for (const row of results) {
+                const values = Object.values(row).map(value => {
+                    if (value === null)
+                        return '';
+                    if (typeof value === 'string') {
+                        // Escape quotes and wrap in quotes if contains comma or newline
+                        if (value.includes(',') || value.includes('\n') || value.includes('"')) {
+                            return `"${value.replace(/"/g, '""')}"`;
+                        }
+                        return value;
+                    }
+                    return String(value);
+                }).join(',');
+                csv += values + '\n';
+            }
+            return {
+                status: 'success',
+                data: {
+                    csv: csv,
+                    row_count: results.length
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Export query results to CSV format
+     */
+    async exportQueryToCSV(params) {
+        try {
+            const { query, params: queryParams = [], include_headers = true } = params;
+            // Validate query is a SELECT statement
+            if (!this.security.isReadOnlyQuery(query)) {
+                return {
+                    status: 'error',
+                    error: 'Only SELECT queries can be exported to CSV'
+                };
+            }
+            // Validate parameters
+            const paramValidation = this.security.validateParameters(queryParams);
+            if (!paramValidation.valid) {
+                return {
+                    status: 'error',
+                    error: paramValidation.error
+                };
+            }
+            // Execute query
+            const results = await this.db.query(query, queryParams);
+            // If no results, return empty CSV
+            if (results.length === 0) {
+                return {
+                    status: 'success',
+                    data: {
+                        csv: include_headers ? '' : '',
+                        row_count: 0
+                    }
+                };
+            }
+            // Generate CSV
+            let csv = '';
+            // Add headers if requested
+            if (include_headers) {
+                const headers = Object.keys(results[0]).join(',');
+                csv += headers + '\n';
+            }
+            // Add data rows
+            for (const row of results) {
+                const values = Object.values(row).map(value => {
+                    if (value === null)
+                        return '';
+                    if (typeof value === 'string') {
+                        // Escape quotes and wrap in quotes if contains comma or newline
+                        if (value.includes(',') || value.includes('\n') || value.includes('"')) {
+                            return `"${value.replace(/"/g, '""')}"`;
+                        }
+                        return value;
+                    }
+                    return String(value);
+                }).join(',');
+                csv += values + '\n';
+            }
+            return {
+                status: 'success',
+                data: {
+                    csv: csv,
+                    row_count: results.length
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+}
+exports.DataExportTools = DataExportTools;

package/dist/validation/schemas.d.ts

@@ -512,6 +512,87 @@ export declare const showCreateProcedureSchema: {
     };
     additionalProperties: boolean;
 };
+export declare const exportTableToCsvSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        table_name: {
+            type: string;
+        };
+        filters: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    field: {
+                        type: string;
+                    };
+                    operator: {
+                        type: string;
+                        enum: string[];
+                    };
+                    value: {};
+                };
+            };
+            nullable: boolean;
+        };
+        pagination: {
+            type: string;
+            properties: {
+                page: {
+                    type: string;
+                    minimum: number;
+                };
+                limit: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+            };
+            required: string[];
+            nullable: boolean;
+        };
+        sorting: {
+            type: string;
+            properties: {
+                field: {
+                    type: string;
+                };
+                direction: {
+                    type: string;
+                    enum: string[];
+                };
+            };
+            required: string[];
+            nullable: boolean;
+        };
+        include_headers: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const exportQueryToCsvSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        query: {
+            type: string;
+        };
+        params: {
+            type: string;
+            items: {};
+            nullable: boolean;
+        };
+        include_headers: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
 export declare const validateListTables: import("ajv").ValidateFunction<{
     database: unknown;
 } & {}>;
@@ -596,3 +677,9 @@ export declare const validateStoredProcedureCreation: import("ajv").ValidateFunc
 export declare const validateGetTableRelationships: import("ajv").ValidateFunction<{
     [x: string]: {};
 }>;
+export declare const validateExportTableToCsv: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateExportQueryToCsv: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;

package/dist/validation/schemas.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateStoredProcedureExecution = exports.validateShowCreateProcedure = exports.validateDropStoredProcedure = exports.validateCreateStoredProcedure = exports.validateExecuteStoredProcedure = exports.validateGetStoredProcedureInfo = exports.validateListStoredProcedures = exports.validateExecuteInTransaction = exports.validateRollbackTransaction = exports.validateCommitTransaction = exports.validateBeginTransaction = exports.validateExecuteDdl = exports.validateDropTable = exports.validateAlterTable = exports.validateCreateTable = exports.validateExecuteSql = exports.validateRunQuery = exports.validateBulkDelete = exports.validateBulkUpdate = exports.validateBulkInsert = exports.validateDeleteRecord = exports.validateUpdateRecord = exports.validateReadRecords = exports.validateCreateRecord = exports.validateReadTableSchema = exports.validateListTables = exports.showCreateProcedureSchema = exports.dropStoredProcedureSchema = exports.createStoredProcedureSchema = exports.executeStoredProcedureSchema = exports.getStoredProcedureInfoSchema = exports.listStoredProceduresSchema = exports.executeInTransactionSchema = exports.getTransactionStatusSchema = exports.rollbackTransactionSchema = exports.commitTransactionSchema = exports.beginTransactionSchema = exports.getTableRelationshipsSchema = exports.executeDdlSchema = exports.dropTableSchema = exports.alterTableSchema = exports.createTableSchema = exports.executeSqlSchema = exports.runQuerySchema = exports.deleteRecordSchema = exports.updateRecordSchema = exports.readRecordsSchema = exports.createRecordSchema = exports.readTableSchemaSchema = exports.listTablesSchema = void 0;
-exports.validateGetTableRelationships = exports.validateStoredProcedureCreation = void 0;
+exports.validateDropStoredProcedure = exports.validateCreateStoredProcedure = exports.validateExecuteStoredProcedure = exports.validateGetStoredProcedureInfo = exports.validateListStoredProcedures = exports.validateExecuteInTransaction = exports.validateRollbackTransaction = exports.validateCommitTransaction = exports.validateBeginTransaction = exports.validateExecuteDdl = exports.validateDropTable = exports.validateAlterTable = exports.validateCreateTable = exports.validateExecuteSql = exports.validateRunQuery = exports.validateBulkDelete = exports.validateBulkUpdate = exports.validateBulkInsert = exports.validateDeleteRecord = exports.validateUpdateRecord = exports.validateReadRecords = exports.validateCreateRecord = exports.validateReadTableSchema = exports.validateListTables = exports.exportQueryToCsvSchema = exports.exportTableToCsvSchema = exports.showCreateProcedureSchema = exports.dropStoredProcedureSchema = exports.createStoredProcedureSchema = exports.executeStoredProcedureSchema = exports.getStoredProcedureInfoSchema = exports.listStoredProceduresSchema = exports.executeInTransactionSchema = exports.getTransactionStatusSchema = exports.rollbackTransactionSchema = exports.commitTransactionSchema = exports.beginTransactionSchema = exports.getTableRelationshipsSchema = exports.executeDdlSchema = exports.dropTableSchema = exports.alterTableSchema = exports.createTableSchema = exports.executeSqlSchema = exports.runQuerySchema = exports.deleteRecordSchema = exports.updateRecordSchema = exports.readRecordsSchema = exports.createRecordSchema = exports.readTableSchemaSchema = exports.listTablesSchema = void 0;
+exports.validateExportQueryToCsv = exports.validateExportTableToCsv = exports.validateGetTableRelationships = exports.validateStoredProcedureCreation = exports.validateStoredProcedureExecution = exports.validateShowCreateProcedure = void 0;
 const ajv_1 = __importDefault(require("ajv"));
 const ajv = new ajv_1.default();
 // Schema definitions
@@ -442,6 +442,64 @@ const bulkDeleteSchema = {
     required: ['table_name', 'condition_sets'],
     additionalProperties: false
 };
+// Data Export schemas
+exports.exportTableToCsvSchema = {
+    type: 'object',
+    required: ['table_name'],
+    properties: {
+        table_name: { type: 'string' },
+        filters: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['field', 'operator', 'value'],
+                properties: {
+                    field: { type: 'string' },
+                    operator: {
+                        type: 'string',
+                        enum: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'like', 'in']
+                    },
+                    value: {}
+                }
+            },
+            nullable: true
+        },
+        pagination: {
+            type: 'object',
+            properties: {
+                page: { type: 'integer', minimum: 1 },
+                limit: { type: 'integer', minimum: 1, maximum: 10000 }
+            },
+            required: ['page', 'limit'],
+            nullable: true
+        },
+        sorting: {
+            type: 'object',
+            properties: {
+                field: { type: 'string' },
+                direction: { type: 'string', enum: ['asc', 'desc'] }
+            },
+            required: ['field', 'direction'],
+            nullable: true
+        },
+        include_headers: { type: 'boolean', nullable: true }
+    },
+    additionalProperties: false
+};
+exports.exportQueryToCsvSchema = {
+    type: 'object',
+    required: ['query'],
+    properties: {
+        query: { type: 'string' },
+        params: {
+            type: 'array',
+            items: {},
+            nullable: true
+        },
+        include_headers: { type: 'boolean', nullable: true }
+    },
+    additionalProperties: false
+};
 // Compile validators
 exports.validateListTables = ajv.compile(exports.listTablesSchema);
 exports.validateReadTableSchema = ajv.compile(exports.readTableSchemaSchema);
@@ -471,3 +529,5 @@ exports.validateShowCreateProcedure = ajv.compile(exports.showCreateProcedureSch
 exports.validateStoredProcedureExecution = ajv.compile(exports.executeStoredProcedureSchema);
 exports.validateStoredProcedureCreation = ajv.compile(exports.createStoredProcedureSchema);
 exports.validateGetTableRelationships = ajv.compile(exports.getTableRelationshipsSchema);
+exports.validateExportTableToCsv = ajv.compile(exports.exportTableToCsvSchema);
+exports.validateExportQueryToCsv = ajv.compile(exports.exportQueryToCsvSchema);

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "name": "mysql-mcp",
   "description": "A Model Context Protocol for MySQL database interaction",
-  "version": "1.0.0",
+  "version": "1.2.6",
   "tools": [
     {
       "name": "list_databases",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@berthojoris/mcp-mysql-server",
-  "version": "1.2.6",
-  "description": "Model Context Protocol server for MySQL database integration with dynamic per-project permissions",
+  "version": "1.4.0",
+  "description": "Model Context Protocol server for MySQL database integration with dynamic per-project permissions and data export capabilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {