@rdbms-erd/core 0.1.3 → 0.1.4

package/src/__tests__/designDocument.test.ts

@@ -1,129 +0,0 @@
-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,110 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-    applyLogicalTypeChange,
-    convertDesignDialect,
-    createColumn,
-    createEmptyDesign,
-    defaultPhysicalType,
-    inferLogicalTypeFromPhysical,
-} 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)");
-  });
-
-  it("inferLogicalTypeFromPhysical maps defaults and common aliases", () => {
-    expect(inferLogicalTypeFromPhysical("mssql", "INT")).toBe("NUMBER");
-    expect(inferLogicalTypeFromPhysical("mssql", "NVARCHAR(500)")).toBe("TEXT");
-    expect(inferLogicalTypeFromPhysical("mssql", "DATETIME2")).toBe("DATETIME");
-    expect(inferLogicalTypeFromPhysical("mssql", "BIT")).toBe("BOOLEAN");
-    expect(inferLogicalTypeFromPhysical("postgres", "INTEGER")).toBe("NUMBER");
-    expect(inferLogicalTypeFromPhysical("postgres", "VARCHAR(255)")).toBe("TEXT");
-  });
-});

package/src/alignment.ts

@@ -1,71 +0,0 @@
-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;
-}