@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/eventlog/EventLogFixtures.res.mjs

@@ -0,0 +1,166 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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 Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+S.enableJson();
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ItemCreated",
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ItemDeleted",
+    id: s.m(S.string)
+  }))
+]);
+
+let ItemEventLogSpec = {
+  Id: undefined,
+  name: "TestItemEventLog",
+  eventSchema: eventSchema
+};
+
+let storedEvents = {
+  contents: {}
+};
+
+let failNextAppend = {
+  contents: false
+};
+
+let failNextAppendsWithTransient = {
+  contents: 0
+};
+
+let appendCallCount = {
+  contents: 0
+};
+
+async function mockStorage_append(_seqNr, id, jsons) {
+  appendCallCount.contents = appendCallCount.contents + 1 | 0;
+  if (failNextAppend.contents) {
+    failNextAppend.contents = false;
+    return {
+      TAG: "Error",
+      _0: "mock storage failure"
+    };
+  }
+  if (failNextAppendsWithTransient.contents > 0) {
+    failNextAppendsWithTransient.contents = failNextAppendsWithTransient.contents - 1 | 0;
+    return {
+      TAG: "Error",
+      _0: "ThrottlingException: Rate exceeded"
+    };
+  }
+  let existing = Stdlib_Option.getOr(storedEvents.contents[id], []);
+  storedEvents.contents[id] = existing.concat(jsons);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function mockStorage_replay(id) {
+  return Stdlib_Option.getOr(storedEvents.contents[id], []);
+}
+
+function mockStorage_replayStream(id) {
+  return Stream.fromIterable(Stdlib_Option.getOr(storedEvents.contents[id], []));
+}
+
+function mockStorage_appendStream(_startingSeqNr, id, stream) {
+  return Stream.runForEach(stream, json => Effect.sync(() => {
+    let existing = Stdlib_Option.getOr(storedEvents.contents[id], []);
+    storedEvents.contents[id] = existing.concat([json]);
+  }));
+}
+
+let mockStorage = {
+  append: mockStorage_append,
+  replay: mockStorage_replay,
+  replayStream: mockStorage_replayStream,
+  appendStream: mockStorage_appendStream
+};
+
+let capturedPublishes = {
+  contents: []
+};
+
+function make(param, param$1, param$2) {
+  return 0;
+}
+
+let MockEventTopic_Spec = {
+  Id: Id$Reventless.StringPure,
+  name: "TestItem",
+  eventSchema: eventSchema
+};
+
+let MockEventTopic = {
+  Spec: MockEventTopic_Spec,
+  make: make
+};
+
+async function mockEventTopicOps_publish(events) {
+  capturedPublishes.contents = capturedPublishes.contents.concat(events);
+}
+
+async function mockEventTopicOps_publishJson(_service, _meta, _json) {
+  
+}
+
+function mockEventTopicOps_publishJsonStream(_stream) {
+  return Effect.succeed();
+}
+
+let mockEventTopicOps = {
+  publish: mockEventTopicOps_publish,
+  publishJson: mockEventTopicOps_publishJson,
+  publishJsonStream: mockEventTopicOps_publishJsonStream
+};
+
+let testMeta = {
+  service: "test",
+  time: "2024-01-01T00:00:00.000Z",
+  ip: "127.0.0.1",
+  user: "testuser",
+  msgId: "msg-001",
+  correlationId: "corr-001"
+};
+
+function makeEvent$p(id, event) {
+  return {
+    id: id,
+    meta: testMeta,
+    event: event
+  };
+}
+
+function reset() {
+  storedEvents.contents = {};
+  failNextAppend.contents = false;
+  failNextAppendsWithTransient.contents = 0;
+  appendCallCount.contents = 0;
+  capturedPublishes.contents = [];
+}
+
+export {
+  ItemEventLogSpec,
+  storedEvents,
+  failNextAppend,
+  failNextAppendsWithTransient,
+  appendCallCount,
+  mockStorage,
+  capturedPublishes,
+  MockEventTopic,
+  mockEventTopicOps,
+  testMeta,
+  makeEvent$p,
+  reset,
+}
+/*  Not a pure module */

package/tests/eventlog/EventLogOperationsTest.res

@@ -0,0 +1,96 @@
+open JestGlobals
+open EventLogFixtures
+
+// Wire up EventLog_Operations with mock storage and mock EventTopic
+module TestOps: EventLog_Operations.Ops with module Spec = ItemEventLogSpec = {
+  module Spec = ItemEventLogSpec
+  module EventTopic = MockEventTopic
+  let eventTopic = mockEventTopicOps
+  let storage = mockStorage
+}
+
+module Ops = EventLog_Operations.Make(ItemEventLogSpec, TestOps)
+
+let _ = beforeEach(() => reset())
+
+describe("EventLog_Operations:", () => {
+  describe("append", () => {
+    testPromise("stores encoded events in storage", async () => {
+      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+      let event' = makeEvent'("item-1", event)
+      let _ = await Ops.append(1, "item-1", [event'])
+      let stored = storedEvents.contents->Dict.get("item-1")->Option.getOr([])
+      expect(stored->Array.length)->toBe(1)
+    })
+
+    testPromise("publishes events to event topic", async () => {
+      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+      let event' = makeEvent'("item-1", event)
+      let _ = await Ops.append(1, "item-1", [event'])
+      expect(capturedPublishes.contents->Array.length)->toBe(1)
+    })
+
+    testPromise("storage failure returns Error result", async () => {
+      failNextAppend := true
+      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+      let event' = makeEvent'("item-1", event)
+      let result = await Ops.append(1, "item-1", [event'])
+      // When storage returns Error (not throws), the operation still publishes
+      // but the Error result is propagated back to the caller.
+      expect(Result.isError(result))->toBe(true)
+    })
+
+    testPromise("multiple events all stored and published", async () => {
+      let events' = [
+        makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "First"})),
+        makeEvent'("item-2", ItemEventLogSpec.ItemCreated({name: "Second"})),
+      ]
+      let _ = await Ops.append(1, "agg-1", events')
+      let stored = storedEvents.contents->Dict.get("agg-1")->Option.getOr([])
+      expect((stored->Array.length, capturedPublishes.contents->Array.length))->toEqual((2, 2))
+    })
+
+    testPromise("returns Ok on success", async () => {
+      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+      let result = await Ops.append(1, "item-1", [event'])
+      expect(Result.isOk(result))->toBe(true)
+    })
+  })
+
+  describe("replay", () => {
+    testPromise("returns empty array for unknown id", async () => {
+      let events = await Ops.replay("unknown-id")
+      expect(events->Array.length)->toBe(0)
+    })
+
+    testPromise("decodes stored events back to typed events", async () => {
+      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+      let event' = makeEvent'("item-1", event)
+      let _ = await Ops.append(1, "item-1", [event'])
+      let replayed = await Ops.replay("item-1")
+      expect(replayed->Array.length)->toBe(1)
+      let first = replayed->Array.getUnsafe(0)
+      expect(first)->toEqual(event)
+    })
+
+    testPromise("decodes multiple events in order", async () => {
+      let events = [
+        ItemEventLogSpec.ItemCreated({name: "Widget"}),
+        ItemEventLogSpec.ItemDeleted({id: "item-1"}),
+      ]
+      let events' = events->Array.map(event => makeEvent'("item-1", event))
+      let _ = await Ops.append(1, "item-1", events')
+      let replayed = await Ops.replay("item-1")
+      expect(replayed->Array.length)->toBe(2)
+      expect(replayed)->toEqual(events)
+    })
+
+    testPromise("separate aggregates have independent event logs", async () => {
+      let _ = await Ops.append(1, "agg-A", [makeEvent'("agg-A", ItemEventLogSpec.ItemCreated({name: "A"}))])
+      let _ = await Ops.append(1, "agg-B", [makeEvent'("agg-B", ItemEventLogSpec.ItemDeleted({id: "B"}))])
+      let eventsA = await Ops.replay("agg-A")
+      let eventsB = await Ops.replay("agg-B")
+      expect((eventsA->Array.length, eventsB->Array.length))->toEqual((1, 1))
+    })
+  })
+})

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

@@ -0,0 +1,121 @@
+open JestGlobals
+open EventLogFixtures
+
+// Wire up EventLog_Operations with the same mock storage and EventTopic as the
+// basic operations tests — but use the counter-based transient failure mock.
+module TestOps: EventLog_Operations.Ops with module Spec = ItemEventLogSpec = {
+  module Spec = ItemEventLogSpec
+  module EventTopic = MockEventTopic
+  let eventTopic = mockEventTopicOps
+  let storage = mockStorage
+}
+
+module Ops = EventLog_Operations.Make(ItemEventLogSpec, TestOps)
+
+let _ = beforeEach(() => reset())
+
+describe("EventLog_Operations — retry:", () => {
+  describe("isTransient predicate:", () => {
+    testPromise("ThrottlingException is transient", async () => {
+      expect(EventLog_Operations.isTransient("ThrottlingException: Rate exceeded"))->toBe(true)
+    })
+
+    testPromise("ProvisionedThroughputExceededException is transient", async () => {
+      expect(
+        EventLog_Operations.isTransient("ProvisionedThroughputExceededException"),
+      )->toBe(true)
+    })
+
+    testPromise("ServiceUnavailable is transient", async () => {
+      expect(EventLog_Operations.isTransient("ServiceUnavailable"))->toBe(true)
+    })
+
+    testPromise("RequestLimitExceeded is transient", async () => {
+      expect(EventLog_Operations.isTransient("RequestLimitExceeded"))->toBe(true)
+    })
+
+    testPromise("InternalServerError is transient", async () => {
+      expect(EventLog_Operations.isTransient("InternalServerError: something went wrong"))->toBe(
+        true,
+      )
+    })
+
+    testPromise("ValidationException is not transient", async () => {
+      expect(EventLog_Operations.isTransient("ValidationException: invalid field"))->toBe(false)
+    })
+
+    testPromise("generic mock storage failure is not transient", async () => {
+      expect(EventLog_Operations.isTransient("mock storage failure"))->toBe(false)
+    })
+  })
+
+  describe("permanent storage failure:", () => {
+    testPromise("returns Error immediately without retry", async () => {
+      failNextAppend := true // "mock storage failure" — not transient, no retry
+      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+      let result = await Ops.append(1, "item-1", [event'])
+      expect(Result.isError(result))->toBe(true)
+      // Exactly one attempt — permanent error is not retried
+      expect(appendCallCount.contents)->toBe(1)
+    })
+
+    testPromise("does not publish events after permanent storage failure", async () => {
+      failNextAppend := true
+      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+      let _ = await Ops.append(1, "item-1", [event'])
+      expect(capturedPublishes.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("transient storage failure — retry:", () => {
+    testPromise("1 transient failure retries and returns Ok", async () => {
+      failNextAppendsWithTransient := 1
+      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+      let result = await Ops.append(1, "item-1", [event'])
+      expect(Result.isOk(result))->toBe(true)
+      // 1 initial attempt + 1 retry = 2 total calls to storage.append
+      expect(appendCallCount.contents)->toBe(2)
+    })
+
+    testPromise("events are stored and published after successful retry", async () => {
+      failNextAppendsWithTransient := 1
+      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+      let _ = await Ops.append(1, "item-1", [event'])
+      let stored = storedEvents.contents->Dict.get("item-1")->Option.getOr([])
+      expect(stored->Array.length)->toBe(1)
+      expect(capturedPublishes.contents->Array.length)->toBe(1)
+    })
+
+    testPromise("2 transient failures retry twice and return Ok", async () => {
+      failNextAppendsWithTransient := 2
+      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+      let result = await Ops.append(1, "item-1", [event'])
+      expect(Result.isOk(result))->toBe(true)
+      // 1 initial + 2 retries = 3 total calls
+      expect(appendCallCount.contents)->toBe(3)
+    })
+  })
+
+  describe("retry exhaustion:", () => {
+    // The retry schedule allows up to 5 retries (recurs(5)).
+    // 6 transient failures exhaust all retries; the append returns Error.
+    //
+    // Timing: exponential backoff (100ms base) + jitter (0–100% extra per step).
+    //   Worst case: 200+400+800+1600+3200 ≈ 6 200 ms.
+    //   A 12-second timeout provides 2× headroom above the jitter ceiling.
+    testPromiseWithTimeout(
+      "6 transient failures exhaust 5 retries and return Error",
+      async () => {
+        failNextAppendsWithTransient := 6
+        let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+        let result = await Ops.append(1, "item-1", [event'])
+        expect(Result.isError(result))->toBe(true)
+        // 1 initial attempt + 5 retries = 6 total calls to storage.append
+        expect(appendCallCount.contents)->toBe(6)
+        // No events published after exhaustion
+        expect(capturedPublishes.contents->Array.length)->toBe(0)
+      },
+      12000,
+    )
+  })
+})