@fragno-dev/db 0.2.0 → 0.2.2

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

@@ -8,6 +8,7 @@ import { withDatabase } from "./with-database";
 import { schema, column, idColumn } from "./schema/create";
 import type { SimpleQueryInterface } from "./query/simple-query-interface";
 import type { DatabaseAdapter } from "./adapters/adapters";
+import * as executeUnitOfWork from "./query/unit-of-work/execute-unit-of-work";
 
 // Create a test schema
 const testSchema = schema((s) => {
@@ -697,7 +698,7 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
       expect(storage.uow).toBeDefined();
     });
 
-    it("should provide DatabaseServiceContext with forSchema and DatabaseHandlerContext with executeRestrictedUnitOfWork", () => {
+    it("should provide DatabaseServiceContext with serviceTx and DatabaseHandlerContext with handlerTx", () => {
       const mockAdapter = createMockAdapter();
 
       const definition = withDatabase(testSchema)(defineFragment("db-frag")).build();
@@ -716,8 +717,8 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
         storage: mockStorage,
       });
 
-      expect(typeof contexts.serviceContext.uow).toBe("function");
-      expect(typeof contexts.handlerContext.uow).toBe("function");
+      expect(typeof contexts.serviceContext.serviceTx).toBe("function");
+      expect(typeof contexts.handlerContext.handlerTx).toBe("function");
     });
   });
 
@@ -845,43 +846,58 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
     });
   });
 
