@reventlessdev/reventless-aws 3.0.0-alpha.263 → 3.0.0-alpha.265

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -112,6 +112,7 @@ describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler", () =>
       ~callback,
       ~publishJsons=noopPublish,
       ~syncTodoItems=async () => steps->Array.push("sync"),
+      ~loadTodoItems=async () => steps->Array.push("restore"),
     )
     let envelope = obj([("meta", obj([("service", str("Order"))])), ("event", str("Placed"))])
     await Stream.fromIterable([envelope, str("bare")])->handler->Effect.runPromise
@@ -120,7 +121,43 @@ describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler", () =>
     expect(receivedCtx.contents->Option.map(c => c.Reventless.AutomationSlice.sliceName))->toEqual(
       Some("S"),
     )
-    expect(steps)->toEqual(["phase1", "sync", "phase2", "sync"])
+    // `restore` first: rehydrating the TODO list after phase 1 would let a stored
+    // row overwrite one this batch just collected, and after phase 2 would leave
+    // the reloaded backlog unprocessed until another invocation.
+    expect(steps)->toEqual(["restore", "phase1", "sync", "phase2", "sync"])
+  })
+})
+
+describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
+  let dummyRegistered: StreamRoutedEntryPoint_Ops.registeredHandler = {
+    handler: (_event, _context) => Effect.succeed(),
+  }
+  let sliceThat = (~comp, ~run): AutomationSliceEntryPoint_Ops.builtSlice => {
+    registered: dummyRegistered,
+    sweep: run,
+    comp,
+  }
+
+  test("sweeps every slice", async () => {
+    let swept = []
+    await AutomationSliceEntryPoint_Ops.runSweeps([
+      sliceThat(~comp="A", ~run=async () => swept->Array.push("a")),
+      sliceThat(~comp="B", ~run=async () => swept->Array.push("b")),
+    ])
+    expect(swept)->toEqual(["a", "b"])
+  })
+
+  // A sweep exists to recover from a failing external call, so one slice whose
+  // geocoder is still down must not cost every other slice on the Lambda its
+  // turn — that would be a worse version of the problem being fixed.
+  test("a throwing slice does not stop the others", async () => {
+    let swept = []
+    await AutomationSliceEntryPoint_Ops.runSweeps([
+      sliceThat(~comp="A", ~run=async () => swept->Array.push("a")),
+      sliceThat(~comp="Boom", ~run=async () => JsError.throwWithMessage("gateway down")),
+      sliceThat(~comp="C", ~run=async () => swept->Array.push("c")),
+    ])
+    expect(swept)->toEqual(["a", "c"])
   })
 })
 
@@ -142,13 +179,14 @@ describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
         received := events
         steps->Array.push("phase1")
       },
-      phase2: async _publish => steps->Array.push("phase2"),
+      phase2: async (_publish, ~capabilities as _) => steps->Array.push("phase2"),
     }
     let handler = AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler(
       ~consumedEventSchema=outboundEventSchema,
       ~callback,
       ~publishJsons=noopPublish,
       ~syncTodoItems=async () => steps->Array.push("sync"),
+      ~loadTodoItems=async () => steps->Array.push("restore"),
     )
     // `id` is the envelope's subject — the entity the event was published for.
     // An Aggregate's event payload does not repeat it, so this is the only place
@@ -170,6 +208,9 @@ describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
       ("ord-1", OrderPlaced({orderId: "ord-1"})),
       ("", OrderArchived),
     ])
-    expect(steps)->toEqual(["phase1", "sync", "phase2", "sync"])
+    // `restore` first: rehydrating the TODO list after phase 1 would let a stored
+    // row overwrite one this batch just collected, and after phase 2 would leave
+    // the reloaded backlog unprocessed until another invocation.
+    expect(steps)->toEqual(["restore", "phase1", "sync", "phase2", "sync"])
   })
 })

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -153,6 +153,8 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
       sliceName: "S"
     }, callback, noopPublish, async () => {
       steps.push("sync");
+    }, async () => {
+      steps.push("restore");
     });
     let envelope = Object.fromEntries([
       [
@@ -177,6 +179,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
     ]);
     globalThis.expect(Stdlib_Option.map(receivedCtx.contents, c => c.sliceName)).toEqual("S");
     globalThis.expect(steps).toEqual([
+      "restore",
       "phase1",
       "sync",
       "phase2",
@@ -185,6 +188,64 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandl
   });
 });
 
+globalThis.describe("AutomationSliceEntryPoint_Ops.runSweeps", () => {
+  let dummyRegistered_handler = (_event, _context) => Effect.succeed();
+  let dummyRegistered = {
+    handler: dummyRegistered_handler
+  };
+  globalThis.test("sweeps every slice", async () => {
+    let swept = [];
+    await AutomationSliceEntryPoint_Ops$ReventlessAws.runSweeps([
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("a");
+        },
+        comp: "A"
+      },
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("b");
+        },
+        comp: "B"
+      }
+    ]);
+    globalThis.expect(swept).toEqual([
+      "a",
+      "b"
+    ]);
+  });
+  globalThis.test("a throwing slice does not stop the others", async () => {
+    let swept = [];
+    await AutomationSliceEntryPoint_Ops$ReventlessAws.runSweeps([
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("a");
+        },
+        comp: "A"
+      },
+      {
+        registered: dummyRegistered,
+        sweep: async () => Stdlib_JsError.throwWithMessage("gateway down"),
+        comp: "Boom"
+      },
+      {
+        registered: dummyRegistered,
+        sweep: async () => {
+          swept.push("c");
+        },
+        comp: "C"
+      }
+    ]);
+    globalThis.expect(swept).toEqual([
+      "a",
+      "c"
+    ]);
+  });
+});
+
 let outboundEventSchema = S.union([
   S.schema(s => ({
     TAG: "OrderPlaced",
@@ -204,7 +265,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       received.contents = events;
       steps.push("phase1");
     };
-    let callback_phase2 = async _publish => {
+    let callback_phase2 = async (_publish, param) => {
       steps.push("phase2");
     };
     let callback = {
@@ -214,6 +275,8 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
     };
     let handler = AutomationSliceEntryPoint_Ops$ReventlessAws.makeOutboundJsonEventsHandler(outboundEventSchema, callback, noopPublish, async () => {
       steps.push("sync");
+    }, async () => {
+      steps.push("restore");
     });
     let placed = Object.fromEntries([
       [
@@ -273,6 +336,7 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler
       ]
     ]);
     globalThis.expect(steps).toEqual([
+      "restore",
       "phase1",
       "sync",
       "phase2",