prisma-guard 1.3.1 → 1.4.1

package/dist/runtime/index.js

@@ -704,7 +704,24 @@ function mergeUniqueWhereForced(where, forced) {
   return result;
 }
 function applyBuiltShape(built, body, isUniqueMethod) {
-  const validated = built.zodSchema.parse(body);
+  let parseable = body;
+  if (built.forcedOnlyWhereKeys.size > 0 && isPlainObject(body)) {
+    const bodyObj = body;
+    if (isPlainObject(bodyObj.where)) {
+      const where = { ...bodyObj.where };
+      let stripped = false;
+      for (const key of built.forcedOnlyWhereKeys) {
+        if (key in where) {
+          delete where[key];
+          stripped = true;
+        }
+      }
+      if (stripped) {
+        parseable = { ...bodyObj, where };
+      }
+    }
+  }
+  const validated = built.zodSchema.parse(parseable);
   if (hasWhereForced(built.forcedWhere)) {
     validated.where = isUniqueMethod ? mergeUniqueWhereForced(
       validated.where,
@@ -928,7 +945,12 @@ function validateUniqueEquality(model, where, method, uniqueMap, typeMap) {
 
 // src/runtime/query-builder-where.ts
 var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
-var STRING_MODE_OPS = /* @__PURE__ */ new Set(["contains", "startsWith", "endsWith", "equals"]);
+var STRING_MODE_OPS = /* @__PURE__ */ new Set([
+  "contains",
+  "startsWith",
+  "endsWith",
+  "equals"
+]);
 var MAX_WHERE_DEPTH = 10;
 function safeStringify(v) {
   if (typeof v === "bigint")
@@ -998,9 +1020,7 @@ function mergeScalarConditions(target, source) {
       continue;
     }
     if (!forcedValuesEqual(existing, ops)) {
-      throw new ShapeError(
-        `Conflicting forced where values for "${field}"`
-      );
+      throw new ShapeError(`Conflicting forced where values for "${field}"`);
     }
   }
 }
@@ -1014,8 +1034,14 @@ function mergeRelationForcedMaps(target, source) {
       if (!target[relName][op]) {
         target[relName][op] = forced;
       } else {
-        mergeScalarConditions(target[relName][op].conditions, forced.conditions);
-        mergeRelationForcedMaps(target[relName][op].relations, forced.relations);
+        mergeScalarConditions(
+          target[relName][op].conditions,
+          forced.conditions
+        );
+        mergeRelationForcedMaps(
+          target[relName][op].relations,
+          forced.relations
+        );
       }
     }
   }
@@ -1067,20 +1093,38 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
           `${fieldMeta.type} field "${key}" cannot be used in where filters`
         );
       }
-      processScalarField(key, value, model, fieldMeta, fieldSchemas, scalarConditions);
+      processScalarField(
+        key,
+        value,
+        model,
+        fieldMeta,
+        fieldSchemas,
+        scalarConditions
+      );
     }
     const schema = Object.keys(fieldSchemas).length > 0 ? z4.object(fieldSchemas).strict().optional() : null;
