@zenstackhq/runtime 3.0.0-alpha.13 → 3.0.0-alpha.14

package/dist/{contract-CBOBlAuw.d.cts → contract-BYc34jr_.d.cts}

@@ -611,6 +611,10 @@ type OnKyselyQueryArgs<Schema extends SchemaDef> = {
     proceed: ProceedKyselyQueryFunction;
 };
 type ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
+type OnKyselyQueryCallback<Schema extends SchemaDef> = (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
+type MutationInterceptionFilter<Schema extends SchemaDef> = (args: MutationHooksArgs<Schema>) => MaybePromise<MutationInterceptionFilterResult>;
+type BeforeEntityMutationCallback<Schema extends SchemaDef> = (args: PluginBeforeEntityMutationArgs<Schema>) => MaybePromise<void>;
+type AfterEntityMutationCallback<Schema extends SchemaDef> = (args: PluginAfterEntityMutationArgs<Schema>) => MaybePromise<void>;
 /**
  * ZenStack runtime plugin.
  */
@@ -634,18 +638,18 @@ interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
     /**
      * Intercepts a Kysely query.
      */
-    onKyselyQuery?: (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
+    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
     /**
      * This callback determines whether a mutation should be intercepted, and if so,
      * what data should be loaded before and after the mutation.
      */
-    mutationInterceptionFilter?: (args: MutationHooksArgs<Schema>) => MaybePromise<MutationInterceptionFilterResult>;
+    mutationInterceptionFilter?: MutationInterceptionFilter<Schema>;
     /**
      * Called before an entity is mutated.
      * @param args.entity Only available if `loadBeforeMutationEntity` is set to true in the
      * return value of {@link RuntimePlugin.mutationInterceptionFilter}.
      */
-    beforeEntityMutation?: (args: PluginBeforeEntityMutationArgs<Schema>) => MaybePromise<void>;
+    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
     /**
      * Called after an entity is mutated.
      * @param args.beforeMutationEntity Only available if `loadBeforeMutationEntity` is set to true in the
@@ -653,7 +657,7 @@ interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
      * @param args.afterMutationEntity Only available if `loadAfterMutationEntity` is set to true in the
      * return value of {@link RuntimePlugin.mutationInterceptionFilter}.
      */
-    afterEntityMutation?: (args: PluginAfterEntityMutationArgs<Schema>) => MaybePromise<void>;
+    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
 }
 type OnQueryHooks<Schema extends SchemaDef = SchemaDef> = {
     [Model in GetModels<Schema> as Uncapitalize<Model>]?: OnQueryOperationHooks<Schema, Model>;

package/dist/{contract-CBOBlAuw.d.ts → contract-BYc34jr_.d.ts}

@@ -611,6 +611,10 @@ type OnKyselyQueryArgs<Schema extends SchemaDef> = {
     proceed: ProceedKyselyQueryFunction;
 };
 type ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
+type OnKyselyQueryCallback<Schema extends SchemaDef> = (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
+type MutationInterceptionFilter<Schema extends SchemaDef> = (args: MutationHooksArgs<Schema>) => MaybePromise<MutationInterceptionFilterResult>;
+type BeforeEntityMutationCallback<Schema extends SchemaDef> = (args: PluginBeforeEntityMutationArgs<Schema>) => MaybePromise<void>;
+type AfterEntityMutationCallback<Schema extends SchemaDef> = (args: PluginAfterEntityMutationArgs<Schema>) => MaybePromise<void>;
 /**
  * ZenStack runtime plugin.
  */
@@ -634,18 +638,18 @@ interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
     /**
      * Intercepts a Kysely query.
      */
-    onKyselyQuery?: (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
+    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
     /**
      * This callback determines whether a mutation should be intercepted, and if so,
      * what data should be loaded before and after the mutation.
      */
-    mutationInterceptionFilter?: (args: MutationHooksArgs<Schema>) => MaybePromise<MutationInterceptionFilterResult>;
+    mutationInterceptionFilter?: MutationInterceptionFilter<Schema>;
     /**
      * Called before an entity is mutated.
      * @param args.entity Only available if `loadBeforeMutationEntity` is set to true in the
      * return value of {@link RuntimePlugin.mutationInterceptionFilter}.
      */
-    beforeEntityMutation?: (args: PluginBeforeEntityMutationArgs<Schema>) => MaybePromise<void>;
+    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
     /**
      * Called after an entity is mutated.
      * @param args.beforeMutationEntity Only available if `loadBeforeMutationEntity` is set to true in the
@@ -653,7 +657,7 @@ interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
      * @param args.afterMutationEntity Only available if `loadAfterMutationEntity` is set to true in the
      * return value of {@link RuntimePlugin.mutationInterceptionFilter}.
      */
-    afterEntityMutation?: (args: PluginAfterEntityMutationArgs<Schema>) => MaybePromise<void>;
+    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
 }
 type OnQueryHooks<Schema extends SchemaDef = SchemaDef> = {
     [Model in GetModels<Schema> as Uncapitalize<Model>]?: OnQueryOperationHooks<Schema, Model>;

package/dist/index.cjs

@@ -2666,14 +2666,14 @@ var BaseOperationHandler = class {
   getField(model, field) {
     return getField(this.schema, model, field);
   }
-  exists(kysely, model, filter) {
+  async exists(kysely, model, filter) {
     const idFields = getIdFields(this.schema, model);
     const _filter = flattenCompoundUniqueFilters(this.schema, model, filter);
     const query = kysely.selectFrom(model).where((eb) => eb.and(_filter)).select(idFields.map((f) => kysely.dynamic.ref(f))).limit(1).modifyEnd(this.makeContextComment({
       model,
       operation: "read"
     }));
-    return query.executeTakeFirst();
+    return this.executeQueryTakeFirst(kysely, query, "exists");
   }
   async read(kysely, model, args) {
     let query = this.dialect.buildSelectModel((0, import_kysely8.expressionBuilder)(), model);
@@ -2850,7 +2850,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
               model: fromRelation.model,
               operation: "update"
             }));
-            return query2.execute();
+            return this.executeQuery(kysely, query2, "update");
           }, "parentUpdateTask");
         }
       }
