@fragno-dev/db 0.2.1 → 0.3.0

package/src/hooks/hooks.test.ts

@@ -2,17 +2,26 @@ import SQLite from "better-sqlite3";
 import { SqliteDialect } from "kysely";
 import { beforeAll, describe, expect, it, vi } from "vitest";
 import { instantiate } from "@fragno-dev/core";
-import { prepareHookMutations, processHooks, type HooksMap, type HookContext } from "./hooks";
+import {
+  prepareHookMutations,
+  processHooks,
+  type HooksMap,
+  type HookContext,
+  type HookHandlerTx,
+} from "./hooks";
 import { internalFragmentDef, internalSchema } from "../fragments/internal-fragment";
 import type { FragnoPublicConfigWithDatabase } from "../db-fragment-definition-builder";
-import { DrizzleAdapter } from "../adapters/drizzle/drizzle-adapter";
+import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
 import { BetterSQLite3DriverConfig } from "../adapters/generic-sql/driver-config";
 import { ExponentialBackoffRetryPolicy, NoRetryPolicy } from "../query/unit-of-work/retry-policy";
 import type { FragnoId } from "../schema/create";
 
 describe("Hook System", () => {
+  const handlerTx = (() => {
+    throw new Error("handlerTx not configured for hooks test");
+  }) as HookHandlerTx;
   let sqliteDatabase: SQLite.Database;
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
   let internalFragment: ReturnType<typeof instantiateFragment>;
 
   function instantiateFragment(options: FragnoPublicConfigWithDatabase) {
@@ -26,18 +35,19 @@ describe("Hook System", () => {
       database: sqliteDatabase,
     });
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new BetterSQLite3DriverConfig(),
     });
 
     {
-      const migrations = adapter.prepareMigrations(internalSchema, "");
+      const migrations = adapter.prepareMigrations(internalSchema, null);
       await migrations.executeWithDriver(adapter.driver, 0);
     }
 
     const options: FragnoPublicConfigWithDatabase = {
       databaseAdapter: adapter,
+      databaseNamespace: null,
     };
 
     internalFragment = instantiateFragment(options);
@@ -57,8 +67,11 @@ describe("Hook System", () => {
       const onBeforeMutate = vi.fn();
 
       await internalFragment.inContext(async function () {
-        await this.uow(
-          async ({ forSchema, executeMutate }) => {
+        await this.handlerTx({
+          onAfterMutate: onSuccess,
+          onBeforeMutate,
+        })
+          .mutate(({ forSchema }) => {
             const uow = forSchema(internalSchema, hooks);
 
             // Trigger a hook
@@ -69,16 +82,11 @@ describe("Hook System", () => {
               hooks,
               namespace,
               internalFragment,
+              handlerTx,
               defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
             });
-
-            await executeMutate();
-          },
-          {
-            onSuccess,
-            onBeforeMutate,
-          },
-        );
+          })
+          .execute();
       });
 
       // Verify callbacks were executed
@@ -87,11 +95,12 @@ describe("Hook System", () => {
 
       // Verify hook was created
       const events = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ executeRetrieve }) => {
-          const result = internalFragment.services.hookService.getPendingHookEvents(namespace);
-          await executeRetrieve();
-          return result;
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getPendingHookEvents(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
       });
 
       expect(events).toHaveLength(1);
@@ -110,28 +119,30 @@ describe("Hook System", () => {
       };
 
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema, hooks);
-
-          uow.triggerHook("onNoRetry", { data: "test" });
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema, hooks);
 
-          prepareHookMutations(uow, {
-            hooks,
-            namespace,
-            internalFragment,
-            defaultRetryPolicy: new NoRetryPolicy(),
-          });
+            uow.triggerHook("onNoRetry", { data: "test" });
 
-          await executeMutate();
-        });
+            prepareHookMutations(uow, {
+              hooks,
+              namespace,
+              internalFragment,
+              handlerTx,
+              defaultRetryPolicy: new NoRetryPolicy(),
+            });
+          })
+          .execute();
       });
 
       const events = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ executeRetrieve }) => {
-          const result = internalFragment.services.hookService.getPendingHookEvents(namespace);
-          await executeRetrieve();
-          return result;
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getPendingHookEvents(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
       });
 
       expect(events).toHaveLength(1);
