@rdbms-erd/core 0.1.0 → 0.1.2

package/src/__tests__/ddl-snapshot.test.ts

@@ -1,91 +1,91 @@
-import { describe, expect, it } from "vitest";
-import { createColumn, createEmptyDesign, generateDdl, generateIndexDdl } from "../index";
-
-function minimalDoc(dialect: "mssql" | "oracle" | "mysql" | "postgres") {
-  const doc = createEmptyDesign(dialect);
-  doc.model.tables.push({
-    id: "parent",
-    logicalName: "부모",
-    physicalName: "TB_PARENT",
-    columns: [
-      createColumn(dialect, {
-        id: "pk",
-        logicalName: "식별자",
-        logicalType: "NUMBER",
-        nullable: false
-      })
-    ]
-  });
-  doc.model.tables.push({
-    id: "child",
-    logicalName: "자식",
-    physicalName: "TB_CHILD",
-    columns: [
-      createColumn(dialect, {
-        id: "fk",
-        logicalName: "부모참조",
-        logicalType: "NUMBER",
-        nullable: false
-      })
-    ]
-  });
-  doc.model.relationships.push({
-    id: "rel1",
-    sourceTableId: "parent",
-    targetTableId: "child",
-    sourceColumnId: "pk",
-    targetColumnId: "fk"
-  });
-  doc.model.indexes.push({
-    id: "ix1",
-    tableId: "child",
-    name: "IX_CHILD_PARENT",
-    columns: ["부모참조"],
-    unique: false
-  });
-  return doc;
-}
-
-describe("generateDdl / generateIndexDdl", () => {
-  it.each(["postgres", "mysql", "oracle", "mssql"] as const)("dialect %s emits CREATE TABLE and FK", (dialect) => {
-    const sql = generateDdl(minimalDoc(dialect));
-    expect(sql).toContain("CREATE TABLE");
-    expect(sql.toUpperCase()).toContain("FOREIGN KEY");
-  });
-
-  it("emits CREATE INDEX", () => {
-    const ix = generateIndexDdl(minimalDoc("postgres"));
-    expect(ix.toUpperCase()).toContain("CREATE ");
-    expect(ix.toUpperCase()).toContain("INDEX");
-  });
-
-  it("includes PK, NOT NULL, and DEFAULT in table DDL", () => {
-    const doc = createEmptyDesign("postgres");
-    doc.model.tables.push({
-      id: "t1",
-      logicalName: "사용자",
-      physicalName: "TB_USER",
-      columns: [
-        createColumn("postgres", {
-          id: "id",
-          logicalName: "아이디",
-          physicalName: "USER_ID",
-          logicalType: "NUMBER",
-          isPrimaryKey: true
-        }),
-        createColumn("postgres", {
-          id: "name",
-          logicalName: "이름",
-          physicalName: "USER_NAME",
-          logicalType: "TEXT",
-          nullable: false,
-          defaultValue: "UNKNOWN"
-        })
-      ]
-    });
-    const sql = generateDdl(doc);
-    expect(sql).toContain("PRIMARY KEY");
-    expect(sql).toContain("NOT NULL");
-    expect(sql).toContain("DEFAULT 'UNKNOWN'");
-  });
-});
+import { describe, expect, it } from "vitest";
+import { createColumn, createEmptyDesign, generateDdl, generateIndexDdl } from "../index";
+
+function minimalDoc(dialect: "mssql" | "oracle" | "mysql" | "postgres" | "sqlite") {
+  const doc = createEmptyDesign(dialect);
+  doc.model.tables.push({
+    id: "parent",
+    logicalName: "부모",
+    physicalName: "TB_PARENT",
+    columns: [
+      createColumn(dialect, {
+        id: "pk",
+        logicalName: "식별자",
+        logicalType: "NUMBER",
+        nullable: false
+      })
+    ]
+  });
+  doc.model.tables.push({
+    id: "child",
+    logicalName: "자식",
+    physicalName: "TB_CHILD",
+    columns: [
+      createColumn(dialect, {
+        id: "fk",
+        logicalName: "부모참조",
+        logicalType: "NUMBER",
+        nullable: false
+      })
+    ]
+  });
+  doc.model.relationships.push({
+    id: "rel1",
+    sourceTableId: "parent",
+    targetTableId: "child",
+    sourceColumnId: "pk",
+    targetColumnId: "fk"
+  });
+  doc.model.indexes.push({
+    id: "ix1",
+    tableId: "child",
+    name: "IX_CHILD_PARENT",
+    columns: ["부모참조"],
+    unique: false
+  });
+  return doc;
+}
+
+describe("generateDdl / generateIndexDdl", () => {
+  it.each(["postgres", "mysql", "oracle", "mssql", "sqlite"] as const)("dialect %s emits CREATE TABLE and FK", (dialect) => {
+    const sql = generateDdl(minimalDoc(dialect));
+    expect(sql).toContain("CREATE TABLE");
+    expect(sql.toUpperCase()).toContain("FOREIGN KEY");
+  });
+
+  it("emits CREATE INDEX", () => {
+    const ix = generateIndexDdl(minimalDoc("postgres"));
+    expect(ix.toUpperCase()).toContain("CREATE ");
+    expect(ix.toUpperCase()).toContain("INDEX");
+  });
+
+  it("includes PK, NOT NULL, and DEFAULT in table DDL", () => {
+    const doc = createEmptyDesign("postgres");
+    doc.model.tables.push({
+      id: "t1",
+      logicalName: "사용자",
+      physicalName: "TB_USER",
+      columns: [
+        createColumn("postgres", {
+          id: "id",
+          logicalName: "아이디",
+          physicalName: "USER_ID",
+          logicalType: "NUMBER",
+          isPrimaryKey: true
+        }),
+        createColumn("postgres", {
+          id: "name",
+          logicalName: "이름",
+          physicalName: "USER_NAME",
+          logicalType: "TEXT",
+          nullable: false,
+          defaultValue: "UNKNOWN"
+        })
+      ]
+    });
+    const sql = generateDdl(doc);
+    expect(sql).toContain("PRIMARY KEY");
+    expect(sql).toContain("NOT NULL");
+    expect(sql).toContain("DEFAULT 'UNKNOWN'");
+  });
+});

