@berthojoris/mcp-mysql-server 1.0.2 → 1.2.0

package/dist/tools/crudTools.js

@@ -439,5 +439,415 @@ class CrudTools {
             };
         }
     }
+    /**
+     * Bulk insert multiple records into the specified table
+     */
+    async bulkInsert(params) {
+        // Validate input schema
+        if (!(0, schemas_1.validateBulkInsert)(params)) {
+            return {
+                status: 'error',
+                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateBulkInsert.errors)
+            };
+        }
+        try {
+            const { table_name, data, batch_size = 1000 } = params;
+            // Validate table name
+            const tableValidation = this.security.validateIdentifier(table_name);
+            if (!tableValidation.valid) {
+                return {
+                    status: 'error',
+                    error: `Invalid table name: ${tableValidation.error}`
+                };
+            }
+            // Ensure data is not empty
+            if (!data || data.length === 0) {
+                return {
+                    status: 'error',
+                    error: 'Data array cannot be empty'
+                };
+            }
+            // Validate that all records have the same columns
+            const firstRecord = data[0];
+            const columns = Object.keys(firstRecord);
+            for (let i = 1; i < data.length; i++) {
+                const recordColumns = Object.keys(data[i]);
+                if (recordColumns.length !== columns.length ||
+                    !recordColumns.every(col => columns.includes(col))) {
+                    return {
+                        status: 'error',
+                        error: `All records must have the same columns. Record ${i + 1} has different columns.`
+                    };
+                }
+            }
+            // Validate column names
+            for (const column of columns) {
+                const columnValidation = this.security.validateIdentifier(column);
+                if (!columnValidation.valid) {
+                    return {
+                        status: 'error',
+                        error: `Invalid column name '${column}': ${columnValidation.error}`
+                    };
+                }
+            }
+            // Process in batches
+            const results = [];
+            let totalInserted = 0;
+            for (let i = 0; i < data.length; i += batch_size) {
+                const batch = data.slice(i, i + batch_size);
+                // Prepare batch values
+                const batchValues = [];
+                for (const record of batch) {
+                    const values = columns.map(col => record[col]);
+                    // Validate and sanitize parameter values for this record
+                    const paramValidation = this.security.validateParameters(values);
+                    if (!paramValidation.valid) {
+                        return {
+                            status: 'error',
+                            error: `Invalid parameter values in record ${i + batchValues.length / columns.length + 1}: ${paramValidation.error}`
+                        };
+                    }
+                    batchValues.push(...paramValidation.sanitizedParams);
+                }
+                // Build the query with escaped identifiers
+                const escapedTableName = this.security.escapeIdentifier(table_name);
+                const escapedColumns = columns.map(col => this.security.escapeIdentifier(col));
+                const valueGroups = batch.map(() => `(${columns.map(() => '?').join(', ')})`).join(', ');
+                const query = `INSERT INTO ${escapedTableName} (${escapedColumns.join(', ')}) VALUES ${valueGroups}`;
+                // Execute the batch query
+                const result = await this.db.query(query, batchValues);
+                results.push({
+                    batchNumber: Math.floor(i / batch_size) + 1,
+                    recordsInserted: batch.length,
+                    firstInsertId: result.insertId,
+                    affectedRows: result.affectedRows
+                });
+                totalInserted += result.affectedRows;
+            }
+            return {
+                status: 'success',
+                data: {
+                    totalRecords: data.length,
+                    totalInserted,
+                    batches: results.length,
+                    batchResults: results
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Bulk update multiple records with different conditions and data
+     */
+    async bulkUpdate(params) {
+        // Validate input schema
+        if (!(0, schemas_1.validateBulkUpdate)(params)) {
+            return {
+                status: 'error',
+                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateBulkUpdate.errors)
+            };
+        }
+        try {
+            const { table_name, updates, batch_size = 100 } = params;
+            // Validate table name
+            const tableValidation = this.security.validateIdentifier(table_name);
+            if (!tableValidation.valid) {
+                return {
+                    status: 'error',
+                    error: `Invalid table name: ${tableValidation.error}`
+                };
+            }
+            // Ensure updates is not empty
+            if (!updates || updates.length === 0) {
+                return {
+                    status: 'error',
+                    error: 'Updates array cannot be empty'
+                };
+            }
+            // Validate each update operation
+            for (let i = 0; i < updates.length; i++) {
+                const update = updates[i];
+                // Validate column names in data
+                const columns = Object.keys(update.data);
+                for (const column of columns) {
+                    const columnValidation = this.security.validateIdentifier(column);
+                    if (!columnValidation.valid) {
+                        return {
+                            status: 'error',
+                            error: `Invalid column name '${column}' in update ${i + 1}: ${columnValidation.error}`
+                        };
+                    }
+                }
+                // Validate condition fields
+                for (const condition of update.conditions) {
+                    const fieldValidation = this.security.validateIdentifier(condition.field);
+                    if (!fieldValidation.valid) {
+                        return {
+                            status: 'error',
+                            error: `Invalid condition field '${condition.field}' in update ${i + 1}: ${fieldValidation.error}`
+                        };
+                    }
+                }
+            }
+            // Process in batches using transactions for consistency
+            const results = [];
+            let totalAffected = 0;
+            for (let i = 0; i < updates.length; i += batch_size) {
+                const batch = updates.slice(i, i + batch_size);
+                // Start a transaction for this batch
+                await this.db.query('START TRANSACTION');
+                try {
+                    const batchResults = [];
+                    for (const update of batch) {
+                        // Build SET clause
+                        const setClause = Object.entries(update.data)
+                            .map(([column, _]) => `${this.security.escapeIdentifier(column)} = ?`)
+                            .join(', ');
+                        const setValues = Object.values(update.data);
+                        // Build WHERE clause
+                        const whereConditions = [];
+                        const whereValues = [];
+                        update.conditions.forEach(condition => {
+                            const escapedField = this.security.escapeIdentifier(condition.field);
+                            switch (condition.operator) {
+                                case 'eq':
+                                    whereConditions.push(`${escapedField} = ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'neq':
+                                    whereConditions.push(`${escapedField} != ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'gt':
+                                    whereConditions.push(`${escapedField} > ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'gte':
+                                    whereConditions.push(`${escapedField} >= ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'lt':
+                                    whereConditions.push(`${escapedField} < ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'lte':
+                                    whereConditions.push(`${escapedField} <= ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'like':
+                                    whereConditions.push(`${escapedField} LIKE ?`);
+                                    whereValues.push(`%${condition.value}%`);
+                                    break;
+                                case 'in':
+                                    if (Array.isArray(condition.value)) {
+                                        const placeholders = condition.value.map(() => '?').join(', ');
+                                        whereConditions.push(`${escapedField} IN (${placeholders})`);
+                                        whereValues.push(...condition.value);
+                                    }
+                                    break;
+                            }
+                        });
+                        const whereClause = whereConditions.length > 0
+                            ? 'WHERE ' + whereConditions.join(' AND ')
+                            : '';
+                        // Validate all parameters
+                        const allParams = [...setValues, ...whereValues];
+                        const paramValidation = this.security.validateParameters(allParams);
+                        if (!paramValidation.valid) {
+                            throw new Error(`Invalid parameters: ${paramValidation.error}`);
+                        }
+                        // Build and execute the query
+                        const escapedTableName = this.security.escapeIdentifier(table_name);
+                        const query = `UPDATE ${escapedTableName} SET ${setClause} ${whereClause}`;
+                        const result = await this.db.query(query, paramValidation.sanitizedParams);
+                        batchResults.push({
+                            affectedRows: result.affectedRows
+                        });
+                        totalAffected += result.affectedRows;
+                    }
+                    // Commit the transaction
+                    await this.db.query('COMMIT');
+                    results.push({
+                        batchNumber: Math.floor(i / batch_size) + 1,
+                        updatesProcessed: batch.length,
+                        results: batchResults
+                    });
+                }
+                catch (error) {
+                    // Rollback on error
+                    await this.db.query('ROLLBACK');
+                    throw error;
+                }
+            }
+            return {
+                status: 'success',
+                data: {
+                    totalUpdates: updates.length,
+                    totalAffectedRows: totalAffected,
+                    batches: results.length,
+                    batchResults: results
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Bulk delete records based on multiple condition sets
+     */
+    async bulkDelete(params) {
+        // Validate input schema
+        if (!(0, schemas_1.validateBulkDelete)(params)) {
+            return {
+                status: 'error',
+                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateBulkDelete.errors)
+            };
+        }
+        try {
+            const { table_name, condition_sets, batch_size = 100 } = params;
+            // Validate table name
+            const tableValidation = this.security.validateIdentifier(table_name);
+            if (!tableValidation.valid) {
+                return {
+                    status: 'error',
+                    error: `Invalid table name: ${tableValidation.error}`
+                };
+            }
+            // Ensure condition_sets is not empty
+            if (!condition_sets || condition_sets.length === 0) {
+                return {
+                    status: 'error',
+                    error: 'Condition sets array cannot be empty'
+                };
+            }
+            // Validate each condition set
+            for (let i = 0; i < condition_sets.length; i++) {
+                const conditions = condition_sets[i];
+                // Ensure there are conditions for safety
+                if (!conditions || conditions.length === 0) {
+                    return {
+                        status: 'error',
+                        error: `DELETE operations require at least one condition for safety. Condition set ${i + 1} is empty.`
+                    };
+                }
+                // Validate condition fields
+                for (const condition of conditions) {
+                    const fieldValidation = this.security.validateIdentifier(condition.field);
+                    if (!fieldValidation.valid) {
+                        return {
+                            status: 'error',
+                            error: `Invalid condition field '${condition.field}' in condition set ${i + 1}: ${fieldValidation.error}`
+                        };
+                    }
+                }
+            }
+            // Process in batches using transactions for consistency
+            const results = [];
+            let totalDeleted = 0;
+            for (let i = 0; i < condition_sets.length; i += batch_size) {
+                const batch = condition_sets.slice(i, i + batch_size);
+                // Start a transaction for this batch
+                await this.db.query('START TRANSACTION');
+                try {
+                    const batchResults = [];
+                    for (const conditions of batch) {
+                        // Build WHERE clause
+                        const whereConditions = [];
+                        const whereValues = [];
+                        conditions.forEach(condition => {
+                            const escapedField = this.security.escapeIdentifier(condition.field);
+                            switch (condition.operator) {
+                                case 'eq':
+                                    whereConditions.push(`${escapedField} = ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'neq':
+                                    whereConditions.push(`${escapedField} != ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'gt':
+                                    whereConditions.push(`${escapedField} > ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'gte':
+                                    whereConditions.push(`${escapedField} >= ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'lt':
+                                    whereConditions.push(`${escapedField} < ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'lte':
+                                    whereConditions.push(`${escapedField} <= ?`);
+                                    whereValues.push(condition.value);
+                                    break;
+                                case 'like':
+                                    whereConditions.push(`${escapedField} LIKE ?`);
+                                    whereValues.push(`%${condition.value}%`);
+                                    break;
+                                case 'in':
+                                    if (Array.isArray(condition.value)) {
+                                        const placeholders = condition.value.map(() => '?').join(', ');
+                                        whereConditions.push(`${escapedField} IN (${placeholders})`);
+                                        whereValues.push(...condition.value);
+                                    }
+                                    break;
+                            }
+                        });
+                        const whereClause = 'WHERE ' + whereConditions.join(' AND ');
+                        // Validate all parameters
+                        const paramValidation = this.security.validateParameters(whereValues);
+                        if (!paramValidation.valid) {
+                            throw new Error(`Invalid parameters: ${paramValidation.error}`);
+                        }
+                        // Build and execute the query
+                        const escapedTableName = this.security.escapeIdentifier(table_name);
+                        const query = `DELETE FROM ${escapedTableName} ${whereClause}`;
+                        const result = await this.db.query(query, paramValidation.sanitizedParams);
+                        batchResults.push({
+                            affectedRows: result.affectedRows
+                        });
+                        totalDeleted += result.affectedRows;
+                    }
+                    // Commit the transaction
+                    await this.db.query('COMMIT');
+                    results.push({
+                        batchNumber: Math.floor(i / batch_size) + 1,
+                        deletesProcessed: batch.length,
+                        results: batchResults
+                    });
+                }
+                catch (error) {
+                    // Rollback on error
+                    await this.db.query('ROLLBACK');
+                    throw error;
+                }
+            }
+            return {
+                status: 'success',
+                data: {
+                    totalDeletes: condition_sets.length,
+                    totalDeletedRows: totalDeleted,
+                    batches: results.length,
+                    batchResults: results
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
 }
 exports.CrudTools = CrudTools;

package/dist/tools/databaseTools.d.ts

@@ -3,7 +3,8 @@ export declare class DatabaseTools {
     private db;
     constructor();
     /**
-     * List all available databases
+     * List only the connected database (security restriction)
+     * This prevents access to other databases on the MySQL server
      */
     listDatabases(): Promise<{
         status: string;

package/dist/tools/databaseTools.js

@@ -6,20 +6,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseTools = void 0;
 const connection_1 = __importDefault(require("../db/connection"));
 const schemas_1 = require("../validation/schemas");
+const config_1 = require("../config/config");
 class DatabaseTools {
     constructor() {
         this.db = connection_1.default.getInstance();
     }
     /**
-     * List all available databases
+     * List only the connected database (security restriction)
+     * This prevents access to other databases on the MySQL server
      */
     async listDatabases() {
         try {
-            const results = await this.db.query('SHOW DATABASES');
-            const databases = results.map(row => row.Database);
+            // Only return the database specified in the connection string
+            // This is a security measure to prevent access to other databases
+            if (!config_1.dbConfig.database) {
+                return {
+                    status: 'error',
+                    error: 'No database specified in connection string. Please specify a database name in your MySQL connection URL.'
+                };
+            }
+            // Verify the database exists and is accessible
+            const results = await this.db.query('SELECT DATABASE() as current_database');
+            const currentDatabase = results[0]?.current_database;
+            if (!currentDatabase) {
+                return {
+                    status: 'error',
+                    error: 'No database selected. Please ensure your connection string includes a valid database name.'
+                };
+            }
             return {
                 status: 'success',
-                data: databases
+                data: [currentDatabase]
             };
         }
         catch (error) {
@@ -41,8 +58,23 @@ class DatabaseTools {
             };
         }
         try {
+            // Security validation: if database is specified, ensure it matches the connected database
+            if (params.database) {
+                if (!config_1.dbConfig.database) {
+                    return {
+                        status: 'error',
+                        error: 'No database specified in connection string. Cannot access other databases.'
+                    };
+                }
+                if (params.database !== config_1.dbConfig.database) {
+                    return {
+                        status: 'error',
+                        error: `Access denied. You can only access the connected database '${config_1.dbConfig.database}'. Requested database '${params.database}' is not allowed.`
+                    };
+                }
+            }
             let query = 'SHOW TABLES';
-            // If database is specified, use it
+            // If database is specified and validated, use it
             if (params.database) {
                 query = `SHOW TABLES FROM \`${params.database}\``;
             }
@@ -76,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/storedProcedureTools.d.ts

@@ -3,6 +3,10 @@ export declare class StoredProcedureTools {
     private db;
     private security;
     constructor(security: SecurityLayer);
+    /**
+     * Validate database access - ensures only the connected database can be accessed
+     */
+    private validateDatabaseAccess;
     /**
      * List all stored procedures in the current database
      */