@cainli/mcp-server-mysql 2.0.8

package/dist/src/db/index.js

@@ -0,0 +1,267 @@
+import { performance } from "perf_hooks";
+import { isMultiDbMode } from "./../config/index.js";
+import { isDDLAllowedForSchema, isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, } from "./permissions.js";
+import { extractSchemaFromQuery, getQueryTypes } from "./utils.js";
+import * as mysql2 from "mysql2/promise";
+import { log } from "./../utils/index.js";
+import { mcpConfig as config, MYSQL_DISABLE_READ_ONLY_TRANSACTIONS } from "./../config/index.js";
+if (isMultiDbMode && process.env.MULTI_DB_WRITE_MODE !== "true") {
+    log("error", "Multi-DB mode detected - enabling read-only mode for safety");
+}
+const isTestEnvironment = process.env.NODE_ENV === "test" || process.env.VITEST;
+function safeExit(code) {
+    if (!isTestEnvironment) {
+        process.exit(code);
+    }
+    else {
+        log("error", `[Test mode] Would have called process.exit(${code})`);
+    }
+}
+let poolPromise;
+const getPool = () => {
+    if (!poolPromise) {
+        poolPromise = new Promise((resolve, reject) => {
+            try {
+                const pool = mysql2.createPool(config.mysql);
+                log("info", "MySQL pool created successfully");
+                resolve(pool);
+            }
+            catch (error) {
+                log("error", "Error creating MySQL pool:", error);
+                reject(error);
+            }
+        });
+    }
+    return poolPromise;
+};
+async function executeQuery(sql, params = []) {
+    let connection;
+    try {
+        const pool = await getPool();
+        connection = await pool.getConnection();
+        const result = await connection.query(sql, params);
+        return (Array.isArray(result) ? result[0] : result);
+    }
+    catch (error) {
+        log("error", "Error executing query:", error);
+        throw error;
+    }
+    finally {
+        if (connection) {
+            connection.release();
+            log("error", "Connection released");
+        }
+    }
+}
+async function executeWriteQuery(sql) {
+    let connection;
+    try {
+        const pool = await getPool();
+        connection = await pool.getConnection();
+        log("error", "Write connection acquired");
+        const schema = extractSchemaFromQuery(sql);
+        await connection.beginTransaction();
+        try {
+            const startTime = performance.now();
+            const result = await connection.query(sql);
+            const endTime = performance.now();
+            const duration = endTime - startTime;
+            const response = Array.isArray(result) ? result[0] : result;
+            await connection.commit();
+            let responseText;
+            const queryTypes = await getQueryTypes(sql);
+            const isUpdateOperation = queryTypes.some((type) => ["update"].includes(type));
+            const isInsertOperation = queryTypes.some((type) => ["insert"].includes(type));
+            const isDeleteOperation = queryTypes.some((type) => ["delete"].includes(type));
+            const isDDLOperation = queryTypes.some((type) => ["create", "alter", "drop", "truncate"].includes(type));
+            if (isInsertOperation) {
+                const resultHeader = response;
+                responseText = `Insert successful on schema '${schema || "default"}'. Affected rows: ${resultHeader.affectedRows}, Last insert ID: ${resultHeader.insertId}`;
+            }
+            else if (isUpdateOperation) {
+                const resultHeader = response;
+                responseText = `Update successful on schema '${schema || "default"}'. Affected rows: ${resultHeader.affectedRows}, Changed rows: ${resultHeader.changedRows || 0}`;
+            }
+            else if (isDeleteOperation) {
+                const resultHeader = response;
+                responseText = `Delete successful on schema '${schema || "default"}'. Affected rows: ${resultHeader.affectedRows}`;
+            }
+            else if (isDDLOperation) {
+                responseText = `DDL operation successful on schema '${schema || "default"}'.`;
+            }
+            else {
+                responseText = JSON.stringify(response, null, 2);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                    {
+                        type: "text",
+                        text: `Query execution time: ${duration.toFixed(2)} ms`,
+                    },
+                ],
+                isError: false,
+            };
+        }
+        catch (error) {
+            log("error", "Error executing write query:", error);
+            await connection.rollback();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error executing write operation: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        log("error", "Error in write operation transaction:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Database connection error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    finally {
+        if (connection) {
+            connection.release();
+            log("error", "Write connection released");
+        }
+    }
+}
+async function executeReadOnlyQuery(sql) {
+    let connection;
+    try {
+        const queryTypes = await getQueryTypes(sql);
+        const schema = extractSchemaFromQuery(sql);
+        const isUpdateOperation = queryTypes.some((type) => ["update"].includes(type));
+        const isInsertOperation = queryTypes.some((type) => ["insert"].includes(type));
+        const isDeleteOperation = queryTypes.some((type) => ["delete"].includes(type));
+        const isDDLOperation = queryTypes.some((type) => ["create", "alter", "drop", "truncate"].includes(type));
+        if (isInsertOperation && !isInsertAllowedForSchema(schema)) {
+            log("error", `INSERT operations are not allowed for schema '${schema || "default"}'. Configure SCHEMA_INSERT_PERMISSIONS.`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: INSERT operations are not allowed for schema '${schema || "default"}'. Ask the administrator to update SCHEMA_INSERT_PERMISSIONS.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (isUpdateOperation && !isUpdateAllowedForSchema(schema)) {
+            log("error", `UPDATE operations are not allowed for schema '${schema || "default"}'. Configure SCHEMA_UPDATE_PERMISSIONS.`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: UPDATE operations are not allowed for schema '${schema || "default"}'. Ask the administrator to update SCHEMA_UPDATE_PERMISSIONS.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (isDeleteOperation && !isDeleteAllowedForSchema(schema)) {
+            log("error", `DELETE operations are not allowed for schema '${schema || "default"}'. Configure SCHEMA_DELETE_PERMISSIONS.`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: DELETE operations are not allowed for schema '${schema || "default"}'. Ask the administrator to update SCHEMA_DELETE_PERMISSIONS.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (isDDLOperation && !isDDLAllowedForSchema(schema)) {
+            log("error", `DDL operations are not allowed for schema '${schema || "default"}'. Configure SCHEMA_DDL_PERMISSIONS.`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: DDL operations are not allowed for schema '${schema || "default"}'. Ask the administrator to update SCHEMA_DDL_PERMISSIONS.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if ((isInsertOperation && isInsertAllowedForSchema(schema)) ||
+            (isUpdateOperation && isUpdateAllowedForSchema(schema)) ||
+            (isDeleteOperation && isDeleteAllowedForSchema(schema)) ||
+            (isDDLOperation && isDDLAllowedForSchema(schema))) {
+            return executeWriteQuery(sql);
+        }
+        const pool = await getPool();
+        connection = await pool.getConnection();
+        log("error", "Read-only connection acquired");
+        if (!MYSQL_DISABLE_READ_ONLY_TRANSACTIONS) {
+            await connection.query("SET SESSION TRANSACTION READ ONLY");
+        }
+        else {
+            log("info", "Read-only transactions disabled via MYSQL_DISABLE_READ_ONLY_TRANSACTIONS=true");
+        }
+        await connection.beginTransaction();
+        try {
+            const startTime = performance.now();
+            const result = await connection.query(sql);
+            const endTime = performance.now();
+            const duration = endTime - startTime;
+            const rows = Array.isArray(result) ? result[0] : result;
+            await connection.rollback();
+            if (!MYSQL_DISABLE_READ_ONLY_TRANSACTIONS) {
+                await connection.query("SET SESSION TRANSACTION READ WRITE");
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(rows, null, 2),
+                    },
+                    {
+                        type: "text",
+                        text: `Query execution time: ${duration.toFixed(2)} ms`,
+                    },
+                ],
+                isError: false,
+            };
+        }
+        catch (error) {
+            log("error", "Error executing read-only query:", error);
+            await connection.rollback();
+            throw error;
+        }
+    }
+    catch (error) {
+        log("error", "Error in read-only query transaction:", error);
+        try {
+            if (connection) {
+                await connection.rollback();
+                if (!MYSQL_DISABLE_READ_ONLY_TRANSACTIONS) {
+                    await connection.query("SET SESSION TRANSACTION READ WRITE");
+                }
+            }
+        }
+        catch (cleanupError) {
+            log("error", "Error during cleanup:", cleanupError);
+        }
+        throw error;
+    }
+    finally {
+        if (connection) {
+            connection.release();
+            log("error", "Read-only connection released");
+        }
+    }
+}
+export { isTestEnvironment, safeExit, executeQuery, getPool, executeWriteQuery, executeReadOnlyQuery, poolPromise, };

package/dist/src/db/permissions.js

@@ -0,0 +1,34 @@
+import { ALLOW_DELETE_OPERATION, ALLOW_DDL_OPERATION, ALLOW_INSERT_OPERATION, ALLOW_UPDATE_OPERATION, SCHEMA_DELETE_PERMISSIONS, SCHEMA_DDL_PERMISSIONS, SCHEMA_INSERT_PERMISSIONS, SCHEMA_UPDATE_PERMISSIONS, } from "../config/index.js";
+function isInsertAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_INSERT_OPERATION;
+    }
+    return schema in SCHEMA_INSERT_PERMISSIONS
+        ? SCHEMA_INSERT_PERMISSIONS[schema]
+        : ALLOW_INSERT_OPERATION;
+}
+function isUpdateAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_UPDATE_OPERATION;
+    }
+    return schema in SCHEMA_UPDATE_PERMISSIONS
+        ? SCHEMA_UPDATE_PERMISSIONS[schema]
+        : ALLOW_UPDATE_OPERATION;
+}
+function isDeleteAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_DELETE_OPERATION;
+    }
+    return schema in SCHEMA_DELETE_PERMISSIONS
+        ? SCHEMA_DELETE_PERMISSIONS[schema]
+        : ALLOW_DELETE_OPERATION;
+}
+function isDDLAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_DDL_OPERATION;
+    }
+    return schema in SCHEMA_DDL_PERMISSIONS
+        ? SCHEMA_DDL_PERMISSIONS[schema]
+        : ALLOW_DDL_OPERATION;
+}
+export { isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, isDDLAllowedForSchema, };

