prisma-guard 1.24.0 → 1.26.0

package/dist/runtime/index.cjs

@@ -373,12 +373,24 @@ var JSON_ARRAY_OPERATORS = /* @__PURE__ */ new Set([
   "array_starts_with",
   "array_ends_with"
 ]);
-function getSupportedOperators(fieldMeta) {
-  if (fieldMeta.isList)
+function getSupportedOperators(input, isList = false, isEnum = false) {
+  let fieldType;
+  let list;
+  let enumField;
+  if (typeof input === "string") {
+    fieldType = input;
+    list = isList;
+    enumField = isEnum;
+  } else {
+    fieldType = input.type;
+    list = input.isList;
+    enumField = input.isEnum === true;
+  }
+  if (list)
     return [...SCALAR_LIST_OPERATORS];
-  if (fieldMeta.isEnum)
+  if (enumField)
     return [...ENUM_OPERATORS];
-  const ops = SCALAR_OPERATORS[fieldMeta.type];
+  const ops = SCALAR_OPERATORS[fieldType];
   if (!ops)
     return [];
   return [...ops];
@@ -439,15 +451,14 @@ function createJsonOperatorSchema(fieldMeta, operator) {
   if (JSON_ARRAY_OPERATORS.has(operator)) {
     return jsonValue;
   }
-  throw new ShapeError(
-    `Operator "${operator}" not supported for Json fields`
-  );
+  throw new ShapeError(`Operator "${operator}" not supported for Json fields`);
 }
 function buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase) {
   const allOps = getSupportedOperators(fieldMeta);
-  const nestedOps = allOps.filter((o) => o !== "not");
-  if (nestedOps.length === 0)
+  const nestedOps = allOps.filter((op) => op !== "not");
+  if (nestedOps.length === 0) {
     return scalarSchema;
+  }
   const nestedSchemas = {};
   for (const op of nestedOps) {
     nestedSchemas[op] = createOperatorSchema(
@@ -459,14 +470,35 @@ function buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase) {
   }
   const nestedKeys = Object.keys(nestedSchemas);
   const nestedObj = import_zod2.z.object(nestedSchemas).strict().refine(
-    (v) => nestedKeys.some(
-      (k) => v[k] !== void 0
+    (value) => nestedKeys.some(
+      (key) => value[key] !== void 0
     ),
     { message: "not filter must specify at least one operator" }
   );
   return import_zod2.z.union([scalarSchema, nestedObj]);
 }
 function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
+  const allowedOps = getSupportedOperators(fieldMeta);
+  if (!allowedOps.includes(operator)) {
+    if (fieldMeta.isList) {
+      throw new ShapeError(
+        `Operator "${operator}" not supported for scalar list fields`
+      );
+    }
+    if (fieldMeta.isEnum) {
+      throw new ShapeError(
+        `Operator "${operator}" not supported for enum fields`
+      );
+    }
+    if (fieldMeta.type === "Bytes" && allowedOps.length === 0) {
+      throw new ShapeError(
+        `Type "${fieldMeta.type}" does not support filter operators`
+      );
+    }
+    throw new ShapeError(
+      `Operator "${operator}" not supported for type "${fieldMeta.type}"`
+    );
+  }
   if (fieldMeta.isList) {
     return createScalarListOperatorSchema(
       fieldMeta,
@@ -480,50 +512,35 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
     if (!values || values.length === 0) {
       throw new ShapeError(`Unknown enum: ${fieldMeta.type}`);
     }
-    if (!ENUM_OPERATORS.has(operator)) {
-      throw new ShapeError(
-        `Operator "${operator}" not supported for enum fields`
-      );
-    }
     const enumSchema = import_zod2.z.enum(values);
     if (operator === "equals") {
       return !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
     }
     if (operator === "not") {
       const scalarSchema = !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
-      return buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase);
+      return buildNotFilterSchema(
+        fieldMeta,
+        scalarSchema,
+        enumMap,
+        scalarBase
+      );
     }
     const itemSchema = !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
     return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemSchema));
   }
   if (fieldMeta.type === "Json") {
-    const supportedOps2 = SCALAR_OPERATORS["Json"];
-    if (!supportedOps2 || !supportedOps2.has(operator)) {
-      throw new ShapeError(
-        `Operator "${operator}" not supported for type "Json"`
-      );
-    }
     if (operator === "not") {
       const jsonValue = import_zod2.z.unknown();
       const scalarSchema = !fieldMeta.isRequired ? import_zod2.z.union([jsonValue, import_zod2.z.null()]) : jsonValue;
-      return buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase);
+      return buildNotFilterSchema(
+        fieldMeta,
+        scalarSchema,
+        enumMap,
+        scalarBase
+      );
     }
     return createJsonOperatorSchema(fieldMeta, operator);
   }
-  const supportedOps = SCALAR_OPERATORS[fieldMeta.type];
-  if (!supportedOps) {
-    throw new ShapeError(`Unknown scalar type for operator: ${fieldMeta.type}`);
-  }
-  if (supportedOps.size === 0) {
-    throw new ShapeError(
-      `Type "${fieldMeta.type}" does not support filter operators`
-    );
-  }
-  if (!supportedOps.has(operator)) {
-    throw new ShapeError(
-      `Operator "${operator}" not supported for type "${fieldMeta.type}"`
-    );
-  }
   const factory = scalarBase[fieldMeta.type];
   if (!factory) {
     throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
@@ -999,33 +1016,67 @@ function mergeWhereForced(where, forced) {
   }
   return result;
 }
