@cuongph.dev/dbdocgen 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,1844 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var import_promises7 = require("fs/promises");
+var import_node_fs = require("fs");
+var import_node_path6 = require("path");
+
+// src/core/config/loader.ts
+var import_cosmiconfig = require("cosmiconfig");
+
+// src/core/config/schema.ts
+var import_zod = require("zod");
+var dialectSchema = import_zod.z.enum([
+  "postgres",
+  "mysql",
+  "mariadb",
+  "sqlite",
+  "mssql",
+  "unknown"
+]);
+var outputFormatSchema = import_zod.z.enum([
+  "excel",
+  "markdown",
+  "html",
+  "diagram",
+  "word"
+]);
+var outputLanguageSchema = import_zod.z.enum(["en", "jp"]);
+var dbdocgenConfigSchema = import_zod.z.object({
+  schema: import_zod.z.string().default("./schema.sql"),
+  dialect: dialectSchema.optional(),
+  outDir: import_zod.z.string().default("./docs/db"),
+  output: import_zod.z.object({
+    formats: import_zod.z.array(outputFormatSchema).default(["excel", "markdown", "html", "diagram", "word"]),
+    language: outputLanguageSchema.default("en")
+  }).default({})
+});
+
+// src/core/config/loader.ts
+async function loadConfig(input) {
+  const explorer = (0, import_cosmiconfig.cosmiconfig)("dbdocgen", {
+    searchPlaces: ["dbdocgen.config.js", "dbdocgen.config.json", ".dbdocgenrc"]
+  });
+  const result = input.cliOptions.configPath ? await explorer.load(input.cliOptions.configPath) : await explorer.search(input.cwd);
+  const fileConfig = result?.config ?? {};
+  const merged = mergeConfig(fileConfig, input.cliOptions);
+  return dbdocgenConfigSchema.parse(merged);
+}
+function mergeConfig(fileConfig, cli) {
+  return {
+    ...fileConfig,
+    schema: cli.schema ?? fileConfig.schema,
+    dialect: cli.dialect ?? fileConfig.dialect,
+    outDir: cli.outDir ?? fileConfig.outDir,
+    output: {
+      ...fileConfig.output,
+      formats: cli.formats ?? fileConfig.output?.formats
+    }
+  };
+}
+
+// src/core/pipeline/generate-db-docs.ts
+var import_promises6 = require("fs/promises");
+
+// src/exporters/diagram/mermaid-exporter.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+async function exportMermaidDiagram(doc, options) {
+  await (0, import_promises.mkdir)(options.outDir, { recursive: true });
+  await (0, import_promises.writeFile)(
+    (0, import_node_path.join)(options.outDir, "er_diagram.mmd"),
+    renderMermaid(doc),
+    "utf8"
+  );
+}
+function renderMermaid(doc) {
+  const lines = ["erDiagram"];
+  for (const warning of doc.warnings) {
+    const target = warning.target ? ` (${warning.target})` : "";
+    lines.push(
+      `  %% WARNING [${warning.severity}] ${warning.code}${target}: ${warning.message}`
+    );
+  }
+  for (const table of doc.tables) {
+    for (const todo of table.reviewTodos) {
+      lines.push(`  %% TODO [${todo.type}] ${todo.target}: ${todo.issue}`);
+    }
+    lines.push(`  ${table.name} {`);
+    for (const column of table.columns) {
+      const markers = [
+        column.isPrimaryKey ? "PK" : "",
+        column.isForeignKey ? "FK" : ""
+      ].filter(Boolean).join(" ");
+      lines.push(
+        `    ${sanitizeType(column.type)} ${column.name}${markers ? ` "${markers}"` : ""}`
+      );
+    }
+    lines.push("  }");
+  }
+  for (const relationship of doc.relationships.filter(
+    (item) => item.source === "schema"
+  )) {
+    lines.push(
+      `  ${relationship.toTable} ||--o{ ${relationship.fromTable} : "${relationship.constraintName ?? relationship.fromColumn}"`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function sanitizeType(type) {
+  return type.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+// src/exporters/excel/excel-exporter.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_exceljs = __toESM(require("exceljs"), 1);
+
+// src/exporters/shared/output-labels.ts
+var LABELS = {
+  en: {
+    docTitle: "Database Documentation",
+    tableInfoHeading: "Table Info",
+    columnsHeading: "Columns",
+    metaField: "Field",
+    metaValue: "Value",
+    tablePhysicalName: "Table Physical Name",
+    tableLogicalName: "Table Logical Name",
+    schema: "Schema",
+    primaryKey: "Primary Key",
+    foreignKeys: "Foreign Keys",
+    indexes: "Indexes",
+    none: "(none)",
+    physicalName: "Physical Name",
+    logicalName: "Logical Name",
+    type: "Type",
+    required: "Required",
+    defaultValue: "Default Value",
+    notes: "Notes",
+    yes: "Yes",
+    no: "No",
+    generatedNote: "Generated by dbdocgen in A5:SQL-style layout.",
+    overviewHeading: "Overview",
+    tableListHeading: "Table List",
+    relationshipsHeading: "Relationships",
+    warningsHeading: "Warnings",
+    tableLabel: "Table",
+    descriptionLabel: "Description",
+    dialectLabel: "Dialect",
+    tablesLabel: "Tables",
+    relationshipsLabel: "Relationships",
+    severity: "Severity",
+    code: "Code",
+    target: "Target",
+    message: "Message",
+    fromTable: "From Table",
+    fromColumn: "From Column",
+    toTable: "To Table",
+    toColumn: "To Column",
+    constraint: "Constraint",
+    source: "Source",
+    needsReview: "Needs Review",
+    columnsCount: "Columns",
+    rowNo: "#",
+    backToOverview: "\u2190 Overview",
+    pkMarker: "PK",
+    fkMarker: "FK"
+  },
+  jp: {
+    docTitle: "Database Documentation",
+    tableInfoHeading: "Table Info",
+    columnsHeading: "Columns",
+    metaField: "\u9805\u76EE",
+    metaValue: "\u5024",
+    tablePhysicalName: "\u30C6\u30FC\u30D6\u30EB\u7269\u7406\u540D",
+    tableLogicalName: "\u30C6\u30FC\u30D6\u30EB\u8AD6\u7406\u540D",
+    schema: "\u30B9\u30AD\u30FC\u30DE",
+    primaryKey: "\u4E3B\u30AD\u30FC",
+    foreignKeys: "\u5916\u90E8\u30AD\u30FC",
+    indexes: "\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9",
+    none: "(none)",
+    physicalName: "\u7269\u7406\u540D",
+    logicalName: "\u8AD6\u7406\u540D",
+    type: "\u578B",
+    required: "\u5FC5\u9808",
+    defaultValue: "\u30C7\u30D5\u30A9\u30EB\u30C8\u5024",
+    notes: "\u5099\u8003",
+    yes: "Yes",
+    no: "No",
+    generatedNote: "Generated by dbdocgen in A5:SQL-style layout.",
+    overviewHeading: "Overview",
+    tableListHeading: "Table List",
+    relationshipsHeading: "Relationships",
+    warningsHeading: "Warnings",
+    tableLabel: "Table",
+    descriptionLabel: "Description",
+    dialectLabel: "Dialect",
+    tablesLabel: "Tables",
+    relationshipsLabel: "Relationships",
+    severity: "Severity",
+    code: "Code",
+    target: "Target",
+    message: "Message",
+    fromTable: "From Table",
+    fromColumn: "From Column",
+    toTable: "To Table",
+    toColumn: "To Column",
+    constraint: "Constraint",
+    source: "Source",
+    needsReview: "Needs Review",
+    columnsCount: "\u5217\u6570",
+    rowNo: "No.",
+    backToOverview: "\u2190 \u4E00\u89A7",
+    pkMarker: "PK",
+    fkMarker: "FK"
+  }
+};
+function getOutputLabels(language = "en") {
+  return LABELS[language];
+}
+
+// src/exporters/excel/excel-exporter.ts
+var COLOR = {
+  headerBg: "FF4472C4",
+  headerFg: "FFFFFFFF",
+  metaBg: "FFD9E1F2",
+  metaFg: "FF1F3864",
+  overviewBg: "FF4472C4",
+  overviewFg: "FFFFFFFF",
+  altRow: "FFF2F7FF",
+  pkBg: "FFFFF3CD",
+  fkBg: "FFE8F4FD",
+  link: "FF0563C1",
+  border: "FFB8CCE4",
+  valueBg: "FFFAFBFE"
+};
+var COL_COUNT = 7;
+async function exportExcelDictionary(doc, options) {
+  await (0, import_promises2.mkdir)(options.outDir, { recursive: true });
+  const workbook = new import_exceljs.default.Workbook();
+  const labels = getOutputLabels(options.language);
+  const sheetNames = /* @__PURE__ */ new Map();
+  for (const table of doc.tables) {
+    sheetNames.set(table.name, buildSheetName(table.name, sheetNames));
+  }
+  addOverviewSheet(workbook, doc, labels, sheetNames);
+  for (const table of doc.tables) {
+    const sheetName = sheetNames.get(table.name);
+    const sheet = workbook.addWorksheet(sheetName);
+    populateTableSheet(sheet, table, doc, labels);
+  }
+  await workbook.xlsx.writeFile(
+    (0, import_node_path2.join)(options.outDir, "database_dictionary.xlsx")
+  );
+}
+function addOverviewSheet(workbook, doc, labels, sheetNames) {
+  const sheet = workbook.addWorksheet("Overview");
+  sheet.mergeCells(1, 1, 1, COL_COUNT);
+  const titleCell = sheet.getCell(1, 1);
+  titleCell.value = labels.docTitle;
+  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 = 30;
+  sheet.addRow([]);
+  const summary = [
+    [labels.dialectLabel, doc.dialect],
+    [labels.tablesLabel, doc.tables.length],
+    [labels.relationshipsLabel, doc.relationships.length]
+  ];
+  for (const [field, value] of summary) {
+    const row = sheet.addRow([field, value]);
+    styleMetaRow(row);
+    applyBorderToRow(row, 2);
+    row.getCell(1).alignment = { vertical: "middle", indent: 1 };
+    row.getCell(2).alignment = { vertical: "middle", indent: 1 };
+  }
+  sheet.addRow([]);
+  const sectionRow = sheet.addRow([labels.tableListHeading]);
+  sheet.mergeCells(sectionRow.number, 1, sectionRow.number, COL_COUNT);
+  const sectionCell = sectionRow.getCell(1);
+  sectionCell.font = { bold: true, size: 11, color: { argb: COLOR.metaFg } };
+  sectionCell.fill = solidFill(COLOR.metaBg);
+  sectionCell.alignment = { vertical: "middle" };
+  sectionRow.height = 22;
+  const headerRowNum = sectionRow.number + 1;
+  const headerRow = sheet.getRow(headerRowNum);
+  headerRow.values = [
+    labels.rowNo,
+    labels.tableLabel,
+    labels.tableLogicalName,
+    labels.columnsCount,
+    labels.primaryKey,
+    labels.foreignKeys,
+    labels.indexes
+  ];
+  styleColorRow(headerRow, COLOR.overviewBg, COLOR.overviewFg);
+  applyBorderToRow(headerRow, COL_COUNT);
+  for (const [i, table] of doc.tables.entries()) {
+    const indexes = collectTableIndexes(table, doc);
+    const targetSheet = sheetNames.get(table.name);
+    const row = sheet.addRow([
+      i + 1,
+      table.name,
+      displayValue(table.comment, labels),
+      table.columns.length,
+      displayValue(table.primaryKeys.join(", "), labels),
+      table.foreignKeys.length > 0 ? table.foreignKeys.map((fk) => `${fk.columns.join(",")} \u2192 ${fk.referencedTable}`).join("; ") : labels.none,
+      indexes.length > 0 ? indexes.map((idx) => idx.name).join("; ") : labels.none
+    ]);
+    setHyperlink(row.getCell(2), table.name, targetSheet);
+    row.getCell(2).font = { bold: true, color: { argb: COLOR.link }, underline: true };
+    row.getCell(4).alignment = { horizontal: "center" };
+    if (i % 2 === 1) {
+      shadeRow(row, COL_COUNT, COLOR.altRow);
+    }
+    applyBorderToRow(row, COL_COUNT);
+  }
+  sheet.columns = [
+    { width: 20 },
+    { width: 28 },
+    { width: 30 },
+    { width: 9 },
+    { width: 20 },
+    { width: 38 },
+    { width: 38 }
+  ];
+  sheet.autoFilter = {
+    from: { row: headerRowNum, column: 1 },
+    to: { row: headerRowNum + doc.tables.length, column: COL_COUNT }
+  };
+  sheet.views = [{ state: "frozen", ySplit: headerRowNum }];
+}
+function populateTableSheet(sheet, table, doc, labels) {
+  const indexes = collectTableIndexes(table, doc);
+  sheet.mergeCells(1, 1, 1, 6);
+  const titleCell = sheet.getCell(1, 1);
+  titleCell.value = table.name;
+  titleCell.font = { bold: true, size: 13, color: { argb: COLOR.overviewFg } };
+  titleCell.fill = solidFill(COLOR.headerBg);
+  titleCell.alignment = { horizontal: "left", vertical: "middle", indent: 1 };
+  sheet.getRow(1).height = 26;
+  const backRow = sheet.addRow([labels.backToOverview]);
+  setHyperlink(backRow.getCell(1), labels.backToOverview, "Overview");
+  backRow.getCell(1).font = { color: { argb: COLOR.link }, underline: true, size: 10 };
+  sheet.addRow([]);
+  const metaData = [
+    [labels.tablePhysicalName, table.name],
+    [labels.tableLogicalName, displayValue(table.comment, labels)],
+    ...table.schema ? [[labels.schema, table.schema]] : [],
+    [labels.columnsCount, String(table.columns.length)],
+    [labels.primaryKey, displayValue(table.primaryKeys.join(", "), labels)],
+    [
+      labels.foreignKeys,
+      table.foreignKeys.length > 0 ? table.foreignKeys.map((fk) => {
+        const name = fk.name ? ` (${fk.name})` : "";
+        return `${fk.columns.join(", ")} \u2192 ${fk.referencedTable}.${fk.referencedColumns.join(", ")}${name}`;
+      }).join("; ") : labels.none
+    ],
+    [
+      labels.indexes,
+      indexes.length > 0 ? indexes.map(
+        (idx) => `${idx.name} (${idx.columns.join(", ")})${idx.unique ? " UNIQUE" : ""}`
+      ).join("; ") : labels.none
+    ]
+  ];
+  for (const [field, value] of metaData) {
+    const row = sheet.addRow([field, value]);
+    styleMetaRow(row);
+    applyBorderToRow(row, 2);
+    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
+  ]);
+  styleColorRow(headerRow, COLOR.headerBg, COLOR.headerFg);
+  applyBorderToRow(headerRow, 6);
+  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 || "-"
+    ]);
+    if (column.isPrimaryKey) {
+      shadeRow(row, 6, COLOR.pkBg);
+      row.getCell(1).font = { bold: true };
+    } else if (column.isForeignKey) {
+      shadeRow(row, 6, COLOR.fkBg);
+    } else if (i % 2 === 1) {
+      shadeRow(row, 6, COLOR.altRow);
+    }
+    row.getCell(4).alignment = { horizontal: "center" };
+    applyBorderToRow(row, 6);
+  }
+  sheet.columns = [
+    { width: 24 },
+    { width: 28 },
+    { width: 18 },
+    { width: 10 },
+    { width: 18 },
+    { width: 36 }
+  ];
+  sheet.views = [{ state: "frozen", ySplit: headerRowNum }];
+}
+function displayValue(value, labels) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : labels.none;
+}
+function buildSheetName(tableName, existing) {
+  const base = tableName.slice(0, 31);
+  if (![...existing.values()].includes(base)) return base;
+  let suffix = 2;
+  while (suffix < 100) {
+    const candidate = `${tableName.slice(0, 28)}_${suffix}`;
+    if (![...existing.values()].includes(candidate)) return candidate;
+    suffix++;
+  }
+  return base;
+}
+function sheetLocation(sheetName, cellRef = "A1") {
+  if (/^[A-Za-z0-9_]+$/.test(sheetName)) {
+    return `${sheetName}!${cellRef}`;
+  }
+  const escaped = sheetName.replace(/'/g, "''");
+  return `'${escaped}'!${cellRef}`;
+}
+function setHyperlink(cell, text, sheetName) {
+  cell.value = { text, hyperlink: sheetLocation(sheetName) };
+}
+function solidFill(argb) {
+  return { type: "pattern", pattern: "solid", fgColor: { argb } };
+}
+function styleMetaRow(row) {
+  row.getCell(1).font = { bold: true, color: { argb: COLOR.metaFg } };
+  row.getCell(1).fill = solidFill(COLOR.metaBg);
+  row.getCell(2).fill = solidFill(COLOR.valueBg);
+}
+function styleColorRow(row, bgArgb, fgArgb) {
+  row.eachCell((cell) => {
+    cell.font = { bold: true, color: { argb: fgArgb } };
+    cell.fill = solidFill(bgArgb);
+    cell.alignment = { vertical: "middle", horizontal: "center" };
+  });
+  row.height = 22;
+}
+function shadeRow(row, colCount, argb) {
+  for (let c = 1; c <= colCount; c++) {
+    row.getCell(c).fill = solidFill(argb);
+  }
+}
+function applyBorderToRow(row, colCount) {
+  const border = { style: "thin", color: { argb: COLOR.border } };
+  for (let c = 1; c <= colCount; c++) {
+    row.getCell(c).border = {
+      top: border,
+      left: border,
+      bottom: border,
+      right: border
+    };
+  }
+}
+function collectTableIndexes(table, doc) {
+  return [
+    ...table.indexes,
+    ...doc.indexes.filter(
+      (idx) => idx.table === table.name && !table.indexes.some((tableIdx) => tableIdx.name === idx.name)
+    )
+  ];
+}
+
+// src/exporters/markdown/markdown-exporter.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+
+// src/core/sanitize.ts
+function sanitizeFilename(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+// src/exporters/markdown/markdown-exporter.ts
+async function exportMarkdownDocs(doc, options) {
+  try {
+    const tablesDir = (0, import_node_path3.join)(options.outDir, "tables");
+    await (0, import_promises3.mkdir)(tablesDir, { recursive: true });
+    const labels = getOutputLabels(options.language);
+    for (const table of doc.tables) {
+      await (0, import_promises3.writeFile)(
+        (0, import_node_path3.join)(tablesDir, `${sanitizeFilename(table.name)}.md`),
+        renderTableDoc(table, doc, labels),
+        "utf8"
+      );
+    }
+  } catch (err) {
+    throw new Error(
+      `Failed to export Markdown docs: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+}
+function renderTableDoc(table, doc, labels) {
+  const lines = [];
+  const tableIndexes = collectTableIndexes2(table, doc);
+  lines.push(`# ${escapeMd(table.name)}`);
+  lines.push("");
+  lines.push(`## ${labels.tableInfoHeading}`);
+  lines.push("");
+  lines.push(`| ${labels.metaField} | ${labels.metaValue} |`);
+  lines.push("|------|----|");
+  lines.push(`| ${labels.tablePhysicalName} | ${escapeMd(table.name)} |`);
+  lines.push(`| ${labels.tableLogicalName} | ${escapeMd(table.comment ?? "")} |`);
+  lines.push(`| ${labels.schema} | ${escapeMd(table.schema ?? "")} |`);
+  lines.push(
+    `| ${labels.primaryKey} | ${escapeMd(table.primaryKeys.join(", ") || labels.none)} |`
+  );
+  lines.push(
+    `| ${labels.foreignKeys} | ${escapeMd(
+      table.foreignKeys.length > 0 ? table.foreignKeys.map((fk) => {
+        const name = fk.name ? ` (${fk.name})` : "";
+        return `${fk.columns.join(", ")} -> ${fk.referencedTable}.${fk.referencedColumns.join(", ")}${name}`;
+      }).join("; ") : labels.none
+    )} |`
+  );
+  lines.push(
+    `| ${labels.indexes} | ${escapeMd(
+      tableIndexes.length > 0 ? tableIndexes.map(
+        (idx) => `${idx.name} (${idx.columns.join(", ")})${idx.unique ? " UNIQUE" : ""}`
+      ).join("; ") : labels.none
+    )} |`
+  );
+  lines.push("");
+  lines.push(`## ${labels.columnsHeading}`);
+  lines.push("");
+  lines.push(
+    `| ${labels.physicalName} | ${labels.logicalName} | ${labels.type} | ${labels.required} | ${labels.defaultValue} | ${labels.notes} |`
+  );
+  lines.push("|--------|--------|----|------|--------------|------|");
+  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 ?? "")} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function collectTableIndexes2(table, doc) {
+  return [
+    ...table.indexes,
+    ...doc.indexes.filter(
+      (idx) => idx.table === table.name && !table.indexes.some((tableIdx) => tableIdx.name === idx.name)
+    )
+  ];
+}
+function escapeMd(text) {
+  return text.replace(/([|*_`\[\]<>#~\\])/g, "\\$1");
+}
+
+// src/exporters/html/html-exporter.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = require("path");
+async function exportHtmlDocs(doc, options) {
+  try {
+    const htmlDir = (0, import_node_path4.join)(options.outDir, "html");
+    const tablesDir = (0, import_node_path4.join)(htmlDir, "tables");
+    await (0, import_promises4.mkdir)(tablesDir, { recursive: true });
+    const labels = getOutputLabels(options.language);
+    await (0, import_promises4.writeFile)(
+      (0, import_node_path4.join)(htmlDir, "index.html"),
+      renderIndexPage(doc, labels),
+      "utf8"
+    );
+    for (const table of doc.tables) {
+      await (0, import_promises4.writeFile)(
+        (0, import_node_path4.join)(tablesDir, `${sanitizeFilename(table.name)}.html`),
+        renderTablePage(table, doc, labels),
+        "utf8"
+      );
+    }
+  } catch (err) {
+    throw new Error(
+      `Failed to export HTML docs: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+}
+var CSS = `
+    :root {
+      --bg: #f3f4f6;
+      --paper: #ffffff;
+      --text: #111827;
+      --muted: #4b5563;
+      --border: #bfc7d4;
+      --accent: #4472c4;
+      --accent-light: #dbe5f1;
+      --accent-mid: #eef3f8;
+      --pk-bg: #fff3cd;
+      --fk-bg: #e8f4fd;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: "Yu Gothic UI", "Meiryo", Arial, sans-serif;
+      background: var(--bg); color: var(--text); line-height: 1.5;
+      padding: 24px;
+    }
+    a { color: var(--accent); text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    .sheet {
+      max-width: 1200px;
+      margin: 0 auto;
+      background: var(--paper);
+      border: 1px solid var(--border);
+      padding: 24px;
+    }
+    h1 { font-size: 22px; margin-bottom: 16px; color: var(--accent); border-bottom: 2px solid var(--accent-light); padding-bottom: 8px; }
+    h2 { font-size: 15px; margin: 20px 0 8px; color: var(--muted); text-transform: uppercase; letter-spacing: .04em; }
+    table { width: 100%; border-collapse: collapse; table-layout: fixed; margin-bottom: 16px; }
+    th, td {
+      border: 1px solid var(--border);
+      padding: 7px 10px;
+      text-align: left;
+      vertical-align: top;
+      word-break: break-word;
+      font-size: 13px;
+    }
+    thead th { background: var(--accent); color: #fff; font-weight: 700; }
+    .meta th { background: var(--accent-light); font-weight: 700; color: #1f3864; width: 180px; }
+    .meta td { background: #fafbfe; }
+    .pk td:first-child { font-weight: 700; }
+    .pk { background: var(--pk-bg); }
+    .fk { background: var(--fk-bg); }
+    .badge {
+      display: inline-block; font-size: 10px; font-weight: 700;
+      padding: 1px 5px; border-radius: 3px; margin-left: 4px; vertical-align: middle;
+    }
+    .badge-pk { background: #f59e0b; color: #fff; }
+    .badge-fk { background: var(--accent); color: #fff; }
+    .note { color: var(--muted); font-size: 12px; margin-top: 10px; }
+    .back { margin-bottom: 16px; font-size: 13px; }
+    .summary { display: flex; gap: 24px; margin-bottom: 20px; }
+    .summary-item { background: var(--accent-light); border-radius: 6px; padding: 10px 18px; }
+    .summary-item .num { font-size: 24px; font-weight: 700; color: var(--accent); }
+    .summary-item .lbl { font-size: 12px; color: var(--muted); }
+    .table-list { width: 100%; border-collapse: collapse; margin-top: 8px; }
+    .table-list th { background: var(--accent); color: #fff; }
+    .table-list tr:nth-child(even) td { background: var(--accent-mid); }
+    .table-list td:first-child a { font-weight: 600; }
+`;
+function pageShell(title, body, fromSubdir = false) {
+  const base = fromSubdir ? "../" : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${esc(title)}</title>
+  <style>${CSS}  </style>
+</head>
+<body>
+  <div class="sheet">
+${body}
+  </div>
+</body>
+</html>`;
+}
+function renderIndexPage(doc, labels) {
+  let tableRows = "";
+  for (const table of doc.tables) {
+    const pkCols = table.primaryKeys.join(", ") || labels.none;
+    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 style="text-align:center">${table.columns.length}</td>
+        <td>${esc(pkCols)}</td>
+        <td style="text-align:center">${fkCount}</td>
+      </tr>
+`;
+  }
+  const body = `
+  <h1>${esc(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>
+  <h2>${esc(labels.tableListHeading)}</h2>
+  <table class="table-list">
+    <thead><tr>
+      <th>${esc(labels.tableLabel)}</th>
+      <th>${esc(labels.tableLogicalName)}</th>
+      <th style="width:70px;text-align:center">Cols</th>
+      <th>${esc(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>
+`;
+  return pageShell(labels.docTitle, body);
+}
+function renderTablePage(table, doc, labels) {
+  const indexes = collectTableIndexes3(table, doc);
+  const foreignKeys = table.foreignKeys.length ? table.foreignKeys.map((fk) => {
+    const name = fk.name ? ` (${fk.name})` : "";
+    return `${fk.columns.join(", ")} \u2192 ${fk.referencedTable}.${fk.referencedColumns.join(", ")}${name}`;
+  }).join("<br>") : labels.none;
+  const indexText = indexes.length ? indexes.map(
+    (idx) => `${idx.name} (${idx.columns.join(", ")})${idx.unique ? " UNIQUE" : ""}`
+  ).join("<br>") : labels.none;
+  let colRows = "";
+  for (const col of table.columns) {
+    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 body = `
+  <p class="back"><a href="../index.html">\u2190 ${esc(labels.tableListHeading)}</a></p>
+  <h1>${esc(table.name)}</h1>
+  <h2>${esc(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>
+    </tbody>
+  </table>
+
+  <h2>${esc(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>
+    </tr></thead>
+    <tbody>
+${colRows}    </tbody>
+  </table>
+  <p class="note">${esc(labels.generatedNote)}</p>
+`;
+  return pageShell(table.name, body);
+}
+function collectTableIndexes3(table, doc) {
+  return [
+    ...table.indexes,
+    ...doc.indexes.filter(
+      (idx) => idx.table === table.name && !table.indexes.some((tableIdx) => tableIdx.name === idx.name)
+    )
+  ];
+}
+function esc(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/exporters/word/word-exporter.ts
+var import_promises5 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_docx = require("docx");
+async function exportWordDocument(doc, options) {
+  try {
+    await (0, import_promises5.mkdir)(options.outDir, { recursive: true });
+    const labels = getOutputLabels(options.language);
+    const children = [];
+    children.push(
+      new import_docx.Paragraph({
+        heading: import_docx.HeadingLevel.HEADING_1,
+        children: [new import_docx.TextRun(labels.docTitle)]
+      })
+    );
+    children.push(
+      new import_docx.Paragraph({
+        heading: import_docx.HeadingLevel.HEADING_2,
+        children: [new import_docx.TextRun(labels.overviewHeading)]
+      })
+    );
+    children.push(
+      new import_docx.Paragraph({
+        children: [new import_docx.TextRun(`${labels.dialectLabel}: ${doc.dialect}`)]
+      })
+    );
+    children.push(
+      new import_docx.Paragraph({
+        children: [new import_docx.TextRun(`${labels.tablesLabel}: ${doc.tables.length}`)]
+      })
+    );
+    children.push(
+      new import_docx.Paragraph({
+        children: [new import_docx.TextRun(`${labels.relationshipsLabel}: ${doc.relationships.length}`)]
+      })
+    );
+    children.push(
+      new import_docx.Paragraph({
+        heading: import_docx.HeadingLevel.HEADING_2,
+        children: [new import_docx.TextRun(labels.tableListHeading)]
+      })
+    );
+    if (doc.tables.length > 0) {
+      const tableListRows = [
+        new import_docx.TableRow({
+          children: [
+            new import_docx.TableCell({
+              children: [
+                new import_docx.Paragraph({
+                  children: [new import_docx.TextRun({ text: labels.tableLabel, bold: true })]
+                })
+              ]
+            }),
+            new import_docx.TableCell({
+              children: [
+                new import_docx.Paragraph({
+                  children: [new import_docx.TextRun({ text: labels.descriptionLabel, bold: true })]
+                })
+              ]
+            })
+          ]
+        })
+      ];
+      for (const table of doc.tables) {
+        tableListRows.push(
+          new import_docx.TableRow({
+            children: [
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(table.name)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({
+                    children: [
+                      new import_docx.TextRun(
+                        table.description?.value ?? table.comment ?? ""
+                      )
+                    ]
+                  })
+                ]
+              })
+            ]
+          })
+        );
+      }
+      children.push(new import_docx.Table({ rows: tableListRows }));
+    }
+    for (const table of doc.tables) {
+      children.push(...renderTableDetail(table, doc, labels));
+    }
+    children.push(
+      new import_docx.Paragraph({
+        heading: import_docx.HeadingLevel.HEADING_2,
+        children: [new import_docx.TextRun(labels.relationshipsHeading)]
+      })
+    );
+    if (doc.relationships.length > 0) {
+      const relHeaderCells = [
+        labels.fromTable,
+        labels.fromColumn,
+        labels.toTable,
+        labels.toColumn,
+        labels.constraint,
+        labels.source,
+        labels.needsReview
+      ].map(
+        (h) => new import_docx.TableCell({
+          children: [
+            new import_docx.Paragraph({
+              children: [new import_docx.TextRun({ text: h, bold: true })]
+            })
+          ]
+        })
+      );
+      const relRows = [new import_docx.TableRow({ children: relHeaderCells })];
+      for (const rel of doc.relationships) {
+        relRows.push(
+          new import_docx.TableRow({
+            children: [
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(rel.fromTable)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(rel.fromColumn)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(rel.toTable)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(rel.toColumn)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({
+                    children: [new import_docx.TextRun(rel.constraintName ?? "")]
+                  })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(rel.source)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({
+                    children: [new import_docx.TextRun(rel.needsReview ? labels.yes : labels.no)]
+                  })
+                ]
+              })
+            ]
+          })
+        );
+      }
+      children.push(new import_docx.Table({ rows: relRows }));
+    } else {
+      children.push(
+        new import_docx.Paragraph({
+          children: [new import_docx.TextRun(labels.none)]
+        })
+      );
+    }
+    children.push(
+      new import_docx.Paragraph({
+        heading: import_docx.HeadingLevel.HEADING_2,
+        children: [new import_docx.TextRun(labels.warningsHeading)]
+      })
+    );
+    if (doc.warnings.length > 0) {
+      const warnHeaderCells = [
+        labels.severity,
+        labels.code,
+        labels.target,
+        labels.message
+      ].map(
+        (h) => new import_docx.TableCell({
+          children: [
+            new import_docx.Paragraph({
+              children: [new import_docx.TextRun({ text: h, bold: true })]
+            })
+          ]
+        })
+      );
+      const warnRows = [new import_docx.TableRow({ children: warnHeaderCells })];
+      for (const warning of doc.warnings) {
+        warnRows.push(
+          new import_docx.TableRow({
+            children: [
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(warning.severity)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(warning.code)] })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({
+                    children: [new import_docx.TextRun(warning.target ?? "")]
+                  })
+                ]
+              }),
+              new import_docx.TableCell({
+                children: [
+                  new import_docx.Paragraph({ children: [new import_docx.TextRun(warning.message)] })
+                ]
+              })
+            ]
+          })
+        );
+      }
+      children.push(new import_docx.Table({ rows: warnRows }));
+    } else {
+      children.push(
+        new import_docx.Paragraph({
+          children: [new import_docx.TextRun(labels.none)]
+        })
+      );
+    }
+    const wordDoc = new import_docx.Document({
+      sections: [{ children }]
+    });
+    const buffer = await import_docx.Packer.toBuffer(wordDoc);
+    await (0, import_promises5.writeFile)((0, import_node_path5.join)(options.outDir, "database_document.docx"), buffer);
+  } catch (err) {
+    throw new Error(
+      `Failed to export Word document: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+}
+function renderTableDetail(table, doc, labels) {
+  const items = [];
+  const indexes = collectTableIndexes4(table, doc);
+  items.push(
+    new import_docx.Paragraph({
+      heading: import_docx.HeadingLevel.HEADING_2,
+      children: [new import_docx.TextRun(table.name)]
+    })
+  );
+  items.push(
+    new import_docx.Paragraph({
+      heading: import_docx.HeadingLevel.HEADING_3,
+      children: [new import_docx.TextRun(labels.tableInfoHeading)]
+    })
+  );
+  items.push(
+    renderMetaTable([
+      [labels.tablePhysicalName, table.name],
+      [labels.tableLogicalName, table.comment ?? ""],
+      [labels.schema, table.schema ?? ""],
+      [labels.primaryKey, table.primaryKeys.join(", ") || labels.none],
+      [
+        labels.foreignKeys,
+        table.foreignKeys.length > 0 ? table.foreignKeys.map((fk) => {
+          const name = fk.name ? ` (${fk.name})` : "";
+          return `${fk.columns.join(", ")} -> ${fk.referencedTable}.${fk.referencedColumns.join(", ")}${name}`;
+        }).join("; ") : labels.none
+      ],
+      [
+        labels.indexes,
+        indexes.length > 0 ? indexes.map(
+          (idx) => `${idx.name} (${idx.columns.join(", ")})${idx.unique ? " UNIQUE" : ""}`
+        ).join("; ") : labels.none
+      ]
+    ])
+  );
+  items.push(
+    new import_docx.Paragraph({
+      heading: import_docx.HeadingLevel.HEADING_3,
+      children: [new import_docx.TextRun(labels.columnsHeading)]
+    })
+  );
+  items.push(renderColumnsTable(table, labels));
+  items.push(
+    new import_docx.Paragraph({
+      children: [new import_docx.TextRun("")]
+    })
+  );
+  return items;
+}
+function renderColumnsTable(table, labels) {
+  const headerCells = [
+    labels.physicalName,
+    labels.logicalName,
+    labels.type,
+    labels.required,
+    labels.defaultValue,
+    labels.notes
+  ].map(
+    (h) => new import_docx.TableCell({
+      children: [
+        new import_docx.Paragraph({ children: [new import_docx.TextRun({ text: h, bold: true })] })
+      ]
+    })
+  );
+  const colRows = [new import_docx.TableRow({ children: headerCells })];
+  for (const col of table.columns) {
+    colRows.push(
+      new import_docx.TableRow({
+        children: [
+          new import_docx.TableCell({
+            children: [new import_docx.Paragraph({ children: [new import_docx.TextRun(col.name)] })]
+          }),
+          new import_docx.TableCell({
+            children: [
+              new import_docx.Paragraph({ children: [new import_docx.TextRun(col.comment ?? "")] })
+            ]
+          }),
+          new import_docx.TableCell({
+            children: [new import_docx.Paragraph({ children: [new import_docx.TextRun(col.type)] })]
+          }),
+          new import_docx.TableCell({
+            children: [
+              new import_docx.Paragraph({
+                children: [new import_docx.TextRun(col.nullable ? labels.no : labels.yes)]
+              })
+            ]
+          }),
+          new import_docx.TableCell({
+            children: [
+              new import_docx.Paragraph({
+                children: [new import_docx.TextRun(col.defaultValue ?? "-")]
+              })
+            ]
+          }),
+          new import_docx.TableCell({
+            children: [
+              new import_docx.Paragraph({
+                children: [new import_docx.TextRun(col.description?.value ?? "")]
+              })
+            ]
+          })
+        ]
+      })
+    );
+  }
+  return new import_docx.Table({ rows: colRows });
+}
+function renderMetaTable(rows) {
+  return new import_docx.Table({
+    rows: rows.map(
+      ([label, value]) => new import_docx.TableRow({
+        children: [
+          new import_docx.TableCell({
+            children: [
+              new import_docx.Paragraph({
+                children: [new import_docx.TextRun({ text: label, bold: true })]
+              })
+            ]
+          }),
+          new import_docx.TableCell({
+            children: [new import_docx.Paragraph({ children: [new import_docx.TextRun(value)] })]
+          })
+        ]
+      })
+    )
+  });
+}
+function collectTableIndexes4(table, doc) {
+  return [
+    ...table.indexes,
+    ...doc.indexes.filter(
+      (idx) => idx.table === table.name && !table.indexes.some((tableIdx) => tableIdx.name === idx.name)
+    )
+  ];
+}
+
+// src/parsers/sql/sql-parser.ts
+var import_node_sql_parser = __toESM(require("node-sql-parser"), 1);
+
+// src/core/warnings.ts
+function createWarning(code, message, target) {
+  return {
+    code,
+    message,
+    target,
+    severity: "warning"
+  };
+}
+
+// src/parsers/sql/sql-normalizer.ts
+function normalizeSqlAst(ast, dialect) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  const tables = [];
+  const indexes = [];
+  const relationships = [];
+  const warnings = [];
+  for (const statement of statements) {
+    if (statement.type === "create" && statement.keyword === "table") {
+      const table = normalizeCreateTable(statement);
+      tables.push(table);
+      const result = relationshipsFromTable(table);
+      relationships.push(...result.relationships);
+      warnings.push(...result.warnings);
+    }
+    if (statement.type === "create" && statement.keyword === "index") {
+      indexes.push(normalizeCreateIndex(statement));
+    }
+  }
+  for (const index of indexes) {
+    const table = tables.find((candidate) => candidate.name === index.table);
+    table?.indexes.push(index);
+  }
+  return {
+    dialect,
+    tables,
+    relationships,
+    indexes,
+    warnings
+  };
+}
+function normalizeCreateTable(statement) {
+  const tableName = extractTableName(statement.table);
+  const createDefinitions = Array.isArray(statement.create_definitions) ? statement.create_definitions : [];
+  const table = {
+    name: tableName,
+    columns: [],
+    primaryKeys: [],
+    foreignKeys: [],
+    indexes: [],
+    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 === "constraint" && isConstraintType(definition.constraint_type, "PRIMARY KEY")) {
+      table.primaryKeys = extractDeepColumnNames(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);
+      const refDef = definition.reference_definition;
+      const referencedTable = extractTableName(refDef?.table);
+      const referencedColumns = extractDeepColumnNames(refDef?.definition);
+      table.foreignKeys.push({
+        name: typeof definition.constraint === "string" ? definition.constraint : void 0,
+        columns,
+        referencedTable,
+        referencedColumns
+      });
+      for (const column of table.columns) {
+        if (columns.includes(column.name)) column.isForeignKey = true;
+      }
+    }
+  }
+  return table;
+}
+function normalizeCreateIndex(statement) {
+  return {
+    name: String(statement.index ?? statement.index_name ?? "unnamed_index"),
+    table: extractTableName(statement.table),
+    columns: extractDeepColumnNames(
+      statement.index_columns ?? statement.columns
+    ),
+    unique: Boolean(statement.unique)
+  };
+}
+function relationshipsFromTable(table) {
+  const relationships = [];
+  const warnings = [];
+  for (const foreignKey of table.foreignKeys) {
+    for (let index = 0; index < foreignKey.columns.length; index++) {
+      const column = foreignKey.columns[index];
+      let toColumn;
+      let needsReview = false;
+      if (foreignKey.referencedColumns[index]) {
+        toColumn = foreignKey.referencedColumns[index];
+      } else {
+        toColumn = foreignKey.referencedColumns[0] ?? column;
+        needsReview = true;
+        table.reviewTodos.push({
+          type: "relationship",
+          target: `${table.name}.${column} \u2192 ${foreignKey.referencedTable}`,
+          issue: `Foreign key column "${column}" references table "${foreignKey.referencedTable}" but the referenced column at position ${index} is missing from the schema. Using "${toColumn}" as a best-guess fallback.`,
+          suggestion: `Verify the referenced column name in table "${foreignKey.referencedTable}" and update manually.`,
+          source: "schema"
+        });
+        warnings.push({
+          code: "FK_REFERENCED_COLUMN_GUESS",
+          message: `In table "${table.name}", foreign key column "${column}" references "${foreignKey.referencedTable}" but the referenced column at index ${index} is missing. Falling back to "${toColumn}".`,
+          target: `${table.name}.${column}`,
+          severity: "warning"
+        });
+      }
+      relationships.push({
+        fromTable: table.name,
+        fromColumn: column,
+        toTable: foreignKey.referencedTable,
+        toColumn,
+        constraintName: foreignKey.name,
+        source: "schema",
+        needsReview
+      });
+    }
+  }
+  return { relationships, warnings };
+}
+function extractTableName(value) {
+  if (Array.isArray(value)) return extractTableName(value[0]);
+  if (typeof value === "object" && value !== null) {
+    const object = value;
+    return String(object.table ?? object.tableName ?? object.name ?? "unknown");
+  }
+  return String(value ?? "unknown");
+}
+function extractDeepColumnName(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);
+  }
+  if (object.column && typeof object.column === "object") {
+    return extractDeepColumnName(object.column);
+  }
+  if (object.value !== void 0) {
+    return String(object.value);
+  }
+  if (object.column !== void 0) {
+    return String(object.column);
+  }
+  return String(object.name ?? object.tableName ?? "unknown");
+}
+function extractDeepColumnNames(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();
+}
+function hasPrimaryKey(def) {
+  if (def.primary_key) return true;
+  if (def.constraint_type && isConstraintType(def.constraint_type, "PRIMARY KEY"))
+    return true;
+  return false;
+}
+function hasNotNull(def) {
+  if (!def.nullable) return false;
+  if (typeof def.nullable === "object" && def.nullable.type === "not null")
+    return true;
+  if (String(def.nullable) === "not null") return true;
+  return false;
+}
+function isConstraintType(value, expected) {
+  if (typeof value !== "string") return false;
+  return value.toUpperCase() === expected.toUpperCase();
+}
+function extractDefaultFromDef(def) {
+  if (!def.default_val) return void 0;
+  const defaultVal = def.default_val;
+  if (defaultVal.type === "default" && defaultVal.value) {
+    if (typeof defaultVal.value === "object" && defaultVal.value !== null) {
+      const val = defaultVal.value;
+      if (val.type === "function" && val.name) {
+        const name = val.name;
+        const parts = Array.isArray(name.name) ? name.name : [];
+        return parts.map((p) => String(p.value ?? "")).join("");
+      }
+      if (val.type === "single_quote_string") {
+        return `'${String(val.value)}'`;
+      }
+      if (val.value !== void 0) return String(val.value);
+    }
+    return String(defaultVal.value);
+  }
+  if (typeof defaultVal.value === "string") return defaultVal.value;
+  return void 0;
+}
+
+// src/parsers/sql/sql-parser.ts
+var { Parser } = import_node_sql_parser.default;
+async function parseSqlSchema(sql, options = {}) {
+  const requestedDialect = options.dialect;
+  const parser = new Parser();
+  const detectedDialect = detectDialect(sql);
+  const attempts = buildDialectAttempts(requestedDialect, detectedDialect);
+  const failures = [];
+  const successes = [];
+  for (const dialect of attempts) {
+    try {
+      const ast = parser.astify(sql, buildAstifyOptions(dialect));
+      const doc = normalizeSqlAst(ast, dialect);
+      successes.push({
+        dialect,
+        doc,
+        score: scoreParsedDoc(doc)
+      });
+    } catch (error) {
+      failures.push({
+        dialect,
+        message: error instanceof Error ? error.message : "Unsupported SQL syntax"
+      });
+    }
+  }
+  const best = pickBestResult(successes, requestedDialect, detectedDialect);
+  if (best) {
+    if (!requestedDialect && best.dialect !== "unknown") {
+      best.doc.warnings.unshift(
+        createWarning(
+          "DIALECT_AUTO_DETECTED",
+          `SQL dialect auto-detected as "${best.dialect}".`
+        )
+      );
+    } else if (requestedDialect && requestedDialect !== best.dialect) {
+      best.doc.warnings.unshift(
+        createWarning(
+          "DIALECT_FALLBACK",
+          `Requested dialect "${requestedDialect}" produced a lower-quality parse, reparsed successfully as "${best.dialect}".`
+        )
+      );
+    }
+    return best.doc;
+  }
+  return {
+    dialect: requestedDialect ?? "unknown",
+    tables: [],
+    relationships: [],
+    indexes: [],
+    warnings: [
+      createWarning(
+        "UNSUPPORTED_SQL",
+        failures[0]?.message ?? "Unsupported SQL syntax"
+      )
+    ]
+  };
+}
+function mapDialect(dialect) {
+  if (dialect === "postgres") return "postgresql";
+  if (dialect === "mysql" || dialect === "mariadb") return "mysql";
+  return void 0;
+}
+function buildAstifyOptions(dialect) {
+  const database = mapDialect(dialect);
+  return database ? { database } : void 0;
+}
+function buildDialectAttempts(requestedDialect, detectedDialect) {
+  const attempts = [];
+  if (requestedDialect) {
+    attempts.push(requestedDialect);
+  }
+  if (detectedDialect) {
+    attempts.push(detectedDialect);
+  }
+  attempts.push("mysql", "mariadb", "postgres", "unknown");
+  return dedupeDialects(attempts);
+}
+function dedupeDialects(dialects) {
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const dialect of dialects) {
+    if (seen.has(dialect)) continue;
+    seen.add(dialect);
+    ordered.push(dialect);
+  }
+  return ordered;
+}
+function detectDialect(sql) {
+  const source = sql.toUpperCase();
+  const mysqlSignals = [
+    "AUTO_INCREMENT",
+    "ENGINE=",
+    "TINYINT",
+    "UNSIGNED",
+    "ZEROFILL",
+    "CHARACTER SET",
+    "COLLATE "
+  ];
+  if (mysqlSignals.some((signal) => source.includes(signal))) {
+    return "mysql";
+  }
+  const postgresSignals = [
+    "SERIAL",
+    "BIGSERIAL",
+    "GENERATED ALWAYS AS IDENTITY",
+    "JSONB",
+    "ILIKE",
+    "CREATE EXTENSION"
+  ];
+  if (postgresSignals.some((signal) => source.includes(signal))) {
+    return "postgres";
+  }
+  return void 0;
+}
+function pickBestResult(successes, requestedDialect, detectedDialect) {
+  const ranked = [...successes].sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    const leftBias = dialectBias(left.dialect, requestedDialect, detectedDialect);
+    const rightBias = dialectBias(
+      right.dialect,
+      requestedDialect,
+      detectedDialect
+    );
+    return rightBias - leftBias;
+  });
+  return ranked[0];
+}
+function scoreParsedDoc(doc) {
+  let score = 0;
+  score += doc.tables.length * 100;
+  score += doc.indexes.length * 15;
+  score += doc.relationships.length * 20;
+  score -= doc.warnings.length * 25;
+  for (const table of doc.tables) {
+    score += table.columns.length * 10;
+    score += table.primaryKeys.length * 5;
+    for (const column of table.columns) {
+      if (column.name && column.name !== "unknown") score += 3;
+      if (column.type && column.type !== "unknown") score += 2;
+      if (column.name.includes("[object Object]")) score -= 50;
+      if (column.type.includes("[object Object]")) score -= 30;
+    }
+  }
+  return score;
+}
+function dialectBias(dialect, requestedDialect, detectedDialect) {
+  let bias = 0;
+  if (detectedDialect && dialect === detectedDialect) bias += 20;
+  if (requestedDialect && dialect === requestedDialect) bias += 5;
+  if (dialect === "unknown") bias -= 10;
+  return bias;
+}
+
+// src/core/pipeline/generate-db-docs.ts
+async function generateDbDocs(options) {
+  const progress = (step, message, detail) => {
+    options.onProgress?.({ step, message, detail });
+  };
+  progress("read_schema", "Reading schema file", { schema: options.schema });
+  const sql = await (0, import_promises6.readFile)(options.schema, "utf8");
+  progress("parse_schema", "Parsing schema", { dialect: options.dialect ?? "auto-detect" });
+  let doc = await parseSqlSchema(sql, {
+    dialect: options.dialect
+  });
+  progress("schema_parsed", "Schema parsed", {
+    tables: doc.tables.length,
+    warnings: doc.warnings.length,
+    dialect: doc.dialect
+  });
+  const exporters = [];
+  if (options.output.formats.includes("excel")) {
+    exporters.push({
+      format: "excel",
+      fn: () => exportExcelDictionary(doc, {
+        outDir: options.outDir,
+        language: options.output.language
+      })
+    });
+  }
+  if (options.output.formats.includes("diagram")) {
+    exporters.push({
+      format: "diagram",
+      fn: () => exportMermaidDiagram(doc, { outDir: options.outDir })
+    });
+  }
+  if (options.output.formats.includes("markdown")) {
+    exporters.push({
+      format: "markdown",
+      fn: () => exportMarkdownDocs(doc, {
+        outDir: options.outDir,
+        language: options.output.language
+      })
+    });
+  }
+  if (options.output.formats.includes("html")) {
+    exporters.push({
+      format: "html",
+      fn: () => exportHtmlDocs(doc, {
+        outDir: options.outDir,
+        language: options.output.language
+      })
+    });
+  }
+  if (options.output.formats.includes("word")) {
+    exporters.push({
+      format: "word",
+      fn: () => exportWordDocument(doc, {
+        outDir: options.outDir,
+        language: options.output.language
+      })
+    });
+  }
+  for (const { format, fn } of exporters) {
+    try {
+      progress(`export_${format}`, `Exporting ${format} output`, {
+        outDir: options.outDir
+      });
+      await fn();
+      progress(`export_${format}_done`, `Exported ${format} output`, {
+        outDir: options.outDir
+      });
+    } catch (err) {
+      console.error(
+        `[dbdocgen] Failed to export ${format} docs:`,
+        err instanceof Error ? err.message : String(err)
+      );
+      progress(`export_${format}_failed`, `Failed to export ${format}`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  progress("complete", "Generation complete", {
+    tables: doc.tables.length,
+    warnings: doc.warnings.length,
+    outDir: options.outDir
+  });
+  return doc;
+}
+
+// src/cli/index.ts
+var DEFAULT_CONFIG_PATH = "dbdocgen.config.json";
+var program = new import_commander.Command();
+program.name("dbdocgen").description("Generate database documentation from SQL schema files.").version("0.1.0");
+program.command("init").description("Create a default config file").option("-f, --force", "Overwrite existing config file").action(async (rawOptions) => {
+  const configPath = (0, import_node_path6.resolve)(process.cwd(), DEFAULT_CONFIG_PATH);
+  if ((0, import_node_fs.existsSync)(configPath) && !rawOptions.force) {
+    console.log(`Config already exists at ${configPath}. Use --force to overwrite.`);
+    return;
+  }
+  const defaultConfig = {
+    schema: "./database/schema.sql",
+    output: {
+      formats: ["excel", "markdown", "html", "diagram", "word"],
+      language: "en"
+    }
+  };
+  await (0, import_promises7.writeFile)(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("Edit the file to configure your database schema path and output formats.");
+});
+var configCommand = program.command("config").description("Manage configuration");
+configCommand.command("show").description("Show resolved configuration").option("--config <path>", "Config file path").action(async (rawOptions) => {
+  const config = await loadConfig({
+    cwd: process.cwd(),
+    cliOptions: { configPath: rawOptions.config }
+  });
+  console.log(JSON.stringify(config, null, 2));
+});
+configCommand.command("validate").description("Validate config file").option("--config <path>", "Config file path").action(async (rawOptions) => {
+  try {
+    const config = await loadConfig({
+      cwd: process.cwd(),
+      cliOptions: { configPath: rawOptions.config }
+    });
+    const result = dbdocgenConfigSchema.safeParse(config);
+    if (result.success) {
+      console.log("Config is valid.");
+    } else {
+      console.error("Config validation failed:");
+      console.error(result.error.format());
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    console.error("Failed to load config:", err instanceof Error ? err.message : err);
+    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) => {
+  console.log("[dbdocgen] Loading configuration...");
+  const config = await loadConfig({
+    cwd: process.cwd(),
+    cliOptions: {
+      schema: rawOptions.schema,
+      outDir: rawOptions.out,
+      formats: parseFormats(rawOptions.format),
+      configPath: rawOptions.config
+    }
+  });
+  const outDir = rawOptions.out ?? createTimestampedOutputDir();
+  console.log("[dbdocgen] Configuration loaded");
+  console.log(`  schema: ${config.schema}`);
+  console.log(`  outDir: ${outDir}`);
+  console.log(`  formats: ${config.output.formats.join(", ")}`);
+  console.log(`  language: ${config.output.language}`);
+  const doc = await generateDbDocs({
+    schema: config.schema,
+    outDir,
+    dialect: config.dialect,
+    output: {
+      formats: config.output.formats,
+      language: config.output.language
+    },
+    onProgress: (event) => {
+      console.log(`[dbdocgen] ${event.message}`);
+      if (event.detail) {
+        for (const [key, value] of Object.entries(event.detail)) {
+          console.log(`  ${key}: ${String(value)}`);
+        }
+      }
+    }
+  });
+  if (doc.warnings.length > 0) {
+    console.log(`[dbdocgen] Completed with ${doc.warnings.length} warning(s)`);
+    for (const warning of doc.warnings) {
+      console.log(
+        `  [${warning.severity}] ${warning.code}: ${warning.message}`
+      );
+    }
+  }
+  console.log(`Generated database documentation in ${outDir}`);
+});
+program.command("validate").description("Validate a SQL schema file without generating docs").option("--schema <path>", "Path to schema.sql").option("--config <path>", "Config file path").action(async (rawOptions) => {
+  const config = await loadConfig({
+    cwd: process.cwd(),
+    cliOptions: {
+      schema: rawOptions.schema,
+      configPath: rawOptions.config
+    }
+  });
+  console.log(`Validating ${config.schema}...`);
+  const sql = await (0, import_promises7.readFile)(config.schema, "utf8");
+  const doc = await parseSqlSchema(sql, { dialect: "postgres" });
+  if (doc.tables.length === 0) {
+    console.log("No tables found in schema.");
+    if (doc.warnings.length > 0) {
+      console.log("\nWarnings:");
+      for (const w of doc.warnings) {
+        console.log(`  [${w.code}] ${w.message}`);
+      }
+    }
+    return;
+  }
+  console.log(`
+Found ${doc.tables.length} table(s):
+`);
+  for (const table of doc.tables) {
+    console.log(`  ${table.name}`);
+    console.log(`    Columns: ${table.columns.length}`);
+    console.log(`    Primary Keys: ${table.primaryKeys.join(", ") || "(none)"}`);
+    console.log(`    Foreign Keys: ${table.foreignKeys.length}`);
+    console.log("");
+  }
+  if (doc.warnings.length > 0) {
+    console.log(`Warnings (${doc.warnings.length}):`);
+    for (const w of doc.warnings) {
+      console.log(`  [${w.severity}] ${w.code}: ${w.message}`);
+    }
+  }
+  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) => {
+  const config = await loadConfig({
+    cwd: process.cwd(),
+    cliOptions: {
+      outDir: rawOptions.out,
+      configPath: rawOptions.config
+    }
+  });
+  const outDir = (0, import_node_path6.resolve)(config.outDir);
+  if (!(0, import_node_fs.existsSync)(outDir)) {
+    console.log(`Output directory ${outDir} does not exist. Nothing to clean.`);
+    return;
+  }
+  console.log(`Cleaning ${outDir}...`);
+  await (0, import_promises7.rm)(outDir, { recursive: true, force: true });
+  console.log("Done.");
+});
+program.command("info").description("Show project info and supported features").action(() => {
+  console.log("dbdocgen v0.1.0");
+  console.log("");
+  console.log("Generate database documentation from SQL schema files.");
+  console.log("");
+  console.log("Supported input:");
+  console.log("  - PostgreSQL schema.sql");
+  console.log("  - MySQL / MariaDB schema.sql");
+  console.log("");
+  console.log("Supported output formats:");
+  console.log("  - excel       Data Dictionary (.xlsx)");
+  console.log("  - markdown    Per-table .md files");
+  console.log("  - html        Static HTML documentation");
+  console.log("  - diagram     Mermaid ER Diagram (.mmd)");
+  console.log("  - word        Word document (.docx)");
+  console.log("");
+  console.log("Commands:");
+  console.log("  init             Create a default config file");
+  console.log("  generate         Generate documentation");
+  console.log("  validate         Validate SQL schema");
+  console.log("  clean            Clean output directory");
+  console.log("  config show      Show current config");
+  console.log("  config validate  Validate config");
+  console.log("  info             Show this info");
+});
+program.parseAsync().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+});
+function parseFormats(value) {
+  if (!value) return void 0;
+  const items = value.split(",").map((item) => item.trim());
+  const valid = [];
+  for (const item of items) {
+    const parsed = outputFormatSchema.safeParse(item);
+    if (parsed.success) {
+      valid.push(parsed.data);
+    } else {
+      console.warn(`Warning: Unrecognized format "${item}" \u2014 must be one of: ${outputFormatSchema.options.join(", ")}`);
+    }
+  }
+  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.cjs.map