@zenstackhq/runtime 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/index.js

@@ -6,29 +6,133 @@ var __export = (target, all) => {
 };
 
 // src/client/client-impl.ts
-import { DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, PostgresDialect, SqliteDialect } from "kysely";
-import { match as match19 } from "ts-pattern";
+import { invariant as invariant12, lowerCaseFirst as lowerCaseFirst2 } from "@zenstackhq/common-helpers";
+import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql9 } from "kysely";
 
 // 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 = {
+  literal: /* @__PURE__ */ __name((value) => {
+    return {
+      kind: "literal",
+      value
+    };
+  }, "literal"),
+  array: /* @__PURE__ */ __name((items) => {
+    return {
+      kind: "array",
+      items
+    };
+  }, "array"),
+  call: /* @__PURE__ */ __name((functionName, args) => {
+    return {
+      kind: "call",
+      function: functionName,
+      args
+    };
+  }, "call"),
+  binary: /* @__PURE__ */ __name((left, op, right) => {
+    return {
+      kind: "binary",
+      op,
+      left,
+      right
+    };
+  }, "binary"),
+  unary: /* @__PURE__ */ __name((op, operand) => {
+    return {
+      kind: "unary",
+      op,
+      operand
+    };
+  }, "unary"),
+  field: /* @__PURE__ */ __name((field) => {
+    return {
+      kind: "field",
+      field
+    };
+  }, "field"),
+  member: /* @__PURE__ */ __name((receiver, members) => {
+    return {
+      kind: "member",
+      receiver,
+      members
+    };
+  }, "member"),
+  _this: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "this"
+    };
+  }, "_this"),
+  _null: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "null"
+    };
+  }, "_null"),
+  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
+  }, "and"),
+  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
+  }, "or"),
+  is: /* @__PURE__ */ __name((value, kind) => {
+    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
+  }, "is"),
+  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
+  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
+  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
+  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
+  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
+  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
+  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
+  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
+  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 {
+    __name(this, "InputValidationError");
+  }
+  constructor(message, cause) {
+    super(message, {
+      cause
+    });
+  }
+};
 var QueryError = class extends Error {
   static {
     __name(this, "QueryError");
   }
-  constructor(message) {
-    super(message);
+  constructor(message, cause) {
+    super(message, {
+      cause
+    });
   }
 };
 var InternalError = class extends Error {
   static {
     __name(this, "InternalError");
   }
-  constructor(message) {
-    super(message);
-  }
 };
 var NotFoundError = class extends Error {
   static {
@@ -47,7 +151,7 @@ __name(getModel, "getModel");
 function requireModel(schema, model) {
   const matchedName = Object.keys(schema.models).find((k) => k.toLowerCase() === model.toLowerCase());
   if (!matchedName) {
-    throw new QueryError(`Model "${model}" not found`);
+    throw new QueryError(`Model "${model}" not found in schema`);
   }
   return schema.models[matchedName];
 }
@@ -111,20 +215,25 @@ function getRelationForeignKeyFieldPairs(schema, model, relationField) {
 }
 __name(getRelationForeignKeyFieldPairs, "getRelationForeignKeyFieldPairs");
 function isScalarField(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  return !fieldDef.relation && !fieldDef.foreignKeyFor;
+  const fieldDef = getField(schema, model, field);
+  return !fieldDef?.relation && !fieldDef?.foreignKeyFor;
 }
 __name(isScalarField, "isScalarField");
 function isForeignKeyField(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  return !!fieldDef.foreignKeyFor;
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.foreignKeyFor;
 }
 __name(isForeignKeyField, "isForeignKeyField");
 function isRelationField(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  return !!fieldDef.relation;
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.relation;
 }
 __name(isRelationField, "isRelationField");
+function isInheritedField(schema, model, field) {
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.originModel;
+}
+__name(isInheritedField, "isInheritedField");
 function getUniqueFields(schema, model) {
   const modelDef = requireModel(schema, model);
   const result = [];
@@ -172,7 +281,7 @@ function buildFieldRef(schema, model, field, options, eb, modelAlias) {
       computer = computedFields?.[model]?.[field];
     }
     if (!computer) {
-      throw new QueryError(`Computed field "${field}" implementation not provided`);
+      throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
     }
     return computer(eb);
   }
@@ -277,13 +386,49 @@ function safeJSONStringify(value) {
   });
 }
 __name(safeJSONStringify, "safeJSONStringify");
+function extractIdFields(entity, schema, model) {
+  const idFields = getIdFields(schema, model);
+  return extractFields(entity, idFields);
+}
+__name(extractIdFields, "extractIdFields");
+function getDiscriminatorField(schema, model) {
+  const modelDef = requireModel(schema, model);
+  const delegateAttr = modelDef.attributes?.find((attr) => attr.name === "@@delegate");
+  if (!delegateAttr) {
+    return void 0;
+  }
+  const discriminator = delegateAttr.args?.find((arg) => arg.name === "discriminator");
+  if (!discriminator || !ExpressionUtils.isField(discriminator.value)) {
+    throw new InternalError(`Discriminator field not defined for model "${model}"`);
+  }
+  return discriminator.value.field;
+}
+__name(getDiscriminatorField, "getDiscriminatorField");
+function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */ new Set()) {
+  const subModels = Object.values(schema.models).filter((m) => m.baseModel === model);
+  subModels.forEach((def) => {
+    if (!collected.has(def)) {
+      collected.add(def);
+      getDelegateDescendantModels(schema, def.name, collected);
+    }
+  });
+  return [
+    ...collected
+  ];
+}
+__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";
-import { expressionBuilder as expressionBuilder2, sql as sql4 } from "kysely";
+import { invariant as invariant7, isPlainObject as isPlainObject3 } from "@zenstackhq/common-helpers";
+import { expressionBuilder as expressionBuilder3, sql as sql4 } from "kysely";
 import { nanoid } from "nanoid";
-import invariant7 from "tiny-invariant";
-import { match as match8 } from "ts-pattern";
+import { inspect } from "util";
+import { match as match9 } from "ts-pattern";
 import { ulid } from "ulid";
 import * as uuid from "uuid";
 
@@ -300,22 +445,44 @@ 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 invariant6 from "tiny-invariant";
-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 invariant2 from "tiny-invariant";
-import { match as match2 } from "ts-pattern";
+import { match as match3 } from "ts-pattern";
+
+// src/client/constants.ts
+var CONTEXT_COMMENT_PREFIX = "-- $$context:";
+var NUMERIC_FIELD_TYPES = [
+  "Int",
+  "Float",
+  "BigInt",
+  "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 { sql } from "kysely";
-import invariant from "tiny-invariant";
-import { match, P } from "ts-pattern";
+import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
+import { expressionBuilder, sql } from "kysely";
+import { match as match2, P } from "ts-pattern";
 
 // src/utils/enumerate.ts
 function enumerate(x) {
@@ -332,7 +499,6 @@ function enumerate(x) {
 __name(enumerate, "enumerate");
 
 // src/client/crud/dialects/base.ts
-import { isPlainObject } from "is-plain-object";
 var BaseCrudDialect = class {
   static {
     __name(this, "BaseCrudDialect");
@@ -343,9 +509,20 @@ var BaseCrudDialect = class {
     this.schema = schema;
     this.options = options;
   }
-  transformPrimitive(value, _type) {
+  transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
+  // #region common query builders
+  buildSelectModel(eb, model) {
+    const modelDef = requireModel(this.schema, model);
+    let result = eb.selectFrom(model);
+    let joinBase = modelDef.baseModel;
+    while (joinBase) {
+      result = this.buildDelegateJoin(model, joinBase, result);
+      joinBase = requireModel(this.schema, joinBase).baseModel;
+    }
+    return result;
+  }
   buildFilter(eb, model, modelAlias, where) {
     if (where === true || where === void 0) {
       return this.true(eb);
@@ -362,17 +539,20 @@ 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;
       }
       const fieldDef = requireField(this.schema, model, key);
       if (fieldDef.relation) {
         result = this.and(eb, result, this.buildRelationFilter(eb, model, modelAlias, key, fieldDef, payload));
-      } else if (fieldDef.array) {
-        result = this.and(eb, result, this.buildArrayFilter(eb, model, modelAlias, key, fieldDef, payload));
       } else {
-        result = this.and(eb, result, this.buildPrimitiveFilter(eb, model, modelAlias, key, fieldDef, payload));
+        const fieldRef = this.fieldRef(fieldDef.originModel ?? model, key, eb, fieldDef.originModel ?? modelAlias);
+        if (fieldDef.array) {
+          result = this.and(eb, result, this.buildArrayFilter(eb, fieldRef, fieldDef, payload));
+        } else {
+          result = this.and(eb, result, this.buildPrimitiveFilter(eb, fieldRef, fieldDef, payload));
+        }
       }
     }
     if ("$expr" in _where && typeof _where["$expr"] === "function") {
@@ -380,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) {
@@ -390,19 +573,26 @@ var BaseCrudDialect = class {
       return this.buildToManyRelationFilter(eb, model, modelAlias, field, fieldDef, payload);
     }
   }
-  buildToOneRelationFilter(eb, model, table, field, fieldDef, payload) {
+  buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (payload === null) {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, field);
-      if (ownedByModel) {
-        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${table}.${fk}`), "is", null)));
+      if (ownedByModel && !fieldDef.originModel) {
+        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${modelAlias}.${fk}`), "is", null)));
       } else {
-        return this.buildToOneRelationFilter(eb, model, table, field, fieldDef, {
+        return this.buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, {
           is: null
         });
       }
     }
-    const joinAlias = `${table}$${field}`;
-    const joinPairs = buildJoinPairs(this.schema, model, table, field, joinAlias);
+    const joinAlias = `${modelAlias}$${field}`;
+    const joinPairs = buildJoinPairs(
+      this.schema,
+      model,
+      // if field is from a base, use the base model to join
+      fieldDef.originModel ?? modelAlias,
+      field,
+      joinAlias
+    );
     const filterResultField = `${field}$filter`;
     const joinSelect = eb.selectFrom(`${fieldDef.type} as ${joinAlias}`).where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right))))).select(() => eb.fn.count(eb.lit(1)).as(filterResultField));
     const conditions = [];
@@ -463,30 +653,29 @@ var BaseCrudDialect = class {
       }
       switch (key) {
         case "some": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
           break;
         }
         case "every": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
           break;
         }
         case "none": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
           break;
         }
       }
     }
     return result;
   }