+function uniqueValuesEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b))
+      return false;
+    if (a.length !== b.length)
+      return false;
+    return a.every((v, i) => uniqueValuesEqual(v, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    return aKeys.every((key) => key in b && uniqueValuesEqual(a[key], b[key]));
+  }
+  return false;
+}
+function mergeUniqueValue(target, key, value) {
+  const cloned = deepClone(value);
+  if (!(key in target)) {
+    target[key] = cloned;
+    return;
+  }
+  const existing = target[key];
+  if (isPlainObject(existing) && isPlainObject(cloned)) {
+    const merged = { ...existing };
+    for (const [nestedKey, nestedValue] of Object.entries(cloned)) {
+      if (nestedKey in merged && !uniqueValuesEqual(merged[nestedKey], nestedValue)) {
+        throw new ShapeError(
+          `Conflicting unique where value for "${key}.${nestedKey}"`
+        );
+      }
+      merged[nestedKey] = nestedValue;
+    }
+    target[key] = merged;
+    return;
+  }
+  if (!uniqueValuesEqual(existing, cloned)) {
+    throw new ShapeError(`Conflicting unique where value for "${key}"`);
+  }
+}
 function mergeUniqueWhereForced(where, forced) {
   if (!hasWhereForced(forced))
     return where ?? {};
-  let result = where ? { ...where } : {};
-  for (const [relName, opMap] of Object.entries(forced.relations)) {
-    if (!result[relName] || typeof result[relName] !== "object") {
-      result[relName] = {};
-    }
-    const relObj = result[relName];
-    for (const [op, nestedForced] of Object.entries(opMap)) {
-      relObj[op] = mergeWhereForced(
-        relObj[op],
-        nestedForced
-      );
-    }
+  if (Object.keys(forced.relations).length > 0) {
+    throw new ShapeError(
+      "Unique where forced conditions cannot contain relation filters"
+    );
   }
-  if (Object.keys(forced.conditions).length > 0) {
-    const conditions = [deepClone(forced.conditions)];
-    const existing = result.AND;
-    if (existing) {
-      if (Array.isArray(existing)) {
-        conditions.unshift(...existing);
-      } else {
-        conditions.unshift(existing);
-      }
-    }
-    result.AND = conditions;
+  const result = where ? deepClone(where) : {};
+  for (const [key, value] of Object.entries(forced.conditions)) {
+    mergeUniqueValue(result, key, value);
   }
   return result;
 }
@@ -1041,6 +1092,17 @@ function applyBuiltShape(built, body, isUniqueMethod, modelName) {
       if (!hasWhereInSchema) {
         const { where: _, ...rest } = bodyObj;
         parseable = rest;
+      } else if (isUniqueMethod && hasWhereForced(built.forcedWhere) && isPlainObject(bodyObj.where)) {
+        const where = stripUniqueWhereForcedInput(
+          bodyObj.where,
+          built.forcedWhere
+        );
+        if (Object.keys(where).length === 0) {
+          const { where: _, ...rest } = bodyObj;
+          parseable = rest;
+        } else {
+          parseable = { ...bodyObj, where };
+        }
       } else if (built.forcedOnlyWhereKeys.size > 0 && isPlainObject(bodyObj.where)) {
         const where = { ...bodyObj.where };
         for (const key of built.forcedOnlyWhereKeys) {
@@ -1148,13 +1210,15 @@ function applyForcedTree(validated, key, tree) {
         );
       }
       if (forced.include) {
-        if (!relObj.include)
+        if (!relObj.include) {
           relObj.include = buildForcedOnlyContainer(forced.include);
+        }
         applyForcedTree(relObj, "include", forced.include);
       }
       if (forced.select) {
-        if (!relObj.select)
+        if (!relObj.select) {
           relObj.select = buildForcedOnlyContainer(forced.select);
+        }
         applyForcedTree(relObj, "select", forced.select);
       }
       if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
@@ -1179,10 +1243,12 @@ function buildForcedOnlyContainer(tree) {
     if (forced.where && hasWhereForced(forced.where)) {
       nested.where = mergeWhereForced(void 0, forced.where);
     }
-    if (forced.include)
+    if (forced.include) {
       nested.include = buildForcedOnlyContainer(forced.include);
-    if (forced.select)
+    }
+    if (forced.select) {
       nested.select = buildForcedOnlyContainer(forced.select);
+    }
     if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
       const placement = forced._countWherePlacement ?? "include";
       if (!nested[placement])
@@ -1218,77 +1284,131 @@ function applyForcedCountWhere(container, forcedCountWhere) {
     }
   }
 }
-function collectWhereFieldKeys(where) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const [key, value] of Object.entries(where)) {
-    if (key === "AND") {
-      const items = Array.isArray(value) ? value : [value];
-      for (const item of items) {
-        if (isPlainObject(item)) {
-          for (const k of collectWhereFieldKeys(item))
-            keys.add(k);
-        }
-      }
-    } else if (key !== "OR" && key !== "NOT") {
-      keys.add(key);
-    }
+function formatUniqueConstraint(constraint) {
+  return constraint.fields.length === 1 ? constraint.selector : `${constraint.selector}(${constraint.fields.join(", ")})`;
+}
+function formatUniqueConstraints(constraints) {
+  return constraints.map(formatUniqueConstraint).join(" | ");
+}
+function resolvedWhereCoversConstraint(where, constraint) {
+  if (constraint.fields.length === 1) {
+    return constraint.fields[0] in where;
   }
-  return keys;
+  const value = where[constraint.selector];
+  if (!isPlainObject(value))
+    return false;
+  return constraint.fields.every((field) => field in value);
 }
 function validateResolvedUniqueWhere(model, where, method, uniqueMap) {
   const constraints = uniqueMap[model];
   if (!constraints || constraints.length === 0)
     return;
-  const fieldKeys = collectWhereFieldKeys(where);
   const covered = constraints.some(
-    (constraint) => constraint.every((field) => fieldKeys.has(field))
+    (constraint) => resolvedWhereCoversConstraint(where, constraint)
   );
   if (!covered) {
-    const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
     throw new ShapeError(
-      `${method} on model "${model}" requires resolved where to cover a unique constraint: ${constraintDesc}`
+      `${method} on model "${model}" requires resolved where to cover a unique constraint: ${formatUniqueConstraints(constraints)}`
     );
   }
 }
-function collectEqualityFields(where, model, typeMap) {
-  const combinators = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
-  const fields = /* @__PURE__ */ new Set();
-  for (const [key, value] of Object.entries(where)) {
-    if (key === "AND") {
-      if (isPlainObject(value)) {
-        for (const f of collectEqualityFields(value, model, typeMap)) {
-          fields.add(f);
-        }
-      }
-      continue;
+function assertDirectUniqueShapeValue(model, field, value, typeMap) {
+  if (typeMap && model) {
+    const fieldMeta = typeMap[model]?.[field];
+    if (!fieldMeta) {
+      throw new ShapeError(`Unknown unique where field "${model}.${field}"`);
     }
-    if (combinators.has(key))
-      continue;
-    if (typeMap && model && typeMap[model]?.[key]?.isRelation)
-      continue;
-    if (!value || !isPlainObject(value))
-      continue;
-    if ("equals" in value) {
-      fields.add(key);
+    if (fieldMeta.isRelation) {
+      throw new ShapeError(
+        `Relation field "${model}.${field}" cannot be used in unique where`
+      );
+    }
+  }
+  if (isForcedValue(value))
+    return;
+  if (isPlainObject(value)) {
+    const keys = Object.keys(value);
+    throw new ShapeError(
+      `Invalid unique where shape for "${model ?? "unknown"}.${field}". Prisma WhereUniqueInput does not accept filter operator objects${keys.length ? `: ${keys.join(", ")}` : ""}. Use { ${field}: true } in guard shape and { ${field}: value } in request args.`
+    );
+  }
+  if (value === null || value === void 0) {
+    throw new ShapeError(
+      `Invalid unique where shape for "${model ?? "unknown"}.${field}". Unique fields must use true or a forced value.`
+    );
+  }
+}
+function shapeCoversConstraint(where, constraint, model, typeMap) {
+  if (constraint.fields.length === 1) {
+    const field = constraint.fields[0];
+    if (!(field in where))
+      return false;
+    assertDirectUniqueShapeValue(model, field, where[field], typeMap);
+    return true;
+  }
+  if (!(constraint.selector in where))
+    return false;
+  const selectorValue = where[constraint.selector];
+  if (isForcedValue(selectorValue))
+    return true;
+  if (!isPlainObject(selectorValue)) {
+    throw new ShapeError(
+      `Compound unique selector "${model}.${constraint.selector}" must be an object with fields: ${constraint.fields.join(", ")}`
+    );
+  }
+  const allowed = new Set(constraint.fields);
+  for (const key of Object.keys(selectorValue)) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Unknown field "${key}" in compound unique selector "${model}.${constraint.selector}". Allowed fields: ${constraint.fields.join(", ")}`
+      );
     }
   }
-  return fields;
+  for (const field of constraint.fields) {
+    if (!(field in selectorValue)) {
+      throw new ShapeError(
+        `Missing field "${field}" in compound unique selector "${model}.${constraint.selector}"`
+      );
+    }
+    assertDirectUniqueShapeValue(model, field, selectorValue[field], typeMap);
+  }
+  return true;
 }
 function validateUniqueEquality(model, where, method, uniqueMap, typeMap) {
   const constraints = uniqueMap[model];
   if (!constraints || constraints.length === 0)
     return;
-  const equalityFields = collectEqualityFields(where, model, typeMap);
   const valid = constraints.some(
-    (constraint) => constraint.every((field) => equalityFields.has(field))
+    (constraint) => shapeCoversConstraint(where, constraint, model, typeMap)
   );
   if (!valid) {
-    const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
     throw new ShapeError(
-      `${method} on model "${model}" requires where to cover a unique constraint with equality operators only: ${constraintDesc}`
+      `${method} on model "${model}" requires unique where shape to cover a unique constraint using Prisma unique selector syntax: ${formatUniqueConstraints(constraints)}`
     );
   }
 }
+function stripUniqueWhereForcedInput(where, forced) {
+  const result = deepClone(where);
+  for (const [key, forcedValue] of Object.entries(forced.conditions)) {
+    if (!(key in result))
+      continue;
+    const currentValue = result[key];
+    if (isPlainObject(currentValue) && isPlainObject(forcedValue)) {
+      const nested = { ...currentValue };
+      for (const nestedKey of Object.keys(forcedValue)) {
+        delete nested[nestedKey];
+      }
+      if (Object.keys(nested).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = nested;
+      }
+      continue;
+    }
+    delete result[key];
+  }
+  return result;
+}
 
 // src/runtime/query-builder-where.ts
 var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Bytes"]);
@@ -1405,7 +1525,7 @@ function isModeCompatibleOp(fieldType, op) {
     return JSON_STRING_MODE_OPS.has(op);
   return false;
 }
-function createWhereBuilder(typeMap, enumMap, scalarBase) {
+function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
   function buildWhereSchema(model, whereConfig, depth) {
     const currentDepth = depth ?? 0;
     if (currentDepth > MAX_WHERE_DEPTH) {
@@ -1462,6 +1582,18 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
         scalarConditions
       );
     }
+    for (const key of Object.keys(scalarConditions)) {
+      if (COMBINATOR_KEYS.has(key))
+        continue;
+      if (!(key in fieldSchemas)) {
+        fieldSchemas[key] = import_zod4.z.object({}).strict().optional();
+      }
+    }
+    for (const key of Object.keys(relationForced)) {
+      if (!(key in fieldSchemas)) {
+        fieldSchemas[key] = import_zod4.z.object({}).strict().optional();
+      }
+    }
     const schema = Object.keys(fieldSchemas).length > 0 ? import_zod4.z.object(fieldSchemas).strict().optional() : null;
     const forcedOnlyKeys = /* @__PURE__ */ new Set();
     for (const key of Object.keys(whereConfig)) {
@@ -1685,7 +1817,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
         );
       }
       if (modeConfigValue === true) {
-        opSchemas["mode"] = import_zod4.z.enum(["default", "insensitive"]).optional();
+        opSchemas.mode = import_zod4.z.enum(["default", "insensitive"]).optional();
       } else {
         const actualModeValue = isForcedValue(modeConfigValue) ? modeConfigValue.value : modeConfigValue;
         const modeSchema = import_zod4.z.enum(["default", "insensitive"]);
@@ -1697,10 +1829,10 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
             `Invalid forced value for "${model}.${fieldName}.mode": ${err.message}`
           );
         }
-        fieldForced["mode"] = parsed;
+        fieldForced.mode = parsed;
       }
     } else if (hasModeCompatibleOp) {
-      opSchemas["mode"] = import_zod4.z.enum(["default", "insensitive"]).optional();
+      opSchemas.mode = import_zod4.z.enum(["default", "insensitive"]).optional();
     }
     if (hasClientOps) {
       const opObj = import_zod4.z.object(opSchemas).strict();
@@ -1728,12 +1860,60 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
       scalarConditions[fieldName] = fieldForced;
     }
   }
+  function getUniqueConstraint(model, selector) {
+    return (uniqueMap[model] ?? []).find(
+      (constraint) => constraint.selector === selector
+    ) ?? null;
+  }
+  function buildDirectUniqueSchema(fieldMeta) {
+    const base = createBaseType(fieldMeta, enumMap, scalarBase);
+    if (!fieldMeta.isEnum && !fieldMeta.isRelation && !fieldMeta.isUnsupported) {
+      return wrapWithInputCoercion(fieldMeta.type, fieldMeta.isList, base);
+    }
+    return base;
+  }
+  function parseForcedUniqueValue(model, fieldName, fieldMeta, value) {
+    const schema = buildDirectUniqueSchema(fieldMeta);
+    const actual = isForcedValue(value) ? value.value : value;
+    try {
+      return schema.parse(actual);
+    } catch (err) {
+      throw new ShapeError(
+        `Invalid forced value for unique where "${model}.${fieldName}": ${err.message}`
+      );
+    }
+  }
+  function assertCompoundSelectorConfig(model, selector, constraint, value) {
+    const actual = isForcedValue(value) ? value.value : value;
+    if (!isPlainObject(actual)) {
+      throw new ShapeError(
+        `Compound unique selector "${model}.${selector}" must be an object with fields: ${constraint.fields.join(", ")}`
+      );
+    }
+    const allowed = new Set(constraint.fields);
+    const keys = Object.keys(actual);
+    for (const key of keys) {
+      if (!allowed.has(key)) {
+        throw new ShapeError(
+          `Unknown field "${key}" in compound unique selector "${model}.${selector}". Allowed fields: ${constraint.fields.join(", ")}`
+        );
+      }
+    }
+    for (const field of constraint.fields) {
+      if (!(field in actual)) {
+        throw new ShapeError(
+          `Missing field "${field}" in compound unique selector "${model}.${selector}"`
+        );
+      }
+    }
+    return actual;
+  }
   function buildUniqueWhereSchema(model, whereConfig) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
     const fieldSchemas = {};
-    const forced = {};
+    const forcedConditions = {};
     const forcedOnlyKeys = /* @__PURE__ */ new Set();
     for (const [key, value] of Object.entries(whereConfig)) {
       if (COMBINATOR_KEYS.has(key)) {
@@ -1741,65 +1921,102 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
           `Combinator "${key}" is not supported in unique where for model "${model}"`
         );
       }
+      const constraint = getUniqueConstraint(model, key);
+      if (constraint && constraint.fields.length > 1) {
+        const compoundConfig = assertCompoundSelectorConfig(
+          model,
+          key,
+          constraint,
+          value
+        );
+        const nestedSchemas = {};
+        const forcedCompound = {};
+        for (const fieldName of constraint.fields) {
+          const fieldMeta2 = modelFields[fieldName];
+          if (!fieldMeta2) {
+            throw new ShapeError(
+              `Unknown field "${fieldName}" in compound unique selector "${model}.${key}"`
+            );
+          }
+          if (fieldMeta2.isRelation) {
+            throw new ShapeError(
+              `Relation field "${fieldName}" cannot be used in compound unique selector "${model}.${key}"`
+            );
+          }
+          const fieldValue = compoundConfig[fieldName];
+          const forced2 = isForcedValue(fieldValue);
+          if (!forced2 && isPlainObject(fieldValue)) {
+            const operators = Object.keys(fieldValue);
+            throw new ShapeError(
+              `Invalid compound unique where shape for "${model}.${key}.${fieldName}". Prisma compound unique selectors do not accept filter operator objects${operators.length ? `: ${operators.join(", ")}` : ""}. Use direct values only.`
+            );
+          }
+          const directSchema2 = buildDirectUniqueSchema(fieldMeta2);
+          if (fieldValue === true) {
+            nestedSchemas[fieldName] = directSchema2;
+          } else {
+            forcedCompound[fieldName] = parseForcedUniqueValue(
+              model,
+              fieldName,
+              fieldMeta2,
+              fieldValue
+            );
+          }
+        }
+        if (Object.keys(nestedSchemas).length > 0) {
+          fieldSchemas[key] = import_zod4.z.object(nestedSchemas).strict();
+        }
+        if (Object.keys(forcedCompound).length > 0) {
+          forcedConditions[key] = forcedCompound;
+        }
+        if (Object.keys(nestedSchemas).length === 0) {
+          forcedOnlyKeys.add(key);
+        }
+        continue;
+      }
       const fieldMeta = modelFields[key];
-      if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${key}" on model "${model}"`);
-      if (fieldMeta.isRelation)
+      if (!fieldMeta) {
+        const selectors = (uniqueMap[model] ?? []).map((constraint2) => constraint2.selector).join(", ");
         throw new ShapeError(
-          `Relation field "${key}" cannot be used in unique where for model "${model}"`
+          `Unknown unique field or selector "${key}" on model "${model}"${selectors ? `. Unique selectors: ${selectors}` : ""}`
         );
-      const base = createBaseType(fieldMeta, enumMap, scalarBase);
-      let directSchema;
-      if (!fieldMeta.isEnum && !fieldMeta.isRelation && !fieldMeta.isUnsupported) {
-        directSchema = wrapWithInputCoercion(
-          fieldMeta.type,
-          fieldMeta.isList,
-          base
-        );
-      } else {
-        directSchema = base;
       }
-      const equalsWrapper = import_zod4.z.object({ equals: directSchema }).strict().transform((v) => v.equals);
-      if (value === true) {
-        fieldSchemas[key] = import_zod4.z.union([directSchema, equalsWrapper]);
-        continue;
+      if (fieldMeta.isRelation) {
+        throw new ShapeError(
+          `Relation field "${key}" cannot be used in unique where for model "${model}"`
+        );
       }
-      if (isPlainObject(value)) {
+      const forced = isForcedValue(value);
+      if (!forced && isPlainObject(value)) {
         const keys = Object.keys(value);
-        if (keys.length === 1 && keys[0] === "equals") {
-          const equalsVal = value.equals;
-          if (equalsVal === true) {
-            fieldSchemas[key] = import_zod4.z.union([directSchema, equalsWrapper]);
-          } else {
-            const actual2 = isForcedValue(equalsVal) ? equalsVal.value : equalsVal;
-            try {
-              forced[key] = directSchema.parse(actual2);
-            } catch (err) {
-              throw new ShapeError(
-                `Invalid forced value for unique where "${model}.${key}": ${err.message}`
-              );
-            }
-            forcedOnlyKeys.add(key);
-          }
-          continue;
+        if (keys.includes("equals")) {
+          throw new ShapeError(
+            `Invalid unique where shape for "${model}.${key}". Prisma WhereUniqueInput does not accept filter operator objects. Use { ${key}: true } instead of { ${key}: { equals: true } }.`
+          );
         }
         throw new ShapeError(
-          `Unique where field "${key}" on model "${model}" only accepts true or { equals: true/value }. Got operators: ${keys.join(", ")}`
+          `Invalid unique where shape for "${model}.${key}". Prisma WhereUniqueInput does not accept operators: ${keys.join(", ")}. Use a direct unique value shape, for example { ${key}: true }.`
         );
       }
-      const actual = isForcedValue(value) ? value.value : value;
-      try {
-        forced[key] = directSchema.parse(actual);
-      } catch (err) {
-        throw new ShapeError(
-          `Invalid forced value for unique where "${model}.${key}": ${err.message}`
-        );
+      const directSchema = buildDirectUniqueSchema(fieldMeta);
+      if (value === true) {
+        fieldSchemas[key] = directSchema;
+        continue;
       }
+      forcedConditions[key] = parseForcedUniqueValue(
+        model,
+        key,
+        fieldMeta,
+        value
+      );
       forcedOnlyKeys.add(key);
     }
     return {
       schema: Object.keys(fieldSchemas).length > 0 ? import_zod4.z.object(fieldSchemas).strict() : null,
-      forced,
+      forced: {
+        conditions: forcedConditions,
+        relations: {}
+      },
       forcedOnlyKeys
     };
   }
@@ -1818,6 +2035,15 @@ function requireConfigTrue(config, context) {
     }
   }
 }
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function formatUniqueConstraint2(constraint) {
+  return constraint.fields.length === 1 ? constraint.selector : `${constraint.selector}(${constraint.fields.join(", ")})`;
+}
+function formatUniqueConstraints2(constraints) {
+  return constraints.map(formatUniqueConstraint2).join(" | ");
+}
 function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
   const sortEnum = import_zod5.z.enum(["asc", "desc"]);
   const nullsEnum = import_zod5.z.enum(["first", "last"]);
@@ -1828,11 +2054,17 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     if (!fieldMeta)
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
     if (fieldMeta.isRelation)
-      throw new ShapeError(`Relation field "${fieldName}" in orderBy requires a nested config object, not true`);
+      throw new ShapeError(
+        `Relation field "${fieldName}" in orderBy requires a nested config object, not true`
+      );
     if (fieldMeta.type === "Json")
-      throw new ShapeError(`Json field "${fieldName}" cannot be used in orderBy`);
+      throw new ShapeError(
+        `Json field "${fieldName}" cannot be used in orderBy`
+      );
     if (fieldMeta.isList)
-      throw new ShapeError(`List field "${fieldName}" cannot be used in orderBy`);
+      throw new ShapeError(
+        `List field "${fieldName}" cannot be used in orderBy`
+      );
   }
   function buildOrderBySchema(model, orderByConfig) {
     const modelFields = typeMap[model];
@@ -1842,158 +2074,274 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     for (const [fieldName, config] of Object.entries(orderByConfig)) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}"`
+        );
       if (config === true) {
         validateScalarOrderByField(fieldName, model, modelFields);
         fieldSchemas[fieldName] = scalarOrderSchema.optional();
         continue;
       }
-      if (typeof config !== "object" || config === null) {
-        throw new ShapeError(`Invalid orderBy config for "${fieldName}" on model "${model}": expected true or a nested config object`);
+      if (!isPlainRecord(config)) {
+        throw new ShapeError(
+          `orderBy config for "${fieldName}" on model "${model}" must be true or a relation aggregate object`
+        );
       }
       if (!fieldMeta.isRelation) {
-        throw new ShapeError(`Scalar field "${fieldName}" in orderBy does not accept nested config`);
-      }
-      if (Object.keys(config).length === 0) {
-        throw new ShapeError(`Empty orderBy config for relation "${fieldName}" on model "${model}". Define at least one nested field.`);
+        const allowedOps = getSupportedOperators(
+          fieldMeta.type,
+          fieldMeta.isList
+        );
+        const opSchemas = {};
+        for (const [op, enabled] of Object.entries(config)) {
+          if (enabled !== true) {
+            throw new ShapeError(
+              `orderBy operator config for "${model}.${fieldName}.${op}" must be true`
+            );
+          }
+          if (!allowedOps.includes(op)) {
+            throw new ShapeError(
+              `Operator "${op}" not supported for orderBy field "${model}.${fieldName}"`
+            );
+          }
+          opSchemas[op] = scalarOrderSchema.optional();
+        }
+        const opKeys = Object.keys(opSchemas);
+        fieldSchemas[fieldName] = import_zod5.z.object(opSchemas).strict().refine(
+          (v) => opKeys.some(
+            (k) => v[k] !== void 0
+          ),
+          {
+            message: `orderBy field "${fieldName}" must specify at least one operator`
+          }
+        ).optional();
+        continue;
       }
       if (fieldMeta.isList) {
-        const relKeys = Object.keys(config);
-        if (relKeys.length !== 1 || relKeys[0] !== "_count") {
-          throw new ShapeError(`To-many relation "${fieldName}" in orderBy only supports { _count: true }`);
+        if (!("_count" in config)) {
+          throw new ShapeError(
+            `To-many relation orderBy "${fieldName}" only supports _count`
+          );
         }
         if (config._count !== true) {
-          throw new ShapeError(`_count in orderBy for "${fieldName}" must be true`);
+          throw new ShapeError(
+            `orderBy relation aggregate "${fieldName}._count" must be true`
+          );
         }
-        fieldSchemas[fieldName] = import_zod5.z.object({ _count: sortEnum }).strict().optional();
+        fieldSchemas[fieldName] = import_zod5.z.object({
+          _count: sortEnum.optional()
+        }).strict().optional();
         continue;
       }
-      const relatedModel = fieldMeta.type;
-      const relatedFields = typeMap[relatedModel];
-      if (!relatedFields)
-        throw new ShapeError(`Related model "${relatedModel}" not found in type map`);
-      const nestedSchemas = {};
-      for (const [nestedField, nestedVal] of Object.entries(config)) {
-        if (nestedVal !== true) {
-          throw new ShapeError(`Nested orderBy field "${nestedField}" on relation "${fieldName}" must be true`);
-        }
-        const nestedMeta = relatedFields[nestedField];
-        if (!nestedMeta)
-          throw new ShapeError(`Unknown field "${nestedField}" on model "${relatedModel}" in orderBy`);
-        if (nestedMeta.isRelation)
-          throw new ShapeError(`Nested relation "${nestedField}" in orderBy on "${fieldName}" is not supported`);
-        if (nestedMeta.type === "Json")
-          throw new ShapeError(`Json field "${nestedField}" cannot be used in orderBy`);
-        if (nestedMeta.isList)
-          throw new ShapeError(`List field "${nestedField}" cannot be used in orderBy`);
-        nestedSchemas[nestedField] = scalarOrderSchema.optional();
-      }
-      const nestedKeys = Object.keys(nestedSchemas);
-      fieldSchemas[fieldName] = import_zod5.z.object(nestedSchemas).strict().refine(
-        (v) => nestedKeys.some((k) => v[k] !== void 0),
-        { message: `orderBy for relation "${fieldName}" must specify at least one field` }
-      ).optional();
+      const nested = buildOrderBySchema(
+        fieldMeta.type,
+        config
+      );
+      fieldSchemas[fieldName] = nested;
     }
     const fieldKeys = Object.keys(fieldSchemas);
     const singleSchema = import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => fieldKeys.some((k) => v[k] !== void 0),
+      (v) => fieldKeys.some(
+        (k) => v[k] !== void 0
+      ),
       { message: "orderBy must specify at least one field" }
     );
-    return import_zod5.z.union([singleSchema, import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(singleSchema).min(1))]).optional();
+    return import_zod5.z.union([
+      singleSchema,
+      import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(singleSchema).min(1))
+    ]).optional();
   }
   function buildTakeSchema(config) {
-    const normalized = typeof config === "number" ? { max: config, default: config } : config;
-    if (!Number.isFinite(normalized.max) || !Number.isInteger(normalized.max)) {
-      throw new ShapeError(`take max must be a finite integer, got ${normalized.max}`);
+    if (typeof config === "number") {
+      if (!Number.isFinite(config) || !Number.isInteger(config)) {
+        throw new ShapeError(`take must be a finite integer, got ${config}`);
+      }
+      if (config <= 0) {
+        throw new ShapeError("take must be a positive integer");
+      }
+      return import_zod5.z.literal(config).optional();
+    }
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+      throw new ShapeError("take config must be a number or { max, default? }");
+    }
+    if (!Number.isFinite(config.max) || !Number.isInteger(config.max)) {
+      throw new ShapeError(
+        `take.max must be a finite integer, got ${config.max}`
+      );
     }
-    if (normalized.max < 1) {
-      throw new ShapeError(`take max must be at least 1, got ${normalized.max}`);
+    if (config.max <= 0) {
+      throw new ShapeError("take.max must be a positive integer");
     }
-    if (normalized.default !== void 0) {
-      if (!Number.isFinite(normalized.default) || !Number.isInteger(normalized.default)) {
-        throw new ShapeError(`take default must be a finite integer, got ${normalized.default}`);
+    if (config.default !== void 0) {
+      if (!Number.isFinite(config.default) || !Number.isInteger(config.default)) {
+        throw new ShapeError(
+          `take.default must be a finite integer, got ${config.default}`
+        );
       }
-      if (normalized.default < 1) {
-        throw new ShapeError(`take default must be at least 1, got ${normalized.default}`);
+      if (config.default <= 0) {
+        throw new ShapeError("take.default must be a positive integer");
       }
-      if (normalized.default > normalized.max) {
-        throw new ShapeError("take default cannot exceed max");
+      if (config.default > config.max) {
+        throw new ShapeError("take.default cannot exceed take.max");
       }
-      return import_zod5.z.number().int().min(1).max(normalized.max).default(normalized.default);
+      return import_zod5.z.number().int().min(1).max(config.max).default(config.default);
     }
-    return import_zod5.z.number().int().min(1).max(normalized.max).optional();
+    return import_zod5.z.number().int().min(1).max(config.max).optional();
   }
-  function buildCursorSchema(model, cursorConfig) {
+  function buildCursorFieldSchema(model, fieldName) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    requireConfigTrue(cursorConfig, `cursor on model "${model}"`);
-    const cursorFields = new Set(Object.keys(cursorConfig));
+    const fieldMeta = modelFields[fieldName];
+    if (!fieldMeta) {
+      throw new ShapeError(
+        `Unknown field "${fieldName}" on model "${model}" in cursor`
+      );
+    }
+    if (fieldMeta.isRelation) {
+      throw new ShapeError(
+        `Relation field "${fieldName}" cannot be used in cursor`
+      );
+    }
+    if (fieldMeta.isList) {
+      throw new ShapeError(
+        `List field "${fieldName}" cannot be used in cursor`
+      );
+    }
+    const base = createBaseType(fieldMeta, enumMap, scalarBase);
+    if (!fieldMeta.isEnum && !fieldMeta.isRelation && !fieldMeta.isUnsupported) {
+      return wrapWithInputCoercion(fieldMeta.type, fieldMeta.isList, base);
+    }
+    return base;
+  }
+  function cursorConfigMatchesConstraint(cursorConfig, constraint) {
+    if (!(constraint.selector in cursorConfig))
+      return false;
+    const value = cursorConfig[constraint.selector];
+    if (constraint.fields.length === 1) {
+      return value === true;
+    }
+    if (!isPlainRecord(value))
+      return false;
+    const keys = Object.keys(value);
+    if (keys.length !== constraint.fields.length)
+      return false;
+    return constraint.fields.every((field) => value[field] === true);
+  }
+  function getUniqueConstraints(model) {
     const constraints = uniqueMap[model];
     if (constraints && constraints.length > 0) {
-      const covered = constraints.some(
-        (constraint) => constraint.length === cursorFields.size && constraint.every((field) => cursorFields.has(field))
-      );
-      if (!covered) {
-        const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
-        throw new ShapeError(
-          `cursor on model "${model}" must exactly match a unique constraint: ${constraintDesc}`
-        );
+      return constraints;
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields) {
+      throw new ShapeError(`Unknown model: ${model}`);
+    }
+    const inferred = [];
+    for (const [fieldName, fieldMeta] of Object.entries(modelFields)) {
+      if (fieldMeta.isRelation)
+        continue;
+      if (fieldMeta.isId || fieldMeta.isUnique) {
+        inferred.push({
+          selector: fieldName,
+          fields: [fieldName]
+        });
       }
     }
+    return inferred;
+  }
+  function buildCursorSchema(model, cursorConfig) {
+    const constraints = getUniqueConstraints(model);
+    if (constraints.length === 0) {
+      throw new ShapeError(
+        `cursor on model "${model}" requires at least one unique constraint`
+      );
+    }
+    const matching = constraints.find(
+      (constraint) => cursorConfigMatchesConstraint(cursorConfig, constraint)
+    );
+    if (!matching) {
+      throw new ShapeError(
+        `cursor on model "${model}" must exactly match a unique selector: ${formatUniqueConstraints2(constraints)}`
+      );
+    }
     const fieldSchemas = {};
-    for (const fieldName of Object.keys(cursorConfig)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in cursor`);
-      if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in cursor`);
-      if (fieldMeta.isList)
-        throw new ShapeError(`List field "${fieldName}" cannot be used in cursor`);
-      fieldSchemas[fieldName] = createBaseType(fieldMeta, enumMap, scalarBase);
+    if (matching.fields.length === 1) {
+      fieldSchemas[matching.selector] = buildCursorFieldSchema(
+        model,
+        matching.fields[0]
+      ).optional();
+    } else {
+      const nestedSchemas = {};
+      for (const field of matching.fields) {
+        nestedSchemas[field] = buildCursorFieldSchema(model, field);
+      }
+      fieldSchemas[matching.selector] = import_zod5.z.object(nestedSchemas).strict().optional();
     }
-    return import_zod5.z.object(fieldSchemas).strict().optional();
+    return import_zod5.z.object(fieldSchemas).strict().refine(
+      (v) => v[matching.selector] !== void 0,
+      { message: `cursor must specify "${matching.selector}"` }
+    ).optional();
   }
   function buildDistinctSchema(model, distinctConfig) {
-    if (distinctConfig.length === 0) {
-      throw new ShapeError("distinct must contain at least one field");
-    }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
+    if (!Array.isArray(distinctConfig) || distinctConfig.length === 0) {
+      throw new ShapeError(
+        `distinct on model "${model}" must be a non-empty array of scalar fields`
+      );
+    }
+    const allowedFields = /* @__PURE__ */ new Set();
     for (const fieldName of distinctConfig) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in distinct`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in distinct`
+        );
       if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in distinct`);
-      if (fieldMeta.isList)
-        throw new ShapeError(`List field "${fieldName}" cannot be used in distinct`);
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in distinct`
+        );
+      allowedFields.add(fieldName);
     }
-    const enumSchema = import_zod5.z.enum(distinctConfig);
-    return import_zod5.z.union([enumSchema, import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(enumSchema).min(1))]).optional();
+    return import_zod5.z.union([
+      import_zod5.z.enum([...allowedFields]),
+      import_zod5.z.array(import_zod5.z.enum([...allowedFields])).min(1)
+    ]).optional();
   }
   function buildBySchema(model, byConfig) {
-    if (byConfig.length === 0) {
-      throw new ShapeError('groupBy "by" must contain at least one field');
-    }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
+    if (!Array.isArray(byConfig) || byConfig.length === 0) {
+      throw new ShapeError(
+        `groupBy "by" on model "${model}" must be a non-empty array`
+      );
+    }
+    const allowedFields = /* @__PURE__ */ new Set();
     for (const fieldName of byConfig) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in by`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in groupBy by`
+        );
       if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in by`);
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in groupBy by`
+        );
+      if (fieldMeta.isList)
+        throw new ShapeError(
+          `List field "${fieldName}" cannot be used in groupBy by`
+        );
       if (UNSUPPORTED_BY_TYPES.has(fieldMeta.type)) {
-        throw new ShapeError(`${fieldMeta.type} field "${fieldName}" cannot be used in by`);
+        throw new ShapeError(
+          `${fieldMeta.type} field "${fieldName}" cannot be used in groupBy by`
+        );
       }
-      if (fieldMeta.isList)
-        throw new ShapeError(`List field "${fieldName}" cannot be used in by`);
+      allowedFields.add(fieldName);
     }
-    const enumSchema = import_zod5.z.enum(byConfig);
-    return import_zod5.z.union([enumSchema, import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(enumSchema).min(1))]);
+    return import_zod5.z.array(import_zod5.z.enum([...allowedFields])).min(1);
   }
   function buildHavingSchema(model, havingConfig) {
     const modelFields = typeMap[model];
@@ -2004,82 +2352,88 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     for (const fieldName of Object.keys(havingConfig)) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in having`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in having`
+        );
       if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in having`);
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in having`
+        );
       if (fieldMeta.isList)
