@cuongph.dev/dbdocgen 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { readFile as readFile2, writeFile as writeFile5, rm } from "fs/promises";
+import { readFile as readFile2, readdir, rm, writeFile as writeFile6 } from "fs/promises";
 import { existsSync } from "fs";
 import { resolve } from "path";
 
@@ -30,7 +30,7 @@ var outputLanguageSchema = z.enum(["en", "jp"]);
 var dbdocgenConfigSchema = z.object({
   schema: z.string().default("./schema.sql"),
   dialect: dialectSchema.optional(),
-  outDir: z.string().default("./docs/db"),
+  outDir: z.string().default("./output"),
   output: z.object({
     formats: z.array(outputFormatSchema).default(["excel", "markdown", "html", "diagram", "word"]),
     language: outputLanguageSchema.default("en")
@@ -113,7 +113,7 @@ function sanitizeType(type) {
 }
 
 // src/exporters/excel/excel-exporter.ts
-import { mkdir as mkdir2 } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { join as join2 } from "path";
 import ExcelJS from "exceljs";
 
@@ -137,6 +137,10 @@ var LABELS = {
     type: "Type",
     required: "Required",
     defaultValue: "Default Value",
+    size: "Size",
+    minValue: "Min",
+    maxValue: "Max",
+    unique: "Unique",
     notes: "Notes",
     yes: "Yes",
     no: "No",
@@ -165,7 +169,15 @@ var LABELS = {
     rowNo: "#",
     backToOverview: "\u2190 Overview",
     pkMarker: "PK",
-    fkMarker: "FK"
+    fkMarker: "FK",
+    erDiagramHeading: "ER Diagram",
+    erDiagramSheet: "ER Diagram",
+    viewErDiagram: "View interactive ER diagram (html/er-diagram.html)",
+    zoomIn: "Zoom in",
+    zoomOut: "Zoom out",
+    zoomReset: "Reset",
+    zoomFit: "Fit",
+    panZoomHint: "Drag to pan \xB7 Scroll to zoom"
   },
   jp: {
     docTitle: "Database Documentation",
@@ -185,6 +197,10 @@ var LABELS = {
     type: "\u578B",
     required: "\u5FC5\u9808",
     defaultValue: "\u30C7\u30D5\u30A9\u30EB\u30C8\u5024",
+    size: "\u6841\u6570",
+    minValue: "\u6700\u5C0F\u5024",
+    maxValue: "\u6700\u5927\u5024",
+    unique: "\u4E00\u610F",
     notes: "\u5099\u8003",
     yes: "Yes",
     no: "No",
@@ -213,13 +229,533 @@ var LABELS = {
     rowNo: "No.",
     backToOverview: "\u2190 \u4E00\u89A7",
     pkMarker: "PK",
-    fkMarker: "FK"
+    fkMarker: "FK",
+    erDiagramHeading: "ER Diagram",
+    erDiagramSheet: "ER Diagram",
+    viewErDiagram: "\u30A4\u30F3\u30BF\u30E9\u30AF\u30C6\u30A3\u30D6ER\u56F3 (html/er-diagram.html)",
+    zoomIn: "\u62E1\u5927",
+    zoomOut: "\u7E2E\u5C0F",
+    zoomReset: "\u30EA\u30BB\u30C3\u30C8",
+    zoomFit: "\u5168\u4F53\u8868\u793A",
+    panZoomHint: "\u30C9\u30E9\u30C3\u30B0\u3067\u79FB\u52D5 \xB7 \u30B9\u30AF\u30ED\u30FC\u30EB\u3067\u62E1\u5927\u7E2E\u5C0F"
   }
 };
 function getOutputLabels(language = "en") {
   return LABELS[language];
 }
 
+// src/exporters/shared/column-definition.ts
+var A5_COLUMN_COUNT = 10;
+function columnDefinitionHeaders(labels) {
+  return [
+    labels.physicalName,
+    labels.logicalName,
+    labels.type,
+    labels.size,
+    labels.required,
+    labels.defaultValue,
+    labels.minValue,
+    labels.maxValue,
+    labels.unique,
+    labels.notes
+  ];
+}
+function formatColumnNotes(column, labels) {
+  const parts = [];
+  if (column.isPrimaryKey) parts.push(labels.pkMarker);
+  if (column.isForeignKey) parts.push(labels.fkMarker);
+  if (column.constraintNotes?.length) parts.push(...column.constraintNotes);
+  if (column.description?.value) parts.push(column.description.value);
+  return parts.join(", ") || labels.none;
+}
+function columnDefinitionRow(column, labels) {
+  return [
+    column.name,
+    column.comment ?? "",
+    column.type,
+    column.size ?? labels.none,
+    column.nullable ? labels.no : labels.yes,
+    column.defaultValue ?? labels.none,
+    column.minValue ?? labels.none,
+    column.maxValue ?? labels.none,
+    column.isUnique ? labels.yes : labels.no,
+    formatColumnNotes(column, labels)
+  ];
+}
+
+// src/exporters/diagram/er-diagram-embed.ts
+function getErDiagramMermaid(doc) {
+  return renderMermaid(doc);
+}
+function renderErDiagramHtmlPage(mermaidSource, labels) {
+  const escaped = mermaidSource.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${esc(labels.erDiagramHeading)}</title>
+  <style>
+    body { margin: 0; font-family: "Yu Gothic UI", "Meiryo", Arial, sans-serif; background: #f3f4f6; }
+    .toolbar {
+      background: #4472c4; color: #fff; padding: 10px 16px;
+      display: flex; align-items: center; gap: 12px; flex-wrap: wrap;
+    }
+    .toolbar a { color: #fff; text-decoration: underline; }
+    .toolbar .spacer { flex: 1; }
+    .toolbar .hint { opacity: 0.9; font-size: 13px; }
+    .toolbar button {
+      background: #fff; color: #2f5597; border: none; border-radius: 4px;
+      padding: 6px 12px; font-size: 13px; cursor: pointer; font-weight: 600;
+    }
+    .toolbar button:hover { background: #e8eef8; }
+    .viewport {
+      position: relative; height: calc(100vh - 52px); margin: 12px;
+      background: #fff; border: 1px solid #bfc7d4; border-radius: 4px;
+      overflow: hidden; cursor: grab; touch-action: none;
+    }
+    .viewport.dragging { cursor: grabbing; }
+    .canvas {
+      position: absolute; left: 0; top: 0; transform-origin: 0 0;
+      padding: 24px;
+    }
+    .mermaid { min-width: 320px; }
+    .mermaid svg { max-width: none !important; height: auto !important; }
+  </style>
+</head>
+<body>
+  <div class="toolbar">
+    <strong>${esc(labels.erDiagramHeading)}</strong>
+    <a href="index.html">\u2190 ${esc(labels.tableListHeading)}</a>
+    <span class="spacer"></span>
+    <span class="hint">${esc(labels.panZoomHint)}</span>
+    <button type="button" id="zoom-out" title="${esc(labels.zoomOut)}">\u2212</button>
+    <button type="button" id="zoom-reset" title="${esc(labels.zoomReset)}">${esc(labels.zoomReset)}</button>
+    <button type="button" id="zoom-in" title="${esc(labels.zoomIn)}">+</button>
+    <button type="button" id="zoom-fit" title="${esc(labels.zoomFit)}">${esc(labels.zoomFit)}</button>
+  </div>
+  <div class="viewport" id="viewport">
+    <div class="canvas" id="canvas">
+      <pre class="mermaid">${escaped}</pre>
+    </div>
+  </div>
+  <script type="module">
+    import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";
+
+    mermaid.initialize({
+      startOnLoad: false,
+      theme: "default",
+      er: { useMaxWidth: false }
+    });
+
+    await mermaid.run({ querySelector: ".mermaid" });
+    setupPanZoom(
+      document.getElementById("viewport"),
+      document.getElementById("canvas")
+    );
+
+    function setupPanZoom(viewport, canvas) {
+      let scale = 1;
+      let tx = 40;
+      let ty = 40;
+      let dragging = false;
+      let lastX = 0;
+      let lastY = 0;
+
+      function apply() {
+        canvas.style.transform = "translate(" + tx + "px," + ty + "px) scale(" + scale + ")";
+      }
+
+      function zoomAt(factor, cx, cy) {
+        const next = Math.min(4, Math.max(0.15, scale * factor));
+        const ratio = next / scale;
+        tx = cx - (cx - tx) * ratio;
+        ty = cy - (cy - ty) * ratio;
+        scale = next;
+        apply();
+      }
+
+      function fitToView() {
+        const svg = canvas.querySelector("svg");
+        if (!svg) return;
+        const box = svg.getBBox();
+        const pad = 32;
+        const vw = viewport.clientWidth;
+        const vh = viewport.clientHeight;
+        scale = Math.min(
+          (vw - pad * 2) / Math.max(box.width, 1),
+          (vh - pad * 2) / Math.max(box.height, 1),
+          1.5
+        );
+        tx = (vw - box.width * scale) / 2 - box.x * scale;
+        ty = (vh - box.height * scale) / 2 - box.y * scale;
+        apply();
+      }
+
+      viewport.addEventListener("wheel", (e) => {
+        e.preventDefault();
+        const rect = viewport.getBoundingClientRect();
+        const cx = e.clientX - rect.left;
+        const cy = e.clientY - rect.top;
+        zoomAt(e.deltaY < 0 ? 1.12 : 0.89, cx, cy);
+      }, { passive: false });
+
+      viewport.addEventListener("mousedown", (e) => {
+        if (e.button !== 0) return;
+        dragging = true;
+        lastX = e.clientX;
+        lastY = e.clientY;
+        viewport.classList.add("dragging");
+      });
+
+      window.addEventListener("mousemove", (e) => {
+        if (!dragging) return;
+        tx += e.clientX - lastX;
+        ty += e.clientY - lastY;
+        lastX = e.clientX;
+        lastY = e.clientY;
+        apply();
+      });
+
+      window.addEventListener("mouseup", () => {
+        dragging = false;
+        viewport.classList.remove("dragging");
+      });
+
+      document.getElementById("zoom-in").addEventListener("click", () => {
+        zoomAt(1.2, viewport.clientWidth / 2, viewport.clientHeight / 2);
+      });
+      document.getElementById("zoom-out").addEventListener("click", () => {
+        zoomAt(1 / 1.2, viewport.clientWidth / 2, viewport.clientHeight / 2);
+      });
+      document.getElementById("zoom-reset").addEventListener("click", () => {
+        scale = 1;
+        tx = 40;
+        ty = 40;
+        apply();
+      });
+      document.getElementById("zoom-fit").addEventListener("click", fitToView);
+
+      fitToView();
+    }
+  </script>
+</body>
+</html>`;
+}
+function renderErDiagramMarkdown(mermaidSource, labels) {
+  return [
+    `# ${labels.erDiagramHeading}`,
+    "",
+    "```mermaid",
+    mermaidSource.trimEnd(),
+    "```",
+    ""
+  ].join("\n");
+}
+function esc(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/exporters/diagram/er-diagram-layout.ts
+import ELK from "elkjs/lib/elk.bundled.js";
+var BOX_W = 200;
+var HEADER_H = 28;
+var LINE_H = 14;
+var MAX_COLS_SHOWN = 6;
+var COMPACT_THRESHOLD = 18;
+var PAD = 24;
+var CLUSTER_GAP = 56;
+function isCompactLayout(tableCount) {
+  return tableCount >= COMPACT_THRESHOLD;
+}
+function getVisibleErColumns(table) {
+  const prioritized = [
+    ...table.columns.filter((column) => column.isPrimaryKey),
+    ...table.columns.filter(
+      (column) => column.isForeignKey && !column.isPrimaryKey
+    ),
+    ...table.columns.filter(
+      (column) => !column.isPrimaryKey && !column.isForeignKey
+    )
+  ];
+  const unique = prioritized.filter(
+    (column, index, columns) => columns.findIndex((item) => item.name === column.name) === index
+  );
+  return unique.slice(0, MAX_COLS_SHOWN);
+}
+function measureTableBox(table, _compact = false) {
+  const visible = getVisibleErColumns(table);
+  const extra = table.columns.length > visible.length ? 1 : 0;
+  return {
+    w: BOX_W,
+    h: HEADER_H + (visible.length + extra) * LINE_H + 8
+  };
+}
+function buildAdjacency(doc) {
+  const names = new Set(doc.tables.map((t) => t.name));
+  const adj = /* @__PURE__ */ new Map();
+  for (const name of names) adj.set(name, /* @__PURE__ */ new Set());
+  for (const rel of doc.relationships.filter((r) => r.source === "schema")) {
+    if (!names.has(rel.fromTable) || !names.has(rel.toTable)) continue;
+    adj.get(rel.fromTable).add(rel.toTable);
+    adj.get(rel.toTable).add(rel.fromTable);
+  }
+  return adj;
+}
+function connectedComponents(tableNames, adj) {
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const name of tableNames) {
+    if (visited.has(name)) continue;
+    const stack = [name];
+    const component = [];
+    visited.add(name);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      component.push(current);
+      for (const next of adj.get(current) ?? []) {
+        if (!visited.has(next)) {
+          visited.add(next);
+          stack.push(next);
+        }
+      }
+    }
+    component.sort();
+    components.push(component);
+  }
+  return components.sort((a, b) => b.length - a.length);
+}
+function sectionToPoints(section) {
+  return [section.startPoint, ...section.bendPoints ?? [], section.endPoint];
+}
+function extractEdges(layouted) {
+  const edges = [];
+  for (const edge of layouted.edges ?? []) {
+    for (const section of edge.sections ?? []) {
+      edges.push({
+        id: edge.id,
+        points: sectionToPoints(section)
+      });
+    }
+  }
+  return edges;
+}
+async function layoutComponent(doc, tableNames, compact) {
+  const elk = new ELK();
+  const nameSet = new Set(tableNames);
+  const tables = doc.tables.filter((t) => nameSet.has(t.name));
+  const direction = tables.length >= 8 ? "DOWN" : "RIGHT";
+  const children = tables.map((table) => {
+    const { w, h } = measureTableBox(table, compact);
+    return { id: table.name, width: w, height: h };
+  });
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rel of doc.relationships.filter((r) => r.source === "schema")) {
+    if (!nameSet.has(rel.fromTable) || !nameSet.has(rel.toTable)) continue;
+    const key = `${rel.fromTable}->${rel.toTable}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push({
+      id: key,
+      sources: [rel.fromTable],
+      targets: [rel.toTable]
+    });
+  }
+  const graph = {
+    id: "root",
+    layoutOptions: {
+      "elk.algorithm": "layered",
+      "elk.direction": direction,
+      "elk.edgeRouting": "ORTHOGONAL",
+      "elk.layered.nodePlacement.strategy": "NETWORK_SIMPLEX",
+      "elk.layered.crossingMinimization.strategy": "LAYER_SWEEP",
+      "elk.layered.spacing.nodeNodeBetweenLayers": compact ? "56" : "80",
+      "elk.spacing.nodeNode": compact ? "32" : "48",
+      "elk.spacing.edgeNode": "24",
+      "elk.padding": `[top=${PAD},left=${PAD},bottom=${PAD},right=${PAD}]`
+    },
+    children,
+    edges
+  };
+  const layouted = await elk.layout(graph);
+  const boxes = /* @__PURE__ */ new Map();
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const child of layouted.children ?? []) {
+    const table = tables.find((t) => t.name === child.id);
+    if (!table) continue;
+    const { w, h } = measureTableBox(table, compact);
+    const x = child.x ?? 0;
+    const y = child.y ?? 0;
+    const box = { x, y, w, h };
+    boxes.set(child.id, box);
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x + w);
+    maxY = Math.max(maxY, y + h);
+  }
+  const width = Math.ceil(maxX - minX + PAD * 2);
+  const height = Math.ceil(maxY - minY + PAD * 2);
+  const dx = PAD - minX;
+  const dy = PAD - minY;
+  for (const [name, box] of boxes) {
+    boxes.set(name, { x: box.x + dx, y: box.y + dy, w: box.w, h: box.h });
+  }
+  const shiftedEdges = extractEdges(layouted).map((edge) => ({
+    ...edge,
+    points: edge.points.map((p) => ({ x: p.x + dx, y: p.y + dy }))
+  }));
+  return { boxes, edges: shiftedEdges, width, height };
+}
+function shiftLayout(boxes, edges, offsetX, offsetY) {
+  for (const [name, box] of boxes) {
+    boxes.set(name, { ...box, x: box.x + offsetX, y: box.y + offsetY });
+  }
+  for (const edge of edges) {
+    for (const p of edge.points) {
+      p.x += offsetX;
+      p.y += offsetY;
+    }
+  }
+}
+async function layoutErDiagram(doc) {
+  const tables = doc.tables;
+  if (tables.length === 0) {
+    return {
+      boxes: /* @__PURE__ */ new Map(),
+      edges: [],
+      compact: false,
+      width: 400,
+      height: 80
+    };
+  }
+  const compact = isCompactLayout(tables.length);
+  const adj = buildAdjacency(doc);
+  const components = connectedComponents(
+    tables.map((t) => t.name),
+    adj
+  );
+  const mergedBoxes = /* @__PURE__ */ new Map();
+  const mergedEdges = [];
+  const clusterCols = components.length <= 1 ? 1 : components.length <= 4 ? 2 : 3;
+  let tileX = 0;
+  let tileY = 0;
+  let rowHeight = 0;
+  let maxWidth = PAD;
+  let maxHeight = PAD;
+  for (const [i, component] of components.entries()) {
+    const laid = await layoutComponent(doc, component, compact);
+    shiftLayout(laid.boxes, laid.edges, tileX, tileY);
+    for (const [name, box] of laid.boxes) mergedBoxes.set(name, box);
+    mergedEdges.push(...laid.edges);
+    rowHeight = Math.max(rowHeight, laid.height);
+    tileX += laid.width + CLUSTER_GAP;
+    maxWidth = Math.max(maxWidth, tileX);
+    maxHeight = Math.max(maxHeight, tileY + laid.height);
+    if ((i + 1) % clusterCols === 0) {
+      tileX = 0;
+      tileY += rowHeight + CLUSTER_GAP;
+      rowHeight = 0;
+    }
+  }
+  return {
+    boxes: mergedBoxes,
+    edges: mergedEdges,
+    compact,
+    width: Math.ceil(maxWidth),
+    height: Math.ceil(maxHeight + PAD)
+  };
+}
+
+// src/exporters/diagram/er-diagram-svg.ts
+async function renderErDiagramSvg(doc) {
+  const tables = doc.tables;
+  if (tables.length === 0) {
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="400" height="80"><text x="10" y="40" font-family="Arial,sans-serif" font-size="14">No tables</text></svg>`;
+  }
+  const layout = await layoutErDiagram(doc);
+  return buildErDiagramSvg(doc, layout);
+}
+async function renderErDiagramPng(doc) {
+  const tables = doc.tables;
+  if (tables.length === 0) {
+    const svg2 = await renderErDiagramSvg(doc);
+    const sharp2 = (await import("sharp")).default;
+    const buffer2 = await sharp2(Buffer.from(svg2)).png().toBuffer();
+    return { buffer: buffer2, width: 400, height: 80 };
+  }
+  const layout = await layoutErDiagram(doc);
+  const svg = buildErDiagramSvg(doc, layout);
+  const sharp = (await import("sharp")).default;
+  const buffer = await sharp(Buffer.from(svg)).png().toBuffer();
+  return { buffer, width: layout.width, height: layout.height };
+}
+function buildErDiagramSvg(doc, layout) {
+  const { boxes, edges, width, height } = layout;
+  const parts = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" font-family="Arial,sans-serif" font-size="11">`,
+    `<rect width="100%" height="100%" fill="#ffffff"/>`,
+    `<defs><marker id="arrow" markerWidth="8" markerHeight="8" refX="7" refY="3" orient="auto"><path d="M0,0 L0,6 L8,3 z" fill="#5b7aa6"/></marker></defs>`,
+    `<g class="edges">`
+  ];
+  for (const edge of edges) {
+    if (edge.points.length < 2) continue;
+    const d = pointsToPath(edge.points);
+    parts.push(
+      `<path d="${d}" fill="none" stroke="#7d96b8" stroke-width="1.25" marker-end="url(#arrow)"/>`
+    );
+  }
+  parts.push(`</g><g class="nodes">`);
+  for (const table of doc.tables) {
+    const box = boxes.get(table.name);
+    parts.push(...renderTableBox(table, box));
+  }
+  parts.push("</g></svg>");
+  return parts.join("");
+}
+function pointsToPath(points) {
+  return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`).join(" ");
+}
+function renderTableBox(table, box) {
+  const parts = [
+    `<rect x="${box.x}" y="${box.y}" width="${box.w}" height="${box.h}" fill="#f8fafc" stroke="#4472c4" stroke-width="1.5" rx="4"/>`,
+    `<rect x="${box.x}" y="${box.y}" width="${box.w}" height="${HEADER_H}" fill="#4472c4" rx="4"/>`,
+    `<rect x="${box.x}" y="${box.y + HEADER_H - 4}" width="${box.w}" height="4" fill="#4472c4"/>`,
+    `<text x="${box.x + 8}" y="${box.y + 18}" fill="#ffffff" font-weight="bold">${escapeXml(table.name)}</text>`
+  ];
+  let cy = box.y + HEADER_H + 14;
+  const visible = getVisibleErColumns(table);
+  for (const col of visible) {
+    const marker = col.isPrimaryKey ? " PK" : col.isForeignKey ? " FK" : "";
+    parts.push(
+      `<text x="${box.x + 8}" y="${cy}" fill="#333333">${escapeXml(col.name)} : ${escapeXml(shortType(col.type))}${marker}</text>`
+    );
+    cy += LINE_H;
+  }
+  if (table.columns.length > visible.length) {
+    parts.push(
+      `<text x="${box.x + 8}" y="${cy}" fill="#666666">... +${table.columns.length - visible.length} more</text>`
+    );
+  }
+  return parts;
+}
+function shortType(type) {
+  return type.length > 18 ? `${type.slice(0, 15)}...` : type;
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function fitErDiagramToBox(width, height, maxWidth, maxHeight) {
+  const scale = Math.min(maxWidth / width, maxHeight / height, 1);
+  return {
+    width: Math.max(1, Math.round(width * scale)),
+    height: Math.max(1, Math.round(height * scale))
+  };
+}
+
 // src/exporters/excel/excel-exporter.ts
 var COLOR = {
   headerBg: "FF4472C4",
@@ -245,6 +781,9 @@ async function exportExcelDictionary(doc, options) {
     sheetNames.set(table.name, buildSheetName(table.name, sheetNames));
   }
   addOverviewSheet(workbook, doc, labels, sheetNames);
+  if (doc.tables.length > 0) {
+    await addErDiagramSheet(workbook, doc, labels, options.outDir);
+  }
   for (const table of doc.tables) {
     const sheetName = sheetNames.get(table.name);
     const sheet = workbook.addWorksheet(sheetName);
@@ -332,6 +871,51 @@ function addOverviewSheet(workbook, doc, labels, sheetNames) {
   };
   sheet.views = [{ state: "frozen", ySplit: headerRowNum }];
 }
+async function addErDiagramSheet(workbook, doc, labels, outDir) {
+  const sheet = workbook.addWorksheet(labels.erDiagramSheet);
+  sheet.mergeCells(1, 1, 1, 6);
+  const titleCell = sheet.getCell(1, 1);
+  titleCell.value = labels.erDiagramHeading;
+  titleCell.font = { bold: true, size: 14, color: { argb: COLOR.overviewFg } };
+  titleCell.fill = solidFill(COLOR.overviewBg);
+  titleCell.alignment = { horizontal: "center", vertical: "middle" };
+  sheet.getRow(1).height = 28;
+  let nextRow = 3;
+  try {
+    const { buffer: png, width, height } = await renderErDiagramPng(doc);
+    await writeFile2(join2(outDir, "er_diagram.png"), png);
+    const imageId = workbook.addImage({
+      base64: png.toString("base64"),
+      extension: "png"
+    });
+    const fitted = fitErDiagramToBox(width, height, 1100, 1200);
+    sheet.addImage(imageId, {
+      tl: { col: 0, row: 2 },
+      ext: fitted
+    });
+    nextRow = Math.max(28, Math.ceil(fitted.height / 18) + 4);
+  } catch {
+    sheet.getCell(3, 1).value = labels.viewErDiagram;
+    nextRow = 5;
+  }
+  const mermaid = getErDiagramMermaid(doc);
+  sheet.getCell(nextRow, 1).value = "Mermaid source";
+  sheet.getCell(nextRow, 1).font = { bold: true, color: { argb: COLOR.metaFg } };
+  nextRow += 1;
+  sheet.mergeCells(nextRow, 1, nextRow + 20, 6);
+  const sourceCell = sheet.getCell(nextRow, 1);
+  sourceCell.value = mermaid;
+  sourceCell.alignment = { wrapText: true, vertical: "top" };
+  sourceCell.font = { name: "Courier New", size: 9 };
+  sheet.columns = [
+    { width: 24 },
+    { width: 24 },
+    { width: 24 },
+    { width: 24 },
+    { width: 24 },
+    { width: 24 }
+  ];
+}
 function populateTableSheet(sheet, table, doc, labels) {
   const indexes = collectTableIndexes(table, doc);
   sheet.mergeCells(1, 1, 1, 6);
@@ -372,48 +956,39 @@ function populateTableSheet(sheet, table, doc, labels) {
     row.getCell(2).alignment = { wrapText: true, vertical: "top" };
   }
   sheet.addRow([]);
-  const headerRow = sheet.addRow([
-    labels.physicalName,
-    labels.logicalName,
-    labels.type,
-    labels.required,
-    labels.defaultValue,
-    labels.notes
-  ]);
+  const headerRow = sheet.addRow(columnDefinitionHeaders(labels));
   styleColorRow(headerRow, COLOR.headerBg, COLOR.headerFg);
-  applyBorderToRow(headerRow, 6);
+  applyBorderToRow(headerRow, A5_COLUMN_COUNT);
   const headerRowNum = headerRow.number;
   for (const [i, column] of table.columns.entries()) {
-    const markers = [];
-    if (column.isPrimaryKey) markers.push(labels.pkMarker);
-    if (column.isForeignKey) markers.push(labels.fkMarker);
-    const notes = [markers.join(", "), column.description?.value ?? ""].filter(Boolean).join(" | ");
-    const row = sheet.addRow([
-      column.name,
-      displayValue(column.comment, labels),
-      column.type,
-      column.nullable ? labels.no : labels.yes,
-      column.defaultValue ?? "-",
-      notes || "-"
-    ]);
+    const row = sheet.addRow(
+      columnDefinitionRow(column, labels).map(
+        (value, index) => index === 1 ? displayValue(value, labels) : value
+      )
+    );
     if (column.isPrimaryKey) {
-      shadeRow(row, 6, COLOR.pkBg);
+      shadeRow(row, A5_COLUMN_COUNT, COLOR.pkBg);
       row.getCell(1).font = { bold: true };
     } else if (column.isForeignKey) {
-      shadeRow(row, 6, COLOR.fkBg);
+      shadeRow(row, A5_COLUMN_COUNT, COLOR.fkBg);
     } else if (i % 2 === 1) {
-      shadeRow(row, 6, COLOR.altRow);
+      shadeRow(row, A5_COLUMN_COUNT, COLOR.altRow);
     }
-    row.getCell(4).alignment = { horizontal: "center" };
-    applyBorderToRow(row, 6);
+    row.getCell(5).alignment = { horizontal: "center" };
+    row.getCell(9).alignment = { horizontal: "center" };
+    applyBorderToRow(row, A5_COLUMN_COUNT);
   }
   sheet.columns = [
+    { width: 22 },
     { width: 24 },
-    { width: 28 },
-    { width: 18 },
+    { width: 16 },
     { width: 10 },
-    { width: 18 },
-    { width: 36 }
+    { width: 8 },
+    { width: 14 },
+    { width: 8 },
+    { width: 8 },
+    { width: 8 },
+    { width: 28 }
   ];
   sheet.views = [{ state: "frozen", ySplit: headerRowNum }];
 }
@@ -484,7 +1059,7 @@ function collectTableIndexes(table, doc) {
 }
 
 // src/exporters/markdown/markdown-exporter.ts
-import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import { join as join3 } from "path";
 
 // src/core/sanitize.ts
@@ -498,8 +1073,16 @@ async function exportMarkdownDocs(doc, options) {
     const tablesDir = join3(options.outDir, "tables");
     await mkdir3(tablesDir, { recursive: true });
     const labels = getOutputLabels(options.language);
+    if (doc.tables.length > 0) {
+      const mermaid = getErDiagramMermaid(doc);
+      await writeFile3(
+        join3(options.outDir, "ER_DIAGRAM.md"),
+        renderErDiagramMarkdown(mermaid, labels),
+        "utf8"
+      );
+    }
     for (const table of doc.tables) {
-      await writeFile2(
+      await writeFile3(
         join3(tablesDir, `${sanitizeFilename(table.name)}.md`),
         renderTableDoc(table, doc, labels),
         "utf8"
@@ -546,12 +1129,12 @@ function renderTableDoc(table, doc, labels) {
   lines.push(`## ${labels.columnsHeading}`);
   lines.push("");
   lines.push(
-    `| ${labels.physicalName} | ${labels.logicalName} | ${labels.type} | ${labels.required} | ${labels.defaultValue} | ${labels.notes} |`
+    `| ${columnDefinitionHeaders(labels).join(" | ")} |`
   );
-  lines.push("|--------|--------|----|------|--------------|------|");
+  lines.push(`|${columnDefinitionHeaders(labels).map(() => "--------").join("|")}|`);
   for (const col of table.columns) {
     lines.push(
-      `| ${escapeMd(col.name)} | ${escapeMd(col.comment ?? "")} | ${escapeMd(col.type)} | ${col.nullable ? labels.no : labels.yes} | ${escapeMd(col.defaultValue ?? "-")} | ${escapeMd(col.description?.value ?? "")} |`
+      `| ${columnDefinitionRow(col, labels).map((value) => escapeMd(value)).join(" | ")} |`
     );
   }
   lines.push("");
@@ -570,7 +1153,7 @@ function escapeMd(text) {
 }
 
 // src/exporters/html/html-exporter.ts
-import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
 import { join as join4 } from "path";
 async function exportHtmlDocs(doc, options) {
   try {
@@ -578,13 +1161,21 @@ async function exportHtmlDocs(doc, options) {
     const tablesDir = join4(htmlDir, "tables");
     await mkdir4(tablesDir, { recursive: true });
     const labels = getOutputLabels(options.language);
-    await writeFile3(
+    await writeFile4(
       join4(htmlDir, "index.html"),
       renderIndexPage(doc, labels),
       "utf8"
     );
+    if (doc.tables.length > 0) {
+      const mermaid = getErDiagramMermaid(doc);
+      await writeFile4(
+        join4(htmlDir, "er-diagram.html"),
+        renderErDiagramHtmlPage(mermaid, labels),
+        "utf8"
+      );
+    }
     for (const table of doc.tables) {
-      await writeFile3(
+      await writeFile4(
         join4(tablesDir, `${sanitizeFilename(table.name)}.html`),
         renderTablePage(table, doc, labels),
         "utf8"
@@ -666,7 +1257,7 @@ function pageShell(title, body, fromSubdir = false) {
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${esc(title)}</title>
+  <title>${esc2(title)}</title>
   <style>${CSS}  </style>
 </head>
 <body>
@@ -683,34 +1274,35 @@ function renderIndexPage(doc, labels) {
     const fkCount = table.foreignKeys.length;
     const fileName = sanitizeFilename(table.name);
     tableRows += `      <tr>
-        <td><a href="tables/${fileName}.html">${esc(table.name)}</a></td>
-        <td>${esc(table.comment ?? "")}</td>
+        <td><a href="tables/${fileName}.html">${esc2(table.name)}</a></td>
+        <td>${esc2(table.comment ?? "")}</td>
         <td style="text-align:center">${table.columns.length}</td>
-        <td>${esc(pkCols)}</td>
+        <td>${esc2(pkCols)}</td>
         <td style="text-align:center">${fkCount}</td>
       </tr>
 `;
   }
   const body = `
-  <h1>${esc(labels.docTitle)}</h1>
+  <h1>${esc2(labels.docTitle)}</h1>
   <div class="summary">
-    <div class="summary-item"><div class="num">${doc.tables.length}</div><div class="lbl">${esc(labels.tablesLabel)}</div></div>
-    <div class="summary-item"><div class="num">${doc.relationships.length}</div><div class="lbl">${esc(labels.relationshipsLabel)}</div></div>
-    <div class="summary-item"><div class="num">${doc.dialect}</div><div class="lbl">${esc(labels.dialectLabel)}</div></div>
+    <div class="summary-item"><div class="num">${doc.tables.length}</div><div class="lbl">${esc2(labels.tablesLabel)}</div></div>
+    <div class="summary-item"><div class="num">${doc.relationships.length}</div><div class="lbl">${esc2(labels.relationshipsLabel)}</div></div>
+    <div class="summary-item"><div class="num">${doc.dialect}</div><div class="lbl">${esc2(labels.dialectLabel)}</div></div>
   </div>
-  <h2>${esc(labels.tableListHeading)}</h2>
+  <p class="back"><a href="er-diagram.html">${esc2(labels.erDiagramHeading)} \u2192</a></p>
+  <h2>${esc2(labels.tableListHeading)}</h2>
   <table class="table-list">
     <thead><tr>
-      <th>${esc(labels.tableLabel)}</th>
-      <th>${esc(labels.tableLogicalName)}</th>
+      <th>${esc2(labels.tableLabel)}</th>
+      <th>${esc2(labels.tableLogicalName)}</th>
       <th style="width:70px;text-align:center">Cols</th>
-      <th>${esc(labels.primaryKey)}</th>
+      <th>${esc2(labels.primaryKey)}</th>
       <th style="width:50px;text-align:center">FK</th>
     </tr></thead>
     <tbody>
 ${tableRows}    </tbody>
   </table>
-  <p class="note">${esc(labels.generatedNote)}</p>
+  <p class="note">${esc2(labels.generatedNote)}</p>
 `;
   return pageShell(labels.docTitle, body);
 }
@@ -728,39 +1320,34 @@ function renderTablePage(table, doc, labels) {
     const pkBadge = col.isPrimaryKey ? `<span class="badge badge-pk">PK</span>` : "";
     const fkBadge = col.isForeignKey ? `<span class="badge badge-fk">FK</span>` : "";
     const rowClass = col.isPrimaryKey ? "pk" : col.isForeignKey ? "fk" : "";
-    const required = col.nullable ? labels.no : labels.yes;
-    colRows += `      <tr${rowClass ? ` class="${rowClass}"` : ""}><td>${esc(col.name)}${pkBadge}${fkBadge}</td><td>${esc(col.comment ?? "")}</td><td>${esc(col.type)}</td><td>${required}</td><td>${esc(col.defaultValue ?? "-")}</td><td>${esc(col.description?.value ?? "")}</td></tr>
+    const cells = columnDefinitionRow(col, labels);
+    colRows += `      <tr${rowClass ? ` class="${rowClass}"` : ""}><td>${esc2(cells[0] ?? "")}${pkBadge}${fkBadge}</td>` + cells.slice(1).map((cell) => `<td>${esc2(cell)}</td>`).join("") + `</tr>
 `;
   }
   const body = `
-  <p class="back"><a href="../index.html">\u2190 ${esc(labels.tableListHeading)}</a></p>
-  <h1>${esc(table.name)}</h1>
-  <h2>${esc(labels.tableInfoHeading)}</h2>
+  <p class="back"><a href="../index.html">\u2190 ${esc2(labels.tableListHeading)}</a></p>
+  <h1>${esc2(table.name)}</h1>
+  <h2>${esc2(labels.tableInfoHeading)}</h2>
   <table class="meta">
     <tbody>
-      <tr><th>${esc(labels.tablePhysicalName)}</th><td>${esc(table.name)}</td></tr>
-      <tr><th>${esc(labels.tableLogicalName)}</th><td>${esc(table.comment ?? "")}</td></tr>
-      <tr><th>${esc(labels.schema)}</th><td>${esc(table.schema ?? "")}</td></tr>
-      <tr><th>${esc(labels.primaryKey)}</th><td>${esc(table.primaryKeys.join(", ") || labels.none)}</td></tr>
-      <tr><th>${esc(labels.foreignKeys)}</th><td>${foreignKeys}</td></tr>
-      <tr><th>${esc(labels.indexes)}</th><td>${indexText}</td></tr>
+      <tr><th>${esc2(labels.tablePhysicalName)}</th><td>${esc2(table.name)}</td></tr>
+      <tr><th>${esc2(labels.tableLogicalName)}</th><td>${esc2(table.comment ?? "")}</td></tr>
+      <tr><th>${esc2(labels.schema)}</th><td>${esc2(table.schema ?? "")}</td></tr>
+      <tr><th>${esc2(labels.primaryKey)}</th><td>${esc2(table.primaryKeys.join(", ") || labels.none)}</td></tr>
+      <tr><th>${esc2(labels.foreignKeys)}</th><td>${foreignKeys}</td></tr>
+      <tr><th>${esc2(labels.indexes)}</th><td>${indexText}</td></tr>
     </tbody>
   </table>
 
-  <h2>${esc(labels.columnsHeading)}</h2>
+  <h2>${esc2(labels.columnsHeading)}</h2>
   <table class="columns">
     <thead><tr>
-      <th>${esc(labels.physicalName)}</th>
-      <th>${esc(labels.logicalName)}</th>
-      <th>${esc(labels.type)}</th>
-      <th>${esc(labels.required)}</th>
-      <th>${esc(labels.defaultValue)}</th>
-      <th>${esc(labels.notes)}</th>
+      ${columnDefinitionHeaders(labels).map((header) => `<th>${esc2(header)}</th>`).join("\n      ")}
     </tr></thead>
     <tbody>
 ${colRows}    </tbody>
   </table>
-  <p class="note">${esc(labels.generatedNote)}</p>
+  <p class="note">${esc2(labels.generatedNote)}</p>
 `;
   return pageShell(table.name, body);
 }
@@ -772,12 +1359,12 @@ function collectTableIndexes3(table, doc) {
     )
   ];
 }
-function esc(text) {
+function esc2(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 
 // src/exporters/word/word-exporter.ts
-import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
 import { join as join5 } from "path";
 import {
   Document,
@@ -787,7 +1374,8 @@ import {
   TableCell,
   TableRow,
   TextRun,
-  HeadingLevel
+  HeadingLevel,
+  ImageRun
 } from "docx";
 async function exportWordDocument(doc, options) {
   try {
@@ -821,6 +1409,53 @@ async function exportWordDocument(doc, options) {
         children: [new TextRun(`${labels.relationshipsLabel}: ${doc.relationships.length}`)]
       })
     );
+    if (doc.tables.length > 0) {
+      children.push(
+        new Paragraph({
+          heading: HeadingLevel.HEADING_2,
+          children: [new TextRun(labels.erDiagramHeading)]
+        })
+      );
+      try {
+        const { buffer: png, width, height } = await renderErDiagramPng(doc);
+        await writeFile5(join5(options.outDir, "er_diagram.png"), png);
+        const fitted = fitErDiagramToBox(width, height, 620, 900);
+        children.push(
+          new Paragraph({
+            children: [
+              new ImageRun({
+                data: png,
+                transformation: fitted,
+                type: "png"
+              })
+            ]
+          })
+        );
+      } catch {
+        children.push(
+          new Paragraph({
+            children: [new TextRun(labels.viewErDiagram)]
+          })
+        );
+      }
+      const mermaid = getErDiagramMermaid(doc);
+      children.push(
+        new Paragraph({
+          children: [new TextRun({ text: "Mermaid source", bold: true })]
+        })
+      );
+      children.push(
+        new Paragraph({
+          children: [
+            new TextRun({
+              text: mermaid,
+              font: "Courier New",
+              size: 18
+            })
+          ]
+        })
+      );
+    }
     children.push(
       new Paragraph({
         heading: HeadingLevel.HEADING_2,
@@ -1021,7 +1656,7 @@ async function exportWordDocument(doc, options) {
       sections: [{ children }]
     });
     const buffer = await Packer.toBuffer(wordDoc);
-    await writeFile4(join5(options.outDir, "database_document.docx"), buffer);
+    await writeFile5(join5(options.outDir, "database_document.docx"), buffer);
   } catch (err) {
     throw new Error(
       `Failed to export Word document: ${err instanceof Error ? err.message : String(err)}`,
@@ -1080,14 +1715,7 @@ function renderTableDetail(table, doc, labels) {
   return items;
 }
 function renderColumnsTable(table, labels) {
-  const headerCells = [
-    labels.physicalName,
-    labels.logicalName,
-    labels.type,
-    labels.required,
-    labels.defaultValue,
-    labels.notes
-  ].map(
+  const headerCells = columnDefinitionHeaders(labels).map(
     (h) => new TableCell({
       children: [
         new Paragraph({ children: [new TextRun({ text: h, bold: true })] })
@@ -1098,40 +1726,11 @@ function renderColumnsTable(table, labels) {
   for (const col of table.columns) {
     colRows.push(
       new TableRow({
-        children: [
-          new TableCell({
-            children: [new Paragraph({ children: [new TextRun(col.name)] })]
-          }),
-          new TableCell({
-            children: [
-              new Paragraph({ children: [new TextRun(col.comment ?? "")] })
-            ]
-          }),
-          new TableCell({
-            children: [new Paragraph({ children: [new TextRun(col.type)] })]
-          }),
-          new TableCell({
-            children: [
-              new Paragraph({
-                children: [new TextRun(col.nullable ? labels.no : labels.yes)]
-              })
-            ]
-          }),
-          new TableCell({
-            children: [
-              new Paragraph({
-                children: [new TextRun(col.defaultValue ?? "-")]
-              })
-            ]
-          }),
-          new TableCell({
-            children: [
-              new Paragraph({
-                children: [new TextRun(col.description?.value ?? "")]
-              })
-            ]
+        children: columnDefinitionRow(col, labels).map(
+          (value) => new TableCell({
+            children: [new Paragraph({ children: [new TextRun(value)] })]
           })
-        ]
+        )
       })
     );
   }
@@ -1179,6 +1778,221 @@ function createWarning(code, message, target) {
   };
 }
 
+// src/parsers/sql/column-meta.ts
+function normalizeColumnType(definition) {
+  if (typeof definition !== "object" || definition === null) {
+    return { type: String(definition ?? "unknown").toLowerCase() };
+  }
+  const def = definition;
+  const base = String(def.dataType ?? def.type ?? def.name ?? "unknown").toLowerCase();
+  if (String(def.dataType ?? "").toUpperCase() === "ENUM") {
+    const values = extractEnumValues(def.expr);
+    if (values.length > 0) {
+      const joined = values.join(", ");
+      return {
+        type: `${base}(${values.map((v) => `'${v}'`).join(",")})`,
+        size: String(values.length)
+      };
+    }
+  }
+  if (def.length !== void 0 && def.length !== null) {
+    const length = formatAstValue(def.length);
+    if (def.scale !== void 0 && def.scale !== null) {
+      const scale = formatAstValue(def.scale);
+      return {
+        type: `${base}(${length},${scale})`,
+        size: `${length},${scale}`
+      };
+    }
+    return {
+      type: `${base}(${length})`,
+      size: length
+    };
+  }
+  const suffix = Array.isArray(def.suffix) ? def.suffix.map((item) => formatAstValue(item)).filter(Boolean).join(" ") : def.suffix ? formatAstValue(def.suffix) : "";
+  return {
+    type: suffix ? `${base} ${suffix}`.trim() : base
+  };
+}
+function extractColumnComment(definition) {
+  const comment = definition.comment;
+  if (!comment) return void 0;
+  const value = comment.value;
+  if (value?.value !== void 0) return String(value.value);
+  if (comment.value !== void 0 && typeof comment.value === "string") {
+    return comment.value;
+  }
+  return void 0;
+}
+function hasColumnUnique(definition) {
+  return definition.unique === "unique" || definition.unique === true;
+}
+function extractColumnConstraintNotes(definition) {
+  const notes = [];
+  if (definition.auto_increment === "auto_increment" || definition.auto_increment === true) {
+    notes.push("AUTO_INCREMENT");
+  }
+  if (definition.on_update) {
+    notes.push(`ON UPDATE ${formatOnUpdate(definition.on_update)}`);
+  }
+  const generated = definition.generated;
+  if (generated) {
+    const storage = String(generated.storage_type ?? "virtual").toUpperCase();
+    const expression = stringifyGeneratedExpression(generated.expr);
+    notes.push(
+      expression ? `GENERATED ALWAYS ${storage}: ${expression}` : `GENERATED ALWAYS ${storage}`
+    );
+  }
+  const enumValues = extractEnumValues(definition.definition?.expr);
+  if (enumValues.length > 0) {
+    notes.push(`ENUM: ${enumValues.join(", ")}`);
+  }
+  return notes;
+}
+function extractEnumValues(expr) {
+  if (!expr || typeof expr !== "object") return [];
+  const object = expr;
+  if (object.type !== "expr_list" || !Array.isArray(object.value)) return [];
+  return object.value.map((item) => {
+    if (!item || typeof item !== "object") return "";
+    const entry = item;
+    return entry.value !== void 0 ? String(entry.value) : "";
+  }).filter(Boolean);
+}
+function formatOnUpdate(value) {
+  if (!value || typeof value !== "object") return String(value ?? "");
+  const object = value;
+  if (object.type === "function" && object.name) {
+    const name = object.name;
+    const parts = Array.isArray(name.name) ? name.name : [];
+    return parts.map((part) => String(part.value ?? "")).join("") || "CURRENT_TIMESTAMP";
+  }
+  return formatAstValue(value);
+}
+function stringifyGeneratedExpression(expr) {
+  if (!expr || typeof expr !== "object") return void 0;
+  const text = stringifyExpression(expr);
+  return text === "check" ? void 0 : text;
+}
+function extractCheckBounds(expression, columnName) {
+  const result = {};
+  walkCheckExpression(expression, columnName, result);
+  return result;
+}
+function walkCheckExpression(expression, columnName, result) {
+  if (!expression || typeof expression !== "object") return;
+  const expr = expression;
+  if (expr.type === "binary_expr") {
+    const operator = String(expr.operator ?? "").toUpperCase();
+    if (operator === "AND" || operator === "OR") {
+      walkCheckExpression(expr.left, columnName, result);
+      walkCheckExpression(expr.right, columnName, result);
+      return;
+    }
+    const columnRef = findColumnRef(expr.left) ?? findColumnRef(expr.right);
+    if (columnRef !== columnName) return;
+    const bound = readBound(expr, columnName);
+    if (!bound) return;
+    if (bound.kind === "min") {
+      result.minValue = mergeBound(result.minValue, bound.value, "max");
+    } else {
+      result.maxValue = mergeBound(result.maxValue, bound.value, "min");
+    }
+    return;
+  }
+  result.expression ??= stringifyExpression(expr);
+}
+function readBound(expr, columnName) {
+  const operator = String(expr.operator ?? "");
+  const left = expr.left;
+  const right = expr.right;
+  if (findColumnRef(left) === columnName) {
+    if (operator === ">=" || operator === ">") {
+      return { kind: "min", value: formatAstValue(right) };
+    }
+    if (operator === "<=" || operator === "<") {
+      return { kind: "max", value: formatAstValue(right) };
+    }
+  }
+  if (findColumnRef(right) === columnName) {
+    if (operator === ">=" || operator === ">") {
+      return { kind: "max", value: formatAstValue(left) };
+    }
+    if (operator === "<=" || operator === "<") {
+      return { kind: "min", value: formatAstValue(left) };
+    }
+  }
+  return void 0;
+}
+function mergeBound(current, next, pick) {
+  if (!current) return next;
+  const currentNum = Number(current);
+  const nextNum = Number(next);
+  if (!Number.isNaN(currentNum) && !Number.isNaN(nextNum)) {
+    return pick === "min" ? String(Math.max(currentNum, nextNum)) : String(Math.min(currentNum, nextNum));
+  }
+  return next;
+}
+function findColumnRef(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const expr = value;
+  if (expr.type === "column_ref" && expr.column) {
+    return String(expr.column);
+  }
+  return void 0;
+}
+function formatAstValue(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") {
+    const object = value;
+    if (object.value !== void 0) return String(object.value);
+    if (object.dataType) return normalizeColumnType(object).type;
+  }
+  return String(value);
+}
+function stringifyExpression(expr) {
+  if (expr.type === "binary_expr") {
+    const left = stringifyExpression(expr.left ?? {});
+    const right = stringifyExpression(expr.right ?? {});
+    return `${left} ${expr.operator} ${right}`.trim();
+  }
+  if (expr.type === "column_ref") return String(expr.column ?? "");
+  if (expr.value !== void 0) return formatAstValue(expr);
+  return "check";
+}
+function extractConstraintColumnNames(definition) {
+  return extractDeepColumnNames(definition);
+}
+function extractDeepColumnNames(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    if (typeof item !== "object" || item === null) return String(item ?? "unknown");
+    const object = item;
+    if (object.column !== void 0) return String(object.column);
+    if (object.expr) return extractDeepColumnName(object.expr);
+    return String(object.name ?? "unknown");
+  });
+}
+function extractDeepColumnName(value) {
+  if (typeof value !== "object" || value === null) {
+    return String(value ?? "unknown");
+  }
+  const object = value;
+  if (object.expr) return extractDeepColumnName(object.expr);
+  if (object.column && typeof object.column === "object") {
+    return extractDeepColumnName(object.column);
+  }
+  if (object.column !== void 0) return String(object.column);
+  return String(object.name ?? "unknown");
+}
+function stringifyCheckDefinition(definition) {
+  if (!Array.isArray(definition) || definition.length === 0) return void 0;
+  if (definition.length === 1) {
+    return stringifyExpression(definition[0]);
+  }
+  return definition.map((item) => stringifyExpression(item)).filter(Boolean).join("; ");
+}
+
 // src/parsers/sql/sql-normalizer.ts
 function normalizeSqlAst(ast, dialect) {
   const statements = Array.isArray(ast) ? ast : [ast];
@@ -1200,7 +2014,11 @@ function normalizeSqlAst(ast, dialect) {
   }
   for (const index of indexes) {
     const table = tables.find((candidate) => candidate.name === index.table);
-    table?.indexes.push(index);
+    if (!table) continue;
+    table.indexes.push(index);
+    if (index.unique) {
+      markColumnsUnique(table, index.columns, `INDEX ${index.name}`);
+    }
   }
   return {
     dialect,
@@ -1222,31 +2040,49 @@ function normalizeCreateTable(statement) {
     reviewTodos: []
   };
   for (const definition of createDefinitions) {
-    if (definition.resource === "column") {
-      const columnName = extractDeepColumnName(definition.column);
-      const isPrimaryKey = hasPrimaryKey(definition);
-      const isNotNull = hasNotNull(definition);
-      table.columns.push({
-        name: columnName,
-        type: normalizeType(definition.definition),
-        nullable: !isNotNull && !isPrimaryKey,
-        defaultValue: extractDefaultFromDef(definition),
-        isPrimaryKey,
-        isForeignKey: false
-      });
-      if (isPrimaryKey) table.primaryKeys.push(columnName);
+    if (definition.resource !== "column") continue;
+    const columnName = extractDeepColumnName2(definition.column);
+    const isPrimaryKey = hasPrimaryKey(definition);
+    const isNotNull = hasNotNull(definition);
+    const { type, size } = normalizeColumnType(definition.definition);
+    const check = definition.check;
+    const bounds = check?.definition ? extractCheckBounds(check.definition, columnName) : {};
+    const constraintNotes = extractColumnConstraintNotes(definition);
+    if (check?.definition) {
+      const expression = stringifyCheckDefinition(check.definition);
+      if (expression && (!bounds.minValue || !bounds.maxValue)) {
+        constraintNotes.push(`CHECK: ${expression}`);
+      }
     }
-    if (definition.resource === "constraint" && isConstraintType(definition.constraint_type, "PRIMARY KEY")) {
-      table.primaryKeys = extractDeepColumnNames(definition.definition);
+    table.columns.push({
+      name: columnName,
+      type,
+      size,
+      nullable: !isNotNull && !isPrimaryKey,
+      defaultValue: extractDefaultFromDef(definition),
+      minValue: bounds.minValue,
+      maxValue: bounds.maxValue,
+      isUnique: hasColumnUnique(definition),
+      isPrimaryKey,
+      isForeignKey: false,
+      comment: extractColumnComment(definition),
+      constraintNotes: constraintNotes.length > 0 ? constraintNotes : void 0
+    });
+    if (isPrimaryKey) table.primaryKeys.push(columnName);
+  }
+  for (const definition of createDefinitions) {
+    if (definition.resource !== "constraint") continue;
+    if (isConstraintType(definition.constraint_type, "PRIMARY KEY")) {
+      table.primaryKeys = extractDeepColumnNames2(definition.definition);
       for (const column of table.columns) {
         if (table.primaryKeys.includes(column.name)) column.isPrimaryKey = true;
       }
     }
-    if (definition.resource === "constraint" && isConstraintType(definition.constraint_type, "FOREIGN KEY")) {
-      const columns = extractDeepColumnNames(definition.definition);
+    if (isConstraintType(definition.constraint_type, "FOREIGN KEY")) {
+      const columns = extractDeepColumnNames2(definition.definition);
       const refDef = definition.reference_definition;
       const referencedTable = extractTableName(refDef?.table);
-      const referencedColumns = extractDeepColumnNames(refDef?.definition);
+      const referencedColumns = extractDeepColumnNames2(refDef?.definition);
       table.foreignKeys.push({
         name: typeof definition.constraint === "string" ? definition.constraint : void 0,
         columns,
@@ -1257,14 +2093,71 @@ function normalizeCreateTable(statement) {
         if (columns.includes(column.name)) column.isForeignKey = true;
       }
     }
+    if (isConstraintType(definition.constraint_type, "UNIQUE")) {
+      const columns = extractConstraintColumnNames(definition.definition);
+      const label = typeof definition.constraint === "string" ? definition.constraint : "UNIQUE";
+      markColumnsUnique(table, columns, label);
+    }
+    if (isConstraintType(definition.constraint_type, "CHECK")) {
+      applyTableCheckConstraint(table, definition);
+    }
   }
   return table;
 }
+function markColumnsUnique(table, columns, label) {
+  const composite = columns.length > 1;
+  for (const columnName of columns) {
+    const column = table.columns.find((item) => item.name === columnName);
+    if (!column) continue;
+    column.isUnique = true;
+    if (composite) {
+      addConstraintNote(
+        column,
+        `UNIQUE (${label}: ${columns.join(", ")})`
+      );
+    }
+  }
+}
+function applyTableCheckConstraint(table, definition) {
+  const expression = stringifyCheckDefinition(definition.definition);
+  if (!expression) return;
+  const referencedColumns = /* @__PURE__ */ new Set();
+  for (const column of table.columns) {
+    const bounds = extractCheckBounds(definition.definition, column.name);
+    if (bounds.minValue) column.minValue = bounds.minValue;
+    if (bounds.maxValue) column.maxValue = bounds.maxValue;
+    if (bounds.minValue || bounds.maxValue) {
+      referencedColumns.add(column.name);
+      continue;
+    }
+    if (expression.includes(column.name)) {
+      referencedColumns.add(column.name);
+    }
+  }
+  if (referencedColumns.size === 0) {
+    for (const column of table.columns) {
+      addConstraintNote(column, `CHECK: ${expression}`);
+    }
+    return;
+  }
+  for (const columnName of referencedColumns) {
+    const column = table.columns.find((item) => item.name === columnName);
+    if (!column) continue;
+    if (!column.minValue && !column.maxValue) {
+      addConstraintNote(column, `CHECK: ${expression}`);
+    }
+  }
+}
+function addConstraintNote(column, note) {
+  const notes = column.constraintNotes ?? [];
+  if (!notes.includes(note)) notes.push(note);
+  column.constraintNotes = notes;
+}
 function normalizeCreateIndex(statement) {
   return {
     name: String(statement.index ?? statement.index_name ?? "unnamed_index"),
     table: extractTableName(statement.table),
-    columns: extractDeepColumnNames(
+    columns: extractDeepColumnNames2(
       statement.index_columns ?? statement.columns
     ),
     unique: Boolean(statement.unique)
@@ -1318,15 +2211,15 @@ function extractTableName(value) {
   }
   return String(value ?? "unknown");
 }
-function extractDeepColumnName(value) {
+function extractDeepColumnName2(value) {
   if (typeof value !== "object" || value === null)
     return String(value ?? "unknown");
   const object = value;
   if (object.expr && typeof object.expr === "object") {
-    return extractDeepColumnName(object.expr);
+    return extractDeepColumnName2(object.expr);
   }
   if (object.column && typeof object.column === "object") {
-    return extractDeepColumnName(object.column);
+    return extractDeepColumnName2(object.column);
   }
   if (object.value !== void 0) {
     return String(object.value);
@@ -1336,18 +2229,9 @@ function extractDeepColumnName(value) {
   }
   return String(object.name ?? object.tableName ?? "unknown");
 }
-function extractDeepColumnNames(value) {
+function extractDeepColumnNames2(value) {
   if (!Array.isArray(value)) return [];
-  return value.map((item) => extractDeepColumnName(item));
-}
-function normalizeType(value) {
-  if (typeof value === "object" && value !== null) {
-    const object = value;
-    return String(
-      object.dataType ?? object.type ?? object.name ?? "unknown"
-    ).toLowerCase();
-  }
-  return String(value ?? "unknown").toLowerCase();
+  return value.map((item) => extractDeepColumnName2(item));
 }
 function hasPrimaryKey(def) {
   if (def.primary_key) return true;
@@ -1627,6 +2511,27 @@ async function generateDbDocs(options) {
   return doc;
 }
 
+// src/core/output-path.ts
+import { basename, join as join6 } from "path";
+var OUTPUT_RUN_DIR_PREFIX = "db_doc_gen_";
+function createTimestampedRunName(date = /* @__PURE__ */ new Date()) {
+  const year = String(date.getFullYear()).slice(-2);
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${OUTPUT_RUN_DIR_PREFIX}${year}${month}${day}${hours}${minutes}`;
+}
+function resolveGenerateOutDir(parentDir, date = /* @__PURE__ */ new Date()) {
+  return join6(parentDir, createTimestampedRunName(date));
+}
+function isOutputRunDir(path) {
+  return basename(path).startsWith(OUTPUT_RUN_DIR_PREFIX);
+}
+function isOutputRunDirName(name) {
+  return name.startsWith(OUTPUT_RUN_DIR_PREFIX);
+}
+
 // src/cli/index.ts
 var DEFAULT_CONFIG_PATH = "dbdocgen.config.json";
 var program = new Command();
@@ -1639,14 +2544,17 @@ program.command("init").description("Create a default config file").option("-f,
   }
   const defaultConfig = {
     schema: "./database/schema.sql",
+    outDir: "./output",
     output: {
       formats: ["excel", "markdown", "html", "diagram", "word"],
       language: "en"
     }
   };
-  await writeFile5(configPath, JSON.stringify(defaultConfig, null, 2), "utf8");
+  await writeFile6(configPath, JSON.stringify(defaultConfig, null, 2), "utf8");
   console.log(`Created config at ${configPath}`);
-  console.log("Default generate output directory is ./output/db_doc_gen_{yymmddhhmm} unless you pass --out.");
+  console.log(
+    "Each generate run writes to {outDir}/db_doc_gen_{yymmddhhmm} (outDir defaults to ./output)."
+  );
   console.log("Edit the file to configure your database schema path and output formats.");
 });
 var configCommand = program.command("config").description("Manage configuration");
@@ -1676,7 +2584,7 @@ configCommand.command("validate").description("Validate config file").option("--
     process.exitCode = 1;
   }
 });
-program.command("generate").description("Generate database documentation").option("--schema <path>", "Path to schema.sql").option("--out <path>", "Output directory").option("--format <formats>", "Comma-separated output formats").option("--config <path>", "Config file path").action(async (rawOptions) => {
+program.command("generate").description("Generate database documentation").option("--schema <path>", "Path to schema.sql").option("--out <path>", "Parent output directory (run folder: db_doc_gen_{yymmddhhmm})").option("--format <formats>", "Comma-separated output formats").option("--config <path>", "Config file path").action(async (rawOptions) => {
   console.log("[dbdocgen] Loading configuration...");
   const config = await loadConfig({
     cwd: process.cwd(),
@@ -1687,9 +2595,11 @@ program.command("generate").description("Generate database documentation").optio
       configPath: rawOptions.config
     }
   });
-  const outDir = rawOptions.out ?? createTimestampedOutputDir();
+  const parentOutDir = config.outDir;
+  const outDir = resolveGenerateOutDir(parentOutDir);
   console.log("[dbdocgen] Configuration loaded");
   console.log(`  schema: ${config.schema}`);
+  console.log(`  outputParent: ${parentOutDir}`);
   console.log(`  outDir: ${outDir}`);
   console.log(`  formats: ${config.output.formats.join(", ")}`);
   console.log(`  language: ${config.output.language}`);
@@ -1759,7 +2669,7 @@ Found ${doc.tables.length} table(s):
   }
   console.log("Schema validation passed.");
 });
-program.command("clean").description("Clean output directory").option("--out <path>", "Output directory to clean").option("--config <path>", "Config file path").action(async (rawOptions) => {
+program.command("clean").description("Clean output directory").option("--out <path>", "Parent output directory or a specific db_doc_gen_* run folder").option("--config <path>", "Config file path").action(async (rawOptions) => {
   const config = await loadConfig({
     cwd: process.cwd(),
     cliOptions: {
@@ -1767,13 +2677,29 @@ program.command("clean").description("Clean output directory").option("--out <pa
       configPath: rawOptions.config
     }
   });
-  const outDir = resolve(config.outDir);
-  if (!existsSync(outDir)) {
-    console.log(`Output directory ${outDir} does not exist. Nothing to clean.`);
+  const target = resolve(config.outDir);
+  if (!existsSync(target)) {
+    console.log(`Output path ${target} does not exist. Nothing to clean.`);
+    return;
+  }
+  if (isOutputRunDir(target)) {
+    console.log(`Cleaning ${target}...`);
+    await rm(target, { recursive: true, force: true });
+    console.log("Done.");
     return;
   }
-  console.log(`Cleaning ${outDir}...`);
-  await rm(outDir, { recursive: true, force: true });
+  const entries = await readdir(target, { withFileTypes: true });
+  const runDirs = entries.filter(
+    (entry) => entry.isDirectory() && isOutputRunDirName(entry.name)
+  );
+  if (runDirs.length === 0) {
+    console.log(`No db_doc_gen_* folders found under ${target}.`);
+    return;
+  }
+  console.log(`Cleaning ${runDirs.length} run folder(s) under ${target}...`);
+  for (const entry of runDirs) {
+    await rm(resolve(target, entry.name), { recursive: true, force: true });
+  }
   console.log("Done.");
 });
 program.command("info").description("Show project info and supported features").action(() => {
@@ -1819,12 +2745,4 @@ function parseFormats(value) {
   }
   return valid.length > 0 ? valid : void 0;
 }
-function createTimestampedOutputDir(date = /* @__PURE__ */ new Date()) {
-  const year = String(date.getFullYear()).slice(-2);
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  return `./output/db_doc_gen_${year}${month}${day}${hours}${minutes}`;
-}
 //# sourceMappingURL=index.js.map