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

package/dist/index.js

@@ -11,7 +11,10 @@ import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as Defau
 
 // src/client/crud/operations/aggregate.ts
 import { sql as sql5 } from "kysely";
-import { match as match9 } from "ts-pattern";
+import { match as match10 } from "ts-pattern";
+
+// src/client/query-utils.ts
+import { match } from "ts-pattern";
 
 // src/schema/expression.ts
 var ExpressionUtils = {
@@ -92,6 +95,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 {
@@ -370,15 +386,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);
@@ -410,6 +417,10 @@ function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */
   ];
 }
 __name(getDelegateDescendantModels, "getDelegateDescendantModels");
+function aggregate(eb, expr2, op) {
+  return 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
 import { createId } from "@paralleldrive/cuid2";
@@ -417,7 +428,7 @@ import { invariant as invariant7, isPlainObject as isPlainObject3 } from "@zenst
 import { expressionBuilder as expressionBuilder2, sql as sql4 } from "kysely";
 import { nanoid } from "nanoid";
 import { inspect } from "util";
-import { match as match8 } from "ts-pattern";
+import { match as match9 } from "ts-pattern";
 import { ulid } from "ulid";
 import * as uuid from "uuid";
 
@@ -436,15 +447,15 @@ var RejectedByPolicyError = class extends Error {
 // src/plugins/policy/policy-handler.ts
 import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import { AliasNode as AliasNode3, BinaryOperationNode as BinaryOperationNode3, ColumnNode as ColumnNode2, DeleteQueryNode, FromNode as FromNode2, IdentifierNode as IdentifierNode2, InsertQueryNode, OperationNodeTransformer, OperatorNode as OperatorNode3, PrimitiveValueListNode, RawNode, ReturningNode, SelectionNode as SelectionNode2, SelectQueryNode as SelectQueryNode2, TableNode as TableNode3, UpdateQueryNode, ValueNode as ValueNode3, ValuesNode, WhereNode as WhereNode2 } from "kysely";
-import { match as match7 } from "ts-pattern";
+import { match as match8 } from "ts-pattern";
 
 // src/client/crud/dialects/index.ts
-import { match as match4 } from "ts-pattern";
+import { match as match5 } from "ts-pattern";
 
 // src/client/crud/dialects/postgresql.ts
 import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { sql as sql2 } from "kysely";
-import { match as match2 } from "ts-pattern";
+import { match as match3 } from "ts-pattern";
 
 // src/client/constants.ts
 var CONTEXT_COMMENT_PREFIX = "-- $$context:";
@@ -455,11 +466,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
 import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
 import { sql } from "kysely";
-import { match, P } from "ts-pattern";
+import { match as match2, P } from "ts-pattern";
 
 // src/utils/enumerate.ts
 function enumerate(x) {
@@ -516,7 +539,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;
       }
@@ -537,8 +560,11 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  isLogicalCombinator(key) {
+    return LOGICAL_COMBINATORS.includes(key);
+  }
   buildCompositeFilter(eb, model, modelAlias, key, payload) {
-    return 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 match2(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) {
@@ -687,7 +713,7 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
     }
-    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(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 match2(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(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`);
@@ -715,7 +741,7 @@ var BaseCrudDialect = class {
         continue;
       }
       const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
-      const condition = match(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
+      const condition = match2(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
         invariant(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.false(eb);
@@ -729,7 +755,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(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 {
@@ -759,7 +789,7 @@ var BaseCrudDialect = class {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = match(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}%`)) : eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`${value}%`)) : eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}`)) : eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
+        const condition = match2(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}%`)) : eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`${value}%`)) : eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}`)) : eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
           throw new QueryError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
@@ -840,9 +870,7 @@ var BaseCrudDialect = class {
           invariant(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => eb.fn(field.slice(1), [
-              sql.ref(k)
-            ]), sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, sql.ref(`${modelAlias}.${k}`), field), sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -1037,7 +1065,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         return value.map((v) => this.transformPrimitive(v, type, false));
       }
     } else {
-      return match2(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
+      return match3(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) {
@@ -1194,7 +1222,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
 // src/client/crud/dialects/sqlite.ts
 import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import { sql as sql3 } from "kysely";
-import { match as match3 } from "ts-pattern";
+import { match as match4 } from "ts-pattern";
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -1212,7 +1240,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       if (this.schema.typeDefs && type in this.schema.typeDefs) {
         return JSON.stringify(value);
       } else {
-        return match3(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 match4(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);
       }
     }
   }
@@ -1358,7 +1386,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 
 // src/client/crud/dialects/index.ts
 function getCrudDialect(schema, options) {
-  return match4(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
+  return match5(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
 }
 __name(getCrudDialect, "getCrudDialect");
 
@@ -1683,17 +1711,17 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 // src/plugins/policy/expression-transformer.ts
 import { invariant as invariant5 } from "@zenstackhq/common-helpers";
 import { AliasNode as AliasNode2, BinaryOperationNode as BinaryOperationNode2, ColumnNode, expressionBuilder, FromNode, FunctionNode as FunctionNode2, IdentifierNode, OperatorNode as OperatorNode2, ReferenceNode as ReferenceNode2, SelectionNode, SelectQueryNode, TableNode as TableNode2, ValueListNode, ValueNode as ValueNode2, WhereNode } from "kysely";
-import { match as match6 } from "ts-pattern";
+import { match as match7 } from "ts-pattern";
 
 // src/plugins/policy/expression-evaluator.ts
 import { invariant as invariant4 } from "@zenstackhq/common-helpers";
-import { match as match5 } from "ts-pattern";
+import { match as match6 } from "ts-pattern";
 var ExpressionEvaluator = class {
   static {
     __name(this, "ExpressionEvaluator");
   }
   evaluate(expression, context) {
-    const result = match5(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 = match6(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) {
@@ -1704,7 +1732,7 @@ var ExpressionEvaluator = class {
     }
   }
   evaluateUnary(expr2, context) {
-    return match5(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
+    return match6(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
   }
   evaluateMember(expr2, context) {
     let val = this.evaluate(expr2.receiver, context);
@@ -1728,7 +1756,7 @@ var ExpressionEvaluator = class {
     }
     const left = this.evaluate(expr2.left, context);
     const right = this.evaluate(expr2.right, context);
-    return match5(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 match6(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 ?? [];
       invariant4(Array.isArray(_right), 'expected array for "in" operator');
       return _right.includes(left);
@@ -1742,7 +1770,7 @@ var ExpressionEvaluator = class {
       return false;
     }
     invariant4(Array.isArray(left), "expected array");
-    return match5(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
+    return match6(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
     }))).with("!", () => left.every((item) => this.evaluate(expr2.right, {
@@ -1996,7 +2024,7 @@ var ExpressionTransformer = class {
     const count = FunctionNode2.create("count", [
       ValueNode2.createImmediate(1)
     ]);
-    const predicateResult = match6(expr2.op).with("?", () => BinaryOperationNode2.create(count, OperatorNode2.create(">"), ValueNode2.createImmediate(0))).with("!", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).with("^", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).exhaustive();
+    const predicateResult = match7(expr2.op).with("?", () => BinaryOperationNode2.create(count, OperatorNode2.create(">"), ValueNode2.createImmediate(0))).with("!", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).with("^", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).exhaustive();
     return this.transform(expr2.left, {
       ...context,
       memberSelect: SelectionNode.create(AliasNode2.create(predicateResult, IdentifierNode.create("$t"))),
@@ -2027,7 +2055,7 @@ var ExpressionTransformer = class {
     return BinaryOperationNode2.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
   }
   transformOperator(op) {
-    const mappedOp = match6(op).with("==", () => "=").otherwise(() => op);
+    const mappedOp = match7(op).with("==", () => "=").otherwise(() => op);
     return OperatorNode2.create(mappedOp);
   }
   _call(expr2, context) {
@@ -2430,7 +2458,7 @@ var PolicyHandler = class extends OperationNodeTransformer {
     return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => BinaryOperationNode3.create(ColumnNode2.create(field), OperatorNode3.create("="), ValueNode3.create(row[field]))))));
   }
   getMutationModel(node) {
-    const r = match7(node).when(InsertQueryNode.is, (node2) => getTableName(node2.into)).when(UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(DeleteQueryNode.is, (node2) => {
+    const r = match8(node).when(InsertQueryNode.is, (node2) => getTableName(node2.into)).when(UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(DeleteQueryNode.is, (node2) => {
       if (node2.from.froms.length !== 1) {
         throw new InternalError("Only one from table is supported for delete");
       }
@@ -2627,19 +2655,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 {
@@ -2996,7 +3011,7 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
         case "connect": {
           const referencedPkFields = relationField.relation.references;
           invariant7(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 {
@@ -3205,7 +3220,7 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
   }
   evalGenerator(defaultValue) {
     if (ExpressionUtils.isCall(defaultValue)) {
-      return match8(defaultValue.function).with("cuid", () => 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" ? nanoid(defaultValue.args[0].value) : nanoid()).with("ulid", () => ulid()).otherwise(() => void 0);
+      return match9(defaultValue.function).with("cuid", () => 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" ? nanoid(defaultValue.args[0].value) : nanoid()).with("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) {
@@ -3387,7 +3402,7 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, false);
     const eb = expressionBuilder2();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
-    return match8(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 match9(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}`);
     });
   }
