@berthojoris/mcp-mysql-server 1.10.2 → 1.10.4

package/dist/tools/crudTools.js

@@ -18,8 +18,8 @@ class CrudTools {
         // Validate input schema
         if (!(0, schemas_1.validateCreateRecord)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateCreateRecord.errors)
+                status: "error",
+                error: "Invalid parameters: " + JSON.stringify(schemas_1.validateCreateRecord.errors),
             };
         }
         try {
@@ -28,8 +28,8 @@ class CrudTools {
             const tableValidation = this.security.validateIdentifier(table_name);
             if (!tableValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid table name: ${tableValidation.error}`
+                    status: "error",
+                    error: `Invalid table name: ${tableValidation.error}`,
                 };
             }
             // Validate column names
@@ -38,8 +38,8 @@ class CrudTools {
                 const columnValidation = this.security.validateIdentifier(column);
                 if (!columnValidation.valid) {
                     return {
-                        status: 'error',
-                        error: `Invalid column name '${column}': ${columnValidation.error}`
+                        status: "error",
+                        error: `Invalid column name '${column}': ${columnValidation.error}`,
                     };
                 }
             }
@@ -48,31 +48,29 @@ class CrudTools {
             const paramValidation = this.security.validateParameters(values);
             if (!paramValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid parameter values: ${paramValidation.error}`
+                    status: "error",
+                    error: `Invalid parameter values: ${paramValidation.error}`,
                 };
             }
             // Build the query with escaped identifiers
             const escapedTableName = this.security.escapeIdentifier(table_name);
-            const escapedColumns = columns.map(col => this.security.escapeIdentifier(col));
-            const placeholders = columns.map(() => '?').join(', ');
-            const query = `INSERT INTO ${escapedTableName} (${escapedColumns.join(', ')}) VALUES (${placeholders})`;
+            const escapedColumns = columns.map((col) => this.security.escapeIdentifier(col));
+            const placeholders = columns.map(() => "?").join(", ");
+            const query = `INSERT INTO ${escapedTableName} (${escapedColumns.join(", ")}) VALUES (${placeholders})`;
             // Execute the query with sanitized parameters
             const result = await this.db.query(query, paramValidation.sanitizedParams);
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     insertId: result.insertId,
-                    affectedRows: result.affectedRows
+                    affectedRows: result.affectedRows,
                 },
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -83,8 +81,8 @@ class CrudTools {
         // Validate input schema
         if (!(0, schemas_1.validateReadRecords)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateReadRecords.errors)
+                status: "error",
+                error: "Invalid parameters: " + JSON.stringify(schemas_1.validateReadRecords.errors),
             };
         }
         try {
@@ -93,8 +91,8 @@ class CrudTools {
             const tableValidation = this.security.validateIdentifier(table_name);
             if (!tableValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid table name: ${tableValidation.error}`
+                    status: "error",
+                    error: `Invalid table name: ${tableValidation.error}`,
                 };
             }
             // Validate sorting field if provided
@@ -102,8 +100,8 @@ class CrudTools {
                 const sortFieldValidation = this.security.validateIdentifier(sorting.field);
                 if (!sortFieldValidation.valid) {
                     return {
-                        status: 'error',
-                        error: `Invalid sorting field: ${sortFieldValidation.error}`
+                        status: "error",
+                        error: `Invalid sorting field: ${sortFieldValidation.error}`,
                     };
                 }
             }
@@ -113,69 +111,69 @@ class CrudTools {
                     const fieldValidation = this.security.validateIdentifier(filter.field);
                     if (!fieldValidation.valid) {
                         return {
-                            status: 'error',
-                            error: `Invalid filter field '${filter.field}': ${fieldValidation.error}`
+                            status: "error",
+                            error: `Invalid filter field '${filter.field}': ${fieldValidation.error}`,
                         };
                     }
                 }
             }
             // Build the WHERE clause if filters are provided
-            let whereClause = '';
+            let whereClause = "";
             let queryParams = [];
             if (filters && filters.length > 0) {
-                const conditions = filters.map(filter => {
+                const conditions = filters.map((filter) => {
                     const escapedField = this.security.escapeIdentifier(filter.field);
                     switch (filter.operator) {
-                        case 'eq':
+                        case "eq":
                             queryParams.push(filter.value);
                             return `${escapedField} = ?`;
-                        case 'neq':
+                        case "neq":
                             queryParams.push(filter.value);
                             return `${escapedField} != ?`;
-                        case 'gt':
+                        case "gt":
                             queryParams.push(filter.value);
                             return `${escapedField} > ?`;
-                        case 'gte':
+                        case "gte":
                             queryParams.push(filter.value);
                             return `${escapedField} >= ?`;
-                        case 'lt':
+                        case "lt":
                             queryParams.push(filter.value);
                             return `${escapedField} < ?`;
-                        case 'lte':
+                        case "lte":
                             queryParams.push(filter.value);
                             return `${escapedField} <= ?`;
-                        case 'like':
+                        case "like":
                             queryParams.push(`%${filter.value}%`);
                             return `${escapedField} LIKE ?`;
-                        case 'in':
+                        case "in":
                             if (Array.isArray(filter.value)) {
-                                const placeholders = filter.value.map(() => '?').join(', ');
+                                const placeholders = filter.value.map(() => "?").join(", ");
                                 queryParams.push(...filter.value);
                                 return `${escapedField} IN (${placeholders})`;
                             }
-                            return '1=1'; // Default true condition if value is not an array
+                            return "1=1"; // Default true condition if value is not an array
                         default:
-                            return '1=1'; // Default true condition
+                            return "1=1"; // Default true condition
                     }
                 });
-                whereClause = 'WHERE ' + conditions.join(' AND ');
+                whereClause = "WHERE " + conditions.join(" AND ");
             }
             // Validate all query parameters
             const paramValidation = this.security.validateParameters(queryParams);
             if (!paramValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid query parameters: ${paramValidation.error}`
+                    status: "error",
+                    error: `Invalid query parameters: ${paramValidation.error}`,
                 };
             }
             // Build the ORDER BY clause if sorting is provided
-            let orderByClause = '';
+            let orderByClause = "";
             if (sorting) {
                 const escapedSortField = this.security.escapeIdentifier(sorting.field);
                 orderByClause = `ORDER BY ${escapedSortField} ${sorting.direction.toUpperCase()}`;
             }
             // Build the LIMIT clause if pagination is provided
-            let limitClause = '';
+            let limitClause = "";
             const escapedTableName = this.security.escapeIdentifier(table_name);
             if (pagination) {
                 const offset = (pagination.page - 1) * pagination.limit;
@@ -188,10 +186,9 @@ class CrudTools {
                 const query = `SELECT * FROM ${escapedTableName} ${whereClause} ${orderByClause} ${limitClause}`;
                 const results = await this.db.query(query, paramValidation.sanitizedParams);
                 return {
-                    status: 'success',
+                    status: "success",
                     data: results,
                     total,
-                    queryLog: this.db.getFormattedQueryLogs(2)
                 };
             }
             else {
@@ -199,18 +196,16 @@ class CrudTools {
                 const query = `SELECT * FROM ${escapedTableName} ${whereClause} ${orderByClause}`;
                 const results = await this.db.query(query, paramValidation.sanitizedParams);
                 return {
-                    status: 'success',
+                    status: "success",
                     data: results,
                     total: results.length,
-                    queryLog: this.db.getFormattedQueryLogs(1)
                 };
             }
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -221,8 +216,8 @@ class CrudTools {
         // Validate input schema
         if (!(0, schemas_1.validateUpdateRecord)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateUpdateRecord.errors)
+                status: "error",
+                error: "Invalid parameters: " + JSON.stringify(schemas_1.validateUpdateRecord.errors),
             };
         }
         try {
@@ -231,8 +226,8 @@ class CrudTools {
             const tableValidation = this.security.validateIdentifier(table_name);
             if (!tableValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid table name: ${tableValidation.error}`
+                    status: "error",
+                    error: `Invalid table name: ${tableValidation.error}`,
                 };
             }
             // Validate column names in data
@@ -241,8 +236,8 @@ class CrudTools {
                 const columnValidation = this.security.validateIdentifier(column);
                 if (!columnValidation.valid) {
                     return {
-                        status: 'error',
-                        error: `Invalid column name '${column}': ${columnValidation.error}`
+                        status: "error",
+                        error: `Invalid column name '${column}': ${columnValidation.error}`,
                     };
                 }
             }
@@ -251,53 +246,53 @@ class CrudTools {
                 const fieldValidation = this.security.validateIdentifier(condition.field);
                 if (!fieldValidation.valid) {
                     return {
-                        status: 'error',
-                        error: `Invalid condition field '${condition.field}': ${fieldValidation.error}`
+                        status: "error",
+                        error: `Invalid condition field '${condition.field}': ${fieldValidation.error}`,
                     };
                 }
             }
             // Build SET clause with escaped identifiers
             const setClause = Object.entries(data)
                 .map(([column, _]) => `${this.security.escapeIdentifier(column)} = ?`)
-                .join(', ');
+                .join(", ");
             const setValues = Object.values(data);
             // Build the WHERE clause
             const whereConditions = [];
             const whereValues = [];
-            conditions.forEach(condition => {
+            conditions.forEach((condition) => {
                 const escapedField = this.security.escapeIdentifier(condition.field);
                 switch (condition.operator) {
-                    case 'eq':
+                    case "eq":
                         whereConditions.push(`${escapedField} = ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'neq':
+                    case "neq":
                         whereConditions.push(`${escapedField} != ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'gt':
+                    case "gt":
                         whereConditions.push(`${escapedField} > ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'gte':
+                    case "gte":
                         whereConditions.push(`${escapedField} >= ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'lt':
+                    case "lt":
                         whereConditions.push(`${escapedField} < ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'lte':
+                    case "lte":
                         whereConditions.push(`${escapedField} <= ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'like':
+                    case "like":
                         whereConditions.push(`${escapedField} LIKE ?`);
                         whereValues.push(`%${condition.value}%`);
                         break;
-                    case 'in':
+                    case "in":
                         if (Array.isArray(condition.value)) {
-                            const placeholders = condition.value.map(() => '?').join(', ');
+                            const placeholders = condition.value.map(() => "?").join(", ");
                             whereConditions.push(`${escapedField} IN (${placeholders})`);
                             whereValues.push(...condition.value);
                         }
@@ -305,15 +300,15 @@ class CrudTools {
                 }
             });
             const whereClause = whereConditions.length > 0
-                ? 'WHERE ' + whereConditions.join(' AND ')
-                : '';
+                ? "WHERE " + whereConditions.join(" AND ")
+                : "";
             // Validate all parameters
             const allParams = [...setValues, ...whereValues];
             const paramValidation = this.security.validateParameters(allParams);
             if (!paramValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid parameters: ${paramValidation.error}`
+                    status: "error",
+                    error: `Invalid parameters: ${paramValidation.error}`,
                 };
             }
             // Build the query with escaped table name
@@ -322,18 +317,16 @@ class CrudTools {
             // Execute the query with sanitized parameters
             const result = await this.db.query(query, paramValidation.sanitizedParams);
             return {
-                status: 'success',
+                status: "success",
                 data: {
-                    affectedRows: result.affectedRows
+                    affectedRows: result.affectedRows,
                 },
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -344,8 +337,8 @@ class CrudTools {
         // Validate input schema
         if (!(0, schemas_1.validateDeleteRecord)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateDeleteRecord.errors)
+                status: "error",
+                error: "Invalid parameters: " + JSON.stringify(schemas_1.validateDeleteRecord.errors),
             };
         }
         try {
@@ -354,15 +347,15 @@ class CrudTools {
             const tableValidation = this.security.validateIdentifier(table_name);
             if (!tableValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid table name: ${tableValidation.error}`
+                    status: "error",
+                    error: `Invalid table name: ${tableValidation.error}`,
                 };
             }
             // Ensure there are conditions for safety
             if (!conditions || conditions.length === 0) {
                 return {
-                    status: 'error',
-                    error: 'DELETE operations require at least one condition for safety'
+                    status: "error",
+                    error: "DELETE operations require at least one condition for safety",
                 };
             }
             // Validate condition fields
@@ -370,61 +363,61 @@ class CrudTools {
                 const fieldValidation = this.security.validateIdentifier(condition.field);
                 if (!fieldValidation.valid) {
                     return {
-                        status: 'error',
-                        error: `Invalid condition field '${condition.field}': ${fieldValidation.error}`
+                        status: "error",
+                        error: `Invalid condition field '${condition.field}': ${fieldValidation.error}`,
                     };
                 }
             }
             // Build the WHERE clause
             const whereConditions = [];
             const whereValues = [];
-            conditions.forEach(condition => {
+            conditions.forEach((condition) => {
                 const escapedField = this.security.escapeIdentifier(condition.field);
                 switch (condition.operator) {
-                    case 'eq':
+                    case "eq":
                         whereConditions.push(`${escapedField} = ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'neq':
+                    case "neq":
                         whereConditions.push(`${escapedField} != ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'gt':
+                    case "gt":
                         whereConditions.push(`${escapedField} > ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'gte':
+                    case "gte":
                         whereConditions.push(`${escapedField} >= ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'lt':
+                    case "lt":
                         whereConditions.push(`${escapedField} < ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'lte':
+                    case "lte":
                         whereConditions.push(`${escapedField} <= ?`);
                         whereValues.push(condition.value);
                         break;
-                    case 'like':
+                    case "like":
                         whereConditions.push(`${escapedField} LIKE ?`);
                         whereValues.push(`%${condition.value}%`);
                         break;
-                    case 'in':
+                    case "in":
                         if (Array.isArray(condition.value)) {
-                            const placeholders = condition.value.map(() => '?').join(', ');
+                            const placeholders = condition.value.map(() => "?").join(", ");
                             whereConditions.push(`${escapedField} IN (${placeholders})`);
                             whereValues.push(...condition.value);
                         }
                         break;
                 }
             });
-            const whereClause = 'WHERE ' + whereConditions.join(' AND ');
+            const whereClause = "WHERE " + whereConditions.join(" AND ");
             // Validate all parameters
             const paramValidation = this.security.validateParameters(whereValues);
             if (!paramValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid parameters: ${paramValidation.error}`
+                    status: "error",
+                    error: `Invalid parameters: ${paramValidation.error}`,
                 };
             }
             // Build the query with escaped table name
@@ -433,18 +426,16 @@ class CrudTools {
             // Execute the query with sanitized parameters
             const result = await this.db.query(query, paramValidation.sanitizedParams);
             return {
-                status: 'success',
+                status: "success",
                 data: {
-                    affectedRows: result.affectedRows
+                    affectedRows: result.affectedRows,
                 },
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -455,8 +446,8 @@ class CrudTools {
         // Validate input schema
         if (!(0, schemas_1.validateBulkInsert)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateBulkInsert.errors)
+                status: "error",
+                error: "Invalid parameters: " + JSON.stringify(schemas_1.validateBulkInsert.errors),
             };
         }
         try {
@@ -465,15 +456,15 @@ class CrudTools {
             const tableValidation = this.security.validateIdentifier(table_name);
             if (!tableValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid table name: ${tableValidation.error}`
+                    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'
+                    status: "error",
+                    error: "Data array cannot be empty",
                 };
             }
             // Validate that all records have the same columns
@@ -482,10 +473,10 @@ class CrudTools {
             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))) {
+                    !recordColumns.every((col) => columns.includes(col))) {
                     return {
-                        status: 'error',
-                        error: `All records must have the same columns. Record ${i + 1} has different columns.`
+                        status: "error",
+                        error: `All records must have the same columns. Record ${i + 1} has different columns.`,
                     };
                 }
             }
@@ -494,8 +485,8 @@ class CrudTools {
                 const columnValidation = this.security.validateIdentifier(column);
                 if (!columnValidation.valid) {
                     return {
-                        status: 'error',
-                        error: `Invalid column name '${column}': ${columnValidation.error}`
+                        status: "error",
+                        error: `Invalid column name '${column}': ${columnValidation.error}`,
                     };
                 }
             }
@@ -507,46 +498,48 @@ class CrudTools {
                 // Prepare batch values
                 const batchValues = [];
                 for (const record of batch) {
-                    const values = columns.map(col => record[col]);
+                    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}`
+                            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}`;
+                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
+                    affectedRows: result.affectedRows,
                 });
                 totalInserted += result.affectedRows;
             }
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     totalRecords: data.length,
                     totalInserted,
                     batches: results.length,
-                    batchResults: results
-                }
+                    batchResults: results,
+                },
             };
         }
         catch (error) {
             return {
-                status: 'error',
-                error: error.message
+                status: "error",
+                error: error.message,
             };
         }
     }
