@vibeorm/dsl 2.0.0-alpha.7 → 2.0.0

package/dist/index.js

@@ -8,7 +8,8 @@ function cloneColumnDef(params) {
     __name: column.__name,
     __config: { ...column.__config },
     __enumValues: column.__enumValues,
-    __enumName: column.__enumName
+    __enumName: column.__enumName,
+    __enumStorage: column.__enumStorage
   };
 }
 
@@ -19,6 +20,7 @@ class ChainableColumn {
   __name;
   __enumValues;
   __enumName;
+  __enumStorage;
   constructor(columnType, config = {}) {
     this.__columnType = columnType;
     this.__config = { ...config };
@@ -69,6 +71,10 @@ class ChainableStringColumn extends ChainableColumn {
     this.__config.text = true;
     return this;
   }
+  collation(name) {
+    this.__config.collation = name;
+    return this;
+  }
 }
 
 class ChainableDecimalColumn extends ChainableColumn {
@@ -119,6 +125,9 @@ class ChainableEnumColumn extends ChainableColumn {
     if (params.enumName !== undefined) {
       this.__enumName = params.enumName;
     }
+    if (params.storage !== undefined) {
+      this.__enumStorage = params.storage;
+    }
   }
   default(value) {
     this.__config.default = value;
@@ -128,8 +137,15 @@ class ChainableEnumColumn extends ChainableColumn {
 function string(config = {}) {
   return new ChainableStringColumn(config);
 }
+
+class ChainableIntegerColumn extends ChainableColumn {
+  autoincrement() {
+    this.__config.autoincrement = true;
+    return this;
+  }
+}
 function int(config = {}) {
-  return new ChainableColumn("int", config);
+  return new ChainableIntegerColumn("int", config);
 }
 function float(config = {}) {
   return new ChainableColumn("float", config);
@@ -164,7 +180,7 @@ function bytes(config = {}) {
   return new ChainableColumn("bytes", config);
 }
 function bigint(config = {}) {
-  return new ChainableColumn("bigint", config);
+  return new ChainableIntegerColumn("bigint", config);
 }
 function unsupported(dbType) {
   const config = { dbType };
@@ -180,25 +196,49 @@ function extensionType(config) {
   });
 }
 function enumCol(config) {
-  const { options, ...restConfig } = config;
-  return new ChainableEnumColumn({ options, config: restConfig });
+  const { options, storage, ...restConfig } = config;
+  return new ChainableEnumColumn({
+    options,
+    config: restConfig,
+    ...storage === undefined ? {} : { storage }
+  });
 }
 
 // packages/dsl/src/enum.ts
+function enumValuesOf(params) {
+  const entries = Object.fromEntries(params.options.map((option) => [option, option]));
+  return Object.freeze(entries);
+}
 function createEnum(config) {
-  const { name, options } = config;
+  const { name, options, storage = "database" } = config;
   return {
     __type: "enum",
     __name: name,
     __options: options,
+    __storage: storage,
+    values: enumValuesOf({ options }),
     field(fieldConfig = {}) {
-      return new ChainableEnumColumn({ options, config: fieldConfig, enumName: name });
+      return new ChainableEnumColumn({ options, config: fieldConfig, enumName: name, storage });
     }
   };
 }
 
 // packages/dsl/src/generator/prisma.ts
-import { internalError } from "@vibeorm/schema";
+import { VibeError as VibeError3, encodePrismaString, internalError } from "@vibeorm/schema";
+
+// packages/dsl/src/to-ir.ts
+import {
+  EMPTY_EXTENSION_REGISTRY,
+  VibeError as VibeError2,
+  assertValidSchemaIR,
+  exactIntegerLiteral,
+  scalarListDefault,
+  serializeJsonDefault,
+  mergeExtensionDeclarations
+} from "@vibeorm/schema";
+
+// packages/dsl/src/relation-plan.ts
+import { VibeError } from "@vibeorm/schema";
 
 // packages/dsl/src/naming.ts
 function capitalize(params) {
@@ -237,17 +277,18 @@ function isChildrenDef(value) {
   return typeof value === "object" && value !== null && "__type" in value && value.__type === "children";
 }
 function createIndexBuilder() {
-  const createIndex = (columns, type, where) => ({
+  const createIndex = (columns, type, where, map) => ({
     __type: "index",
     __columns: [...columns],
     __indexType: type,
+    ...map === undefined ? {} : { __map: map },
     ...where === undefined ? {} : { __where: where }
   });
   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, second.where);
+        return createIndex(first, second.type, second.where, second.map);
       }
       return createIndex(args);
     },
@@ -260,6 +301,7 @@ function createIndexBuilder() {
         return {
           __type: "unique",
           __columns: [...first],
+          ...second.map === undefined ? {} : { __map: second.map },
           ...second.where === undefined ? {} : { __where: second.where },
           ...second.nullsNotDistinct === true ? { __nullsNotDistinct: true } : {},
           ...second.name === undefined ? {} : { __clientName: second.name }
@@ -320,7 +362,9 @@ function create(config) {
     __map: config.map,
     __primaryKey: config.primaryKey,
     __checks: config.checks,
-    __extensions: config.extensions
+    __extensions: config.extensions,
+    __policy: config.policy,
+    __comment: config.comment
   };
 }
 function getColumnNames(params) {
@@ -341,6 +385,9 @@ function detectOneToOnePairs(params) {
   const allOnes = [];
   for (const [modelName, modelRelations] of Object.entries(relations)) {
     for (const [relName, rel] of Object.entries(modelRelations)) {
+      if (rel.__ownsForeignKey !== undefined && (typeof rel.__ownsForeignKey !== "boolean" || rel.__relationType !== "one" || rel.__ownsForeignKey && rel.__fromModel !== modelName)) {
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `Invalid foreign-key ownership declaration on ${modelName}.${relName}` });
+      }
       if (rel.__relationType === "one") {
         allOnes.push({ modelName, relName, rel });
       }
@@ -362,7 +409,7 @@ function detectOneToOnePairs(params) {
       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)
+      if (!sameColumnPair || (a.rel.__alias ?? "") !== (b.rel.__alias ?? ""))
         continue;
       const { fkOwner, backRelation } = resolveFkOwner({ a, b, models });
       const onDelete = fkOwner.rel.__onDelete ?? backRelation.rel.__onDelete;
@@ -392,21 +439,35 @@ function detectOneToOnePairs(params) {
 }
 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";
+  const ownershipError = () => {
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `Ambiguous foreign-key ownership between ${a.modelName}.${a.relName} and ${b.modelName}.${b.relName}; set ownsForeignKey: true on the foreign-key side`, meta: { rule: "ambiguous-foreign-key-owner" } });
+  };
+  const aOwns = a.rel.__ownsForeignKey;
+  const bOwns = b.rel.__ownsForeignKey;
+  if (aOwns !== undefined || bOwns !== undefined) {
+    if (aOwns === bOwns)
+      return ownershipError();
+    return aOwns === true || bOwns === false ? { fkOwner: a, backRelation: b } : { fkOwner: b, backRelation: a };
+  }
+  const aFromIsId = models.get(a.modelName)?.__columns.get(a.rel.__fromColumn)?.__columnType === "id" || models.get(a.modelName)?.__primaryKey?.includes(a.rel.__fromColumn) === true;
+  const bFromIsId = models.get(b.modelName)?.__columns.get(b.rel.__fromColumn)?.__columnType === "id" || models.get(b.modelName)?.__primaryKey?.includes(b.rel.__fromColumn) === true;
   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) {
+  const aActions = a.rel.__onDelete !== undefined || a.rel.__onUpdate !== undefined;
+  const bActions = b.rel.__onDelete !== undefined || b.rel.__onUpdate !== undefined;
+  if (aActions && !bActions) {
     return { fkOwner: a, backRelation: b };
   }
-  if (b.rel.__onDelete !== undefined || b.rel.__onUpdate !== undefined) {
+  if (bActions && !aActions) {
     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 };
+  if (aLooksFk === bLooksFk)
+    return ownershipError();
+  return aLooksFk ? { fkOwner: a, backRelation: b } : { fkOwner: b, backRelation: a };
 }
 function looksLikeForeignKey(params) {
   const { column } = params;
@@ -432,7 +493,7 @@ function planExplicitRelations(params) {
       planned.push({ ...base, kind: "backOne", isList: false, isOptional: true });
       continue;
     }
-    const ownsFk = mergeInfo?.role === "fkOwner" || rel.__fromModel === modelName;
+    const ownsFk = mergeInfo?.role === "fkOwner" || rel.__ownsForeignKey !== false && rel.__fromModel === modelName;
     if (!ownsFk) {
       planned.push({ ...base, kind: "backOne", isList: false, isOptional: rel.__optional });
       continue;
@@ -549,10 +610,13 @@ function planIndexes(params) {
         isUnique,
         columns: [...index.__columns],
         indexType: index.__indexType,
+        ...index.__map === undefined ? {} : { map: index.__map },
         ...index.__where === undefined ? {} : { where: index.__where },
         ...index.__nullsNotDistinct === true ? { nullsNotDistinct: true } : {},
         ...index.__clientName === undefined ? {} : { clientName: index.__clientName }
       });
+    } else if (index.__map !== undefined) {
+      byKey.set(key, { ...existing, map: index.__map, indexType: index.__indexType ?? existing.indexType });
     } else if (index.__indexType !== undefined && existing.indexType === undefined) {
       byKey.set(key, { ...existing, indexType: index.__indexType });
     }
@@ -606,815 +670,994 @@ function findCounterparts(params) {
   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) {
+// packages/dsl/src/to-ir.ts
+function fieldType(params) {
   const { column } = params;
-  const list = column.__config.array === true ? "[]" : "";
   switch (column.__columnType) {
     case "string":
-      return `String${list}`;
+      return "String";
     case "int":
-      return `Int${list}`;
+      return "Int";
     case "bigint":
-      return `BigInt${list}`;
+      return "BigInt";
     case "float":
-      return `Float${list}`;
+      return "Float";
     case "decimal":
-      return `Decimal${list}`;
+      return "Decimal";
     case "boolean":
-      return `Boolean${list}`;
+      return "Boolean";
     case "datetime":
-      return `DateTime${list}`;
+      return "DateTime";
     case "json":
-      return `Json${list}`;
+      return "Json";
     case "bytes":
-      return `Bytes${list}`;
+      return "Bytes";
     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}`;
-    }
+      return column.__enumName === undefined ? "String" : { enum: column.__enumName };
+    case "unsupported":
+      return "String";
   }
 }
-function idDefaultAttribute(params) {
-  const idType = params.column.__config.type;
-  switch (idType) {
+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 `@default(${idType}())`;
+      return { kind: "autoincrement" };
     default:
       return;
   }
 }
-function defaultAttribute(params) {
+function fieldDefault(params) {
   const { column } = params;
-  const { dbgenerated, default: value } = column.__config;
-  if (typeof dbgenerated === "string") {
-    return `@default(dbgenerated("${dbgenerated}"))`;
+  if (column.__columnType === "id") {
+    if (column.__config.default !== undefined || column.__config.dbgenerated !== undefined || column.__config.autoincrement !== undefined)
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "Use the id generator strategy instead of a conflicting id default" });
+    return idDefault({ column });
+  }
+  const { dbgenerated, default: value, autoincrement } = column.__config;
+  if ([dbgenerated !== undefined, value !== undefined, autoincrement === true].filter(Boolean).length > 1) {
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: `Column "${column.__name ?? column.__columnType}" has conflicting defaults` });
+  }
+  if (autoincrement === true) {
+    if (column.__columnType !== "int" && column.__columnType !== "bigint" || column.__config.array === true || column.__config.optional === true) {
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "autoincrement requires a required scalar Int or BigInt column" });
+    }
+    return { kind: "autoincrement" };
   }
+  if (typeof dbgenerated === "string")
+    return { kind: "dbgenerated", sql: dbgenerated };
   if (value === undefined)
     return;
-  if (column.__columnType === "datetime" && value === "now") {
-    return "@default(now())";
+  if (column.__config.array === true) {
+    if (!Array.isArray(value))
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "A scalar-list default must be an array" });
+    return { kind: "list", values: scalarListDefault({ type: fieldType({ column }), values: column.__columnType === "json" ? value.map((entry) => typeof entry === "string" ? entry : serializeJsonDefault({ value: entry })) : value }) };
+  }
+  if (column.__columnType === "json" && typeof value !== "string") {
+    return { kind: "literal", value: serializeJsonDefault({ value }) };
   }
+  if (column.__columnType === "datetime" && value === "now")
+    return { kind: "now" };
   if (column.__columnType === "enum" && typeof value === "string") {
-    return `@default(${value})`;
+    return { kind: "enumValue", value };
+  }
+  if (typeof value === "number" && (!Number.isFinite(value) || (column.__columnType === "int" || column.__columnType === "bigint") && !Number.isSafeInteger(value))) {
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "Numeric defaults must be finite; integer defaults must be exact" });
+  }
+  if (typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+    return { kind: "literal", 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;
+    return { kind: "literal", value: exactIntegerLiteral({ text: value.toString() }) };
+  throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
 }
-function nativeTypeAttribute(params) {
+function nativeType(params) {
   const { column } = params;
-  if (column.__columnType === "string") {
+  if (column.__columnType === "enum") {
+    const { maxLength, text } = column.__config;
+    if (maxLength !== undefined || text !== undefined) {
+      const invalid = column.__enumStorage !== "string" || maxLength !== undefined && (typeof maxLength !== "number" || !Number.isSafeInteger(maxLength) || maxLength <= 0) || text !== undefined && typeof text !== "boolean" || text === true && maxLength !== undefined;
+      if (invalid) {
+        throw new VibeError2({
+          code: "VIBE_SCHEMA_INVALID",
+          message: "Enum text/maxLength options require string storage and either a positive integer maxLength or text: true, not both",
+          meta: { issues: [{ rule: "enum-string-storage-options", enum: column.__enumName }] }
+        });
+      }
+    }
+  }
+  if (column.__columnType === "string" || column.__columnType === "enum" && column.__enumStorage === "string") {
     const { maxLength, text } = column.__config;
     if (typeof maxLength === "number")
-      return `@db.VarChar(${maxLength})`;
+      return `VarChar(${maxLength})`;
     if (text === true)
-      return "@db.Text";
+      return "Text";
     return;
   }
   if (column.__columnType === "decimal") {
     const { precision, scale } = column.__config;
     if (typeof precision === "number")
-      return `@db.Decimal(${precision}, ${scale ?? 0})`;
+      return `Decimal(${precision}, ${scale ?? 0})`;
     return;
   }
   if (column.__columnType === "datetime" && column.__config.tz === true) {
-    return "@db.Timestamptz";
+    return "Timestamptz";
+  }
+  if (column.__columnType === "unsupported") {
+    return String(column.__config.dbType);
   }
   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 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 collation = typeof config.collation === "string" ? config.collation : 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,
+    ...collation === undefined ? {} : { collation },
+    ...dbName === undefined ? {} : { dbName },
+    ...defaultValue === undefined ? {} : { default: defaultValue },
+    ...native === undefined ? {} : { nativeType: native },
+    ...column.__columnType === "unsupported" ? { isUnsupported: true } : {},
+    ...documentation === undefined ? {} : { documentation }
+  };
 }
-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 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 }
+  };
 }
-function formatIndex(params) {
+var INDEX_KINDS = {
+  BTree: "btree",
+  Hash: "hash",
+  Gin: "gin",
+  Gist: "gist",
+  SpGist: "spgist",
+  Brin: "brin"
+};
+function buildIndex(params) {
   const { index } = params;
-  const columns = index.columns.join(", ");
-  const whereArg = index.where === undefined ? "" : `, where: ${JSON.stringify(index.where)}`;
-  const nndArg = index.nullsNotDistinct === true ? ", nullsNotDistinct: true" : "";
-  const nameArg = index.clientName === undefined ? "" : `, name: ${JSON.stringify(index.clientName)}`;
-  if (index.isUnique) {
-    return `  @@unique([${columns}]${nameArg}${nndArg}${whereArg})`;
-  }
-  const typeArg = index.indexType === undefined ? "" : `, type: ${index.indexType}`;
-  return `  @@index([${columns}]${typeArg}${whereArg})`;
-}
-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);
+  const kind = index.isUnique ? "unique" : index.indexType === undefined ? "btree" : INDEX_KINDS[index.indexType];
+  return {
+    kind,
+    fields: index.columns.map((name) => ({ name })),
+    ...index.map === undefined ? {} : { name: index.map },
+    ...index.where === undefined ? {} : { where: index.where },
+    ...index.nullsNotDistinct === true ? { nullsNotDistinct: true } : {},
+    ...index.clientName === undefined ? {} : { clientName: index.clientName }
+  };
 }
-function formatModel(params) {
-  const { model, plan } = params;
-  const lines = [`model ${model.__name} {`];
-  lines.push("  //> Columns");
+function buildModel(params) {
+  const { model, plan, extensions, declarations, issues } = params;
+  const primaryKey = model.__primaryKey !== undefined && model.__primaryKey.length > 0 ? { fields: [...model.__primaryKey] } : undefined;
+  const policy = model.__policy === undefined ? undefined : { field: model.__policy.field, context: model.__policy.context ?? model.__policy.field };
+  const fields = [];
   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 check of model.__checks ?? []) {
-    lines.push(`  @@check(${JSON.stringify(check.expression)}, name: ${JSON.stringify(check.name)})`);
-  }
-  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 })}`);
+    const extensionTypeName = column.__config["extensionType"];
+    if (typeof extensionTypeName !== "string") {
+      fields.push(buildField({ name, column }));
+      continue;
     }
-    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;
+    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;
     }
-    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 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") : []
     });
-    const model = models[modelName];
-    if (model === undefined)
+    if ("error" in lowered) {
+      issues.push({
+        rule: "extension-attribute",
+        message: `Field "${model.__name}.${name}": ${lowered.error}`,
+        model: model.__name,
+        field: name
+      });
       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 });
+    fields.push(buildField({ name, column, extensionNativeType: lowered.nativeType }));
+    if (lowered.declaration !== undefined) {
+      declarations.add({
+        extension: registered.extension.name,
+        model: model.__name,
+        declaration: lowered.declaration
+      });
     }
   }
-}
-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;
+  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: fields.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 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 });
+  return {
+    name: model.__name,
+    ...model.__map === undefined ? {} : { dbName: model.__map },
+    fields,
+    relations: (plan.relations.get(model.__name) ?? []).map((relation) => buildRelation({ relation, plan })),
+    indexes: (plan.indexes.get(model.__name) ?? []).map((index) => buildIndex({ index })),
+    ...model.__checks === undefined || model.__checks.length === 0 ? {} : { checks: model.__checks.map((check) => ({ name: check.name, expression: check.expression })) },
+    ...policy === undefined ? {} : { policy },
+    ...primaryKey === undefined ? {} : { primaryKey },
+    isView: false,
+    ...model.__comment === undefined ? {} : { documentation: model.__comment }
+  };
+}
+
+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 }));
   }