-        throw new ShapeError(`List field "${fieldName}" cannot be used in having`);
-      const ops = getSupportedOperators(fieldMeta);
-      if (ops.length === 0) {
-        throw new ShapeError(`${fieldMeta.type} field "${fieldName}" cannot be used in having filters`);
+        throw new ShapeError(
+          `List field "${fieldName}" cannot be used in having`
+        );
+      if (UNSUPPORTED_BY_TYPES.has(fieldMeta.type)) {
+        throw new ShapeError(
+          `${fieldMeta.type} field "${fieldName}" cannot be used in having`
+        );
       }
+      const allowedOps = getSupportedOperators(
+        fieldMeta.type,
+        fieldMeta.isList
+      );
       const opSchemas = {};
-      const opKeys = [];
-      for (const op of ops) {
-        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap, scalarBase).optional();
-        opKeys.push(op);
+      for (const op of allowedOps) {
+        opSchemas[op] = createOperatorSchema(
+          fieldMeta,
+          op,
+          enumMap,
+          scalarBase
+        ).optional();
       }
-      if (fieldMeta.type === "String" && !fieldMeta.isList) {
-        opSchemas["mode"] = import_zod5.z.enum(["default", "insensitive"]).optional();
+      if (fieldMeta.type === "String") {
+        opSchemas.mode = import_zod5.z.enum(["default", "insensitive"]).optional();
       }
+      const opKeys = Object.keys(opSchemas).filter((key) => key !== "mode");
       fieldSchemas[fieldName] = import_zod5.z.object(opSchemas).strict().refine(
         (v) => opKeys.some((k) => v[k] !== void 0),
-        { message: `At least one operator required for having field "${fieldName}"` }
+        {
+          message: `having field "${fieldName}" must specify at least one operator`
+        }
       ).optional();
     }
-    const havingFieldKeys = Object.keys(fieldSchemas);
-    const havingSchema = import_zod5.z.lazy(() => {
-      const allSchemas = { ...fieldSchemas };
-      allSchemas["AND"] = import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(havingSchema).min(1)).optional();
-      allSchemas["OR"] = import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(havingSchema).min(1)).optional();
-      allSchemas["NOT"] = import_zod5.z.union([
-        havingSchema,
-        import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(havingSchema).min(1))
-      ]).optional();
-      const allKeys = [...havingFieldKeys, "AND", "OR", "NOT"];
-      return import_zod5.z.object(allSchemas).strict().refine(
-        (v) => allKeys.some((k) => v[k] !== void 0),
-        { message: "having must specify at least one field or combinator" }
-      );
-    });
-    return havingSchema.optional();
+    const fieldKeys = Object.keys(fieldSchemas);
+    return import_zod5.z.object(fieldSchemas).strict().refine(
+      (v) => fieldKeys.some(
+        (k) => v[k] !== void 0
+      ),
+      { message: "having must specify at least one field" }
+    ).optional();
   }
