prisma-guard 1.19.0 → 1.20.0

package/dist/runtime/index.cjs

@@ -1451,13 +1451,6 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
     }
   }
   function processScalarField(fieldName, operators, model, fieldMeta, fieldSchemas, scalarConditions) {
-    if (operators === true) {
-      const supportedOps = getSupportedOperators(fieldMeta);
-      const expanded = {};
-      for (const op of supportedOps)
-        expanded[op] = true;
-      operators = expanded;
-    }
     if (!isPlainObject(operators)) {
       throw new ShapeError(
         `Where config for scalar field "${fieldName}" on model "${model}" must be an object of operators`
@@ -1570,7 +1563,82 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
       scalarConditions[fieldName] = fieldForced;
     }
   }
-  return { buildWhereSchema };
+  function buildUniqueWhereSchema(model, whereConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    const forced = {};
+    const forcedOnlyKeys = /* @__PURE__ */ new Set();
+    for (const [key, value] of Object.entries(whereConfig)) {
+      if (COMBINATOR_KEYS.has(key)) {
+        throw new ShapeError(
+          `Combinator "${key}" is not supported in unique where for model "${model}"`
+        );
+      }
+      const fieldMeta = modelFields[key];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${key}" on model "${model}"`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(
+          `Relation field "${key}" cannot be used in unique where for model "${model}"`
+        );
+      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 (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;
+        }
+        throw new ShapeError(
+          `Unique where field "${key}" on model "${model}" only accepts true or { equals: true/value }. Got operators: ${keys.join(", ")}`
+        );
+      }
+      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}`
+        );
+      }
+      forcedOnlyKeys.add(key);
+    }
+    return {
+      schema: Object.keys(fieldSchemas).length > 0 ? import_zod4.z.object(fieldSchemas).strict() : null,
+      forced,
+      forcedOnlyKeys
+    };
+  }
+  return { buildWhereSchema, buildUniqueWhereSchema };
 }
 
 // src/runtime/query-builder-args.ts
@@ -2656,6 +2724,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     buildQuerySchema,
     buildShapeZodSchema,
     buildWhereSchema: whereBuilder.buildWhereSchema,
+    buildUniqueWhereSchema: whereBuilder.buildUniqueWhereSchema,
     buildIncludeSchema: projectionBuilder.buildIncludeSchema,
     buildSelectSchema: projectionBuilder.buildSelectSchema
   };
@@ -3801,17 +3870,6 @@ var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "updateManyAndReturn"
 ]);
 var BATCH_CREATE_METHODS = /* @__PURE__ */ new Set(["createMany", "createManyAndReturn"]);
-function normalizeUniqueWhere(where) {
-  const result = {};
-  for (const [key, value] of Object.entries(where)) {
-    if (key !== "AND" && key !== "OR" && key !== "NOT" && isPlainObject(value) && "equals" in value && Object.keys(value).length === 1) {
-      result[key] = value.equals;
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
 function buildDefaultSelectInput(config) {
   const result = {};
   for (const [key, value] of Object.entries(config)) {
@@ -4031,6 +4089,36 @@ function createModelGuardExtension(config) {
       return;
     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) && "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}`