-};
-var withExternalId = {
-  get externalId() {
-    return string({ index: true });
+  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))
+      }
+    }));
   }
-};
-var withNameDescription = {
-  get name() {
-    return string();
-  },
-  get description() {
-    return string({ optional: true });
+}
+function toIR(params) {
+  const { schema, provider = "postgresql" } = params;
+  const extensions = params.extensions ?? EMPTY_EXTENSION_REGISTRY;
+  const plan = planSchema({ schema });
+  const declarations = new ExtensionDeclarationCollector;
+  const issues = [];
+  const models = Array.from(schema.__models.values(), (model) => {
+    const built = buildModel({ model, plan, extensions, declarations, issues });
+    const rls = schema.__rls?.policies[model.__name];
+    return rls === undefined ? built : { ...built, rls };
+  });
+  if (schema.__rls !== undefined) {
+    for (const name of Object.keys(schema.__rls.policies)) {
+      if (!schema.__models.has(name)) {
+        issues.push({ rule: "rls-unknown-model", model: name, message: `RLS classification references model "${name}" absent from the composed schema` });
+      }
+    }
   }
-};
-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 });
+  const enums = Array.from(schema.__enums, ([name, values]) => ({
+    name,
+    values: [...values],
+    ...schema.__enumStorage.get(name) === "string" ? { storage: "string" } : {}
+  }));
+  if (issues.length > 0) {
+    throw new VibeError2({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Schema validation failed with ${issues.length} issue(s): ${issues.map((issue) => issue.message).join("; ")}`,
+      meta: { issues }
+    });
   }
-};
-var templates = {
-  base,
-  baseWithWorkspace,
-  withMetadata,
-  withActive,
-  withAudit,
-  withExternalId,
-  withNameDescription,
-  fields
-};
+  const ir = {
+    datasource: { provider },
+    models,
+    enums,
+    extensions: declarations.toIR(),
+    ...schema.__rls === undefined ? {} : { rls: { context: schema.__rls.context } }
+  };
+  assertValidSchemaIR({ schema: ir });
+  return ir;
+}
 
-// packages/dsl/src/to-ir.ts
-import {
-  EMPTY_EXTENSION_REGISTRY,
-  VibeError,
-  assertValidSchemaIR,
-  mergeExtensionDeclarations
-} from "@vibeorm/schema";
-function fieldType(params) {
+// 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";
+      return `String${list}`;
     case "int":
-      return "Int";
+      return `Int${list}`;
     case "bigint":
-      return "BigInt";
+      return `BigInt${list}`;
     case "float":
-      return "Float";
+      return `Float${list}`;
     case "decimal":
-      return "Decimal";
+      return `Decimal${list}`;
     case "boolean":
-      return "Boolean";
+      return `Boolean${list}`;
     case "datetime":
-      return "DateTime";
+      return `DateTime${list}`;
     case "json":
-      return "Json";
+      return `Json${list}`;
     case "bytes":
-      return "Bytes";
+      return `Bytes${list}`;
     case "id":
       return column.__config.type === "autoincrement" ? "Int" : "String";
     case "enum":
-      return column.__enumName === undefined ? "String" : { enum: column.__enumName };
-    case "unsupported":
-      return "String";
+      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(${encodePrismaString({ value: String(column.__config.dbType) })})${list}`;
+    }
   }
 }