package/src/__tests__/designDocument.test.ts

@@ -1,78 +1,129 @@
-import { describe, expect, it } from "vitest";
-import {
-  createColumn,
-  createEmptyDesign,
-  isRelationshipLineRenderable,
-  parseDesign,
-  roundTripDesign,
-  serializeDesign,
-  validateDesignDocument
-} from "../index";
-
-describe("DesignDocument", () => {
-  it("round-trips", () => {
-    const doc = createEmptyDesign("mysql");
-    doc.model.tables.push({
-      id: "t1",
-      logicalName: "엔티티",
-      physicalName: "TB_T1",
-      columns: []
-    });
-    const again = roundTripDesign(doc);
-    expect(again.model.dialect).toBe("mysql");
-    expect(again.model.tables).toHaveLength(1);
-  });
-
-  it("rejects invalid dialect", () => {
-    const raw = JSON.parse(serializeDesign(createEmptyDesign()));
-    raw.model.dialect = "sqlite";
-    expect(() => validateDesignDocument(raw)).toThrow(/dialect/);
-  });
-
-  it("parseDesign validates", () => {
-    const json = serializeDesign(createEmptyDesign("oracle"));
-    expect(parseDesign(json).model.dialect).toBe("oracle");
-  });
-
-  it("createEmptyDesign defaults to mssql", () => {
-    expect(createEmptyDesign().model.dialect).toBe("mssql");
-  });
-
-  it("isRelationshipLineRenderable respects FK column flag and global toggle", () => {
-    const doc = createEmptyDesign("postgres");
-    doc.model.tables.push(
-      {
-        id: "a",
-        logicalName: "A",
-        physicalName: "TA",
-        columns: [createColumn("postgres", { id: "apk", logicalName: "id", logicalType: "NUMBER", nullable: false, isPrimaryKey: true })]
-      },
-      {
-        id: "b",
-        logicalName: "B",
-        physicalName: "TB",
-        columns: [
-          createColumn("postgres", {
-            id: "bfk",
-            logicalName: "aid",
-            logicalType: "NUMBER",
-            isForeignKey: true,
-            showFkRelationLine: false
-          })
-        ]
-      }
-    );
-    const rel = {
-      id: "r1",
-      sourceTableId: "a",
-      targetTableId: "b",
-      sourceColumnId: "apk",
-      targetColumnId: "bfk"
-    };
-    doc.model.relationships.push(rel);
-    expect(isRelationshipLineRenderable(rel, doc.model, false)).toBe(false);
-    expect(isRelationshipLineRenderable(rel, doc.model, true)).toBe(false);
-    doc.model.tables[1].columns[0] = { ...doc.model.tables[1].columns[0], showFkRelationLine: true };
-    expect(isRelationshipLineRenderable(rel, doc.model, true)).toBe(true);
-  });
-});
+import { describe, expect, it } from "vitest";
+import {
+  createColumn,
+  createEmptyDesign,
+  isRelationshipLineRenderable,
+  parseDesign,
+  roundTripDesign,
+  serializeDesign,
+  validateDesignDocument,
+} from "../index";
+
+describe("DesignDocument", () => {
+  it("round-trips", () => {
+    const doc = createEmptyDesign("mysql");
+    doc.model.tables.push({
+      id: "t1",
+      logicalName: "엔티티",
+      physicalName: "TB_T1",
+      columns: []
+    });
+    const again = roundTripDesign(doc);
+    expect(again.model.dialect).toBe("mysql");
+    expect(again.model.tables).toHaveLength(1);
+  });
+
+  it("rejects invalid dialect", () => {
+    const raw = JSON.parse(serializeDesign(createEmptyDesign()));
+    raw.model.dialect = "mariadb";
+    expect(() => validateDesignDocument(raw)).toThrow(/dialect/);
+  });
+
+  it("parseDesign validates", () => {
+    const json = serializeDesign(createEmptyDesign("oracle"));
+    expect(parseDesign(json).model.dialect).toBe("oracle");
+  });
+
+  it("createEmptyDesign defaults to mssql", () => {
+    expect(createEmptyDesign().model.dialect).toBe("mssql");
+  });
+
+  it("isRelationshipLineRenderable respects relationship canvasLineHidden and reveal toggle", () => {
+    const doc = createEmptyDesign("postgres");
+    doc.model.tables.push(
+      {
+        id: "a",
+        logicalName: "A",
+        physicalName: "TA",
+        columns: [createColumn("postgres", { id: "apk", logicalName: "id", logicalType: "NUMBER", nullable: false, isPrimaryKey: true })]
+      },
+      {
+        id: "b",
+        logicalName: "B",
+        physicalName: "TB",
+        columns: [
+          createColumn("postgres", {
+            id: "bfk",
+            logicalName: "aid",
+            logicalType: "NUMBER",
+            isForeignKey: true
+          })
+        ]
+      }
+    );
+    const rel = {
+      id: "r1",
+      sourceTableId: "a",
+      targetTableId: "b",
+      sourceColumnId: "apk",
+      targetColumnId: "bfk",
+      canvasLineHidden: true as const
+    };
+    doc.model.relationships.push(rel);
+    expect(isRelationshipLineRenderable(rel, false)).toBe(false);
+    expect(isRelationshipLineRenderable(rel, true)).toBe(true);
+    delete rel.canvasLineHidden;
+    expect(isRelationshipLineRenderable(rel, false)).toBe(true);
+  });
+
+  it("migrates legacy column showFkRelationLine false to relationship canvasLineHidden", () => {
+    const doc = createEmptyDesign("postgres");
+    doc.model.tables.push(
+      {
+        id: "a",
+        logicalName: "A",
+        physicalName: "TA",
+        columns: [
+          createColumn("postgres", {
+            id: "apk",
+            logicalName: "id",
+            logicalType: "NUMBER",
+            nullable: false,
+            isPrimaryKey: true,
+          }),
+        ],
+      },
+      {
+        id: "b",
+        logicalName: "B",
+        physicalName: "TB",
+        columns: [
+          createColumn("postgres", {
+            id: "bfk",
+            logicalName: "aid",
+            logicalType: "NUMBER",
+            isForeignKey: true,
+          }),
+        ],
+      },
+    );
+    doc.model.relationships.push({
+      id: "r1",
+      sourceTableId: "a",
+      targetTableId: "b",
+      sourceColumnId: "apk",
+      targetColumnId: "bfk",
+    });
+    const raw = JSON.parse(serializeDesign(doc)) as Record<string, unknown>;
+    const tables = (raw.model as { tables: { id: string; columns: Record<string, unknown>[] }[] }).tables;
+    const bTable = tables.find((t) => t.id === "b");
+    const fkCol = bTable?.columns.find((c) => c.id === "bfk");
+    if (fkCol) fkCol.showFkRelationLine = false;
+    const out = validateDesignDocument(raw);
+    expect(out.model.relationships.find((r) => r.id === "r1")?.canvasLineHidden).toBe(true);
+    const migratedFk = out.model.tables.find((t) => t.id === "b")?.columns.find((c) => c.id === "bfk");
+    expect(
+      migratedFk && "showFkRelationLine" in migratedFk ? (migratedFk as { showFkRelationLine?: boolean }).showFkRelationLine : undefined,
+    ).toBeUndefined();
+  });
+});

