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

package/dist/index.cjs

@@ -31,34 +31,143 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ZenStackClient: () => ZenStackClient
+  InputValidationError: () => InputValidationError,
+  InternalError: () => InternalError,
+  NotFoundError: () => NotFoundError,
+  QueryError: () => QueryError,
+  ZenStackClient: () => ZenStackClient,
+  definePlugin: () => definePlugin
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_kysely16 = require("kysely");
-var import_ts_pattern19 = require("ts-pattern");
 
 // src/client/crud/operations/aggregate.ts
 var import_kysely9 = require("kysely");
-var import_ts_pattern9 = require("ts-pattern");
+var import_ts_pattern10 = require("ts-pattern");
+
+// src/client/query-utils.ts
+var import_ts_pattern = require("ts-pattern");
+
+// src/schema/expression.ts
+var ExpressionUtils = {
+  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 {
@@ -77,7 +186,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];
 }
@@ -141,20 +250,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 = [];
@@ -202,7 +316,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);
   }
@@ -307,13 +421,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 (0, import_ts_pattern.match)(op).with("_count", () => eb.fn.count(expr2)).with("_sum", () => eb.fn.sum(expr2)).with("_avg", () => eb.fn.avg(expr2)).with("_min", () => eb.fn.min(expr2)).with("_max", () => eb.fn.max(expr2)).exhaustive();
+}
+__name(aggregate, "aggregate");
 
 // src/client/crud/operations/base.ts
 var import_cuid2 = require("@paralleldrive/cuid2");
+var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_kysely8 = require("kysely");
 var import_nanoid = require("nanoid");
-var import_tiny_invariant7 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern8 = require("ts-pattern");
+var import_node_util = require("util");
+var import_ts_pattern9 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
 
@@ -330,22 +480,44 @@ var RejectedByPolicyError = class extends Error {
 };
 
 // src/plugins/policy/policy-handler.ts
+var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_kysely7 = require("kysely");
-var import_tiny_invariant6 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern7 = require("ts-pattern");
+var import_ts_pattern8 = require("ts-pattern");
 
 // src/client/crud/dialects/index.ts