+    const forcedOnlyKeys = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(whereConfig)) {
+      if (COMBINATOR_KEYS.has(key))
+        continue;
+      if (!(key in fieldSchemas)) {
+        forcedOnlyKeys.add(key);
+      }
+    }
     return {
       schema,
       forced: {
         conditions: scalarConditions,
         relations: relationForced
-      }
+      },
+      forcedOnlyKeys
     };
   }
   function processCombinator(key, value, model, fieldSchemas, parentConditions, parentRelations, depth) {
     if (!isPlainObject(value)) {
-      throw new ShapeError(`"${key}" in where shape must be an object defining allowed fields`);
+      throw new ShapeError(
+        `"${key}" in where shape must be an object defining allowed fields`
+      );
     }
     const result = buildWhereSchema(model, value, depth + 1);
     if (!result.schema && !hasWhereForced(result.forced)) {
@@ -1121,7 +1165,9 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
   }
   function processRelationFilter(key, value, fieldMeta, model, fieldSchemas, parentRelations, depth) {
     if (!isPlainObject(value)) {
-      throw new ShapeError(`Relation filter for "${key}" must be an object with operators (some, every, none, is, isNot)`);
+      throw new ShapeError(
+        `Relation filter for "${key}" must be an object with operators (some, every, none, is, isNot)`
+      );
     }
     const allowedOps = fieldMeta.isList ? TO_MANY_RELATION_OPS : TO_ONE_RELATION_OPS;
     if (Object.keys(value).length === 0) {
@@ -1154,7 +1200,9 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
         if (!hasWhereForced(nested.forced)) {
           opSchemas[op] = nested.schema.refine(
             (v) => v === void 0 || Object.keys(v).length > 0,
-            { message: `Relation filter "${key}.${op}" requires at least one condition` }
+            {
+              message: `Relation filter "${key}.${op}" requires at least one condition`
+            }
           );
         } else {
           opSchemas[op] = nested.schema;
@@ -1175,7 +1223,9 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
       const opObjSchema = z4.object(opSchemas).strict();
       if (Object.keys(opForced).length === 0) {
         fieldSchemas[key] = opObjSchema.refine(
-          (v) => clientOpKeys.some((k) => v[k] !== void 0),
+          (v) => clientOpKeys.some(
+            (k) => v[k] !== void 0
+          ),
           { message: `At least one relation operator required for "${key}"` }
         ).optional();
       } else {
@@ -1199,7 +1249,12 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
     const clientOpKeys = [];
     for (const [op, opValue] of Object.entries(operators)) {
       if (opValue === true) {
-        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap, scalarBase).optional();
+        opSchemas[op] = createOperatorSchema(
+          fieldMeta,
+          op,
+          enumMap,
+          scalarBase
+        ).optional();
         hasClientOps = true;
         clientOpKeys.push(op);
         if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
@@ -1207,7 +1262,12 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
         }
       } else {
         const actualOpValue = isForcedValue(opValue) ? opValue.value : opValue;
-        const opSchema = createOperatorSchema(fieldMeta, op, enumMap, scalarBase);
+        const opSchema = createOperatorSchema(
+          fieldMeta,
+          op,
+          enumMap,
+          scalarBase
+        );
         let parsed;
         try {
           parsed = opSchema.parse(actualOpValue);
@@ -1230,8 +1290,12 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
     if (hasClientOps) {
       const opObj = z4.object(opSchemas).strict();
       fieldSchemas[fieldName] = opObj.refine(
-        (v) => clientOpKeys.some((k) => v[k] !== void 0),
-        { message: `At least one operator required for where field "${fieldName}"` }
+        (v) => clientOpKeys.some(
+          (k) => v[k] !== void 0
+        ),
+        {
+          message: `At least one operator required for where field "${fieldName}"`
+        }
       ).optional();
     }
     if (Object.keys(fieldForced).length > 0) {
@@ -1254,23 +1318,80 @@ function requireConfigTrue(config, context) {
   }
 }
 function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
+  const sortEnum = z5.enum(["asc", "desc"]);
+  const nullsEnum = z5.enum(["first", "last"]);
+  const sortWithNulls = z5.object({ sort: sortEnum, nulls: nullsEnum.optional() }).strict();
+  const scalarOrderSchema = z5.union([sortEnum, sortWithNulls]);
+  function validateScalarOrderByField(fieldName, model, modelFields) {
+    const fieldMeta = modelFields[fieldName];
+    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`);
+    if (fieldMeta.type === "Json")
+      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`);
+  }
   function buildOrderBySchema(model, orderByConfig) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    requireConfigTrue(orderByConfig, `orderBy on model "${model}"`);
     const fieldSchemas = {};
-    for (const fieldName of Object.keys(orderByConfig)) {
+    for (const [fieldName, config] of Object.entries(orderByConfig)) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
         throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
-      if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in orderBy`);
-      if (fieldMeta.type === "Json")
-        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`);
-      fieldSchemas[fieldName] = z5.enum(["asc", "desc"]).optional();
+      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 (!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.`);
+      }
+      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 (config._count !== true) {
+          throw new ShapeError(`_count in orderBy for "${fieldName}" must be true`);
+        }
+        fieldSchemas[fieldName] = z5.object({ _count: sortEnum }).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] = z5.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 fieldKeys = Object.keys(fieldSchemas);
     const singleSchema = z5.object(fieldSchemas).strict().refine(
@@ -1840,19 +1961,77 @@ function createProjectionBuilder(typeMap, enumMap, deps) {
 
 // src/runtime/query-builder.ts
 var METHOD_ALLOWED_ARGS = {
-  findMany: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
-  findFirst: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
-  findFirstOrThrow: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
+  findMany: /* @__PURE__ */ new Set([
+    "where",
+    "include",
+    "select",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "distinct"
+  ]),
+  findFirst: /* @__PURE__ */ new Set([
+    "where",
+    "include",
+    "select",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "distinct"
+  ]),
+  findFirstOrThrow: /* @__PURE__ */ new Set([
+    "where",
+    "include",
+    "select",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "distinct"
+  ]),
   findUnique: /* @__PURE__ */ new Set(["where", "include", "select"]),
   findUniqueOrThrow: /* @__PURE__ */ new Set(["where", "include", "select"]),
   count: /* @__PURE__ */ new Set(["where", "select", "cursor", "orderBy", "skip", "take"]),
-  aggregate: /* @__PURE__ */ new Set(["where", "orderBy", "cursor", "take", "skip", "_count", "_avg", "_sum", "_min", "_max"]),
-  groupBy: /* @__PURE__ */ new Set(["where", "by", "having", "_count", "_avg", "_sum", "_min", "_max", "orderBy", "take", "skip"])
+  aggregate: /* @__PURE__ */ new Set([
+    "where",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "_count",
+    "_avg",
+    "_sum",
+    "_min",
+    "_max"
+  ]),
+  groupBy: /* @__PURE__ */ new Set([
+    "where",
+    "by",
+    "having",
+    "_count",
+    "_avg",
+    "_sum",
+    "_min",
+    "_max",
+    "orderBy",
+    "take",
+    "skip"
+  ])
 };
-var UNIQUE_WHERE_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
+var UNIQUE_WHERE_METHODS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findUniqueOrThrow"
+]);
 function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
   const whereBuilder = createWhereBuilder(typeMap, enumMap, scalarBase);
-  const argsBuilder = createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase);
+  const argsBuilder = createArgsBuilder(
+    typeMap,
+    enumMap,
+    uniqueMap,
+    scalarBase
+  );
   const projectionBuilder = createProjectionBuilder(typeMap, enumMap, {
     buildWhereSchema: whereBuilder.buildWhereSchema,
     buildOrderBySchema: argsBuilder.buildOrderBySchema,
@@ -1877,7 +2056,9 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       throw new ShapeError(`${method} shape must define "where"`);
     }
     if (shape.include && shape.select) {
-      throw new ShapeError('Shape config cannot define both "include" and "select".');
+      throw new ShapeError(
+        'Shape config cannot define both "include" and "select".'
+      );
     }
     if (method === "groupBy" && !shape.by)
       throw new ShapeError('groupBy shape must define "by"');
@@ -1893,7 +2074,9 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       const bySet = new Set(shape.by);
       for (const fieldName of Object.keys(shape.orderBy)) {
         if (!bySet.has(fieldName)) {
-          throw new ShapeError(`orderBy field "${fieldName}" must be included in "by" for groupBy`);
+          throw new ShapeError(
+            `orderBy field "${fieldName}" must be included in "by" for groupBy`
+          );
         }
       }
     }
@@ -1901,7 +2084,9 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       const bySet = new Set(shape.by);
       for (const fieldName of Object.keys(shape.having)) {
         if (!bySet.has(fieldName)) {
-          throw new ShapeError(`having field "${fieldName}" must be included in "by" for groupBy`);
+          throw new ShapeError(
+            `having field "${fieldName}" must be included in "by" for groupBy`
+          );
         }
       }
     }
@@ -1918,7 +2103,9 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       requireContext(ctx, "shape function");
       const result = shapeOrFn(ctx);
       if (!isPlainObject(result)) {
-        throw new ShapeError("Dynamic shape function must return a plain object");
+        throw new ShapeError(
+          "Dynamic shape function must return a plain object"
+        );
       }
       return result;
     }
@@ -1929,15 +2116,20 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     validateUniqueWhere(model, method, shape);
     const schemaFields = {};
     let forcedWhere = EMPTY_WHERE_FORCED;
+    let forcedOnlyWhereKeys = /* @__PURE__ */ new Set();
     let forcedIncludeTree = {};
     let forcedSelectTree = {};
     let forcedIncludeCountWhere = {};
     let forcedSelectCountWhere = {};
     if (shape.where) {
-      const { schema, forced } = whereBuilder.buildWhereSchema(model, shape.where);
+      const { schema, forced, forcedOnlyKeys } = whereBuilder.buildWhereSchema(
+        model,
+        shape.where
+      );
       if (schema)
         schemaFields["where"] = schema;
       forcedWhere = forced;
+      forcedOnlyWhereKeys = forcedOnlyKeys;
     }
     if (shape.include) {
       const result = projectionBuilder.buildIncludeSchema(model, shape.include);
@@ -1947,7 +2139,10 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     }
     if (shape.select) {
       if (method === "count") {
-        schemaFields["select"] = argsBuilder.buildCountSelectSchema(model, shape.select);
+        schemaFields["select"] = argsBuilder.buildCountSelectSchema(
+          model,
+          shape.select
+        );
       } else {
         const result = projectionBuilder.buildSelectSchema(model, shape.select);
         schemaFields["select"] = result.schema;
@@ -1956,9 +2151,15 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       }
     }
     if (shape.orderBy)
-      schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(model, shape.orderBy);
+      schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
+        model,
+        shape.orderBy
+      );
     if (shape.cursor)
-      schemaFields["cursor"] = argsBuilder.buildCursorSchema(model, shape.cursor);
+      schemaFields["cursor"] = argsBuilder.buildCursorSchema(
+        model,
+        shape.cursor
+      );
     if (shape.take)
       schemaFields["take"] = argsBuilder.buildTakeSchema(shape.take);
     if (shape.skip !== void 0) {
@@ -1968,24 +2169,51 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       schemaFields["skip"] = z7.number().int().min(0).optional();
     }
     if (shape.distinct)
-      schemaFields["distinct"] = argsBuilder.buildDistinctSchema(model, shape.distinct);
+      schemaFields["distinct"] = argsBuilder.buildDistinctSchema(
+        model,
+        shape.distinct
+      );
     if (shape._count)
-      schemaFields["_count"] = argsBuilder.buildCountFieldSchema(model, shape._count, "_count");
+      schemaFields["_count"] = argsBuilder.buildCountFieldSchema(
+        model,
+        shape._count,
+        "_count"
+      );
     if (shape._avg)
-      schemaFields["_avg"] = argsBuilder.buildAggregateFieldSchema(model, "_avg", shape._avg);
+      schemaFields["_avg"] = argsBuilder.buildAggregateFieldSchema(
+        model,
+        "_avg",
+        shape._avg
+      );
     if (shape._sum)
-      schemaFields["_sum"] = argsBuilder.buildAggregateFieldSchema(model, "_sum", shape._sum);
+      schemaFields["_sum"] = argsBuilder.buildAggregateFieldSchema(
+        model,
+        "_sum",
+        shape._sum
+      );
     if (shape._min)
-      schemaFields["_min"] = argsBuilder.buildAggregateFieldSchema(model, "_min", shape._min);
+      schemaFields["_min"] = argsBuilder.buildAggregateFieldSchema(
+        model,
+        "_min",
+        shape._min
+      );
     if (shape._max)
-      schemaFields["_max"] = argsBuilder.buildAggregateFieldSchema(model, "_max", 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(model, shape.having);
+      schemaFields["having"] = argsBuilder.buildHavingSchema(
+        model,
+        shape.having
+      );
     return {
       zodSchema: z7.object(schemaFields).strict(),
       forcedWhere,
+      forcedOnlyWhereKeys,
       forcedIncludeTree,
       forcedSelectTree,
       forcedIncludeCountWhere,
@@ -2002,17 +2230,27 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     const isSingle = typeof config === "function" || isShapeConfig(config);
     const builtCache = /* @__PURE__ */ new Map();
     if (isSingle && typeof config !== "function") {
-      builtCache.set("_default", buildShapeZodSchema(model, method, config));
+      builtCache.set(
+        "_default",
+        buildShapeZodSchema(model, method, config)
+      );
     }
     if (!isSingle) {
       for (const key of Object.keys(config)) {
         if (SHAPE_CONFIG_KEYS.has(key)) {
-          throw new ShapeError(`Caller key "${key}" collides with reserved shape config key. Rename the caller path.`);
+          throw new ShapeError(
+            `Caller key "${key}" collides with reserved shape config key. Rename the caller path.`
+          );
         }
       }
-      for (const [key, shapeOrFn] of Object.entries(config)) {
+      for (const [key, shapeOrFn] of Object.entries(
+        config
+      )) {
         if (typeof shapeOrFn !== "function") {
-          builtCache.set(key, buildShapeZodSchema(model, method, shapeOrFn));
+          builtCache.set(
+            key,
+            buildShapeZodSchema(model, method, shapeOrFn)
+          );
         }
       }
     }
@@ -2041,14 +2279,21 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
           }
           const caller = opts?.caller;
           if (typeof caller !== "string") {
-            const allowed = Object.keys(config);
+            const allowed = Object.keys(
+              config
+            );
             throw new CallerError(
               `Missing caller. This query uses named shape routing with keys: ${allowed.map((k) => `"${k}"`).join(", ")}. Provide caller via opts.caller.`
             );
           }
-          const matched = matchCaller(config, caller);
+          const matched = matchCaller(
+            config,
+            caller
+          );
           if (!matched) {
-            const allowed = Object.keys(config);
+            const allowed = Object.keys(
+              config
+            );
             throw new CallerError(
               `Unknown caller: "${caller}". Allowed: ${allowed.map((k) => `"${k}"`).join(", ")}`
             );
@@ -2681,7 +2926,10 @@ function resolveShape(input, body, contextFn, caller) {
 
 // src/runtime/model-guard.ts
 var UNIQUE_MUTATION_METHODS = /* @__PURE__ */ new Set(["update", "delete", "upsert"]);
-var UNIQUE_READ_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
+var UNIQUE_READ_METHODS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findUniqueOrThrow"
+]);
 var BULK_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "updateMany",
   "updateManyAndReturn",
@@ -2695,15 +2943,14 @@ var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "createManyAndReturn",
   "updateManyAndReturn"
 ]);
-var BATCH_CREATE_METHODS = /* @__PURE__ */ new Set([
-  "createMany",
-  "createManyAndReturn"
-]);
+var BATCH_CREATE_METHODS = /* @__PURE__ */ new Set(["createMany", "createManyAndReturn"]);
 function buildDefaultSelectInput(config) {
   const result = {};
   for (const [key, value] of Object.entries(config)) {
     if (key === "_count") {
-      result[key] = buildDefaultCountInput(value);
+      result[key] = buildDefaultCountInput(
+        value
+      );
       continue;
     }
     if (value === true) {
@@ -2721,7 +2968,9 @@ function buildDefaultIncludeInput(config) {
   const result = {};
   for (const [key, value] of Object.entries(config)) {
     if (key === "_count") {
-      result[key] = buildDefaultCountInput(value);
+      result[key] = buildDefaultCountInput(
+        value
+      );
       continue;
     }
     if (value === true) {
@@ -2835,12 +3084,32 @@ function hasNestedClientControlledArgs(shape) {
   return false;
 }
 function createModelGuardExtension(config) {
-  const { typeMap, enumMap, zodChains, zodDefaults, uniqueMap, scopeMap, guardConfig, contextFn } = config;
+  const {
+    typeMap,
+    enumMap,
+    zodChains,
+    zodDefaults,
+    uniqueMap,
+    scopeMap,
+    guardConfig,
+    contextFn
+  } = config;
   const wrapZodErrors = config.wrapZodErrors ?? false;
   const enforceProjection = guardConfig.enforceProjection ?? false;
   const scalarBase = createScalarBase(guardConfig.strictDecimal ?? false);
-  const schemaBuilder = createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefaults);
-  const queryBuilder = createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase);
+  const schemaBuilder = createSchemaBuilder(
+    typeMap,
+    zodChains,
+    enumMap,
+    scalarBase,
+    zodDefaults
+  );
+  const queryBuilder = createQueryBuilder(
+    typeMap,
+    enumMap,
+    uniqueMap,
+    scalarBase
+  );
   const modelScopeFks = /* @__PURE__ */ new Map();
   for (const [model, entries] of Object.entries(scopeMap)) {
     const fks = /* @__PURE__ */ new Set();
@@ -2858,7 +3127,9 @@ function createModelGuardExtension(config) {
   function createGuardedMethods(modelName, modelDelegate, input, explicitCaller) {
     function callDelegate(method, args) {
       if (typeof modelDelegate[method] !== "function") {
-        throw new ShapeError(`Method "${method}" is not available on this model`);
+        throw new ShapeError(
+          `Method "${method}" is not available on this model`
+        );
       }
       return modelDelegate[method](args);
     }
@@ -2881,11 +3152,19 @@ function createModelGuardExtension(config) {
         const cached = readShapeCache.get(cacheKey);
         if (cached)
           return cached;
-        const built = queryBuilder.buildShapeZodSchema(modelName, method, queryShape);
+        const built = queryBuilder.buildShapeZodSchema(
+          modelName,
+          method,
+          queryShape
+        );
         readShapeCache.set(cacheKey, built);
         return built;
       }
-      return queryBuilder.buildShapeZodSchema(modelName, method, queryShape);
+      return queryBuilder.buildShapeZodSchema(
+        modelName,
+        method,
+        queryShape
+      );
     }
     function getDataSchema(mode, dataConfig, matchedKey, wasDynamic) {
       if (!wasDynamic && !hasDataRefines(dataConfig)) {
@@ -2893,11 +3172,25 @@ function createModelGuardExtension(config) {
         const cached = dataSchemaCache.get(cacheKey);
         if (cached)
           return cached;
-        const built = buildDataSchema(modelName, dataConfig, mode, typeMap, schemaBuilder, zodDefaults);
+        const built = buildDataSchema(
+          modelName,
+          dataConfig,
+          mode,
+          typeMap,
+          schemaBuilder,
+          zodDefaults
+        );
         dataSchemaCache.set(cacheKey, built);
         return built;
       }
-      return buildDataSchema(modelName, dataConfig, mode, typeMap, schemaBuilder, zodDefaults);
+      return buildDataSchema(
+        modelName,
+        dataConfig,
+        mode,
+        typeMap,
+        schemaBuilder,
+        zodDefaults
+      );
     }
     function getWhereBuilt(whereConfig, matchedKey, wasDynamic) {
       if (!wasDynamic) {
@@ -3016,12 +3309,28 @@ function createModelGuardExtension(config) {
       const built = getWhereBuilt(shape.where, matchedKey, wasDynamic);
       let validatedWhere;
       if (built.schema) {
-        validatedWhere = built.schema.parse(bodyWhere);
+        let sanitizedWhere = bodyWhere;
+        if (built.forcedOnlyKeys.size > 0 && isPlainObject(bodyWhere)) {
+          const w = { ...bodyWhere };
+          for (const key of built.forcedOnlyKeys) {
+            delete w[key];
+          }
+          sanitizedWhere = w;
+        }
+        validatedWhere = built.schema.parse(sanitizedWhere);
       } else if (bodyWhere !== void 0) {
         if (bodyWhere === null || !isPlainObject(bodyWhere) || Object.keys(bodyWhere).length > 0) {
-          throw new ShapeError(
-            "Guard shape where contains only forced conditions. Client where input is not accepted."
-          );
+          let hasOnlyForcedKeys = false;
+          if (isPlainObject(bodyWhere) && built.forcedOnlyKeys.size > 0) {
+            hasOnlyForcedKeys = Object.keys(bodyWhere).every(
+              (k) => built.forcedOnlyKeys.has(k)
+            );
+          }
+          if (!hasOnlyForcedKeys) {
+            throw new ShapeError(
+              "Guard shape where contains only forced conditions. Client where input is not accepted."
+            );
+          }
         }
       }
       if (hasWhereForced(built.forced)) {
@@ -3030,7 +3339,13 @@ function createModelGuardExtension(config) {
       return validatedWhere ?? {};
     }
     function requireWhere(shape, bodyWhere, method, preserveUnique, matchedKey, wasDynamic) {
-      const where = buildWhereFromShape(shape, bodyWhere, preserveUnique, matchedKey, wasDynamic);
+      const where = buildWhereFromShape(
+        shape,
+        bodyWhere,
+        preserveUnique,
+        matchedKey,
+        wasDynamic
+      );
       if (Object.keys(where).length === 0) {
         throw new ShapeError(`${method} requires a where condition`);
       }
@@ -3044,7 +3359,12 @@ function createModelGuardExtension(config) {
           throw new ShapeError(`Guard shape "data" is not valid for ${method}`);
         }
         const { data: _, ...queryShape } = resolved.shape;
-        const built = getReadShape(method, queryShape, resolved.matchedKey, resolved.wasDynamic);
+        const built = getReadShape(
+          method,
+          queryShape,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
         const isUnique = UNIQUE_READ_METHODS.has(method);
         const args = applyBuiltShape(built, resolved.body, isUnique);
         if (isUnique && args.where) {
@@ -3077,14 +3397,33 @@ function createModelGuardExtension(config) {
         const resolved = resolveShape(input, body, contextFn, caller);
         if (!resolved.shape.data)
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
-        validateMutationShapeKeys(resolved.shape, allowedShapeKeys, method);
+        validateMutationShapeKeys(
+          resolved.shape,
+          allowedShapeKeys,
+          method
+        );
         validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
         const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
-        validateCreateCompleteness(modelName, resolved.shape.data, typeMap, fks, zodDefaults);
-        const dataSchema = getDataSchema("create", resolved.shape.data, resolved.matchedKey, resolved.wasDynamic);
+        validateCreateCompleteness(
+          modelName,
+          resolved.shape.data,
+          typeMap,
+          fks,
+          zodDefaults
+        );
+        const dataSchema = getDataSchema(
+          "create",
+          resolved.shape.data,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
         let args;
         if (method === "create") {
-          const data = validateAndMergeData(resolved.body.data, dataSchema, method);
+          const data = validateAndMergeData(
+            resolved.body.data,
+            dataSchema,
+            method
+          );
           args = { data };
         } else {
           if (!Array.isArray(resolved.body.data))
@@ -3103,7 +3442,13 @@ function createModelGuardExtension(config) {
           args.skipDuplicates = resolved.body.skipDuplicates;
         }
         if (supportsProjection) {
-          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
+          const projectionArgs = resolveProjection(
+            resolved.shape,
+            resolved.body,
+            method,
+            resolved.matchedKey,
+            resolved.wasDynamic
+          );
           Object.assign(args, projectionArgs);
         }
         return callDelegate(method, args);
@@ -3120,24 +3465,60 @@ function createModelGuardExtension(config) {
         const resolved = resolveShape(input, body, contextFn, caller);
         if (!resolved.shape.data)
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
-        validateMutationShapeKeys(resolved.shape, allowedShapeKeys, method);
+        validateMutationShapeKeys(
+          resolved.shape,
+          allowedShapeKeys,
+          method
+        );
         validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
         if (isBulk && !resolved.shape.where) {
-          throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
+          throw new ShapeError(
+            `Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`
+          );
         }
         maybeValidateUniqueWhere(modelName, resolved.shape, method);
-        const dataSchema = getDataSchema("update", resolved.shape.data, resolved.matchedKey, resolved.wasDynamic);
-        const data = validateAndMergeData(resolved.body.data, dataSchema, method);
-        const where = isUniqueWhere ? requireWhere(resolved.shape, resolved.body.where, method, true, resolved.matchedKey, resolved.wasDynamic) : buildWhereFromShape(resolved.shape, resolved.body.where, false, resolved.matchedKey, resolved.wasDynamic);
+        const dataSchema = getDataSchema(
+          "update",
+          resolved.shape.data,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
+        const data = validateAndMergeData(
+          resolved.body.data,
+          dataSchema,
+          method
+        );
+        const where = isUniqueWhere ? requireWhere(
+          resolved.shape,
+          resolved.body.where,
+          method,
+          true,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        ) : buildWhereFromShape(
+          resolved.shape,
+          resolved.body.where,
+          false,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
         if (isBulk && Object.keys(where).length === 0) {
-          throw new ShapeError(`${method} requires at least one where condition`);
+          throw new ShapeError(
+            `${method} requires at least one where condition`
+          );
         }
         if (isUniqueWhere) {
           validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
         }
         const args = { data, where };
         if (supportsProjection) {
-          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
+          const projectionArgs = resolveProjection(
+            resolved.shape,
+            resolved.body,
+            method,
+            resolved.matchedKey,
+            resolved.wasDynamic
+          );
           Object.assign(args, projectionArgs);
         }
         return callDelegate(method, args);
@@ -3154,22 +3535,49 @@ function createModelGuardExtension(config) {
         const resolved = resolveShape(input, body, contextFn, caller);
         if (resolved.shape.data)
           throw new ShapeError(`Guard shape "data" is not valid for ${method}`);
-        validateMutationShapeKeys(resolved.shape, allowedShapeKeys, method);
+        validateMutationShapeKeys(
+          resolved.shape,
+          allowedShapeKeys,
+          method
+        );
         validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
         if (isBulk && !resolved.shape.where) {
-          throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
+          throw new ShapeError(
+            `Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`
+          );
         }
         maybeValidateUniqueWhere(modelName, resolved.shape, method);
-        const where = isUniqueWhere ? requireWhere(resolved.shape, resolved.body.where, method, true, resolved.matchedKey, resolved.wasDynamic) : buildWhereFromShape(resolved.shape, resolved.body.where, false, resolved.matchedKey, resolved.wasDynamic);
+        const where = isUniqueWhere ? requireWhere(
+          resolved.shape,
+          resolved.body.where,
+          method,
+          true,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        ) : buildWhereFromShape(
+          resolved.shape,
+          resolved.body.where,
+          false,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
         if (isBulk && Object.keys(where).length === 0) {
-          throw new ShapeError(`${method} requires at least one where condition`);
+          throw new ShapeError(
+            `${method} requires at least one where condition`
+          );
         }
         if (isUniqueWhere) {
           validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
         }
         const args = { where };
         if (supportsProjection) {
-          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
+          const projectionArgs = resolveProjection(
+            resolved.shape,
+            resolved.body,
+            method,
+            resolved.matchedKey,
+            resolved.wasDynamic
+          );
           Object.assign(args, projectionArgs);
         }
         return callDelegate(method, args);
@@ -3180,7 +3588,9 @@ function createModelGuardExtension(config) {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
         if (resolved.shape.data) {
-          throw new ShapeError('Guard shape "data" is not valid for upsert. Use "create" and "update" instead.');
+          throw new ShapeError(
+            'Guard shape "data" is not valid for upsert. Use "create" and "update" instead.'
+          );
         }
         if (!resolved.shape.create) {
           throw new ShapeError('Guard shape requires "create" for upsert');
@@ -3196,24 +3606,42 @@ function createModelGuardExtension(config) {
           VALID_SHAPE_KEYS_UPSERT,
           "upsert"
         );
-        validateMutationBodyKeys(resolved.body, ALLOWED_BODY_KEYS_UPSERT, "upsert");
+        validateMutationBodyKeys(
+          resolved.body,
+          ALLOWED_BODY_KEYS_UPSERT,
+          "upsert"
+        );
         maybeValidateUniqueWhere(modelName, resolved.shape, "upsert");
         const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
-        validateCreateCompleteness(modelName, resolved.shape.create, typeMap, fks, zodDefaults);
+        validateCreateCompleteness(
+          modelName,
+          resolved.shape.create,
+          typeMap,
+          fks,
+          zodDefaults
+        );
         const createDataSchema = getDataSchema(
           "create",
           resolved.shape.create,
           `upsert:create\0${resolved.matchedKey}`,
           resolved.wasDynamic
         );
-        const createData = validateAndMergeData(resolved.body.create, createDataSchema, "upsert (create)");
+        const createData = validateAndMergeData(
+          resolved.body.create,
+          createDataSchema,
+          "upsert (create)"
+        );
         const updateDataSchema = getDataSchema(
           "update",
           resolved.shape.update,
           `upsert:update\0${resolved.matchedKey}`,
           resolved.wasDynamic
         );
-        const updateData = validateAndMergeData(resolved.body.update, updateDataSchema, "upsert (update)");
+        const updateData = validateAndMergeData(
+          resolved.body.update,
+          updateDataSchema,
+          "upsert (update)"
+        );
         const where = requireWhere(
           resolved.shape,
           resolved.body.where,
@@ -3267,10 +3695,9 @@ function createModelGuardExtension(config) {
           return fn(body);
         } catch (err) {
           if (err instanceof z9.ZodError) {
-            throw new ShapeError(
-              `Validation failed: ${formatZodError(err)}`,
-              { cause: err }
-            );
+            throw new ShapeError(`Validation failed: ${formatZodError(err)}`, {
+              cause: err
+            });
           }
           throw err;
         }
@@ -3289,7 +3716,12 @@ function createModelGuardExtension(config) {
             `Could not resolve Prisma delegate for model "${modelName}" (key: "${delegateKey}")`
           );
         }
-        const methods = createGuardedMethods(modelName, modelDelegate, input, caller);
+        const methods = createGuardedMethods(
+          modelName,
+          modelDelegate,
+          input,
+          caller
+        );
         if (!wrapZodErrors)
           return methods;
         return wrapMethods(methods);