@zenstackhq/orm 3.5.4 → 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;
   }
@@ -1096,6 +1111,9 @@ var BaseCrudDialect = class {
       return this.buildEnumFilter(fieldRef, fieldDef, payload);
     }
     if (isTypeDef(this.schema, fieldDef.type)) {
+      if (payload instanceof DbNullClass || payload instanceof JsonNullClass || payload instanceof AnyNullClass) {
+        return this.buildJsonValueFilterClause(fieldRef, payload);
+      }
       return this.buildJsonFilter(fieldRef, payload, fieldDef);
     }
     return (0, import_ts_pattern2.match)(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(import_ts_pattern2.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => this.buildJsonFilter(fieldRef, payload, fieldDef)).with("Unsupported", () => {
@@ -1573,12 +1591,13 @@ var BaseCrudDialect = class {
       const fieldDef = requireField(this.schema, model, field);
       const fieldModel = fieldDef.type;
       let fieldCountQuery;
+      const subQueryAlias = tmpAlias(`${parentAlias}$_${field}$count`);
       const m2m = getManyToManyRelation(this.schema, model, field);
       if (m2m) {
-        fieldCountQuery = this.buildModelSelect(fieldModel, fieldModel, value, false).innerJoin(m2m.joinTable, (join) => join.onRef(`${m2m.joinTable}.${m2m.otherFkName}`, "=", `${fieldModel}.${m2m.otherPKName}`).onRef(`${m2m.joinTable}.${m2m.parentFkName}`, "=", `${parentAlias}.${m2m.parentPKName}`)).select(eb.fn.countAll().as(`_count$${field}`));
+        fieldCountQuery = this.buildModelSelect(fieldModel, subQueryAlias, value, false).innerJoin(m2m.joinTable, (join) => join.onRef(`${m2m.joinTable}.${m2m.otherFkName}`, "=", `${subQueryAlias}.${m2m.otherPKName}`).onRef(`${m2m.joinTable}.${m2m.parentFkName}`, "=", `${parentAlias}.${m2m.parentPKName}`)).select(eb.fn.countAll().as(`_count$${field}`));
       } else {
-        fieldCountQuery = this.buildModelSelect(fieldModel, fieldModel, value, false).select(eb.fn.countAll().as(`_count$${field}`));
-        const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
+        fieldCountQuery = this.buildModelSelect(fieldModel, subQueryAlias, value, false).select(eb.fn.countAll().as(`_count$${field}`));
+        const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, subQueryAlias);
         for (const [left, right] of joinPairs) {
           fieldCountQuery = fieldCountQuery.whereRef(left, "=", right);
         }
@@ -2331,10 +2350,20 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     return query;
   }
   buildJsonObject(value) {
-    return this.eb.fn("jsonb_build_object", Object.entries(value).flatMap(([key, value2]) => [
-      import_kysely4.sql.lit(key),
-      value2
-    ]));
+    const entries = Object.entries(value);
+    const MAX_PAIRS = 50;
+    const buildChunk = /* @__PURE__ */ __name((chunk) => this.eb.fn("jsonb_build_object", chunk.flatMap(([k, v]) => [
+      import_kysely4.sql.lit(k),
+      v
+    ])), "buildChunk");
+    if (entries.length <= MAX_PAIRS) {
+      return buildChunk(entries);
+    }
+    const chunks = [];
+    for (let i = 0; i < entries.length; i += MAX_PAIRS) {
+      chunks.push(buildChunk(entries.slice(i, i + MAX_PAIRS)));
+    }
+    return chunks.reduce((acc, chunk) => import_kysely4.sql`${acc} || ${chunk}`);
   }
   castInt(expression) {
     return this.eb.cast(expression, "integer");
@@ -5427,9 +5456,28 @@ var ZodSchemaFactory = class {
     candidates.push(this.makeJsonFilterSchema(contextModel, field, optional));
     if (optional) {
       candidates.push(import_zod2.z.null());
+      candidates.push(import_zod2.z.instanceof(DbNullClass));
+      candidates.push(import_zod2.z.instanceof(JsonNullClass));
+      candidates.push(import_zod2.z.instanceof(AnyNullClass));
     }
     return import_zod2.z.union(candidates);
   }
+  // For optional typed JSON fields, allow DbNull, JsonNull, and null.
+  // z.union doesn't work here because `z.any()` (returned by `makeScalarSchema`)
+  // always wins, so we create a wrapper superRefine instead.
+  // The caller must pass the already-built fieldSchema so that array/list
+  // mutation shapes (set, push, etc.) are preserved.
+  makeNullableTypedJsonMutationSchema(fieldSchema) {
+    return import_zod2.z.any().superRefine((value, ctx) => {
+      if (value instanceof DbNullClass || value instanceof JsonNullClass || value === null || value === void 0) {
+        return;
+      }
+      const parseResult = fieldSchema.safeParse(value);
+      if (!parseResult.success) {
+        parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
+      }
+    }).optional();
+  }
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
   }
@@ -5768,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) {
@@ -5775,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();
           });
@@ -5811,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);
@@ -5921,6 +5972,8 @@ var ZodSchemaFactory = class {
               fieldSchema,
               import_zod2.z.instanceof(DbNullClass)
             ]);
+          } else if (this.isTypeDefType(fieldDef.type)) {
+            fieldSchema = this.makeNullableTypedJsonMutationSchema(fieldSchema);
           } else {
             fieldSchema = fieldSchema.nullable();
           }
@@ -6157,6 +6210,8 @@ var ZodSchemaFactory = class {
               fieldSchema,
               import_zod2.z.instanceof(DbNullClass)
             ]);
+          } else if (this.isTypeDefType(fieldDef.type)) {
+            fieldSchema = this.makeNullableTypedJsonMutationSchema(fieldSchema);
           } else {
             fieldSchema = fieldSchema.nullable();
           }