@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/aggregate/AggregateCallbackTest.res.mjs

@@ -0,0 +1,140 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
+
+globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+
+globalThis.describe("Aggregate_Callback.handleCommands:", () => {
+  globalThis.describe("single command — new aggregate", () => {
+    globalThis.test("Create returns Ok(reference) and stores 1 event", async () => {
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+          TAG: "Create",
+          name: "Widget"
+        })])));
+      globalThis.expect([
+        results,
+        AggregateFixtures$ReventlessCore.mock.getAll().length
+      ]).toEqual([
+        [{
+            TAG: "Ok",
+            _0: "ref-1"
+          }],
+        1
+      ]);
+    });
+  });
+  globalThis.describe("command on existing aggregate", () => {
+    globalThis.test("Rename after Create replays history and appends new event", async () => {
+      await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+          TAG: "Create",
+          name: "Widget"
+        })])));
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-2", {
+          TAG: "Rename",
+          newName: "Gadget"
+        })])));
+      globalThis.expect([
+        results,
+        AggregateFixtures$ReventlessCore.mock.getAll().length
+      ]).toEqual([
+        [{
+            TAG: "Ok",
+            _0: "ref-2"
+          }],
+        2
+      ]);
+    });
+  });
+  globalThis.describe("behavior returns no events", () => {
+    globalThis.test("Rename on new aggregate returns Ok with no event stored", async () => {
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+          TAG: "Rename",
+          newName: "Gadget"
+        })])));
+      globalThis.expect([
+        results,
+        AggregateFixtures$ReventlessCore.mock.getAll().length
+      ]).toEqual([
+        [{
+            TAG: "Ok",
+            _0: "ref-1"
+          }],
+        0
+      ]);
+    });
+  });
+  globalThis.describe("append failure", () => {
+    globalThis.test("eventLog.append fails → reference returned Error", async () => {
+      AggregateFixtures$ReventlessCore.mock.failNextAppend.contents = true;
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+          TAG: "Create",
+          name: "Widget"
+        })])));
+      globalThis.expect(results).toEqual([{
+          TAG: "Error",
+          _0: "ref-1"
+        }]);
+    });
+  });
+  globalThis.describe("multiple commands for same aggregate ID", () => {
+    globalThis.test("Create then Rename in one batch accumulate state correctly", async () => {
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-1", {
+          TAG: "Create",
+          name: "Widget"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-2", {
+          TAG: "Rename",
+          newName: "Gadget"
+        })
+      ])));
+      globalThis.expect([
+        results,
+        AggregateFixtures$ReventlessCore.mock.getAll().length
+      ]).toEqual([
+        [
+          {
+            TAG: "Ok",
+            _0: "ref-1"
+          },
+          {
+            TAG: "Ok",
+            _0: "ref-2"
+          }
+        ],
+        2
+      ]);
+    });
+  });
+  globalThis.describe("commands for different aggregate IDs", () => {
+    globalThis.test("each ID processed independently", async () => {
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-a", "ref-a", {
+          TAG: "Create",
+          name: "Alpha"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-b", "ref-b", {
+          TAG: "Create",
+          name: "Beta"
+        })
+      ])));
+      globalThis.expect([
+        results.length,
+        AggregateFixtures$ReventlessCore.mock.getAll().length
+      ]).toEqual([
+        2,
+        2
+      ]);
+    });
+  });
+  globalThis.describe("empty batch", () => {
+    globalThis.test("returns empty array", async () => {
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([])));
+      globalThis.expect(results).toEqual([]);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/aggregate/AggregateCausationTest.res

@@ -0,0 +1,49 @@
+// Regression test for causation propagation through Aggregate_Callback:
+// events emitted from a command must carry
+//   - causationId = the command's msgId
+//   - correlationId = the command's correlationId (chain-root id stays stable)
+//   - service inherited from the command (parent's service)
+//   - fresh msgId distinct from the command's
+
+open JestGlobals
+open AggregateFixtures
+
+let _ = beforeEach(() => mock.reset())
+
+describe("Aggregate_Callback causation propagation:", () => {
+  testPromise("event.meta.causationId = command.meta.msgId", async () => {
+    let _ =
+      await Stream.fromIterable([
+        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+      ])->TestHandler.handleCommands->Effect.runPromise
+    let stored = mock.getAll()->Array.getUnsafe(0)
+    expect(stored.meta.causationId)->toEqual(Some(testMeta.msgId))
+  })
+
+  testPromise("event.meta.correlationId = command.meta.correlationId (chain root stable)", async () => {
+    let _ =
+      await Stream.fromIterable([
+        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+      ])->TestHandler.handleCommands->Effect.runPromise
+    let stored = mock.getAll()->Array.getUnsafe(0)
+    expect(stored.meta.correlationId)->toBe(testMeta.correlationId)
+  })
+
+  testPromise("event has a fresh msgId distinct from the command's msgId", async () => {
+    let _ =
+      await Stream.fromIterable([
+        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+      ])->TestHandler.handleCommands->Effect.runPromise
+    let stored = mock.getAll()->Array.getUnsafe(0)
+    expect(stored.meta.msgId == testMeta.msgId)->toBe(false)
+  })
+
+  testPromise("event inherits ip / user / service from the command's meta", async () => {
+    let _ =
+      await Stream.fromIterable([
+        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+      ])->TestHandler.handleCommands->Effect.runPromise
+    let stored = mock.getAll()->Array.getUnsafe(0)
+    expect(stored.meta.service)->toBe(testMeta.service)
+  })
+})

package/tests/aggregate/AggregateCausationTest.res.mjs

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
+
+globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+
+globalThis.describe("Aggregate_Callback causation propagation:", () => {
+  globalThis.test("event.meta.causationId = command.meta.msgId", async () => {
+    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      })])));
+    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
+    globalThis.expect(stored.meta.causationId).toEqual(AggregateFixtures$ReventlessCore.testMeta.msgId);
+  });
+  globalThis.test("event.meta.correlationId = command.meta.correlationId (chain root stable)", async () => {
+    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      })])));
+    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
+    globalThis.expect(stored.meta.correlationId).toBe(AggregateFixtures$ReventlessCore.testMeta.correlationId);
+  });
+  globalThis.test("event has a fresh msgId distinct from the command's msgId", async () => {
+    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      })])));
+    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
+    globalThis.expect(stored.meta.msgId === AggregateFixtures$ReventlessCore.testMeta.msgId).toBe(false);
+  });
+  globalThis.test("event inherits ip / user / service from the command's meta", async () => {
+    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+        TAG: "Create",
+        name: "Widget"
+      })])));
+    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
+    globalThis.expect(stored.meta.service).toBe(AggregateFixtures$ReventlessCore.testMeta.service);
+  });
+});
+
+/*  Not a pure module */

