@fragno-dev/db 0.2.1 → 0.2.2

package/src/db-fragment-definition-builder.ts

@@ -2,7 +2,6 @@ import type { AnySchema } from "./schema/create";
 import type { SimpleQueryInterface } from "./query/simple-query-interface";
 import type { DatabaseAdapter } from "./adapters/adapters";
 import type { IUnitOfWork } from "./query/unit-of-work/unit-of-work";
-import { TypedUnitOfWork, UnitOfWork } from "./query/unit-of-work/unit-of-work";
 import type {
   RequestThisContext,
   FragnoPublicConfig,
@@ -14,14 +13,11 @@ import {
   type ServiceConstructorFn,
 } from "@fragno-dev/core";
 import {
-  executeRestrictedUnitOfWork,
-  executeTxArray,
-  executeTxCallbacks,
-  executeServiceTx,
-  type AwaitedPromisesInObject,
-  type ExecuteRestrictedUnitOfWorkOptions,
-  type HandlerTxCallbacks,
-  type ServiceTxCallbacks,
+  createServiceTxBuilder,
+  createHandlerTxBuilder,
+  ServiceTxBuilder,
+  HandlerTxBuilder,
+  type ExecuteTxOptions,
 } from "./query/unit-of-work/execute-unit-of-work";
 import {
   prepareHookMutations,
@@ -69,35 +65,38 @@ export type ImplicitDatabaseDependencies<TSchema extends AnySchema> = {
  */
 export type DatabaseServiceContext<THooks extends HooksMap> = RequestThisContext & {
   /**
-   * Get a typed, restricted Unit of Work for the given schema.
-   * @param schema - Schema to get a typed view for
-   * @returns TypedUnitOfWork (restricted version without execute methods)
-   */
-  uow<TSchema extends AnySchema>(schema: TSchema): TypedUnitOfWork<TSchema, [], unknown, THooks>;
-
-  /**
-   * Execute a transaction with two-phase callbacks (retrieve + mutate).
-   *
-   * @param schema - Schema to use for the transaction
-   * @param callbacks - Object containing retrieve and mutate callbacks
-   * @returns Promise resolving to the mutation result with promises awaited 1 level deep
+   * Create a service-level transaction builder using the fluent API.
+   * Returns a builder that can be chained with withServiceCalls, retrieve,
+   * transformRetrieve, mutate, transform, and build.
    *
    * @example
    * ```ts
-   * return this.tx(schema, {
-   *   retrieve: (uow) => uow.findFirst("users", ...),
-   *   mutate: async (uow, [user]) => {
-   *     await validateUser(user);
-   *     uow.update("users", user.id, ...).check();
-   *     return { ok: true };
-   *   }
-   * });
+   * return this.serviceTx(schema)
+   *   .withServiceCalls(() => [otherService.getData()])
+   *   .retrieve((uow) => uow.find("users", ...))
+   *   .transformRetrieve(([users]) => users[0])
+   *   .mutate(({ uow, retrieveResult, serviceIntermediateResult }) =>
+   *     uow.create("records", { ... })
+   *   )
+   *   .transform(({ mutateResult, serviceResult }) => ({ id: mutateResult }))
+   *   .build();
    * ```
    */
-  tx<TSchema extends AnySchema, TRetrievalResults extends unknown[], TMutationResult = void>(
+  serviceTx<TSchema extends AnySchema>(
     schema: TSchema,
-    callbacks: ServiceTxCallbacks<TSchema, TRetrievalResults, TMutationResult, THooks>,
-  ): Promise<AwaitedPromisesInObject<TMutationResult>>;
+  ): ServiceTxBuilder<
+    TSchema,
+    readonly [],
+    [],
+    [],
+    unknown,
+    unknown,
+    false,
+    false,
+    false,
+    false,
+    THooks
+  >;
 };
 
 /**
@@ -105,92 +104,24 @@ export type DatabaseServiceContext<THooks extends HooksMap> = RequestThisContext
  */
 export type DatabaseHandlerContext<THooks extends HooksMap = {}> = RequestThisContext & {
   /**
-   * Execute a Unit of Work with explicit phase control and automatic retry support.
-   * This method provides an API where users call forSchema to create a schema-specific
-   * UOW, then call executeRetrieve() and executeMutate() to execute the phases. The entire
-   * callback is re-executed on optimistic concurrency conflicts, ensuring retries work properly.
-   * Automatically provides the UOW factory from context.
-   * Promises in the returned object are awaited 1 level deep.
-   *
-   * @param callback - Async function that receives a context with forSchema, executeRetrieve, executeMutate, nonce, and currentAttempt
-   * @param options - Optional configuration for retry policy and abort signal
-   * @returns Promise resolving to the callback's return value with promises awaited 1 level deep
-   * @throws Error if retries are exhausted or callback throws an error
+   * Create a handler-level transaction builder using the fluent API.
+   * Returns a builder that can be chained with withServiceCalls, retrieve,
+   * transformRetrieve, mutate, transform, and execute.
    *
    * @example
    * ```ts
-   * const result = await this.uow(async ({ forSchema, executeRetrieve, executeMutate, nonce, currentAttempt }) => {
-   *   const uow = forSchema(schema);
-   *   const userId = uow.create("users", { name: "John" });
-   *
-   *   // Execute retrieval phase
-   *   await executeRetrieve();
-   *
-   *   const profileId = uow.create("profiles", { userId });
-   *
-   *   // Execute mutation phase
-   *   await executeMutate();
-   *
-   *   return { userId, profileId };
-   * });
-   * ```
-   */
-  uow<TResult>(
-    callback: (context: {
-      forSchema: <TSchema extends AnySchema, H extends HooksMap = THooks>(
-        schema: TSchema,
-        hooks?: H,
-      ) => TypedUnitOfWork<TSchema, [], unknown, H>;
-      executeRetrieve: () => Promise<void>;
-      executeMutate: () => Promise<void>;
-      nonce: string;
-      currentAttempt: number;
-    }) => Promise<TResult> | TResult,
-    options?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">,
-  ): Promise<AwaitedPromisesInObject<TResult>>;
-
-  /**
-   * Execute a transaction with automatic retry support.
-   * Provides two overloads: array syntax (common case) and callback syntax (advanced).
-   *
-   * Array syntax - pass a factory function that returns service calls:
-   * ```ts
-   * const [transfer, notify] = await this.tx(
-   *   () => [
-   *     services.transfer({ from, to, amount }),
-   *     services.notify({ userId, message })
-   *   ]
-   * );
-   * ```
-   *
-   * Callback syntax - for handlers that need direct UOW access:
-   * ```ts
-   * const result = await this.tx({
-   *   retrieve: ({ forSchema }) => {
-   *     const uow = forSchema(schema);
-   *     uow.find("users", ...);
-   *     return services.transfer({ ... });
-   *   },
-   *   mutate: ({ forSchema }, transferPromise) => {
-   *     const uow = forSchema(schema);
-   *     uow.create("auditLog", { ... });
-   *     return transferPromise;
-   *   }
-   * });
+   * const result = await this.handlerTx()
+   *   .withServiceCalls(() => [userService.getUser(id)])
+   *   .mutate(({ forSchema, idempotencyKey, currentAttempt, serviceIntermediateResult }) => {
+   *     return forSchema(ordersSchema).create("orders", { ... });
+   *   })
+   *   .transform(({ mutateResult, serviceResult }) => ({ ... }))
+   *   .execute();
    * ```
-   *
-   * Note: Handler callbacks are synchronous only to prevent accidentally awaiting services in wrong place.
    */
-  // Overload 1: Array syntax (common case) - accepts a factory
-  tx<T extends readonly unknown[]>(
-    servicesFactory: () => readonly [...{ [K in keyof T]: Promise<T[K]> }],
-    options?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">,
-  ): Promise<{ [K in keyof T]: T[K] }>;
-  // Overload 2: Callback syntax (advanced, sync callbacks only)
-  tx<TRetrieveResult, TMutationResult>(
-    callbacks: HandlerTxCallbacks<TRetrieveResult, TMutationResult, THooks>,
-    options?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">,
-  ): Promise<AwaitedPromisesInObject<TMutationResult>>;
+  handlerTx(
+    options?: Omit<ExecuteTxOptions, "createUnitOfWork">,
+  ): HandlerTxBuilder<readonly [], [], [], unknown, unknown, false, false, false, false, THooks>;
 };
 
 /**
@@ -487,7 +418,7 @@ export class DatabaseFragmentDefinitionBuilder<
    * ```ts
    * .provideHooks(({ defineHook, config }) => ({
    *   onSubscribe: defineHook(async function (payload: { email: string }) {
-   *     // 'this' context available (HookServiceContext with nonce)
+   *     // 'this' context available (HookServiceContext with idempotencyKey)
    *     await config.onSubscribe?.(payload.email);
    *   }),
    * }))
@@ -719,55 +650,23 @@ export class DatabaseFragmentDefinitionBuilder<
           }
         : undefined;
 
-      function forSchema<TSchema extends AnySchema>(
-        schema: TSchema,
-      ): TypedUnitOfWork<TSchema, [], unknown, THooks> {
+      // Builder API: serviceTx using createServiceTxBuilder
+      function serviceTx<TSchema extends AnySchema>(schema: TSchema) {
         const uow = storage.getStore()?.uow;
         if (!uow) {
           throw new Error(
             "No UnitOfWork in context. Service must be called within a route handler OR using `withUnitOfWork`.",
           );
         }
-
-        return uow.restrict().forSchema<TSchema, THooks>(schema);
+        return createServiceTxBuilder<TSchema, THooks>(schema, uow, hooksConfig?.hooks);
       }
 
-      const serviceTx = async <
-        TSchema extends AnySchema,
-        TRetrievalResults extends unknown[],
-        TMutationResult = void,
-      >(
-        schema: TSchema,
-        callbacks: ServiceTxCallbacks<TSchema, TRetrievalResults, TMutationResult, THooks>,
-      ): Promise<AwaitedPromisesInObject<TMutationResult>> => {
-        const uow = storage.getStore()?.uow;
-        if (!uow) {
-          throw new Error(
-            "No UnitOfWork in context. Service must be called within a route handler OR using `withUnitOfWork`.",
-          );
-        }
-
-        return executeServiceTx(schema, callbacks, uow);
-      };
-
       const serviceContext: DatabaseServiceContext<THooks> = {
-        uow: forSchema,
-        tx: serviceTx,
+        serviceTx,
       };
 
-      async function uow<TResult>(
-        callback: (context: {
-          forSchema: <S extends AnySchema, H extends HooksMap = THooks>(
-            schema: S,
-            hooks?: H,
-          ) => TypedUnitOfWork<S, [], unknown, H>;
-          executeRetrieve: () => Promise<void>;
-          executeMutate: () => Promise<void>;
-          nonce: string;
-          currentAttempt: number;
-        }) => Promise<TResult> | TResult,
-        execOptions?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">,
-      ): Promise<AwaitedPromisesInObject<TResult>> {
+      // Builder API: handlerTx using createHandlerTxBuilder
+      function handlerTx(execOptions?: Omit<ExecuteTxOptions, "createUnitOfWork">) {
         const currentStorage = storage.getStore();
         if (!currentStorage) {
           throw new Error(
@@ -775,23 +674,10 @@ export class DatabaseFragmentDefinitionBuilder<
           );
         }
 
-        const wrappedCallback = async (context: {
-          forSchema: <S extends AnySchema, H extends HooksMap = THooks>(
-            schema: S,
-            hooks?: H,
-          ) => TypedUnitOfWork<S, [], unknown, H>;
-          executeRetrieve: () => Promise<void>;
-          executeMutate: () => Promise<void>;
-          nonce: string;
-          currentAttempt: number;
-        }): Promise<TResult> => {
-          return callback(context);
-        };
-
         const userOnBeforeMutate = execOptions?.onBeforeMutate;
-        const userOnSuccess = execOptions?.onSuccess;
+        const userOnAfterMutate = execOptions?.onAfterMutate;
 
-        return executeRestrictedUnitOfWork(wrappedCallback, {
+        return createHandlerTxBuilder<THooks>({
           ...execOptions,
           createUnitOfWork: () => {
             currentStorage.uow.reset();
@@ -801,8 +687,7 @@ export class DatabaseFragmentDefinitionBuilder<
                 hooksConfig.internalFragment.$internal.deps.namespace,
               );
             }
-            // Safe cast: currentStorage.uow is always a UnitOfWork instance
-            return currentStorage.uow as UnitOfWork;
+            return currentStorage.uow;
           },
           onBeforeMutate: (uow) => {
             if (hooksConfig) {
@@ -812,94 +697,19 @@ export class DatabaseFragmentDefinitionBuilder<
               userOnBeforeMutate(uow);
             }
           },
-          onSuccess: async (uow) => {
+          onAfterMutate: async (uow) => {
             if (hooksConfig) {
               await processHooks(hooksConfig);
             }
-            if (userOnSuccess) {
-              await userOnSuccess(uow);
+            if (userOnAfterMutate) {
+              await userOnAfterMutate(uow);
             }
           },
         });
       }
 
-      // Handler tx method with two overloads
-      function handlerTx<T extends readonly unknown[]>(
-        servicesFactory: () => readonly [...{ [K in keyof T]: Promise<T[K]> }],
-        execOptions?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">,
-      ): Promise<{ [K in keyof T]: T[K] }>;
-      function handlerTx<TRetrieveResult, TMutationResult>(
-        callbacks: HandlerTxCallbacks<TRetrieveResult, TMutationResult, THooks>,
-        execOptions?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">,
-      ): Promise<AwaitedPromisesInObject<TMutationResult>>;
-      async function handlerTx<T extends readonly unknown[], TRetrieveResult, TMutationResult>(
-        factoryOrCallbacks:
-          | (() => readonly [...{ [K in keyof T]: Promise<T[K]> }])
-          | HandlerTxCallbacks<TRetrieveResult, TMutationResult, THooks>,
-        execOptions?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">,
-      ): Promise<{ [K in keyof T]: T[K] } | AwaitedPromisesInObject<TMutationResult>> {
-        const currentStorage = storage.getStore();
-        if (!currentStorage) {
-          throw new Error(
-            "No storage in context. Handler must be called within a request context.",
-          );
-        }
-
-        const userOnBeforeMutate = execOptions?.onBeforeMutate;
-        const userOnSuccess = execOptions?.onSuccess;
-
-        const createUow = () => {
-          currentStorage.uow.reset();
-
-          if (hooksConfig) {
-            currentStorage.uow.registerSchema(
-              hooksConfig.internalFragment.$internal.deps.schema,
-              hooksConfig.internalFragment.$internal.deps.namespace,
-            );
-          }
-          // Safe cast: currentStorage.uow is always a UnitOfWork instance
-          return currentStorage.uow as UnitOfWork;
-        };
-
-        const options: ExecuteRestrictedUnitOfWorkOptions = {
-          ...execOptions,
-          createUnitOfWork: createUow,
-          onBeforeMutate: (uow) => {
-            if (hooksConfig) {
-              prepareHookMutations(uow, hooksConfig);
-            }
-            if (userOnBeforeMutate) {
-              userOnBeforeMutate(uow);
-            }
-          },
-          onSuccess: async (uow) => {
-            if (hooksConfig) {
-              await processHooks(hooksConfig);
-            }
-            if (userOnSuccess) {
-              await userOnSuccess(uow);
-            }
-          },
-        };
-
-        // Check if it's a function (array syntax factory) or callbacks object (callback syntax)
-        if (typeof factoryOrCallbacks === "function") {
-          // Array syntax - factoryOrCallbacks is a factory function
-          return executeTxArray(
-            factoryOrCallbacks as () => readonly [...{ [K in keyof T]: Promise<T[K]> }],
-            options,
-          ) as Promise<{ [K in keyof T]: T[K] }>;
-        } else {
-          return executeTxCallbacks(
-            factoryOrCallbacks as HandlerTxCallbacks<TRetrieveResult, TMutationResult, THooks>,
-            options,
-          );
-        }
-      }
-
       const handlerContext: DatabaseHandlerContext<THooks> = {
-        uow,
-        tx: handlerTx,
+        handlerTx,
       };
 
       return { serviceContext, handlerContext };

package/src/db-fragment-instantiator.test.ts

@@ -29,11 +29,19 @@ function createMockAdapter(): DatabaseAdapter {
             findMany: vi.fn(),
           })),
           restrict: vi.fn(() => createMockRestrictedUow()),
+          signalReadyForRetrieval: vi.fn(),
+          signalReadyForMutation: vi.fn(),
+          retrievalPhase: Promise.resolve([]),
+          mutationPhase: Promise.resolve(),
         })),
         restrict: vi.fn(() => createMockRestrictedUow()),
         table: vi.fn(() => ({
           findMany: vi.fn(),
         })),
+        signalReadyForRetrieval: vi.fn(),
+        signalReadyForMutation: vi.fn(),
+        retrievalPhase: Promise.resolve([]),
+        mutationPhase: Promise.resolve(),
       });
 
       return {
@@ -43,16 +51,22 @@ function createMockAdapter(): DatabaseAdapter {
             findMany: vi.fn(),
           })),
           restrict: vi.fn(() => createMockRestrictedUow()),
+          signalReadyForRetrieval: vi.fn(),
+          signalReadyForMutation: vi.fn(),
+          retrievalPhase: Promise.resolve([]),
+          mutationPhase: Promise.resolve(),
         })),
         restrict: vi.fn(() => createMockRestrictedUow()),
-        executeRetrieve: vi.fn(),
-        executeMutations: vi.fn(),
+        executeRetrieve: vi.fn(async () => {}),
+        executeMutations: vi.fn(async () => ({ success: true })),
         commit: vi.fn(),
         rollback: vi.fn(),
         reset: vi.fn(),
         table: vi.fn(() => ({
           findMany: vi.fn(),
         })),
+        idempotencyKey: "test-nonce",
+        state: "building-retrieval",
       };
     }),
     type: "mock",
@@ -69,7 +83,7 @@ function createMockAdapter(): DatabaseAdapter {
 
 describe("db-fragment-instantiator", () => {
   describe("Unit of Work in request context", () => {
-    it("should provide executeRestrictedUnitOfWork on this context in route handlers", async () => {
+    it("should provide handlerTx on this context in route handlers", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .build();
@@ -79,10 +93,10 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/test",
           handler: async function (_input, { json }) {
-            // Access executeRestrictedUnitOfWork from this context
-            expect(this.uow).toBeDefined();
+            // Access handlerTx from this context
+            expect(this.handlerTx).toBeDefined();
 
-            return json({ hasExecuteMethod: !!this.uow });
+            return json({ hasHandlerTxBuilder: !!this.handlerTx });
           },
         }),
       ]);
@@ -96,10 +110,10 @@ describe("db-fragment-instantiator", () => {
       const response = await fragment.handler(new Request("http://localhost/api/test"));
       const data = await response.json();
 
-      expect(data).toEqual({ hasExecuteMethod: true });
+      expect(data).toEqual({ hasHandlerTxBuilder: true });
     });
 
-    it("should provide schema-typed UOW via executeRestrictedUnitOfWork", async () => {
+    it("should provide schema-typed UOW via handlerTx", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .build();
@@ -109,10 +123,12 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/test",
           handler: async function (_input, { json }) {
-            const result = await this.uow(async ({ forSchema }) => {
-              const uow = forSchema(testSchema);
-              return { hasSchemaUow: !!uow };
-            });
+            const result = await this.handlerTx()
+              .mutate(({ forSchema }) => {
+                const uow = forSchema(testSchema);
+                return { hasSchemaUow: !!uow };
+              })
+              .execute();
 
             return json(result);
           },
@@ -189,7 +205,7 @@ describe("db-fragment-instantiator", () => {
   });
 
   describe("database operations with UOW", () => {
-    it("should allow accessing schema-typed UOW in handlers via executeRestrictedUnitOfWork", async () => {
+    it("should allow accessing schema-typed UOW in handlers via handlerTx", async () => {
       const testSchemaWithCounter = schema((s) => {
         return s.addTable("counters", (t) => {
           return t.addColumn("id", idColumn()).addColumn("value", column("integer"));
@@ -205,11 +221,13 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/counters",
           handler: async function (_input, { json }) {
-            const result = await this.uow(async ({ forSchema }) => {
-              const uow = forSchema(testSchemaWithCounter);
-              // Verify that we can access the UOW
-              return { hasCountersTable: !!uow };
-            });
+            const result = await this.handlerTx()
+              .mutate(({ forSchema }) => {
+                const uow = forSchema(testSchemaWithCounter);
+                // Verify that we can access the UOW
+                return { hasCountersTable: !!uow };
+              })
+              .execute();
 
             return json(result);
           },
@@ -230,14 +248,15 @@ describe("db-fragment-instantiator", () => {
   });
 
   describe("service integration with UOW", () => {
-    it("should allow services to access UOW via forSchema", async () => {
+    it("should allow services to access UOW via serviceTx", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .providesBaseService(({ defineService }) =>
           defineService({
             checkTypedUowExists: function () {
-              const uow = this.uow(testSchema);
-              return !!uow;
+              return this.serviceTx(testSchema)
+                .mutate(({ uow }) => !!uow)
+                .build();
             },
           }),
         )
@@ -249,7 +268,10 @@ describe("db-fragment-instantiator", () => {
           path: "/check",
           outputSchema: z.object({ hasTypedUow: z.boolean() }),
           handler: async function (_input, { json }) {
-            const hasTypedUow = services.checkTypedUowExists();
+            const hasTypedUow = await this.handlerTx()
+              .withServiceCalls(() => [services.checkTypedUowExists()] as const)
+              .transform(({ serviceResult: [result] }) => result)
+              .execute();
             return json({ hasTypedUow });
           },
         }),
@@ -266,73 +288,18 @@ describe("db-fragment-instantiator", () => {
       assert(response.type === "json");
       expect(response.data).toEqual({ hasTypedUow: true });
     });
-
-    it.skip("should share same UOW across multiple service calls from handler", async () => {
-      const definition = defineFragment("test-db-fragment")
-        .extend(withDatabase(testSchema))
-        .providesService("helpers", ({ defineService }) =>
-          defineService({
-            logUow: function () {
-              return this.uow(testSchema);
-            },
-          }),
-        )
-        .providesService("main", ({ defineService }) =>
-          defineService({
-            markUow: function () {
-              return this.uow(testSchema);
-            },
-          }),
-        )
-        .build();
-
-      const routes = defineRoutes(definition).create(({ services, defineRoute }) => [
-        defineRoute({
-          method: "GET",
-          path: "/nested",
-          handler: async function (_input, { json }) {
-            // Mark the UOW with an ID
-            const uow1 = services.main.markUow();
-            const uow2 = services.helpers.logUow();
-            const uow3 = services.main.markUow();
-
-            console.log({
-              x: uow1 === uow2,
-              y: uow2 === uow3,
-              z: uow1 === uow3,
-            });
-
-            return json({
-              same: uow1 === uow2 && uow2 === uow3,
-            });
-          },
-        }),
-      ]);
-
-      const mockAdapter = createMockAdapter();
-      const fragment = instantiate(definition)
-        .withRoutes([routes])
-        .withOptions({ mountRoute: "/api", databaseAdapter: mockAdapter })
-        .build();
-
-      const response = await fragment.handler(new Request("http://localhost/api/nested"));
-      const data = await response.json();
-
-      expect(data).toEqual({
-        same: true,
-      });
-    });
   });
 
   describe("inContext with database fragments", () => {
-    it("should allow calling services with UOW via inContext", () => {
+    it("should allow calling services with UOW via inContext", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .providesBaseService(({ defineService }) =>
           defineService({
             getUowExists: function () {
-              const uow = this.uow(testSchema);
-              return !!uow;
+              return this.serviceTx(testSchema)
+                .mutate(({ uow }) => !!uow)
+                .build();
             },
           }),
         )
@@ -343,7 +310,12 @@ describe("db-fragment-instantiator", () => {
         .withOptions({ databaseAdapter: mockAdapter })
         .build();
 
-      const result = fragment.inContext(() => fragment.services.getUowExists());
+      const result = await fragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(() => [fragment.services.getUowExists()] as const)
+          .transform(({ serviceResult: [exists] }) => exists)
+          .execute();
+      });
       expect(result).toBe(true);
     });
   });
@@ -370,10 +342,12 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/test",
           handler: async function (_input, { json }) {
-            const result = await this.uow(async ({ forSchema }) => {
-              const uow = forSchema(testSchema);
-              return { hasUow: !!uow };
-            });
+            const result = await this.handlerTx()
+              .mutate(({ forSchema }) => {
+                const uow = forSchema(testSchema);
+                return { hasUow: !!uow };
+              })
+              .execute();
             return json(result);
           },
         }),
@@ -518,13 +492,15 @@ describe("db-fragment-instantiator", () => {
       }).toThrow("Database fragment requires a database adapter");
     });
 
-    it("should throw when forSchema called outside request context", () => {
+    it("should throw when serviceTx called outside request context", () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .providesBaseService(({ defineService }) =>
           defineService({
             tryGetUow: function () {
-              return this.uow(testSchema);
+              return this.serviceTx(testSchema)
+                .mutate(({ uow }) => uow)
+                .build();
             },
           }),
         )