@zenstackhq/runtime 3.0.0-beta.7 → 3.0.0-beta.8

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(src_exports, {
   NotFoundError: () => NotFoundError,
   QueryError: () => QueryError,
   ZenStackClient: () => ZenStackClient,
+  ZenStackError: () => ZenStackError,
   definePlugin: () => definePlugin,
   sql: () => import_kysely19.sql
 });
@@ -47,7 +48,7 @@ var import_kysely18 = require("kysely");
 
 // src/client/crud/operations/aggregate.ts
 var import_kysely11 = require("kysely");
-var import_ts_pattern10 = require("ts-pattern");
+var import_ts_pattern11 = require("ts-pattern");
 
 // src/client/query-utils.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
@@ -152,7 +153,12 @@ function fieldsToSelectObject(fields) {
 __name(fieldsToSelectObject, "fieldsToSelectObject");
 
 // src/client/errors.ts
-var InputValidationError = class extends Error {
+var ZenStackError = class extends Error {
+  static {
+    __name(this, "ZenStackError");
+  }
+};
+var InputValidationError = class extends ZenStackError {
   static {
     __name(this, "InputValidationError");
   }
@@ -162,7 +168,7 @@ var InputValidationError = class extends Error {
     });
   }
 };
-var QueryError = class extends Error {
+var QueryError = class extends ZenStackError {
   static {
     __name(this, "QueryError");
   }
@@ -172,12 +178,12 @@ var QueryError = class extends Error {
     });
   }
 };
