@zenstackhq/runtime 3.0.0-alpha.30 → 3.0.0-alpha.32

package/dist/index.js

@@ -6,8 +6,8 @@ var __export = (target, all) => {
 };
 
 // src/client/client-impl.ts
-import { invariant as invariant12 } from "@zenstackhq/common-helpers";
-import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql9 } from "kysely";
+import { invariant as invariant15 } from "@zenstackhq/common-helpers";
+import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql9, Transaction } from "kysely";
 
 // src/client/crud/operations/aggregate.ts
 import { sql as sql5 } from "kysely";
@@ -2704,6 +2704,16 @@ function clone(value) {
 }
 __name(clone, "clone");
 
+// src/client/contract.ts
+var TransactionIsolationLevel = /* @__PURE__ */ function(TransactionIsolationLevel2) {
+  TransactionIsolationLevel2["ReadUncommitted"] = "read uncommitted";
+  TransactionIsolationLevel2["ReadCommitted"] = "read committed";
+  TransactionIsolationLevel2["RepeatableRead"] = "repeatable read";
+  TransactionIsolationLevel2["Serializable"] = "serializable";
+  TransactionIsolationLevel2["Snapshot"] = "snapshot";
+  return TransactionIsolationLevel2;
+}({});
+
 // src/client/crud/operations/base.ts
 var BaseOperationHandler = class {
   static {
@@ -3942,7 +3952,7 @@ var BaseOperationHandler = class {
       return callback(this.kysely);
     } else {
       let txBuilder = this.kysely.transaction();
-      txBuilder = txBuilder.setIsolationLevel(isolationLevel ?? "repeatable read");
+      txBuilder = txBuilder.setIsolationLevel(isolationLevel ?? TransactionIsolationLevel.RepeatableRead);
       return txBuilder.execute(callback);
     }
   }
@@ -5350,10 +5360,11 @@ var InputValidator = class {
   makeGroupBySchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields), true) : z.never();
     let schema = z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
