ts-prorm-orm 1.1.0

package/dist/diagrams/index-diagram.js

@@ -0,0 +1,353 @@
+"use strict";
+/**
+ * IndexDiagram — an INDEX & CONSTRAINT MAP for a single table.
+ *
+ * A table's columns are laid out as a horizontal strip of "column chips".
+ * Below the strip, every index/constraint is drawn as a labeled "bracket" that
+ * spans the column chips it covers — so composite indexes visibly span multiple
+ * columns and overlapping coverage is obvious at a glance.
+ *
+ * Index kinds (PRIMARY / UNIQUE / INDEX / FULLTEXT / FOREIGN KEY / CHECK) are
+ * distinguished by color + a short badge; each row also shows the index name,
+ * its access method (btree/hash/gin…) and whether it is unique.
+ *
+ * `--theme light|dark` drives the canvas/text colors and `--color <name|hex>`
+ * drives the accent used for the header and the PRIMARY index — both genuinely
+ * change fill/stroke values in the generated SVG.
+ *
+ * Usage:
+ *   const diag = new IndexDiagram({ table: 'users', columns: [...], indexes: [...] });
+ *   diag.save('./diagrams/users-indexes.svg');
+ *   // or:
+ *   const svg = diag.generate();
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexDiagram = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const palette_1 = require("./palette");
+const svg_dom_1 = require("./svg-dom");
+const KIND_STYLES = {
+    PRIMARY: { badge: 'PK', color: '#92400E', bg: '#FEF3C7' },
+    UNIQUE: { badge: 'UQ', color: '#5B21B6', bg: '#EDE9FE' },
+    INDEX: { badge: 'IX', color: '#0369A1', bg: '#E0F2FE' },
+    FULLTEXT: { badge: 'FT', color: '#065F46', bg: '#D1FAE5' },
+    'FOREIGN KEY': { badge: 'FK', color: '#1E3A8A', bg: '#DBEAFE' },
+    CHECK: { badge: 'CK', color: '#9F1239', bg: '#FFE4E6' },
+};
+function kindStyle(kind) {
+    return KIND_STYLES[kind ?? 'INDEX'] ?? KIND_STYLES.INDEX;
+}
+// ─── Main class ──────────────────────────────────────────────────────────────
+class IndexDiagram {
+    constructor(options) {
+        this.opts = {
+            title: options.title ?? '',
+            theme: options.theme ?? 'light',
+            color: options.color ?? '',
+            ...options,
+        };
+    }
+    chipWidth() {
+        const label = this.opts.columns.map((c) => `${c.name} ${c.type ?? ''}`.trim());
+        const longest = label.reduce((m, s) => Math.max(m, s.length), 4);
+        return Math.max(IndexDiagram.MIN_CHIP_W, longest * 8 + 24);
+    }
+    generate() {
+        const { table, columns, indexes, title, theme, color } = this.opts;
+        const accent = (0, palette_1.resolveAccent)(color);
+        const t = (0, palette_1.resolveTheme)(theme);
+        const PAD = IndexDiagram.PAD;
+        const HDR = IndexDiagram.HDR;
+        const CHIP_H = IndexDiagram.CHIP_H;
+        const CHIP_GAP = IndexDiagram.CHIP_GAP;
+        const STRIP_LABEL = IndexDiagram.STRIP_LABEL;
+        const GAP_AFTER_STRIP = IndexDiagram.GAP_AFTER_STRIP;
+        const ROW_H = IndexDiagram.ROW_H;
+        const LABEL_W = IndexDiagram.LABEL_W;
+        const R = IndexDiagram.R;
+        const chipW = this.chipWidth();
+        const nCols = Math.max(columns.length, 1);
+        // Geometry of the column strip.
+        const stripX = PAD + LABEL_W;
+        const stripY = PAD + HDR + STRIP_LABEL;
+        const chipStride = chipW + CHIP_GAP;
+        const stripW = nCols * chipStride - CHIP_GAP;
+        // Center X of each column chip, keyed by column name.
+        const colCenter = {};
+        columns.forEach((c, i) => {
+            colCenter[c.name] = stripX + i * chipStride + chipW / 2;
+        });
+        // Overall canvas size.
+        const contentW = stripX + stripW;
+        const svgW = contentW + PAD;
+        const rowsTop = stripY + CHIP_H + GAP_AFTER_STRIP;
+        const svgH = rowsTop + indexes.length * ROW_H + PAD;
+        const uid = table.replace(/\W/g, '') || 'tbl';
+        const doc = new svg_dom_1.SvgDocument(svgW, svgH);
+        const svg = doc.root;
+        // ── Background ──────────────────────────────────────────────────────────
+        svg.child('rect', { width: svgW, height: svgH, fill: t.canvasBg });
+        // ── Defs: header gradient ───────────────────────────────────────────────
+        doc.linearGradient(`hg${uid}`, [
+            [0, accent.from],
+            [55, accent.mid],
+            [100, accent.to],
+        ]);
+        // ── Header bar ──────────────────────────────────────────────────────────
+        svg.child('rect', { x: PAD, y: PAD, width: contentW - PAD, height: HDR, rx: R, fill: `url(#hg${uid})` });
+        svg
+            .child('text', {
+            x: PAD + 18,
+            y: PAD + 27,
+            'font-family': 'system-ui,-apple-system,sans-serif',
+            'font-size': 20,
+            'font-weight': 800,
+            fill: '#FFFFFF',
+        })
+            .text(title || `Index Map · ${table}`);
+        svg
+            .child('text', {
+            x: PAD + 18,
+            y: PAD + 47,
+            'font-family': "'SF Mono','Fira Code',monospace",
+            'font-size': 11,
+            fill: 'rgba(255,255,255,0.8)',
+        })
+            .text(`${columns.length} columns · ${indexes.length} indexes`);
+        // "TABLE" pill on the right of the header.
+        svg
+            .child('text', {
+            x: contentW - 16,
+            y: PAD + 33,
+            'font-family': "'SF Mono',monospace",
+            'font-size': 12,
+            'font-weight': 700,
+            fill: 'rgba(255,255,255,0.92)',
+            'text-anchor': 'end',
+        })
+            .text(table);
+        // ── Column strip label ──────────────────────────────────────────────────
+        svg
+            .child('text', {
+            x: stripX,
+            y: stripY - 8,
+            'font-family': 'system-ui,sans-serif',
+            'font-size': 11,
+            'font-weight': 700,
+            'letter-spacing': 1,
+            fill: t.textSecondary,
+        })
+            .text('COLUMNS');
+        // ── Column chips ────────────────────────────────────────────────────────
+        columns.forEach((c, i) => {
+            const x = stripX + i * chipStride;
+            svg.child('rect', {
+                x,
+                y: stripY,
+                width: chipW,
+                height: CHIP_H,
+                rx: 9,
+                fill: t.cardBg,
+                stroke: t.border,
+                'stroke-width': 1.5,
+            });
+            svg
+                .child('text', {
+                x: x + chipW / 2,
+                y: stripY + 20,
+                'font-family': "'SF Mono','Fira Code',monospace",
+                'font-size': 13,
+                'font-weight': 700,
+                fill: t.textPrimary,
+                'text-anchor': 'middle',
+            })
+                .text(c.name);
+            if (c.type) {
+                svg
+                    .child('text', {
+                    x: x + chipW / 2,
+                    y: stripY + 37,
+                    'font-family': "'SF Mono',monospace",
+                    'font-size': 10,
+                    fill: t.textSecondary,
+                    'text-anchor': 'middle',
+                })
+                    .text(c.type);
+            }
+        });
+        // ── Index / constraint rows with spanning brackets ──────────────────────
+        // Each row draws: left label block (badge + name + method) and a spanning
+        // bracket that connects to every covered column chip via connector lines.
+        const chipBottom = stripY + CHIP_H;
+        indexes.forEach((idx, i) => {
+            const rowY = rowsTop + i * ROW_H;
+            const rowMid = rowY + ROW_H / 2;
+            const style = kindStyle(idx.kind);
+            const isPrimary = idx.kind === 'PRIMARY';
+            // The PRIMARY index adopts the accent color so --color is visibly wired in.
+            const lineColor = isPrimary ? accent.mid : style.color;
+            // Alternating row background band.
+            if (i % 2 === 1) {
+                svg.child('rect', {
+                    x: PAD,
+                    y: rowY,
+                    width: contentW - PAD,
+                    height: ROW_H,
+                    rx: 8,
+                    fill: t.rowAlt,
+                });
+            }
+            // ── Left label block ──
+            // Badge chip.
+            const badgeBg = isPrimary ? accent.light : style.bg;
+            const badgeFg = isPrimary ? accent.text : style.color;
+            svg.child('rect', { x: PAD + 8, y: rowMid - 12, width: 30, height: 24, rx: 6, fill: badgeBg });
+            svg
+                .child('text', {
+                x: PAD + 8 + 15,
+                y: rowMid + 5,
+                'font-family': "'SF Mono',monospace",
+                'font-size': 11,
+                'font-weight': 800,
+                fill: badgeFg,
+                'text-anchor': 'middle',
+            })
+                .text(style.badge);
+            // Index name.
+            svg
+                .child('text', {
+                x: PAD + 48,
+                y: rowMid - 2,
+                'font-family': "'SF Mono','Fira Code',monospace",
+                'font-size': 12,
+                'font-weight': 700,
+                fill: t.textPrimary,
+            })
+                .text(idx.name);
+            // Method + unique subtitle.
+            const meta = [];
+            meta.push((idx.kind ?? 'INDEX').toLowerCase());
+            if (idx.method)
+                meta.push(idx.method);
+            if (idx.unique || idx.kind === 'PRIMARY' || idx.kind === 'UNIQUE')
+                meta.push('unique');
+            svg
+                .child('text', {
+                x: PAD + 48,
+                y: rowMid + 13,
+                'font-family': "'SF Mono',monospace",
+                'font-size': 10,
+                fill: t.textSecondary,
+            })
+                .text(meta.join(' · '));
+            // ── Spanning bracket over covered columns ──
+            const covered = idx.columns
+                .map((cn) => colCenter[cn])
+                .filter((v) => typeof v === 'number')
+                .sort((a, b) => a - b);
+            if (covered.length > 0) {
+                const first = covered[0];
+                const last = covered[covered.length - 1];
+                const bracketY = rowMid;
+                // Horizontal spine of the bracket across the covered span.
+                svg.child('line', {
+                    x1: first,
+                    y1: bracketY,
+                    x2: last,
+                    y2: bracketY,
+                    stroke: lineColor,
+                    'stroke-width': isPrimary ? 3 : 2,
+                    'stroke-linecap': 'round',
+                });
+                // A connector path from each covered column chip down to the spine.
+                covered.forEach((cxp) => {
+                    // Curved connector from the bottom of the chip to the spine node.
+                    const d = `M ${cxp} ${chipBottom} C ${cxp} ${(chipBottom + bracketY) / 2}, ${cxp} ${(chipBottom + bracketY) / 2}, ${cxp} ${bracketY}`;
+                    svg.child('path', {
+                        d,
+                        stroke: lineColor,
+                        'stroke-width': 1.5,
+                        fill: 'none',
+                        opacity: 0.85,
+                    });
+                    // Node dot where the connector meets the spine.
+                    svg.child('circle', { cx: cxp, cy: bracketY, r: isPrimary ? 5 : 4, fill: lineColor });
+                });
+                // Order labels (1,2,3…) for composite indexes so column order reads.
+                if (covered.length > 1) {
+                    idx.columns.forEach((cn, ord) => {
+                        const cxp = colCenter[cn];
+                        if (typeof cxp !== 'number')
+                            return;
+                        svg
+                            .child('text', {
+                            x: cxp + 8,
+                            y: bracketY - 8,
+                            'font-family': "'SF Mono',monospace",
+                            'font-size': 9,
+                            'font-weight': 700,
+                            fill: lineColor,
+                        })
+                            .text(String(ord + 1));
+                    });
+                }
+            }
+        });
+        return doc.toString('Generated by ts-prorm-orm IndexDiagram');
+    }
+    /** Write the SVG to a file. Creates parent directories if needed. */
+    save(outputPath) {
+        const resolved = path.resolve(outputPath);
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(resolved, this.generate(), 'utf-8');
+        return resolved;
+    }
+}
+exports.IndexDiagram = IndexDiagram;
+// Layout constants (px)
+IndexDiagram.PAD = 28;
+IndexDiagram.HDR = 60;
+IndexDiagram.CHIP_H = 46;
+IndexDiagram.CHIP_GAP = 12;
+IndexDiagram.STRIP_LABEL = 26;
+IndexDiagram.GAP_AFTER_STRIP = 46;
+IndexDiagram.ROW_H = 54;
+IndexDiagram.LABEL_W = 250; // left column: badge + name + method
+IndexDiagram.MIN_CHIP_W = 96;
+IndexDiagram.R = 12;

