prisma-guard 1.8.0 → 1.9.0

package/dist/runtime/index.cjs

@@ -1715,6 +1715,7 @@ var KNOWN_NESTED_INCLUDE_KEYS = /* @__PURE__ */ new Set([
 ]);
 var KNOWN_NESTED_SELECT_KEYS = /* @__PURE__ */ new Set([
   "select",
+  "include",
   "where",
   "orderBy",
   "cursor",
@@ -1968,10 +1969,13 @@ function createProjectionBuilder(typeMap, enumMap, deps) {
           KNOWN_NESTED_SELECT_KEYS,
           `nested select for "${fieldName}" on model "${model}"`
         );
+        if (config.select && config.include) {
+          throw new ShapeError(`Nested select for "${fieldName}" cannot define both "select" and "include".`);
+        }
         if (!fieldMeta.isList) {
           if (config.where || config.orderBy || config.cursor || config.take || config.skip) {
             throw new ShapeError(
-              `Relation "${fieldName}" on model "${model}" is to-one. Only "select" is supported for to-one nested reads, not where/orderBy/cursor/take/skip.`
+              `Relation "${fieldName}" on model "${model}" is to-one. Only "select" and "include" are supported for to-one nested reads, not where/orderBy/cursor/take/skip.`
             );
           }
         }
@@ -1987,6 +1991,16 @@ function createProjectionBuilder(typeMap, enumMap, deps) {
             relForced._countWherePlacement = "select";
           }
         }
+        if (config.include) {
+          const nested = buildIncludeSchema(fieldMeta.type, config.include, currentDepth + 1);
+          nestedSchemas["include"] = nested.schema;
+          if (Object.keys(nested.forcedTree).length > 0)
+            relForced.include = nested.forcedTree;
+          if (Object.keys(nested.forcedCountWhere).length > 0) {
+            relForced._countWhere = nested.forcedCountWhere;
+            relForced._countWherePlacement = "include";
+          }
+        }
         if (config.where) {
           const { schema: whereSchema, forced } = deps.buildWhereSchema(
             fieldMeta.type,
@@ -3096,6 +3110,8 @@ function buildDefaultSelectInput(config) {
       const nested = {};
       if (value.select)
         nested.select = buildDefaultSelectInput(value.select);
+      if (value.include)
+        nested.include = buildDefaultIncludeInput(value.include);
       result[key] = Object.keys(nested).length > 0 ? nested : true;
     }
   }
@@ -3144,6 +3160,41 @@ function buildDefaultProjectionBody(shape) {
   }
   return {};
 }
+function applyClientProjectionOverrides(shapeDefault, clientProjection) {
+  const result = { ...shapeDefault };
+  for (const [key, clientValue] of Object.entries(clientProjection)) {
+    const defaultValue = result[key];
+    if (defaultValue === void 0) {
+      result[key] = clientValue;
+      continue;
+    }
+    if (clientValue === true) {
+      result[key] = true;
+      continue;
+    }
+    if (isPlainObject(clientValue)) {
+      if (!isPlainObject(defaultValue)) {
+        result[key] = clientValue;
+        continue;
+      }
+      const merged = { ...defaultValue };
+      const clientObj = clientValue;
+      for (const [argKey, argValue] of Object.entries(clientObj)) {
+        const defaultArgValue = merged[argKey];
+        if ((argKey === "select" || argKey === "include") && isPlainObject(argValue) && isPlainObject(defaultArgValue)) {
+          merged[argKey] = applyClientProjectionOverrides(
+            defaultArgValue,
+            argValue
+          );
+        } else {
+          merged[argKey] = argValue;
+        }
+      }
+      result[key] = merged;
+    }
+  }
+  return result;
+}
 function hasClientControlledValues(obj) {
   for (const value of Object.values(obj)) {
     if (isForcedValue(value))
@@ -3206,6 +3257,8 @@ function checkSelectForClientArgs(config) {
       return true;
     if (value.select && checkSelectForClientArgs(value.select))
       return true;
+    if (value.include && checkIncludeForClientArgs(value.include))
+      return true;
   }
   return false;
 }
@@ -3488,6 +3541,29 @@ function createModelGuardExtension(config) {
       }
       return where;
     }
+    function buildEffectiveReadBody(resolved) {
+      const hasShapeProjection = !!resolved.shape.select || !!resolved.shape.include;
+      if (!hasShapeProjection)
+        return resolved.body;
+      const defaultProjection = buildDefaultProjectionBody(resolved.shape);
+      const hasBodyProjection = "select" in resolved.body || "include" in resolved.body;
+      if (!hasBodyProjection) {
+        return { ...resolved.body, ...defaultProjection };
+      }
+      const merged = { ...resolved.body };
+      if ("select" in resolved.body && "select" in defaultProjection && isPlainObject(resolved.body.select) && isPlainObject(defaultProjection.select)) {
+        merged.select = applyClientProjectionOverrides(
+          defaultProjection.select,
+          resolved.body.select
+        );
+      } else if ("include" in resolved.body && "include" in defaultProjection && isPlainObject(resolved.body.include) && isPlainObject(defaultProjection.include)) {
+        merged.include = applyClientProjectionOverrides(
+          defaultProjection.include,
+          resolved.body.include
+        );
+      }
+      return merged;
+    }
     function makeReadMethod(method) {
       return (body) => {
         const caller = resolveCaller();
@@ -3503,17 +3579,7 @@ function createModelGuardExtension(config) {
           resolved.wasDynamic
         );
         const isUnique = UNIQUE_READ_METHODS.has(method);
-        let effectiveBody = resolved.body;
-        const hasShapeProjection = !!resolved.shape.select || !!resolved.shape.include;
-        if (hasShapeProjection) {
-          const hasBodyProjection = "select" in resolved.body || "include" in resolved.body;
-          if (!hasBodyProjection) {
-            effectiveBody = {
-              ...resolved.body,
-              ...buildDefaultProjectionBody(resolved.shape)
-            };
-          }
-        }
+        const effectiveBody = buildEffectiveReadBody(resolved);
         const args = applyBuiltShape(built, effectiveBody, isUnique);
         if (isUnique && args.where) {
           validateResolvedUniqueWhere(