@berthojoris/mcp-mysql-server 1.16.3 → 1.17.0

package/dist/tools/schemaDesignTools.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDesignTools = void 0;
+class SchemaDesignTools {
+    constructor(security) {
+        this.security = security;
+    }
+    async designSchemaFromRequirements(params) {
+        try {
+            const requirementsText = params?.requirements_text?.trim();
+            if (!requirementsText) {
+                return { status: "error", error: "requirements_text is required" };
+            }
+            const naming = params.naming_convention ?? "snake_case";
+            const includeAudit = params.include_audit_columns ?? true;
+            const idType = params.id_type ?? "BIGINT";
+            const engine = params.engine ?? "InnoDB";
+            const charset = params.charset ?? "utf8mb4";
+            const collation = params.collation ?? "utf8mb4_unicode_ci";
+            const notes = [
+                "This tool uses deterministic heuristics (no external LLM) and may require manual refinement.",
+                "Review data types, nullability, and indexes before applying DDL in production.",
+            ];
+            const extracted = this.extractEntitiesAndRelations(requirementsText);
+            const explicitEntities = (params.entities || [])
+                .map((e) => ({
+                name: e.name,
+                fields: e.fields || [],
+            }))
+                .filter((e) => !!e.name?.trim());
+            const entityNames = new Set();
+            for (const e of explicitEntities)
+                entityNames.add(e.name.trim());
+            for (const e of extracted.entities)
+                entityNames.add(e);
+            if (entityNames.size === 0) {
+                // Fallback: create a single generic table
+                entityNames.add("items");
+                notes.push("No entities could be inferred from the text; generated a single fallback table 'items'.");
+            }
+            // Build initial table specs
+            const tablesSpec = Array.from(entityNames).map((rawName, idx) => {
+                const tableName = this.normalizeIdentifier(rawName, naming, `entity_${idx + 1}`);
+                const idColumn = idType === "UUID"
+                    ? { name: "id", type: "CHAR(36)", nullable: false, primary_key: true }
+                    : {
+                        name: "id",
+                        type: "BIGINT UNSIGNED",
+                        nullable: false,
+                        primary_key: true,
+                    };
+                const baseColumns = [
+                    idType === "UUID"
+                        ? idColumn
+                        : { ...idColumn, type: "BIGINT UNSIGNED AUTO_INCREMENT" },
+                ];
+                if (includeAudit) {
+                    baseColumns.push({ name: "created_at", type: "DATETIME", nullable: false }, { name: "updated_at", type: "DATETIME", nullable: false });
+                }
+                return {
+                    table_name: tableName,
+                    columns: baseColumns,
+                    indexes: [],
+                    _raw_name: rawName,
+                };
+            });
+            const rawNameToTable = new Map();
+            for (const t of tablesSpec) {
+                rawNameToTable.set(t._raw_name, t.table_name);
+            }
+            // Apply field hints from explicit entities and text patterns
+            for (const t of tablesSpec) {
+                const explicit = explicitEntities.find((e) => this.normalizeLoose(e.name) === this.normalizeLoose(t._raw_name));
+                const fieldsFromText = extracted.fieldsByEntity.get(t._raw_name) || [];
+                const hintedFields = [
+                    ...(explicit?.fields || []),
+                    ...fieldsFromText,
+                ].map((f) => f.trim());
+                for (const field of hintedFields) {
+                    const colName = this.normalizeIdentifier(field, naming, undefined);
+                    if (!colName || colName === "id" || colName === "created_at" || colName === "updated_at") {
+                        continue;
+                    }
+                    if (t.columns.some((c) => c.name === colName))
+                        continue;
+                    const inferred = this.inferColumnType(colName);
+                    t.columns.push(inferred.column);
+                    if (inferred.uniqueIndex) {
+                        t.indexes.push({
+                            name: this.makeIndexName(t.table_name, [colName], true),
+                            columns: [colName],
+                            unique: true,
+                        });
+                    }
+                }
+            }
+            // Apply inferred relationships
+            const relationships = [];
+            for (const rel of extracted.relationships) {
+                const fromTableRaw = rel.from;
+                const toTableRaw = rel.to;
+                const fromTable = this.findTableNameForRaw(fromTableRaw, tablesSpec) ?? this.normalizeIdentifier(fromTableRaw, naming, undefined);
+                const toTable = this.findTableNameForRaw(toTableRaw, tablesSpec) ?? this.normalizeIdentifier(toTableRaw, naming, undefined);
+                if (!fromTable || !toTable)
+                    continue;
+                const parentTable = rel.type === "many_to_one" ? toTable : fromTable;
+                const childTable = rel.type === "many_to_one" ? fromTable : toTable;
+                const child = tablesSpec.find((t) => t.table_name === childTable);
+                const parent = tablesSpec.find((t) => t.table_name === parentTable);
+                if (!child || !parent)
+                    continue;
+                const fkColumn = this.normalizeIdentifier(`${parentTable}_id`, naming, `${parentTable}_id`);
+                if (!child.columns.some((c) => c.name === fkColumn)) {
+                    child.columns.push({
+                        name: fkColumn,
+                        type: idType === "UUID" ? "CHAR(36)" : "BIGINT UNSIGNED",
+                        nullable: false,
+                        references: { table: parentTable, column: "id" },
+                    });
+                    child.indexes.push({
+                        name: this.makeIndexName(childTable, [fkColumn], false),
+                        columns: [fkColumn],
+                    });
+                }
+                relationships.push({
+                    from_table: childTable,
+                    from_column: fkColumn,
+                    to_table: parentTable,
+                    to_column: "id",
+                    type: "many_to_one",
+                });
+            }
+            // Generate DDL
+            const ddlStatements = [];
+            for (const t of tablesSpec) {
+                ddlStatements.push(this.generateCreateTableDDL(t, engine, charset, collation));
+                for (const idx of t.indexes) {
+                    ddlStatements.push(this.generateCreateIndexDDL(t.table_name, idx));
+                }
+            }
+            // Basic sanity: validate generated identifiers
+            for (const t of tablesSpec) {
+                if (!this.security.validateIdentifier(t.table_name).valid) {
+                    notes.push(`Generated table name '${t.table_name}' may be invalid. Consider renaming.`);
+                }
+                for (const c of t.columns) {
+                    if (!this.security.validateIdentifier(c.name).valid) {
+                        notes.push(`Generated column name '${t.table_name}.${c.name}' may be invalid. Consider renaming.`);
+                    }
+                }
+            }
+            return {
+                status: "success",
+                data: {
+                    input: {
+                        requirements_text: requirementsText,
+                        inferred_entities_count: tablesSpec.length,
+                    },
+                    tables: tablesSpec.map(({ _raw_name, ...t }) => t),
+                    relationships,
+                    ddl_statements: ddlStatements,
+                    notes,
+                },
+            };
+        }
+        catch (error) {
+            return { status: "error", error: error.message };
+        }
+    }
+    normalizeLoose(value) {
+        return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+    }
+    toSnakeCase(value) {
+        return value
+            .trim()
+            .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+            .replace(/[^a-zA-Z0-9]+/g, "_")
+            .replace(/^_+|_+$/g, "")
+            .replace(/_+/g, "_")
+            .toLowerCase();
+    }
+    toCamelCase(value) {
+        const parts = value
+            .trim()
+            .replace(/[^a-zA-Z0-9]+/g, " ")
+            .split(/\s+/)
+            .filter(Boolean);
+        if (parts.length === 0)
+            return "";
+        return (parts[0].toLowerCase() +
+            parts
+                .slice(1)
+                .map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase())
+                .join(""));
+    }
+    normalizeIdentifier(raw, naming, fallback) {
+        const base = naming === "camelCase" ? this.toCamelCase(raw) : this.toSnakeCase(raw);
+        let ident = base;
+        if (!ident)
+            ident = fallback || "";
+        if (!ident)
+            return "";
+        // Ensure valid start char
+        if (!/^[a-zA-Z_$]/.test(ident)) {
+            ident = `_${ident}`;
+        }
+        // Strip invalid chars (safety)
+        ident = ident.replace(/[^a-zA-Z0-9_$]/g, "_");
+        ident = ident.slice(0, 64);
+        // If still invalid, fallback
+        if (!this.security.validateIdentifier(ident).valid) {
+            const fb = fallback ? this.toSnakeCase(fallback) : "entity";
+            const safe = fb && this.security.validateIdentifier(fb).valid ? fb : "entity";
+            return safe;
+        }
+        return ident;
+    }
+    inferColumnType(colName) {
+        const name = colName.toLowerCase();
+        if (name === "email") {
+            return {
+                column: { name: colName, type: "VARCHAR(255)", nullable: false, unique: true },
+                uniqueIndex: true,
+            };
+        }
+        if (name.endsWith("_id")) {
+            return { column: { name: colName, type: "BIGINT UNSIGNED", nullable: false } };
+        }
+        if (name.includes("amount") ||
+            name.includes("price") ||
+            name.includes("total") ||
+            name.includes("cost")) {
+            return { column: { name: colName, type: "DECIMAL(10,2)", nullable: false } };
+        }
+        if (name.startsWith("is_") || name.startsWith("has_") || name.includes("enabled") || name.includes("active")) {
+            return { column: { name: colName, type: "BOOLEAN", nullable: false } };
+        }
+        if (name.endsWith("_at") || name.includes("date") || name.includes("time")) {
+            return { column: { name: colName, type: "DATETIME", nullable: true } };
+        }
+        if (name.includes("count") || name.includes("qty") || name.includes("quantity") || name.includes("number")) {
+            return { column: { name: colName, type: "INT", nullable: false } };
+        }
+        if (name.includes("description") || name.includes("notes") || name.includes("comment")) {
+            return { column: { name: colName, type: "TEXT", nullable: true } };
+        }
+        if (name.includes("name") || name.includes("title") || name.includes("status")) {
+            return { column: { name: colName, type: "VARCHAR(255)", nullable: false } };
+        }
+        return { column: { name: colName, type: "VARCHAR(255)", nullable: true } };
+    }
+    extractEntitiesAndRelations(text) {
+        const entities = new Set();
+        const relationships = [];
+        const fieldsByEntity = new Map();
+        const raw = text;
+        // Entity hints: "table for X", "entity X", "model X"
+        for (const match of raw.matchAll(/\b(?:table|entity|model)\s+(?:for\s+)?([a-zA-Z][a-zA-Z0-9 _-]{1,40})/gi)) {
+            const name = match[1].trim();
+            if (name)
+                entities.add(name);
+        }
+        // Relationship patterns: "A has many B" / "A belongs to B"
+        for (const match of raw.matchAll(/\b([a-zA-Z][a-zA-Z0-9_-]{1,40})\s+has\s+many\s+([a-zA-Z][a-zA-Z0-9_-]{1,40})\b/gi)) {
+            const from = match[1].trim();
+            const to = match[2].trim();
+            if (from && to) {
+                entities.add(from);
+                entities.add(to);
+                relationships.push({ from, to, type: "one_to_many" });
+            }
+        }
+        for (const match of raw.matchAll(/\b([a-zA-Z][a-zA-Z0-9_-]{1,40})\s+belongs\s+to\s+([a-zA-Z][a-zA-Z0-9_-]{1,40})\b/gi)) {
+            const from = match[1].trim();
+            const to = match[2].trim();
+            if (from && to) {
+                entities.add(from);
+                entities.add(to);
+                relationships.push({ from, to, type: "many_to_one" });
+            }
+        }
+        // Field list patterns: "X fields: a, b, c" or "X columns: ..."
+        for (const match of raw.matchAll(/\b([a-zA-Z][a-zA-Z0-9_-]{1,40})\s+(?:fields|columns|attributes)\s*:\s*([^\n\.]+)(?:\.|\n|$)/gi)) {
+            const entity = match[1].trim();
+            const list = match[2].trim();
+            if (!entity || !list)
+                continue;
+            entities.add(entity);
+            const fields = list
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean)
+                .map((s) => s.replace(/[^a-zA-Z0-9 _-]/g, "").trim())
+                .filter(Boolean);
+            if (fields.length > 0) {
+                fieldsByEntity.set(entity, fields);
+            }
+        }
+        return {
+            entities: Array.from(entities.values()),
+            relationships,
+            fieldsByEntity,
+        };
+    }
+    findTableNameForRaw(raw, tablesSpec) {
+        const target = this.normalizeLoose(raw);
+        const match = tablesSpec.find((t) => this.normalizeLoose(t._raw_name) === target);
+        return match?.table_name;
+    }
+    makeIndexName(table, columns, unique) {
+        const base = `${unique ? "uidx" : "idx"}_${table}_${columns.join("_")}`;
+        const name = base.replace(/[^a-zA-Z0-9_]/g, "_").slice(0, 64);
+        return name;
+    }
+    generateCreateTableDDL(table, engine, charset, collation) {
+        const colLines = [];
+        const pk = [];
+        const fkLines = [];
+        for (const c of table.columns) {
+            const nullSql = c.nullable ? "NULL" : "NOT NULL";
+            colLines.push("  `" + c.name + "` " + c.type + " " + nullSql);
+            if (c.primary_key)
+                pk.push(c.name);
+            if (c.references) {
+                const fkName = `fk_${table.table_name}_${c.name}`.slice(0, 64);
+                fkLines.push("  CONSTRAINT `" +
+                    fkName +
+                    "` FOREIGN KEY (`" +
+                    c.name +
+                    "`) REFERENCES `" +
+                    c.references.table +
+                    "`(`" +
+                    c.references.column +
+                    "`)");
+            }
+        }
+        if (pk.length > 0) {
+            colLines.push("  PRIMARY KEY (" + pk.map((c) => "`" + c + "`").join(", ") + ")");
+        }
+        const allLines = [...colLines, ...fkLines];
+        return ("CREATE TABLE `" +
+            table.table_name +
+            "` (\n" +
+            allLines.join(",\n") +
+            "\n) ENGINE=" +
+            engine +
+            " DEFAULT CHARSET=" +
+            charset +
+            " COLLATE=" +
+            collation +
+            ";");
+    }
+    generateCreateIndexDDL(tableName, idx) {
+        const uniq = idx.unique ? "UNIQUE " : "";
+        const cols = idx.columns.map((c) => "`" + c + "`").join(", ");
+        return "CREATE " + uniq + "INDEX `" + idx.name + "` ON `" + tableName + "` (" + cols + ");";
+    }
+}
+exports.SchemaDesignTools = SchemaDesignTools;

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/securityAuditTools.d.ts

@@ -0,0 +1,39 @@
+type Severity = "info" | "low" | "medium" | "high" | "critical";
+export declare class SecurityAuditTools {
+    private db;
+    constructor();
+    private validateDatabaseAccess;
+    auditDatabaseSecurity(params?: {
+        database?: string;
+        include_user_account_checks?: boolean;
+        include_privilege_checks?: boolean;
+    }): Promise<{
+        status: string;
+        data?: {
+            database: string;
+            findings: Array<{
+                severity: Severity;
+                title: string;
+                evidence?: string;
+                recommendation: string;
+            }>;
+            summary: {
+                critical: number;
+                high: number;
+                medium: number;
+                low: number;
+                info: number;
+            };
+            notes: string[];
+        };
+        error?: string;
+    }>;
+    private severityRank;
+    private summarizeFindings;
+    private asOnOff;
+    private asInt;
+    private readVariables;
+    private tryReadUserAccounts;
+    private tryReadPrivilegeSummaries;
+}
+export {};