prisma-guard 1.6.1 → 1.8.0

package/dist/runtime/index.d.cts

@@ -54,7 +54,7 @@ interface ShapeConfig {
     where?: Record<string, unknown>;
     include?: Record<string, true | NestedIncludeArgs>;
     select?: Record<string, true | NestedSelectArgs>;
-    orderBy?: Record<string, OrderByFieldConfig>;
+    orderBy?: true | Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;

package/dist/runtime/index.d.ts

@@ -54,7 +54,7 @@ interface ShapeConfig {
     where?: Record<string, unknown>;
     include?: Record<string, true | NestedIncludeArgs>;
     select?: Record<string, true | NestedSelectArgs>;
-    orderBy?: Record<string, OrderByFieldConfig>;
+    orderBy?: true | Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;

package/dist/runtime/index.js

@@ -2194,21 +2194,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 = 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();
+        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 = 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 {
+          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"] = z7.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 = 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,
@@ -3427,7 +3473,18 @@ function createModelGuardExtension(config) {
           resolved.wasDynamic
         );
         const isUnique = UNIQUE_READ_METHODS.has(method);
-        const args = applyBuiltShape(built, resolved.body, isUnique);
+        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 args = applyBuiltShape(built, effectiveBody, isUnique);
         if (isUnique && args.where) {
           validateResolvedUniqueWhere(
             modelName,