@zenstackhq/orm 3.5.5 → 3.5.6

package/dist/index.cjs

@@ -833,17 +833,32 @@ var BaseCrudDialect = class {
       take = -take;
     }
     result = this.buildSkipTake(result, skip, take);
-    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, negateOrderBy, take);
+    let distinctFields = [];
     if ("distinct" in args && args.distinct) {
-      const distinct = ensureArray(args.distinct);
+      distinctFields = ensureArray(args.distinct);
       if (this.supportsDistinctOn) {
-        result = result.distinctOn(distinct.map((f) => this.eb.ref(`${modelAlias}.${f}`)));
+        result = result.distinctOn(distinctFields.map((f) => this.eb.ref(`${modelAlias}.${f}`)));
       } else {
         throw createNotSupportedError(`"distinct" is not supported by "${this.schema.provider.type}" provider`);
       }
     }
+    let effectiveOrderBy = args.orderBy;
+    if (distinctFields.length > 0 && this.supportsDistinctOn) {
+      const existingOrderBy = (0, import_common_helpers3.enumerate)(args.orderBy).filter((o) => Object.keys(o).length > 0);
+      const alreadySatisfied = distinctFields.every((f, i) => i < existingOrderBy.length && Object.keys(existingOrderBy[i])[0] === f);
+      if (existingOrderBy.length > 0 && !alreadySatisfied) {
+        const prependedOrderBy = distinctFields.map((f) => ({
+          [f]: "asc"
+        }));
+        effectiveOrderBy = [
+          ...prependedOrderBy,
+          ...existingOrderBy
+        ];
+      }
+    }
+    result = this.buildOrderBy(result, model, modelAlias, effectiveOrderBy, negateOrderBy, take);
     if (args.cursor) {
-      result = this.buildCursorFilter(model, result, args.cursor, args.orderBy, negateOrderBy, modelAlias);
+      result = this.buildCursorFilter(model, result, args.cursor, effectiveOrderBy, negateOrderBy, modelAlias);
     }
     return result;
   }
@@ -5801,6 +5816,9 @@ var ZodSchemaFactory = class {
       import_zod2.z.literal("asc"),
       import_zod2.z.literal("desc")
     ]);
+    const refineAtMostOneKey = /* @__PURE__ */ __name((s) => s.refine((v) => Object.keys(v).length <= 1, {
+      message: "Each orderBy element must have at most one key"
+    }), "refineAtMostOneKey");
     const nextOpts = this.nextOptions(options);
     for (const [field, fieldDef] of this.getModelFields(model)) {
       if (fieldDef.relation) {
@@ -5808,9 +5826,9 @@ var ZodSchemaFactory = class {
           fields[field] = import_zod2.z.lazy(() => {
             let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation, nextOpts);
             if (fieldDef.array) {
-              relationOrderBy = relationOrderBy.extend({
+              relationOrderBy = refineAtMostOneKey(relationOrderBy.safeExtend({
                 _count: sort
-              });
+              }));
             }
             return relationOrderBy.optional();
           });
@@ -5844,7 +5862,7 @@ var ZodSchemaFactory = class {
         fields[agg] = import_zod2.z.lazy(() => this.makeOrderBySchema(model, true, false, options).optional());
       }
     }
-    return import_zod2.z.strictObject(fields);
+    return refineAtMostOneKey(import_zod2.z.strictObject(fields));
   }
   makeDistinctSchema(model) {
     const nonRelationFields = this.getModelFields(model).filter(([, def]) => !def.relation).map(([name]) => name);