@@ -557,8 +550,8 @@ class CrudTools {
         // Validate input schema
         if (!(0, schemas_1.validateBulkUpdate)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateBulkUpdate.errors)
+                status: "error",
+                error: "Invalid parameters: " + JSON.stringify(schemas_1.validateBulkUpdate.errors),
             };
         }
         try {
@@ -567,15 +560,15 @@ class CrudTools {
             const tableValidation = this.security.validateIdentifier(table_name);
             if (!tableValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid table name: ${tableValidation.error}`
+                    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'
+                    status: "error",
+                    error: "Updates array cannot be empty",
                 };
             }
             // Validate each update operation
@@ -587,8 +580,8 @@ class CrudTools {
                     const columnValidation = this.security.validateIdentifier(column);
                     if (!columnValidation.valid) {
                         return {
-                            status: 'error',
-                            error: `Invalid column name '${column}' in update ${i + 1}: ${columnValidation.error}`
+                            status: "error",
+                            error: `Invalid column name '${column}' in update ${i + 1}: ${columnValidation.error}`,
                         };
                     }
                 }
@@ -597,8 +590,8 @@ class CrudTools {
                     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}`
+                            status: "error",
+                            error: `Invalid condition field '${condition.field}' in update ${i + 1}: ${fieldValidation.error}`,
                         };
                     }
                 }