@@ -3397,7 +3412,7 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, true);
     const eb = expressionBuilder2();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
-    return match8(key).with("set", () => value).with("push", () => {
+    return match9(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw new InternalError(`Invalid array update operation: ${key}`);
@@ -4060,7 +4075,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = match9(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = match10(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(sql5.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -4093,7 +4108,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = match9(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = match10(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4144,14 +4159,14 @@ var CountOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/create.ts
-import { match as match10 } from "ts-pattern";
+import { match as match11 } from "ts-pattern";
 var CreateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return match10(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+    return match11(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));
@@ -4198,14 +4213,14 @@ var CreateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/delete.ts
-import { match as match11 } from "ts-pattern";
+import { match as match12 } from "ts-pattern";
 var DeleteOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return match11(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
+    return match12(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, {
@@ -4249,7 +4264,7 @@ var FindOperationHandler = class extends BaseOperationHandler {
 
 // src/client/crud/operations/group-by.ts
 import { sql as sql7 } from "kysely";
-import { match as match12 } from "ts-pattern";
+import { match as match13 } from "ts-pattern";
 var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "GroupByOperationHandler");
@@ -4273,12 +4288,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) => sql7.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(() => sql7.ref(`$sub.${by}`).as(by));
@@ -4308,7 +4323,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = match12(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = match13(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(sql7.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -4345,7 +4360,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = match12(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = match13(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4360,14 +4375,14 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/update.ts
-import { match as match13 } from "ts-pattern";
+import { match as match14 } from "ts-pattern";
 var UpdateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return match13(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 match14(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) => {
@@ -4439,7 +4454,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 import { invariant as invariant8 } from "@zenstackhq/common-helpers";
 import Decimal from "decimal.js";
 import stableStringify from "json-stable-stringify";
-import { match as match14, P as P2 } from "ts-pattern";
+import { match as match15, P as P2 } from "ts-pattern";
 import { z } from "zod";
 var InputValidator = class {
   static {
@@ -4540,8 +4555,8 @@ var InputValidator = class {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefSchema(type);
     } else {
-      return match14(type).with("String", () => z.string()).with("Int", () => z.number()).with("Float", () => z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([
-        z.number(),
+      return match15(type).with("String", () => z.string()).with("Int", () => z.int()).with("Float", () => z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([
+        z.int(),
         z.bigint()
       ])).with("Decimal", () => z.union([
         z.number(),
@@ -4577,7 +4592,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`);
@@ -4614,12 +4629,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) {
@@ -4636,12 +4651,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 = z.never();
               }
             } else {
-              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional);
+              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
             }
             return [
               key,
@@ -4674,17 +4689,21 @@ var InputValidator = class {
     }
     return result;
   }
-  makeEnumFilterSchema(enumDef, optional) {
+  makeEnumFilterSchema(enumDef, optional, withAggregations) {
     const baseSchema = z.enum(Object.keys(enumDef));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.lazy(() => this.makeEnumFilterSchema(enumDef, optional)));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+      "equals",
+      "in",
+      "notIn",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return z.union([
       this.nullableIf(baseSchema, optional),
-      z.strictObject({
-        equals: components.equals,
-        in: components.in,
-        notIn: components.notIn,
-        not: components.not
-      })
+      z.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
@@ -4696,45 +4715,59 @@ var InputValidator = class {
       isEmpty: 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 match14(type).with("String", () => this.makeStringFilterSchema(optional)).with(P2.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", () => z.any()).with("Unsupported", () => z.never()).exhaustive();
+    return match15(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(P2.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", () => z.any()).with("Unsupported", () => z.never()).exhaustive();
   }
   makeTypeDefFilterSchema(_type, _optional) {
     return z.never();
   }
-  makeDateTimeFilterSchema(optional) {
+  makeDateTimeFilterSchema(optional, withAggregations) {
     return this.makeCommonPrimitiveFilterSchema(z.union([
-      z.string().datetime(),
+      z.iso.datetime(),
       z.date()
-    ]), optional, () => z.lazy(() => this.makeDateTimeFilterSchema(optional)));
-  }
-  makeBooleanFilterSchema(optional) {
+    ]), optional, () => z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
+  }
+  makeBooleanFilterSchema(optional, withAggregations) {
+    const components = this.makeCommonPrimitiveFilterComponents(z.boolean(), optional, () => z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+      "equals",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return z.union([
       this.nullableIf(z.boolean(), optional),
-      z.strictObject({
-        equals: this.nullableIf(z.boolean(), optional).optional(),
-        not: z.lazy(() => this.makeBooleanFilterSchema(optional)).optional()
-      })
+      z.strictObject(components)
     ]);
   }
-  makeBytesFilterSchema(optional) {
+  makeBytesFilterSchema(optional, withAggregations) {
     const baseSchema = z.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.instanceof(Uint8Array));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.instanceof(Uint8Array), [
+      "equals",
+      "in",
+      "notIn",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return z.union([
       this.nullableIf(baseSchema, optional),
-      z.strictObject({
-        equals: components.equals,
-        in: components.in,
-        notIn: components.notIn,
-        not: components.not
-      })
+      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(),
@@ -4743,23 +4776,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(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 z.union([
       this.nullableIf(baseSchema, optional),
-      z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
+      z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
-  makeNumberFilterSchema(baseSchema, optional) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional)));
+  makeNumberFilterSchema(baseSchema, optional, withAggregations) {
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+      "_count",
+      "_avg",
+      "_sum",
+      "_min",
+      "_max"
+    ] : void 0);
   }
-  makeStringFilterSchema(optional) {
+  makeStringFilterSchema(optional, withAggregations) {
     return z.union([
       this.nullableIf(z.string(), optional),
       z.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional))),
+        ...this.makeCommonPrimitiveFilterComponents(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
+          "_count",
+          "_min",
+          "_max"
+        ] : void 0),
         startsWith: z.string().optional(),
         endsWith: z.string().optional(),
         contains: z.string().optional(),
@@ -5117,7 +5183,7 @@ var InputValidator = class {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: z.number().int().nonnegative().optional()
+      limit: z.int().nonnegative().optional()
     });
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -5224,7 +5290,7 @@ var InputValidator = class {
   makeDeleteManySchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: z.number().int().nonnegative().optional()
+      limit: z.int().nonnegative().optional()
     }).optional();
   }
   // #endregion
@@ -5293,7 +5359,7 @@ var InputValidator = class {
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: this.orArray(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(),
@@ -5306,17 +5372,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;
@@ -5324,13 +5402,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 z.number().int().nonnegative();
+    return z.int().nonnegative();
   }
   makeTakeSchema() {
-    return z.number().int();
+    return z.int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -5538,7 +5633,7 @@ __name(performanceNow, "performanceNow");
 import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode3, SelectionNode as SelectionNode4, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
 import { nanoid as nanoid2 } from "nanoid";
 import { inspect as inspect2 } from "util";
-import { match as match15 } from "ts-pattern";
+import { match as match16 } from "ts-pattern";
 
 // src/client/executor/name-mapper.ts
 import { AliasNode as AliasNode4, ColumnNode as ColumnNode3, IdentifierNode as IdentifierNode3, OperationNodeTransformer as OperationNodeTransformer2, ReferenceNode as ReferenceNode3, ReturningNode as ReturningNode2, SelectAllNode, SelectionNode as SelectionNode3, TableNode as TableNode4 } from "kysely";
@@ -5886,7 +5981,7 @@ ${compiled.parameters.map((p) => inspect2(p)).join("\n")}`;
     return this.client.$options.plugins?.some((plugin) => plugin.beforeEntityMutation || plugin.afterEntityMutation);
   }
   getMutationModel(queryNode) {
-    return match15(queryNode).when(InsertQueryNode2.is, (node) => node.into.table.identifier.name).when(UpdateQueryNode2.is, (node) => node.table.table.identifier.name).when(DeleteQueryNode2.is, (node) => {
+    return match16(queryNode).when(InsertQueryNode2.is, (node) => node.into.table.identifier.name).when(UpdateQueryNode2.is, (node) => node.table.table.identifier.name).when(DeleteQueryNode2.is, (node) => {
       if (node.from.froms.length !== 1) {
         throw new InternalError(`Delete query must have exactly one from table`);
       }
@@ -5902,7 +5997,7 @@ ${compiled.parameters.map((p) => inspect2(p)).join("\n")}`;
       const result = {
         intercept: false
       };
-      const { action, where } = match15(queryNode).when(InsertQueryNode2.is, () => ({
+      const { action, where } = match16(queryNode).when(InsertQueryNode2.is, () => ({
         action: "create",
         where: void 0
       })).when(UpdateQueryNode2.is, (node) => ({
@@ -6042,7 +6137,7 @@ __export(functions_exports, {
 });
 import { invariant as invariant9, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
 import { sql as sql8, ValueNode as ValueNode4 } from "kysely";
-import { match as match16 } from "ts-pattern";
+import { match as match17 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
   if (!field) {
@@ -6127,7 +6222,7 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   return eb(dialect.buildArrayLength(eb, field), "=", sql8.lit(0));
 }, "isEmpty");
 var now = /* @__PURE__ */ __name((eb, _args, { dialect }) => {
-  return match16(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => sql8.raw("CURRENT_TIMESTAMP")).exhaustive();
+  return match17(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => sql8.raw("CURRENT_TIMESTAMP")).exhaustive();
 }, "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
@@ -6148,7 +6243,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
   invariant9(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = match16(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst(result)).otherwise(() => {
+  result = match17(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -6158,7 +6253,7 @@ __name(processCasing, "processCasing");
 // src/client/helpers/schema-db-pusher.ts
 import { invariant as invariant10 } from "@zenstackhq/common-helpers";
 import { sql as sql9 } from "kysely";
-import { match as match17 } from "ts-pattern";
+import { match as match18 } from "ts-pattern";
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -6262,7 +6357,7 @@ var SchemaDbPusher = class {
       return "serial";
     }
     const type = fieldDef.type;
-    const result = match17(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 = match18(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) {
@@ -6291,7 +6386,7 @@ var SchemaDbPusher = class {
     return table;
   }
   mapCascadeAction(action) {
-    return match17(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+    return match18(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
   }
 };
 
@@ -6332,7 +6427,7 @@ __name(valueToPromise, "valueToPromise");
 // src/client/result-processor.ts
 import { invariant as invariant11 } from "@zenstackhq/common-helpers";
 import Decimal2 from "decimal.js";
-import { match as match18 } from "ts-pattern";
+import { match as match19 } from "ts-pattern";
 var ResultProcessor = class {
   static {
     __name(this, "ResultProcessor");
@@ -6423,7 +6518,7 @@ var ResultProcessor = class {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.transformJson(value);
     } else {
-      return match18(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 match19(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) {
@@ -6480,7 +6575,7 @@ var ResultProcessor = class {
     }
   }
   transformJson(value) {
-    return match18(this.schema.provider.type).with("sqlite", () => {
+    return match19(this.schema.provider.type).with("sqlite", () => {
       invariant11(typeof value === "string", "Expected string, got " + typeof value);
       return JSON.parse(value);
     }).otherwise(() => value);
@@ -6817,7 +6912,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")
   };
 }