@zenstackhq/runtime 3.0.0-alpha.19 → 3.0.0-alpha.20

package/dist/index.cjs

@@ -46,7 +46,10 @@ var import_kysely16 = require("kysely");
 
 // src/client/crud/operations/aggregate.ts
 var import_kysely9 = require("kysely");
-var import_ts_pattern9 = require("ts-pattern");
+var import_ts_pattern10 = require("ts-pattern");
+
+// src/client/query-utils.ts
+var import_ts_pattern = require("ts-pattern");
 
 // src/schema/expression.ts
 var ExpressionUtils = {
@@ -127,6 +130,19 @@ var ExpressionUtils = {
   isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
 };
 
+// src/utils/object-utils.ts
+function extractFields(obj, fields) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => fields.includes(key)));
+}
+__name(extractFields, "extractFields");
+function fieldsToSelectObject(fields) {
+  return Object.fromEntries(fields.map((f) => [
+    f,
+    true
+  ]));
+}
+__name(fieldsToSelectObject, "fieldsToSelectObject");
+
 // src/client/errors.ts
 var InputValidationError = class extends Error {
   static {
@@ -405,15 +421,6 @@ function safeJSONStringify(value) {
   });
 }
 __name(safeJSONStringify, "safeJSONStringify");
-function extractFields(object, fields) {
-  return fields.reduce((acc, field) => {
-    if (field in object) {
-      acc[field] = object[field];
-    }
-    return acc;
-  }, {});
-}
-__name(extractFields, "extractFields");
 function extractIdFields(entity, schema, model) {
   const idFields = getIdFields(schema, model);
   return extractFields(entity, idFields);
@@ -445,6 +452,10 @@ function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */
   ];
 }
 __name(getDelegateDescendantModels, "getDelegateDescendantModels");
+function aggregate(eb, expr2, op) {
+  return (0, import_ts_pattern.match)(op).with("_count", () => eb.fn.count(expr2)).with("_sum", () => eb.fn.sum(expr2)).with("_avg", () => eb.fn.avg(expr2)).with("_min", () => eb.fn.min(expr2)).with("_max", () => eb.fn.max(expr2)).exhaustive();
+}
+__name(aggregate, "aggregate");
 
 // src/client/crud/operations/base.ts
 var import_cuid2 = require("@paralleldrive/cuid2");
@@ -452,7 +463,7 @@ var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_kysely8 = require("kysely");
 var import_nanoid = require("nanoid");
 var import_node_util = require("util");
-var import_ts_pattern8 = require("ts-pattern");
+var import_ts_pattern9 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
 