+      );
+    }
+  }
   function createGuardedMethods(modelName, modelDelegate, input, explicitCaller) {
     function callDelegate(method, args) {
       if (typeof modelDelegate[method] !== "function") {
@@ -4053,6 +4141,7 @@ function createModelGuardExtension(config) {
     const dataSchemaCache = /* @__PURE__ */ new Map();
     const whereBuiltCache = /* @__PURE__ */ new Map();
     const projectionCache = /* @__PURE__ */ new Map();
+    const uniqueWhereCache = /* @__PURE__ */ new Map();
     function getReadShape(method, queryShape, matchedKey, wasDynamic) {
       if (!wasDynamic) {
         const cacheKey = `${method}\0${matchedKey}`;
@@ -4110,6 +4199,18 @@ function createModelGuardExtension(config) {
       }
       return queryBuilder.buildWhereSchema(modelName, whereConfig);
     }
+    function getUniqueWhereBuilt(whereConfig, matchedKey, wasDynamic) {
+      if (!wasDynamic) {
+        const cacheKey = `unique\0${matchedKey}`;
+        const cached = uniqueWhereCache.get(cacheKey);
+        if (cached)
+          return cached;
+        const built = queryBuilder.buildUniqueWhereSchema(modelName, whereConfig);
+        uniqueWhereCache.set(cacheKey, built);
+        return built;
+      }
+      return queryBuilder.buildUniqueWhereSchema(modelName, whereConfig);
+    }
     function buildProjectionSchema(shape) {
       const schemaFields = {};
       let forcedIncludeTree = {};
@@ -4260,6 +4361,49 @@ function createModelGuardExtension(config) {
       }
       return where;
     }
+    function buildUniqueWhereFromShape(shape, bodyWhere, matchedKey, wasDynamic) {
+      if (!shape.where)
+        return {};
+      const built = getUniqueWhereBuilt(shape.where, matchedKey, wasDynamic);
+      let result = {};
+      if (built.schema) {
+        if (bodyWhere !== void 0 && bodyWhere !== null) {
+          if (!isPlainObject(bodyWhere)) {
+            throw new ShapeError("Unique where must be an object");
+          }
+          const sanitized = { ...bodyWhere };
+          for (const key of built.forcedOnlyKeys) {
+            delete sanitized[key];
+          }
+          result = built.schema.parse(sanitized);
+        }
+      } 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) {
+            throw new ShapeError(
+              "Unique where shape contains only forced values. Client where input is not accepted."
+            );
+          }
+        }
+      }
+      for (const [key, value] of Object.entries(built.forced)) {
+        result[key] = value;
+      }
+      return result;
+    }
+    function requireUniqueWhere(shape, bodyWhere, method, matchedKey, wasDynamic) {
+      const where = buildUniqueWhereFromShape(
+        shape,
+        bodyWhere,
+        matchedKey,
+        wasDynamic
+      );
+      if (Object.keys(where).length === 0) {
+        throw new ShapeError(`${method} requires a where condition`);
+      }
+      return where;
+    }
     function buildEffectiveReadBody(resolved) {
       const hasShapeProjection = !!resolved.shape.select || !!resolved.shape.include;
       if (!hasShapeProjection)
@@ -4409,7 +4553,6 @@ function createModelGuardExtension(config) {
             `Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`
           );
         }
-        maybeValidateUniqueWhere(modelName, resolved.shape, method);
         const dataSchema = getDataSchema(
           "update",
           resolved.shape.data,
@@ -4421,28 +4564,37 @@ function createModelGuardExtension(config) {
           dataSchema,
           method
         );
-        let 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`
-          );
-        }
+        let where;
         if (isUniqueWhere) {
+          if (resolved.shape.where) {
+            validateUniqueWhereShapeConfig(
+              modelName,
+              resolved.shape.where,
+              method
+            );
+          }
+          where = requireUniqueWhere(
+            resolved.shape,
+            resolved.body.where,
+            method,
+            resolved.matchedKey,
+            resolved.wasDynamic
+          );
           validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
-          where = normalizeUniqueWhere(where);
+        } else {
+          maybeValidateUniqueWhere(modelName, resolved.shape, method);
+          where = 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`
+            );
+          }
         }
         const args = { data, where };
         if (supportsProjection) {
@@ -4480,29 +4632,37 @@ function createModelGuardExtension(config) {
             `Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`
           );
         }
-        maybeValidateUniqueWhere(modelName, resolved.shape, method);
-        let 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`
-          );
-        }
+        let where;
         if (isUniqueWhere) {
+          if (resolved.shape.where) {
+            validateUniqueWhereShapeConfig(
+              modelName,
+              resolved.shape.where,
+              method
+            );
+          }
+          where = requireUniqueWhere(
+            resolved.shape,
+            resolved.body.where,
+            method,
+            resolved.matchedKey,
+            resolved.wasDynamic
+          );
           validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
-          where = normalizeUniqueWhere(where);
+        } else {
+          maybeValidateUniqueWhere(modelName, resolved.shape, method);
+          where = 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`
+            );
+          }
         }
         const args = { where };
         if (supportsProjection) {
@@ -4546,7 +4706,11 @@ function createModelGuardExtension(config) {
           ALLOWED_BODY_KEYS_UPSERT,
           "upsert"
         );
-        maybeValidateUniqueWhere(modelName, resolved.shape, "upsert");
+        validateUniqueWhereShapeConfig(
+          modelName,
+          resolved.shape.where,
+          "upsert"
+        );
         const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
         validateCreateCompleteness(
           modelName,
@@ -4577,17 +4741,16 @@ function createModelGuardExtension(config) {
           updateDataSchema,
           "upsert (update)"
         );
-        const where = requireWhere(
+        const where = requireUniqueWhere(
           resolved.shape,
           resolved.body.where,
           "upsert",
-          true,
           resolved.matchedKey,
           resolved.wasDynamic
         );
         validateResolvedUniqueWhere(modelName, where, "upsert", uniqueMap);
         const args = {
-          where: normalizeUniqueWhere(where),
+          where,
           create: createData,
           update: updateData
         };