draw2sql 1.0.0-beta.1

package/README.md

@@ -0,0 +1,131 @@
+# draw2sql
+
+[![npm](https://img.shields.io/npm/v/draw2sql)](https://www.npmjs.com/package/draw2sql)
+
+Generate SQL DDL from a draw.io XML ER diagram.
+
+## Dependencies
+
+**Runtime:** Node.js 18 or later. No other dependencies — the published package is a single compiled JavaScript file.
+
+**To build from source:** Node.js 18+, TypeScript 5+, ts-node 10+.
+
+## Installation
+
+### Run without installing (recommended)
+
+No install needed. `npx` downloads and runs draw2sql on the fly:
+
+```powershell
+npx draw2sql --input schema.drawio --dialect postgres
+```
+
+### Install as a project dev dependency
+
+Add draw2sql to a project's dev dependencies so it's available via `npx` without downloading each time:
+
+```powershell
+npm install --save-dev draw2sql
+npx draw2sql --input schema.drawio --dialect postgres
+```
+
+Or add a script to your project's `package.json` and skip `npx` entirely:
+
+```json
+"scripts": {
+  "generate-sql": "draw2sql --input schema.drawio --dialect postgres"
+}
+```
+
+```powershell
+npm run generate-sql
+```
+
+`npm run` automatically looks in `node_modules/.bin`, so no `npx` is needed in scripts.
+
+### Install globally
+
+Install once and run as a plain command from anywhere:
+
+```powershell
+npm install -g draw2sql
+draw2sql --input schema.drawio --dialect postgres
+```
+
+To uninstall: `npm uninstall -g draw2sql`
+
+## Usage
+
+If `--output` is omitted, the output file is derived from the input filename with a `.<dialect>.sql` extension:
+
+```powershell
+npx draw2sql --input schema.drawio --dialect postgres
+# writes schema.postgres.sql
+```
+
+If `--output` already exists, draw2sql fails by default to prevent accidental overwrite. Use `--overwrite` (or `-f`) to replace it:
+
+```powershell
+npx draw2sql --input schema.drawio --dialect postgres --overwrite
+```
+
+### Naming cases
+
+By default, draw2sql uses `db-default` naming:
+
+| SQL Dialect | Convention | Case | Traditional Identifier Quoting | If Unquoted |
+| --- | --- | --- | --- | --- |
+| `postgres` | `snake_case` | `snake` | `"name"` | Folded to lowercase (`MyTable` -> `mytable`); names with spaces fail unless quoted |
+| `mariadb` / `mysql` | `snake_case` | `snake` | `` `name` `` | Works for simple names; reserved words/special chars fail; spaces require quoting |
+| `sqlite` | `snake_case` | `snake` | `"name"` | Usually case-insensitive matching; names with spaces require quoting |
+| `sqlserver` | `PascalCase` | `pascal` | `[name]` | Works for regular names; reserved words/special chars fail; spaces require quoting |
+| `oracle` | `SCREAMING_SNAKE_CASE` | `screaming_snake` | `"NAME"` | Folded to uppercase (`mytable` -> `MYTABLE`); names with spaces fail unless quoted |
+
+Override with:
+
+```powershell
+npx draw2sql -i schema.drawio -d postgres --table-case snake --field-case snake
+```
+
+Supported cases:
+- `as-drawn` (no transformation)
+- `db-default` (default; depends on `--dialect`)
+- `pascal`
+- `camel`
+- `snake`
+- `screaming_snake`
+- `kebab`
+
+Supported dialects:
+- `postgres`
+- `mariadb` (also accepts `mysql`)
+- `sqlserver`
+- `sqlite`
+- `oracle`
+
+## Diagram parameter block
+
+You can add a text block in draw.io that includes parameters. Example:
+
+```text
+draw2sql
+dialect = oracle
+schema = FILEOMATIC
+```
+
+When present, recognized keys are captured and included in SQL output comments.
+- `dialect` (also `sqldialect`, `flavor`, `sqlFlavor`) overrides the CLI dialect.
+- `schema` qualifies generated table names (e.g. `"myschema"."users"`). If omitted, table names are unqualified and the database will use its session default (`public` for postgres, `dbo` for sqlserver, the connected user's schema for oracle, etc.). Ignored for `sqlite`, which has no schema concept.
+
+## Output strategy
+
+Generated SQL is idempotent-oriented and includes:
+1. create-table pass
+2. add-missing-columns pass
+3. inferred foreign-key pass
+
+This generator infers column types/keys from draw.io table shapes and labels (for example `PK`, `FK`, `Name: varchar(120)`, `ProviderId (FK)`).
+
+## Notes on Oracle
+
+Oracle output uses PL/SQL blocks for create/alter operations with existence checks so scripts can be rerun safely.

package/dist/draw2sql.js

@@ -0,0 +1,985 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlTypeMapper = exports.DrawIoDiagramParser = exports.CliParser = exports.NameStyler = exports.NameStyleResolver = exports.DialectResolver = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const DEFAULT_REF_COLUMN = "Id";
+const MARKER_WORDS = new Set(["PK", "FK", "NN", "NOT NULL", "UNIQUE", "UQ"]);
+class DialectResolver {
+    static normalize(input) {
+        const normalized = input.trim().toLowerCase();
+        if (normalized === "postgres" || normalized === "postgresql")
+            return "postgres";
+        if (normalized === "mariadb" || normalized === "mysql")
+            return "mariadb";
+        if (normalized === "sqlserver" || normalized === "mssql")
+            return "sqlserver";
+        if (normalized === "sqlite" || normalized === "sqlite3")
+            return "sqlite";
+        if (normalized === "oracle" || normalized === "oracledb")
+            return "oracle";
+        return null;
+    }
+}
+exports.DialectResolver = DialectResolver;
+class NameStyleResolver {
+    static normalize(input) {
+        const normalized = input.trim().toLowerCase();
+        if (normalized === "as-drawn" || normalized === "asdrawn" || normalized === "as_drawn")
+            return "as-drawn";
+        if (normalized === "db-default" || normalized === "dbdefault" || normalized === "db_default" || normalized === "default")
+            return "db-default";
+        if (normalized === "pascal" || normalized === "pascalcase")
+            return "pascal";
+        if (normalized === "camel" || normalized === "camelcase")
+            return "camel";
+        if (normalized === "snake" || normalized === "snake_case" || normalized === "snakecase")
+            return "snake";
+        if (normalized === "screaming_snake" || normalized === "screaming-snake" || normalized === "screamingsnake")
+            return "screaming_snake";
+        if (normalized === "kebab" || normalized === "kebab-case" || normalized === "kebabcase")
+            return "kebab";
+        return null;
+    }
+}
+exports.NameStyleResolver = NameStyleResolver;
+class NameStyler {
+    static resolveDbDefault(dialect) {
+        if (dialect === "sqlserver")
+            return "pascal";
+        if (dialect === "oracle")
+            return "screaming_snake";
+        return "snake";
+    }
+    static resolve(style, dialect) {
+        return style === "db-default" ? NameStyler.resolveDbDefault(dialect) : style;
+    }
+    static apply(tables, dialect, naming) {
+        const tableStyle = NameStyler.resolve(naming.tableCase, dialect);
+        const fieldStyle = NameStyler.resolve(naming.fieldCase, dialect);
+        const usedTableNames = new Set();
+        const tableOldToNew = new Map();
+        const colOldToNewByTable = new Map();
+        for (const table of tables) {
+            const oldTableName = table.name;
+            const styledTableName = NameStyler.uniqueName(NameStyler.transform(oldTableName, tableStyle), usedTableNames, tableStyle);
+            tableOldToNew.set(oldTableName, styledTableName);
+            const usedColNames = new Set();
+            const colOldToNew = new Map();
+            for (const col of table.columns) {
+                const oldColName = col.name;
+                const styledColName = NameStyler.uniqueName(NameStyler.transform(oldColName, fieldStyle), usedColNames, fieldStyle);
+                colOldToNew.set(oldColName, styledColName);
+            }
+            colOldToNewByTable.set(oldTableName, colOldToNew);
+        }
+        for (const table of tables) {
+            const oldTableName = table.name;
+            const colOldToNew = colOldToNewByTable.get(oldTableName);
+            table.name = tableOldToNew.get(oldTableName) ?? table.name;
+            for (const col of table.columns) {
+                const oldColName = col.name;
+                col.name = colOldToNew?.get(oldColName) ?? col.name;
+            }
+        }
+        for (const table of tables) {
+            for (const col of table.columns) {
+                const refTableOld = col.referencesTable;
+                if (!refTableOld)
+                    continue;
+                col.referencesTable = tableOldToNew.get(refTableOld) ?? refTableOld;
+                const refColOld = col.referencesColumn;
+                if (!refColOld)
+                    continue;
+                const refColMap = colOldToNewByTable.get(refTableOld);
+                col.referencesColumn = refColMap?.get(refColOld) ?? refColOld;
+            }
+        }
+        return { tableStyle, fieldStyle };
+    }
+    static transform(name, style) {
+        const trimmed = name.trim();
+        if (!trimmed)
+            return trimmed;
+        if (style === "as-drawn")
+            return trimmed;
+        const words = NameStyler.words(trimmed);
+        if (words.length === 0)
+            return trimmed;
+        if (style === "snake")
+            return words.map((w) => w.toLowerCase()).join("_");
+        if (style === "screaming_snake")
+            return words.map((w) => w.toUpperCase()).join("_");
+        if (style === "kebab")
+            return words.map((w) => w.toLowerCase()).join("-");
+        if (style === "pascal")
+            return words.map((w) => NameStyler.capitalize(w)).join("");
+        if (style === "camel") {
+            const [first, ...rest] = words;
+            return [first.toLowerCase(), ...rest.map((w) => NameStyler.capitalize(w))].join("");
+        }
+        return trimmed;
+    }
+    static words(input) {
+        const withCamelBoundaries = input
+            .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+            .replace(/([A-Z])([A-Z][a-z])/g, "$1 $2");
+        const normalized = withCamelBoundaries.replace(/[^A-Za-z0-9]+/g, " ");
+        return normalized.split(/\s+/).map((w) => w.trim()).filter(Boolean);
+    }
+    static capitalize(word) {
+        if (!word)
+            return word;
+        const lower = word.toLowerCase();
+        return lower[0].toUpperCase() + lower.slice(1);
+    }
+    static uniqueName(base, used, style) {
+        const trimmed = base.trim();
+        if (!trimmed)
+            return trimmed;
+        if (!used.has(trimmed)) {
+            used.add(trimmed);
+            return trimmed;
+        }
+        let i = 2;
+        while (true) {
+            const candidate = `${trimmed}${NameStyler.suffix(style, i)}`;
+            if (!used.has(candidate)) {
+                used.add(candidate);
+                return candidate;
+            }
+            i++;
+        }
+    }
+    static suffix(style, i) {
+        if (style === "kebab")
+            return `-${i}`;
+        if (style === "snake" || style === "screaming_snake" || style === "as-drawn")
+            return `_${i}`;
+        return `${i}`;
+    }
+}
+exports.NameStyler = NameStyler;
+class CliParser {
+    static HELP = [
+        "",
+        "+--------------------------------------------------------------+",
+        "|   draw2sql:  Convert draw.io ER diagram into SQL DDL         |",
+        "+--------------------------------------------------------------+",
+        "",
+        "Usage:",
+        "  draw2sql --input <file> --dialect <dialect> [options]",
+        "  draw2sql <input.drawio> <dialect> [output.sql] [options]",
+        "",
+        "Arguments:",
+        "  -i, --input <file>              Input .drawio diagram file (or 1st positional arg)",
+        "  -d, --dialect <dialect>         SQL dialect to generate (or 2nd positional arg; or set in diagram)",
+        "  -o, --output <file>             Output SQL file (default: <input>.<dialect>.sql)",
+        "  -f, --overwrite                 Overwrite output file if it exists",
+        "  -h, --help                      Show this help",
+        "      --schema <name>             Qualify table names with a schema prefix; omit to use the database default (ignored for sqlite)",
+        "      --table-case <case>         Table naming case (default: db-default)",
+        "      --field-case <case>         Field/column naming case (default: db-default)",
+        "",
+        "Examples:",
+        "  draw2sql -i schema.drawio -d postgres",
+        "  draw2sql -i schema.drawio -d mariadb -o out.sql -f",
+        "  draw2sql -i schema.drawio -d oracle --schema MYAPP",
+        "  draw2sql -i schema.drawio -d sqlserver --table-case pascal --field-case camel",
+        "  draw2sql schema.drawio oracle",
+        "",
+        "Diagram options:",
+        "  Add a text block like this anywhere in your diagram:",
+        "  +--------------------+",
+        "  | draw2sql           |",
+        "  | dialect = oracle   |",
+        "  | schema  = myschema |",
+        "  +--------------------+",
+        "  Recognized keys: dialect (overrides -d), schema",
+        "",
+        "Dialects:",
+        "  postgres",
+        "  mariadb  (mysql is accepted as an alias)",
+        "  sqlserver",
+        "  sqlite",
+        "  oracle",
+        "",
+        "Cases:",
+        "  as-drawn        No transformation — use names exactly as drawn",
+        "  db-default      Dialect's conventional case (default)",
+        "  pascal          MyTableName        (sqlserver default)",
+        "  camel           myTableName",
+        "  snake           my_table_name      (postgres, mariadb, sqlite default)",
+        "  screaming_snake MY_TABLE_NAME      (oracle default)",
+        "  kebab           my-table-name",
+    ].join("\n");
+    static parse(argv) {
+        if (argv.some((a) => a === "--help" || a === "-h")) {
+            console.log(CliParser.HELP);
+            process.exit(0);
+        }
+        const positional = argv.filter((x) => !x.startsWith("-"));
+        let inputFile = "";
+        let outputFile = "";
+        let dialect = "";
+        let schema = "";
+        let tableCase = "db-default";
+        let fieldCase = "db-default";
+        let overwrite = false;
+        if (positional.length >= 3) {
+            [inputFile, dialect, outputFile] = positional;
+        }
+        else if (positional.length === 2) {
+            [inputFile, dialect] = positional;
+        }
+        for (let i = 0; i < argv.length; i++) {
+            const token = argv[i];
+            const next = argv[i + 1];
+            if ((token === "--input" || token === "-i") && next)
+                inputFile = next;
+            if ((token === "--output" || token === "-o") && next)
+                outputFile = next;
+            if ((token === "--dialect" || token === "-d") && next)
+                dialect = next;
+            if (token === "--schema" && next)
+                schema = next;
+            if ((token === "--table-case" || token === "--table-style") && next) {
+                const normalized = NameStyleResolver.normalize(next);
+                if (!normalized)
+                    throw new Error(`Unsupported table case: ${next}`);
+                tableCase = normalized;
+            }
+            if ((token === "--field-case" || token === "--column-case" || token === "--field-style" || token === "--column-style") && next) {
+                const normalized = NameStyleResolver.normalize(next);
+                if (!normalized)
+                    throw new Error(`Unsupported field case: ${next}`);
+                fieldCase = normalized;
+            }
+            if (token === "--overwrite" || token === "-f")
+                overwrite = true;
+        }
+        if (!inputFile || !dialect) {
+            throw new Error(CliParser.HELP);
+        }
+        const normalizedDialect = DialectResolver.normalize(dialect);
+        if (!normalizedDialect) {
+            throw new Error(`Unsupported SQL dialect: ${dialect}`);
+        }
+        return {
+            inputFile,
+            outputFile: outputFile || undefined,
+            dialect: normalizedDialect,
+            schema: schema || undefined,
+            tableCase,
+            fieldCase,
+            overwrite,
+        };
+    }
+}
+exports.CliParser = CliParser;
+class XmlText {
+    static decode(input) {
+        return input
+            .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
+            .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(parseInt(dec, 10)))
+            .replace(/&quot;/g, '"')
+            .replace(/&apos;/g, "'")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&amp;/g, "&");
+    }
+    static stripHtml(input) {
+        return XmlText.decode(input)
+            .replace(/<br\s*\/?\s*>/gi, "\n")
+            .replace(/\\n/g, "\n")
+            .replace(/<[^>]+>/g, "")
+            .replace(/\u00A0/g, " ")
+            .trim();
+    }
+    static normalizeColumnName(name) {
+        return name.replace(/^`|`$/g, "").replace(/^\[|\]$/g, "").replace(/^"|"$/g, "").trim();
+    }
+}
+class DrawIoDiagramParser {
+    parse(xml) {
+        const cells = this.parseCells(xml);
+        const cellsById = new Map(cells.map((c) => [c.id, c]));
+        const cellsByParent = this.indexByParent(cells);
+        const tableCells = cells.filter((c) => c.vertex && /(?:^|;)shape=table(?:;|$)/.test(c.style));
+        const tables = tableCells
+            .map((tableCell) => {
+            const name = XmlText.stripHtml(tableCell.value).replace(/\s+/g, " ").trim();
+            const columns = this.extractTableColumns(cellsByParent, tableCell);
+            const table = { id: tableCell.id, name, columns };
+            this.assignImplicitKeys(table);
+            return table;
+        })
+            .filter((t) => t.name.length > 0);
+        this.bindEdgeBasedRelationships(cells, cellsById, cellsByParent, tables);
+        this.deduceForeignKeyTargets(tables);
+        const parameters = {};
+        for (const cell of cells) {
+            if (!cell.vertex || cell.style.includes("shape=table") || !cell.value)
+                continue;
+            const parsed = this.parseParameterBlock(XmlText.stripHtml(cell.value));
+            for (const [k, v] of Object.entries(parsed)) {
+                parameters[k] = v;
+            }
+        }
+        return { tables, parameters };
+    }
+    parseCells(xml) {
+        const cells = [];
+        const cellRegex = /<mxCell\b([^>]*?)(?:\/>|>)/g;
+        for (const match of xml.matchAll(cellRegex)) {
+            const attrs = this.parseAttributes(match[1] ?? "");
+            if (!attrs.id)
+                continue;
+            cells.push({
+                id: attrs.id,
+                parent: attrs.parent,
+                style: attrs.style ?? "",
+                value: attrs.value ?? "",
+                vertex: attrs.vertex === "1",
+                edge: attrs.edge === "1",
+                source: attrs.source,
+                target: attrs.target,
+            });
+        }
+        return cells;
+    }
+    parseAttributes(rawAttrs) {
+        const out = {};
+        const attrRegex = /([a-zA-Z_][\w:-]*)\s*=\s*"([^"]*)"/g;
+        for (const match of rawAttrs.matchAll(attrRegex)) {
+            out[match[1]] = XmlText.decode(match[2]);
+        }
+        return out;
+    }
+    indexByParent(cells) {
+        const map = new Map();
+        for (const cell of cells) {
+            if (!cell.parent)
+                continue;
+            if (!map.has(cell.parent))
+                map.set(cell.parent, []);
+            map.get(cell.parent)?.push(cell);
+        }
+        return map;
+    }
+    parseParameterBlock(text) {
+        const params = {};
+        const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+        const hasMarker = lines.some((l) => /draw2sql/i.test(l));
+        for (const line of lines) {
+            const cleaned = line.replace(/^draw2sql\s*[:\-]?\s*/i, "");
+            const m = cleaned.match(/^([A-Za-z0-9_ .-]+)\s*[:=]\s*(.+)$/);
+            if (!m)
+                continue;
+            const key = m[1].toLowerCase().replace(/[\s_.-]+/g, "");
+            const value = m[2].trim();
+            if (!value)
+                continue;
+            if (!hasMarker && !(key.includes("sql") || key === "schema" || key === "flavor")) {
+                continue;
+            }
+            params[key] = value;
+        }
+        return params;
+    }
+    parseColumnLabel(raw) {
+        let text = XmlText.stripHtml(raw).replace(/\s+/g, " ").trim();
+        if (!text)
+            return null;
+        const markers = new Set();
+        const trailingMeta = text.match(/\(([^)]+)\)\s*$/);
+        if (trailingMeta) {
+            for (const part of trailingMeta[1].split(/[;,/|]/)) {
+                const word = part.trim().toUpperCase();
+                if (MARKER_WORDS.has(word))
+                    markers.add(word);
+            }
+            text = text.slice(0, trailingMeta.index).trim();
+        }
+        const bracketMeta = text.match(/\[([^\]]+)\]$/);
+        if (bracketMeta) {
+            for (const part of bracketMeta[1].split(/[;,/|]/)) {
+                const word = part.trim().toUpperCase();
+                if (MARKER_WORDS.has(word))
+                    markers.add(word);
+            }
+            text = text.slice(0, bracketMeta.index).trim();
+        }
+        let name = text;
+        let rawType;
+        if (text.includes(":")) {
+            const [left, ...right] = text.split(":");
+            name = left.trim();
+            rawType = right.join(":").trim() || undefined;
+        }
+        else {
+            const tokens = text.split(" ").filter(Boolean);
+            if (tokens.length >= 2 && /[a-z]/i.test(tokens[1])) {
+                const possibleType = tokens.slice(1).join(" ");
+                if (/^(varchar|char|text|uuid|int|bigint|decimal|numeric|date|datetime|timestamp|bool|boolean|json|jsonb|number|clob|blob)/i.test(possibleType)) {
+                    name = tokens[0];
+                    rawType = possibleType;
+                }
+            }
+        }
+        name = XmlText.normalizeColumnName(name);
+        if (!name)
+            return null;
+        const upper = text.toUpperCase();
+        if (upper.startsWith("PK "))
+            markers.add("PK");
+        if (upper.startsWith("FK "))
+            markers.add("FK");
+        if (upper.includes(" NOT NULL"))
+            markers.add("NOT NULL");
+        if (upper.startsWith("PK "))
+            name = name.replace(/^PK\s+/i, "").trim();
+        if (upper.startsWith("FK "))
+            name = name.replace(/^FK\s+/i, "").trim();
+        return {
+            name,
+            rawType,
+            inferredType: undefined,
+            nullable: !(markers.has("NN") || markers.has("NOT NULL") || markers.has("PK")),
+            primaryKey: markers.has("PK"),
+            foreignKey: markers.has("FK"),
+            unique: markers.has("UNIQUE") || markers.has("UQ"),
+        };
+    }
+    extractTableColumns(cellsByParent, tableCell) {
+        const columns = [];
+        const seen = new Set();
+        const tableChildren = cellsByParent.get(tableCell.id) ?? [];
+        for (const row of tableChildren) {
+            const isRow = row.style.includes("shape=tableRow");
+            const isText = row.style.includes("text;") || row.style.startsWith("text");
+            if (isRow) {
+                const childParts = (cellsByParent.get(row.id) ?? []).map((c) => XmlText.stripHtml(c.value)).filter(Boolean);
+                if (childParts.length === 0 && row.value) {
+                    const parsed = this.parseColumnLabel(row.value);
+                    if (parsed && !seen.has(parsed.name.toLowerCase())) {
+                        columns.push(parsed);
+                        seen.add(parsed.name.toLowerCase());
+                    }
+                    continue;
+                }
+                const markerWords = childParts.map((p) => p.toUpperCase()).filter((p) => MARKER_WORDS.has(p));
+                const candidateName = childParts.filter((p) => !MARKER_WORDS.has(p.toUpperCase())).pop();
+                if (candidateName) {
+                    const parsed = this.parseColumnLabel(candidateName);
+                    if (parsed && !seen.has(parsed.name.toLowerCase())) {
+                        for (const marker of markerWords) {
+                            if (marker === "PK")
+                                parsed.primaryKey = true;
+                            if (marker === "FK")
+                                parsed.foreignKey = true;
+                            if (marker === "NN" || marker === "NOT NULL")
+                                parsed.nullable = false;
+                            if (marker === "UNIQUE" || marker === "UQ")
+                                parsed.unique = true;
+                        }
+                        if (parsed.primaryKey)
+                            parsed.nullable = false;
+                        columns.push(parsed);
+                        seen.add(parsed.name.toLowerCase());
+                    }
+                }
+                continue;
+            }
+            if (isText) {
+                const lines = XmlText.stripHtml(row.value).split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+                for (const line of lines) {
+                    const parsed = this.parseColumnLabel(line);
+                    if (parsed && !seen.has(parsed.name.toLowerCase())) {
+                        columns.push(parsed);
+                        seen.add(parsed.name.toLowerCase());
+                    }
+                }
+            }
+        }
+        return columns;
+    }
+    assignImplicitKeys(table) {
+        if (table.columns.length === 0)
+            return;
+        const hasPk = table.columns.some((c) => c.primaryKey);
+        if (!hasPk) {
+            const idCol = table.columns.find((c) => c.name.toLowerCase() === "id")
+                ?? table.columns.find((c) => c.name.toLowerCase() === `${table.name.toLowerCase()}id`);
+            if (idCol) {
+                idCol.primaryKey = true;
+                idCol.nullable = false;
+            }
+        }
+        for (const col of table.columns) {
+            if (!col.foreignKey && /id$/i.test(col.name) && !col.primaryKey && col.name.toLowerCase() !== "id") {
+                col.foreignKey = true;
+            }
+        }
+    }
+    deduceForeignKeyTargets(tables) {
+        const tableByName = new Map();
+        for (const table of tables) {
+            tableByName.set(table.name.toLowerCase(), table);
+        }
+        for (const table of tables) {
+            for (const col of table.columns) {
+                if (!col.foreignKey || col.referencesTable)
+                    continue;
+                const base = col.name.replace(/id$/i, "");
+                if (!base)
+                    continue;
+                const candidates = [base.toLowerCase(), `${base.toLowerCase()}s`, `${base.toLowerCase()}es`];
+                const target = candidates.map((key) => tableByName.get(key)).find(Boolean);
+                if (!target)
+                    continue;
+                col.referencesTable = target.name;
+                col.referencesColumn = target.columns.find((c) => c.primaryKey)?.name ?? DEFAULT_REF_COLUMN;
+            }
+        }
+    }
+    bindEdgeBasedRelationships(cells, cellsById, cellsByParent, tables) {
+        const rowToTableName = new Map();
+        for (const t of tables) {
+            const children = cellsByParent.get(t.id) ?? [];
+            for (const row of children) {
+                if (row.style.includes("shape=tableRow")) {
+                    rowToTableName.set(row.id, t.name);
+                    for (const part of cellsByParent.get(row.id) ?? []) {
+                        rowToTableName.set(part.id, t.name);
+                    }
+                }
+            }
+        }
+        const findColumnByCellId = (cellId) => {
+            let current = cellsById.get(cellId);
+            while (current) {
+                const tableName = rowToTableName.get(current.id);
+                if (tableName) {
+                    const table = tables.find((t) => t.name === tableName);
+                    if (!table)
+                        return null;
+                    const textParts = [
+                        XmlText.stripHtml(current.value),
+                        ...(cellsByParent.get(current.id) ?? []).map((p) => XmlText.stripHtml(p.value)),
+                    ].filter(Boolean);
+                    for (const text of textParts) {
+                        const colName = XmlText.normalizeColumnName(text.replace(/^PK\s+|^FK\s+/i, ""));
+                        const col = table.columns.find((c) => c.name.toLowerCase() === colName.toLowerCase());
+                        if (col)
+                            return { table, column: col };
+                    }
+                    const likely = table.columns.find((c) => c.foreignKey) ?? table.columns.find((c) => c.primaryKey);
+                    if (likely)
+                        return { table, column: likely };
+                }
+                current = current.parent ? cellsById.get(current.parent) : undefined;
+            }
+            return null;
+        };
+        for (const edge of cells.filter((c) => c.edge && c.source && c.target)) {
+            const a = findColumnByCellId(edge.source);
+            const b = findColumnByCellId(edge.target);
+            if (!a || !b || a.table.name === b.table.name)
+                continue;
+            if (a.column.foreignKey && !a.column.referencesTable) {
+                a.column.referencesTable = b.table.name;
+                a.column.referencesColumn = b.column.primaryKey ? b.column.name : (b.table.columns.find((c) => c.primaryKey)?.name ?? DEFAULT_REF_COLUMN);
+            }
+            else if (b.column.foreignKey && !b.column.referencesTable) {
+                b.column.referencesTable = a.table.name;
+                b.column.referencesColumn = a.column.primaryKey ? a.column.name : (a.table.columns.find((c) => c.primaryKey)?.name ?? DEFAULT_REF_COLUMN);
+            }
+        }
+    }
+}
+exports.DrawIoDiagramParser = DrawIoDiagramParser;
+class SqlTypeMapper {
+    dialect;
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    map(rawType) {
+        const t = rawType.trim().toLowerCase();
+        if (t === "string") {
+            if (this.dialect === "sqlserver")
+                return "nvarchar(255)";
+            if (this.dialect === "oracle")
+                return "varchar2(255)";
+            return "text";
+        }
+        if (t === "bool") {
+            if (this.dialect === "sqlserver")
+                return "bit";
+            if (this.dialect === "oracle")
+                return "number(1)";
+            return "boolean";
+        }
+        if (t === "datetime") {
+            if (this.dialect === "postgres")
+                return "timestamptz";
+            if (this.dialect === "sqlserver")
+                return "datetime2";
+            if (this.dialect === "oracle")
+                return "timestamp";
+        }
+        if (t === "uuid" && this.dialect === "mariadb")
+            return "char(36)";
+        if (t === "uuid" && this.dialect === "sqlserver")
+            return "uniqueidentifier";
+        if (t === "uuid" && this.dialect === "oracle")
+            return "raw(16)";
+        if ((t === "json" || t === "jsonb") && this.dialect === "oracle")
+            return "clob";
+        if (t === "text" && this.dialect === "oracle")
+            return "clob";
+        return rawType;
+    }
+    infer(columnName) {
+        const lower = columnName.toLowerCase();
+        if (lower.endsWith("key")) {
+            if (this.dialect === "sqlserver")
+                return "nvarchar(255)";
+            if (this.dialect === "oracle")
+                return "varchar2(255)";
+            return "text";
+        }
+        if (lower.includes("external") && lower.endsWith("id")) {
+            if (this.dialect === "sqlserver")
+                return "nvarchar(255)";
+            if (this.dialect === "oracle")
+                return "varchar2(255)";
+            return "text";
+        }
+        if (lower === "id" || lower.endsWith("id")) {
+            if (this.dialect === "postgres")
+                return "uuid";
+            if (this.dialect === "mariadb")
+                return "char(36)";
+            if (this.dialect === "sqlserver")
+                return "uniqueidentifier";
+            if (this.dialect === "oracle")
+                return "raw(16)";
+            return "text";
+        }
+        if (lower.startsWith("is") || lower.startsWith("has")) {
+            if (this.dialect === "sqlserver")
+                return "bit";
+            if (this.dialect === "sqlite")
+                return "integer";
+            if (this.dialect === "oracle")
+                return "number(1)";
+            return "boolean";
+        }
+        if (lower.includes("createdat") || lower.includes("updatedat") || lower.includes("deletedat")) {
+            if (this.dialect === "postgres")
+                return "timestamptz";
+            if (this.dialect === "mariadb")
+                return "datetime";
+            if (this.dialect === "sqlserver")
+                return "datetime2";
+            if (this.dialect === "oracle")
+                return "timestamp";
+            return "text";
+        }
+        if (lower.includes("date")) {
+            if (this.dialect === "sqlite")
+                return "text";
+            if (this.dialect === "oracle")
+                return "date";
+            return "date";
+        }
+        if (lower.includes("amount") || lower.includes("price") || lower.includes("total") || lower.includes("cost")) {
+            return this.dialect === "oracle" ? "number(12,2)" : "decimal(12,2)";
+        }
+        if (lower.includes("count") || lower.includes("qty") || lower.includes("quantity")) {
+            return this.dialect === "oracle" ? "number(10)" : "integer";
+        }
+        if (lower.includes("json") || lower.includes("metadata")) {
+            if (this.dialect === "postgres")
+                return "jsonb";
+            if (this.dialect === "mariadb")
+                return "json";
+            if (this.dialect === "sqlserver")
+                return "nvarchar(max)";
+            if (this.dialect === "oracle")
+                return "clob";
+            return "text";
+        }
+        if (this.dialect === "sqlserver")
+            return "nvarchar(255)";
+        if (this.dialect === "oracle")
+            return "varchar2(255)";
+        return "text";
+    }
+}
+exports.SqlTypeMapper = SqlTypeMapper;
+class SqlSyntax {
+    settings;
+    constructor(settings) {
+        this.settings = settings;
+    }
+    quoteIdent(name) {
+        if (this.settings.dialect === "mariadb")
+            return `\`${name}\``;
+        if (this.settings.dialect === "sqlserver")
+            return `[${name}]`;
+        return `"${name}"`;
+    }
+    qualifyTable(name) {
+        if (!this.settings.schema || this.settings.dialect === "sqlite")
+            return this.quoteIdent(name);
+        if (this.settings.dialect === "sqlserver") {
+            return `${this.quoteIdent(this.settings.schema)}.${this.quoteIdent(name)}`;
+        }
+        return `${this.quoteIdent(this.settings.schema)}.${this.quoteIdent(name)}`;
+    }
+    createTable(table) {
+        const lines = this.getCreateColumns(table);
+        if (this.settings.dialect === "sqlserver") {
+            return [
+                `IF OBJECT_ID(N'${table.name}', N'U') IS NULL`,
+                "BEGIN",
+                `CREATE TABLE ${this.qualifyTable(table.name)} (`,
+                lines.join(",\n"),
+                ");",
+                "END;",
+            ].join("\n");
+        }
+        if (this.settings.dialect === "oracle") {
+            const sql = [
+                `CREATE TABLE ${this.qualifyTable(table.name)} (`,
+                lines.join(",\n"),
+                ")",
+            ].join("\n");
+            return [
+                "BEGIN",
+                `  EXECUTE IMMEDIATE q'[${sql}]';`,
+                "EXCEPTION",
+                "  WHEN OTHERS THEN",
+                "    IF SQLCODE != -955 THEN RAISE; END IF;",
+                "END;",
+                "/",
+            ].join("\n");
+        }
+        return [
+            `CREATE TABLE IF NOT EXISTS ${this.qualifyTable(table.name)} (`,
+            lines.join(",\n"),
+            ");",
+        ].join("\n");
+    }
+    addColumn(tableName, col) {
+        const colType = col.inferredType ?? col.rawType ?? "text";
+        const nullSql = col.nullable ? "" : " NOT NULL";
+        if (this.settings.dialect === "sqlserver") {
+            return [
+                `IF COL_LENGTH(N'${tableName}', N'${col.name}') IS NULL`,
+                `  ALTER TABLE ${this.qualifyTable(tableName)} ADD ${this.quoteIdent(col.name)} ${colType}${nullSql};`,
+            ].join("\n");
+        }
+        if (this.settings.dialect === "oracle") {
+            const checkSchema = (this.settings.schema ?? "").toUpperCase();
+            const schemaFilter = checkSchema ? ` AND owner = '${checkSchema}'` : "";
+            return [
+                "DECLARE",
+                "  v_count NUMBER;",
+                "BEGIN",
+                "  SELECT COUNT(1) INTO v_count",
+                "  FROM all_tab_cols",
+                `  WHERE table_name = '${tableName.toUpperCase()}'${schemaFilter}`,
+                `    AND column_name = '${col.name.toUpperCase()}';`,
+                "  IF v_count = 0 THEN",
+                `    EXECUTE IMMEDIATE q'[ALTER TABLE ${this.qualifyTable(tableName)} ADD (${this.quoteIdent(col.name)} ${colType}${nullSql})]';`,
+                "  END IF;",
+                "END;",
+                "/",
+            ].join("\n");
+        }
+        return `ALTER TABLE ${this.qualifyTable(tableName)} ADD COLUMN IF NOT EXISTS ${this.quoteIdent(col.name)} ${colType}${nullSql};`;
+    }
+    addForeignKey(table, col) {
+        if (!col.referencesTable || !col.referencesColumn)
+            return "";
+        const constraintName = `fk_${table.name}_${col.name}_${col.referencesTable}_${col.referencesColumn}`.replace(/[^A-Za-z0-9_]/g, "_");
+        const tableQ = this.qualifyTable(table.name);
+        const colQ = this.quoteIdent(col.name);
+        const refTableQ = this.qualifyTable(col.referencesTable);
+        const refColQ = this.quoteIdent(col.referencesColumn);
+        if (this.settings.dialect === "postgres") {
+            return [
+                "DO $$",
+                "BEGIN",
+                `  IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}') THEN`,
+                `    ALTER TABLE ${tableQ} ADD CONSTRAINT ${this.quoteIdent(constraintName)} FOREIGN KEY (${colQ}) REFERENCES ${refTableQ} (${refColQ});`,
+                "  END IF;",
+                "END $$;",
+            ].join("\n");
+        }
+        if (this.settings.dialect === "mariadb") {
+            return [
+                "SET @fk_exists := (",
+                "  SELECT COUNT(1)",
+                "  FROM information_schema.table_constraints",
+                "  WHERE constraint_schema = DATABASE()",
+                `    AND table_name = '${table.name}'`,
+                `    AND constraint_name = '${constraintName}'`,
+                ");",
+                `SET @fk_sql := IF(@fk_exists = 0, 'ALTER TABLE ${table.name} ADD CONSTRAINT ${constraintName} FOREIGN KEY (${col.name}) REFERENCES ${col.referencesTable} (${col.referencesColumn});', 'SELECT 1;');`,
+                "PREPARE stmt FROM @fk_sql;",
+                "EXECUTE stmt;",
+                "DEALLOCATE PREPARE stmt;",
+            ].join("\n");
+        }
+        if (this.settings.dialect === "sqlserver") {
+            return [
+                `IF NOT EXISTS (SELECT 1 FROM sys.foreign_keys WHERE name = N'${constraintName}')`,
+                `  ALTER TABLE ${tableQ} ADD CONSTRAINT ${this.quoteIdent(constraintName)} FOREIGN KEY (${colQ}) REFERENCES ${refTableQ} (${refColQ});`,
+            ].join("\n");
+        }
+        if (this.settings.dialect === "oracle") {
+            const owner = (this.settings.schema ?? "").toUpperCase();
+            const ownerFilter = owner ? ` AND owner = '${owner}'` : "";
+            return [
+                "DECLARE",
+                "  v_count NUMBER;",
+                "BEGIN",
+                "  SELECT COUNT(1) INTO v_count",
+                "  FROM all_constraints",
+                `  WHERE constraint_name = '${constraintName.toUpperCase()}'${ownerFilter};`,
+                "  IF v_count = 0 THEN",
+                `    EXECUTE IMMEDIATE q'[ALTER TABLE ${tableQ} ADD CONSTRAINT ${this.quoteIdent(constraintName)} FOREIGN KEY (${colQ}) REFERENCES ${refTableQ} (${refColQ})]';`,
+                "  END IF;",
+                "END;",
+                "/",
+            ].join("\n");
+        }
+        return `-- SQLite note: FK ${constraintName} (${table.name}.${col.name} -> ${col.referencesTable}.${col.referencesColumn}) requires table rebuild if not created initially.`;
+    }
+    getCreateColumns(table) {
+        const lines = [];
+        const pkColumns = [];
+        const uniqueConstraints = [];
+        for (const col of table.columns) {
+            const parts = [`${this.quoteIdent(col.name)} ${col.inferredType ?? col.rawType ?? "text"}`, col.nullable ? "" : "NOT NULL"].filter(Boolean);
+            lines.push(`  ${parts.join(" ")}`);
+            if (col.primaryKey)
+                pkColumns.push(this.quoteIdent(col.name));
+            if (col.unique)
+                uniqueConstraints.push(`UNIQUE (${this.quoteIdent(col.name)})`);
+        }
+        if (pkColumns.length > 0)
+            lines.push(`  PRIMARY KEY (${pkColumns.join(", ")})`);
+        for (const uq of uniqueConstraints)
+            lines.push(`  ${uq}`);
+        return lines;
+    }
+}
+class SqlGenerator {
+    generate(parsed, cliDialect, naming, cliSchema) {
+        const dialectOverride = parsed.parameters.dialect ?? parsed.parameters.sqldialect ?? parsed.parameters.flavor ?? parsed.parameters.sqlflavor ?? parsed.parameters.sqldatabase;
+        const effectiveDialect = dialectOverride ? (DialectResolver.normalize(dialectOverride) ?? cliDialect) : cliDialect;
+        const schema = cliSchema ?? parsed.parameters.schema ?? parsed.parameters.defaultschema;
+        const settings = { dialect: effectiveDialect, schema };
+        const mapper = new SqlTypeMapper(settings.dialect);
+        const dialect = new SqlSyntax(settings);
+        for (const table of parsed.tables) {
+            for (const col of table.columns) {
+                col.inferredType = col.rawType ? mapper.map(col.rawType) : mapper.infer(col.name);
+            }
+        }
+        const resolvedNaming = NameStyler.apply(parsed.tables, settings.dialect, naming);
+        const header = [
+            "-- Generated by draw2sql",
+            `-- Dialect: ${settings.dialect}`,
+            `-- Table Case: ${naming.tableCase} (${resolvedNaming.tableStyle})`,
+            `-- Field Case: ${naming.fieldCase} (${resolvedNaming.fieldStyle})`,
+            `-- Generated UTC: ${new Date().toISOString()}`,
+        ];
+        if (settings.schema) {
+            header.push(`-- Schema: ${settings.schema}`);
+        }
+        if (Object.keys(parsed.parameters).length > 0) {
+            header.push("-- Diagram Parameters:");
+            for (const [k, v] of Object.entries(parsed.parameters)) {
+                header.push(`--   ${k} = ${v}`);
+            }
+        }
+        if (parsed.tables.length === 0) {
+            header.push("-- No tables detected in draw.io file.");
+            return { sql: `${header.join("\n")}\n`, dialect: settings.dialect };
+        }
+        const sections = [header.join("\n")];
+        sections.push("\n-- 1) Create missing tables");
+        for (const table of parsed.tables) {
+            sections.push(dialect.createTable(table));
+        }
+        sections.push("\n-- 2) Add missing columns");
+        for (const table of parsed.tables) {
+            for (const col of table.columns) {
+                sections.push(dialect.addColumn(table.name, col));
+            }
+        }
+        sections.push("\n-- 3) Add foreign keys where inferred");
+        for (const table of parsed.tables) {
+            for (const col of table.columns.filter((c) => c.foreignKey)) {
+                const fkSql = dialect.addForeignKey(table, col);
+                if (fkSql)
+                    sections.push(fkSql);
+            }
+        }
+        return {
+            sql: `${sections.join("\n\n")}\n`,
+            dialect: settings.dialect,
+        };
+    }
+}
+class Draw2SqlApp {
+    parser = new DrawIoDiagramParser();
+    generator = new SqlGenerator();
+    run(argv) {
+        const args = CliParser.parse(argv);
+        const xml = node_fs_1.default.readFileSync(args.inputFile, "utf8");
+        const parsed = this.parser.parse(xml);
+        const generated = this.generator.generate(parsed, args.dialect, { tableCase: args.tableCase, fieldCase: args.fieldCase }, args.schema);
+        const outputFile = args.outputFile ?? this.deriveOutputFile(args.inputFile, generated.dialect);
+        if (!args.overwrite && node_fs_1.default.existsSync(outputFile)) {
+            console.error(`Output file already exists: ${outputFile}`);
+            console.error(`Pass --overwrite (or -f) to replace it.`);
+            process.exit(1);
+        }
+        this.ensureDirForFile(outputFile);
+        node_fs_1.default.writeFileSync(outputFile, generated.sql, "utf8");
+        console.log("draw2sql complete.");
+        console.log(`Input: ${args.inputFile}`);
+        console.log(`Dialect: ${generated.dialect}`);
+        console.log(`Tables: ${parsed.tables.length}`);
+        console.log(`Output: ${outputFile}`);
+    }
+    deriveOutputFile(inputFile, dialect) {
+        const ext = node_path_1.default.extname(inputFile);
+        const base = inputFile.slice(0, inputFile.length - ext.length);
+        return `${base}.${dialect}.sql`;
+    }
+    ensureDirForFile(filePath) {
+        const dir = node_path_1.default.dirname(node_path_1.default.resolve(filePath));
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+}
+if (require.main === module) {
+    try {
+        new Draw2SqlApp().run(process.argv.slice(2));
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "draw2sql",
+  "version": "1.0.0-beta.1",
+  "description": "Generate SQL DDL from a draw.io XML ER diagram",
+  "author": "Kyle White",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kylemwhite/draw2sql.git"
+  },
+  "main": "dist/draw2sql.js",
+  "bin": {
+    "draw2sql": "dist/draw2sql.js"
+  },
+  "files": [
+    "dist/draw2sql.js"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "ts-node draw2sql.test.ts",
+    "start": "ts-node draw2sql.ts",
+    "prepublishOnly": "tsc",
+    "repack": "npm run build && npm pack && node -e \"const v=require('./package.json').version;require('child_process').execSync('npm install -g draw2sql-'+v+'.tgz',{stdio:'inherit'})\""
+  },
+  "keywords": [
+    "draw.io",
+    "sql",
+    "ddl",
+    "erd",
+    "diagram"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "ts-node": "^10.9.0",
+    "@types/node": "^22.0.0"
+  }
+}