@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/eventlog/EventLogAppendStreamTest.res.mjs

@@ -0,0 +1,113 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as EventLogFixtures$ReventlessLocal from "./EventLogFixtures.res.mjs";
+
+globalThis.describe("EventLog.appendStream (in-memory adapter)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+  });
+  globalThis.beforeEach(() => EventLogFixtures$ReventlessLocal.reset());
+  globalThis.describe("basic append", () => {
+    globalThis.test("appendStream writes all events to storage", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      let stream = Stream$1.fromIterable([
+        {
+          TAG: "ItemCreated",
+          name: "e1"
+        },
+        {
+          TAG: "ItemCreated",
+          name: "e2"
+        },
+        {
+          TAG: "ItemCreated",
+          name: "e3"
+        }
+      ]);
+      await Effect.runPromise(ops.appendStream(0, "as-basic-1", stream));
+      let replayed = await ops.replay("as-basic-1");
+      globalThis.expect(replayed.length).toBe(3);
+    });
+    globalThis.test("appendStream on empty stream writes nothing", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await Effect.runPromise(ops.appendStream(0, "as-empty-1", Stream$1.empty));
+      let replayed = await ops.replay("as-empty-1");
+      globalThis.expect(replayed.length).toBe(0);
+    });
+    globalThis.test("appendStream preserves event order", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      let stream = Stream$1.fromIterable([
+        {
+          TAG: "ItemCreated",
+          name: "first"
+        },
+        {
+          TAG: "ItemDeleted",
+          id: "second"
+        }
+      ]);
+      await Effect.runPromise(ops.appendStream(0, "as-order-1", stream));
+      let replayed = await Effect.runPromise(Stream.runCollect(ops.replayStream("as-order-1")));
+      let first = replayed[0];
+      globalThis.expect(first).toEqual({
+        TAG: "ItemCreated",
+        name: "first"
+      });
+    });
+    globalThis.test("appendStream after array append continues from correct sequenceNr", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "as-seq-1", [EventLogFixtures$ReventlessLocal.makeEvent$p("as-seq-1", {
+          TAG: "ItemCreated",
+          name: "initial"
+        })]);
+      let stream = Stream$1.fromIterable([{
+          TAG: "ItemCreated",
+          name: "streamed"
+        }]);
+      await Effect.runPromise(ops.appendStream(1, "as-seq-1", stream));
+      let replayed = await ops.replay("as-seq-1");
+      globalThis.expect(replayed.length).toBe(2);
+    });
+  });
+  globalThis.describe("replayStream → appendStream pipeline", () => {
+    globalThis.test("can copy events from one aggregate to another via streams", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "as-src-1", [
+        EventLogFixtures$ReventlessLocal.makeEvent$p("as-src-1", {
+          TAG: "ItemCreated",
+          name: "a"
+        }),
+        EventLogFixtures$ReventlessLocal.makeEvent$p("as-src-1", {
+          TAG: "ItemDeleted",
+          id: "b"
+        })
+      ]);
+      let sourceStream = ops.replayStream("as-src-1");
+      await Effect.runPromise(ops.appendStream(0, "as-dst-1", sourceStream));
+      let destEvents = await ops.replay("as-dst-1");
+      globalThis.expect(destEvents.length).toBe(2);
+    });
+    globalThis.test("copied events round-trip through decode correctly", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "as-src-2", [EventLogFixtures$ReventlessLocal.makeEvent$p("as-src-2", {
+          TAG: "ItemCreated",
+          name: "copied"
+        })]);
+      let sourceStream = ops.replayStream("as-src-2");
+      await Effect.runPromise(ops.appendStream(0, "as-dst-2", sourceStream));
+      let destEvents = await Effect.runPromise(Stream.runCollect(ops.replayStream("as-dst-2")));
+      let first = destEvents[0];
+      globalThis.expect(first).toEqual({
+        TAG: "ItemCreated",
+        name: "copied"
+      });
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/components/eventlog/EventLogConflictTest.res

