@berthojoris/mcp-mysql-server 1.10.3 → 1.10.5

package/dist/tools/storedProcedureTools.d.ts

@@ -1,4 +1,4 @@
-import { SecurityLayer } from '../security/securityLayer';
+import { SecurityLayer } from "../security/securityLayer";
 export declare class StoredProcedureTools {
     private db;
     private security;
@@ -16,7 +16,6 @@ export declare class StoredProcedureTools {
         status: string;
         data?: any[];
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Get detailed information about a specific stored procedure
@@ -28,7 +27,6 @@ export declare class StoredProcedureTools {
         status: string;
         data?: any;
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Execute a stored procedure with parameters
@@ -49,7 +47,7 @@ export declare class StoredProcedureTools {
         procedure_name: string;
         parameters?: Array<{
             name: string;
-            mode: 'IN' | 'OUT' | 'INOUT';
+            mode: "IN" | "OUT" | "INOUT";
             data_type: string;
         }>;
         body: string;

package/dist/tools/storedProcedureTools.js

@@ -20,28 +20,28 @@ class StoredProcedureTools {
         if (!connectedDatabase) {
             return {
                 valid: false,
-                database: '',
-                error: 'No database specified in connection string. Cannot access any database.'
+                database: "",
+                error: "No database specified in connection string. Cannot access any database.",
             };
         }
         // If no database is requested, use the connected database
         if (!requestedDatabase) {
             return {
                 valid: true,
-                database: connectedDatabase
+                database: connectedDatabase,
             };
         }
         // If a specific database is requested, ensure it matches the connected database
         if (requestedDatabase !== connectedDatabase) {
             return {
                 valid: false,
-                database: '',
-                error: `Access denied. You can only access the connected database '${connectedDatabase}'. Requested database '${requestedDatabase}' is not allowed.`
+                database: "",
+                error: `Access denied. You can only access the connected database '${connectedDatabase}'. Requested database '${requestedDatabase}' is not allowed.`,
             };
         }
         return {
             valid: true,
-            database: connectedDatabase
+            database: connectedDatabase,
         };
     }
     /**
@@ -52,47 +52,46 @@ class StoredProcedureTools {
             // Validate input
             if (!(0, schemas_1.validateListStoredProcedures)(params)) {
                 return {
-                    status: 'error',
-                    error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateListStoredProcedures.errors)
+                    status: "error",
+                    error: "Invalid parameters: " +
+                        JSON.stringify(schemas_1.validateListStoredProcedures.errors),
                 };
             }
             // Validate database access
             const dbValidation = this.validateDatabaseAccess(params.database);
             if (!dbValidation.valid) {
                 return {
-                    status: 'error',
-                    error: dbValidation.error
+                    status: "error",
+                    error: dbValidation.error,
                 };
             }
             const database = dbValidation.database;
-            const query = `
-        SELECT 
-          ROUTINE_NAME as name,
-          ROUTINE_TYPE as type,
-          DATA_TYPE as return_type,
-          ROUTINE_DEFINITION as definition,
-          CREATED,
-          LAST_ALTERED,
-          ROUTINE_COMMENT as comment,
-          DEFINER,
-          SQL_MODE,
-          SECURITY_TYPE
-        FROM INFORMATION_SCHEMA.ROUTINES 
-        WHERE ROUTINE_SCHEMA = ? AND ROUTINE_TYPE = 'PROCEDURE'
-        ORDER BY ROUTINE_NAME
+            const query = `
+        SELECT
+          ROUTINE_NAME as name,
+          ROUTINE_TYPE as type,
+          DATA_TYPE as return_type,
+          ROUTINE_DEFINITION as definition,
+          CREATED,
+          LAST_ALTERED,
+          ROUTINE_COMMENT as comment,
+          DEFINER,
+          SQL_MODE,
+          SECURITY_TYPE
+        FROM INFORMATION_SCHEMA.ROUTINES
+        WHERE ROUTINE_SCHEMA = ? AND ROUTINE_TYPE = 'PROCEDURE'
+        ORDER BY ROUTINE_NAME
       `;
             const results = await this.db.query(query, [database]);
             return {
-                status: 'success',
+                status: "success",
                 data: results,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -104,76 +103,74 @@ class StoredProcedureTools {
             // Validate input
             if (!(0, schemas_1.validateGetStoredProcedureInfo)(params)) {
                 return {
-                    status: 'error',
-                    error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateGetStoredProcedureInfo.errors)
+                    status: "error",
+                    error: "Invalid parameters: " +
+                        JSON.stringify(schemas_1.validateGetStoredProcedureInfo.errors),
                 };
             }
             // Validate database access
             const dbValidation = this.validateDatabaseAccess(params.database);
             if (!dbValidation.valid) {
                 return {
-                    status: 'error',
-                    error: dbValidation.error
+                    status: "error",
+                    error: dbValidation.error,
                 };
             }
             const { procedure_name } = params;
             const database = dbValidation.database;
             // Get procedure information
-            const procedureQuery = `
-        SELECT 
-          ROUTINE_NAME as name,
-          ROUTINE_TYPE as type,
-          DATA_TYPE as return_type,
-          ROUTINE_DEFINITION as definition,
-          CREATED,
-          LAST_ALTERED,
-          ROUTINE_COMMENT as comment,
-          DEFINER,
-          SQL_MODE,
-          SECURITY_TYPE,
-          IS_DETERMINISTIC,
-          SQL_DATA_ACCESS,
-          ROUTINE_BODY
-        FROM INFORMATION_SCHEMA.ROUTINES 
-        WHERE ROUTINE_SCHEMA = ? AND ROUTINE_NAME = ? AND ROUTINE_TYPE = 'PROCEDURE'
+            const procedureQuery = `
+        SELECT
+          ROUTINE_NAME as name,
+          ROUTINE_TYPE as type,
+          DATA_TYPE as return_type,
+          ROUTINE_DEFINITION as definition,
+          CREATED,
+          LAST_ALTERED,
+          ROUTINE_COMMENT as comment,
+          DEFINER,
+          SQL_MODE,
+          SECURITY_TYPE,
+          IS_DETERMINISTIC,
+          SQL_DATA_ACCESS,
+          ROUTINE_BODY
+        FROM INFORMATION_SCHEMA.ROUTINES
+        WHERE ROUTINE_SCHEMA = ? AND ROUTINE_NAME = ? AND ROUTINE_TYPE = 'PROCEDURE'
       `;
             // Get procedure parameters
-            const parametersQuery = `
-        SELECT 
-          PARAMETER_NAME as name,
-          PARAMETER_MODE as mode,
-          DATA_TYPE as data_type,
-          CHARACTER_MAXIMUM_LENGTH as max_length,
-          ORDINAL_POSITION as position
-        FROM INFORMATION_SCHEMA.PARAMETERS 
-        WHERE SPECIFIC_SCHEMA = ? AND SPECIFIC_NAME = ?
-        ORDER BY ORDINAL_POSITION
+            const parametersQuery = `
+        SELECT
+          PARAMETER_NAME as name,
+          PARAMETER_MODE as mode,
+          DATA_TYPE as data_type,
+          CHARACTER_MAXIMUM_LENGTH as max_length,
+          ORDINAL_POSITION as position
+        FROM INFORMATION_SCHEMA.PARAMETERS
+        WHERE SPECIFIC_SCHEMA = ? AND SPECIFIC_NAME = ?
+        ORDER BY ORDINAL_POSITION
       `;
             const [procedureInfo, parameters] = await Promise.all([
                 this.db.query(procedureQuery, [database, procedure_name]),
-                this.db.query(parametersQuery, [database, procedure_name])
+                this.db.query(parametersQuery, [database, procedure_name]),
             ]);
             if (procedureInfo.length === 0) {
                 return {
-                    status: 'error',
+                    status: "error",
                     error: `Stored procedure '${procedure_name}' not found in database '${database}'`,
-                    queryLog: this.db.getFormattedQueryLogs(2)
                 };
             }
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     ...procedureInfo[0],
-                    parameters: parameters
+                    parameters: parameters,
                 },
-                queryLog: this.db.getFormattedQueryLogs(2)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(2)
             };
         }
     }
@@ -184,8 +181,9 @@ class StoredProcedureTools {
         // Validate input schema
         if (!(0, schemas_1.validateStoredProcedureExecution)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateStoredProcedureExecution.errors)
+                status: "error",
+                error: "Invalid parameters: " +
+                    JSON.stringify(schemas_1.validateStoredProcedureExecution.errors),
             };
         }
         try {
@@ -193,8 +191,8 @@ class StoredProcedureTools {
             const dbValidation = this.validateDatabaseAccess(params.database);
             if (!dbValidation.valid) {
                 return {
-                    status: 'error',
-                    error: dbValidation.error
+                    status: "error",
+                    error: dbValidation.error,
                 };
             }
             const { procedure_name, parameters = [] } = params;
@@ -203,32 +201,35 @@ class StoredProcedureTools {
             const identifierValidation = this.security.validateIdentifier(procedure_name);
             if (!identifierValidation.valid) {
                 return {
-                    status: 'error',
-                    error: identifierValidation.error || 'Invalid procedure name'
+                    status: "error",
+                    error: identifierValidation.error || "Invalid procedure name",
                 };
             }
             // Get procedure parameter information to handle OUT/INOUT parameters
-            const procInfo = await this.getStoredProcedureInfo({ procedure_name, database });
-            if (procInfo.status !== 'success' || !procInfo.data) {
+            const procInfo = await this.getStoredProcedureInfo({
+                procedure_name,
+                database,
+            });
+            if (procInfo.status !== "success" || !procInfo.data) {
                 return {
-                    status: 'error',
-                    error: `Could not retrieve procedure information: ${procInfo.error || 'Unknown error'}`
+                    status: "error",
+                    error: `Could not retrieve procedure information: ${procInfo.error || "Unknown error"}`,
                 };
             }
             const procedureParams = procInfo.data.parameters || [];
             // Validate parameter count
             if (parameters.length > procedureParams.length) {
                 return {
-                    status: 'error',
-                    error: `Too many parameters provided. Expected ${procedureParams.length}, got ${parameters.length}`
+                    status: "error",
+                    error: `Too many parameters provided. Expected ${procedureParams.length}, got ${parameters.length}`,
                 };
             }
             // Validate parameters
             const paramValidation = this.security.validateParameters(parameters);
             if (!paramValidation.valid) {
                 return {
-                    status: 'error',
-                    error: `Parameter validation failed: ${paramValidation.error}`
+                    status: "error",
+                    error: `Parameter validation failed: ${paramValidation.error}`,
                 };
             }
             // Build parameter list for CALL statement
@@ -237,57 +238,59 @@ class StoredProcedureTools {
             let paramIndex = 0;
             for (let i = 0; i < procedureParams.length; i++) {
                 const procParam = procedureParams[i];
-                if (procParam.mode === 'IN') {
+                if (procParam.mode === "IN") {
                     // IN parameters use provided values or NULL if not provided
                     if (paramIndex < parameters.length) {
-                        callParams.push('?');
+                        callParams.push("?");
                         paramIndex++;
                     }
                     else {
-                        callParams.push('NULL');
+                        callParams.push("NULL");
                     }
                 }
-                else if (procParam.mode === 'OUT' || procParam.mode === 'INOUT') {
+                else if (procParam.mode === "OUT" || procParam.mode === "INOUT") {
                     // OUT/INOUT parameters use session variables
                     const varName = `@${procParam.name}_${Date.now()}_${i}`;
                     sessionVars.push(varName);
-                    if (procParam.mode === 'INOUT' && paramIndex < parameters.length) {
+                    if (procParam.mode === "INOUT" && paramIndex < parameters.length) {
                         // For INOUT, set the session variable to the input value first
-                        await this.db.query(`SET ${varName} = ?`, [paramValidation.sanitizedParams[paramIndex]]);
+                        await this.db.query(`SET ${varName} = ?`, [
+                            paramValidation.sanitizedParams[paramIndex],
+                        ]);
                         paramIndex++;
                     }
                     callParams.push(varName);
                 }
             }
             // Build and execute CALL statement
-            const callQuery = `CALL \`${database}\`.\`${procedure_name}\`(${callParams.join(', ')})`;
+            const callQuery = `CALL \`${database}\`.\`${procedure_name}\`(${callParams.join(", ")})`;
             const callResults = await this.db.query(callQuery, paramValidation.sanitizedParams.slice(0, paramIndex));
             // Get OUT/INOUT parameter values
             const outputValues = {};
             if (sessionVars.length > 0) {
-                const selectQuery = `SELECT ${sessionVars.join(', ')}`;
+                const selectQuery = `SELECT ${sessionVars.join(", ")}`;
                 const outputResults = await this.db.query(selectQuery);
                 if (outputResults && outputResults.length > 0) {
                     const outputRow = outputResults[0];
                     sessionVars.forEach((varName, index) => {
-                        const paramName = procedureParams.find((p) => (p.mode === 'OUT' || p.mode === 'INOUT') &&
+                        const paramName = procedureParams.find((p) => (p.mode === "OUT" || p.mode === "INOUT") &&
                             varName.includes(p.name))?.name || `param_${index}`;
                         outputValues[paramName] = outputRow[varName];
                     });
                 }
             }
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     results: callResults,
-                    outputParameters: Object.keys(outputValues).length > 0 ? outputValues : undefined
-                }
+                    outputParameters: Object.keys(outputValues).length > 0 ? outputValues : undefined,
+                },
             };
         }
         catch (error) {
             return {
-                status: 'error',
-                error: error.message
+                status: "error",
+                error: error.message,
             };
         }
     }
@@ -298,8 +301,9 @@ class StoredProcedureTools {
         // Validate input schema
         if (!(0, schemas_1.validateStoredProcedureCreation)(params)) {
             return {
-                status: 'error',
-                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateStoredProcedureCreation.errors)
+                status: "error",
+                error: "Invalid parameters: " +
+                    JSON.stringify(schemas_1.validateStoredProcedureCreation.errors),
             };
         }
         try {
@@ -307,8 +311,8 @@ class StoredProcedureTools {
             const dbValidation = this.validateDatabaseAccess(params.database);
             if (!dbValidation.valid) {
                 return {
-                    status: 'error',
-                    error: dbValidation.error
+                    status: "error",
+                    error: dbValidation.error,
                 };
             }
             const { procedure_name, parameters = [], body, comment } = params;
@@ -317,26 +321,29 @@ class StoredProcedureTools {
             const identifierValidation = this.security.validateIdentifier(procedure_name);
             if (!identifierValidation.valid) {
                 return {
-                    status: 'error',
-                    error: identifierValidation.error || 'Invalid procedure name'
+                    status: "error",
+                    error: identifierValidation.error || "Invalid procedure name",
                 };
             }
             // Build parameter list
-            const parameterList = parameters.map(param => {
+            const parameterList = parameters
+                .map((param) => {
                 if (!this.security.validateIdentifier(param.name).valid) {
                     throw new Error(`Invalid parameter name: ${param.name}`);
                 }
                 return `${param.mode} \`${param.name}\` ${param.data_type}`;
-            }).join(', ');
+            })
+                .join(", ");
             // Build CREATE PROCEDURE statement
             let createQuery = `CREATE PROCEDURE \`${database}\`.\`${procedure_name}\`(${parameterList})\n`;
             if (comment) {
-                createQuery += `COMMENT '${comment.replace(/'/g, "''")}'
+                createQuery += `COMMENT '${comment.replace(/'/g, "''")}'
 `;
             }
             // Check if body already contains BEGIN/END, if not add them
             const trimmedBody = body.trim();
-            if (trimmedBody.toUpperCase().startsWith('BEGIN') && trimmedBody.toUpperCase().endsWith('END')) {
+            if (trimmedBody.toUpperCase().startsWith("BEGIN") &&
+                trimmedBody.toUpperCase().endsWith("END")) {
                 createQuery += `\n${body}`;
             }
             else {
@@ -345,18 +352,18 @@ class StoredProcedureTools {
             // Execute the CREATE PROCEDURE statement
             await this.db.query(createQuery);
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     message: `Stored procedure '${procedure_name}' created successfully`,
                     procedure_name,
-                    database
-                }
+                    database,
+                },
             };
         }
         catch (error) {
             return {
-                status: 'error',
-                error: error.message
+                status: "error",
+                error: error.message,
             };
         }
     }
@@ -368,16 +375,17 @@ class StoredProcedureTools {
             // Validate input
             if (!(0, schemas_1.validateDropStoredProcedure)(params)) {
                 return {
-                    status: 'error',
-                    error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateDropStoredProcedure.errors)
+                    status: "error",
+                    error: "Invalid parameters: " +
+                        JSON.stringify(schemas_1.validateDropStoredProcedure.errors),
                 };
             }
             // Validate database access
             const dbValidation = this.validateDatabaseAccess(params.database);
             if (!dbValidation.valid) {
                 return {
-                    status: 'error',
-                    error: dbValidation.error
+                    status: "error",
+                    error: dbValidation.error,
                 };
             }
             const { procedure_name, if_exists = false } = params;
@@ -386,23 +394,23 @@ class StoredProcedureTools {
             const identifierValidation = this.security.validateIdentifier(procedure_name);
             if (!identifierValidation.valid) {
                 return {
-                    status: 'error',
-                    error: identifierValidation.error || 'Invalid procedure name'
+                    status: "error",
+                    error: identifierValidation.error || "Invalid procedure name",
                 };
             }
             // Build DROP PROCEDURE statement
-            const dropQuery = `DROP PROCEDURE ${if_exists ? 'IF EXISTS' : ''} \`${database}\`.\`${procedure_name}\``;
+            const dropQuery = `DROP PROCEDURE ${if_exists ? "IF EXISTS" : ""} \`${database}\`.\`${procedure_name}\``;
             // Execute the DROP PROCEDURE statement
             await this.db.query(dropQuery);
             return {
-                status: 'success',
-                message: `Stored procedure '${procedure_name}' dropped successfully`
+                status: "success",
+                message: `Stored procedure '${procedure_name}' dropped successfully`,
             };
         }
         catch (error) {
             return {
-                status: 'error',
-                error: error.message
+                status: "error",
+                error: error.message,
             };
         }
     }
@@ -414,16 +422,17 @@ class StoredProcedureTools {
             // Validate input
             if (!(0, schemas_1.validateShowCreateProcedure)(params)) {
                 return {
-                    status: 'error',
-                    error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateShowCreateProcedure.errors)
+                    status: "error",
+                    error: "Invalid parameters: " +
+                        JSON.stringify(schemas_1.validateShowCreateProcedure.errors),
                 };
             }
             // Validate database access
             const dbValidation = this.validateDatabaseAccess(params.database);
             if (!dbValidation.valid) {
                 return {
-                    status: 'error',
-                    error: dbValidation.error
+                    status: "error",
+                    error: dbValidation.error,
                 };
             }
             const { procedure_name } = params;
@@ -432,27 +441,27 @@ class StoredProcedureTools {
             const identifierValidation = this.security.validateIdentifier(procedure_name);
             if (!identifierValidation.valid) {
                 return {
-                    status: 'error',
-                    error: identifierValidation.error || 'Invalid procedure name'
+                    status: "error",
+                    error: identifierValidation.error || "Invalid procedure name",
                 };
             }
             const query = `SHOW CREATE PROCEDURE \`${database}\`.\`${procedure_name}\``;
             const results = await this.db.query(query);
             if (results.length === 0) {
                 return {
-                    status: 'error',
-                    error: `Stored procedure '${procedure_name}' not found`
+                    status: "error",
+                    error: `Stored procedure '${procedure_name}' not found`,
                 };
             }
             return {
-                status: 'success',
-                data: results[0]
+                status: "success",
+                data: results[0],
             };
         }
         catch (error) {
             return {
-                status: 'error',
-                error: error.message
+                status: "error",
+                error: error.message,
             };
         }
     }

package/dist/tools/transactionTools.d.ts

@@ -1,5 +1,5 @@
 export interface TransactionResult {
-    status: 'success' | 'error';
+    status: "success" | "error";
     transactionId?: string;
     message?: string;
     activeTransactions?: string[];
@@ -38,9 +38,8 @@ export declare class TransactionTools {
         query: string;
         params?: any[];
     }): Promise<{
-        status: 'success' | 'error';
+        status: "success" | "error";
         data?: any;
         error?: string;
-        queryLog?: string;
     }>;
 }