@vibeorm/dsl 2.0.0 → 2.1.0

package/dist/index.js

@@ -224,21 +224,224 @@ function createEnum(config) {
 }
 
 // packages/dsl/src/generator/prisma.ts
-import { VibeError as VibeError3, encodePrismaString, internalError } from "@vibeorm/schema";
+import { VibeError as VibeError5, encodePrismaString, internalError, providerToDialect as providerToDialect2 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect2 } from "@vibeorm/sql";
+
+// packages/dsl/src/predicate.ts
+import { VibeError } from "@vibeorm/schema";
+import { compileExclusion, renderPredicate } from "@vibeorm/sql";
+function isFieldExpr(operand) {
+  return typeof operand === "object" && operand !== null && "kind" in operand && operand.kind === "field";
+}
+function toRef(params) {
+  return { kind: "field", name: params.expr.name };
+}
+function toValue(params) {
+  const { input, at } = params;
+  if (typeof input === "bigint")
+    return { kind: "value", value: input.toString() };
+  if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+    return { kind: "value", value: input };
+  }
+  throw new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `${at}: ${input === null ? "null" : typeof input} is not a comparable literal \u2014 use isNull()/isNotNull() for null, and a string, number, bigint or boolean otherwise`,
+    meta: { rule: "predicate-literal-invalid", at }
+  });
+}
+function toOperand(params) {
+  const { operand, at } = params;
+  return isFieldExpr(operand) ? toRef({ expr: operand }) : toValue({ input: operand, at });
+}
+function requireFieldExpr(params) {
+  const { value, at } = params;
+  if (isFieldExpr(value))
+    return value;
+  throw new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `${at}: the left side of a comparison must be c.field("\u2026"), not a bare value`,
+    meta: { rule: "predicate-operand-invalid", at }
+  });
+}
+function requireOperands(params) {
+  const { operands, at } = params;
+  if (operands.length === 0) {
+    throw new VibeError({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `${at}: an empty boolean group has no honest SQL spelling \u2014 pass at least one operand`,
+      meta: { rule: "predicate-empty", at }
+    });
+  }
+  return operands;
+}
+function createPredicateBuilder() {
+  const compare = (op) => (left, right) => ({
+    kind: "compare",
+    op,
+    left: toRef({ expr: requireFieldExpr({ value: left, at: `c.${op}()` }) }),
+    right: toOperand({ operand: right, at: `c.${op}()` })
+  });
+  const membership = (negate) => (field, values) => {
+    const at = negate ? "c.notInList()" : "c.inList()";
+    const ref = toRef({ expr: requireFieldExpr({ value: field, at }) });
+    if (values.length === 0) {
+      throw new VibeError({
+        code: "VIBE_SCHEMA_INVALID",
+        message: `${at}: an empty IN list is UNKNOWN on every row and is never what an author means`,
+        meta: { rule: "predicate-empty", at, field: ref.name }
+      });
+    }
+    return {
+      kind: "inList",
+      field: ref,
+      values: values.map((value) => toValue({ input: value, at })),
+      ...negate ? { negate: true } : {}
+    };
+  };
+  return {
+    field: (name) => ({ kind: "field", name, __kind: "String" }),
+    eq: compare("eq"),
+    ne: compare("ne"),
+    gt: compare("gt"),
+    gte: compare("gte"),
+    lt: compare("lt"),
+    lte: compare("lte"),
+    inList: membership(false),
+    notInList: membership(true),
+    isNull: (name) => ({ kind: "isNull", field: { kind: "field", name } }),
+    isNotNull: (name) => ({ kind: "isNull", field: { kind: "field", name }, negate: true }),
+    and: (...operands) => ({ kind: "and", operands: requireOperands({ operands, at: "c.and()" }) }),
+    or: (...operands) => ({ kind: "or", operands: requireOperands({ operands, at: "c.or()" }) }),
+    not: (operand) => ({ kind: "not", operand }),
+    named: (name, predicate) => {
+      if (name.trim() === "") {
+        throw new VibeError({
+          code: "VIBE_SCHEMA_INVALID",
+          message: "c.named(): a CHECK needs a non-empty name \u2014 the name is what keys the migration diff",
+          meta: { rule: "predicate-unnamed-check" }
+        });
+      }
+      return { __type: "check", name, predicate };
+    }
+  };
+}
+function evaluateChecks(params) {
+  const { checks, model } = params;
+  if (checks === undefined)
+    return [];
+  if (typeof checks !== "function") {
+    return checks.map((check) => ({ kind: "raw", name: check.name, expression: check.expression }));
+  }
+  const declared = checks(createPredicateBuilder());
+  return declared.map((entry, index) => {
+    if (entry === null || typeof entry !== "object" || entry.__type !== "check") {
+      throw new VibeError({
+        code: "VIBE_SCHEMA_INVALID",
+        message: `Model "${model}": checks[${index}] is not a named CHECK \u2014 wrap the expression in c.named("name", \u2026)`,
+        meta: { rule: "predicate-unnamed-check", model, index }
+      });
+    }
+    return { kind: "typed", name: entry.name, predicate: entry.predicate };
+  });
+}
+function compileExclusions(params) {
+  const specs = typeof params.exclusions === "function" ? params.exclusions(createPredicateBuilder()) : params.exclusions ?? [];
+  return specs.map((exclusion) => compileExclusion({ exclusion, model: params.model, dialect: params.dialect }));
+}
+function compileChecks(params) {
+  const { checks, model, dialect, enums } = params;
+  return evaluateChecks({ checks, model: model.name }).map((check) => check.kind === "raw" ? { name: check.name, expression: check.expression } : {
+    name: check.name,
+    expression: renderPredicate({
+      predicate: check.predicate,
+      model,
+      dialect,
+      enums,
+      usage: "check",
+      site: `CHECK "${check.name}"`
+    }),
+    predicate: check.predicate
+  });
+}
+function compileIndexPredicate(params) {
+  const { where, wherePredicate, columns, model, dialect, enums } = params;
+  if (where !== undefined && wherePredicate !== undefined) {
+    throw new VibeError({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Index on "${model.name}" [${columns.join(", ")}] carries both a raw where: string and a typed .where() \u2014 an index has ONE predicate`,
+      meta: { rule: "predicate-duplicate-where", model: model.name, columns: [...columns] }
+    });
+  }
+  if (where !== undefined)
+    return { where };
+  if (wherePredicate === undefined)
+    return;
+  return {
+    where: renderPredicate({
+      predicate: wherePredicate,
+      model,
+      dialect,
+      enums,
+      usage: "indexPredicate",
+      site: `partial index on [${columns.join(", ")}]`
+    }),
+    wherePredicate
+  };
+}
 
 // packages/dsl/src/to-ir.ts
 import {
   EMPTY_EXTENSION_REGISTRY,
-  VibeError as VibeError2,
+  VibeError as VibeError4,
   assertValidSchemaIR,
   exactIntegerLiteral,
+  providerToDialect,
   scalarListDefault,
   serializeJsonDefault,
   mergeExtensionDeclarations
 } from "@vibeorm/schema";
+import { getSqlDialect } from "@vibeorm/sql";
+
+// packages/dsl/src/field-type.ts
+import { fieldTypeIdentity } from "@vibeorm/schema";
+function columnFieldType(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 fieldTypeKey(params) {
+  return fieldTypeIdentity({ type: columnFieldType({ column: params.column }) });
+}
 
 // packages/dsl/src/relation-plan.ts
-import { VibeError } from "@vibeorm/schema";
+import { VibeError as VibeError3, predicateKey } from "@vibeorm/schema";
+
+// packages/dsl/src/model.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
 
 // packages/dsl/src/naming.ts
 function capitalize(params) {
@@ -277,6 +480,24 @@ function isChildrenDef(value) {
   return typeof value === "object" && value !== null && "__type" in value && value.__type === "children";
 }
 function createIndexBuilder() {
+  const partial = (index) => {
+    const where = (predicate) => {
+      if (index.__where !== undefined) {
+        throw new VibeError2({
+          code: "VIBE_SCHEMA_INVALID",
+          message: `Index on [${index.__columns.join(", ")}] already carries a raw where: predicate \u2014 an index has ONE predicate, so use either the raw string or .where(), not both`,
+          meta: { rule: "predicate-duplicate-where", columns: [...index.__columns] }
+        });
+      }
+      return { ...index, __wherePredicate: predicate(createPredicateBuilder()) };
+    };
+    return Object.defineProperty({ ...index }, "where", {
+      value: where,
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  };
   const createIndex = (columns, type, where, map) => ({
     __type: "index",
     __columns: [...columns],
@@ -288,38 +509,38 @@ function createIndexBuilder() {
     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, second.map);
+        return partial(createIndex(first, second.type, second.where, second.map));
       }
-      return createIndex(args);
+      return partial(createIndex(args));
     },
     index(...columns) {
-      return createIndex(columns);
+      return partial(createIndex(columns));
     },
     unique(...args) {
       const [first, second] = args;
       if (args.length === 2 && Array.isArray(first) && typeof second === "object" && !Array.isArray(second)) {
-        return {
+        return partial({
           __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 }
-        };
+        });
       }
-      return { __type: "unique", __columns: [...args] };
+      return partial({ __type: "unique", __columns: [...args] });
     },
     gin(...columns) {
-      return createIndex(columns, "Gin");
+      return partial(createIndex(columns, "Gin"));
     },
     gist(...columns) {
-      return createIndex(columns, "Gist");
+      return partial(createIndex(columns, "Gist"));
     },
     hash(...columns) {
-      return createIndex(columns, "Hash");
+      return partial(createIndex(columns, "Hash"));
     },
     brin(...columns) {
-      return createIndex(columns, "Brin");
+      return partial(createIndex(columns, "Brin"));
     }
   };
 }
@@ -361,6 +582,7 @@ function create(config) {
     __children: children2,
     __map: config.map,
     __primaryKey: config.primaryKey,
+    __exclusions: config.exclusions,
     __checks: config.checks,
     __extensions: config.extensions,
     __policy: config.policy,
@@ -386,7 +608,7 @@ function detectOneToOnePairs(params) {
   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}` });
+        throw new VibeError3({ code: "VIBE_SCHEMA_INVALID", message: `Invalid foreign-key ownership declaration on ${modelName}.${relName}` });
       }
       if (rel.__relationType === "one") {
         allOnes.push({ modelName, relName, rel });
@@ -408,12 +630,13 @@ function detectOneToOnePairs(params) {
       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;
+      const sameColumnPair = a.rel.__fromModel === b.rel.__toModel && sameColumnTuple({ left: a.rel.__fromColumns, right: b.rel.__toColumns }) && a.rel.__toModel === b.rel.__fromModel && sameColumnTuple({ left: a.rel.__toColumns, right: b.rel.__fromColumns });
       if (!sameColumnPair || (a.rel.__alias ?? "") !== (b.rel.__alias ?? ""))
         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 constraintName = fkOwner.rel.__constraintName ?? backRelation.rel.__constraintName;
       const fkKey = `${fkOwner.modelName}:${fkOwner.relName}`;
       const backKey = `${backRelation.modelName}:${backRelation.relName}`;
       mergeMap.set(fkKey, {
@@ -421,14 +644,16 @@ function detectOneToOnePairs(params) {
         pairedRelName: backRelation.relName,
         pairedModelName: backRelation.modelName,
         onDelete,
-        onUpdate
+        onUpdate,
+        ...constraintName === undefined ? {} : { constraintName }
       });
       mergeMap.set(backKey, {
         role: "backRelation",
         pairedRelName: fkOwner.relName,
         pairedModelName: fkOwner.modelName,
         onDelete,
-        onUpdate
+        onUpdate,
+        ...constraintName === undefined ? {} : { constraintName }
       });
       paired.add(fkKey);
       paired.add(backKey);
@@ -437,10 +662,14 @@ function detectOneToOnePairs(params) {
   }
   return mergeMap;
 }
+function sameColumnTuple(params) {
+  const { left, right } = params;
+  return left.length === right.length && left.every((name, index) => name === right[index]);
+}
 function resolveFkOwner(params) {
   const { a, b, models } = params;
   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" } });
+    throw new VibeError3({ 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;
@@ -449,8 +678,8 @@ function resolveFkOwner(params) {
       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;
+  const aFromIsId = fromIsPrimaryKey({ model: models.get(a.modelName), columns: a.rel.__fromColumns });
+  const bFromIsId = fromIsPrimaryKey({ model: models.get(b.modelName), columns: b.rel.__fromColumns });
   if (aFromIsId && !bFromIsId)
     return { fkOwner: b, backRelation: a };
   if (!aFromIsId && bFromIsId)
@@ -463,12 +692,25 @@ function resolveFkOwner(params) {
   if (bActions && !aActions) {
     return { fkOwner: b, backRelation: a };
   }
-  const aLooksFk = looksLikeForeignKey({ column: a.rel.__fromColumn });
-  const bLooksFk = looksLikeForeignKey({ column: b.rel.__fromColumn });
+  const aLooksFk = a.rel.__fromColumns.some((column) => looksLikeForeignKey({ column }));
+  const bLooksFk = b.rel.__fromColumns.some((column) => looksLikeForeignKey({ column }));
   if (aLooksFk === bLooksFk)
     return ownershipError();
   return aLooksFk ? { fkOwner: a, backRelation: b } : { fkOwner: b, backRelation: a };
 }
+function fromIsPrimaryKey(params) {
+  const { model, columns } = params;
+  if (model === undefined)
+    return false;
+  if (columns.length > 1) {
+    const primaryKey = model.__primaryKey;
+    return primaryKey !== undefined && primaryKey.length === columns.length && primaryKey.every((name) => columns.includes(name));
+  }
+  const column = columns[0];
+  if (column === undefined)
+    return false;
+  return model.__columns.get(column)?.__columnType === "id" || model.__primaryKey?.includes(column) === true;
+}
 function looksLikeForeignKey(params) {
   const { column } = params;
   return column.toLowerCase().includes("id") && column !== "id";
@@ -498,14 +740,16 @@ function planExplicitRelations(params) {
       planned.push({ ...base, kind: "backOne", isList: false, isOptional: rel.__optional });
       continue;
     }
-    const fkColumn = model.__columns.get(rel.__fromColumn);
+    const anyMemberOptional = rel.__fromColumns.some((name2) => model.__columns.get(name2)?.__config.optional === true);
+    const constraintName = mergeInfo?.constraintName ?? rel.__constraintName;
     planned.push({
       ...base,
       kind: "fkOwner",
       isList: false,
-      isOptional: fkColumn?.__config.optional === true || rel.__optional,
-      fields: [rel.__fromColumn],
-      references: [rel.__toColumn],
+      isOptional: anyMemberOptional || rel.__optional,
+      fields: [...rel.__fromColumns],
+      references: [...rel.__toColumns],
+      ...constraintName === undefined ? {} : { constraintName },
       onDelete: mergeInfo?.onDelete ?? rel.__onDelete,
       onUpdate: mergeInfo?.onUpdate ?? rel.__onUpdate
     });
@@ -602,7 +846,8 @@ function planIndexes(params) {
     }
   }
   for (const index of evaluateIndexes({ model })) {
-    const key = index.__columns.join(",") + (index.__where === undefined ? "" : `|where:${index.__where}`);
+    const predicateSuffix = index.__where !== undefined ? `|where:${index.__where}` : index.__wherePredicate === undefined ? "" : `|where:${predicateKey({ predicate: index.__wherePredicate })}`;
+    const key = index.__columns.join(",") + predicateSuffix;
     const existing = byKey.get(key);
     const isUnique = index.__type === "unique";
     if (existing === undefined || isUnique) {
@@ -612,6 +857,7 @@ function planIndexes(params) {
         indexType: index.__indexType,
         ...index.__map === undefined ? {} : { map: index.__map },
         ...index.__where === undefined ? {} : { where: index.__where },
+        ...index.__wherePredicate === undefined ? {} : { wherePredicate: index.__wherePredicate },
         ...index.__nullsNotDistinct === true ? { nullsNotDistinct: true } : {},
         ...index.__clientName === undefined ? {} : { clientName: index.__clientName }
       });
@@ -623,6 +869,77 @@ function planIndexes(params) {
   }
   return Array.from(byKey.values());
 }
+function referenceableKeys(params) {
+  const { model } = params;
+  const keys = [];
+  for (const [name, column] of model.__columns) {
+    if (column.__columnType === "id" || column.__config.unique === true)
+      keys.push([name]);
+  }
+  if (model.__primaryKey !== undefined && model.__primaryKey.length > 0)
+    keys.push([...model.__primaryKey]);
+  for (const index of evaluateIndexes({ model })) {
+    if (index.__type === "unique" && index.__where === undefined && index.__wherePredicate === undefined) {
+      keys.push([...index.__columns]);
+    }
+  }
+  return keys;
+}
+function assertForeignKeyIntegrity(params) {
+  const { relation, models } = params;
+  const fields = relation.fields ?? [];
+  const references = relation.references ?? [];
+  const at = `${relation.model}.${relation.name}`;
+  const refuse = (message, rule, meta = {}) => {
+    throw new VibeError3({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Relation ${at}: ${message}`,
+      meta: { rule, model: relation.model, relation: relation.name, ...meta }
+    });
+  };
+  if (fields.length !== references.length) {
+    refuse(`pairs ${fields.length} foreign-key column(s) with ${references.length} referenced column(s)`, "relation-tuple-arity", { fields, references });
+  }
+  if (new Set(fields).size !== fields.length) {
+    refuse(`repeats a foreign-key column (${fields.join(", ")})`, "relation-duplicate-column", { fields });
+  }
+  if (new Set(references).size !== references.length) {
+    refuse(`repeats a referenced column (${references.join(", ")})`, "relation-duplicate-column", { references });
+  }
+  const owner = models.get(relation.model);
+  const target = models.get(relation.targetModel);
+  if (owner === undefined || target === undefined)
+    return;
+  fields.forEach((name, index) => {
+    const referenced = references[index];
+    const column = owner.__columns.get(name);
+    const refColumn = target.__columns.get(referenced);
+    if (column === undefined) {
+      refuse(`uses foreign-key column "${name}", which ${relation.model} does not declare`, "unknown-relation-field", { field: name });
+      return;
+    }
+    if (refColumn === undefined) {
+      refuse(`references "${relation.targetModel}.${referenced}", which does not exist`, "unknown-relation-reference", { reference: referenced });
+      return;
+    }
+    if (column.__config.array === true || refColumn.__config.array === true) {
+      refuse(`pairs a scalar list (${name} \u2194 ${referenced}) \u2014 a foreign key compares single values`, "relation-list-column", { field: name, reference: referenced });
+    }
+    if (column.__columnType === "json" || refColumn.__columnType === "json" || column.__columnType === "unsupported" || refColumn.__columnType === "unsupported") {
+      refuse(`pairs ${name} \u2194 ${referenced}, and Json/unsupported columns cannot be a foreign key`, "relation-unsupported-column", { field: name, reference: referenced });
+    }
+    const ownType = fieldTypeKey({ column });
+    const refType = fieldTypeKey({ column: refColumn });
+    if (ownType !== refType) {
+      refuse(`pairs ${relation.model}.${name} (${ownType}) with ${relation.targetModel}.${referenced} (${refType}) \u2014 both ends of a foreign key need the same scalar type`, "relation-type-mismatch", { field: name, reference: referenced, fieldType: ownType, referenceType: refType });
+    }
+  });
+  const keys = referenceableKeys({ model: target });
+  const matched = keys.some((key) => key.length === references.length && key.every((name) => references.includes(name)));
+  if (!matched) {
+    refuse(`references ${relation.targetModel}.(${references.join(", ")}), which is not a unique key there \u2014 declare those columns as the primary key, a unique column, or a total @@unique index`, "relation-reference-not-unique", { references, candidates: keys.map((key) => [...key]) });
+  }
+}
 function planSchema(params) {
   const { schema } = params;
   const mergeMap = detectOneToOnePairs({
@@ -645,7 +962,12 @@ function planSchema(params) {
       existing: explicit
     });
     const children2 = planChildRelations({ modelName, model, models: schema.__models });
-    relations.set(modelName, [...explicit, ...reverses, ...children2]);
+    const planned = [...explicit, ...reverses, ...children2];
+    for (const relation of planned) {
+      if (relation.kind === "fkOwner")
+        assertForeignKeyIntegrity({ relation, models: schema.__models });
+    }
+    relations.set(modelName, planned);
     indexes.set(modelName, planIndexes({ model }));
   }
   return { relations, indexes };
@@ -671,35 +993,7 @@ function findCounterparts(params) {
 }
 
 // packages/dsl/src/to-ir.ts
-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";
-  }
-}
+var fieldType = columnFieldType;
 function idDefault(params) {
   switch (params.column.__config.type) {
     case "ulid":
@@ -720,16 +1014,16 @@ function fieldDefault(params) {
   const { column } = params;
   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" });
+      throw new VibeError4({ 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` });
+    throw new VibeError4({ 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" });
+      throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "autoincrement requires a required scalar Int or BigInt column" });
     }
     return { kind: "autoincrement" };
   }
@@ -739,7 +1033,7 @@ function fieldDefault(params) {
     return;
   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" });
+      throw new VibeError4({ 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") {
@@ -751,14 +1045,14 @@ function fieldDefault(params) {
     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" });
+    throw new VibeError4({ 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 === "bigint")
     return { kind: "literal", value: exactIntegerLiteral({ text: value.toString() }) };
-  throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
+  throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
 }
 function nativeType(params) {
   const { column } = params;
@@ -767,7 +1061,7 @@ function nativeType(params) {
     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({
+        throw new VibeError4({
           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 }] }
@@ -832,6 +1126,7 @@ function buildRelation(params) {
     isList: relation.isList,
     isOptional: relation.isOptional,
     ...relation.relationName === undefined ? {} : { relationName: relation.relationName },
+    ...relation.constraintName === undefined ? {} : { constraintName: relation.constraintName },
     ...relation.fields === undefined ? {} : { fields: [...relation.fields] },
     ...relation.references === undefined ? {} : { references: [...relation.references] },
     ...relation.onDelete === undefined ? {} : { onDelete: relation.onDelete },
@@ -847,19 +1142,28 @@ var INDEX_KINDS = {
   Brin: "brin"
 };
 function buildIndex(params) {
-  const { index } = params;
+  const { index, model, dialect, enums } = params;
   const kind = index.isUnique ? "unique" : index.indexType === undefined ? "btree" : INDEX_KINDS[index.indexType];
+  const predicate = compileIndexPredicate({
+    where: index.where,
+    wherePredicate: index.wherePredicate,
+    columns: index.columns,
+    model,
+    dialect,
+    enums
+  });
   return {
     kind,
     fields: index.columns.map((name) => ({ name })),
     ...index.map === undefined ? {} : { name: index.map },
-    ...index.where === undefined ? {} : { where: index.where },
+    ...predicate === undefined ? {} : { where: predicate.where },
+    ...predicate?.wherePredicate === undefined ? {} : { wherePredicate: predicate.wherePredicate },
     ...index.nullsNotDistinct === true ? { nullsNotDistinct: true } : {},
     ...index.clientName === undefined ? {} : { clientName: index.clientName }
   };
 }
 function buildModel(params) {
-  const { model, plan, extensions, declarations, issues } = params;
+  const { model, plan, extensions, declarations, issues, dialect, enums } = 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 = [];
@@ -935,13 +1239,17 @@ function buildModel(params) {
       declaration: parsed.declaration
     });
   }
+  const predicateModel = { name: model.__name, fields };
+  const exclusions = compileExclusions({ exclusions: model.__exclusions, model: predicateModel, dialect });
+  const checks = compileChecks({ checks: model.__checks, model: predicateModel, dialect, enums });
   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 })) },
+    indexes: (plan.indexes.get(model.__name) ?? []).map((index) => buildIndex({ index, model: predicateModel, dialect, enums })),
+    ...exclusions.length === 0 ? {} : { exclusions },
+    ...checks.length === 0 ? {} : { checks },
     ...policy === undefined ? {} : { policy },
     ...primaryKey === undefined ? {} : { primaryKey },
     isView: false,
@@ -972,8 +1280,14 @@ function toIR(params) {
   const plan = planSchema({ schema });
   const declarations = new ExtensionDeclarationCollector;
   const issues = [];
+  const enums = Array.from(schema.__enums, ([name, values]) => ({
+    name,
+    values: [...values],
+    ...schema.__enumStorage.get(name) === "string" ? { storage: "string" } : {}
+  }));
+  const dialect = getSqlDialect({ dialect: providerToDialect({ provider }) });
   const models = Array.from(schema.__models.values(), (model) => {
-    const built = buildModel({ model, plan, extensions, declarations, issues });
+    const built = buildModel({ model, plan, extensions, declarations, issues, dialect, enums });
     const rls = schema.__rls?.policies[model.__name];
     return rls === undefined ? built : { ...built, rls };
   });
@@ -984,13 +1298,8 @@ function toIR(params) {
       }
     }
   }
-  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({
+    throw new VibeError4({
       code: "VIBE_SCHEMA_INVALID",
       message: `Schema validation failed with ${issues.length} issue(s): ${issues.map((issue) => issue.message).join("; ")}`,
       meta: { issues }
@@ -1008,6 +1317,12 @@ function toIR(params) {
 }
 
 // packages/dsl/src/generator/prisma.ts
+function predicateModel(params) {
+  return {
+    name: params.model.__name,
+    fields: Array.from(params.model.__columns, ([name, column]) => buildField({ name, column }))
+  };
+}
 function prismaType(params) {
   const { column } = params;
   const list = column.__config.array === true ? "[]" : "";
@@ -1148,12 +1463,23 @@ function formatRelation(params) {
     args.push(`onDelete: ${relation.onDelete}`);
   if (relation.onUpdate !== undefined)
     args.push(`onUpdate: ${relation.onUpdate}`);
+  if (relation.constraintName !== undefined) {
+    args.push(`map: ${encodePrismaString({ value: relation.constraintName })}`);
+  }
   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 predicate = compileIndexPredicate({
+    where: index.where,
+    wherePredicate: index.wherePredicate,
+    columns: index.columns,
+    model: predicateModel({ model: params.model }),
+    dialect: params.dialect,
+    enums: params.enums
+  });
+  const whereArg = predicate === undefined ? "" : `, where: ${encodePrismaString({ value: predicate.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 })}`;
@@ -1192,9 +1518,14 @@ function formatModel(params) {
   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(formatIndex({ index, model: params.model, dialect: params.dialect, enums: params.enums }));
+  }
+  for (const check of compileChecks({
+    checks: model.__checks,
+    model: predicateModel({ model: params.model }),
+    dialect: params.dialect,
+    enums: params.enums
+  })) {
     lines.push(`  @@check(${encodePrismaString({ value: check.expression })}, name: ${encodePrismaString({ value: check.name })})`);
   }
   for (const use of model.__extensions ?? []) {
@@ -1226,17 +1557,22 @@ function formatEnum(params) {
   return [`enum ${name} {`, ...values.map((value) => `  ${value}`), "}"].join(`
 `);
 }
-function generatePrisma(schema, _config = {}) {
+function generatePrisma(schema, config = {}) {
+  for (const model of schema.__models.values()) {
+    const exclusions = compileExclusions({ exclusions: model.__exclusions, model: { name: model.__name, fields: Array.from(model.__columns, ([name, column]) => buildField({ name, column })) }, dialect: getSqlDialect2({ dialect: providerToDialect2({ provider: config.provider ?? "postgresql" }) }) });
+    if (exclusions.length > 0)
+      throw new VibeError5({ code: "VIBE_CONFIG", message: "Prisma output cannot preserve exclusion constraints; keep the DSL source", meta: { feature: "exclusionConstraints", target: "prisma" } });
+  }
   const stringEnums = [...schema.__enumStorage].filter(([, storage]) => storage === "string").map(([name]) => name);
   if (stringEnums.length > 0) {
-    throw new VibeError3({
+    throw new VibeError5({
       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 (schema.__rls !== undefined) {
-    throw new VibeError3({
+    throw new VibeError5({
       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" }
@@ -1244,6 +1580,8 @@ function generatePrisma(schema, _config = {}) {
   }
   const plan = planSchema({ schema });
   const sections = [];
+  const dialect = getSqlDialect2({ dialect: providerToDialect2({ provider: config.provider ?? "postgresql" }) });
+  const enums = Array.from(schema.__enums, ([name, values]) => ({ name, values: [...values] }));
   if (schema.__enums.size > 0) {
     sections.push("// ============================================");
     sections.push("// Enums");
@@ -1259,7 +1597,7 @@ function generatePrisma(schema, _config = {}) {
   sections.push("// ============================================");
   sections.push("");
   for (const model of schema.__models.values()) {
-    sections.push(formatModel({ model, plan }));
+    sections.push(formatModel({ model, plan, dialect, enums }));
     sections.push("");
   }
   return sections.join(`
@@ -1267,12 +1605,28 @@ function generatePrisma(schema, _config = {}) {
 }
 
 // packages/dsl/src/relations.ts
+import { VibeError as VibeError6 } from "@vibeorm/schema";
+var REF_KIND_BY_COLUMN_TYPE = {
+  string: "String",
+  int: "Int",
+  bigint: "BigInt",
+  float: "Float",
+  decimal: "Decimal",
+  boolean: "Boolean",
+  datetime: "DateTime",
+  json: "Json",
+  bytes: "Bytes",
+  id: "Id",
+  enum: "Enum",
+  unsupported: "Unsupported"
+};
 function createColumnRef(params) {
-  const { model, column } = params;
+  const { model, column, kind } = params;
   return {
     __type: "columnRef",
     __model: model,
     __column: column,
+    __kind: kind,
     through(junction) {
       return {
         __type: "throughRef",
@@ -1285,38 +1639,77 @@ function createColumnRef(params) {
   };
 }
 function extractRefInfo(params) {
-  const { ref } = params;
-  return { model: ref.__model, column: ref.__column };
+  const { ref, side, target } = params;
+  if (!Array.isArray(ref)) {
+    const single = ref;
+    return { model: single.__model, columns: [single.__column] };
+  }
+  const members = ref;
+  if (members.length === 0) {
+    throw new VibeError6({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Relation to ${target}: "${side}" is an empty tuple \u2014 name at least one column`,
+      meta: { rule: "relation-empty-tuple", side, targetModel: target }
+    });
+  }
+  const models = [...new Set(members.map((member) => member.__model))].sort();
+  if (models.length > 1) {
+    throw new VibeError6({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Relation to ${target}: "${side}" mixes models ${models.join(", ")} \u2014 every member of a composite key must sit on one model`,
+      meta: { rule: "relation-mixed-models", side, targetModel: target, models }
+    });
+  }
+  if (members.some((member) => member.__type !== "columnRef")) {
+    throw new VibeError6({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Relation to ${target}: "${side}" routes through a junction inside a tuple \u2014 implicit many-to-many is single-key; model the join with an explicit junction model`,
+      meta: { rule: "relation-through-in-tuple", side, targetModel: target }
+    });
+  }
+  return { model: members[0].__model, columns: members.map((member) => member.__column) };
 }
 function createRelationFactory(params) {
   const { relationType, targetModelName } = params;
   return (config) => {
-    const from = extractRefInfo({ ref: config.from });
-    const to = extractRefInfo({ ref: config.to });
+    const from = extractRefInfo({ ref: config.from, side: "from", target: targetModelName });
+    const to = extractRefInfo({ ref: config.to, side: "to", target: targetModelName });
+    if (from.columns.length !== to.columns.length) {
+      throw new VibeError6({
+        code: "VIBE_SCHEMA_INVALID",
+        message: `Relation to ${targetModelName}: "from" names ${from.columns.length} column(s) but "to" names ${to.columns.length} \u2014 a composite key pairs member by member`,
+        meta: { rule: "relation-tuple-arity", targetModel: targetModelName, from: from.columns, to: to.columns }
+      });
+    }
     let throughJunction;
     let throughFromCol;
     let throughToCol;
-    if (config.from.__type === "throughRef") {
-      throughJunction = config.from.__junction;
-      throughFromCol = config.from.__junctionColumn;
+    const fromRef = Array.isArray(config.from) ? undefined : config.from;
+    const toRef2 = Array.isArray(config.to) ? undefined : config.to;
+    if (fromRef?.__type === "throughRef") {
+      throughJunction = fromRef.__junction;
+      throughFromCol = fromRef.__junctionColumn;
     }
-    if (config.to.__type === "throughRef") {
-      throughJunction = throughJunction ?? config.to.__junction;
-      throughToCol = config.to.__junctionColumn;
+    if (toRef2?.__type === "throughRef") {
+      throughJunction = throughJunction ?? toRef2.__junction;
+      throughToCol = toRef2.__junctionColumn;
     }
     return {
       __type: "storedRelation",
       __relationType: relationType,
       __targetModel: targetModelName,
       __fromModel: from.model,
-      __fromColumn: from.column,
+      __fromColumn: from.columns[0],
+      __fromColumns: from.columns,
       __toModel: to.model,
-      __toColumn: to.column,
+      __toColumn: to.columns[0],
+      __toColumns: to.columns,
       __throughJunction: throughJunction,
       __throughFromCol: throughFromCol,
       __throughToCol: throughToCol,
       __optional: config.optional ?? relationType === "many",
       __alias: config.alias,
+      ...config.constraintName === undefined ? {} : { __constraintName: config.constraintName },
       ..."ownsForeignKey" in config ? { __ownsForeignKey: config.ownsForeignKey } : {},
       __onDelete: config.onDelete,
       __onUpdate: config.onUpdate
@@ -1338,8 +1731,12 @@ function createRelationsBuilder(params) {
     if (model === undefined)
       continue;
     const columnRefs = {};
-    for (const columnName of model.__columns.keys()) {
-      columnRefs[columnName] = createColumnRef({ model: modelName, column: columnName });
+    for (const [columnName, column] of model.__columns) {
+      columnRefs[columnName] = createColumnRef({
+        model: modelName,
+        column: columnName,
+        kind: REF_KIND_BY_COLUMN_TYPE[column.__columnType]
+      });
     }
     builder[modelName] = columnRefs;
   }
@@ -1376,7 +1773,7 @@ function mergeRelations(...parts) {
 }
 
 // packages/dsl/src/schema.ts
-import { VibeError as VibeError4, validateRlsContextIR } from "@vibeorm/schema";
+import { VibeError as VibeError7, validateRlsContextIR } from "@vibeorm/schema";
 function sameValues(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
@@ -1395,7 +1792,7 @@ function registerEnum(params) {
     ...valuesDiffer ? [`values [${existing.values.join(", ")}] vs [${entry.values.join(", ")}]`] : [],
     ...storageDiffers ? [`storage "${existing.storage}" vs "${entry.storage}"`] : []
   ].join("; ");
-  throw new VibeError4({
+  throw new VibeError7({
     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: {
@@ -1421,7 +1818,7 @@ function addModelTree(params) {
   const { model, models, origin } = params;
   const existing = models.get(model.__name);
   if (existing !== undefined && existing !== model) {
-    throw new VibeError4({
+    throw new VibeError7({
       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: {
@@ -1499,7 +1896,7 @@ var RLS_CONTEXT_TYPES = {
 };
 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" }] } });
+    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "RLS context must be a record of scalar declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
   }
   const entries = [];
   const refs = [];
@@ -1507,7 +1904,7 @@ function defineRls(params) {
     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" }] } });
+      throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "RLS context slots must be named scalar column declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
     }
     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 })]);
@@ -1515,22 +1912,22 @@ function defineRls(params) {
   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 } });
+    throw new VibeError7({ 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" }] } });
+    throw new VibeError7({ 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" }] } });
+      throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be named data properties", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
     }
     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 }] } });
+      throw new VibeError7({ 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]);
@@ -1704,18 +2101,30 @@ function validateSchema(schema2) {
         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
-          });
+        for (const column of relation.__fromColumns) {
+          if (!model.__columns.has(column)) {
+            errors.push({
+              type: "error",
+              message: `Relation "${relationName}" references FK column "${column}" which doesn't exist on model "${modelName}"`,
+              model: modelName,
+              relation: relationName
+            });
+          }
+        }
+        for (const column of relation.__toColumns) {
+          if (!targetModel.__columns.has(column)) {
+            errors.push({
+              type: "error",
+              message: `Relation "${relationName}" references column "${column}" which doesn't exist on target model "${relation.__targetModel}"`,
+              model: modelName,
+              relation: relationName
+            });
+          }
         }
-        if (!targetModel.__columns.has(relation.__toColumn)) {
+        if (relation.__fromColumns.length !== relation.__toColumns.length) {
           errors.push({
             type: "error",
-            message: `Relation "${relationName}" references column "${relation.__toColumn}" which doesn't exist on target model "${relation.__targetModel}"`,
+            message: `Relation "${relationName}" pairs ${relation.__fromColumns.length} FK column(s) with ${relation.__toColumns.length} referenced column(s)`,
             model: modelName,
             relation: relationName
           });
@@ -1802,16 +2211,20 @@ export {
   generatePrisma,
   fields,
   evaluateIndexes,
+  evaluateChecks,
   dsl,
   domain,
   detectOneToOnePairs,
   defineRls,
   defineRelationsPart,
   defineRelations,
+  createPredicateBuilder,
   createIndexBuilder,
   createEnum,
   createChildrenBuilder,
   create,
+  compileIndexPredicate,
+  compileChecks,
   cloneColumnDef,
   children,
   baseWithWorkspace,
@@ -1825,4 +2238,4 @@ export {
   ChainableColumn
 };
 
-//# debugId=88D4E8D0B695042E64756E2164756E21
+//# debugId=13292A89548F16A064756E2164756E21