-  // describe("defineService", () => {
-  //   it("getUnitOfWork should be available in defineService", () => {
-  //     const mockAdapter = createMockAdapter();
-
-  //     const definition = withDatabase(testSchema)(defineFragment("db-frag"))
-  //       .withDependencies(() => ({ apiKey: "key" }))
-  //       .providesBaseService(({ deps, defineService }) => {
-  //         expect(deps.apiKey).toBe("key");
-  //         expect(deps.db).toBeDefined();
-  //         expect(defineService).toBeDefined();
-
-  //         return defineService({
-  //           getUsers: function () {
-  //             return typeof this.getUnitOfWork;
-  //           },
-  //         });
-  //       })
-  //       .build();
-
-  //     expect(definition.baseServices).toBeDefined();
-
-  //     // Get implicit deps first
-  //     const deps = definition.dependencies!({
-  //       config: {},
-  //       options: { databaseAdapter: mockAdapter },
-  //     });
-
-  //     const services = definition.baseServices!({
-  //       config: {},
-  //       options: { databaseAdapter: mockAdapter },
-  //       deps,
-  //       serviceDeps: {},
-  //       privateServices: {},
-  //       defineService: (svc) => svc,
-  //     });
-
-  //     expect(services.getUsers()).toBe("function");
-  //   });
-  // });
+  describe("serviceTx hooks propagation", () => {
+    it("should pass hooks to createServiceTxBuilder", () => {
+      const mockAdapter = createMockAdapter();
+
+      // Define hooks type
+      type TestHooks = {
+        onUserCreated: (payload: { email: string }) => void;
+      };
+
+      // Create a fragment with hooks
+      const definition = withDatabase(testSchema)(defineFragment("db-frag-with-hooks"))
+        .provideHooks<TestHooks>(({ defineHook }) => ({
+          onUserCreated: defineHook(function (payload: { email: string }) {
+            // Hook implementation
+            console.log("User created:", payload.email);
+          }),
+        }))
+        .build();
+
+      // Create a mock storage
+      const mockStorage = {
+        getStore: () => ({
+          uow: mockAdapter.createQueryEngine(testSchema, "test").createUnitOfWork(),
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any;
+
+      // Spy on createServiceTxBuilder
+      const createServiceTxBuilderSpy = vi.spyOn(executeUnitOfWork, "createServiceTxBuilder");
+
+      // Get the contexts which includes serviceTx
+      const contexts = definition.createThisContext!({
+        config: {},
+        options: { databaseAdapter: mockAdapter },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        deps: {} as any,
+        storage: mockStorage,
+      });
+
+      // Call serviceTx - this should pass hooks to createServiceTxBuilder
+      contexts.serviceContext.serviceTx(testSchema);
+
+      // Verify createServiceTxBuilder was called with 3 arguments (schema, uow, hooks)
+      expect(createServiceTxBuilderSpy).toHaveBeenCalledOnce();
+      const callArgs = createServiceTxBuilderSpy.mock.calls[0];
+      expect(callArgs).toHaveLength(3);
+      expect(callArgs[0]).toBe(testSchema); // schema
+      expect(callArgs[1]).toBeDefined(); // uow
+      expect(callArgs[2]).toBeDefined(); // hooks - this is what we're testing
+      expect(callArgs[2]).toHaveProperty("onUserCreated");
+
+      createServiceTxBuilderSpy.mockRestore();
+    });
+  });
 });

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,9 +13,11 @@ import {
   type ServiceConstructorFn,
 } from "@fragno-dev/core";
 import {
-  executeRestrictedUnitOfWork,
-  type AwaitedPromisesInObject,
-  type ExecuteRestrictedUnitOfWorkOptions,
+  createServiceTxBuilder,
+  createHandlerTxBuilder,
+  ServiceTxBuilder,
+  HandlerTxBuilder,
+  type ExecuteTxOptions,
 } from "./query/unit-of-work/execute-unit-of-work";
 import {
   prepareHookMutations,
@@ -64,11 +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)
+   * 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.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();
+   * ```
    */
-  uow<TSchema extends AnySchema>(schema: TSchema): TypedUnitOfWork<TSchema, [], unknown, THooks>;
+  serviceTx<TSchema extends AnySchema>(
+    schema: TSchema,
+  ): ServiceTxBuilder<
+    TSchema,
+    readonly [],
+    [],
+    [],
+    unknown,
+    unknown,
+    false,
+    false,
+    false,
+    false,
+    THooks
+  >;
 };
 
 /**
@@ -76,49 +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 };
-   * });
+   * const result = await this.handlerTx()
+   *   .withServiceCalls(() => [userService.getUser(id)])
+   *   .mutate(({ forSchema, idempotencyKey, currentAttempt, serviceIntermediateResult }) => {
+   *     return forSchema(ordersSchema).create("orders", { ... });
+   *   })
+   *   .transform(({ mutateResult, serviceResult }) => ({ ... }))
+   *   .execute();
    * ```
    */
-  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>>;
+  handlerTx(
+    options?: Omit<ExecuteTxOptions, "createUnitOfWork">,
+  ): HandlerTxBuilder<readonly [], [], [], unknown, unknown, false, false, false, false, THooks>;
 };
 
 /**
@@ -415,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);
    *   }),
    * }))
@@ -647,39 +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 serviceContext: DatabaseServiceContext<THooks> = {
-        uow: forSchema,
+        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" | "onBeforeMutate" | "onSuccess"
-        >,
-      ): Promise<AwaitedPromisesInObject<TResult>> {
+      // Builder API: handlerTx using createHandlerTxBuilder
+      function handlerTx(execOptions?: Omit<ExecuteTxOptions, "createUnitOfWork">) {
         const currentStorage = storage.getStore();
         if (!currentStorage) {
           throw new Error(
@@ -687,39 +674,42 @@ 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);
-        };
-
-        return executeRestrictedUnitOfWork(wrappedCallback, {
+        const userOnBeforeMutate = execOptions?.onBeforeMutate;
+        const userOnAfterMutate = execOptions?.onAfterMutate;
+
+        return createHandlerTxBuilder<THooks>({
           ...execOptions,
           createUnitOfWork: () => {
             currentStorage.uow.reset();
-            // Register internal schema for hook mutations
             if (hooksConfig) {
               currentStorage.uow.registerSchema(
                 hooksConfig.internalFragment.$internal.deps.schema,
                 hooksConfig.internalFragment.$internal.deps.namespace,
               );
             }
-            return currentStorage.uow as UnitOfWork;
+            return currentStorage.uow;
+          },
+          onBeforeMutate: (uow) => {
+            if (hooksConfig) {
+              prepareHookMutations(uow, hooksConfig);
+            }
+            if (userOnBeforeMutate) {
+              userOnBeforeMutate(uow);
+            }
+          },
+          onAfterMutate: async (uow) => {
+            if (hooksConfig) {
+              await processHooks(hooksConfig);
+            }
+            if (userOnAfterMutate) {
+              await userOnAfterMutate(uow);
+            }
           },
-          onBeforeMutate: hooksConfig ? (uow) => prepareHookMutations(uow, hooksConfig) : undefined,
-          onSuccess: hooksConfig ? () => processHooks(hooksConfig) : undefined,
         });
       }
 
       const handlerContext: DatabaseHandlerContext<THooks> = {
-        uow,
+        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();
             },
           }),
         )