@fragno-dev/db 0.2.0 → 0.2.2

package/src/fragments/internal-fragment.test.ts

@@ -49,11 +49,12 @@ describe("Internal Fragment", () => {
 
   it("should get undefined for non-existent key", async () => {
     const result = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
-        await executeRetrieve();
-        return await valuePromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key")] as const,
+        )
+        .transform(({ serviceResult: [value] }) => value)
+        .execute();
     });
 
     expect(result).toBeUndefined();
@@ -61,23 +62,20 @@ describe("Internal Fragment", () => {
 
   it("should set and get a value", async () => {
     await fragment.inContext(async function () {
-      return await this.uow(async ({ executeMutate }) => {
-        const setPromise = fragment.services.settingsService.set(
-          SETTINGS_NAMESPACE,
-          "test-key",
-          "test-value",
-        );
-        await executeMutate();
-        await setPromise;
-      });
+      await this.handlerTx()
+        .withServiceCalls(() => [
+          fragment.services.settingsService.set(SETTINGS_NAMESPACE, "test-key", "test-value"),
+        ])
+        .execute();
     });
 
     const result = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
-        await executeRetrieve();
-        return await valuePromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key")] as const,
+        )
+        .transform(({ serviceResult: [value] }) => value)
+        .execute();
     });
 
     expect(result).toMatchObject({
@@ -88,23 +86,27 @@ describe("Internal Fragment", () => {
 
   it("should update an existing value", async () => {
     await fragment.inContext(async function () {
-      return await this.uow(async ({ executeMutate }) => {
-        const setPromise = fragment.services.settingsService.set(
-          SETTINGS_NAMESPACE,
-          "test-key",
-          "updated-value",
-        );
-        await executeMutate();
-        await setPromise;
-      });
+      await this.handlerTx()
+        .withServiceCalls(
+          () =>
+            [
+              fragment.services.settingsService.set(
+                SETTINGS_NAMESPACE,
+                "test-key",
+                "updated-value",
+              ),
+            ] as const,
+        )
+        .execute();
     });
 
     const result = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
-        await executeRetrieve();
-        return await valuePromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key")] as const,
+        )
+        .transform(({ serviceResult: [value] }) => value)
+        .execute();
     });
 
     expect(result).toMatchObject({
@@ -116,31 +118,31 @@ describe("Internal Fragment", () => {
   it("should delete a value", async () => {
     // First get the ID
     const setting = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
-        await executeRetrieve();
-        return await valuePromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key")] as const,
+        )
+        .transform(({ serviceResult: [value] }) => value)
+        .execute();
     });
 
     expect(setting).toBeDefined();
 
     // Delete it
     await fragment.inContext(async function () {
-      return await this.uow(async ({ executeMutate }) => {
-        const deletePromise = fragment.services.settingsService.delete(setting!.id);
-        await executeMutate();
-        await deletePromise;
-      });
+      await this.handlerTx()
+        .withServiceCalls(() => [fragment.services.settingsService.delete(setting!.id)] as const)
+        .execute();
     });
 
     // Verify it's gone
     const result = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
-        await executeRetrieve();
-        return await valuePromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key")] as const,
+        )
+        .transform(({ serviceResult: [value] }) => value)
+        .execute();
     });
 
     expect(result).toBeUndefined();
@@ -188,42 +190,44 @@ describe("Hook Service", () => {
     const nonce = "test-nonce-1";
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onTest",
-          payload: { test: "data" },
-          status: "pending",
-          attempts: 0,
-          maxAttempts: 5,
-          lastAttemptAt: null,
-          nextRetryAt: null,
-          error: null,
-          nonce,
-        });
-        uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onTest",
-          payload: { test: "already-completed-data" },
-          status: "completed",
-          attempts: 0,
-          maxAttempts: 5,
-          lastAttemptAt: null,
-          nextRetryAt: null,
-          error: null,
-          nonce,
-        });
-        await executeMutate();
-      });
+      await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onTest",
+            payload: { test: "data" },
+            status: "pending",
+            attempts: 0,
+            maxAttempts: 5,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce,
+          });
+          uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onTest",
+            payload: { test: "already-completed-data" },
+            status: "completed",
+            attempts: 0,
+            maxAttempts: 5,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce,
+          });
+        })
+        .execute();
     });
 
     const events = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
-        await executeRetrieve();
-        return await eventsPromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.hookService.getPendingHookEvents("test-namespace")] as const,
+        )
+        .transform(({ serviceResult: [result] }) => result)
+        .execute();
     });
 
     expect(events).toHaveLength(1);
