@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res

@@ -0,0 +1,191 @@
+// Unit tests for OutboundTranslationSlice_Callback — tests collect and translate phases directly.
+
+open JestGlobals
+open OutboundTranslationSliceFixtures
+
+module SendTrackingEmailTranslation = {
+  let collect = SendTrackingEmailSpec.collect
+  let translate = SendTrackingEmailSpec.translate
+  let moduleUrl = SendTrackingEmailSpec.moduleUrl
+}
+module ProcessPaymentTranslation = {
+  let collect = ProcessPaymentSpec.collect
+  let translate = ProcessPaymentSpec.translate
+  let moduleUrl = ProcessPaymentSpec.moduleUrl
+}
+module FireForgetCallback = ReventlessCore.OutboundTranslationSlice_Callback.Make(
+  SendTrackingEmailSpec,
+  SendTrackingEmailTranslation,
+)
+module CommandBackCallback = ReventlessCore.OutboundTranslationSlice_Callback.Make(
+  ProcessPaymentSpec,
+  ProcessPaymentTranslation,
+)
+
+open ReventlessCore.OutboundTranslationSlice_Callback
+
+describe("OutboundTranslationSlice Callback", () => {
+  let _ = beforeEach(() => {
+    FireForgetCallback.todoItems->Dict.keysToArray->Array.forEach(k => FireForgetCallback.todoItems->Dict.delete(k))
+    CommandBackCallback.todoItems->Dict.keysToArray->Array.forEach(k => CommandBackCallback.todoItems->Dict.delete(k))
+    // Reset the translate function to its default
+    ProcessPaymentSpec.translateFn :=
+      (async (id, _item) => Ok(Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id})))))
+  })
+
+  describe("Phase 1 — collect", () => {
+    testPromise("OrderShipped event creates a pending outbound item", async () => {
+      FireForgetCallback.phase1([OrderShipped({orderId: "ord-1", email: "test@example.com"})])
+      let items = FireForgetCallback.todoItems
+      expect(items->Dict.toArray->Array.length)->toBe(1)
+      let row = items->Dict.get("ord-1")
+      expect(row->Option.isSome)->toBe(true)
+      let r = row->Option.getOrThrow
+      expect(r.status)->toBe(Pending)
+      expect(r.retryCount)->toBe(0)
+    })
+
+    testPromise("duplicate event does not create a second item (idempotent)", async () => {
+      FireForgetCallback.phase1([OrderShipped({orderId: "ord-1", email: "test@example.com"})])
+      FireForgetCallback.phase1([OrderShipped({orderId: "ord-1", email: "other@example.com"})])
+      let items = FireForgetCallback.todoItems
+      expect(items->Dict.toArray->Array.length)->toBe(1)
+    })
+
+    testPromise("multiple different events create multiple items", async () => {
+      FireForgetCallback.phase1([
+        OrderShipped({orderId: "ord-1", email: "a@example.com"}),
+        OrderShipped({orderId: "ord-2", email: "b@example.com"}),
+      ])
+      let items = FireForgetCallback.todoItems
+      expect(items->Dict.toArray->Array.length)->toBe(2)
+    })
+
+  })
+
+  describe("Phase 2 — translate (fire-and-forget)", () => {
+    testPromise("Ok(None) marks item as Completed, no command published", async () => {
+      FireForgetCallback.phase1([OrderShipped({orderId: "ord-1", email: "test@example.com"})])
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await FireForgetCallback.phase2(mockPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+      let row = FireForgetCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Completed)
+    })
+
+    testPromise("empty TODO list produces no commands", async () => {
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await FireForgetCallback.phase2(mockPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("Phase 2 — translate (command-back)", () => {
+    testPromise("Ok(Some(...)) marks item as Completed and publishes command", async () => {
+      CommandBackCallback.phase1([PaymentReceived({orderId: "ord-1", amount: 50.0})])
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := Array.concat(publishedCommands.contents, cmds)
+      }
+      await CommandBackCallback.phase2(mockPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(1)
+      let cmd = publishedCommands.contents->Array.getUnsafe(0)
+      expect(cmd.id)->toBe("ord-1")
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Completed)
+    })
+
+    testPromise("Error marks item as Failed with incremented retryCount", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway timeout"))
+
+      CommandBackCallback.phase1([PaymentReceived({orderId: "ord-1", amount: 50.0})])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+      await CommandBackCallback.phase2(mockPublish)
+
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Failed)
+      expect(row.retryCount)->toBe(1)
+    })
+
+    testPromise("failed items with retryCount < maxRetries are retried", async () => {
+      // First attempt fails
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("timeout"))
+      CommandBackCallback.phase1([PaymentReceived({orderId: "ord-1", amount: 50.0})])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+      await CommandBackCallback.phase2(mockPublish)
+      let row1 = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row1.retryCount)->toBe(1)
+
+      // Second attempt succeeds
+      ProcessPaymentSpec.translateFn :=
+        (async (id, _item) => Ok(Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id})))))
+      let publishedCommands = ref([])
+      let successPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await CommandBackCallback.phase2(successPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(1)
+      let row2 = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row2.status)->toBe(Completed)
+    })
+
+    testPromise("failed items beyond maxRetries are not retried", async () => {
+      // ProcessPaymentSpec.maxRetries = 2, so after 2 failures it should stop
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("timeout"))
+      CommandBackCallback.phase1([PaymentReceived({orderId: "ord-1", amount: 50.0})])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+
+      // Fail twice
+      await CommandBackCallback.phase2(mockPublish)
+      await CommandBackCallback.phase2(mockPublish)
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.retryCount)->toBe(2)
+
+      // Third attempt should not be tried
+      let publishedCommands = ref([])
+      let trackPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await CommandBackCallback.phase2(trackPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+      let row2 = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      // retryCount should still be 2 — not retried
+      expect(row2.retryCount)->toBe(2)
+    })
+
+    testPromise("individual item failure does not affect other items", async () => {
+      let callCount = ref(0)
+      ProcessPaymentSpec.translateFn := (async (id, _item) => {
+        callCount := callCount.contents + 1
+        if callCount.contents == 1 {
+          Error("first item fails")
+        } else {
+          Ok(Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
+        }
+      })
+
+      CommandBackCallback.phase1([
+        PaymentReceived({orderId: "ord-1", amount: 50.0}),
+        PaymentReceived({orderId: "ord-2", amount: 75.0}),
+      ])
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := Array.concat(publishedCommands.contents, cmds)
+      }
+      await CommandBackCallback.phase2(mockPublish)
+
+      // ord-1 should be Failed, ord-2 should be Completed
+      let row1 = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row1.status)->toBe(Failed)
+      let row2 = CommandBackCallback.todoItems->Dict.get("ord-2")->Option.getOrThrow
+      expect(row2.status)->toBe(Completed)
+      expect(publishedCommands.contents->Array.length)->toBe(1)
+    })
+  })
+})

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res.mjs

