@reventlessdev/reventless-local 3.0.0-alpha.115 → 3.0.0-alpha.116

package/src/test/Mocks/MockEventLogStorage.res

@@ -27,8 +27,22 @@ let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOption
     events.contents->Dict.get(id)->Option.getOr([])
   }
 
-  let replayStream: string => Stream.t<JSON.t, string, unit> = id =>
-    events.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable
+  let replayStream = (id, ~fromSeq=0) =>
+    events.contents
+    ->Dict.get(id)
+    ->Option.getOr([])
+    ->Array.filterWithIndex((_, i) => i >= fromSeq)
+    ->Stream.fromIterable
+
+  let snapshots: dict<ReventlessCore.EventLog.snapshot> = Dict.make()
+
+  let latestSnapshot: ReventlessCore.EventLog.latestSnapshot<string> = async id =>
+    Ok(snapshots->Dict.get(id))
+
+  let writeSnapshot: ReventlessCore.EventLog.writeSnapshot<string> = async (id, snap) => {
+    snapshots->Dict.set(id, snap)
+    Ok()
+  }
 
   let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (_startingSeqNr, id, stream) =>
     stream->Stream.runForEach(json =>
@@ -45,11 +59,14 @@ let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOption
       replay,
       replayStream,
       appendStream,
+      latestSnapshot,
+      writeSnapshot,
     }),
   }
 
   let reset = () => {
     events := Dict.make()
+    snapshots->Dict.forEachWithKey((_, k) => snapshots->Dict.delete(k))
     failNextAppends := 0
   }
 

package/src/test/Mocks/MockEventLogStorage.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
@@ -35,7 +36,22 @@ function make($staropt$star, $staropt$star$1) {
     };
   };
   let replay = async id => Stdlib_Option.getOr(events.contents[id], []);