-var InternalError = class extends Error {
+var InternalError = class extends ZenStackError {
   static {
     __name(this, "InternalError");
   }
 };
-var NotFoundError = class extends Error {
+var NotFoundError = class extends ZenStackError {
   static {
     __name(this, "NotFoundError");
   }
@@ -518,7 +524,7 @@ var import_cuid2 = require("@paralleldrive/cuid2");
 var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely10 = require("kysely");
 var import_nanoid = require("nanoid");
-var import_ts_pattern9 = require("ts-pattern");
+var import_ts_pattern10 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
 
@@ -529,7 +535,7 @@ var RejectedByPolicyReason = /* @__PURE__ */ function(RejectedByPolicyReason2) {
   RejectedByPolicyReason2["OTHER"] = "other";
   return RejectedByPolicyReason2;
 }({});
-var RejectedByPolicyError = class extends Error {
+var RejectedByPolicyError = class extends ZenStackError {
   static {
     __name(this, "RejectedByPolicyError");
   }
@@ -559,6 +565,10 @@ var CRUD = [
   "update",
   "delete"
 ];
+var CRUD_EXT = [
+  ...CRUD,
+  "post-update"
+];
 
 // src/client/kysely-utils.ts
 var import_kysely = require("kysely");
@@ -595,7 +605,7 @@ __name(extractFieldName, "extractFieldName");
 // src/plugins/policy/policy-handler.ts
 var import_common_helpers7 = require("@zenstackhq/common-helpers");
 var import_kysely8 = require("kysely");
-var import_ts_pattern8 = require("ts-pattern");
+var import_ts_pattern9 = require("ts-pattern");
 
 // src/client/crud/dialects/index.ts
 var import_ts_pattern5 = require("ts-pattern");
@@ -1742,6 +1752,59 @@ function getCrudDialect(schema, options) {
 }
 __name(getCrudDialect, "getCrudDialect");
 
+// src/utils/expression-utils.ts
+var import_ts_pattern6 = require("ts-pattern");
+var ExpressionVisitor = class {
+  static {
+    __name(this, "ExpressionVisitor");
+  }
+  visit(expr2) {
+    (0, import_ts_pattern6.match)(expr2).with({
+      kind: "literal"
+    }, (e) => this.visitLiteral(e)).with({
+      kind: "array"
+    }, (e) => this.visitArray(e)).with({
+      kind: "field"
+    }, (e) => this.visitField(e)).with({
+      kind: "member"
+    }, (e) => this.visitMember(e)).with({
+      kind: "binary"
+    }, (e) => this.visitBinary(e)).with({
+      kind: "unary"
+    }, (e) => this.visitUnary(e)).with({
+      kind: "call"
+    }, (e) => this.visitCall(e)).with({
+      kind: "this"
+    }, (e) => this.visitThis(e)).with({
+      kind: "null"
+    }, (e) => this.visitNull(e)).exhaustive();
+  }
+  visitLiteral(_e) {
+  }
+  visitArray(e) {
+    e.items.forEach((item) => this.visit(item));
+  }
+  visitField(_e) {
+  }
+  visitMember(e) {
+    this.visit(e.receiver);
+  }
+  visitBinary(e) {
+    this.visit(e.left);
+    this.visit(e.right);
+  }
+  visitUnary(e) {
+    this.visit(e.operand);
+  }
+  visitCall(e) {
+    e.args?.forEach((arg) => this.visit(arg));
+  }
+  visitThis(_e) {
+  }
+  visitNull(_e) {
+  }
+};
+
 // src/utils/default-operation-node-visitor.ts
 var import_kysely5 = require("kysely");
 var DefaultOperationNodeVisitor = class extends import_kysely5.OperationNodeVisitor {
@@ -2063,17 +2126,17 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 // src/plugins/policy/expression-transformer.ts
 var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_kysely7 = require("kysely");
-var import_ts_pattern7 = require("ts-pattern");
+var import_ts_pattern8 = require("ts-pattern");
 
 // src/plugins/policy/expression-evaluator.ts
 var import_common_helpers5 = require("@zenstackhq/common-helpers");
-var import_ts_pattern6 = require("ts-pattern");
+var import_ts_pattern7 = require("ts-pattern");
 var ExpressionEvaluator = class {
   static {
     __name(this, "ExpressionEvaluator");
   }
   evaluate(expression, context) {
-    const result = (0, import_ts_pattern6.match)(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
+    const result = (0, import_ts_pattern7.match)(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
     return result ?? null;
   }
   evaluateCall(expr2, context) {
@@ -2084,7 +2147,7 @@ var ExpressionEvaluator = class {
     }
   }
   evaluateUnary(expr2, context) {
-    return (0, import_ts_pattern6.match)(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
+    return (0, import_ts_pattern7.match)(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
   }
   evaluateMember(expr2, context) {
     let val = this.evaluate(expr2.receiver, context);
@@ -2108,7 +2171,7 @@ var ExpressionEvaluator = class {
     }
     const left = this.evaluate(expr2.left, context);
     const right = this.evaluate(expr2.right, context);
-    return (0, import_ts_pattern6.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
+    return (0, import_ts_pattern7.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
       const _right = right ?? [];
       (0, import_common_helpers5.invariant)(Array.isArray(_right), 'expected array for "in" operator');
       return _right.includes(left);
@@ -2122,7 +2185,7 @@ var ExpressionEvaluator = class {
       return false;
     }
     (0, import_common_helpers5.invariant)(Array.isArray(left), "expected array");
-    return (0, import_ts_pattern6.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
+    return (0, import_ts_pattern7.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
     }))).with("!", () => left.every((item) => this.evaluate(expr2.right, {
@@ -2232,6 +2295,10 @@ function getTableName(node) {
   return void 0;
 }
 __name(getTableName, "getTableName");
+function isBeforeInvocation(expr2) {
+  return ExpressionUtils.isCall(expr2) && expr2.function === "before";
+}
+__name(isBeforeInvocation, "isBeforeInvocation");
 
 // src/plugins/policy/expression-transformer.ts
 function _ts_decorate(decorators, target, key, desc) {
@@ -2435,7 +2502,7 @@ var ExpressionTransformer = class {
     const count = import_kysely7.FunctionNode.create("count", [
       import_kysely7.ValueNode.createImmediate(1)
     ]);
-    const predicateResult = (0, import_ts_pattern7.match)(expr2.op).with("?", () => import_kysely7.BinaryOperationNode.create(count, import_kysely7.OperatorNode.create(">"), import_kysely7.ValueNode.createImmediate(0))).with("!", () => import_kysely7.BinaryOperationNode.create(count, import_kysely7.OperatorNode.create("="), import_kysely7.ValueNode.createImmediate(0))).with("^", () => import_kysely7.BinaryOperationNode.create(count, import_kysely7.OperatorNode.create("="), import_kysely7.ValueNode.createImmediate(0))).exhaustive();
+    const predicateResult = (0, import_ts_pattern8.match)(expr2.op).with("?", () => import_kysely7.BinaryOperationNode.create(count, import_kysely7.OperatorNode.create(">"), import_kysely7.ValueNode.createImmediate(0))).with("!", () => import_kysely7.BinaryOperationNode.create(count, import_kysely7.OperatorNode.create("="), import_kysely7.ValueNode.createImmediate(0))).with("^", () => import_kysely7.BinaryOperationNode.create(count, import_kysely7.OperatorNode.create("="), import_kysely7.ValueNode.createImmediate(0))).exhaustive();
     return this.transform(expr2.left, {
       ...context,
       memberSelect: import_kysely7.SelectionNode.create(import_kysely7.AliasNode.create(predicateResult, import_kysely7.IdentifierNode.create("$t"))),
@@ -2500,7 +2567,7 @@ var ExpressionTransformer = class {
     return logicalNot(this.dialect, this.transform(expr2.operand, context));
   }
   transformOperator(op) {
-    const mappedOp = (0, import_ts_pattern7.match)(op).with("==", () => "=").otherwise(() => op);
+    const mappedOp = (0, import_ts_pattern8.match)(op).with("==", () => "=").otherwise(() => op);
     return import_kysely7.OperatorNode.create(mappedOp);
   }
   _call(expr2, context) {
@@ -2544,7 +2611,7 @@ var ExpressionTransformer = class {
       return this.transformCall(arg, context);
     }
     if (this.isAuthMember(arg)) {
-      const valNode = this.valueMemberAccess(context.auth, arg, this.authType);
+      const valNode = this.valueMemberAccess(this.auth, arg, this.authType);
       return valNode ? eb.val(valNode.value) : eb.val(null);
     }
     throw new InternalError(`Unsupported argument expression: ${arg.kind}`);
@@ -2553,6 +2620,11 @@ var ExpressionTransformer = class {
     if (this.isAuthCall(expr2.receiver)) {
       return this.valueMemberAccess(this.auth, expr2, this.authType);
     }
+    if (isBeforeInvocation(expr2.receiver)) {
+      (0, import_common_helpers6.invariant)(context.operation === "post-update", "before() can only be used in post-update policy");
+      (0, import_common_helpers6.invariant)(expr2.members.length === 1, "before() can only be followed by a scalar field access");
+      return import_kysely7.ReferenceNode.create(import_kysely7.ColumnNode.create(expr2.members[0]), import_kysely7.TableNode.create("$before"));
+    }
     (0, import_common_helpers6.invariant)(ExpressionUtils.isField(expr2.receiver) || ExpressionUtils.isThis(expr2.receiver), 'expect receiver to be field expression or "this"');
     let members = expr2.members;
     let receiver;
@@ -2597,7 +2669,6 @@ var ExpressionTransformer = class {
           alias: void 0
         });
         if (currNode) {
-          (0, import_common_helpers6.invariant)(import_kysely7.SelectQueryNode.is(currNode), "expected select query node");
           currNode = {
             ...relation,
             selections: [
@@ -2808,9 +2879,45 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
         await this.enforcePreCreatePolicy(node, mutationModel, isManyToManyJoinTable, proceed);
       }
     }
+    const hasPostUpdatePolicies = import_kysely8.UpdateQueryNode.is(node) && this.hasPostUpdatePolicies(mutationModel);
+    let beforeUpdateInfo;
+    if (hasPostUpdatePolicies) {
+      beforeUpdateInfo = await this.loadBeforeUpdateEntities(mutationModel, node.where, proceed);
+    }
     const result = await proceed(this.transformNode(node));
+    if (hasPostUpdatePolicies && result.rows.length > 0) {
+      const idConditions = this.buildIdConditions(mutationModel, result.rows);
+      const postUpdateFilter = this.buildPolicyFilter(mutationModel, void 0, "post-update");
+      const eb = (0, import_kysely8.expressionBuilder)();
+      const beforeUpdateTable = beforeUpdateInfo ? {
+        kind: "SelectQueryNode",
+        from: import_kysely8.FromNode.create([
+          import_kysely8.ParensNode.create(import_kysely8.ValuesNode.create(beforeUpdateInfo.rows.map((r) => import_kysely8.PrimitiveValueListNode.create(beforeUpdateInfo.fields.map((f) => r[f])))))
+        ]),
+        selections: beforeUpdateInfo.fields.map((name, index) => {
+          const def = requireField(this.client.$schema, mutationModel, name);
+          const castedColumnRef = import_kysely8.sql`CAST(${eb.ref(`column${index + 1}`)} as ${import_kysely8.sql.raw(this.dialect.getFieldSqlType(def))})`.as(name);
+          return import_kysely8.SelectionNode.create(castedColumnRef.toOperationNode());
+        })
+      } : void 0;
+      const postUpdateQuery = eb.selectFrom(mutationModel).select(() => [
+        eb(eb.fn("COUNT", [
+          eb.lit(1)
+        ]), "=", result.rows.length).as("$condition")
+      ]).where(() => new import_kysely8.ExpressionWrapper(conjunction(this.dialect, [
+        idConditions,
+        postUpdateFilter
+      ]))).$if(!!beforeUpdateInfo, (qb) => qb.leftJoin(() => new import_kysely8.ExpressionWrapper(beforeUpdateTable).as("$before"), (join) => {
+        const idFields = requireIdFields(this.client.$schema, mutationModel);
+        return idFields.reduce((acc, f) => acc.onRef(`${mutationModel}.${f}`, "=", `$before.${f}`), join);
+      }));
+      const postUpdateResult = await proceed(postUpdateQuery.toOperationNode());
+      if (!postUpdateResult.rows[0]?.$condition) {
+        throw new RejectedByPolicyError(mutationModel, RejectedByPolicyReason.NO_ACCESS, "some or all updated rows failed to pass post-update policy check");
+      }
+    }
     if (!node.returning || this.onlyReturningId(node)) {
-      return result;
+      return this.postProcessMutationResult(result, node);
     } else {
       const readBackResult = await this.processReadBack(node, result, proceed);
       if (readBackResult.rows.length !== result.rows.length) {
@@ -2819,6 +2926,68 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
       return readBackResult;
     }
   }
+  // correction to kysely mutation result may be needed because we might have added
+  // returning clause to the query and caused changes to the result shape
+  postProcessMutationResult(result, node) {
+    if (node.returning) {
+      return result;
+    } else {
+      return {
+        ...result,
+        rows: [],
+        numAffectedRows: result.numAffectedRows ?? BigInt(result.rows.length)
+      };
+    }
+  }
+  hasPostUpdatePolicies(model) {
+    const policies = this.getModelPolicies(model, "post-update");
+    return policies.length > 0;
+  }
+  async loadBeforeUpdateEntities(model, where, proceed) {
+    const beforeUpdateAccessFields = this.getFieldsAccessForBeforeUpdatePolicies(model);
+    if (!beforeUpdateAccessFields || beforeUpdateAccessFields.length === 0) {
+      return void 0;
+    }
+    const query = {
+      kind: "SelectQueryNode",
+      from: import_kysely8.FromNode.create([
+        import_kysely8.TableNode.create(model)
+      ]),
+      where,
+      selections: [
+        ...beforeUpdateAccessFields.map((f) => import_kysely8.SelectionNode.create(import_kysely8.ColumnNode.create(f)))
+      ]
+    };
+    const result = await proceed(query);
+    return {
+      fields: beforeUpdateAccessFields,
+      rows: result.rows
+    };
+  }
+  getFieldsAccessForBeforeUpdatePolicies(model) {
+    const policies = this.getModelPolicies(model, "post-update");
+    if (policies.length === 0) {
+      return void 0;
+    }
+    const fields = /* @__PURE__ */ new Set();
+    const fieldCollector = new class extends ExpressionVisitor {
+      visitMember(e) {
+        if (isBeforeInvocation(e.receiver)) {
+          (0, import_common_helpers7.invariant)(e.members.length === 1, "before() can only be followed by a scalar field access");
+          fields.add(e.members[0]);
+        }
+        super.visitMember(e);
+      }
+    }();
+    for (const policy of policies) {
+      fieldCollector.visit(policy.condition);
+    }
+    if (fields.size === 0) {
+      return void 0;
+    }
+    requireIdFields(this.client.$schema, model).forEach((f) => fields.add(f));
+    return Array.from(fields).sort();
+  }
   // #region overrides
   transformSelectQuery(node) {
     let whereNode = this.transformNode(node.where);
@@ -2884,19 +3053,16 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
       onConflict
     } : node;
     const result = super.transformInsertQuery(processedNode);
-    if (!node.returning) {
-      return result;
-    }
-    if (this.onlyReturningId(node)) {
-      return result;
-    } else {
+    let returning = result.returning;
+    if (returning) {
       const { mutationModel } = this.getMutationModel(node);
       const idFields = requireIdFields(this.client.$schema, mutationModel);
-      return {
-        ...result,
-        returning: import_kysely8.ReturningNode.create(idFields.map((field) => import_kysely8.SelectionNode.create(import_kysely8.ColumnNode.create(field))))
-      };
+      returning = import_kysely8.ReturningNode.create(idFields.map((f) => import_kysely8.SelectionNode.create(import_kysely8.ColumnNode.create(f))));
     }
+    return {
+      ...result,
+      returning
+    };
   }
   transformUpdateQuery(node) {
     const result = super.transformUpdateQuery(node);
@@ -2911,12 +3077,18 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
         ]);
       }
     }
+    let returning = result.returning;
+    if (returning || this.hasPostUpdatePolicies(mutationModel)) {
+      const idFields = requireIdFields(this.client.$schema, mutationModel);
+      returning = import_kysely8.ReturningNode.create(idFields.map((f) => import_kysely8.SelectionNode.create(import_kysely8.ColumnNode.create(f))));
+    }
     return {
       ...result,
       where: import_kysely8.WhereNode.create(result.where ? conjunction(this.dialect, [
         result.where.where,
         filter
-      ]) : filter)
+      ]) : filter),
+      returning
     };
   }
   transformDeleteQuery(node) {
@@ -2948,6 +3120,14 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
     }
     const { mutationModel } = this.getMutationModel(node);
     const idFields = requireIdFields(this.client.$schema, mutationModel);
+    if (node.returning.selections.some((s) => import_kysely8.SelectAllNode.is(s.selection))) {
+      const modelDef = requireModel(this.client.$schema, mutationModel);
+      if (Object.keys(modelDef.fields).some((f) => !idFields.includes(f))) {
+        return false;
+      } else {
+        return true;
+      }
+    }
     const collector = new ColumnCollector();
     const selectedColumns = collector.collect(node.returning);
     return selectedColumns.every((c) => idFields.includes(c));
@@ -3131,10 +3311,10 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
   }
   buildIdConditions(table, rows) {
     const idFields = requireIdFields(this.client.$schema, table);
-    return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => import_kysely8.BinaryOperationNode.create(import_kysely8.ColumnNode.create(field), import_kysely8.OperatorNode.create("="), import_kysely8.ValueNode.create(row[field]))))));
+    return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => import_kysely8.BinaryOperationNode.create(import_kysely8.ReferenceNode.create(import_kysely8.ColumnNode.create(field), import_kysely8.TableNode.create(table)), import_kysely8.OperatorNode.create("="), import_kysely8.ValueNode.create(row[field]))))));
   }
   getMutationModel(node) {
-    const r = (0, import_ts_pattern8.match)(node).when(import_kysely8.InsertQueryNode.is, (node2) => ({
+    const r = (0, import_ts_pattern9.match)(node).when(import_kysely8.InsertQueryNode.is, (node2) => ({
       mutationModel: getTableName(node2.into),
       alias: void 0
     })).when(import_kysely8.UpdateQueryNode.is, (node2) => {
@@ -3173,23 +3353,24 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
       return m2mFilter;
     }
     const policies = this.getModelPolicies(model, operation);
-    if (policies.length === 0) {
-      return falseNode(this.dialect);
-    }
     const allows = policies.filter((policy) => policy.kind === "allow").map((policy) => this.compilePolicyCondition(model, alias, operation, policy));
     const denies = policies.filter((policy) => policy.kind === "deny").map((policy) => this.compilePolicyCondition(model, alias, operation, policy));
     let combinedPolicy;
     if (allows.length === 0) {
-      combinedPolicy = falseNode(this.dialect);
+      if (operation === "post-update") {
+        combinedPolicy = trueNode(this.dialect);
+      } else {
+        combinedPolicy = falseNode(this.dialect);
+      }
     } else {
       combinedPolicy = disjunction(this.dialect, allows);
-      if (denies.length !== 0) {
-        const combinedDenies = conjunction(this.dialect, denies.map((d) => buildIsFalse(d, this.dialect)));
-        combinedPolicy = conjunction(this.dialect, [
-          combinedPolicy,
-          combinedDenies
-        ]);
-      }
+    }
+    if (denies.length !== 0) {
+      const combinedDenies = conjunction(this.dialect, denies.map((d) => buildIsFalse(d, this.dialect)));
+      combinedPolicy = conjunction(this.dialect, [
+        combinedPolicy,
+        combinedDenies
+      ]);
     }
     return combinedPolicy;
   }
@@ -3236,8 +3417,7 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
     return new ExpressionTransformer(this.client).transform(policy.condition, {
       model,
       alias,
-      operation,
-      auth: this.client.$auth
+      operation
     });
   }
   getModelPolicies(model, operation) {
@@ -3253,7 +3433,7 @@ var PolicyHandler = class extends import_kysely8.OperationNodeTransformer {
         kind: attr.name === "@@allow" ? "allow" : "deny",
         operations: extractOperations(attr.args[0].value),
         condition: attr.args[1].value
-      })).filter((policy) => policy.operations.includes("all") || policy.operations.includes(operation)));
+      })).filter((policy) => operation !== "post-update" && policy.operations.includes("all") || policy.operations.includes(operation)));
     }
     return result;
   }
@@ -3354,18 +3534,9 @@ var PolicyPlugin = class {
       check
     };
   }