-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 defaultAttribute(params) {
+  const { column } = params;
+  const value = fieldDefault({ column });
+  if (value === undefined)
+    return;
+  if (value.kind === "list") {
+    const values = value.values.map((entry) => column.__columnType === "enum" ? String(entry) : column.__columnType === "bigint" ? String(entry) : JSON.stringify(entry));
+    return `@default([${values.join(", ")}])`;
+  }
+  if (value.kind === "literal")
+    return `@default(${typeof value.value === "string" ? encodePrismaString({ value: value.value }) : String(value.value)})`;
+  if (value.kind === "enumValue")
+    return `@default(${value.value})`;
+  if (value.kind === "dbgenerated")
+    return `@default(dbgenerated(${encodePrismaString({ value: value.sql })}))`;
+  return `@default(${value.kind}())`;
+}
+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 idDefault2 = defaultAttribute({ column });
+    if (idDefault2 !== undefined)
+      parts.push(idDefault2);
+  } 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(${encodePrismaString({ value: column.__config.map })})`);
+  }
+  const nativeType2 = nativeTypeAttribute({ column });
+  if (nativeType2 !== undefined)
+    parts.push(nativeType2);
+  if (typeof column.__config.collation === "string") {
+    parts.push(`@collation(${encodePrismaString({ value: column.__config.collation })})`);
+  }
+  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(${encodePrismaString({ value: relationName })})`;
+    return `  ${name} ${targetModel}[]${attribute}`;
+  }
+  const optional = relation.isOptional ? "?" : "";
+  if (relation.kind === "backOne") {
+    const attribute = relationName === undefined ? "" : ` @relation(${encodePrismaString({ value: relationName })})`;
+    return `  ${name} ${targetModel}${optional}${attribute}`;
+  }
+  const args = [];
+  if (relationName !== undefined)
+    args.push(encodePrismaString({ value: 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(", ");
+  const whereArg = index.where === undefined ? "" : `, where: ${encodePrismaString({ value: index.where })}`;
+  const mapArg = index.map === undefined ? "" : `, map: ${encodePrismaString({ value: index.map })}`;
+  const nndArg = index.nullsNotDistinct === true ? ", nullsNotDistinct: true" : "";
+  const nameArg = index.clientName === undefined ? "" : `, name: ${encodePrismaString({ value: index.clientName })}`;
+  if (index.isUnique) {
+    return `  @@unique([${columns}]${nameArg}${mapArg}${nndArg}${whereArg})`;
+  }
+  const typeArg = index.indexType === undefined ? "" : `, type: ${index.indexType}`;
+  return `  @@index([${columns}]${typeArg}${mapArg}${whereArg})`;
+}
+function formatExtensionValue(params) {
+  const { value } = params;
+  if (typeof value === "string")
+    return encodePrismaString({ value });
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => formatExtensionValue({ value: entry })).join(", ")}]`;
   }
+  return String(value);
 }
-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 };
+function formatModel(params) {
+  const { model, plan } = params;
+  const lines = [
+    ...model.__comment === undefined ? [] : model.__comment.split(`
+`).map((line) => `/// ${line}`),
+    `model ${model.__name} {`
+  ];
+  lines.push("  //> Columns");
+  for (const [name, column] of model.__columns) {
+    lines.push(formatColumn({ name, column }));
   }
