@berthojoris/mcp-mysql-server 1.2.6 → 1.4.1

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.4.1',
 }, {
     capabilities: {
         tools: {},
@@ -718,49 +792,49 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 result = await mysqlMCP.listDatabases();
                 break;
             case 'list_tables':
-                result = await mysqlMCP.listTables(args);
+                result = await mysqlMCP.listTables((args || {}));
                 break;
             case 'read_table_schema':
-                result = await mysqlMCP.readTableSchema(args);
+                result = await mysqlMCP.readTableSchema((args || {}));
                 break;
             case 'create_record':
-                result = await mysqlMCP.createRecord(args);
+                result = await mysqlMCP.createRecord((args || {}));
                 break;
             case 'read_records':
-                result = await mysqlMCP.readRecords(args);
+                result = await mysqlMCP.readRecords((args || {}));
                 break;
             case 'update_record':
-                result = await mysqlMCP.updateRecord(args);
+                result = await mysqlMCP.updateRecord((args || {}));
                 break;
             case 'delete_record':
-                result = await mysqlMCP.deleteRecord(args);
+                result = await mysqlMCP.deleteRecord((args || {}));
                 break;
             case 'bulk_insert':
-                result = await mysqlMCP.bulkInsert(args);
+                result = await mysqlMCP.bulkInsert((args || {}));
                 break;
             case 'bulk_update':
-                result = await mysqlMCP.bulkUpdate(args);
+                result = await mysqlMCP.bulkUpdate((args || {}));
                 break;
             case 'bulk_delete':
-                result = await mysqlMCP.bulkDelete(args);
+                result = await mysqlMCP.bulkDelete((args || {}));
                 break;
             case 'run_query':
-                result = await mysqlMCP.runQuery(args);
+                result = await mysqlMCP.runQuery((args || {}));
                 break;
             case 'execute_sql':
-                result = await mysqlMCP.executeSql(args);
+                result = await mysqlMCP.executeSql((args || {}));
                 break;
             case 'create_table':
-                result = await mysqlMCP.createTable(args);
+                result = await mysqlMCP.createTable(args || {});
                 break;
             case 'alter_table':
-                result = await mysqlMCP.alterTable(args);
+                result = await mysqlMCP.alterTable(args || {});
                 break;
             case 'drop_table':
-                result = await mysqlMCP.dropTable(args);
+                result = await mysqlMCP.dropTable(args || {});
                 break;
             case 'execute_ddl':
-                result = await mysqlMCP.executeDdl(args);
+                result = await mysqlMCP.executeDdl((args || {}));
                 break;
             case 'describe_connection':
                 result = await mysqlMCP.describeConnection();
@@ -769,42 +843,49 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 result = await mysqlMCP.testConnection();
                 break;
             case 'get_table_relationships':
-                result = await mysqlMCP.getTableRelationships(args);
+                result = await mysqlMCP.getTableRelationships((args || {}));
                 break;
             // Transaction Tools
             case 'begin_transaction':
-                result = await mysqlMCP.beginTransaction(args);
+                result = await mysqlMCP.beginTransaction((args || {}));
                 break;
             case 'commit_transaction':
-                result = await mysqlMCP.commitTransaction(args);
+                result = await mysqlMCP.commitTransaction((args || {}));
                 break;
             case 'rollback_transaction':
-                result = await mysqlMCP.rollbackTransaction(args);
+                result = await mysqlMCP.rollbackTransaction((args || {}));
                 break;
             case 'get_transaction_status':
                 result = await mysqlMCP.getTransactionStatus();
                 break;
             case 'execute_in_transaction':
-                result = await mysqlMCP.executeInTransaction(args);
+                result = await mysqlMCP.executeInTransaction((args || {}));
                 break;
             // Stored Procedure Tools
             case 'list_stored_procedures':
-                result = await mysqlMCP.listStoredProcedures(args);
+                result = await mysqlMCP.listStoredProcedures((args || {}));
                 break;
             case 'get_stored_procedure_info':
-                result = await mysqlMCP.getStoredProcedureInfo(args);
+                result = await mysqlMCP.getStoredProcedureInfo((args || {}));
                 break;
             case 'execute_stored_procedure':
-                result = await mysqlMCP.executeStoredProcedure(args);
+                result = await mysqlMCP.executeStoredProcedure((args || {}));
                 break;
             case 'create_stored_procedure':
-                result = await mysqlMCP.createStoredProcedure(args);
+                result = await mysqlMCP.createStoredProcedure((args || {}));
                 break;
             case 'drop_stored_procedure':
-                result = await mysqlMCP.dropStoredProcedure(args);
+                result = await mysqlMCP.dropStoredProcedure((args || {}));
                 break;
             case 'show_create_procedure':
-                result = await mysqlMCP.showCreateProcedure(args);
+                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]: {};
+}>;