@dexical30/mcp-server-mysql 2.1.0 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexical30/mcp-server-mysql",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "MCP server for interacting with MySQL databases with write operations support",
   "license": "MIT",
   "author": "Ben Borla (https://github.com/benborla)",
@@ -21,9 +21,9 @@
   "scripts": {
     "start": "node dist/index.js",
     "dev": "ts-node index.ts",
-    "build": "tsc && shx chmod +x dist/*.js",
+    "build": "tsc --noEmit && node scripts/build.mjs",
     "prepare": "npm run build",
-    "watch": "tsc --watch",
+    "watch": "tsc --noEmit --watch",
     "setup:test:db": "tsx scripts/setup-test-db.ts",
     "pretest": "pnpm run setup:test:db",
     "test": "pnpm run setup:test:db && vitest run",
@@ -42,30 +42,26 @@
     "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"
+    "@modelcontextprotocol/sdk": "1.32.2",
+    "@types/express": "5.0.6",
+    "@types/jest": "29.5.14",
+    "@types/node": "20.19.43",
+    "@typescript-eslint/eslint-plugin": "8.72.1",
+    "@typescript-eslint/parser": "8.72.1",
+    "dotenv": "16.6.1",
+    "esbuild": "0.28.2",
+    "eslint": "9.39.5",
+    "express": "5.3.0",
+    "markdownlint-cli": "0.45.0",
+    "mysql2": "3.24.6",
+    "node-sql-parser": "5.4.0",
+    "ts-node": "10.9.2",
+    "tslib": "2.8.1",
+    "tsx": "4.23.15",
+    "typescript": "5.9.3",
+    "vitest": "1.6.1",
+    "zod": "4.6.7"
   },
   "publishConfig": {
     "access": "public"

package/dist/evals.js

@@ -1,32 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { grade } from "mcp-evals";
-const mysqlQueryToolEval = {
-    name: 'mysql_query Tool Evaluation',
-    description: 'Evaluates the MySQL query execution functionality',
-    run: async () => {
-        const result = await grade(openai("gpt-4"), "Please execute the following SQL query and return the results: SELECT * FROM employees WHERE status='ACTIVE';");
-        return JSON.parse(result);
-    }
-};
-const mysqlQueryGenerationEval = {
-    name: 'mysql_query Tool Generation Evaluation',
-    description: 'Evaluates the MySQL query tool for correct SQL generation and execution',
-    run: async () => {
-        const result = await grade(openai("gpt-4"), "Use the mysql_query tool to select all rows from the 'users' table where isActive = 1. Provide the SQL query in the correct format.");
-        return JSON.parse(result);
-    }
-};
-const mysqlQueryColumnsEval = {
-    name: 'mysql_query Columns Evaluation',
-    description: 'Evaluates the mysql_query tool for column selection',
-    run: async () => {
-        const result = await grade(openai("gpt-4"), "Please provide a SQL query to retrieve the id, name, and email columns for all records in the users table.");
-        return JSON.parse(result);
-    }
-};
-const config = {
-    model: openai("gpt-4"),
-    evals: [mysqlQueryToolEval, mysqlQueryGenerationEval, mysqlQueryColumnsEval]
-};
-export default config;
-export const evals = [mysqlQueryToolEval, mysqlQueryGenerationEval, mysqlQueryColumnsEval];

package/dist/src/config/index.js

@@ -1,166 +0,0 @@
-import * as dotenv from "dotenv";
-import * as fs from "fs";
-import { execFileSync } from "child_process";
-import { parseSchemaPermissions, parseMySQLConnectionString } from "../utils/index.js";
-function readSSLFile(filePath, label) {
-    try {
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`SSL ${label} file not found: ${filePath}`);
-        }
-        const data = fs.readFileSync(filePath);
-        if (data.length === 0) {
-            throw new Error(`SSL ${label} file is empty: ${filePath}`);
-        }
-        return data;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            if (error.message.startsWith('SSL ')) {
-                throw error;
-            }
-            throw new Error(`Failed to read SSL ${label}: ${error.message}`);
-        }
-        throw error;
-    }
-}
-function readCACertificate(filePath) {
-    return readSSLFile(filePath, 'CA certificate');
-}
-function readPasswordFromOp(reference, opBin = "op") {
-    if (!reference.startsWith("op://")) {
-        throw new Error(`1Password secret reference must start with op://, got: ${reference}`);
-    }
-    try {
-        return execFileSync(opBin, ["read", "--no-newline", reference], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-            timeout: 60000,
-        });
-    }
-    catch (error) {
-        const err = error;
-        const detail = err.stderr?.trim() || err.message;
-        throw new Error(`Failed to read MySQL password from 1Password (${reference}): ${detail}`);
-    }
-}
-export const MCP_VERSION = "2.1.0";
-dotenv.config();
-const connectionStringConfig = process.env.MYSQL_CONNECTION_STRING
-    ? parseMySQLConnectionString(process.env.MYSQL_CONNECTION_STRING)
-    : {};
-const rawMysqlPass = process.env.MYSQL_PASS ?? "";
-const mysqlPassword = connectionStringConfig.password !== undefined
-    ? connectionStringConfig.password
-    : rawMysqlPass.startsWith("op://")
-        ? readPasswordFromOp(rawMysqlPass, process.env.MYSQL_OP_PATH || "op")
-        : rawMysqlPass;
-if (process.env.NODE_ENV === "test" && !process.env.MYSQL_DB) {
-    process.env.MYSQL_DB = "mcp_test_db";
-}
-export const ALLOW_INSERT_OPERATION = process.env.ALLOW_INSERT_OPERATION === "true";
-export const ALLOW_UPDATE_OPERATION = process.env.ALLOW_UPDATE_OPERATION === "true";
-export const ALLOW_DELETE_OPERATION = process.env.ALLOW_DELETE_OPERATION === "true";
-export const ALLOW_DDL_OPERATION = process.env.ALLOW_DDL_OPERATION === "true";
-export const MYSQL_DISABLE_READ_ONLY_TRANSACTIONS = process.env.MYSQL_DISABLE_READ_ONLY_TRANSACTIONS === "true";
-export const ENABLE_PII_REDACTION = process.env.ENABLE_PII_REDACTION === "true";
-export const PII_EXTRA_COLUMNS = (process.env.PII_EXTRA_COLUMNS ?? "")
-    .split(",")
-    .map((s) => s.trim().toLowerCase())
-    .filter((s) => s.length > 0);
-function parseColumnPatterns(raw) {
-    if (!raw)
-        return [];
-    const out = [];
-    for (const entry of raw.split(";")) {
-        const trimmed = entry.trim();
-        if (!trimmed)
-            continue;
-        try {
-            out.push(new RegExp(trimmed, "i"));
-        }
-        catch (err) {
-            console.error(`[config] ignoring invalid PII_EXTRA_COLUMN_PATTERNS entry "${trimmed}": ${err.message}`);
-        }
-    }
-    return out;
-}
-export const PII_EXTRA_COLUMN_PATTERNS = parseColumnPatterns(process.env.PII_EXTRA_COLUMN_PATTERNS);
-export const PII_REDACT_JSON_STRINGS = process.env.PII_REDACT_JSON_STRINGS !== "false";
-export const PII_ALLOW_SELECT_STAR = process.env.PII_ALLOW_SELECT_STAR === "true";
-export const PII_ALLOW_REFERENCES = process.env.PII_ALLOW_REFERENCES === "true";
-export const PII_ALLOW_INTROSPECTION = process.env.PII_ALLOW_INTROSPECTION === "true";
-export const PII_BLOCK_INTROSPECTION = process.env.PII_BLOCK_INTROSPECTION === "true";
-export const SCHEMA_INSERT_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_INSERT_PERMISSIONS);
-export const SCHEMA_UPDATE_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_UPDATE_PERMISSIONS);
-export const SCHEMA_DELETE_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_DELETE_PERMISSIONS);
-export const SCHEMA_DDL_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_DDL_PERMISSIONS);
-export const IS_REMOTE_MCP = process.env.IS_REMOTE_MCP === "true";
-export const REMOTE_SECRET_KEY = process.env.REMOTE_SECRET_KEY || "";
-export const PORT = process.env.PORT || 3000;
-const dbFromEnvOrConnString = connectionStringConfig.database || process.env.MYSQL_DB;
-export const isMultiDbMode = !dbFromEnvOrConnString || dbFromEnvOrConnString.trim() === "";
-export const mcpConfig = {
-    server: {
-        name: "@dexical30/mcp-server-mysql",
-        version: MCP_VERSION,
-        connectionTypes: ["stdio", "streamableHttp"],
-    },
-    mysql: {
-        ...(connectionStringConfig.socketPath || process.env.MYSQL_SOCKET_PATH
-            ? {
-                socketPath: connectionStringConfig.socketPath || process.env.MYSQL_SOCKET_PATH,
-            }
-            : {
-                host: connectionStringConfig.host || process.env.MYSQL_HOST || "127.0.0.1",
-                port: connectionStringConfig.port || Number(process.env.MYSQL_PORT || "3306"),
-            }),
-        user: connectionStringConfig.user || process.env.MYSQL_USER || "root",
-        password: mysqlPassword,
-        database: connectionStringConfig.database || process.env.MYSQL_DB || undefined,
-        connectionLimit: 10,
-        waitForConnections: true,
-        queueLimit: process.env.MYSQL_QUEUE_LIMIT ? parseInt(process.env.MYSQL_QUEUE_LIMIT, 10) : 100,
-        enableKeepAlive: true,
-        keepAliveInitialDelay: 0,
-        connectTimeout: process.env.MYSQL_CONNECT_TIMEOUT ? parseInt(process.env.MYSQL_CONNECT_TIMEOUT, 10) : 10000,
-        authPlugins: {
-            mysql_clear_password: () => () => Buffer.from(mysqlPassword),
-        },
-        ...(process.env.MYSQL_SSL === "true"
-            ? {
-                ssl: {
-                    rejectUnauthorized: process.env.MYSQL_SSL_REJECT_UNAUTHORIZED === "true",
-                    ...(process.env.MYSQL_SSL_CA
-                        ? { ca: readCACertificate(process.env.MYSQL_SSL_CA) }
-                        : {}),
-                    ...(process.env.MYSQL_SSL_CERT
-                        ? { cert: readSSLFile(process.env.MYSQL_SSL_CERT, 'client certificate') }
-                        : {}),
-                    ...(process.env.MYSQL_SSL_KEY
-                        ? { key: readSSLFile(process.env.MYSQL_SSL_KEY, 'client private key') }
-                        : {}),
-                },
-            }
-            : {}),
-        ...(process.env.MYSQL_TIMEZONE
-            ? {
-                timezone: process.env.MYSQL_TIMEZONE,
-            }
-            : {}),
-        ...(process.env.MYSQL_DATE_STRINGS === "true"
-            ? {
-                dateStrings: true,
-            }
-            : {}),
-        ...(process.env.MYSQL_BIG_NUMBER_STRINGS === "true"
-            ? {
-                supportBigNumbers: true,
-                bigNumberStrings: true,
-            }
-            : {}),
-    },
-    paths: {
-        schema: "schema",
-    },
-};
-export { readCACertificate, readSSLFile, readPasswordFromOp };

