prisma-guard 1.4.0 → 1.5.0

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 {
@@ -1197,9 +1247,21 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
     let hasClientOps = false;
     let hasStringModeOp = false;
     const clientOpKeys = [];
+    let modeConfigValue = void 0;
+    let hasModeConfig = false;
     for (const [op, opValue] of Object.entries(operators)) {
+      if (op === "mode") {
+        hasModeConfig = true;
+        modeConfigValue = opValue;
+        continue;
+      }
       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 +1269,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);
@@ -1217,21 +1284,54 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
           );
         }
         fieldForced[op] = parsed;
+        if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
+          hasStringModeOp = true;
+        }
       }
     }
     if (!hasClientOps && Object.keys(fieldForced).length === 0) {
+      if (hasModeConfig) {
+        throw new ShapeError(
+          `Where field "${fieldName}" on model "${model}" has "mode" but no operators. Add at least one operator (contains, startsWith, endsWith, equals).`
+        );
+      }
       throw new ShapeError(
         `Empty operator config for where field "${fieldName}" on model "${model}". Define at least one operator.`
       );
     }
-    if (hasStringModeOp) {
+    if (hasModeConfig) {
+      if (!hasStringModeOp) {
+        throw new ShapeError(
+          `"mode" on where field "${fieldName}" on model "${model}" requires a compatible String operator (contains, startsWith, endsWith, equals)`
+        );
+      }
+      if (modeConfigValue === true) {
+        opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
+      } else {
+        const actualModeValue = isForcedValue(modeConfigValue) ? modeConfigValue.value : modeConfigValue;
+        const modeSchema = z4.enum(["default", "insensitive"]);
+        let parsed;
+        try {
+          parsed = modeSchema.parse(actualModeValue);
+        } catch (err) {
+          throw new ShapeError(
+            `Invalid forced value for "${model}.${fieldName}.mode": ${err.message}`
+          );
+        }
+        fieldForced["mode"] = parsed;
+      }
+    } else if (hasStringModeOp) {
       opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
     }
     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) {
@@ -1897,19 +1997,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,
@@ -1934,7 +2092,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"');
@@ -1950,7 +2110,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`
+          );
         }
       }
     }
@@ -1958,7 +2120,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`
+          );
         }
       }
     }
@@ -1975,7 +2139,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;
     }
@@ -1986,15 +2152,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);
@@ -2004,7 +2175,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;
@@ -2013,9 +2187,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) {
@@ -2025,24 +2205,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,
@@ -2059,17 +2266,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)
+          );
         }
       }
     }
@@ -2098,14 +2315,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(", ")}`
             );
@@ -2738,7 +2962,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",
@@ -2752,15 +2979,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) {
@@ -2778,7 +3004,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) {
@@ -2892,12 +3120,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();
@@ -2915,7 +3163,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);
     }
@@ -2938,11 +3188,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)) {
@@ -2950,11 +3208,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) {
@@ -3073,12 +3345,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)) {
@@ -3087,7 +3375,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`);
       }
@@ -3101,7 +3395,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) {
@@ -3134,14 +3433,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))
@@ -3160,7 +3478,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);
@@ -3177,24 +3501,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);
@@ -3211,22 +3571,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);
@@ -3237,7 +3624,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');
@@ -3253,24 +3642,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,
@@ -3324,10 +3731,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;
         }
@@ -3346,7 +3752,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);