@reventlessdev/reventless-core 3.0.0-alpha.180 → 3.0.0-alpha.181

package/tests/eventlog/EventLogOperationsTest.res.mjs

@@ -0,0 +1,192 @@
+// 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:", () => {
+  globalThis.describe("append", () => {
+    globalThis.test("stores encoded events in storage", async () => {
+      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.test("publishes events to event topic", async () => {
+      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(1);
+    });
+    globalThis.test("storage failure returns Error result", 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.test("multiple events all stored and published", async () => {
+      let events$p = [
+        EventLogFixtures$ReventlessCore.makeEvent$p("item-1", {
+          TAG: "ItemCreated",
+          name: "First"
+        }),
+        EventLogFixtures$ReventlessCore.makeEvent$p("item-2", {
+          TAG: "ItemCreated",
+          name: "Second"
+        })
+      ];
+      await Ops.append(1, "agg-1", events$p);
+      let stored = Stdlib_Option.getOr(EventLogFixtures$ReventlessCore.storedEvents.contents["agg-1"], []);
+      globalThis.expect([
+        stored.length,
+        EventLogFixtures$ReventlessCore.capturedPublishes.contents.length
+      ]).toEqual([
+        2,
+        2
+      ]);
+    });
+    globalThis.test("returns Ok on success", async () => {
+      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.describe("replay", () => {
+    globalThis.test("returns empty array for unknown id", async () => {
+      let events = await Ops.replay("unknown-id");
+      globalThis.expect(events.length).toBe(0);
+    });
+    globalThis.test("decodes stored events back to typed events", async () => {
+      let event = {
+        TAG: "ItemCreated",
+        name: "Widget"
+      };
+      let event$p = EventLogFixtures$ReventlessCore.makeEvent$p("item-1", event);
+      await Ops.append(1, "item-1", [event$p]);
+      let replayed = await Ops.replay("item-1");
+      globalThis.expect(replayed.length).toBe(1);
+      let first = replayed[0];
+      globalThis.expect(first).toEqual(event);
+    });
+    globalThis.test("decodes multiple events in order", async () => {
+      let events = [
+        {
+          TAG: "ItemCreated",
+          name: "Widget"
+        },
+        {
+          TAG: "ItemDeleted",
+          id: "item-1"
+        }
+      ];
+      let events$p = events.map(event => EventLogFixtures$ReventlessCore.makeEvent$p("item-1", event));
+      await Ops.append(1, "item-1", events$p);
+      let replayed = await Ops.replay("item-1");
+      globalThis.expect(replayed.length).toBe(2);
+      globalThis.expect(replayed).toEqual(events);
+    });
+    globalThis.test("separate aggregates have independent event logs", async () => {
+      await Ops.append(1, "agg-A", [EventLogFixtures$ReventlessCore.makeEvent$p("agg-A", {
+          TAG: "ItemCreated",
+          name: "A"
+        })]);
+      await Ops.append(1, "agg-B", [EventLogFixtures$ReventlessCore.makeEvent$p("agg-B", {
+          TAG: "ItemDeleted",
+          id: "B"
+        })]);
+      let eventsA = await Ops.replay("agg-A");
+      let eventsB = await Ops.replay("agg-B");
+      globalThis.expect([
+        eventsA.length,
+        eventsB.length
+      ]).toEqual([
+        1,
+        1
+      ]);
+    });
+  });
+});
+
+export {
+  TestOps,
+  Ops,
+}
+/* Ops Not a pure module */

package/tests/eventlog/EventLogRetryTest.res.mjs

@@ -0,0 +1,195 @@
+// 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({
+        TAG: "StorageFailure",
+        _0: "ThrottlingException: Rate exceeded"
+      })).toBe(true);
+    });
+    globalThis.test("ProvisionedThroughputExceededException is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ProvisionedThroughputExceededException"
+      })).toBe(true);
+    });
+    globalThis.test("ServiceUnavailable is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ServiceUnavailable"
+      })).toBe(true);
+    });
+    globalThis.test("RequestLimitExceeded is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "RequestLimitExceeded"
+      })).toBe(true);
+    });
+    globalThis.test("InternalServerError is transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "InternalServerError: something went wrong"
+      })).toBe(true);
+    });
+    globalThis.test("ValidationException is not transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ValidationException: invalid field"
+      })).toBe(false);
+    });
+    globalThis.test("generic mock storage failure is not transient", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "mock storage failure"
+      })).toBe(false);
+    });
+    globalThis.test("a Conflict is never transient (retried a layer up, not here)", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("Conflict")).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.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 */