package/tests/aggregate/AggregateConflictTest.res

@@ -0,0 +1,212 @@
+// Tests for Aggregate_Callback conflict retry logic.
+// Verifies that on optimistic locking conflict, the callback re-replays and re-processes.
+
+open JestGlobals
+
+S.enableJson()
+
+module AggSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "ConflictTestAggregate"
+
+  @schema
+  type command = | Create({name: string})
+
+  @schema
+  type event = | Created({name: string})
+
+  @schema
+  type error = | AlreadyExists
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+module TestBehavior = {
+  module Spec = AggSpec
+  type state = {name: string}
+
+  let initialState = {name: ""}
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  let evolve = (_state: state, event: AggSpec.event): state =>
+    switch event {
+    | Created({name}) => {name: name}
+    }
+
+  let decide = (_state: state, command: AggSpec.command): result<array<AggSpec.event>, AggSpec.error> =>
+    switch command {
+    | Create({name}) => Ok([AggSpec.Created({name: name})])
+    }
+}
+
+type mockEL = {
+  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+  replayFn: string => promise<array<AggSpec.event>>,
+  replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
+  getAll: unit => array<Message.event'<string, AggSpec.event>>,
+  failNextAppendsWithConflict: ref<int>,
+  appendCallCount: ref<int>,
+  replayCallCount: ref<int>,
+  reset: unit => unit,
+}
+
+let makeMockEL = (): mockEL => {
+  let storedRef: ref<array<Message.event'<string, AggSpec.event>>> = ref([])
+  let failConflictRef = ref(0)
+  let appendCount = ref(0)
+  let replayCount = ref(0)
+
+  let appendFn = async (_seqNr, _id, newEvents) => {
+    appendCount := appendCount.contents + 1
+    if failConflictRef.contents > 0 {
+      failConflictRef := failConflictRef.contents - 1
+      Error("conflict")
+    } else {
+      storedRef := storedRef.contents->Array.concat(newEvents)
+      Ok(())
+    }
+  }
+
+  let replayFn = async id => {
+    replayCount := replayCount.contents + 1
+    storedRef.contents
+    ->Array.filter(e => e.id == id)
+    ->Array.map(e => e.event)
+  }
+
+  let replayStreamFn = id => {
+    replayCount := replayCount.contents + 1
+    storedRef.contents
+    ->Array.filter(e => e.id == id)
+    ->Array.map(e => e.event)
+    ->Stream.fromIterable
+  }
+
+  {
+    appendFn,
+    replayFn,
+    replayStreamFn,
+    getAll: () => storedRef.contents,
+    failNextAppendsWithConflict: failConflictRef,
+    appendCallCount: appendCount,
+    replayCallCount: replayCount,
+    reset: () => {
+      storedRef := []
+      failConflictRef := 0
+      appendCount := 0
+      replayCount := 0
+    },
+  }
+}
+
+let mock = makeMockEL()
+
+module OuterEventLog = EventLog
+
+module TestOps = {
+  module Spec = AggSpec
+  module EventLog = {
+    module Spec = {
+      module Id = AggSpec.Id
+      let name = "ConflictMockEventLog"
+      @schema
+      type event = AggSpec.event
+    }
+    type operations = {
+      append: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+      replay: string => promise<array<AggSpec.event>>,
+      replayStream: string => Stream.t<AggSpec.event, string, unit>,
+      appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,
+    }
+    type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
+    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+  }
+  let eventLog: EventLog.operations = {
+    append: mock.appendFn,
+    replay: mock.replayFn,
+    replayStream: mock.replayStreamFn,
+    appendStream: (_startingSeqNr, _id, stream) => stream->Stream.runDrain,
+  }
+}
+
+module TestHandler = Aggregate_Callback.Make(AggSpec, TestBehavior, TestOps)
+
+let testMeta: Message.meta = {
+  service: "ConflictTestAggregate",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "msg-1",
+  correlationId: "corr-1",
+}
+
+let makeTopicItem = (reference, command): CommandTopic.topicItem<
+  Message.command'<string, AggSpec.command>,
+> => {
+  command: {
+    id: "agg-1",
+    meta: testMeta,
+    command,
+  },
+  reference,
+}
+
+let _ = beforeEach(() => mock.reset())
+
+describe("Aggregate_Callback — conflict retry:", () => {
+  testPromise("1 conflict retries and succeeds", async () => {
+    mock.failNextAppendsWithConflict := 1
+    let results = await Stream.fromIterable([
+      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+    ])->TestHandler.handleCommands->Effect.runPromise
+    expect(results)->toEqual([Ok("ref-1")])
+    // 1 initial append (conflict) + 1 retry append (success) = 2
+    expect(mock.appendCallCount.contents)->toBe(2)
+  })
+
+  testPromise("conflict triggers re-replay", async () => {
+    mock.failNextAppendsWithConflict := 1
+    let _ = await Stream.fromIterable([
+      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+    ])->TestHandler.handleCommands->Effect.runPromise
+    // 1 initial replay + 1 retry replay = 2
+    expect(mock.replayCallCount.contents)->toBe(2)
+  })
+
+  testPromise("2 conflicts retry twice and succeed", async () => {
+    mock.failNextAppendsWithConflict := 2
+    let results = await Stream.fromIterable([
+      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+    ])->TestHandler.handleCommands->Effect.runPromise
+    expect(results)->toEqual([Ok("ref-1")])
+    expect(mock.appendCallCount.contents)->toBe(3)
+  })
+
+  testPromise("max retries exhausted returns Error with detail message", async () => {
+    // 4 conflicts exhaust 3 retries (1 initial + 3 retries = 4 attempts)
+    mock.failNextAppendsWithConflict := 4
+    let results = await Stream.fromIterable([
+      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+    ])->TestHandler.handleCommands->Effect.runPromise
+    expect(results)->toEqual([Error("concurrent modification (3 retries exhausted): conflict")])
+    expect(mock.appendCallCount.contents)->toBe(4)
+  })
+
+  testPromise("successful append after conflict stores event", async () => {
+    mock.failNextAppendsWithConflict := 1
+    let _ = await Stream.fromIterable([
+      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+    ])->TestHandler.handleCommands->Effect.runPromise
+    expect(mock.getAll()->Array.length)->toBe(1)
+  })
+
+  testPromise("no conflict does not retry", async () => {
+    let results = await Stream.fromIterable([
+      makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+    ])->TestHandler.handleCommands->Effect.runPromise
+    expect(results)->toEqual([Ok("ref-1")])
+    expect(mock.appendCallCount.contents)->toBe(1)
+    expect(mock.replayCallCount.contents)->toBe(1)
+  })
+})