@@ -232,7 +236,7 @@ describe("Hook Service", () => {
       payload: { test: "data" },
       attempts: 0,
       maxAttempts: 5,
-      nonce,
+      idempotencyKey: nonce,
     });
   });
 
@@ -241,41 +245,36 @@ describe("Hook Service", () => {
     let eventId: FragnoId;
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        eventId = uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onComplete",
-          payload: { test: "data" },
-          status: "pending",
-          attempts: 0,
-          maxAttempts: 5,
-          lastAttemptAt: null,
-          nextRetryAt: null,
-          error: null,
-          nonce,
-        });
-        await executeMutate();
-      });
+      await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          eventId = uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onComplete",
+            payload: { test: "data" },
+            status: "pending",
+            attempts: 0,
+            maxAttempts: 5,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce,
+          });
+        })
+        .execute();
     });
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ executeMutate }) => {
-        fragment.services.hookService.markHookCompleted(eventId);
-        await executeMutate();
-      });
+      await this.handlerTx()
+        .withServiceCalls(() => [fragment.services.hookService.markHookCompleted(eventId)] as const)
+        .execute();
     });
 
     const result = await fragment.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(() => [fragment.services.hookService.getHookById(eventId)] as const)
+        .transform(({ serviceResult: [event] }) => event)
+        .execute();
     });
 
     expect(result).toBeDefined();
@@ -288,41 +287,38 @@ describe("Hook Service", () => {
     let eventId: FragnoId;
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        eventId = uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onProcess",
-          payload: { test: "data" },
-          status: "pending",
-          attempts: 0,
-          maxAttempts: 5,
-          lastAttemptAt: null,
-          nextRetryAt: null,
-          error: null,
-          nonce,
-        });
-        await executeMutate();
-      });
+      return this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          eventId = uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onProcess",
+            payload: { test: "data" },
+            status: "pending",
+            attempts: 0,
+            maxAttempts: 5,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce,
+          });
+        })
+        .execute();
     });
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ executeMutate }) => {
-        fragment.services.hookService.markHookProcessing(eventId);
-        await executeMutate();
-      });
+      await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.hookService.markHookProcessing(eventId)] as const,
+        )
+        .execute();
     });
 
     const result = await fragment.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(() => [fragment.services.hookService.getHookById(eventId)] as const)
+        .transform(({ serviceResult: [event] }) => event)
+        .execute();
     });
 
     expect(result).toBeDefined();
@@ -335,43 +331,44 @@ describe("Hook Service", () => {
     let eventId: FragnoId;
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        eventId = uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onFail",
-          payload: { test: "data" },
-          status: "pending",
-          attempts: 0,
-          maxAttempts: 5,
-          lastAttemptAt: null,
-          nextRetryAt: null,
-          error: null,
-          nonce,
-        });
-        await executeMutate();
-      });
+      const createdId = await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          return uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onFail",
+            payload: { test: "data" },
+            status: "pending",
+            attempts: 0,
+            maxAttempts: 5,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce,
+          });
+        })
+        .execute();
+      eventId = createdId;
     });
 
     const retryPolicy = new ExponentialBackoffRetryPolicy({ maxRetries: 3 });
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ executeMutate }) => {
-        fragment.services.hookService.markHookFailed(eventId, "Test error", 0, retryPolicy);
-        await executeMutate();
-      });
+      await this.handlerTx()
+        .withServiceCalls(
+          () =>
+            [
+              fragment.services.hookService.markHookFailed(eventId, "Test error", 0, retryPolicy),
+            ] as const,
+        )
+        .execute();
     });
 
     const result = await fragment.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(() => [fragment.services.hookService.getHookById(eventId)] as const)
+        .transform(({ serviceResult: [event] }) => event)
+        .execute();
     });
 
     expect(result).toBeDefined();
@@ -387,48 +384,49 @@ describe("Hook Service", () => {
     let eventId: FragnoId;
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        eventId = uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onMaxFail",
-          payload: { test: "data" },
-          status: "pending",
-          attempts: 0,
-          maxAttempts: 1,
-          lastAttemptAt: null,
-          nextRetryAt: null,
-          error: null,
-          nonce,
-        });
-        await executeMutate();
-      });
+      const createdId = await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          return uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onMaxFail",
+            payload: { test: "data" },
+            status: "pending",
+            attempts: 0,
+            maxAttempts: 1,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce,
+          });
+        })
+        .execute();
+      eventId = createdId;
     });
 
     const retryPolicy = new NoRetryPolicy();
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ executeMutate }) => {
-        fragment.services.hookService.markHookFailed(
-          eventId,
-          "Max attempts reached",
-          0,
-          retryPolicy,
-        );
-        await executeMutate();
-      });
+      await this.handlerTx()
+        .withServiceCalls(
+          () =>
+            [
+              fragment.services.hookService.markHookFailed(
+                eventId,
+                "Max attempts reached",
+                0,
+                retryPolicy,
+              ),
+            ] as const,
+        )
+        .execute();
     });
 
     const result = await fragment.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(() => [fragment.services.hookService.getHookById(eventId)] as const)
