@reventlessdev/reventless-local 3.0.0-alpha.233 → 3.0.0-alpha.235

package/tests/components/outboundtranslationslice/OutboundTranslationSliceCallbackTest.res

@@ -6,11 +6,13 @@ open OutboundTranslationSliceFixtures
 module SendTrackingEmailTranslation = {
   let collect = SendTrackingEmailSpec.collect
   let translate = SendTrackingEmailSpec.translate
+  let onExhausted = SendTrackingEmailSpec.onExhausted
   let moduleUrl = SendTrackingEmailSpec.moduleUrl
 }
 module ProcessPaymentTranslation = {
   let collect = ProcessPaymentSpec.collect
   let translate = ProcessPaymentSpec.translate
+  let onExhausted = ProcessPaymentSpec.onExhausted
   let moduleUrl = ProcessPaymentSpec.moduleUrl
 }
 module FireForgetCallback = ReventlessCore.OutboundTranslationSlice_Callback.Make(
@@ -31,6 +33,8 @@ describe("OutboundTranslationSlice Callback", () => {
     // Reset the translate function to its default
     ProcessPaymentSpec.translateFn :=
       (async (id, _item) => Ok(Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id})))))
+    // Default is a slice with nothing to say when its budget runs out.
+    ProcessPaymentSpec.onExhaustedFn := ((_id, _item, _lastError) => None)
   })
 
   describe("Phase 1 — collect", () => {
@@ -157,11 +161,17 @@ describe("OutboundTranslationSlice Callback", () => {
       CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
       let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
 
-      // Fail twice
+      // Fail once — still retriable, and the status says so.
       await CommandBackCallback.phase2(mockPublish, ~capabilities=Reventless.Capabilities.none)
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Failed)
+
+      // The second failure spends the budget, and is marked at that moment rather
+      // than by falling out of the next pass's filter.
       await CommandBackCallback.phase2(mockPublish, ~capabilities=Reventless.Capabilities.none)
       let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
       expect(row.retryCount)->toBe(2)
+      expect(row.status)->toBe(Abandoned)
 
       // Third attempt should not be tried
       let publishedCommands = ref([])
@@ -173,6 +183,130 @@ describe("OutboundTranslationSlice Callback", () => {
       let row2 = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
       // retryCount should still be 2 — not retried
       expect(row2.retryCount)->toBe(2)
+      expect(row2.status)->toBe(Abandoned)
+    })
+
+    // What an older build wrote, and what a Spec that lowers maxRetries leaves
+    // behind: Failed at the ceiling, a status promising a retry no pass will make.
+    testPromise("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("timeout"))
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      CommandBackCallback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 2})
+
+      await CommandBackCallback.phase2(
+        async _cmds => (),
+        ~capabilities=Reventless.Capabilities.none,
+      )
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
+    })
+
+    testPromise("the last error survives the transition to Abandoned", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Abandoned)
+      expect(row.lastError)->toEqual(Some("gateway down"))
+    })
+
+    testPromise("the row carries the ceiling its count is racing", async () => {
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries)
+      ->toEqual(Some(ProcessPaymentSpec.maxRetries))
+    })
+
+    // Abandonment is an outcome, and a slice that has one to report gets to say
+    // so — the row going quiet is otherwise the only trace.
+    testPromise("a slice that answers onExhausted has its command published", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
+
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let published = ref([])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+        published := Array.concat(published.contents, cmds)
+
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      expect(published.contents->Array.length)->toBe(0) // still retriable
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
+      expect(published.contents->Array.length)->toBe(1)
+      expect((published.contents->Array.getUnsafe(0)).id)->toBe("ord-1")
+      // The target's name, not the slice's — the same rule the success path follows.
+      expect((published.contents->Array.getUnsafe(0)).meta.service)->toBe("ConfirmPayment")
+    })
+
+    testPromise("the hook is handed the error that ended it", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      let seen = ref(None)
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((_id, _item, lastError) => {
+          seen := lastError
+          None
+        })
+
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      expect(seen.contents)->toEqual(Some("gateway down"))
+    })
+
+    testPromise("a silent slice publishes nothing, and the row is still Abandoned", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      // onExhaustedFn stays at its default None (reset in beforeEach).
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let published = ref([])
+      let publish: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+        published := Array.concat(published.contents, cmds)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(publish, ~capabilities=Reventless.Capabilities.none)
+      expect(published.contents->Array.length)->toBe(0)
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
+    })
+
+    // The budget is what ran out, so there is nothing left to retry with — a row
+    // must not fall back to Failed and re-enter the sweep on a publish error.
+    testPromise("a failed announcement leaves the row Abandoned", async () => {
+      ProcessPaymentSpec.translateFn := (async (_id, _item) => Error("gateway down"))
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
+
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let failOnAbandonment: ReventlessInfra.CommandTopic.publishJsons = async _cmds =>
+        JsError.throwWithMessage("topic unavailable")
+      await CommandBackCallback.phase2(failOnAbandonment, ~capabilities=Reventless.Capabilities.none)
+      await CommandBackCallback.phase2(failOnAbandonment, ~capabilities=Reventless.Capabilities.none)
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Abandoned)
+      expect(row.retryCount)->toBe(2)
+    })
+
+    // A row an older build stranded reaches the hook too — it is being abandoned
+    // now, as far as anything downstream is concerned.
+    testPromise("a stranded row announces when it is normalised", async () => {
+      ProcessPaymentSpec.onExhaustedFn :=
+        ((id, _item, _lastError) => Some((id, ProcessPaymentSpec.ConfirmPayment({orderId: id}))))
+      CommandBackCallback.phase1([("evt", PaymentReceived({orderId: "ord-1", amount: 50.0}))])
+      let row = CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      CommandBackCallback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 2})
+
+      let published = ref([])
+      await CommandBackCallback.phase2(
+        async cmds => published := cmds,
+        ~capabilities=Reventless.Capabilities.none,
+      )
+      expect(published.contents->Array.length)->toBe(1)
+      expect((CommandBackCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)
+      ->toBe(Abandoned)
     })
 
     testPromise("individual item failure does not affect other items", async () => {

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

@@ -2,6 +2,7 @@
 
 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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as OutboundTranslationSliceFixtures$ReventlessLocal from "./OutboundTranslationSliceFixtures.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
@@ -10,11 +11,14 @@ let collect = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmail
 
 let translate = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.translate;
 
+let onExhausted = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.onExhausted;
+
 let moduleUrl = OutboundTranslationSliceFixtures$ReventlessLocal.SendTrackingEmailSpec.moduleUrl;
 
 let SendTrackingEmailTranslation = {
   collect: collect,
   translate: translate,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl
 };
 
@@ -22,11 +26,14 @@ let collect$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentS
 
 let translate$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translate;
 
+let onExhausted$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhausted;
+
 let moduleUrl$1 = OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.moduleUrl;
 
 let ProcessPaymentTranslation = {
   collect: collect$1,
   translate: translate$1,
+  onExhausted: onExhausted$1,
   moduleUrl: moduleUrl$1
 };
 
@@ -70,6 +77,7 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         }
       ]
     });
