@rdbms-erd/core 0.1.2 → 0.1.4

package/dist/index.js

@@ -0,0 +1,883 @@
+// src/alignment.ts
+function alignNodePositions(selectedIds, positions, command) {
+  const entries = selectedIds.map((id) => {
+    const pos = positions[id];
+    return pos ? { id, pos: { ...pos } } : null;
+  }).filter((e) => 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 = {};
+  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;
+}
+
+// src/index.ts
+var LOGICAL_DATA_TYPES = [
+  "TEXT",
+  "DATE",
+  "TIME",
+  "DATETIME",
+  "NUMBER",
+  "DECIMAL",
+  "FLOAT",
+  "BOOLEAN",
+  "JSON",
+  "UUID",
+  "BINARY"
+];
+function isRelationshipLineRenderable(rel, revealHiddenLines) {
+  if (rel.canvasLineHidden === true) return revealHiddenLines;
+  return true;
+}
+function migrateLegacyFkLineVisibility(model) {
+  for (const table of model.tables) {
+    for (const col of table.columns) {
+      const legacy = col.showFkRelationLine;
+      if (legacy === false && col.isForeignKey) {
+        for (const rel of model.relationships) {
+          if (rel.targetTableId === table.id && rel.targetColumnId === col.id) {
+            rel.canvasLineHidden = true;
+          }
+        }
+      }
+      if ("showFkRelationLine" in col) {
+        delete col.showFkRelationLine;
+      }
+    }
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+var BUILTIN_DIALECTS = [
+  "mssql",
+  "oracle",
+  "mysql",
+  "postgres",
+  "sqlite"
+];
+var DIALECT_DEFAULT_TYPE_MAP = {
+  mssql: {
+    TEXT: "NVARCHAR(255)",
+    DATE: "DATE",
+    TIME: "TIME",
+    DATETIME: "DATETIME2",
+    NUMBER: "INT",
+    DECIMAL: "DECIMAL(10,2)",
+    FLOAT: "FLOAT",
+    BOOLEAN: "BIT",
+    JSON: "NVARCHAR(MAX)",
+    UUID: "UNIQUEIDENTIFIER",
+    BINARY: "VARBINARY(255)"
+  },
+  oracle: {
+    TEXT: "VARCHAR2(255)",
+    DATE: "DATE",
+    TIME: "TIMESTAMP",
+    DATETIME: "TIMESTAMP",
+    NUMBER: "NUMBER(10)",
+    DECIMAL: "NUMBER(10,2)",
+    FLOAT: "BINARY_FLOAT",
+    BOOLEAN: "NUMBER(1)",
+    JSON: "CLOB",
+    UUID: "RAW(16)",
+    BINARY: "RAW(255)"
+  },
+  mysql: {
+    TEXT: "VARCHAR(255)",
+    DATE: "DATE",
+    TIME: "TIME",
+    DATETIME: "DATETIME",
+    NUMBER: "INT",
+    DECIMAL: "DECIMAL(10,2)",
+    FLOAT: "FLOAT",
+    BOOLEAN: "BOOLEAN",
+    JSON: "JSON",
+    UUID: "CHAR(36)",
+    BINARY: "VARBINARY(255)"
+  },
+  postgres: {
+    TEXT: "VARCHAR(255)",
+    DATE: "DATE",
+    TIME: "TIME",
+    DATETIME: "TIMESTAMP",
+    NUMBER: "INTEGER",
+    DECIMAL: "NUMERIC(10,2)",
+    FLOAT: "REAL",
+    BOOLEAN: "BOOLEAN",
+    JSON: "JSONB",
+    UUID: "UUID",
+    BINARY: "BYTEA"
+  },
+  sqlite: {
+    TEXT: "TEXT",
+    DATE: "TEXT",
+    TIME: "TEXT",
+    DATETIME: "TEXT",
+    NUMBER: "INTEGER",
+    DECIMAL: "NUMERIC(10,2)",
+    FLOAT: "REAL",
+    BOOLEAN: "INTEGER",
+    JSON: "TEXT",
+    UUID: "TEXT",
+    BINARY: "BLOB"
+  }
+};
+var DIALECT_CAPABILITIES = {
+  mssql: { supportsSchema: true },
+  oracle: { supportsSchema: true },
+  mysql: { supportsSchema: true },
+  postgres: { supportsSchema: true },
+  sqlite: { supportsSchema: false }
+};
+var DIALECT_LABELS = {
+  mssql: "MS SQL Server",
+  oracle: "Oracle",
+  mysql: "MySQL",
+  postgres: "PostgreSQL",
+  sqlite: "SQLite"
+};
+var DIALECT_DDL_STYLE = {
+  mssql: {
+    quote: "bracket",
+    boolLiteral: "oneZero",
+    nowKeyword: "GETDATE()"
+  },
+  oracle: {
+    quote: "double",
+    boolLiteral: "oneZero",
+    nowKeyword: "CURRENT_TIMESTAMP"
+  },
+  mysql: {
+    quote: "backtick",
+    boolLiteral: "oneZero",
+    nowKeyword: "CURRENT_TIMESTAMP"
+  },
+  postgres: {
+    quote: "double",
+    boolLiteral: "trueFalse",
+    nowKeyword: "CURRENT_TIMESTAMP"
+  },
+  sqlite: {
+    quote: "double",
+    boolLiteral: "oneZero",
+    nowKeyword: "CURRENT_TIMESTAMP"
+  }
+};
+function toLogicalTypeMetas(dialect) {
+  return LOGICAL_DATA_TYPES.map((id) => ({
+    id,
+    defaultPhysicalType: DIALECT_DEFAULT_TYPE_MAP[dialect][id]
+  }));
+}
+var BUILTIN_DIALECT_METAS_JSON = BUILTIN_DIALECTS.map((dialect) => ({
+  id: dialect,
+  label: DIALECT_LABELS[dialect],
+  supportsSchema: DIALECT_CAPABILITIES[dialect].supportsSchema,
+  logicalTypes: toLogicalTypeMetas(dialect),
+  ddlStyle: DIALECT_DDL_STYLE[dialect]
+}));
+function defaultDdlRules() {
+  return {
+    quoteIdentifier: (dialect, identifier) => {
+      if (dialect === "mssql") return `[${identifier}]`;
+      if (dialect === "mysql") return `\`${identifier}\``;
+      return `"${identifier}"`;
+    },
+    toDefaultExpression: (dialect, col) => {
+      const raw = col.defaultValue?.trim();
+      if (!raw) return null;
+      const upper = raw.toUpperCase();
+      const isFunctionLike = /[()]/.test(raw) || upper === "NULL" || upper === "CURRENT_TIMESTAMP" || upper === "CURRENT_DATE";
+      if (isFunctionLike) return raw;
+      if (col.logicalType === "NUMBER" || col.logicalType === "DECIMAL" || col.logicalType === "FLOAT")
+        return raw;
+      if (col.logicalType === "BOOLEAN") {
+        if (upper === "TRUE" || upper === "FALSE") {
+          if (dialect === "mssql" || dialect === "oracle" || dialect === "sqlite")
+            return upper === "TRUE" ? "1" : "0";
+          return upper;
+        }
+        if (raw === "1" || raw === "0") return raw;
+        return quoteSqlString(raw);
+      }
+      if (col.logicalType === "DATE" || col.logicalType === "DATETIME") {
+        if (dialect === "mssql" && upper === "NOW") return "GETDATE()";
+        if (upper === "NOW") return "CURRENT_TIMESTAMP";
+        return quoteSqlString(raw);
+      }
+      if (raw.startsWith("'") && raw.endsWith("'") || raw.startsWith('"') && raw.endsWith('"'))
+        return raw;
+      return quoteSqlString(raw);
+    }
+  };
+}
+function toAdapterDialectMeta(meta) {
+  const typeMap = {};
+  for (const lt of meta.logicalTypes) typeMap[lt.id] = lt.defaultPhysicalType;
+  return {
+    id: meta.id,
+    label: meta.label,
+    capabilities: { supportsSchema: meta.supportsSchema },
+    logicalTypes: meta.logicalTypes.map((lt) => lt.id),
+    defaultPhysicalTypeMap: typeMap
+  };
+}
+function mergeDialectMetas(base, host = []) {
+  const byId = new Map(
+    base.map((meta) => [meta.id, meta])
+  );
+  for (const meta of host) byId.set(meta.id, meta);
+  return Array.from(byId.values());
+}
+function resolveDialectMetas(options) {
+  return mergeDialectMetas(
+    BUILTIN_DIALECT_METAS_JSON,
+    options?.hostMetas ?? []
+  );
+}
+function buildDbMetaAdapterFromMetas(metas) {
+  const byId = new Map(
+    metas.map((meta) => [meta.id, toAdapterDialectMeta(meta)])
+  );
+  const defaultRules = defaultDdlRules();
+  return {
+    listDialects: () => Array.from(byId.values()),
+    getDialectMeta: (dialect) => byId.get(dialect),
+    getDefaultPhysicalType: (dialect, logicalType) => {
+      const mapped = byId.get(dialect)?.defaultPhysicalTypeMap[logicalType];
+      return mapped ?? DIALECT_DEFAULT_TYPE_MAP.postgres[logicalType];
+    },
+    getDdlRules: (dialect) => {
+      const json = metas.find((m) => m.id === dialect);
+      const style = json?.ddlStyle;
+      if (!style) return defaultRules;
+      const quoteIdentifier2 = (_d, identifier) => {
+        if (style.quote === "bracket") return `[${identifier}]`;
+        if (style.quote === "backtick") return `\`${identifier}\``;
+        return `"${identifier}"`;
+      };
+      const toDefaultExpression2 = (_d, col) => {
+        const raw = col.defaultValue?.trim();
+        if (!raw) return null;
+        const upper = raw.toUpperCase();
+        const isFunctionLike = /[()]/.test(raw) || upper === "NULL" || upper === "CURRENT_TIMESTAMP" || upper === "CURRENT_DATE";
+        if (isFunctionLike) return raw;
+        if (col.logicalType === "NUMBER" || col.logicalType === "DECIMAL" || col.logicalType === "FLOAT")
+          return raw;
+        if (col.logicalType === "BOOLEAN") {
+          if (upper === "TRUE" || upper === "FALSE") {
+            if ((style.boolLiteral ?? "oneZero") === "oneZero")
+              return upper === "TRUE" ? "1" : "0";
+            return upper;
+          }
+          if (raw === "1" || raw === "0") return raw;
+          return quoteSqlString(raw);
+        }
+        if (col.logicalType === "DATE" || col.logicalType === "DATETIME") {
+          if (upper === "NOW")
+            return style.nowKeyword ?? "CURRENT_TIMESTAMP";
+          return quoteSqlString(raw);
+        }
+        if (raw.startsWith("'") && raw.endsWith("'") || raw.startsWith('"') && raw.endsWith('"'))
+          return raw;
+        return quoteSqlString(raw);
+      };
+      return { quoteIdentifier: quoteIdentifier2, toDefaultExpression: toDefaultExpression2 };
+    }
+  };
+}
+function createDefaultDbMetaAdapter(overrides) {
+  const base = buildDbMetaAdapterFromMetas(BUILTIN_DIALECT_METAS_JSON);
+  return { ...base, ...overrides };
+}
+var defaultDbMetaAdapter = createDefaultDbMetaAdapter();
+function resolveDbMetaAdapter(options) {
+  if (options?.dbMetaAdapter) return options.dbMetaAdapter;
+  if (options?.hostMetas && options.hostMetas.length > 0) {
+    return buildDbMetaAdapterFromMetas(resolveDialectMetas(options));
+  }
+  return defaultDbMetaAdapter;
+}
+function defaultPhysicalType(dialect, logicalType, options) {
+  return resolveDbMetaAdapter(options).getDefaultPhysicalType(
+    dialect,
+    logicalType
+  );
+}
+function normalizePhysicalCompare(s) {
+  return s.trim().toUpperCase().replace(/\s+/g, " ");
+}
+function physicalTypeBaseName(s) {
+  const n = normalizePhysicalCompare(s);
+  const p = n.indexOf("(");
+  return p >= 0 ? n.slice(0, p).trim() : n;
+}
+function inferLogicalTypeFromPhysical(dialect, physicalType, options) {
+  const raw = physicalType?.trim();
+  if (!raw) return "TEXT";
+  const metas = resolveDialectMetas(options);
+  const meta = metas.find((m) => m.id === dialect);
+  const normFull = normalizePhysicalCompare(raw);
+  const base = physicalTypeBaseName(raw);
+  if (meta) {
+    for (const lt of meta.logicalTypes) {
+      if (normalizePhysicalCompare(lt.defaultPhysicalType) === normFull) {
+        return lt.id;
+      }
+    }
+    for (const lt of meta.logicalTypes) {
+      if (physicalTypeBaseName(lt.defaultPhysicalType) === base) {
+        return lt.id;
+      }
+    }
+  }
+  const b = base;
+  if (b === "INT" || b === "INTEGER" || b === "BIGINT" || b === "SMALLINT" || b === "TINYINT" || b === "NUMBER" || b === "SERIAL" || b === "SERIAL4" || b === "SERIAL8") {
+    return "NUMBER";
+  }
+  if (b === "DECIMAL" || b === "NUMERIC" || b === "MONEY" || b === "SMALLMONEY") {
+    return "DECIMAL";
+  }
+  if (b === "FLOAT" || b === "REAL" || b === "DOUBLE" || b === "BINARY_FLOAT" || b === "BINARY_DOUBLE") {
+    return "FLOAT";
+  }
+  if (b === "BIT" || b === "BOOLEAN" || b === "BOOL") {
+    return "BOOLEAN";
+  }
+  if (b === "DATETIME" || b === "DATETIME2" || b === "SMALLDATETIME" || b === "TIMESTAMP" || b === "TIMESTAMPTZ") {
+    return "DATETIME";
+  }
+  if (b === "DATE") return "DATE";
+  if (b === "TIME" || b === "TIMETZ") return "TIME";
+  if (b.includes("CHAR") || b === "TEXT" || b === "CLOB" || b === "NCLOB" || b === "NCHAR" || b === "NVARCHAR" || b === "VARCHAR" || b === "VARCHAR2") {
+    return "TEXT";
+  }
+  if (b === "JSON" || b === "JSONB") return "JSON";
+  if (b === "UUID" || b === "UNIQUEIDENTIFIER") return "UUID";
+  if (b === "BINARY" || b === "VARBINARY" || b === "RAW" || b === "BYTEA" || b === "BLOB" || b === "IMAGE") {
+    return "BINARY";
+  }
+  return "TEXT";
+}
+function getRdbmsDialectCapability(dialect, options) {
+  const meta = resolveDbMetaAdapter(options).getDialectMeta(dialect);
+  return meta?.capabilities ?? { supportsSchema: false };
+}
+function dialectSupportsSchema(dialect, options) {
+  return getRdbmsDialectCapability(dialect, options).supportsSchema;
+}
+function parseTypeArguments(physicalType) {
+  const m = physicalType.match(/\(([^)]+)\)/);
+  if (!m) return null;
+  const values = m[1].split(",").map((v) => Number.parseInt(v.trim(), 10)).filter((v) => Number.isFinite(v));
+  return values.length > 0 ? values : null;
+}
+function convertPhysicalTypeByLogicalType(physicalType, logicalType, nextDialect, options) {
+  const args = parseTypeArguments(physicalType);
+  const precision = args?.[0];
+  const scale = args?.[1];
+  const length = args?.[0];
+  if (logicalType === "NUMBER") {
+    if (nextDialect === "oracle") {
+      if (precision && scale !== void 0)
+        return `NUMBER(${precision},${scale})`;
+      if (precision) return `NUMBER(${precision})`;
+      return "NUMBER(10)";
+    }
+    if (nextDialect === "mssql") {
+      if (precision && scale !== void 0)
+        return `NUMERIC(${precision},${scale})`;
+      if (precision) return `NUMERIC(${precision},0)`;
+      return "INT";
+    }
+    if (nextDialect === "mysql") {
+      if (precision && scale !== void 0)
+        return `DECIMAL(${precision},${scale})`;
+      if (precision) return `DECIMAL(${precision},0)`;
+      return "INT";
+    }
+    if (nextDialect === "postgres") {
+      if (precision && scale !== void 0)
+        return `NUMERIC(${precision},${scale})`;
+      if (precision) return `NUMERIC(${precision},0)`;
+      return "INTEGER";
+    }
+    return "INTEGER";
+  }
+  if (logicalType === "DECIMAL") {
+    if (precision && scale !== void 0) {
+      if (nextDialect === "oracle")
+        return `NUMBER(${precision},${scale})`;
+      if (nextDialect === "postgres")
+        return `NUMERIC(${precision},${scale})`;
+      return `DECIMAL(${precision},${scale})`;
+    }
+    return defaultPhysicalType(nextDialect, logicalType, options);
+  }
+  if (logicalType === "FLOAT") {
+    if (nextDialect === "oracle") return "BINARY_FLOAT";
+    if (nextDialect === "sqlite") return "REAL";
+    return "FLOAT";
+  }
+  if (logicalType === "TEXT") {
+    if (nextDialect === "oracle")
+      return length ? `VARCHAR2(${length})` : "VARCHAR2(255)";
+    if (nextDialect === "mssql")
+      return length ? `NVARCHAR(${length})` : "NVARCHAR(255)";
+    if (nextDialect === "mysql")
+      return length ? `VARCHAR(${length})` : "VARCHAR(255)";
+    if (nextDialect === "postgres")
+      return length ? `VARCHAR(${length})` : "VARCHAR(255)";
+    return "TEXT";
+  }
+  if (logicalType === "BINARY") {
+    if (nextDialect === "mssql")
+      return length ? `VARBINARY(${length})` : "VARBINARY(255)";
+    if (nextDialect === "oracle")
+      return length ? `RAW(${length})` : "RAW(255)";
+    if (nextDialect === "mysql")
+      return length ? `VARBINARY(${length})` : "VARBINARY(255)";
+    if (nextDialect === "postgres") return "BYTEA";
+    return "BLOB";
+  }
+  return defaultPhysicalType(nextDialect, logicalType, options);
+}
+function convertDesignDialect(doc, nextDialect, options) {
+  if (doc.model.dialect === nextDialect) return doc;
+  const supportsSchema = dialectSupportsSchema(nextDialect, options);
+  return {
+    ...doc,
+    model: {
+      ...doc.model,
+      dialect: nextDialect,
+      tables: doc.model.tables.map((table) => ({
+        ...table,
+        schemaName: supportsSchema ? table.schemaName : void 0,
+        columns: table.columns.map((col) => ({
+          ...col,
+          physicalType: convertPhysicalTypeByLogicalType(
+            col.physicalType,
+            col.logicalType,
+            nextDialect,
+            options
+          )
+        }))
+      }))
+    }
+  };
+}
+function applyLogicalTypeChange(column, nextLogicalType, dialect, options) {
+  return {
+    ...column,
+    logicalType: nextLogicalType,
+    physicalType: defaultPhysicalType(dialect, nextLogicalType, options)
+  };
+}
+function createColumn(dialect, params, options) {
+  const physicalName = params.physicalName ?? params.logicalName;
+  const isPrimaryKey = params.isPrimaryKey ?? false;
+  const isForeignKey = params.isForeignKey ?? false;
+  const col = {
+    id: params.id,
+    logicalName: params.logicalName,
+    physicalName,
+    description: params.description,
+    logicalType: params.logicalType,
+    physicalType: defaultPhysicalType(dialect, params.logicalType, options),
+    defaultValue: params.defaultValue,
+    nullable: isPrimaryKey ? false : params.nullable ?? true,
+    isPrimaryKey,
+    isForeignKey,
+    referencesPrimaryColumnId: params.referencesPrimaryColumnId
+  };
+  if (params.color !== void 0) col.color = params.color;
+  return col;
+}
+function createEmptyDesign(dialect = "mssql") {
+  return {
+    schemaVersion: 1,
+    model: {
+      dialect,
+      tables: [],
+      relationships: [],
+      indexes: []
+    },
+    layout: {
+      nodePositions: {}
+    }
+  };
+}
+function serializeDesign(doc) {
+  return JSON.stringify(doc, null, 2);
+}
+function parseDesign(json, options) {
+  const parsed = JSON.parse(json);
+  return validateDesignDocument(parsed, options);
+}
+function validateDesignDocument(input, options) {
+  if (!isObject(input)) {
+    throw new Error("Invalid design document: root must be object");
+  }
+  if (input.schemaVersion !== 1) {
+    throw new Error("Unsupported schemaVersion");
+  }
+  if (!isObject(input.model) || !Array.isArray(input.model.tables) || !Array.isArray(input.model.relationships) || !Array.isArray(input.model.indexes)) {
+    throw new Error("Invalid design document: model is malformed");
+  }
+  const dialects = new Set(
+    resolveDbMetaAdapter(options).listDialects().map((d) => d.id)
+  );
+  const modelDialect = input.model.dialect;
+  if (typeof modelDialect !== "string" || !dialects.has(modelDialect)) {
+    throw new Error("Invalid design document: model.dialect is invalid");
+  }
+  if (!isObject(input.layout) || !isObject(input.layout.nodePositions)) {
+    throw new Error("Invalid design document: layout is malformed");
+  }
+  const doc = input;
+  migrateLegacyFkLineVisibility(doc.model);
+  return doc;
+}
+function roundTripDesign(doc) {
+  return parseDesign(serializeDesign(doc));
+}
+function quoteIdentifier(dialect, identifier, options) {
+  const quote = resolveDbMetaAdapter(options).getDdlRules(dialect).quoteIdentifier ?? defaultDdlRules().quoteIdentifier;
+  return quote(dialect, identifier);
+}
+function qualifiedTableName(table, dialect, options) {
+  const schema = table.schemaName?.trim();
+  if (dialectSupportsSchema(dialect, options) && schema) {
+    return `${quoteIdentifier(dialect, schema, options)}.${quoteIdentifier(dialect, table.physicalName, options)}`;
+  }
+  return quoteIdentifier(dialect, table.physicalName, options);
+}
+function quoteSqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function toDefaultExpression(dialect, col, options) {
+  const handler = resolveDbMetaAdapter(options).getDdlRules(dialect).toDefaultExpression ?? defaultDdlRules().toDefaultExpression;
+  return handler(dialect, col);
+}
+function joinColumnDefs(table, dialect, options) {
+  const defs = table.columns.map((col) => {
+    const nullable = col.nullable ? "NULL" : "NOT NULL";
+    const defaultExpr = toDefaultExpression(dialect, col, options);
+    const defaultSql = defaultExpr ? ` DEFAULT ${defaultExpr}` : "";
+    return `  ${quoteIdentifier(dialect, col.physicalName, options)} ${col.physicalType}${defaultSql} ${nullable}`;
+  });
+  const pkColumns = table.columns.filter((col) => col.isPrimaryKey).map((col) => quoteIdentifier(dialect, col.physicalName, options));
+  if (pkColumns.length > 0) {
+    defs.push(`  PRIMARY KEY (${pkColumns.join(", ")})`);
+  }
+  return defs;
+}
+function createTableSql(table, dialect, options) {
+  const columns = joinColumnDefs(table, dialect, options);
+  return `CREATE TABLE ${qualifiedTableName(table, dialect, options)} (
+${columns.join(",\n")}
+);`;
+}
+function createRelationshipSql(rel, model, dialect, index, options) {
+  const sourceTable = model.tables.find(
+    (table) => table.id === rel.sourceTableId
+  );
+  const targetTable = model.tables.find(
+    (table) => table.id === rel.targetTableId
+  );
+  if (!sourceTable || !targetTable || !rel.sourceColumnId || !rel.targetColumnId) {
+    return null;
+  }
+  const sourceColumn = sourceTable.columns.find(
+    (col) => col.id === rel.sourceColumnId
+  );
+  const targetColumn = targetTable.columns.find(
+    (col) => col.id === rel.targetColumnId
+  );
+  if (!sourceColumn || !targetColumn) {
+    return null;
+  }
+  const fkName = `FK_${targetTable.physicalName}_${sourceTable.physicalName}_${index + 1}`;
+  return [
+    `ALTER TABLE ${qualifiedTableName(targetTable, dialect, options)}`,
+    `  ADD CONSTRAINT ${quoteIdentifier(dialect, fkName, options)}`,
+    `  FOREIGN KEY (${quoteIdentifier(dialect, targetColumn.physicalName, options)})`,
+    `  REFERENCES ${qualifiedTableName(sourceTable, dialect, options)} (${quoteIdentifier(dialect, sourceColumn.physicalName, options)});`
+  ].join("\n");
+}
+function createIndexSql(indexModel, model, dialect, options) {
+  const table = model.tables.find((item) => item.id === indexModel.tableId);
+  if (!table || indexModel.columns.length === 0) {
+    return null;
+  }
+  const unique = indexModel.unique ? "UNIQUE " : "";
+  const columns = indexModel.columns.map((col) => quoteIdentifier(dialect, col, options)).join(", ");
+  return `CREATE ${unique}INDEX ${quoteIdentifier(dialect, indexModel.name, options)} ON ${qualifiedTableName(table, dialect, options)} (${columns});`;
+}
+function buildDdlSql(doc, options) {
+  const { model } = doc;
+  const tableSql = model.tables.map(
+    (table) => createTableSql(table, model.dialect, options)
+  );
+  const relSql = model.relationships.map(
+    (rel, index) => createRelationshipSql(rel, model, model.dialect, index, options)
+  ).filter((item) => Boolean(item));
+  return [...tableSql, ...relSql].join("\n\n");
+}
+function buildIndexDdlSql(doc, options) {
+  const { model } = doc;
+  const statements = model.indexes.map((index) => createIndexSql(index, model, model.dialect, options)).filter((item) => Boolean(item));
+  return statements.join("\n\n");
+}
+function sliceDocByScope(doc, scope) {
+  if (scope.kind === "all") return doc;
+  const selected = new Set(scope.tableIds);
+  return {
+    ...doc,
+    model: {
+      ...doc.model,
+      tables: doc.model.tables.filter((t) => selected.has(t.id)),
+      relationships: doc.model.relationships.filter(
+        (r) => selected.has(r.sourceTableId) && selected.has(r.targetTableId)
+      ),
+      indexes: doc.model.indexes.filter((i) => selected.has(i.tableId))
+    }
+  };
+}
+function styleBasedDdlGenerator(input, options) {
+  const scoped = sliceDocByScope(input.doc, input.scope);
+  return {
+    sql: buildDdlSql(scoped, options),
+    diagnostics: analyzeDdlDocument(scoped, options)
+  };
+}
+function hasBuiltinDialect(dialectId) {
+  return BUILTIN_DIALECTS.includes(dialectId);
+}
+function getBuiltinDdlGenerator(dialectId, _options) {
+  if (!hasBuiltinDialect(dialectId)) return void 0;
+  return (input) => styleBasedDdlGenerator(input, _options);
+}
+function invokeDdlGeneratorSync(generator, input) {
+  const result = generator(input);
+  if (result && typeof result.then === "function") {
+    throw new Error("Async DDL generator is not supported in sync API");
+  }
+  return result;
+}
+function runDdlGenerator(doc, scope, options) {
+  const input = {
+    doc,
+    dialectId: doc.model.dialect,
+    scope
+  };
+  const hostGenerator = options?.hostDdlGenerators?.[doc.model.dialect];
+  const builtinGenerator = getBuiltinDdlGenerator(doc.model.dialect, options);
+  const fallback = () => styleBasedDdlGenerator(input, options);
+  const fallbackOnError = options?.fallbackOnHookError ?? true;
+  const selectedGenerator = hostGenerator ?? builtinGenerator;
+  if (!selectedGenerator) return fallback();
+  try {
+    return invokeDdlGeneratorSync(selectedGenerator, input);
+  } catch (error) {
+    if (!fallbackOnError) throw error;
+    return fallback();
+  }
+}
+function formatDdlDiagnostic(d) {
+  const level = d.severity === "error" ? "ERROR" : "WARN";
+  const tail = d.context ? ` | ${d.context}` : "";
+  return `[${level}][${d.code}] ${d.message}${tail}`;
+}
+function formatDdlDiagnostics(diagnostics) {
+  return diagnostics.map(formatDdlDiagnostic).join("\n");
+}
+function analyzeDdlDocument(doc, options) {
+  const out = [];
+  const { model } = doc;
+  const tableById = new Map(model.tables.map((t) => [t.id, t]));
+  const physicalTableNames = /* @__PURE__ */ new Map();
+  for (const table of model.tables) {
+    const qualifiedName = dialectSupportsSchema(model.dialect, options) && table.schemaName?.trim() ? `${table.schemaName.trim()}.${table.physicalName}` : table.physicalName;
+    const list = physicalTableNames.get(qualifiedName) ?? [];
+    list.push(table.id);
+    physicalTableNames.set(qualifiedName, list);
+    if (table.columns.length === 0) {
+      out.push({
+        severity: "warning",
+        code: "DDL_EMPTY_TABLE",
+        message: "\uCEEC\uB7FC\uC774 \uC5C6\uB294 \uD14C\uC774\uBE14\uC740 CREATE TABLE \uAD6C\uBB38\uC774 \uBE44\uC5B4 \uC788\uAC70\uB098 \uBB34\uC758\uBBF8\uD560 \uC218 \uC788\uB2E4.",
+        context: `table:${table.id}`
+      });
+    }
+  }
+  for (const [name, ids] of physicalTableNames) {
+    if (ids.length > 1) {
+      out.push({
+        severity: "warning",
+        code: "DDL_DUPLICATE_TABLE_NAME",
+        message: `\uB3D9\uC77C\uD55C \uBB3C\uB9AC \uD14C\uC774\uBE14\uBA85 "${name}"\uC774 ${ids.length}\uAC1C \uD14C\uC774\uBE14\uC5D0 \uC0AC\uC6A9\uB418\uC5C8\uB2E4.`,
+        context: `tables:${ids.join(",")}`
+      });
+    }
+  }
+  for (const rel of model.relationships) {
+    const ctx = `relationship:${rel.id}`;
+    const sourceTable = tableById.get(rel.sourceTableId);
+    const targetTable = tableById.get(rel.targetTableId);
+    if (!sourceTable || !targetTable) {
+      out.push({
+        severity: "error",
+        code: "DDL_REL_UNKNOWN_TABLE",
+        message: "\uAD00\uACC4\uC758 \uC18C\uC2A4 \uB610\uB294 \uD0C0\uAC9F \uD14C\uC774\uBE14\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC5B4 FK DDL\uC744 \uC0DD\uC131\uD560 \uC218 \uC5C6\uB2E4.",
+        context: ctx
+      });
+      continue;
+    }
+    if (!rel.sourceColumnId || !rel.targetColumnId) {
+      out.push({
+        severity: "warning",
+        code: "DDL_REL_MISSING_COLUMNS",
+        message: "\uC18C\uC2A4/\uD0C0\uAC9F \uCEEC\uB7FC\uC774 \uC9C0\uC815\uB418\uC9C0 \uC54A\uC544 FK DDL\uC744 \uC0DD\uB7B5\uD55C\uB2E4.",
+        context: ctx
+      });
+      continue;
+    }
+    const sourceColumn = sourceTable.columns.find(
+      (c) => c.id === rel.sourceColumnId
+    );
+    const targetColumn = targetTable.columns.find(
+      (c) => c.id === rel.targetColumnId
+    );
+    if (!sourceColumn || !targetColumn) {
+      out.push({
+        severity: "warning",
+        code: "DDL_REL_UNKNOWN_COLUMN",
+        message: "\uAD00\uACC4\uC5D0 \uC9C0\uC815\uB41C \uCEEC\uB7FC id\uB97C \uD14C\uC774\uBE14\uC5D0\uC11C \uCC3E\uC744 \uC218 \uC5C6\uC5B4 FK DDL\uC744 \uC0DD\uB7B5\uD55C\uB2E4.",
+        context: ctx
+      });
+    }
+  }
+  for (const indexModel of model.indexes) {
+    const ctx = `index:${indexModel.id}`;
+    const table = tableById.get(indexModel.tableId);
+    if (!table) {
+      out.push({
+        severity: "warning",
+        code: "IDX_UNKNOWN_TABLE",
+        message: "\uC778\uB371\uC2A4\uAC00 \uAC00\uB9AC\uD0A4\uB294 \uD14C\uC774\uBE14\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC5B4 \uC778\uB371\uC2A4 DDL\uC744 \uC0DD\uB7B5\uD55C\uB2E4.",
+        context: ctx
+      });
+      continue;
+    }
+    if (indexModel.columns.length === 0) {
+      out.push({
+        severity: "warning",
+        code: "IDX_EMPTY_COLUMNS",
+        message: "\uC778\uB371\uC2A4 \uCEEC\uB7FC \uBAA9\uB85D\uC774 \uBE44\uC5B4 \uC788\uC5B4 \uC778\uB371\uC2A4 DDL\uC744 \uC0DD\uB7B5\uD55C\uB2E4.",
+        context: ctx
+      });
+      continue;
+    }
+    for (const colPhys of indexModel.columns) {
+      if (!table.columns.some((c) => c.physicalName === colPhys)) {
+        out.push({
+          severity: "warning",
+          code: "IDX_UNKNOWN_COLUMN",
+          message: `\uC778\uB371\uC2A4\uAC00 \uCC38\uC870\uD558\uB294 \uBB3C\uB9AC \uCEEC\uB7FC\uBA85 "${colPhys}"\uC744(\uB97C) \uD14C\uC774\uBE14 "${table.physicalName}"\uC5D0\uC11C \uCC3E\uC744 \uC218 \uC5C6\uB2E4.`,
+          context: ctx
+        });
+      }
+    }
+  }
+  return out;
+}
+function generateDdlWithDiagnostics(doc, options) {
+  const out = runDdlGenerator(doc, { kind: "all" }, options);
+  return {
+    sql: out.sql,
+    diagnostics: out.diagnostics ?? analyzeDdlDocument(doc, options)
+  };
+}
+function generateIndexDdlWithDiagnostics(doc, options) {
+  return {
+    sql: buildIndexDdlSql(doc, options),
+    diagnostics: analyzeDdlDocument(doc, options)
+  };
+}
+function generateDdl(doc, options) {
+  return runDdlGenerator(doc, { kind: "all" }, options).sql;
+}
+function generateDdlForSelection(doc, tableIds, options) {
+  const out = runDdlGenerator(doc, { kind: "selected", tableIds }, options);
+  const diagnostics = out.diagnostics ?? analyzeDdlDocument(
+    sliceDocByScope(doc, { kind: "selected", tableIds }),
+    options
+  );
+  return { sql: out.sql, diagnostics };
+}
+function generateIndexDdl(doc, options) {
+  return buildIndexDdlSql(doc, options);
+}
+function createLargeDesign(tableCount, dialect = "postgres") {
+  const doc = createEmptyDesign(dialect);
+  const cols = 20;
+  for (let i = 0; i < tableCount; i++) {
+    const id = `t-${i}`;
+    doc.model.tables.push({
+      id,
+      logicalName: `\uC5D4\uD2F0\uD2F0${i}`,
+      physicalName: `TB_T${i}`,
+      columns: [
+        createColumn(dialect, {
+          id: `${id}-pk`,
+          logicalName: "\uC2DD\uBCC4\uC790",
+          logicalType: "NUMBER",
+          nullable: false
+        })
+      ]
+    });
+    doc.layout.nodePositions[id] = {
+      x: i % cols * 220,
+      y: Math.floor(i / cols) * 120
+    };
+  }
+  return doc;
+}
+
+export { BUILTIN_DIALECTS, BUILTIN_DIALECT_METAS_JSON, LOGICAL_DATA_TYPES, alignNodePositions, analyzeDdlDocument, applyLogicalTypeChange, convertDesignDialect, createColumn, createDefaultDbMetaAdapter, createEmptyDesign, createLargeDesign, defaultDbMetaAdapter, defaultPhysicalType, dialectSupportsSchema, formatDdlDiagnostic, formatDdlDiagnostics, generateDdl, generateDdlForSelection, generateDdlWithDiagnostics, generateIndexDdl, generateIndexDdlWithDiagnostics, getRdbmsDialectCapability, inferLogicalTypeFromPhysical, isRelationshipLineRenderable, mergeDialectMetas, migrateLegacyFkLineVisibility, parseDesign, resolveDialectMetas, roundTripDesign, serializeDesign, validateDesignDocument };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map