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

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 */

package/tests/adapter/EventLogStorageSqliteTest.res

@@ -61,6 +61,52 @@ describe("EventLogStorage_Sqlite", () => {
     }
   })
 
+  testPromise("multi-event append advances the expected seq via MAX(seq_nr)+1", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = makeFreshDb()
+    }
+    module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
+    let s = Storage.make(~name="agg", ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
+    // Batch of three at seq 0 → occupies seq 0,1,2.
+    let r1 = await ops.append(0, "id-m", [ev(0), ev(1), ev(2)])
+    expect(r1)->toEqual(Ok())
+    // A stale seq (2) is a conflict; the correct next seq is 3.
+    let stale = await ops.append(2, "id-m", [ev(9)])
+    switch stale {
+    | Error(ReventlessCore.EventLog.Conflict) => expect(true)->toBe(true)
+    | _ => expect("expected Conflict")->toBe("other")
+    }
+    let r2 = await ops.append(3, "id-m", [ev(3)])
+    expect(r2)->toEqual(Ok())
+    let replayed = await ops.replay("id-m")
+    expect(replayed->Array.length)->toBe(4)
+  })
+
+  testPromise("appendStream persists the whole batch in order from the starting seq", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = makeFreshDb()
+    }
+    module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
+    let s = Storage.make(~name="agg", ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
+    // Seed one event, then stream three more starting at seq 1.
+    let _ = await ops.append(0, "id-s", [ev(0)])
+    let _ =
+      await ops.appendStream(1, "id-s", Stream.fromIterable([ev(1), ev(2), ev(3)]))
+      ->Effect.runPromise
+    let replayed = await ops.replay("id-s")
+    expect(replayed->Array.length)->toBe(4)
+    expect(replayed->Array.getUnsafe(0))->toEqual(ev(0))
+    expect(replayed->Array.getUnsafe(3))->toEqual(ev(3))
+  })
+
   testPromise("replay returns empty array for unknown id", async () => {
     module TestBus = LocalBus.Make()
     module DbProvider = {
@@ -75,6 +121,88 @@ describe("EventLogStorage_Sqlite", () => {
     expect(replayed->Array.length)->toBe(0)
   })
 
+  testPromise("replayStream ~fromSeq reads only the delta", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = makeFreshDb()
+    }
+    module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
+    let s = Storage.make(~name="agg", ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
+    let _ = await ops.append(0, "id-d", [ev(0), ev(1), ev(2), ev(3)])
+    let delta = await ops.replayStream("id-d", ~fromSeq=2)->Stream.runCollect->Effect.runPromise
+    expect(delta)->toEqual([ev(2), ev(3)])
+    // Omitted fromSeq still replays from 0 (unchanged default).
+    let full = await ops.replayStream("id-d")->Stream.runCollect->Effect.runPromise
+    expect(full->Array.length)->toBe(4)
+  })
+
+  testPromise("snapshot round-trip with keep-one overwrite", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = makeFreshDb()
+    }
+    module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
+    let s = Storage.make(~name="agg", ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let none = await ops.latestSnapshot("id-snap")
+    expect(none)->toEqual(Ok(None))
+
+    let state = JSON.Encode.object(Dict.fromArray([("names", JSON.Encode.int(2))]))
+    let w1 = await ops.writeSnapshot(
+      "id-snap",
+      {ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"},
+    )
+    expect(w1)->toEqual(Ok())
+    let r1 = await ops.latestSnapshot("id-snap")
+    expect(r1)->toEqual(Ok(Some({ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"})))
+
+    // Keep-one: a later write replaces the row, it does not accumulate.
+    let state5 = JSON.Encode.object(Dict.fromArray([("names", JSON.Encode.int(5))]))
+    let _ = await ops.writeSnapshot(
+      "id-snap",
+      {ReventlessCore.EventLog.seqNr: 5, state: state5, schemaHash: "h2"},
+    )
+    let r2 = await ops.latestSnapshot("id-snap")
+    expect(r2)->toEqual(
+      Ok(Some({ReventlessCore.EventLog.seqNr: 5, state: state5, schemaHash: "h2"})),
+    )
+  })
+
+  testPromise("snapshots persist across a reopen of the database file", async () => {
+    let path = `/tmp/reventless-test-snapshot-${Float.toString(Date.now())}.db`
+    let state = JSON.Encode.object(Dict.fromArray([("v", JSON.Encode.int(7))]))
+
+    {
+      module TestBus = LocalBus.Make()
+      module DbProvider = {
+        let db = SqliteDriver.openDb(~path)
+      }
+      module Storage = EventLogStorage_Sqlite.Make(TestBus, DbProvider)
+      let s = Storage.make(~name="persist", ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.writeSnapshot(
+        "id-sp",
+        {ReventlessCore.EventLog.seqNr: 3, state, schemaHash: "h"},
+      )
+      DbProvider.db->SqliteDriver.close
+    }
+
+    module TestBus2 = LocalBus.Make()
+    module DbProvider2 = {
+      let db = SqliteDriver.openDb(~path)
+    }
+    module Storage2 = EventLogStorage_Sqlite.Make(TestBus2, DbProvider2)
+    let s2 = Storage2.make(~name="persist", ~opts)
+    let ops2 = await s2.operations->TestRunner.resolve
+    let r = await ops2.latestSnapshot("id-sp")
+    expect(r)->toEqual(Ok(Some({ReventlessCore.EventLog.seqNr: 3, state, schemaHash: "h"})))
+    DbProvider2.db->SqliteDriver.close
+  })
+
   testPromise("events persist across a reopen of the database file", async () => {
     let path = `/tmp/reventless-test-eventlog-${Float.toString(Date.now())}.db`
 

package/tests/adapter/EventLogStorageSqliteTest.res.mjs

@@ -1,5 +1,8 @@
 // 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 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";
@@ -72,6 +75,71 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
     }
     globalThis.expect("expected Conflict, got StorageFailure").toBe(msg._0);
   });
+  globalThis.test("multi-event append advances the expected seq via MAX(seq_nr)+1", async () => {
+    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("agg", opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let ev = i => Object.fromEntries([[
+        "i",
+        i
+      ]]);
+    let r1 = await ops.append(0, "id-m", [
+      ev(0),
+      ev(1),
+      ev(2)
+    ]);
+    globalThis.expect(r1).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+    let stale = await ops.append(2, "id-m", [ev(9)]);
+    if (stale.TAG === "Ok") {
+      globalThis.expect("expected Conflict").toBe("other");
+    } else {
+      let tmp = stale._0;
+      if (typeof tmp !== "object") {
+        globalThis.expect(true).toBe(true);
+      } else {
+        globalThis.expect("expected Conflict").toBe("other");
+      }
+    }
+    let r2 = await ops.append(3, "id-m", [ev(3)]);
+    globalThis.expect(r2).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+    let replayed = await ops.replay("id-m");
+    globalThis.expect(replayed.length).toBe(4);
+  });
+  globalThis.test("appendStream persists the whole batch in order from the starting seq", async () => {
+    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("agg", opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let ev = i => Object.fromEntries([[
+        "i",
+        i
+      ]]);
+    await ops.append(0, "id-s", [ev(0)]);
+    await Effect.runPromise(ops.appendStream(1, "id-s", Stream$1.fromIterable([
+      ev(1),
+      ev(2),
+      ev(3)
+    ])));
+    let replayed = await ops.replay("id-s");
+    globalThis.expect(replayed.length).toBe(4);
+    globalThis.expect(replayed[0]).toEqual(ev(0));
+    globalThis.expect(replayed[3]).toEqual(ev(3));
+  });
   globalThis.test("replay returns empty array for unknown id", async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});
     let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
@@ -84,6 +152,127 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
     let replayed = await ops.replay("not-there");
     globalThis.expect(replayed.length).toBe(0);
   });
+  globalThis.test("replayStream ~fromSeq reads only the delta", async () => {
+    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("agg", opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let ev = i => Object.fromEntries([[
+        "i",
+        i
+      ]]);
+    await ops.append(0, "id-d", [
+      ev(0),
+      ev(1),
+      ev(2),
+      ev(3)
+    ]);
+    let delta = await Effect.runPromise(Stream.runCollect(ops.replayStream("id-d", 2)));
+    globalThis.expect(delta).toEqual([
+      ev(2),
+      ev(3)
+    ]);
+    let full = await Effect.runPromise(Stream.runCollect(ops.replayStream("id-d", undefined)));
+    globalThis.expect(full.length).toBe(4);
+  });
+  globalThis.test("snapshot round-trip with keep-one overwrite", async () => {
+    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("agg", opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let none = await ops.latestSnapshot("id-snap");
+    globalThis.expect(none).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+    let state = Object.fromEntries([[
+        "names",
+        2
+      ]]);
+    let w1 = await ops.writeSnapshot("id-snap", {
+      seqNr: 2,
+      state: state,
+      schemaHash: "h1"
+    });
+    globalThis.expect(w1).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+    let r1 = await ops.latestSnapshot("id-snap");
+    globalThis.expect(r1).toEqual({
+      TAG: "Ok",
+      _0: {
+        seqNr: 2,
+        state: state,
+        schemaHash: "h1"
+      }
+    });
+    let state5 = Object.fromEntries([[
+        "names",
+        5
+      ]]);
+    await ops.writeSnapshot("id-snap", {
+      seqNr: 5,
+      state: state5,
+      schemaHash: "h2"
+    });
+    let r2 = await ops.latestSnapshot("id-snap");
+    globalThis.expect(r2).toEqual({
+      TAG: "Ok",
+      _0: {
+        seqNr: 5,
+        state: state5,
+        schemaHash: "h2"
+      }
+    });
+  });
+  globalThis.test("snapshots persist across a reopen of the database file", async () => {
+    let path = `/tmp/reventless-test-snapshot-` + Date.now().toString() + `.db`;
+    let state = Object.fromEntries([[
+        "v",
+        7
+      ]]);
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(path);
+    let DbProvider = {
+      db: db
+    };
+    let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("persist", opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.writeSnapshot("id-sp", {
+      seqNr: 3,
+      state: state,
+      schemaHash: "h"
+    });
+    SqliteDriver$ReventlessLocal.close(db);
+    let TestBus2 = LocalBus$ReventlessLocal.Make({});
+    let db$1 = SqliteDriver$ReventlessLocal.openDb(path);
+    let DbProvider2 = {
+      db: db$1
+    };
+    let Storage2 = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus2)(DbProvider2);
+    let s2 = Storage2.make("persist", opts);
+    let ops2 = await TestRunner$ReventlessLocal.resolve(s2.operations);
+    let r = await ops2.latestSnapshot("id-sp");
+    globalThis.expect(r).toEqual({
+      TAG: "Ok",
+      _0: {
+        seqNr: 3,
+        state: state,
+        schemaHash: "h"
+      }
+    });
+    return SqliteDriver$ReventlessLocal.close(db$1);
+  });
   globalThis.test("events persist across a reopen of the database file", async () => {
     let path = `/tmp/reventless-test-eventlog-` + Date.now().toString() + `.db`;
     let TestBus = LocalBus$ReventlessLocal.Make({});