prisma-guard 1.8.0 → 1.9.1

package/dist/runtime/index.cjs

@@ -162,7 +162,7 @@ var import_zod3 = require("zod");
 // src/runtime/zod-type-map.ts
 var import_zod2 = require("zod");
 var SCALAR_OPERATORS = {
-  String: /* @__PURE__ */ new Set(["equals", "not", "contains", "startsWith", "endsWith", "in", "notIn"]),
+  String: /* @__PURE__ */ new Set(["equals", "not", "contains", "startsWith", "endsWith", "in", "notIn", "gt", "gte", "lt", "lte"]),
   Int: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
   Float: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
   Decimal: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
@@ -738,6 +738,9 @@ function applyBuiltShape(built, body, isUniqueMethod) {
   const hasWhereInSchema = "where" in built.zodSchema.shape;
   if (isPlainObject(body)) {
     const bodyObj = body;
+    if ("select" in bodyObj && "include" in bodyObj) {
+      throw new ShapeError('Request cannot define both "include" and "select"');
+    }
     if ("where" in bodyObj) {
       if (!hasWhereInSchema) {
         const { where: _, ...rest } = bodyObj;
@@ -1715,6 +1718,7 @@ var KNOWN_NESTED_INCLUDE_KEYS = /* @__PURE__ */ new Set([
 ]);
 var KNOWN_NESTED_SELECT_KEYS = /* @__PURE__ */ new Set([
   "select",
+  "include",
   "where",
   "orderBy",
   "cursor",
@@ -1968,10 +1972,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 +1994,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,
@@ -2126,11 +2143,6 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     if (UNIQUE_WHERE_METHODS.has(method) && !shape.where) {
       throw new ShapeError(`${method} shape must define "where"`);
     }
-    if (shape.include && shape.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"');
     if (method === "groupBy" && (shape.include || shape.select)) {
@@ -3096,6 +3108,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 +3158,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 +3255,8 @@ function checkSelectForClientArgs(config) {
       return true;
     if (value.select && checkSelectForClientArgs(value.select))
       return true;
+    if (value.include && checkIncludeForClientArgs(value.include))
+      return true;
   }
   return false;
 }
@@ -3341,9 +3392,6 @@ function createModelGuardExtension(config) {
       return queryBuilder.buildWhereSchema(modelName, whereConfig);
     }
     function buildProjectionSchema(shape) {
-      if (shape.select && shape.include) {
-        throw new ShapeError('Shape cannot define both "select" and "include"');
-      }
       const schemaFields = {};
       let forcedIncludeTree = {};
       let forcedSelectTree = {};
@@ -3395,6 +3443,11 @@ function createModelGuardExtension(config) {
           `Guard shape does not define "select" or "include" for ${method} return projection`
         );
       }
+      if ("select" in parsed && "include" in parsed) {
+        throw new ShapeError(
+          'Request body cannot define both "select" and "include"'
+        );
+      }
       if (!hasShapeProjection)
         return {};
       if (!hasBodyProjection && !enforceProjection)
@@ -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(