@@ -145,38 +156,118 @@ describe("Hook System", () => {
       };
 
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema, hooks);
-
-          uow.triggerHook(
-            "onCustomRetry",
-            { data: "test" },
-            {
-              retryPolicy: new NoRetryPolicy(),
-            },
-          );
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema, hooks);
 
-          prepareHookMutations(uow, {
-            hooks,
-            namespace,
-            internalFragment,
-            defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 10 }),
-          });
+            uow.triggerHook(
+              "onCustomRetry",
+              { data: "test" },
+              {
+                retryPolicy: new NoRetryPolicy(),
+              },
+            );
 
-          await executeMutate();
-        });
+            prepareHookMutations(uow, {
+              hooks,
+              namespace,
+              internalFragment,
+              handlerTx,
+              defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 10 }),
+            });
+          })
+          .execute();
       });
 
       const events = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ executeRetrieve }) => {
-          const result = internalFragment.services.hookService.getPendingHookEvents(namespace);
-          await executeRetrieve();
-          return result;
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getPendingHookEvents(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
       });
 
       expect(events[0]?.maxAttempts).toBe(1);
     });
+
+    it("should set nextRetryAt when processAt is in the future", async () => {
+      const namespace = "test-process-at-future";
+      const hooks: HooksMap = {
+        onScheduled: vi.fn(),
+      };
+      const futureTime = new Date(Date.now() + 60000);
+
+      await internalFragment.inContext(async function () {
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema, hooks);
+
+            uow.triggerHook("onScheduled", { data: "test" }, { processAt: futureTime });
+
+            prepareHookMutations(uow, {
+              hooks,
+              namespace,
+              internalFragment,
+              handlerTx,
+              defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
+            });
+          })
+          .execute();
+      });
+
+      const events = await internalFragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHooksByNamespace(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
+      });
+
+      expect(events).toHaveLength(1);
+      expect(events[0]?.nextRetryAt).toBeInstanceOf(Date);
+      expect(events[0]?.nextRetryAt?.getTime()).toBe(futureTime.getTime());
+    });
+
+    it("should keep processAt in the past while remaining immediately eligible", async () => {
+      const namespace = "test-process-at-past";
+      const hooks: HooksMap = {
+        onImmediate: vi.fn(),
+      };
+      const pastTime = new Date(Date.now() - 60000);
+
+      await internalFragment.inContext(async function () {
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema, hooks);
+
+            uow.triggerHook("onImmediate", { data: "test" }, { processAt: pastTime });
+
+            prepareHookMutations(uow, {
+              hooks,
+              namespace,
+              internalFragment,
+              handlerTx,
+              defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
+            });
+          })
+          .execute();
+      });
+
+      const events = await internalFragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHooksByNamespace(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
+      });
+
+      expect(events).toHaveLength(1);
+      expect(events[0]?.nextRetryAt).toBeInstanceOf(Date);
+      expect(events[0]?.nextRetryAt?.getTime()).toBe(pastTime.getTime());
+    });
   });
 
   describe("processHooks", () => {
@@ -191,22 +282,24 @@ describe("Hook System", () => {
 
       // Create a pending hook event
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema);
-          eventId = uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onSuccess",
-            payload: { email: "test@example.com" },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "test-nonce",
-          });
-          await executeMutate();
-        });
+        const createdId = await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            return uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onSuccess",
+              payload: { email: "test@example.com" },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "test-nonce",
+            });
+          })
+          .execute();
+        eventId = createdId;
       });
 
       // Process hooks
@@ -214,6 +307,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
@@ -223,19 +317,16 @@ describe("Hook System", () => {
 
       // Verify hook context (this)
       const hookContext = hookFn.mock.contexts[0] as HookContext;
-      expect(hookContext.nonce).toBe("test-nonce");
+      expect(hookContext.idempotencyKey).toBe("test-nonce");
 
       // Verify event was marked as completed
       const result = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ forSchema, executeRetrieve }) => {
-          const uow = forSchema(internalSchema);
-          const findUow = uow.find("fragno_hooks", (b) =>
-            b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
-          );
-          await executeRetrieve();
-          const [events] = await findUow.retrievalPhase;
-          return events?.[0];
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHookById(eventId)] as const,
+          )
+          .transform(({ serviceResult: [event] }) => event)
+          .execute();
       });
 
       expect(result?.status).toBe("completed");