-  let replayStream = id => Stream.fromIterable(Stdlib_Option.getOr(events.contents[id], []));
+  let replayStream = (id, fromSeqOpt) => {
+    let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+    return Stream.fromIterable(Stdlib_Option.getOr(events.contents[id], []).filter((param, i) => i >= fromSeq));
+  };
+  let snapshots = {};
+  let latestSnapshot = async id => ({
+    TAG: "Ok",
+    _0: snapshots[id]
+  });
+  let writeSnapshot = async (id, snap) => {
+    snapshots[id] = snap;
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
   let appendStream = (_startingSeqNr, id, stream) => Stream.runForEach(stream, json => Effect.sync(() => {
     let existing = Stdlib_Option.getOr(events.contents[id], []);
     events.contents[id] = existing.concat([json]);
@@ -45,7 +61,9 @@ function make($staropt$star, $staropt$star$1) {
     append: append,
     replay: replay,
     replayStream: replayStream,
-    appendStream: appendStream
+    appendStream: appendStream,
+    latestSnapshot: latestSnapshot,
+    writeSnapshot: writeSnapshot
   });
   let storage = {
     resources: storage_resources,
@@ -53,6 +71,7 @@ function make($staropt$star, $staropt$star$1) {
   };
   let reset = () => {
     events.contents = {};
+    Stdlib_Dict.forEachWithKey(snapshots, (param, k) => Stdlib_Dict.$$delete(snapshots, k));
     failNextAppends.contents = 0;
   };
   return {

package/tests/PluginEventDecodeTest.res

@@ -0,0 +1,51 @@
+// Regression: subscribeToPluginEvents' Source-C emission decoded the WHOLE bus
+// envelope {id, meta, event} with the bare Plugin event schema — convert mode
+// "succeeded" and then threw a TypeError on every variant's payload access, so
+// the onPluginStatusChange / onUIFragmentChange subscription emissions never
+// fired on the local platform. decodePluginEventEnvelope must decode the
+// payload under "event" and degrade to None on anything malformed.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let meta = ReventlessCore.Message.generateMeta(~service=ReventlessCore.PluginSpec.name)
+
+let envelopeOf = (event: ReventlessCore.PluginSpec.event) =>
+  ReventlessCore.Message.composeEventJson'(
+    "Catalog",
+    meta,
+    event->S.reverseConvertToJsonOrThrow(ReventlessCore.PluginSpec.eventSchema),
+  )
+
+describe("Platform.decodePluginEventEnvelope", () => {
+  testSync("decodes a VersionConnected event from the published envelope", () => {
+    let envelope = envelopeOf(VersionConnected(Plugin_Fixtures.pluginDefinition))
+    switch Platform.decodePluginEventEnvelope(envelope) {
+    | Some(VersionConnected(def)) => expect(def.name)->toBe(Plugin_Fixtures.pluginDefinition.name)
+    | _ => expect("VersionConnected")->toBe("something else")
+    }
+  })
+
+  testSync("decodes a payload-light variant (VersionDetected)", () => {
+    let envelope = envelopeOf(VersionDetected("2.0.0"))
+    expect(Platform.decodePluginEventEnvelope(envelope))->toEqual(
+      Some(ReventlessCore.PluginSpec.VersionDetected("2.0.0")),
+    )
+  })
+
+  testSync("returns None for a bare event JSON (no envelope) and malformed input", () => {
+    // The old bug class: input that is not the {id, meta, event} envelope.
+    let bare =
+      ReventlessCore.PluginSpec.VersionDetected("2.0.0")->S.reverseConvertToJsonOrThrow(
+        ReventlessCore.PluginSpec.eventSchema,
+      )
+    expect(Platform.decodePluginEventEnvelope(bare))->toEqual(None)
+    expect(Platform.decodePluginEventEnvelope(JSON.Encode.string("junk")))->toEqual(None)
+    expect(
+      Platform.decodePluginEventEnvelope(
+        JSON.Encode.object(Dict.fromArray([("event", JSON.Encode.object(Dict.make()))])),
+      ),
+    )->toEqual(None)
+  })
+})

package/tests/PluginEventDecodeTest.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Platform$ReventlessLocal from "../src/Platform.res.mjs";
+import * as PluginSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.res.mjs";
+import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
+import * as Plugin_Fixtures$ReventlessLocal from "./plugin/Plugin_Fixtures.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let meta = Message$ReventlessCore.generateMeta(PluginSpec$ReventlessCore.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+
+function envelopeOf(event) {
+  return Message$ReventlessCore.composeEventJson$p("Catalog", meta, S.reverseConvertToJsonOrThrow(event, PluginSpec$ReventlessCore.eventSchema));
+}
+
+globalThis.describe("Platform.decodePluginEventEnvelope", () => {
+  globalThis.test("decodes a VersionConnected event from the published envelope", () => {
+    let envelope = envelopeOf({
+      TAG: "VersionConnected",
+      _0: Plugin_Fixtures$ReventlessLocal.pluginDefinition
+    });
+    let match = Platform$ReventlessLocal.decodePluginEventEnvelope(envelope);
+    if (match !== undefined) {
+      if (match.TAG === "VersionConnected") {
+        globalThis.expect(match._0.name).toBe(Plugin_Fixtures$ReventlessLocal.pluginDefinition.name);
+        return;
+      }
+      globalThis.expect("VersionConnected").toBe("something else");
+      return;
+    }
+    globalThis.expect("VersionConnected").toBe("something else");
+  });
+  globalThis.test("decodes a payload-light variant (VersionDetected)", () => {
+    let envelope = envelopeOf({
+      TAG: "VersionDetected",
+      _0: "2.0.0"
+    });
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope(envelope)).toEqual({
+      TAG: "VersionDetected",
+      _0: "2.0.0"
+    });
+  });
+  globalThis.test("returns None for a bare event JSON (no envelope) and malformed input", () => {
+    let bare = S.reverseConvertToJsonOrThrow({
+      TAG: "VersionDetected",
+      _0: "2.0.0"
+    }, PluginSpec$ReventlessCore.eventSchema);
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope(bare)).toEqual(undefined);
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope("junk")).toEqual(undefined);
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope(Object.fromEntries([[
+        "event",
+        {}
+      ]]))).toEqual(undefined);
+  });
+});
+
+export {
+  meta,
+  envelopeOf,
+}
+/*  Not a pure module */

package/tests/adapter/DcbEventLogStorageSqliteTest.res

@@ -83,6 +83,79 @@ describe("DcbEventLogStorage_Sqlite", () => {
     })
   })
 