-  if (typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
-    return { kind: "literal", value };
+  lines.push("");
+  lines.push("  //> Relations");
+  for (const relation of plan.relations.get(model.__name) ?? []) {
+    lines.push(formatRelation({ relation }));
   }
-  if (typeof value === "bigint")
-    return { kind: "literal", value: Number(value) };
-  return;
+  lines.push("");
+  lines.push("  //> Indexes");
+  lines.push("");
+  for (const index of plan.indexes.get(model.__name) ?? []) {
+    lines.push(formatIndex({ index }));
+  }
+  for (const check of model.__checks ?? []) {
+    lines.push(`  @@check(${encodePrismaString({ value: check.expression })}, name: ${encodePrismaString({ value: check.name })})`);
+  }
+  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 (model.__policy !== undefined) {
+    const { field, context } = model.__policy;
+    const contextArg = context === undefined || context === field ? "" : `, context: ${encodePrismaString({ value: context })}`;
+    lines.push(`  @@policy([${field}]${contextArg})`);
+  }
+  if (typeof model.__map === "string") {
+    lines.push(`  @@map(${encodePrismaString({ value: model.__map })})`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
 }
-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;
+function formatEnum(params) {
+  const { name, values } = params;
+  return [`enum ${name} {`, ...values.map((value) => `  ${value}`), "}"].join(`
+`);
+}
+function generatePrisma(schema, _config = {}) {
+  const stringEnums = [...schema.__enumStorage].filter(([, storage]) => storage === "string").map(([name]) => name);
+  if (stringEnums.length > 0) {
+    throw new VibeError3({
+      code: "VIBE_CONFIG",
+      message: `Cannot print to Prisma: enum(s) ${stringEnums.join(", ")} use storage: "string", which .prisma cannot express losslessly. Keep the DSL as the source or switch the enum to database storage.`,
+      meta: { enums: stringEnums, target: "prisma" }
+    });
   }
-  if (column.__columnType === "decimal") {
-    const { precision, scale } = column.__config;
-    if (typeof precision === "number")
-      return `Decimal(${precision}, ${scale ?? 0})`;
-    return;
+  if (schema.__rls !== undefined) {
+    throw new VibeError3({
+      code: "VIBE_CONFIG",
+      message: "Cannot print to Prisma: this schema uses native RLS, which .prisma cannot express losslessly. Keep the DSL as the source.",
+      meta: { feature: "nativeRowLevelSecurity", target: "prisma" }
+    });
   }
-  if (column.__columnType === "datetime" && column.__config.tz === true) {
-    return "Timestamptz";
+  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("");
+    }
   }
-  if (column.__columnType === "unsupported") {
-    return String(column.__config.dbType);
+  sections.push("// ============================================");
+  sections.push("// Models");
+  sections.push("// ============================================");
+  sections.push("");
+  for (const model of schema.__models.values()) {
+    sections.push(formatModel({ model, plan }));
+    sections.push("");
   }
-  return;
+  return sections.join(`
+`).trim();
 }
-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 });
+
+// packages/dsl/src/relations.ts
+function createColumnRef(params) {
+  const { model, column } = params;
   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 }
+    __type: "columnRef",
+    __model: model,
+    __column: column,
+    through(junction) {
+      return {
+        __type: "throughRef",
+        __model: model,
+        __column: column,
+        __junction: junction.__model,
+        __junctionColumn: junction.__column
+      };
+    }
   };
 }