@@ -0,0 +1,86 @@
+// Tests for optimistic locking conflict detection in EventLog (in-memory).
+
+open JestGlobals
+open EventLogFixtures
+
+describe("EventLog — conflict detection (in-memory)", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => reset())
+
+  testPromise("append with stale sequenceNr returns conflict error", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await ops.append(
+      0,
+      "conflict-1",
+      [makeEvent'("conflict-1", ItemEventLogSpec.ItemCreated({name: "First"}))],
+    )
+    // Now storage has 1 event for "conflict-1"; passing sequenceNr=0 again should conflict
+    let result = await ops.append(
+      0,
+      "conflict-1",
+      [makeEvent'("conflict-1", ItemEventLogSpec.ItemCreated({name: "Duplicate"}))],
+    )
+    expect(Result.isError(result))->toBe(true)
+  })
+
+  testPromise("append with correct sequenceNr succeeds after prior append", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await ops.append(
+      0,
+      "conflict-2",
+      [makeEvent'("conflict-2", ItemEventLogSpec.ItemCreated({name: "First"}))],
+    )
+    let result = await ops.append(
+      1,
+      "conflict-2",
+      [makeEvent'("conflict-2", ItemEventLogSpec.ItemDeleted({id: "conflict-2"}))],
+    )
+    expect(Result.isOk(result))->toBe(true)
+  })
+
+  testPromise("conflict does not publish events to event topic", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await ops.append(
+      0,
+      "conflict-3",
+      [makeEvent'("conflict-3", ItemEventLogSpec.ItemCreated({name: "First"}))],
+    )
+    reset() // Reset captured count after first append
+    let _ = await ops.append(
+      0,
+      "conflict-3",
+      [makeEvent'("conflict-3", ItemEventLogSpec.ItemCreated({name: "Duplicate"}))],
+    )
+    expect(capturedTopicEventCount.contents)->toBe(0)
+  })
+
+  testPromise("conflict does not store events", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await ops.append(
+      0,
+      "conflict-4",
+      [makeEvent'("conflict-4", ItemEventLogSpec.ItemCreated({name: "First"}))],
+    )
+    let _ = await ops.append(
+      0,
+      "conflict-4",
+      [makeEvent'("conflict-4", ItemEventLogSpec.ItemCreated({name: "Should not be stored"}))],
+    )
+    let replayed = await ops.replay("conflict-4")
+    expect(replayed->Array.length)->toBe(1)
+  })
+
+  testPromise("batch append with correct sequenceNr stores all events", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let result = await ops.append(0, "conflict-5", [
+      makeEvent'("conflict-5", ItemEventLogSpec.ItemCreated({name: "e1"})),
+      makeEvent'("conflict-5", ItemEventLogSpec.ItemDeleted({id: "e2"})),
+    ])
+    expect(Result.isOk(result))->toBe(true)
+    let replayed = await ops.replay("conflict-5")
+    expect(replayed->Array.length)->toBe(2)
+  })
+})

package/tests/components/eventlog/EventLogConflictTest.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as EventLogFixtures$ReventlessLocal from "./EventLogFixtures.res.mjs";
+
+globalThis.describe("EventLog — conflict detection (in-memory)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+  });
+  globalThis.beforeEach(() => EventLogFixtures$ReventlessLocal.reset());
+  globalThis.test("append with stale sequenceNr returns conflict error", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+    await ops.append(0, "conflict-1", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-1", {
+        TAG: "ItemCreated",
+        name: "First"
+      })]);
+    let result = await ops.append(0, "conflict-1", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-1", {
+        TAG: "ItemCreated",
+        name: "Duplicate"
+      })]);
+    globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+  });
+  globalThis.test("append with correct sequenceNr succeeds after prior append", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+    await ops.append(0, "conflict-2", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-2", {
+        TAG: "ItemCreated",
+        name: "First"
+      })]);
+    let result = await ops.append(1, "conflict-2", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-2", {
+        TAG: "ItemDeleted",
+        id: "conflict-2"
+      })]);
+    globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+  });
+  globalThis.test("conflict does not publish events to event topic", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+    await ops.append(0, "conflict-3", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-3", {
+        TAG: "ItemCreated",
+        name: "First"
+      })]);
+    EventLogFixtures$ReventlessLocal.reset();
+    await ops.append(0, "conflict-3", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-3", {
+        TAG: "ItemCreated",
+        name: "Duplicate"
+      })]);
+    globalThis.expect(EventLogFixtures$ReventlessLocal.capturedTopicEventCount.contents).toBe(0);
+  });
+  globalThis.test("conflict does not store events", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+    await ops.append(0, "conflict-4", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-4", {
+        TAG: "ItemCreated",
+        name: "First"
+      })]);
+    await ops.append(0, "conflict-4", [EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-4", {
+        TAG: "ItemCreated",
+        name: "Should not be stored"
+      })]);
+    let replayed = await ops.replay("conflict-4");
+    globalThis.expect(replayed.length).toBe(1);
+  });
+  globalThis.test("batch append with correct sequenceNr stores all events", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+    let result = await ops.append(0, "conflict-5", [
+      EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-5", {
+        TAG: "ItemCreated",
+        name: "e1"
+      }),
+      EventLogFixtures$ReventlessLocal.makeEvent$p("conflict-5", {
+        TAG: "ItemDeleted",
+        id: "e2"
+      })
+    ]);
+    globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    let replayed = await ops.replay("conflict-5");
+    globalThis.expect(replayed.length).toBe(2);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/eventlog/EventLogFixtures.res