@@ -2889,7 +2889,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
       model,
       operation: "create"
     }));
-    const createdEntity = await query.executeTakeFirst();
+    const createdEntity = await this.executeQueryTakeFirst(kysely, query, "create");
     if (Object.keys(postCreateRelations).length > 0) {
       const relationPromises = Object.entries(postCreateRelations).map(([field, subPayload]) => {
         return this.processNoneOwnedRelationForCreate(kysely, model, field, subPayload, createdEntity);
@@ -3121,9 +3121,9 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
       operation: "create"
     }));
     if (!returnData) {
-      const result = await query.executeTakeFirstOrThrow();
+      const result = await this.executeQuery(kysely, query, "createMany");
       return {
-        count: Number(result.numInsertedOrUpdatedRows)
+        count: Number(result.numAffectedRows)
       };
     } else {
       const idFields = getIdFields(this.schema, model);
@@ -3302,7 +3302,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
         model,
         operation: "update"
       }));
-      const updatedEntity = await query.executeTakeFirst();
+      const updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
       if (!updatedEntity) {
         if (throwIfNotFound) {
           throw new NotFoundError(model);
@@ -3442,9 +3442,9 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
       operation: "update"
     }));
     if (!returnData) {
-      const result = await query.executeTakeFirstOrThrow();
+      const result = await this.executeQuery(kysely, query, "update");
       return {
-        count: Number(result.numUpdatedRows)
+        count: Number(result.numAffectedRows)
       };
     } else {
       const idFields = getIdFields(this.schema, model);
@@ -3589,7 +3589,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
           model: fromRelation.model,
           operation: "update"
         }));
-        updateResult = await query.executeTakeFirstOrThrow();
+        updateResult = await this.executeQuery(kysely, query, "connect");
       } else {
         const relationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
         if (!relationFieldDef.array) {
@@ -3600,7 +3600,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
             model: fromRelation.model,
             operation: "update"
           }));
-          await query2.execute();
+          await this.executeQuery(kysely, query2, "disconnect");
         }
         const query = kysely.updateTable(model).where((eb) => eb.or(_data.map((d) => eb.and(d)))).set(keyPairs.reduce((acc, { fk, pk }) => ({
           ...acc,
@@ -3609,9 +3609,9 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
           model,
           operation: "update"
         }));
-        updateResult = await query.executeTakeFirstOrThrow();
+        updateResult = await this.executeQuery(kysely, query, "connect");
       }
-      if (_data.length > updateResult.numUpdatedRows) {
+      if (_data.length > updateResult.numAffectedRows) {
         throw new NotFoundError(model);
       }
     }
@@ -3679,7 +3679,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
           model: fromRelation.model,
           operation: "update"
         }));
