@berthojoris/mcp-mysql-server 1.1.0 → 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.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]);