@berthojoris/mcp-mysql-server 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,236 @@
+/**
+ * MySQL Model Context Protocol (MCP)
+ * A secure interface for AI models to interact with MySQL databases
+ */
+export declare class MySQLMCP {
+    private dbTools;
+    private crudTools;
+    private queryTools;
+    private utilityTools;
+    private ddlTools;
+    private transactionTools;
+    private storedProcedureTools;
+    private security;
+    private featureConfig;
+    constructor(permissionsConfig?: string);
+    private checkToolEnabled;
+    listDatabases(): Promise<{
+        status: string;
+        data?: string[];
+        error?: string;
+    }>;
+    listTables(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: import("./validation/schemas").TableInfo[];
+        error?: string;
+    }>;
+    readTableSchema(params: {
+        table_name: string;
+    }): Promise<{
+        status: string;
+        data?: import("./validation/schemas").ColumnInfo[];
+        error?: string;
+    }>;
+    createRecord(params: {
+        table_name: string;
+        data: Record<string, any>;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    readRecords(params: {
+        table_name: string;
+        filters?: any[];
+        pagination?: {
+            page: number;
+            limit: number;
+        };
+        sorting?: {
+            field: string;
+            direction: 'asc' | 'desc';
+        };
+    }): Promise<{
+        status: string;
+        data?: any[];
+        total?: number;
+        error?: string;
+    }>;
+    updateRecord(params: {
+        table_name: string;
+        data: Record<string, any>;
+        conditions: any[];
+    }): Promise<{
+        status: string;
+        data?: {
+            affectedRows: number;
+        };
+        error?: string;
+    }>;
+    deleteRecord(params: {
+        table_name: string;
+        conditions: any[];
+    }): Promise<{
+        status: string;
+        data?: {
+            affectedRows: number;
+        };
+        error?: string;
+    }>;
+    runQuery(params: {
+        query: string;
+        params?: any[];
+    }): Promise<{
+        status: string;
+        data?: any[];
+        error?: string;
+    }>;
+    executeSql(params: {
+        query: string;
+        params?: any[];
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    createTable(params: any): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    alterTable(params: any): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    dropTable(params: any): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    executeDdl(params: {
+        query: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    describeConnection(): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    testConnection(): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    getTableRelationships(params: {
+        table_name: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    beginTransaction(params?: {
+        transactionId?: string;
+    }): Promise<import("./tools/transactionTools").TransactionResult | {
+        status: string;
+        error: string | undefined;
+    }>;
+    commitTransaction(params: {
+        transactionId: string;
+    }): Promise<import("./tools/transactionTools").TransactionResult | {
+        status: string;
+        error: string | undefined;
+    }>;
+    rollbackTransaction(params: {
+        transactionId: string;
+    }): Promise<import("./tools/transactionTools").TransactionResult | {
+        status: string;
+        error: string | undefined;
+    }>;
+    getTransactionStatus(): Promise<import("./tools/transactionTools").TransactionResult | {
+        status: string;
+        error: string | undefined;
+    }>;
+    executeInTransaction(params: {
+        transactionId: string;
+        query: string;
+        params?: any[];
+    }): Promise<{
+        status: "success" | "error";
+        data?: any;
+        error?: string;
+    } | {
+        status: string;
+        error: string | undefined;
+    }>;
+    listStoredProcedures(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any[];
+        error?: string;
+    }>;
+    getStoredProcedureInfo(params: {
+        procedure_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    executeStoredProcedure(params: {
+        procedure_name: string;
+        parameters?: any[];
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    createStoredProcedure(params: {
+        procedure_name: string;
+        parameters?: Array<{
+            name: string;
+            mode: 'IN' | 'OUT' | 'INOUT';
+            data_type: string;
+        }>;
+        body: string;
+        comment?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    dropStoredProcedure(params: {
+        procedure_name: string;
+        if_exists?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        message?: string;
+        error?: string;
+    }>;
+    showCreateProcedure(params: {
+        procedure_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    getFeatureStatus(): {
+        status: string;
+        data: {
+            enabledCategories: import("./config/featureConfig").ToolCategory[];
+            categoryStatus: Record<import("./config/featureConfig").ToolCategory, boolean>;
+        };
+    };
+    close(): Promise<void>;
+}
+export default MySQLMCP;

package/dist/index.js

@@ -0,0 +1,273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLMCP = void 0;
+const databaseTools_1 = require("./tools/databaseTools");
+const crudTools_1 = require("./tools/crudTools");
+const queryTools_1 = require("./tools/queryTools");
+const utilityTools_1 = require("./tools/utilityTools");
+const ddlTools_1 = require("./tools/ddlTools");
+const transactionTools_1 = require("./tools/transactionTools");
+const storedProcedureTools_1 = require("./tools/storedProcedureTools");
+const securityLayer_1 = __importDefault(require("./security/securityLayer"));
+const connection_1 = __importDefault(require("./db/connection"));
+const featureConfig_1 = require("./config/featureConfig");
+/**
+ * MySQL Model Context Protocol (MCP)
+ * A secure interface for AI models to interact with MySQL databases
+ */
+class MySQLMCP {
+    constructor(permissionsConfig) {
+        this.featureConfig = new featureConfig_1.FeatureConfig(permissionsConfig);
+        this.security = new securityLayer_1.default(this.featureConfig);
+        this.dbTools = new databaseTools_1.DatabaseTools();
+        this.crudTools = new crudTools_1.CrudTools(this.security);
+        this.queryTools = new queryTools_1.QueryTools(this.security);
+        this.utilityTools = new utilityTools_1.UtilityTools();
+        this.ddlTools = new ddlTools_1.DdlTools();
+        this.transactionTools = new transactionTools_1.TransactionTools();
+        this.storedProcedureTools = new storedProcedureTools_1.StoredProcedureTools(this.security);
+    }
+    // Helper method to check if tool is enabled
+    checkToolEnabled(toolName) {
+        if (!this.featureConfig.isToolEnabled(toolName)) {
+            return {
+                enabled: false,
+                error: `Tool '${toolName}' is disabled in the current configuration. Enabled categories: ${this.featureConfig.getEnabledCategories().join(', ')}`
+            };
+        }
+        return { enabled: true };
+    }
+    // Database Tools
+    async listDatabases() {
+        const check = this.checkToolEnabled('listDatabases');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.dbTools.listDatabases();
+    }
+    async listTables(params) {
+        const check = this.checkToolEnabled('listTables');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.dbTools.listTables(params);
+    }
+    async readTableSchema(params) {
+        const check = this.checkToolEnabled('readTableSchema');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.dbTools.readTableSchema(params);
+    }
+    // CRUD Tools
+    async createRecord(params) {
+        const check = this.checkToolEnabled('createRecord');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.crudTools.createRecord(params);
+    }
+    async readRecords(params) {
+        const check = this.checkToolEnabled('readRecords');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.crudTools.readRecords(params);
+    }
+    async updateRecord(params) {
+        const check = this.checkToolEnabled('updateRecord');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.crudTools.updateRecord(params);
+    }
+    async deleteRecord(params) {
+        const check = this.checkToolEnabled('deleteRecord');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.crudTools.deleteRecord(params);
+    }
+    // Query Tools
+    async runQuery(params) {
+        const check = this.checkToolEnabled('runQuery');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        // Additional security check
+        if (!this.security.isReadOnlyQuery(params.query)) {
+            return {
+                status: 'error',
+                error: 'Only SELECT queries are allowed with runQuery. Use executeSql for other operations.'
+            };
+        }
+        return await this.queryTools.runQuery(params);
+    }
+    async executeSql(params) {
+        const check = this.checkToolEnabled('executeSql');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        // Additional security check - block DDL unless DDL permission is enabled
+        if (this.security.hasDangerousOperations(params.query)) {
+            // Check if DDL permission is enabled
+            if (!this.featureConfig.isCategoryEnabled('ddl')) {
+                return {
+                    status: 'error',
+                    error: 'DDL operations (DROP, TRUNCATE, ALTER, CREATE) require the "ddl" permission. Use executeDdl tool or add "ddl" to permissions.'
+                };
+            }
+        }
+        return await this.queryTools.executeSql(params);
+    }
+    // DDL Tools
+    async createTable(params) {
+        const check = this.checkToolEnabled('createTable');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.ddlTools.createTable(params);
+    }
+    async alterTable(params) {
+        const check = this.checkToolEnabled('alterTable');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.ddlTools.alterTable(params);
+    }
+    async dropTable(params) {
+        const check = this.checkToolEnabled('dropTable');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.ddlTools.dropTable(params);
+    }
+    async executeDdl(params) {
+        const check = this.checkToolEnabled('executeDdl');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.ddlTools.executeDdl(params);
+    }
+    // Utility Tools
+    async describeConnection() {
+        const check = this.checkToolEnabled('describeConnection');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.utilityTools.describeConnection();
+    }
+    async testConnection() {
+        const check = this.checkToolEnabled('testConnection');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.utilityTools.testConnection();
+    }
+    async getTableRelationships(params) {
+        const check = this.checkToolEnabled('getTableRelationships');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.utilityTools.getTableRelationships(params);
+    }
+    // Transaction Tools
+    async beginTransaction(params) {
+        const check = this.checkToolEnabled('beginTransaction');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.transactionTools.beginTransaction(params);
+    }
+    async commitTransaction(params) {
+        const check = this.checkToolEnabled('commitTransaction');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.transactionTools.commitTransaction(params);
+    }
+    async rollbackTransaction(params) {
+        const check = this.checkToolEnabled('rollbackTransaction');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.transactionTools.rollbackTransaction(params);
+    }
+    async getTransactionStatus() {
+        const check = this.checkToolEnabled('getTransactionStatus');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.transactionTools.getTransactionStatus();
+    }
+    async executeInTransaction(params) {
+        const check = this.checkToolEnabled('executeSql'); // Use executeSql permission for transaction queries
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.transactionTools.executeInTransaction(params);
+    }
+    // Stored Procedure Tools
+    async listStoredProcedures(params) {
+        const check = this.checkToolEnabled('listStoredProcedures');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.storedProcedureTools.listStoredProcedures(params);
+    }
+    async getStoredProcedureInfo(params) {
+        const check = this.checkToolEnabled('getStoredProcedureInfo');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.storedProcedureTools.getStoredProcedureInfo(params);
+    }
+    async executeStoredProcedure(params) {
+        const check = this.checkToolEnabled('executeStoredProcedure');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.storedProcedureTools.executeStoredProcedure(params);
+    }
+    async createStoredProcedure(params) {
+        const check = this.checkToolEnabled('createStoredProcedure');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.storedProcedureTools.createStoredProcedure(params);
+    }
+    async dropStoredProcedure(params) {
+        const check = this.checkToolEnabled('dropStoredProcedure');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.storedProcedureTools.dropStoredProcedure(params);
+    }
+    async showCreateProcedure(params) {
+        const check = this.checkToolEnabled('showCreateProcedure');
+        if (!check.enabled) {
+            return { status: 'error', error: check.error };
+        }
+        return await this.storedProcedureTools.showCreateProcedure(params);
+    }
+    // Get feature configuration status
+    getFeatureStatus() {
+        return {
+            status: 'success',
+            data: {
+                enabledCategories: this.featureConfig.getEnabledCategories(),
+                categoryStatus: this.featureConfig.getCategoryStatus()
+            }
+        };
+    }
+    // Close database connection
+    async close() {
+        const db = connection_1.default.getInstance();
+        await db.closePool();
+    }
+}
+exports.MySQLMCP = MySQLMCP;
+exports.default = MySQLMCP;

package/dist/mcp-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};