-        await query.executeTakeFirstOrThrow();
+        await this.executeQuery(kysely, query, "disconnect");
       } else {
         const query = kysely.updateTable(model).where(eb.and([
           // fk filter
@@ -3696,7 +3696,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
           model,
           operation: "update"
         }));
-        await query.executeTakeFirstOrThrow();
+        await this.executeQuery(kysely, query, "disconnect");
       }
     }
   }
@@ -3734,7 +3734,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
         model,
         operation: "update"
       }));
-      await query.execute();
+      await this.executeQuery(kysely, query, "disconnect");
       if (_data.length > 0) {
         const query2 = kysely.updateTable(model).where((eb) => eb.or(_data.map((d) => eb.and(d)))).set(keyPairs.reduce((acc, { fk, pk }) => ({
           ...acc,
@@ -3743,8 +3743,8 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
           model,
           operation: "update"
         }));
-        const r = await query2.executeTakeFirstOrThrow();
-        if (_data.length > r.numUpdatedRows) {
+        const r = await this.executeQuery(kysely, query2, "connect");
+        if (_data.length > r.numAffectedRows) {
           throw new NotFoundError(model);
         }
       }
@@ -3860,9 +3860,9 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
       model,
       operation: "delete"
     }));
-    const result = await query.executeTakeFirstOrThrow();
+    const result = await this.executeQuery(kysely, query, "delete");
     return {
-      count: Number(result.numDeletedRows)
+      count: Number(result.numAffectedRows)
     };
   }
   async processDelegateRelationDelete(kysely, modelDef, where, limit) {
@@ -3959,6 +3959,25 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
       }
     }
   }
+  makeQueryId(operation) {
+    return {
+      queryId: `${operation}-${(0, import_cuid2.createId)()}`
+    };
+  }
+  executeQuery(kysely, query, operation) {
+    return kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+  }
+  async executeQueryTakeFirst(kysely, query, operation) {
+    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+    return result.rows[0];
+  }
+  async executeQueryTakeFirstOrThrow(kysely, query, operation) {
+    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+    if (result.rows.length === 0) {
+      throw new QueryError("No rows found");
+    }
+    return result.rows[0];
+  }
 };
 
 // src/client/crud/operations/aggregate.ts
@@ -4031,9 +4050,9 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
         }
       }
     }
-    const result = await query.executeTakeFirstOrThrow();
+    const result = await this.executeQuery(this.kysely, query, "aggregate");
     const ret = {};
-    for (const [key, value] of Object.entries(result)) {
+    for (const [key, value] of Object.entries(result.rows[0])) {
       if (key === "_count") {
         ret[key] = value;
         continue;
@@ -4095,11 +4114,12 @@ var CountOperationHandler = class extends BaseOperationHandler {
     });
     if (parsedArgs?.select && typeof parsedArgs.select === "object") {
       query = query.select((eb) => Object.keys(parsedArgs.select).map((key) => key === "_all" ? eb.cast(eb.fn.countAll(), "integer").as("_all") : eb.cast(eb.fn.count(import_kysely10.sql.ref(`${subQueryName}.${key}`)), "integer").as(key)));
-      return query.executeTakeFirstOrThrow();
+      const result = await this.executeQuery(this.kysely, query, "count");
+      return result.rows[0];
     } else {
       query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
-      const result = await query.executeTakeFirstOrThrow();
-      return result.count;
+      const result = await this.executeQuery(this.kysely, query, "count");
+      return result.rows[0].count;
     }
   }
 };
@@ -4179,7 +4199,7 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
       throw new NotFoundError(this.model);
     }
     await this.safeTransaction(async (tx) => {
-      const result = await this.delete(tx, this.model, args.where, void 0);
+      const result = await this.delete(tx, this.model, args.where);
       if (result.count === 0) {
         throw new NotFoundError(this.model);
       }
@@ -4278,8 +4298,8 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
         }
       }
     }