package/dist/src/db/index.js

@@ -1,375 +0,0 @@
-import { performance } from "perf_hooks";
-import { isMultiDbMode } from "./../config/index.js";
-import { isDDLAllowedForSchema, isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, } from "./permissions.js";
-import { extractSchemaFromQuery, getQueryTypes, containsSelectStar, findPIIColumnReferences, isIntrospectionQuery, } from "./utils.js";
-import * as mysql2 from "mysql2/promise";
-import { log } from "./../utils/index.js";
-import { mcpConfig as config, MYSQL_DISABLE_READ_ONLY_TRANSACTIONS, ENABLE_PII_REDACTION, PII_EXTRA_COLUMNS, PII_EXTRA_COLUMN_PATTERNS, PII_REDACT_JSON_STRINGS, PII_ALLOW_SELECT_STAR, PII_ALLOW_REFERENCES, PII_ALLOW_INTROSPECTION, PII_BLOCK_INTROSPECTION, } from "./../config/index.js";
-import { redactPII, isPIIColumn, DEFAULT_PII_COLUMNS, filterIntrospectionRows, } from "./../security/redact.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 {
-        if (ENABLE_PII_REDACTION &&
-            !PII_ALLOW_SELECT_STAR &&
-            containsSelectStar(sql)) {
-            log("error", "Refusing query with SELECT * while PII redaction is enabled; project explicit columns instead.");
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: SELECT * (and `table.*`) is not permitted while PII redaction is enabled. " +
-                            "Project an explicit column list (e.g. SELECT col1, col2 FROM ...) so redacted columns are not accidentally returned. " +
-                            "Set PII_ALLOW_SELECT_STAR=true to override this policy.",
-                    },
-                ],
-                isError: true,
-            };
-        }
-        let introspectionFilterKind = null;
-        let isIntrospectionPassThrough = false;
-        if (ENABLE_PII_REDACTION && !PII_ALLOW_INTROSPECTION) {
-            const intro = isIntrospectionQuery(sql);
-            if (intro.kind) {
-                const filterable = intro.kind === "show_columns" ||
-                    intro.kind === "describe" ||
-                    intro.kind === "show_index"
-                    ? intro.kind
-                    : null;
-                const passthrough = intro.kind === "show_passthrough";
-                if (PII_BLOCK_INTROSPECTION || (!filterable && !passthrough)) {
-                    log("error", `Refusing introspection query (${intro.kind}) while PII redaction is enabled.`);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Error: SQL introspection (${intro.kind}) is not permitted while PII redaction is enabled. ` +
-                                    `Use the mysql://tables and mysql://tables/{name} MCP resources to inspect schemas (PII columns are filtered there), ` +
-                                    `or use SHOW COLUMNS / DESCRIBE / SHOW INDEX (PII columns will be filtered from the result). ` +
-                                    `Set PII_ALLOW_INTROSPECTION=true to bypass this policy entirely.`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                if (filterable) {
-                    introspectionFilterKind = filterable;
-                }
-                else if (passthrough) {
-                    isIntrospectionPassThrough = true;
-                }
-            }
-        }
-        if (ENABLE_PII_REDACTION && !PII_ALLOW_REFERENCES) {
-            const piiList = [...DEFAULT_PII_COLUMNS, ...PII_EXTRA_COLUMNS];
-            const hits = findPIIColumnReferences(sql, (col) => isPIIColumn(col, piiList, PII_EXTRA_COLUMN_PATTERNS));
-            if (hits.length > 0) {
-                const names = hits
-                    .map((h) => (h.table ? `${h.table}.${h.column}` : h.column))
-                    .join(", ");
-                log("error", `Refusing query referencing redacted column(s): ${names}.`);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error: query references redacted column(s): ${names}. ` +
-                                `These columns are protected by PII redaction policy and cannot be projected, ` +
-                                `filtered, joined, or ordered on. Choose a different projection, ` +
-                                `or set PII_ALLOW_REFERENCES=true to override this policy.`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        }
-        let queryTypes = [];
-        let schema = null;
-        let isUpdateOperation = false;
-        let isInsertOperation = false;
-        let isDeleteOperation = false;
-        let isDDLOperation = false;
-        if (!introspectionFilterKind && !isIntrospectionPassThrough) {
-            queryTypes = await getQueryTypes(sql);
-            schema = extractSchemaFromQuery(sql);
-            isUpdateOperation = queryTypes.some((type) => ["update"].includes(type));
-            isInsertOperation = queryTypes.some((type) => ["insert"].includes(type));
-            isDeleteOperation = queryTypes.some((type) => ["delete"].includes(type));
-            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");
-            }
-            let intermediate = rows;
-            if (introspectionFilterKind) {
-                const piiList = [...DEFAULT_PII_COLUMNS, ...PII_EXTRA_COLUMNS];
-                const filtered = filterIntrospectionRows(rows, introspectionFilterKind, (col) => isPIIColumn(col, piiList, PII_EXTRA_COLUMN_PATTERNS));
-                if (filtered === null) {
-                    log("error", `Refusing introspection result (${introspectionFilterKind}): unrecognised row shape, cannot filter PII safely.`);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Error: could not safely filter introspection result for kind '${introspectionFilterKind}'. ` +
-                                    `Use SHOW COLUMNS / DESCRIBE / SHOW INDEX against a real table, ` +
-                                    `or set PII_ALLOW_INTROSPECTION=true to bypass filtering.`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                intermediate = filtered;
-            }
-            const payload = ENABLE_PII_REDACTION
-                ? redactPII(intermediate, {
-                    extraColumns: PII_EXTRA_COLUMNS,
-                    columnPatterns: PII_EXTRA_COLUMN_PATTERNS,
-                    parseJsonStrings: PII_REDACT_JSON_STRINGS,
-                })
-                : intermediate;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(payload, 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

@@ -1,34 +0,0 @@
-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, };