package/src/__tests__/logical-physical.test.ts

@@ -1,37 +1,94 @@
-import { describe, expect, it } from "vitest";
-import { applyLogicalTypeChange, createColumn, defaultPhysicalType } from "../index";
-
-describe("logical / physical types", () => {
-  it("createColumn defaults physical name to logical name and sets default physical type", () => {
-    const col = createColumn("postgres", {
-      id: "c1",
-      logicalName: "이름",
-      logicalType: "TEXT"
-    });
-    expect(col.physicalName).toBe("이름");
-    expect(col.physicalType).toBe(defaultPhysicalType("postgres", "TEXT"));
-  });
-
-  it("createColumn uses explicit physical name when provided", () => {
-    const col = createColumn("postgres", {
-      id: "c1",
-      logicalName: "이름",
-      physicalName: "Name",
-      logicalType: "TEXT"
-    });
-    expect(col.physicalName).toBe("Name");
-  });
-
-  it("applyLogicalTypeChange resets physical to default", () => {
-    let col = createColumn("mssql", {
-      id: "c1",
-      logicalName: "수량",
-      physicalName: "Qty",
-      logicalType: "NUMBER"
-    });
-    col = { ...col, physicalType: "BIGINT" };
-    col = applyLogicalTypeChange(col, "FLOAT", "mssql");
-    expect(col.logicalType).toBe("FLOAT");
-    expect(col.physicalType).toBe(defaultPhysicalType("mssql", "FLOAT"));
-  });
-});
+import { describe, expect, it } from "vitest";
+import { applyLogicalTypeChange, convertDesignDialect, createColumn, createEmptyDesign, defaultPhysicalType } from "../index";
+
+describe("logical / physical types", () => {
+  it("createColumn defaults physical name to logical name and sets default physical type", () => {
+    const col = createColumn("postgres", {
+      id: "c1",
+      logicalName: "이름",
+      logicalType: "TEXT"
+    });
+    expect(col.physicalName).toBe("이름");
+    expect(col.physicalType).toBe(defaultPhysicalType("postgres", "TEXT"));
+  });
+
+  it("createColumn uses explicit physical name when provided", () => {
+    const col = createColumn("postgres", {
+      id: "c1",
+      logicalName: "이름",
+      physicalName: "Name",
+      logicalType: "TEXT"
+    });
+    expect(col.physicalName).toBe("Name");
+  });
+
+  it("applyLogicalTypeChange resets physical to default", () => {
+    let col = createColumn("mssql", {
+      id: "c1",
+      logicalName: "수량",
+      physicalName: "Qty",
+      logicalType: "NUMBER"
+    });
+    col = { ...col, physicalType: "BIGINT" };
+    col = applyLogicalTypeChange(col, "FLOAT", "mssql");
+    expect(col.logicalType).toBe("FLOAT");
+    expect(col.physicalType).toBe(defaultPhysicalType("mssql", "FLOAT"));
+  });
+
+  it("convertDesignDialect preserves numeric precision/scale when possible", () => {
+    const doc = createEmptyDesign("mssql");
+    doc.model.tables.push({
+      id: "t1",
+      logicalName: "주문",
+      physicalName: "orders",
+      columns: [
+        {
+          ...createColumn("mssql", {
+            id: "c1",
+            logicalName: "금액",
+            physicalName: "amount",
+            logicalType: "NUMBER"
+          }),
+          physicalType: "NUMERIC(10,5)"
+        }
+      ]
+    });
+
+    const oracleDoc = convertDesignDialect(doc, "oracle");
+    expect(oracleDoc.model.tables[0].columns[0].physicalType).toBe("NUMBER(10,5)");
+
+    const pgDoc = convertDesignDialect(doc, "postgres");
+    expect(pgDoc.model.tables[0].columns[0].physicalType).toBe("NUMERIC(10,5)");
+  });
+
+  it("convertDesignDialect preserves varchar length when possible", () => {
+    const doc = createEmptyDesign("postgres");
+    doc.model.tables.push({
+      id: "t1",
+      logicalName: "상품",
+      physicalName: "products",
+      columns: [
+        {
+          ...createColumn("postgres", {
+            id: "c1",
+            logicalName: "코드",
+            physicalName: "code",
+            logicalType: "TEXT"
+          }),
+          physicalType: "VARCHAR(120)"
+        }
+      ]
+    });
+
+    const mssqlDoc = convertDesignDialect(doc, "mssql");
+    expect(mssqlDoc.model.tables[0].columns[0].physicalType).toBe("NVARCHAR(120)");
+  });
+
+  it("defaultPhysicalType includes newly added logical types", () => {
+    expect(defaultPhysicalType("postgres", "BOOLEAN")).toBe("BOOLEAN");
+    expect(defaultPhysicalType("mysql", "JSON")).toBe("JSON");
+    expect(defaultPhysicalType("oracle", "UUID")).toBe("RAW(16)");
+    expect(defaultPhysicalType("sqlite", "BINARY")).toBe("BLOB");
+    expect(defaultPhysicalType("mssql", "DECIMAL")).toBe("DECIMAL(10,2)");
+  });
+});