-  buildArrayFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildArrayFilter(eb, fieldRef, fieldDef, payload) {
     const clauses = [];
     const fieldType = fieldDef.type;
-    const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb, modelAlias);
     for (const [key, _value] of Object.entries(payload)) {
       if (_value === void 0) {
         continue;
       }
-      const value = this.transformPrimitive(_value, fieldType);
+      const value = this.transformPrimitive(_value, fieldType, !!fieldDef.array);
       switch (key) {
         case "equals": {
           clauses.push(this.buildLiteralFilter(eb, fieldRef, fieldType, eb.val(value)));
@@ -517,19 +706,23 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...clauses);
   }
-  buildPrimitiveFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildPrimitiveFilter(eb, fieldRef, fieldDef, payload) {
     if (payload === null) {
-      return eb(sql.ref(`${modelAlias}.${field}`), "is", null);
+      return eb(fieldRef, "is", null);
     }
     if (isEnum(this.schema, fieldDef.type)) {
-      return this.buildEnumFilter(eb, modelAlias, field, fieldDef, payload);
+      return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
     }
-    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, model, modelAlias, field, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, modelAlias, field, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, modelAlias, field, payload)).with("Bytes", () => this.buildBytesFilter(eb, modelAlias, field, payload)).exhaustive();
+    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`);
+    }).exhaustive();
   }
   buildLiteralFilter(eb, lhs, type, rhs) {
-    return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type) : rhs);
+    return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type, false) : rhs);
   }
-  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0) {
+  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
     if (payload === null || !isPlainObject(payload)) {
       return {
         conditions: [
@@ -544,8 +737,11 @@ var BaseCrudDialect = class {
       if (onlyForKeys && !onlyForKeys.includes(op)) {
         continue;
       }
+      if (excludeKeys.includes(op)) {
+        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);
@@ -559,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 {
@@ -576,24 +776,21 @@ var BaseCrudDialect = class {
       consumedKeys
     };
   }
-  buildStringFilter(eb, table, field, payload) {
-    const fieldDef = getField(this.schema, table, field);
-    let fieldRef = fieldDef?.computed ? sql.ref(field) : sql.ref(`${table}.${field}`);
-    let insensitive = false;
-    if (payload && typeof payload === "object" && "mode" in payload && payload.mode === "insensitive") {
-      insensitive = true;
-      fieldRef = eb.fn("lower", [
-        fieldRef
-      ]);
+  buildStringFilter(eb, fieldRef, payload) {
+    let mode;
+    if (payload && typeof payload === "object" && "mode" in payload) {
+      mode = payload.mode;
     }
-    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => this.prepStringCasing(eb, value, insensitive), (value) => this.buildStringFilter(eb, table, field, value));
+    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, mode === "insensitive" ? eb.fn("lower", [
+      fieldRef
+    ]) : fieldRef, (value) => this.prepStringCasing(eb, value, mode), (value) => this.buildStringFilter(eb, fieldRef, value));
     if (payload && typeof payload === "object") {
       for (const [key, value] of Object.entries(payload)) {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = match(key).with("contains", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`%${value}%`)) : eb(fieldRef, "like", sql.lit(`%${value}%`))).with("startsWith", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`${value}%`)) : eb(fieldRef, "like", sql.lit(`${value}%`))).with("endsWith", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`%${value}`)) : eb(fieldRef, "like", sql.lit(`%${value}`))).otherwise(() => {
-          throw new Error(`Invalid string filter key: ${key}`);
+        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) {
           conditions.push(condition);
@@ -602,34 +799,37 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...conditions);
   }
-  prepStringCasing(eb, value, toLower = true) {
+  prepStringCasing(eb, value, mode) {
+    if (!mode || mode === "default") {
+      return value === null ? value : sql.val(value);
+    }
     if (typeof value === "string") {
-      return toLower ? eb.fn("lower", [
-        sql.lit(value)
-      ]) : sql.lit(value);
+      return eb.fn("lower", [
+        sql.val(value)
+      ]);
     } else if (Array.isArray(value)) {
-      return value.map((v) => this.prepStringCasing(eb, v, toLower));
+      return value.map((v) => this.prepStringCasing(eb, v, mode));
     } else {
-      return value === null ? null : sql.lit(value);
+      return value === null ? null : sql.val(value);
     }
   }
-  buildNumberFilter(eb, model, table, field, type, payload) {
-    const { conditions } = this.buildStandardFilter(eb, type, payload, buildFieldRef(this.schema, model, field, this.options, eb), (value) => this.transformPrimitive(value, type), (value) => this.buildNumberFilter(eb, model, table, field, type, value));
+  buildNumberFilter(eb, fieldRef, type, payload) {
+    const { conditions } = this.buildStandardFilter(eb, type, payload, fieldRef, (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, fieldRef, type, value));
     return this.and(eb, ...conditions);
   }
-  buildBooleanFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean"), (value) => this.buildBooleanFilter(eb, table, field, value), true, [
+  buildBooleanFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, fieldRef, (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, fieldRef, value), true, [
       "equals",
       "not"
     ]);
     return this.and(eb, ...conditions);
   }
-  buildDateTimeFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime"), (value) => this.buildDateTimeFilter(eb, table, field, value), true);
+  buildDateTimeFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, fieldRef, (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, fieldRef, value), true);
     return this.and(eb, ...conditions);
   }
-  buildBytesFilter(eb, table, field, payload) {
-    const conditions = this.buildStandardFilter(eb, "Bytes", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes"), (value) => this.buildBytesFilter(eb, table, field, value), true, [
+  buildBytesFilter(eb, fieldRef, payload) {
+    const conditions = this.buildStandardFilter(eb, "Bytes", payload, fieldRef, (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, fieldRef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -637,8 +837,8 @@ var BaseCrudDialect = class {
     ]);
     return this.and(eb, ...conditions.conditions);
   }
-  buildEnumFilter(eb, table, field, fieldDef, payload) {
-    const conditions = this.buildStandardFilter(eb, "String", payload, sql.ref(`${table}.${field}`), (value) => value, (value) => this.buildEnumFilter(eb, table, field, fieldDef, value), true, [
+  buildEnumFilter(eb, fieldRef, fieldDef, payload) {
+    const conditions = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => value, (value) => this.buildEnumFilter(eb, fieldRef, fieldDef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -670,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, this.fieldRef(model, k, eb, modelAlias), field), sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -681,7 +879,7 @@ var BaseCrudDialect = class {
             invariant(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             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.count(sql.ref(k)), sql.raw(this.negateSort(v, negated)));
+              result = result.orderBy((eb) => eb.fn.count(this.fieldRef(model, k, eb, modelAlias)), sql.raw(this.negateSort(v, negated)));
             }
             continue;
           }
@@ -690,10 +888,11 @@ var BaseCrudDialect = class {
         }
         const fieldDef = requireField(this.schema, model, field);
         if (!fieldDef.relation) {
+          const fieldRef = this.fieldRef(model, field, expressionBuilder(), modelAlias);
           if (value === "asc" || value === "desc") {
-            result = result.orderBy(sql.ref(`${modelAlias}.${field}`), this.negateSort(value, negated));
+            result = result.orderBy(fieldRef, this.negateSort(value, negated));
           } else if (value && typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) {
-            result = result.orderBy(sql.ref(`${modelAlias}.${field}`), sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
+            result = result.orderBy(fieldRef, sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
           }
         } else {
           const relationModel = fieldDef.type;
@@ -705,7 +904,7 @@ var BaseCrudDialect = class {
               invariant(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
               const sort = this.negateSort(value._count, negated);
               result = result.orderBy((eb) => {
-                let subQuery = eb.selectFrom(relationModel);
+                let subQuery = this.buildSelectModel(eb, relationModel);
                 const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
                 subQuery = subQuery.where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right)))));
                 subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
@@ -724,14 +923,90 @@ var BaseCrudDialect = class {
     });
     return result;
   }
+  buildSelectAllFields(model, query, omit) {
+    const modelDef = requireModel(this.schema, model);
+    let result = query;
+    for (const field of Object.keys(modelDef.fields)) {
+      if (isRelationField(this.schema, model, field)) {
+        continue;
+      }
+      if (omit?.[field] === true) {
+        continue;
+      }
+      result = this.buildSelectField(result, model, model, field);
+    }
+    const descendants = getDelegateDescendantModels(this.schema, model);
+    for (const subModel of descendants) {
+      result = this.buildDelegateJoin(model, subModel.name, result);
+      result = result.select((eb) => {
+        const jsonObject = {};
+        for (const field of Object.keys(subModel.fields)) {
+          if (isRelationField(this.schema, subModel.name, field) || isInheritedField(this.schema, subModel.name, field)) {
+            continue;
+          }
+          jsonObject[field] = eb.ref(`${subModel.name}.${field}`);
+        }
+        return this.buildJsonObject(eb, jsonObject).as(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`);
+      });
+    }
+    return result;
+  }
+  buildSelectField(query, model, modelAlias, field) {
+    const fieldDef = requireField(this.schema, model, field);
+    if (fieldDef.computed) {
+      return query.select((eb) => this.fieldRef(model, field, eb, modelAlias).as(field));
+    } else if (!fieldDef.originModel) {
+      return query.select(sql.ref(`${modelAlias}.${field}`).as(field));
+    } else {
+      return this.buildSelectField(query, fieldDef.originModel, fieldDef.originModel, field);
+    }
+  }
+  buildDelegateJoin(thisModel, otherModel, query) {
+    const idFields = getIdFields(this.schema, thisModel);
+    query = query.leftJoin(otherModel, (qb) => {
+      for (const idField of idFields) {
+        qb = qb.onRef(`${thisModel}.${idField}`, "=", `${otherModel}.${idField}`);
+      }
+      return qb;
+    });
+    return query;
+  }
+  buildCountJson(model, eb, parentAlias, payload) {
+    const modelDef = requireModel(this.schema, model);
+    const toManyRelations = Object.entries(modelDef.fields).filter(([, field]) => field.relation && field.array);
+    const selections = payload === true ? {
+      select: toManyRelations.reduce((acc, [field]) => {
+        acc[field] = true;
+        return acc;
+      }, {})
+    } : payload;
+    const jsonObject = {};
+    for (const [field, value] of Object.entries(selections.select)) {
+      const fieldDef = requireField(this.schema, model, field);
+      const fieldModel = fieldDef.type;
+      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
+      let fieldCountQuery = eb.selectFrom(fieldModel).select(eb.fn.countAll().as(`_count$${field}`));
+      for (const [left, right] of joinPairs) {
+        fieldCountQuery = fieldCountQuery.whereRef(left, "=", right);
+      }
+      if (value && typeof value === "object" && "where" in value && value.where && typeof value.where === "object") {
+        const filter = this.buildFilter(eb, fieldModel, fieldModel, value.where);
+        fieldCountQuery = fieldCountQuery.where(filter);
+      }
+      jsonObject[field] = fieldCountQuery;
+    }
+    return this.buildJsonObject(eb, jsonObject);
+  }
+  // #endregion
+  // #region utils
   negateSort(sort, negated) {
     return negated ? sort === "asc" ? "desc" : "asc" : sort;
   }
   true(eb) {
-    return eb.lit(this.transformPrimitive(true, "Boolean"));
+    return eb.lit(this.transformPrimitive(true, "Boolean", false));
   }
   false(eb) {
-    return eb.lit(this.transformPrimitive(false, "Boolean"));
+    return eb.lit(this.transformPrimitive(false, "Boolean", false));
   }
   isTrue(expression) {
     const node = expression.toOperationNode();
@@ -770,6 +1045,9 @@ var BaseCrudDialect = class {
   not(eb, ...args) {
     return eb.not(this.and(eb, ...args));
   }
+  fieldRef(model, field, eb, modelAlias) {
+    return buildFieldRef(this.schema, model, field, this.options, eb, modelAlias);
+  }
 };
 
 // src/client/crud/dialects/postgresql.ts
@@ -780,14 +1058,18 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   get provider() {
     return "postgresql";
   }
-  transformPrimitive(value, type) {
+  transformPrimitive(value, type, forArrayField) {
     if (value === void 0) {
       return value;
     }
     if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type));
+      if (type === "Json" && !forArrayField) {
+        return JSON.stringify(value);
+      } else {
+        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).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) {
@@ -801,7 +1083,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       const joinTableName = `${parentName}$${relationField}`;
       let result = eb.selectFrom(`${relationModel} as ${joinTableName}`);
       result = eb.selectFrom(() => {
-        let subQuery = eb.selectFrom(`${relationModel}`).selectAll();
+        let subQuery = this.buildSelectModel(eb, relationModel);
+        subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
         if (payload && typeof payload === "object") {
           if (payload.where) {
             subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -845,34 +1128,57 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     });
     return qb;
   }
-  buildRelationObjectArgs(relationModel, relationField, eb, payload, parentName) {
+  buildRelationObjectArgs(relationModel, relationField, eb, payload, parentAlias) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
+    const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+    if (descendantModels.length > 0) {
+      objArgs.push(...descendantModels.map((subModel) => [
+        sql2.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+        eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+      ]).flatMap((v) => v));
+    }
     if (payload === true || !payload.select) {
       objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
         sql2.lit(field),
-        buildFieldRef(this.schema, relationModel, field, this.options, eb)
+        this.fieldRef(relationModel, field, eb)
       ]).flatMap((v) => v));
     } else if (payload.select) {
-      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field]) => [
-        sql2.lit(field),
-        buildFieldRef(this.schema, relationModel, field, this.options, eb)
-      ]).flatMap((v) => v));
+      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
+        if (field === "_count") {
+          const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
+          return [
+            sql2.lit(field),
+            subJson
+          ];
+        } else {
+          const fieldDef = requireField(this.schema, relationModel, field);
+          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : this.fieldRef(relationModel, field, eb);
+          return [
+            sql2.lit(field),
+            fieldValue
+          ];
+        }
+      }).flatMap((v) => v));
     }
     if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
       objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => [
         sql2.lit(field),
-        eb.ref(`${parentName}$${relationField}$${field}.$j`)
+        // reference the synthesized JSON field
+        eb.ref(`${parentAlias}$${relationField}$${field}.$j`)
       ]).flatMap((v) => v));
     }
     return objArgs;
   }
-  buildRelationJoins(model, relationField, qb, payload, parentName) {
+  buildRelationJoins(relationModel, relationField, qb, payload, parentName) {
     let result = qb;
-    if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
-      Object.entries(payload.include).filter(([, value]) => value).forEach(([field, value]) => {
-        result = this.buildRelationJSON(model, result, field, `${parentName}$${relationField}`, value);
-      });
+    if (typeof payload === "object") {
+      const selectInclude = payload.include ?? payload.select;
+      if (selectInclude && typeof selectInclude === "object") {
+        Object.entries(selectInclude).filter(([, value]) => value).filter(([field]) => isRelationField(this.schema, relationModel, field)).forEach(([field, value]) => {
+          result = this.buildRelationJSON(relationModel, result, field, `${parentName}$${relationField}`, value);
+        });
+      }
     }
     return result;
   }
@@ -912,12 +1218,15 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       return `ARRAY[${values.map((v) => typeof v === "string" ? `'${v}'` : v)}]`;
     }
   }
+  get supportInsertWithDefault() {
+    return true;
+  }
 };
 
 // src/client/crud/dialects/sqlite.ts
+import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import { sql as sql3 } from "kysely";
-import invariant3 from "tiny-invariant";
-import { match as match3 } from "ts-pattern";
+import { match as match4 } from "ts-pattern";
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -925,26 +1234,31 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   get provider() {
     return "sqlite";
   }
-  transformPrimitive(value, type) {
+  transformPrimitive(value, type, _forArrayField) {
     if (value === void 0) {
       return value;
     }
     if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type));
+      return value.map((v) => this.transformPrimitive(v, type, false));
     } 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)).otherwise(() => value);
+      if (this.schema.typeDefs && type in this.schema.typeDefs) {
+        return JSON.stringify(value);
+      } else {
+        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);
+      }
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
     return query.select((eb) => this.buildRelationJSON(model, eb, relationField, parentAlias, payload).as(relationField));
   }
-  buildRelationJSON(model, eb, relationField, parentName, payload) {
+  buildRelationJSON(model, eb, relationField, parentAlias, payload) {
     const relationFieldDef = requireField(this.schema, model, relationField);
     const relationModel = relationFieldDef.type;
     const relationModelDef = requireModel(this.schema, relationModel);
-    const subQueryName = `${parentName}$${relationField}`;
+    const subQueryName = `${parentAlias}$${relationField}`;
     let tbl = eb.selectFrom(() => {
-      let subQuery = eb.selectFrom(relationModel).selectAll();
+      let subQuery = this.buildSelectModel(eb, relationModel);
+      subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
       if (payload && typeof payload === "object") {
         if (payload.where) {
           subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -965,14 +1279,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         const relationIds = getIdFields(this.schema, relationModel);
         invariant3(parentIds.length === 1, "many-to-many relation must have exactly one id field");
         invariant3(relationIds.length === 1, "many-to-many relation must have exactly one id field");
-        subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
+        subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
       } else {
         const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
         keyPairs.forEach(({ fk, pk }) => {
           if (ownedByModel) {
-            subQuery = subQuery.whereRef(`${relationModel}.${pk}`, "=", `${parentName}.${fk}`);
+            subQuery = subQuery.whereRef(`${relationModel}.${pk}`, "=", `${parentAlias}.${fk}`);
           } else {
-            subQuery = subQuery.whereRef(`${relationModel}.${fk}`, "=", `${parentName}.${pk}`);
+            subQuery = subQuery.whereRef(`${relationModel}.${fk}`, "=", `${parentAlias}.${pk}`);
           }
         });
       }
@@ -980,167 +1294,106 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     });
     tbl = tbl.select(() => {
       const objArgs = [];
+      const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+      if (descendantModels.length > 0) {
+        objArgs.push(...descendantModels.map((subModel) => [
+          sql3.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+          eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+        ]).flatMap((v) => v));
+      }
       if (payload === true || !payload.select) {
         objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
           sql3.lit(field),
-          buildFieldRef(this.schema, relationModel, field, this.options, eb)
+          this.fieldRef(relationModel, field, eb)
         ]).flatMap((v) => v));
       } else if (payload.select) {
         objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
-          const fieldDef = requireField(this.schema, relationModel, field);
-          if (fieldDef.relation) {
-            const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentName}$${relationField}`, value);
+          if (field === "_count") {
+            const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
             return [
               sql3.lit(field),
               subJson
             ];
           } else {
-            return [
-              sql3.lit(field),
-              buildFieldRef(this.schema, relationModel, field, this.options, eb)
-            ];
+            const fieldDef = requireField(this.schema, relationModel, field);
+            if (fieldDef.relation) {
+              const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
+              return [
+                sql3.lit(field),
+                subJson
+              ];
+            } else {
+              return [
+                sql3.lit(field),
+                this.fieldRef(relationModel, field, eb)
+              ];
+            }
           }
         }).flatMap((v) => v));
       }
       if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
         objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field, value]) => {
-          const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentName}$${relationField}`, value);
+          const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
           return [
             sql3.lit(field),
             subJson
           ];
         }).flatMap((v) => v));
       }
-      if (relationFieldDef.array) {
-        return eb.fn.coalesce(sql3`json_group_array(json_object(${sql3.join(objArgs)}))`, sql3`json_array()`).as("$j");
-      } else {
-        return sql3`json_object(${sql3.join(objArgs)})`.as("data");
-      }
-    });
-    return tbl;
-  }
-  buildSkipTake(query, skip, take) {
-    if (take !== void 0) {
-      query = query.limit(take);
-    }
-    if (skip !== void 0) {
-      query = query.offset(skip);
-      if (take === void 0) {
-        query = query.limit(-1);
-      }
-    }
-    return query;
-  }
-  buildJsonObject(eb, value) {
-    return eb.fn("json_object", Object.entries(value).flatMap(([key, value2]) => [
-      sql3.lit(key),
-      value2
-    ]));
-  }
-  get supportsUpdateWithLimit() {
-    return false;
-  }
-  get supportsDeleteWithLimit() {
-    return false;
-  }
-  get supportsDistinctOn() {
-    return false;
-  }
-  buildArrayLength(eb, array) {
-    return eb.fn("json_array_length", [
-      array
-    ]);
-  }
-  buildArrayLiteralSQL(_values) {
-    throw new Error("SQLite does not support array literals");
-  }
-};
-
-// 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();
-}
-__name(getCrudDialect, "getCrudDialect");
-
-// src/schema/expression.ts
-var ExpressionUtils = {
-  literal: /* @__PURE__ */ __name((value) => {
-    return {
-      kind: "literal",
-      value
-    };
-  }, "literal"),
-  array: /* @__PURE__ */ __name((items) => {
-    return {
-      kind: "array",
-      items
-    };
-  }, "array"),
-  call: /* @__PURE__ */ __name((functionName, args) => {
-    return {
-      kind: "call",
-      function: functionName,
-      args
-    };
-  }, "call"),
-  binary: /* @__PURE__ */ __name((left, op, right) => {
-    return {
-      kind: "binary",
-      op,
-      left,
-      right
-    };
-  }, "binary"),
-  unary: /* @__PURE__ */ __name((op, operand) => {
-    return {
-      kind: "unary",
-      op,
-      operand
-    };
-  }, "unary"),
-  field: /* @__PURE__ */ __name((field) => {
-    return {
-      kind: "field",
-      field
-    };
-  }, "field"),
-  member: /* @__PURE__ */ __name((receiver, members) => {
-    return {
-      kind: "member",
-      receiver,
-      members
-    };
-  }, "member"),
-  _this: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "this"
-    };
-  }, "_this"),
-  _null: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "null"
-    };
-  }, "_null"),
-  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
-  }, "and"),
-  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
-  }, "or"),
-  is: /* @__PURE__ */ __name((value, kind) => {
-    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
-  }, "is"),
-  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
-  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
-  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
-  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
-  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
-  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
-  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
-  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
-  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
+      if (relationFieldDef.array) {
+        return eb.fn.coalesce(sql3`json_group_array(json_object(${sql3.join(objArgs)}))`, sql3`json_array()`).as("$j");
+      } else {
+        return sql3`json_object(${sql3.join(objArgs)})`.as("data");
+      }
+    });
+    return tbl;
+  }
+  buildSkipTake(query, skip, take) {
+    if (take !== void 0) {
+      query = query.limit(take);
+    }
+    if (skip !== void 0) {
+      query = query.offset(skip);
+      if (take === void 0) {
+        query = query.limit(-1);
+      }
+    }
+    return query;
+  }
+  buildJsonObject(eb, value) {
+    return eb.fn("json_object", Object.entries(value).flatMap(([key, value2]) => [
+      sql3.lit(key),
+      value2
+    ]));
+  }
+  get supportsUpdateWithLimit() {
+    return false;
+  }
+  get supportsDeleteWithLimit() {
+    return false;
+  }
+  get supportsDistinctOn() {
+    return false;
+  }
+  buildArrayLength(eb, array) {
+    return eb.fn("json_array_length", [
+      array
+    ]);
+  }
+  buildArrayLiteralSQL(_values) {
+    throw new Error("SQLite does not support array literals");
+  }
+  get supportInsertWithDefault() {
+    return false;
+  }
 };
 
+// src/client/crud/dialects/index.ts
+function getCrudDialect(schema, options) {
+  return match5(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
+}
+__name(getCrudDialect, "getCrudDialect");
+
 // src/utils/default-operation-node-visitor.ts
 import { OperationNodeVisitor } from "kysely";
 var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
@@ -1460,19 +1713,19 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 };
 
 // src/plugins/policy/expression-transformer.ts
-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 invariant5 from "tiny-invariant";
-import { match as match6 } from "ts-pattern";
+import { invariant as invariant5 } from "@zenstackhq/common-helpers";
+import { AliasNode as AliasNode2, BinaryOperationNode as BinaryOperationNode2, ColumnNode, expressionBuilder as expressionBuilder2, 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 match7 } from "ts-pattern";
 
 // src/plugins/policy/expression-evaluator.ts
