@vibeorm/schema 2.5.0 → 4.0.0

package/dist/index.js

@@ -19,6 +19,7 @@ var VIBE_ERROR_CODES = [
   "VIBE_RLS_CONTEXT",
   "VIBE_PERMISSION_DENIED",
   "VIBE_ADAPTER",
+  "VIBE_ADAPTER_CLOSED",
   "VIBE_INTERNAL"
 ];
 
@@ -259,6 +260,7 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   exclusionConstraints: true,
   exclusionExtensions: Object.freeze(["btree_gist"]),
   checkNormalization: "rollback",
+  schemaCheckExpressions: true,
   nativeRowLevelSecurity: true,
   returning: true,
   scalarArrays: true,
@@ -275,7 +277,8 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   fullTextEngines: Object.freeze(["bm25", "tsvector"]),
   rowLockStrengths: Object.freeze(["update", "noKeyUpdate", "share", "keyShare"]),
   rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
-  advisoryLocks: true
+  advisoryLocks: true,
+  timeOfDayTypes: Object.freeze(["time", "timetz"])
 });
 var SQLITE_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
@@ -284,6 +287,7 @@ var SQLITE_CAPABILITIES = Object.freeze({
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "sourceText",
+  schemaCheckExpressions: false,
   nativeRowLevelSecurity: false,
   returning: true,
   scalarArrays: false,
@@ -300,7 +304,8 @@ var SQLITE_CAPABILITIES = Object.freeze({
   fullTextEngines: Object.freeze(["fts5"]),
   rowLockStrengths: Object.freeze([]),
   rowLockWaitPolicies: Object.freeze([]),
-  advisoryLocks: false
+  advisoryLocks: false,
+  timeOfDayTypes: Object.freeze([])
 });
 var MYSQL_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
@@ -309,6 +314,7 @@ var MYSQL_CAPABILITIES = Object.freeze({
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "temporary",
+  schemaCheckExpressions: false,
   nativeRowLevelSecurity: false,
   returning: false,
   scalarArrays: false,
@@ -325,7 +331,8 @@ var MYSQL_CAPABILITIES = Object.freeze({
   fullTextEngines: Object.freeze(["fulltext"]),
   rowLockStrengths: Object.freeze(["update", "share"]),
   rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
-  advisoryLocks: false
+  advisoryLocks: false,
+  timeOfDayTypes: Object.freeze(["time"])
 });
 var DIALECT_CAPABILITIES = Object.freeze({
   postgres: POSTGRES_CAPABILITIES,
@@ -606,36 +613,121 @@ function isPredicateFieldRef(operand) {
   return operand.kind === "field";
 }
 function predicateFieldNames(params) {
-  const seen = new Set;
+  return [...new Set(inspectPredicate(params).expressions.flatMap((expression) => expression.kind === "field" ? [expression.name] : []))];
+}
+function inspectPredicate(params) {
+  const expressions = [];
+  let checkOnly = false;
+  const expression = (node) => {
+    if (typeof node !== "object" || node === null)
+      throw invalidOperand();
+    switch (node.kind) {
+      case "field":
+        expressions.push(node);
+        return;
+      case "jsonText":
+        if (typeof node.field !== "object" || node.field === null || node.field.kind !== "field")
+          throw invalidOperand();
+        expressions.push(node);
+        checkOnly = true;
+        expression(node.field);
+        return;
+      case "length":
+        expressions.push(node);
+        checkOnly = true;
+        expression(node.expression);
+        return;
+      default:
+        throw invalidOperand();
+    }
+  };
   const walk = (node) => {
     switch (node.kind) {
       case "compare":
-        seen.add(node.left.name);
-        if (isPredicateFieldRef(node.right))
-          seen.add(node.right.name);
+        expression(node.left);
+        if (typeof node.right !== "object" || node.right === null || node.right.kind !== "value")
+          expression(node.right);
         return;
       case "inList":
       case "isNull":
-        seen.add(node.field.name);
+        expression(node.field);
         return;
       case "and":
       case "or":
         for (const operand of node.operands)
           walk(operand);
         return;
+      case "isTrue":
+        checkOnly = true;
+        walk(node.operand);
+        return;
       case "not":
         walk(node.operand);
         return;
     }
   };
   walk(params.predicate);
-  return [...seen];
+  return { expressions, checkOnly };
+}
+function invalidOperand() {
+  return new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: "A schema predicate operand must be a field, jsonText or length expression, or a literal on the right of a comparison",
+    meta: { rule: "predicate-operand-invalid" }
+  });
+}
+function assertPredicateCapabilities(params) {
+  if (!inspectPredicate(params).checkOnly)
+    return;
+  if (params.usage !== "check")
+    throw unsupportedCapability({ dialect: params.dialect, feature: "schema CHECK expressions outside CHECK constraints" });
+  if (!DIALECT_CAPABILITIES[params.dialect].schemaCheckExpressions)
+    throw unsupportedCapability({ dialect: params.dialect, feature: "schemaCheckExpressions" });
 }
 function predicateKey(params) {
+  if (inspectPredicate(params).checkOnly) {
+    const scalar = (node) => {
+      switch (node.kind) {
+        case "field":
+          return ["field", node.name];
+        case "jsonText":
+          return ["jsonText", node.field.name, node.path];
+        case "length":
+          return ["length", scalar(node.expression)];
+      }
+    };
+    const key = (node) => {
+      switch (node.kind) {
+        case "compare":
+          return [node.kind, node.op, scalar(node.left), node.right.kind === "value" ? ["value", node.right.value] : scalar(node.right)];
+        case "inList":
+          return [node.kind, node.field.name, node.negate === true, node.values.map((value) => value.value)];
+        case "isNull":
+          return [node.kind, node.field.name, node.negate === true];
+        case "and":
+        case "or":
+          return [node.kind, node.operands.map(key)];
+        case "not":
+        case "isTrue":
+          return [node.kind, key(node.operand)];
+      }
+    };
+    return `check:${JSON.stringify(key(params.predicate))}`;
+  }
+  const expression = (node) => {
+    switch (node.kind) {
+      case "field":
+        return `f:${node.name}`;
+      case "jsonText":
+        return `jsonText(${JSON.stringify([node.field.name, node.path])})`;
+      case "length":
+        return `length(${expression(node.expression)})`;
+    }
+  };
   const encode = (node) => {
     switch (node.kind) {
       case "compare":
-        return `cmp(${node.op},${node.left.name},${isPredicateFieldRef(node.right) ? `f:${node.right.name}` : `v:${typeof node.right.value}:${String(node.right.value)}`})`;
+        return `cmp(${node.op},${node.left.kind === "field" ? node.left.name : expression(node.left)},${node.right.kind === "value" ? `v:${typeof node.right.value}:${String(node.right.value)}` : expression(node.right)})`;
       case "inList":
         return `in${node.negate === true ? "!" : ""}(${node.field.name},[${node.values.map((entry) => `${typeof entry.value}:${String(entry.value)}`).join("|")}])`;
       case "isNull":
@@ -645,10 +737,26 @@ function predicateKey(params) {
         return `${node.kind}(${node.operands.map(encode).join(",")})`;
       case "not":
         return `not(${encode(node.operand)})`;
+      case "isTrue":
+        return `isTrue(${encode(node.operand)})`;
     }
   };
   return encode(params.predicate);
 }
+// packages/schema/src/time-of-day.ts
+var TIME_OF_DAY_NATIVE_TYPE = /^time(tz)?(?:\(\d+\))?$|^time(?:\(\d+\))?with(out)?timezone$/;
+function timeOfDayType(params) {
+  if (params.nativeType === undefined)
+    return;
+  const match = TIME_OF_DAY_NATIVE_TYPE.exec(params.nativeType.toLowerCase().replace(/\s+/g, ""));
+  if (match === null)
+    return;
+  if (match[1] !== undefined)
+    return "timetz";
+  if (match[0].endsWith("withtimezone") && match[2] === undefined)
+    return "timetz";
+  return "time";
+}
 // packages/schema/src/prisma-literal.ts
 var STRING_ESCAPES = {
   '"': '"',
@@ -785,6 +893,7 @@ var RESERVED_CLIENT_NAMES = [
   "$disconnect",
   "$transaction",
   "$querySql",
+  "$querySqlResult",
   "$executeSql",
   "$queryRaw",
   "$queryRawUnsafe",
@@ -1079,6 +1188,80 @@ function scalarListDefault(params) {
   });
 }
 
+// packages/schema/src/json-schema-ref.ts
+var EXPORT_NAME = /^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u;
+var REFERENCE_ANNOTATION = /@(schema|type)\(\s*([$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*)\s+from\s+("(?:[^"\\\r\n]|\\.)*")\s*\)/gu;
+function annotations(params) {
+  const matches = [...params.documentation.matchAll(REFERENCE_ANNOTATION)].filter((match) => match[1] === params.kind);
+  const remaining = params.documentation.replace(REFERENCE_ANNOTATION, "");
+  const malformed = remaining.match(params.kind === "schema" ? /@schema(?=\s*\(|\s|$)/gu : /@type(?=\s*\(|\s|$)/gu) ?? [];
+  return { matches, count: matches.length + malformed.length };
+}
+function hasJsonSchemaAnnotation(params) {
+  return annotations({ documentation: params.documentation ?? "", kind: "schema" }).count > 0;
+}
+function jsonTypeAnnotationIssue(params) {
+  const refs = annotations({ documentation: params.documentation ?? "", kind: "type" });
+  if (refs.count === 0)
+    return;
+  if (refs.count > 1)
+    return "A field may declare only one assertion-only JSON type";
+  const match = refs.matches[0];
+  if (match === undefined)
+    return 'Expected @type(Name from "specifier")';
+  return jsonSchemaRefIssue({ value: { name: match[2], from: decodePrismaString({ raw: match[3] }) } });
+}
+function jsonTypeAnnotationRef(params) {
+  const issue = jsonTypeAnnotationIssue(params);
+  if (issue !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { issues: [{ rule: "invalid-json-type-ref", message: issue }] } });
+  const match = annotations({ documentation: params.documentation ?? "", kind: "type" }).matches[0];
+  return match === undefined ? undefined : assertJsonSchemaRef({ value: { name: match[2], from: decodePrismaString({ raw: match[3] }) } });
+}
+function jsonSchemaRefIssue(params) {
+  const { value } = params;
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return "JSON schema reference must be { name, from }; validators belong in the referenced export";
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== 2 || !keys.includes("name") || !keys.includes("from"))
+    return "JSON schema reference accepts only name and from";
+  const name = Object.getOwnPropertyDescriptor(value, "name");
+  const from = Object.getOwnPropertyDescriptor(value, "from");
+  if (name?.enumerable !== true || !("value" in name) || typeof name.value !== "string" || !EXPORT_NAME.test(name.value) || name.value === "default")
+    return "JSON schema name must be a valid named export, not default";
+  if (from?.enumerable !== true || !("value" in from) || typeof from.value !== "string" || from.value.trim().length === 0 || /[\u0000-\u001f\u007f]/u.test(from.value))
+    return "JSON schema from must be a non-empty import specifier without control characters";
+  return;
+}
+function assertJsonSchemaRef(params) {
+  const issue = jsonSchemaRefIssue(params);
+  if (issue !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { issues: [{ rule: "invalid-json-schema-ref", message: issue }] } });
+  const value = params.value;
+  return Object.freeze({ name: value.name, from: value.from });
+}
+function normalizeJsonSchemaRef(params) {
+  const { documentation, reference } = params;
+  const jsonType = jsonTypeAnnotationRef({ documentation });
+  const refs = annotations({ documentation: documentation ?? "", kind: "schema" });
+  let jsonSchema = reference === undefined ? undefined : assertJsonSchemaRef({ value: reference });
+  let remaining = documentation;
+  if (refs.count > 1 || refs.count > 0 && 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" }] } });
+  if (refs.count === 1) {
+    const match = refs.matches[0];
+    if (match === undefined)
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: 'Expected @schema(Name from "specifier")', meta: { issues: [{ rule: "invalid-json-schema-ref" }] } });
+    jsonSchema = assertJsonSchemaRef({ value: { name: match[2], from: decodePrismaString({ raw: match[3] }) } });
+    remaining = documentation?.replace(match[0], "").trim();
+    if (remaining === "")
+      remaining = undefined;
+  }
+  if (jsonSchema !== undefined && jsonType !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "JSON schema validation and assertion-only @type cannot be combined on one field", meta: { issues: [{ rule: "conflicting-json-schema-ref" }] } });
+  return { ...remaining === undefined ? {} : { documentation: remaining }, ...jsonSchema === undefined ? {} : { jsonSchema } };
+}
+
 // packages/schema/src/m2m.ts
 function implicitJoinTable(params) {
   const sorted = [params.modelA, params.modelB].sort();
@@ -1104,6 +1287,8 @@ var RESERVED_ENUM_NAMES = [
   "SqlColumn",
   "SqlFragment",
   "ResultDecoder",
+  "ResultReadDecoder",
+  "SqlQueryResult",
   "ExtendedDateTime",
   "enumValidators",
   "enumValidator",
@@ -1113,6 +1298,11 @@ var RESERVED_ENUM_NAMES = [
   "UncertainKeys",
   "HasSelectedField",
   "Provided",
+  "SelectionMember",
+  "SelectionValue",
+  "BagKeys",
+  "IncludedRelation",
+  "IncludedCount",
   "ViewDelegateMap",
   "extensionManifest",
   "extensionMounts",
@@ -1155,6 +1345,9 @@ var RESERVED_ENUM_NAMES = [
   "InputJsonValue",
   "InputJsonArray",
   "InputJsonObject",
+  "BoundJsonFilter",
+  "BoundJsonFilterCommon",
+  "BoundJsonNullableFilter",
   "VibeTelemetryOptions",
   "VibeTelemetryExporter",
   "VibeTelemetryOperationEvent",
@@ -1226,6 +1419,18 @@ var GENERATED_TYPE_NAMES = {
     "SumAggregateInput",
     "MinAggregateInput",
     "MaxAggregateInput",
+    "CountAggregateHavingInput",
+    "AvgAggregateHavingInput",
+    "SumAggregateHavingInput",
+    "MinAggregateHavingInput",
+    "MaxAggregateHavingInput",
+    "CountAggregateOrderByInput",
+    "AvgAggregateOrderByInput",
+    "SumAggregateOrderByInput",
+    "MinAggregateOrderByInput",
+    "MaxAggregateOrderByInput",
+    "HavingInput",
+    "GroupByOrderByInput",
     "FindManyArgs",
     "FindPageArgs",
     "FindFirstArgs",
@@ -1254,6 +1459,7 @@ var GENERATED_TYPE_NAMES = {
     "AggregateSelection",
     "CountOutput",
     "RelationPayload",
+    "ResolvedSelection",
     "IncludePayload",
     "GetPayload",
     "AggregateResult",
@@ -1395,6 +1601,57 @@ function validateGeneratedNames(params) {
       register({ name: `${declared.name}${suffix}`, owner: `enum "${declared.name}"` });
   }
 }
+function foreignKeyKeys(params) {
+  const distinct = new Set;
+  const repeated = [];
+  for (const fields of params.keys) {
+    if (new Set(fields).size === fields.length)
+      distinct.add(JSON.stringify([...fields].sort()));
+    else
+      repeated.push(fields);
+  }
+  return { distinct, repeated };
+}
+function matchesForeignKey(params) {
+  if (params.keys.distinct.has(JSON.stringify([...params.references].sort())))
+    return true;
+  return params.keys.repeated.some((fields) => fields.length === params.references.length && fields.every((name) => params.references.includes(name)));
+}
+function referencesPartialOnly(params) {
+  const { target, references, schema, lookups } = params;
+  let partial = lookups.partialKeys.get(target);
+  if (partial === undefined) {
+    partial = foreignKeyKeys({ keys: target.indexes.filter((index) => index.kind === "unique" && (index.where !== undefined || index.wherePredicate !== undefined)).map((index) => index.fields.map((field) => field.name)) });
+    lookups.partialKeys.set(target, partial);
+  }
+  if (partial.distinct.size === 0 && partial.repeated.length === 0)
+    return false;
+  if (!matchesForeignKey({ keys: partial, references }))
+    return false;
+  let total = lookups.totalKeys.get(target);
+  if (total === undefined) {
+    total = foreignKeyKeys({ keys: [
+      ...target.fields.filter((field) => field.isId || field.isUnique).map((field) => [field.name]),
+      ...target.primaryKey === undefined ? [] : [target.primaryKey.fields],
+      ...target.indexes.filter((index) => index.kind === "unique" && index.where === undefined && index.wherePredicate === undefined).map((index) => index.fields.map((field) => field.name))
+    ] });
+    lookups.totalKeys.set(target, total);
+  }
+  if (matchesForeignKey({ keys: total, references }))
+    return false;
+  if (lookups.independentTables === undefined) {
+    const tables = new Set;
+    for (const object of schema.migrationObjects ?? []) {
+      const identity = object.identity;
+      if (identity.kind === "index" || identity.kind === "constraint" && (identity.constraintType === "unique" || identity.constraintType === "primaryKey")) {
+        tables.add(JSON.stringify([identity.table.namespace, identity.table.name]));
+      }
+    }
+    lookups.independentTables = tables;
+  }
+  const placement = qualifiedSqlName({ name: target.dbName ?? target.name, namespace: target.namespace });
+  return !lookups.independentTables.has(JSON.stringify([placement.namespace, placement.name]));
+}
 function validateSchemaIR(params) {
   const { schema } = params;
   const issues = [];
@@ -1465,8 +1722,18 @@ function validateSchemaIR(params) {
       });
     }
   }
+  const fieldsByModel = new Map;
   for (const model of schema.models) {
-    validateModel({ model, modelByName, enumByName, issues });
+    const fields = new Map;
+    for (const field of model.fields)
+      if (!fields.has(field.name))
+        fields.set(field.name, field);
+    fieldsByModel.set(model, fields);
+  }
+  const lookups = { fieldsByModel, partialKeys: new Map, totalKeys: new Map };
+  const postgres = providerToDialect({ provider: schema.datasource.provider }) === "postgres";
+  for (const model of schema.models) {
+    validateModel({ model, modelByName, enumByName, issues, schema, lookups, postgres });
   }
   for (const model of schema.models) {
     for (const relation of model.relations) {
@@ -1511,19 +1778,11 @@ function validateSchemaIR(params) {
     }
   }
   for (const model of schema.models) {
-    const fieldNames = new Set(model.fields.map((field) => field.name));
-    const defaultKeys = new Set;
-    if (model.primaryKey !== undefined && model.primaryKey.fields.length > 1 && model.primaryKey.clientName === undefined) {
-      defaultKeys.add(model.primaryKey.fields.join("_"));
-    }
-    for (const index of model.indexes) {
-      if (index.kind === "unique" && index.where === undefined && index.fields.length > 1 && index.clientName === undefined) {
-        defaultKeys.add(index.fields.map((field) => field.name).join("_"));
-      }
-    }
-    const seenSelectorNames = new Set;
+    const fieldNames = fieldsByModel.get(model);
+    const seenSelectorNames = new Map;
+    const addressable = (names) => names.every((name) => fieldNames.get(name)?.isUnsupported !== true);
     const checkSelectorName = (params) => {
-      const { clientName, fieldCount, where, isUnique, site } = params;
+      const { clientName, fields, where, isUnique, site } = params;
       if (!isUnique) {
         issues.push({
           rule: "client-name-non-unique",
@@ -1540,7 +1799,7 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      if (fieldCount < 2) {
+      if (fields.length < 2) {
         issues.push({
           rule: "client-name-single-field",
           message: `name: ("${clientName}") on a single-field ${site} of "${model.name}" \u2014 the field itself is the selector; name: applies to compound groups only`,
@@ -1548,7 +1807,9 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      if (fieldNames.has(clientName) || defaultKeys.has(clientName) || seenSelectorNames.has(clientName)) {
+      const tuple = JSON.stringify(fields);
+      const previous = seenSelectorNames.get(clientName);
+      if (fieldNames.has(clientName) || previous !== undefined && previous !== tuple) {
         issues.push({
           rule: "client-name-collision",
           message: `name: ("${clientName}") on "${model.name}" collides with a field or another unique selector \u2014 WhereUniqueInput keys must be unambiguous`,
@@ -1556,22 +1817,22 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      seenSelectorNames.add(clientName);
+      seenSelectorNames.set(clientName, tuple);
     };
-    if (model.primaryKey !== undefined && model.primaryKey.clientName !== undefined) {
+    if (model.primaryKey !== undefined && (model.primaryKey.clientName !== undefined || model.primaryKey.fields.length > 1 && addressable(model.primaryKey.fields))) {
       checkSelectorName({
-        clientName: model.primaryKey.clientName,
-        fieldCount: model.primaryKey.fields.length,
+        clientName: model.primaryKey.clientName ?? model.primaryKey.fields.join("_"),
+        fields: model.primaryKey.fields,
         isUnique: true,
         site: "@@id"
       });
     }
     for (const index of model.indexes) {
-      if (index.clientName === undefined)
+      if (index.clientName === undefined && (index.kind !== "unique" || index.where !== undefined || index.fields.length < 2 || !addressable(index.fields.map((field) => field.name))))
         continue;
       checkSelectorName({
-        clientName: index.clientName,
-        fieldCount: index.fields.length,
+        clientName: index.clientName ?? index.fields.map((field) => field.name).join("_"),
+        fields: index.fields.map((field) => field.name),
         ...index.where === undefined ? {} : { where: index.where },
         isUnique: index.kind === "unique",
         site: "@@unique"
@@ -1579,13 +1840,13 @@ function validateSchemaIR(params) {
     }
   }
   validateIdentifierLengths({ schema, issues });
-  validatePhysicalNameUniqueness({ schema, issues });
+  validatePhysicalNameUniqueness({ schema, issues, modelByName, fieldsByModel });
   validateGeneratedNames({ schema, issues });
   validateNativeRls({ schema, issues });
   return issues;
 }
 function validatePhysicalNameUniqueness(params) {
-  const { schema, issues } = params;
+  const { schema, issues, modelByName, fieldsByModel } = params;
   const dialect = providerToDialect({ provider: schema.datasource.provider });
   const owners = new Map;
   const claim = (entry) => {
@@ -1615,7 +1876,8 @@ function validatePhysicalNameUniqueness(params) {
     }
     if (model.isView)
       continue;
-    const columnOf = (name) => model.fields.find((candidate) => candidate.name === name)?.dbName ?? name;
+    const fields = fieldsByModel.get(model);
+    const columnOf = (name) => fields.get(name)?.dbName ?? name;
     const seenIndexKeys = new Set;
     const declarations = [
       ...model.indexes.map((index) => ({ index, site: index.kind === "unique" ? "@@unique" : "@@index" })),
@@ -1623,8 +1885,8 @@ function validatePhysicalNameUniqueness(params) {
     ];
     for (const { index, site } of declarations) {
       const unique = index.kind === "unique";
-      const columns = index.fields.map((entry) => `${columnOf(entry.name)}${entry.sort === "desc" ? " desc" : ""}`);
-      const key = `${unique ? "u" : "i"}${index.nullsNotDistinct === true ? "n" : ""}:${unique ? "btree" : index.kind}:${columns.join(",")}:${index.where?.trim() ?? ""}`;
+      const columns = index.fields.map((entry) => [columnOf(entry.name), entry.sort === "desc", entry.operatorClass === undefined ? null : [entry.operatorClass.namespace, entry.operatorClass.name]]);
+      const key = JSON.stringify([unique, index.nullsNotDistinct === true, unique ? "btree" : index.kind, columns, index.where?.trim() ?? ""]);
       if (seenIndexKeys.has(key))
         continue;
       seenIndexKeys.add(key);
@@ -1642,7 +1904,7 @@ function validatePhysicalNameUniqueness(params) {
     for (const relation of model.relations) {
       if (relation.fields === undefined || relation.fields.length === 0)
         continue;
-      const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+      const target = modelByName.get(relation.targetModel);
       if (target !== undefined && target.isView)
         continue;
       const name = relation.constraintName ?? defaultForeignKeyName({ table, columns: relation.fields.map((entry) => columnOf(entry)), dialect });
@@ -1671,7 +1933,7 @@ function validatePhysicalNameUniqueness(params) {
         continue;
       if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
         continue;
-      const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+      const target = modelByName.get(relation.targetModel);
       const physicalNamespace = model.namespace ?? "public";
       if ((target?.namespace ?? "public") !== physicalNamespace) {
         issues.push({ rule: "implicit-join-namespace", message: "Implicit many-to-many endpoints must share one fixed namespace", model: model.name, field: relation.name });
@@ -1770,7 +2032,7 @@ function validateIdentifierLengths(params) {
   }
 }
 function validateModel(params) {
-  const { model, modelByName, enumByName, issues } = params;
+  const { model, modelByName, enumByName, issues, lookups, postgres } = params;
   const memberNames = new Set;
   for (const field of model.fields) {
     if (memberNames.has(field.name)) {
@@ -1782,6 +2044,23 @@ function validateModel(params) {
       });
     }
     memberNames.add(field.name);
+    const typedIssue = jsonTypeAnnotationIssue({ documentation: field.documentation });
+    if (typedIssue !== undefined)
+      issues.push({ rule: "invalid-json-type-ref", message: typedIssue, model: model.name, field: field.name });
+    const hasType = typedIssue === undefined && jsonTypeAnnotationRef({ documentation: field.documentation }) !== undefined;
+    if (hasType && field.type !== "Json")
+      issues.push({ rule: "json-type-non-json", message: "JSON type assertions are only valid on Json fields", model: model.name, field: field.name });
+    if (field.jsonSchema !== undefined) {
+      const issue = jsonSchemaRefIssue({ value: field.jsonSchema });
+      if (issue !== undefined)
+        issues.push({ rule: "invalid-json-schema-ref", message: issue, model: model.name, field: field.name });
+      if (field.type !== "Json" || field.isUnsupported === true)
+        issues.push({ rule: "json-schema-non-json", message: "JSON schemas are only valid on queryable Json fields", model: model.name, field: field.name });
+      if (hasType)
+        issues.push({ rule: "conflicting-json-schema-ref", message: "A field cannot declare both @type and a JSON schema", model: model.name, field: field.name });
+    }
+    if (hasJsonSchemaAnnotation({ documentation: field.documentation }))
+      issues.push({ rule: "unnormalized-json-schema-ref", message: "Normalize @schema documentation into FieldIR.jsonSchema before consuming SchemaIR", model: model.name, field: field.name });
     const typeIdentity = field.nativeTypeIdentity;
     if (typeIdentity !== undefined && (typeIdentity === null || typeof typeIdentity !== "object" || field.isUnsupported !== true || typeof typeIdentity.source !== "string" || typeIdentity.source !== field.nativeType || typeof typeIdentity.namespace !== "string" || typeIdentity.namespace.length === 0 || typeIdentity.namespace.includes("\x00"))) {
       issues.push({ rule: "invalid-native-type-identity", message: `PostgreSQL type identity on "${model.name}.${field.name}" must be bound to its unsupported declaration`, model: model.name, field: field.name });
@@ -1872,8 +2151,23 @@ function validateModel(params) {
     }
     memberNames.add(relation.name);
   }
-  const fieldNames = new Set(model.fields.map((f) => f.name));
-  const hasIdField = model.fields.some((f) => f.isId);
+  const fieldNames = new Set(lookups.fieldsByModel.get(model).keys());
+  const idFields = model.fields.filter((f) => f.isId);
+  const hasIdField = idFields.length > 0;
+  if (idFields.length > 1) {
+    issues.push({
+      rule: "multiple-field-ids",
+      message: `Model "${model.name}" has multiple @id fields (${idFields.map((field) => field.name).join(", ")}); declare one compound primary key instead`,
+      model: model.name
+    });
+  }
+  if (idFields.length === 1 && model.primaryKey !== undefined && (model.primaryKey.fields.length !== 1 || model.primaryKey.fields[0] !== idFields[0]?.name)) {
+    issues.push({
+      rule: "conflicting-primary-key",
+      message: `Model "${model.name}" declares @id on "${idFields[0]?.name}" and a different block primary key; both declarations must name the same single logical field`,
+      model: model.name
+    });
+  }
   if (!model.isView && !hasIdField && model.primaryKey === undefined) {
     issues.push({
       rule: "missing-id",
@@ -1932,8 +2226,14 @@ function validateModel(params) {
           });
         }
       }
+      if (postgres && new Set(relation.references).size !== relation.references.length) {
+        issues.push({ rule: "relation-duplicate-column", message: `Relation "${model.name}.${relation.name}" repeats a referenced column`, model: model.name, field: relation.name });
+      }
       if (target !== undefined) {
-        const targetFieldNames = new Set(target.fields.map((f) => f.name));
+        if (postgres && referencesPartialOnly({ target, references: relation.references, schema: params.schema, lookups })) {
+          issues.push({ rule: "relation-partial-only-target", message: `Relation "${model.name}.${relation.name}" references only a partial unique key`, model: model.name, field: relation.name });
+        }
+        const targetFieldNames = lookups.fieldsByModel.get(target);
         for (const refField of relation.references) {
           if (!targetFieldNames.has(refField)) {
             issues.push({
@@ -2004,6 +2304,8 @@ function validateModel(params) {
         model,
         fieldNames,
         site: `CHECK "${check.name}"`,
+        usage: "check",
+        dialect: providerToDialect({ provider: params.schema.datasource.provider }),
         issues
       });
     }
@@ -2025,13 +2327,55 @@ function validateModel(params) {
         model,
         fieldNames,
         site: `partial index on [${index.fields.map((entry) => entry.name).join(", ")}]`,
+        usage: "indexPredicate",
+        dialect: providerToDialect({ provider: params.schema.datasource.provider }),
         issues
       });
     }
   }
+  for (const exclusion of model.exclusions ?? []) {
+    const predicate = exclusion.source?.where;
+    if (predicate !== undefined)
+      validatePredicateFields({ predicate, model, fieldNames, site: `exclusion "${exclusion.name}"`, usage: "exclusionPredicate", dialect: providerToDialect({ provider: params.schema.datasource.provider }), issues });
+  }
 }
 function validatePredicateFields(params) {
   const { predicate, model, fieldNames, site, issues } = params;
+  const inspection = inspectPredicate({ predicate });
+  if (inspection.checkOnly && (params.usage !== "check" || !DIALECT_CAPABILITIES[params.dialect].schemaCheckExpressions)) {
+    issues.push({ rule: "predicate-check-capability", message: `${site}: computed schema predicates require a PostgreSQL CHECK`, model: model.name });
+  }
+  const expressionType = (expression) => {
+    if (expression.kind === "field")
+      return model.fields.find((field) => field.name === expression.name)?.type;
+    if (expression.kind === "jsonText") {
+      const field = model.fields.find((candidate) => candidate.name === expression.field.name);
+      if (field !== undefined && (field.type !== "Json" || field.isUnsupported === true))
+        issues.push({ rule: "predicate-type-mismatch", message: `${site}: jsonText requires a Json field`, model: model.name, field: field.name });
+      if (!Array.isArray(expression.path) || Array.from(expression.path).some((segment) => typeof segment !== "string" || segment.includes("\x00")))
+        issues.push({ rule: "predicate-json-path", message: `${site}: jsonText requires a string-only path without NUL bytes`, model: model.name });
+      return "String";
+    }
+    if (expressionType(expression.expression) !== "String")
+      issues.push({ rule: "predicate-type-mismatch", message: `${site}: length requires a text expression`, model: model.name });
+    return "Int";
+  };
+  const validateComputedComparisons = (node) => {
+    if (node.kind === "compare") {
+      if (node.left.kind !== "field" || node.right.kind !== "value" && node.right.kind !== "field") {
+        const left = expressionType(node.left);
+        const right = node.right.kind === "value" ? undefined : expressionType(node.right);
+        if (left !== undefined && right !== undefined && left !== right)
+          issues.push({ rule: "predicate-type-mismatch", message: `${site}: computed comparison operands must have the same scalar type`, model: model.name });
+        if (node.right.kind === "value" && left === "String" && typeof node.right.value !== "string")
+          issues.push({ rule: "predicate-type-mismatch", message: `${site}: a text expression requires a string literal`, model: model.name });
+      }
+    } else if (node.kind === "and" || node.kind === "or")
+      node.operands.forEach(validateComputedComparisons);
+    else if (node.kind === "not" || node.kind === "isTrue")
+      validateComputedComparisons(node.operand);
+  };
+  validateComputedComparisons(predicate);
   for (const name of predicateFieldNames({ predicate })) {
     if (!fieldNames.has(name)) {
       issues.push({
@@ -2042,7 +2386,10 @@ function validatePredicateFields(params) {
       });
       continue;
     }
-    if (model.fields.find((field) => field.name === name)?.isList === true) {
+    const referenced = model.fields.find((field) => field.name === name);
+    if (inspection.checkOnly && referenced?.isUnsupported === true)
+      issues.push({ rule: "predicate-unsupported-type", message: `${site}: computed predicates cannot reference unsupported fields`, model: model.name, field: name });
+    if (referenced?.isList === true) {
       issues.push({
         rule: "predicate-list-field",
         message: `${site} on "${model.name}" compares scalar list "${name}" \u2014 use a raw expression for array operators`,
@@ -2069,6 +2416,12 @@ function assertValidSchemaIR(params) {
         throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Enum reference namespace differs from its declared native type", meta: { rule: "enum-namespace", model: model.name, field: field.name } });
     }
   for (const model of params.schema.models) {
+    for (const check of model.checks ?? [])
+      if (check.predicate !== undefined)
+        assertPredicateCapabilities({ predicate: check.predicate, dialect, usage: "check" });
+    for (const index of model.indexes)
+      if (index.wherePredicate !== undefined)
+        assertPredicateCapabilities({ predicate: index.wherePredicate, dialect, usage: "indexPredicate" });
     if (model.exclusions !== undefined && !Array.isArray(model.exclusions))
       throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Exclusions must be an array", meta: { rule: "exclusion-definition" } });
     if ((model.exclusions?.length ?? 0) === 0)
@@ -2082,6 +2435,8 @@ function assertValidSchemaIR(params) {
         throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Invalid exclusion declaration", meta: { rule: "exclusion-definition" } });
       const source = exclusion.source;
       if (source !== undefined) {
+        if (source.where !== undefined)
+          assertPredicateCapabilities({ predicate: source.where, dialect, usage: "exclusionPredicate" });
         const references = [...source.keys.flatMap((key) => ("field" in key) ? [key.field] : key.fields), ...[source.range.lower, source.range.upper].flatMap((endpoint) => ("field" in endpoint) ? [endpoint.field] : []), ...source.where === undefined ? [] : predicateFieldNames({ predicate: source.where })];
         if (references.some((name) => !model.fields.some((field) => field.name === name && !field.isList)))
           throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Exclusion references an unknown or list field", meta: { rule: "exclusion-field", model: model.name } });
@@ -2101,6 +2456,16 @@ function assertValidSchemaIR(params) {
     if (dialect === "mysql" && counters.length > 1)
       throw unsupportedCapability({ dialect, feature: "multiple auto-increment columns" });
     for (const field of model.fields) {
+      const timeOfDay = field.isUnsupported === true || field.type !== "DateTime" ? undefined : timeOfDayType({ nativeType: field.nativeType });
+      if (timeOfDay !== undefined && !DIALECT_CAPABILITIES[dialect].timeOfDayTypes.includes(timeOfDay)) {
+        const instead = dialect === "sqlite" ? "sqlite has no time-of-day column type; store a plain DateTime or a String" : "there is no time-with-offset type here; use @db.Time(n), which stores the UTC time of day";
+        const error = unsupportedCapability({ dialect, feature: "timeOfDayTypes", hint: `${model.name}.${field.name} declares @db.${field.nativeType ?? ""} (${timeOfDay}) \u2014 ${instead}` });
+        throw new VibeError({ code: error.code, message: error.message, meta: { ...error.meta, model: model.name, field: field.name, nativeType: field.nativeType } });
+      }
+      if (timeOfDay !== undefined && dialect === "mysql" && field.default?.kind === "now") {
+        const error = unsupportedCapability({ dialect, feature: "@default(now()) on a TIME column", hint: `${model.name}.${field.name} \u2014 MySQL has no current-time default for TIME; drop the default and write the value (or use @updatedAt)` });
+        throw new VibeError({ code: error.code, message: error.message, meta: { ...error.meta, model: model.name, field: field.name, nativeType: field.nativeType } });
+      }
       if (field.default?.kind === "list") {
         if (dialect !== "postgres")
           throw unsupportedCapability({ dialect, feature: "scalar-list defaults" });
@@ -2333,7 +2698,9 @@ export {
   VibeError,
   assertIdentifierFits,
   assertIndexOperatorClasses,
+  assertJsonSchemaRef,
   assertMigrationObjects,
+  assertPredicateCapabilities,
   assertSqlNamespace,
   assertValidSchemaIR,
   buildComputedManifest,
@@ -2352,9 +2719,11 @@ export {
   extensionOptionsHash,
   fieldTypeIdentity,
   fitDefaultName,
+  hasJsonSchemaAnnotation,
   identifierLength,
   implicitJoinTable,
   implicitJoinTableObjectNames,
+  inspectPredicate,
   internalError,
   invalidStoredData,
   isEnumType,
@@ -2364,7 +2733,11 @@ export {
   isReservedDelegateName,
   isSqlObjectDefinition,
   isSqlObjectIdentity,
+  jsonSchemaRefIssue,
+  jsonTypeAnnotationIssue,
+  jsonTypeAnnotationRef,
   mergeExtensionDeclarations,
+  normalizeJsonSchemaRef,
   postgresGeneratedObjectName,
   predicateFieldNames,
   predicateKey,
@@ -2376,10 +2749,11 @@ export {
   sqlNamespaceIssue,
   sqlObjectKey,
   sqlObjectNamespace,
+  timeOfDayType,
   unsupportedCapability,
   validateComputedConfig,
   validateRlsContextIR,
   validateSchemaIR
 };
 
-//# debugId=20984641ACA6D36E64756E2164756E21
+//# debugId=6D288D6F1DD93E5864756E2164756E21