prisma-guard 1.32.0 → 1.32.1

package/dist/runtime/index.js

@@ -1486,12 +1486,15 @@ function applyForcedCountWhere(container, forcedCountWhere) {
 }
 function resolvedWhereCoversConstraint(where, constraint) {
   if (constraint.fields.length === 1) {
-    return constraint.fields[0] in where;
+    const value2 = where[constraint.fields[0]];
+    return value2 !== null && value2 !== void 0;
   }
   const value = where[constraint.selector];
   if (!isPlainObject(value))
     return false;
-  return constraint.fields.every((field) => field in value);
+  return constraint.fields.every(
+    (field) => value[field] !== null && value[field] !== void 0
+  );
 }
 function validateResolvedUniqueWhere(model, where, method, uniqueMap) {
   const constraints = uniqueMap[model];
@@ -1518,17 +1521,16 @@ function assertDirectUniqueShapeValue(model, field, value, typeMap) {
       );
     }
   }
-  if (isForcedValue(value))
-    return;
-  if (isPlainObject(value)) {
-    const keys = Object.keys(value);
+  const actual = isForcedValue(value) ? value.value : value;
+  if (isPlainObject(actual)) {
+    const keys = Object.keys(actual);
     throw new ShapeError(
       `Invalid unique where shape for "${model ?? "unknown"}.${field}". Prisma WhereUniqueInput does not accept filter operator objects${keys.length ? `: ${keys.join(", ")}` : ""}. Use { ${field}: true } in guard shape and { ${field}: value } in request args.`
     );
   }
-  if (value === null || value === void 0) {
+  if (actual === null || actual === void 0) {
     throw new ShapeError(
-      `Invalid unique where shape for "${model ?? "unknown"}.${field}". Unique fields must use true or a forced value.`
+      `Invalid unique where shape for "${model ?? "unknown"}.${field}". Unique fields must use true or a forced non-null value.`
     );
   }
 }
@@ -1542,9 +1544,8 @@ function shapeCoversConstraint(where, constraint, model, typeMap) {
   }
   if (!(constraint.selector in where))
     return false;
-  const selectorValue = where[constraint.selector];
-  if (isForcedValue(selectorValue))
-    return true;
+  const rawSelectorValue = where[constraint.selector];
+  const selectorValue = isForcedValue(rawSelectorValue) ? rawSelectorValue.value : rawSelectorValue;
   if (!isPlainObject(selectorValue)) {
     throw new ShapeError(
       `Compound unique selector "${model}.${constraint.selector}" must be an object with fields: ${constraint.fields.join(", ")}`
@@ -2047,8 +2048,18 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
       (constraint) => constraint.selector === selector
     ) ?? null;
   }
-  function parseForcedUniqueValue(model, fieldName, fieldMeta, value) {
+  function buildUniqueWhereFieldSchema(fieldMeta, allowNullableFilter) {
     const schema = buildDirectScalarSchema(fieldMeta, enumMap, scalarBase);
+    if (allowNullableFilter && !fieldMeta.isRequired) {
+      return schema.nullable();
+    }
+    return schema;
+  }
+  function parseForcedUniqueValue(model, fieldName, fieldMeta, value, allowNullableFilter) {
+    const schema = buildUniqueWhereFieldSchema(
+      fieldMeta,
+      allowNullableFilter
+    );
     const actual = isForcedValue(value) ? value.value : value;
     try {
       return schema.parse(actual);
@@ -2126,10 +2137,9 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
               `Invalid compound unique where shape for "${model}.${key}.${fieldName}". Prisma compound unique selectors do not accept filter operator objects${operators.length ? `: ${operators.join(", ")}` : ""}. Use direct values only.`
             );
           }
-          const directSchema2 = buildDirectScalarSchema(
+          const directSchema2 = buildUniqueWhereFieldSchema(
             fieldMeta2,
-            enumMap,
-            scalarBase
+            false
           );
           if (fieldValue === true) {
             nestedSchemas[fieldName] = directSchema2;
@@ -2138,7 +2148,8 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
               model,
               fieldName,
               fieldMeta2,
-              fieldValue
+              fieldValue,
+              false
             );
           }
         }
@@ -2177,7 +2188,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
           `Invalid unique where shape for "${model}.${key}". Prisma WhereUniqueInput does not accept operators: ${keys.join(", ")}. Use a direct unique value shape, for example { ${key}: true }.`
         );
       }
-      const directSchema = buildDirectScalarSchema(fieldMeta, enumMap, scalarBase);
+      const directSchema = buildUniqueWhereFieldSchema(fieldMeta, true);
       if (value === true) {
         fieldSchemas[key] = directSchema;
         continue;
@@ -2186,7 +2197,8 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
         model,
         key,
         fieldMeta,
-        value
+        value,
+        true
       );
       forcedOnlyKeys.add(key);
     }
@@ -3539,7 +3551,21 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
             built = builtCache.get(resolution.key);
           }
         }
-        return applyBuiltShape(built, normalizedBody, isUnique);
+        const result = applyBuiltShape(
+          built,
+          normalizedBody,
+          isUnique,
+          model
+        );
+        if (isUnique && result.where) {
+          validateResolvedUniqueWhere(
+            model,
+            result.where,
+            method,
+            uniqueMap
+          );
+        }
+        return result;
       }
     };
   }