-  function buildAggregateFieldSchema(model, opName, fieldConfig) {
+  function buildAggregateFieldSchema(model, op, config) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    requireConfigTrue(fieldConfig, `${opName} on model "${model}"`);
-    const isNumericOnly = opName === "_avg" || opName === "_sum";
-    const isComparableOnly = opName === "_min" || opName === "_max";
+    requireConfigTrue(config, `${op} on model "${model}"`);
+    const allowedTypes = op === "_avg" || op === "_sum" ? NUMERIC_TYPES : COMPARABLE_TYPES;
     const fieldSchemas = {};
-    for (const fieldName of Object.keys(fieldConfig)) {
-      if (fieldName === "_all" && opName === "_count") {
-        fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
-        continue;
-      }
+    for (const fieldName of Object.keys(config)) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in ${opName}`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in ${op}`
+        );
       if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${opName}`);
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in ${op}`
+        );
       if (fieldMeta.isList)
-        throw new ShapeError(`List field "${fieldName}" cannot be used in ${opName}`);
-      if (isNumericOnly && !NUMERIC_TYPES.has(fieldMeta.type)) {
         throw new ShapeError(
-          `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only numeric types (Int, Float, Decimal, BigInt) are supported.`
+          `List field "${fieldName}" cannot be used in ${op}`
         );
-      }
-      if (isComparableOnly && !COMPARABLE_TYPES.has(fieldMeta.type)) {
+      if (!allowedTypes.has(fieldMeta.type)) {
         throw new ShapeError(
-          `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only comparable types (Int, Float, Decimal, BigInt, String, DateTime) are supported.`
+          `Field "${fieldName}" of type "${fieldMeta.type}" cannot be used in ${op}`
         );
       }
       fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
     }