@@ -609,52 +602,54 @@ class CrudTools {
             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');
+                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(', ');
+                            .join(", ");
                         const setValues = Object.values(update.data);
                         // Build WHERE clause
                         const whereConditions = [];
                         const whereValues = [];
-                        update.conditions.forEach(condition => {
+                        update.conditions.forEach((condition) => {
                             const escapedField = this.security.escapeIdentifier(condition.field);
                             switch (condition.operator) {
-                                case 'eq':
+                                case "eq":
                                     whereConditions.push(`${escapedField} = ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'neq':
+                                case "neq":
                                     whereConditions.push(`${escapedField} != ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'gt':
+                                case "gt":
                                     whereConditions.push(`${escapedField} > ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'gte':
+                                case "gte":
                                     whereConditions.push(`${escapedField} >= ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'lt':
+                                case "lt":
                                     whereConditions.push(`${escapedField} < ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'lte':
+                                case "lte":
                                     whereConditions.push(`${escapedField} <= ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'like':
+                                case "like":
                                     whereConditions.push(`${escapedField} LIKE ?`);
                                     whereValues.push(`%${condition.value}%`);
                                     break;
-                                case 'in':
+                                case "in":
                                     if (Array.isArray(condition.value)) {
-                                        const placeholders = condition.value.map(() => '?').join(', ');
+                                        const placeholders = condition.value
+                                            .map(() => "?")
+                                            .join(", ");
                                         whereConditions.push(`${escapedField} IN (${placeholders})`);
                                         whereValues.push(...condition.value);
                                     }
@@ -662,8 +657,8 @@ class CrudTools {
                             }
                         });
                         const whereClause = whereConditions.length > 0
-                            ? 'WHERE ' + whereConditions.join(' AND ')
-                            : '';
+                            ? "WHERE " + whereConditions.join(" AND ")
+                            : "";
                         // Validate all parameters
                         const allParams = [...setValues, ...whereValues];
                         const paramValidation = this.security.validateParameters(allParams);
@@ -675,38 +670,38 @@ class CrudTools {
                         const query = `UPDATE ${escapedTableName} SET ${setClause} ${whereClause}`;
                         const result = await this.db.query(query, paramValidation.sanitizedParams);
                         batchResults.push({
-                            affectedRows: result.affectedRows
+                            affectedRows: result.affectedRows,
                         });
                         totalAffected += result.affectedRows;
                     }
                     // Commit the transaction
-                    await this.db.query('COMMIT');
+                    await this.db.query("COMMIT");
                     results.push({
                         batchNumber: Math.floor(i / batch_size) + 1,
                         updatesProcessed: batch.length,
-                        results: batchResults
+                        results: batchResults,
                     });
                 }
                 catch (error) {
                     // Rollback on error
-                    await this.db.query('ROLLBACK');
+                    await this.db.query("ROLLBACK");
                     throw error;
                 }
             }
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     totalUpdates: updates.length,
                     totalAffectedRows: totalAffected,
                     batches: results.length,
-                    batchResults: results
-                }
+                    batchResults: results,
+                },
             };
         }
         catch (error) {
             return {
-                status: 'error',
-                error: error.message
+                status: "error",
+                error: error.message,
             };
         }
     }
