@berthojoris/mcp-mysql-server 1.2.5 → 1.4.0

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/tools/databaseTools.js

@@ -108,20 +108,20 @@ class DatabaseTools {
             };
         }
         try {
-            const query = `
-        SELECT 
-          COLUMN_NAME as column_name,
-          DATA_TYPE as data_type,
-          IS_NULLABLE as is_nullable,
-          COLUMN_KEY as column_key,
-          COLUMN_DEFAULT as column_default,
-          EXTRA as extra
-        FROM 
-          INFORMATION_SCHEMA.COLUMNS
-        WHERE 
-          TABLE_NAME = ?
-        ORDER BY 
-          ORDINAL_POSITION
+            const query = `
+        SELECT 
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
+          IS_NULLABLE as is_nullable,
+          COLUMN_KEY as column_key,
+          COLUMN_DEFAULT as column_default,
+          EXTRA as extra
+        FROM 
+          INFORMATION_SCHEMA.COLUMNS
+        WHERE 
+          TABLE_NAME = ?
+        ORDER BY 
+          ORDINAL_POSITION
       `;
             const results = await this.db.query(query, [params.table_name]);
             return {

package/dist/tools/utilityTools.js

@@ -71,33 +71,33 @@ class UtilityTools {
         try {
             const { table_name } = params;
             // Query to get foreign keys where this table is the parent
-            const parentQuery = `
-        SELECT 
-          TABLE_NAME as child_table,
-          COLUMN_NAME as child_column,
-          REFERENCED_TABLE_NAME as parent_table,
-          REFERENCED_COLUMN_NAME as parent_column,
-          CONSTRAINT_NAME as constraint_name
-        FROM 
-          INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-        WHERE 
-          REFERENCED_TABLE_NAME = ?
-          AND REFERENCED_TABLE_SCHEMA = DATABASE()
+            const parentQuery = `
+        SELECT 
+          TABLE_NAME as child_table,
+          COLUMN_NAME as child_column,
+          REFERENCED_TABLE_NAME as parent_table,
+          REFERENCED_COLUMN_NAME as parent_column,
+          CONSTRAINT_NAME as constraint_name
+        FROM 
+          INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+        WHERE 
+          REFERENCED_TABLE_NAME = ?
+          AND REFERENCED_TABLE_SCHEMA = DATABASE()
       `;
             // Query to get foreign keys where this table is the child
-            const childQuery = `
-        SELECT 
-          TABLE_NAME as child_table,
-          COLUMN_NAME as child_column,
-          REFERENCED_TABLE_NAME as parent_table,
-          REFERENCED_COLUMN_NAME as parent_column,
-          CONSTRAINT_NAME as constraint_name
-        FROM 
-          INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-        WHERE 
-          TABLE_NAME = ?
-          AND REFERENCED_TABLE_NAME IS NOT NULL
-          AND TABLE_SCHEMA = DATABASE()
+            const childQuery = `
+        SELECT 
+          TABLE_NAME as child_table,
+          COLUMN_NAME as child_column,
+          REFERENCED_TABLE_NAME as parent_table,
+          REFERENCED_COLUMN_NAME as parent_column,
+          CONSTRAINT_NAME as constraint_name
+        FROM 
+          INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+        WHERE 
+          TABLE_NAME = ?
+          AND REFERENCED_TABLE_NAME IS NOT NULL
+          AND TABLE_SCHEMA = DATABASE()
       `;
             // Execute both queries
             const parentRelationships = await this.db.query(parentQuery, [table_name]);