prisma-guard 1.6.0 → 1.7.0

package/dist/runtime/index.cjs

@@ -735,28 +735,25 @@ function mergeUniqueWhereForced(where, forced) {
 }
 function applyBuiltShape(built, body, isUniqueMethod) {
   let parseable = body;
+  const hasWhereInSchema = "where" in built.zodSchema.shape;
   if (isPlainObject(body)) {
     const bodyObj = body;
-    if (isPlainObject(bodyObj.where)) {
-      const where = { ...bodyObj.where };
-      let modified = false;
-      if (built.forcedOnlyWhereKeys.size > 0) {
-        for (const key of built.forcedOnlyWhereKeys) {
-          if (key in where) {
-            delete where[key];
-            modified = true;
-          }
-        }
-      }
-      if (Object.keys(where).length === 0 && hasWhereForced(built.forcedWhere)) {
+    if ("where" in bodyObj) {
+      if (!hasWhereInSchema) {
         const { where: _, ...rest } = bodyObj;
         parseable = rest;
-      } else if (modified) {
-        parseable = { ...bodyObj, where };
+      } else if (built.forcedOnlyWhereKeys.size > 0 && isPlainObject(bodyObj.where)) {
+        const where = { ...bodyObj.where };
+        for (const key of built.forcedOnlyWhereKeys) {
+          delete where[key];
+        }
+        if (Object.keys(where).length === 0 && hasWhereForced(built.forcedWhere)) {
+          const { where: _, ...rest } = bodyObj;
+          parseable = rest;
+        } else {
+          parseable = { ...bodyObj, where };
+        }
       }
-    } else if ("where" in bodyObj && hasWhereForced(built.forcedWhere) && !built.zodSchema.shape.where) {
-      const { where: _, ...rest } = bodyObj;
-      parseable = rest;
     }
   }
   const validated = built.zodSchema.parse(parseable);
@@ -2227,21 +2224,67 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       }
     }
     if (shape.orderBy) {
-      if (method === "groupBy" && shape.orderBy === true && shape.by) {
+      if (method === "groupBy" && shape.by) {
         const sortEnum = import_zod7.z.enum(["asc", "desc"]);
-        const groupByOrderFields = {};
-        for (const field of shape.by) {
-          groupByOrderFields[field] = sortEnum.optional();
-        }
-        groupByOrderFields["_count"] = sortEnum.optional();
-        const fieldKeys = Object.keys(groupByOrderFields);
-        const singleSchema = import_zod7.z.object(groupByOrderFields).strict().refine(
-          (v) => fieldKeys.some(
-            (k) => v[k] !== void 0
-          ),
-          { message: "orderBy must specify at least one field" }
-        );
-        schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.array(singleSchema).min(1)]).optional();
+        const bySet = new Set(shape.by);
+        if (shape.orderBy === true) {
+          const groupByOrderFields = {};
+          for (const field of shape.by) {
+            groupByOrderFields[field] = sortEnum.optional();
+          }
+          groupByOrderFields["_count"] = sortEnum.optional();
+          const fieldKeys = Object.keys(groupByOrderFields);
+          const singleSchema = import_zod7.z.object(groupByOrderFields).strict().refine(
+            (v) => fieldKeys.some(
+              (k) => v[k] !== void 0
+            ),
+            { message: "orderBy must specify at least one field" }
+          );
+          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.array(singleSchema).min(1)]).optional();
+        } else {
+          const groupByOrderFields = {};
+          for (const [fieldName, config] of Object.entries(shape.orderBy)) {
+            if (fieldName === "_count") {
+              if (config === true) {
+                groupByOrderFields["_count"] = sortEnum.optional();
+              } else if (typeof config === "object" && config !== null) {
+                const countFields = {};
+                for (const countField of Object.keys(config)) {
+                  if (!bySet.has(countField)) {
+                    throw new ShapeError(
+                      `orderBy _count field "${countField}" must be included in "by" for groupBy`
+                    );
+                  }
+                  countFields[countField] = sortEnum.optional();
+                }
+                const countKeys = Object.keys(countFields);
+                groupByOrderFields["_count"] = import_zod7.z.object(countFields).strict().refine(
+                  (v) => countKeys.some(
+                    (k) => v[k] !== void 0
+                  ),
+                  {
+                    message: "orderBy._count must specify at least one field"
+                  }
+                ).optional();
+              }
+              continue;
+            }
+            if (!bySet.has(fieldName)) {
+              throw new ShapeError(
+                `orderBy field "${fieldName}" must be included in "by" for groupBy`
+              );
+            }
+            groupByOrderFields[fieldName] = sortEnum.optional();
+          }
+          const fieldKeys = Object.keys(groupByOrderFields);
+          const singleSchema = import_zod7.z.object(groupByOrderFields).strict().refine(
+            (v) => fieldKeys.some(
+              (k) => v[k] !== void 0
+            ),
+            { message: "orderBy must specify at least one field" }
+          );
+          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.array(singleSchema).min(1)]).optional();
+        }
       } else {
         schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
           model,