@berthojoris/mcp-mysql-server 1.0.0

package/dist/tools/utilityTools.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UtilityTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+const config_1 = require("../config/config");
+const schemas_1 = require("../validation/schemas");
+class UtilityTools {
+    constructor() {
+        this.db = connection_1.default.getInstance();
+    }
+    /**
+     * Returns the current database connection info
+     */
+    async describeConnection() {
+        try {
+            // Return connection info without sensitive data
+            const connectionInfo = {
+                host: config_1.dbConfig.host,
+                port: config_1.dbConfig.port,
+                user: config_1.dbConfig.user,
+                database: config_1.dbConfig.database,
+                // Exclude password for security
+            };
+            return {
+                status: 'success',
+                data: connectionInfo
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Tests the DB connection and returns latency
+     */
+    async testConnection() {
+        try {
+            const result = await this.db.testConnection();
+            return {
+                status: result.connected ? 'success' : 'error',
+                data: {
+                    connected: result.connected,
+                    latency: result.latency
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Detects and describes foreign key relationships between tables
+     */
+    async getTableRelationships(params) {
+        // Validate input
+        if (!(0, schemas_1.validateGetTableRelationships)(params)) {
+            return {
+                status: 'error',
+                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateGetTableRelationships.errors)
+            };
+        }
+        try {
+            const { table_name } = params;
+            // Query to get foreign keys where this table is the parent
+            const parentQuery = `
+        SELECT 
+          TABLE_NAME as child_table,
+          COLUMN_NAME as child_column,
+          REFERENCED_TABLE_NAME as parent_table,
+          REFERENCED_COLUMN_NAME as parent_column,
+          CONSTRAINT_NAME as constraint_name
+        FROM 
+          INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+        WHERE 
+          REFERENCED_TABLE_NAME = ?
+          AND REFERENCED_TABLE_SCHEMA = DATABASE()
+      `;
+            // Query to get foreign keys where this table is the child
+            const childQuery = `
+        SELECT 
+          TABLE_NAME as child_table,
+          COLUMN_NAME as child_column,
+          REFERENCED_TABLE_NAME as parent_table,
+          REFERENCED_COLUMN_NAME as parent_column,
+          CONSTRAINT_NAME as constraint_name
+        FROM 
+          INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+        WHERE 
+          TABLE_NAME = ?
+          AND REFERENCED_TABLE_NAME IS NOT NULL
+          AND TABLE_SCHEMA = DATABASE()
+      `;
+            // Execute both queries
+            const parentRelationships = await this.db.query(parentQuery, [table_name]);
+            const childRelationships = await this.db.query(childQuery, [table_name]);
+            return {
+                status: 'success',
+                data: {
+                    as_parent: parentRelationships,
+                    as_child: childRelationships
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+}
+exports.UtilityTools = UtilityTools;

package/dist/validation/schemas.d.ts

@@ -0,0 +1,423 @@
+export interface TableInfo {
+    table_name: string;
+}
+export interface ColumnInfo {
+    column_name: string;
+    data_type: string;
+    is_nullable: string;
+    column_key: string;
+    column_default: string | null;
+    extra: string;
+}
+export interface FilterCondition {
+    field: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'in';
+    value: any;
+}
+export interface Pagination {
+    page: number;
+    limit: number;
+}
+export interface Sorting {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export declare const listTablesSchema: {
+    type: string;
+    properties: {
+        database: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const readTableSchemaSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        table_name: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const createRecordSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        table_name: {
+            type: string;
+        };
+        data: {
+            type: string;
+            additionalProperties: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const readRecordsSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        table_name: {
+            type: string;
+        };
+        filters: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    field: {
+                        type: string;
+                    };
+                    operator: {
+                        type: string;
+                        enum: string[];
+                    };
+                    value: {};
+                };
+            };
+            nullable: boolean;
+        };
+        pagination: {
+            type: string;
+            properties: {
+                page: {
+                    type: string;
+                    minimum: number;
+                };
+                limit: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+            };
+            required: string[];
+            nullable: boolean;
+        };
+        sorting: {
+            type: string;
+            properties: {
+                field: {
+                    type: string;
+                };
+                direction: {
+                    type: string;
+                    enum: string[];
+                };
+            };
+            required: string[];
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const updateRecordSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        table_name: {
+            type: string;
+        };
+        data: {
+            type: string;
+            additionalProperties: boolean;
+        };
+        conditions: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    field: {
+                        type: string;
+                    };
+                    operator: {
+                        type: string;
+                        enum: string[];
+                    };
+                    value: {};
+                };
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const deleteRecordSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        table_name: {
+            type: string;
+        };
+        conditions: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    field: {
+                        type: string;
+                    };
+                    operator: {
+                        type: string;
+                        enum: string[];
+                    };
+                    value: {};
+                };
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const runQuerySchema: {
+    type: string;
+    required: string[];
+    properties: {
+        query: {
+            type: string;
+        };
+        params: {
+            type: string;
+            items: {};
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const getTableRelationshipsSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        table_name: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const beginTransactionSchema: {
+    type: string;
+    properties: {
+        transactionId: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const commitTransactionSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        transactionId: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const rollbackTransactionSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        transactionId: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const getTransactionStatusSchema: {
+    type: string;
+    properties: {};
+    additionalProperties: boolean;
+};
+export declare const executeInTransactionSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        transactionId: {
+            type: string;
+        };
+        query: {
+            type: string;
+        };
+        params: {
+            type: string;
+            items: {};
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const listStoredProceduresSchema: {
+    type: string;
+    properties: {
+        database: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const getStoredProcedureInfoSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        procedure_name: {
+            type: string;
+        };
+        database: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const executeStoredProcedureSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        procedure_name: {
+            type: string;
+        };
+        parameters: {
+            type: string;
+            items: {};
+            nullable: boolean;
+        };
+        database: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const createStoredProcedureSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        procedure_name: {
+            type: string;
+        };
+        parameters: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    mode: {
+                        type: string;
+                        enum: string[];
+                    };
+                    data_type: {
+                        type: string;
+                    };
+                };
+            };
+            nullable: boolean;
+        };
+        body: {
+            type: string;
+        };
+        comment: {
+            type: string;
+            nullable: boolean;
+        };
+        database: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const dropStoredProcedureSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        procedure_name: {
+            type: string;
+        };
+        if_exists: {
+            type: string;
+            nullable: boolean;
+        };
+        database: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const showCreateProcedureSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        procedure_name: {
+            type: string;
+        };
+        database: {
+            type: string;
+            nullable: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare const validateListTables: import("ajv").ValidateFunction<{
+    database: unknown;
+} & {}>;
+export declare const validateReadTableSchema: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateCreateRecord: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateReadRecords: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateUpdateRecord: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateDeleteRecord: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateRunQuery: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateGetTableRelationships: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateBeginTransaction: import("ajv").ValidateFunction<{
+    transactionId: unknown;
+} & {}>;
+export declare const validateCommitTransaction: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateRollbackTransaction: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateGetTransactionStatus: import("ajv").ValidateFunction<{} & {}>;
+export declare const validateExecuteInTransaction: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateListStoredProcedures: import("ajv").ValidateFunction<{
+    database: unknown;
+} & {}>;
+export declare const validateGetStoredProcedureInfo: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateStoredProcedureExecution: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateStoredProcedureCreation: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateDropStoredProcedure: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const validateShowCreateProcedure: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;