+    OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (_id, _item, _lastError) => {};
   });
   globalThis.describe("Phase 1 — collect", () => {
     globalThis.test("OrderShipped event creates a pending outbound item", async () => {
@@ -276,9 +284,11 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
         ]]);
       let mockPublish = async _cmds => {};
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Failed");
       await CommandBackCallback.phase2(mockPublish, Capabilities$Reventless.none);
       let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       globalThis.expect(row.retryCount).toBe(2);
+      globalThis.expect(row.status).toBe("Abandoned");
       let publishedCommands = {
         contents: []
       };
@@ -289,6 +299,198 @@ globalThis.describe("OutboundTranslationSlice Callback", () => {
       globalThis.expect(publishedCommands.contents.length).toBe(0);
       let row2 = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
       globalThis.expect(row2.retryCount).toBe(2);
+      globalThis.expect(row2.status).toBe("Abandoned");
+    });
+    globalThis.test("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "timeout"
+      });
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      let newrecord = {...row};
+      newrecord.retryCount = 2;
+      newrecord.status = "Failed";
+      CommandBackCallback.todoItems["ord-1"] = newrecord;
+      await CommandBackCallback.phase2(async _cmds => {}, Capabilities$Reventless.none);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
+    });
+    globalThis.test("the last error survives the transition to Abandoned", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let publish = async _cmds => {};
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.status).toBe("Abandoned");
+      globalThis.expect(row.lastError).toEqual("gateway down");
+    });
+    globalThis.test("the row carries the ceiling its count is racing", async () => {
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).maxRetries).toEqual(OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.maxRetries);
+    });
+    globalThis.test("a slice that answers onExhausted has its command published", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (id, _item, _lastError) => [
+        id,
+        {
+          TAG: "ConfirmPayment",
+          orderId: id
+        }
+      ];
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let published = {
+        contents: []
+      };
+      let publish = async cmds => {
+        published.contents = published.contents.concat(cmds);
+      };
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(published.contents.length).toBe(0);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
+      globalThis.expect(published.contents.length).toBe(1);
+      globalThis.expect(published.contents[0].id).toBe("ord-1");
+      globalThis.expect(published.contents[0].meta.service).toBe("ConfirmPayment");
+    });
+    globalThis.test("the hook is handed the error that ended it", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      let seen = {
+        contents: undefined
+      };
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (_id, _item, lastError) => {
+        seen.contents = lastError;
+      };
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let publish = async _cmds => {};
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(seen.contents).toEqual("gateway down");
+    });
+    globalThis.test("a silent slice publishes nothing, and the row is still Abandoned", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let published = {
+        contents: []
+      };
+      let publish = async cmds => {
+        published.contents = published.contents.concat(cmds);
+      };
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(publish, Capabilities$Reventless.none);
+      globalThis.expect(published.contents.length).toBe(0);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
+    });
+    globalThis.test("a failed announcement leaves the row Abandoned", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.translateFn.contents = async (_id, _item) => ({
+        TAG: "Error",
+        _0: "gateway down"
+      });
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (id, _item, _lastError) => [
+        id,
+        {
+          TAG: "ConfirmPayment",
+          orderId: id
+        }
+      ];
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let failOnAbandonment = async _cmds => Stdlib_JsError.throwWithMessage("topic unavailable");
+      await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
+      await CommandBackCallback.phase2(failOnAbandonment, Capabilities$Reventless.none);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      globalThis.expect(row.status).toBe("Abandoned");
+      globalThis.expect(row.retryCount).toBe(2);
+    });
+    globalThis.test("a stranded row announces when it is normalised", async () => {
+      OutboundTranslationSliceFixtures$ReventlessLocal.ProcessPaymentSpec.onExhaustedFn.contents = (id, _item, _lastError) => [
+        id,
+        {
+          TAG: "ConfirmPayment",
+          orderId: id
+        }
+      ];
+      CommandBackCallback.phase1([[
+          "evt",
+          {
+            TAG: "PaymentReceived",
+            orderId: "ord-1",
+            amount: 50.0
+          }
+        ]]);
+      let row = Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined);
+      let newrecord = {...row};
+      newrecord.retryCount = 2;
+      newrecord.status = "Failed";
+      CommandBackCallback.todoItems["ord-1"] = newrecord;
+      let published = {
+        contents: []
+      };
+      await CommandBackCallback.phase2(async cmds => {
+        published.contents = cmds;
+      }, Capabilities$Reventless.none);
+      globalThis.expect(published.contents.length).toBe(1);
+      globalThis.expect(Stdlib_Option.getOrThrow(CommandBackCallback.todoItems["ord-1"], undefined).status).toBe("Abandoned");
     });
     globalThis.test("individual item failure does not affect other items", async () => {
       let callCount = {

package/tests/components/outboundtranslationslice/OutboundTranslationSliceFixtures.res

@@ -36,6 +36,7 @@ module SendTrackingEmailSpec = {
     }
 
   let translate = async (_id, _item, ~capabilities as _) => Ok(None)
+  let onExhausted = (_id, _item, ~lastError as _) => None
 
   let maxRetries = 3
   let heartbeatInterval = 60
@@ -77,6 +78,13 @@ module ProcessPaymentSpec = {
   // one restate a type it does not use.
   let translate = (id, item, ~capabilities as _) => translateFn.contents(id, item)
 
+  // Overridable like `translateFn`, so a test can assert both answers a slice may
+  // give when its budget runs out: say nothing, or tell the domain.
+  let onExhaustedFn: ref<(string, outboundItem, option<string>) => option<(string, inboundCommand)>> = ref(
+    (_id, _item, _lastError) => None
+  )
+  let onExhausted = (id, item, ~lastError) => onExhaustedFn.contents(id, item, lastError)
+
   let maxRetries = 2
   let heartbeatInterval = 30
   let targetName = Some("ConfirmPayment")

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

@@ -56,6 +56,10 @@ async function translate(_id, _item, param) {
   };
 }
 
+function onExhausted(_id, _item, param) {
+  
+}
+
 let sourceNames = [];
 
 let SendTrackingEmailSpec = {
@@ -66,6 +70,7 @@ let SendTrackingEmailSpec = {
   inboundCommandSchema: inboundCommandSchema,
   collect: collect,
   translate: translate,
+  onExhausted: onExhausted,
   maxRetries: 3,
   heartbeatInterval: 60,
   targetName: undefined,
@@ -119,6 +124,14 @@ function translate$1(id, item, param) {
   return translateFn.contents(id, item);
 }
 
+let onExhaustedFn = {
+  contents: (_id, _item, _lastError) => {}
+};
+
+function onExhausted$1(id, item, lastError) {
+  return onExhaustedFn.contents(id, item, lastError);
+}
+
 let sourceNames$1 = [];
 
 let ProcessPaymentSpec_targetName = "ConfirmPayment";
@@ -132,6 +145,8 @@ let ProcessPaymentSpec = {
   collect: collect$1,
   translateFn: translateFn,
   translate: translate$1,
+  onExhaustedFn: onExhaustedFn,
+  onExhausted: onExhausted$1,
   maxRetries: 2,
   heartbeatInterval: 30,
   targetName: ProcessPaymentSpec_targetName,

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformFixtures.res

@@ -111,6 +111,8 @@ module SendConfirmTranslation: OutboundTranslationSlice.Translation
     externalCalls->Array.push(item.orderId)
     Ok(None)
   }
+
+  let onExhausted = (_id, _item: SendConfirmSpec.outboundItem, ~lastError as _) => None
 }
 
 // ─────────────────────────────────────────────────────────────

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

@@ -141,9 +141,14 @@ async function translate(_id, item, param) {
   };
 }
 
+function onExhausted(_id, _item, param) {
+  
+}
+
 let SendConfirmTranslation = {
   collect: collect,
   translate: translate,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$3
 };