@@ -471,15 +482,15 @@ var RejectedByPolicyError = class extends Error {
 // src/plugins/policy/policy-handler.ts
 var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_kysely7 = require("kysely");
-var import_ts_pattern7 = require("ts-pattern");
+var import_ts_pattern8 = require("ts-pattern");
 
 // src/client/crud/dialects/index.ts
-var import_ts_pattern4 = require("ts-pattern");
+var import_ts_pattern5 = require("ts-pattern");
 
 // src/client/crud/dialects/postgresql.ts
 var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_kysely2 = require("kysely");
-var import_ts_pattern2 = require("ts-pattern");
+var import_ts_pattern3 = require("ts-pattern");
 
 // src/client/constants.ts
 var CONTEXT_COMMENT_PREFIX = "-- $$context:";
@@ -490,11 +501,23 @@ var NUMERIC_FIELD_TYPES = [
   "Decimal"
 ];
 var DELEGATE_JOINED_FIELD_PREFIX = "$delegate$";
+var LOGICAL_COMBINATORS = [
+  "AND",
+  "OR",
+  "NOT"
+];
+var AGGREGATE_OPERATORS = [
+  "_count",
+  "_sum",
+  "_avg",
+  "_min",
+  "_max"
+];
 
 // src/client/crud/dialects/base.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_kysely = require("kysely");
-var import_ts_pattern = require("ts-pattern");
+var import_ts_pattern2 = require("ts-pattern");
 
 // src/utils/enumerate.ts
 function enumerate(x) {
@@ -551,7 +574,7 @@ var BaseCrudDialect = class {
       if (key.startsWith("$")) {
         continue;
       }
-      if (key === "AND" || key === "OR" || key === "NOT") {
+      if (this.isLogicalCombinator(key)) {
         result = this.and(eb, result, this.buildCompositeFilter(eb, model, modelAlias, key, payload));
         continue;
       }
@@ -572,8 +595,11 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  isLogicalCombinator(key) {
+    return LOGICAL_COMBINATORS.includes(key);
+  }
   buildCompositeFilter(eb, model, modelAlias, key, payload) {
-    return (0, import_ts_pattern.match)(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
+    return (0, import_ts_pattern2.match)(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
   }
   buildRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (!fieldDef.array) {
@@ -722,7 +748,7 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
     }
-    return (0, import_ts_pattern.match)(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(import_ts_pattern.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
+    return (0, import_ts_pattern2.match)(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(import_ts_pattern2.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
       throw new InternalError("JSON filters are not supported yet");
     }).with("Unsupported", () => {
       throw new QueryError(`Unsupported field cannot be used in filters`);
@@ -750,7 +776,7 @@ var BaseCrudDialect = class {
         continue;
       }
       const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
-      const condition = (0, import_ts_pattern.match)(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
+      const condition = (0, import_ts_pattern2.match)(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
         (0, import_common_helpers.invariant)(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.false(eb);
@@ -764,7 +790,11 @@ var BaseCrudDialect = class {
         } else {
           return eb.not(eb(lhs, "in", rhs));
         }
-      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).otherwise(() => {
+      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).with(import_ts_pattern2.P.union(...AGGREGATE_OPERATORS), (op2) => {
+        const innerResult = this.buildStandardFilter(eb, type, value, aggregate(eb, lhs, op2), getRhs, recurse, throwIfInvalid);
+        consumedKeys.push(...innerResult.consumedKeys);
+        return this.and(eb, ...innerResult.conditions);
+      }).otherwise(() => {
         if (throwIfInvalid) {
           throw new QueryError(`Invalid filter key: ${op}`);
         } else {
@@ -794,7 +824,7 @@ var BaseCrudDialect = class {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = (0, import_ts_pattern.match)(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}`))).otherwise(() => {
+        const condition = (0, import_ts_pattern2.match)(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}`))).otherwise(() => {
           throw new QueryError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
@@ -875,9 +905,7 @@ var BaseCrudDialect = class {
           (0, import_common_helpers.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => eb.fn(field.slice(1), [
-              import_kysely.sql.ref(k)
-            ]), import_kysely.sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, import_kysely.sql.ref(`${modelAlias}.${k}`), field), import_kysely.sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -1072,7 +1100,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         return value.map((v) => this.transformPrimitive(v, type, false));
       }
     } else {
-      return (0, import_ts_pattern2.match)(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
+      return (0, import_ts_pattern3.match)(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -1229,7 +1257,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
 // src/client/crud/dialects/sqlite.ts
 var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_kysely3 = require("kysely");
-var import_ts_pattern3 = require("ts-pattern");
+var import_ts_pattern4 = require("ts-pattern");
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -1247,7 +1275,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       if (this.schema.typeDefs && type in this.schema.typeDefs) {
         return JSON.stringify(value);
       } else {
-        return (0, import_ts_pattern3.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+        return (0, import_ts_pattern4.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
       }
     }
   }
@@ -1393,7 +1421,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 
 // src/client/crud/dialects/index.ts
 function getCrudDialect(schema, options) {
-  return (0, import_ts_pattern4.match)(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
+  return (0, import_ts_pattern5.match)(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
 }
 __name(getCrudDialect, "getCrudDialect");
 
@@ -1718,17 +1746,17 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 // src/plugins/policy/expression-transformer.ts
 var import_common_helpers5 = require("@zenstackhq/common-helpers");
 var import_kysely6 = require("kysely");
-var import_ts_pattern6 = require("ts-pattern");
+var import_ts_pattern7 = require("ts-pattern");
 
 // src/plugins/policy/expression-evaluator.ts
 var import_common_helpers4 = require("@zenstackhq/common-helpers");
-var import_ts_pattern5 = require("ts-pattern");
+var import_ts_pattern6 = require("ts-pattern");
 var ExpressionEvaluator = class {
   static {
     __name(this, "ExpressionEvaluator");
   }
   evaluate(expression, context) {
-    const result = (0, import_ts_pattern5.match)(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
+    const result = (0, import_ts_pattern6.match)(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
     return result ?? null;
   }
   evaluateCall(expr2, context) {
@@ -1739,7 +1767,7 @@ var ExpressionEvaluator = class {
     }
   }
   evaluateUnary(expr2, context) {
-    return (0, import_ts_pattern5.match)(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
+    return (0, import_ts_pattern6.match)(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
   }
   evaluateMember(expr2, context) {
     let val = this.evaluate(expr2.receiver, context);
@@ -1763,7 +1791,7 @@ var ExpressionEvaluator = class {
     }
     const left = this.evaluate(expr2.left, context);
     const right = this.evaluate(expr2.right, context);
-    return (0, import_ts_pattern5.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
+    return (0, import_ts_pattern6.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
       const _right = right ?? [];
       (0, import_common_helpers4.invariant)(Array.isArray(_right), 'expected array for "in" operator');
       return _right.includes(left);
@@ -1777,7 +1805,7 @@ var ExpressionEvaluator = class {
       return false;
     }
     (0, import_common_helpers4.invariant)(Array.isArray(left), "expected array");
-    return (0, import_ts_pattern5.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
+    return (0, import_ts_pattern6.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
     }))).with("!", () => left.every((item) => this.evaluate(expr2.right, {
@@ -2031,7 +2059,7 @@ var ExpressionTransformer = class {
     const count = import_kysely6.FunctionNode.create("count", [
       import_kysely6.ValueNode.createImmediate(1)
     ]);
-    const predicateResult = (0, import_ts_pattern6.match)(expr2.op).with("?", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create(">"), import_kysely6.ValueNode.createImmediate(0))).with("!", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).with("^", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).exhaustive();
+    const predicateResult = (0, import_ts_pattern7.match)(expr2.op).with("?", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create(">"), import_kysely6.ValueNode.createImmediate(0))).with("!", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).with("^", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).exhaustive();
     return this.transform(expr2.left, {
       ...context,
       memberSelect: import_kysely6.SelectionNode.create(import_kysely6.AliasNode.create(predicateResult, import_kysely6.IdentifierNode.create("$t"))),
@@ -2062,7 +2090,7 @@ var ExpressionTransformer = class {
     return import_kysely6.BinaryOperationNode.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
   }
   transformOperator(op) {
-    const mappedOp = (0, import_ts_pattern6.match)(op).with("==", () => "=").otherwise(() => op);
+    const mappedOp = (0, import_ts_pattern7.match)(op).with("==", () => "=").otherwise(() => op);
     return import_kysely6.OperatorNode.create(mappedOp);
   }
   _call(expr2, context) {
@@ -2465,7 +2493,7 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => import_kysely7.BinaryOperationNode.create(import_kysely7.ColumnNode.create(field), import_kysely7.OperatorNode.create("="), import_kysely7.ValueNode.create(row[field]))))));
   }
   getMutationModel(node) {
-    const r = (0, import_ts_pattern7.match)(node).when(import_kysely7.InsertQueryNode.is, (node2) => getTableName(node2.into)).when(import_kysely7.UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(import_kysely7.DeleteQueryNode.is, (node2) => {
+    const r = (0, import_ts_pattern8.match)(node).when(import_kysely7.InsertQueryNode.is, (node2) => getTableName(node2.into)).when(import_kysely7.UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(import_kysely7.DeleteQueryNode.is, (node2) => {
       if (node2.from.froms.length !== 1) {
         throw new InternalError("Only one from table is supported for delete");
       }
@@ -2662,19 +2690,6 @@ function clone(value) {
 }
 __name(clone, "clone");
 
-// src/utils/object-utils.ts
-function extractFields2(obj, fields) {
-  return Object.fromEntries(Object.entries(obj).filter(([key]) => fields.includes(key)));
-}
-__name(extractFields2, "extractFields");
-function fieldsToSelectObject(fields) {
-  return Object.fromEntries(fields.map((f) => [
-    f,
-    true
-  ]));
-}
-__name(fieldsToSelectObject, "fieldsToSelectObject");
-
 // src/client/crud/operations/base.ts
 var BaseOperationHandler = class {
   static {
@@ -3031,7 +3046,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
         case "connect": {
           const referencedPkFields = relationField.relation.references;
           (0, import_common_helpers8.invariant)(referencedPkFields, "relation must have fields info");
-          const extractedFks = extractFields2(subPayload, referencedPkFields);
+          const extractedFks = extractFields(subPayload, referencedPkFields);
           if (Object.keys(extractedFks).length === referencedPkFields.length) {
             result = extractedFks;
           } else {
@@ -3240,7 +3255,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
   }
   evalGenerator(defaultValue) {
     if (ExpressionUtils.isCall(defaultValue)) {
-      return (0, import_ts_pattern8.match)(defaultValue.function).with("cuid", () => (0, import_cuid2.createId)()).with("uuid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args?.[0]) && defaultValue.args[0].value === 7 ? uuid.v7() : uuid.v4()).with("nanoid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args[0]) && typeof defaultValue.args[0].value === "number" ? (0, import_nanoid.nanoid)(defaultValue.args[0].value) : (0, import_nanoid.nanoid)()).with("ulid", () => (0, import_ulid.ulid)()).otherwise(() => void 0);
+      return (0, import_ts_pattern9.match)(defaultValue.function).with("cuid", () => (0, import_cuid2.createId)()).with("uuid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args?.[0]) && defaultValue.args[0].value === 7 ? uuid.v7() : uuid.v4()).with("nanoid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args[0]) && typeof defaultValue.args[0].value === "number" ? (0, import_nanoid.nanoid)(defaultValue.args[0].value) : (0, import_nanoid.nanoid)()).with("ulid", () => (0, import_ulid.ulid)()).otherwise(() => void 0);
     } else if (ExpressionUtils.isMember(defaultValue) && ExpressionUtils.isCall(defaultValue.receiver) && defaultValue.receiver.function === "auth") {
       let val = this.client.$auth;
       for (const member of defaultValue.members) {
@@ -3422,7 +3437,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely8.expressionBuilder)();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
-    return (0, import_ts_pattern8.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
+    return (0, import_ts_pattern9.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
       throw new InternalError(`Invalid incremental update operation: ${key}`);
     });
   }
@@ -3432,7 +3447,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely8.expressionBuilder)();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
-    return (0, import_ts_pattern8.match)(key).with("set", () => value).with("push", () => {
+    return (0, import_ts_pattern9.match)(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw new InternalError(`Invalid array update operation: ${key}`);
@@ -4095,7 +4110,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = (0, import_ts_pattern9.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = (0, import_ts_pattern10.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(import_kysely9.sql.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -4128,7 +4143,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern9.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern10.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4179,14 +4194,14 @@ var CountOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/create.ts
-var import_ts_pattern10 = require("ts-pattern");
+var import_ts_pattern11 = require("ts-pattern");
 var CreateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern10.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+    return (0, import_ts_pattern11.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
       return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, normalizedArgs));
     }).with("createManyAndReturn", () => {
       return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, normalizedArgs));
@@ -4233,14 +4248,14 @@ var CreateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/delete.ts
-var import_ts_pattern11 = require("ts-pattern");
+var import_ts_pattern12 = require("ts-pattern");
 var DeleteOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern11.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
+    return (0, import_ts_pattern12.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runDelete(args) {
     const existing = await this.readUnique(this.kysely, this.model, {
@@ -4284,7 +4299,7 @@ var FindOperationHandler = class extends BaseOperationHandler {
 
 // src/client/crud/operations/group-by.ts
 var import_kysely11 = require("kysely");
-var import_ts_pattern12 = require("ts-pattern");
+var import_ts_pattern13 = require("ts-pattern");
 var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "GroupByOperationHandler");
@@ -4308,12 +4323,12 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
     const bys = typeof parsedArgs.by === "string" ? [
       parsedArgs.by
     ] : parsedArgs.by;
-    query = query.groupBy(bys);
+    query = query.groupBy(bys.map((by) => import_kysely11.sql.ref(`$sub.${by}`)));
     if (parsedArgs.orderBy) {
       query = this.dialect.buildOrderBy(query, this.model, "$sub", parsedArgs.orderBy, false, false);
     }
     if (parsedArgs.having) {
-      query = query.having((eb1) => this.dialect.buildFilter(eb1, this.model, "$sub", parsedArgs.having));
+      query = query.having((eb) => this.dialect.buildFilter(eb, this.model, "$sub", parsedArgs.having));
     }
     for (const by of bys) {
       query = query.select(() => import_kysely11.sql.ref(`$sub.${by}`).as(by));
@@ -4343,7 +4358,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = (0, import_ts_pattern12.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = (0, import_ts_pattern13.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(import_kysely11.sql.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -4380,7 +4395,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern12.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern13.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4395,14 +4410,14 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/update.ts
-var import_ts_pattern13 = require("ts-pattern");
+var import_ts_pattern14 = require("ts-pattern");
 var UpdateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern13.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
+    return (0, import_ts_pattern14.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runUpdate(args) {
     const readBackResult = await this.safeTransaction(async (tx) => {
@@ -4474,7 +4489,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
-var import_ts_pattern14 = require("ts-pattern");
+var import_ts_pattern15 = require("ts-pattern");
 var import_zod = require("zod");
 var InputValidator = class {
   static {
@@ -4575,8 +4590,8 @@ var InputValidator = class {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefSchema(type);
     } else {
-      return (0, import_ts_pattern14.match)(type).with("String", () => import_zod.z.string()).with("Int", () => import_zod.z.number()).with("Float", () => import_zod.z.number()).with("Boolean", () => import_zod.z.boolean()).with("BigInt", () => import_zod.z.union([
-        import_zod.z.number(),
+      return (0, import_ts_pattern15.match)(type).with("String", () => import_zod.z.string()).with("Int", () => import_zod.z.int()).with("Float", () => import_zod.z.number()).with("Boolean", () => import_zod.z.boolean()).with("BigInt", () => import_zod.z.union([
+        import_zod.z.int(),
         import_zod.z.bigint()
       ])).with("Decimal", () => import_zod.z.union([
         import_zod.z.number(),
@@ -4612,7 +4627,7 @@ var InputValidator = class {
     this.schemaCache.set(key, schema);
     return schema;
   }
-  makeWhereSchema(model, unique, withoutRelationFields = false) {
+  makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
     const modelDef = getModel(this.schema, model);
     if (!modelDef) {
       throw new QueryError(`Model "${model}" not found in schema`);
@@ -4649,12 +4664,12 @@ var InputValidator = class {
         const enumDef = getEnum(this.schema, fieldDef.type);
         if (enumDef) {
           if (Object.keys(enumDef).length > 0) {
-            fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional);
+            fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, withAggregations);
           }
         } else if (fieldDef.array) {
           fieldSchema = this.makeArrayFilterSchema(fieldDef.type);
         } else {
-          fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional);
+          fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations);
         }
       }
       if (fieldSchema) {
@@ -4671,12 +4686,12 @@ var InputValidator = class {
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
               if (Object.keys(enumDef).length > 0) {
-                fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional);
+                fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
               } else {
                 fieldSchema = import_zod.z.never();
               }
             } else {
-              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional);
+              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
             }
             return [
               key,
@@ -4709,17 +4724,21 @@ var InputValidator = class {
     }
     return result;
   }
-  makeEnumFilterSchema(enumDef, optional) {
+  makeEnumFilterSchema(enumDef, optional, withAggregations) {
     const baseSchema = import_zod.z.enum(Object.keys(enumDef));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional)));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+      "equals",
+      "in",
+      "notIn",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.strictObject({
-        equals: components.equals,
-        in: components.in,
-        notIn: components.notIn,
-        not: components.not
-      })
+      import_zod.z.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
@@ -4731,45 +4750,59 @@ var InputValidator = class {
       isEmpty: import_zod.z.boolean().optional()
     });
   }
-  makePrimitiveFilterSchema(type, optional) {
+  makePrimitiveFilterSchema(type, optional, withAggregations) {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefFilterSchema(type, optional);
     }
-    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional)).with("Boolean", () => this.makeBooleanFilterSchema(optional)).with("DateTime", () => this.makeDateTimeFilterSchema(optional)).with("Bytes", () => this.makeBytesFilterSchema(optional)).with("Json", () => import_zod.z.any()).with("Unsupported", () => import_zod.z.never()).exhaustive();
+    return (0, import_ts_pattern15.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern15.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => import_zod.z.any()).with("Unsupported", () => import_zod.z.never()).exhaustive();
   }
   makeTypeDefFilterSchema(_type, _optional) {
     return import_zod.z.never();
   }
-  makeDateTimeFilterSchema(optional) {
+  makeDateTimeFilterSchema(optional, withAggregations) {
     return this.makeCommonPrimitiveFilterSchema(import_zod.z.union([
-      import_zod.z.string().datetime(),
+      import_zod.z.iso.datetime(),
       import_zod.z.date()
-    ]), optional, () => import_zod.z.lazy(() => this.makeDateTimeFilterSchema(optional)));
-  }
-  makeBooleanFilterSchema(optional) {
+    ]), optional, () => import_zod.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
+  }
+  makeBooleanFilterSchema(optional, withAggregations) {
+    const components = this.makeCommonPrimitiveFilterComponents(import_zod.z.boolean(), optional, () => import_zod.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+      "equals",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return import_zod.z.union([
       this.nullableIf(import_zod.z.boolean(), optional),
-      import_zod.z.strictObject({
-        equals: this.nullableIf(import_zod.z.boolean(), optional).optional(),
-        not: import_zod.z.lazy(() => this.makeBooleanFilterSchema(optional)).optional()
-      })
+      import_zod.z.strictObject(components)
     ]);
   }
-  makeBytesFilterSchema(optional) {
+  makeBytesFilterSchema(optional, withAggregations) {
     const baseSchema = import_zod.z.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.instanceof(Uint8Array));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.instanceof(Uint8Array), [
+      "equals",
+      "in",
+      "notIn",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.strictObject({
-        equals: components.equals,
-        in: components.in,
-        notIn: components.notIn,
-        not: components.not
-      })
+      import_zod.z.strictObject(components)
     ]);
   }
-  makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis) {
-    return {
+  makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
+    const commonAggSchema = /* @__PURE__ */ __name(() => this.makeCommonPrimitiveFilterSchema(baseSchema, false, makeThis, void 0).optional(), "commonAggSchema");
+    let result = {
       equals: this.nullableIf(baseSchema.optional(), optional),
       notEquals: this.nullableIf(baseSchema.optional(), optional),
       in: baseSchema.array().optional(),
@@ -4778,23 +4811,56 @@ var InputValidator = class {
       lte: baseSchema.optional(),
       gt: baseSchema.optional(),
       gte: baseSchema.optional(),
-      not: makeThis().optional()
+      not: makeThis().optional(),
+      ...withAggregations?.includes("_count") ? {
+        _count: this.makeNumberFilterSchema(import_zod.z.int(), false, false).optional()
+      } : {},
+      ...withAggregations?.includes("_avg") ? {
+        _avg: commonAggSchema()
+      } : {},
+      ...withAggregations?.includes("_sum") ? {
+        _sum: commonAggSchema()
+      } : {},
+      ...withAggregations?.includes("_min") ? {
+        _min: commonAggSchema()
+      } : {},
+      ...withAggregations?.includes("_max") ? {
+        _max: commonAggSchema()
+      } : {}
     };
+    if (supportedOperators) {
+      const keys = [
+        ...supportedOperators,
+        ...withAggregations ?? []
+      ];
+      result = extractFields(result, keys);
+    }
+    return result;
   }
-  makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis) {
+  makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
+      import_zod.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
-  makeNumberFilterSchema(baseSchema, optional) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional)));
+  makeNumberFilterSchema(baseSchema, optional, withAggregations) {
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+      "_count",
+      "_avg",
+      "_sum",
+      "_min",
+      "_max"
+    ] : void 0);
   }
-  makeStringFilterSchema(optional) {
+  makeStringFilterSchema(optional, withAggregations) {
     return import_zod.z.union([
       this.nullableIf(import_zod.z.string(), optional),
       import_zod.z.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(import_zod.z.string(), optional, () => import_zod.z.lazy(() => this.makeStringFilterSchema(optional))),
+        ...this.makeCommonPrimitiveFilterComponents(import_zod.z.string(), optional, () => import_zod.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
+          "_count",
+          "_min",
+          "_max"
+        ] : void 0),
         startsWith: import_zod.z.string().optional(),
         endsWith: import_zod.z.string().optional(),
         contains: import_zod.z.string().optional(),
@@ -5152,7 +5218,7 @@ var InputValidator = class {
     return import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: import_zod.z.number().int().nonnegative().optional()
+      limit: import_zod.z.int().nonnegative().optional()
     });
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -5259,7 +5325,7 @@ var InputValidator = class {
   makeDeleteManySchema(model) {
     return import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: import_zod.z.number().int().nonnegative().optional()
+      limit: import_zod.z.int().nonnegative().optional()
     }).optional();
   }
   // #endregion
@@ -5328,7 +5394,7 @@ var InputValidator = class {
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: this.orArray(import_zod.z.enum(nonRelationFields), true),
-      having: this.makeWhereSchema(model, false, true).optional(),
+      having: this.makeHavingSchema(model).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
@@ -5341,17 +5407,29 @@ var InputValidator = class {
       const bys = typeof value.by === "string" ? [
         value.by
       ] : value.by;
-      if (value.having && Object.keys(value.having).filter((f) => !f.startsWith("_")).some((key) => !bys.includes(key))) {
-        return false;
-      } else {
-        return true;
+      if (value.having && typeof value.having === "object") {
+        for (const [key, val] of Object.entries(value.having)) {
+          if (AGGREGATE_OPERATORS.includes(key)) {
+            continue;
+          }
+          if (bys.includes(key)) {
+            continue;
+          }
+          if (!val || typeof val !== "object") {
+            return false;
+          }
+          if (!this.onlyAggregationFields(val)) {
+            return false;
+          }
+        }
       }
+      return true;
     }, 'fields in "having" must be in "by"');
     schema = schema.refine((value) => {
       const bys = typeof value.by === "string" ? [
         value.by
       ] : value.by;
-      if (value.orderBy && Object.keys(value.orderBy).filter((f) => !f.startsWith("_")).some((key) => !bys.includes(key))) {
+      if (value.orderBy && Object.keys(value.orderBy).filter((f) => !AGGREGATE_OPERATORS.includes(f)).some((key) => !bys.includes(key))) {
         return false;
       } else {
         return true;
@@ -5359,13 +5437,30 @@ var InputValidator = class {
     }, 'fields in "orderBy" must be in "by"');
     return schema;
   }
+  onlyAggregationFields(val) {
+    for (const [key, value] of Object.entries(val)) {
+      if (AGGREGATE_OPERATORS.includes(key)) {
+        continue;
+      }
+      if (LOGICAL_COMBINATORS.includes(key)) {
+        if (enumerate(value).every((v) => this.onlyAggregationFields(v))) {
+          continue;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+  makeHavingSchema(model) {
+    return this.makeWhereSchema(model, false, true, true);
+  }
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return import_zod.z.number().int().nonnegative();
+    return import_zod.z.int().nonnegative();
   }
   makeTakeSchema() {
-    return import_zod.z.number().int();
+    return import_zod.z.int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -5573,7 +5668,7 @@ __name(performanceNow, "performanceNow");
 var import_kysely13 = require("kysely");
 var import_nanoid2 = require("nanoid");
 var import_node_util2 = require("util");
-var import_ts_pattern15 = require("ts-pattern");
+var import_ts_pattern16 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
 var import_kysely12 = require("kysely");
@@ -5921,7 +6016,7 @@ ${compiled.parameters.map((p) => (0, import_node_util2.inspect)(p)).join("\n")}`
     return this.client.$options.plugins?.some((plugin) => plugin.beforeEntityMutation || plugin.afterEntityMutation);
   }
   getMutationModel(queryNode) {
-    return (0, import_ts_pattern15.match)(queryNode).when(import_kysely13.InsertQueryNode.is, (node) => node.into.table.identifier.name).when(import_kysely13.UpdateQueryNode.is, (node) => node.table.table.identifier.name).when(import_kysely13.DeleteQueryNode.is, (node) => {
+    return (0, import_ts_pattern16.match)(queryNode).when(import_kysely13.InsertQueryNode.is, (node) => node.into.table.identifier.name).when(import_kysely13.UpdateQueryNode.is, (node) => node.table.table.identifier.name).when(import_kysely13.DeleteQueryNode.is, (node) => {
       if (node.from.froms.length !== 1) {
         throw new InternalError(`Delete query must have exactly one from table`);
       }
@@ -5937,7 +6032,7 @@ ${compiled.parameters.map((p) => (0, import_node_util2.inspect)(p)).join("\n")}`
       const result = {
         intercept: false
       };
-      const { action, where } = (0, import_ts_pattern15.match)(queryNode).when(import_kysely13.InsertQueryNode.is, () => ({
+      const { action, where } = (0, import_ts_pattern16.match)(queryNode).when(import_kysely13.InsertQueryNode.is, () => ({
         action: "create",
         where: void 0
       })).when(import_kysely13.UpdateQueryNode.is, (node) => ({
@@ -6077,7 +6172,7 @@ __export(functions_exports, {
 });
 var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely14 = require("kysely");
-var import_ts_pattern16 = require("ts-pattern");
+var import_ts_pattern17 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
   if (!field) {
@@ -6162,7 +6257,7 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   return eb(dialect.buildArrayLength(eb, field), "=", import_kysely14.sql.lit(0));
 }, "isEmpty");
 var now = /* @__PURE__ */ __name((eb, _args, { dialect }) => {
-  return (0, import_ts_pattern16.match)(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => import_kysely14.sql.raw("CURRENT_TIMESTAMP")).exhaustive();
+  return (0, import_ts_pattern17.match)(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => import_kysely14.sql.raw("CURRENT_TIMESTAMP")).exhaustive();
 }, "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
@@ -6183,7 +6278,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
   (0, import_common_helpers10.invariant)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern16.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers10.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers10.lowerCaseFirst)(result)).otherwise(() => {
+  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers10.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers10.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -6193,7 +6288,7 @@ __name(processCasing, "processCasing");
 // src/client/helpers/schema-db-pusher.ts
 var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
-var import_ts_pattern17 = require("ts-pattern");
+var import_ts_pattern18 = require("ts-pattern");
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -6297,7 +6392,7 @@ var SchemaDbPusher = class {
       return "serial";
     }
     const type = fieldDef.type;
-    const result = (0, import_ts_pattern17.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").with("Json", () => "jsonb").otherwise(() => {
+    const result = (0, import_ts_pattern18.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").with("Json", () => "jsonb").otherwise(() => {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
@@ -6326,7 +6421,7 @@ var SchemaDbPusher = class {
     return table;
   }
   mapCascadeAction(action) {
-    return (0, import_ts_pattern17.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+    return (0, import_ts_pattern18.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
   }
 };
 
@@ -6367,7 +6462,7 @@ __name(valueToPromise, "valueToPromise");
 // src/client/result-processor.ts
 var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
-var import_ts_pattern18 = require("ts-pattern");
+var import_ts_pattern19 = require("ts-pattern");
 var ResultProcessor = class {
   static {
     __name(this, "ResultProcessor");
@@ -6458,7 +6553,7 @@ var ResultProcessor = class {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.transformJson(value);
     } else {
-      return (0, import_ts_pattern18.match)(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).with("Json", () => this.transformJson(value)).otherwise(() => value);
+      return (0, import_ts_pattern19.match)(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).with("Json", () => this.transformJson(value)).otherwise(() => value);
     }
   }
   transformDecimal(value) {
@@ -6515,7 +6610,7 @@ var ResultProcessor = class {
     }
   }
   transformJson(value) {
-    return (0, import_ts_pattern18.match)(this.schema.provider.type).with("sqlite", () => {
+    return (0, import_ts_pattern19.match)(this.schema.provider.type).with("sqlite", () => {
       (0, import_common_helpers12.invariant)(typeof value === "string", "Expected string, got " + typeof value);
       return JSON.parse(value);
     }).otherwise(() => value);
@@ -6852,7 +6947,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       return createPromise("aggregate", args, new AggregateOperationHandler(client, model, inputValidator), false);
     }, "aggregate"),
     groupBy: /* @__PURE__ */ __name((args) => {
-      return createPromise("groupBy", args, new GroupByOperationHandler(client, model, inputValidator));
+      return createPromise("groupBy", args, new GroupByOperationHandler(client, model, inputValidator), true);
     }, "groupBy")
   };
 }