-      by: this.orArray(z.enum(nonRelationFields), true),
+      by: bySchema,
       having: this.makeHavingSchema(model).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -5507,7 +5518,11 @@ var ZenStackDriver = class {
       this.#txConnections.delete(connection);
       if (callbacks) {
         for (const callback of callbacks) {
-          await callback();
+          try {
+            await callback();
+          } catch (err) {
+            console.error(`Error executing transaction commit callback: ${err}`);
+          }
         }
       }
       return result;
@@ -5625,12 +5640,32 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode3, SelectionNode as SelectionNode4, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
-import { nanoid as nanoid2 } from "nanoid";
+import { invariant as invariant11 } from "@zenstackhq/common-helpers";
+import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode2, SelectionNode as SelectionNode4, SingleConnectionProvider, TableNode as TableNode5, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
 import { match as match16 } from "ts-pattern";
 
+// src/client/executor/kysely-utils.ts
+import { invariant as invariant9 } from "@zenstackhq/common-helpers";
+import { AliasNode as AliasNode4, IdentifierNode as IdentifierNode3 } from "kysely";
+function stripAlias(node) {
+  if (AliasNode4.is(node)) {
+    invariant9(IdentifierNode3.is(node.alias), "Expected identifier as alias");
+    return {
+      alias: node.alias.name,
+      node: node.node
+    };
+  } else {
+    return {
+      alias: void 0,
+      node
+    };
+  }
+}
+__name(stripAlias, "stripAlias");
+
 // src/client/executor/name-mapper.ts
-import { AliasNode as AliasNode4, ColumnNode as ColumnNode3, IdentifierNode as IdentifierNode3, OperationNodeTransformer as OperationNodeTransformer2, ReferenceNode as ReferenceNode3, ReturningNode as ReturningNode2, SelectAllNode, SelectionNode as SelectionNode3, TableNode as TableNode4 } from "kysely";
+import { invariant as invariant10 } from "@zenstackhq/common-helpers";
+import { AliasNode as AliasNode5, ColumnNode as ColumnNode3, FromNode as FromNode3, IdentifierNode as IdentifierNode4, OperationNodeTransformer as OperationNodeTransformer2, ReferenceNode as ReferenceNode3, SelectAllNode, SelectionNode as SelectionNode3, TableNode as TableNode4 } from "kysely";
 var QueryNameMapper = class extends OperationNodeTransformer2 {
   static {
     __name(this, "QueryNameMapper");
@@ -5638,7 +5673,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
   schema;
   modelToTableMap = /* @__PURE__ */ new Map();
   fieldToColumnMap = /* @__PURE__ */ new Map();
-  modelStack = [];
+  modelScopes = [];
   constructor(schema) {
     super(), this.schema = schema;
     for (const [modelName, modelDef] of Object.entries(schema.models)) {
@@ -5654,150 +5689,185 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
       }
     }
   }
-  get currentModel() {
-    return this.modelStack[this.modelStack.length - 1];
-  }
-  transformCreateTable(node) {
-    try {
-      this.modelStack.push(node.table.table.identifier.name);
-      return super.transformCreateTable(node);
-    } finally {
-      this.modelStack.pop();
+  // #region overrides
+  transformSelectQuery(node) {
+    if (!node.from?.froms) {
+      return super.transformSelectQuery(node);
     }
+    const scopes = this.createScopesFromFroms(node.from, true);
+    return this.withScopes(scopes, () => {
+      return {
+        ...super.transformSelectQuery(node),
+        // convert "from" to nested query as needed
+        from: this.processFrom(node.from)
+      };
+    });
   }
   transformInsertQuery(node) {
-    try {
-      if (node.into?.table.identifier.name) {
-        this.modelStack.push(node.into.table.identifier.name);
-      }
+    if (!node.into) {
       return super.transformInsertQuery(node);
-    } finally {
-      if (node.into?.table.identifier.name) {
-        this.modelStack.pop();
-      }
     }
+    return this.withScope({
+      model: node.into.table.identifier.name
+    }, () => ({
+      ...super.transformInsertQuery(node),
+      // map table name
+      into: this.processTableRef(node.into)
+    }));
   }
   transformReturning(node) {
-    return ReturningNode2.create(this.transformSelections(node.selections, node));
+    return {
+      kind: node.kind,
+      // map column names in returning selections (include returningAll)
+      selections: this.processSelections(node.selections)
+    };
   }
-  transformUpdateQuery(node) {
-    let pushed = false;
-    if (node.table && TableNode4.is(node.table)) {
-      this.modelStack.push(node.table.table.identifier.name);
-      pushed = true;
-    }
-    try {
-      return super.transformUpdateQuery(node);
-    } finally {
-      if (pushed) {
-        this.modelStack.pop();
+  transformJoin(node) {
+    const { alias, node: innerNode } = stripAlias(node.table);
+    if (TableNode4.is(innerNode)) {
+      const modelName = innerNode.table.identifier.name;
+      if (this.hasMappedColumns(modelName)) {
+        const select = this.createSelectAll(modelName);
+        return {
+          ...super.transformJoin(node),
+          table: this.wrapAlias(select, alias ?? modelName)
+        };
       }
     }
+    return super.transformJoin(node);
   }
-  transformDeleteQuery(node) {
-    let pushed = false;
-    if (node.from?.froms && node.from.froms.length === 1 && node.from.froms[0]) {
-      const from = node.from.froms[0];
-      if (TableNode4.is(from)) {
-        this.modelStack.push(from.table.identifier.name);
-        pushed = true;
-      } else if (AliasNode4.is(from) && TableNode4.is(from.node)) {
-        this.modelStack.push(from.node.table.identifier.name);
-        pushed = true;
-      }
+  transformReference(node) {
+    if (!ColumnNode3.is(node.column)) {
+      return super.transformReference(node);
     }
-    try {
-      return super.transformDeleteQuery(node);
-    } finally {
-      if (pushed) {
-        this.modelStack.pop();
+    const { fieldDef, modelDef, scope } = this.resolveFieldFromScopes(node.column.column.name, node.table?.table.identifier.name);
+    if (fieldDef && !scope.namesMapped) {
+      const mappedFieldName = this.mapFieldName(modelDef.name, fieldDef.name);
+      let mappedTableName = node.table?.table.identifier.name;
+      if (mappedTableName) {
+        if (scope.alias === mappedTableName) {
+        } else if (scope.model === mappedTableName) {
+          mappedTableName = this.mapTableName(scope.model);
+        }
       }
+      return ReferenceNode3.create(ColumnNode3.create(mappedFieldName), mappedTableName ? TableNode4.create(mappedTableName) : void 0);
+    } else {
+      return super.transformReference(node);
     }
   }
-  transformSelectQuery(node) {
-    if (!node.from?.froms || node.from.froms.length === 0) {
-      return super.transformSelectQuery(node);
+  transformColumn(node) {
+    const { modelDef, fieldDef, scope } = this.resolveFieldFromScopes(node.column.name);
+    if (!fieldDef || scope.namesMapped) {
+      return super.transformColumn(node);
     }
-    if (node.from.froms.length > 1) {
-      throw new InternalError(`SelectQueryNode must have a single table in from clause`);
+    const mappedName = this.mapFieldName(modelDef.name, fieldDef.name);
+    return ColumnNode3.create(mappedName);
+  }
+  transformUpdateQuery(node) {
+    if (!node.table) {
+      return super.transformUpdateQuery(node);
     }
-    let pushed = false;
-    const from = node.from.froms[0];
-    if (TableNode4.is(from)) {
-      this.modelStack.push(from.table.identifier.name);
-      pushed = true;
-    } else if (AliasNode4.is(from) && TableNode4.is(from.node)) {
-      this.modelStack.push(from.node.table.identifier.name);
-      pushed = true;
+    const { alias, node: innerTable } = stripAlias(node.table);
+    if (!innerTable || !TableNode4.is(innerTable)) {
+      return super.transformUpdateQuery(node);
     }
-    const selections = node.selections ? this.transformSelections(node.selections, node) : node.selections;
-    try {
+    return this.withScope({
+      model: innerTable.table.identifier.name,
+      alias
+    }, () => {
       return {
-        ...super.transformSelectQuery(node),
-        selections
+        ...super.transformUpdateQuery(node),
+        // map table name
+        table: this.wrapAlias(this.processTableRef(innerTable), alias)
       };
-    } finally {
-      if (pushed) {
-        this.modelStack.pop();
+    });
+  }
+  transformDeleteQuery(node) {
+    const scopes = this.createScopesFromFroms(node.from, false);
+    const froms = node.from.froms.map((from) => {
+      const { alias, node: innerNode } = stripAlias(from);
+      if (TableNode4.is(innerNode)) {
+        return this.wrapAlias(this.processTableRef(innerNode), alias);
+      } else {
+        return super.transformNode(from);
       }
-    }
+    });
+    return this.withScopes(scopes, () => {
+      return {
+        ...super.transformDeleteQuery(node),
+        from: FromNode3.create(froms)
+      };
+    });
   }
-  transformSelections(selections, contextNode) {
-    const result = [];
-    for (const selection of selections) {
-      let selectAllFromModel = void 0;
-      let isSelectAll = false;
-      if (SelectAllNode.is(selection.selection)) {
-        selectAllFromModel = this.currentModel;
-        isSelectAll = true;
-      } else if (ReferenceNode3.is(selection.selection) && SelectAllNode.is(selection.selection.column)) {
-        selectAllFromModel = selection.selection.table?.table.identifier.name ?? this.currentModel;
-        isSelectAll = true;
-      }
-      if (isSelectAll) {
-        if (!selectAllFromModel) {
-          continue;
+  // #endregion
+  // #region utils
+  resolveFieldFromScopes(name, qualifier) {
+    for (const scope of this.modelScopes.toReversed()) {
+      if (qualifier) {
+        if (scope.alias) {
+          if (qualifier !== scope.alias) {
+            continue;
+          }
         } else {
-          const scalarFields = this.getModelScalarFields(contextNode, selectAllFromModel);
-          const fromModelDef = requireModel(this.schema, selectAllFromModel);
-          const mappedTableName = this.getMappedName(fromModelDef) ?? selectAllFromModel;
-          result.push(...scalarFields.map((fieldName) => {
-            const fieldRef = ReferenceNode3.create(ColumnNode3.create(this.mapFieldName(fieldName)), TableNode4.create(mappedTableName));
-            return SelectionNode3.create(this.fieldHasMappedName(fieldName) ? AliasNode4.create(fieldRef, IdentifierNode3.create(fieldName)) : fieldRef);
-          }));
+          if (qualifier !== scope.model) {
+            continue;
+          }
         }
-      } else {
-        result.push(this.transformSelectionWithAlias(selection));
+      }
+      const modelDef = getModel(this.schema, scope.model);
+      if (!modelDef) {
+        continue;
+      }
+      if (modelDef.fields[name]) {
+        return {
+          modelDef,
+          fieldDef: modelDef.fields[name],
+          scope
+        };
       }
     }
-    return result;
+    return {
+      modelDef: void 0,
+      fieldDef: void 0,
+      scope: void 0
+    };
   }
-  transformSelectionWithAlias(node) {
-    if (ColumnNode3.is(node.selection) && this.fieldHasMappedName(node.selection.column.name)) {
-      return SelectionNode3.create(AliasNode4.create(this.transformColumn(node.selection), IdentifierNode3.create(node.selection.column.name)));
-    } else if (ReferenceNode3.is(node.selection) && this.fieldHasMappedName(node.selection.column.column.name)) {
-      return SelectionNode3.create(AliasNode4.create(this.transformReference(node.selection), IdentifierNode3.create(node.selection.column.column.name)));
-    } else {
-      return this.transformSelection(node);
+  pushScope(scope) {
+    this.modelScopes.push(scope);
+  }
+  withScope(scope, fn) {
+    this.pushScope(scope);
+    try {
+      return fn();
+    } finally {
+      this.modelScopes.pop();
     }
   }
-  fieldHasMappedName(name) {
-    if (!this.currentModel) {
-      return false;
+  withScopes(scopes, fn) {
+    scopes.forEach((s) => this.pushScope(s));
+    try {
+      return fn();
+    } finally {
+      scopes.forEach(() => this.modelScopes.pop());
     }
-    return this.fieldToColumnMap.has(`${this.currentModel}.${name}`);
   }
-  transformTable(node) {
-    const tableName = node.table.identifier.name;
-    const mappedName = this.modelToTableMap.get(tableName);
-    if (mappedName) {
-      return TableNode4.create(mappedName);
-    } else {
+  wrapAlias(node, alias) {
+    return alias ? AliasNode5.create(node, IdentifierNode4.create(alias)) : node;
+  }
+  ensureAlias(node, alias, fallbackName) {
+    if (!node) {
       return node;
     }
+    return alias ? AliasNode5.create(node, IdentifierNode4.create(alias)) : AliasNode5.create(node, IdentifierNode4.create(fallbackName));
   }
-  transformColumn(node) {
-    return ColumnNode3.create(this.mapFieldName(node.column.name));
+  processTableRef(node) {
+    if (!node) {
+      return node;
+    }
+    if (!TableNode4.is(node)) {
+      return super.transformNode(node);
+    }
+    return TableNode4.create(this.mapTableName(node.table.identifier.name));
   }
   getMappedName(def) {
     const mapAttr = def.attributes?.find((attr) => attr.name === "@@map" || attr.name === "@map");
@@ -5809,28 +5879,132 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     }
     return void 0;
   }
-  mapFieldName(fieldName) {
-    if (!this.currentModel) {
-      return fieldName;
+  mapFieldName(model, field) {
+    const mappedName = this.fieldToColumnMap.get(`${model}.${field}`);
+    if (mappedName) {
+      return mappedName;
+    } else {
+      return field;
     }
-    const mappedName = this.fieldToColumnMap.get(`${this.currentModel}.${fieldName}`);
+  }
+  mapTableName(tableName) {
+    const mappedName = this.modelToTableMap.get(tableName);
     if (mappedName) {
       return mappedName;
     } else {
-      return fieldName;
+      return tableName;
     }
   }
-  requireCurrentModel(node) {
-    if (!this.currentModel) {
-      throw new InternalError(`Missing model context for "${node}"`);
+  hasMappedColumns(modelName) {
+    return [
+      ...this.fieldToColumnMap.keys()
+    ].some((key) => key.startsWith(modelName + "."));
+  }
+  createScopesFromFroms(node, namesMapped) {
+    if (!node) {
+      return [];
     }
+    return node.froms.map((from) => {
+      const { alias, node: innerNode } = stripAlias(from);
+      if (innerNode && TableNode4.is(innerNode)) {
+        return {
+          model: innerNode.table.identifier.name,
+          alias,
+          namesMapped
+        };
+      } else {
+        return void 0;
+      }
+    }).filter((s) => !!s);
   }
-  getModelScalarFields(contextNode, model) {
-    this.requireCurrentModel(contextNode);
-    model = model ?? this.currentModel;
+  // convert a "from" node to a nested query if there are columns with name mapping
+  processFrom(node) {
+    return {
+      ...super.transformFrom(node),
+      froms: node.froms.map((from) => {
+        const { alias, node: innerNode } = stripAlias(from);
+        if (!innerNode) {
+          return super.transformNode(from);
+        }
+        if (TableNode4.is(innerNode)) {
+          if (this.hasMappedColumns(innerNode.table.identifier.name)) {
+            const selectAll = this.createSelectAll(innerNode.table.identifier.name);
+            return this.ensureAlias(selectAll, alias, innerNode.table.identifier.name);
+          }
+        }
+        return this.transformNode(from);
+      })
+    };
+  }
+  // create a `SelectQueryNode` for the given model with all columns mapped
+  createSelectAll(model) {
     const modelDef = requireModel(this.schema, model);
-    const scalarFields = Object.entries(modelDef.fields).filter(([, fieldDef]) => !fieldDef.relation && !fieldDef.computed && !fieldDef.originModel).map(([fieldName]) => fieldName);
-    return scalarFields;
+    const tableName = this.mapTableName(model);
+    return {
+      kind: "SelectQueryNode",
+      from: FromNode3.create([
+        TableNode4.create(tableName)
+      ]),
+      selections: this.getModelFields(modelDef).map((fieldDef) => {
+        const columnName = this.mapFieldName(model, fieldDef.name);
+        const columnRef = ReferenceNode3.create(ColumnNode3.create(columnName), TableNode4.create(tableName));
+        if (columnName !== fieldDef.name) {
+          const aliased = AliasNode5.create(columnRef, IdentifierNode4.create(fieldDef.name));
+          return SelectionNode3.create(aliased);
+        } else {
+          return SelectionNode3.create(columnRef);
+        }
+      })
+    };
+  }
+  getModelFields(modelDef) {
+    return Object.values(modelDef.fields).filter((f) => !f.relation && !f.computed && !f.originModel);
+  }
+  processSelections(selections) {
+    const result = [];
+    selections.forEach((selection) => {
+      if (SelectAllNode.is(selection.selection)) {
+        const processed = this.processSelectAll(selection.selection);
+        if (Array.isArray(processed)) {
+          result.push(...processed.map((s) => SelectionNode3.create(s)));
+        } else {
+          result.push(SelectionNode3.create(processed));
+        }
+      } else {
+        result.push(SelectionNode3.create(this.processSelection(selection.selection)));
+      }
+    });
+    return result;
+  }
+  processSelection(node) {
+    let alias;
+    if (!AliasNode5.is(node)) {
+      alias = this.extractFieldName(node);
+    }
+    const result = super.transformNode(node);
+    return this.wrapAlias(result, alias);
+  }
+  processSelectAll(node) {
+    const scope = this.modelScopes[this.modelScopes.length - 1];
+    invariant10(scope);
+    if (!this.hasMappedColumns(scope.model)) {
+      return super.transformSelectAll(node);
+    }
+    const modelDef = requireModel(this.schema, scope.model);
+    return this.getModelFields(modelDef).map((fieldDef) => {
+      const columnName = this.mapFieldName(scope.model, fieldDef.name);
+      const columnRef = ReferenceNode3.create(ColumnNode3.create(columnName));
+      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, fieldDef.name) : columnRef;
+    });
+  }
+  extractFieldName(node) {
+    if (ReferenceNode3.is(node) && ColumnNode3.is(node.column)) {
+      return node.column.column.name;
+    } else if (ColumnNode3.is(node)) {
+      return node.column.name;
+    } else {
+      return void 0;
+    }
   }
 };
 
@@ -5843,9 +6017,10 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   driver;
   compiler;
   connectionProvider;
+  suppressMutationHooks;
   nameMapper;
-  constructor(client, driver, compiler, adapter, connectionProvider, plugins = []) {
-    super(compiler, adapter, connectionProvider, plugins), this.client = client, this.driver = driver, this.compiler = compiler, this.connectionProvider = connectionProvider;
+  constructor(client, driver, compiler, adapter, connectionProvider, plugins = [], suppressMutationHooks = false) {
+    super(compiler, adapter, connectionProvider, plugins), this.client = client, this.driver = driver, this.compiler = compiler, this.connectionProvider = connectionProvider, this.suppressMutationHooks = suppressMutationHooks;
     this.nameMapper = new QueryNameMapper(client.$schema);
   }
   get kysely() {
@@ -5854,38 +6029,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   get options() {
     return this.client.$options;
   }
-  async executeQuery(compiledQuery, _queryId) {
-    let queryNode = compiledQuery.query;
-    let mutationInterceptionInfo;
-    if (this.isMutationNode(queryNode) && this.hasMutationHooks) {
-      mutationInterceptionInfo = await this.callMutationInterceptionFilters(queryNode);
-    }
-    const task = /* @__PURE__ */ __name(async () => {
-      if (this.isMutationNode(queryNode)) {
-        await this.callBeforeMutationHooks(queryNode, mutationInterceptionInfo);
-      }
-      const oldQueryNode = queryNode;
-      if ((InsertQueryNode2.is(queryNode) || UpdateQueryNode2.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntities) {
-        queryNode = {
-          ...queryNode,
-          returning: ReturningNode3.create([
-            SelectionNode4.createSelectAll()
-          ])
-        };
-      }
-      const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
-      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryParams);
-      if (this.isMutationNode(queryNode)) {
-        await this.callAfterMutationHooks(result.result, queryNode, mutationInterceptionInfo, result.connection);
-      }
-      if (oldQueryNode !== queryNode) {
-      }
-      return result.result;
-    }, "task");
-    return task();
+  async executeQuery(compiledQuery, queryId) {
+    const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
+    const result = await this.proceedQueryWithKyselyInterceptors(compiledQuery.query, queryParams, queryId.queryId);
+    return result.result;
   }
-  proceedQueryWithKyselyInterceptors(queryNode, parameters) {
-    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters), "proceed");
+  async proceedQueryWithKyselyInterceptors(queryNode, parameters, queryId) {
+    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters, queryId), "proceed");
     const hooks = [];
     for (const plugin of this.client.$options.plugins ?? []) {
       if (plugin.onKyselyQuery) {
@@ -5895,10 +6045,8 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
     for (const hook of hooks) {
       const _proceed = proceed;
       proceed = /* @__PURE__ */ __name(async (query) => {
-        let connection;
         const _p = /* @__PURE__ */ __name(async (q) => {
           const r = await _proceed(q);
-          connection = r.connection;
           return r.result;
         }, "_p");
         const hookResult = await hook({
@@ -5909,35 +6057,129 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
           proceed: _p
         });
         return {
-          result: hookResult,
-          connection
+          result: hookResult
         };
       }, "proceed");
     }
-    return proceed(queryNode);
+    const result = await proceed(queryNode);
+    return result;
   }
-  async proceedQuery(query, parameters) {
-    const finalQuery = this.nameMapper.transformNode(query);
-    let compiled = this.compileQuery(finalQuery);
-    if (parameters) {
-      compiled = {
-        ...compiled,
-        parameters
-      };
-    }
+  getMutationInfo(queryNode) {
+    const model = this.getMutationModel(queryNode);
+    const { action, where } = match16(queryNode).when(InsertQueryNode2.is, () => ({
+      action: "create",
+      where: void 0
+    })).when(UpdateQueryNode2.is, (node) => ({
+      action: "update",
+      where: node.where
+    })).when(DeleteQueryNode2.is, (node) => ({
+      action: "delete",
+      where: node.where
+    })).exhaustive();
+    return {
+      model,
+      action,
+      where
+    };
+  }
+  async proceedQuery(query, parameters, queryId) {
+    let compiled;
     try {
       return await this.provideConnection(async (connection) => {
-        const result = await connection.executeQuery(compiled);
-        return {
-          result,
-          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 ((InsertQueryNode2.is(query) || UpdateQueryNode2.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks) {
+          query = {
+            ...query,
+            returning: ReturningNode2.create([
+              SelectionNode4.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 && (UpdateQueryNode2.is(query) || DeleteQueryNode2.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}`;
+      const message = `Failed to execute query: ${err}, sql: ${compiled?.sql}`;
       throw new QueryError(message, err);
     }
   }
+  createClientForConnection(connection, inTx) {
+    const innerExecutor = this.withConnectionProvider(new SingleConnectionProvider(connection));
+    innerExecutor.suppressMutationHooks = true;
+    const innerClient = this.client.withExecutor(innerExecutor);
+    if (inTx) {
+      innerClient.forceTransaction();
+    }
+    return innerClient;
+  }
+  get hasEntityMutationPlugins() {
+    return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation);
+  }
+  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 InsertQueryNode2.is(queryNode) || UpdateQueryNode2.is(queryNode) || DeleteQueryNode2.is(queryNode);
   }
@@ -5945,154 +6187,102 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
     return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
       ...this.plugins,
       plugin
-    ]);
+    ], this.suppressMutationHooks);
   }
   withPlugins(plugins) {
     return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
       ...this.plugins,
       ...plugins
-    ]);
+    ], this.suppressMutationHooks);
   }
   withPluginAtFront(plugin) {
     return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
       plugin,
       ...this.plugins
-    ]);
+    ], this.suppressMutationHooks);
   }
   withoutPlugins() {
-    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, []);
+    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [], this.suppressMutationHooks);
   }
   withConnectionProvider(connectionProvider) {
-    const newExecutor = new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider);
+    const newExecutor = new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider, this.plugins, this.suppressMutationHooks);
     newExecutor.client = this.client.withExecutor(newExecutor);
     return newExecutor;
   }
-  get hasMutationHooks() {
-    return this.client.$options.plugins?.some((plugin) => !!plugin.onEntityMutation);
-  }
   getMutationModel(queryNode) {
-    return match16(queryNode).when(InsertQueryNode2.is, (node) => node.into.table.identifier.name).when(UpdateQueryNode2.is, (node) => node.table.table.identifier.name).when(DeleteQueryNode2.is, (node) => {
-      if (node.from.froms.length !== 1) {
-        throw new InternalError(`Delete query must have exactly one from table`);
-      }
-      return node.from.froms[0].table.identifier.name;
+    return match16(queryNode).when(InsertQueryNode2.is, (node) => {
+      invariant11(node.into, "InsertQueryNode must have an into clause");
+      return node.into.table.identifier.name;
+    }).when(UpdateQueryNode2.is, (node) => {
+      invariant11(node.table, "UpdateQueryNode must have a table");
+      const { node: tableNode } = stripAlias(node.table);
+      invariant11(TableNode5.is(tableNode), "UpdateQueryNode must use a TableNode");
+      return tableNode.table.identifier.name;
+    }).when(DeleteQueryNode2.is, (node) => {
+      invariant11(node.from.froms.length === 1, "Delete query must have exactly one from table");
+      const { node: tableNode } = stripAlias(node.from.froms[0]);
+      invariant11(TableNode5.is(tableNode), "DeleteQueryNode must use a TableNode");
+      return tableNode.table.identifier.name;
     }).otherwise((node) => {
       throw new InternalError(`Invalid query node: ${node}`);
     });
   }
-  async callMutationInterceptionFilters(queryNode) {
-    const plugins = this.client.$options.plugins;
-    if (plugins) {
-      const mutationModel = this.getMutationModel(queryNode);
-      const result = {
-        intercept: false
-      };
-      const { action, where } = match16(queryNode).when(InsertQueryNode2.is, () => ({
-        action: "create",
-        where: void 0
-      })).when(UpdateQueryNode2.is, (node) => ({
-        action: "update",
-        where: node.where
-      })).when(DeleteQueryNode2.is, (node) => ({
-        action: "delete",
-        where: node.where
-      })).exhaustive();
-      for (const plugin of plugins) {
-        const onEntityMutation = plugin.onEntityMutation;
-        if (!onEntityMutation) {
-          continue;
-        }
-        if (!onEntityMutation.mutationInterceptionFilter) {
-          result.intercept = true;
-        } else {
-          const filterResult = await onEntityMutation.mutationInterceptionFilter({
-            model: mutationModel,
-            action,
-            queryNode
-          });
-          result.intercept ||= filterResult.intercept;
-          result.loadBeforeMutationEntities ||= filterResult.loadBeforeMutationEntities;
-          result.loadAfterMutationEntities ||= filterResult.loadAfterMutationEntities;
-        }
-      }
-      let beforeMutationEntities;
-      if (result.loadBeforeMutationEntities && (UpdateQueryNode2.is(queryNode) || DeleteQueryNode2.is(queryNode))) {
-        beforeMutationEntities = await this.loadEntities(mutationModel, where);
-      }
-      return {
-        ...result,
-        mutationModel,
-        action,
-        where,
-        beforeMutationEntities
-      };
-    } else {
-      return void 0;
-    }
-  }
-  async callBeforeMutationHooks(queryNode, mutationInterceptionInfo) {
-    if (!mutationInterceptionInfo?.intercept) {
-      return;
-    }
+  async callBeforeMutationHooks(queryNode, mutationInfo, loadBeforeMutationEntities, client, queryId) {
     if (this.options.plugins) {
-      const mutationModel = this.getMutationModel(queryNode);
       for (const plugin of this.options.plugins) {
         const onEntityMutation = plugin.onEntityMutation;
-        if (onEntityMutation?.beforeEntityMutation) {
-          await onEntityMutation.beforeEntityMutation({
-            model: mutationModel,
-            action: mutationInterceptionInfo.action,
-            queryNode,
-            entities: mutationInterceptionInfo.beforeMutationEntities
-          });
+        if (!onEntityMutation?.beforeEntityMutation) {
+          continue;
         }
+        await onEntityMutation.beforeEntityMutation({
+          model: mutationInfo.model,
+          action: mutationInfo.action,
+          queryNode,
+          loadBeforeMutationEntities,
+          client,
+          queryId
+        });
       }
     }
   }
-  async callAfterMutationHooks(queryResult, queryNode, mutationInterceptionInfo, connection) {
-    if (!mutationInterceptionInfo?.intercept) {
-      return;
-    }
+  async callAfterMutationHooks(queryResult, queryNode, mutationInfo, client, filterFor, queryId) {
     const hooks = [];
     for (const plugin of this.options.plugins ?? []) {
       const onEntityMutation = plugin.onEntityMutation;
-      if (onEntityMutation?.afterEntityMutation) {
-        hooks.push(onEntityMutation.afterEntityMutation.bind(plugin));
+      if (!onEntityMutation?.afterEntityMutation) {
+        continue;
+      }
+      if (filterFor === "inTx" && !onEntityMutation.runAfterMutationWithinTransaction) {
+        continue;
       }
+      if (filterFor === "outTx" && onEntityMutation.runAfterMutationWithinTransaction) {
+        continue;
+      }
+      hooks.push(onEntityMutation.afterEntityMutation.bind(plugin));
     }
     if (hooks.length === 0) {
       return;
     }
     const mutationModel = this.getMutationModel(queryNode);
-    const inTransaction = this.driver.isTransactionConnection(connection);
-    for (const hook of hooks) {
-      let afterMutationEntities = void 0;
-      if (mutationInterceptionInfo.loadAfterMutationEntities) {
-        if (InsertQueryNode2.is(queryNode) || UpdateQueryNode2.is(queryNode)) {
-          afterMutationEntities = queryResult.rows;
-        }
-      }
-      const action = /* @__PURE__ */ __name(async () => {
-        try {
-          await hook({
-            model: mutationModel,
-            action: mutationInterceptionInfo.action,
-            queryNode,
-            beforeMutationEntities: mutationInterceptionInfo.beforeMutationEntities,
-            afterMutationEntities
-          });
-        } catch (err) {
-          console.error(`Error in afterEntityMutation hook for model "${mutationModel}": ${err}`);
-        }
-      }, "action");
-      if (inTransaction) {
-        this.driver.registerTransactionCommitCallback(connection, action);
+    const loadAfterMutationEntities = /* @__PURE__ */ __name(async () => {
+      if (mutationInfo.action === "delete") {
+        return void 0;
       } else {
-        await action();
+        return queryResult.rows;
       }
+    }, "loadAfterMutationEntities");
+    for (const hook of hooks) {
+      await hook({
+        model: mutationModel,
+        action: mutationInfo.action,
+        queryNode,
+        loadAfterMutationEntities,
+        client,
+        queryId
+      });
     }
   }
-  async loadEntities(model, where) {
+  async loadEntities(model, where, connection) {
     const selectQuery = this.kysely.selectFrom(model).selectAll();
     let selectQueryNode = selectQuery.toOperationNode();
     selectQueryNode = {
@@ -6100,9 +6290,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       where: this.andNodes(selectQueryNode.where, where)
     };
     const compiled = this.compileQuery(selectQueryNode);
-    const result = await this.executeQuery(compiled, {
-      queryId: `zenstack-${nanoid2()}`
-    });
+    const result = await connection.executeQuery(compiled);
     return result.rows;
   }
   andNodes(condition1, condition2) {
@@ -6131,7 +6319,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-import { invariant as invariant9, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
+import { invariant as invariant12, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
 import { sql as sql7, ValueNode as ValueNode4 } from "kysely";
 import { match as match17 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args) => {
@@ -6238,7 +6426,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  invariant9(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  invariant12(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
   result = match17(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
@@ -6247,7 +6435,7 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
-import { invariant as invariant10 } from "@zenstackhq/common-helpers";
+import { invariant as invariant13 } from "@zenstackhq/common-helpers";
 import { sql as sql8 } from "kysely";
 import toposort from "toposort";
 import { match as match18 } from "ts-pattern";
@@ -6343,7 +6531,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      invariant10(typeof value === "object", "expecting an object");
+      invariant13(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -6411,7 +6599,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    invariant10(fieldDef.relation, "field must be a relation");
+    invariant13(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -6466,7 +6654,7 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
-import { invariant as invariant11 } from "@zenstackhq/common-helpers";
+import { invariant as invariant14 } from "@zenstackhq/common-helpers";
 import Decimal2 from "decimal.js";
 import { match as match19 } from "ts-pattern";
 var ResultProcessor = class {
@@ -6566,14 +6754,14 @@ var ResultProcessor = class {
     if (value instanceof Decimal2) {
       return value;
     }
-    invariant11(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
+    invariant14(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
     return new Decimal2(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    invariant11(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    invariant14(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -6617,7 +6805,7 @@ var ResultProcessor = class {
   }
   transformJson(value) {
     return match19(this.schema.provider.type).with("sqlite", () => {
-      invariant11(typeof value === "string", "Expected string, got " + typeof value);
+      invariant14(typeof value === "string", "Expected string, got " + typeof value);
       return JSON.parse(value);
     }).otherwise(() => value);
   }
@@ -6694,13 +6882,18 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    invariant12(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    invariant15(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);
     }
   }
+  forceTransaction() {
+    if (!this.kysely.isTransaction) {
+      this.kysely = new Transaction(this.kyselyProps);
+    }
+  }
   async interactiveTransaction(callback, options) {
     if (this.kysely.isTransaction) {
       return callback(this);