@@ -252,43 +343,43 @@ describe("Hook System", () => {
       let eventId: FragnoId;
 
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema);
-          eventId = uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onFailure",
-            payload: { data: "test" },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "test-nonce",
-          });
-          await executeMutate();
-        });
+        const createdId = await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            return uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onFailure",
+              payload: { data: "test" },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "test-nonce",
+            });
+          })
+          .execute();
+        eventId = createdId;
       });
 
       await processHooks({
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
       expect(hookFn).toHaveBeenCalledOnce();
 
       const result = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ forSchema, executeRetrieve }) => {
-          const uow = forSchema(internalSchema);
-          const findUow = uow.find("fragno_hooks", (b) =>
-            b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
-          );
-          await executeRetrieve();
-          const [events] = await findUow.retrievalPhase;
-          return events?.[0];
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHookById(eventId)] as const,
+          )
+          .transform(({ serviceResult: [event] }) => event)
+          .execute();
       });
 
       expect(result?.status).toBe("pending");
@@ -307,41 +398,41 @@ describe("Hook System", () => {
       let eventId: FragnoId;
 
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema);
-          eventId = uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onMaxRetries",
-            payload: { data: "test" },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 1,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "test-nonce",
-          });
-          await executeMutate();
-        });
+        const createdId = await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            return uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onMaxRetries",
+              payload: { data: "test" },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 1,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "test-nonce",
+            });
+          })
+          .execute();
+        eventId = createdId;
       });
 
       await processHooks({
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new NoRetryPolicy(),
       });
 
       const result = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ forSchema, executeRetrieve }) => {
-          const uow = forSchema(internalSchema);
-          const findUow = uow.find("fragno_hooks", (b) =>
-            b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
-          );
-          await executeRetrieve();
-          const [events] = await findUow.retrievalPhase;
-          return events?.[0];
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHookById(eventId)] as const,
+          )
+          .transform(({ serviceResult: [event] }) => event)
+          .execute();
       });
 
       expect(result?.status).toBe("failed");
@@ -358,47 +449,109 @@ describe("Hook System", () => {
       let eventId: FragnoId;
 
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema);
-          eventId = uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onMissing",
-            payload: { data: "test" },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 1,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "test-nonce",
-          });
-          await executeMutate();
-        });
+        const createdId = await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            return uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onMissing",
+              payload: { data: "test" },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 1,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "test-nonce",
+            });
+          })
+          .execute();
+        eventId = createdId;
       });
 
       await processHooks({
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new NoRetryPolicy(),
       });
 
       const result = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ forSchema, executeRetrieve }) => {
-          const uow = forSchema(internalSchema);
-          const findUow = uow.find("fragno_hooks", (b) =>
-            b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
-          );
-          await executeRetrieve();
-          const [events] = await findUow.retrievalPhase;
-          return events?.[0];
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHookById(eventId)] as const,
+          )
+          .transform(({ serviceResult: [event] }) => event)
+          .execute();
       });
 
       expect(result?.status).toBe("failed");
       expect(result?.error).toBe("Hook 'onMissing' not found in hooks map");
     });
 