-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 }
-  };
+function extractRefInfo(params) {
+  const { ref } = params;
+  return { model: ref.__model, column: ref.__column };
 }
-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 })),
-    ...index.where === undefined ? {} : { where: index.where },
-    ...index.nullsNotDistinct === true ? { nullsNotDistinct: true } : {},
-    ...index.clientName === undefined ? {} : { clientName: index.clientName }
+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,
+      ..."ownsForeignKey" in config ? { __ownsForeignKey: config.ownsForeignKey } : {},
+      __onDelete: config.onDelete,
+      __onUpdate: config.onUpdate
+    };
   };
 }
-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 }));
+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 };
     }
-    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;
+  }
+  return result;
+}
+
+// packages/dsl/src/schema.ts
+import { VibeError as VibeError4, validateRlsContextIR } from "@vibeorm/schema";
+function sameValues(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function registerEnum(params) {
+  const { registry, name, entry, origin } = params;
+  const existing = registry.get(name);
+  if (existing === undefined) {
+    registry.set(name, entry);
+    return;
+  }
+  const valuesDiffer = !sameValues(existing.values, entry.values);
+  const storageDiffers = existing.storage !== entry.storage;
+  if (!valuesDiffer && !storageDiffers)
+    return;
+  const detail = [
+    ...valuesDiffer ? [`values [${existing.values.join(", ")}] vs [${entry.values.join(", ")}]`] : [],
+    ...storageDiffers ? [`storage "${existing.storage}" vs "${entry.storage}"`] : []
+  ].join("; ");
+  throw new VibeError4({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `Enum "${name}" is defined more than once with conflicting definitions (${origin}): ${detail} \u2014 share one enum object across modules, or give the definitions different names`,
+    meta: {
+      issues: [
+        {
+          rule: "enum-conflict",
+          message: `Enum "${name}" reused with conflicting ${valuesDiffer ? "values" : "storage"} (${origin})`
+        }
+      ],
+      enum: name,
+      existing,
+      incoming: entry
     }
-    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") : []
+  });
+}
+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, origin } = params;
+  const existing = models.get(model.__name);
+  if (existing !== undefined && existing !== model) {
+    throw new VibeError4({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Model "${model.__name}" is defined more than once with different definitions (${origin}) \u2014 ` + `share one model object across modules, or give the definitions different names`,
+      meta: {
+        issues: [
+          {
+            rule: "model-conflict",
+            message: `Model "${model.__name}" reused with a different definition (${origin})`,
+            model: model.__name
+          }
+        ],
+        model: model.__name
+      }
     });
-    if ("error" in lowered) {
-      issues.push({
-        rule: "extension-attribute",
-        message: `Field "${model.__name}.${name}": ${lowered.error}`,
-        model: model.__name,
-        field: name
+  }
+  models.set(model.__name, model);
+  for (const childModel of model.__children.values()) {
+    addModelTree({ model: childModel, models, origin: `inline child of ${model.__name}` });
+  }
+}
+function extractModelsAndEnums(params) {
+  const { input, models, enums } = params;
+  for (const value of Object.values(input)) {
+    if (isModelDef(value)) {
+      addModelTree({ model: value, models, origin: "listed in dsl.schema()" });
+    } else if (isEnumDef(value)) {
+      registerEnum({
+        registry: enums,
+        name: value.__name,
+        entry: { values: value.__options, storage: value.__storage },
+        origin: "standalone enum listed in dsl.schema()"
       });
-      continue;
+    } else if (typeof value === "object" && value !== null) {
+      extractModelsAndEnums({ input: value, models, enums });
     }
-    fields2.push(buildField({ name, column, extensionNativeType: lowered.nativeType }));
-    if (lowered.declaration !== undefined) {
-      declarations.add({
-        extension: registered.extension.name,
-        model: model.__name,
-        declaration: lowered.declaration
+  }
+}
+function resolveEnums(params) {
+  const { models, enums } = params;
+  for (const [modelName, model] of models) {
+    for (const [columnName, column] of model.__columns) {
+      if (column.__columnType !== "enum" || column.__enumValues === undefined)
+        continue;
+      const entry = {
+        values: column.__enumValues,
+        storage: column.__enumStorage ?? "database"
+      };
+      if (column.__enumName !== undefined) {
+        registerEnum({
+          registry: enums,
+          name: column.__enumName,
+          entry,
+          origin: `standalone enum used by ${modelName}.${columnName}`
+        });
+        continue;
+      }
+      const name = inlineEnumName({ modelName, columnName });
+      registerEnum({
+        registry: enums,
+        name,
+        entry,
+        origin: `inline enum on ${modelName}.${columnName}, named ${name}`
       });
+      column.__enumName = name;
     }
   }
-  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;
+}
+var RLS_CONTEXT_TYPES = {
+  string: "String",
+  boolean: "Boolean",
+  int: "Int",
+  bigint: "BigInt",
+  float: "Float",
+  decimal: "Decimal",
+  datetime: "DateTime"
+};
+function defineRls(params) {
+  if (typeof params.context !== "object" || params.context === null || Array.isArray(params.context)) {
+    throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "RLS context must be a record of scalar declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
+  }
+  const entries = [];
+  const refs = [];
+  for (const key of Reflect.ownKeys(params.context)) {
+    const descriptor = Object.getOwnPropertyDescriptor(params.context, key);
+    const column = descriptor?.value;
+    if (typeof key !== "string" || descriptor?.enumerable !== true || typeof column !== "object" || column === null || !("__columnType" in column) || !("__config" in column) || typeof column.__config !== "object" || column.__config === null || typeof column.__columnType !== "string" || !Object.hasOwn(RLS_CONTEXT_TYPES, column.__columnType) || "array" in column.__config && column.__config.array === true) {
+      throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "RLS context slots must be named scalar column declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
     }
-    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;
+    entries.push([key, { type: RLS_CONTEXT_TYPES[column.__columnType], nullable: "optional" in column.__config && column.__config.optional === true }]);
+    refs.push([key, Object.freeze({ context: key })]);
+  }
+  const context = Object.freeze(Object.fromEntries(entries));
+  const issues = validateRlsContextIR({ context });
+  if (issues.length > 0) {
+    throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Invalid RLS context declaration", meta: { issues } });
+  }
+  const policies = params.policies({ context: Object.freeze(Object.fromEntries(refs)) });
+  if (typeof policies !== "object" || policies === null || Array.isArray(policies)) {
+    throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be a record of model classifications", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
+  }
+  const named = [];
+  const classified = new Set;
+  for (const key of Reflect.ownKeys(policies)) {
+    const descriptor = Object.getOwnPropertyDescriptor(policies, key);
+    if (typeof key !== "string" || descriptor?.enumerable !== true || !("value" in descriptor)) {
+      throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be named data properties", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
     }
-    declarations.add({
-      extension: registered.extension.name,
-      model: model.__name,
-      declaration: parsed.declaration
-    });
+    const name = params.models[key]?.__name ?? key;
+    if (classified.has(name)) {
+      throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `RLS classifies model "${name}" more than once`, meta: { issues: [{ rule: "rls-duplicate-classification", model: name }] } });
+    }
+    classified.add(name);
+    named.push([name, descriptor.value]);
   }
+  return { context, policies: Object.fromEntries(named) };
+}
+function schema(input, options) {
+  const models = new Map;
+  const enums = new Map;
+  extractModelsAndEnums({ input, models, enums });
+  resolveEnums({ models, enums });
   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 })),
-    ...model.__checks === undefined || model.__checks.length === 0 ? {} : { checks: model.__checks.map((check) => ({ name: check.name, expression: check.expression })) },
-    ...primaryKey === undefined ? {} : { primaryKey },
-    isView: false
+    __type: "schema",
+    __models: models,
+    __enums: new Map(Array.from(enums, ([name, entry]) => [name, entry.values])),
+    __enumStorage: new Map(Array.from(enums, ([name, entry]) => [name, entry.storage])),
+    __relations: options?.relations ?? {},
+    ...options?.rls === undefined ? {} : { __rls: options.rls }
   };
 }
+function domain(params) {
+  const { name, models } = params;
+  return { name, models };
+}
 
-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 }));
+// 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 });
   }
-  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))
-      }
-    }));
+};
+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 });
   }
-}
-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 }
-    });
+};
+var withMetadata = {
+  get metadata() {
+    return json({ optional: true });
+  },
+  get settings() {
+    return json({ optional: true });
   }
-  const ir = {
-    datasource: { provider },
-    models,
-    enums,
-    extensions: declarations.toIR()
-  };
-  assertValidSchemaIR({ schema: ir });
-  return ir;
-}
+};
+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/validate.ts
 function validateSchema(schema2) {
@@ -1534,6 +1777,7 @@ var dsl = {
   defineRelations,
   defineRelationsPart,
   mergeRelations,
+  defineRls,
   schema,
   domain,
   toIR,
@@ -1561,6 +1805,7 @@ export {
   dsl,
   domain,
   detectOneToOnePairs,
+  defineRls,
   defineRelationsPart,
   defineRelations,
   createIndexBuilder,
@@ -1572,6 +1817,7 @@ export {
   baseWithWorkspace,
   base,
   ChainableStringColumn,
+  ChainableIntegerColumn,
   ChainableIdColumn,
   ChainableEnumColumn,
   ChainableDecimalColumn,
@@ -1579,4 +1825,4 @@ export {
   ChainableColumn
 };
 
-//# debugId=EB3F790CB1F4BD1C64756E2164756E21
+//# debugId=88D4E8D0B695042E64756E2164756E21