package/dist/src/db/utils.js

@@ -0,0 +1,34 @@
+import { isMultiDbMode } from "./../config/index.js";
+import { log } from "./../utils/index.js";
+import SqlParser from "node-sql-parser";
+const { Parser } = SqlParser;
+const parser = new Parser();
+function extractSchemaFromQuery(sql) {
+    const defaultSchema = process.env.MYSQL_DB || null;
+    if (defaultSchema && !isMultiDbMode) {
+        return defaultSchema;
+    }
+    const useMatch = sql.match(/USE\s+`?([a-zA-Z0-9_]+)`?/i);
+    if (useMatch && useMatch[1]) {
+        return useMatch[1];
+    }
+    const dbTableMatch = sql.match(/`?([a-zA-Z0-9_]+)`?\.`?[a-zA-Z0-9_]+`?/i);
+    if (dbTableMatch && dbTableMatch[1]) {
+        return dbTableMatch[1];
+    }
+    return defaultSchema;
+}
+async function getQueryTypes(query) {
+    try {
+        log("info", "Parsing SQL query: ", query);
+        const astOrArray = parser.astify(query, { database: "mysql" });
+        const statements = Array.isArray(astOrArray) ? astOrArray : [astOrArray];
+        return statements.map((stmt) => stmt.type?.toLowerCase() ?? "unknown");
+    }
+    catch (err) {
+        log("error", "sqlParser error, query: ", query);
+        log("error", "Error parsing SQL query:", err);
+        throw new Error(`Parsing failed: ${err.message}`);
+    }
+}
+export { extractSchemaFromQuery, getQueryTypes };

