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

package/tests/adapter/BackendParityTest.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
@@ -65,6 +67,49 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderMemory(scenario);
     return await runUnderSqlite(scenario);
   });
+  globalThis.test("QueryDb: count returns a running total and loadStream reflects it under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-count", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let r1 = await ops.count("prod-1", "orderCount", 3);
+      globalThis.expect(r1).toEqual({
+        TAG: "Ok",
+        _0: 3
+      });
+      let r2 = await ops.count("prod-1", "orderCount", 2);
+      globalThis.expect(r2).toEqual({
+        TAG: "Ok",
+        _0: 5
+      });
+      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("prod-1")), param => Effect.succeed([])));
+      globalThis.expect(items.length).toBe(1);
+      let field = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(items[0]), o => o["orderCount"]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+      globalThis.expect(field).toBe(5);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
+  globalThis.test("QueryDb: an expired-TTL item is filtered from loadStream under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-ttl", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let item = k => Object.fromEntries([[
+          "id",
+          k
+        ]]);
+      let readCount = async k => (await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream(k)), param => Effect.succeed([])))).length;
+      await ops.save("live", item("live"), "Any", undefined);
+      await ops.save("dead", item("dead"), "Any", 1);
+      globalThis.expect(await readCount("live")).toBe(1);
+      globalThis.expect(await readCount("dead")).toBe(0);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
   globalThis.test("EventLog: conflict detection works under both", async () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});

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)
+    })
+  })
+})

package/tests/adapter/EventLogSnapshotParityTest.res.mjs

@@ -0,0 +1,141 @@
+// 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 LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as EventLogStorage_Sqlite$ReventlessLocal from "../../src/adapter/EventLog/EventLogStorage_Sqlite.res.mjs";
+import * as EventLogStorage_InMemory$ReventlessLocal from "../../src/adapter/EventLog/EventLogStorage_InMemory.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+function makeMemoryOps() {
+  let s = EventLogStorage_InMemory$ReventlessLocal.make("parity", opts);
+  return TestRunner$ReventlessLocal.resolve(s.operations);
+}
+
+function makeSqliteOps() {
+  let TestBus = LocalBus$ReventlessLocal.Make({});
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  let DbProvider = {
+    db: db
+  };
+  let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+  let s = Storage.make("parity", opts);
+  return TestRunner$ReventlessLocal.resolve(s.operations);
+}
+
+let backends = [
+  [
+    "memory",
+    makeMemoryOps
+  ],
+  [
+    "sqlite",
+    makeSqliteOps
+  ]
+];
+
+globalThis.describe("EventLog snapshot backend parity", () => {
+  backends.forEach(param => {
+    let makeOps = param[1];
+    let label = param[0];
+    globalThis.test(label + `: latestSnapshot is None before any write`, async () => {
+      let ops = await makeOps();
+      globalThis.expect(await ops.latestSnapshot("id-1")).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+    });
+    globalThis.test(label + `: snapshot round-trips and keep-one overwrites`, async () => {
+      let ops = await makeOps();
+      let state = Object.fromEntries([[
+          "n",
+          1
+        ]]);
+      globalThis.expect(await ops.writeSnapshot("id-1", {
+        seqNr: 2,
+        state: state,
+        schemaHash: "h1"
+      })).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+      globalThis.expect(await ops.latestSnapshot("id-1")).toEqual({
+        TAG: "Ok",
+        _0: {
+          seqNr: 2,
+          state: state,
+          schemaHash: "h1"
+        }
+      });
+      let state2 = Object.fromEntries([[
+          "n",
+          9
+        ]]);
+      await ops.writeSnapshot("id-1", {
+        seqNr: 9,
+        state: state2,
+        schemaHash: "h2"
+      });
+      globalThis.expect(await ops.latestSnapshot("id-1")).toEqual({
+        TAG: "Ok",
+        _0: {
+          seqNr: 9,
+          state: state2,
+          schemaHash: "h2"
+        }
+      });
+    });
+    globalThis.test(label + `: snapshots are per-aggregate-id`, async () => {
+      let ops = await makeOps();
+      let state = Object.fromEntries([[
+          "n",
+          1
+        ]]);
+      await ops.writeSnapshot("id-a", {
+        seqNr: 1,
+        state: state,
+        schemaHash: "h"
+      });
+      globalThis.expect(await ops.latestSnapshot("id-b")).toEqual({
+        TAG: "Ok",
+        _0: undefined
+      });
+    });
+    globalThis.test(label + `: replayStream ~fromSeq equals the tail of a full replay`, async () => {
+      let ops = await makeOps();
+      let ev = i => Object.fromEntries([[
+          "i",
+          i
+        ]]);
+      await ops.append(0, "id-1", [
+        ev(0),
+        ev(1),
+        ev(2),
+        ev(3),
+        ev(4)
+      ]);
+      let delta = await Effect.runPromise(Stream.runCollect(ops.replayStream("id-1", 3)));
+      globalThis.expect(delta).toEqual([
+        ev(3),
+        ev(4)
+      ]);
+      let empty = await Effect.runPromise(Stream.runCollect(ops.replayStream("id-1", 5)));
+      globalThis.expect(empty).toEqual([]);
+      let full = await Effect.runPromise(Stream.runCollect(ops.replayStream("id-1", undefined)));
+      globalThis.expect(full.length).toBe(5);
+    });
+  });
+});
+
+export {
+  opts,
+  makeMemoryOps,
+  makeSqliteOps,
+  backends,
+}
+/*  Not a pure module */