+        .transform(({ serviceResult: [event] }) => event)
+        .execute();
     });
 
     expect(result).toBeDefined();
@@ -444,30 +442,33 @@ describe("Hook Service", () => {
     const pastTime = new Date(Date.now() - 10000);
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        eventId = uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onStale",
-          payload: { test: "stale" },
-          status: "pending",
-          attempts: 1,
-          maxAttempts: 5,
-          lastAttemptAt: pastTime,
-          nextRetryAt: pastTime,
-          error: "Previous error",
-          nonce,
-        });
-        await executeMutate();
-      });
+      const createdId = await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          return uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onStale",
+            payload: { test: "stale" },
+            status: "pending",
+            attempts: 1,
+            maxAttempts: 5,
+            lastAttemptAt: pastTime,
+            nextRetryAt: pastTime,
+            error: "Previous error",
+            nonce,
+          });
+        })
+        .execute();
+      eventId = createdId;
     });
 
     const events = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
-        await executeRetrieve();
-        return await eventsPromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.hookService.getPendingHookEvents("test-namespace")] as const,
+        )
+        .transform(({ serviceResult: [result] }) => result)
+        .execute();
     });
 
     const staleEvent = events.find((e) => e.id.externalId === eventId.externalId);
@@ -480,30 +481,32 @@ describe("Hook Service", () => {
     const nonce = "test-nonce-7";
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        uow.create("fragno_hooks", {
-          namespace: "other-namespace",
-          hookName: "onOther",
-          payload: { test: "other" },
-          status: "pending",
-          attempts: 0,
-          maxAttempts: 5,
-          lastAttemptAt: null,
-          nextRetryAt: null,
-          error: null,
-          nonce,
-        });
-        await executeMutate();
-      });
+      await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          uow.create("fragno_hooks", {
+            namespace: "other-namespace",
+            hookName: "onOther",
+            payload: { test: "other" },
+            status: "pending",
+            attempts: 0,
+            maxAttempts: 5,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce,
+          });
+        })
+        .execute();
     });
 
     const events = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
-        await executeRetrieve();
-        return await eventsPromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.hookService.getPendingHookEvents("test-namespace")] as const,
+        )
+        .transform(({ serviceResult: [result] }) => result)
+        .execute();
     });
 
     const otherEvent = events.find((e) => e.hookName === "onOther");
@@ -517,30 +520,33 @@ describe("Hook Service", () => {
     const futureTime = new Date(Date.now() + 60000);
 
     await fragment.inContext(async function () {
-      return await this.uow(async ({ forSchema, executeMutate }) => {
-        const uow = forSchema(internalSchema);
-        eventId = uow.create("fragno_hooks", {
-          namespace: "test-namespace",
-          hookName: "onFuture",
-          payload: { test: "future" },
-          status: "pending",
-          attempts: 1,
-          maxAttempts: 5,
-          lastAttemptAt: new Date(),
-          nextRetryAt: futureTime,
-          error: "Previous error",
-          nonce,
-        });
-        await executeMutate();
-      });
+      const createdId = await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          return uow.create("fragno_hooks", {
+            namespace: "test-namespace",
+            hookName: "onFuture",
+            payload: { test: "future" },
+            status: "pending",
+            attempts: 1,
+            maxAttempts: 5,
+            lastAttemptAt: new Date(),
+            nextRetryAt: futureTime,
+            error: "Previous error",
+            nonce,
+          });
+        })
+        .execute();
+      eventId = createdId;
     });
 
     const events = await fragment.inContext(async function () {
-      return await this.uow(async ({ executeRetrieve }) => {
-        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
-        await executeRetrieve();
-        return await eventsPromise;
-      });
+      return await this.handlerTx()
+        .withServiceCalls(
+          () => [fragment.services.hookService.getPendingHookEvents("test-namespace")] as const,
+        )
+        .transform(({ serviceResult: [result] }) => result)
+        .execute();
     });
 
     const futureEvent = events.find((e) => e.id.externalId === eventId.externalId);