-import invariant4 from "tiny-invariant";
-import { match as match5 } from "ts-pattern";
+import { invariant as invariant4 } from "@zenstackhq/common-helpers";
+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) {
@@ -1483,7 +1736,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);
@@ -1507,7 +1760,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);
@@ -1521,7 +1774,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, {
@@ -1537,11 +1790,11 @@ var ExpressionEvaluator = class {
 // src/plugins/policy/utils.ts
 import { AliasNode, AndNode, BinaryOperationNode, FunctionNode, OperatorNode, OrNode, ParensNode, ReferenceNode, TableNode, UnaryOperationNode, ValueNode } from "kysely";
 function trueNode(dialect) {
-  return ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean"));
+  return ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean", false));
 }
 __name(trueNode, "trueNode");
 function falseNode(dialect) {
-  return ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean"));
+  return ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean", false));
 }
 __name(falseNode, "falseNode");
 function isTrueNode(node) {
@@ -1775,7 +2028,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"))),
@@ -1799,14 +2052,14 @@ var ExpressionTransformer = class {
     }
   }
   transformValue(value, type) {
-    return ValueNode2.create(this.dialect.transformPrimitive(value, type) ?? null);
+    return ValueNode2.create(this.dialect.transformPrimitive(value, type, false) ?? null);
   }
   _unary(expr2, context) {
     invariant5(expr2.op === "!", 'only "!" operator is supported');
     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) {
@@ -1818,7 +2071,7 @@ var ExpressionTransformer = class {
     if (!func) {
       throw new QueryError(`Function not implemented: ${expr2.function}`);
     }
-    const eb = expressionBuilder();
+    const eb = expressionBuilder2();
     return func(eb, (expr2.args ?? []).map((arg) => this.transformCallArg(eb, arg, context)), {
       dialect: this.dialect,
       model: context.model,
@@ -2042,7 +2295,7 @@ var PolicyHandler = class extends OperationNodeTransformer {
   get kysely() {
     return this.client.$qb;
   }
-  async handle(node, proceed, transaction) {
+  async handle(node, proceed) {
     if (!this.isCrudQueryNode(node)) {
       throw new RejectedByPolicyError(void 0, "non-CRUD queries are not allowed");
     }
@@ -2062,27 +2315,20 @@ var PolicyHandler = class extends OperationNodeTransformer {
     if (!mutationRequiresTransaction && !node.returning) {
       return proceed(this.transformNode(node));
     }
-    let readBackError = false;
-    const result = await transaction(async (txProceed) => {
-      if (InsertQueryNode.is(node)) {
-        await this.enforcePreCreatePolicy(node, txProceed);
-      }
-      const transformedNode = this.transformNode(node);
-      const result2 = await txProceed(transformedNode);
-      if (!this.onlyReturningId(node)) {
-        const readBackResult = await this.processReadBack(node, result2, txProceed);
-        if (readBackResult.rows.length !== result2.rows.length) {
-          readBackError = true;
-        }
-        return readBackResult;
-      } else {
-        return result2;
+    if (InsertQueryNode.is(node)) {
+      await this.enforcePreCreatePolicy(node, proceed);
+    }
+    const transformedNode = this.transformNode(node);
+    const result = await proceed(transformedNode);
+    if (!this.onlyReturningId(node)) {
+      const readBackResult = await this.processReadBack(node, result, proceed);
+      if (readBackResult.rows.length !== result.rows.length) {
+        throw new RejectedByPolicyError(mutationModel, "result is not allowed to be read back");
       }
-    });
-    if (readBackError) {
-      throw new RejectedByPolicyError(mutationModel, "result is not allowed to be read back");
+      return readBackResult;
+    } else {
+      return result;
     }
-    return result;
   }
   onlyReturningId(node) {
     if (!node.returning) {
@@ -2143,11 +2389,11 @@ var PolicyHandler = class extends OperationNodeTransformer {
       if (typeof item === "object" && item && "kind" in item) {
         invariant6(item.kind === "ValueNode", "expecting a ValueNode");
         result.push({
-          node: ValueNode3.create(this.dialect.transformPrimitive(item.value, fieldDef.type)),
+          node: ValueNode3.create(this.dialect.transformPrimitive(item.value, fieldDef.type, !!fieldDef.array)),
           raw: item.value
         });
       } else {
-        const value = this.dialect.transformPrimitive(item, fieldDef.type);
+        const value = this.dialect.transformPrimitive(item, fieldDef.type, !!fieldDef.array);
         if (Array.isArray(value)) {
           result.push({
             node: RawNode.createWithSql(this.dialect.buildArrayLiteralSQL(value)),
@@ -2216,7 +2462,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");
       }
@@ -2378,14 +2624,23 @@ var PolicyPlugin = class {
   get description() {
     return "Enforces access policies defined in the schema.";
   }
-  onKyselyQuery({ query, client, proceed, transaction }) {
+  onKyselyQuery({
+    query,
+    client,
+    proceed
+    /*, transaction*/
+  }) {
     const handler = new PolicyHandler(client);
-    return handler.handle(query, proceed, transaction);
+    return handler.handle(
+      query,
+      proceed
+      /*, transaction*/
+    );
   }
 };
 
 // src/utils/clone.ts
-import { isPlainObject as isPlainObject2 } from "is-plain-object";
+import { isPlainObject as isPlainObject2 } from "@zenstackhq/common-helpers";
 function clone(value) {
   if (Array.isArray(value)) {
     return value.map((v) => clone(v));
@@ -2404,28 +2659,6 @@ function clone(value) {
 }
 __name(clone, "clone");
 
-// 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/constants.ts
-var CONTEXT_COMMENT_PREFIX = "-- $$context:";
-var NUMERIC_FIELD_TYPES = [
-  "Int",
-  "Float",
-  "BigInt",
-  "Decimal"
-];
-
 // src/client/crud/operations/base.ts
 var BaseOperationHandler = class {
   static {
@@ -2469,17 +2702,17 @@ var BaseOperationHandler = class {
   getField(model, field) {
     return getField(this.schema, model, field);
   }
-  exists(kysely, model, filter) {
+  async exists(kysely, model, filter) {
     const idFields = getIdFields(this.schema, model);
     const _filter = flattenCompoundUniqueFilters(this.schema, model, filter);
     const query = kysely.selectFrom(model).where((eb) => eb.and(_filter)).select(idFields.map((f) => kysely.dynamic.ref(f))).limit(1).modifyEnd(this.makeContextComment({
       model,
       operation: "read"
     }));
-    return query.executeTakeFirst();
+    return this.executeQueryTakeFirst(kysely, query, "exists");
   }
   async read(kysely, model, args) {
-    let query = kysely.selectFrom(model);
+    let query = this.dialect.buildSelectModel(expressionBuilder3(), model);
     if (args?.where) {
       query = query.where((eb) => this.dialect.buildFilter(eb, model, model, args?.where));
     }
@@ -2499,15 +2732,16 @@ var BaseOperationHandler = class {
         query = query.distinctOn(distinct.map((f) => sql4.ref(`${model}.${f}`)));
       } else {
         inMemoryDistinct = distinct;
+        query = distinct.reduce((acc, field) => acc.select((eb) => this.dialect.fieldRef(model, field, eb).as(`$distinct$${field}`)), query);
       }
     }
-    if (args?.select) {
-      query = this.buildFieldSelection(model, query, args?.select, model);
+    if (args && "select" in args && args.select) {
+      query = this.buildFieldSelection(model, query, args.select, model);
     } else {
-      query = this.buildSelectAllScalarFields(model, query, args?.omit);
+      query = this.dialect.buildSelectAllFields(model, query, args?.omit);
     }
-    if (args?.include) {
-      query = this.buildFieldSelection(model, query, args?.include, model);
+    if (args && "include" in args && args.include) {
+      query = this.buildFieldSelection(model, query, args.include, model);
     }
     if (args?.cursor) {
       query = this.buildCursorFilter(model, query, args.cursor, args.orderBy, negateOrderBy);
@@ -2517,23 +2751,35 @@ var BaseOperationHandler = class {
       operation: "read"
     }));
     let result = [];
+    const queryId = {
+      queryId: `zenstack-${createId()}`
+    };
+    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), queryId);
     try {
-      result = await query.execute();
+      const r = await kysely.getExecutor().executeQuery(compiled, queryId);
+      result = r.rows;
     } catch (err) {
-      const { sql: sql10, parameters } = query.compile();
-      throw new QueryError(`Failed to execute query: ${err}, sql: ${sql10}, parameters: ${parameters}`);
+      let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
+      if (this.options.debug) {
+        message += `, parameters: 
+${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
     if (inMemoryDistinct) {
       const distinctResult = [];
       const seen = /* @__PURE__ */ new Set();
       for (const r of result) {
-        const key = safeJSONStringify(inMemoryDistinct.map((f) => r[f]));
+        const key = safeJSONStringify(inMemoryDistinct.map((f) => r[`$distinct$${f}`]));
         if (!seen.has(key)) {
           distinctResult.push(r);
           seen.add(key);
         }
       }
       result = distinctResult;
+      for (const r of result) {
+        Object.keys(r).filter((k) => k.startsWith("$distinct$")).forEach((k) => delete r[k]);
+      }
     }
     return result;
   }
@@ -2556,72 +2802,29 @@ var BaseOperationHandler = class {
       }
       const fieldDef = this.requireField(model, field);
       if (!fieldDef.relation) {
-        result = this.selectField(result, model, parentAlias, field);
+        result = this.dialect.buildSelectField(result, model, parentAlias, field);
       } else {
         if (!fieldDef.array && !fieldDef.optional && payload.where) {
           throw new QueryError(`Field "${field}" doesn't support filtering`);
         }
-        result = this.dialect.buildRelationSelection(result, model, field, parentAlias, payload);
+        if (fieldDef.originModel) {
+          result = this.dialect.buildRelationSelection(result, fieldDef.originModel, field, fieldDef.originModel, payload);
+        } else {
+          result = this.dialect.buildRelationSelection(result, model, field, parentAlias, payload);
+        }
       }
     }
     return result;
   }
   buildCountSelection(query, model, parentAlias, payload) {
-    const modelDef = requireModel(this.schema, model);
-    const toManyRelations = Object.entries(modelDef.fields).filter(([, field]) => field.relation && field.array);
-    const selections = payload === true ? {
-      select: toManyRelations.reduce((acc, [field]) => {
-        acc[field] = true;
-        return acc;
-      }, {})
-    } : payload;
-    const eb = expressionBuilder2();
-    const jsonObject = {};
-    for (const [field, value] of Object.entries(selections.select)) {
-      const fieldDef = requireField(this.schema, model, field);
-      const fieldModel = fieldDef.type;
-      const jointTable = `${parentAlias}$${field}$count`;
-      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, jointTable);
-      query = query.leftJoin((eb2) => {
-        let result = eb2.selectFrom(fieldModel).selectAll();
-        if (value && typeof value === "object" && "where" in value && value.where && typeof value.where === "object") {
-          const filter = this.dialect.buildFilter(eb2, fieldModel, fieldModel, value.where);
-          result = result.where(filter);
-        }
-        return result.as(jointTable);
-      }, (join) => {
-        for (const [left, right] of joinPairs) {
-          join = join.onRef(left, "=", right);
-        }
-        return join;
-      });
-      jsonObject[field] = this.countIdDistinct(eb, fieldDef.type, jointTable);
-    }
-    query = query.select((eb2) => this.dialect.buildJsonObject(eb2, jsonObject).as("_count"));
-    return query;
-  }
-  countIdDistinct(eb, model, table) {
-    const idFields = getIdFields(this.schema, model);
-    return eb.fn.count(sql4.join(idFields.map((f) => sql4.ref(`${table}.${f}`)))).distinct();
-  }
-  buildSelectAllScalarFields(model, query, omit) {
-    const modelDef = this.requireModel(model);
-    return Object.keys(modelDef.fields).filter((f) => !isRelationField(this.schema, model, f)).filter((f) => omit?.[f] !== true).reduce((acc, f) => this.selectField(acc, model, model, f), query);
-  }
-  selectField(query, model, modelAlias, field) {
-    const fieldDef = this.requireField(model, field);
-    if (!fieldDef.computed) {
-      return query.select(sql4.ref(`${modelAlias}.${field}`).as(field));
-    } else {
-      return query.select((eb) => buildFieldRef(this.schema, model, field, this.options, eb).as(field));
-    }
+    return query.select((eb) => this.dialect.buildCountJson(model, eb, parentAlias, payload).as("_count"));
   }
   buildCursorFilter(model, query, cursor, orderBy, negateOrderBy) {
     if (!orderBy) {
       orderBy = makeDefaultOrderBy(this.schema, model);
     }
     const orderByItems = ensureArray(orderBy).flatMap((obj) => Object.entries(obj));
-    const eb = expressionBuilder2();
+    const eb = expressionBuilder3();
     const cursorFilter = this.dialect.buildFilter(eb, model, model, cursor);
     let result = query;
     const filters = [];
@@ -2638,9 +2841,12 @@ var BaseOperationHandler = class {
     result = result.where((eb2) => eb2.or(filters));
     return result;
   }
-  async create(kysely, model, data, fromRelation) {
+  async create(kysely, model, data, fromRelation, creatingForDelegate = false) {
     const modelDef = this.requireModel(model);
-    const createFields = {};
+    if (modelDef.isDelegate && !creatingForDelegate) {
+      throw new QueryError(`Model "${this.model}" is a delegate and cannot be created directly.`);
+    }
+    let createFields = {};
     let parentUpdateTask = void 0;
     let m2m = void 0;
     if (fromRelation) {
@@ -2659,7 +2865,7 @@ var BaseOperationHandler = class {
               model: fromRelation.model,
               operation: "update"
             }));
-            return query2.execute();
+            return this.executeQuery(kysely, query2, "update");
           }, "parentUpdateTask");
         }
       }
@@ -2669,14 +2875,14 @@ var BaseOperationHandler = class {
       const fieldDef = this.requireField(model, field);
       if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) {
         if (fieldDef.array && value && typeof value === "object" && "set" in value && Array.isArray(value.set)) {
-          createFields[field] = this.dialect.transformPrimitive(value.set, fieldDef.type);
+          createFields[field] = this.dialect.transformPrimitive(value.set, fieldDef.type, true);
         } else {
-          createFields[field] = this.dialect.transformPrimitive(value, fieldDef.type);
+          createFields[field] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
         }
       } else {
         const subM2M = getManyToManyRelation(this.schema, model, field);
         if (!subM2M && fieldDef.relation?.fields && fieldDef.relation?.references) {
-          const fkValues = await this.processOwnedRelation(kysely, fieldDef, value);
+          const fkValues = await this.processOwnedRelationForCreate(kysely, fieldDef, value);
           for (let i = 0; i < fieldDef.relation.fields.length; i++) {
             createFields[fieldDef.relation.fields[i]] = fkValues[fieldDef.relation.references[i]];
           }
@@ -2688,16 +2894,20 @@ var BaseOperationHandler = class {
         }
       }
     }
+    if (modelDef.baseModel) {
+      const baseCreateResult = await this.processBaseModelCreate(kysely, modelDef.baseModel, createFields, model);
+      createFields = baseCreateResult.remainingFields;
+    }
     const updatedData = this.fillGeneratedValues(modelDef, createFields);
     const idFields = getIdFields(this.schema, model);
-    const query = kysely.insertInto(model).values(updatedData).returning(idFields).modifyEnd(this.makeContextComment({
+    const query = kysely.insertInto(model).$if(Object.keys(updatedData).length === 0, (qb) => qb.defaultValues()).$if(Object.keys(updatedData).length > 0, (qb) => qb.values(updatedData)).returning(idFields).modifyEnd(this.makeContextComment({
       model,
       operation: "create"
     }));
-    const createdEntity = await query.executeTakeFirst();
+    const createdEntity = await this.executeQueryTakeFirst(kysely, query, "create");
     if (Object.keys(postCreateRelations).length > 0) {
       const relationPromises = Object.entries(postCreateRelations).map(([field, subPayload]) => {
-        return this.processNoneOwnedRelation(kysely, model, field, subPayload, createdEntity);
+        return this.processNoneOwnedRelationForCreate(kysely, model, field, subPayload, createdEntity);
       });
       await Promise.all(relationPromises);
     }
@@ -2709,6 +2919,28 @@ var BaseOperationHandler = class {
     }
     return createdEntity;
   }
+  async processBaseModelCreate(kysely, model, createFields, forModel) {
+    const thisCreateFields = {};
+    const remainingFields = {};
+    Object.entries(createFields).forEach(([field, value]) => {
+      const fieldDef = this.getField(model, field);
+      if (fieldDef) {
+        thisCreateFields[field] = value;
+      } else {
+        remainingFields[field] = value;
+      }
+    });
+    const discriminatorField = getDiscriminatorField(this.schema, model);
+    invariant7(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    thisCreateFields[discriminatorField] = forModel;
+    const baseEntity = await this.create(kysely, model, thisCreateFields, void 0, true);
+    const idValues = extractIdFields(baseEntity, this.schema, model);
+    Object.assign(remainingFields, idValues);
+    return {
+      baseEntity,
+      remainingFields
+    };
+  }
   buildFkAssignments(model, relationField, entity) {
     const parentFkFields = {};
     invariant7(relationField, "parentField must be defined if parentModel is defined");
@@ -2751,7 +2983,7 @@ var BaseOperationHandler = class {
       ]).doNothing()).execute();
       return result[0];
     } else {
-      const eb = expressionBuilder2();
+      const eb = expressionBuilder3();
       const result = await kysely.deleteFrom(joinTable).where(eb(`${joinTable}.A`, "=", sortedRecords[0].entity[firstIds[0]])).where(eb(`${joinTable}.B`, "=", sortedRecords[1].entity[secondIds[0]])).execute();
       return result[0];
     }
@@ -2761,10 +2993,10 @@ var BaseOperationHandler = class {
     const parentId = Object.values(parentIds)[0];
     const m2m = getManyToManyRelation(this.schema, model, field);
     invariant7(m2m, "not a many-to-many relation");
-    const eb = expressionBuilder2();
+    const eb = expressionBuilder3();
     return kysely.deleteFrom(m2m.joinTable).where(eb(`${m2m.joinTable}.${m2m.parentFkName}`, "=", parentId)).execute();
   }
-  async processOwnedRelation(kysely, relationField, payload) {
+  async processOwnedRelationForCreate(kysely, relationField, payload) {
     if (!payload) {
       return;
     }
@@ -2814,21 +3046,27 @@ var BaseOperationHandler = class {
     }
     return result;
   }
-  processNoneOwnedRelation(kysely, contextModel, relationFieldName, payload, parentEntity) {
+  processNoneOwnedRelationForCreate(kysely, contextModel, relationFieldName, payload, parentEntity) {
     const relationFieldDef = this.requireField(contextModel, relationFieldName);
     const relationModel = relationFieldDef.type;
     const tasks = [];
+    const fromRelationContext = {
+      model: contextModel,
+      field: relationFieldName,
+      ids: parentEntity
+    };
     for (const [action, subPayload] of Object.entries(payload)) {
       if (!subPayload) {
         continue;
       }
       switch (action) {
         case "create": {
-          tasks.push(...enumerate(subPayload).map((item) => this.create(kysely, relationModel, item, {
-            model: contextModel,
-            field: relationFieldName,
-            ids: parentEntity
-          })));
+          tasks.push(...enumerate(subPayload).map((item) => this.create(kysely, relationModel, item, fromRelationContext)));
+          break;
+        }
+        case "createMany": {
+          invariant7(relationFieldDef.array, "relation must be an array for createMany");
+          tasks.push(this.createMany(kysely, relationModel, subPayload, false, fromRelationContext));
           break;
         }
         case "connect": {
@@ -2858,6 +3096,11 @@ var BaseOperationHandler = class {
     return Promise.all(tasks);
   }
   async createMany(kysely, model, input, returnData, fromRelation) {
+    if (!input.data || Array.isArray(input.data) && input.data.length === 0) {
+      return returnData ? [] : {
+        count: 0
+      };
+    }
     const modelDef = this.requireModel(model);
     let relationKeyPairs = [];
     if (fromRelation) {
@@ -2867,12 +3110,12 @@ var BaseOperationHandler = class {
       }
       relationKeyPairs = keyPairs;
     }
-    const createData = enumerate(input.data).map((item) => {
+    let createData = enumerate(input.data).map((item) => {
       const newItem = {};
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
         invariant7(!fieldDef.relation, "createMany does not support relations");
-        newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type);
+        newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
       }
       if (fromRelation) {
         for (const { fk, pk } of relationKeyPairs) {
@@ -2881,14 +3124,44 @@ var BaseOperationHandler = class {
       }
       return this.fillGeneratedValues(modelDef, newItem);
     });
+    if (!this.dialect.supportInsertWithDefault) {
+      const allPassedFields = createData.reduce((acc, item) => {
+        Object.keys(item).forEach((field) => {
+          if (!acc.includes(field)) {
+            acc.push(field);
+          }
+        });
+        return acc;
+      }, []);
+      for (const item of createData) {
+        if (Object.keys(item).length === allPassedFields.length) {
+          continue;
+        }
+        for (const field of allPassedFields) {
+          if (!(field in item)) {
+            const fieldDef = this.requireField(model, field);
+            if (fieldDef.default !== void 0 && fieldDef.default !== null && typeof fieldDef.default !== "object") {
+              item[field] = this.dialect.transformPrimitive(fieldDef.default, fieldDef.type, !!fieldDef.array);
+            }
+          }
+        }
+      }
+    }
+    if (modelDef.baseModel) {
+      if (input.skipDuplicates) {
+        throw new QueryError('"skipDuplicates" options is not supported for polymorphic models');
+      }
+      const baseCreateResult = await this.processBaseModelCreateMany(kysely, modelDef.baseModel, createData, !!input.skipDuplicates, model);
+      createData = baseCreateResult.remainingFieldRows;
+    }
     const query = kysely.insertInto(model).values(createData).$if(!!input.skipDuplicates, (qb) => qb.onConflict((oc) => oc.doNothing())).modifyEnd(this.makeContextComment({
       model,
       operation: "create"
     }));
     if (!returnData) {
-      const result = await query.executeTakeFirstOrThrow();
+      const result = await this.executeQuery(kysely, query, "createMany");
       return {
-        count: Number(result.numInsertedOrUpdatedRows)
+        count: Number(result.numAffectedRows)
       };
     } else {
       const idFields = getIdFields(this.schema, model);
@@ -2896,10 +3169,46 @@ var BaseOperationHandler = class {
       return result;
     }
   }
+  async processBaseModelCreateMany(kysely, model, createRows, skipDuplicates, forModel) {
+    const thisCreateRows = [];
+    const remainingFieldRows = [];
+    const discriminatorField = getDiscriminatorField(this.schema, model);
+    invariant7(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    for (const createFields of createRows) {
+      const thisCreateFields = {};
+      const remainingFields = {};
+      Object.entries(createFields).forEach(([field, value]) => {
+        const fieldDef = this.getField(model, field);
+        if (fieldDef) {
+          thisCreateFields[field] = value;
+        } else {
+          remainingFields[field] = value;
+        }
+      });
+      thisCreateFields[discriminatorField] = forModel;
+      thisCreateRows.push(thisCreateFields);
+      remainingFieldRows.push(remainingFields);
+    }
+    const baseEntities = await this.createMany(kysely, model, {
+      data: thisCreateRows,
+      skipDuplicates
+    }, true);
+    for (let i = 0; i < baseEntities.length; i++) {
+      const idValues = extractIdFields(baseEntities[i], this.schema, model);
+      Object.assign(remainingFieldRows[i], idValues);
+    }
+    return {
+      baseEntities,
+      remainingFieldRows
+    };
+  }
   fillGeneratedValues(modelDef, data) {
     const fields = modelDef.fields;
     const values = clone(data);
-    for (const field in fields) {
+    for (const [field, fieldDef] of Object.entries(fields)) {
+      if (fieldDef.originModel) {
+        continue;
+      }
       if (!(field in data)) {
         if (typeof fields[field]?.default === "object" && "kind" in fields[field].default) {
           const generated = this.evalGenerator(fields[field].default);
@@ -2907,7 +3216,7 @@ var BaseOperationHandler = class {
             values[field] = generated;
           }
         } else if (fields[field]?.updatedAt) {
-          values[field] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime");
+          values[field] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime", false);
         }
       }
     }
@@ -2915,7 +3224,7 @@ var BaseOperationHandler = class {
   }
   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) {
@@ -2972,32 +3281,37 @@ var BaseOperationHandler = class {
         if (finalData === data) {
           finalData = clone(data);
         }
-        finalData[fieldName] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime");
+        finalData[fieldName] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime", false);
       }
     }
     if (Object.keys(finalData).length === 0) {
-      const r = await this.readUnique(kysely, model, {
-        where: combinedWhere
+      return combinedWhere;
+    }
+    let needIdRead = false;
+    if (modelDef.baseModel && !this.isIdFilter(model, combinedWhere)) {
+      needIdRead = true;
+    }
+    if (needIdRead) {
+      const readResult = await this.readUnique(kysely, model, {
+        where: combinedWhere,
+        select: this.makeIdSelect(model)
       });
-      if (!r && throwIfNotFound) {
+      if (!readResult && throwIfNotFound) {
         throw new NotFoundError(model);
       }
-      return r;
+      combinedWhere = readResult;
+    }
+    if (modelDef.baseModel) {
+      const baseUpdateResult = await this.processBaseModelUpdate(kysely, modelDef.baseModel, combinedWhere, finalData, throwIfNotFound);
+      finalData = baseUpdateResult.remainingFields;
+      combinedWhere = baseUpdateResult.baseEntity;
     }
     const updateFields = {};
     let thisEntity = void 0;
     for (const field in finalData) {
       const fieldDef = this.requireField(model, field);
       if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) {
-        if (this.isNumericField(fieldDef) && typeof finalData[field] === "object" && finalData[field]) {
-          updateFields[field] = this.transformIncrementalUpdate(model, field, fieldDef, finalData[field]);
-          continue;
-        }
-        if (fieldDef.array && typeof finalData[field] === "object" && !Array.isArray(finalData[field]) && finalData[field]) {
-          updateFields[field] = this.transformScalarListUpdate(model, field, fieldDef, finalData[field]);
-          continue;
-        }
-        updateFields[field] = this.dialect.transformPrimitive(finalData[field], fieldDef.type);
+        updateFields[field] = this.processScalarFieldUpdateData(model, field, finalData);
       } else {
         if (!allowRelationUpdate) {
           throw new QueryError(`Relation update not allowed for field "${field}"`);
@@ -3019,16 +3333,14 @@ var BaseOperationHandler = class {
       }
     }
     if (Object.keys(updateFields).length === 0) {
-      return thisEntity ?? await this.readUnique(kysely, model, {
-        where: combinedWhere
-      });
+      return combinedWhere;
     } else {
       const idFields = getIdFields(this.schema, model);
       const query = kysely.updateTable(model).where((eb) => this.dialect.buildFilter(eb, model, model, combinedWhere)).set(updateFields).returning(idFields).modifyEnd(this.makeContextComment({
         model,
         operation: "update"
       }));
-      const updatedEntity = await query.executeTakeFirst();
+      const updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
       if (!updatedEntity) {
         if (throwIfNotFound) {
           throw new NotFoundError(model);
@@ -3039,23 +3351,72 @@ var BaseOperationHandler = class {
       return updatedEntity;
     }
   }
+  processScalarFieldUpdateData(model, field, data) {
+    const fieldDef = this.requireField(model, field);
+    if (this.isNumericIncrementalUpdate(fieldDef, data[field])) {
+      return this.transformIncrementalUpdate(model, field, fieldDef, data[field]);
+    }
+    if (fieldDef.array && typeof data[field] === "object" && !Array.isArray(data[field]) && data[field]) {
+      return this.transformScalarListUpdate(model, field, fieldDef, data[field]);
+    }
+    return this.dialect.transformPrimitive(data[field], fieldDef.type, !!fieldDef.array);
+  }
+  isNumericIncrementalUpdate(fieldDef, value) {
+    if (!this.isNumericField(fieldDef)) {
+      return false;
+    }
+    if (typeof value !== "object" || !value) {
+      return false;
+    }
+    return [
+      "increment",
+      "decrement",
+      "multiply",
+      "divide",
+      "set"
+    ].some((key) => key in value);
+  }
+  isIdFilter(model, filter) {
+    if (!filter || typeof filter !== "object") {
+      return false;
+    }
+    const idFields = getIdFields(this.schema, model);
+    return idFields.length === Object.keys(filter).length && idFields.every((field) => field in filter);
+  }
+  async processBaseModelUpdate(kysely, model, where, updateFields, throwIfNotFound) {
+    const thisUpdateFields = {};
+    const remainingFields = {};
+    Object.entries(updateFields).forEach(([field, value]) => {
+      const fieldDef = this.getField(model, field);
+      if (fieldDef) {
+        thisUpdateFields[field] = value;
+      } else {
+        remainingFields[field] = value;
+      }
+    });
+    const baseEntity = await this.update(kysely, model, where, thisUpdateFields, void 0, void 0, throwIfNotFound);
+    return {
+      baseEntity,
+      remainingFields
+    };
+  }
   transformIncrementalUpdate(model, field, fieldDef, payload) {
     invariant7(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
     const key = Object.keys(payload)[0];
-    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type);
-    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(() => {
+    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, false);
+    const eb = expressionBuilder3();
+    const fieldRef = this.dialect.fieldRef(model, field, eb);
+    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}`);
     });
   }
   transformScalarListUpdate(model, field, fieldDef, payload) {
     invariant7(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
     const key = Object.keys(payload)[0];
-    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type);
-    const eb = expressionBuilder2();
-    const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
-    return match8(key).with("set", () => value).with("push", () => {
+    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, true);
+    const eb = expressionBuilder3();
+    const fieldRef = this.dialect.fieldRef(model, field, eb);
+    return match9(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw new InternalError(`Invalid array update operation: ${key}`);
@@ -3067,7 +3428,7 @@ var BaseOperationHandler = class {
   makeContextComment(context) {
     return sql4.raw(`${CONTEXT_COMMENT_PREFIX}${JSON.stringify(context)}`);
   }
-  async updateMany(kysely, model, where, data, limit, returnData) {
+  async updateMany(kysely, model, where, data, limit, returnData, filterModel) {
     if (typeof data !== "object") {
       throw new InternalError("data must be an object");
     }
@@ -3076,49 +3437,79 @@ var BaseOperationHandler = class {
         count: 0
       };
     }
-    const updateFields = {};
+    const modelDef = this.requireModel(model);
+    if (modelDef.baseModel && limit !== void 0) {
+      throw new QueryError("Updating with a limit is not supported for polymorphic models");
+    }
+    filterModel ??= model;
+    let updateFields = {};
     for (const field in data) {
-      const fieldDef = this.requireField(model, field);
       if (isRelationField(this.schema, model, field)) {
         continue;
       }
-      updateFields[field] = this.dialect.transformPrimitive(data[field], fieldDef.type);
+      updateFields[field] = this.processScalarFieldUpdateData(model, field, data);
+    }
+    let shouldFallbackToIdFilter = false;
+    if (limit !== void 0 && !this.dialect.supportsUpdateWithLimit) {
+      shouldFallbackToIdFilter = true;
+    }
+    if (modelDef.isDelegate || modelDef.baseModel) {
+      shouldFallbackToIdFilter = true;
+    }
+    let resultFromBaseModel = void 0;
+    if (modelDef.baseModel) {
+      const baseResult = await this.processBaseModelUpdateMany(kysely, modelDef.baseModel, where, updateFields, filterModel);
+      updateFields = baseResult.remainingFields;
+      resultFromBaseModel = baseResult.baseResult;
+    }
+    if (Object.keys(updateFields).length === 0) {
+      return resultFromBaseModel ?? (returnData ? [] : {
+        count: 0
+      });
     }
     let query = kysely.updateTable(model).set(updateFields);
-    if (limit === void 0) {
-      query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where));
+    if (!shouldFallbackToIdFilter) {
+      query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where)).$if(limit !== void 0, (qb) => qb.limit(limit));
     } else {
-      if (this.dialect.supportsUpdateWithLimit) {
-        query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where)).limit(limit);
-      } else {
-        query = query.where((eb) => eb(eb.refTuple(
-          ...this.buildIdFieldRefs(kysely, model)
-        ), "in", kysely.selectFrom(model).where((eb2) => this.dialect.buildFilter(eb2, model, model, where)).select(this.buildIdFieldRefs(kysely, model)).limit(limit)));
-      }
+      query = query.where((eb) => eb(eb.refTuple(
+        ...this.buildIdFieldRefs(kysely, model)
+      ), "in", this.dialect.buildSelectModel(eb, filterModel).where(this.dialect.buildFilter(eb, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
     }
     query = query.modifyEnd(this.makeContextComment({
       model,
       operation: "update"
     }));
-    try {
-      if (!returnData) {
-        const result = await query.executeTakeFirstOrThrow();
-        return {
-          count: Number(result.numUpdatedRows)
-        };
+    if (!returnData) {
+      const result = await this.executeQuery(kysely, query, "update");
+      return {
+        count: Number(result.numAffectedRows)
+      };
+    } else {
+      const idFields = getIdFields(this.schema, model);
+      const result = await query.returning(idFields).execute();
+      return result;
+    }
+  }
+  async processBaseModelUpdateMany(kysely, model, where, updateFields, filterModel) {
+    const thisUpdateFields = {};
+    const remainingFields = {};
+    Object.entries(updateFields).forEach(([field, value]) => {
+      const fieldDef = this.getField(model, field);
+      if (fieldDef) {
+        thisUpdateFields[field] = value;
       } else {
-        const idFields = getIdFields(this.schema, model);
-        const result = await query.returning(idFields).execute();
-        return result;
+        remainingFields[field] = value;
       }
-    } catch (err) {
-      const { sql: sql10, parameters } = query.compile();
-      throw new QueryError(`Error during updateMany: ${err}, sql: ${sql10}, parameters: ${parameters}`);
-    }
+    });
+    const baseResult = await this.updateMany(kysely, model, where, thisUpdateFields, void 0, false, filterModel);
+    return {
+      baseResult,
+      remainingFields
+    };
   }
   buildIdFieldRefs(kysely, model) {
     const idFields = getIdFields(this.schema, model);
-    return idFields.map((f) => kysely.dynamic.ref(f));
+    return idFields.map((f) => kysely.dynamic.ref(`${model}.${f}`));
   }
   async processRelationUpdates(kysely, model, field, fieldDef, parentIds, args, throwIfNotFound) {
     const tasks = [];
@@ -3236,7 +3627,7 @@ var BaseOperationHandler = class {
           model: fromRelation.model,
           operation: "update"
         }));
-        updateResult = await query.executeTakeFirstOrThrow();
+        updateResult = await this.executeQuery(kysely, query, "connect");
       } else {
         const relationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
         if (!relationFieldDef.array) {
@@ -3247,7 +3638,7 @@ var BaseOperationHandler = class {
             model: fromRelation.model,
             operation: "update"
           }));
-          await query2.execute();
+          await this.executeQuery(kysely, query2, "disconnect");
         }
         const query = kysely.updateTable(model).where((eb) => eb.or(_data.map((d) => eb.and(d)))).set(keyPairs.reduce((acc, { fk, pk }) => ({
           ...acc,
@@ -3256,9 +3647,9 @@ var BaseOperationHandler = class {
           model,
           operation: "update"
         }));
-        updateResult = await query.executeTakeFirstOrThrow();
+        updateResult = await this.executeQuery(kysely, query, "connect");
       }
-      if (_data.length > updateResult.numUpdatedRows) {
+      if (_data.length > updateResult.numAffectedRows) {
         throw new NotFoundError(model);
       }
     }
@@ -3310,7 +3701,7 @@ var BaseOperationHandler = class {
       await Promise.all(actions);
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
-      const eb = expressionBuilder2();
+      const eb = expressionBuilder3();
       if (ownedByModel) {
         invariant7(disconnectConditions.length === 1, "only one entity can be disconnected");
         const condition = disconnectConditions[0];
@@ -3326,7 +3717,7 @@ var BaseOperationHandler = class {
           model: fromRelation.model,
           operation: "update"
         }));
-        await query.executeTakeFirstOrThrow();
+        await this.executeQuery(kysely, query, "disconnect");
       } else {
         const query = kysely.updateTable(model).where(eb.and([
           // fk filter
@@ -3343,7 +3734,7 @@ var BaseOperationHandler = class {
           model,
           operation: "update"
         }));
-        await query.executeTakeFirstOrThrow();
+        await this.executeQuery(kysely, query, "disconnect");
       }
     }
   }
@@ -3381,7 +3772,7 @@ var BaseOperationHandler = class {
         model,
         operation: "update"
       }));
-      await query.execute();
+      await this.executeQuery(kysely, query, "disconnect");
       if (_data.length > 0) {
         const query2 = kysely.updateTable(model).where((eb) => eb.or(_data.map((d) => eb.and(d)))).set(keyPairs.reduce((acc, { fk, pk }) => ({
           ...acc,
@@ -3390,8 +3781,8 @@ var BaseOperationHandler = class {
           model,
           operation: "update"
         }));
-        const r = await query2.executeTakeFirstOrThrow();
-        if (_data.length > r.numUpdatedRows) {
+        const r = await this.executeQuery(kysely, query2, "connect");
+        if (_data.length > r.numAffectedRows) {
           throw new NotFoundError(model);
         }
       }
@@ -3432,7 +3823,7 @@ var BaseOperationHandler = class {
             OR: deleteConditions
           }
         ]
-      }, void 0, false);
+      });
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
@@ -3455,7 +3846,7 @@ var BaseOperationHandler = class {
               OR: deleteConditions
             }
           ]
-        }, void 0, false);
+        });
       } else {
         deleteResult = await this.delete(kysely, model, {
           AND: [
@@ -3467,7 +3858,7 @@ var BaseOperationHandler = class {
               OR: deleteConditions
             }
           ]
-        }, void 0, false);
+        });
       }
     }
     if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
@@ -3478,33 +3869,59 @@ var BaseOperationHandler = class {
     return enumerate(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
   }
   // #endregion
-  async delete(kysely, model, where, limit, returnData) {
+  async delete(kysely, model, where, limit, filterModel) {
+    filterModel ??= model;
+    const modelDef = this.requireModel(model);
+    if (modelDef.baseModel) {
+      if (limit !== void 0) {
+        throw new QueryError("Deleting with a limit is not supported for polymorphic models");
+      }
+      return this.processBaseModelDelete(kysely, modelDef.baseModel, where, limit, filterModel);
+    }
     let query = kysely.deleteFrom(model);
-    if (limit === void 0) {
+    let needIdFilter = false;
+    if (limit !== void 0 && !this.dialect.supportsDeleteWithLimit) {
+      needIdFilter = true;
+    }
+    if (modelDef.isDelegate || modelDef.baseModel) {
+      needIdFilter = true;
+    }
+    if (!needIdFilter) {
       query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where));
     } else {
-      if (this.dialect.supportsDeleteWithLimit) {
-        query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where)).limit(limit);
-      } else {
-        query = query.where((eb) => eb(eb.refTuple(
-          ...this.buildIdFieldRefs(kysely, model)
-        ), "in", kysely.selectFrom(model).where((eb2) => this.dialect.buildFilter(eb2, model, model, where)).select(this.buildIdFieldRefs(kysely, model)).limit(limit)));
-      }
+      query = query.where((eb) => eb(eb.refTuple(
+        ...this.buildIdFieldRefs(kysely, model)
+      ), "in", this.dialect.buildSelectModel(eb, filterModel).where((eb2) => this.dialect.buildFilter(eb2, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
     }
+    await this.processDelegateRelationDelete(kysely, modelDef, where, limit);
     query = query.modifyEnd(this.makeContextComment({
       model,
       operation: "delete"
     }));
-    if (returnData) {
-      const result = await query.execute();
-      return result;
-    } else {
-      const result = await query.executeTakeFirstOrThrow();
-      return {
-        count: Number(result.numDeletedRows)
-      };
+    const result = await this.executeQuery(kysely, query, "delete");
+    return {
+      count: Number(result.numAffectedRows)
+    };
+  }
+  async processDelegateRelationDelete(kysely, modelDef, where, limit) {
+    for (const fieldDef of Object.values(modelDef.fields)) {
+      if (fieldDef.relation && fieldDef.relation.opposite) {
+        const oppositeModelDef = this.requireModel(fieldDef.type);
+        const oppositeRelation = this.requireField(fieldDef.type, fieldDef.relation.opposite);
+        if (oppositeModelDef.baseModel && oppositeRelation.relation?.onDelete === "Cascade") {
+          if (limit !== void 0) {
+            throw new QueryError("Deleting with a limit is not supported for polymorphic models");
+          }
+          await this.delete(kysely, fieldDef.type, {
+            [fieldDef.relation.opposite]: where
+          }, void 0);
+        }
+      }
     }
   }
+  async processBaseModelDelete(kysely, model, where, limit, filterModel) {
+    return this.delete(kysely, model, where, limit, filterModel);
+  }
   makeIdSelect(model) {
     const modelDef = this.requireModel(model);
     return modelDef.idFields.reduce((acc, f) => {
@@ -3513,7 +3930,7 @@ var BaseOperationHandler = class {
     }, {});
   }
   trimResult(data, args) {
-    if (!args.select) {
+    if (!("select" in args) || !args.select) {
       return data;
     }
     return Object.keys(args.select).reduce((acc, field) => {
@@ -3523,9 +3940,9 @@ var BaseOperationHandler = class {
   }
   needReturnRelations(model, args) {
     let returnRelation = false;
-    if (args.include) {
+    if ("include" in args && args.include) {
       returnRelation = Object.keys(args.include).length > 0;
-    } else if (args.select) {
+    } else if ("select" in args && args.select) {
       returnRelation = Object.entries(args.select).some(([K, v]) => {
         const fieldDef = this.requireField(model, K);
         return fieldDef.relation && v;
@@ -3533,11 +3950,13 @@ var BaseOperationHandler = class {
     }
     return returnRelation;
   }
-  async safeTransaction(callback) {
+  async safeTransaction(callback, isolationLevel) {
     if (this.kysely.isTransaction) {
       return callback(this.kysely);
     } else {
-      return this.kysely.transaction().setIsolationLevel("repeatable read").execute(callback);
+      let txBuilder = this.kysely.transaction();
+      txBuilder = txBuilder.setIsolationLevel(isolationLevel ?? "repeatable read");
+      return txBuilder.execute(callback);
     }
   }
   // Given a unique filter of a model, return the entity ids by trying to
@@ -3556,6 +3975,47 @@ var BaseOperationHandler = class {
       where: uniqueFilter
     });
   }
+  /**
+   * Normalize input args to strip `undefined` fields
+   */
+  normalizeArgs(args) {
+    if (!args) {
+      return;
+    }
+    const newArgs = clone(args);
+    this.doNormalizeArgs(newArgs);
+    return newArgs;
+  }
+  doNormalizeArgs(args) {
+    if (args && typeof args === "object") {
+      for (const [key, value] of Object.entries(args)) {
+        if (value === void 0) {
+          delete args[key];
+        } else if (value && isPlainObject3(value)) {
+          this.doNormalizeArgs(value);
+        }
+      }
+    }
+  }
+  makeQueryId(operation) {
+    return {
+      queryId: `${operation}-${createId()}`
+    };
+  }
+  executeQuery(kysely, query, operation) {
+    return kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+  }
+  async executeQueryTakeFirst(kysely, query, operation) {
+    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+    return result.rows[0];
+  }
+  async executeQueryTakeFirstOrThrow(kysely, query, operation) {
+    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+    if (result.rows.length === 0) {
+      throw new QueryError("No rows found");
+    }
+    return result.rows[0];
+  }
 };
 
 // src/client/crud/operations/aggregate.ts
@@ -3564,21 +4024,37 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
     __name(this, "AggregateOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateAggregateArgs(this.model, args);
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateAggregateArgs(this.model, normalizedArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll(this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, validatedArgs?.where));
-      const skip = validatedArgs?.skip;
-      let take = validatedArgs?.take;
+      let subQuery = this.dialect.buildSelectModel(eb, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      const selectedFields = [];
+      for (const [key, value] of Object.entries(parsedArgs)) {
+        if (key.startsWith("_") && value && typeof value === "object") {
+          Object.entries(value).filter(([field]) => field !== "_all").filter(([, val]) => val === true).forEach(([field]) => {
+            if (!selectedFields.includes(field)) selectedFields.push(field);
+          });
+        }
+      }
+      if (selectedFields.length > 0) {
+        for (const field of selectedFields) {
+          subQuery = this.dialect.buildSelectField(subQuery, this.model, this.model, field);
+        }
+      } else {
+        subQuery = subQuery.select(() => eb.lit(1).as("_all"));
+      }
+      const skip = parsedArgs?.skip;
+      let take = parsedArgs?.take;
       let negateOrderBy = false;
       if (take !== void 0 && take < 0) {
         negateOrderBy = true;
         take = -take;
       }
       subQuery = this.dialect.buildSkipTake(subQuery, skip, take);
-      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, validatedArgs.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
       return subQuery.as("$sub");
     });
-    for (const [key, value] of Object.entries(validatedArgs)) {
+    for (const [key, value] of Object.entries(parsedArgs)) {
       switch (key) {
         case "_count": {
           if (value === true) {
@@ -3603,7 +4079,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}`);
               });
             }
@@ -3612,9 +4088,9 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
         }
       }
     }
-    const result = await query.executeTakeFirstOrThrow();
+    const result = await this.executeQuery(this.kysely, query, "aggregate");
     const ret = {};
-    for (const [key, value] of Object.entries(result)) {
+    for (const [key, value] of Object.entries(result.rows[0])) {
       if (key === "_count") {
         ret[key] = value;
         continue;
@@ -3636,7 +4112,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);
             }
           }
         }
@@ -3657,34 +4133,47 @@ var CountOperationHandler = class extends BaseOperationHandler {
     __name(this, "CountOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateCountArgs(this.model, args);
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateCountArgs(this.model, normalizedArgs);
+    const subQueryName = "$sub";
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, validatedArgs?.where));
-      subQuery = this.dialect.buildSkipTake(subQuery, validatedArgs?.skip, validatedArgs?.take);
-      return subQuery.as("$sub");
+      let subQuery = this.dialect.buildSelectModel(eb, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      if (parsedArgs?.select && typeof parsedArgs.select === "object") {
+        for (const [key, value] of Object.entries(parsedArgs.select)) {
+          if (key !== "_all" && value === true) {
+            subQuery = this.dialect.buildSelectField(subQuery, this.model, this.model, key);
+          }
+        }
+      } else {
+        subQuery = subQuery.select(() => eb.lit(1).as("_all"));
+      }
+      subQuery = this.dialect.buildSkipTake(subQuery, parsedArgs?.skip, parsedArgs?.take);
+      return subQuery.as(subQueryName);
     });
-    if (validatedArgs?.select && typeof validatedArgs.select === "object") {
-      query = query.select((eb) => Object.keys(validatedArgs.select).map((key) => key === "_all" ? eb.cast(eb.fn.countAll(), "integer").as("_all") : eb.cast(eb.fn.count(sql6.ref(`$sub.${key}`)), "integer").as(key)));
-      return query.executeTakeFirstOrThrow();
+    if (parsedArgs?.select && typeof parsedArgs.select === "object") {
+      query = query.select((eb) => Object.keys(parsedArgs.select).map((key) => key === "_all" ? eb.cast(eb.fn.countAll(), "integer").as("_all") : eb.cast(eb.fn.count(sql6.ref(`${subQueryName}.${key}`)), "integer").as(key)));
+      const result = await this.executeQuery(this.kysely, query, "count");
+      return result.rows[0];
     } else {
       query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
-      const result = await query.executeTakeFirstOrThrow();
-      return result.count;
+      const result = await this.executeQuery(this.kysely, query, "count");
+      return result.rows[0].count;
     }
   }
 };
 
 // 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) {
-    return match10(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, args))).with("createMany", () => {
-      return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, args));
+    const normalizedArgs = this.normalizeArgs(args);
+    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, args));
+      return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, normalizedArgs));
     }).exhaustive();
   }
   async runCreate(args) {
@@ -3728,13 +4217,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) {
-    return match11(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, args))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, args))).exhaustive();
+    const normalizedArgs = this.normalizeArgs(args);
+    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, {
@@ -3746,15 +4236,19 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     if (!existing) {
       throw new NotFoundError(this.model);
     }
-    const result = await this.delete(this.kysely, this.model, args.where, void 0, false);
-    if (result.count === 0) {
-      throw new NotFoundError(this.model);
-    }
+    await this.safeTransaction(async (tx) => {
+      const result = await this.delete(tx, this.model, args.where);
+      if (result.count === 0) {
+        throw new NotFoundError(this.model);
+      }
+    });
     return existing;
   }
   async runDeleteMany(args) {
-    const result = await this.delete(this.kysely, this.model, args?.where, args?.limit, false);
-    return result;
+    return await this.safeTransaction(async (tx) => {
+      const result = await this.delete(tx, this.model, args?.where, args?.limit);
+      return result;
+    });
   }
 };
 
@@ -3764,7 +4258,8 @@ var FindOperationHandler = class extends BaseOperationHandler {
     __name(this, "FindOperationHandler");
   }
   async handle(operation, args, validateArgs = true) {
-    const parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, operation === "findUnique", args) : args;
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, operation === "findUnique", normalizedArgs) : normalizedArgs;
     const result = await this.read(this.client.$qb, this.model, parsedArgs);
     const finalResult = operation === "findMany" ? result : result[0] ?? null;
     return finalResult;
@@ -3772,18 +4267,19 @@ 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";
-var GroupByeOperationHandler = class extends BaseOperationHandler {
+import { expressionBuilder as expressionBuilder4 } from "kysely";
+import { match as match13 } from "ts-pattern";
+var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
-    __name(this, "GroupByeOperationHandler");
+    __name(this, "GroupByOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateGroupByArgs(this.model, args);
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateGroupByArgs(this.model, normalizedArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, validatedArgs?.where));
-      const skip = validatedArgs?.skip;
-      let take = validatedArgs?.take;
+      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      const skip = parsedArgs?.skip;
+      let take = parsedArgs?.take;
       let negateOrderBy = false;
       if (take !== void 0 && take < 0) {
         negateOrderBy = true;
@@ -3793,20 +4289,21 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
       subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, void 0, skip !== void 0 || take !== void 0, negateOrderBy);
       return subQuery.as("$sub");
     });
-    const bys = typeof validatedArgs.by === "string" ? [
-      validatedArgs.by
-    ] : validatedArgs.by;
-    query = query.groupBy(bys);
-    if (validatedArgs.orderBy) {
-      query = this.dialect.buildOrderBy(query, this.model, "$sub", validatedArgs.orderBy, false, false);
+    const fieldRef = /* @__PURE__ */ __name((field) => this.dialect.fieldRef(this.model, field, expressionBuilder4(), "$sub"), "fieldRef");
+    const bys = typeof parsedArgs.by === "string" ? [
+      parsedArgs.by
+    ] : parsedArgs.by;
+    query = query.groupBy(bys.map((by) => fieldRef(by)));
+    if (parsedArgs.orderBy) {
+      query = this.dialect.buildOrderBy(query, this.model, "$sub", parsedArgs.orderBy, false, false);
     }
-    if (validatedArgs.having) {
-      query = query.having((eb1) => this.dialect.buildFilter(eb1, this.model, "$sub", validatedArgs.having));
+    if (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));
+      query = query.select(() => fieldRef(by).as(by));
     }
-    for (const [key, value] of Object.entries(validatedArgs)) {
+    for (const [key, value] of Object.entries(parsedArgs)) {
       switch (key) {
         case "_count": {
           if (value === true) {
@@ -3817,7 +4314,7 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
                 if (field === "_all") {
                   query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as(`_count._all`));
                 } else {
-                  query = query.select((eb) => eb.cast(eb.fn.count(sql7.ref(`$sub.${field}`)), "integer").as(`${key}.${field}`));
+                  query = query.select((eb) => eb.cast(eb.fn.count(fieldRef(field)), "integer").as(`${key}.${field}`));
                 }
               }
             });
@@ -3830,18 +4327,15 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
         case "_min": {
           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();
-                return fn(sql7.ref(`$sub.${field}`)).as(`${key}.${field}`);
-              });
+              query = query.select((eb) => aggregate(eb, fieldRef(field), key).as(`${key}.${field}`));
             }
           });
           break;
         }
       }
     }
-    const result = await query.execute();
-    return result.map((row) => this.postProcessRow(row));
+    const result = await this.executeQuery(this.kysely, query, "groupBy");
+    return result.rows.map((row) => this.postProcessRow(row));
   }
   postProcessRow(row) {
     const ret = {};
@@ -3868,7 +4362,7 @@ var GroupByeOperationHandler = 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);
             }
           }
         }
@@ -3883,31 +4377,45 @@ var GroupByeOperationHandler = 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) {
-    return match13(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, args))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, args))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, args))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, args))).exhaustive();
+    const normalizedArgs = this.normalizeArgs(args);
+    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 result = await this.safeTransaction(async (tx) => {
-      const updated = await this.update(tx, this.model, args.where, args.data);
-      return this.readUnique(tx, this.model, {
-        select: args.select,
-        include: args.include,
-        omit: args.omit,
-        where: getIdValues(this.schema, this.model, updated)
-      });
+    const readBackResult = await this.safeTransaction(async (tx) => {
+      const updateResult = await this.update(tx, this.model, args.where, args.data);
+      const readFilter = updateResult ?? args.where;
+      let readBackResult2 = void 0;
+      try {
+        readBackResult2 = await this.readUnique(tx, this.model, {
+          select: args.select,
+          include: args.include,
+          omit: args.omit,
+          where: readFilter
+        });
+      } catch {
+      }
+      return readBackResult2;
     });
-    if (!result && this.hasPolicyEnabled) {
-      throw new RejectedByPolicyError(this.model, "result is not allowed to be read back");
+    if (!readBackResult) {
+      if (this.hasPolicyEnabled) {
+        throw new RejectedByPolicyError(this.model, "result is not allowed to be read back");
+      } else {
+        return null;
+      }
+    } else {
+      return readBackResult;
     }
-    return result;
   }
   async runUpdateMany(args) {
-    return this.updateMany(this.kysely, this.model, args.where, args.data, args.limit, false);
+    return this.safeTransaction(async (tx) => {
+      return this.updateMany(tx, this.model, args.where, args.data, args.limit, false);
+    });
   }
   async runUpdateManyAndReturn(args) {
     if (!args) {
@@ -3945,19 +4453,19 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/validator.ts
+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 {
     __name(this, "InputValidator");
   }
   schema;
-  schemaCache;
+  schemaCache = /* @__PURE__ */ new Map();
   constructor(schema) {
     this.schema = schema;
-    this.schemaCache = /* @__PURE__ */ new Map();
   }
   validateFindArgs(model, unique, args) {
     return this.validate(model, "find", {
@@ -4014,7 +4522,7 @@ var InputValidator = class {
     }
     const { error } = schema.safeParse(args);
     if (error) {
-      throw new QueryError(`Invalid ${operation} args: ${error.message}`);
+      throw new InputValidationError(`Invalid ${operation} args: ${error.message}`, error);
     }
     return args;
   }
@@ -4033,11 +4541,11 @@ var InputValidator = class {
     fields["distinct"] = this.makeDistinctSchema(model).optional();
     fields["cursor"] = this.makeCursorSchema(model).optional();
     if (options.collection) {
-      fields["skip"] = z.number().int().nonnegative().optional();
-      fields["take"] = z.number().int().optional();
+      fields["skip"] = this.makeSkipSchema().optional();
+      fields["take"] = this.makeTakeSchema().optional();
       fields["orderBy"] = this.orArray(this.makeOrderBySchema(model, true, false), true).optional();
     }
-    let result = z.object(fields).strict();
+    let result = z.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4046,22 +4554,50 @@ var InputValidator = class {
     return result;
   }
   makePrimitiveSchema(type) {
-    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(),
-      z.bigint()
-    ])).with("Decimal", () => z.union([
-      z.number(),
-      z.instanceof(Decimal),
-      z.string()
-    ])).with("DateTime", () => z.union([
-      z.date(),
-      z.string().datetime()
-    ])).with("Bytes", () => z.instanceof(Uint8Array)).otherwise(() => z.unknown());
-  }
-  makeWhereSchema(model, unique, withoutRelationFields = false) {
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.makeTypeDefSchema(type);
+    } else {
+      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(),
+        z.instanceof(Decimal),
+        z.string()
+      ])).with("DateTime", () => z.union([
+        z.date(),
+        z.string().datetime()
+      ])).with("Bytes", () => z.instanceof(Uint8Array)).otherwise(() => z.unknown());
+    }
+  }
+  makeTypeDefSchema(type) {
+    const key = `$typedef-${type}`;
+    let schema = this.schemaCache.get(key);
+    if (schema) {
+      return schema;
+    }
+    const typeDef = this.schema.typeDefs?.[type];
+    invariant8(typeDef, `Type definition "${type}" not found in schema`);
+    schema = z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+      let fieldSchema = this.makePrimitiveSchema(def.type);
+      if (def.array) {
+        fieldSchema = fieldSchema.array();
+      }
+      if (def.optional) {
+        fieldSchema = fieldSchema.optional();
+      }
+      return [
+        field,
+        fieldSchema
+      ];
+    })));
+    this.schemaCache.set(key, schema);
+    return schema;
+  }
+  makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
     const modelDef = getModel(this.schema, model);
     if (!modelDef) {
-      throw new QueryError(`Model "${model}" not found`);
+      throw new QueryError(`Model "${model}" not found in schema`);
     }
     const fields = {};
     for (const field of Object.keys(modelDef.fields)) {
@@ -4076,7 +4612,7 @@ var InputValidator = class {
         if (fieldDef.array) {
           fieldSchema = z.union([
             fieldSchema,
-            z.object({
+            z.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
@@ -4085,7 +4621,7 @@ var InputValidator = class {
         } else {
           fieldSchema = z.union([
             fieldSchema,
-            z.object({
+            z.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4095,12 +4631,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) {
@@ -4111,18 +4647,32 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => [
-            key,
-            this.makePrimitiveFilterSchema(def.type, !!def.optional)
-          ]))).optional();
+          fields[uniqueField.name] = z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+            invariant8(!def.relation, "unique field cannot be a relation");
+            let fieldSchema;
+            const enumDef = getEnum(this.schema, def.type);
+            if (enumDef) {
+              if (Object.keys(enumDef).length > 0) {
+                fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
+              } else {
+                fieldSchema = z.never();
+              }
+            } else {
+              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
+            }
+            return [
+              key,
+              fieldSchema
+            ];
+          }))).optional();
         }
       }
     }
-    fields["$expr"] = z.function().optional();
+    fields["$expr"] = z.custom((v) => typeof v === "function").optional();
     fields["AND"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
     fields["OR"] = z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
     fields["NOT"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = z.object(fields).strict();
+    const baseWhere = z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4141,21 +4691,25 @@ 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.object({
-        equals: components.equals,
-        in: components.in,
-        notIn: components.notIn,
-        not: components.not
-      })
+      z.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
-    return z.object({
+    return z.strictObject({
       equals: this.makePrimitiveSchema(type).array().optional(),
       has: this.makePrimitiveSchema(type).optional(),
       hasEvery: this.makePrimitiveSchema(type).array().optional(),
@@ -4163,39 +4717,59 @@ var InputValidator = class {
       isEmpty: z.boolean().optional()
     });
   }
-  makePrimitiveFilterSchema(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)).exhaustive();
+  makePrimitiveFilterSchema(type, optional, withAggregations) {
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.makeTypeDefFilterSchema(type, optional);
+    }
+    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.object({
-        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.object({
-        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(),
@@ -4204,20 +4778,70 @@ 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.object(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, withAggregations) {
+    return z.union([
+      this.nullableIf(z.string(), optional),
+      z.strictObject({
+        ...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(),
+        ...this.providerSupportsCaseSensitivity ? {
+          mode: this.makeStringModeSchema().optional()
+        } : {}
+      })
+    ]);
   }
-  makeStringFilterSchema(optional) {
-    return this.makeCommonPrimitiveFilterSchema(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional)));
+  makeStringModeSchema() {
+    return z.union([
+      z.literal("default"),
+      z.literal("insensitive")
+    ]);
   }
   makeSelectSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4227,7 +4851,7 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = z.union([
           z.literal(true),
-          z.object({
+          z.strictObject({
             select: z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional()
           })
@@ -4236,22 +4860,24 @@ var InputValidator = class {
         fields[field] = z.boolean().optional();
       }
     }
-    const toManyRelations = Object.entries(modelDef.fields).filter(([, value]) => value.relation && value.array);
+    const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
       fields["_count"] = z.union([
         z.literal(true),
-        z.object(toManyRelations.reduce((acc, [name, fieldDef]) => ({
-          ...acc,
-          [name]: z.union([
-            z.boolean(),
-            z.object({
-              where: this.makeWhereSchema(fieldDef.type, false, false)
-            })
-          ]).optional()
-        }), {}))
+        z.strictObject({
+          select: z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+            ...acc,
+            [fieldDef.name]: z.union([
+              z.boolean(),
+              z.strictObject({
+                where: this.makeWhereSchema(fieldDef.type, false, false)
+              })
+            ]).optional()
+          }), {}))
+        })
       ]).optional();
     }
-    return z.object(fields).strict();
+    return z.strictObject(fields);
   }
   makeOmitSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4262,7 +4888,7 @@ var InputValidator = class {
         fields[field] = z.boolean().optional();
       }
     }
-    return z.object(fields).strict();
+    return z.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4272,15 +4898,20 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = z.union([
           z.literal(true),
-          z.object({
+          z.strictObject({
             select: z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
-            where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+            omit: z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
+            where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional(),
+            orderBy: z.lazy(() => this.makeOrderBySchema(fieldDef.type, true, false)).optional(),
+            skip: this.makeSkipSchema().optional(),
+            take: this.makeTakeSchema().optional(),
+            distinct: this.makeDistinctSchema(fieldDef.type).optional()
           })
         ]).optional();
       }
     }
-    return z.object(fields).strict();
+    return z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
@@ -4293,13 +4924,21 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = z.lazy(() => this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation).optional());
+          fields[field] = z.lazy(() => {
+            let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
+            if (fieldDef.array) {
+              relationOrderBy = relationOrderBy.extend({
+                _count: sort
+              });
+            }
+            return relationOrderBy.optional();
+          });
         }
       } else {
         if (fieldDef.optional) {
           fields[field] = z.union([
             sort,
-            z.object({
+            z.strictObject({
               sort,
               nulls: z.union([
                 z.literal("first"),
@@ -4324,7 +4963,7 @@ var InputValidator = class {
         fields[agg] = z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return z.object(fields);
+    return z.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4343,7 +4982,7 @@ var InputValidator = class {
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeCreateManySchema(model) {
@@ -4351,15 +4990,15 @@ var InputValidator = class {
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.merge(z.object({
+    const result = base.merge(z.strictObject({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
     return this.refineForSelectOmitMutuallyExclusive(result).optional();
   }
   makeCreateDataSchema(model, canBeArray, withoutFields = [], withoutRelationFields = false) {
-    const regularAndFkFields = {};
-    const regularAndRelationFields = {};
+    const uncheckedVariantFields = {};
+    const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
     const hasRelation = !withoutRelationFields && Object.entries(modelDef.fields).some(([f, def]) => !withoutFields.includes(f) && def.relation);
     Object.keys(modelDef.fields).forEach((field) => {
@@ -4370,6 +5009,9 @@ var InputValidator = class {
       if (fieldDef.computed) {
         return;
       }
+      if (this.isDelegateDiscriminator(fieldDef)) {
+        return;
+      }
       if (fieldDef.relation) {
         if (withoutRelationFields) {
           return;
@@ -4401,13 +5043,16 @@ var InputValidator = class {
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
-        regularAndRelationFields[field] = fieldSchema;
+        checkedVariantFields[field] = fieldSchema;
+        if (fieldDef.array || !fieldDef.relation.references) {
+          uncheckedVariantFields[field] = fieldSchema;
+        }
       } else {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type);
         if (fieldDef.array) {
           fieldSchema = z.union([
             z.array(fieldSchema),
-            z.object({
+            z.strictObject({
               set: z.array(fieldSchema)
             })
           ]).optional();
@@ -4418,27 +5063,34 @@ var InputValidator = class {
         if (fieldDef.optional) {
           fieldSchema = fieldSchema.nullable();
         }
-        regularAndFkFields[field] = fieldSchema;
+        uncheckedVariantFields[field] = fieldSchema;
         if (!fieldDef.foreignKeyFor) {
-          regularAndRelationFields[field] = fieldSchema;
+          checkedVariantFields[field] = fieldSchema;
         }
       }
     });
     if (!hasRelation) {
-      return this.orArray(z.object(regularAndFkFields).strict(), canBeArray);
+      return this.orArray(z.strictObject(uncheckedVariantFields), canBeArray);
     } else {
       return z.union([
-        z.object(regularAndFkFields).strict(),
-        z.object(regularAndRelationFields).strict(),
+        z.strictObject(uncheckedVariantFields),
+        z.strictObject(checkedVariantFields),
         ...canBeArray ? [
-          z.array(z.object(regularAndFkFields).strict())
+          z.array(z.strictObject(uncheckedVariantFields))
         ] : [],
         ...canBeArray ? [
-          z.array(z.object(regularAndRelationFields).strict())
+          z.array(z.strictObject(checkedVariantFields))
         ] : []
       ]);
     }
   }
+  isDelegateDiscriminator(fieldDef) {
+    if (!fieldDef.originModel) {
+      return false;
+    }
+    const discriminatorField = getDiscriminatorField(this.schema, fieldDef.originModel);
+    return discriminatorField === fieldDef.name;
+  }
   makeRelationManipulationSchema(fieldDef, withoutFields, mode) {
     const fieldType = fieldDef.type;
     const array = !!fieldDef.array;
@@ -4455,31 +5107,31 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(z.object({
+      fields["update"] = array ? this.orArray(z.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional() : z.union([
-        z.object({
+        z.strictObject({
           where: this.makeWhereSchema(fieldType, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
       ]).optional();
-      fields["upsert"] = this.orArray(z.object({
+      fields["upsert"] = this.orArray(z.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         create: this.makeCreateDataSchema(fieldType, false, withoutFields),
         update: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional();
       if (array) {
         fields["set"] = this.makeSetDataSchema(fieldType, true).optional();
-        fields["updateMany"] = this.orArray(z.object({
+        fields["updateMany"] = this.orArray(z.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return z.object(fields).strict().refine((v) => Object.keys(v).length > 0, "At least one action is required");
+    return z.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4509,13 +5161,13 @@ var InputValidator = class {
     return this.orArray(z.object({
       where: whereSchema,
       create: createSchema
-    }).strict(), canBeArray);
+    }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
     return z.object({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
       skipDuplicates: z.boolean().optional()
-    }).strict();
+    });
   }
   // #endregion
   // #region Update
@@ -4526,19 +5178,19 @@ var InputValidator = class {
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateManySchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: z.number().int().nonnegative().optional()
-    }).strict();
+      limit: z.int().nonnegative().optional()
+    });
   }
   makeUpdateManyAndReturnSchema(model) {
     const base = this.makeUpdateManySchema(model);
-    const result = base.merge(z.object({
+    const result = base.merge(z.strictObject({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
@@ -4552,12 +5204,12 @@ var InputValidator = class {
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateDataSchema(model, withoutFields = [], withoutRelationFields = false) {
-    const regularAndFkFields = {};
-    const regularAndRelationFields = {};
+    const uncheckedVariantFields = {};
+    const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
     const hasRelation = Object.entries(modelDef.fields).some(([key, value]) => value.relation && !withoutFields.includes(key));
     Object.keys(modelDef.fields).forEach((field) => {
@@ -4582,7 +5234,10 @@ var InputValidator = class {
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
-        regularAndRelationFields[field] = fieldSchema;
+        checkedVariantFields[field] = fieldSchema;
+        if (fieldDef.array || !fieldDef.relation.references) {
+          uncheckedVariantFields[field] = fieldSchema;
+        }
       } else {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type).optional();
         if (this.isNumericField(fieldDef)) {
@@ -4609,18 +5264,18 @@ var InputValidator = class {
         if (fieldDef.optional) {
           fieldSchema = fieldSchema.nullable();
         }
-        regularAndFkFields[field] = fieldSchema;
+        uncheckedVariantFields[field] = fieldSchema;
         if (!fieldDef.foreignKeyFor) {
-          regularAndRelationFields[field] = fieldSchema;
+          checkedVariantFields[field] = fieldSchema;
         }
       }
     });
     if (!hasRelation) {
-      return z.object(regularAndFkFields).strict();
+      return z.strictObject(uncheckedVariantFields);
     } else {
       return z.union([
-        z.object(regularAndFkFields).strict(),
-        z.object(regularAndRelationFields).strict()
+        z.strictObject(uncheckedVariantFields),
+        z.strictObject(checkedVariantFields)
       ]);
     }
   }
@@ -4631,25 +5286,25 @@ var InputValidator = class {
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeDeleteManySchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: z.number().int().nonnegative().optional()
-    }).strict().optional();
+      limit: z.int().nonnegative().optional()
+    }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: z.number().int().nonnegative().optional(),
-      take: z.number().int().optional(),
+      skip: this.makeSkipSchema().optional(),
+      take: this.makeTakeSchema().optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
       select: this.makeCountAggregateInputSchema(model).optional()
-    }).strict().optional();
+    }).optional();
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4661,7 +5316,7 @@ var InputValidator = class {
           acc[field] = z.literal(true).optional();
           return acc;
         }, {})
-      }).strict()
+      })
     ]);
   }
   // #endregion
@@ -4669,19 +5324,19 @@ var InputValidator = class {
   makeAggregateSchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: z.number().int().nonnegative().optional(),
-      take: z.number().int().optional(),
+      skip: this.makeSkipSchema().optional(),
+      take: this.makeTakeSchema().optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
       _avg: this.makeSumAvgInputSchema(model).optional(),
       _sum: this.makeSumAvgInputSchema(model).optional(),
       _min: this.makeMinMaxInputSchema(model).optional(),
       _max: this.makeMinMaxInputSchema(model).optional()
-    }).strict().optional();
+    }).optional();
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
         acc[field] = z.literal(true).optional();
@@ -4691,7 +5346,7 @@ var InputValidator = class {
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
         acc[field] = z.literal(true).optional();
@@ -4706,30 +5361,42 @@ 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(),
-      skip: z.number().int().nonnegative().optional(),
-      take: z.number().int().optional(),
+      having: this.makeHavingSchema(model).optional(),
+      skip: this.makeSkipSchema().optional(),
+      take: this.makeTakeSchema().optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
       _avg: this.makeSumAvgInputSchema(model).optional(),
       _sum: this.makeSumAvgInputSchema(model).optional(),
       _min: this.makeMinMaxInputSchema(model).optional(),
       _max: this.makeMinMaxInputSchema(model).optional()
-    }).strict();
+    });
     schema = schema.refine((value) => {
       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;
@@ -4737,8 +5404,31 @@ 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.int().nonnegative();
+  }
+  makeTakeSchema() {
+    return z.int();
+  }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
   }
@@ -4757,6 +5447,9 @@ var InputValidator = class {
   isNumericField(fieldDef) {
     return NUMERIC_FIELD_TYPES.includes(fieldDef.type) && !fieldDef.array;
   }
+  get providerSupportsCaseSensitivity() {
+    return this.schema.provider.type === "postgresql";
+  }
 };
 
 // src/client/executor/zenstack-driver.ts
@@ -4766,11 +5459,11 @@ var ZenStackDriver = class {
   }
   #driver;
   #log;
-  txConnection;
   #initPromise;
   #initDone;
   #destroyPromise;
   #connections = /* @__PURE__ */ new WeakSet();
+  #txConnections = /* @__PURE__ */ new WeakMap();
   constructor(driver, log) {
     this.#initDone = false;
     this.#driver = driver;
@@ -4811,21 +5504,30 @@ var ZenStackDriver = class {
   }
   async beginTransaction(connection, settings) {
     const result = await this.#driver.beginTransaction(connection, settings);
-    this.txConnection = connection;
+    this.#txConnections.set(connection, []);
     return result;
   }
-  commitTransaction(connection) {
+  async commitTransaction(connection) {
     try {
-      return this.#driver.commitTransaction(connection);
-    } finally {
-      this.txConnection = void 0;
+      const result = await this.#driver.commitTransaction(connection);
+      const callbacks = this.#txConnections.get(connection);
+      this.#txConnections.delete(connection);
+      if (callbacks) {
+        for (const callback of callbacks) {
+          await callback();
+        }
+      }
+      return result;
+    } catch (err) {
+      this.#txConnections.delete(connection);
+      throw err;
     }
   }
-  rollbackTransaction(connection) {
+  async rollbackTransaction(connection) {
     try {
-      return this.#driver.rollbackTransaction(connection);
+      return await this.#driver.rollbackTransaction(connection);
     } finally {
-      this.txConnection = void 0;
+      this.#txConnections.delete(connection);
     }
   }
   async destroy() {
@@ -4903,6 +5605,22 @@ var ZenStackDriver = class {
   #calculateDurationMillis(startTime) {
     return performanceNow() - startTime;
   }
+  isTransactionConnection(connection) {
+    return this.#txConnections.has(connection);
+  }
+  registerTransactionCommitCallback(connection, callback) {
+    if (!this.#txConnections.has(connection)) {
+      return;
+    }
+    const callbacks = this.#txConnections.get(connection);
+    if (callbacks) {
+      callbacks.push(callback);
+    } else {
+      this.#txConnections.set(connection, [
+        callback
+      ]);
+    }
+  }
 };
 function performanceNow() {
   if (typeof performance !== "undefined" && typeof performance.now === "function") {
@@ -4914,9 +5632,10 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode3, SelectionNode as SelectionNode4, SingleConnectionProvider, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
+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 { match as match15 } from "ts-pattern";
+import { inspect as inspect2 } from "util";
+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";
@@ -4925,11 +5644,11 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     __name(this, "QueryNameMapper");
   }
   schema;
-  modelToTableMap;
-  fieldToColumnMap;
-  modelStack;
+  modelToTableMap = /* @__PURE__ */ new Map();
+  fieldToColumnMap = /* @__PURE__ */ new Map();
+  modelStack = [];
   constructor(schema) {
-    super(), this.schema = schema, this.modelToTableMap = /* @__PURE__ */ new Map(), this.fieldToColumnMap = /* @__PURE__ */ new Map(), this.modelStack = [];
+    super(), this.schema = schema;
     for (const [modelName, modelDef] of Object.entries(schema.models)) {
       const mappedName = this.getMappedName(modelDef);
       if (mappedName) {
@@ -5118,7 +5837,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     this.requireCurrentModel(contextNode);
     model = model ?? this.currentModel;
     const modelDef = requireModel(this.schema, model);
-    const scalarFields = Object.entries(modelDef.fields).filter(([, fieldDef]) => !fieldDef.relation && !fieldDef.computed).map(([fieldName]) => fieldName);
+    const scalarFields = Object.entries(modelDef.fields).filter(([, fieldDef]) => !fieldDef.relation && !fieldDef.computed && !fieldDef.originModel).map(([fieldName]) => fieldName);
     return scalarFields;
   }
 };
@@ -5143,16 +5862,18 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   get options() {
     return this.client.$options;
   }
-  async executeQuery(compiledQuery, queryId) {
+  async executeQuery(compiledQuery, _queryId) {
     let queryNode = compiledQuery.query;
     let mutationInterceptionInfo;
     if (this.isMutationNode(queryNode) && this.hasMutationHooks) {
       mutationInterceptionInfo = await this.callMutationInterceptionFilters(queryNode);
     }
     const task = /* @__PURE__ */ __name(async () => {
-      await this.callBeforeMutationHooks(queryNode, mutationInterceptionInfo);
+      if (this.isMutationNode(queryNode)) {
+        await this.callBeforeMutationHooks(queryNode, mutationInterceptionInfo);
+      }
       const oldQueryNode = queryNode;
-      if ((InsertQueryNode2.is(queryNode) || DeleteQueryNode2.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
+      if ((InsertQueryNode2.is(queryNode) || UpdateQueryNode2.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
         queryNode = {
           ...queryNode,
           returning: ReturningNode3.create([
@@ -5160,42 +5881,73 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
           ])
         };
       }
-      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryId);
-      await this.callAfterQueryInterceptionFilters(result, queryNode, mutationInterceptionInfo);
+      const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
+      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryParams);
+      if (this.isMutationNode(queryNode)) {
+        await this.callAfterMutationHooks(result.result, queryNode, mutationInterceptionInfo, result.connection);
+      }
       if (oldQueryNode !== queryNode) {
       }
-      return result;
+      return result.result;
     }, "task");
-    return this.executeWithTransaction(task, !!mutationInterceptionInfo?.useTransactionForMutation);
-  }
-  proceedQueryWithKyselyInterceptors(queryNode, queryId) {
-    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, queryId), "proceed");
-    const makeTx = /* @__PURE__ */ __name((p) => (callback) => {
-      return this.executeWithTransaction(() => callback(p));
-    }, "makeTx");
-    const hooks = this.options.plugins?.filter((plugin) => typeof plugin.onKyselyQuery === "function").map((plugin) => plugin.onKyselyQuery.bind(plugin)) ?? [];
+    return task();
+  }
+  proceedQueryWithKyselyInterceptors(queryNode, parameters) {
+    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters), "proceed");
+    const hooks = [];
+    for (const plugin of this.client.$options.plugins ?? []) {
+      if (plugin.onKyselyQuery) {
+        hooks.push(plugin.onKyselyQuery.bind(plugin));
+      }
+    }
     for (const hook of hooks) {
       const _proceed = proceed;
-      proceed = /* @__PURE__ */ __name((query) => {
-        return hook({
+      proceed = /* @__PURE__ */ __name(async (query) => {
+        let connection;
+        const _p = /* @__PURE__ */ __name(async (q) => {
+          const r = await _proceed(q);
+          connection = r.connection;
+          return r.result;
+        }, "_p");
+        const hookResult = await hook({
           client: this.client,
           schema: this.client.$schema,
           kysely: this.kysely,
           query,
-          proceed: _proceed,
-          transaction: makeTx(_proceed)
+          proceed: _p
         });
+        return {
+          result: hookResult,
+          connection
+        };
       }, "proceed");
     }
     return proceed(queryNode);
   }
-  async proceedQuery(query, queryId) {
+  async proceedQuery(query, parameters) {
     const finalQuery = this.nameMapper.transformNode(query);
-    const compiled = this.compileQuery(finalQuery);
+    let compiled = this.compileQuery(finalQuery);
+    if (parameters) {
+      compiled = {
+        ...compiled,
+        parameters
+      };
+    }
     try {
-      return this.driver.txConnection ? await super.withConnectionProvider(new SingleConnectionProvider(this.driver.txConnection)).executeQuery(compiled, queryId) : await super.executeQuery(compiled, queryId);
+      return await this.provideConnection(async (connection) => {
+        const result = await connection.executeQuery(compiled);
+        return {
+          result,
+          connection
+        };
+      });
     } catch (err) {
-      throw new QueryError(`Failed to execute query: ${err}, sql: ${compiled.sql}, parameters: ${compiled.parameters}`);
+      let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
+      if (this.options.debug) {
+        message += `, parameters: 
+${compiled.parameters.map((p) => inspect2(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
   }
   isMutationNode(queryNode) {
@@ -5223,30 +5975,15 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
     return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, []);
   }
   withConnectionProvider(connectionProvider) {
-    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider);
-  }
-  async executeWithTransaction(callback, useTransaction = true) {
-    if (!useTransaction || this.driver.txConnection) {
-      return callback();
-    } else {
-      return this.provideConnection(async (connection) => {
-        try {
-          await this.driver.beginTransaction(connection, {});
-          const result = await callback();
-          await this.driver.commitTransaction(connection);
-          return result;
-        } catch (error) {
-          await this.driver.rollbackTransaction(connection);
-          throw error;
-        }
-      });
-    }
+    const newExecutor = new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider);
+    newExecutor.client = this.client.withExecutor(newExecutor);
+    return newExecutor;
   }
   get hasMutationHooks() {
     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`);
       }
@@ -5262,7 +5999,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       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) => ({
@@ -5282,14 +6019,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
             queryNode
           });
           result.intercept ||= filterResult.intercept;
-          result.useTransactionForMutation ||= filterResult.useTransactionForMutation;
           result.loadBeforeMutationEntity ||= filterResult.loadBeforeMutationEntity;
           result.loadAfterMutationEntity ||= filterResult.loadAfterMutationEntity;
         }
       }
       let beforeMutationEntities;
       if (result.loadBeforeMutationEntity && (UpdateQueryNode2.is(queryNode) || DeleteQueryNode2.is(queryNode))) {
-        beforeMutationEntities = await this.loadEntities(this.kysely, mutationModel, where);
+        beforeMutationEntities = await this.loadEntities(mutationModel, where);
       }
       return {
         ...result,
@@ -5302,16 +6038,16 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       return void 0;
     }
   }
-  callBeforeMutationHooks(queryNode, mutationInterceptionInfo) {
+  async callBeforeMutationHooks(queryNode, mutationInterceptionInfo) {
     if (!mutationInterceptionInfo?.intercept) {
       return;
     }
     if (this.options.plugins) {
+      const mutationModel = this.getMutationModel(queryNode);
       for (const plugin of this.options.plugins) {
         if (plugin.beforeEntityMutation) {
-          plugin.beforeEntityMutation({
-            // context: this.queryContext,
-            model: this.getMutationModel(queryNode),
+          await plugin.beforeEntityMutation({
+            model: mutationModel,
             action: mutationInterceptionInfo.action,
             queryNode,
             entities: mutationInterceptionInfo.beforeMutationEntities
@@ -5320,44 +6056,59 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       }
     }
   }
-  async callAfterQueryInterceptionFilters(queryResult, queryNode, mutationInterceptionInfo) {
+  async callAfterMutationHooks(queryResult, queryNode, mutationInterceptionInfo, connection) {
     if (!mutationInterceptionInfo?.intercept) {
       return;
     }
-    if (this.options.plugins) {
-      const mutationModel = this.getMutationModel(queryNode);
-      for (const plugin of this.options.plugins) {
-        if (plugin.afterEntityMutation) {
-          let afterMutationEntities = void 0;
-          if (mutationInterceptionInfo.loadAfterMutationEntity) {
-            if (UpdateQueryNode2.is(queryNode)) {
-              afterMutationEntities = await this.loadEntities(this.kysely, mutationModel, mutationInterceptionInfo.where);
-            } else {
-              afterMutationEntities = queryResult.rows;
-            }
-          }
-          plugin.afterEntityMutation({
-            model: this.getMutationModel(queryNode),
+    const hooks = [];
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.afterEntityMutation) {
+        hooks.push(plugin.afterEntityMutation.bind(plugin));
+      }
+    }
+    if (hooks.length === 0) {
+      return;
+    }
+    const mutationModel = this.getMutationModel(queryNode);
+    const inTransaction = this.driver.isTransactionConnection(connection);
+    for (const hook of hooks) {
+      let afterMutationEntities = void 0;
+      if (mutationInterceptionInfo.loadAfterMutationEntity) {
+        if (InsertQueryNode2.is(queryNode) || UpdateQueryNode2.is(queryNode)) {
+          afterMutationEntities = queryResult.rows;
+        }
+      }
+      const action = /* @__PURE__ */ __name(async () => {
+        try {
+          await hook({
+            model: mutationModel,
             action: mutationInterceptionInfo.action,
             queryNode,
             beforeMutationEntities: mutationInterceptionInfo.beforeMutationEntities,
             afterMutationEntities
           });
+        } catch (err) {
+          console.error(`Error in afterEntityMutation hook for model "${mutationModel}": ${err}`);
         }
+      }, "action");
+      if (inTransaction) {
+        this.driver.registerTransactionCommitCallback(connection, action);
+      } else {
+        await action();
       }
     }
   }
-  async loadEntities(kysely, model, where) {
-    const selectQuery = kysely.selectFrom(model).selectAll();
+  async loadEntities(model, where) {
+    const selectQuery = this.kysely.selectFrom(model).selectAll();
     let selectQueryNode = selectQuery.toOperationNode();
     selectQueryNode = {
       ...selectQueryNode,
       where: this.andNodes(selectQueryNode.where, where)
     };
-    const compiled = kysely.getExecutor().compileQuery(selectQueryNode, {
+    const compiled = this.compileQuery(selectQueryNode);
+    const result = await this.executeQuery(compiled, {
       queryId: `zenstack-${nanoid2()}`
     });
-    const result = await kysely.executeQuery(compiled);
     return result.rows;
   }
   andNodes(condition1, condition2) {
@@ -5386,9 +6137,9 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-import { sql as sql8, ValueNode as ValueNode4 } from "kysely";
-import invariant8 from "tiny-invariant";
-import { match as match16 } from "ts-pattern";
+import { invariant as invariant9, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
+import { sql as sql7, ValueNode as ValueNode4 } from "kysely";
+import { match as match17 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
   if (!field) {
@@ -5398,9 +6149,9 @@ var contains = /* @__PURE__ */ __name((eb, args) => {
     throw new Error('"search" parameter is required');
   }
   const searchExpr = eb.fn("CONCAT", [
-    sql8.lit("%"),
+    sql7.lit("%"),
     search2,
-    sql8.lit("%")
+    sql7.lit("%")
   ]);
   return eb(field, caseInsensitive ? "ilike" : "like", searchExpr);
 }, "contains");
@@ -5417,7 +6168,7 @@ var startsWith = /* @__PURE__ */ __name((eb, args) => {
   }
   return eb(field, "like", eb.fn("CONCAT", [
     search2,
-    sql8.lit("%")
+    sql7.lit("%")
   ]));
 }, "startsWith");
 var endsWith = /* @__PURE__ */ __name((eb, args) => {
@@ -5429,7 +6180,7 @@ var endsWith = /* @__PURE__ */ __name((eb, args) => {
     throw new Error('"search" parameter is required');
   }
   return eb(field, "like", eb.fn("CONCAT", [
-    sql8.lit("%"),
+    sql7.lit("%"),
     search2
   ]));
 }, "endsWith");
@@ -5470,10 +6221,10 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   if (!field) {
     throw new Error('"field" parameter is required');
   }
-  return eb(dialect.buildArrayLength(eb, field), "=", sql8.lit(0));
+  return eb(dialect.buildArrayLength(eb, field), "=", sql7.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", () => sql7.raw("CURRENT_TIMESTAMP")).exhaustive();
 }, "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
@@ -5481,7 +6232,7 @@ var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   if (casing) {
     result = processCasing(casing, result, model);
   }
-  return sql8.lit(result);
+  return sql7.lit(result);
 }, "currentModel");
 var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   let result = operation;
@@ -5489,12 +6240,12 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   if (casing) {
     result = processCasing(casing, result, operation);
   }
-  return sql8.lit(result);
+  return sql7.lit(result);
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  invariant8(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", () => `${result.charAt(0).toUpperCase() + result.slice(1)}`).with("uncapitalize", () => `${result.charAt(0).toLowerCase() + result.slice(1)}`).otherwise(() => {
+  invariant9(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  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;
@@ -5502,9 +6253,9 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
-import { sql as sql9 } from "kysely";
-import invariant9 from "tiny-invariant";
-import { match as match17 } from "ts-pattern";
+import { invariant as invariant10 } from "@zenstackhq/common-helpers";
+import { sql as sql8 } from "kysely";
+import { match as match18 } from "ts-pattern";
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -5535,14 +6286,17 @@ var SchemaDbPusher = class {
     for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
       if (fieldDef.relation) {
         table = this.addForeignKeyConstraint(table, model, fieldName, fieldDef);
-      } else {
+      } else if (!this.isComputedField(fieldDef)) {
         table = this.createModelField(table, fieldName, fieldDef, modelDef);
       }
     }
     table = this.addPrimaryKeyConstraint(table, model, modelDef);
-    table = this.addUniqueConstraint(table, modelDef);
+    table = this.addUniqueConstraint(table, model, modelDef);
     return table;
   }
+  isComputedField(fieldDef) {
+    return fieldDef.attributes?.some((a) => a.name === "@computed");
+  }
   addPrimaryKeyConstraint(table, model, modelDef) {
     if (modelDef.idFields.length === 1) {
       if (Object.values(modelDef.fields).some((f) => f.id)) {
@@ -5554,16 +6308,19 @@ var SchemaDbPusher = class {
     }
     return table;
   }
-  addUniqueConstraint(table, modelDef) {
+  addUniqueConstraint(table, model, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      invariant9(typeof value === "object", "expecting an object");
+      invariant10(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
           continue;
         }
+        table = table.addUniqueConstraint(`unique_${model}_${key}`, [
+          key
+        ]);
       } else {
-        table = table.addUniqueConstraint(`unique_${key}`, Object.keys(value));
+        table = table.addUniqueConstraint(`unique_${model}_${key}`, Object.keys(value));
       }
     }
     return table;
@@ -5576,7 +6333,7 @@ var SchemaDbPusher = class {
       if (fieldDef.default !== void 0) {
         if (typeof fieldDef.default === "object" && "kind" in fieldDef.default) {
           if (ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "now") {
-            col = col.defaultTo(sql9`CURRENT_TIMESTAMP`);
+            col = col.defaultTo(sql8`CURRENT_TIMESTAMP`);
           }
         } else {
           col = col.defaultTo(fieldDef.default);
@@ -5596,17 +6353,17 @@ var SchemaDbPusher = class {
   }
   mapFieldType(fieldDef) {
     if (this.schema.enums?.[fieldDef.type]) {
-      return this.schema.provider.type === "postgresql" ? sql9.ref(fieldDef.type) : "text";
+      return this.schema.provider.type === "postgresql" ? sql8.ref(fieldDef.type) : "text";
     }
     if (this.isAutoIncrement(fieldDef) && this.schema.provider.type === "postgresql") {
       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").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) {
-      return sql9.raw(`${result}[]`);
+      return sql8.raw(`${result}[]`);
     } else {
       return result;
     }
@@ -5615,7 +6372,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    invariant9(fieldDef.relation, "field must be a relation");
+    invariant10(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -5631,16 +6388,16 @@ 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();
   }
 };
 
 // src/client/promise.ts
-function createDeferredPromise(callback) {
+function createZenStackPromise(callback) {
   let promise;
-  const cb = /* @__PURE__ */ __name(() => {
+  const cb = /* @__PURE__ */ __name((txClient) => {
     try {
-      return promise ??= valueToPromise(callback());
+      return promise ??= valueToPromise(callback(txClient));
     } catch (err) {
       return Promise.reject(err);
     }
@@ -5655,10 +6412,11 @@ function createDeferredPromise(callback) {
     finally(onFinally) {
       return cb().finally(onFinally);
     },
+    cb,
     [Symbol.toStringTag]: "ZenStackPromise"
   };
 }
-__name(createDeferredPromise, "createDeferredPromise");
+__name(createZenStackPromise, "createZenStackPromise");
 function valueToPromise(thing) {
   if (typeof thing === "object" && typeof thing?.then === "function") {
     return thing;
@@ -5669,9 +6427,9 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
+import { invariant as invariant11 } from "@zenstackhq/common-helpers";
 import Decimal2 from "decimal.js";
-import invariant10 from "tiny-invariant";
-import { match as match18 } from "ts-pattern";
+import { match as match19 } from "ts-pattern";
 var ResultProcessor = class {
   static {
     __name(this, "ResultProcessor");
@@ -5705,6 +6463,21 @@ var ResultProcessor = class {
         data[key] = typeof value === "string" ? JSON.parse(value) : value;
         continue;
       }
+      if (key.startsWith(DELEGATE_JOINED_FIELD_PREFIX)) {
+        if (value) {
+          const subRow = this.transformJson(value);
+          const subModel = key.slice(DELEGATE_JOINED_FIELD_PREFIX.length);
+          const idValues = getIdValues(this.schema, subModel, subRow);
+          if (Object.values(idValues).some((v) => v === null || v === void 0)) {
+            delete data[key];
+            continue;
+          }
+          const processedSubRow = this.processRow(subRow, subModel);
+          Object.assign(data, processedSubRow);
+        }
+        delete data[key];
+        continue;
+      }
       const fieldDef = getField(this.schema, model, key);
       if (!fieldDef) {
         continue;
@@ -5744,20 +6517,24 @@ var ResultProcessor = class {
     return this.doProcessResult(relationData, fieldDef.type);
   }
   transformScalar(value, type) {
-    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)).otherwise(() => value);
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.transformJson(value);
+    } else {
+      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) {
     if (value instanceof Decimal2) {
       return value;
     }
-    invariant10(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
+    invariant11(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
     return new Decimal2(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    invariant10(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    invariant11(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -5776,6 +6553,9 @@ var ResultProcessor = class {
     return Buffer.isBuffer(value) ? Uint8Array.from(value) : value;
   }
   fixReversedResult(data, model, args) {
+    if (!data) {
+      return;
+    }
     if (Array.isArray(data) && typeof args === "object" && args && args.take !== void 0 && args.take < 0) {
       data.reverse();
     }
@@ -5789,13 +6569,19 @@ var ResultProcessor = class {
           continue;
         }
         const fieldDef = getField(this.schema, model, field);
-        if (!fieldDef?.relation) {
+        if (!fieldDef || !fieldDef.relation || !fieldDef.array) {
           continue;
         }
         this.fixReversedResult(row[field], fieldDef.type, value);
       }
     }
   }
+  transformJson(value) {
+    return match19(this.schema.provider.type).with("sqlite", () => {
+      invariant11(typeof value === "string", "Expected string, got " + typeof value);
+      return JSON.parse(value);
+    }).otherwise(() => value);
+  }
 };
 
 // src/client/client-impl.ts
@@ -5814,7 +6600,7 @@ var ClientImpl = class _ClientImpl {
   $schema;
   kyselyProps;
   auth;
-  constructor(schema, options, baseClient) {
+  constructor(schema, options, baseClient, executor) {
     this.schema = schema;
     this.options = options;
     this.$schema = schema;
@@ -5826,24 +6612,23 @@ var ClientImpl = class _ClientImpl {
     if (baseClient) {
       this.kyselyProps = {
         ...baseClient.kyselyProps,
-        executor: new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
+      this.auth = baseClient.auth;
     } else {
-      const dialect = this.getKyselyDialect();
-      const driver = new ZenStackDriver(dialect.createDriver(), new Log(this.$options.log ?? []));
-      const compiler = dialect.createQueryCompiler();
-      const adapter = dialect.createAdapter();
+      const driver = new ZenStackDriver(options.dialect.createDriver(), new Log(this.$options.log ?? []));
+      const compiler = options.dialect.createQueryCompiler();
+      const adapter = options.dialect.createAdapter();
       const connectionProvider = new DefaultConnectionProvider(driver);
-      const executor = new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider);
       this.kyselyProps = {
         config: {
-          dialect,
+          dialect: options.dialect,
           log: this.$options.log
         },
-        dialect,
+        dialect: options.dialect,
         driver,
-        executor
+        executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
       this.kyselyRaw = new Kysely({
         ...this.kyselyProps,
@@ -5859,31 +6644,58 @@ var ClientImpl = class _ClientImpl {
   get $qbRaw() {
     return this.kyselyRaw;
   }
-  getKyselyDialect() {
-    return match19(this.schema.provider.type).with("sqlite", () => this.makeSqliteKyselyDialect()).with("postgresql", () => this.makePostgresKyselyDialect()).exhaustive();
+  get isTransaction() {
+    return this.kysely.isTransaction;
   }
-  makePostgresKyselyDialect() {
-    const { dialectConfigProvider } = this.schema.provider;
-    const mergedConfig = {
-      ...dialectConfigProvider(),
-      ...this.options?.dialectConfig
-    };
-    return new PostgresDialect(mergedConfig);
+  /**
+   * Create a new client with a new query executor.
+   */
+  withExecutor(executor) {
+    return new _ClientImpl(this.schema, this.$options, this, executor);
   }
-  makeSqliteKyselyDialect() {
-    const { dialectConfigProvider } = this.schema.provider;
-    const mergedConfig = {
-      ...dialectConfigProvider(),
-      ...this.options?.dialectConfig
-    };
-    return new SqliteDialect(mergedConfig);
+  // implementation
+  async $transaction(input, options) {
+    invariant12(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    if (typeof input === "function") {
+      return this.interactiveTransaction(input, options);
+    } else {
+      return this.sequentialTransaction(input, options);
+    }
+  }
+  async interactiveTransaction(callback, options) {
+    if (this.kysely.isTransaction) {
+      return callback(this);
+    } else {
+      let txBuilder = this.kysely.transaction();
+      if (options?.isolationLevel) {
+        txBuilder = txBuilder.setIsolationLevel(options.isolationLevel);
+      }
+      return txBuilder.execute((tx) => {
+        const txClient = new _ClientImpl(this.schema, this.$options, this);
+        txClient.kysely = tx;
+        return callback(txClient);
+      });
+    }
   }
-  async $transaction(callback) {
-    return this.kysely.transaction().execute((tx) => {
-      const txClient = new _ClientImpl(this.schema, this.$options);
+  async sequentialTransaction(arg, options) {
+    const execute = /* @__PURE__ */ __name(async (tx) => {
+      const txClient = new _ClientImpl(this.schema, this.$options, this);
       txClient.kysely = tx;
-      return callback(txClient);
-    });
+      const result = [];
+      for (const promise of arg) {
+        result.push(await promise.cb(txClient));
+      }
+      return result;
+    }, "execute");
+    if (this.kysely.isTransaction) {
+      return execute(this.kysely);
+    } else {
+      let txBuilder = this.kysely.transaction();
+      if (options?.isolationLevel) {
+        txBuilder = txBuilder.setIsolationLevel(options.isolationLevel);
+      }
+      return txBuilder.execute((tx) => execute(tx));
+    }
   }
   get $procedures() {
     return Object.keys(this.$schema.procedures ?? {}).reduce((acc, name) => {
@@ -5911,12 +6723,26 @@ var ClientImpl = class _ClientImpl {
     await new SchemaDbPusher(this.schema, this.kysely).push();
   }
   $use(plugin) {
+    const newPlugins = [
+      ...this.$options.plugins ?? [],
+      plugin
+    ];
     const newOptions = {
       ...this.options,
-      plugins: [
-        ...this.options?.plugins ?? [],
-        plugin
-      ]
+      plugins: newPlugins
+    };
+    return new _ClientImpl(this.schema, newOptions, this);
+  }
+  $unuse(pluginId) {
+    const newPlugins = [];
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.id !== pluginId) {
+        newPlugins.push(plugin);
+      }
+    }
+    const newOptions = {
+      ...this.options,
+      plugins: newPlugins
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }
@@ -5938,6 +6764,39 @@ var ClientImpl = class _ClientImpl {
   get $auth() {
     return this.auth;
   }
+  $executeRaw(query, ...values) {
+    return createZenStackPromise(async () => {
+      const result = await sql9(query, ...values).execute(this.kysely);
+      return Number(result.numAffectedRows ?? 0);
+    });
+  }
+  $executeRawUnsafe(query, ...values) {
+    return createZenStackPromise(async () => {
+      const compiledQuery = this.createRawCompiledQuery(query, values);
+      const result = await this.kysely.executeQuery(compiledQuery);
+      return Number(result.numAffectedRows ?? 0);
+    });
+  }
+  $queryRaw(query, ...values) {
+    return createZenStackPromise(async () => {
+      const result = await sql9(query, ...values).execute(this.kysely);
+      return result.rows;
+    });
+  }
+  $queryRawUnsafe(query, ...values) {
+    return createZenStackPromise(async () => {
+      const compiledQuery = this.createRawCompiledQuery(query, values);
+      const result = await this.kysely.executeQuery(compiledQuery);
+      return result.rows;
+    });
+  }
+  createRawCompiledQuery(query, values) {
+    const q = CompiledQuery.raw(query, values);
+    return {
+      ...q,
+      $raw: true
+    };
+  }
 };
 function createClientProxy(client) {
   const inputValidator = new InputValidator(client.$schema);
@@ -5960,9 +6819,9 @@ function createClientProxy(client) {
 __name(createClientProxy, "createClientProxy");
 function createModelCrudHandler(client, model, inputValidator, resultProcessor) {
   const createPromise = /* @__PURE__ */ __name((operation, args, handler, postProcess = false, throwIfNoResult = false) => {
-    return createDeferredPromise(async () => {
-      let proceed = /* @__PURE__ */ __name(async (_args, tx) => {
-        const _handler = tx ? handler.withClient(tx) : handler;
+    return createZenStackPromise(async (txClient) => {
+      let proceed = /* @__PURE__ */ __name(async (_args) => {
+        const _handler = txClient ? handler.withClient(txClient) : handler;
         const r = await _handler.handle(operation, _args ?? args);
         if (!r && throwIfNoResult) {
           throw new NotFoundError(model);
@@ -5975,22 +6834,31 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
         }
         return result;
       }, "proceed");
-      const context = {
-        client,
-        model,
-        operation,
-        queryArgs: args
-      };
       const plugins = [
         ...client.$options.plugins ?? []
       ];
       for (const plugin of plugins) {
-        if (plugin.onQuery) {
-          const _proceed = proceed;
-          proceed = /* @__PURE__ */ __name(() => plugin.onQuery({
-            ...context,
-            proceed: _proceed
-          }), "proceed");
+        if (plugin.onQuery && typeof plugin.onQuery === "object") {
+          for (const [_model, modelHooks] of Object.entries(plugin.onQuery)) {
+            if (_model === lowerCaseFirst2(model) || _model === "$allModels") {
+              if (modelHooks && typeof modelHooks === "object") {
+                for (const [op, opHooks] of Object.entries(modelHooks)) {
+                  if (op === operation || op === "$allOperations") {
+                    if (typeof opHooks === "function") {
+                      const _proceed = proceed;
+                      proceed = /* @__PURE__ */ __name(() => opHooks({
+                        client,
+                        model,
+                        operation,
+                        args,
+                        query: _proceed
+                      }), "proceed");
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       }
       return proceed(args);
@@ -6046,12 +6914,23 @@ 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 GroupByeOperationHandler(client, model, inputValidator));
+      return createPromise("groupBy", args, new GroupByOperationHandler(client, model, inputValidator), true);
     }, "groupBy")
   };
 }
 __name(createModelCrudHandler, "createModelCrudHandler");
+
+// src/client/plugin.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+__name(definePlugin, "definePlugin");
 export {
-  ZenStackClient
+  InputValidationError,
+  InternalError,
+  NotFoundError,
+  QueryError,
+  ZenStackClient,
+  definePlugin
 };
 //# sourceMappingURL=index.js.map