@@ -0,0 +1,52 @@
+// Integration test fixtures for EventLog builder (in-memory).
+
+open TestFixtures
+
+// ─────────────────────────────────────────────────────────────
+// Test event spec
+// ─────────────────────────────────────────────────────────────
+
+module ItemEventLogSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestItemEventLog"
+
+  @schema
+  type event = | ItemCreated({name: string}) | ItemDeleted({id: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Bus and Pulumi setup
+// ─────────────────────────────────────────────────────────────
+
+module Bus = LocalBus.Make()
+
+// Capture events published to the event topic.
+// Topic name = Spec.name ++ "EventTopic" = "TestItemEventLogEventTopic"
+let capturedTopicEventCount: ref<int> = ref(0)
+let _ = Bus.subscribeToEvents("TestItemEventLogEventTopic", async (_, _, _) => {
+  capturedTopicEventCount := capturedTopicEventCount.contents + 1
+})
+
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Build EventLog using in-memory adapters directly
+// ─────────────────────────────────────────────────────────────
+
+module EventLogMaker = ReventlessCore.EventLog_Builder.Make(
+  ItemEventLogSpec,
+  EventLogStorage_InMemory,
+  LocalEventTopicPublisher.Make(Bus),
+)
+
+let eventLog = EventLogMaker.make(~name="TestItemEventLog")
+
+let makeEvent' = (id, event) => ({
+  Reventless.Message.id,
+  meta: testMeta,
+  event,
+}: Reventless.Message.event'<string, ItemEventLogSpec.event>)
+
+let reset = () => {
+  capturedTopicEventCount := 0
+}

package/tests/components/eventlog/EventLogFixtures.res.mjs

@@ -0,0 +1,80 @@
+// 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 LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as EventLog_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventLog/EventLog_Builder.res.mjs";
+import * as EventLogStorage_InMemory$ReventlessLocal from "../../../src/adapter/EventLog/EventLogStorage_InMemory.res.mjs";
+import * as LocalEventTopicPublisher$ReventlessLocal from "../../../src/adapter/EventTopic/LocalEventTopicPublisher.res.mjs";
+
+let name = "TestItemEventLog";
+
+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: name,
+  eventSchema: eventSchema
+};
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+let capturedTopicEventCount = {
+  contents: 0
+};
+
+Bus.subscribeToEvents("TestItemEventLogEventTopic", async (param, param$1, param$2) => {
+  capturedTopicEventCount.contents = capturedTopicEventCount.contents + 1 | 0;
+});
+
+TestRunner$ReventlessLocal.setup();
+
+let EventLogMaker = EventLog_Builder$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name,
+  eventSchema: eventSchema
+})({
+  make: EventLogStorage_InMemory$ReventlessLocal.make
+})(LocalEventTopicPublisher$ReventlessLocal.Make(Bus));
+
+let eventLog = EventLogMaker.make("TestItemEventLog", undefined);
+
+function makeEvent$p(id, event) {
+  return {
+    id: id,
+    meta: TestFixtures$ReventlessLocal.testMeta,
+    event: event
+  };
+}
+
+function reset() {
+  capturedTopicEventCount.contents = 0;
+}
+
+export {
+  ItemEventLogSpec,
+  Bus,
+  capturedTopicEventCount,
+  EventLogMaker,
+  eventLog,
+  makeEvent$p,
+  reset,
+}
+/* eventSchema Not a pure module */

package/tests/components/eventlog/EventLogStreamTest.res