package/dist/diagrams/index.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * @module diagrams
+ *
+ * SVG diagram generators for ORM models and ER schemas.
+ *
+ * ─── Quick-start ────────────────────────────────────────────────────────
+ *
+ * 1) Single-model card
+ *    ─────────────────
+ *    import { ModelDiagram } from './diagrams';
+ *
+ *    const diag = new ModelDiagram({
+ *      name: 'User',
+ *      tableName: 'users',
+ *      fields: {
+ *        id:        { type: 'INTEGER', primaryKey: true, autoIncrement: true },
+ *        name:      { type: 'VARCHAR(100)', allowNull: false },
+ *        email:     { type: 'VARCHAR(255)', unique: true, allowNull: false },
+ *        role:      { type: 'ENUM', enum: ['admin','user'], defaultValue: 'user' },
+ *        createdAt: { type: 'DATE' },
+ *      },
+ *      associations: [
+ *        { type: 'hasMany',   target: 'Post',    foreignKey: 'userId', as: 'posts' },
+ *        { type: 'hasOne',    target: 'Profile',  foreignKey: 'userId' },
+ *        { type: 'belongsToMany', target: 'Team', through: 'UserTeam' },
+ *      ],
+ *      timestamps: true,
+ *      comment: 'Application users',
+ *    });
+ *
+ *    diag.save('./diagrams/User.svg');
+ *    // or get SVG string: const svg = diag.generate();
+ *
+ *
+ * 2) Full ER diagram
+ *    ────────────────
+ *    import { ERDiagram } from './diagrams';
+ *
+ *    const er = new ERDiagram({
+ *      title: 'E-Commerce Schema',
+ *      columns: 3,
+ *      models: [ userModel, productModel, orderModel, orderItemModel ],
+ *    });
+ *
+ *    er.save('./diagrams/schema.svg');
+ *
+ *
+ * 3) CLI
+ *    ────
+ *    # Single model (from JSON spec)
+ *    cli diagram:model --file ./User.json --out ./diagrams/User.svg
+ *
+ *    # Full ER diagram (from schema JSON)
+ *    cli diagram:er --file ./schema.json --out ./diagrams/er.svg
+ *
+ *    # Inline model
+ *    cli diagram:model --name User \
+ *          --fields "id:INTEGER:pk,name:VARCHAR(100):nn,email:VARCHAR(255):uq nn" \
+ *          --assoc "hasMany:Post:userId" \
+ *          --out ./diagrams/User.svg
+ *
+ * ─── JSON spec format ───────────────────────────────────────────────────
+ *
+ *  Single model file:
+ *  {
+ *    "name": "User",
+ *    "tableName": "users",
+ *    "fields": {
+ *      "id":    { "type": "INTEGER", "primaryKey": true, "autoIncrement": true },
+ *      "email": { "type": "VARCHAR(255)", "unique": true, "allowNull": false }
+ *    },
+ *    "associations": [
+ *      { "type": "hasMany", "target": "Post", "foreignKey": "userId" }
+ *    ],
+ *    "timestamps": true
+ *  }
+ *
+ *  ER schema file:
+ *  {
+ *    "title": "My App Schema",
+ *    "columns": 3,
+ *    "models": [ <model-spec>, <model-spec>, … ]
+ *  }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACCENT_PALETTES = exports.rotatedPalettes = exports.resolveTheme = exports.resolveAccent = exports.El = exports.SvgDocument = exports.GanttDiagram = exports.PackageDiagram = exports.ChenDiagram = exports.TreeDiagram = exports.FlowDiagram = exports.IndexDiagram = exports.SchemaDocDiagram = exports.DependencyDiagram = exports.StateDiagram = exports.SequenceDiagram = exports.RelationalDiagram = exports.ClassDiagram = exports.MigrationDiagram = exports.ERDiagram = exports.ModelDiagram = void 0;
+exports.generateModelDiagram = generateModelDiagram;
+exports.generateERDiagram = generateERDiagram;
+exports.generateModelDiagramFromFile = generateModelDiagramFromFile;
+exports.generateERDiagramFromFile = generateERDiagramFromFile;
+var model_diagram_1 = require("./model-diagram");
+Object.defineProperty(exports, "ModelDiagram", { enumerable: true, get: function () { return model_diagram_1.ModelDiagram; } });
+var er_diagram_1 = require("./er-diagram");
+Object.defineProperty(exports, "ERDiagram", { enumerable: true, get: function () { return er_diagram_1.ERDiagram; } });
+var migration_diagram_1 = require("./migration-diagram");
+Object.defineProperty(exports, "MigrationDiagram", { enumerable: true, get: function () { return migration_diagram_1.MigrationDiagram; } });
+// ─── Extended diagram generators (all built on the shared DOM SVG builder) ──
+var class_diagram_1 = require("./class-diagram");
+Object.defineProperty(exports, "ClassDiagram", { enumerable: true, get: function () { return class_diagram_1.ClassDiagram; } });
+var relational_diagram_1 = require("./relational-diagram");
+Object.defineProperty(exports, "RelationalDiagram", { enumerable: true, get: function () { return relational_diagram_1.RelationalDiagram; } });
+var sequence_diagram_1 = require("./sequence-diagram");
+Object.defineProperty(exports, "SequenceDiagram", { enumerable: true, get: function () { return sequence_diagram_1.SequenceDiagram; } });
+var state_diagram_1 = require("./state-diagram");
+Object.defineProperty(exports, "StateDiagram", { enumerable: true, get: function () { return state_diagram_1.StateDiagram; } });
+var dependency_diagram_1 = require("./dependency-diagram");
+Object.defineProperty(exports, "DependencyDiagram", { enumerable: true, get: function () { return dependency_diagram_1.DependencyDiagram; } });
+var schemadoc_diagram_1 = require("./schemadoc-diagram");
+Object.defineProperty(exports, "SchemaDocDiagram", { enumerable: true, get: function () { return schemadoc_diagram_1.SchemaDocDiagram; } });
+var index_diagram_1 = require("./index-diagram");
+Object.defineProperty(exports, "IndexDiagram", { enumerable: true, get: function () { return index_diagram_1.IndexDiagram; } });
+var flow_diagram_1 = require("./flow-diagram");
+Object.defineProperty(exports, "FlowDiagram", { enumerable: true, get: function () { return flow_diagram_1.FlowDiagram; } });
+var tree_diagram_1 = require("./tree-diagram");
+Object.defineProperty(exports, "TreeDiagram", { enumerable: true, get: function () { return tree_diagram_1.TreeDiagram; } });
+var chen_diagram_1 = require("./chen-diagram");
+Object.defineProperty(exports, "ChenDiagram", { enumerable: true, get: function () { return chen_diagram_1.ChenDiagram; } });
+var package_diagram_1 = require("./package-diagram");
+Object.defineProperty(exports, "PackageDiagram", { enumerable: true, get: function () { return package_diagram_1.PackageDiagram; } });
+var gantt_diagram_1 = require("./gantt-diagram");
+Object.defineProperty(exports, "GanttDiagram", { enumerable: true, get: function () { return gantt_diagram_1.GanttDiagram; } });
+// Shared DOM SVG builder + palette (exposed for custom generators)
+var svg_dom_1 = require("./svg-dom");
+Object.defineProperty(exports, "SvgDocument", { enumerable: true, get: function () { return svg_dom_1.SvgDocument; } });
+Object.defineProperty(exports, "El", { enumerable: true, get: function () { return svg_dom_1.El; } });
+var palette_1 = require("./palette");
+Object.defineProperty(exports, "resolveAccent", { enumerable: true, get: function () { return palette_1.resolveAccent; } });
+Object.defineProperty(exports, "resolveTheme", { enumerable: true, get: function () { return palette_1.resolveTheme; } });
+Object.defineProperty(exports, "rotatedPalettes", { enumerable: true, get: function () { return palette_1.rotatedPalettes; } });
+Object.defineProperty(exports, "ACCENT_PALETTES", { enumerable: true, get: function () { return palette_1.ACCENT_PALETTES; } });
+// ─── Convenience factory functions ──────────────────────────────────────────
+const model_diagram_2 = require("./model-diagram");
+const er_diagram_2 = require("./er-diagram");
+/**
+ * Create and immediately save a model SVG diagram.
+ *
+ * @param options  Model definition
+ * @param outPath  Output SVG file path
+ * @returns        Resolved output path
+ *
+ * @example
+ * generateModelDiagram(
+ *   { name:'User', fields:{ id:{type:'INTEGER',primaryKey:true} } },
+ *   './diagrams/User.svg'
+ * );
+ */
+function generateModelDiagram(options, outPath) {
+    return new model_diagram_2.ModelDiagram(options).save(outPath);
+}
+/**
+ * Create and immediately save an ER diagram.
+ *
+ * @param options  ER diagram options (title + models array)
+ * @param outPath  Output SVG file path
+ * @returns        Resolved output path
+ *
+ * @example
+ * generateERDiagram(
+ *   { title:'My Schema', models:[userDef, postDef] },
+ *   './diagrams/schema.svg'
+ * );
+ */
+function generateERDiagram(options, outPath) {
+    return new er_diagram_2.ERDiagram(options).save(outPath);
+}
+/**
+ * Load a model definition from a JSON file and generate its SVG diagram.
+ */
+function generateModelDiagramFromFile(specPath, outPath) {
+    const raw = require('fs').readFileSync(specPath, 'utf-8');
+    const options = JSON.parse(raw);
+    const dest = outPath ?? specPath.replace(/\.json$/, '.svg');
+    return generateModelDiagram(options, dest);
+}
+/**
+ * Load an ER schema from a JSON file and generate the SVG diagram.
+ */
+function generateERDiagramFromFile(schemaPath, outPath) {
+    const raw = require('fs').readFileSync(schemaPath, 'utf-8');
+    const options = JSON.parse(raw);
+    const dest = outPath ?? schemaPath.replace(/\.json$/, '.svg');
+    return generateERDiagram(options, dest);
+}