-    const aggFieldKeys = Object.keys(fieldSchemas);
+    const aggregateFieldKeys = Object.keys(fieldSchemas);
     return import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => aggFieldKeys.some((k) => v[k] !== void 0),
-      { message: `${opName} must specify at least one field` }
+      (v) => aggregateFieldKeys.some(
+        (k) => v[k] !== void 0
+      ),
+      { message: `${op} must specify at least one field` }
     ).optional();
   }
   function buildCountFieldSchema(model, config, context) {
@@ -2095,15 +2449,21 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       if (fieldName !== "_all") {
         const fieldMeta = modelFields[fieldName];
         if (!fieldMeta)
-          throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in ${context}`);
+          throw new ShapeError(
+            `Unknown field "${fieldName}" on model "${model}" in ${context}`
+          );
         if (fieldMeta.isRelation)
-          throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${context}`);
+          throw new ShapeError(
+            `Relation field "${fieldName}" cannot be used in ${context}`
+          );
       }
       fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
     }
     const countFieldKeys = Object.keys(fieldSchemas);
     return import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => countFieldKeys.some((k) => v[k] !== void 0),
+      (v) => countFieldKeys.some(
+        (k) => v[k] !== void 0
+      ),
       { message: `${context} must specify at least one field` }
     ).optional();
   }
