prisma-guard 1.5.0 → 1.6.0

package/dist/runtime/index.js

@@ -705,20 +705,28 @@ function mergeUniqueWhereForced(where, forced) {
 }
 function applyBuiltShape(built, body, isUniqueMethod) {
   let parseable = body;
-  if (built.forcedOnlyWhereKeys.size > 0 && isPlainObject(body)) {
+  if (isPlainObject(body)) {
     const bodyObj = body;
     if (isPlainObject(bodyObj.where)) {
       const where = { ...bodyObj.where };
-      let stripped = false;
-      for (const key of built.forcedOnlyWhereKeys) {
-        if (key in where) {
-          delete where[key];
-          stripped = true;
+      let modified = false;
+      if (built.forcedOnlyWhereKeys.size > 0) {
+        for (const key of built.forcedOnlyWhereKeys) {
+          if (key in where) {
+            delete where[key];
+            modified = true;
+          }
         }
       }
-      if (stripped) {
+      if (Object.keys(where).length === 0 && hasWhereForced(built.forcedWhere)) {
+        const { where: _, ...rest } = bodyObj;
+        parseable = rest;
+      } else if (modified) {
         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);
@@ -2106,9 +2114,11 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     }
     if (method === "count" && shape.include)
       throw new ShapeError('count does not support "include"');
-    if (method === "groupBy" && shape.orderBy) {
+    if (method === "groupBy" && shape.orderBy && shape.orderBy !== true) {
       const bySet = new Set(shape.by);
       for (const fieldName of Object.keys(shape.orderBy)) {
+        if (fieldName === "_count")
+          continue;
         if (!bySet.has(fieldName)) {
           throw new ShapeError(
             `orderBy field "${fieldName}" must be included in "by" for groupBy`
@@ -2186,11 +2196,29 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         forcedSelectCountWhere = result.forcedCountWhere;
       }
     }
-    if (shape.orderBy)
-      schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
-        model,
-        shape.orderBy
-      );
+    if (shape.orderBy) {
+      if (method === "groupBy" && shape.orderBy === true && shape.by) {
+        const sortEnum = z7.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 = z7.object(groupByOrderFields).strict().refine(
+          (v) => fieldKeys.some(
+            (k) => v[k] !== void 0
+          ),
+          { message: "orderBy must specify at least one field" }
+        );
+        schemaFields["orderBy"] = z7.union([singleSchema, z7.array(singleSchema).min(1)]).optional();
+      } else {
+        schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
+          model,
+          shape.orderBy
+        );
+      }
+    }
     if (shape.cursor)
       schemaFields["cursor"] = argsBuilder.buildCursorSchema(
         model,