@@ -717,8 +712,8 @@ class CrudTools {
         // Validate input schema
         if (!(0, schemas_1.validateBulkDelete)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateBulkDelete.errors)
+                status: "error",
+                error: "Invalid parameters: " + JSON.stringify(schemas_1.validateBulkDelete.errors),
             };
         }
         try {
@@ -727,15 +722,15 @@ class CrudTools {
             const tableValidation = this.security.validateIdentifier(table_name);
             if (!tableValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Invalid table name: ${tableValidation.error}`
+                    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'
+                    status: "error",
+                    error: "Condition sets array cannot be empty",
                 };
             }
             // Validate each condition set
@@ -744,8 +739,8 @@ class CrudTools {
                 // 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.`
+                        status: "error",
+                        error: `DELETE operations require at least one condition for safety. Condition set ${i + 1} is empty.`,
                     };
                 }
                 // Validate condition fields
@@ -753,8 +748,8 @@ class CrudTools {
                     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}`
+                            status: "error",
+                            error: `Invalid condition field '${condition.field}' in condition set ${i + 1}: ${fieldValidation.error}`,
                         };
                     }
                 }
@@ -765,54 +760,56 @@ class CrudTools {
             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');
+                await this.db.query("START TRANSACTION");
                 try {
                     const batchResults = [];
                     for (const conditions of batch) {
                         // Build WHERE clause
                         const whereConditions = [];
                         const whereValues = [];
-                        conditions.forEach(condition => {
+                        conditions.forEach((condition) => {
                             const escapedField = this.security.escapeIdentifier(condition.field);
                             switch (condition.operator) {
-                                case 'eq':
+                                case "eq":
                                     whereConditions.push(`${escapedField} = ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'neq':
+                                case "neq":
                                     whereConditions.push(`${escapedField} != ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'gt':
+                                case "gt":
                                     whereConditions.push(`${escapedField} > ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'gte':
+                                case "gte":
                                     whereConditions.push(`${escapedField} >= ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'lt':
+                                case "lt":
                                     whereConditions.push(`${escapedField} < ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'lte':
+                                case "lte":
                                     whereConditions.push(`${escapedField} <= ?`);
                                     whereValues.push(condition.value);
                                     break;
-                                case 'like':
+                                case "like":
                                     whereConditions.push(`${escapedField} LIKE ?`);
                                     whereValues.push(`%${condition.value}%`);
                                     break;
-                                case 'in':
+                                case "in":
                                     if (Array.isArray(condition.value)) {
-                                        const placeholders = condition.value.map(() => '?').join(', ');
+                                        const placeholders = condition.value
+                                            .map(() => "?")
+                                            .join(", ");
                                         whereConditions.push(`${escapedField} IN (${placeholders})`);
                                         whereValues.push(...condition.value);
                                     }
                                     break;
                             }
                         });
