@zenstackhq/runtime 3.0.0-alpha.31 → 3.0.0-alpha.33

package/dist/index.cjs

@@ -37,13 +37,13 @@ __export(src_exports, {
   QueryError: () => QueryError,
   ZenStackClient: () => ZenStackClient,
   definePlugin: () => definePlugin,
-  sql: () => import_kysely17.sql
+  sql: () => import_kysely18.sql
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
-var import_common_helpers14 = require("@zenstackhq/common-helpers");
-var import_kysely16 = require("kysely");
+var import_common_helpers16 = require("@zenstackhq/common-helpers");
+var import_kysely17 = require("kysely");
 
 // src/client/crud/operations/aggregate.ts
 var import_kysely9 = require("kysely");
@@ -128,7 +128,10 @@ var ExpressionUtils = {
   isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
   isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
   isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
-  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
+  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember"),
+  getLiteralValue: /* @__PURE__ */ __name((expr2) => {
+    return ExpressionUtils.isLiteral(expr2) ? expr2.value : void 0;
+  }, "getLiteralValue")
 };
 
 // src/utils/object-utils.ts
@@ -1052,6 +1055,16 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  buildModelSelect(eb, model, subQueryAlias, payload, selectAllFields) {
+    let subQuery = this.buildSelectModel(eb, model, subQueryAlias);
+    if (selectAllFields) {
+      subQuery = this.buildSelectAllFields(model, subQuery, typeof payload === "object" ? payload?.omit : void 0, subQueryAlias);
+    }
+    if (payload && typeof payload === "object") {
+      subQuery = this.buildFilterSortTake(model, payload, subQuery, subQueryAlias);
+    }
+    return subQuery;
+  }
   buildSelectField(query, model, modelAlias, field) {
     const fieldDef = requireField(this.schema, model, field);
     if (fieldDef.computed) {
@@ -1149,6 +1162,18 @@ var BaseCrudDialect = class {
   fieldRef(model, field, eb, modelAlias, inlineComputedField = true) {
     return buildFieldRef(this.schema, model, field, this.options, eb, modelAlias, inlineComputedField);
   }
+  canJoinWithoutNestedSelect(modelDef, payload) {
+    if (modelDef.computedFields) {
+      return false;
+    }
+    if (modelDef.baseModel || modelDef.isDelegate) {
+      return false;
+    }
+    if (typeof payload === "object" && (payload.orderBy || payload.skip !== void 0 || payload.take !== void 0 || payload.cursor || payload.distinct)) {
+      return false;
+    }
+    return true;
+  }
 };
 
 // src/client/crud/dialects/postgresql.ts
@@ -1174,52 +1199,58 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
-    const joinedQuery = this.buildRelationJSON(model, query, relationField, parentAlias, payload);
-    return joinedQuery.select(`${parentAlias}$${relationField}.$j as ${relationField}`);
+    const relationResultName = `${parentAlias}$${relationField}`;
+    const joinedQuery = this.buildRelationJSON(model, query, relationField, parentAlias, payload, relationResultName);
+    return joinedQuery.select(`${relationResultName}.$data as ${relationField}`);
   }
-  buildRelationJSON(model, qb, relationField, parentName, payload) {
+  buildRelationJSON(model, qb, relationField, parentAlias, payload, resultName) {
     const relationFieldDef = requireField(this.schema, model, relationField);
     const relationModel = relationFieldDef.type;
     return qb.leftJoinLateral((eb) => {
-      const joinTableName = `${parentName}$${relationField}`;
-      let result = eb.selectFrom(`${relationModel} as ${joinTableName}`);
-      const subQueryAlias = `${relationModel}$${relationField}$sub`;
-      result = eb.selectFrom(() => {
-        let subQuery = this.buildSelectModel(eb, relationModel, subQueryAlias);
-        subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0, subQueryAlias);
-        if (payload && typeof payload === "object") {
-          subQuery = this.buildFilterSortTake(relationModel, payload, subQuery, subQueryAlias);
-        }
-        const m2m = getManyToManyRelation(this.schema, model, relationField);
-        if (m2m) {
-          const parentIds = getIdFields(this.schema, model);
-          const relationIds = getIdFields(this.schema, relationModel);
-          (0, import_common_helpers2.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-          (0, import_common_helpers2.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
-          subQuery = subQuery.where(eb(eb.ref(`${subQueryAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
-        } else {
-          const joinPairs = buildJoinPairs(this.schema, model, parentName, relationField, subQueryAlias);
-          subQuery = subQuery.where((eb2) => this.and(eb2, ...joinPairs.map(([left, right]) => eb2(import_kysely2.sql.ref(left), "=", import_kysely2.sql.ref(right)))));
-        }
-        return subQuery.as(joinTableName);
-      });
-      result = this.buildRelationObjectSelect(relationModel, joinTableName, relationField, relationFieldDef, result, payload, parentName);
-      result = this.buildRelationJoins(relationModel, relationField, result, payload, parentName);
-      return result.as(joinTableName);
+      const relationSelectName = `${resultName}$sub`;
+      const relationModelDef = requireModel(this.schema, relationModel);
+      let tbl;
+      if (this.canJoinWithoutNestedSelect(relationModelDef, payload)) {
+        tbl = this.buildModelSelect(eb, relationModel, relationSelectName, payload, false);
+        tbl = this.buildRelationJoinFilter(tbl, model, relationField, relationModel, relationSelectName, parentAlias);
+      } else {
+        tbl = eb.selectFrom(() => {
+          let subQuery = this.buildModelSelect(eb, relationModel, `${relationSelectName}$t`, payload, true);
+          subQuery = this.buildRelationJoinFilter(subQuery, model, relationField, relationModel, `${relationSelectName}$t`, parentAlias);
+          return subQuery.as(relationSelectName);
+        });
+      }
+      tbl = this.buildRelationObjectSelect(relationModel, relationSelectName, relationFieldDef, tbl, payload, resultName);
+      tbl = this.buildRelationJoins(tbl, relationModel, relationSelectName, payload, resultName);
+      return tbl.as(resultName);
     }, (join) => join.onTrue());
   }
-  buildRelationObjectSelect(relationModel, relationModelAlias, relationField, relationFieldDef, qb, payload, parentName) {
+  buildRelationJoinFilter(query, model, relationField, relationModel, relationModelAlias, parentAlias) {
+    const m2m = getManyToManyRelation(this.schema, model, relationField);
+    if (m2m) {
+      const parentIds = getIdFields(this.schema, model);
+      const relationIds = getIdFields(this.schema, relationModel);
+      (0, import_common_helpers2.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers2.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+      query = query.where((eb) => eb(eb.ref(`${relationModelAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
+    } else {
+      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, relationField, relationModelAlias);
+      query = query.where((eb) => this.and(eb, ...joinPairs.map(([left, right]) => eb(import_kysely2.sql.ref(left), "=", import_kysely2.sql.ref(right)))));
+    }
+    return query;
+  }
+  buildRelationObjectSelect(relationModel, relationModelAlias, relationFieldDef, qb, payload, parentResultName) {
     qb = qb.select((eb) => {
-      const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, relationField, eb, payload, parentName);
+      const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName);
       if (relationFieldDef.array) {
-        return eb.fn.coalesce(import_kysely2.sql`jsonb_agg(jsonb_build_object(${import_kysely2.sql.join(objArgs)}))`, import_kysely2.sql`'[]'::jsonb`).as("$j");
+        return eb.fn.coalesce(import_kysely2.sql`jsonb_agg(jsonb_build_object(${import_kysely2.sql.join(objArgs)}))`, import_kysely2.sql`'[]'::jsonb`).as("$data");
       } else {
-        return import_kysely2.sql`jsonb_build_object(${import_kysely2.sql.join(objArgs)})`.as("$j");
+        return import_kysely2.sql`jsonb_build_object(${import_kysely2.sql.join(objArgs)})`.as("$data");
       }
     });
     return qb;
   }
-  buildRelationObjectArgs(relationModel, relationModelAlias, relationField, eb, payload, parentAlias) {
+  buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
     const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
@@ -1237,14 +1268,14 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     } else if (payload.select) {
       objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
         if (field === "_count") {
-          const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
+          const subJson = this.buildCountJson(relationModel, eb, relationModelAlias, value);
           return [
             import_kysely2.sql.lit(field),
             subJson
           ];
         } else {
           const fieldDef = requireField(this.schema, relationModel, field);
-          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : this.fieldRef(relationModel, field, eb, void 0, false);
+          const fieldValue = fieldDef.relation ? eb.ref(`${parentResultName}$${field}.$data`) : this.fieldRef(relationModel, field, eb, relationModelAlias, false);
           return [
             import_kysely2.sql.lit(field),
             fieldValue
@@ -1256,18 +1287,18 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => [
         import_kysely2.sql.lit(field),
         // reference the synthesized JSON field
-        eb.ref(`${parentAlias}$${relationField}$${field}.$j`)
+        eb.ref(`${parentResultName}$${field}.$data`)
       ]).flatMap((v) => v));
     }
     return objArgs;
   }
-  buildRelationJoins(relationModel, relationField, qb, payload, parentName) {
-    let result = qb;
+  buildRelationJoins(query, relationModel, relationModelAlias, payload, parentResultName) {
+    let result = query;
     if (typeof payload === "object") {
       const selectInclude = payload.include ?? payload.select;
       if (selectInclude && typeof selectInclude === "object") {
         Object.entries(selectInclude).filter(([, value]) => value).filter(([field]) => isRelationField(this.schema, relationModel, field)).forEach(([field, value]) => {
-          result = this.buildRelationJSON(relationModel, result, field, `${parentName}$${relationField}`, value);
+          result = this.buildRelationJSON(relationModel, result, field, relationModelAlias, value, `${parentResultName}$${field}`);
         });
       }
     }
@@ -1347,32 +1378,18 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     const relationModel = relationFieldDef.type;
     const relationModelDef = requireModel(this.schema, relationModel);
     const subQueryName = `${parentAlias}$${relationField}`;
-    let tbl = eb.selectFrom(() => {
-      const subQueryAlias = `${parentAlias}$${relationField}$sub`;
-      let subQuery = this.buildSelectModel(eb, relationModel, subQueryAlias);
-      subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0, subQueryAlias);
-      if (payload && typeof payload === "object") {
-        subQuery = this.buildFilterSortTake(relationModel, payload, subQuery, subQueryAlias);
-      }
-      const m2m = getManyToManyRelation(this.schema, model, relationField);
-      if (m2m) {
-        const parentIds = getIdFields(this.schema, model);
-        const relationIds = getIdFields(this.schema, relationModel);
-        (0, import_common_helpers3.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-        (0, import_common_helpers3.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
-        subQuery = subQuery.where(eb(eb.ref(`${subQueryAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
-      } else {
-        const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
-        keyPairs.forEach(({ fk, pk }) => {
-          if (ownedByModel) {
-            subQuery = subQuery.whereRef(`${subQueryAlias}.${pk}`, "=", `${parentAlias}.${fk}`);
-          } else {
-            subQuery = subQuery.whereRef(`${subQueryAlias}.${fk}`, "=", `${parentAlias}.${pk}`);
-          }
-        });
-      }
-      return subQuery.as(subQueryName);
-    });
+    let tbl;
+    if (this.canJoinWithoutNestedSelect(relationModelDef, payload)) {
+      tbl = this.buildModelSelect(eb, relationModel, subQueryName, payload, false);
+      tbl = this.buildRelationJoinFilter(tbl, model, relationField, subQueryName, parentAlias);
+    } else {
+      tbl = eb.selectFrom(() => {
+        const selectModelAlias = `${parentAlias}$${relationField}$sub`;
+        let selectModelQuery = this.buildModelSelect(eb, relationModel, selectModelAlias, payload, true);
+        selectModelQuery = this.buildRelationJoinFilter(selectModelQuery, model, relationField, selectModelAlias, parentAlias);
+        return selectModelQuery.as(subQueryName);
+      });
+    }
     tbl = tbl.select(() => {
       const objArgs = [];
       const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
@@ -1385,7 +1402,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       if (payload === true || !payload.select) {
         objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
           import_kysely3.sql.lit(field),
-          this.fieldRef(relationModel, field, eb, void 0, false)
+          this.fieldRef(relationModel, field, eb, subQueryName, false)
         ]).flatMap((v) => v));
       } else if (payload.select) {
         objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
@@ -1406,7 +1423,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
             } else {
               return [
                 import_kysely3.sql.lit(field),
-                this.fieldRef(relationModel, field, eb, void 0, false)
+                this.fieldRef(relationModel, field, eb, subQueryName, false)
               ];
             }
           }
@@ -1422,13 +1439,35 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         }).flatMap((v) => v));
       }
       if (relationFieldDef.array) {
-        return eb.fn.coalesce(import_kysely3.sql`json_group_array(json_object(${import_kysely3.sql.join(objArgs)}))`, import_kysely3.sql`json_array()`).as("$j");
+        return eb.fn.coalesce(import_kysely3.sql`json_group_array(json_object(${import_kysely3.sql.join(objArgs)}))`, import_kysely3.sql`json_array()`).as("$data");
       } else {
-        return import_kysely3.sql`json_object(${import_kysely3.sql.join(objArgs)})`.as("data");
+        return import_kysely3.sql`json_object(${import_kysely3.sql.join(objArgs)})`.as("$data");
       }
     });
     return tbl;
   }
+  buildRelationJoinFilter(selectModelQuery, model, relationField, relationModelAlias, parentAlias) {
+    const fieldDef = requireField(this.schema, model, relationField);
+    const relationModel = fieldDef.type;
+    const m2m = getManyToManyRelation(this.schema, model, relationField);
+    if (m2m) {
+      const parentIds = getIdFields(this.schema, model);
+      const relationIds = getIdFields(this.schema, relationModel);
+      (0, import_common_helpers3.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers3.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+      selectModelQuery = selectModelQuery.where((eb) => eb(eb.ref(`${relationModelAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
+    } else {
+      const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
+      keyPairs.forEach(({ fk, pk }) => {
+        if (ownedByModel) {
+          selectModelQuery = selectModelQuery.whereRef(`${relationModelAlias}.${pk}`, "=", `${parentAlias}.${fk}`);
+        } else {
+          selectModelQuery = selectModelQuery.whereRef(`${relationModelAlias}.${fk}`, "=", `${parentAlias}.${pk}`);
+        }
+      });
+    }
+    return selectModelQuery;
+  }
   buildSkipTake(query, skip, take) {
     if (take !== void 0) {
       query = query.limit(take);
@@ -2740,6 +2779,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 {
@@ -3978,7 +4027,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);
     }
   }
@@ -5544,7 +5593,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;
@@ -5662,21 +5715,40 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-var import_kysely13 = require("kysely");
-var import_nanoid2 = require("nanoid");
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
+var import_kysely14 = require("kysely");
 var import_ts_pattern16 = require("ts-pattern");
 
-// src/client/executor/name-mapper.ts
+// src/client/executor/kysely-utils.ts
 var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely12 = require("kysely");
-var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
+function stripAlias(node) {
+  if (import_kysely12.AliasNode.is(node)) {
+    (0, import_common_helpers10.invariant)(import_kysely12.IdentifierNode.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
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
+var import_kysely13 = require("kysely");
+var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
   static {
     __name(this, "QueryNameMapper");
   }
   schema;
   modelToTableMap = /* @__PURE__ */ new Map();
   fieldToColumnMap = /* @__PURE__ */ new Map();
-  modelScopes = [];
+  scopes = [];
   constructor(schema) {
     super(), this.schema = schema;
     for (const [modelName, modelDef] of Object.entries(schema.models)) {
@@ -5697,12 +5769,23 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     if (!node.from?.froms) {
       return super.transformSelectQuery(node);
     }
-    const scopes = this.createScopesFromFroms(node.from, true);
+    const processedFroms = node.from.froms.map((from) => this.processSelectTable(from));
+    const processedJoins = (node.joins ?? []).map((join) => this.processSelectTable(join.table));
+    const scopes = [
+      ...processedFroms.map(({ scope }) => scope),
+      ...processedJoins.map(({ scope }) => scope)
+    ];
     return this.withScopes(scopes, () => {
+      const joins = node.joins ? node.joins.map((join, i) => ({
+        ...join,
+        table: processedJoins[i].node,
+        on: this.transformNode(join.on)
+      })) : void 0;
       return {
         ...super.transformSelectQuery(node),
-        // convert "from" to nested query as needed
-        from: this.processFrom(node.from)
+        from: import_kysely13.FromNode.create(processedFroms.map((f) => f.node)),
+        joins,
+        selections: this.processSelectQuerySelections(node)
       };
     });
   }
@@ -5725,27 +5808,13 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
       selections: this.processSelections(node.selections)
     };
   }
-  transformJoin(node) {
-    const { alias, node: innerNode } = this.stripAlias(node.table);
-    if (import_kysely12.TableNode.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);
-  }
   transformReference(node) {
-    if (!import_kysely12.ColumnNode.is(node.column)) {
+    if (!import_kysely13.ColumnNode.is(node.column)) {
       return super.transformReference(node);
     }
-    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);
+    const scope = this.resolveFieldFromScopes(node.column.column.name, node.table?.table.identifier.name);
+    if (scope && !scope.namesMapped && scope.model) {
+      const mappedFieldName = this.mapFieldName(scope.model, node.column.column.name);
       let mappedTableName = node.table?.table.identifier.name;
       if (mappedTableName) {
         if (scope.alias === mappedTableName) {
@@ -5753,22 +5822,25 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
           mappedTableName = this.mapTableName(scope.model);
         }
       }
-      return import_kysely12.ReferenceNode.create(import_kysely12.ColumnNode.create(mappedFieldName), mappedTableName ? import_kysely12.TableNode.create(mappedTableName) : void 0);
+      return import_kysely13.ReferenceNode.create(import_kysely13.ColumnNode.create(mappedFieldName), mappedTableName ? import_kysely13.TableNode.create(mappedTableName) : void 0);
     } else {
       return super.transformReference(node);
     }
   }
   transformColumn(node) {
-    const { modelDef, fieldDef, scope } = this.resolveFieldFromScopes(node.column.name);
-    if (!fieldDef || scope.namesMapped) {
+    const scope = this.resolveFieldFromScopes(node.column.name);
+    if (!scope || scope.namesMapped || !scope.model) {
       return super.transformColumn(node);
     }
-    const mappedName = this.mapFieldName(modelDef.name, fieldDef.name);
-    return import_kysely12.ColumnNode.create(mappedName);
+    const mappedName = this.mapFieldName(scope.model, node.column.name);
+    return import_kysely13.ColumnNode.create(mappedName);
   }
   transformUpdateQuery(node) {
-    const { alias, node: innerTable } = this.stripAlias(node.table);
-    if (!innerTable || !import_kysely12.TableNode.is(innerTable)) {
+    if (!node.table) {
+      return super.transformUpdateQuery(node);
+    }
+    const { alias, node: innerTable } = stripAlias(node.table);
+    if (!innerTable || !import_kysely13.TableNode.is(innerTable)) {
       return super.transformUpdateQuery(node);
     }
     return this.withScope({
@@ -5783,10 +5855,17 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     });
   }
   transformDeleteQuery(node) {
-    const scopes = this.createScopesFromFroms(node.from, false);
+    const scopes = node.from.froms.map((node2) => {
+      const { alias, node: innerNode } = stripAlias(node2);
+      return {
+        model: this.extractModelName(innerNode),
+        alias,
+        namesMapped: false
+      };
+    });
     const froms = node.from.froms.map((from) => {
-      const { alias, node: innerNode } = this.stripAlias(from);
-      if (import_kysely12.TableNode.is(innerNode)) {
+      const { alias, node: innerNode } = stripAlias(from);
+      if (import_kysely13.TableNode.is(innerNode)) {
         return this.wrapAlias(this.processTableRef(innerNode), alias);
       } else {
         return super.transformNode(from);
@@ -5795,52 +5874,81 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     return this.withScopes(scopes, () => {
       return {
         ...super.transformDeleteQuery(node),
-        from: import_kysely12.FromNode.create(froms)
+        from: import_kysely13.FromNode.create(froms)
       };
     });
   }
   // #endregion
   // #region utils
+  processSelectQuerySelections(node) {
+    const selections = [];
+    for (const selection of node.selections ?? []) {
+      if (import_kysely13.SelectAllNode.is(selection.selection)) {
+        const scope = this.scopes[this.scopes.length - 1];
+        if (scope?.model && !scope.namesMapped) {
+          selections.push(...this.createSelectAllFields(scope.model, scope.alias));
+        } else {
+          selections.push(super.transformSelection(selection));
+        }
+      } else if (import_kysely13.ReferenceNode.is(selection.selection) || import_kysely13.ColumnNode.is(selection.selection)) {
+        const transformed = this.transformNode(selection.selection);
+        if (import_kysely13.AliasNode.is(transformed)) {
+          selections.push(import_kysely13.SelectionNode.create(transformed));
+        } else {
+          const origFieldName = this.extractFieldName(selection.selection);
+          const fieldName = this.extractFieldName(transformed);
+          if (fieldName !== origFieldName) {
+            selections.push(import_kysely13.SelectionNode.create(this.wrapAlias(transformed, origFieldName)));
+          } else {
+            selections.push(import_kysely13.SelectionNode.create(transformed));
+          }
+        }
+      } else {
+        selections.push(super.transformSelection(selection));
+      }
+    }
+    return selections;
+  }
   resolveFieldFromScopes(name, qualifier) {
-    for (const scope of this.modelScopes.toReversed()) {
+    for (let i = this.scopes.length - 1; i >= 0; i--) {
+      const scope = this.scopes[i];
       if (qualifier) {
         if (scope.alias) {
-          if (qualifier !== scope.alias) {
+          if (scope.alias === qualifier) {
+            return scope;
+          } else {
             continue;
           }
-        } else {
-          if (qualifier !== scope.model) {
+        } else if (scope.model) {
+          if (scope.model === qualifier) {
+            return scope;
+          } else {
             continue;
           }
         }
-      }
-      const modelDef = getModel(this.schema, scope.model);
-      if (!modelDef) {
-        continue;
-      }
-      if (modelDef.fields[name]) {
-        return {
-          modelDef,
-          fieldDef: modelDef.fields[name],
-          scope
-        };
+      } else {
+        if (scope.model) {
+          const modelDef = getModel(this.schema, scope.model);
+          if (!modelDef) {
+            continue;
+          }
+          if (modelDef.fields[name]) {
+            return scope;
+          }
+        }
       }
     }
-    return {
-      modelDef: void 0,
-      fieldDef: void 0,
-      scope: void 0
-    };
+    return void 0;
   }
   pushScope(scope) {
-    this.modelScopes.push(scope);
+    this.scopes.push(scope);
   }
   withScope(scope, fn) {
     this.pushScope(scope);
     try {
       return fn();
     } finally {
-      this.modelScopes.pop();
+      this.scopes.pop();
     }
   }
   withScopes(scopes, fn) {
@@ -5848,26 +5956,20 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     try {
       return fn();
     } finally {
-      scopes.forEach(() => this.modelScopes.pop());
+      scopes.forEach(() => this.scopes.pop());
     }
   }
   wrapAlias(node, alias) {
-    return alias ? import_kysely12.AliasNode.create(node, import_kysely12.IdentifierNode.create(alias)) : node;
-  }
-  ensureAlias(node, alias, fallbackName) {
-    if (!node) {
-      return node;
-    }
-    return alias ? import_kysely12.AliasNode.create(node, import_kysely12.IdentifierNode.create(alias)) : import_kysely12.AliasNode.create(node, import_kysely12.IdentifierNode.create(fallbackName));
+    return alias ? import_kysely13.AliasNode.create(node, import_kysely13.IdentifierNode.create(alias)) : node;
   }
   processTableRef(node) {
     if (!node) {
       return node;
     }
-    if (!import_kysely12.TableNode.is(node)) {
+    if (!import_kysely13.TableNode.is(node)) {
       return super.transformNode(node);
     }
-    return import_kysely12.TableNode.create(this.mapTableName(node.table.identifier.name));
+    return import_kysely13.TableNode.create(this.mapTableName(node.table.identifier.name));
   }
   getMappedName(def) {
     const mapAttr = def.attributes?.find((attr) => attr.name === "@@map" || attr.name === "@map");
@@ -5895,86 +5997,49 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
       return tableName;
     }
   }
-  stripAlias(node) {
-    if (!node) {
-      return {
-        alias: void 0,
-        node
-      };
-    }
-    if (import_kysely12.AliasNode.is(node)) {
-      (0, import_common_helpers10.invariant)(import_kysely12.IdentifierNode.is(node.alias), "Expected identifier as alias");
-      return {
-        alias: node.alias.name,
-        node: node.node
-      };
-    }
-    return {
-      alias: void 0,
-      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 } = this.stripAlias(from);
-      if (innerNode && import_kysely12.TableNode.is(innerNode)) {
-        return {
-          model: innerNode.table.identifier.name,
-          alias,
-          namesMapped
-        };
-      } else {
-        return void 0;
-      }
-    }).filter((s) => !!s);
-  }
   // 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 } = this.stripAlias(from);
-        if (!innerNode) {
-          return super.transformNode(from);
-        }
-        if (import_kysely12.TableNode.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);
-          }
+  processSelectTable(node) {
+    const { alias, node: innerNode } = stripAlias(node);
+    if (innerNode && import_kysely13.TableNode.is(innerNode)) {
+      const modelName = innerNode.table.identifier.name;
+      const mappedName = this.mapTableName(modelName);
+      const finalAlias = alias ?? (mappedName !== modelName ? modelName : void 0);
+      return {
+        node: this.wrapAlias(import_kysely13.TableNode.create(mappedName), finalAlias),
+        scope: {
+          alias: alias ?? modelName,
+          model: modelName,
+          namesMapped: !this.hasMappedColumns(modelName)
         }
-        return this.transformNode(from);
-      })
-    };
+      };
+    } else {
+      return {
+        node: super.transformNode(node),
+        scope: {
+          alias,
+          model: void 0,
+          namesMapped: true
+        }
+      };
+    }
   }
-  // create a `SelectQueryNode` for the given model with all columns mapped
-  createSelectAll(model) {
+  createSelectAllFields(model, alias) {
     const modelDef = requireModel(this.schema, model);
-    const tableName = this.mapTableName(model);
-    return {
-      kind: "SelectQueryNode",
-      from: import_kysely12.FromNode.create([
-        import_kysely12.TableNode.create(tableName)
-      ]),
-      selections: this.getModelFields(modelDef).map((fieldDef) => {
-        const columnName = this.mapFieldName(model, fieldDef.name);
-        const columnRef = import_kysely12.ReferenceNode.create(import_kysely12.ColumnNode.create(columnName), import_kysely12.TableNode.create(tableName));
-        if (columnName !== fieldDef.name) {
-          const aliased = import_kysely12.AliasNode.create(columnRef, import_kysely12.IdentifierNode.create(fieldDef.name));
-          return import_kysely12.SelectionNode.create(aliased);
-        } else {
-          return import_kysely12.SelectionNode.create(columnRef);
-        }
-      })
-    };
+    return this.getModelFields(modelDef).map((fieldDef) => {
+      const columnName = this.mapFieldName(model, fieldDef.name);
+      const columnRef = import_kysely13.ReferenceNode.create(import_kysely13.ColumnNode.create(columnName), alias ? import_kysely13.TableNode.create(alias) : void 0);
+      if (columnName !== fieldDef.name) {
+        const aliased = import_kysely13.AliasNode.create(columnRef, import_kysely13.IdentifierNode.create(fieldDef.name));
+        return import_kysely13.SelectionNode.create(aliased);
+      } else {
+        return import_kysely13.SelectionNode.create(columnRef);
+      }
+    });
   }
   getModelFields(modelDef) {
     return Object.values(modelDef.fields).filter((f) => !f.relation && !f.computed && !f.originModel);
@@ -5982,44 +6047,48 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
   processSelections(selections) {
     const result = [];
     selections.forEach((selection) => {
-      if (import_kysely12.SelectAllNode.is(selection.selection)) {
+      if (import_kysely13.SelectAllNode.is(selection.selection)) {
         const processed = this.processSelectAll(selection.selection);
         if (Array.isArray(processed)) {
-          result.push(...processed.map((s) => import_kysely12.SelectionNode.create(s)));
+          result.push(...processed.map((s) => import_kysely13.SelectionNode.create(s)));
         } else {
-          result.push(import_kysely12.SelectionNode.create(processed));
+          result.push(import_kysely13.SelectionNode.create(processed));
         }
       } else {
-        result.push(import_kysely12.SelectionNode.create(this.processSelection(selection.selection)));
+        result.push(import_kysely13.SelectionNode.create(this.processSelection(selection.selection)));
       }
     });
     return result;
   }
   processSelection(node) {
     let alias;
-    if (!import_kysely12.AliasNode.is(node)) {
+    if (!import_kysely13.AliasNode.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];
-    (0, import_common_helpers10.invariant)(scope);
-    if (!this.hasMappedColumns(scope.model)) {
+    const scope = this.scopes[this.scopes.length - 1];
+    (0, import_common_helpers11.invariant)(scope);
+    if (!scope.model || !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 = import_kysely12.ReferenceNode.create(import_kysely12.ColumnNode.create(columnName));
+      const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
+      const columnRef = import_kysely13.ReferenceNode.create(import_kysely13.ColumnNode.create(columnName));
       return columnName !== fieldDef.name ? this.wrapAlias(columnRef, fieldDef.name) : columnRef;
     });
   }
+  extractModelName(node) {
+    const { node: innerNode } = stripAlias(node);
+    return import_kysely13.TableNode.is(innerNode) ? innerNode.table.identifier.name : void 0;
+  }
   extractFieldName(node) {
-    if (import_kysely12.ReferenceNode.is(node) && import_kysely12.ColumnNode.is(node.column)) {
+    if (import_kysely13.ReferenceNode.is(node) && import_kysely13.ColumnNode.is(node.column)) {
       return node.column.column.name;
-    } else if (import_kysely12.ColumnNode.is(node)) {
+    } else if (import_kysely13.ColumnNode.is(node)) {
       return node.column.name;
     } else {
       return void 0;
@@ -6028,7 +6097,7 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
 };
 
 // src/client/executor/zenstack-query-executor.ts
-var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13.DefaultQueryExecutor {
+var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely14.DefaultQueryExecutor {
   static {
     __name(this, "ZenStackQueryExecutor");
   }
@@ -6036,9 +6105,10 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
   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() {
@@ -6047,38 +6117,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
   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 ((import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.UpdateQueryNode.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntities) {
-        queryNode = {
-          ...queryNode,
-          returning: import_kysely13.ReturningNode.create([
-            import_kysely13.SelectionNode.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) {
@@ -6088,10 +6133,8 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
     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({
@@ -6102,190 +6145,232 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
           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 } = (0, import_ts_pattern16.match)(queryNode).when(import_kysely14.InsertQueryNode.is, () => ({
+      action: "create",
+      where: void 0
+    })).when(import_kysely14.UpdateQueryNode.is, (node) => ({
+      action: "update",
+      where: node.where
+    })).when(import_kysely14.DeleteQueryNode.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 ((import_kysely14.InsertQueryNode.is(query) || import_kysely14.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks) {
+          query = {
+            ...query,
+            returning: import_kysely14.ReturningNode.create([
+              import_kysely14.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_kysely14.UpdateQueryNode.is(query) || import_kysely14.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}`;
+      const message = `Failed to execute query: ${err}, sql: ${compiled?.sql}`;
       throw new QueryError(message, err);
     }
   }
+  createClientForConnection(connection, inTx) {
+    const innerExecutor = this.withConnectionProvider(new import_kysely14.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 import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.UpdateQueryNode.is(queryNode) || import_kysely13.DeleteQueryNode.is(queryNode);
+    return import_kysely14.InsertQueryNode.is(queryNode) || import_kysely14.UpdateQueryNode.is(queryNode) || import_kysely14.DeleteQueryNode.is(queryNode);
   }
   withPlugin(plugin) {
     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 (0, import_ts_pattern16.match)(queryNode).when(import_kysely13.InsertQueryNode.is, (node) => node.into.table.identifier.name).when(import_kysely13.UpdateQueryNode.is, (node) => node.table.table.identifier.name).when(import_kysely13.DeleteQueryNode.is, (node) => {
-      if (node.from.froms.length !== 1) {
-        throw new InternalError(`Delete query must have exactly one from table`);
-      }
-      return node.from.froms[0].table.identifier.name;
+    return (0, import_ts_pattern16.match)(queryNode).when(import_kysely14.InsertQueryNode.is, (node) => {
+      (0, import_common_helpers12.invariant)(node.into, "InsertQueryNode must have an into clause");
+      return node.into.table.identifier.name;
+    }).when(import_kysely14.UpdateQueryNode.is, (node) => {
+      (0, import_common_helpers12.invariant)(node.table, "UpdateQueryNode must have a table");
+      const { node: tableNode } = stripAlias(node.table);
+      (0, import_common_helpers12.invariant)(import_kysely14.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
+      return tableNode.table.identifier.name;
+    }).when(import_kysely14.DeleteQueryNode.is, (node) => {
+      (0, import_common_helpers12.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
+      const { node: tableNode } = stripAlias(node.from.froms[0]);
+      (0, import_common_helpers12.invariant)(import_kysely14.TableNode.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 } = (0, import_ts_pattern16.match)(queryNode).when(import_kysely13.InsertQueryNode.is, () => ({
-        action: "create",
-        where: void 0
-      })).when(import_kysely13.UpdateQueryNode.is, (node) => ({
-        action: "update",
-        where: node.where
-      })).when(import_kysely13.DeleteQueryNode.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 && (import_kysely13.UpdateQueryNode.is(queryNode) || import_kysely13.DeleteQueryNode.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 (import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.UpdateQueryNode.is(queryNode)) {
-          afterMutationEntities = queryResult.rows;
-        }
-      }
-      const action = /* @__PURE__ */ __name(async () => {
-        try {
-          await hook({
-            model: mutationModel,
-            action: mutationInterceptionInfo.action,
-            queryNode,
-            beforeMutationEntities: mutationInterceptionInfo.beforeMutationEntities,
-            afterMutationEntities
-          });
-        } catch (err) {
-          console.error(`Error in afterEntityMutation hook for model "${mutationModel}": ${err}`);
-        }
-      }, "action");
-      if (inTransaction) {
-        this.driver.registerTransactionCommitCallback(connection, action);
+    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 = {
@@ -6293,16 +6378,14 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       where: this.andNodes(selectQueryNode.where, where)
     };
     const compiled = this.compileQuery(selectQueryNode);
-    const result = await this.executeQuery(compiled, {
-      queryId: `zenstack-${(0, import_nanoid2.nanoid)()}`
-    });
+    const result = await connection.executeQuery(compiled);
     return result.rows;
   }
   andNodes(condition1, condition2) {
     if (condition1 && condition2) {
-      return import_kysely13.WhereNode.create(import_kysely13.AndNode.create(condition1, condition2));
+      return import_kysely14.WhereNode.create(import_kysely14.AndNode.create(condition1, condition2));
     } else if (condition1) {
-      return import_kysely13.WhereNode.create(condition1);
+      return import_kysely14.WhereNode.create(condition1);
     } else {
       return condition2;
     }
@@ -6324,8 +6407,8 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
-var import_kysely14 = require("kysely");
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
+var import_kysely15 = require("kysely");
 var import_ts_pattern17 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
@@ -6336,9 +6419,9 @@ var contains = /* @__PURE__ */ __name((eb, args) => {
     throw new Error('"search" parameter is required');
   }
   const searchExpr = eb.fn("CONCAT", [
-    import_kysely14.sql.lit("%"),
+    import_kysely15.sql.lit("%"),
     search2,
-    import_kysely14.sql.lit("%")
+    import_kysely15.sql.lit("%")
   ]);
   return eb(field, caseInsensitive ? "ilike" : "like", searchExpr);
 }, "contains");
@@ -6355,7 +6438,7 @@ var startsWith = /* @__PURE__ */ __name((eb, args) => {
   }
   return eb(field, "like", eb.fn("CONCAT", [
     search2,
-    import_kysely14.sql.lit("%")
+    import_kysely15.sql.lit("%")
   ]));
 }, "startsWith");
 var endsWith = /* @__PURE__ */ __name((eb, args) => {
@@ -6367,7 +6450,7 @@ var endsWith = /* @__PURE__ */ __name((eb, args) => {
     throw new Error('"search" parameter is required');
   }
   return eb(field, "like", eb.fn("CONCAT", [
-    import_kysely14.sql.lit("%"),
+    import_kysely15.sql.lit("%"),
     search2
   ]));
 }, "endsWith");
@@ -6408,10 +6491,10 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   if (!field) {
     throw new Error('"field" parameter is required');
   }
-  return eb(dialect.buildArrayLength(eb, field), "=", import_kysely14.sql.lit(0));
+  return eb(dialect.buildArrayLength(eb, field), "=", import_kysely15.sql.lit(0));
 }, "isEmpty");
 var now = /* @__PURE__ */ __name((eb, _args, { dialect }) => {
-  return (0, import_ts_pattern17.match)(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => import_kysely14.sql.raw("CURRENT_TIMESTAMP")).exhaustive();
+  return (0, import_ts_pattern17.match)(dialect.provider).with("postgresql", () => eb.fn("now")).with("sqlite", () => import_kysely15.sql.raw("CURRENT_TIMESTAMP")).exhaustive();
 }, "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
@@ -6419,7 +6502,7 @@ var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   if (casing) {
     result = processCasing(casing, result, model);
   }
-  return import_kysely14.sql.lit(result);
+  return import_kysely15.sql.lit(result);
 }, "currentModel");
 var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   let result = operation;
@@ -6427,12 +6510,12 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   if (casing) {
     result = processCasing(casing, result, operation);
   }
-  return import_kysely14.sql.lit(result);
+  return import_kysely15.sql.lit(result);
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers11.invariant)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers11.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers11.lowerCaseFirst)(result)).otherwise(() => {
+  (0, import_common_helpers13.invariant)(import_kysely15.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_helpers13.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers13.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -6440,8 +6523,8 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
-var import_kysely15 = require("kysely");
+var import_common_helpers14 = require("@zenstackhq/common-helpers");
+var import_kysely16 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern18 = require("ts-pattern");
 var SchemaDbPusher = class {
@@ -6501,7 +6584,7 @@ var SchemaDbPusher = class {
     return (0, import_toposort.default)(graph).reverse().filter((m) => !!m);
   }
   createModelTable(kysely, modelDef) {
-    let table = kysely.schema.createTable(modelDef.name).ifNotExists();
+    let table = kysely.schema.createTable(this.getTableName(modelDef)).ifNotExists();
     for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
       if (fieldDef.originModel && !fieldDef.id) {
         continue;
@@ -6520,6 +6603,26 @@ var SchemaDbPusher = class {
     table = this.addUniqueConstraint(table, modelDef);
     return table;
   }
+  getTableName(modelDef) {
+    const mapAttr = modelDef.attributes?.find((a) => a.name === "@@map");
+    if (mapAttr && mapAttr.args?.[0]) {
+      const mappedName = ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
+      if (mappedName) {
+        return mappedName;
+      }
+    }
+    return modelDef.name;
+  }
+  getColumnName(fieldDef) {
+    const mapAttr = fieldDef.attributes?.find((a) => a.name === "@map");
+    if (mapAttr && mapAttr.args?.[0]) {
+      const mappedName = ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
+      if (mappedName) {
+        return mappedName;
+      }
+    }
+    return fieldDef.name;
+  }
   isComputedField(fieldDef) {
     return fieldDef.attributes?.some((a) => a.name === "@computed");
   }
@@ -6530,36 +6633,36 @@ var SchemaDbPusher = class {
       }
     }
     if (modelDef.idFields.length > 0) {
-      table = table.addPrimaryKeyConstraint(`pk_${modelDef.name}`, modelDef.idFields);
+      table = table.addPrimaryKeyConstraint(`pk_${modelDef.name}`, modelDef.idFields.map((f) => this.getColumnName(modelDef.fields[f])));
     }
     return table;
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_common_helpers12.invariant)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers14.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
           continue;
         }
         table = table.addUniqueConstraint(`unique_${modelDef.name}_${key}`, [
-          key
+          this.getColumnName(fieldDef)
         ]);
       } else {
-        table = table.addUniqueConstraint(`unique_${modelDef.name}_${key}`, Object.keys(value));
+        table = table.addUniqueConstraint(`unique_${modelDef.name}_${key}`, Object.keys(value).map((f) => this.getColumnName(modelDef.fields[f])));
       }
     }
     return table;
   }
   createModelField(table, fieldDef, modelDef) {
-    return table.addColumn(fieldDef.name, this.mapFieldType(fieldDef), (col) => {
+    return table.addColumn(this.getColumnName(fieldDef), this.mapFieldType(fieldDef), (col) => {
       if (fieldDef.id && modelDef.idFields.length === 1) {
         col = col.primaryKey();
       }
       if (fieldDef.default !== void 0) {
         if (typeof fieldDef.default === "object" && "kind" in fieldDef.default) {
           if (ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "now") {
-            col = col.defaultTo(import_kysely15.sql`CURRENT_TIMESTAMP`);
+            col = col.defaultTo(import_kysely16.sql`CURRENT_TIMESTAMP`);
           }
         } else {
           col = col.defaultTo(fieldDef.default);
@@ -6579,7 +6682,7 @@ var SchemaDbPusher = class {
   }
   mapFieldType(fieldDef) {
     if (this.schema.enums?.[fieldDef.type]) {
-      return this.schema.provider.type === "postgresql" ? import_kysely15.sql.ref(fieldDef.type) : "text";
+      return this.schema.provider.type === "postgresql" ? import_kysely16.sql.ref(fieldDef.type) : "text";
     }
     if (this.isAutoIncrement(fieldDef) && this.schema.provider.type === "postgresql") {
       return "serial";
@@ -6592,7 +6695,7 @@ var SchemaDbPusher = class {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
-      return import_kysely15.sql.raw(`${result}[]`);
+      return import_kysely16.sql.raw(`${result}[]`);
     } else {
       return result;
     }
@@ -6604,11 +6707,13 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_common_helpers12.invariant)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers14.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
-    table = table.addForeignKeyConstraint(`fk_${model}_${fieldName}`, fieldDef.relation.fields, fieldDef.type, fieldDef.relation.references, (cb) => {
+    const modelDef = requireModel(this.schema, model);
+    const relationModelDef = requireModel(this.schema, fieldDef.type);
+    table = table.addForeignKeyConstraint(`fk_${model}_${fieldName}`, fieldDef.relation.fields.map((f) => this.getColumnName(modelDef.fields[f])), this.getTableName(relationModelDef), fieldDef.relation.references.map((f) => this.getColumnName(relationModelDef.fields[f])), (cb) => {
       if (fieldDef.relation?.onDelete) {
         cb = cb.onDelete(this.mapCascadeAction(fieldDef.relation.onDelete));
       }
@@ -6659,7 +6764,7 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
-var import_common_helpers13 = require("@zenstackhq/common-helpers");
+var import_common_helpers15 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern19 = require("ts-pattern");
 var ResultProcessor = class {
@@ -6759,14 +6864,14 @@ var ResultProcessor = class {
     if (value instanceof import_decimal2.default) {
       return value;
     }
-    (0, import_common_helpers13.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers15.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal2.default(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers13.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers15.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -6810,7 +6915,7 @@ var ResultProcessor = class {
   }
   transformJson(value) {
     return (0, import_ts_pattern19.match)(this.schema.provider.type).with("sqlite", () => {
-      (0, import_common_helpers13.invariant)(typeof value === "string", "Expected string, got " + typeof value);
+      (0, import_common_helpers15.invariant)(typeof value === "string", "Expected string, got " + typeof value);
       return JSON.parse(value);
     }).otherwise(() => value);
   }
@@ -6844,15 +6949,15 @@ var ClientImpl = class _ClientImpl {
     if (baseClient) {
       this.kyselyProps = {
         ...baseClient.kyselyProps,
-        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely16.DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely17.DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
       this.auth = baseClient.auth;
     } else {
-      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely16.Log(this.$options.log ?? []));
+      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely17.Log(this.$options.log ?? []));
       const compiler = options.dialect.createQueryCompiler();
       const adapter = options.dialect.createAdapter();
-      const connectionProvider = new import_kysely16.DefaultConnectionProvider(driver);
+      const connectionProvider = new import_kysely17.DefaultConnectionProvider(driver);
       this.kyselyProps = {
         config: {
           dialect: options.dialect,
@@ -6862,12 +6967,12 @@ var ClientImpl = class _ClientImpl {
         driver,
         executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
-      this.kyselyRaw = new import_kysely16.Kysely({
+      this.kyselyRaw = new import_kysely17.Kysely({
         ...this.kyselyProps,
-        executor: new import_kysely16.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
+        executor: new import_kysely17.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
       });
     }
-    this.kysely = new import_kysely16.Kysely(this.kyselyProps);
+    this.kysely = new import_kysely17.Kysely(this.kyselyProps);
     return createClientProxy(this);
   }
   get $qb() {
@@ -6887,13 +6992,18 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    (0, import_common_helpers14.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    (0, import_common_helpers16.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
     if (typeof input === "function") {
       return this.interactiveTransaction(input, options);
     } else {
       return this.sequentialTransaction(input, options);
     }
   }
+  forceTransaction() {
+    if (!this.kysely.isTransaction) {
+      this.kysely = new import_kysely17.Transaction(this.kyselyProps);
+    }
+  }
   async interactiveTransaction(callback, options) {
     if (this.kysely.isTransaction) {
       return callback(this);
@@ -6998,7 +7108,7 @@ var ClientImpl = class _ClientImpl {
   }
   $executeRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely16.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely17.sql)(query, ...values).execute(this.kysely);
       return Number(result.numAffectedRows ?? 0);
     });
   }
@@ -7011,7 +7121,7 @@ var ClientImpl = class _ClientImpl {
   }
   $queryRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely16.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely17.sql)(query, ...values).execute(this.kysely);
       return result.rows;
     });
   }
@@ -7023,7 +7133,7 @@ var ClientImpl = class _ClientImpl {
     });
   }
   createRawCompiledQuery(query, values) {
-    const q = import_kysely16.CompiledQuery.raw(query, values);
+    const q = import_kysely17.CompiledQuery.raw(query, values);
     return {
       ...q,
       $raw: true
@@ -7150,7 +7260,7 @@ function definePlugin(plugin) {
 __name(definePlugin, "definePlugin");
 
 // src/client/index.ts
-var import_kysely17 = require("kysely");
+var import_kysely18 = require("kysely");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InputValidationError,