-    const result = await query.execute();
-    return result.map((row) => this.postProcessRow(row));
+    const result = await this.executeQuery(this.kysely, query, "groupBy");
+    return result.rows.map((row) => this.postProcessRow(row));
   }
   postProcessRow(row) {
     const ret = {};
@@ -5282,11 +5302,11 @@ var ZenStackDriver = class {
   }
   #driver;
   #log;
-  txConnection;
   #initPromise;
   #initDone;
   #destroyPromise;
   #connections = /* @__PURE__ */ new WeakSet();
+  #txConnections = /* @__PURE__ */ new WeakMap();
   constructor(driver, log) {
     this.#initDone = false;
     this.#driver = driver;
@@ -5327,21 +5347,30 @@ var ZenStackDriver = class {
   }
   async beginTransaction(connection, settings) {
     const result = await this.#driver.beginTransaction(connection, settings);
-    this.txConnection = connection;
+    this.#txConnections.set(connection, []);
     return result;
   }
-  commitTransaction(connection) {
+  async commitTransaction(connection) {
     try {
-      return this.#driver.commitTransaction(connection);
-    } finally {
-      this.txConnection = void 0;
+      const result = await this.#driver.commitTransaction(connection);
+      const callbacks = this.#txConnections.get(connection);
+      this.#txConnections.delete(connection);
+      if (callbacks) {
+        for (const callback of callbacks) {
+          await callback();
+        }
+      }
+      return result;
+    } catch (err) {
+      this.#txConnections.delete(connection);
+      throw err;
     }
   }
-  rollbackTransaction(connection) {
+  async rollbackTransaction(connection) {
     try {
-      return this.#driver.rollbackTransaction(connection);
+      return await this.#driver.rollbackTransaction(connection);
     } finally {
-      this.txConnection = void 0;
+      this.#txConnections.delete(connection);
     }
   }
   async destroy() {
@@ -5419,6 +5448,22 @@ var ZenStackDriver = class {
   #calculateDurationMillis(startTime) {
     return performanceNow() - startTime;
   }
+  isTransactionConnection(connection) {
+    return this.#txConnections.has(connection);
+  }
+  registerTransactionCommitCallback(connection, callback) {
+    if (!this.#txConnections.has(connection)) {
+      return;
+    }
+    const callbacks = this.#txConnections.get(connection);
+    if (callbacks) {
+      callbacks.push(callback);
+    } else {
+      this.#txConnections.set(connection, [
+        callback
+      ]);
+    }
+  }
 };
 function performanceNow() {
   if (typeof performance !== "undefined" && typeof performance.now === "function") {
@@ -5660,7 +5705,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
   get options() {
     return this.client.$options;
   }
-  async executeQuery(compiledQuery, queryId) {
+  async executeQuery(compiledQuery, _queryId) {
     let queryNode = compiledQuery.query;
     let mutationInterceptionInfo;
     if (this.isMutationNode(queryNode) && this.hasMutationHooks) {
@@ -5671,7 +5716,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
         await this.callBeforeMutationHooks(queryNode, mutationInterceptionInfo);
       }
       const oldQueryNode = queryNode;
-      if ((import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.DeleteQueryNode.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
+      if ((import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.UpdateQueryNode.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
         queryNode = {
           ...queryNode,
           returning: import_kysely13.ReturningNode.create([
@@ -5680,34 +5725,49 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
         };
       }
       const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
-      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryParams, queryId);
+      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryParams);
       if (this.isMutationNode(queryNode)) {
-        await this.callAfterQueryInterceptionFilters(result, queryNode, mutationInterceptionInfo);
+        await this.callAfterMutationHooks(result.result, queryNode, mutationInterceptionInfo, result.connection);
       }
       if (oldQueryNode !== queryNode) {
       }
-      return result;
+      return result.result;
     }, "task");
     return task();
   }
-  proceedQueryWithKyselyInterceptors(queryNode, parameters, queryId) {
-    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters, queryId), "proceed");
-    const hooks = this.options.plugins?.filter((plugin) => typeof plugin.onKyselyQuery === "function").map((plugin) => plugin.onKyselyQuery.bind(plugin)) ?? [];
+  proceedQueryWithKyselyInterceptors(queryNode, parameters) {
+    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters), "proceed");
+    const hooks = [];
+    for (const plugin of this.client.$options.plugins ?? []) {
+      if (plugin.onKyselyQuery) {
+        hooks.push(plugin.onKyselyQuery.bind(plugin));
+      }
+    }
     for (const hook of hooks) {
       const _proceed = proceed;
-      proceed = /* @__PURE__ */ __name((query) => {
-        return hook({
+      proceed = /* @__PURE__ */ __name(async (query) => {
+        let connection;
+        const _p = /* @__PURE__ */ __name(async (q) => {
+          const r = await _proceed(q);
+          connection = r.connection;
+          return r.result;
+        }, "_p");
+        const hookResult = await hook({
           client: this.client,
           schema: this.client.$schema,
           kysely: this.kysely,
           query,
-          proceed: _proceed
+          proceed: _p
         });
+        return {
+          result: hookResult,
+          connection
+        };
       }, "proceed");
     }
     return proceed(queryNode);
   }
-  async proceedQuery(query, parameters, queryId) {
+  async proceedQuery(query, parameters) {
     const finalQuery = this.nameMapper.transformNode(query);
     let compiled = this.compileQuery(finalQuery);
     if (parameters) {
@@ -5717,7 +5777,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       };
     }
     try {
-      return await super.executeQuery(compiled, queryId);
+      return await this.provideConnection(async (connection) => {
+        const result = await connection.executeQuery(compiled);
+        return {
+          result,
+          connection
+        };
+      });
     } catch (err) {
       let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
       if (this.options.debug) {
@@ -5820,10 +5886,11 @@ ${compiled.parameters.map((p) => (0, import_node_util2.inspect)(p)).join("\n")}`
       return;
     }
     if (this.options.plugins) {
+      const mutationModel = this.getMutationModel(queryNode);
       for (const plugin of this.options.plugins) {
         if (plugin.beforeEntityMutation) {
           await plugin.beforeEntityMutation({
-            model: this.getMutationModel(queryNode),
+            model: mutationModel,
             action: mutationInterceptionInfo.action,
             queryNode,
             entities: mutationInterceptionInfo.beforeMutationEntities
@@ -5832,30 +5899,45 @@ ${compiled.parameters.map((p) => (0, import_node_util2.inspect)(p)).join("\n")}`
       }
     }
   }
-  async callAfterQueryInterceptionFilters(queryResult, queryNode, mutationInterceptionInfo) {
+  async callAfterMutationHooks(queryResult, queryNode, mutationInterceptionInfo, connection) {
     if (!mutationInterceptionInfo?.intercept) {
       return;
     }
-    if (this.options.plugins) {
-      const mutationModel = this.getMutationModel(queryNode);
-      for (const plugin of this.options.plugins) {
-        if (plugin.afterEntityMutation) {
-          let afterMutationEntities = void 0;
-          if (mutationInterceptionInfo.loadAfterMutationEntity) {
-            if (import_kysely13.UpdateQueryNode.is(queryNode)) {
-              afterMutationEntities = await this.loadEntities(mutationModel, mutationInterceptionInfo.where);
-            } else {
-              afterMutationEntities = queryResult.rows;
-            }
-          }
-          await plugin.afterEntityMutation({
-            model: this.getMutationModel(queryNode),
+    const hooks = [];
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.afterEntityMutation) {
+        hooks.push(plugin.afterEntityMutation.bind(plugin));
+      }
+    }
+    if (hooks.length === 0) {
+      return;
+    }
+    const mutationModel = this.getMutationModel(queryNode);
+    const inTransaction = this.driver.isTransactionConnection(connection);
+    for (const hook of hooks) {
+      let afterMutationEntities = void 0;
+      if (mutationInterceptionInfo.loadAfterMutationEntity) {
+        if (import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.UpdateQueryNode.is(queryNode)) {
+          afterMutationEntities = queryResult.rows;
+        }
+      }
+      const action = /* @__PURE__ */ __name(async () => {
+        try {
+          await hook({
+            model: mutationModel,
             action: mutationInterceptionInfo.action,
             queryNode,
             beforeMutationEntities: mutationInterceptionInfo.beforeMutationEntities,
             afterMutationEntities
           });
+        } catch (err) {
+          console.error(`Error in afterEntityMutation hook for model "${mutationModel}": ${err}`);
         }
+      }, "action");
+      if (inTransaction) {
+        this.driver.registerTransactionCommitCallback(connection, action);
+      } else {
+        await action();
       }
     }
   }
@@ -6494,19 +6576,26 @@ var ClientImpl = class _ClientImpl {
     await new SchemaDbPusher(this.schema, this.kysely).push();
   }
   $use(plugin) {
+    const newPlugins = [
+      ...this.$options.plugins ?? [],
+      plugin
+    ];
     const newOptions = {
       ...this.options,
-      plugins: [
-        ...this.options.plugins ?? [],
-        plugin
-      ]
+      plugins: newPlugins
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }
   $unuse(pluginId) {
+    const newPlugins = [];
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.id !== pluginId) {
+        newPlugins.push(plugin);
+      }
+    }
     const newOptions = {
       ...this.options,
-      plugins: this.options.plugins?.filter((p) => p.id !== pluginId)
+      plugins: newPlugins
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }