@berthojoris/mcp-mysql-server 1.10.3 → 1.10.4

package/dist/tools/constraintTools.d.ts

@@ -1,4 +1,4 @@
-import { SecurityLayer } from '../security/securityLayer';
+import { SecurityLayer } from "../security/securityLayer";
 export declare class ConstraintTools {
     private db;
     private security;
@@ -17,7 +17,6 @@ export declare class ConstraintTools {
         status: string;
         data?: any[];
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * List all constraints (PK, FK, UNIQUE, CHECK) for a table
@@ -29,7 +28,6 @@ export declare class ConstraintTools {
         status: string;
         data?: any[];
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Add a foreign key constraint
@@ -40,14 +38,13 @@ export declare class ConstraintTools {
         columns: string[];
         referenced_table: string;
         referenced_columns: string[];
-        on_delete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | 'SET DEFAULT';
-        on_update?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | 'SET DEFAULT';
+        on_delete?: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+        on_update?: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
         database?: string;
     }): Promise<{
         status: string;
         data?: any;
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Drop a foreign key constraint
@@ -60,7 +57,6 @@ export declare class ConstraintTools {
         status: string;
         message?: string;
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Add a unique constraint
@@ -74,7 +70,6 @@ export declare class ConstraintTools {
         status: string;
         data?: any;
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Drop a constraint (UNIQUE or CHECK)
@@ -82,13 +77,12 @@ export declare class ConstraintTools {
     dropConstraint(params: {
         table_name: string;
         constraint_name: string;
-        constraint_type: 'UNIQUE' | 'CHECK';
+        constraint_type: "UNIQUE" | "CHECK";
         database?: string;
     }): Promise<{
         status: string;
         message?: string;
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Add a check constraint (MySQL 8.0.16+)
@@ -103,6 +97,5 @@ export declare class ConstraintTools {
         status: string;
         data?: any;
         error?: string;
-        queryLog?: string;
     }>;
 }

package/dist/tools/constraintTools.js

@@ -19,26 +19,26 @@ class ConstraintTools {
         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 (!requestedDatabase) {
             return {
                 valid: true,
-                database: connectedDatabase
+                database: connectedDatabase,
             };
         }
         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,
         };
     }
     /**
@@ -48,32 +48,32 @@ class ConstraintTools {
         try {
             const dbValidation = this.validateDatabaseAccess(params?.database);
             if (!dbValidation.valid) {
-                return { status: 'error', error: dbValidation.error };
+                return { status: "error", error: dbValidation.error };
             }
             const { table_name } = params;
             const database = dbValidation.database;
             // Validate table name
             if (!this.security.validateIdentifier(table_name).valid) {
-                return { status: 'error', error: 'Invalid table name' };
+                return { status: "error", error: "Invalid table name" };
             }
-            const query = `
-        SELECT
-          kcu.CONSTRAINT_NAME as constraint_name,
-          kcu.COLUMN_NAME as column_name,
-          kcu.REFERENCED_TABLE_SCHEMA as referenced_schema,
-          kcu.REFERENCED_TABLE_NAME as referenced_table,
-          kcu.REFERENCED_COLUMN_NAME as referenced_column,
-          kcu.ORDINAL_POSITION as ordinal_position,
-          rc.UPDATE_RULE as on_update,
-          rc.DELETE_RULE as on_delete
-        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
-        JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
-          ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-          AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
-        WHERE kcu.TABLE_SCHEMA = ?
-          AND kcu.TABLE_NAME = ?
-          AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
-        ORDER BY kcu.CONSTRAINT_NAME, kcu.ORDINAL_POSITION
+            const query = `
+        SELECT
+          kcu.CONSTRAINT_NAME as constraint_name,
+          kcu.COLUMN_NAME as column_name,
+          kcu.REFERENCED_TABLE_SCHEMA as referenced_schema,
+          kcu.REFERENCED_TABLE_NAME as referenced_table,
+          kcu.REFERENCED_COLUMN_NAME as referenced_column,
+          kcu.ORDINAL_POSITION as ordinal_position,
+          rc.UPDATE_RULE as on_update,
+          rc.DELETE_RULE as on_delete
+        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+        JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+          ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+          AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+        WHERE kcu.TABLE_SCHEMA = ?
+          AND kcu.TABLE_NAME = ?
+          AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
+        ORDER BY kcu.CONSTRAINT_NAME, kcu.ORDINAL_POSITION
       `;
             const results = await this.db.query(query, [database, table_name]);
             // Group by constraint name
@@ -88,26 +88,24 @@ class ConstraintTools {
                         referenced_table: row.referenced_table,
                         on_update: row.on_update,
                         on_delete: row.on_delete,
-                        columns: []
+                        columns: [],
                     });
                 }
                 fkMap.get(constraintName).columns.push({
                     column_name: row.column_name,
                     referenced_column: row.referenced_column,
-                    ordinal_position: row.ordinal_position
+                    ordinal_position: row.ordinal_position,
                 });
             }
             return {
-                status: 'success',
+                status: "success",
                 data: Array.from(fkMap.values()),
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -118,50 +116,50 @@ class ConstraintTools {
         try {
             const dbValidation = this.validateDatabaseAccess(params?.database);
             if (!dbValidation.valid) {
-                return { status: 'error', error: dbValidation.error };
+                return { status: "error", error: dbValidation.error };
             }
             const { table_name } = params;
             const database = dbValidation.database;
             // Validate table name
             if (!this.security.validateIdentifier(table_name).valid) {
-                return { status: 'error', error: 'Invalid table name' };
+                return { status: "error", error: "Invalid table name" };
             }
-            const query = `
-        SELECT
-          tc.CONSTRAINT_NAME as constraint_name,
-          tc.CONSTRAINT_TYPE as constraint_type,
-          GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as columns,
-          kcu.REFERENCED_TABLE_NAME as referenced_table,
-          GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as referenced_columns
-        FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-        LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
-          ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
-          AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
-          AND tc.TABLE_NAME = kcu.TABLE_NAME
-        WHERE tc.TABLE_SCHEMA = ? AND tc.TABLE_NAME = ?
-        GROUP BY tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE, kcu.REFERENCED_TABLE_NAME
-        ORDER BY tc.CONSTRAINT_TYPE, tc.CONSTRAINT_NAME
+            const query = `
+        SELECT
+          tc.CONSTRAINT_NAME as constraint_name,
+          tc.CONSTRAINT_TYPE as constraint_type,
+          GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as columns,
+          kcu.REFERENCED_TABLE_NAME as referenced_table,
+          GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as referenced_columns
+        FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+        LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+          ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+          AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
+          AND tc.TABLE_NAME = kcu.TABLE_NAME
+        WHERE tc.TABLE_SCHEMA = ? AND tc.TABLE_NAME = ?
+        GROUP BY tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE, kcu.REFERENCED_TABLE_NAME
+        ORDER BY tc.CONSTRAINT_TYPE, tc.CONSTRAINT_NAME
       `;
             const results = await this.db.query(query, [database, table_name]);
             // Format results
-            const constraints = results.map(row => ({
+            const constraints = results.map((row) => ({
                 constraint_name: row.constraint_name,
                 constraint_type: row.constraint_type,
-                columns: row.columns ? row.columns.split(',') : [],
+                columns: row.columns ? row.columns.split(",") : [],
                 referenced_table: row.referenced_table || null,
-                referenced_columns: row.referenced_columns ? row.referenced_columns.split(',') : null
+                referenced_columns: row.referenced_columns
+                    ? row.referenced_columns.split(",")
+                    : null,
             }));
             return {
-                status: 'success',
+                status: "success",
                 data: constraints,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -172,63 +170,69 @@ class ConstraintTools {
         try {
             const dbValidation = this.validateDatabaseAccess(params?.database);
             if (!dbValidation.valid) {
-                return { status: 'error', error: dbValidation.error };
+                return { status: "error", error: dbValidation.error };
             }
-            const { table_name, constraint_name, columns, referenced_table, referenced_columns, on_delete = 'RESTRICT', on_update = 'RESTRICT' } = params;
+            const { table_name, constraint_name, columns, referenced_table, referenced_columns, on_delete = "RESTRICT", on_update = "RESTRICT", } = params;
             const database = dbValidation.database;
             // Validate names
             if (!this.security.validateIdentifier(table_name).valid) {
-                return { status: 'error', error: 'Invalid table name' };
+                return { status: "error", error: "Invalid table name" };
             }
             if (!this.security.validateIdentifier(constraint_name).valid) {
-                return { status: 'error', error: 'Invalid constraint name' };
+                return { status: "error", error: "Invalid constraint name" };
             }
             if (!this.security.validateIdentifier(referenced_table).valid) {
-                return { status: 'error', error: 'Invalid referenced table name' };
+                return { status: "error", error: "Invalid referenced table name" };
             }
             // Validate column names
             for (const col of columns) {
                 if (!this.security.validateIdentifier(col).valid) {
-                    return { status: 'error', error: `Invalid column name: ${col}` };
+                    return { status: "error", error: `Invalid column name: ${col}` };
                 }
             }
             for (const col of referenced_columns) {
                 if (!this.security.validateIdentifier(col).valid) {
-                    return { status: 'error', error: `Invalid referenced column name: ${col}` };
+                    return {
+                        status: "error",
+                        error: `Invalid referenced column name: ${col}`,
+                    };
                 }
             }
             // Column counts must match
             if (columns.length !== referenced_columns.length) {
-                return { status: 'error', error: 'Column count must match referenced column count' };
+                return {
+                    status: "error",
+                    error: "Column count must match referenced column count",
+                };
             }
-            const columnList = columns.map(c => `\`${c}\``).join(', ');
-            const refColumnList = referenced_columns.map(c => `\`${c}\``).join(', ');
-            const alterQuery = `
-        ALTER TABLE \`${database}\`.\`${table_name}\`
-        ADD CONSTRAINT \`${constraint_name}\`
-        FOREIGN KEY (${columnList})
-        REFERENCES \`${database}\`.\`${referenced_table}\` (${refColumnList})
-        ON DELETE ${on_delete}
-        ON UPDATE ${on_update}
+            const columnList = columns.map((c) => `\`${c}\``).join(", ");
+            const refColumnList = referenced_columns
+                .map((c) => `\`${c}\``)
+                .join(", ");
+            const alterQuery = `
+        ALTER TABLE \`${database}\`.\`${table_name}\`
+        ADD CONSTRAINT \`${constraint_name}\`
+        FOREIGN KEY (${columnList})
+        REFERENCES \`${database}\`.\`${referenced_table}\` (${refColumnList})
+        ON DELETE ${on_delete}
+        ON UPDATE ${on_update}
       `;
             await this.db.query(alterQuery);
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     message: `Foreign key '${constraint_name}' added successfully`,
                     constraint_name,
                     table_name,
                     referenced_table,
-                    database
+                    database,
                 },
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -239,30 +243,28 @@ class ConstraintTools {
         try {
             const dbValidation = this.validateDatabaseAccess(params?.database);
             if (!dbValidation.valid) {
-                return { status: 'error', error: dbValidation.error };
+                return { status: "error", error: dbValidation.error };
             }
             const { table_name, constraint_name } = params;
             const database = dbValidation.database;
             // Validate names
             if (!this.security.validateIdentifier(table_name).valid) {
-                return { status: 'error', error: 'Invalid table name' };
+                return { status: "error", error: "Invalid table name" };
             }
             if (!this.security.validateIdentifier(constraint_name).valid) {
-                return { status: 'error', error: 'Invalid constraint name' };
+                return { status: "error", error: "Invalid constraint name" };
             }
             const alterQuery = `ALTER TABLE \`${database}\`.\`${table_name}\` DROP FOREIGN KEY \`${constraint_name}\``;
             await this.db.query(alterQuery);
             return {
-                status: 'success',
+                status: "success",
                 message: `Foreign key '${constraint_name}' dropped successfully from table '${table_name}'`,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -273,43 +275,41 @@ class ConstraintTools {
         try {
             const dbValidation = this.validateDatabaseAccess(params?.database);
             if (!dbValidation.valid) {
-                return { status: 'error', error: dbValidation.error };
+                return { status: "error", error: dbValidation.error };
             }
             const { table_name, constraint_name, columns } = params;
             const database = dbValidation.database;
             // Validate names
             if (!this.security.validateIdentifier(table_name).valid) {
-                return { status: 'error', error: 'Invalid table name' };
+                return { status: "error", error: "Invalid table name" };
             }
             if (!this.security.validateIdentifier(constraint_name).valid) {
-                return { status: 'error', error: 'Invalid constraint name' };
+                return { status: "error", error: "Invalid constraint name" };
             }
             // Validate column names
             for (const col of columns) {
                 if (!this.security.validateIdentifier(col).valid) {
-                    return { status: 'error', error: `Invalid column name: ${col}` };
+                    return { status: "error", error: `Invalid column name: ${col}` };
                 }
             }
-            const columnList = columns.map(c => `\`${c}\``).join(', ');
+            const columnList = columns.map((c) => `\`${c}\``).join(", ");
             const alterQuery = `ALTER TABLE \`${database}\`.\`${table_name}\` ADD CONSTRAINT \`${constraint_name}\` UNIQUE (${columnList})`;
             await this.db.query(alterQuery);
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     message: `Unique constraint '${constraint_name}' added successfully`,
                     constraint_name,
                     table_name,
                     columns,
-                    database
+                    database,
                 },
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -320,40 +320,41 @@ class ConstraintTools {
         try {
             const dbValidation = this.validateDatabaseAccess(params?.database);
             if (!dbValidation.valid) {
-                return { status: 'error', error: dbValidation.error };
+                return { status: "error", error: dbValidation.error };
             }
             const { table_name, constraint_name, constraint_type } = params;
             const database = dbValidation.database;
             // Validate names
             if (!this.security.validateIdentifier(table_name).valid) {
-                return { status: 'error', error: 'Invalid table name' };
+                return { status: "error", error: "Invalid table name" };
             }
             if (!this.security.validateIdentifier(constraint_name).valid) {
-                return { status: 'error', error: 'Invalid constraint name' };
+                return { status: "error", error: "Invalid constraint name" };
             }
             let alterQuery;
-            if (constraint_type === 'UNIQUE') {
+            if (constraint_type === "UNIQUE") {
                 // UNIQUE constraints are implemented as indexes in MySQL
                 alterQuery = `ALTER TABLE \`${database}\`.\`${table_name}\` DROP INDEX \`${constraint_name}\``;
             }
-            else if (constraint_type === 'CHECK') {
+            else if (constraint_type === "CHECK") {
                 alterQuery = `ALTER TABLE \`${database}\`.\`${table_name}\` DROP CHECK \`${constraint_name}\``;
             }
             else {
-                return { status: 'error', error: 'Invalid constraint type. Use UNIQUE or CHECK.' };
+                return {
+                    status: "error",
+                    error: "Invalid constraint type. Use UNIQUE or CHECK.",
+                };
             }
             await this.db.query(alterQuery);
             return {
-                status: 'success',
+                status: "success",
                 message: `${constraint_type} constraint '${constraint_name}' dropped successfully from table '${table_name}'`,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -364,40 +365,38 @@ class ConstraintTools {
         try {
             const dbValidation = this.validateDatabaseAccess(params?.database);
             if (!dbValidation.valid) {
-                return { status: 'error', error: dbValidation.error };
+                return { status: "error", error: dbValidation.error };
             }
-            const { table_name, constraint_name, expression, enforced = true } = params;
+            const { table_name, constraint_name, expression, enforced = true, } = params;
             const database = dbValidation.database;
             // Validate names
             if (!this.security.validateIdentifier(table_name).valid) {
-                return { status: 'error', error: 'Invalid table name' };
+                return { status: "error", error: "Invalid table name" };
             }
             if (!this.security.validateIdentifier(constraint_name).valid) {
-                return { status: 'error', error: 'Invalid constraint name' };
+                return { status: "error", error: "Invalid constraint name" };
             }
             let alterQuery = `ALTER TABLE \`${database}\`.\`${table_name}\` ADD CONSTRAINT \`${constraint_name}\` CHECK (${expression})`;
             if (!enforced) {
-                alterQuery += ' NOT ENFORCED';
+                alterQuery += " NOT ENFORCED";
             }
             await this.db.query(alterQuery);
             return {
-                status: 'success',
+                status: "success",
                 data: {
                     message: `Check constraint '${constraint_name}' added successfully`,
                     constraint_name,
                     table_name,
                     expression,
                     enforced,
-                    database
+                    database,
                 },
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }

package/dist/tools/crudTools.d.ts

@@ -1,5 +1,5 @@
-import SecurityLayer from '../security/securityLayer';
-import { FilterCondition, Pagination, Sorting } from '../validation/schemas';
+import SecurityLayer from "../security/securityLayer";
+import { FilterCondition, Pagination, Sorting } from "../validation/schemas";
 export declare class CrudTools {
     private db;
     private security;
@@ -14,7 +14,6 @@ export declare class CrudTools {
         status: string;
         data?: any;
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Read records from the specified table with optional filters, pagination, and sorting
@@ -29,7 +28,6 @@ export declare class CrudTools {
         data?: any[];
         total?: number;
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Update records in the specified table based on conditions
@@ -44,7 +42,6 @@ export declare class CrudTools {
             affectedRows: number;
         };
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Delete records from the specified table based on conditions
@@ -58,7 +55,6 @@ export declare class CrudTools {
             affectedRows: number;
         };
         error?: string;
-        queryLog?: string;
     }>;
     /**
      * Bulk insert multiple records into the specified table