package/dist/src/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/index.js

@@ -0,0 +1,123 @@
+const ENABLE_LOGGING = process.env.ENABLE_LOGGING === "true" || process.env.ENABLE_LOGGING === "1";
+export function log(type = "info", ...args) {
+    if (!ENABLE_LOGGING)
+        return;
+    switch (type) {
+        case "info":
+            console.info(...args);
+            break;
+        case "error":
+            console.error(...args);
+            break;
+        default:
+            console.log(...args);
+    }
+}
+export function parseSchemaPermissions(permissionsString) {
+    const permissions = {};
+    if (!permissionsString) {
+        return permissions;
+    }
+    const permissionPairs = permissionsString.split(",");
+    for (const pair of permissionPairs) {
+        const [schema, value] = pair.split(":");
+        if (schema && value) {
+            permissions[schema.trim()] = value.trim() === "true";
+        }
+    }
+    return permissions;
+}
+export function parseMySQLConnectionString(connectionString) {
+    const config = {};
+    let cleanedString = connectionString.trim().replace(/^mysql\s+/, '');
+    const tokens = [];
+    let currentToken = '';
+    let inQuotes = false;
+    let quoteChar = null;
+    for (let i = 0; i < cleanedString.length; i++) {
+        const char = cleanedString[i];
+        if ((char === '"' || char === "'") && (!inQuotes || char === quoteChar)) {
+            inQuotes = !inQuotes;
+            quoteChar = inQuotes ? char : null;
+        }
+        else if (char === ' ' && !inQuotes) {
+            if (currentToken) {
+                tokens.push(currentToken);
+                currentToken = '';
+            }
+        }
+        else {
+            currentToken += char;
+        }
+    }
+    if (currentToken) {
+        tokens.push(currentToken);
+    }
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.startsWith('-') && !token.startsWith('--')) {
+            const flag = token[1];
+            let value = token.substring(2);
+            if (!value && i + 1 < tokens.length && !tokens[i + 1].startsWith('-')) {
+                value = tokens[i + 1];
+                i++;
+            }
+            switch (flag) {
+                case 'h':
+                    config.host = value;
+                    break;
+                case 'P': {
+                    const port = parseInt(value, 10);
+                    if (Number.isNaN(port) || !Number.isFinite(port) || port < 1 || port > 65535) {
+                        throw new Error(`Invalid port: ${value}`);
+                    }
+                    config.port = port;
+                    break;
+                }
+                case 'u':
+                    config.user = value;
+                    break;
+                case 'p':
+                    config.password = value;
+                    break;
+                case 'S':
+                    config.socketPath = value;
+                    break;
+            }
+        }
+        else if (token.startsWith('--')) {
+            const [flag, ...valueParts] = token.substring(2).split('=');
+            let value = valueParts.join('=');
+            if (!value && i + 1 < tokens.length && !tokens[i + 1].startsWith('-')) {
+                value = tokens[i + 1];
+                i++;
+            }
+            switch (flag) {
+                case 'host':
+                    config.host = value;
+                    break;
+                case 'port': {
+                    const port = parseInt(value, 10);
+                    if (Number.isNaN(port) || !Number.isFinite(port) || port < 1 || port > 65535) {
+                        throw new Error(`Invalid port: ${value}`);
+                    }
+                    config.port = port;
+                    break;
+                }
+                case 'user':
+                    config.user = value;
+                    break;
+                case 'password':
+                    config.password = value;
+                    break;
+                case 'socket':
+                    config.socketPath = value;
+                    break;
+            }
+        }
+        else if (!token.startsWith('-')) {
+            config.database = token;
+        }
+    }
+    return config;
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@cainli/mcp-server-mysql",
+  "version": "2.0.8",
+  "description": "MCP server for interacting with MySQL databases with write operations support",
+  "license": "MIT",
+  "author": "cainli (https://github.com/cainli)",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "index.ts",
+  "preferGlobal": true,
+  "bin": {
+    "mcp-server-mysql": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "assets"
+  ],
+  "scripts": {
+    "start": "node dist/index.js",
+    "dev": "ts-node index.ts",
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "setup:test:db": "tsx scripts/setup-test-db.ts",
+    "pretest": "pnpm run setup:test:db",
+    "test": "pnpm run setup:test:db && vitest run",
+    "test:socket": "pnpm run setup:test:db && vitest run tests/integration/socket-connection.test.ts",
+    "test:watch": "pnpm run setup:test:db && vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run --config vitest.unit.config.ts",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "stdio": "node dist/index.js --stdio",
+    "exec": " pnpm build && npx node --env-file=.env dist/index.js",
+    "lint": "npm run lint:eslint && npm run lint:markdown",
+    "lint:eslint": "eslint .",
+    "lint:markdown": "markdownlint .",
+    "lint:fix": "npm run lint:eslint:fix && npm run lint:markdown:fix",
+    "lint:eslint:fix": "eslint . --fix",
+    "lint:markdown:fix": "markdownlint . --fix"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^1.3.22",
+    "@modelcontextprotocol/sdk": "1.15.1",
+    "dotenv": "^16.5.0",
+    "express": "^5.1.0",
+    "mcp-evals": "^1.0.18",
+    "mysql2": "^3.14.1",
+    "node-sql-parser": "^5.3.9",
+    "zod": "^3.25.67"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.35.0",
+    "@typescript-eslint/parser": "^8.35.0",
+    "eslint": "^9.27.0",
+    "markdownlint-cli": "^0.45.0",
+    "shx": "^0.3.4",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "vitest": "^1.6.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "node",
+    "mcp",
+    "ai",
+    "cursor",
+    "mcp-server",
+    "modelcontextprotocol",
+    "smithery",
+    "mcp-get",
+    "mcp-put",
+    "mcp-post",
+    "mcp-delete",
+    "mcp-patch",
+    "mcp-options",
+    "mcp-head"
+  ]
+}