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

package/tests/adapter/EventLogStorageSqliteTest.res

@@ -51,14 +51,62 @@ describe("EventLogStorage_Sqlite", () => {
     let e = JSON.Encode.object(Dict.fromArray([("t", JSON.Encode.string("X"))]))
     let _ = await ops.append(0, "id-c", [e])
 
-    // Caller re-uses seqNr=0 — conflict.
+    // Caller re-uses seqNr=0 — a genuine conflict must be the typed Conflict
+    // sentinel (not a StorageFailure), so the core retry loop treats it as OCC.
     let result = await ops.append(0, "id-c", [e])
     switch result {
-    | Error(_) => expect(true)->toBe(true)
+    | Error(ReventlessCore.EventLog.Conflict) => expect(true)->toBe(true)
+    | Error(StorageFailure(msg)) => expect("expected Conflict, got StorageFailure")->toBe(msg)
     | Ok() => expect("expected conflict")->toBe("actual Ok")
     }
   })
 
+  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 = {
@@ -73,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";
@@ -65,7 +68,77 @@ globalThis.describe("EventLogStorage_Sqlite", () => {
       globalThis.expect("expected conflict").toBe("actual Ok");
       return;
     }
-    globalThis.expect(true).toBe(true);
+    let msg = result._0;
+    if (typeof msg !== "object") {
+      globalThis.expect(true).toBe(true);
+      return;
+    }
+    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({});
@@ -79,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({});

package/tests/adapter/LocalBusPubSubTest.res

@@ -78,4 +78,35 @@ describe("LocalBus PubSub (Phase F)", () => {
       expect(countB.contents)->toBe(0)
     })
   })
+
+  // A5: a throwing/rejecting subscriber must not (a) hang publishEvent (its
+  // done_ countdown never reaching zero) nor (b) kill the drain fiber so the
+  // topic stops working. If either regressed, these tests would time out.
+  describe("failing subscriber", () => {
+    testPromise("a throwing subscriber does not hang publish; healthy siblings still receive it", async () => {
+      module TestBus = LocalBus.Make()
+      let healthy = ref(0)
+      TestBus.subscribeToEvents("T", async (_, _, _) => JsError.throwWithMessage("boom"))
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        healthy := healthy.contents + 1
+      })
+      // Must resolve — not hang — even though one subscriber threw.
+      await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      expect(healthy.contents)->toBe(1)
+    })
+
+    testPromise("the topic keeps working after a subscriber throws (drain fiber survives)", async () => {
+      module TestBus = LocalBus.Make()
+      let healthy = ref(0)
+      TestBus.subscribeToEvents("T", async (_, _, _) => JsError.throwWithMessage("boom"))
+      TestBus.subscribeToEvents("T", async (_, _, _) => {
+        healthy := healthy.contents + 1
+      })
+      await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      // Second publish on the same topic must also complete and be delivered —
+      // proving the dead-fiber cascade is gone.
+      await TestBus.publishEvent("T", "svc", defaultMeta, JSON.Null)
+      expect(healthy.contents)->toBe(2)
+    })
+  })
 })

package/tests/adapter/LocalBusPubSubTest.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
 
@@ -73,6 +74,33 @@ globalThis.describe("LocalBus PubSub (Phase F)", () => {
       globalThis.expect(countB.contents).toBe(0);
     });
   });
+  globalThis.describe("failing subscriber", () => {
+    globalThis.test("a throwing subscriber does not hang publish; healthy siblings still receive it", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let healthy = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("boom"));
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        healthy.contents = healthy.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(healthy.contents).toBe(1);
+    });
+    globalThis.test("the topic keeps working after a subscriber throws (drain fiber survives)", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let healthy = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("boom"));
+      TestBus.subscribeToEvents("T", async (param, param$1, param$2) => {
+        healthy.contents = healthy.contents + 1 | 0;
+      });
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      await TestBus.publishEvent("T", "svc", defaultMeta, null);
+      globalThis.expect(healthy.contents).toBe(2);
+    });
+  });
 });
 
 export {