@fragno-dev/db 0.2.0 → 0.2.2

package/src/hooks/hooks.ts

@@ -2,17 +2,18 @@ import type { RetryPolicy } from "../query/unit-of-work/retry-policy";
 import { ExponentialBackoffRetryPolicy } from "../query/unit-of-work/retry-policy";
 import type { IUnitOfWork } from "../query/unit-of-work/unit-of-work";
 import type { InternalFragmentInstance } from "../fragments/internal-fragment";
+import type { TxResult } from "../query/unit-of-work/execute-unit-of-work";
 
 /**
  * Context available in hook functions via `this`.
- * Contains the nonce for idempotency and database access.
+ * Contains the idempotency key for idempotency and database access.
  */
 export interface HookContext {
   /**
-   * Unique nonce for this transaction.
+   * Unique idempotency key for this transaction.
    * Use this for idempotency checks in your hook implementation.
    */
-  nonce: string;
+  idempotencyKey: string;
 }
 
 /**
@@ -95,7 +96,7 @@ export function prepareHookMutations(uow: IUnitOfWork, config: HookProcessorConf
       lastAttemptAt: null,
       nextRetryAt: null,
       error: null,
-      nonce: uow.nonce,
+      nonce: uow.idempotencyKey,
     });
   }
 }
@@ -108,72 +109,82 @@ export async function processHooks(config: HookProcessorConfig): Promise<void> {
   const { hooks, namespace, internalFragment, defaultRetryPolicy } = config;
   const retryPolicy = defaultRetryPolicy ?? new ExponentialBackoffRetryPolicy({ maxRetries: 5 });
 
-  await internalFragment.inContext(async function () {
-    return await this.uow(async ({ executeRetrieve, executeMutate }) => {
-      const pendingEventsPromise =
-        internalFragment.services.hookService.getPendingHookEvents(namespace);
-      await executeRetrieve();
+  // Get pending events
+  const pendingEvents = await internalFragment.inContext(async function () {
+    return await this.handlerTx()
+      .withServiceCalls(
+        () => [internalFragment.services.hookService.getPendingHookEvents(namespace)] as const,
+      )
+      .transform(({ serviceResult: [events] }) => events)
+      .execute();
+  });
 
-      const pendingEvents = await pendingEventsPromise;
+  if (pendingEvents.length === 0) {
+    return;
+  }
 
-      if (pendingEvents.length === 0) {
-        return;
+  // Process events (async work outside transaction)
+  const processedEvents = await Promise.allSettled(
+    pendingEvents.map(async (event) => {
+      const hookFn = hooks[event.hookName];
+      if (!hookFn) {
+        return {
+          eventId: event.id,
+          status: "failed" as const,
+          error: `Hook '${event.hookName}' not found in hooks map`,
+          attempts: event.attempts,
+          maxAttempts: event.maxAttempts,
+        };
       }
 
-      const processedEvents = await Promise.allSettled(
-        pendingEvents.map(async (event) => {
-          const hookFn = hooks[event.hookName];
-          if (!hookFn) {
-            return {
-              eventId: event.id,
-              status: "failed" as const,
-              error: `Hook '${event.hookName}' not found in hooks map`,
-              attempts: event.attempts,
-              maxAttempts: event.maxAttempts,
-            };
-          }
+      try {
+        const hookContext: HookContext = { idempotencyKey: event.idempotencyKey };
+        await hookFn.call(hookContext, event.payload);
+        return {
+          eventId: event.id,
+          status: "completed" as const,
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+          eventId: event.id,
+          status: "failed" as const,
+          error: errorMessage,
+          attempts: event.attempts,
+          maxAttempts: event.maxAttempts,
+        };
+      }
+    }),
+  );
 
-          try {
-            const hookContext: HookContext = { nonce: event.nonce };
-            await hookFn.call(hookContext, event.payload);
-            return {
-              eventId: event.id,
-              status: "completed" as const,
-            };
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return {
-              eventId: event.id,
-              status: "failed" as const,
-              error: errorMessage,
-              attempts: event.attempts,
-              maxAttempts: event.maxAttempts,
-            };
+  // Mark events as completed/failed
+  await internalFragment.inContext(async function () {
+    await this.handlerTx()
+      .withServiceCalls(() => {
+        const txResults: TxResult<void>[] = [];
+        for (const processedEvent of processedEvents) {
+          if (processedEvent.status === "rejected") {
+            continue;
           }
-        }),
-      );
 
-      for (const processedEvent of processedEvents) {
-        if (processedEvent.status === "rejected") {
-          continue;
-        }
-
-        const { eventId, status } = processedEvent.value;
-
-        if (status === "completed") {
-          internalFragment.services.hookService.markHookCompleted(eventId);
-        } else if (status === "failed") {
-          const { error, attempts } = processedEvent.value;
-          internalFragment.services.hookService.markHookFailed(
-            eventId,
-            error,
-            attempts,
-            retryPolicy,
-          );
+          const { eventId, status } = processedEvent.value;
+
+          if (status === "completed") {
+            txResults.push(internalFragment.services.hookService.markHookCompleted(eventId));
+          } else if (status === "failed") {
+            const { error, attempts } = processedEvent.value;
+            txResults.push(
+              internalFragment.services.hookService.markHookFailed(
+                eventId,
+                error,
+                attempts,
+                retryPolicy,
+              ),
+            );
+          }
         }
-      }
-
-      await executeMutate();
-    });
+        return txResults;
+      })
+      .execute();
   });
 }

package/src/mod.ts

@@ -101,10 +101,20 @@ export {
 } from "./query/unit-of-work/retry-policy";
 
 export {
-  executeUnitOfWork,
-  type ExecuteUnitOfWorkResult,
-  type ExecuteUnitOfWorkCallbacks,
-  type ExecuteUnitOfWorkOptions,
+  ConcurrencyConflictError,
+  // Builder pattern exports
+  ServiceTxBuilder,
+  HandlerTxBuilder,
+  createServiceTxBuilder,
+  createHandlerTxBuilder,
+  type TxResult,
+  // Builder context types
+  type ServiceBuilderMutateContext,
+  type HandlerBuilderMutateContext,
+  type BuilderTransformContextWithMutate,
+  type BuilderTransformContextWithoutMutate,
+  type ExtractServiceRetrieveResults,
+  type ExtractServiceFinalResults,
 } from "./query/unit-of-work/execute-unit-of-work";
 
 export type { BoundServices } from "@fragno-dev/core";