@@ -2115,19 +2475,25 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     const fieldSchemas = {};
     for (const fieldName of Object.keys(selectConfig)) {
       if (fieldName === "_all") {
-        fieldSchemas["_all"] = import_zod5.z.literal(true).optional();
+        fieldSchemas._all = import_zod5.z.literal(true).optional();
         continue;
       }
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in count select`);
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in count select`
+        );
       if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in count select`);
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in count select`
+        );
       fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
     }
     const countSelectKeys = Object.keys(fieldSchemas);
     return import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => countSelectKeys.some((k) => v[k] !== void 0),
+      (v) => countSelectKeys.some(
+        (k) => v[k] !== void 0
+      ),
       { message: "count select must specify at least one field" }
     ).optional();
   }
@@ -2536,7 +2902,12 @@ var UNIQUE_WHERE_METHODS = /* @__PURE__ */ new Set([
   "findUniqueOrThrow"
 ]);
 function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
-  const whereBuilder = createWhereBuilder(typeMap, enumMap, scalarBase);
+  const whereBuilder = createWhereBuilder(
+    typeMap,
+    enumMap,
+    scalarBase,
+    uniqueMap
+  );
   const argsBuilder = createArgsBuilder(
     typeMap,
     enumMap,
@@ -2558,24 +2929,28 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
   function validateShapeArgs(method, shape) {
     const allowed = METHOD_ALLOWED_ARGS[method];
     for (const key of Object.keys(shape)) {
-      if (!SHAPE_CONFIG_KEYS.has(key))
+      if (!SHAPE_CONFIG_KEYS.has(key)) {
         throw new ShapeError(`Unknown shape config key "${key}"`);
-      if (!allowed.has(key))
+      }
+      if (!allowed.has(key)) {
         throw new ShapeError(`Arg "${key}" not allowed for method "${method}"`);
+      }
     }
     if (UNIQUE_WHERE_METHODS.has(method) && !shape.where) {
       throw new ShapeError(`${method} shape must define "where"`);
     }
-    if (method === "groupBy" && !shape.by)
+    if (method === "groupBy" && !shape.by) {
       throw new ShapeError('groupBy shape must define "by"');
+    }
     if (method === "groupBy" && (shape.include || shape.select)) {
       throw new ShapeError('groupBy does not support "include" or "select"');
     }
     if (method === "aggregate" && (shape.include || shape.select)) {
       throw new ShapeError('aggregate does not support "include" or "select"');
     }
-    if (method === "count" && shape.include)
+    if (method === "count" && shape.include) {
       throw new ShapeError('count does not support "include"');
+    }
     if (method === "groupBy" && shape.orderBy && shape.orderBy !== true) {
       const bySet = new Set(shape.by);
       for (const fieldName of Object.keys(shape.orderBy)) {
@@ -2630,30 +3005,28 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     let forcedIncludeCountWhere = {};
     let forcedSelectCountWhere = {};
     if (shape.where) {
-      const { schema, forced, forcedOnlyKeys } = whereBuilder.buildWhereSchema(
-        model,
-        shape.where
-      );
-      if (schema)
-        schemaFields["where"] = schema;
-      forcedWhere = forced;
-      forcedOnlyWhereKeys = forcedOnlyKeys;
+      const builtWhere = UNIQUE_WHERE_METHODS.has(method) ? whereBuilder.buildUniqueWhereSchema(model, shape.where) : whereBuilder.buildWhereSchema(model, shape.where);
+      if (builtWhere.schema) {
+        schemaFields.where = builtWhere.schema;
+      }
+      forcedWhere = builtWhere.forced;
+      forcedOnlyWhereKeys = builtWhere.forcedOnlyKeys;
     }
     if (shape.include) {
       const result = projectionBuilder.buildIncludeSchema(model, shape.include);
-      schemaFields["include"] = result.schema;
+      schemaFields.include = result.schema;
       forcedIncludeTree = result.forcedTree;
       forcedIncludeCountWhere = result.forcedCountWhere;
     }
     if (shape.select) {
       if (method === "count") {
-        schemaFields["select"] = argsBuilder.buildCountSelectSchema(
+        schemaFields.select = argsBuilder.buildCountSelectSchema(
           model,
           shape.select
         );
       } else {
         const result = projectionBuilder.buildSelectSchema(model, shape.select);
-        schemaFields["select"] = result.schema;
+        schemaFields.select = result.schema;
         forcedSelectTree = result.forcedTree;
         forcedSelectCountWhere = result.forcedCountWhere;
       }
@@ -2667,7 +3040,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
           for (const field of shape.by) {
             groupByOrderFields[field] = sortEnum.optional();
           }
-          groupByOrderFields["_count"] = sortEnum.optional();
+          groupByOrderFields._count = sortEnum.optional();
           const fieldKeys = Object.keys(groupByOrderFields);
           const singleSchema = import_zod7.z.object(groupByOrderFields).strict().refine(
             (v) => fieldKeys.some(
@@ -2675,13 +3048,16 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
             ),
             { message: "orderBy must specify at least one field" }
           );
-          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))]).optional();
+          schemaFields.orderBy = import_zod7.z.union([
+            singleSchema,
+            import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))
+          ]).optional();
         } else {
           const groupByOrderFields = {};
           for (const [fieldName, config] of Object.entries(shape.orderBy)) {
             if (fieldName === "_count") {
               if (config === true) {
-                groupByOrderFields["_count"] = sortEnum.optional();
+                groupByOrderFields._count = sortEnum.optional();
               } else if (typeof config === "object" && config !== null) {
                 const countFields = {};
                 for (const countField of Object.keys(config)) {
@@ -2693,7 +3069,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
                   countFields[countField] = sortEnum.optional();
                 }
                 const countKeys = Object.keys(countFields);
-                groupByOrderFields["_count"] = import_zod7.z.object(countFields).strict().refine(
+                groupByOrderFields._count = import_zod7.z.object(countFields).strict().refine(
                   (v) => countKeys.some(
                     (k) => v[k] !== void 0
                   ),
@@ -2718,70 +3094,83 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
             ),
             { message: "orderBy must specify at least one field" }
           );
-          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))]).optional();
+          schemaFields.orderBy = import_zod7.z.union([
+            singleSchema,
+            import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))
+          ]).optional();
         }
       } else {
-        schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
+        schemaFields.orderBy = argsBuilder.buildOrderBySchema(
           model,
           shape.orderBy
         );
       }
     }