+  testPromise("batched tag hydration preserves per-event tags and order", async () => {
+    await runUnderSqlite(async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(
+        ~name="dcb-multitag",
+        ~indexes=[],
+        ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+
+      // e1 carries three tags (declaration order matters); e2 carries one; e3 none.
+      let e1 = stored(
+        "Multi",
+        [
+          {key: "a", value: "1"},
+          {key: "b", value: "2"},
+          {key: "c", value: "3"},
+        ],
+        JSON.Encode.string("first"),
+      )
+      let e2 = stored("Single", [{key: "only", value: "z"}], JSON.Encode.string("second"))
+      let e3 = stored("None", [], JSON.Encode.string("third"))
+      let _ = await ops.append([e1])
+      let _ = await ops.append([e2])
+      let _ = await ops.append([e3])
+
+      let read = await ops.read(~query=[])
+      expect(read.events->Array.length)->toBe(3)
+      let first = read.events->Array.getUnsafe(0)
+      // Order and grouping survive the single batched IN query.
+      expect(first.tags->Array.map(t => t.key))->toEqual(["a", "b", "c"])
+      expect(first.tags->Array.map(t => t.value))->toEqual(["1", "2", "3"])
+      let second = read.events->Array.getUnsafe(1)
+      expect(second.tags->Array.length)->toBe(1)
+      expect((second.tags->Array.getUnsafe(0)).key)->toBe("only")
+      let third = read.events->Array.getUnsafe(2)
+      expect(third.tags->Array.length)->toBe(0)
+    })
+  })
+
+  testPromise("append with a non-conflicting condition succeeds", async () => {
+    await runUnderSqlite(async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      let s = Storage.make(
+        ~name="dcb-noconflict",
+        ~indexes=[],
+        ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+
+      let _ = await ops.append([stored("Created", [{key: "id", value: "x"}], JSON.Encode.string("a"))])
+      // Condition queries a tag value that does not exist → anyMatch is false →
+      // the append is allowed.
+      let cond: Reventless.DcbTag.appendCondition = {
+        query: [{tags: [{key: "id", value: "other"}]}],
+      }
+      let result = await ops.append(
+        [stored("Created", [{key: "id", value: "other"}], JSON.Encode.string("b"))],
+        ~condition=cond,
+      )
+      switch result {
+      | Ok(_) => expect(true)->toBe(true)
+      | Error(m) => expect(m)->toBe("expected Ok")
+      }
+      let read = await ops.read(~query=[])
+      expect(read.events->Array.length)->toBe(2)
+    })
+  })
+
   testPromise("append with conflicting condition returns Error", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()

package/tests/adapter/DcbEventLogStorageSqliteTest.res.mjs

@@ -88,6 +88,92 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
       }], undefined);
     globalThis.expect(read.events.length).toBe(2);
   }));
+  globalThis.test("batched tag hydration preserves per-event tags and order", async () => await runUnderSqlite(async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("dcb-multitag", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let e1 = stored("Multi", [
+      {
+        key: "a",
+        value: "1"
+      },
+      {
+        key: "b",
+        value: "2"
+      },
+      {
+        key: "c",
+        value: "3"
+      }
+    ], "first");
+    let e2 = stored("Single", [{
+        key: "only",
+        value: "z"
+      }], "second");
+    let e3 = stored("None", [], "third");
+    await ops.append([e1], undefined);
+    await ops.append([e2], undefined);
+    await ops.append([e3], undefined);
+    let read = await ops.read([], undefined);
+    globalThis.expect(read.events.length).toBe(3);
+    let first = read.events[0];
+    globalThis.expect(first.tags.map(t => t.key)).toEqual([
+      "a",
+      "b",
+      "c"
+    ]);
+    globalThis.expect(first.tags.map(t => t.value)).toEqual([
+      "1",
+      "2",
+      "3"
+    ]);
+    let second = read.events[1];
+    globalThis.expect(second.tags.length).toBe(1);
+    globalThis.expect(second.tags[0].key).toBe("only");
+    let third = read.events[2];
+    globalThis.expect(third.tags.length).toBe(0);
+  }));
+  globalThis.test("append with a non-conflicting condition succeeds", async () => await runUnderSqlite(async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("dcb-noconflict", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.append([stored("Created", [{
+          key: "id",
+          value: "x"
+        }], "a")], undefined);
+    let cond_query = [{
+        tags: [{
+            key: "id",
+            value: "other"
+          }]
+      }];
+    let cond = {
+      query: cond_query
+    };
+    let result = await ops.append([stored("Created", [{
+          key: "id",
+          value: "other"
+        }], "b")], cond);
+    if (result.TAG === "Ok") {
+      globalThis.expect(true).toBe(true);
+    } else {
+      globalThis.expect(result._0).toBe("expected Ok");
+    }
+    let read = await ops.read([], undefined);
+    globalThis.expect(read.events.length).toBe(2);
+  }));
   globalThis.test("append with conflicting condition returns Error", async () => await runUnderSqlite(async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});
     let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);