-                        const whereClause = 'WHERE ' + whereConditions.join(' AND ');
+                        const whereClause = "WHERE " + whereConditions.join(" AND ");
                         // Validate all parameters
                         const paramValidation = this.security.validateParameters(whereValues);
                         if (!paramValidation.valid) {
@@ -823,38 +820,38 @@ class CrudTools {
                         const query = `DELETE FROM ${escapedTableName} ${whereClause}`;
                         const result = await this.db.query(query, paramValidation.sanitizedParams);
                         batchResults.push({
-                            affectedRows: result.affectedRows
+                            affectedRows: result.affectedRows,
                         });
                         totalDeleted += result.affectedRows;
                     }
                     // Commit the transaction
-                    await this.db.query('COMMIT');
+                    await this.db.query("COMMIT");
                     results.push({
                         batchNumber: Math.floor(i / batch_size) + 1,
                         deletesProcessed: batch.length,
-                        results: batchResults
+                        results: batchResults,
                     });
                 }
                 catch (error) {
                     // Rollback on error
-                    await this.db.query('ROLLBACK');
+                    await this.db.query("ROLLBACK");
                     throw error;
                 }
             }
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     totalDeletes: condition_sets.length,
                     totalDeletedRows: totalDeleted,
                     batches: results.length,
-                    batchResults: results
-                }
+                    batchResults: results,
+                },
             };
         }
         catch (error) {
             return {
-                status: 'error',
-                error: error.message
+                status: "error",
+                error: error.message,
             };
         }
     }