-var import_ts_pattern4 = require("ts-pattern");
+var import_ts_pattern5 = require("ts-pattern");
 
 // src/client/crud/dialects/postgresql.ts
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_kysely2 = require("kysely");
-var import_tiny_invariant2 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern2 = require("ts-pattern");
+var import_ts_pattern3 = require("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
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_kysely = require("kysely");
-var import_tiny_invariant = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern = require("ts-pattern");
+var import_ts_pattern2 = require("ts-pattern");
 
 // src/utils/enumerate.ts
 function enumerate(x) {
@@ -362,7 +534,6 @@ function enumerate(x) {
 __name(enumerate, "enumerate");
 
 // src/client/crud/dialects/base.ts
-var import_is_plain_object = require("is-plain-object");
 var BaseCrudDialect = class {
   static {
     __name(this, "BaseCrudDialect");
@@ -373,9 +544,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);
@@ -392,17 +574,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 = buildFieldRef(this.schema, fieldDef.originModel ?? model, key, this.options, 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") {
@@ -410,8 +595,11 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  isLogicalCombinator(key) {
+    return LOGICAL_COMBINATORS.includes(key);
+  }
   buildCompositeFilter(eb, model, modelAlias, key, payload) {
-    return (0, import_ts_pattern.match)(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
+    return (0, import_ts_pattern2.match)(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
   }
   buildRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (!fieldDef.array) {
@@ -420,19 +608,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(import_kysely.sql.ref(`${table}.${fk}`), "is", null)));
+      if (ownedByModel && !fieldDef.originModel) {
+        return this.and(eb, ...keyPairs.map(({ fk }) => eb(import_kysely.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(import_kysely.sql.ref(left), "=", import_kysely.sql.ref(right))))).select(() => eb.fn.count(eb.lit(1)).as(filterResultField));
     const conditions = [];
@@ -493,30 +688,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)));
@@ -547,20 +741,24 @@ 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(import_kysely.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 (0, import_ts_pattern.match)(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(import_ts_pattern.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 (0, import_ts_pattern2.match)(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(import_ts_pattern2.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
+      throw new InternalError("JSON filters are not supported yet");
+    }).with("Unsupported", () => {
+      throw new QueryError(`Unsupported field cannot be used in filters`);
+    }).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) {
-    if (payload === null || !(0, import_is_plain_object.isPlainObject)(payload)) {
+  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
+    if (payload === null || !(0, import_common_helpers.isPlainObject)(payload)) {
       return {
         conditions: [
           this.buildLiteralFilter(eb, lhs, type, payload)
@@ -574,22 +772,29 @@ 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 = (0, import_ts_pattern.match)(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
-        (0, import_tiny_invariant.default)(Array.isArray(rhs), "right hand side must be an array");
+      const condition = (0, import_ts_pattern2.match)(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
+        (0, import_common_helpers.invariant)(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.false(eb);
         } else {
           return eb(lhs, "in", rhs);
         }
       }).with("notIn", () => {
-        (0, import_tiny_invariant.default)(Array.isArray(rhs), "right hand side must be an array");
+        (0, import_common_helpers.invariant)(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.true(eb);
         } else {
           return eb.not(eb(lhs, "in", rhs));
         }
-      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).otherwise(() => {
+      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).with(import_ts_pattern2.P.union(...AGGREGATE_OPERATORS), (op2) => {
+        const innerResult = this.buildStandardFilter(eb, type, value, aggregate(eb, lhs, op2), getRhs, recurse, throwIfInvalid);
+        consumedKeys.push(...innerResult.consumedKeys);
+        return this.and(eb, ...innerResult.conditions);
+      }).otherwise(() => {
         if (throwIfInvalid) {
           throw new QueryError(`Invalid filter key: ${op}`);
         } else {
@@ -606,24 +811,21 @@ var BaseCrudDialect = class {
       consumedKeys
     };
   }
-  buildStringFilter(eb, table, field, payload) {
-    const fieldDef = getField(this.schema, table, field);
-    let fieldRef = fieldDef?.computed ? import_kysely.sql.ref(field) : import_kysely.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 = (0, import_ts_pattern.match)(key).with("contains", () => insensitive ? eb(fieldRef, "ilike", import_kysely.sql.lit(`%${value}%`)) : eb(fieldRef, "like", import_kysely.sql.lit(`%${value}%`))).with("startsWith", () => insensitive ? eb(fieldRef, "ilike", import_kysely.sql.lit(`${value}%`)) : eb(fieldRef, "like", import_kysely.sql.lit(`${value}%`))).with("endsWith", () => insensitive ? eb(fieldRef, "ilike", import_kysely.sql.lit(`%${value}`)) : eb(fieldRef, "like", import_kysely.sql.lit(`%${value}`))).otherwise(() => {
-          throw new Error(`Invalid string filter key: ${key}`);
+        const condition = (0, import_ts_pattern2.match)(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}`))).otherwise(() => {
+          throw new QueryError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
           conditions.push(condition);
@@ -632,34 +834,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 : import_kysely.sql.val(value);
+    }
     if (typeof value === "string") {
-      return toLower ? eb.fn("lower", [
-        import_kysely.sql.lit(value)
-      ]) : import_kysely.sql.lit(value);
+      return eb.fn("lower", [
+        import_kysely.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 : import_kysely.sql.lit(value);
+      return value === null ? null : import_kysely.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, import_kysely.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, import_kysely.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, import_kysely.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",
@@ -667,8 +872,8 @@ var BaseCrudDialect = class {
     ]);
     return this.and(eb, ...conditions.conditions);
   }
-  buildEnumFilter(eb, table, field, fieldDef, payload) {
-    const conditions = this.buildStandardFilter(eb, "String", payload, import_kysely.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",
@@ -697,20 +902,18 @@ var BaseCrudDialect = class {
           "_min",
           "_max"
         ].includes(field)) {
-          (0, import_tiny_invariant.default)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
+          (0, import_common_helpers.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
-            (0, import_tiny_invariant.default)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => eb.fn(field.slice(1), [
-              import_kysely.sql.ref(k)
-            ]), import_kysely.sql.raw(this.negateSort(v, negated)));
+            (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
+            result = result.orderBy((eb) => aggregate(eb, import_kysely.sql.ref(`${modelAlias}.${k}`), field), import_kysely.sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
         switch (field) {
           case "_count": {
-            (0, import_tiny_invariant.default)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
+            (0, import_common_helpers.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
-              (0, import_tiny_invariant.default)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
+              (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
               result = result.orderBy((eb) => eb.fn.count(import_kysely.sql.ref(k)), import_kysely.sql.raw(this.negateSort(v, negated)));
             }
             continue;
@@ -732,10 +935,10 @@ var BaseCrudDialect = class {
               throw new QueryError(`invalid orderBy value for field "${field}"`);
             }
             if ("_count" in value) {
-              (0, import_tiny_invariant.default)(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
+              (0, import_common_helpers.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(import_kysely.sql.ref(left), "=", import_kysely.sql.ref(right)))));
                 subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
@@ -754,14 +957,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) => buildFieldRef(this.schema, model, field, this.options, eb).as(field));
+    } else if (!fieldDef.originModel) {
+      return query.select(import_kysely.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();
@@ -810,14 +1089,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 (0, import_ts_pattern2.match)(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).otherwise(() => value);
+      return (0, import_ts_pattern3.match)(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -831,7 +1114,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));
@@ -850,8 +1134,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         if (m2m) {
           const parentIds = getIdFields(this.schema, model);
           const relationIds = getIdFields(this.schema, relationModel);
-          (0, import_tiny_invariant2.default)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-          (0, import_tiny_invariant2.default)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+          (0, import_common_helpers2.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+          (0, import_common_helpers2.invariant)(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}`)));
         } else {
           const joinPairs = buildJoinPairs(this.schema, model, parentName, relationField, relationModel);
@@ -875,34 +1159,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) => [
+        import_kysely2.sql.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]) => [
         import_kysely2.sql.lit(field),
         buildFieldRef(this.schema, relationModel, field, this.options, eb)
       ]).flatMap((v) => v));
     } else if (payload.select) {
-      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field]) => [
-        import_kysely2.sql.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 [
+            import_kysely2.sql.lit(field),
+            subJson
+          ];
+        } else {
+          const fieldDef = requireField(this.schema, relationModel, field);
+          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : buildFieldRef(this.schema, relationModel, field, this.options, eb);
+          return [
+            import_kysely2.sql.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]) => [
         import_kysely2.sql.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;
   }
@@ -942,12 +1249,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
+var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_kysely3 = require("kysely");
-var import_tiny_invariant3 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern3 = require("ts-pattern");
+var import_ts_pattern4 = require("ts-pattern");
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -955,26 +1265,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 (0, import_ts_pattern3.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
+      if (this.schema.typeDefs && type in this.schema.typeDefs) {
+        return JSON.stringify(value);
+      } else {
+        return (0, import_ts_pattern4.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+      }
     }
   }
   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));
@@ -993,16 +1308,16 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       if (m2m) {
         const parentIds = getIdFields(this.schema, model);
         const relationIds = getIdFields(this.schema, relationModel);
-        (0, import_tiny_invariant3.default)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-        (0, import_tiny_invariant3.default)(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}`)));
+        (0, import_common_helpers3.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+        (0, import_common_helpers3.invariant)(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(`${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}`);
           }
         });
       }
@@ -1010,6 +1325,13 @@ 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) => [
+          import_kysely3.sql.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]) => [
           import_kysely3.sql.lit(field),
@@ -1017,160 +1339,92 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         ]).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 [
               import_kysely3.sql.lit(field),
               subJson
             ];
           } else {
-            return [
-              import_kysely3.sql.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 [
+                import_kysely3.sql.lit(field),
+                subJson
+              ];
+            } else {
+              return [
+                import_kysely3.sql.lit(field),
+                buildFieldRef(this.schema, relationModel, field, this.options, 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 [
             import_kysely3.sql.lit(field),
             subJson
           ];
-        }).flatMap((v) => v));
-      }
-      if (relationFieldDef.array) {
-        return eb.fn.coalesce(import_kysely3.sql`json_group_array(json_object(${import_kysely3.sql.join(objArgs)}))`, import_kysely3.sql`json_array()`).as("$j");
-      } else {
-        return import_kysely3.sql`json_object(${import_kysely3.sql.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]) => [
-      import_kysely3.sql.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 (0, import_ts_pattern4.match)(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")
+        }).flatMap((v) => v));
+      }
+      if (relationFieldDef.array) {
+        return eb.fn.coalesce(import_kysely3.sql`json_group_array(json_object(${import_kysely3.sql.join(objArgs)}))`, import_kysely3.sql`json_array()`).as("$j");
+      } else {
+        return import_kysely3.sql`json_object(${import_kysely3.sql.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]) => [
+      import_kysely3.sql.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 (0, import_ts_pattern5.match)(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
 var import_kysely4 = require("kysely");
 var DefaultOperationNodeVisitor = class extends import_kysely4.OperationNodeVisitor {
@@ -1490,19 +1744,19 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 };
 
 // src/plugins/policy/expression-transformer.ts
+var import_common_helpers5 = require("@zenstackhq/common-helpers");
 var import_kysely6 = require("kysely");
-var import_tiny_invariant5 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern6 = require("ts-pattern");
+var import_ts_pattern7 = require("ts-pattern");
 
 // src/plugins/policy/expression-evaluator.ts
-var import_tiny_invariant4 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern5 = require("ts-pattern");
+var import_common_helpers4 = require("@zenstackhq/common-helpers");
+var import_ts_pattern6 = require("ts-pattern");
 var ExpressionEvaluator = class {
   static {
     __name(this, "ExpressionEvaluator");
   }
   evaluate(expression, context) {
-    const result = (0, import_ts_pattern5.match)(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
+    const result = (0, import_ts_pattern6.match)(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
     return result ?? null;
   }
   evaluateCall(expr2, context) {
@@ -1513,7 +1767,7 @@ var ExpressionEvaluator = class {
     }
   }
   evaluateUnary(expr2, context) {
-    return (0, import_ts_pattern5.match)(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
+    return (0, import_ts_pattern6.match)(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
   }
   evaluateMember(expr2, context) {
     let val = this.evaluate(expr2.receiver, context);
@@ -1537,21 +1791,21 @@ var ExpressionEvaluator = class {
     }
     const left = this.evaluate(expr2.left, context);
     const right = this.evaluate(expr2.right, context);
-    return (0, import_ts_pattern5.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
+    return (0, import_ts_pattern6.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
       const _right = right ?? [];
-      (0, import_tiny_invariant4.default)(Array.isArray(_right), 'expected array for "in" operator');
+      (0, import_common_helpers4.invariant)(Array.isArray(_right), 'expected array for "in" operator');
       return _right.includes(left);
     }).exhaustive();
   }
   evaluateCollectionPredicate(expr2, context) {
     const op = expr2.op;
-    (0, import_tiny_invariant4.default)(op === "?" || op === "!" || op === "^", 'expected "?" or "!" or "^" operator');
+    (0, import_common_helpers4.invariant)(op === "?" || op === "!" || op === "^", 'expected "?" or "!" or "^" operator');
     const left = this.evaluate(expr2.left, context);
     if (!left) {
       return false;
     }
-    (0, import_tiny_invariant4.default)(Array.isArray(left), "expected array");
-    return (0, import_ts_pattern5.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
+    (0, import_common_helpers4.invariant)(Array.isArray(left), "expected array");
+    return (0, import_ts_pattern6.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
     }))).with("!", () => left.every((item) => this.evaluate(expr2.right, {
@@ -1567,11 +1821,11 @@ var ExpressionEvaluator = class {
 // src/plugins/policy/utils.ts
 var import_kysely5 = require("kysely");
 function trueNode(dialect) {
-  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean"));
+  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean", false));
 }
 __name(trueNode, "trueNode");
 function falseNode(dialect) {
-  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean"));
+  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean", false));
 }
 __name(falseNode, "falseNode");
 function isTrueNode(node) {
@@ -1772,20 +2026,20 @@ var ExpressionTransformer = class {
     return import_kysely6.BinaryOperationNode.create(left, this.transformOperator(op), right);
   }
   transformCollectionPredicate(expr2, context) {
-    (0, import_tiny_invariant5.default)(expr2.op === "?" || expr2.op === "!" || expr2.op === "^", 'expected "?" or "!" or "^" operator');
+    (0, import_common_helpers5.invariant)(expr2.op === "?" || expr2.op === "!" || expr2.op === "^", 'expected "?" or "!" or "^" operator');
     if (this.isAuthCall(expr2.left) || this.isAuthMember(expr2.left)) {
       const value = new ExpressionEvaluator().evaluate(expr2, {
         auth: this.auth
       });
       return this.transformValue(value, "Boolean");
     }
-    (0, import_tiny_invariant5.default)(ExpressionUtils.isField(expr2.left) || ExpressionUtils.isMember(expr2.left), "left operand must be field or member access");
+    (0, import_common_helpers5.invariant)(ExpressionUtils.isField(expr2.left) || ExpressionUtils.isMember(expr2.left), "left operand must be field or member access");
     let newContextModel;
     if (ExpressionUtils.isField(expr2.left)) {
       const fieldDef = requireField(this.schema, context.model, expr2.left.field);
       newContextModel = fieldDef.type;
     } else {
-      (0, import_tiny_invariant5.default)(ExpressionUtils.isField(expr2.left.receiver));
+      (0, import_common_helpers5.invariant)(ExpressionUtils.isField(expr2.left.receiver));
       const fieldDef = requireField(this.schema, context.model, expr2.left.receiver.field);
       newContextModel = fieldDef.type;
       for (const member of expr2.left.members) {
@@ -1805,7 +2059,7 @@ var ExpressionTransformer = class {
     const count = import_kysely6.FunctionNode.create("count", [
       import_kysely6.ValueNode.createImmediate(1)
     ]);
-    const predicateResult = (0, import_ts_pattern6.match)(expr2.op).with("?", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create(">"), import_kysely6.ValueNode.createImmediate(0))).with("!", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).with("^", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).exhaustive();
+    const predicateResult = (0, import_ts_pattern7.match)(expr2.op).with("?", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create(">"), import_kysely6.ValueNode.createImmediate(0))).with("!", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).with("^", () => import_kysely6.BinaryOperationNode.create(count, import_kysely6.OperatorNode.create("="), import_kysely6.ValueNode.createImmediate(0))).exhaustive();
     return this.transform(expr2.left, {
       ...context,
       memberSelect: import_kysely6.SelectionNode.create(import_kysely6.AliasNode.create(predicateResult, import_kysely6.IdentifierNode.create("$t"))),
@@ -1829,14 +2083,14 @@ var ExpressionTransformer = class {
     }
   }
   transformValue(value, type) {
-    return import_kysely6.ValueNode.create(this.dialect.transformPrimitive(value, type) ?? null);
+    return import_kysely6.ValueNode.create(this.dialect.transformPrimitive(value, type, false) ?? null);
   }
   _unary(expr2, context) {
-    (0, import_tiny_invariant5.default)(expr2.op === "!", 'only "!" operator is supported');
+    (0, import_common_helpers5.invariant)(expr2.op === "!", 'only "!" operator is supported');
     return import_kysely6.BinaryOperationNode.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
   }
   transformOperator(op) {
-    const mappedOp = (0, import_ts_pattern6.match)(op).with("==", () => "=").otherwise(() => op);
+    const mappedOp = (0, import_ts_pattern7.match)(op).with("==", () => "=").otherwise(() => op);
     return import_kysely6.OperatorNode.create(mappedOp);
   }
   _call(expr2, context) {
@@ -1875,10 +2129,10 @@ var ExpressionTransformer = class {
     if (this.isAuthCall(expr2.receiver)) {
       return this.valueMemberAccess(this.auth, expr2, this.authType);
     }
-    (0, import_tiny_invariant5.default)(ExpressionUtils.isField(expr2.receiver), "expect receiver to be field expression");
+    (0, import_common_helpers5.invariant)(ExpressionUtils.isField(expr2.receiver), "expect receiver to be field expression");
     const { memberFilter, memberSelect, ...restContext } = context;
     const receiver = this.transform(expr2.receiver, restContext);
-    (0, import_tiny_invariant5.default)(import_kysely6.SelectQueryNode.is(receiver), "expected receiver to be select query");
+    (0, import_common_helpers5.invariant)(import_kysely6.SelectQueryNode.is(receiver), "expected receiver to be select query");
     const receiverField = requireField(this.schema, context.model, expr2.receiver.field);
     const memberFields = [];
     let currType = receiverField.type;
@@ -1902,7 +2156,7 @@ var ExpressionTransformer = class {
           thisEntity: void 0
         });
         if (currNode) {
-          (0, import_tiny_invariant5.default)(import_kysely6.SelectQueryNode.is(currNode), "expected select query node");
+          (0, import_common_helpers5.invariant)(import_kysely6.SelectQueryNode.is(currNode), "expected select query node");
           currNode = {
             ...relation,
             selections: [
@@ -1919,8 +2173,8 @@ var ExpressionTransformer = class {
           };
         }
       } else {
-        (0, import_tiny_invariant5.default)(i === expr2.members.length - 1, "plain field access must be the last segment");
-        (0, import_tiny_invariant5.default)(!currNode, "plain field access must be the last segment");
+        (0, import_common_helpers5.invariant)(i === expr2.members.length - 1, "plain field access must be the last segment");
+        (0, import_common_helpers5.invariant)(!currNode, "plain field access must be the last segment");
         currNode = import_kysely6.ColumnNode.create(member);
       }
     }
@@ -2072,7 +2326,7 @@ var PolicyHandler = class extends import_kysely7.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");
     }
@@ -2092,27 +2346,20 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     if (!mutationRequiresTransaction && !node.returning) {
       return proceed(this.transformNode(node));
     }
-    let readBackError = false;
-    const result = await transaction(async (txProceed) => {
-      if (import_kysely7.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 (import_kysely7.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) {
@@ -2165,19 +2412,19 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     }
   }
   unwrapCreateValueRow(data, model, fields) {
-    (0, import_tiny_invariant6.default)(data.length === fields.length, "data length must match fields length");
+    (0, import_common_helpers6.invariant)(data.length === fields.length, "data length must match fields length");
     const result = [];
     for (let i = 0; i < data.length; i++) {
       const item = data[i];
       const fieldDef = requireField(this.client.$schema, model, fields[i]);
       if (typeof item === "object" && item && "kind" in item) {
-        (0, import_tiny_invariant6.default)(item.kind === "ValueNode", "expecting a ValueNode");
+        (0, import_common_helpers6.invariant)(item.kind === "ValueNode", "expecting a ValueNode");
         result.push({
-          node: import_kysely7.ValueNode.create(this.dialect.transformPrimitive(item.value, fieldDef.type)),
+          node: import_kysely7.ValueNode.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: import_kysely7.RawNode.createWithSql(this.dialect.buildArrayLiteralSQL(value)),
@@ -2246,7 +2493,7 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => import_kysely7.BinaryOperationNode.create(import_kysely7.ColumnNode.create(field), import_kysely7.OperatorNode.create("="), import_kysely7.ValueNode.create(row[field]))))));
   }
   getMutationModel(node) {
-    const r = (0, import_ts_pattern7.match)(node).when(import_kysely7.InsertQueryNode.is, (node2) => getTableName(node2.into)).when(import_kysely7.UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(import_kysely7.DeleteQueryNode.is, (node2) => {
+    const r = (0, import_ts_pattern8.match)(node).when(import_kysely7.InsertQueryNode.is, (node2) => getTableName(node2.into)).when(import_kysely7.UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(import_kysely7.DeleteQueryNode.is, (node2) => {
       if (node2.from.froms.length !== 1) {
         throw new InternalError("Only one from table is supported for delete");
       }
@@ -2379,8 +2626,8 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     const modelDef = requireModel(this.client.$schema, modelName);
     const result = [];
     const extractOperations = /* @__PURE__ */ __name((expr2) => {
-      (0, import_tiny_invariant6.default)(ExpressionUtils.isLiteral(expr2), "expecting a literal");
-      (0, import_tiny_invariant6.default)(typeof expr2.value === "string", "expecting a string literal");
+      (0, import_common_helpers6.invariant)(ExpressionUtils.isLiteral(expr2), "expecting a literal");
+      (0, import_common_helpers6.invariant)(typeof expr2.value === "string", "expecting a string literal");
       return expr2.value.split(",").filter((v) => !!v).map((v) => v.trim());
     }, "extractOperations");
     if (modelDef.attributes) {
@@ -2408,20 +2655,29 @@ 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
-var import_is_plain_object2 = require("is-plain-object");
+var import_common_helpers7 = require("@zenstackhq/common-helpers");
 function clone(value) {
   if (Array.isArray(value)) {
     return value.map((v) => clone(v));
   }
   if (typeof value === "object") {
-    if (!value || !(0, import_is_plain_object2.isPlainObject)(value)) {
+    if (!value || !(0, import_common_helpers7.isPlainObject)(value)) {
       return value;
     }
     const result = {};
@@ -2434,28 +2690,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 {
@@ -2499,17 +2733,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((0, import_kysely8.expressionBuilder)(), model);
     if (args?.where) {
       query = query.where((eb) => this.dialect.buildFilter(eb, model, model, args?.where));
     }
@@ -2529,15 +2763,16 @@ var BaseOperationHandler = class {
         query = query.distinctOn(distinct.map((f) => import_kysely8.sql.ref(`${model}.${f}`)));
       } else {
         inMemoryDistinct = distinct;
+        query = distinct.reduce((acc, field) => acc.select((eb) => buildFieldRef(this.schema, model, field, this.options, 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);
@@ -2547,23 +2782,35 @@ var BaseOperationHandler = class {
       operation: "read"
     }));
     let result = [];
+    const queryId = {
+      queryId: `zenstack-${(0, import_cuid2.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) => (0, import_node_util.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;
   }
@@ -2586,65 +2833,22 @@ 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 = (0, import_kysely8.expressionBuilder)();
-    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(import_kysely8.sql.join(idFields.map((f) => import_kysely8.sql.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(import_kysely8.sql.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) {
@@ -2668,9 +2872,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) {
@@ -2689,7 +2896,7 @@ var BaseOperationHandler = class {
               model: fromRelation.model,
               operation: "update"
             }));
-            return query2.execute();
+            return this.executeQuery(kysely, query2, "update");
           }, "parentUpdateTask");
         }
       }
@@ -2699,14 +2906,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]];
           }
@@ -2718,16 +2925,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);
     }
@@ -2739,10 +2950,32 @@ 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);
+    (0, import_common_helpers8.invariant)(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 = {};
-    (0, import_tiny_invariant7.default)(relationField, "parentField must be defined if parentModel is defined");
-    (0, import_tiny_invariant7.default)(entity, "parentEntity must be defined if parentModel is defined");
+    (0, import_common_helpers8.invariant)(relationField, "parentField must be defined if parentModel is defined");
+    (0, import_common_helpers8.invariant)(entity, "parentEntity must be defined if parentModel is defined");
     const { keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
     for (const pair of keyPairs) {
       if (!(pair.pk in entity)) {
@@ -2769,8 +3002,8 @@ var BaseOperationHandler = class {
     ].sort((a, b) => a.model.localeCompare(b.model));
     const firstIds = getIdFields(this.schema, sortedRecords[0].model);
     const secondIds = getIdFields(this.schema, sortedRecords[1].model);
-    (0, import_tiny_invariant7.default)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
-    (0, import_tiny_invariant7.default)(secondIds.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(secondIds.length === 1, "many-to-many relation must have exactly one id field");
     if (action === "connect") {
       const result = await kysely.insertInto(joinTable).values({
         A: sortedRecords[0].entity[firstIds[0]],
@@ -2787,14 +3020,14 @@ var BaseOperationHandler = class {
     }
   }
   resetManyToManyRelation(kysely, model, field, parentIds) {
-    (0, import_tiny_invariant7.default)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
+    (0, import_common_helpers8.invariant)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
     const parentId = Object.values(parentIds)[0];
     const m2m = getManyToManyRelation(this.schema, model, field);
-    (0, import_tiny_invariant7.default)(m2m, "not a many-to-many relation");
+    (0, import_common_helpers8.invariant)(m2m, "not a many-to-many relation");
     const eb = (0, import_kysely8.expressionBuilder)();
     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;
     }
@@ -2812,7 +3045,7 @@ var BaseOperationHandler = class {
         }
         case "connect": {
           const referencedPkFields = relationField.relation.references;
-          (0, import_tiny_invariant7.default)(referencedPkFields, "relation must have fields info");
+          (0, import_common_helpers8.invariant)(referencedPkFields, "relation must have fields info");
           const extractedFks = extractFields(subPayload, referencedPkFields);
           if (Object.keys(extractedFks).length === referencedPkFields.length) {
             result = extractedFks;
@@ -2844,21 +3077,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": {
+          (0, import_common_helpers8.invariant)(relationFieldDef.array, "relation must be an array for createMany");
+          tasks.push(this.createMany(kysely, relationModel, subPayload, false, fromRelationContext));
           break;
         }
         case "connect": {
@@ -2888,6 +3127,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) {
@@ -2897,12 +3141,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);
-        (0, import_tiny_invariant7.default)(!fieldDef.relation, "createMany does not support relations");
-        newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type);
+        (0, import_common_helpers8.invariant)(!fieldDef.relation, "createMany does not support relations");
+        newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
       }
       if (fromRelation) {
         for (const { fk, pk } of relationKeyPairs) {
@@ -2911,14 +3155,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);
@@ -2926,10 +3200,46 @@ var BaseOperationHandler = class {
       return result;
     }
   }
+  async processBaseModelCreateMany(kysely, model, createRows, skipDuplicates, forModel) {
+    const thisCreateRows = [];
+    const remainingFieldRows = [];
+    const discriminatorField = getDiscriminatorField(this.schema, model);
+    (0, import_common_helpers8.invariant)(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);
@@ -2937,7 +3247,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);
         }
       }
     }
@@ -2945,7 +3255,7 @@ var BaseOperationHandler = class {
   }
   evalGenerator(defaultValue) {
     if (ExpressionUtils.isCall(defaultValue)) {
-      return (0, import_ts_pattern8.match)(defaultValue.function).with("cuid", () => (0, import_cuid2.createId)()).with("uuid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args?.[0]) && defaultValue.args[0].value === 7 ? uuid.v7() : uuid.v4()).with("nanoid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args[0]) && typeof defaultValue.args[0].value === "number" ? (0, import_nanoid.nanoid)(defaultValue.args[0].value) : (0, import_nanoid.nanoid)()).with("ulid", () => (0, import_ulid.ulid)()).otherwise(() => void 0);
+      return (0, import_ts_pattern9.match)(defaultValue.function).with("cuid", () => (0, import_cuid2.createId)()).with("uuid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args?.[0]) && defaultValue.args[0].value === 7 ? uuid.v7() : uuid.v4()).with("nanoid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args[0]) && typeof defaultValue.args[0].value === "number" ? (0, import_nanoid.nanoid)(defaultValue.args[0].value) : (0, import_nanoid.nanoid)()).with("ulid", () => (0, import_ulid.ulid)()).otherwise(() => void 0);
     } else if (ExpressionUtils.isMember(defaultValue) && ExpressionUtils.isCall(defaultValue.receiver) && defaultValue.receiver.function === "auth") {
       let val = this.client.$auth;
       for (const member of defaultValue.members) {
@@ -2980,7 +3290,7 @@ var BaseOperationHandler = class {
         }
       } else {
         const fromRelationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_tiny_invariant7.default)(fromRelationFieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fromRelationFieldDef.relation?.opposite);
         parentWhere[fromRelationFieldDef.relation.opposite] = {
           some: fromRelation.ids
         };
@@ -3002,32 +3312,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}"`);
@@ -3049,16 +3364,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);
@@ -3069,23 +3382,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) {
-    (0, import_tiny_invariant7.default)(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
+    (0, import_common_helpers8.invariant)(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 value = this.dialect.transformPrimitive(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely8.expressionBuilder)();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
-    return (0, import_ts_pattern8.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
+    return (0, import_ts_pattern9.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
       throw new InternalError(`Invalid incremental update operation: ${key}`);
     });
   }
   transformScalarListUpdate(model, field, fieldDef, payload) {
-    (0, import_tiny_invariant7.default)(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
+    (0, import_common_helpers8.invariant)(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 value = this.dialect.transformPrimitive(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely8.expressionBuilder)();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
-    return (0, import_ts_pattern8.match)(key).with("set", () => value).with("push", () => {
+    return (0, import_ts_pattern9.match)(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw new InternalError(`Invalid array update operation: ${key}`);
@@ -3097,7 +3459,7 @@ var BaseOperationHandler = class {
   makeContextComment(context) {
     return import_kysely8.sql.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");
     }
@@ -3106,49 +3468,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 = [];
@@ -3161,12 +3553,12 @@ var BaseOperationHandler = class {
     for (const [key, value] of Object.entries(args)) {
       switch (key) {
         case "create": {
-          (0, import_tiny_invariant7.default)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
+          (0, import_common_helpers8.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
           tasks.push(...enumerate(value).map((item) => this.create(kysely, fieldModel, item, fromRelationContext)));
           break;
         }
         case "createMany": {
-          (0, import_tiny_invariant7.default)(fieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array for createMany");
           tasks.push(this.createMany(kysely, fieldModel, value, false, fromRelationContext));
           break;
         }
@@ -3183,7 +3575,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "set": {
-          (0, import_tiny_invariant7.default)(fieldDef.array, "relation must be an array");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array");
           tasks.push(this.setRelation(kysely, fieldModel, value, fromRelationContext));
           break;
         }
@@ -3252,7 +3644,7 @@ var BaseOperationHandler = class {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       let updateResult;
       if (ownedByModel) {
-        (0, import_tiny_invariant7.default)(_data.length === 1, "only one entity can be connected");
+        (0, import_common_helpers8.invariant)(_data.length === 1, "only one entity can be connected");
         const target = await this.readUnique(kysely, model, {
           where: _data[0]
         });
@@ -3266,7 +3658,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) {
@@ -3277,7 +3669,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,
@@ -3286,9 +3678,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);
       }
     }
@@ -3342,7 +3734,7 @@ var BaseOperationHandler = class {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       const eb = (0, import_kysely8.expressionBuilder)();
       if (ownedByModel) {
-        (0, import_tiny_invariant7.default)(disconnectConditions.length === 1, "only one entity can be disconnected");
+        (0, import_common_helpers8.invariant)(disconnectConditions.length === 1, "only one entity can be disconnected");
         const condition = disconnectConditions[0];
         const query = kysely.updateTable(fromRelation.model).where(eb.and(fromRelation.ids)).$if(condition !== true, (qb) => qb.where(eb(
           // @ts-ignore
@@ -3356,7 +3748,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
@@ -3373,7 +3765,7 @@ var BaseOperationHandler = class {
           model,
           operation: "update"
         }));
-        await query.executeTakeFirstOrThrow();
+        await this.executeQuery(kysely, query, "disconnect");
       }
     }
   }
@@ -3411,7 +3803,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,
@@ -3420,8 +3812,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);
         }
       }
@@ -3450,7 +3842,7 @@ var BaseOperationHandler = class {
     const m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
     if (m2m) {
       const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-      (0, import_tiny_invariant7.default)(fieldDef.relation?.opposite);
+      (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
       deleteResult = await this.delete(kysely, model, {
         AND: [
           {
@@ -3462,7 +3854,7 @@ var BaseOperationHandler = class {
             OR: deleteConditions
           }
         ]
-      }, void 0, false);
+      });
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
@@ -3473,7 +3865,7 @@ var BaseOperationHandler = class {
           throw new NotFoundError(model);
         }
         const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_tiny_invariant7.default)(fieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
         deleteResult = await this.delete(kysely, model, {
           AND: [
             // filter for parent
@@ -3485,7 +3877,7 @@ var BaseOperationHandler = class {
               OR: deleteConditions
             }
           ]
-        }, void 0, false);
+        });
       } else {
         deleteResult = await this.delete(kysely, model, {
           AND: [
@@ -3497,7 +3889,7 @@ var BaseOperationHandler = class {
               OR: deleteConditions
             }
           ]
-        }, void 0, false);
+        });
       }
     }
     if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
@@ -3508,33 +3900,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) => {
@@ -3543,7 +3961,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) => {
@@ -3553,9 +3971,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;
@@ -3563,11 +3981,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
@@ -3586,6 +4006,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 && (0, import_common_helpers8.isPlainObject)(value)) {
+          this.doNormalizeArgs(value);
+        }
+      }
+    }
+  }
+  makeQueryId(operation) {
+    return {
+      queryId: `${operation}-${(0, import_cuid2.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
@@ -3594,21 +4055,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) {
@@ -3633,7 +4110,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = (0, import_ts_pattern9.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = (0, import_ts_pattern10.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(import_kysely9.sql.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -3642,9 +4119,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;
@@ -3666,7 +4143,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern9.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern10.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -3687,34 +4164,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(import_kysely10.sql.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(import_kysely10.sql.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
-var import_ts_pattern10 = require("ts-pattern");
+var import_ts_pattern11 = require("ts-pattern");
 var CreateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
-    return (0, import_ts_pattern10.match)(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 (0, import_ts_pattern11.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+      return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, normalizedArgs));
     }).with("createManyAndReturn", () => {
-      return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, args));
+      return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, normalizedArgs));
     }).exhaustive();
   }
   async runCreate(args) {
@@ -3758,13 +4248,14 @@ var CreateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/delete.ts
-var import_ts_pattern11 = require("ts-pattern");
+var import_ts_pattern12 = require("ts-pattern");
 var DeleteOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
-    return (0, import_ts_pattern11.match)(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 (0, import_ts_pattern12.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runDelete(args) {
     const existing = await this.readUnique(this.kysely, this.model, {
@@ -3776,15 +4267,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;
+    });
   }
 };
 
@@ -3794,7 +4289,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;
@@ -3803,17 +4299,18 @@ var FindOperationHandler = class extends BaseOperationHandler {
 
 // src/client/crud/operations/group-by.ts
 var import_kysely11 = require("kysely");
-var import_ts_pattern12 = require("ts-pattern");
-var GroupByeOperationHandler = class extends BaseOperationHandler {
+var import_ts_pattern13 = require("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;
@@ -3823,20 +4320,20 @@ 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 bys = typeof parsedArgs.by === "string" ? [
+      parsedArgs.by
+    ] : parsedArgs.by;
+    query = query.groupBy(bys.map((by) => import_kysely11.sql.ref(`$sub.${by}`)));
+    if (parsedArgs.orderBy) {
+      query = this.dialect.buildOrderBy(query, this.model, "$sub", parsedArgs.orderBy, false, false);
     }
-    if (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(() => import_kysely11.sql.ref(`$sub.${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) {
@@ -3861,7 +4358,7 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = (0, import_ts_pattern12.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = (0, import_ts_pattern13.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(import_kysely11.sql.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -3870,8 +4367,8 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
         }
       }
     }
-    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 = {};
@@ -3898,7 +4395,7 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern12.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern13.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -3913,31 +4410,45 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/update.ts
-var import_ts_pattern13 = require("ts-pattern");
+var import_ts_pattern14 = require("ts-pattern");
 var UpdateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
-    return (0, import_ts_pattern13.match)(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 (0, import_ts_pattern14.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runUpdate(args) {
-    const 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) {
@@ -3975,19 +4486,19 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/validator.ts
+var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
-var import_ts_pattern14 = require("ts-pattern");
+var import_ts_pattern15 = require("ts-pattern");
 var import_zod = require("zod");
 var InputValidator = class {
   static {
     __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", {
@@ -4044,7 +4555,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;
   }
@@ -4063,11 +4574,11 @@ var InputValidator = class {
     fields["distinct"] = this.makeDistinctSchema(model).optional();
     fields["cursor"] = this.makeCursorSchema(model).optional();
     if (options.collection) {
-      fields["skip"] = import_zod.z.number().int().nonnegative().optional();
-      fields["take"] = import_zod.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 = import_zod.z.object(fields).strict();
+    let result = import_zod.z.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4076,22 +4587,50 @@ var InputValidator = class {
     return result;
   }
   makePrimitiveSchema(type) {
-    return (0, import_ts_pattern14.match)(type).with("String", () => import_zod.z.string()).with("Int", () => import_zod.z.number()).with("Float", () => import_zod.z.number()).with("Boolean", () => import_zod.z.boolean()).with("BigInt", () => import_zod.z.union([
-      import_zod.z.number(),
-      import_zod.z.bigint()
-    ])).with("Decimal", () => import_zod.z.union([
-      import_zod.z.number(),
-      import_zod.z.instanceof(import_decimal.default),
-      import_zod.z.string()
-    ])).with("DateTime", () => import_zod.z.union([
-      import_zod.z.date(),
-      import_zod.z.string().datetime()
-    ])).with("Bytes", () => import_zod.z.instanceof(Uint8Array)).otherwise(() => import_zod.z.unknown());
-  }
-  makeWhereSchema(model, unique, withoutRelationFields = false) {
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.makeTypeDefSchema(type);
+    } else {
+      return (0, import_ts_pattern15.match)(type).with("String", () => import_zod.z.string()).with("Int", () => import_zod.z.int()).with("Float", () => import_zod.z.number()).with("Boolean", () => import_zod.z.boolean()).with("BigInt", () => import_zod.z.union([
+        import_zod.z.int(),
+        import_zod.z.bigint()
+      ])).with("Decimal", () => import_zod.z.union([
+        import_zod.z.number(),
+        import_zod.z.instanceof(import_decimal.default),
+        import_zod.z.string()
+      ])).with("DateTime", () => import_zod.z.union([
+        import_zod.z.date(),
+        import_zod.z.string().datetime()
+      ])).with("Bytes", () => import_zod.z.instanceof(Uint8Array)).otherwise(() => import_zod.z.unknown());
+    }
+  }
+  makeTypeDefSchema(type) {
+    const key = `$typedef-${type}`;
+    let schema = this.schemaCache.get(key);
+    if (schema) {
+      return schema;
+    }
+    const typeDef = this.schema.typeDefs?.[type];
+    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    schema = import_zod.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)) {
@@ -4106,7 +4645,7 @@ var InputValidator = class {
         if (fieldDef.array) {
           fieldSchema = import_zod.z.union([
             fieldSchema,
-            import_zod.z.object({
+            import_zod.z.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
@@ -4115,7 +4654,7 @@ var InputValidator = class {
         } else {
           fieldSchema = import_zod.z.union([
             fieldSchema,
-            import_zod.z.object({
+            import_zod.z.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4125,12 +4664,12 @@ var InputValidator = class {
         const enumDef = getEnum(this.schema, fieldDef.type);
         if (enumDef) {
           if (Object.keys(enumDef).length > 0) {
-            fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional);
+            fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, withAggregations);
           }
         } else if (fieldDef.array) {
           fieldSchema = this.makeArrayFilterSchema(fieldDef.type);
         } else {
-          fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional);
+          fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations);
         }
       }
       if (fieldSchema) {
@@ -4141,18 +4680,32 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = import_zod.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => [
-            key,
-            this.makePrimitiveFilterSchema(def.type, !!def.optional)
-          ]))).optional();
+          fields[uniqueField.name] = import_zod.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+            (0, import_common_helpers9.invariant)(!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 = import_zod.z.never();
+              }
+            } else {
+              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
+            }
+            return [
+              key,
+              fieldSchema
+            ];
+          }))).optional();
         }
       }
     }
-    fields["$expr"] = import_zod.z.function().optional();
+    fields["$expr"] = import_zod.z.custom((v) => typeof v === "function").optional();
     fields["AND"] = this.orArray(import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
     fields["OR"] = import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
     fields["NOT"] = this.orArray(import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = import_zod.z.object(fields).strict();
+    const baseWhere = import_zod.z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4171,21 +4724,25 @@ var InputValidator = class {
     }
     return result;
   }
-  makeEnumFilterSchema(enumDef, optional) {
+  makeEnumFilterSchema(enumDef, optional, withAggregations) {
     const baseSchema = import_zod.z.enum(Object.keys(enumDef));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional)));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+      "equals",
+      "in",
+      "notIn",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object({
-        equals: components.equals,
-        in: components.in,
-        notIn: components.notIn,
-        not: components.not
-      })
+      import_zod.z.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
-    return import_zod.z.object({
+    return import_zod.z.strictObject({
       equals: this.makePrimitiveSchema(type).array().optional(),
       has: this.makePrimitiveSchema(type).optional(),
       hasEvery: this.makePrimitiveSchema(type).array().optional(),
@@ -4193,39 +4750,59 @@ var InputValidator = class {
       isEmpty: import_zod.z.boolean().optional()
     });
   }
-  makePrimitiveFilterSchema(type, optional) {
-    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional)).with("Boolean", () => this.makeBooleanFilterSchema(optional)).with("DateTime", () => this.makeDateTimeFilterSchema(optional)).with("Bytes", () => this.makeBytesFilterSchema(optional)).exhaustive();
+  makePrimitiveFilterSchema(type, optional, withAggregations) {
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.makeTypeDefFilterSchema(type, optional);
+    }
+    return (0, import_ts_pattern15.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern15.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => import_zod.z.any()).with("Unsupported", () => import_zod.z.never()).exhaustive();
+  }
+  makeTypeDefFilterSchema(_type, _optional) {
+    return import_zod.z.never();
   }
-  makeDateTimeFilterSchema(optional) {
+  makeDateTimeFilterSchema(optional, withAggregations) {
     return this.makeCommonPrimitiveFilterSchema(import_zod.z.union([
-      import_zod.z.string().datetime(),
+      import_zod.z.iso.datetime(),
       import_zod.z.date()
-    ]), optional, () => import_zod.z.lazy(() => this.makeDateTimeFilterSchema(optional)));
-  }
-  makeBooleanFilterSchema(optional) {
+    ]), optional, () => import_zod.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
+  }
+  makeBooleanFilterSchema(optional, withAggregations) {
+    const components = this.makeCommonPrimitiveFilterComponents(import_zod.z.boolean(), optional, () => import_zod.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+      "equals",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return import_zod.z.union([
       this.nullableIf(import_zod.z.boolean(), optional),
-      import_zod.z.object({
-        equals: this.nullableIf(import_zod.z.boolean(), optional).optional(),
-        not: import_zod.z.lazy(() => this.makeBooleanFilterSchema(optional)).optional()
-      })
+      import_zod.z.strictObject(components)
     ]);
   }
-  makeBytesFilterSchema(optional) {
+  makeBytesFilterSchema(optional, withAggregations) {
     const baseSchema = import_zod.z.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.instanceof(Uint8Array));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.instanceof(Uint8Array), [
+      "equals",
+      "in",
+      "notIn",
+      "not"
+    ], withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0);
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object({
-        equals: components.equals,
-        in: components.in,
-        notIn: components.notIn,
-        not: components.not
-      })
+      import_zod.z.strictObject(components)
     ]);
   }
-  makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis) {
-    return {
+  makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
+    const commonAggSchema = /* @__PURE__ */ __name(() => this.makeCommonPrimitiveFilterSchema(baseSchema, false, makeThis, void 0).optional(), "commonAggSchema");
+    let result = {
       equals: this.nullableIf(baseSchema.optional(), optional),
       notEquals: this.nullableIf(baseSchema.optional(), optional),
       in: baseSchema.array().optional(),
@@ -4234,20 +4811,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(import_zod.z.int(), false, false).optional()
+      } : {},
+      ...withAggregations?.includes("_avg") ? {
+        _avg: commonAggSchema()
+      } : {},
+      ...withAggregations?.includes("_sum") ? {
+        _sum: commonAggSchema()
+      } : {},
+      ...withAggregations?.includes("_min") ? {
+        _min: commonAggSchema()
+      } : {},
+      ...withAggregations?.includes("_max") ? {
+        _max: commonAggSchema()
+      } : {}
     };
+    if (supportedOperators) {
+      const keys = [
+        ...supportedOperators,
+        ...withAggregations ?? []
+      ];
+      result = extractFields(result, keys);
+    }
+    return result;
   }
-  makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis) {
+  makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
+      import_zod.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
-  makeNumberFilterSchema(baseSchema, optional) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional)));
+  makeNumberFilterSchema(baseSchema, optional, withAggregations) {
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+      "_count",
+      "_avg",
+      "_sum",
+      "_min",
+      "_max"
+    ] : void 0);
+  }
+  makeStringFilterSchema(optional, withAggregations) {
+    return import_zod.z.union([
+      this.nullableIf(import_zod.z.string(), optional),
+      import_zod.z.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(import_zod.z.string(), optional, () => import_zod.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
+          "_count",
+          "_min",
+          "_max"
+        ] : void 0),
+        startsWith: import_zod.z.string().optional(),
+        endsWith: import_zod.z.string().optional(),
+        contains: import_zod.z.string().optional(),
+        ...this.providerSupportsCaseSensitivity ? {
+          mode: this.makeStringModeSchema().optional()
+        } : {}
+      })
+    ]);
   }
-  makeStringFilterSchema(optional) {
-    return this.makeCommonPrimitiveFilterSchema(import_zod.z.string(), optional, () => import_zod.z.lazy(() => this.makeStringFilterSchema(optional)));
+  makeStringModeSchema() {
+    return import_zod.z.union([
+      import_zod.z.literal("default"),
+      import_zod.z.literal("insensitive")
+    ]);
   }
   makeSelectSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4257,7 +4884,7 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = import_zod.z.union([
           import_zod.z.literal(true),
-          import_zod.z.object({
+          import_zod.z.strictObject({
             select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional()
           })
@@ -4266,22 +4893,24 @@ var InputValidator = class {
         fields[field] = import_zod.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"] = import_zod.z.union([
         import_zod.z.literal(true),
-        import_zod.z.object(toManyRelations.reduce((acc, [name, fieldDef]) => ({
-          ...acc,
-          [name]: import_zod.z.union([
-            import_zod.z.boolean(),
-            import_zod.z.object({
-              where: this.makeWhereSchema(fieldDef.type, false, false)
-            })
-          ]).optional()
-        }), {}))
+        import_zod.z.strictObject({
+          select: import_zod.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+            ...acc,
+            [fieldDef.name]: import_zod.z.union([
+              import_zod.z.boolean(),
+              import_zod.z.strictObject({
+                where: this.makeWhereSchema(fieldDef.type, false, false)
+              })
+            ]).optional()
+          }), {}))
+        })
       ]).optional();
     }
-    return import_zod.z.object(fields).strict();
+    return import_zod.z.strictObject(fields);
   }
   makeOmitSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4292,7 +4921,7 @@ var InputValidator = class {
         fields[field] = import_zod.z.boolean().optional();
       }
     }
-    return import_zod.z.object(fields).strict();
+    return import_zod.z.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4302,15 +4931,20 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = import_zod.z.union([
           import_zod.z.literal(true),
-          import_zod.z.object({
+          import_zod.z.strictObject({
             select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
-            where: import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+            omit: import_zod.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
+            where: import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional(),
+            orderBy: import_zod.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 import_zod.z.object(fields).strict();
+    return import_zod.z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
@@ -4323,13 +4957,21 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = import_zod.z.lazy(() => this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation).optional());
+          fields[field] = import_zod.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] = import_zod.z.union([
             sort,
-            import_zod.z.object({
+            import_zod.z.strictObject({
               sort,
               nulls: import_zod.z.union([
                 import_zod.z.literal("first"),
@@ -4354,7 +4996,7 @@ var InputValidator = class {
         fields[agg] = import_zod.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return import_zod.z.object(fields);
+    return import_zod.z.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4373,7 +5015,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) {
@@ -4381,15 +5023,15 @@ var InputValidator = class {
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.merge(import_zod.z.object({
+    const result = base.merge(import_zod.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) => {
@@ -4400,6 +5042,9 @@ var InputValidator = class {
       if (fieldDef.computed) {
         return;
       }
+      if (this.isDelegateDiscriminator(fieldDef)) {
+        return;
+      }
       if (fieldDef.relation) {
         if (withoutRelationFields) {
           return;
@@ -4431,13 +5076,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 = import_zod.z.union([
             import_zod.z.array(fieldSchema),
-            import_zod.z.object({
+            import_zod.z.strictObject({
               set: import_zod.z.array(fieldSchema)
             })
           ]).optional();
@@ -4448,27 +5096,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(import_zod.z.object(regularAndFkFields).strict(), canBeArray);
+      return this.orArray(import_zod.z.strictObject(uncheckedVariantFields), canBeArray);
     } else {
       return import_zod.z.union([
-        import_zod.z.object(regularAndFkFields).strict(),
-        import_zod.z.object(regularAndRelationFields).strict(),
+        import_zod.z.strictObject(uncheckedVariantFields),
+        import_zod.z.strictObject(checkedVariantFields),
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(regularAndFkFields).strict())
+          import_zod.z.array(import_zod.z.strictObject(uncheckedVariantFields))
         ] : [],
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(regularAndRelationFields).strict())
+          import_zod.z.array(import_zod.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;
@@ -4485,31 +5140,31 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(import_zod.z.object({
+      fields["update"] = array ? this.orArray(import_zod.z.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional() : import_zod.z.union([
-        import_zod.z.object({
+        import_zod.z.strictObject({
           where: this.makeWhereSchema(fieldType, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
       ]).optional();
-      fields["upsert"] = this.orArray(import_zod.z.object({
+      fields["upsert"] = this.orArray(import_zod.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(import_zod.z.object({
+        fields["updateMany"] = this.orArray(import_zod.z.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return import_zod.z.object(fields).strict().refine((v) => Object.keys(v).length > 0, "At least one action is required");
+    return import_zod.z.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4539,13 +5194,13 @@ var InputValidator = class {
     return this.orArray(import_zod.z.object({
       where: whereSchema,
       create: createSchema
-    }).strict(), canBeArray);
+    }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
     return import_zod.z.object({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
       skipDuplicates: import_zod.z.boolean().optional()
-    }).strict();
+    });
   }
   // #endregion
   // #region Update
@@ -4556,19 +5211,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 import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: import_zod.z.number().int().nonnegative().optional()
-    }).strict();
+      limit: import_zod.z.int().nonnegative().optional()
+    });
   }
   makeUpdateManyAndReturnSchema(model) {
     const base = this.makeUpdateManySchema(model);
-    const result = base.merge(import_zod.z.object({
+    const result = base.merge(import_zod.z.strictObject({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
@@ -4582,12 +5237,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) => {
@@ -4612,7 +5267,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)) {
@@ -4639,18 +5297,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 import_zod.z.object(regularAndFkFields).strict();
+      return import_zod.z.strictObject(uncheckedVariantFields);
     } else {
       return import_zod.z.union([
-        import_zod.z.object(regularAndFkFields).strict(),
-        import_zod.z.object(regularAndRelationFields).strict()
+        import_zod.z.strictObject(uncheckedVariantFields),
+        import_zod.z.strictObject(checkedVariantFields)
       ]);
     }
   }
@@ -4661,25 +5319,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 import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: import_zod.z.number().int().nonnegative().optional()
-    }).strict().optional();
+      limit: import_zod.z.int().nonnegative().optional()
+    }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
     return import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.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);
@@ -4691,7 +5349,7 @@ var InputValidator = class {
           acc[field] = import_zod.z.literal(true).optional();
           return acc;
         }, {})
-      }).strict()
+      })
     ]);
   }
   // #endregion
@@ -4699,19 +5357,19 @@ var InputValidator = class {
   makeAggregateSchema(model) {
     return import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.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 import_zod.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
         acc[field] = import_zod.z.literal(true).optional();
@@ -4721,7 +5379,7 @@ var InputValidator = class {
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
         acc[field] = import_zod.z.literal(true).optional();
@@ -4736,30 +5394,42 @@ var InputValidator = class {
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: this.orArray(import_zod.z.enum(nonRelationFields), true),
-      having: this.makeWhereSchema(model, false, true).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.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;
@@ -4767,8 +5437,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 import_zod.z.int().nonnegative();
+  }
+  makeTakeSchema() {
+    return import_zod.z.int();
+  }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
   }
@@ -4787,6 +5480,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
@@ -4796,11 +5492,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;
@@ -4841,21 +5537,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() {
@@ -4933,6 +5638,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") {
@@ -4946,7 +5667,8 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 var import_kysely13 = require("kysely");
 var import_nanoid2 = require("nanoid");
-var import_ts_pattern15 = require("ts-pattern");
+var import_node_util2 = require("util");
+var import_ts_pattern16 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
 var import_kysely12 = require("kysely");
@@ -4955,11 +5677,11 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     __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) {
@@ -5148,7 +5870,7 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     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;
   }
 };
@@ -5173,16 +5895,18 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
   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 ((import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.DeleteQueryNode.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
+      if ((import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.UpdateQueryNode.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
         queryNode = {
           ...queryNode,
           returning: import_kysely13.ReturningNode.create([
@@ -5190,42 +5914,73 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
           ])
         };
       }
-      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 import_kysely13.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) => (0, import_node_util2.inspect)(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
   }
   isMutationNode(queryNode) {
@@ -5253,30 +6008,15 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
     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 (0, import_ts_pattern15.match)(queryNode).when(import_kysely13.InsertQueryNode.is, (node) => node.into.table.identifier.name).when(import_kysely13.UpdateQueryNode.is, (node) => node.table.table.identifier.name).when(import_kysely13.DeleteQueryNode.is, (node) => {
+    return (0, import_ts_pattern16.match)(queryNode).when(import_kysely13.InsertQueryNode.is, (node) => node.into.table.identifier.name).when(import_kysely13.UpdateQueryNode.is, (node) => node.table.table.identifier.name).when(import_kysely13.DeleteQueryNode.is, (node) => {
       if (node.from.froms.length !== 1) {
         throw new InternalError(`Delete query must have exactly one from table`);
       }
@@ -5292,7 +6032,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       const result = {
         intercept: false
       };
-      const { action, where } = (0, import_ts_pattern15.match)(queryNode).when(import_kysely13.InsertQueryNode.is, () => ({
+      const { action, where } = (0, import_ts_pattern16.match)(queryNode).when(import_kysely13.InsertQueryNode.is, () => ({
         action: "create",
         where: void 0
       })).when(import_kysely13.UpdateQueryNode.is, (node) => ({
@@ -5312,14 +6052,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
             queryNode
           });
           result.intercept ||= filterResult.intercept;
-          result.useTransactionForMutation ||= filterResult.useTransactionForMutation;
           result.loadBeforeMutationEntity ||= filterResult.loadBeforeMutationEntity;
           result.loadAfterMutationEntity ||= filterResult.loadAfterMutationEntity;
         }
       }
       let beforeMutationEntities;
       if (result.loadBeforeMutationEntity && (import_kysely13.UpdateQueryNode.is(queryNode) || import_kysely13.DeleteQueryNode.is(queryNode))) {
-        beforeMutationEntities = await this.loadEntities(this.kysely, mutationModel, where);
+        beforeMutationEntities = await this.loadEntities(mutationModel, where);
       }
       return {
         ...result,
@@ -5332,16 +6071,16 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       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
@@ -5350,44 +6089,59 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       }
     }
   }
-  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 (import_kysely13.UpdateQueryNode.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 (import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.UpdateQueryNode.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-${(0, import_nanoid2.nanoid)()}`
     });
-    const result = await kysely.executeQuery(compiled);
     return result.rows;
   }
   andNodes(condition1, condition2) {
@@ -5416,9 +6170,9 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely14 = require("kysely");
-var import_tiny_invariant8 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern16 = require("ts-pattern");
+var import_ts_pattern17 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
   if (!field) {
@@ -5503,7 +6257,7 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   return eb(dialect.buildArrayLength(eb, field), "=", import_kysely14.sql.lit(0));
 }, "isEmpty");
 var now = /* @__PURE__ */ __name((eb, _args, { dialect }) => {
-  return (0, import_ts_pattern16.match)(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => import_kysely14.sql.raw("CURRENT_TIMESTAMP")).exhaustive();
+  return (0, import_ts_pattern17.match)(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => import_kysely14.sql.raw("CURRENT_TIMESTAMP")).exhaustive();
 }, "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
@@ -5523,8 +6277,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_tiny_invariant8.default)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern16.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => `${result.charAt(0).toUpperCase() + result.slice(1)}`).with("uncapitalize", () => `${result.charAt(0).toLowerCase() + result.slice(1)}`).otherwise(() => {
+  (0, import_common_helpers10.invariant)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers10.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers10.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -5532,9 +6286,9 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
-var import_tiny_invariant9 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern17 = require("ts-pattern");
+var import_ts_pattern18 = require("ts-pattern");
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -5565,14 +6319,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)) {
@@ -5584,16 +6341,19 @@ var SchemaDbPusher = class {
     }
     return table;
   }
-  addUniqueConstraint(table, modelDef) {
+  addUniqueConstraint(table, model, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_tiny_invariant9.default)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers11.invariant)(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;
@@ -5632,7 +6392,7 @@ var SchemaDbPusher = class {
       return "serial";
     }
     const type = fieldDef.type;
-    const result = (0, import_ts_pattern17.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").otherwise(() => {
+    const result = (0, import_ts_pattern18.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").with("Json", () => "jsonb").otherwise(() => {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
@@ -5645,7 +6405,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_tiny_invariant9.default)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers11.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -5661,16 +6421,16 @@ var SchemaDbPusher = class {
     return table;
   }
   mapCascadeAction(action) {
-    return (0, import_ts_pattern17.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+    return (0, import_ts_pattern18.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
   }
 };
 
 // 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);
     }
@@ -5685,10 +6445,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;
@@ -5699,9 +6460,9 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
-var import_tiny_invariant10 = __toESM(require("tiny-invariant"), 1);
-var import_ts_pattern18 = require("ts-pattern");
+var import_ts_pattern19 = require("ts-pattern");
 var ResultProcessor = class {
   static {
     __name(this, "ResultProcessor");
@@ -5735,6 +6496,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;
@@ -5774,20 +6550,24 @@ var ResultProcessor = class {
     return this.doProcessResult(relationData, fieldDef.type);
   }
   transformScalar(value, type) {
-    return (0, import_ts_pattern18.match)(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).otherwise(() => value);
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.transformJson(value);
+    } else {
+      return (0, import_ts_pattern19.match)(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).with("Json", () => this.transformJson(value)).otherwise(() => value);
+    }
   }
   transformDecimal(value) {
     if (value instanceof import_decimal2.default) {
       return value;
     }
-    (0, import_tiny_invariant10.default)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers12.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal2.default(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_tiny_invariant10.default)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers12.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -5806,6 +6586,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();
     }
@@ -5819,13 +6602,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 (0, import_ts_pattern19.match)(this.schema.provider.type).with("sqlite", () => {
+      (0, import_common_helpers12.invariant)(typeof value === "string", "Expected string, got " + typeof value);
+      return JSON.parse(value);
+    }).otherwise(() => value);
+  }
 };
 
 // src/client/client-impl.ts
@@ -5844,7 +6633,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;
@@ -5856,24 +6645,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 import_kysely16.DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely16.DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
+      this.auth = baseClient.auth;
     } else {
-      const dialect = this.getKyselyDialect();
-      const driver = new ZenStackDriver(dialect.createDriver(), new import_kysely16.Log(this.$options.log ?? []));
-      const compiler = dialect.createQueryCompiler();
-      const adapter = dialect.createAdapter();
+      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely16.Log(this.$options.log ?? []));
+      const compiler = options.dialect.createQueryCompiler();
+      const adapter = options.dialect.createAdapter();
       const connectionProvider = new import_kysely16.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 import_kysely16.Kysely({
         ...this.kyselyProps,
@@ -5889,31 +6677,58 @@ var ClientImpl = class _ClientImpl {
   get $qbRaw() {
     return this.kyselyRaw;
   }
-  getKyselyDialect() {
-    return (0, import_ts_pattern19.match)(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 import_kysely16.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 import_kysely16.SqliteDialect(mergedConfig);
+  // implementation
+  async $transaction(input, options) {
+    (0, import_common_helpers13.invariant)(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) => {
@@ -5941,12 +6756,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);
   }
@@ -5968,6 +6797,39 @@ var ClientImpl = class _ClientImpl {
   get $auth() {
     return this.auth;
   }
+  $executeRaw(query, ...values) {
+    return createZenStackPromise(async () => {
+      const result = await (0, import_kysely16.sql)(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 (0, import_kysely16.sql)(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 = import_kysely16.CompiledQuery.raw(query, values);
+    return {
+      ...q,
+      $raw: true
+    };
+  }
 };
 function createClientProxy(client) {
   const inputValidator = new InputValidator(client.$schema);
@@ -5990,9 +6852,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);
@@ -6005,22 +6867,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 === (0, import_common_helpers13.lowerCaseFirst)(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);
@@ -6076,13 +6947,24 @@ 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");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ZenStackClient
+  InputValidationError,
+  InternalError,
+  NotFoundError,
+  QueryError,
+  ZenStackClient,
+  definePlugin
 });
 //# sourceMappingURL=index.cjs.map