@zenstackhq/runtime 3.0.0-alpha.0 → 3.0.0-alpha.10

package/dist/index.cjs

@@ -31,11 +31,17 @@ 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");
 
@@ -44,21 +50,30 @@ var import_kysely9 = require("kysely");
 var import_ts_pattern9 = require("ts-pattern");
 
 // 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 +92,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];
 }
@@ -202,7 +217,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);
   }
@@ -310,9 +325,10 @@ __name(safeJSONStringify, "safeJSONStringify");
 
 // 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_node_util = require("util");
 var import_ts_pattern8 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
@@ -330,21 +346,21 @@ 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");
 
 // src/client/crud/dialects/index.ts
 var import_ts_pattern4 = 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");
 
 // 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");
 
 // src/utils/enumerate.ts
@@ -362,7 +378,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,7 +388,7 @@ var BaseCrudDialect = class {
     this.schema = schema;
     this.options = options;
   }
-  transformPrimitive(value, _type) {
+  transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
   buildFilter(eb, model, modelAlias, where) {
@@ -516,7 +531,7 @@ var BaseCrudDialect = class {
       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)));
@@ -554,13 +569,17 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(eb, modelAlias, field, 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_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)).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)) {
+    if (payload === null || !(0, import_common_helpers.isPlainObject)(payload)) {
       return {
         conditions: [
           this.buildLiteralFilter(eb, lhs, type, payload)
@@ -576,14 +595,14 @@ var BaseCrudDialect = class {
       }
       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");
+        (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 {
@@ -644,22 +663,22 @@ var BaseCrudDialect = class {
     }
   }
   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));
+    const { conditions } = this.buildStandardFilter(eb, type, payload, buildFieldRef(this.schema, model, field, this.options, eb), (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, model, table, field, 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, [
+    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, table, field, 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);
+    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, table, field, 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, [
+    const conditions = this.buildStandardFilter(eb, "Bytes", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, table, field, value), true, [
       "equals",
       "in",
       "notIn",
@@ -697,9 +716,9 @@ 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}"`);
+            (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
             result = result.orderBy((eb) => eb.fn(field.slice(1), [
               import_kysely.sql.ref(k)
             ]), import_kysely.sql.raw(this.negateSort(v, negated)));
@@ -708,9 +727,9 @@ var BaseCrudDialect = class {
         }
         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,7 +751,7 @@ 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);
@@ -758,10 +777,10 @@ var BaseCrudDialect = class {
     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 +829,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_pattern2.match)(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -850,8 +873,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);
@@ -884,25 +907,33 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         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]) => {
+        const fieldDef = requireField(this.schema, relationModel, field);
+        const fieldValue = fieldDef.relation ? eb.ref(`${parentName}$${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),
+        // reference the synthesized JSON field
         eb.ref(`${parentName}$${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;
   }
@@ -945,8 +976,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
 };
 
 // src/client/crud/dialects/sqlite.ts
+var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_kysely3 = require("kysely");
-var import_tiny_invariant3 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern3 = require("ts-pattern");
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
@@ -955,14 +986,14 @@ 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);
+      return (0, import_ts_pattern3.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -993,8 +1024,8 @@ 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");
+        (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(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
       } else {
         const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
@@ -1490,12 +1521,12 @@ 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");
 
 // src/plugins/policy/expression-evaluator.ts
-var import_tiny_invariant4 = __toESM(require("tiny-invariant"), 1);
+var import_common_helpers4 = require("@zenstackhq/common-helpers");
 var import_ts_pattern5 = require("ts-pattern");
 var ExpressionEvaluator = class {
   static {
@@ -1539,18 +1570,18 @@ var ExpressionEvaluator = class {
     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", () => {
       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");
+    (0, import_common_helpers4.invariant)(Array.isArray(left), "expected array");
     return (0, import_ts_pattern5.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
@@ -1567,11 +1598,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 +1803,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) {
@@ -1829,10 +1860,10 @@ 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) {
@@ -1875,10 +1906,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 +1933,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 +1950,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 +2103,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 +2123,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 +2189,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)),
@@ -2379,8 +2403,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 +2432,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 = {};
@@ -2550,8 +2583,13 @@ var BaseOperationHandler = class {
     try {
       result = await query.execute();
     } catch (err) {
-      const { sql: sql10, parameters } = query.compile();
-      throw new QueryError(`Failed to execute query: ${err}, sql: ${sql10}, parameters: ${parameters}`);
+      const { sql: sql11, parameters } = query.compile();
+      let message = `Failed to execute query: ${err}, sql: ${sql11}`;
+      if (this.options.debug) {
+        message += `, parameters: 
+${parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
     if (inMemoryDistinct) {
       const distinctResult = [];
@@ -2610,30 +2648,20 @@ var BaseOperationHandler = class {
     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);
+      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.dialect.buildFilter(eb, fieldModel, fieldModel, value.where);
+        fieldCountQuery = fieldCountQuery.where(filter);
+      }
+      jsonObject[field] = fieldCountQuery;
     }
     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);
@@ -2699,14 +2727,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]];
           }
@@ -2727,7 +2755,7 @@ var BaseOperationHandler = class {
     const createdEntity = await query.executeTakeFirst();
     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);
     }
@@ -2741,8 +2769,8 @@ var BaseOperationHandler = class {
   }
   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 +2797,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 +2815,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 +2840,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 +2872,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 +2922,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) {
@@ -2901,8 +2940,8 @@ var BaseOperationHandler = class {
       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) {
@@ -2937,7 +2976,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);
         }
       }
     }
@@ -2980,7 +3019,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,7 +3041,7 @@ 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) {
@@ -3027,7 +3066,7 @@ var BaseOperationHandler = class {
           updateFields[field] = this.transformScalarListUpdate(model, field, fieldDef, finalData[field]);
           continue;
         }
-        updateFields[field] = this.dialect.transformPrimitive(finalData[field], fieldDef.type);
+        updateFields[field] = this.dialect.transformPrimitive(finalData[field], fieldDef.type, !!fieldDef.array);
       } else {
         if (!allowRelationUpdate) {
           throw new QueryError(`Relation update not allowed for field "${field}"`);
@@ -3070,9 +3109,9 @@ var BaseOperationHandler = class {
     }
   }
   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(() => {
@@ -3080,9 +3119,9 @@ var BaseOperationHandler = class {
     });
   }
   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", () => {
@@ -3112,7 +3151,7 @@ var BaseOperationHandler = class {
       if (isRelationField(this.schema, model, field)) {
         continue;
       }
-      updateFields[field] = this.dialect.transformPrimitive(data[field], fieldDef.type);
+      updateFields[field] = this.dialect.transformPrimitive(data[field], fieldDef.type, !!fieldDef.array);
     }
     let query = kysely.updateTable(model).set(updateFields);
     if (limit === void 0) {
@@ -3130,20 +3169,15 @@ var BaseOperationHandler = class {
       model,
       operation: "update"
     }));
-    try {
-      if (!returnData) {
-        const result = await query.executeTakeFirstOrThrow();
-        return {
-          count: Number(result.numUpdatedRows)
-        };
-      } else {
-        const idFields = getIdFields(this.schema, model);
-        const result = await query.returning(idFields).execute();
-        return result;
-      }
-    } catch (err) {
-      const { sql: sql10, parameters } = query.compile();
-      throw new QueryError(`Error during updateMany: ${err}, sql: ${sql10}, parameters: ${parameters}`);
+    if (!returnData) {
+      const result = await query.executeTakeFirstOrThrow();
+      return {
+        count: Number(result.numUpdatedRows)
+      };
+    } else {
+      const idFields = getIdFields(this.schema, model);
+      const result = await query.returning(idFields).execute();
+      return result;
     }
   }
   buildIdFieldRefs(kysely, model) {
@@ -3161,12 +3195,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 +3217,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 +3286,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]
         });
@@ -3342,7 +3376,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
@@ -3450,7 +3484,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: [
           {
@@ -3473,7 +3507,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
@@ -3563,11 +3597,15 @@ 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();
+      if (isolationLevel) {
+        txBuilder = txBuilder.setIsolationLevel(isolationLevel);
+      }
+      return txBuilder.execute(callback);
     }
   }
   // Given a unique filter of a model, return the entity ids by trying to
@@ -3586,6 +3624,28 @@ 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);
+        }
+      }
+    }
+  }
 };
 
 // src/client/crud/operations/aggregate.ts
@@ -3594,21 +3654,22 @@ 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 = eb.selectFrom(this.model).selectAll(this.model).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;
         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) {
@@ -3687,14 +3748,15 @@ 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);
     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);
+      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      subQuery = this.dialect.buildSkipTake(subQuery, parsedArgs?.skip, parsedArgs?.take);
       return subQuery.as("$sub");
     });
-    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)));
+    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(`$sub.${key}`)), "integer").as(key)));
       return query.executeTakeFirstOrThrow();
     } else {
       query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
@@ -3711,10 +3773,11 @@ var CreateOperationHandler = class extends BaseOperationHandler {
     __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_pattern10.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) {
@@ -3764,7 +3827,8 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     __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_pattern11.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, {
@@ -3794,7 +3858,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 normalizeArgs = this.normalizeArgs(args);
+    const parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, operation === "findUnique", normalizeArgs) : normalizeArgs;
     const result = await this.read(this.client.$qb, this.model, parsedArgs);
     const finalResult = operation === "findMany" ? result : result[0] ?? null;
     return finalResult;
@@ -3804,16 +3869,17 @@ 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 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 +3889,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;
+    const bys = typeof parsedArgs.by === "string" ? [
+      parsedArgs.by
+    ] : parsedArgs.by;
     query = query.groupBy(bys);
-    if (validatedArgs.orderBy) {
-      query = this.dialect.buildOrderBy(query, this.model, "$sub", validatedArgs.orderBy, false, false);
+    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((eb1) => this.dialect.buildFilter(eb1, 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) {
@@ -3919,7 +3985,8 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     __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_pattern13.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runUpdate(args) {
     const result = await this.safeTransaction(async (tx) => {
@@ -3975,6 +4042,7 @@ 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");
@@ -3984,10 +4052,9 @@ var InputValidator = class {
     __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 +4111,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;
   }
@@ -4091,7 +4158,7 @@ var InputValidator = class {
   makeWhereSchema(model, unique, withoutRelationFields = 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)) {
@@ -4141,14 +4208,28 @@ 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);
+              } else {
+                fieldSchema = import_zod.z.never();
+              }
+            } else {
+              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional);
+            }
+            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();
@@ -4194,7 +4275,7 @@ var InputValidator = class {
     });
   }
   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();
+    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional)).with("Boolean", () => this.makeBooleanFilterSchema(optional)).with("DateTime", () => this.makeDateTimeFilterSchema(optional)).with("Bytes", () => this.makeBytesFilterSchema(optional)).with("Json", () => import_zod.z.any()).with("Unsupported", () => import_zod.z.never()).exhaustive();
   }
   makeDateTimeFilterSchema(optional) {
     return this.makeCommonPrimitiveFilterSchema(import_zod.z.union([
@@ -4388,8 +4469,8 @@ var InputValidator = class {
     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) => {
@@ -4431,7 +4512,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);
         if (fieldDef.array) {
@@ -4448,23 +4532,23 @@ 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.object(uncheckedVariantFields).strict(), canBeArray);
     } else {
       return import_zod.z.union([
-        import_zod.z.object(regularAndFkFields).strict(),
-        import_zod.z.object(regularAndRelationFields).strict(),
+        import_zod.z.object(uncheckedVariantFields).strict(),
+        import_zod.z.object(checkedVariantFields).strict(),
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(regularAndFkFields).strict())
+          import_zod.z.array(import_zod.z.object(uncheckedVariantFields).strict())
         ] : [],
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(regularAndRelationFields).strict())
+          import_zod.z.array(import_zod.z.object(checkedVariantFields).strict())
         ] : []
       ]);
     }
@@ -4509,7 +4593,7 @@ var InputValidator = class {
         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.object(fields).strict();
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4946,6 +5030,7 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 var import_kysely13 = require("kysely");
 var import_nanoid2 = require("nanoid");
+var import_node_util2 = require("util");
 var import_ts_pattern15 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
@@ -4955,11 +5040,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) {
@@ -5180,7 +5265,9 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       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) {
         queryNode = {
@@ -5190,19 +5277,19 @@ 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, queryId);
+      if (this.isMutationNode(queryNode)) {
+        await this.callAfterQueryInterceptionFilters(result, queryNode, mutationInterceptionInfo);
+      }
       if (oldQueryNode !== queryNode) {
       }
       return result;
     }, "task");
-    return this.executeWithTransaction(task, !!mutationInterceptionInfo?.useTransactionForMutation);
+    return task();
   }
-  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");
+  proceedQueryWithKyselyInterceptors(queryNode, parameters, queryId) {
+    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters, queryId), "proceed");
     const hooks = this.options.plugins?.filter((plugin) => typeof plugin.onKyselyQuery === "function").map((plugin) => plugin.onKyselyQuery.bind(plugin)) ?? [];
     for (const hook of hooks) {
       const _proceed = proceed;
@@ -5212,20 +5299,30 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
           schema: this.client.$schema,
           kysely: this.kysely,
           query,
-          proceed: _proceed,
-          transaction: makeTx(_proceed)
+          proceed: _proceed
         });
       }, "proceed");
     }
     return proceed(queryNode);
   }
-  async proceedQuery(query, queryId) {
+  async proceedQuery(query, parameters, queryId) {
     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 super.executeQuery(compiled, queryId);
     } 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,24 +5350,9 @@ 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);
@@ -5312,14 +5394,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,15 +5413,14 @@ 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) {
       for (const plugin of this.options.plugins) {
         if (plugin.beforeEntityMutation) {
-          plugin.beforeEntityMutation({
-            // context: this.queryContext,
+          await plugin.beforeEntityMutation({
             model: this.getMutationModel(queryNode),
             action: mutationInterceptionInfo.action,
             queryNode,
@@ -5361,12 +5441,12 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
           let afterMutationEntities = void 0;
           if (mutationInterceptionInfo.loadAfterMutationEntity) {
             if (import_kysely13.UpdateQueryNode.is(queryNode)) {
-              afterMutationEntities = await this.loadEntities(this.kysely, mutationModel, mutationInterceptionInfo.where);
+              afterMutationEntities = await this.loadEntities(mutationModel, mutationInterceptionInfo.where);
             } else {
               afterMutationEntities = queryResult.rows;
             }
           }
-          plugin.afterEntityMutation({
+          await plugin.afterEntityMutation({
             model: this.getMutationModel(queryNode),
             action: mutationInterceptionInfo.action,
             queryNode,
@@ -5377,17 +5457,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       }
     }
   }
-  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,8 +5496,8 @@ __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 contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
@@ -5523,8 +5603,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_pattern16.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers10.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers10.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -5532,8 +5612,8 @@ 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 SchemaDbPusher = class {
   static {
@@ -5565,7 +5645,7 @@ 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);
       }
     }
@@ -5573,6 +5653,9 @@ var SchemaDbPusher = class {
     table = this.addUniqueConstraint(table, 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)) {
@@ -5586,7 +5669,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, 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) {
@@ -5632,7 +5715,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_pattern17.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").with("Json", () => "jsonb").otherwise(() => {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
@@ -5645,7 +5728,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;
     }
@@ -5666,11 +5749,11 @@ var SchemaDbPusher = class {
 };
 
 // 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 +5768,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,8 +5783,8 @@ 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 ResultProcessor = class {
   static {
@@ -5774,20 +5858,20 @@ 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);
+    return (0, import_ts_pattern18.match)(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).with("Json", () => this.transformJson(value)).otherwise(() => value);
   }
   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 +5890,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 +5906,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_pattern18.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 +5937,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,16 +5949,16 @@ 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 connectionProvider = new import_kysely16.DefaultConnectionProvider(driver);
-      const executor = new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider);
       this.kyselyProps = {
         config: {
           dialect,
@@ -5873,7 +5966,7 @@ var ClientImpl = class _ClientImpl {
         },
         dialect,
         driver,
-        executor
+        executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
       this.kyselyRaw = new import_kysely16.Kysely({
         ...this.kyselyProps,
@@ -5889,31 +5982,67 @@ var ClientImpl = class _ClientImpl {
   get $qbRaw() {
     return this.kyselyRaw;
   }
+  get isTransaction() {
+    return this.kysely.isTransaction;
+  }
+  /**
+   * Create a new client with a new query executor.
+   */
+  withExecutor(executor) {
+    return new _ClientImpl(this.schema, this.$options, this, executor);
+  }
   getKyselyDialect() {
     return (0, import_ts_pattern19.match)(this.schema.provider.type).with("sqlite", () => this.makeSqliteKyselyDialect()).with("postgresql", () => this.makePostgresKyselyDialect()).exhaustive();
   }
   makePostgresKyselyDialect() {
-    const { dialectConfigProvider } = this.schema.provider;
-    const mergedConfig = {
-      ...dialectConfigProvider(),
-      ...this.options?.dialectConfig
-    };
-    return new import_kysely16.PostgresDialect(mergedConfig);
+    return new import_kysely16.PostgresDialect(this.options.dialectConfig);
   }
   makeSqliteKyselyDialect() {
-    const { dialectConfigProvider } = this.schema.provider;
-    const mergedConfig = {
-      ...dialectConfigProvider(),
-      ...this.options?.dialectConfig
-    };
-    return new import_kysely16.SqliteDialect(mergedConfig);
+    return new import_kysely16.SqliteDialect(this.options.dialectConfig);
+  }
+  // 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) => {
@@ -5944,12 +6073,19 @@ var ClientImpl = class _ClientImpl {
     const newOptions = {
       ...this.options,
       plugins: [
-        ...this.options?.plugins ?? [],
+        ...this.options.plugins ?? [],
         plugin
       ]
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }
+  $unuse(pluginId) {
+    const newOptions = {
+      ...this.options,
+      plugins: this.options.plugins?.filter((p) => p.id !== pluginId)
+    };
+    return new _ClientImpl(this.schema, newOptions, this);
+  }
   $unuseAll() {
     const newOptions = {
       ...this.options,
@@ -5968,6 +6104,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 +6159,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 +6174,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 +6254,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));
     }, "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