@vibeorm/dsl 0.3.0 → 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1546 @@
+// @bun
+// packages/dsl/src/column.ts
+function cloneColumnDef(params) {
+  const { column } = params;
+  return {
+    __type: "column",
+    __columnType: column.__columnType,
+    __name: column.__name,
+    __config: { ...column.__config },
+    __enumValues: column.__enumValues,
+    __enumName: column.__enumName
+  };
+}
+
+class ChainableColumn {
+  __type = "column";
+  __columnType;
+  __config;
+  __name;
+  __enumValues;
+  __enumName;
+  constructor(columnType, config = {}) {
+    this.__columnType = columnType;
+    this.__config = { ...config };
+  }
+  optional() {
+    this.__config.optional = true;
+    return this;
+  }
+  unique() {
+    this.__config.unique = true;
+    return this;
+  }
+  index() {
+    this.__config.index = true;
+    return this;
+  }
+  array() {
+    this.__config.array = true;
+    return this;
+  }
+  default(value) {
+    this.__config.default = value;
+    return this;
+  }
+  map(dbColumnName) {
+    this.__config.map = dbColumnName;
+    return this;
+  }
+  dbgenerated(expression) {
+    this.__config.dbgenerated = expression;
+    return this;
+  }
+  comment(text) {
+    this.__config.comment = text;
+    return this;
+  }
+}
+
+class ChainableStringColumn extends ChainableColumn {
+  constructor(config = {}) {
+    super("string", config);
+  }
+  maxLength(n) {
+    this.__config.maxLength = n;
+    return this;
+  }
+  text() {
+    this.__config.text = true;
+    return this;
+  }
+}
+
+class ChainableDecimalColumn extends ChainableColumn {
+  constructor(config = {}) {
+    super("decimal", config);
+  }
+  precision(p, s) {
+    this.__config.precision = p;
+    if (s !== undefined) {
+      this.__config.scale = s;
+    }
+    return this;
+  }
+}
+
+class ChainableDatetimeColumn extends ChainableColumn {
+  constructor(config = {}) {
+    super("datetime", config);
+  }
+  tz() {
+    this.__config.tz = true;
+    return this;
+  }
+  updatedAt() {
+    this.__config.updatedAt = true;
+    return this;
+  }
+  defaultNow() {
+    this.__config.default = "now";
+    return this;
+  }
+}
+
+class ChainableIdColumn extends ChainableColumn {
+  constructor(config = {}) {
+    super("id", { ...config, type: config.type ?? "ulid" });
+  }
+  type(idType) {
+    this.__config.type = idType;
+    return this;
+  }
+}
+
+class ChainableEnumColumn extends ChainableColumn {
+  constructor(params) {
+    super("enum", params.config ?? {});
+    this.__enumValues = params.options;
+    if (params.enumName !== undefined) {
+      this.__enumName = params.enumName;
+    }
+  }
+  default(value) {
+    this.__config.default = value;
+    return this;
+  }
+}
+function string(config = {}) {
+  return new ChainableStringColumn(config);
+}
+function int(config = {}) {
+  return new ChainableColumn("int", config);
+}
+function float(config = {}) {
+  return new ChainableColumn("float", config);
+}
+function decimal(config = {}) {
+  return new ChainableDecimalColumn(config);
+}
+function boolean(config = {}) {
+  return new ChainableColumn("boolean", config);
+}
+function datetime(config = {}) {
+  return new ChainableDatetimeColumn(config);
+}
+function json(config = {}) {
+  return new ChainableColumn("json", config);
+}
+function id(config = {}) {
+  return new ChainableIdColumn(config);
+}
+function bytes(config = {}) {
+  return new ChainableColumn("bytes", config);
+}
+function bigint(config = {}) {
+  return new ChainableColumn("bigint", config);
+}
+function unsupported(dbType) {
+  const config = { dbType };
+  return new ChainableColumn("unsupported", config);
+}
+function extensionType(config) {
+  const { type, args, ...rest } = config;
+  return new ChainableColumn("unsupported", {
+    ...rest,
+    dbType: "",
+    extensionType: type,
+    extensionArgs: [...args ?? []]
+  });
+}
+function enumCol(config) {
+  const { options, ...restConfig } = config;
+  return new ChainableEnumColumn({ options, config: restConfig });
+}
+
+// packages/dsl/src/enum.ts
+function createEnum(config) {
+  const { name, options } = config;
+  return {
+    __type: "enum",
+    __name: name,
+    __options: options,
+    field(fieldConfig = {}) {
+      return new ChainableEnumColumn({ options, config: fieldConfig, enumName: name });
+    }
+  };
+}
+
+// packages/dsl/src/generator/prisma.ts
+import { internalError } from "@vibeorm/schema";
+
+// packages/dsl/src/naming.ts
+function capitalize(params) {
+  const { value } = params;
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function uncapitalize(params) {
+  const { value } = params;
+  return value.charAt(0).toLowerCase() + value.slice(1);
+}
+function toFkColumnName(params) {
+  return `${uncapitalize({ value: params.modelName })}Id`;
+}
+function inlineEnumName(params) {
+  const { modelName, columnName } = params;
+  return `${modelName}${capitalize({ value: columnName })}`;
+}
+
+// packages/dsl/src/relation.ts
+function children(config) {
+  return {
+    __type: "children",
+    __name: config.name,
+    __schema: config.schema
+  };
+}
+function createChildrenBuilder() {
+  return { children };
+}
+
+// packages/dsl/src/model.ts
+function isColumnDef(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "column";
+}
+function isChildrenDef(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "children";
+}
+function createIndexBuilder() {
+  const createIndex = (columns, type) => ({
+    __type: "index",
+    __columns: [...columns],
+    __indexType: type
+  });
+  return {
+    on(...args) {
+      const [first, second] = args;
+      if (args.length === 2 && Array.isArray(first) && typeof second === "object" && !Array.isArray(second)) {
+        return createIndex(first, second.type);
+      }
+      return createIndex(args);
+    },
+    index(...columns) {
+      return createIndex(columns);
+    },
+    unique(...columns) {
+      return { __type: "unique", __columns: [...columns] };
+    },
+    gin(...columns) {
+      return createIndex(columns, "Gin");
+    },
+    gist(...columns) {
+      return createIndex(columns, "Gist");
+    },
+    hash(...columns) {
+      return createIndex(columns, "Hash");
+    },
+    brin(...columns) {
+      return createIndex(columns, "Brin");
+    }
+  };
+}
+function processSchema(params) {
+  const { modelName, schema } = params;
+  const resolvedSchema = typeof schema === "function" ? schema(createChildrenBuilder()) : schema;
+  const columns = new Map;
+  const children2 = new Map;
+  for (const [key, value] of Object.entries(resolvedSchema)) {
+    if (isColumnDef(value)) {
+      const cloned = cloneColumnDef({ column: value });
+      cloned.__name = key;
+      columns.set(key, cloned);
+    } else if (isChildrenDef(value)) {
+      const childModel = create({ name: value.__name, schema: value.__schema });
+      const parentFkName = toFkColumnName({ modelName });
+      childModel.__columns.set(parentFkName, {
+        __type: "column",
+        __columnType: "string",
+        __name: parentFkName,
+        __config: { index: true }
+      });
+      children2.set(key, childModel);
+    }
+  }
+  return { columns, children: children2 };
+}
+function create(config) {
+  const { columns, children: children2 } = processSchema({
+    modelName: config.name,
+    schema: config.schema
+  });
+  return {
+    __type: "model",
+    __name: config.name,
+    __schema: config.schema,
+    __indexes: config.indexes,
+    __columns: columns,
+    __children: children2,
+    __map: config.map,
+    __primaryKey: config.primaryKey,
+    __extensions: config.extensions
+  };
+}
+function getColumnNames(params) {
+  return Array.from(params.model.__columns.keys());
+}
+function evaluateIndexes(params) {
+  const { model } = params;
+  if (model.__indexes === undefined) {
+    return [];
+  }
+  return model.__indexes(createIndexBuilder());
+}
+
+// packages/dsl/src/relation-plan.ts
+function detectOneToOnePairs(params) {
+  const { relations, models } = params;
+  const mergeMap = new Map;
+  const allOnes = [];
+  for (const [modelName, modelRelations] of Object.entries(relations)) {
+    for (const [relName, rel] of Object.entries(modelRelations)) {
+      if (rel.__relationType === "one") {
+        allOnes.push({ modelName, relName, rel });
+      }
+    }
+  }
+  const paired = new Set;
+  for (let i = 0;i < allOnes.length; i++) {
+    const a = allOnes[i];
+    if (a === undefined)
+      continue;
+    const keyA = `${a.modelName}:${a.relName}`;
+    if (paired.has(keyA))
+      continue;
+    for (let j = i + 1;j < allOnes.length; j++) {
+      const b = allOnes[j];
+      if (b === undefined)
+        continue;
+      const keyB = `${b.modelName}:${b.relName}`;
+      if (paired.has(keyB))
+        continue;
+      const sameColumnPair = a.rel.__fromModel === b.rel.__toModel && a.rel.__fromColumn === b.rel.__toColumn && a.rel.__toModel === b.rel.__fromModel && a.rel.__toColumn === b.rel.__fromColumn;
+      if (!sameColumnPair)
+        continue;
+      const { fkOwner, backRelation } = resolveFkOwner({ a, b, models });
+      const onDelete = fkOwner.rel.__onDelete ?? backRelation.rel.__onDelete;
+      const onUpdate = fkOwner.rel.__onUpdate ?? backRelation.rel.__onUpdate;
+      const fkKey = `${fkOwner.modelName}:${fkOwner.relName}`;
+      const backKey = `${backRelation.modelName}:${backRelation.relName}`;
+      mergeMap.set(fkKey, {
+        role: "fkOwner",
+        pairedRelName: backRelation.relName,
+        pairedModelName: backRelation.modelName,
+        onDelete,
+        onUpdate
+      });
+      mergeMap.set(backKey, {
+        role: "backRelation",
+        pairedRelName: fkOwner.relName,
+        pairedModelName: fkOwner.modelName,
+        onDelete,
+        onUpdate
+      });
+      paired.add(fkKey);
+      paired.add(backKey);
+      break;
+    }
+  }
+  return mergeMap;
+}
+function resolveFkOwner(params) {
+  const { a, b, models } = params;
+  const aFromIsId = models.get(a.modelName)?.__columns.get(a.rel.__fromColumn)?.__columnType === "id";
+  const bFromIsId = models.get(b.modelName)?.__columns.get(b.rel.__fromColumn)?.__columnType === "id";
+  if (aFromIsId && !bFromIsId)
+    return { fkOwner: b, backRelation: a };
+  if (!aFromIsId && bFromIsId)
+    return { fkOwner: a, backRelation: b };
+  if (a.rel.__onDelete !== undefined || a.rel.__onUpdate !== undefined) {
+    return { fkOwner: a, backRelation: b };
+  }
+  if (b.rel.__onDelete !== undefined || b.rel.__onUpdate !== undefined) {
+    return { fkOwner: b, backRelation: a };
+  }
+  const aLooksFk = looksLikeForeignKey({ column: a.rel.__fromColumn });
+  const bLooksFk = looksLikeForeignKey({ column: b.rel.__fromColumn });
+  return aLooksFk && !bLooksFk ? { fkOwner: a, backRelation: b } : { fkOwner: b, backRelation: a };
+}
+function looksLikeForeignKey(params) {
+  const { column } = params;
+  return column.toLowerCase().includes("id") && column !== "id";
+}
+function planExplicitRelations(params) {
+  const { modelName, model, relations, mergeMap } = params;
+  const planned = [];
+  for (const [relName, rel] of Object.entries(relations[modelName] ?? {})) {
+    const name = relName;
+    const base = {
+      model: modelName,
+      name,
+      targetModel: rel.__targetModel,
+      relationName: rel.__alias
+    };
+    if (rel.__relationType === "many") {
+      planned.push({ ...base, kind: "list", isList: true, isOptional: false });
+      continue;
+    }
+    const mergeInfo = mergeMap.get(`${modelName}:${relName}`);
+    if (mergeInfo?.role === "backRelation") {
+      planned.push({ ...base, kind: "backOne", isList: false, isOptional: true });
+      continue;
+    }
+    const ownsFk = mergeInfo?.role === "fkOwner" || rel.__fromModel === modelName;
+    if (!ownsFk) {
+      planned.push({ ...base, kind: "backOne", isList: false, isOptional: rel.__optional });
+      continue;
+    }
+    const fkColumn = model.__columns.get(rel.__fromColumn);
+    planned.push({
+      ...base,
+      kind: "fkOwner",
+      isList: false,
+      isOptional: fkColumn?.__config.optional === true || rel.__optional,
+      fields: [rel.__fromColumn],
+      references: [rel.__toColumn],
+      onDelete: mergeInfo?.onDelete ?? rel.__onDelete,
+      onUpdate: mergeInfo?.onUpdate ?? rel.__onUpdate
+    });
+  }
+  return planned;
+}
+function planMissingReverseRelations(params) {
+  const { modelName, relations, mergeMap, existing } = params;
+  const planned = [];
+  const existingLists = new Set;
+  const existingNames = new Set;
+  for (const relation of existing) {
+    existingNames.add(relation.name);
+    if (relation.isList) {
+      existingLists.add(`${relation.targetModel}:${relation.relationName ?? ""}`);
+    }
+  }
+  for (const [sourceModelName, sourceRelations] of Object.entries(relations)) {
+    for (const [relName, rel] of Object.entries(sourceRelations)) {
+      if (rel.__targetModel !== modelName || rel.__relationType !== "one")
+        continue;
+      if (mergeMap.has(`${sourceModelName}:${relName}`))
+        continue;
+      const reverseKey = `${sourceModelName}:${rel.__alias ?? ""}`;
+      if (existingLists.has(reverseKey))
+        continue;
+      if (sourceModelName === modelName) {
+        const hasExplicitReverse = Object.values(sourceRelations).some((other) => other.__relationType === "many" && other.__targetModel === modelName && other.__alias === rel.__alias);
+        if (hasExplicitReverse)
+          continue;
+      }
+      const baseName = rel.__alias ?? sourceModelName;
+      let name = baseName;
+      let counter = 1;
+      while (existingNames.has(name)) {
+        counter++;
+        name = `${baseName}${counter}`;
+      }
+      planned.push({
+        model: modelName,
+        name,
+        targetModel: sourceModelName,
+        kind: "list",
+        isList: true,
+        isOptional: false,
+        relationName: rel.__alias
+      });
+      existingLists.add(reverseKey);
+      existingNames.add(name);
+    }
+  }
+  return planned;
+}
+function planChildRelations(params) {
+  const { modelName, model, models } = params;
+  const planned = [];
+  for (const [childKey, childModel] of model.__children) {
+    planned.push({
+      model: modelName,
+      name: childKey,
+      targetModel: childModel.__name,
+      kind: "list",
+      isList: true,
+      isOptional: false
+    });
+  }
+  for (const [parentModelName, parentModel] of models) {
+    for (const childModel of parentModel.__children.values()) {
+      if (childModel.__name !== modelName)
+        continue;
+      const parentPk = parentModel.__primaryKey?.[0] ?? Array.from(parentModel.__columns.entries()).find(([, column]) => column.__columnType === "id")?.[0] ?? "id";
+      planned.push({
+        model: modelName,
+        name: parentModelName,
+        targetModel: parentModelName,
+        kind: "fkOwner",
+        isList: false,
+        isOptional: false,
+        fields: [toFkColumnName({ modelName: parentModelName })],
+        references: [parentPk]
+      });
+    }
+  }
+  return planned;
+}
+function planIndexes(params) {
+  const { model } = params;
+  const byKey = new Map;
+  for (const [columnName, column] of model.__columns) {
+    if (column.__columnType === "id" || column.__config.unique === true)
+      continue;
+    if (column.__config.index === true) {
+      byKey.set(columnName, { isUnique: false, columns: [columnName] });
+    }
+  }
+  for (const index of evaluateIndexes({ model })) {
+    const key = index.__columns.join(",");
+    const existing = byKey.get(key);
+    const isUnique = index.__type === "unique";
+    if (existing === undefined || isUnique) {
+      byKey.set(key, {
+        isUnique,
+        columns: [...index.__columns],
+        indexType: index.__indexType
+      });
+    } else if (index.__indexType !== undefined && existing.indexType === undefined) {
+      byKey.set(key, { ...existing, indexType: index.__indexType });
+    }
+  }
+  return Array.from(byKey.values());
+}
+function planSchema(params) {
+  const { schema } = params;
+  const mergeMap = detectOneToOnePairs({
+    relations: schema.__relations,
+    models: schema.__models
+  });
+  const relations = new Map;
+  const indexes = new Map;
+  for (const [modelName, model] of schema.__models) {
+    const explicit = planExplicitRelations({
+      modelName,
+      model,
+      relations: schema.__relations,
+      mergeMap
+    });
+    const reverses = planMissingReverseRelations({
+      modelName,
+      relations: schema.__relations,
+      mergeMap,
+      existing: explicit
+    });
+    const children2 = planChildRelations({ modelName, model, models: schema.__models });
+    relations.set(modelName, [...explicit, ...reverses, ...children2]);
+    indexes.set(modelName, planIndexes({ model }));
+  }
+  return { relations, indexes };
+}
+function resolveRelationType(params) {
+  const { relation, plan } = params;
+  const counterparts = findCounterparts({ relation, plan });
+  if (relation.isList) {
+    if (counterparts.some((candidate) => !candidate.isList))
+      return "oneToMany";
+    return counterparts.some((candidate) => candidate.isList) ? "manyToMany" : "oneToMany";
+  }
+  if (relation.kind === "fkOwner") {
+    const pairedWithSingular = counterparts.length > 0 && counterparts.every((candidate) => !candidate.isList);
+    return pairedWithSingular ? "oneToOne" : "manyToOne";
+  }
+  return "oneToOne";
+}
+function findCounterparts(params) {
+  const { relation, plan } = params;
+  const nameKey = relation.relationName ?? "";
+  return (plan.relations.get(relation.targetModel) ?? []).filter((candidate) => candidate !== relation && candidate.targetModel === relation.model && (candidate.relationName ?? "") === nameKey);
+}
+
+// packages/dsl/src/generator/prisma.ts
+function prismaType(params) {
+  const { column } = params;
+  const list = column.__config.array === true ? "[]" : "";
+  switch (column.__columnType) {
+    case "string":
+      return `String${list}`;
+    case "int":
+      return `Int${list}`;
+    case "bigint":
+      return `BigInt${list}`;
+    case "float":
+      return `Float${list}`;
+    case "decimal":
+      return `Decimal${list}`;
+    case "boolean":
+      return `Boolean${list}`;
+    case "datetime":
+      return `DateTime${list}`;
+    case "json":
+      return `Json${list}`;
+    case "bytes":
+      return `Bytes${list}`;
+    case "id":
+      return column.__config.type === "autoincrement" ? "Int" : "String";
+    case "enum":
+      return column.__enumName === undefined ? `String${list}` : `${column.__enumName}${list}`;
+    case "unsupported": {
+      const extensionTypeName = column.__config["extensionType"];
+      if (typeof extensionTypeName === "string") {
+        const rawArgs = column.__config["extensionArgs"];
+        const args = Array.isArray(rawArgs) ? rawArgs.map(String).join(", ") : "";
+        return `${extensionTypeName}${args.length > 0 ? `(${args})` : ""}${list}`;
+      }
+      return `Unsupported("${String(column.__config.dbType)}")${list}`;
+    }
+  }
+}
+function idDefaultAttribute(params) {
+  const idType = params.column.__config.type;
+  switch (idType) {
+    case "ulid":
+    case "cuid":
+    case "uuid":
+    case "nanoid":
+    case "autoincrement":
+      return `@default(${idType}())`;
+    default:
+      return;
+  }
+}
+function defaultAttribute(params) {
+  const { column } = params;
+  const { dbgenerated, default: value } = column.__config;
+  if (typeof dbgenerated === "string") {
+    return `@default(dbgenerated("${dbgenerated}"))`;
+  }
+  if (value === undefined)
+    return;
+  if (column.__columnType === "datetime" && value === "now") {
+    return "@default(now())";
+  }
+  if (column.__columnType === "enum" && typeof value === "string") {
+    return `@default(${value})`;
+  }
+  if (typeof value === "string")
+    return `@default("${value}")`;
+  if (typeof value === "boolean" || typeof value === "number")
+    return `@default(${value})`;
+  if (typeof value === "bigint")
+    return `@default(${value.toString()})`;
+  return;
+}
+function nativeTypeAttribute(params) {
+  const { column } = params;
+  if (column.__columnType === "string") {
+    const { maxLength, text } = column.__config;
+    if (typeof maxLength === "number")
+      return `@db.VarChar(${maxLength})`;
+    if (text === true)
+      return "@db.Text";
+    return;
+  }
+  if (column.__columnType === "decimal") {
+    const { precision, scale } = column.__config;
+    if (typeof precision === "number")
+      return `@db.Decimal(${precision}, ${scale ?? 0})`;
+    return;
+  }
+  if (column.__columnType === "datetime" && column.__config.tz === true) {
+    return "@db.Timestamptz";
+  }
+  return;
+}
+function formatColumn(params) {
+  const { name, column } = params;
+  const parts = [`  ${name} ${prismaType({ column })}${column.__config.optional === true ? "?" : ""}`];
+  if (column.__columnType === "id") {
+    parts.push("@id");
+    const idDefault = idDefaultAttribute({ column });
+    if (idDefault !== undefined)
+      parts.push(idDefault);
+  } else {
+    const columnDefault = defaultAttribute({ column });
+    if (columnDefault !== undefined)
+      parts.push(columnDefault);
+  }
+  if (column.__columnType === "datetime" && column.__config.updatedAt === true) {
+    parts.push("@updatedAt");
+  }
+  if (column.__config.unique === true) {
+    parts.push("@unique");
+  }
+  if (typeof column.__config.map === "string") {
+    parts.push(`@map("${column.__config.map}")`);
+  }
+  const nativeType = nativeTypeAttribute({ column });
+  if (nativeType !== undefined)
+    parts.push(nativeType);
+  const columnLine = parts.join(" ");
+  const comment = column.__config.comment;
+  if (typeof comment === "string") {
+    const commentLines = comment.split(`
+`).map((line) => `  /// ${line}`);
+    return [...commentLines, columnLine].join(`
+`);
+  }
+  return columnLine;
+}
+function formatRelation(params) {
+  const { relation } = params;
+  const { name, targetModel, relationName } = relation;
+  if (relation.kind === "list") {
+    const attribute = relationName === undefined ? "" : ` @relation("${relationName}")`;
+    return `  ${name} ${targetModel}[]${attribute}`;
+  }
+  const optional = relation.isOptional ? "?" : "";
+  if (relation.kind === "backOne") {
+    const attribute = relationName === undefined ? "" : ` @relation("${relationName}")`;
+    return `  ${name} ${targetModel}${optional}${attribute}`;
+  }
+  const args = [];
+  if (relationName !== undefined)
+    args.push(`"${relationName}"`);
+  if (relation.fields === undefined || relation.references === undefined) {
+    throw internalError({
+      message: `planned FK relation "${relation.model}.${name}" has no fields/references`,
+      meta: { model: relation.model, relation: name }
+    });
+  }
+  args.push(`fields: [${relation.fields.join(", ")}]`);
+  args.push(`references: [${relation.references.join(", ")}]`);
+  if (relation.onDelete !== undefined)
+    args.push(`onDelete: ${relation.onDelete}`);
+  if (relation.onUpdate !== undefined)
+    args.push(`onUpdate: ${relation.onUpdate}`);
+  return `  ${name} ${targetModel}${optional} @relation(${args.join(", ")})`;
+}
+function formatIndex(params) {
+  const { index } = params;
+  const columns = index.columns.join(", ");
+  if (index.isUnique) {
+    return `  @@unique([${columns}])`;
+  }
+  const typeArg = index.indexType === undefined ? "" : `, type: ${index.indexType}`;
+  return `  @@index([${columns}]${typeArg})`;
+}
+function formatExtensionValue(params) {
+  const { value } = params;
+  if (typeof value === "string")
+    return `"${value}"`;
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => formatExtensionValue({ value: entry })).join(", ")}]`;
+  }
+  return String(value);
+}
+function formatModel(params) {
+  const { model, plan } = params;
+  const lines = [`model ${model.__name} {`];
+  lines.push("  //> Columns");
+  for (const [name, column] of model.__columns) {
+    lines.push(formatColumn({ name, column }));
+  }
+  lines.push("");
+  lines.push("  //> Relations");
+  for (const relation of plan.relations.get(model.__name) ?? []) {
+    lines.push(formatRelation({ relation }));
+  }
+  lines.push("");
+  lines.push("  //> Indexes");
+  lines.push("");
+  for (const index of plan.indexes.get(model.__name) ?? []) {
+    lines.push(formatIndex({ index }));
+  }
+  for (const use of model.__extensions ?? []) {
+    const args = [];
+    if (use.fields !== undefined)
+      args.push(`[${use.fields.join(", ")}]`);
+    for (const [key, value] of Object.entries(use.args ?? {})) {
+      args.push(`${key}: ${formatExtensionValue({ value })}`);
+    }
+    lines.push(`  @@${use.attribute}(${args.join(", ")})`);
+  }
+  if (model.__primaryKey !== undefined && model.__primaryKey.length > 0) {
+    lines.push(`  @@id([${model.__primaryKey.join(", ")}])`);
+  }
+  if (typeof model.__map === "string") {
+    lines.push(`  @@map("${model.__map}")`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+}
+function formatEnum(params) {
+  const { name, values } = params;
+  return [`enum ${name} {`, ...values.map((value) => `  ${value}`), "}"].join(`
+`);
+}
+function generatePrisma(schema, _config = {}) {
+  const plan = planSchema({ schema });
+  const sections = [];
+  if (schema.__enums.size > 0) {
+    sections.push("// ============================================");
+    sections.push("// Enums");
+    sections.push("// ============================================");
+    sections.push("");
+    for (const [name, values] of schema.__enums) {
+      sections.push(formatEnum({ name, values }));
+      sections.push("");
+    }
+  }
+  sections.push("// ============================================");
+  sections.push("// Models");
+  sections.push("// ============================================");
+  sections.push("");
+  for (const model of schema.__models.values()) {
+    sections.push(formatModel({ model, plan }));
+    sections.push("");
+  }
+  return sections.join(`
+`).trim();
+}
+
+// packages/dsl/src/relations.ts
+function createColumnRef(params) {
+  const { model, column } = params;
+  return {
+    __type: "columnRef",
+    __model: model,
+    __column: column,
+    through(junction) {
+      return {
+        __type: "throughRef",
+        __model: model,
+        __column: column,
+        __junction: junction.__model,
+        __junctionColumn: junction.__column
+      };
+    }
+  };
+}
+function extractRefInfo(params) {
+  const { ref } = params;
+  return { model: ref.__model, column: ref.__column };
+}
+function createRelationFactory(params) {
+  const { relationType, targetModelName } = params;
+  return (config) => {
+    const from = extractRefInfo({ ref: config.from });
+    const to = extractRefInfo({ ref: config.to });
+    let throughJunction;
+    let throughFromCol;
+    let throughToCol;
+    if (config.from.__type === "throughRef") {
+      throughJunction = config.from.__junction;
+      throughFromCol = config.from.__junctionColumn;
+    }
+    if (config.to.__type === "throughRef") {
+      throughJunction = throughJunction ?? config.to.__junction;
+      throughToCol = config.to.__junctionColumn;
+    }
+    return {
+      __type: "storedRelation",
+      __relationType: relationType,
+      __targetModel: targetModelName,
+      __fromModel: from.model,
+      __fromColumn: from.column,
+      __toModel: to.model,
+      __toColumn: to.column,
+      __throughJunction: throughJunction,
+      __throughFromCol: throughFromCol,
+      __throughToCol: throughToCol,
+      __optional: config.optional ?? relationType === "many",
+      __alias: config.alias,
+      __onDelete: config.onDelete,
+      __onUpdate: config.onUpdate
+    };
+  };
+}
+function createRelationsBuilder(params) {
+  const { models } = params;
+  const builder = {};
+  const oneObj = {};
+  const manyObj = {};
+  for (const modelName of Object.keys(models)) {
+    oneObj[modelName] = createRelationFactory({ relationType: "one", targetModelName: modelName });
+    manyObj[modelName] = createRelationFactory({
+      relationType: "many",
+      targetModelName: modelName
+    });
+    const model = models[modelName];
+    if (model === undefined)
+      continue;
+    const columnRefs = {};
+    for (const columnName of model.__columns.keys()) {
+      columnRefs[columnName] = createColumnRef({ model: modelName, column: columnName });
+    }
+    builder[modelName] = columnRefs;
+  }
+  builder.one = oneObj;
+  builder.many = manyObj;
+  return builder;
+}
+function processRelationsOutput(params) {
+  const result = {};
+  for (const [modelName, relations] of Object.entries(params.output)) {
+    if (relations) {
+      result[modelName] = relations;
+    }
+  }
+  return result;
+}
+function defineRelations(models, callback) {
+  const builder = createRelationsBuilder({ models });
+  return processRelationsOutput({ output: callback(builder) });
+}
+function defineRelationsPart(models, callback) {
+  const builder = createRelationsBuilder({ models });
+  return processRelationsOutput({ output: callback(builder) });
+}
+function mergeRelations(...parts) {
+  const result = {};
+  for (const part of parts) {
+    for (const [modelName, relations] of Object.entries(part)) {
+      const existing = result[modelName] ?? {};
+      result[modelName] = { ...existing, ...relations };
+    }
+  }
+  return result;
+}
+
+// packages/dsl/src/schema.ts
+function isModelDef(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "model";
+}
+function isEnumDef(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "enum";
+}
+function addModelTree(params) {
+  const { model, models } = params;
+  models.set(model.__name, model);
+  for (const childModel of model.__children.values()) {
+    addModelTree({ model: childModel, models });
+  }
+}
+function extractModelsAndEnums(params) {
+  const { input, models, standaloneEnums } = params;
+  for (const value of Object.values(input)) {
+    if (isModelDef(value)) {
+      addModelTree({ model: value, models });
+    } else if (isEnumDef(value)) {
+      standaloneEnums.set(value.__name, value.__options);
+    } else if (typeof value === "object" && value !== null) {
+      extractModelsAndEnums({ input: value, models, standaloneEnums });
+    }
+  }
+}
+function resolveEnums(params) {
+  const { models, standaloneEnums } = params;
+  const enums = new Map(standaloneEnums);
+  for (const [modelName, model] of models) {
+    for (const [columnName, column] of model.__columns) {
+      if (column.__columnType !== "enum" || column.__enumValues === undefined)
+        continue;
+      if (column.__enumName !== undefined) {
+        if (!enums.has(column.__enumName)) {
+          enums.set(column.__enumName, column.__enumValues);
+        }
+        continue;
+      }
+      const name = inlineEnumName({ modelName, columnName });
+      enums.set(name, column.__enumValues);
+      column.__enumName = name;
+    }
+  }
+  return enums;
+}
+function schema(input, options) {
+  const models = new Map;
+  const standaloneEnums = new Map;
+  extractModelsAndEnums({ input, models, standaloneEnums });
+  return {
+    __type: "schema",
+    __models: models,
+    __enums: resolveEnums({ models, standaloneEnums }),
+    __relations: options?.relations ?? {}
+  };
+}
+function domain(params) {
+  const { name, models } = params;
+  return { name, models };
+}
+
+// packages/dsl/src/templates.ts
+var base = {
+  get id() {
+    return id({ type: "ulid" });
+  },
+  get createdAt() {
+    return datetime({ default: "now", tz: true, index: true });
+  },
+  get updatedAt() {
+    return datetime({ default: "now", updatedAt: true, tz: true, index: true });
+  },
+  get deletedAt() {
+    return datetime({ optional: true, index: true });
+  }
+};
+var baseWithWorkspace = {
+  get id() {
+    return id({ type: "ulid" });
+  },
+  get createdAt() {
+    return datetime({ default: "now", tz: true, index: true });
+  },
+  get updatedAt() {
+    return datetime({ default: "now", updatedAt: true, tz: true, index: true });
+  },
+  get deletedAt() {
+    return datetime({ optional: true, index: true });
+  },
+  get workspaceId() {
+    return string({ index: true });
+  }
+};
+var withMetadata = {
+  get metadata() {
+    return json({ optional: true });
+  },
+  get settings() {
+    return json({ optional: true });
+  }
+};
+var withActive = {
+  get isActive() {
+    return boolean({ default: true });
+  }
+};
+var withAudit = {
+  get createdById() {
+    return string({ optional: true, index: true });
+  },
+  get updatedById() {
+    return string({ optional: true, index: true });
+  }
+};
+var withExternalId = {
+  get externalId() {
+    return string({ index: true });
+  }
+};
+var withNameDescription = {
+  get name() {
+    return string();
+  },
+  get description() {
+    return string({ optional: true });
+  }
+};
+var fields = {
+  get datetime() {
+    return datetime({ default: "now", updatedAt: true, tz: true, index: true });
+  },
+  get id() {
+    return id({ type: "ulid" });
+  },
+  get title() {
+    return string();
+  },
+  get description() {
+    return string({ optional: true });
+  },
+  get externalId() {
+    return string({ index: true });
+  },
+  get metadata() {
+    return json({ optional: true });
+  },
+  get settings() {
+    return json({ optional: true });
+  },
+  get isActive() {
+    return boolean({ default: true });
+  }
+};
+var templates = {
+  base,
+  baseWithWorkspace,
+  withMetadata,
+  withActive,
+  withAudit,
+  withExternalId,
+  withNameDescription,
+  fields
+};
+
+// packages/dsl/src/to-ir.ts
+import {
+  EMPTY_EXTENSION_REGISTRY,
+  VibeError,
+  assertValidSchemaIR,
+  mergeExtensionDeclarations
+} from "@vibeorm/schema";
+function fieldType(params) {
+  const { column } = params;
+  switch (column.__columnType) {
+    case "string":
+      return "String";
+    case "int":
+      return "Int";
+    case "bigint":
+      return "BigInt";
+    case "float":
+      return "Float";
+    case "decimal":
+      return "Decimal";
+    case "boolean":
+      return "Boolean";
+    case "datetime":
+      return "DateTime";
+    case "json":
+      return "Json";
+    case "bytes":
+      return "Bytes";
+    case "id":
+      return column.__config.type === "autoincrement" ? "Int" : "String";
+    case "enum":
+      return column.__enumName === undefined ? "String" : { enum: column.__enumName };
+    case "unsupported":
+      return "String";
+  }
+}
+function idDefault(params) {
+  switch (params.column.__config.type) {
+    case "ulid":
+      return { kind: "ulid" };
+    case "cuid":
+      return { kind: "cuid" };
+    case "uuid":
+      return { kind: "uuid" };
+    case "nanoid":
+      return { kind: "nanoid" };
+    case "autoincrement":
+      return { kind: "autoincrement" };
+    default:
+      return;
+  }
+}
+function fieldDefault(params) {
+  const { column } = params;
+  if (column.__columnType === "id")
+    return idDefault({ column });
+  const { dbgenerated, default: value } = column.__config;
+  if (typeof dbgenerated === "string")
+    return { kind: "dbgenerated", sql: dbgenerated };
+  if (value === undefined)
+    return;
+  if (column.__columnType === "datetime" && value === "now")
+    return { kind: "now" };
+  if (column.__columnType === "enum" && typeof value === "string") {
+    return { kind: "enumValue", value };
+  }
+  if (typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+    return { kind: "literal", value };
+  }
+  if (typeof value === "bigint")
+    return { kind: "literal", value: Number(value) };
+  return;
+}
+function nativeType(params) {
+  const { column } = params;
+  if (column.__columnType === "string") {
+    const { maxLength, text } = column.__config;
+    if (typeof maxLength === "number")
+      return `VarChar(${maxLength})`;
+    if (text === true)
+      return "Text";
+    return;
+  }
+  if (column.__columnType === "decimal") {
+    const { precision, scale } = column.__config;
+    if (typeof precision === "number")
+      return `Decimal(${precision}, ${scale ?? 0})`;
+    return;
+  }
+  if (column.__columnType === "datetime" && column.__config.tz === true) {
+    return "Timestamptz";
+  }
+  if (column.__columnType === "unsupported") {
+    return String(column.__config.dbType);
+  }
+  return;
+}
+function buildField(params) {
+  const { name, column, extensionNativeType } = params;
+  const config = column.__config;
+  const isList = column.__columnType !== "id" && config.array === true;
+  const dbName = typeof config.map === "string" ? config.map : undefined;
+  const documentation = typeof config.comment === "string" ? config.comment : undefined;
+  const defaultValue = fieldDefault({ column });
+  const native = extensionNativeType ?? nativeType({ column });
+  return {
+    name,
+    type: fieldType({ column }),
+    isList,
+    isOptional: config.optional === true,
+    isId: column.__columnType === "id",
+    isUnique: config.unique === true,
+    isUpdatedAt: column.__columnType === "datetime" && config.updatedAt === true,
+    ...dbName === undefined ? {} : { dbName },
+    ...defaultValue === undefined ? {} : { default: defaultValue },
+    ...native === undefined ? {} : { nativeType: native },
+    ...column.__columnType === "unsupported" ? { isUnsupported: true } : {},
+    ...documentation === undefined ? {} : { documentation }
+  };
+}
+function buildRelation(params) {
+  const { relation, plan } = params;
+  return {
+    name: relation.name,
+    model: relation.model,
+    targetModel: relation.targetModel,
+    type: resolveRelationType({ relation, plan }),
+    isList: relation.isList,
+    isOptional: relation.isOptional,
+    ...relation.relationName === undefined ? {} : { relationName: relation.relationName },
+    ...relation.fields === undefined ? {} : { fields: [...relation.fields] },
+    ...relation.references === undefined ? {} : { references: [...relation.references] },
+    ...relation.onDelete === undefined ? {} : { onDelete: relation.onDelete },
+    ...relation.onUpdate === undefined ? {} : { onUpdate: relation.onUpdate }
+  };
+}
+var INDEX_KINDS = {
+  BTree: "btree",
+  Hash: "hash",
+  Gin: "gin",
+  Gist: "gist",
+  SpGist: "spgist",
+  Brin: "brin"
+};
+function buildIndex(params) {
+  const { index } = params;
+  const kind = index.isUnique ? "unique" : index.indexType === undefined ? "btree" : INDEX_KINDS[index.indexType];
+  return {
+    kind,
+    fields: index.columns.map((name) => ({ name }))
+  };
+}
+function buildModel(params) {
+  const { model, plan, extensions, declarations, issues } = params;
+  const primaryKey = model.__primaryKey !== undefined && model.__primaryKey.length > 0 ? { fields: [...model.__primaryKey] } : undefined;
+  const fields2 = [];
+  for (const [name, column] of model.__columns) {
+    const extensionTypeName = column.__config["extensionType"];
+    if (typeof extensionTypeName !== "string") {
+      fields2.push(buildField({ name, column }));
+      continue;
+    }
+    const registered = extensions.fieldTypes.get(extensionTypeName);
+    if (registered === undefined) {
+      issues.push({
+        rule: "extension-attribute",
+        message: `Field "${model.__name}.${name}" uses extension type "${extensionTypeName}" but no configured extension provides it`,
+        model: model.__name,
+        field: name
+      });
+      continue;
+    }
+    const rawArgs = column.__config["extensionArgs"];
+    const lowered = registered.fieldType.lower({
+      model: model.__name,
+      field: name,
+      args: Array.isArray(rawArgs) ? rawArgs.filter((entry) => typeof entry === "string" || typeof entry === "number") : []
+    });
+    if ("error" in lowered) {
+      issues.push({
+        rule: "extension-attribute",
+        message: `Field "${model.__name}.${name}": ${lowered.error}`,
+        model: model.__name,
+        field: name
+      });
+      continue;
+    }
+    fields2.push(buildField({ name, column, extensionNativeType: lowered.nativeType }));
+    if (lowered.declaration !== undefined) {
+      declarations.add({
+        extension: registered.extension.name,
+        model: model.__name,
+        declaration: lowered.declaration
+      });
+    }
+  }
+  for (const use of model.__extensions ?? []) {
+    const registered = extensions.modelAttributes.get(use.attribute);
+    if (registered === undefined) {
+      issues.push({
+        rule: "unknown-attribute",
+        message: `Unknown block attribute "@@${use.attribute}" on model "${model.__name}" \u2014 no extension provides it`,
+        model: model.__name
+      });
+      continue;
+    }
+    const parsed = registered.attribute.parse({
+      model: model.__name,
+      args: {
+        named: { ...use.args ?? {} },
+        ...use.fields === undefined ? {} : { fields: use.fields }
+      },
+      fieldNames: fields2.map((field) => field.name)
+    });
+    if ("error" in parsed) {
+      issues.push({
+        rule: "extension-attribute",
+        message: `@@${use.attribute} on "${model.__name}": ${parsed.error}`,
+        model: model.__name
+      });
+      continue;
+    }
+    declarations.add({
+      extension: registered.extension.name,
+      model: model.__name,
+      declaration: parsed.declaration
+    });
+  }
+  return {
+    name: model.__name,
+    ...model.__map === undefined ? {} : { dbName: model.__map },
+    fields: fields2,
+    relations: (plan.relations.get(model.__name) ?? []).map((relation) => buildRelation({ relation, plan })),
+    indexes: (plan.indexes.get(model.__name) ?? []).map((index) => buildIndex({ index })),
+    ...primaryKey === undefined ? {} : { primaryKey },
+    isView: false
+  };
+}
+
+class ExtensionDeclarationCollector {
+  byExtension = new Map;
+  add(params) {
+    const perModel = this.byExtension.get(params.extension) ?? new Map;
+    this.byExtension.set(params.extension, perModel);
+    const existing = perModel.get(params.model) ?? {};
+    perModel.set(params.model, mergeExtensionDeclarations({ base: existing, next: params.declaration }));
+  }
+  toIR() {
+    return [...this.byExtension.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, perModel]) => ({
+      name,
+      options: {
+        models: Object.fromEntries([...perModel.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+      }
+    }));
+  }
+}
+function toIR(params) {
+  const { schema: schema2, provider = "postgresql" } = params;
+  const extensions = params.extensions ?? EMPTY_EXTENSION_REGISTRY;
+  const plan = planSchema({ schema: schema2 });
+  const declarations = new ExtensionDeclarationCollector;
+  const issues = [];
+  const models = Array.from(schema2.__models.values(), (model) => buildModel({ model, plan, extensions, declarations, issues }));
+  const enums = Array.from(schema2.__enums, ([name, values]) => ({
+    name,
+    values: [...values]
+  }));
+  if (issues.length > 0) {
+    throw new VibeError({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Schema validation failed with ${issues.length} issue(s): ${issues.map((issue) => issue.message).join("; ")}`,
+      meta: { issues }
+    });
+  }
+  const ir = {
+    datasource: { provider },
+    models,
+    enums,
+    extensions: declarations.toIR()
+  };
+  assertValidSchemaIR({ schema: ir });
+  return ir;
+}
+
+// packages/dsl/src/validate.ts
+function validateSchema(schema2) {
+  const errors = [];
+  const allNames = new Set;
+  for (const name of schema2.__models.keys()) {
+    if (allNames.has(name)) {
+      errors.push({
+        type: "error",
+        message: `Duplicate name "${name}" \u2014 used by more than one model`,
+        model: name
+      });
+    }
+    allNames.add(name);
+  }
+  for (const name of schema2.__enums.keys()) {
+    if (allNames.has(name)) {
+      errors.push({
+        type: "error",
+        message: `Duplicate name "${name}" \u2014 used by both a model and an enum`
+      });
+    }
+    allNames.add(name);
+  }
+  for (const [modelName, modelRelations] of Object.entries(schema2.__relations)) {
+    const model = schema2.__models.get(modelName);
+    if (model === undefined) {
+      errors.push({
+        type: "error",
+        message: `Relations defined for unknown model "${modelName}"`,
+        model: modelName
+      });
+      continue;
+    }
+    for (const [relationName, relation] of Object.entries(modelRelations)) {
+      const targetModel = schema2.__models.get(relation.__targetModel);
+      if (targetModel === undefined) {
+        errors.push({
+          type: "error",
+          message: `Relation "${relationName}" references unknown model "${relation.__targetModel}"`,
+          model: modelName,
+          relation: relationName
+        });
+        continue;
+      }
+      if (relation.__relationType === "one" && relation.__fromModel === modelName) {
+        if (!model.__columns.has(relation.__fromColumn)) {
+          errors.push({
+            type: "error",
+            message: `Relation "${relationName}" references FK column "${relation.__fromColumn}" which doesn't exist on model "${modelName}"`,
+            model: modelName,
+            relation: relationName
+          });
+        }
+        if (!targetModel.__columns.has(relation.__toColumn)) {
+          errors.push({
+            type: "error",
+            message: `Relation "${relationName}" references column "${relation.__toColumn}" which doesn't exist on target model "${relation.__targetModel}"`,
+            model: modelName,
+            relation: relationName
+          });
+        }
+      }
+      if (relation.__targetModel === modelName && relation.__alias === undefined) {
+        const otherSelfRelations = Object.values(modelRelations).filter((other) => other.__targetModel === modelName && other !== relation);
+        if (otherSelfRelations.length > 0) {
+          errors.push({
+            type: "warning",
+            message: `Self-referential relation "${relationName}" on "${modelName}" has no alias \u2014 this may cause Prisma ambiguity`,
+            model: modelName,
+            relation: relationName
+          });
+        }
+      }
+    }
+  }
+  for (const [modelName, model] of schema2.__models) {
+    const hasIdColumn = Array.from(model.__columns.values()).some((column) => column.__columnType === "id");
+    const hasPrimaryKey = model.__primaryKey !== undefined && model.__primaryKey.length > 0;
+    if (!hasIdColumn && !hasPrimaryKey) {
+      errors.push({
+        type: "warning",
+        message: `Model "${modelName}" has no id column and no compound primaryKey defined`,
+        model: modelName
+      });
+    }
+  }
+  return errors;
+}
+
+// packages/dsl/src/index.ts
+function isStandaloneEnumConfig(config) {
+  return "name" in config && typeof config.name === "string";
+}
+function enumFactory(config) {
+  if (isStandaloneEnumConfig(config)) {
+    return createEnum(config);
+  }
+  return enumCol(config);
+}
+var generate = Object.assign((schemaDef) => ({ prisma: generatePrisma(schemaDef) }), { prisma: generatePrisma });
+var dsl = {
+  string,
+  int,
+  bigint,
+  float,
+  decimal,
+  boolean,
+  datetime,
+  json,
+  id,
+  bytes,
+  unsupported,
+  extensionType,
+  enum: enumFactory,
+  create,
+  defineRelations,
+  defineRelationsPart,
+  mergeRelations,
+  schema,
+  domain,
+  toIR,
+  validateSchema,
+  generate,
+  templates
+};
+export {
+  withNameDescription,
+  withMetadata,
+  withExternalId,
+  withAudit,
+  withActive,
+  validateSchema,
+  toIR,
+  templates,
+  schema,
+  resolveRelationType,
+  planSchema,
+  mergeRelations,
+  getColumnNames,
+  generatePrisma,
+  fields,
+  evaluateIndexes,
+  dsl,
+  domain,
+  detectOneToOnePairs,
+  defineRelationsPart,
+  defineRelations,
+  createIndexBuilder,
+  createEnum,
+  createChildrenBuilder,
+  create,
+  cloneColumnDef,
+  children,
+  baseWithWorkspace,
+  base,
+  ChainableStringColumn,
+  ChainableIdColumn,
+  ChainableEnumColumn,
+  ChainableDecimalColumn,
+  ChainableDatetimeColumn,
+  ChainableColumn
+};
+
+//# debugId=536E52A51C12A18264756E2164756E21