+    it("should re-queue stuck processing hooks and call the handler", async () => {
+      const namespace = "test-stuck-processing";
+      const hookFn = vi.fn();
+      const hooks: HooksMap = {
+        onStuck: hookFn,
+      };
+      const onStuckProcessingHooks = vi.fn();
+
+      let eventId: FragnoId;
+
+      await internalFragment.inContext(async function () {
+        const createdId = await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            return uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onStuck",
+              payload: { ok: true },
+              status: "processing",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: new Date(Date.now() - 20 * 60_000),
+              nextRetryAt: null,
+              error: null,
+              nonce: "test-nonce",
+            });
+          })
+          .execute();
+        eventId = createdId;
+      });
+
+      await processHooks({
+        hooks,
+        namespace,
+        internalFragment,
+        handlerTx,
+        stuckProcessingTimeoutMinutes: 1,
+        onStuckProcessingHooks,
+      });
+
+      expect(hookFn).toHaveBeenCalledOnce();
+      expect(onStuckProcessingHooks).toHaveBeenCalledOnce();
+      expect(onStuckProcessingHooks).toHaveBeenCalledWith(
+        expect.objectContaining({
+          namespace,
+          timeoutMinutes: 1,
+          events: [expect.objectContaining({ hookName: "onStuck" })],
+        }),
+      );
+
+      const result = await internalFragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHookById(eventId)] as const,
+          )
+          .transform(({ serviceResult: [event] }) => event)
+          .execute();
+      });
+
+      expect(result?.status).toBe("completed");
+    });
+
     it("should process multiple hooks in parallel", async () => {
       const namespace = "test-parallel";
       const hook1 = vi.fn();
@@ -411,52 +564,54 @@ describe("Hook System", () => {
       };
 
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema);
-          uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onHook1",
-            payload: { id: 1 },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "nonce-1",
-          });
-          uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onHook2",
-            payload: { id: 2 },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "nonce-2",
-          });
-          uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onHook3",
-            payload: { id: 3 },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "nonce-3",
-          });
-          await executeMutate();
-        });
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onHook1",
+              payload: { id: 1 },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "nonce-1",
+            });
+            uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onHook2",
+              payload: { id: 2 },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "nonce-2",
+            });
+            uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onHook3",
+              payload: { id: 3 },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "nonce-3",
+            });
+          })
+          .execute();
       });
 
       await processHooks({
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
@@ -466,15 +621,12 @@ describe("Hook System", () => {
 
       // Verify all were marked as completed
       const events = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ forSchema, executeRetrieve }) => {
-          const uow = forSchema(internalSchema);
-          const findUow = uow.find("fragno_hooks", (b) =>
-            b.whereIndex("idx_namespace_status_retry", (eb) => eb("namespace", "=", namespace)),
-          );
-          await executeRetrieve();
-          const [results] = await findUow.retrievalPhase;
-          return results;
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHooksByNamespace(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
       });
 
       const completed = events.filter((e) => e.status === "completed");
@@ -493,52 +645,54 @@ describe("Hook System", () => {
       };
 
       await internalFragment.inContext(async function () {
-        await this.uow(async ({ forSchema, executeMutate }) => {
-          const uow = forSchema(internalSchema);
-          uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onHook1",
-            payload: { id: 1 },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "nonce-1",
-          });
-          uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onHook2",
-            payload: { id: 2 },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "nonce-2",
-          });
-          uow.create("fragno_hooks", {
-            namespace,
-            hookName: "onHook3",
-            payload: { id: 3 },
-            status: "pending",
-            attempts: 0,
-            maxAttempts: 5,
-            lastAttemptAt: null,
-            nextRetryAt: null,
-            error: null,
-            nonce: "nonce-3",
-          });
-          await executeMutate();
-        });
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onHook1",
+              payload: { id: 1 },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "nonce-1",
+            });
+            uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onHook2",
+              payload: { id: 2 },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "nonce-2",
+            });
+            uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onHook3",
+              payload: { id: 3 },
+              status: "pending",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: null,
+              nextRetryAt: null,
+              error: null,
+              nonce: "nonce-3",
+            });
+          })
+          .execute();
       });
 
       await processHooks({
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
@@ -548,15 +702,12 @@ describe("Hook System", () => {
 
       // Verify hook1 and hook3 were completed, hook2 was marked for retry
       const events = await internalFragment.inContext(async function () {
-        return await this.uow(async ({ forSchema, executeRetrieve }) => {
-          const uow = forSchema(internalSchema);
-          const findUow = uow.find("fragno_hooks", (b) =>
-            b.whereIndex("idx_namespace_status_retry", (eb) => eb("namespace", "=", namespace)),
-          );
-          await executeRetrieve();
-          const [results] = await findUow.retrievalPhase;
-          return results;
-        });
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHooksByNamespace(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
       });
 
       const completed = events.filter((e) => e.status === "completed");
@@ -578,6 +729,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });