@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/eventlog/EventLogRetryTest.res.mjs

@@ -0,0 +1,171 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as EventLogFixtures$ReventlessCore from "./EventLogFixtures.res.mjs";
+import * as EventLog_Operations$ReventlessCore from "../../src/components/EventLog/EventLog_Operations.res.mjs";
+
+let $$let = EventLogFixtures$ReventlessCore.MockEventTopic.Spec;
+
+let $$let$1 = $$let.Id;
+
+let TestOps_Spec = {
+  Id: Id$Reventless.StringPure,
+  name: EventLogFixtures$ReventlessCore.ItemEventLogSpec.name,
+  eventSchema: EventLogFixtures$ReventlessCore.ItemEventLogSpec.eventSchema
+};
+
+let TestOps_EventTopic = {
+  Spec: {
+    Id: {
+      schema: $$let$1.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: $$let$1.cmp
+    },
+    name: $$let.name,
+    eventSchema: $$let.eventSchema
+  },
+  make: EventLogFixtures$ReventlessCore.MockEventTopic.make
+};
+
+let TestOps = {
+  Spec: TestOps_Spec,
+  EventTopic: TestOps_EventTopic,
+  eventTopic: EventLogFixtures$ReventlessCore.mockEventTopicOps,
+  storage: EventLogFixtures$ReventlessCore.mockStorage
+};
+
+let $$let$2 = TestOps_Spec;
+
+let $$let$3 = $$let$2.Id;
+
+let Ops = EventLog_Operations$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: EventLogFixtures$ReventlessCore.ItemEventLogSpec.name,
+  eventSchema: EventLogFixtures$ReventlessCore.ItemEventLogSpec.eventSchema
+})({
+  Spec: {
+    Id: {
+      schema: $$let$3.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: $$let$3.cmp
+    },
+    name: $$let$2.name,
+    eventSchema: $$let$2.eventSchema
+  },
+  EventTopic: TestOps_EventTopic,
+  eventTopic: EventLogFixtures$ReventlessCore.mockEventTopicOps,
+  storage: EventLogFixtures$ReventlessCore.mockStorage
+});
+
+globalThis.beforeEach(() => EventLogFixtures$ReventlessCore.reset());
+
+globalThis.describe("EventLog_Operations — retry:", () => {
+  globalThis.describe("isTransient predicate:", () => {
+    globalThis.test("ThrottlingException is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ThrottlingException: Rate exceeded")).toBe(true);
+    });
+    globalThis.test("ProvisionedThroughputExceededException is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ProvisionedThroughputExceededException")).toBe(true);
+    });
+    globalThis.test("ServiceUnavailable is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ServiceUnavailable")).toBe(true);
+    });
+    globalThis.test("RequestLimitExceeded is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("RequestLimitExceeded")).toBe(true);
+    });
+    globalThis.test("InternalServerError is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("InternalServerError: something went wrong")).toBe(true);
+    });
+    globalThis.test("ValidationException is not transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ValidationException: invalid field")).toBe(false);
+    });
+    globalThis.test("generic mock storage failure is not transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("mock storage failure")).toBe(false);
+    });
+  });
+  globalThis.describe("permanent storage failure:", () => {
+    globalThis.test("returns Error immediately without retry", async () => {
+      EventLogFixtures$ReventlessCore.failNextAppend.contents = true;
+      let event$p = EventLogFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemCreated",
+        name: "Widget"
+      });
+      let result = await Ops.append(1, "item-1", [event$p]);
+      globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+      globalThis.expect(EventLogFixtures$ReventlessCore.appendCallCount.contents).toBe(1);
+    });
+    globalThis.test("does not publish events after permanent storage failure", async () => {
+      EventLogFixtures$ReventlessCore.failNextAppend.contents = true;
+      let event$p = EventLogFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemCreated",
+        name: "Widget"
+      });
+      await Ops.append(1, "item-1", [event$p]);
+      globalThis.expect(EventLogFixtures$ReventlessCore.capturedPublishes.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("transient storage failure — retry:", () => {
+    globalThis.test("1 transient failure retries and returns Ok", async () => {
+      EventLogFixtures$ReventlessCore.failNextAppendsWithTransient.contents = 1;
+      let event$p = EventLogFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemCreated",
+        name: "Widget"
+      });
+      let result = await Ops.append(1, "item-1", [event$p]);
+      globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+      globalThis.expect(EventLogFixtures$ReventlessCore.appendCallCount.contents).toBe(2);
+    });
+    globalThis.test("events are stored and published after successful retry", async () => {
+      EventLogFixtures$ReventlessCore.failNextAppendsWithTransient.contents = 1;
+      let event$p = EventLogFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemCreated",
+        name: "Widget"
+      });
+      await Ops.append(1, "item-1", [event$p]);
+      let stored = Stdlib_Option.getOr(EventLogFixtures$ReventlessCore.storedEvents.contents["item-1"], []);
+      globalThis.expect(stored.length).toBe(1);
+      globalThis.expect(EventLogFixtures$ReventlessCore.capturedPublishes.contents.length).toBe(1);
+    });
+    globalThis.test("2 transient failures retry twice and return Ok", async () => {
+      EventLogFixtures$ReventlessCore.failNextAppendsWithTransient.contents = 2;
+      let event$p = EventLogFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemCreated",
+        name: "Widget"
+      });
+      let result = await Ops.append(1, "item-1", [event$p]);
+      globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+      globalThis.expect(EventLogFixtures$ReventlessCore.appendCallCount.contents).toBe(3);
+    });
+  });
+  globalThis.describe("retry exhaustion:", () => {
+    globalThis.test("6 transient failures exhaust 5 retries and return Error", async () => {
+      EventLogFixtures$ReventlessCore.failNextAppendsWithTransient.contents = 6;
+      let event$p = EventLogFixtures$ReventlessCore.makeEvent$p("item-1", {
+        TAG: "ItemCreated",
+        name: "Widget"
+      });
+      let result = await Ops.append(1, "item-1", [event$p]);
+      globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+      globalThis.expect(EventLogFixtures$ReventlessCore.appendCallCount.contents).toBe(6);
+      globalThis.expect(EventLogFixtures$ReventlessCore.capturedPublishes.contents.length).toBe(0);
+    }, 12000);
+  });
+});
+
+export {
+  TestOps,
+  Ops,
+}
+/* Ops Not a pure module */

package/tests/eventmapper/EventMapperCallbackTest.res

@@ -0,0 +1,134 @@
+open JestGlobals
+open EventMapperFixtures
+
+let _ = beforeEach(() => resetMocks())
+
+// ─────────────────────────────────────────────────────────────
+// MakeCounterHandler.handleCounterEvents
+// ─────────────────────────────────────────────────────────────
+
+describe("MakeCounterHandler.handleCounterEvents:", () => {
+  describe("event with matching source mapping", () => {
+    testPromise("publishes command JSON for OrderPlaced", async () => {
+      let eventJson =
+        makeEventJson(
+          "src-1",
+          CmdSourceSpec.OrderPlaced({orderId: "order-1", amount: 99.99})->Message.encode(
+            CmdSourceSpec.eventSchema,
+          ),
+        )
+      await TestCounterHandler.handleCounterEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
+      // publishJsons should have been called with 1 command
+      expect(capturedCmds.contents->Array.length)->toBe(1)
+    })
+  })
+
+  describe("event with unknown service", () => {
+    testPromise("skipped — no publish", async () => {
+      let eventJson =
+        makeEventJson(
+          ~service="UnknownService",
+          "src-1",
+          CmdSourceSpec.OrderPlaced({orderId: "order-1", amount: 50.0})->Message.encode(
+            CmdSourceSpec.eventSchema,
+          ),
+        )
+      await TestCounterHandler.handleCounterEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
+      expect(capturedCmds.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("invalid event JSON", () => {
+    testPromise("skipped gracefully — no throw, no publish", async () => {
+      let invalidJson = JSON.Encode.string("not-an-object")
+      await TestCounterHandler.handleCounterEvents(Stream.fromIterable([invalidJson]))->Effect.runPromise
+      expect(capturedCmds.contents->Array.length)->toBe(0)
+    })
+  })
+})
+
+// ─────────────────────────────────────────────────────────────
+// MakeEventCollectorHandler.handleJsonEvents
+// ─────────────────────────────────────────────────────────────
+
+describe("MakeEventCollectorHandler.handleJsonEvents:", () => {
+  describe("Count action", () => {
+    testPromise("calls count with the countItem", async () => {
+      let countItem: ReventlessInfra.Counter.countItem = {
+        counterId: "c1",
+        reference: "ref-1",
+        inc: 1,
+      }
+      mockCommonHandler :=
+        async _ => (Promise.resolve([]), [Counter.Count(countItem)])
+      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
+      expect(capturedCountItems.contents)->toEqual([countItem])
+    })
+  })
+
+  describe("AddToCounterTarget action", () => {
+    testPromise("calls addToCounterTarget with the counterTargetRef", async () => {
+      let target: ReventlessInfra.Counter.counterTargetRef = {
+        counterId: "c1",
+        target: 5,
+        targetRef: "ref-1",
+      }
+      mockCommonHandler :=
+        async _ => (Promise.resolve([]), [Counter.AddToCounterTarget(target)])
+      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
+      expect(capturedCounterTargets.contents)->toEqual([target])
+    })
+  })
+
+  describe("Publisher action", () => {
+    testPromise("calls publishJsons with the command", async () => {
+      let cmd: Message.commandJson = {
+        id: "agg-1",
+        meta: evtMapTestMeta,
+        commandJson: JSON.Encode.string("DoSomething"),
+      }
+      mockCommonHandler := async _ => (Promise.resolve([cmd]), [])
+      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
+      expect(capturedCmds.contents->Array.length)->toBe(1)
+    })
+  })
+
+  describe("mixed actions", () => {
+    testPromise("both publish and count called", async () => {
+      let countItem: ReventlessInfra.Counter.countItem = {
+        counterId: "c1",
+        reference: "ref-1",
+        inc: 2,
+      }
+      let cmd: Message.commandJson = {
+        id: "agg-1",
+        meta: evtMapTestMeta,
+        commandJson: JSON.Encode.string("Cmd"),
+      }
+      mockCommonHandler :=
+        async _ => (Promise.resolve([cmd]), [Counter.Count(countItem)])
+      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
+      expect((
+        capturedCmds.contents->Array.length,
+        capturedCountItems.contents->Array.length,
+      ))->toEqual((1, 1))
+    })
+  })
+
+  describe("doCount retry", () => {
+    testPromise("retries when count throws, eventually succeeds", async () => {
+      let countItem: ReventlessInfra.Counter.countItem = {
+        counterId: "c1",
+        reference: "ref-1",
+        inc: 1,
+      }
+      // Fail on first call, succeed on second
+      mockCountFailUntil := 1
+      mockCommonHandler :=
+        async _ => (Promise.resolve([]), [Counter.Count(countItem)])
+      await TestECHandler.handleJsonEvents(Stream.fromIterable([JSON.Encode.null]))->Effect.runPromise
+      // count was called at least twice (1 failure + 1 success)
+      expect(mockCountCallCount.contents >= 2)->toBe(true)
+    })
+  })
+})

package/tests/eventmapper/EventMapperCallbackTest.res.mjs

@@ -0,0 +1,141 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as EventMapperFixtures$ReventlessCore from "./EventMapperFixtures.res.mjs";
+
+globalThis.beforeEach(() => EventMapperFixtures$ReventlessCore.resetMocks());
+
+globalThis.describe("MakeCounterHandler.handleCounterEvents:", () => {
+  globalThis.describe("event with matching source mapping", () => {
+    globalThis.test("publishes command JSON for OrderPlaced", async () => {
+      let eventJson = EventMapperFixtures$ReventlessCore.makeEventJson(undefined, "src-1", Message$ReventlessCore.encode({
+        TAG: "OrderPlaced",
+        orderId: "order-1",
+        amount: 99.99
+      }, EventMapperFixtures$ReventlessCore.CmdSourceSpec.eventSchema));
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestCounterHandler.handleCounterEvents(Stream.fromIterable([eventJson])));
+      globalThis.expect(EventMapperFixtures$ReventlessCore.capturedCmds.contents.length).toBe(1);
+    });
+  });
+  globalThis.describe("event with unknown service", () => {
+    globalThis.test("skipped — no publish", async () => {
+      let eventJson = EventMapperFixtures$ReventlessCore.makeEventJson("UnknownService", "src-1", Message$ReventlessCore.encode({
+        TAG: "OrderPlaced",
+        orderId: "order-1",
+        amount: 50.0
+      }, EventMapperFixtures$ReventlessCore.CmdSourceSpec.eventSchema));
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestCounterHandler.handleCounterEvents(Stream.fromIterable([eventJson])));
+      globalThis.expect(EventMapperFixtures$ReventlessCore.capturedCmds.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("invalid event JSON", () => {
+    globalThis.test("skipped gracefully — no throw, no publish", async () => {
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestCounterHandler.handleCounterEvents(Stream.fromIterable(["not-an-object"])));
+      globalThis.expect(EventMapperFixtures$ReventlessCore.capturedCmds.contents.length).toBe(0);
+    });
+  });
+});
+
+globalThis.describe("MakeEventCollectorHandler.handleJsonEvents:", () => {
+  globalThis.describe("Count action", () => {
+    globalThis.test("calls count with the countItem", async () => {
+      let countItem = {
+        counterId: "c1",
+        reference: "ref-1",
+        inc: 1
+      };
+      EventMapperFixtures$ReventlessCore.mockCommonHandler.contents = async param => [
+        Promise.resolve([]),
+        [{
+            TAG: "Count",
+            _0: countItem
+          }]
+      ];
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestECHandler.handleJsonEvents(Stream.fromIterable([null])));
+      globalThis.expect(EventMapperFixtures$ReventlessCore.capturedCountItems.contents).toEqual([countItem]);
+    });
+  });
+  globalThis.describe("AddToCounterTarget action", () => {
+    globalThis.test("calls addToCounterTarget with the counterTargetRef", async () => {
+      let target = {
+        counterId: "c1",
+        target: 5,
+        targetRef: "ref-1"
+      };
+      EventMapperFixtures$ReventlessCore.mockCommonHandler.contents = async param => [
+        Promise.resolve([]),
+        [{
+            TAG: "AddToCounterTarget",
+            _0: target
+          }]
+      ];
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestECHandler.handleJsonEvents(Stream.fromIterable([null])));
+      globalThis.expect(EventMapperFixtures$ReventlessCore.capturedCounterTargets.contents).toEqual([target]);
+    });
+  });
+  globalThis.describe("Publisher action", () => {
+    globalThis.test("calls publishJsons with the command", async () => {
+      let cmd = {
+        id: "agg-1",
+        meta: EventMapperFixtures$ReventlessCore.evtMapTestMeta,
+        commandJson: "DoSomething"
+      };
+      EventMapperFixtures$ReventlessCore.mockCommonHandler.contents = async param => [
+        Promise.resolve([cmd]),
+        []
+      ];
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestECHandler.handleJsonEvents(Stream.fromIterable([null])));
+      globalThis.expect(EventMapperFixtures$ReventlessCore.capturedCmds.contents.length).toBe(1);
+    });
+  });
+  globalThis.describe("mixed actions", () => {
+    globalThis.test("both publish and count called", async () => {
+      let cmd = {
+        id: "agg-1",
+        meta: EventMapperFixtures$ReventlessCore.evtMapTestMeta,
+        commandJson: "Cmd"
+      };
+      EventMapperFixtures$ReventlessCore.mockCommonHandler.contents = async param => [
+        Promise.resolve([cmd]),
+        [{
+            TAG: "Count",
+            _0: {
+              counterId: "c1",
+              reference: "ref-1",
+              inc: 2
+            }
+          }]
+      ];
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestECHandler.handleJsonEvents(Stream.fromIterable([null])));
+      globalThis.expect([
+        EventMapperFixtures$ReventlessCore.capturedCmds.contents.length,
+        EventMapperFixtures$ReventlessCore.capturedCountItems.contents.length
+      ]).toEqual([
+        1,
+        1
+      ]);
+    });
+  });
+  globalThis.describe("doCount retry", () => {
+    globalThis.test("retries when count throws, eventually succeeds", async () => {
+      EventMapperFixtures$ReventlessCore.mockCountFailUntil.contents = 1;
+      EventMapperFixtures$ReventlessCore.mockCommonHandler.contents = async param => [
+        Promise.resolve([]),
+        [{
+            TAG: "Count",
+            _0: {
+              counterId: "c1",
+              reference: "ref-1",
+              inc: 1
+            }
+          }]
+      ];
+      await Effect.runPromise(EventMapperFixtures$ReventlessCore.TestECHandler.handleJsonEvents(Stream.fromIterable([null])));
+      globalThis.expect(EventMapperFixtures$ReventlessCore.mockCountCallCount.contents >= 2).toBe(true);
+    });
+  });
+});
+
+/*  Not a pure module */