@@ -0,0 +1,98 @@
+// Tests for EventLog.replayStream (Phase B of effect-stream-integration plan).
+// These tests verify the streaming replay API and the (state, count) fold pattern
+// used by Aggregate_Callback to replace the two-pass replay + Array.length approach.
+
+open JestGlobals
+open EventLogFixtures
+
+describe("EventLog.replayStream (in-memory adapter)", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => reset())
+
+  describe("basic streaming", () => {
+    testPromise("replayStream returns all appended events", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(0, "stream-1", [makeEvent'("stream-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))])
+      let _ = await ops.append(1, "stream-1", [makeEvent'("stream-1", ItemEventLogSpec.ItemDeleted({id: "stream-1"}))])
+      let count = await ops.replayStream("stream-1")
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      expect(count)->toBe(2)
+    })
+
+    testPromise("replayStream for unknown id returns empty stream", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let count = await ops.replayStream("no-such-id")
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      expect(count)->toBe(0)
+    })
+
+    testPromise("replayStream emits events in append order", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(0, "stream-2", [makeEvent'("stream-2", ItemEventLogSpec.ItemCreated({name: "First"}))])
+      let _ = await ops.append(1, "stream-2", [makeEvent'("stream-2", ItemEventLogSpec.ItemDeleted({id: "stream-2"}))])
+      let events = await ops.replayStream("stream-2")
+        ->Stream.runCollect
+        ->Effect.runPromise
+      expect(events->Array.length)->toBe(2)
+      // First emitted is the Created event
+      let first = events->Array.getUnsafe(0)
+      expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "First"}))
+    })
+
+    testPromise("separate aggregate IDs have independent streams", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(0, "agg-X", [makeEvent'("agg-X", ItemEventLogSpec.ItemCreated({name: "X"}))])
+      let _ = await ops.append(0, "agg-Y", [makeEvent'("agg-Y", ItemEventLogSpec.ItemCreated({name: "Y1"})), makeEvent'("agg-Y", ItemEventLogSpec.ItemDeleted({id: "agg-Y"}))])
+      let countX = await ops.replayStream("agg-X")
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      let countY = await ops.replayStream("agg-Y")
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      expect(countX)->toBe(1)
+      expect(countY)->toBe(2)
+    })
+
+    testPromise("take(2) on a 5-event log returns only 2 events", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(0, "stream-3", [
+        makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e1"})),
+        makeEvent'("stream-3", ItemEventLogSpec.ItemDeleted({id: "e2"})),
+        makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e3"})),
+        makeEvent'("stream-3", ItemEventLogSpec.ItemDeleted({id: "e4"})),
+        makeEvent'("stream-3", ItemEventLogSpec.ItemCreated({name: "e5"})),
+      ])
+      let first2 = await ops.replayStream("stream-3")
+        ->Stream.take(2)
+        ->Stream.runCollect
+        ->Effect.runPromise
+      expect(first2->Array.length)->toBe(2)
+    })
+  })
+
+  describe("tuple fold — (state, count) pattern used in Aggregate_Callback", () => {
+    testPromise("runFold produces correct count for sequenceNr", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(0, "fold-1", [makeEvent'("fold-1", ItemEventLogSpec.ItemCreated({name: "e1"})), makeEvent'("fold-1", ItemEventLogSpec.ItemDeleted({id: "e2"}))])
+      let _ = await ops.append(2, "fold-1", [makeEvent'("fold-1", ItemEventLogSpec.ItemCreated({name: "e3"}))])
+      let (_state, count) = await ops.replayStream("fold-1")
+        ->Stream.runFold((None, 0), ((st, n), _ev) => (st, n + 1))
+        ->Effect.runPromise
+      expect(count)->toBe(3)
+    })
+
+    testPromise("runFold on empty stream returns initial accumulator", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let (state, count) = await ops.replayStream("unknown-fold")
+        ->Stream.runFold((None, 0), ((st, n), _ev) => (st, n + 1))
+        ->Effect.runPromise
+      expect(state)->toEqual(None)
+      expect(count)->toBe(0)
+    })
+  })
+})

package/tests/components/eventlog/EventLogStreamTest.res.mjs

