@berthojoris/mcp-mysql-server 1.16.4 → 1.17.0

package/dist/tools/queryVisualizationTools.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryVisualizationTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+class QueryVisualizationTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    extractExplainNodes(explainJson) {
+        const nodes = [];
+        const visit = (obj) => {
+            if (!obj || typeof obj !== "object")
+                return;
+            if (obj.table && typeof obj.table === "object") {
+                const t = obj.table;
+                nodes.push({
+                    table_name: t.table_name,
+                    access_type: t.access_type,
+                    possible_keys: t.possible_keys,
+                    key: t.key,
+                    rows_examined_per_scan: t.rows_examined_per_scan,
+                    rows_produced_per_join: t.rows_produced_per_join,
+                    filtered: t.filtered,
+                    attached_condition: t.attached_condition,
+                });
+            }
+            for (const v of Object.values(obj)) {
+                if (Array.isArray(v))
+                    v.forEach(visit);
+                else if (v && typeof v === "object")
+                    visit(v);
+            }
+        };
+        visit(explainJson);
+        return nodes;
+    }
+    sqlJoinEdges(query) {
+        const edges = [];
+        const q = query.replace(/\s+/g, " ");
+        // Very lightweight parser: FROM <t> ... JOIN <t2> ON <cond>
+        const fromMatch = q.match(/\bFROM\s+([`"']?\w+[`"']?)(?:\s+AS\s+\w+|\s+\w+)?/i);
+        const base = fromMatch ? fromMatch[1].replace(/[`"']/g, "") : undefined;
+        if (!base)
+            return edges;
+        const joinRegex = /\bJOIN\s+([`"']?\w+[`"']?)(?:\s+AS\s+\w+|\s+\w+)?\s+ON\s+(.+?)(?=\bJOIN\b|\bWHERE\b|\bGROUP\b|\bORDER\b|\bLIMIT\b|$)/gi;
+        let m;
+        let prev = base;
+        while ((m = joinRegex.exec(q))) {
+            const table = m[1].replace(/[`"']/g, "");
+            const on = m[2].trim();
+            edges.push({ from: prev, to: table, on });
+            prev = table;
+        }
+        return edges;
+    }
+    buildMermaid(nodes, edges) {
+        const lines = [];
+        lines.push("graph TD");
+        const uniqTables = Array.from(new Set(nodes.map((n) => n.table_name).filter(Boolean)));
+        const nodeId = (t) => `t_${t.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+        for (const t of uniqTables) {
+            const n = nodes.find((x) => x.table_name === t);
+            const labelParts = [t];
+            if (n?.access_type)
+                labelParts.push(`access=${n.access_type}`);
+            if (n?.key)
+                labelParts.push(`key=${n.key}`);
+            if (typeof n?.rows_examined_per_scan === "number") {
+                labelParts.push(`rows≈${n.rows_examined_per_scan}`);
+            }
+            lines.push(`${nodeId(t)}["${labelParts.join("\\n")}"]`);
+        }
+        if (edges.length) {
+            for (const e of edges) {
+                lines.push(`${nodeId(e.from)} -->|"${(e.on || "").replace(/"/g, "'").slice(0, 60)}"| ${nodeId(e.to)}`);
+            }
+            return lines.join("\n");
+        }
+        // Fallback: join order from EXPLAIN
+        for (let i = 0; i < uniqTables.length - 1; i++) {
+            lines.push(`${nodeId(uniqTables[i])} --> ${nodeId(uniqTables[i + 1])}`);
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Create a lightweight visual representation of a SQL query.
+     * Returns Mermaid flowchart + EXPLAIN FORMAT=JSON summary.
+     */
+    async visualizeQuery(params) {
+        try {
+            const query = params.query;
+            if (!query || typeof query !== "string") {
+                return { status: "error", error: "query is required" };
+            }
+            if (!this.security.isReadOnlyQuery(query)) {
+                return {
+                    status: "error",
+                    error: "Only read-only queries (SELECT/SHOW/DESCRIBE/EXPLAIN) are supported for visualization.",
+                };
+            }
+            const includeExplain = params.include_explain_json ?? true;
+            const format = params.format ?? "both";
+            const explainQuery = `EXPLAIN FORMAT=JSON ${query}`;
+            const explainRows = await this.db.query(explainQuery);
+            let explainJson = null;
+            let queryCost = null;
+            if (explainRows[0] && explainRows[0].EXPLAIN) {
+                try {
+                    explainJson = JSON.parse(explainRows[0].EXPLAIN);
+                    queryCost =
+                        explainJson?.query_block?.cost_info?.query_cost?.toString?.() ?? null;
+                }
+                catch {
+                    explainJson = explainRows;
+                }
+            }
+            const nodes = explainJson ? this.extractExplainNodes(explainJson) : [];
+            const edges = this.sqlJoinEdges(query);
+            const mermaid = this.buildMermaid(nodes, edges);
+            const data = {
+                mermaid,
+                explain_summary: {
+                    query_cost: queryCost,
+                    tables: nodes.map((n) => ({
+                        table_name: n.table_name,
+                        access_type: n.access_type,
+                        key: n.key,
+                        rows_examined_per_scan: n.rows_examined_per_scan,
+                        filtered: n.filtered,
+                    })),
+                },
+            };
+            if (includeExplain)
+                data.explain_json = explainJson;
+            if (format === "mermaid") {
+                return { status: "success", data: { mermaid } };
+            }
+            if (format === "json") {
+                return {
+                    status: "success",
+                    data: { explain_summary: data.explain_summary, explain_json: explainJson },
+                };
+            }
+            return { status: "success", data };
+        }
+        catch (error) {
+            return { status: "error", error: error.message };
+        }
+    }
+}
+exports.QueryVisualizationTools = QueryVisualizationTools;

package/dist/tools/schemaPatternTools.d.ts

@@ -0,0 +1,19 @@
+import { SecurityLayer } from "../security/securityLayer";
+export declare class SchemaPatternTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    private validateDatabaseAccess;
+    /**
+     * Recognize common schema patterns and anti-patterns based on INFORMATION_SCHEMA.
+     */
+    analyzeSchemaPatterns(params?: {
+        scope?: "database" | "table";
+        table_name?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}

package/dist/tools/schemaPatternTools.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaPatternTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+const config_1 = require("../config/config");
+class SchemaPatternTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    validateDatabaseAccess(requestedDatabase) {
+        const connectedDatabase = config_1.dbConfig.database;
+        if (!connectedDatabase) {
+            return {
+                valid: false,
+                database: "",
+                error: "No database configured. Please specify a database in your connection settings.",
+            };
+        }
+        if (requestedDatabase && requestedDatabase !== connectedDatabase) {
+            return {
+                valid: false,
+                database: "",
+                error: `Access denied: You are connected to '${connectedDatabase}' but requested '${requestedDatabase}'. Cross-database access is not permitted.`,
+            };
+        }
+        return { valid: true, database: connectedDatabase };
+    }
+    /**
+     * Recognize common schema patterns and anti-patterns based on INFORMATION_SCHEMA.
+     */
+    async analyzeSchemaPatterns(params = {}) {
+        try {
+            const dbValidation = this.validateDatabaseAccess(params?.database);
+            if (!dbValidation.valid) {
+                return { status: "error", error: dbValidation.error };
+            }
+            const database = dbValidation.database;
+            const scope = params.scope || (params.table_name ? "table" : "database");
+            if (scope === "table") {
+                if (!params.table_name) {
+                    return { status: "error", error: "table_name is required for table scope" };
+                }
+                if (!this.security.validateIdentifier(params.table_name).valid) {
+                    return { status: "error", error: "Invalid table name" };
+                }
+            }
+            const tables = await this.db.query(`
+          SELECT TABLE_NAME, TABLE_ROWS
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = ? AND TABLE_TYPE = 'BASE TABLE'
+          ${scope === "table" ? "AND TABLE_NAME = ?" : ""}
+          ORDER BY TABLE_NAME
+        `, scope === "table" ? [database, params.table_name] : [database]);
+            if (!tables.length) {
+                return {
+                    status: "success",
+                    data: {
+                        database,
+                        scope,
+                        tables_analyzed: 0,
+                        findings: [],
+                        summary: { high: 0, medium: 0, low: 0 },
+                        message: "No tables found.",
+                    },
+                };
+            }
+            const tableNames = tables.map((t) => t.TABLE_NAME);
+            const placeholders = tableNames.map(() => "?").join(",");
+            const columns = await this.db.query(`
+          SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY
+          FROM INFORMATION_SCHEMA.COLUMNS
+          WHERE TABLE_SCHEMA = ?
+            AND TABLE_NAME IN (${placeholders})
+          ORDER BY TABLE_NAME, ORDINAL_POSITION
+        `, [database, ...tableNames]);
+            const stats = await this.db.query(`
+          SELECT TABLE_NAME, INDEX_NAME, COLUMN_NAME, SEQ_IN_INDEX
+          FROM INFORMATION_SCHEMA.STATISTICS
+          WHERE TABLE_SCHEMA = ?
+            AND TABLE_NAME IN (${placeholders})
+          ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
+        `, [database, ...tableNames]);
+            const fks = await this.db.query(`
+          SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+          FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = ?
+            AND TABLE_NAME IN (${placeholders})
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        `, [database, ...tableNames]);
+            const columnsByTable = new Map();
+            for (const c of columns) {
+                if (!columnsByTable.has(c.TABLE_NAME))
+                    columnsByTable.set(c.TABLE_NAME, []);
+                columnsByTable.get(c.TABLE_NAME).push(c);
+            }
+            const indexesByTable = new Map();
+            for (const s of stats) {
+                if (!indexesByTable.has(s.TABLE_NAME))
+                    indexesByTable.set(s.TABLE_NAME, []);
+                indexesByTable.get(s.TABLE_NAME).push(s);
+            }
+            const fksByTable = new Map();
+            for (const fk of fks) {
+                if (!fksByTable.has(fk.TABLE_NAME))
+                    fksByTable.set(fk.TABLE_NAME, []);
+                fksByTable.get(fk.TABLE_NAME).push(fk);
+            }
+            const findings = [];
+            const isColumnIndexed = (table, column) => {
+                const idx = indexesByTable.get(table) || [];
+                return idx.some((s) => s.COLUMN_NAME === column);
+            };
+            for (const t of tables) {
+                const tCols = columnsByTable.get(t.TABLE_NAME) || [];
+                const tFks = fksByTable.get(t.TABLE_NAME) || [];
+                const pkCols = tCols.filter((c) => c.COLUMN_KEY === "PRI");
+                if (!pkCols.length) {
+                    findings.push({
+                        severity: "high",
+                        table_name: t.TABLE_NAME,
+                        pattern: "MISSING_PRIMARY_KEY",
+                        description: "Table has no PRIMARY KEY.",
+                        recommendations: [
+                            "Add a surrogate primary key (e.g., BIGINT AUTO_INCREMENT) or a natural composite key.",
+                            "Primary keys improve replication, indexing, and ORM compatibility.",
+                        ],
+                    });
+                }
+                if (tCols.length > 40) {
+                    findings.push({
+                        severity: "medium",
+                        table_name: t.TABLE_NAME,
+                        pattern: "WIDE_TABLE",
+                        description: `Table has ${tCols.length} columns, which can indicate overloading multiple concerns.`,
+                        evidence: { column_count: tCols.length },
+                        recommendations: [
+                            "Consider vertical partitioning or splitting into related tables.",
+                            "Move sparse/optional fields into a separate table.",
+                        ],
+                    });
+                }
+                const nullableCount = tCols.filter((c) => c.IS_NULLABLE === "YES").length;
+                if (tCols.length > 0 && nullableCount / tCols.length > 0.6) {
+                    findings.push({
+                        severity: "medium",
+                        table_name: t.TABLE_NAME,
+                        pattern: "HIGH_NULLABILITY",
+                        description: `More than 60% of columns are NULLable (${nullableCount}/${tCols.length}).`,
+                        evidence: { nullable_columns: nullableCount, total_columns: tCols.length },
+                        recommendations: [
+                            "Review whether columns should be NOT NULL with defaults.",
+                            "Consider splitting rarely-used columns into another table.",
+                        ],
+                    });
+                }
+                // Foreign key columns without any index
+                for (const fk of tFks) {
+                    if (!isColumnIndexed(t.TABLE_NAME, fk.COLUMN_NAME)) {
+                        findings.push({
+                            severity: "medium",
+                            table_name: t.TABLE_NAME,
+                            pattern: "FK_NOT_INDEXED",
+                            description: `Foreign key column '${fk.COLUMN_NAME}' is not indexed.`,
+                            evidence: {
+                                column: fk.COLUMN_NAME,
+                                references: `${fk.REFERENCED_TABLE_NAME}.${fk.REFERENCED_COLUMN_NAME}`,
+                            },
+                            recommendations: [
+                                `Add an index on '${fk.COLUMN_NAME}' to improve join and delete/update performance.`,
+                            ],
+                        });
+                    }
+                }
+                // Heuristic EAV detection: entity_id + attribute_id + value-like
+                const colNames = new Set(tCols.map((c) => c.COLUMN_NAME.toLowerCase()));
+                const hasEntityId = colNames.has("entity_id") || colNames.has("object_id");
+                const hasAttrId = colNames.has("attribute_id") || colNames.has("field_id");
+                const hasValue = colNames.has("value") ||
+                    colNames.has("value_string") ||
+                    colNames.has("value_int") ||
+                    colNames.has("value_decimal");
+                if (hasEntityId && hasAttrId && hasValue) {
+                    findings.push({
+                        severity: "high",
+                        table_name: t.TABLE_NAME,
+                        pattern: "EAV_PATTERN",
+                        description: "Table resembles an Entity-Attribute-Value (EAV) design, which often causes performance and integrity issues.",
+                        recommendations: [
+                            "Consider modeling attributes as real columns or separate typed tables.",
+                            "If EAV is required, ensure strong indexing and constraints on (entity_id, attribute_id).",
+                        ],
+                    });
+                }
+                // Soft delete without index
+                const softDeleteCol = tCols.find((c) => ["deleted_at", "is_deleted", "deleted"].includes(c.COLUMN_NAME.toLowerCase()));
+                if (softDeleteCol && !isColumnIndexed(t.TABLE_NAME, softDeleteCol.COLUMN_NAME)) {
+                    findings.push({
+                        severity: "low",
+                        table_name: t.TABLE_NAME,
+                        pattern: "SOFT_DELETE_NOT_INDEXED",
+                        description: `Soft-delete column '${softDeleteCol.COLUMN_NAME}' exists but is not indexed.`,
+                        recommendations: [
+                            `If queries frequently filter on '${softDeleteCol.COLUMN_NAME}', add an index (possibly composite with tenant/account keys).`,
+                        ],
+                    });
+                }
+                // Potential implicit relationships: *_id columns without FK constraints
+                const idCols = tCols
+                    .filter((c) => c.COLUMN_NAME.toLowerCase().endsWith("_id"))
+                    .map((c) => c.COLUMN_NAME);
+                if (idCols.length > 0 && tFks.length === 0) {
+                    findings.push({
+                        severity: "low",
+                        table_name: t.TABLE_NAME,
+                        pattern: "IMPLICIT_RELATIONSHIPS",
+                        description: "Table has *_id columns but no declared foreign keys; this may be intentional, but can reduce integrity and join discoverability.",
+                        evidence: { id_columns: idCols.slice(0, 10), total_id_columns: idCols.length },
+                        recommendations: [
+                            "If appropriate, add foreign keys for critical relationships.",
+                            "At minimum, ensure *_id columns are indexed.",
+                        ],
+                    });
+                }
+            }
+            const summary = {
+                high: findings.filter((f) => f.severity === "high").length,
+                medium: findings.filter((f) => f.severity === "medium").length,
+                low: findings.filter((f) => f.severity === "low").length,
+            };
+            return {
+                status: "success",
+                data: {
+                    database,
+                    scope,
+                    tables_analyzed: tables.length,
+                    findings,
+                    summary,
+                    notes: [
+                        "Heuristic-based analysis; review recommendations before changing production schema.",
+                    ],
+                },
+            };
+        }
+        catch (error) {
+            return { status: "error", error: error.message };
+        }
+    }
+}
+exports.SchemaPatternTools = SchemaPatternTools;

package/dist/tools/testDataTools.d.ts

@@ -0,0 +1,26 @@
+import { SecurityLayer } from "../security/securityLayer";
+export declare class TestDataTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    private validateDatabaseAccess;
+    private escapeValue;
+    private parseEnumValues;
+    private clampString;
+    private generateValueForColumn;
+    /**
+     * Generate SQL INSERT statements (does not execute) for synthetic test data.
+     * Attempts to maintain referential integrity by sampling referenced keys when foreign keys exist.
+     */
+    generateTestData(params: {
+        table_name: string;
+        row_count: number;
+        batch_size?: number;
+        include_nulls?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}