package/tests/adapter/DcbEventLogStorageTest.res

@@ -96,6 +96,52 @@ describe("DcbEventLogStorage_InMemory", () => {
       expect(firstEvent.tags->Array.length)->toBe(1)
     })
 
+    testPromise("multi-tag clause matches only events carrying ALL tags", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([
+        makeEvent(
+          ~eventType="Evt",
+          ~data=JSON.Null,
+          ~tags=[{Reventless.DcbTag.key: "tenant", value: "acme"}, {key: "region", value: "eu"}],
+        ),
+        makeEvent(~eventType="Evt", ~data=JSON.Null, ~tags=[{Reventless.DcbTag.key: "tenant", value: "acme"}]),
+        makeEvent(~eventType="Evt", ~data=JSON.Null, ~tags=[{Reventless.DcbTag.key: "region", value: "eu"}]),
+      ])
+      // Intersection of the two tags' posting lists → only the first event.
+      let result = await ops.read(
+        ~query=[
+          {
+            Reventless.DcbTag.tags: [
+              {Reventless.DcbTag.key: "tenant", value: "acme"},
+              {key: "region", value: "eu"},
+            ],
+          },
+        ],
+      )
+      expect(result.events->Array.length)->toBe(1)
+    })
+
+    testPromise("OR of clauses unions matches across clauses in position order", async () => {
+      let storage = makeStorage()
+      let ops = await storage.operations->TestRunner.resolve
+      let _ = await ops.append([
+        makeEvent(~eventType="A", ~data=JSON.Null),
+        makeEvent(~eventType="B", ~data=JSON.Null, ~tags=[{Reventless.DcbTag.key: "x", value: "1"}]),
+        makeEvent(~eventType="C", ~data=JSON.Null),
+      ])
+      // Clause 1 (type A) ∪ clause 2 (tag x=1) → events at positions 1 and 2.
+      let result = await ops.read(
+        ~query=[
+          {Reventless.DcbTag.eventTypes: ["A"]},
+          {Reventless.DcbTag.tags: [{Reventless.DcbTag.key: "x", value: "1"}]},
+        ],
+      )
+      expect(result.events->Array.length)->toBe(2)
+      expect((result.events->Array.getUnsafe(0)).eventType)->toBe("A")
+      expect((result.events->Array.getUnsafe(1)).eventType)->toBe("B")
+    })
+
     testPromise("after parameter skips events at or before that position", async () => {
       let storage = makeStorage()
       let ops = await storage.operations->TestRunner.resolve

package/tests/adapter/DcbEventLogStorageTest.res.mjs

@@ -102,6 +102,69 @@ globalThis.describe("DcbEventLogStorage_InMemory", () => {
       let firstEvent = result.events[0];
       globalThis.expect(firstEvent.tags.length).toBe(1);
     });
+    globalThis.test("multi-tag clause matches only events carrying ALL tags", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([
+        makeEvent("Evt", null, [
+          {
+            key: "tenant",
+            value: "acme"
+          },
+          {
+            key: "region",
+            value: "eu"
+          }
+        ]),
+        makeEvent("Evt", null, [{
+            key: "tenant",
+            value: "acme"
+          }]),
+        makeEvent("Evt", null, [{
+            key: "region",
+            value: "eu"
+          }])
+      ], undefined);
+      let result = await ops.read([{
+          tags: [
+            {
+              key: "tenant",
+              value: "acme"
+            },
+            {
+              key: "region",
+              value: "eu"
+            }
+          ]
+        }], undefined);
+      globalThis.expect(result.events.length).toBe(1);
+    });
+    globalThis.test("OR of clauses unions matches across clauses in position order", async () => {
+      let storage = makeStorage();
+      let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+      await ops.append([
+        makeEvent("A", null, undefined),
+        makeEvent("B", null, [{
+            key: "x",
+            value: "1"
+          }]),
+        makeEvent("C", null, undefined)
+      ], undefined);
+      let result = await ops.read([
+        {
+          eventTypes: ["A"]
+        },
+        {
+          tags: [{
+              key: "x",
+              value: "1"
+            }]
+        }
+      ], undefined);
+      globalThis.expect(result.events.length).toBe(2);
+      globalThis.expect(result.events[0].eventType).toBe("A");
+      globalThis.expect(result.events[1].eventType).toBe("B");
+    });
     globalThis.test("after parameter skips events at or before that position", async () => {
       let storage = makeStorage();
       let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);

package/tests/adapter/EventLogSnapshotParityTest.res

@@ -0,0 +1,81 @@
+// Backend-parity tests for the EventLog snapshot ops
+// (docs/plans/aggregate-snapshotting.md): the in-memory and SQLite backends
+// must behave identically for latestSnapshot / writeSnapshot (keep-one) and
+// the replayStream ~fromSeq delta read, so GWT/local tests of
+// snapshot-enabled aggregates give the same results under either backend.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let makeMemoryOps = () => {
+  let s = EventLogStorage_InMemory.make(~name="parity", ~opts)
+  s.operations->TestRunner.resolve
+}
+
+let makeSqliteOps = () => {
+  module TestBus = LocalBus.Make()
+  module DbProvider = {
+    let db = SqliteDriver.openDb(~path=":memory:")
+  }
+  module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
+  let s = Storage.make(~name="parity", ~opts)
+  s.operations->TestRunner.resolve
+}
+
+let backends = [("memory", makeMemoryOps), ("sqlite", makeSqliteOps)]
+
+describe("EventLog snapshot backend parity", () => {
+  backends->Array.forEach(((label, makeOps)) => {
+    testPromise(`${label}: latestSnapshot is None before any write`, async () => {
+      let ops = await makeOps()
+      expect(await ops.latestSnapshot("id-1"))->toEqual(Ok(None))
+    })
+
+    testPromise(`${label}: snapshot round-trips and keep-one overwrites`, async () => {
+      let ops = await makeOps()
+      let state = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(1))]))
+      expect(
+        await ops.writeSnapshot(
+          "id-1",
+          {ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"},
+        ),
+      )->toEqual(Ok())
+      expect(await ops.latestSnapshot("id-1"))->toEqual(
+        Ok(Some({ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"})),
+      )
+      let state2 = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(9))]))
+      let _ = await ops.writeSnapshot(
+        "id-1",
+        {ReventlessCore.EventLog.seqNr: 9, state: state2, schemaHash: "h2"},
+      )
+      expect(await ops.latestSnapshot("id-1"))->toEqual(
+        Ok(Some({ReventlessCore.EventLog.seqNr: 9, state: state2, schemaHash: "h2"})),
+      )
+    })
+
+    testPromise(`${label}: snapshots are per-aggregate-id`, async () => {
+      let ops = await makeOps()
+      let state = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(1))]))
+      let _ = await ops.writeSnapshot(
+        "id-a",
+        {ReventlessCore.EventLog.seqNr: 1, state, schemaHash: "h"},
+      )
+      expect(await ops.latestSnapshot("id-b"))->toEqual(Ok(None))
+    })
+
+    testPromise(`${label}: replayStream ~fromSeq equals the tail of a full replay`, async () => {
+      let ops = await makeOps()
+      let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
+      let _ = await ops.append(0, "id-1", [ev(0), ev(1), ev(2), ev(3), ev(4)])
+      let delta = await ops.replayStream("id-1", ~fromSeq=3)->Stream.runCollect->Effect.runPromise
+      expect(delta)->toEqual([ev(3), ev(4)])
+      // fromSeq at the head yields nothing; omitted fromSeq yields everything.
+      let empty = await ops.replayStream("id-1", ~fromSeq=5)->Stream.runCollect->Effect.runPromise
+      expect(empty)->toEqual([])
+      let full = await ops.replayStream("id-1")->Stream.runCollect->Effect.runPromise
+      expect(full->Array.length)->toBe(5)
+    })
+  })
+})