package/src/alignment.ts

@@ -1,71 +1,71 @@
-export type AlignCommand =
-  | "left"
-  | "h-center"
-  | "right"
-  | "top"
-  | "v-center"
-  | "bottom"
-  | "h-gap"
-  | "v-gap";
-
-/**
- * 멀티 선택된 노드 위치를 bounding box 기준으로 정렬/분배한다.
- * positions는 id -> 좌표 맵이며, 반환값은 동일 키에 갱신된 좌표만 포함한다.
- */
-export function alignNodePositions(
-  selectedIds: string[],
-  positions: Record<string, { x: number; y: number }>,
-  command: AlignCommand
-): Record<string, { x: number; y: number }> {
-  const entries = selectedIds
-    .map((id) => {
-      const pos = positions[id];
-      return pos ? { id, pos: { ...pos } } : null;
-    })
-    .filter((e): e is { id: string; pos: { x: number; y: number } } => Boolean(e));
-
-  if (entries.length < 2) {
-    return {};
-  }
-
-  const xs = entries.map((e) => e.pos.x);
-  const ys = entries.map((e) => e.pos.y);
-  const minX = Math.min(...xs);
-  const maxX = Math.max(...xs);
-  const minY = Math.min(...ys);
-  const maxY = Math.max(...ys);
-  const centerX = (minX + maxX) / 2;
-  const centerY = (minY + maxY) / 2;
-
-  const sortByX = [...entries].sort((a, b) => a.pos.x - b.pos.x);
-  const sortByY = [...entries].sort((a, b) => a.pos.y - b.pos.y);
-
-  const out: Record<string, { x: number; y: number }> = {};
-
-  for (const e of entries) {
-    const next = { ...e.pos };
-    if (command === "left") next.x = minX;
-    if (command === "h-center") next.x = centerX;
-    if (command === "right") next.x = maxX;
-    if (command === "top") next.y = minY;
-    if (command === "v-center") next.y = centerY;
-    if (command === "bottom") next.y = maxY;
-    out[e.id] = next;
-  }
-
-  if (command === "h-gap") {
-    const gap = entries.length > 1 ? (maxX - minX) / (entries.length - 1) : 0;
-    sortByX.forEach((e, index) => {
-      out[e.id] = { ...e.pos, x: minX + gap * index };
-    });
-  }
-
-  if (command === "v-gap") {
-    const gap = entries.length > 1 ? (maxY - minY) / (entries.length - 1) : 0;
-    sortByY.forEach((e, index) => {
-      out[e.id] = { ...e.pos, y: minY + gap * index };
-    });
-  }
-
-  return out;
-}
+export type AlignCommand =
+  | "left"
+  | "h-center"
+  | "right"
+  | "top"
+  | "v-center"
+  | "bottom"
+  | "h-gap"
+  | "v-gap";
+
+/**
+ * 멀티 선택된 노드 위치를 bounding box 기준으로 정렬/분배한다.
+ * positions는 id -> 좌표 맵이며, 반환값은 동일 키에 갱신된 좌표만 포함한다.
+ */
+export function alignNodePositions(
+  selectedIds: string[],
+  positions: Record<string, { x: number; y: number }>,
+  command: AlignCommand
+): Record<string, { x: number; y: number }> {
+  const entries = selectedIds
+    .map((id) => {
+      const pos = positions[id];
+      return pos ? { id, pos: { ...pos } } : null;
+    })
+    .filter((e): e is { id: string; pos: { x: number; y: number } } => Boolean(e));
+
+  if (entries.length < 2) {
+    return {};
+  }
+
+  const xs = entries.map((e) => e.pos.x);
+  const ys = entries.map((e) => e.pos.y);
+  const minX = Math.min(...xs);
+  const maxX = Math.max(...xs);
+  const minY = Math.min(...ys);
+  const maxY = Math.max(...ys);
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+
+  const sortByX = [...entries].sort((a, b) => a.pos.x - b.pos.x);
+  const sortByY = [...entries].sort((a, b) => a.pos.y - b.pos.y);
+
+  const out: Record<string, { x: number; y: number }> = {};
+
+  for (const e of entries) {
+    const next = { ...e.pos };
+    if (command === "left") next.x = minX;
+    if (command === "h-center") next.x = centerX;
+    if (command === "right") next.x = maxX;
+    if (command === "top") next.y = minY;
+    if (command === "v-center") next.y = centerY;
+    if (command === "bottom") next.y = maxY;
+    out[e.id] = next;
+  }
+
+  if (command === "h-gap") {
+    const gap = entries.length > 1 ? (maxX - minX) / (entries.length - 1) : 0;
+    sortByX.forEach((e, index) => {
+      out[e.id] = { ...e.pos, x: minX + gap * index };
+    });
+  }
+
+  if (command === "v-gap") {
+    const gap = entries.length > 1 ? (maxY - minY) / (entries.length - 1) : 0;
+    sortByY.forEach((e, index) => {
+      out[e.id] = { ...e.pos, y: minY + gap * index };
+    });
+  }
+
+  return out;
+}