schema2md-cli 0.3.0

package/README.md

@@ -0,0 +1,123 @@
+# schema2md-cli
+
+Generate database documentation (Markdown or LaTeX) with an optional ER diagram from your schema.
+
+- TypeScript/Node.js CLI
+- Supported sources: SQLite, PostgreSQL, MySQL/MariaDB
+- Outputs: Markdown (.md) or LaTeX (.tex), with optional PDF compile
+- ER diagram: Mermaid.js → rendered to image and embedded (Markdown/LaTeX)
+
+## Installation
+
+- Requirements: Node.js 18+
+- Global install:
+  - `npm install -g schema2md-cli`
+  - Run: `db-doc --help`
+- Without install: `npx schema2md-cli@latest --help`
+
+## CLI
+
+Required:
+- `--url` Database URL (sqlite://, postgres://, mysql://)
+- `--output` Output path (.md or .tex)
+
+Common:
+- `--exclude` Comma-separated glob patterns to ignore tables, e.g. `migrations,temp_*`
+- `--title` Document title (default: `Database Documentation`)
+
+Formats:
+- `--format md` (default)
+- `--format latex`
+
+LaTeX options:
+- `--summary` Generate a condensed LaTeX (counts + index + relations). Omit to include full per-table details.
+- `--compile` Compile `.tex` into `.pdf` (requires local LaTeX or Docker)
+- `--cleanup aux|all` Clean LaTeX aux files; `all` also deletes the `.tex`
+- `--docker` Use Docker to compile (when no local LaTeX): recommend `--docker-image blang/latex:ctanfull`
+- `--docker-image <image>` LaTeX Docker image (default: `paperist/alpine-texlive` if not set; `blang/latex:ctanfull` is safer)
+
+ER diagram options (Mermaid):
+- `--er` / `--no-er` Include/exclude ER diagram in LaTeX (default: include)
+- `--diagram-format svg|png|pdf` Render format for ER (default: `png` for LaTeX/pdflatex compatibility)
+- `--er-docker-image <image>` Mermaid CLI Docker image (e.g., `minlag/mermaid-cli:latest`)
+
+Notes on Mermaid rendering:
+- The CLI first tries Docker (Mermaid CLI). If not available or fails, it falls back to Kroki (https://kroki.io) to render the image. You can disable the fallback by providing an invalid URL via `KROKI_URL` env or removing network access.
+
+## Examples
+
+Project ships with ready SQLite examples:
+- `examples/sqlite/shop/`
+- `examples/sqlite/university/`
+- `examples/sqlite/org/`
+
+Each folder contains:
+- `*.sqlite` sample DB
+- `*.tex` LaTeX source
+- `*.pdf` compiled output
+- `*-er.mmd` Mermaid source of the ER diagram
+- `*-er.png` rendered ER diagram image
+
+Example command (Shop, LaTeX + PDF + ER diagram via Docker):
+
+```bash
+# Windows paths: ensure sqlite URL uses an absolute path
+# Use PNG diagram for pdflatex compatibility
+
+db-doc \
+  --url "sqlite:///C:/ABS/PATH/examples/sqlite/shop/shop.sqlite" \
+  --output "examples/sqlite/shop/shop.tex" \
+  --format latex \
+  --summary \
+  --er --diagram-format png \
+  --compile --cleanup aux \
+  --docker --docker-image "blang/latex:ctanfull"
+```
+
+PostgreSQL example:
+
+```bash
+db-doc \
+  --url "postgres://user:pass@host:5432/db?schema=public" \
+  --output out.tex \
+  --format latex \
+  --er --diagram-format png \
+  --compile --cleanup aux \
+  --docker --docker-image "blang/latex:ctanfull"
+```
+
+Markdown example (no PDF):
+
+```bash
+db-doc --url "sqlite:///C:/ABS/PATH/db.sqlite" --output README.md --format md --exclude "migrations,temp_*"
+```
+
+## Configuration (.dbdoc.json)
+
+Place at repo root to persist exclusions and future options:
+
+```json
+{
+  "exclude": ["migrations*", "sqlite_%"]
+}
+```
+
+CLI `--exclude` merges with config values (deduped).
+
+## Engine specifics
+
+- SQLite: PRAGMA introspection; no native comments → Description shows `-`.
+- PostgreSQL: information_schema + pg_description for comments; select schema via `?schema=`.
+- MySQL/MariaDB: information_schema; comments supported when present.
+
+## Development
+
+```bash
+npm install
+npm run build
+node dist/cli.js --url "sqlite:///C:/ABS/PATH/examples/sqlite/shop/shop.sqlite" \
+  --output "examples/sqlite/shop/shop.tex" --format latex --summary --er \
+  --diagram-format png --compile --cleanup aux --docker --docker-image blang/latex:ctanfull
+```
+
+

package/dist/cli.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("./utils/config");
+const filters_1 = require("./utils/filters");
+const sqliteExtractor_1 = require("./extractors/sqliteExtractor");
+const postgresExtractor_1 = require("./extractors/postgresExtractor");
+const mysqlExtractor_1 = require("./extractors/mysqlExtractor");
+const markdown_1 = require("./emitters/markdown");
+const latex_1 = require("./emitters/latex");
+const mermaidExport_1 = require("./utils/mermaidExport");
+const latexCompile_1 = require("./utils/latexCompile");
+function parseUrlToPath(urlStr) {
+    const u = new URL(urlStr);
+    if (u.protocol !== 'sqlite:')
+        throw new Error('Only sqlite URLs are supported (sqlite:///absolute/path.db)');
+    let p = u.pathname;
+    if (process.platform === 'win32' && p.startsWith('/') && p[2] === ':')
+        p = p.slice(1);
+    return p;
+}
+async function loadSchema(url, patterns) {
+    const proto = new URL(url).protocol;
+    if (proto.startsWith('sqlite')) {
+        const p = parseUrlToPath(url);
+        if (!(0, node_fs_1.existsSync)(p))
+            throw new Error(`SQLite file not found: ${p}`);
+        const ex = new sqliteExtractor_1.SQLiteExtractor(p);
+        const all = await ex.load();
+        const names = all.tables.map(t => t.name);
+        const kept = (0, filters_1.excludeNames)(names, patterns);
+        return (kept.length === names.length) ? all : await ex.load(kept);
+    }
+    if (proto.startsWith('postgres')) {
+        const schema = new URL(url).searchParams.get('schema') || 'public';
+        const ex = new postgresExtractor_1.PostgresExtractor(url, schema);
+        const all = await ex.load();
+        const names = all.tables.map(t => t.name);
+        const kept = (0, filters_1.excludeNames)(names, patterns);
+        return (kept.length === names.length) ? all : await ex.load(kept);
+    }
+    if (proto.startsWith('mysql')) {
+        const ex = new mysqlExtractor_1.MySQLExtractor(url);
+        const all = await ex.load();
+        const names = all.tables.map(t => t.name);
+        const kept = (0, filters_1.excludeNames)(names, patterns);
+        return (kept.length === names.length) ? all : await ex.load(kept);
+    }
+    throw new Error('Unsupported URL scheme. Use sqlite://, postgres://, or mysql://');
+}
+async function main() {
+    const { values } = (0, node_util_1.parseArgs)({
+        options: {
+            url: { type: 'string' },
+            output: { type: 'string' },
+            exclude: { type: 'string', default: '' },
+            title: { type: 'string', default: 'Database Documentation' },
+            format: { type: 'string', default: 'md' },
+            summary: { type: 'boolean', default: false },
+            compile: { type: 'boolean', default: false },
+            cleanup: { type: 'string', default: 'aux' },
+            docker: { type: 'boolean', default: false },
+            'docker-image': { type: 'string', default: 'paperist/alpine-texlive' },
+            er: { type: 'boolean', default: true },
+            'er-docker-image': { type: 'string', default: 'minlag/mermaid-cli:latest' },
+            'diagram-format': { type: 'string', default: 'png' },
+            'diagram-only': { type: 'boolean', default: false }
+        },
+        allowPositionals: false
+    });
+    if (!values.url || !values.output)
+        throw new Error('--url and --output are required');
+    const conf = (0, config_1.loadConfig)();
+    const excludeCli = String(values.exclude || '').split(',').map((s) => s.trim()).filter(Boolean);
+    const patterns = (0, config_1.mergePatterns)(excludeCli, conf.exclude);
+    const schema = await loadSchema(String(values.url), patterns);
+    const outPath = String(values.output);
+    const dir = (0, node_path_1.dirname)(outPath);
+    if (dir && !(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const fmt = String(values.format || 'md').toLowerCase();
+    if (Boolean(values['diagram-only'])) {
+        const desiredOut = String(values.output);
+        const fmtFromExt = /\.(png|svg|pdf)$/i.test(desiredOut) ? desiredOut.replace(/^.*\./, '').toLowerCase() : String(values['diagram-format'] || 'png');
+        const diag = await (0, mermaidExport_1.renderMermaidDiagram)(schema, desiredOut, { dockerImage: String(values['er-docker-image'] || ''), format: fmtFromExt });
+        if (!diag.ok || !diag.outPath) {
+            console.error(diag.log || 'Diagram generation failed');
+            process.exit(1);
+        }
+        console.log(`Wrote diagram: ${diag.outPath}`);
+        return;
+    }
+    const isSummary = Boolean(values.summary);
+    let figure;
+    if (fmt === 'latex' && values.er !== false) {
+        const diag = await (0, mermaidExport_1.renderMermaidDiagram)(schema, outPath, { dockerImage: String(values['er-docker-image'] || ''), format: String(values['diagram-format'] || 'png') });
+        if (diag.ok && diag.outPath)
+            figure = require('node:path').basename(diag.outPath);
+    }
+    const content = fmt === 'latex' ? (0, latex_1.renderLatex)(schema, String(values.title), isSummary, figure) : (0, markdown_1.renderMarkdown)(schema, String(values.title));
+    (0, node_fs_1.writeFileSync)(outPath, content, 'utf-8');
+    if (fmt === 'latex' && values.compile) {
+        const res = (0, latexCompile_1.compileLatex)(outPath, { docker: Boolean(values.docker), dockerImage: String(values['docker-image'] || 'paperist/alpine-texlive') });
+        if (!res.ok) {
+            console.error(res.log || 'LaTeX compile failed');
+            process.exit(1);
+        }
+        const mode = String(values.cleanup || 'aux');
+        (0, latexCompile_1.cleanupLatex)(outPath, mode);
+    }
+    console.log(`Wrote: ${outPath}`);
+}
+main().catch(err => { console.error(err.message); process.exit(1); });

package/dist/core/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/typeMapping.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGeneric = toGeneric;
+const GENERIC = {
+    'INT': 'Integer', 'INTEGER': 'Integer', 'TINYINT': 'Integer', 'SMALLINT': 'Integer',
+    'BIGINT': 'Integer', 'UNSIGNED BIG INT': 'Integer',
+    'REAL': 'Float', 'DOUBLE': 'Float', 'DOUBLE PRECISION': 'Float', 'FLOAT': 'Float',
+    'NUMERIC': 'Numeric', 'DECIMAL': 'Numeric', 'BOOLEAN': 'Boolean',
+    'DATE': 'Date', 'DATETIME': 'Datetime', 'TIMESTAMP': 'Datetime',
+    'TEXT': 'String', 'CLOB': 'String', 'CHAR': 'String', 'VARCHAR': 'String', 'NVARCHAR': 'String',
+    'BLOB': 'Blob'
+};
+function toGeneric(dbType) {
+    if (!dbType)
+        return 'Unknown';
+    const t = String(dbType).trim().toUpperCase();
+    const base = t.match(/^([A-Z ]+)/)?.[1].trim() ?? t;
+    const norm = base.replace(/\s+/g, ' ');
+    return GENERIC[norm] ?? (norm.includes('CHAR') || norm.includes('TEXT') ? 'String' : capitalize(norm));
+}
+function capitalize(s) {
+    return s.toLowerCase().replace(/(^|\s)([a-z])/g, (_, a, b) => a + b.toUpperCase());
+}

package/dist/counter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCounter = setupCounter;
+function setupCounter(element) {
+    let counter = 0;
+    const setCounter = (count) => {
+        counter = count;
+        element.innerHTML = `Count is ${counter}`;
+    };
+    element.addEventListener('click', () => setCounter(counter + 1));
+    setCounter(0);
+}

package/dist/emitters/latex.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderLatex = renderLatex;
+function esc(s) {
+    return s
+        .replace(/\\/g, '\\textbackslash{}')
+        .replace(/([#%&_{}$])/g, '\\$1')
+        .replace(/\^/g, '\\textasciicircum{}')
+        .replace(/~/g, '\\textasciitilde{}');
+}
+function header(title) {
+    return [
+        '\\documentclass[11pt]{article}',
+        '\\usepackage[margin=2.5cm]{geometry}',
+        '\\usepackage[T1]{fontenc}',
+        '\\usepackage{graphicx}',
+        '\\usepackage{hyperref}',
+        '\\usepackage{longtable}',
+        '\\usepackage{booktabs}',
+        '\\title{' + esc(title) + '}',
+        '\\begin{document}',
+        '\\maketitle',
+    ];
+}
+function tableIndex(schema) {
+    const lines = [];
+    lines.push('\\section*{Table Index}');
+    lines.push('\\begin{itemize}');
+    for (const t of [...schema.tables].sort((a, b) => a.name.localeCompare(b.name))) {
+        lines.push('  \\item ' + esc(t.name));
+    }
+    lines.push('\\end{itemize}');
+    return lines;
+}
+function relationships(schema) {
+    const lines = [];
+    lines.push('\\section*{Relations (FK)}');
+    if (!schema.tables.some(t => t.fks.length)) {
+        lines.push('No foreign keys detected.');
+        return lines;
+    }
+    lines.push('\\begin{itemize}');
+    for (const t of schema.tables) {
+        for (const fk of t.fks) {
+            lines.push('  \\item ' + esc(`${fk.from_table}.${fk.from_column} -> ${fk.to_table}.${fk.to_column}`));
+        }
+    }
+    lines.push('\\end{itemize}');
+    return lines;
+}
+function tableSummary(schema) {
+    const lines = [];
+    lines.push('\\section*{Summary}');
+    const tableCount = schema.tables.length;
+    const colCount = schema.tables.reduce((n, t) => n + t.columns.length, 0);
+    const fkCount = schema.tables.reduce((n, t) => n + t.fks.length, 0);
+    lines.push(`Total tables: ${tableCount}\\\\`);
+    lines.push(`Total columns: ${colCount}\\\\`);
+    lines.push(`Total foreign keys: ${fkCount}`);
+    return lines;
+}
+function tableDetails(schema) {
+    const lines = [];
+    for (const t of [...schema.tables].sort((a, b) => a.name.localeCompare(b.name))) {
+        lines.push('\\section*{Table: ' + esc(t.name) + '}');
+        if (t.comment)
+            lines.push(esc(t.comment));
+        lines.push('\\begin{longtable}{@{}llllll@{}}');
+        lines.push('\\toprule');
+        lines.push('Column & Type & Attr & Null & Default & Description \\\\');
+        lines.push('\\midrule');
+        const cols = [...t.columns].sort((a, b) => (Number(b.is_pk) - Number(a.is_pk)) || a.name.localeCompare(b.name));
+        for (const c of cols) {
+            const attrs = [c.is_pk ? 'PK' : '', c.is_fk ? 'FK' : ''].filter(Boolean).join('/') || '-';
+            const nullable = c.nullable ? 'Yes' : 'No';
+            const defv = c.default != null && String(c.default).trim() !== '' ? esc(String(c.default)) : '-';
+            const desc = c.comment?.trim() ? esc(c.comment) : '-';
+            lines.push(`${esc(c.name)} & ${esc(c.type)} & ${esc(attrs)} & ${nullable} & ${defv} & ${desc} \\\\`);
+        }
+        lines.push('\\bottomrule');
+        lines.push('\\end{longtable}');
+    }
+    return lines;
+}
+function renderLatex(schema, title = 'Database Documentation', summaryOnly = false, figurePath) {
+    const out = [];
+    out.push(...header(title));
+    out.push(...tableSummary(schema));
+    out.push('');
+    out.push(...tableIndex(schema));
+    out.push('');
+    if (figurePath) {
+        out.push('\\section*{ER Diagram}');
+        out.push('\\begin{center}');
+        out.push('\\includegraphics[width=\\textwidth]{' + (figurePath.replace(/\\\\/g, '/')) + '}');
+        out.push('\\end{center}');
+    }
+    out.push(...relationships(schema));
+    if (!summaryOnly) {
+        out.push('');
+        out.push(...tableDetails(schema));
+    }
+    out.push('\\end{document}');
+    return out.join('\n');
+}

package/dist/emitters/markdown.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdown = renderMarkdown;
+const mermaid_1 = require("./mermaid");
+function slug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function sortColumns(cols) {
+    return [...cols].sort((a, b) => (Number(b.is_pk) - Number(a.is_pk)) || a.name.localeCompare(b.name));
+}
+function header() {
+    return '| Column | Type | Attr | Null | Default | Description |\n|---|---|---|---|---|---|';
+}
+function row(c) {
+    const attrs = [c.is_pk ? 'PK' : '', c.is_fk ? 'FK' : ''].filter(Boolean).join('/') || '-';
+    const nullable = c.nullable ? 'Yes' : 'No';
+    const defv = c.default != null && String(c.default).trim() !== '' ? `\`${String(c.default)}\`` : '-';
+    const desc = c.comment?.trim() ? c.comment : '-';
+    return `| ${c.name} | \`${c.type}\` | ${attrs} | ${nullable} | ${defv} | ${desc} |`;
+}
+function sectionForTable(t) {
+    const lines = [];
+    const id = slug(t.name);
+    const pkCount = t.columns.filter(c => c.is_pk).length;
+    const fkCount = t.fks.length;
+    lines.push(`### ${t.name}`);
+    lines.push(`<a id="table-${id}"></a>`);
+    if (t.comment && t.comment.trim()) {
+        lines.push('');
+        lines.push(`_${t.comment.trim()}_`);
+    }
+    lines.push('');
+    lines.push(`Columns: ${t.columns.length} / PK: ${pkCount} / FKs: ${fkCount}`);
+    lines.push('');
+    lines.push(header());
+    for (const c of sortColumns(t.columns))
+        lines.push(row(c));
+    if (t.fks.length) {
+        lines.push('');
+        lines.push('Foreign Keys');
+        lines.push('');
+        for (const fk of t.fks) {
+            lines.push(`- \`${fk.from_table}.${fk.from_column}\` -> \`${fk.to_table}.${fk.to_column}\` (\`${fk.name}\`)`);
+        }
+    }
+    lines.push('');
+    lines.push('[Back to index](#table-index)');
+    lines.push('');
+    return lines;
+}
+function renderMarkdown(schema, title = 'Database Documentation') {
+    const out = [];
+    const tables = [...schema.tables].sort((a, b) => a.name.localeCompare(b.name));
+    out.push(`# ${title}`);
+    out.push('');
+    out.push('## Table Index');
+    out.push('<a id="table-index"></a>');
+    for (const t of tables)
+        out.push(`- [${t.name}](#table-${slug(t.name)})`);
+    out.push('');
+    out.push('## Global ER Diagram');
+    out.push('```mermaid');
+    out.push((0, mermaid_1.erDiagram)(schema));
+    out.push('```');
+    out.push('');
+    out.push('## Tables');
+    out.push('');
+    for (const t of tables)
+        out.push(...sectionForTable(t));
+    return out.join('\n');
+}

package/dist/emitters/mermaid.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erDiagram = erDiagram;
+function erDiagram(schema) {
+    const lines = [];
+    lines.push('erDiagram');
+    for (const table of schema.tables) {
+        lines.push(`    ${table.name} {`);
+        for (const col of table.columns) {
+            const pk = col.is_pk ? ' PK' : '';
+            const coltype = col.type.toLowerCase();
+            lines.push(`        ${coltype} ${col.name}${pk}`);
+        }
+        lines.push('    }');
+    }
+    for (const table of schema.tables) {
+        for (const fk of table.fks) {
+            lines.push(`    ${fk.to_table} ||--o{ ${fk.from_table} : \"${fk.name}\"`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/extractors/mysqlExtractor.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLExtractor = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+const typeMapping_1 = require("../core/typeMapping");
+class MySQLExtractor {
+    constructor(url, database) {
+        this.url = url;
+        this.database = database;
+    }
+    async load(includeTables) {
+        const conn = await promise_1.default.createConnection(this.url);
+        try {
+            const [dbRow] = await conn.query("SELECT DATABASE() AS db");
+            // @ts-ignore
+            const dbName = (Array.isArray(dbRow) ? dbRow[0].db : dbRow.db);
+            const [tablesRows] = await conn.query("SELECT table_name, table_comment FROM information_schema.tables WHERE table_type='BASE TABLE' AND table_schema=? ORDER BY table_name", [dbName]);
+            let tableNames = tablesRows.map(r => r.table_name);
+            const tableComment = new Map(tablesRows.map(r => [r.table_name, r.table_comment ?? null]));
+            if (includeTables)
+                tableNames = includeTables;
+            const [colsRows] = await conn.query("SELECT table_name, column_name, data_type, is_nullable, column_default, column_comment FROM information_schema.columns WHERE table_schema=? AND table_name IN (?)", [dbName, tableNames]);
+            const [pkRows] = await conn.query("SELECT kcu.table_name, kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name=kcu.constraint_name AND tc.table_schema=kcu.table_schema WHERE tc.constraint_type='PRIMARY KEY' AND tc.table_schema=? AND kcu.table_name IN (?)", [dbName, tableNames]);
+            const pkSet = new Set(pkRows.map(r => `${r.table_name}.${r.column_name}`));
+            const [fkRows] = await conn.query("SELECT kcu.constraint_name, kcu.table_name AS from_table, kcu.column_name AS from_column, kcu.referenced_table_name AS to_table, kcu.referenced_column_name AS to_column FROM information_schema.key_column_usage kcu WHERE kcu.table_schema=? AND kcu.referenced_table_schema=? AND kcu.table_name IN (?) AND kcu.referenced_table_name IS NOT NULL", [dbName, dbName, tableNames]);
+            const colComment = new Map();
+            const columnsByTable = new Map();
+            for (const r of colsRows) {
+                const key = r.table_name;
+                const id = `${r.table_name}.${r.column_name}`;
+                const cols = columnsByTable.get(key) || [];
+                cols.push({
+                    name: r.column_name,
+                    type: (0, typeMapping_1.toGeneric)(r.data_type),
+                    nullable: String(r.is_nullable).toUpperCase() === 'YES',
+                    default: r.column_default ?? null,
+                    is_pk: pkSet.has(id),
+                    is_fk: false,
+                    comment: (r.column_comment ?? null)
+                });
+                columnsByTable.set(key, cols);
+            }
+            const fks = fkRows.map(r => ({
+                name: r.constraint_name,
+                from_table: r.from_table,
+                from_column: r.from_column,
+                to_table: r.to_table,
+                to_column: r.to_column
+            }));
+            for (const fk of fks) {
+                const cols = columnsByTable.get(fk.from_table) || [];
+                const c = cols.find(x => x.name === fk.from_column);
+                if (c)
+                    c.is_fk = true;
+            }
+            const tables = [];
+            for (const t of tableNames) {
+                tables.push({
+                    name: t,
+                    comment: tableComment.get(t) ?? null,
+                    columns: columnsByTable.get(t) || [],
+                    fks: fks.filter(f => f.from_table === t)
+                });
+            }
+            return { tables };
+        }
+        finally {
+            await conn.end();
+        }
+    }
+}
+exports.MySQLExtractor = MySQLExtractor;

package/dist/extractors/postgresExtractor.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresExtractor = void 0;
+const pg_1 = require("pg");
+const typeMapping_1 = require("../core/typeMapping");
+class PostgresExtractor {
+    constructor(url, schema = 'public') {
+        this.url = url;
+        this.schema = schema;
+    }
+    async load(includeTables) {
+        const client = new pg_1.Client({ connectionString: this.url });
+        await client.connect();
+        try {
+            const tablesRes = await client.query(`SELECT table_name FROM information_schema.tables
+         WHERE table_type='BASE TABLE' AND table_schema=$1
+         ORDER BY table_name`, [this.schema]);
+            let tableNames = tablesRes.rows.map((r) => r.table_name);
+            if (includeTables)
+                tableNames = includeTables;
+            // Columns
+            const colsRes = await client.query(`SELECT table_name, column_name, data_type, is_nullable, column_default
+         FROM information_schema.columns
+         WHERE table_schema=$1 AND table_name = ANY($2::text[])`, [this.schema, tableNames]);
+            // PKs
+            const pksRes = await client.query(`SELECT kcu.table_name, kcu.column_name
+           FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          WHERE tc.constraint_type = 'PRIMARY KEY'
+            AND tc.table_schema = $1
+            AND kcu.table_name = ANY($2::text[])`, [this.schema, tableNames]);
+            const pkSet = new Set(pksRes.rows.map((r) => `${r.table_name}.${r.column_name}`));
+            // FKs
+            const fksRes = await client.query(`SELECT tc.constraint_name,
+                kcu.table_name   AS from_table,
+                kcu.column_name  AS from_column,
+                ccu.table_name   AS to_table,
+                ccu.column_name  AS to_column
+           FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+           JOIN information_schema.constraint_column_usage ccu
+             ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND tc.table_schema = $1
+            AND kcu.table_name = ANY($2::text[])`, [this.schema, tableNames]);
+            // Comments (optional)
+            const commentsRes = await client.query(`SELECT c.relname AS table_name, obj_description(c.oid) AS table_comment
+           FROM pg_class c
+           JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE n.nspname = $1 AND c.relkind='r'`, [this.schema]);
+            const tableComment = new Map(commentsRes.rows.map((r) => [r.table_name, r.table_comment]));
+            const colCommentsRes = await client.query(`SELECT c.relname AS table_name, a.attname AS column_name, col_description(c.oid, a.attnum) AS column_comment
+           FROM pg_class c
+           JOIN pg_namespace n ON n.oid = c.relnamespace
+           JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
+          WHERE n.nspname = $1`, [this.schema]);
+            const colComment = new Map(colCommentsRes.rows.map((r) => [`${r.table_name}.${r.column_name}`, r.column_comment]));
+            const columnsByTable = new Map();
+            for (const row of colsRes.rows) {
+                const key = `${row.table_name}`;
+                const cols = columnsByTable.get(key) || [];
+                const id = `${row.table_name}.${row.column_name}`;
+                cols.push({
+                    name: row.column_name,
+                    type: (0, typeMapping_1.toGeneric)(row.data_type),
+                    nullable: String(row.is_nullable).toUpperCase() === 'YES',
+                    default: row.column_default ?? null,
+                    is_pk: pkSet.has(id),
+                    is_fk: false,
+                    comment: colComment.get(id) ?? null
+                });
+                columnsByTable.set(key, cols);
+            }
+            const fks = fksRes.rows.map((r) => ({
+                name: r.constraint_name,
+                from_table: r.from_table,
+                from_column: r.from_column,
+                to_table: r.to_table,
+                to_column: r.to_column
+            }));
+            // mark FK flags
+            for (const fk of fks) {
+                const cols = columnsByTable.get(fk.from_table) || [];
+                const c = cols.find(x => x.name === fk.from_column);
+                if (c)
+                    c.is_fk = true;
+            }
+            const tables = [];
+            for (const t of tableNames) {
+                tables.push({
+                    name: t,
+                    comment: tableComment.get(t) ?? null,
+                    columns: columnsByTable.get(t) || [],
+                    fks: fks.filter(f => f.from_table === t)
+                });
+            }
+            return { tables };
+        }
+        finally {
+            await client.end();
+        }
+    }
+}
+exports.PostgresExtractor = PostgresExtractor;

package/dist/extractors/sqliteExtractor.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteExtractor = void 0;
+const node_fs_1 = require("node:fs");
+const sql_js_1 = __importDefault(require("sql.js"));
+const typeMapping_1 = require("../core/typeMapping");
+function rows(res) {
+    if (!res)
+        return [];
+    const { columns, values } = res;
+    return values.map((v) => Object.fromEntries(v.map((val, i) => [columns[i], val])));
+}
+class SQLiteExtractor {
+    constructor(path) {
+        this.path = path;
+    }
+    async load(includeTables) {
+        const SQL = await (0, sql_js_1.default)();
+        const data = (0, node_fs_1.readFileSync)(this.path);
+        const db = new SQL.Database(new Uint8Array(data));
+        try {
+            const result = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name")[0];
+            let tableNames = rows(result).map(r => String(r.name));
+            if (includeTables)
+                tableNames = includeTables;
+            const tables = [];
+            for (const tname of tableNames) {
+                const info = db.exec(`PRAGMA table_info('${tname.replace(/'/g, "''")}')`)[0];
+                const cols = rows(info).map(r => ({
+                    name: String(r.name),
+                    type: (0, typeMapping_1.toGeneric)(String(r.type ?? '')),
+                    nullable: Number(r.notnull) === 0,
+                    default: r.dflt_value == null ? null : String(r.dflt_value),
+                    is_pk: Number(r.pk) > 0,
+                    is_fk: false,
+                    comment: null
+                }));
+                const fkRes = db.exec(`PRAGMA foreign_key_list('${tname.replace(/'/g, "''")}')`)[0];
+                const fks = rows(fkRes).map(r => ({
+                    name: `fk_${tname}_${r.from}_to_${r.table}_${r.to}`,
+                    from_table: tname,
+                    from_column: String(r.from),
+                    to_table: String(r.table),
+                    to_column: String(r.to)
+                }));
+                for (const fk of fks) {
+                    const c = cols.find(x => x.name === fk.from_column);
+                    if (c)
+                        c.is_fk = true;
+                }
+                tables.push({ name: tname, columns: cols, fks });
+            }
+            return { tables };
+        }
+        finally {
+            db.close();
+        }
+    }
+}
+exports.SQLiteExtractor = SQLiteExtractor;

package/dist/main.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./style.css");
+const typescript_svg_1 = __importDefault(require("./assets/typescript.svg"));
+const vite_svg_1 = __importDefault(require("./assets/vite.svg"));
+const hero_png_1 = __importDefault(require("./assets/hero.png"));
+const counter_ts_1 = require("./counter.ts");
+document.querySelector('#app').innerHTML = `
+<section id="center">
+  <div class="hero">
+    <img src="${hero_png_1.default}" class="base" width="170" height="179">
+    <img src="${typescript_svg_1.default}" class="framework" alt="TypeScript logo"/>
+    <img src=${vite_svg_1.default} class="vite" alt="Vite logo" />
+  </div>
+  <div>
+    <h1>Get started</h1>
+    <p>Edit <code>src/main.ts</code> and save to test <code>HMR</code></p>
+  </div>
+  <button id="counter" type="button" class="counter"></button>
+</section>
+
+<div class="ticks"></div>
+
+<section id="next-steps">
+  <div id="docs">
+    <svg class="icon" role="presentation" aria-hidden="true"><use href="/icons.svg#documentation-icon"></use></svg>
+    <h2>Documentation</h2>
+    <p>Your questions, answered</p>
+    <ul>
+      <li>
+        <a href="https://vite.dev/" target="_blank">
+          <img class="logo" src=${vite_svg_1.default} alt="" />
+          Explore Vite
+        </a>
+      </li>
+      <li>
+        <a href="https://www.typescriptlang.org" target="_blank">
+          <img class="button-icon" src="${typescript_svg_1.default}" alt="">
+          Learn more
+        </a>
+      </li>
+    </ul>
+  </div>
+  <div id="social">
+    <svg class="icon" role="presentation" aria-hidden="true"><use href="/icons.svg#social-icon"></use></svg>
+    <h2>Connect with us</h2>
+    <p>Join the Vite community</p>
+    <ul>
+      <li><a href="https://github.com/vitejs/vite" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#github-icon"></use></svg>GitHub</a></li>
+      <li><a href="https://chat.vite.dev/" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#discord-icon"></use></svg>Discord</a></li>
+      <li><a href="https://x.com/vite_js" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#x-icon"></use></svg>X.com</a></li>
+      <li><a href="https://bsky.app/profile/vite.dev" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#bluesky-icon"></use></svg>Bluesky</a></li>
+    </ul>
+  </div>
+</section>
+
+<div class="ticks"></div>
+<section id="spacer"></section>
+`;
+(0, counter_ts_1.setupCounter)(document.querySelector('#counter'));

package/dist/utils/config.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.mergePatterns = mergePatterns;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const DEFAULT = { exclude: [] };
+const FILENAME = '.dbdoc.json';
+function loadConfig(cwd = process.cwd()) {
+    const path = (0, node_path_1.join)(cwd, FILENAME);
+    if (!(0, node_fs_1.existsSync)(path))
+        return { ...DEFAULT };
+    try {
+        const raw = (0, node_fs_1.readFileSync)(path, 'utf-8');
+        const obj = JSON.parse(raw);
+        const out = { ...DEFAULT };
+        if (obj && Array.isArray(obj.exclude))
+            out.exclude = obj.exclude.map(String);
+        return out;
+    }
+    catch {
+        return { ...DEFAULT };
+    }
+}
+function mergePatterns(cli, conf) {
+    const list = [...(conf || []), ...(cli || [])];
+    const seen = new Set();
+    const out = [];
+    for (const p of list)
+        if (!seen.has(p)) {
+            seen.add(p);
+            out.push(p);
+        }
+    return out;
+}

package/dist/utils/filters.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeNames = excludeNames;
+exports.matchPattern = matchPattern;
+function excludeNames(names, patterns) {
+    if (!patterns || patterns.length === 0)
+        return Array.from(names);
+    const out = [];
+    for (const n of names) {
+        if (patterns.some((p) => matchPattern(n, p)))
+            continue;
+        out.push(n);
+    }
+    return out;
+}
+// Simple wildcard: * and ? only
+function matchPattern(text, pattern) {
+    const esc = pattern.replace(/[.+^${}()|\[\]\\]/g, '\\$&');
+    const rx = '^' + esc.replace(/\*/g, '.*').replace(/\?/g, '.') + '$';
+    return new RegExp(rx).test(text);
+}

package/dist/utils/latexCompile.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileLatex = compileLatex;
+exports.cleanupLatex = cleanupLatex;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+function which(cmd) {
+    const r = (0, node_child_process_1.spawnSync)(process.platform === 'win32' ? 'where' : 'which', [cmd], { stdio: 'ignore' });
+    return r.status === 0;
+}
+function hasDocker() { return which('docker'); }
+function compileLatex(texPath, opts = {}) {
+    const texAbs = (0, node_path_1.resolve)(texPath);
+    const dir = (0, node_path_1.dirname)(texAbs);
+    const pdfPath = texAbs.replace(/\.tex$/i, '.pdf');
+    const localEngine = which('pdflatex') ? 'pdflatex' : (which('xelatex') ? 'xelatex' : null);
+    const wantDocker = !!opts.docker || !localEngine;
+    if (!wantDocker) {
+        const args = ['-interaction=nonstopmode', '-halt-on-error', texAbs];
+        const r = (0, node_child_process_1.spawnSync)(localEngine, args, { cwd: dir, encoding: 'utf-8' });
+        const ok = r.status === 0 && (0, node_fs_1.existsSync)(pdfPath);
+        return { ok, pdfPath, log: r.stdout + (r.stderr || '') };
+    }
+    if (!hasDocker()) {
+        return { ok: false, log: 'No LaTeX engine (pdflatex/xelatex) and Docker not found.' };
+    }
+    const image = opts.dockerImage || 'tectonicapp/tectonic:latest';
+    const fileBase = texAbs.replace(/^.*[\\\/]/, '');
+    let args;
+    if ((image || '').includes('tectonic')) {
+        args = ['run', '--rm', '-v', `${dir}:/work`, '-w', '/work', image, 'tectonic', '-X', 'compile', fileBase];
+    }
+    else {
+        args = ['run', '--rm', '-v', `${dir}:/work`, '-w', '/work', image, 'latexmk', '-pdf', '-interaction=nonstopmode', '-halt-on-error', fileBase];
+    }
+    const r = (0, node_child_process_1.spawnSync)('docker', args, { encoding: 'utf-8' });
+    const ok = r.status === 0 && (0, node_fs_1.existsSync)(pdfPath);
+    return { ok, pdfPath, log: r.stdout + (r.stderr || '') };
+}
+function cleanupLatex(texPath, mode) {
+    const fs = require('node:fs');
+    const path = require('node:path');
+    const abs = path.resolve(texPath);
+    const base = abs.replace(/\.tex$/i, '');
+    const exts = ['.aux', '.log', '.out', '.toc', '.synctex.gz'];
+    if (mode === 'aux' || mode === 'all') {
+        for (const ext of exts) {
+            const p = base + ext;
+            try {
+                if (fs.existsSync(p))
+                    fs.unlinkSync(p);
+            }
+            catch { }
+        }
+    }
+    if (mode === 'all') {
+        try {
+            if (fs.existsSync(abs))
+                fs.unlinkSync(abs);
+        }
+        catch { }
+    }
+}

package/dist/utils/mermaidExport.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMermaidDiagram = renderMermaidDiagram;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const mermaid_1 = require("../emitters/mermaid");
+function which(cmd) {
+    const r = (0, node_child_process_1.spawnSync)(process.platform === 'win32' ? 'where' : 'which', [cmd], { stdio: 'ignore' });
+    return r.status === 0;
+}
+async function tryKroki(diagram, outPath, format) {
+    const urlBase = process.env.KROKI_URL || 'https://kroki.io';
+    const endpoint = `${urlBase}/mermaid/${format}`;
+    const resp = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'text/plain' },
+        body: diagram
+    });
+    if (!resp.ok)
+        return false;
+    const buf = new Uint8Array(await resp.arrayBuffer());
+    (0, node_fs_1.writeFileSync)(outPath, buf);
+    return (0, node_fs_1.existsSync)(outPath);
+}
+async function renderMermaidDiagram(schema, outPath, opts) {
+    const format = (opts?.format || 'png');
+    const isImage = /\.(png|svg|pdf)$/i.test(outPath);
+    const baseNoExt = outPath.replace(/\.[^.]+$/, '');
+    const base = isImage ? baseNoExt : (baseNoExt + '-er');
+    const imgPath = isImage ? outPath : `${base}.${format}`;
+    const mmdPath = `${base}.mmd`;
+    const mmd = (0, mermaid_1.erDiagram)(schema);
+    (0, node_fs_1.writeFileSync)(mmdPath, mmd, 'utf-8');
+    // 1) Try Docker Mermaid CLI if provided
+    const image = opts?.dockerImage;
+    if (image && which('docker')) {
+        const wd = (0, node_path_1.resolve)((0, node_path_1.dirname)(outPath));
+        const input = (0, node_path_1.basename)(mmdPath);
+        const output = (0, node_path_1.basename)(imgPath);
+        const args = ['run', '--rm', '-v', `${wd}:/data`, '-w', '/data', image, 'mmdc', '-i', input, '-o', output, '-b', 'transparent'];
+        const r = (0, node_child_process_1.spawnSync)('docker', args, { encoding: 'utf-8' });
+        if (r.status === 0 && (0, node_fs_1.existsSync)(imgPath))
+            return { ok: true, outPath: imgPath };
+    }
+    // 2) Try Kroki HTTP fallback
+    try {
+        const ok = await tryKroki(mmd, imgPath, format);
+        if (ok)
+            return { ok: true, outPath: imgPath };
+    }
+    catch (e) {
+        return { ok: false, log: e?.message || String(e) };
+    }
+    return { ok: false, log: 'Mermaid render failed (Docker+Kroki)' };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name":  "schema2md-cli",
+    "version":  "0.3.0",
+    "description":  "Generate Markdown/LaTeX + Mermaid ER (CLI for DB schemas)",
+    "private":  false,
+    "type":  "commonjs",
+    "bin":  {
+                "db-doc":  "dist/cli.js"
+            },
+    "scripts":  {
+                    "build":  "tsc",
+                    "start":  "node dist/cli.js",
+                    "clean":  "node -e \"require(\u0027fs\u0027).rmSync(\u0027dist\u0027,{recursive:true,force:true})\"",
+                    "prepublishOnly":  "npm run build"
+                },
+    "dependencies":  {
+                         "sql.js":  "^1.9.0",
+                         "pg":  "^8.11.5",
+                         "mysql2":  "^3.11.0"
+                     },
+    "devDependencies":  {
+                            "typescript":  "^5.4.0",
+                            "@types/node":  "^20.11.30"
+                        },
+    "license":  "MIT",
+    "repository":  {
+                       "type":  "git",
+                       "url":  ""
+                   },
+    "files":  [
+                  "dist",
+                  "README.md",
+                  "LICENSE"
+              ],
+    "engines":  {
+
+                }
+}