@@ -0,0 +1,297 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as OutboundTranslationSliceFixtures$ReventlessLocal from "./OutboundTranslationSliceFixtures.res.mjs";
+import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
+
+let collect = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.collect;
+
+let translate = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.translate;
+
+let moduleUrl = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.moduleUrl;
+
+let SendTrackingEmailTranslation = {
+  collect: collect,
+  translate: translate,
+  moduleUrl: moduleUrl
+};
+
+let collect$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.collect;
+
+let translate$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translate;
+
+let moduleUrl$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.moduleUrl;
+
+let ProcessPaymentTranslation = {
+  collect: collect$1,
+  translate: translate$1,
+  moduleUrl: moduleUrl$1
+};
+
+let FireForgetCallback = OutboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.name,
+  moduleUrl: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.moduleUrl,
+  consumedEventSchema: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.consumedEventSchema,
+  outboundItemSchema: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.outboundItemSchema,
+  inboundCommandSchema: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.inboundCommandSchema,
+  maxRetries: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.maxRetries,
+  heartbeatInterval: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.heartbeatInterval,
+  targetName: OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.targetName
+})(SendTrackingEmailTranslation);
+
+let CommandBackCallback = OutboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.name,
+  moduleUrl: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.moduleUrl,
+  consumedEventSchema: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.consumedEventSchema,
+  outboundItemSchema: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.outboundItemSchema,
+  inboundCommandSchema: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.inboundCommandSchema,
+  maxRetries: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.maxRetries,
+  heartbeatInterval: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.heartbeatInterval,
+  targetName: OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.targetName
+})(ProcessPaymentTranslation);
+
+globalThis.describe("OutboundTranslationSlice Callback", () => {
+  globalThis.beforeEach(() => {
+    Object.keys(FireForgetCallback.todoItems).forEach(k => Stdlib_Dict.$$delete(FireForgetCallback.todoItems, k));
+    Object.keys(CommandBackCallback.todoItems).forEach(k => Stdlib_Dict.$$delete(CommandBackCallback.todoItems, k));
+    OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (id, _item) => ({
+      TAG: "Ok",
+      _0: [
+        id,
+        {
+          TAG: "ConfirmPayment",
+          orderId: id
+        }
+      ]
+    });
+  });
+  globalThis.describe("Phase 1 — collect", () => {
+    globalThis.test("OrderShipped event creates a pending outbound item", async () => {
+      FireForgetCallback.phase1([{
+          TAG: "OrderShipped",
+          orderId: "ord-1",
+          email: "test@example.com"
+        }]);
+      let items = FireForgetCallback.todoItems;
+      globalThis.expect(Object.entries(items).length).toBe(1);
+      let row = items["ord-1"];
+      globalThis.expect(Stdlib_Option.isSome(row)).toBe(true);
+      let r = Stdlib_Option.getOrThrow(row, undefined);
+      globalThis.expect(r.status).toBe("Pending");
+      globalThis.expect(r.retryCount).toBe(0);
+    });
+    globalThis.test("duplicate event does not create a second item (idempotent)", async () => {
+      FireForgetCallback.phase1([{
+          TAG: "OrderShipped",
+          orderId: "ord-1",
+          email: "test@example.com"
+        }]);
+      FireForgetCallback.phase1([{
+          TAG: "OrderShipped",
+          orderId: "ord-1",
+          email: "other@example.com"
+        }]);
+      globalThis.expect(Object.entries(FireForgetCallback.todoItems).length).toBe(1);
+    });
+    globalThis.test("multiple different events create multiple items", async () => {
+      FireForgetCallback.phase1([
+        {
+          TAG: "OrderShipped",
+          orderId: "ord-1",
+          email: "a@example.com"
+        },
+        {
+          TAG: "OrderShipped",
+          orderId: "ord-2",
+          email: "b@example.com"
+        }
+      ]);
+      globalThis.expect(Object.entries(FireForgetCallback.todoItems).length).toBe(2);
+    });
+  });
+  globalThis.describe("Phase 2 — translate (fire-and-forget)", () => {
+    globalThis.test("Ok(None) marks item as Completed, no command published", async () => {
+      FireForgetCallback.phase1([{
+          TAG: "OrderShipped",
+          orderId: "ord-1",
+          email: "test@example.com"
+        }]);
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      await FireForgetCallback.phase2(mockPublish);
+      globalThis.expect(publishedCommands.contents.length).toBe(0);
+      let row = Stdlib_Option.getOrThrow(FireForgetCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.status).toBe("Completed");
+    });
+    globalThis.test("empty TODO list produces no commands", async () => {
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      await FireForgetCallback.phase2(mockPublish);
+      globalThis.expect(publishedCommands.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("Phase 2 — translate (command-back)", () => {
+    globalThis.test("Ok(Some(...)) marks item as Completed and publishes command", async () => {
+      CommandBackCallback.phase1([{
+          TAG: "PaymentReceived",
+          orderId: "ord-1",
+          amount: 50.0
+        }]);
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = publishedCommands.contents.concat(cmds);
+      };
+      await CommandBackCallback.phase2(mockPublish);
+      globalThis.expect(publishedCommands.contents.length).toBe(1);
+      let cmd = publishedCommands.contents[0];
+      globalThis.expect(cmd.id).toBe("ord-1");
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.status).toBe("Completed");
+    });
+    globalThis.test("Error marks item as Failed with incremented retryCount", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway timeout"
+      });
+      CommandBackCallback.phase1([{
+          TAG: "PaymentReceived",
+          orderId: "ord-1",
+          amount: 50.0
+        }]);
+      let mockPublish = async _cmds => {};
+      await CommandBackCallback.phase2(mockPublish);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.status).toBe("Failed");
+      globalThis.expect(row.retryCount).toBe(1);
+    });
+    globalThis.test("failed items with retryCount < maxRetries are retried", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "timeout"
+      });
+      CommandBackCallback.phase1([{
+          TAG: "PaymentReceived",
+          orderId: "ord-1",
+          amount: 50.0
+        }]);
+      let mockPublish = async _cmds => {};
+      await CommandBackCallback.phase2(mockPublish);
+      let row1 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row1.retryCount).toBe(1);
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (id, _item) => ({
+        TAG: "Ok",
+        _0: [
+          id,
+          {
+            TAG: "ConfirmPayment",
+            orderId: id
+          }
+        ]
+      });
+      let publishedCommands = {
+        contents: []
+      };
+      let successPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      await CommandBackCallback.phase2(successPublish);
+      globalThis.expect(publishedCommands.contents.length).toBe(1);
+      let row2 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row2.status).toBe("Completed");
+    });
+    globalThis.test("failed items beyond maxRetries are not retried", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "timeout"
+      });
+      CommandBackCallback.phase1([{
+          TAG: "PaymentReceived",
+          orderId: "ord-1",
+          amount: 50.0
+        }]);
+      let mockPublish = async _cmds => {};
+      await CommandBackCallback.phase2(mockPublish);
+      await CommandBackCallback.phase2(mockPublish);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.retryCount).toBe(2);
+      let publishedCommands = {
+        contents: []
+      };
+      let trackPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      await CommandBackCallback.phase2(trackPublish);
+      globalThis.expect(publishedCommands.contents.length).toBe(0);
+      let row2 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row2.retryCount).toBe(2);
+    });
+    globalThis.test("individual item failure does not affect other items", async () => {
+      let callCount = {
+        contents: 0
+      };
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (id, _item) => {
+        callCount.contents = callCount.contents + 1 | 0;
+        if (callCount.contents === 1) {
+          return {
+            TAG: "Error",
+            _0: "first item fails"
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [
+              id,
+              {
+                TAG: "ConfirmPayment",
+                orderId: id
+              }
+            ]
+          };
+        }
+      };
+      CommandBackCallback.phase1([
+        {
+          TAG: "PaymentReceived",
+          orderId: "ord-1",
+          amount: 50.0
+        },
+        {
+          TAG: "PaymentReceived",
+          orderId: "ord-2",
+          amount: 75.0
+        }
+      ]);
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = publishedCommands.contents.concat(cmds);
+      };
+      await CommandBackCallback.phase2(mockPublish);
+      let row1 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row1.status).toBe("Failed");
+      let row2 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-2"], undefined);
+      globalThis.expect(row2.status).toBe("Completed");
+      globalThis.expect(publishedCommands.contents.length).toBe(1);
+    });
+  });
+});
+
+export {
+  SendTrackingEmailTranslation,
+  ProcessPaymentTranslation,
+  FireForgetCallback,
+  CommandBackCallback,
+}
+/* FireForgetCallback Not a pure module */

