@rog0x/mcp-database-tools 1.0.0

package/src/tools/schema-analyzer.ts

@@ -0,0 +1,370 @@
+/**
+ * Schema Analyzer — parse CREATE TABLE statements to extract
+ * tables, columns, types, constraints, foreign keys, indexes.
+ * Generate ER diagrams in Mermaid format.
+ */
+
+interface ColumnInfo {
+  name: string;
+  type: string;
+  nullable: boolean;
+  defaultValue: string | null;
+  isPrimaryKey: boolean;
+  isUnique: boolean;
+  autoIncrement: boolean;
+}
+
+interface ForeignKeyInfo {
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onDelete: string | null;
+  onUpdate: string | null;
+}
+
+interface IndexInfo {
+  name: string | null;
+  columns: string[];
+  unique: boolean;
+}
+
+interface TableInfo {
+  name: string;
+  columns: ColumnInfo[];
+  primaryKey: string[];
+  foreignKeys: ForeignKeyInfo[];
+  indexes: IndexInfo[];
+  uniqueConstraints: string[][];
+  checkConstraints: string[];
+}
+
+interface SchemaAnalysis {
+  tables: TableInfo[];
+  relationships: {
+    from: string;
+    fromColumns: string[];
+    to: string;
+    toColumns: string[];
+    type: string;
+  }[];
+  mermaidDiagram: string;
+  summary: string;
+}
+
+function splitRespectingParens(text: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of text) {
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+
+function extractTableBody(createStmt: string): string | null {
+  // Find the outermost parentheses
+  let depth = 0;
+  let start = -1;
+  let end = -1;
+  for (let i = 0; i < createStmt.length; i++) {
+    if (createStmt[i] === "(") {
+      if (depth === 0) start = i + 1;
+      depth++;
+    }
+    if (createStmt[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (start === -1 || end === -1) return null;
+  return createStmt.substring(start, end).trim();
+}
+
+function parseColumn(def: string): ColumnInfo | null {
+  const trimmed = def.trim();
+  // Skip table-level constraints
+  if (/^\s*(PRIMARY KEY|FOREIGN KEY|UNIQUE|CHECK|CONSTRAINT|INDEX|KEY)\b/i.test(trimmed)) {
+    return null;
+  }
+
+  const parts = trimmed.split(/\s+/);
+  if (parts.length < 2) return null;
+
+  const name = parts[0].replace(/[`"[\]]/g, "");
+  const upper = trimmed.toUpperCase();
+
+  // Type can be multi-word, e.g. "DOUBLE PRECISION", "CHARACTER VARYING(255)"
+  // Find everything after the name up to the first constraint keyword
+  const afterName = trimmed.substring(parts[0].length).trim();
+  const typeMatch = afterName.match(
+    /^(\w+(?:\s*\([^)]*\))?(?:\s+(?:PRECISION|VARYING|WITHOUT|WITH|TIME|ZONE)(?:\s*\([^)]*\))?)*)/i
+  );
+  const type = typeMatch ? typeMatch[1].trim() : parts[1];
+
+  return {
+    name,
+    type,
+    nullable: !upper.includes("NOT NULL"),
+    defaultValue: extractDefault(trimmed),
+    isPrimaryKey: upper.includes("PRIMARY KEY"),
+    isUnique: upper.includes("UNIQUE"),
+    autoIncrement:
+      upper.includes("AUTO_INCREMENT") ||
+      upper.includes("AUTOINCREMENT") ||
+      /\bSERIAL\b|\bBIGSERIAL\b|\bSMALLSERIAL\b/i.test(type),
+  };
+}
+
+function extractDefault(colDef: string): string | null {
+  const match = colDef.match(/\bDEFAULT\s+('[^']*'|"[^"]*"|\S+)/i);
+  return match ? match[1] : null;
+}
+
+function parseTable(createStmt: string): TableInfo | null {
+  const nameMatch = createStmt.match(
+    /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`?(\w+)`?\.)?`?(\w+)`?/i
+  );
+  if (!nameMatch) return null;
+  const tableName = nameMatch[2];
+
+  const body = extractTableBody(createStmt);
+  if (!body) return null;
+
+  const definitions = splitRespectingParens(body);
+
+  const columns: ColumnInfo[] = [];
+  const primaryKey: string[] = [];
+  const foreignKeys: ForeignKeyInfo[] = [];
+  const indexes: IndexInfo[] = [];
+  const uniqueConstraints: string[][] = [];
+  const checkConstraints: string[] = [];
+
+  for (const def of definitions) {
+    const trimmed = def.trim();
+    const upper = trimmed.toUpperCase();
+
+    // Table-level PRIMARY KEY
+    if (/^\s*(?:CONSTRAINT\s+\w+\s+)?PRIMARY\s+KEY\s*\(/i.test(trimmed)) {
+      const colsMatch = trimmed.match(/PRIMARY\s+KEY\s*\(([^)]+)\)/i);
+      if (colsMatch) {
+        const cols = colsMatch[1].split(",").map((c) => c.trim().replace(/[`"[\]]/g, ""));
+        primaryKey.push(...cols);
+      }
+      continue;
+    }
+
+    // FOREIGN KEY
+    if (/^\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\(/i.test(trimmed)) {
+      const fkMatch = trimmed.match(
+        /FOREIGN\s+KEY\s*\(([^)]+)\)\s*REFERENCES\s+`?(\w+)`?\s*\(([^)]+)\)/i
+      );
+      if (fkMatch) {
+        const fkCols = fkMatch[1].split(",").map((c) => c.trim().replace(/[`"[\]]/g, ""));
+        const refTable = fkMatch[2];
+        const refCols = fkMatch[3].split(",").map((c) => c.trim().replace(/[`"[\]]/g, ""));
+        const onDeleteMatch = trimmed.match(/ON\s+DELETE\s+(\w+(?:\s+\w+)?)/i);
+        const onUpdateMatch = trimmed.match(/ON\s+UPDATE\s+(\w+(?:\s+\w+)?)/i);
+        foreignKeys.push({
+          columns: fkCols,
+          referencedTable: refTable,
+          referencedColumns: refCols,
+          onDelete: onDeleteMatch ? onDeleteMatch[1] : null,
+          onUpdate: onUpdateMatch ? onUpdateMatch[1] : null,
+        });
+      }
+      continue;
+    }
+
+    // UNIQUE constraint
+    if (/^\s*(?:CONSTRAINT\s+\w+\s+)?UNIQUE\s*\(/i.test(trimmed)) {
+      const uqMatch = trimmed.match(/UNIQUE\s*\(([^)]+)\)/i);
+      if (uqMatch) {
+        const cols = uqMatch[1].split(",").map((c) => c.trim().replace(/[`"[\]]/g, ""));
+        uniqueConstraints.push(cols);
+      }
+      continue;
+    }
+
+    // CHECK constraint
+    if (/^\s*(?:CONSTRAINT\s+\w+\s+)?CHECK\s*\(/i.test(trimmed)) {
+      checkConstraints.push(trimmed);
+      continue;
+    }
+
+    // INDEX / KEY (MySQL syntax in CREATE TABLE)
+    if (/^\s*(?:INDEX|KEY)\s+/i.test(trimmed)) {
+      const idxMatch = trimmed.match(/(?:INDEX|KEY)\s+`?(\w+)`?\s*\(([^)]+)\)/i);
+      if (idxMatch) {
+        indexes.push({
+          name: idxMatch[1],
+          columns: idxMatch[2].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "")),
+          unique: false,
+        });
+      }
+      continue;
+    }
+
+    // Column definition
+    const col = parseColumn(trimmed);
+    if (col) {
+      columns.push(col);
+      if (col.isPrimaryKey) {
+        primaryKey.push(col.name);
+      }
+    }
+  }
+
+  return {
+    name: tableName,
+    columns,
+    primaryKey,
+    foreignKeys,
+    indexes,
+    uniqueConstraints,
+    checkConstraints,
+  };
+}
+
+function generateMermaidER(tables: TableInfo[]): string {
+  const lines: string[] = ["erDiagram"];
+
+  for (const table of tables) {
+    lines.push(`    ${table.name} {`);
+    for (const col of table.columns) {
+      const pk = table.primaryKey.includes(col.name) ? " PK" : "";
+      const fk = table.foreignKeys.some((fk) => fk.columns.includes(col.name)) ? " FK" : "";
+      const type = col.type.replace(/\s+/g, "_").replace(/[()]/g, "");
+      lines.push(`        ${type} ${col.name}${pk}${fk}`);
+    }
+    lines.push("    }");
+  }
+
+  // Relationships
+  for (const table of tables) {
+    for (const fk of table.foreignKeys) {
+      const relLabel = fk.columns.join(", ");
+      // Determine cardinality heuristic
+      const isUnique =
+        table.uniqueConstraints.some((uc) =>
+          fk.columns.every((c) => uc.includes(c))
+        ) ||
+        fk.columns.every((c) =>
+          table.columns.find((col) => col.name === c)?.isUnique
+        ) ||
+        fk.columns.every((c) => table.primaryKey.includes(c));
+
+      const cardinality = isUnique ? "||--||" : "}o--||";
+      lines.push(
+        `    ${table.name} ${cardinality} ${fk.referencedTable} : "${relLabel}"`
+      );
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function parseCreateIndexes(sql: string): IndexInfo[] {
+  const indexes: IndexInfo[] = [];
+  const regex =
+    /CREATE\s+(UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?`?(\w+)`?\s+ON\s+`?(\w+)`?\s*\(([^)]+)\)/gi;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(sql)) !== null) {
+    indexes.push({
+      name: match[2],
+      columns: match[4].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "")),
+      unique: !!match[1],
+    });
+  }
+  return indexes;
+}
+
+export function schemaAnalyzer(sql: string): SchemaAnalysis {
+  // Split into individual statements
+  const statements = sql
+    .split(";")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  const tables: TableInfo[] = [];
+  const standaloneIndexes: { tableName: string; index: IndexInfo }[] = [];
+
+  for (const stmt of statements) {
+    if (/^\s*CREATE\s+TABLE\b/i.test(stmt)) {
+      const table = parseTable(stmt);
+      if (table) tables.push(table);
+    }
+    if (/^\s*CREATE\s+(UNIQUE\s+)?INDEX\b/i.test(stmt)) {
+      const idxMatch = stmt.match(
+        /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?`?(\w+)`?\s+ON\s+`?(\w+)`?\s*\(([^)]+)\)/i
+      );
+      if (idxMatch) {
+        standaloneIndexes.push({
+          tableName: idxMatch[2],
+          index: {
+            name: idxMatch[1],
+            columns: idxMatch[3].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "")),
+            unique: /UNIQUE/i.test(stmt),
+          },
+        });
+      }
+    }
+  }
+
+  // Attach standalone indexes to their tables
+  for (const si of standaloneIndexes) {
+    const table = tables.find(
+      (t) => t.name.toLowerCase() === si.tableName.toLowerCase()
+    );
+    if (table) {
+      table.indexes.push(si.index);
+    }
+  }
+
+  // Build relationships
+  const relationships = tables.flatMap((t) =>
+    t.foreignKeys.map((fk) => ({
+      from: t.name,
+      fromColumns: fk.columns,
+      to: fk.referencedTable,
+      toColumns: fk.referencedColumns,
+      type: fk.columns.every((c) => t.primaryKey.includes(c))
+        ? "one-to-one"
+        : "many-to-one",
+    }))
+  );
+
+  const mermaidDiagram = generateMermaidER(tables);
+
+  const totalColumns = tables.reduce((sum, t) => sum + t.columns.length, 0);
+  const totalFKs = tables.reduce((sum, t) => sum + t.foreignKeys.length, 0);
+  const totalIndexes = tables.reduce((sum, t) => sum + t.indexes.length, 0);
+
+  const summary = [
+    `Schema contains ${tables.length} table(s) with ${totalColumns} total column(s).`,
+    totalFKs > 0
+      ? `${totalFKs} foreign key relationship(s) found.`
+      : "No foreign keys defined.",
+    totalIndexes > 0
+      ? `${totalIndexes} index(es) defined.`
+      : "No standalone indexes defined.",
+    `Tables: ${tables.map((t) => t.name).join(", ")}`,
+  ].join(" ");
+
+  return {
+    tables,
+    relationships,
+    mermaidDiagram,
+    summary,
+  };
+}