@@ -0,0 +1,142 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as EventLogFixtures$ReventlessLocal from "./EventLogFixtures.res.mjs";
+
+globalThis.describe("EventLog.replayStream (in-memory adapter)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+  });
+  globalThis.beforeEach(() => EventLogFixtures$ReventlessLocal.reset());
+  globalThis.describe("basic streaming", () => {
+    globalThis.test("replayStream returns all appended events", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "stream-1", [EventLogFixtures$ReventlessLocal.makeEvent$p("stream-1", {
+          TAG: "ItemCreated",
+          name: "Widget"
+        })]);
+      await ops.append(1, "stream-1", [EventLogFixtures$ReventlessLocal.makeEvent$p("stream-1", {
+          TAG: "ItemDeleted",
+          id: "stream-1"
+        })]);
+      let count = await Effect.runPromise(Stream$1.runFold(ops.replayStream("stream-1"), 0, (n, param) => n + 1 | 0));
+      globalThis.expect(count).toBe(2);
+    });
+    globalThis.test("replayStream for unknown id returns empty stream", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      let count = await Effect.runPromise(Stream$1.runFold(ops.replayStream("no-such-id"), 0, (n, param) => n + 1 | 0));
+      globalThis.expect(count).toBe(0);
+    });
+    globalThis.test("replayStream emits events in append order", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "stream-2", [EventLogFixtures$ReventlessLocal.makeEvent$p("stream-2", {
+          TAG: "ItemCreated",
+          name: "First"
+        })]);
+      await ops.append(1, "stream-2", [EventLogFixtures$ReventlessLocal.makeEvent$p("stream-2", {
+          TAG: "ItemDeleted",
+          id: "stream-2"
+        })]);
+      let events = await Effect.runPromise(Stream.runCollect(ops.replayStream("stream-2")));
+      globalThis.expect(events.length).toBe(2);
+      let first = events[0];
+      globalThis.expect(first).toEqual({
+        TAG: "ItemCreated",
+        name: "First"
+      });
+    });
+    globalThis.test("separate aggregate IDs have independent streams", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "agg-X", [EventLogFixtures$ReventlessLocal.makeEvent$p("agg-X", {
+          TAG: "ItemCreated",
+          name: "X"
+        })]);
+      await ops.append(0, "agg-Y", [
+        EventLogFixtures$ReventlessLocal.makeEvent$p("agg-Y", {
+          TAG: "ItemCreated",
+          name: "Y1"
+        }),
+        EventLogFixtures$ReventlessLocal.makeEvent$p("agg-Y", {
+          TAG: "ItemDeleted",
+          id: "agg-Y"
+        })
+      ]);
+      let countX = await Effect.runPromise(Stream$1.runFold(ops.replayStream("agg-X"), 0, (n, param) => n + 1 | 0));
+      let countY = await Effect.runPromise(Stream$1.runFold(ops.replayStream("agg-Y"), 0, (n, param) => n + 1 | 0));
+      globalThis.expect(countX).toBe(1);
+      globalThis.expect(countY).toBe(2);
+    });
+    globalThis.test("take(2) on a 5-event log returns only 2 events", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "stream-3", [
+        EventLogFixtures$ReventlessLocal.makeEvent$p("stream-3", {
+          TAG: "ItemCreated",
+          name: "e1"
+        }),
+        EventLogFixtures$ReventlessLocal.makeEvent$p("stream-3", {
+          TAG: "ItemDeleted",
+          id: "e2"
+        }),
+        EventLogFixtures$ReventlessLocal.makeEvent$p("stream-3", {
+          TAG: "ItemCreated",
+          name: "e3"
+        }),
+        EventLogFixtures$ReventlessLocal.makeEvent$p("stream-3", {
+          TAG: "ItemDeleted",
+          id: "e4"
+        }),
+        EventLogFixtures$ReventlessLocal.makeEvent$p("stream-3", {
+          TAG: "ItemCreated",
+          name: "e5"
+        })
+      ]);
+      let first2 = await Effect.runPromise(Stream.runCollect(Stream$1.take(ops.replayStream("stream-3"), 2)));
+      globalThis.expect(first2.length).toBe(2);
+    });
+  });
+  globalThis.describe("tuple fold — (state, count) pattern used in Aggregate_Callback", () => {
+    globalThis.test("runFold produces correct count for sequenceNr", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      await ops.append(0, "fold-1", [
+        EventLogFixtures$ReventlessLocal.makeEvent$p("fold-1", {
+          TAG: "ItemCreated",
+          name: "e1"
+        }),
+        EventLogFixtures$ReventlessLocal.makeEvent$p("fold-1", {
+          TAG: "ItemDeleted",
+          id: "e2"
+        })
+      ]);
+      await ops.append(2, "fold-1", [EventLogFixtures$ReventlessLocal.makeEvent$p("fold-1", {
+          TAG: "ItemCreated",
+          name: "e3"
+        })]);
+      let match = await Effect.runPromise(Stream$1.runFold(ops.replayStream("fold-1"), [
+        undefined,
+        0
+      ], (param, _ev) => [
+        param[0],
+        param[1] + 1 | 0
+      ]));
+      globalThis.expect(match[1]).toBe(3);
+    });
+    globalThis.test("runFold on empty stream returns initial accumulator", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventLogFixtures$ReventlessLocal.eventLog));
+      let match = await Effect.runPromise(Stream$1.runFold(ops.replayStream("unknown-fold"), [
+        undefined,
+        0
+      ], (param, _ev) => [
+        param[0],
+        param[1] + 1 | 0
+      ]));
+      globalThis.expect(match[0]).toEqual(undefined);
+      globalThis.expect(match[1]).toBe(0);
+    });
+  });
+});
+
+/*  Not a pure module */