@vibeorm/dsl 2.4.0 → 4.0.0

package/dist/index.js

@@ -1,12 +1,13 @@
 // @bun
 // packages/dsl/src/column.ts
+import { VibeError, assertJsonSchemaRef, encodePrismaString } from "@vibeorm/schema";
 function cloneColumnDef(params) {
   const { column } = params;
   return {
     __type: "column",
     __columnType: column.__columnType,
     __name: column.__name,
-    __config: { ...column.__config },
+    __config: { ...column.__config, ...column.__config.jsonSchema === undefined ? {} : { jsonSchema: assertJsonSchemaRef({ value: column.__config.jsonSchema }) } },
     __enumValues: column.__enumValues,
     __enumName: column.__enumName,
     __enumStorage: column.__enumStorage
@@ -165,10 +166,17 @@ function datetime(config = {}) {
 
 class ChainableJsonColumn extends ChainableColumn {
   constructor(config = {}) {
-    super("json", config);
+    super("json", { ...config, ...config.jsonSchema === undefined ? {} : { jsonSchema: assertJsonSchemaRef({ value: config.jsonSchema }) } });
+  }
+  schema(reference) {
+    if (this.__config.jsonSchema !== undefined)
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "A field may declare only one JSON schema reference", meta: { issues: [{ rule: "duplicate-json-schema-ref" }] } });
+    this.__config.jsonSchema = assertJsonSchemaRef({ value: reference });
+    return this;
   }
   typed(config) {
-    const annotation = `@type(${config.name} from "${config.from}")`;
+    const ref = assertJsonSchemaRef({ value: config });
+    const annotation = `@type(${ref.name} from ${encodePrismaString({ value: ref.from })})`;
     this.__config.comment = this.__config.comment === undefined ? annotation : `${this.__config.comment} ${annotation}`;
     return this;
   }
@@ -227,11 +235,11 @@ function createEnum(config) {
 }
 
 // packages/dsl/src/generator/prisma.ts
-import { VibeError as VibeError5, encodePrismaString, internalError, providerToDialect as providerToDialect2 } from "@vibeorm/schema";
+import { VibeError as VibeError6, encodePrismaString as encodePrismaString2, internalError, normalizeJsonSchemaRef as normalizeJsonSchemaRef2, providerToDialect as providerToDialect2 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect2 } from "@vibeorm/sql";
 
 // packages/dsl/src/predicate.ts
-import { VibeError } from "@vibeorm/schema";
+import { VibeError as VibeError2 } from "@vibeorm/schema";
 import { compileExclusion, renderPredicate } from "@vibeorm/sql";
 function isFieldExpr(operand) {
   return typeof operand === "object" && operand !== null && "kind" in operand && operand.kind === "field";
@@ -246,7 +254,7 @@ function toValue(params) {
   if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
     return { kind: "value", value: input };
   }
-  throw new VibeError({
+  throw new VibeError2({
     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 }
@@ -254,13 +262,27 @@ function toValue(params) {
 }
 function toOperand(params) {
   const { operand, at } = params;
-  return isFieldExpr(operand) ? toRef({ expr: operand }) : toValue({ input: operand, at });
+  return typeof operand === "object" && operand !== null ? toExpression({ value: operand, at }) : toValue({ input: operand, at });
+}
+function toExpression(params) {
+  const { value, at } = params;
+  if (isFieldExpr(value))
+    return toRef({ expr: value });
+  if (typeof value === "object" && value !== null && "kind" in value) {
+    if (value.kind === "jsonText" && "field" in value && "path" in value && Array.isArray(value.path) && Array.from(value.path).every((segment) => typeof segment === "string" && !segment.includes("\x00"))) {
+      return { kind: "jsonText", field: toRef({ expr: requireFieldExpr({ value: value.field, at }) }), path: [...value.path] };
+    }
+    if (value.kind === "length" && "expression" in value) {
+      return { kind: "length", expression: toExpression({ value: value.expression, at }) };
+    }
+  }
+  throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: `${at}: expected a field, jsonText or length expression with a string-only JSON path`, meta: { rule: "predicate-operand-invalid", at } });
 }
 function requireFieldExpr(params) {
   const { value, at } = params;
   if (isFieldExpr(value))
     return value;
-  throw new VibeError({
+  throw new VibeError2({
     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 }
@@ -269,7 +291,7 @@ function requireFieldExpr(params) {
 function requireOperands(params) {
   const { operands, at } = params;
   if (operands.length === 0) {
-    throw new VibeError({
+    throw new VibeError2({
       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 }
@@ -281,14 +303,14 @@ function createPredicateBuilder() {
   const compare = (op) => (left, right) => ({
     kind: "compare",
     op,
-    left: toRef({ expr: requireFieldExpr({ value: left, at: `c.${op}()` }) }),
+    left: toExpression({ 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({
+      throw new VibeError2({
         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 }
@@ -309,6 +331,9 @@ function createPredicateBuilder() {
     gte: compare("gte"),
     lt: compare("lt"),
     lte: compare("lte"),
+    jsonText: ({ field, path }) => ({ ...toExpression({ value: { kind: "jsonText", field: { kind: "field", name: field }, path }, at: "c.jsonText()" }), __kind: "String" }),
+    length: (expression) => ({ kind: "length", expression: toExpression({ value: expression, at: "c.length()" }), __kind: "Int" }),
+    isTrue: (operand) => ({ kind: "isTrue", operand }),
     inList: membership(false),
     notInList: membership(true),
     isNull: (name) => ({ kind: "isNull", field: { kind: "field", name } }),
@@ -318,7 +343,7 @@ function createPredicateBuilder() {
     not: (operand) => ({ kind: "not", operand }),
     named: (name, predicate) => {
       if (name.trim() === "") {
-        throw new VibeError({
+        throw new VibeError2({
           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" }
@@ -337,10 +362,13 @@ function evaluateChecks(params) {
   }
   const declared = checks(createPredicateBuilder());
   return declared.map((entry, index) => {
-    if (entry === null || typeof entry !== "object" || entry.__type !== "check") {
-      throw new VibeError({
+    if (entry !== null && typeof entry === "object" && !("__type" in entry) && typeof entry.name === "string" && "expression" in entry && typeof entry.expression === "string") {
+      return { kind: "raw", name: entry.name, expression: entry.expression };
+    }
+    if (entry === null || typeof entry !== "object" || !("__type" in entry) || entry.__type !== "check") {
+      throw new VibeError2({
         code: "VIBE_SCHEMA_INVALID",
-        message: `Model "${model}": checks[${index}] is not a named CHECK \u2014 wrap the expression in c.named("name", \u2026)`,
+        message: `Model "${model}": checks[${index}] must be c.named("name", predicate) or a raw { name, expression } CHECK`,
         meta: { rule: "predicate-unnamed-check", model, index }
       });
     }
@@ -369,7 +397,7 @@ function compileChecks(params) {
 function compileIndexPredicate(params) {
   const { where, wherePredicate, columns, model, dialect, enums } = params;
   if (where !== undefined && wherePredicate !== undefined) {
-    throw new VibeError({
+    throw new VibeError2({
       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] }
@@ -395,13 +423,14 @@ function compileIndexPredicate(params) {
 // packages/dsl/src/to-ir.ts
 import {
   EMPTY_EXTENSION_REGISTRY,
-  VibeError as VibeError4,
+  VibeError as VibeError5,
   assertValidSchemaIR,
   exactIntegerLiteral,
   providerToDialect,
   scalarListDefault,
   serializeJsonDefault,
   mergeExtensionDeclarations,
+  normalizeJsonSchemaRef,
   unsupportedCapability
 } from "@vibeorm/schema";
 import { getSqlDialect } from "@vibeorm/sql";
@@ -442,10 +471,10 @@ function fieldTypeKey(params) {
 }
 
 // packages/dsl/src/relation-plan.ts
-import { VibeError as VibeError3, isSqlObjectIdentity, predicateKey } from "@vibeorm/schema";
+import { VibeError as VibeError4, isSqlObjectIdentity, predicateKey } from "@vibeorm/schema";
 
 // packages/dsl/src/model.ts
-import { VibeError as VibeError2 } from "@vibeorm/schema";
+import { VibeError as VibeError3 } from "@vibeorm/schema";
 
 // packages/dsl/src/naming.ts
 function capitalize(params) {
@@ -487,7 +516,7 @@ function createIndexBuilder() {
   const partial = (index) => {
     const where = (predicate) => {
       if (index.__where !== undefined) {
-        throw new VibeError2({
+        throw new VibeError3({
           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] }
@@ -525,7 +554,7 @@ function createIndexBuilder() {
       const [first, second] = args;
       if (args.length === 2 && Array.isArray(first) && typeof second === "object" && !Array.isArray(second)) {
         if ("ops" in second && second.ops !== undefined) {
-          throw new VibeError2({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses" } });
+          throw new VibeError3({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses" } });
         }
         return partial({
           __type: "unique",
@@ -609,6 +638,10 @@ function evaluateIndexes(params) {
 }
 
 // packages/dsl/src/relation-plan.ts
+function relationPairKey(params) {
+  const { relation, reverse } = params;
+  return JSON.stringify(reverse ? [relation.__toModel, relation.__toColumns, relation.__fromModel, relation.__fromColumns, relation.__alias ?? ""] : [relation.__fromModel, relation.__fromColumns, relation.__toModel, relation.__toColumns, relation.__alias ?? ""]);
+}
 function detectOneToOnePairs(params) {
   const { relations, models } = params;
   const mergeMap = new Map;
@@ -616,13 +649,22 @@ 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 VibeError3({ code: "VIBE_SCHEMA_INVALID", message: `Invalid foreign-key ownership declaration on ${modelName}.${relName}` });
+        throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `Invalid foreign-key ownership declaration on ${modelName}.${relName}` });
       }
       if (rel.__relationType === "one") {
         allOnes.push({ modelName, relName, rel });
       }
     }
   }
+  const candidatesByKey = new Map;
+  for (const [position, entry] of allOnes.entries()) {
+    const key = relationPairKey({ relation: entry.rel });
+    const bucket = candidatesByKey.get(key);
+    if (bucket === undefined)
+      candidatesByKey.set(key, { positions: [position], start: 0 });
+    else
+      bucket.positions.push(position);
+  }
   const paired = new Set;
   for (let i = 0;i < allOnes.length; i++) {
     const a = allOnes[i];
@@ -631,13 +673,17 @@ function detectOneToOnePairs(params) {
     const keyA = `${a.modelName}:${a.relName}`;
     if (paired.has(keyA))
       continue;
-    for (let j = i + 1;j < allOnes.length; j++) {
+    const bucket = candidatesByKey.get(relationPairKey({ relation: a.rel, reverse: true }));
+    if (bucket === undefined)
+      continue;
+    for (let candidate = bucket.start;candidate < bucket.positions.length; candidate++) {
+      const j = bucket.positions[candidate];
       const b = allOnes[j];
-      if (b === undefined)
-        continue;
       const keyB = `${b.modelName}:${b.relName}`;
-      if (paired.has(keyB))
+      if (j <= i || paired.has(keyB)) {
+        bucket.start = candidate + 1;
         continue;
+      }
       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;
@@ -665,6 +711,7 @@ function detectOneToOnePairs(params) {
       });
       paired.add(fkKey);
       paired.add(backKey);
+      bucket.start = candidate + 1;
       break;
     }
   }
@@ -677,7 +724,7 @@ function sameColumnTuple(params) {
 function resolveFkOwner(params) {
   const { a, b, models } = params;
   const ownershipError = () => {
-    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" } });
+    throw new VibeError4({ 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;
@@ -765,7 +812,7 @@ function planExplicitRelations(params) {
   return planned;
 }
 function planMissingReverseRelations(params) {
-  const { modelName, relations, mergeMap, existing } = params;
+  const { modelName, relations, incoming, mergeMap, existing } = params;
   const planned = [];
   const existingLists = new Set;
   const existingNames = new Set;
@@ -775,44 +822,40 @@ function planMissingReverseRelations(params) {
       existingLists.add(`${relation.targetModel}:${relation.relationName ?? ""}`);
     }
   }
-  for (const [sourceModelName, sourceRelations] of Object.entries(relations)) {
-    for (const [relName, rel] of Object.entries(sourceRelations)) {
-      if (rel.__targetModel !== modelName || rel.__relationType !== "one")
-        continue;
-      if (mergeMap.has(`${sourceModelName}:${relName}`))
-        continue;
-      const reverseKey = `${sourceModelName}:${rel.__alias ?? ""}`;
-      if (existingLists.has(reverseKey))
+  for (const { modelName: sourceModelName, relName, rel } of incoming) {
+    if (mergeMap.has(`${sourceModelName}:${relName}`))
+      continue;
+    const reverseKey = `${sourceModelName}:${rel.__alias ?? ""}`;
+    if (existingLists.has(reverseKey))
+      continue;
+    if (sourceModelName === modelName) {
+      const hasExplicitReverse = Object.values(relations[sourceModelName] ?? {}).some((other) => other.__relationType === "many" && other.__targetModel === modelName && other.__alias === rel.__alias);
+      if (hasExplicitReverse)
         continue;
-      if (sourceModelName === modelName) {
-        const hasExplicitReverse = Object.values(sourceRelations).some((other) => other.__relationType === "many" && other.__targetModel === modelName && other.__alias === rel.__alias);
-        if (hasExplicitReverse)
-          continue;
-      }
-      const baseName = rel.__alias ?? sourceModelName;
-      let name = baseName;
-      let counter = 1;
-      while (existingNames.has(name)) {
-        counter++;
-        name = `${baseName}${counter}`;
-      }
-      planned.push({
-        model: modelName,
-        name,
-        targetModel: sourceModelName,
-        kind: "list",
-        isList: true,
-        isOptional: false,
-        relationName: rel.__alias
-      });
-      existingLists.add(reverseKey);
-      existingNames.add(name);
     }
+    const baseName = rel.__alias ?? sourceModelName;
+    let name = baseName;
+    let counter = 1;
+    while (existingNames.has(name)) {
+      counter++;
+      name = `${baseName}${counter}`;
+    }
+    planned.push({
+      model: modelName,
+      name,
+      targetModel: sourceModelName,
+      kind: "list",
+      isList: true,
+      isOptional: false,
+      relationName: rel.__alias
+    });
+    existingLists.add(reverseKey);
+    existingNames.add(name);
   }
   return planned;
 }
 function planChildRelations(params) {
-  const { modelName, model, models } = params;
+  const { modelName, model, parents } = params;
   const planned = [];
   for (const [childKey, childModel] of model.__children) {
     planned.push({
@@ -824,22 +867,18 @@ function planChildRelations(params) {
       isOptional: false
     });
   }
-  for (const [parentModelName, parentModel] of models) {
-    for (const childModel of parentModel.__children.values()) {
-      if (childModel.__name !== modelName)
-        continue;
-      const parentPk = parentModel.__primaryKey?.[0] ?? Array.from(parentModel.__columns.entries()).find(([, column]) => column.__columnType === "id")?.[0] ?? "id";
-      planned.push({
-        model: modelName,
-        name: parentModelName,
-        targetModel: parentModelName,
-        kind: "fkOwner",
-        isList: false,
-        isOptional: false,
-        fields: [toFkColumnName({ modelName: parentModelName })],
-        references: [parentPk]
-      });
-    }
+  for (const [parentModelName, parentModel] of parents) {
+    const parentPk = parentModel.__primaryKey?.[0] ?? Array.from(parentModel.__columns.entries()).find(([, column]) => column.__columnType === "id")?.[0] ?? "id";
+    planned.push({
+      model: modelName,
+      name: parentModelName,
+      targetModel: parentModelName,
+      kind: "fkOwner",
+      isList: false,
+      isOptional: false,
+      fields: [toFkColumnName({ modelName: parentModelName })],
+      references: [parentPk]
+    });
   }
   return planned;
 }
@@ -856,14 +895,14 @@ function planIndexes(params) {
   for (const index of evaluateIndexes({ model })) {
     if (index.__ops !== undefined) {
       if (index.__ops === null || typeof index.__ops !== "object" || Array.isArray(index.__ops))
-        throw new VibeError3({ code: "VIBE_SCHEMA_INVALID", message: "Index ops must be a field-keyed qualified-name map", meta: { rule: "index-operator-class-map", model: model.__name } });
+        throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Index ops must be a field-keyed qualified-name map", meta: { rule: "index-operator-class-map", model: model.__name } });
       if (index.__type === "unique")
-        throw new VibeError3({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses", model: model.__name } });
+        throw new VibeError4({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Custom unique operator classes can change client selector equality", meta: { feature: "uniqueIndexOperatorClasses", model: model.__name } });
       for (const [field, operatorClass] of Object.entries(index.__ops)) {
         if (!index.__columns.includes(field))
-          throw new VibeError3({ code: "VIBE_SCHEMA_INVALID", message: "Operator class names a field outside the index", meta: { rule: "index-operator-class-field", model: model.__name, field } });
+          throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Operator class names a field outside the index", meta: { rule: "index-operator-class-field", model: model.__name, field } });
         if (operatorClass !== undefined && !isSqlObjectIdentity({ kind: "table", name: operatorClass }))
-          throw new VibeError3({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", model: model.__name, field } });
+          throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", model: model.__name, field } });
       }
     }
     const operatorClasses = index.__columns.map((field) => index.__ops?.[field]);
@@ -914,7 +953,7 @@ function assertForeignKeyIntegrity(params) {
   const references = relation.references ?? [];
   const at = `${relation.model}.${relation.name}`;
   const refuse = (message, rule, meta = {}) => {
-    throw new VibeError3({
+    throw new VibeError4({
       code: "VIBE_SCHEMA_INVALID",
       message: `Relation ${at}: ${message}`,
       meta: { rule, model: relation.model, relation: relation.name, ...meta }
@@ -963,6 +1002,33 @@ function assertForeignKeyIntegrity(params) {
     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 relationLookups(params) {
+  const incoming = new Map;
+  for (const [modelName, relations] of Object.entries(params.schema.__relations)) {
+    for (const [relName, rel] of Object.entries(relations)) {
+      if (rel.__relationType !== "one")
+        continue;
+      const target = rel.__targetModel;
+      const entries = incoming.get(target);
+      const entry = { modelName, relName, rel };
+      if (entries === undefined)
+        incoming.set(target, [entry]);
+      else
+        entries.push(entry);
+    }
+  }
+  const parents = new Map;
+  for (const [name, model] of params.schema.__models) {
+    for (const child of model.__children.values()) {
+      const entries = parents.get(child.__name);
+      if (entries === undefined)
+        parents.set(child.__name, [[name, model]]);
+      else
+        entries.push([name, model]);
+    }
+  }
+  return { incoming, parents };
+}
 function planSchema(params) {
   const { schema } = params;
   const mergeMap = detectOneToOnePairs({
@@ -971,7 +1037,13 @@ function planSchema(params) {
   });
   const relations = new Map;
   const indexes = new Map;
+  let lookups = relationLookups({ schema });
+  let refreshLookups = false;
   for (const [modelName, model] of schema.__models) {
+    if (refreshLookups) {
+      lookups = relationLookups({ schema });
+      refreshLookups = false;
+    }
     const explicit = planExplicitRelations({
       modelName,
       model,
@@ -981,16 +1053,22 @@ function planSchema(params) {
     const reverses = planMissingReverseRelations({
       modelName,
       relations: schema.__relations,
+      incoming: lookups.incoming.get(modelName) ?? [],
       mergeMap,
       existing: explicit
     });
-    const children = planChildRelations({ modelName, model, models: schema.__models });
+    const children = planChildRelations({ modelName, model, parents: lookups.parents.get(modelName) ?? [] });
     const planned = [...explicit, ...reverses, ...children];
     for (const relation of planned) {
-      if (relation.kind === "fkOwner")
+      if (relation.kind === "fkOwner") {
+        if (schema.__models.get(relation.targetModel)?.__indexes !== undefined)
+          refreshLookups = true;
         assertForeignKeyIntegrity({ relation, models: schema.__models });
+      }
     }
     relations.set(modelName, planned);
+    if (model.__indexes !== undefined)
+      refreshLookups = true;
     indexes.set(modelName, planIndexes({ model }));
   }
   return { relations, indexes };
@@ -1037,16 +1115,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 VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Use the id generator strategy instead of a conflicting id default" });
+      throw new VibeError5({ 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 VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `Column "${column.__name ?? column.__columnType}" has conflicting defaults` });
+    throw new VibeError5({ 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 VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "autoincrement requires a required scalar Int or BigInt column" });
+      throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: "autoincrement requires a required scalar Int or BigInt column" });
     }
     return { kind: "autoincrement" };
   }
@@ -1056,7 +1134,7 @@ function fieldDefault(params) {
     return;
   if (column.__config.array === true) {
     if (!Array.isArray(value))
-      throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "A scalar-list default must be an array" });
+      throw new VibeError5({ 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") {
@@ -1071,20 +1149,20 @@ 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 VibeError4({ code: "VIBE_SCHEMA_INVALID", message: "Numeric defaults must be finite; integer defaults must be exact" });
+    throw new VibeError5({ 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 VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
+  throw new VibeError5({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
 }
 function datetimeNativeType(params) {
   const { tz, precision } = params.config;
   if (precision !== undefined && (tz !== true || !Number.isInteger(precision) || precision < 0 || precision > 6)) {
     const at = params.column === undefined ? "A datetime column" : `Column "${params.column}"`;
-    throw new VibeError4({
+    throw new VibeError5({
       code: "VIBE_SCHEMA_INVALID",
       message: `${at}: a datetime precision must be an integer from 0 to 6 on a tz() column, as in dsl.datetime().tz({ precision: 3 })`,
       meta: { issues: [{ rule: "datetime-precision", column: params.column, precision, tz: tz === true }] }
@@ -1101,7 +1179,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 VibeError4({
+        throw new VibeError5({
           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 }] }
@@ -1138,6 +1216,7 @@ function buildField(params) {
   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 metadata = normalizeJsonSchemaRef({ documentation, reference: config.jsonSchema });
   const defaultValue = fieldDefault({ column });
   const native = extensionNativeType ?? nativeType({ column });
   return {
@@ -1153,7 +1232,7 @@ function buildField(params) {
     ...defaultValue === undefined ? {} : { default: defaultValue },
     ...native === undefined ? {} : { nativeType: native },
     ...column.__columnType === "unsupported" ? { isUnsupported: true } : {},
-    ...documentation === undefined ? {} : { documentation }
+    ...metadata
   };
 }
 function buildRelation(params) {
@@ -1341,7 +1420,7 @@ function toIR(params) {
     }
   }
   if (issues.length > 0) {
-    throw new VibeError4({
+    throw new VibeError5({
       code: "VIBE_SCHEMA_INVALID",
       message: `Schema validation failed with ${issues.length} issue(s): ${issues.map((issue) => issue.message).join("; ")}`,
       meta: { issues }
@@ -1398,7 +1477,7 @@ function prismaType(params) {
         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}`;
+      return `Unsupported(${encodePrismaString2({ value: String(column.__config.dbType) })})${list}`;
     }
   }
 }
@@ -1413,11 +1492,11 @@ function defaultAttribute(params) {
   }
   const numericColumn = column.__columnType === "int" || column.__columnType === "bigint" || column.__columnType === "float" || column.__columnType === "decimal";
   if (value.kind === "literal")
-    return `@default(${typeof value.value === "string" && !(numericColumn && /^-?\d+(\.\d+)?$/.test(value.value)) ? encodePrismaString({ value: value.value }) : String(value.value)})`;
+    return `@default(${typeof value.value === "string" && !(numericColumn && /^-?\d+(\.\d+)?$/.test(value.value)) ? encodePrismaString2({ 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(dbgenerated(${encodePrismaString2({ value: value.sql })}))`;
   return `@default(${value.kind}())`;
 }
 function nativeTypeAttribute(params) {
@@ -1462,39 +1541,41 @@ function formatColumn(params) {
     parts.push("@unique");
   }
   if (typeof column.__config.map === "string") {
-    parts.push(`@map(${encodePrismaString({ value: column.__config.map })})`);
+    parts.push(`@map(${encodePrismaString2({ value: column.__config.map })})`);
   }
   const nativeType = nativeTypeAttribute({ column });
   if (nativeType !== undefined)
     parts.push(nativeType);
   if (typeof column.__config.collation === "string") {
-    parts.push(`@collation(${encodePrismaString({ value: column.__config.collation })})`);
+    parts.push(`@collation(${encodePrismaString2({ 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(`
+  const metadata = normalizeJsonSchemaRef2({ documentation: typeof column.__config.comment === "string" ? column.__config.comment : undefined, reference: column.__config.jsonSchema });
+  if (metadata.jsonSchema !== undefined && column.__columnType !== "json")
+    throw new VibeError6({ code: "VIBE_SCHEMA_INVALID", message: "JSON schemas are only valid on Json fields", meta: { issues: [{ rule: "json-schema-non-json", field: name }] } });
+  const comments = [
+    ...metadata.documentation === undefined ? [] : metadata.documentation.split(`
+`),
+    ...metadata.jsonSchema === undefined ? [] : [`@schema(${metadata.jsonSchema.name} from ${encodePrismaString2({ value: metadata.jsonSchema.from })})`]
+  ];
+  return [...comments.map((line) => `  /// ${line}`), 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 })})`;
+    const attribute = relationName === undefined ? "" : ` @relation(${encodePrismaString2({ value: relationName })})`;
     return `  ${name} ${targetModel}[]${attribute}`;
   }
   const optional = relation.isOptional ? "?" : "";
   if (relation.kind === "backOne") {
-    const attribute = relationName === undefined ? "" : ` @relation(${encodePrismaString({ value: relationName })})`;
+    const attribute = relationName === undefined ? "" : ` @relation(${encodePrismaString2({ value: relationName })})`;
     return `  ${name} ${targetModel}${optional}${attribute}`;
   }
   const args = [];
   if (relationName !== undefined)
-    args.push(encodePrismaString({ value: relationName }));
+    args.push(encodePrismaString2({ value: relationName }));
   if (relation.fields === undefined || relation.references === undefined) {
     throw internalError({
       message: `planned FK relation "${relation.model}.${name}" has no fields/references`,
@@ -1508,14 +1589,14 @@ function formatRelation(params) {
   if (relation.onUpdate !== undefined)
     args.push(`onUpdate: ${relation.onUpdate}`);
   if (relation.constraintName !== undefined) {
-    args.push(`map: ${encodePrismaString({ value: relation.constraintName })}`);
+    args.push(`map: ${encodePrismaString2({ value: relation.constraintName })}`);
   }
   return `  ${name} ${targetModel}${optional} @relation(${args.join(", ")})`;
 }
 function formatIndex(params) {
   const { index } = params;
   if (index.ops !== undefined && Object.values(index.ops).some((operatorClass) => operatorClass !== undefined))
-    throw new VibeError5({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Prisma output cannot preserve qualified index operator classes; keep the DSL source", meta: { feature: "prismaIndexOperatorClasses", target: "prisma" } });
+    throw new VibeError6({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Prisma output cannot preserve qualified index operator classes; keep the DSL source", meta: { feature: "prismaIndexOperatorClasses", target: "prisma" } });
   const columns = index.columns.join(", ");
   const predicate = compileIndexPredicate({
     where: index.where,
@@ -1525,10 +1606,10 @@ function formatIndex(params) {
     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 whereArg = predicate === undefined ? "" : `, where: ${encodePrismaString2({ value: predicate.where })}`;
+  const mapArg = index.map === undefined ? "" : `, map: ${encodePrismaString2({ value: index.map })}`;
   const nndArg = index.nullsNotDistinct === true ? ", nullsNotDistinct: true" : "";
-  const nameArg = index.clientName === undefined ? "" : `, name: ${encodePrismaString({ value: index.clientName })}`;
+  const nameArg = index.clientName === undefined ? "" : `, name: ${encodePrismaString2({ value: index.clientName })}`;
   if (index.isUnique) {
     return `  @@unique([${columns}]${nameArg}${mapArg}${nndArg}${whereArg})`;
   }
@@ -1538,7 +1619,7 @@ function formatIndex(params) {
 function formatExtensionValue(params) {
   const { value } = params;
   if (typeof value === "string")
-    return encodePrismaString({ value });
+    return encodePrismaString2({ value });
   if (Array.isArray(value)) {
     return `[${value.map((entry) => formatExtensionValue({ value: entry })).join(", ")}]`;
   }
@@ -1572,7 +1653,7 @@ function formatModel(params) {
     dialect: params.dialect,
     enums: params.enums
   })) {
-    lines.push(`  @@check(${encodePrismaString({ value: check.expression })}, name: ${encodePrismaString({ value: check.name })})`);
+    lines.push(`  @@check(${encodePrismaString2({ value: check.expression })}, name: ${encodePrismaString2({ value: check.name })})`);
   }
   for (const use of model.__extensions ?? []) {
     const args = [];
@@ -1588,11 +1669,11 @@ function formatModel(params) {
   }
   if (model.__policy !== undefined) {
     const { field, context } = model.__policy;
-    const contextArg = context === undefined || context === field ? "" : `, context: ${encodePrismaString({ value: context })}`;
+    const contextArg = context === undefined || context === field ? "" : `, context: ${encodePrismaString2({ value: context })}`;
     lines.push(`  @@policy([${field}]${contextArg})`);
   }
   if (typeof model.__map === "string") {
-    lines.push(`  @@map(${encodePrismaString({ value: model.__map })})`);
+    lines.push(`  @@map(${encodePrismaString2({ value: model.__map })})`);
   }
   lines.push("}");
   return lines.join(`
@@ -1607,18 +1688,18 @@ 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" } });
+      throw new VibeError6({ 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 VibeError5({
+    throw new VibeError6({
       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 VibeError5({
+    throw new VibeError6({
       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" }
@@ -1651,7 +1732,7 @@ function generatePrisma(schema, config = {}) {
 }
 
 // packages/dsl/src/relations.ts
-import { VibeError as VibeError6 } from "@vibeorm/schema";
+import { VibeError as VibeError7 } from "@vibeorm/schema";
 var REF_KIND_BY_COLUMN_TYPE = {
   string: "String",
   int: "Int",
@@ -1692,7 +1773,7 @@ function extractRefInfo(params) {
   }
   const members = ref;
   if (members.length === 0) {
-    throw new VibeError6({
+    throw new VibeError7({
       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 }
@@ -1700,14 +1781,14 @@ function extractRefInfo(params) {
   }
   const models = [...new Set(members.map((member) => member.__model))].sort();
   if (models.length > 1) {
-    throw new VibeError6({
+    throw new VibeError7({
       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({
+    throw new VibeError7({
       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 }
@@ -1721,7 +1802,7 @@ function createRelationFactory(params) {
     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({
+      throw new VibeError7({
         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 }
@@ -1819,7 +1900,7 @@ function mergeRelations(...parts) {
 }
 
 // packages/dsl/src/schema.ts
-import { VibeError as VibeError7, validateRlsContextIR } from "@vibeorm/schema";
+import { VibeError as VibeError8, validateRlsContextIR } from "@vibeorm/schema";
 function sameValues(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
@@ -1838,7 +1919,7 @@ function registerEnum(params) {
     ...valuesDiffer ? [`values [${existing.values.join(", ")}] vs [${entry.values.join(", ")}]`] : [],
     ...storageDiffers ? [`storage "${existing.storage}" vs "${entry.storage}"`] : []
   ].join("; ");
-  throw new VibeError7({
+  throw new VibeError8({
     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: {
@@ -1864,7 +1945,7 @@ function addModelTree(params) {
   const { model, models, origin } = params;
   const existing = models.get(model.__name);
   if (existing !== undefined && existing !== model) {
-    throw new VibeError7({
+    throw new VibeError8({
       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: {
@@ -1942,7 +2023,7 @@ var RLS_CONTEXT_TYPES = {
 };
 function defineRls(params) {
   if (typeof params.context !== "object" || params.context === null || Array.isArray(params.context)) {
-    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "RLS context must be a record of scalar declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
+    throw new VibeError8({ code: "VIBE_SCHEMA_INVALID", message: "RLS context must be a record of scalar declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
   }
   const entries = [];
   const refs = [];
@@ -1950,7 +2031,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 VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "RLS context slots must be named scalar column declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
+      throw new VibeError8({ 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 })]);
@@ -1958,22 +2039,22 @@ function defineRls(params) {
   const context = Object.freeze(Object.fromEntries(entries));
   const issues = validateRlsContextIR({ context });
   if (issues.length > 0) {
-    throw new VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "Invalid RLS context declaration", meta: { issues } });
+    throw new VibeError8({ 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 VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be a record of model classifications", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
+    throw new VibeError8({ 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 VibeError7({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be named data properties", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
+      throw new VibeError8({ 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 VibeError7({ code: "VIBE_SCHEMA_INVALID", message: `RLS classifies model "${name}" more than once`, meta: { issues: [{ rule: "rls-duplicate-classification", model: name }] } });
+      throw new VibeError8({ 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]);
@@ -2285,4 +2366,4 @@ export {
   withNameDescription
 };
 
-//# debugId=0EC0F0E6154BF1C064756E2164756E21
+//# debugId=21B90DDA6F5E192964756E2164756E21