-  onKyselyQuery({
-    query,
-    client,
-    proceed
-    /*, transaction*/
-  }) {
+  onKyselyQuery({ query, client, proceed }) {
     const handler = new PolicyHandler(client);
-    return handler.handle(
-      query,
-      proceed
-      /*, transaction*/
-    );
+    return handler.handle(query, proceed);
   }
 };
 
@@ -3906,7 +4077,7 @@ var BaseOperationHandler = class {
   }
   evalGenerator(defaultValue) {
     if (ExpressionUtils.isCall(defaultValue)) {
-      return (0, import_ts_pattern9.match)(defaultValue.function).with("cuid", () => (0, import_cuid2.createId)()).with("uuid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args?.[0]) && defaultValue.args[0].value === 7 ? uuid.v7() : uuid.v4()).with("nanoid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args[0]) && typeof defaultValue.args[0].value === "number" ? (0, import_nanoid.nanoid)(defaultValue.args[0].value) : (0, import_nanoid.nanoid)()).with("ulid", () => (0, import_ulid.ulid)()).otherwise(() => void 0);
+      return (0, import_ts_pattern10.match)(defaultValue.function).with("cuid", () => (0, import_cuid2.createId)()).with("uuid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args?.[0]) && defaultValue.args[0].value === 7 ? uuid.v7() : uuid.v4()).with("nanoid", () => defaultValue.args?.[0] && ExpressionUtils.isLiteral(defaultValue.args[0]) && typeof defaultValue.args[0].value === "number" ? (0, import_nanoid.nanoid)(defaultValue.args[0].value) : (0, import_nanoid.nanoid)()).with("ulid", () => (0, import_ulid.ulid)()).otherwise(() => void 0);
     } else if (ExpressionUtils.isMember(defaultValue) && ExpressionUtils.isCall(defaultValue.receiver) && defaultValue.receiver.function === "auth") {
       let val = this.client.$auth;
       for (const member of defaultValue.members) {
@@ -4088,7 +4259,7 @@ var BaseOperationHandler = class {
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely10.expressionBuilder)();
     const fieldRef = this.dialect.fieldRef(model, field, eb);
-    return (0, import_ts_pattern9.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
+    return (0, import_ts_pattern10.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
       throw new InternalError(`Invalid incremental update operation: ${key}`);
     });
   }
@@ -4098,7 +4269,7 @@ var BaseOperationHandler = class {
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely10.expressionBuilder)();
     const fieldRef = this.dialect.fieldRef(model, field, eb);
-    return (0, import_ts_pattern9.match)(key).with("set", () => value).with("push", () => {
+    return (0, import_ts_pattern10.match)(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw new InternalError(`Invalid array update operation: ${key}`);
@@ -4168,8 +4339,9 @@ var BaseOperationHandler = class {
       };
     } else {
       const idFields = requireIdFields(this.schema, model);
-      const result = await query.returning(idFields).execute();
-      return result;
+      const finalQuery = query.returning(idFields);
+      const result = await this.executeQuery(kysely, finalQuery, "update");
+      return result.rows;
     }
   }
   async processBaseModelUpdateMany(kysely, model, where, updateFields, filterModel) {
@@ -4789,7 +4961,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = (0, import_ts_pattern10.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = (0, import_ts_pattern11.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(import_kysely11.sql.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -4822,7 +4994,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern10.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern11.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4873,14 +5045,14 @@ var CountOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/create.ts
-var import_ts_pattern11 = require("ts-pattern");
+var import_ts_pattern12 = require("ts-pattern");
 var CreateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern11.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+    return (0, import_ts_pattern12.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
       return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, normalizedArgs));
     }).with("createManyAndReturn", () => {
       return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, normalizedArgs));
@@ -4927,14 +5099,14 @@ var CreateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/delete.ts
-var import_ts_pattern12 = require("ts-pattern");
+var import_ts_pattern13 = require("ts-pattern");
 var DeleteOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern12.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
+    return (0, import_ts_pattern13.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, {
@@ -4986,7 +5158,7 @@ var FindOperationHandler = class extends BaseOperationHandler {
 
 // src/client/crud/operations/group-by.ts
 var import_kysely13 = require("kysely");
-var import_ts_pattern13 = require("ts-pattern");
+var import_ts_pattern14 = require("ts-pattern");
 var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "GroupByOperationHandler");
@@ -5080,7 +5252,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern13.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern14.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -5095,14 +5267,14 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/update.ts
-var import_ts_pattern14 = require("ts-pattern");
+var import_ts_pattern15 = require("ts-pattern");
 var UpdateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern14.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
+    return (0, import_ts_pattern15.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runUpdate(args) {
     const readBackResult = await this.safeTransaction(async (tx) => {
@@ -5182,7 +5354,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_decimal3 = __toESM(require("decimal.js"), 1);
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
-var import_ts_pattern15 = require("ts-pattern");
+var import_ts_pattern16 = require("ts-pattern");
 var import_zod = require("zod");
 
 // src/utils/zod-utils.ts
@@ -5298,7 +5470,7 @@ var InputValidator = class {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefSchema(type);
     } else {
-      return (0, import_ts_pattern15.match)(type).with("String", () => import_zod.z.string()).with("Int", () => import_zod.z.number().int()).with("Float", () => import_zod.z.number()).with("Boolean", () => import_zod.z.boolean()).with("BigInt", () => import_zod.z.union([
+      return (0, import_ts_pattern16.match)(type).with("String", () => import_zod.z.string()).with("Int", () => import_zod.z.number().int()).with("Float", () => import_zod.z.number()).with("Boolean", () => import_zod.z.boolean()).with("BigInt", () => import_zod.z.union([
         import_zod.z.number().int(),
         import_zod.z.bigint()
       ])).with("Decimal", () => import_zod.z.union([
@@ -5459,7 +5631,7 @@ var InputValidator = class {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefFilterSchema(type, optional);
     }
-    return (0, import_ts_pattern15.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern15.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => import_zod.z.any()).with("Unsupported", () => import_zod.z.never()).exhaustive();
+    return (0, import_ts_pattern16.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern16.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => import_zod.z.any()).with("Unsupported", () => import_zod.z.never()).exhaustive();
   }
   makeTypeDefFilterSchema(_type, _optional) {
     return import_zod.z.never();
@@ -6405,7 +6577,7 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
-var import_ts_pattern16 = require("ts-pattern");
+var import_ts_pattern17 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
 var import_common_helpers12 = require("@zenstackhq/common-helpers");
@@ -6773,13 +6945,37 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely15
   get options() {
     return this.client.$options;
   }
-  async executeQuery(compiledQuery, queryId) {
+  executeQuery(compiledQuery, queryId) {
     const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
-    const result = await this.proceedQueryWithKyselyInterceptors(compiledQuery.query, queryParams, queryId.queryId);
-    return result.result;
+    return this.provideConnection(async (connection) => {
+      let startedTx = false;
+      try {
+        if (this.isMutationNode(compiledQuery.query) && !this.driver.isTransactionConnection(connection)) {
+          await this.driver.beginTransaction(connection, {
+            isolationLevel: TransactionIsolationLevel.RepeatableRead
+          });
+          startedTx = true;
+        }
+        const result = await this.proceedQueryWithKyselyInterceptors(connection, compiledQuery.query, queryParams, queryId.queryId);
+        if (startedTx) {
+          await this.driver.commitTransaction(connection);
+        }
+        return result;
+      } catch (err) {
+        if (startedTx) {
+          await this.driver.rollbackTransaction(connection);
+        }
+        if (err instanceof ZenStackError) {
+          throw err;
+        } else {
+          const message = `Failed to execute query: ${err}, sql: ${compiledQuery?.sql}`;
+          throw new QueryError(message, err);
+        }
+      }
+    });
   }
-  async proceedQueryWithKyselyInterceptors(queryNode, parameters, queryId) {
-    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters, queryId), "proceed");
+  async proceedQueryWithKyselyInterceptors(connection, queryNode, parameters, queryId) {
+    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(connection, q, parameters, queryId), "proceed");
     const hooks = [];
     for (const plugin of this.client.$options.plugins ?? []) {
       if (plugin.onKyselyQuery) {
@@ -6789,19 +6985,14 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely15
     for (const hook of hooks) {
       const _proceed = proceed;
       proceed = /* @__PURE__ */ __name(async (query) => {
-        const _p = /* @__PURE__ */ __name(async (q) => {
-          const r = await _proceed(q);
-          return r.result;
-        }, "_p");
+        const _p = /* @__PURE__ */ __name((q) => _proceed(q), "_p");
         const hookResult = await hook({
           client: this.client,
           schema: this.client.$schema,
           query,
           proceed: _p
         });
-        return {
-          result: hookResult
-        };
+        return hookResult;
       }, "proceed");
     }
     const result = await proceed(queryNode);
@@ -6809,7 +7000,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely15
   }
   getMutationInfo(queryNode) {
     const model = this.getMutationModel(queryNode);
-    const { action, where } = (0, import_ts_pattern16.match)(queryNode).when(import_kysely15.InsertQueryNode.is, () => ({
+    const { action, where } = (0, import_ts_pattern17.match)(queryNode).when(import_kysely15.InsertQueryNode.is, () => ({
       action: "create",
       where: void 0
     })).when(import_kysely15.UpdateQueryNode.is, (node) => ({
@@ -6825,85 +7016,54 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely15
       where
     };
   }
-  async proceedQuery(query, parameters, queryId) {
+  async proceedQuery(connection, query, parameters, queryId) {
     let compiled;
-    try {
-      return await this.provideConnection(async (connection) => {
-        if (this.suppressMutationHooks || !this.isMutationNode(query) || !this.hasEntityMutationPlugins) {
-          const finalQuery2 = this.nameMapper.transformNode(query);
-          compiled = this.compileQuery(finalQuery2);
-          if (parameters) {
-            compiled = {
-              ...compiled,
-              parameters
-            };
-          }
-          const result = await connection.executeQuery(compiled);
-          return {
-            result
-          };
-        }
-        if ((import_kysely15.InsertQueryNode.is(query) || import_kysely15.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks) {
-          query = {
-            ...query,
-            returning: import_kysely15.ReturningNode.create([
-              import_kysely15.SelectionNode.createSelectAll()
-            ])
-          };
-        }
-        const finalQuery = this.nameMapper.transformNode(query);
-        compiled = this.compileQuery(finalQuery);
-        if (parameters) {
-          compiled = {
-            ...compiled,
-            parameters
-          };
-        }
-        const currentlyInTx = this.driver.isTransactionConnection(connection);
-        const connectionClient = this.createClientForConnection(connection, currentlyInTx);
-        const mutationInfo = this.getMutationInfo(finalQuery);
-        let beforeMutationEntities;
-        const loadBeforeMutationEntities = /* @__PURE__ */ __name(async () => {
-          if (beforeMutationEntities === void 0 && (import_kysely15.UpdateQueryNode.is(query) || import_kysely15.DeleteQueryNode.is(query))) {
-            beforeMutationEntities = await this.loadEntities(mutationInfo.model, mutationInfo.where, connection);
-          }
-          return beforeMutationEntities;
-        }, "loadBeforeMutationEntities");
-        await this.callBeforeMutationHooks(finalQuery, mutationInfo, loadBeforeMutationEntities, connectionClient, queryId);
-        const shouldCreateTx = this.hasPluginRequestingAfterMutationWithinTransaction && !this.driver.isTransactionConnection(connection);
-        if (!shouldCreateTx) {
-          const result = await connection.executeQuery(compiled);
-          if (!this.driver.isTransactionConnection(connection)) {
-            await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "all", queryId);
-          } else {
-            await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "inTx", queryId);
-            this.driver.registerTransactionCommitCallback(connection, () => this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "outTx", queryId));
-          }
-          return {
-            result
-          };
-        } else {
-          await this.driver.beginTransaction(connection, {
-            isolationLevel: TransactionIsolationLevel.ReadCommitted
-          });
-          try {
-            const result = await connection.executeQuery(compiled);
-            await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "inTx", queryId);
-            await this.driver.commitTransaction(connection);
-            await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "outTx", queryId);
-            return {
-              result
-            };
-          } catch (err) {
-            await this.driver.rollbackTransaction(connection);
-            throw err;
-          }
-        }
-      });
-    } catch (err) {
-      const message = `Failed to execute query: ${err}, sql: ${compiled?.sql}`;
-      throw new QueryError(message, err);
+    if (this.suppressMutationHooks || !this.isMutationNode(query) || !this.hasEntityMutationPlugins) {
+      const finalQuery2 = this.nameMapper.transformNode(query);
+      compiled = this.compileQuery(finalQuery2);
+      if (parameters) {
+        compiled = {
+          ...compiled,
+          parameters
+        };
+      }
+      return connection.executeQuery(compiled);
+    }
+    if ((import_kysely15.InsertQueryNode.is(query) || import_kysely15.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks) {
+      query = {
+        ...query,
+        returning: import_kysely15.ReturningNode.create([
+          import_kysely15.SelectionNode.createSelectAll()
+        ])
+      };
     }
+    const finalQuery = this.nameMapper.transformNode(query);
+    compiled = this.compileQuery(finalQuery);
+    if (parameters) {
+      compiled = {
+        ...compiled,
+        parameters
+      };
+    }
+    const currentlyInTx = this.driver.isTransactionConnection(connection);
+    const connectionClient = this.createClientForConnection(connection, currentlyInTx);
+    const mutationInfo = this.getMutationInfo(finalQuery);
+    let beforeMutationEntities;
+    const loadBeforeMutationEntities = /* @__PURE__ */ __name(async () => {
+      if (beforeMutationEntities === void 0 && (import_kysely15.UpdateQueryNode.is(query) || import_kysely15.DeleteQueryNode.is(query))) {
+        beforeMutationEntities = await this.loadEntities(mutationInfo.model, mutationInfo.where, connection);
+      }
+      return beforeMutationEntities;
+    }, "loadBeforeMutationEntities");
+    await this.callBeforeMutationHooks(finalQuery, mutationInfo, loadBeforeMutationEntities, connectionClient, queryId);
+    const result = await connection.executeQuery(compiled);
+    if (!this.driver.isTransactionConnection(connection)) {
+      await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "all", queryId);
+    } else {
+      await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "inTx", queryId);
+      this.driver.registerTransactionCommitCallback(connection, () => this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "outTx", queryId));
+    }
+    return result;
   }
   createClientForConnection(connection, inTx) {
     const innerExecutor = this.withConnectionProvider(new import_kysely15.SingleConnectionProvider(connection));
@@ -6920,9 +7080,6 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely15
   get hasEntityMutationPluginsWithAfterMutationHooks() {
     return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation?.afterEntityMutation);
   }
-  get hasPluginRequestingAfterMutationWithinTransaction() {
-    return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation?.runAfterMutationWithinTransaction);
-  }
   isMutationNode(queryNode) {
     return import_kysely15.InsertQueryNode.is(queryNode) || import_kysely15.UpdateQueryNode.is(queryNode) || import_kysely15.DeleteQueryNode.is(queryNode);
   }
@@ -6953,7 +7110,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely15
     return newExecutor;
   }
   getMutationModel(queryNode) {
-    return (0, import_ts_pattern16.match)(queryNode).when(import_kysely15.InsertQueryNode.is, (node) => {
+    return (0, import_ts_pattern17.match)(queryNode).when(import_kysely15.InsertQueryNode.is, (node) => {
       (0, import_common_helpers13.invariant)(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
     }).when(import_kysely15.UpdateQueryNode.is, (node) => {
@@ -7064,7 +7221,7 @@ __export(functions_exports, {
 });
 var import_common_helpers14 = require("@zenstackhq/common-helpers");
 var import_kysely16 = require("kysely");
-var import_ts_pattern17 = require("ts-pattern");
+var import_ts_pattern18 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
 var search = /* @__PURE__ */ __name((_eb, _args) => {
   throw new Error(`"search" function is not implemented yet`);
@@ -7101,7 +7258,7 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   } else {
     op = "like";
   }
-  searchExpr = (0, import_ts_pattern17.match)(method).with("contains", () => eb.fn("CONCAT", [
+  searchExpr = (0, import_ts_pattern18.match)(method).with("contains", () => eb.fn("CONCAT", [
     import_kysely16.sql.lit("%"),
     import_kysely16.sql`CAST(${searchExpr} as text)`,
     import_kysely16.sql.lit("%")
@@ -7173,7 +7330,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
   (0, import_common_helpers14.invariant)(import_kysely16.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers14.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers14.lowerCaseFirst)(result)).otherwise(() => {
+  result = (0, import_ts_pattern18.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers14.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers14.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -7193,7 +7350,7 @@ __name(readBoolean, "readBoolean");
 var import_common_helpers15 = require("@zenstackhq/common-helpers");
 var import_kysely17 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
-var import_ts_pattern18 = require("ts-pattern");
+var import_ts_pattern19 = require("ts-pattern");
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -7359,7 +7516,7 @@ var SchemaDbPusher = class {
       return "jsonb";
     }
     const type = fieldDef.type;
-    const result = (0, import_ts_pattern18.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").with("Json", () => "jsonb").otherwise(() => {
+    const result = (0, import_ts_pattern19.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) {
@@ -7393,7 +7550,7 @@ var SchemaDbPusher = class {
     return table;
   }
   mapCascadeAction(action) {
-    return (0, import_ts_pattern18.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+    return (0, import_ts_pattern19.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
   }
 };
 
@@ -7893,6 +8050,7 @@ var import_kysely19 = require("kysely");
   NotFoundError,
   QueryError,
   ZenStackClient,
+  ZenStackError,
   definePlugin,
   sql
 });