package/tests/components/outboundtranslationslice/OutboundTranslationSliceFixtures.res

@@ -0,0 +1,78 @@
+// Test fixtures for OutboundTranslationSlice callback tests.
+
+// ─────────────────────────────────────────────────────────────
+// Minimal DcbEventLog spec
+// ─────────────────────────────────────────────────────────────
+
+module OrderEventLog = {
+  let moduleUrl: string = %raw(`import.meta.url`)
+  @schema
+  type event =
+    | OrderShipped({orderId: @s.matches(Reventless.DcbTag.string) string, email: string})
+    | PaymentReceived({orderId: @s.matches(Reventless.DcbTag.string) string, amount: float})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Fire-and-forget spec — translate returns Ok(None)
+// ─────────────────────────────────────────────────────────────
+
+module SendTrackingEmailSpec = {
+  let name = "SendTrackingEmail"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type consumedEvent =
+    | OrderShipped({orderId: string, email: string})
+
+  @schema
+  type outboundItem = {orderId: string, email: string}
+
+  @schema
+  type inboundCommand = unit
+
+  let collect = event =>
+    switch event {
+    | OrderShipped({orderId, email}) => [(orderId, {orderId, email})]
+    }
+
+  let translate = async (_id, _item) => Ok(None)
+
+  let maxRetries = 3
+  let heartbeatInterval = 60
+  let targetName = None
+}
+
+// ─────────────────────────────────────────────────────────────
+// Command-back spec — translate returns Ok(Some(...))
+// ─────────────────────────────────────────────────────────────
+
+module ProcessPaymentSpec = {
+  let name = "ProcessPayment"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type consumedEvent =
+    | PaymentReceived({orderId: string, amount: float})
+
+  @schema
+  type outboundItem = {orderId: string, amount: float}
+
+  @schema
+  type inboundCommand = ConfirmPayment({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  let collect = event =>
+    switch event {
+    | PaymentReceived({orderId, amount}) => [(orderId, {orderId, amount})]
+    }
+
+  // Simulate calling external payment gateway, then return a command
+  let translateFn: ref<(string, outboundItem) => promise<result<option<(string, inboundCommand)>, string>>> = ref(
+    async (id, _item) => Ok(Some((id, ConfirmPayment({orderId: id}))))
+  )
+
+  let translate = (id, item) => translateFn.contents(id, item)
+
+  let maxRetries = 2
+  let heartbeatInterval = 30
+  let targetName = Some("ConfirmPayment")
+}