-    if (shape.cursor)
-      schemaFields["cursor"] = argsBuilder.buildCursorSchema(
+    if (shape.cursor) {
+      schemaFields.cursor = argsBuilder.buildCursorSchema(
         model,
         shape.cursor
       );
-    if (shape.take)
-      schemaFields["take"] = argsBuilder.buildTakeSchema(shape.take);
+    }
+    if (shape.take) {
+      schemaFields.take = argsBuilder.buildTakeSchema(shape.take);
+    }
     if (shape.skip !== void 0) {
       if (shape.skip !== true) {
         throw new ShapeError('Shape config "skip" must be true');
       }
-      schemaFields["skip"] = import_zod7.z.number().int().min(0).optional();
+      schemaFields.skip = import_zod7.z.number().int().min(0).optional();
     }
-    if (shape.distinct)
-      schemaFields["distinct"] = argsBuilder.buildDistinctSchema(
+    if (shape.distinct) {
+      schemaFields.distinct = argsBuilder.buildDistinctSchema(
         model,
         shape.distinct
       );
-    if (shape._count)
-      schemaFields["_count"] = argsBuilder.buildCountFieldSchema(
+    }
+    if (shape._count) {
+      schemaFields._count = argsBuilder.buildCountFieldSchema(
         model,
         shape._count,
         "_count"
       );
-    if (shape._avg)
-      schemaFields["_avg"] = argsBuilder.buildAggregateFieldSchema(
+    }
+    if (shape._avg) {
+      schemaFields._avg = argsBuilder.buildAggregateFieldSchema(
         model,
         "_avg",
         shape._avg
       );
-    if (shape._sum)
-      schemaFields["_sum"] = argsBuilder.buildAggregateFieldSchema(
+    }
+    if (shape._sum) {
+      schemaFields._sum = argsBuilder.buildAggregateFieldSchema(
         model,
         "_sum",
         shape._sum
       );
-    if (shape._min)
-      schemaFields["_min"] = argsBuilder.buildAggregateFieldSchema(
+    }
+    if (shape._min) {
+      schemaFields._min = argsBuilder.buildAggregateFieldSchema(
         model,
         "_min",
         shape._min
       );
-    if (shape._max)
-      schemaFields["_max"] = argsBuilder.buildAggregateFieldSchema(
+    }
+    if (shape._max) {
+      schemaFields._max = argsBuilder.buildAggregateFieldSchema(
         model,
         "_max",
         shape._max
       );
-    if (shape.by)
-      schemaFields["by"] = argsBuilder.buildBySchema(model, shape.by);
-    if (shape.having)
-      schemaFields["having"] = argsBuilder.buildHavingSchema(
+    }
+    if (shape.by) {
+      schemaFields.by = argsBuilder.buildBySchema(model, shape.by);
+    }
+    if (shape.having) {
+      schemaFields.having = argsBuilder.buildHavingSchema(
         model,
         shape.having
       );
+    }
     return {
       zodSchema: import_zod7.z.object(schemaFields).strict(),
       forcedWhere,
@@ -2799,7 +3188,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     return { key: matched, shape: shapes[matched] };
   }
   function resolveDefaultShape(config, model, method, normalizedBody, opts, builtCache, isUnique) {
-    const shapeOrFn = config["default"];
+    const shapeOrFn = config.default;
     let built;
     if (typeof shapeOrFn === "function") {
       const resolved = resolveAndValidateShape(shapeOrFn, opts?.ctx);
@@ -2853,8 +3242,9 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
             built = builtCache.get("_default");
           }
         } else {
-          if (!isPlainObject(normalizedBody))
+          if (!isPlainObject(normalizedBody)) {
             throw new ShapeError("Request body must be an object");
+          }
           if ("caller" in normalizedBody) {
             throw new CallerError(
               "Pass caller via opts.caller, not in the request body."
@@ -4184,8 +4574,9 @@ function buildDefaultSelectInput(config) {
       const nested = {};
       if (value.select)
         nested.select = buildDefaultSelectInput(value.select);
-      if (value.include)
+      if (value.include) {
         nested.include = buildDefaultIncludeInput(value.include);
+      }
       result[key] = Object.keys(nested).length > 0 ? nested : true;
     }
   }
@@ -4204,8 +4595,9 @@ function buildDefaultIncludeInput(config) {
       result[key] = true;
     } else {
       const nested = {};
-      if (value.include)
+      if (value.include) {
         nested.include = buildDefaultIncludeInput(value.include);
+      }
       if (value.select)
         nested.select = buildDefaultSelectInput(value.select);
       result[key] = Object.keys(nested).length > 0 ? nested : true;
@@ -4216,8 +4608,9 @@ function buildDefaultIncludeInput(config) {
 function buildDefaultCountInput(config) {
   if (config === true)
     return true;
-  if (!isPlainObject(config) || !config.select || !isPlainObject(config.select))
+  if (!isPlainObject(config) || !config.select || !isPlainObject(config.select)) {
     return true;
+  }
   const selectObj = config.select;
   const result = {};
   for (const key of Object.keys(selectObj)) {
@@ -4299,8 +4692,9 @@ function checkIncludeForClientArgs(config) {
       continue;
     if (value.orderBy || value.cursor || value.take || value.skip)
       return true;
-    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where))
+    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where)) {
       return true;
+    }
     if (value.include && checkIncludeForClientArgs(value.include))
       return true;
     if (value.select && checkSelectForClientArgs(value.select))
@@ -4327,8 +4721,9 @@ function checkSelectForClientArgs(config) {
       continue;
     if (value.orderBy || value.cursor || value.take || value.skip)
       return true;
-    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where))
+    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where)) {
       return true;
+    }
     if (value.select && checkSelectForClientArgs(value.select))
       return true;
     if (value.include && checkIncludeForClientArgs(value.include))
@@ -4389,36 +4784,7 @@ function createModelGuardExtension(config) {
     validateUniqueEquality(modelName, shape.where, method, uniqueMap, typeMap);
   }
   function validateUniqueWhereShapeConfig(modelName, where, method) {
-    const constraints = uniqueMap[modelName];
-    if (!constraints || constraints.length === 0)
-      return;
-    const equalityFields = /* @__PURE__ */ new Set();
-    for (const [key, value] of Object.entries(where)) {
-      if (key === "AND" || key === "OR" || key === "NOT")
-        continue;
-      if (value === true) {
-        equalityFields.add(key);
-        continue;
-      }
-      if (isPlainObject(value)) {
-        if ("equals" in value) {
-          equalityFields.add(key);
-        }
-        continue;
-      }
-      if (value !== null && value !== void 0) {
-        equalityFields.add(key);
-      }
-    }
-    const valid = constraints.some(
-      (constraint) => constraint.every((field) => equalityFields.has(field))
-    );
-    if (!valid) {
-      const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
-      throw new ShapeError(
-        `${method} on model "${modelName}" requires where to cover a unique constraint with equality operators only: ${constraintDesc}`
-      );
-    }
+    validateUniqueEquality(modelName, where, method, uniqueMap, typeMap);
   }
   function createGuardedMethods(modelName, modelDelegate, input, explicitCaller) {
     function callDelegate(method, args) {
@@ -4692,10 +5058,10 @@ function createModelGuardExtension(config) {
               `Invalid "where" on model "${modelName}": unique where must be a plain object`
             );
           }
-          const sanitized = { ...bodyWhere };
-          for (const key of built.forcedOnlyKeys) {
-            delete sanitized[key];
-          }
+          const sanitized = hasWhereForced(built.forced) ? stripUniqueWhereForcedInput(
+            bodyWhere,
+            built.forced
+          ) : { ...bodyWhere };
           try {
             result = built.schema.parse(sanitized);
           } catch (err) {
@@ -4708,16 +5074,23 @@ function createModelGuardExtension(config) {
         }
       } else if (bodyWhere !== void 0 && bodyWhere !== null) {
         if (isPlainObject(bodyWhere)) {
-          const hasOnlyForcedKeys = built.forcedOnlyKeys.size > 0 && Object.keys(bodyWhere).every((k) => built.forcedOnlyKeys.has(k));
-          if (!hasOnlyForcedKeys && Object.keys(bodyWhere).length > 0) {
+          const sanitized = hasWhereForced(built.forced) ? stripUniqueWhereForcedInput(
+            bodyWhere,
+            built.forced
+          ) : { ...bodyWhere };
+          if (Object.keys(sanitized).length > 0) {
             throw new ShapeError(
               `Unique where on model "${modelName}" contains only forced values. Client where input is not accepted.`
             );
           }
+        } else {
+          throw new ShapeError(
+            `Invalid "where" on model "${modelName}": unique where must be a plain object`
+          );
         }
       }
-      for (const [key, value] of Object.entries(built.forced)) {
-        result[key] = value;
+      if (hasWhereForced(built.forced)) {
+        result = mergeUniqueWhereForced(result, built.forced);
       }
       return result;
     }
@@ -4730,7 +5103,9 @@ function createModelGuardExtension(config) {
       );
       if (Object.keys(where).length === 0) {
         const constraints = uniqueMap[modelName];
-        const constraintDesc = constraints ? constraints.map((c) => `(${c.join(", ")})`).join(" | ") : "unknown";
+        const constraintDesc = constraints ? constraints.map(
+          (constraint) => constraint.fields.length === 1 ? constraint.selector : `${constraint.selector}(${constraint.fields.join(", ")})`
+        ).join(" | ") : "unknown";
         const expectedFields = shape.where ? Object.keys(shape.where).join(", ") : "none defined";
         throw new ShapeError(
           `${method} on model "${modelName}" requires a unique where condition. Unique constraints: ${constraintDesc}. Shape allows: ${expectedFields}`
@@ -4806,8 +5181,9 @@ function createModelGuardExtension(config) {
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
-        if (!resolved.shape.data)
+        if (!resolved.shape.data) {
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
+        }
         validateMutationShapeKeys(
           resolved.shape,
           allowedShapeKeys,
@@ -4838,10 +5214,12 @@ function createModelGuardExtension(config) {
           );
           args = { data };
         } else {
-          if (!Array.isArray(resolved.body.data))
+          if (!Array.isArray(resolved.body.data)) {
             throw new ShapeError(`${method} expects data to be an array`);
-          if (resolved.body.data.length === 0)
+          }
+          if (resolved.body.data.length === 0) {
             throw new ShapeError(`${method} received empty data array`);
+          }
           const data = resolved.body.data.map(
             (item) => validateAndMergeData(item, dataSchema, method, modelName)
           );
@@ -4875,8 +5253,9 @@ function createModelGuardExtension(config) {
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
-        if (!resolved.shape.data)
+        if (!resolved.shape.data) {
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
+        }
         validateMutationShapeKeys(
           resolved.shape,
           allowedShapeKeys,
@@ -4955,8 +5334,9 @@ function createModelGuardExtension(config) {
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
-        if (resolved.shape.data)
+        if (resolved.shape.data) {
           throw new ShapeError(`Guard shape "data" is not valid for ${method}`);
+        }
         validateMutationShapeKeys(
           resolved.shape,
           allowedShapeKeys,