prisma-guard 1.26.1 → 1.27.0

package/dist/runtime/index.js

@@ -959,6 +959,60 @@ var EMPTY_WHERE_FORCED = {
 function hasWhereForced(f) {
   return Object.keys(f.conditions).length > 0 || Object.keys(f.relations).length > 0;
 }
+function forcedScalarsEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b))
+      return false;
+    if (a.length !== b.length)
+      return false;
+    return a.every((v, i) => forcedScalarsEqual(v, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    return aKeys.every(
+      (k) => k in b && forcedScalarsEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+function tryInlineForcedField(result, field, forcedValue) {
+  if (!(field in result))
+    return false;
+  if (!isPlainObject(forcedValue))
+    return false;
+  const existing = result[field];
+  if (!isPlainObject(existing))
+    return false;
+  const merged = { ...existing };
+  for (const [op, value] of Object.entries(forcedValue)) {
+    if (op in merged) {
+      if (!forcedScalarsEqual(merged[op], value)) {
+        throw new ShapeError(
+          `Conflicting where values for "${field}.${op}": client provided a different value than the forced shape`
+        );
+      }
+      continue;
+    }
+    merged[op] = deepClone(value);
+  }
+  result[field] = merged;
+  return true;
+}
 function mergeWhereForced(where, forced) {
   if (!hasWhereForced(forced))
     return where ?? {};
@@ -976,11 +1030,19 @@ function mergeWhereForced(where, forced) {
     }
   }
   if (Object.keys(forced.conditions).length > 0) {
-    const scalarClone = deepClone(forced.conditions);
-    if (Object.keys(result).length === 0) {
-      result = scalarClone;
-    } else {
-      result = { AND: [result, scalarClone] };
+    const remaining = {};
+    for (const [field, forcedValue] of Object.entries(forced.conditions)) {
+      const inlined = tryInlineForcedField(result, field, forcedValue);
+      if (!inlined) {
+        remaining[field] = deepClone(forcedValue);
+      }
+    }
+    if (Object.keys(remaining).length > 0) {
+      if (Object.keys(result).length === 0) {
+        result = remaining;
+      } else {
+        result = { AND: [result, remaining] };
+      }
     }
   }
   return result;
@@ -5510,15 +5572,15 @@ function createModelGuardExtension(config) {
     }
     return wrapped;
   }
-  return {
-    $allModels: {
+  const extension = {};
+  for (const modelName of Object.keys(typeMap)) {
+    const key = toDelegateKey(modelName);
+    extension[key] = {
       guard(input, caller) {
-        const modelName = this.$name;
-        const delegateKey = toDelegateKey(modelName);
-        const modelDelegate = this.$parent[delegateKey];
+        const modelDelegate = this.$parent[key];
         if (!modelDelegate) {
           throw new ShapeError(
-            `Could not resolve Prisma delegate for model "${modelName}" (key: "${delegateKey}")`
+            `Could not resolve Prisma delegate for model "${modelName}" (key: "${key}")`
           );
         }
         const methods = createGuardedMethods(
@@ -5531,8 +5593,9 @@ function createModelGuardExtension(config) {
           return methods;
         return wrapMethods(methods);
       }
-    }
-  };
+    };
+  }
+  return extension;
 }
 
 // src/runtime/guard.ts