@reventlessdev/reventless-local 3.0.0-alpha.117 → 3.0.0-alpha.118

package/tests/adapter/DcbEventLogStorageSqliteTest.res

@@ -20,11 +20,19 @@ let stored = (eventType, tags, data): ReventlessCore.DcbEventLog_Adapter.rawStor
   meta: ReventlessCore.Message.generateMeta(~service="test"),
 }
 
+// Render a typed appendError for assertion diagnostics: an "expected Ok" guard
+// surfaces the real error message on failure instead of a meaningless literal.
+let appendErrMsg = e =>
+  switch e {
+  | ReventlessInfra.DcbEventLog.Conflict => "conflict"
+  | StorageFailure(m) => m
+  }
+
 describe("DcbEventLogStorage_Sqlite", () => {
   testPromise("append + read round-trips events with tags", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()
-      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      module Storage = LocalDcbEventLogStorage.Make(TestBus)
       let s = Storage.make(
         ~name="dcb-rt",
         ~indexes=[],
@@ -42,7 +50,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
       let result = await ops.append([e1])
       switch result {
       | Ok(_) => expect(true)->toBe(true)
-      | Error(m) => expect(m)->toBe("Ok")
+      | Error(e) => expect(appendErrMsg(e))->toBe("Ok")
       }
 
       let read = await ops.read(~query=[])
@@ -58,7 +66,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
   testPromise("read filters by tag", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()
-      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      module Storage = LocalDcbEventLogStorage.Make(TestBus)
       let s = Storage.make(
         ~name="dcb-tagfilter",
         ~indexes=[],
@@ -86,7 +94,7 @@ 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)
+      module Storage = LocalDcbEventLogStorage.Make(TestBus)
       let s = Storage.make(
         ~name="dcb-multitag",
         ~indexes=[],
@@ -128,7 +136,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
   testPromise("append with a non-conflicting condition succeeds", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()
-      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      module Storage = LocalDcbEventLogStorage.Make(TestBus)
       let s = Storage.make(
         ~name="dcb-noconflict",
         ~indexes=[],
@@ -149,7 +157,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
       )
       switch result {
       | Ok(_) => expect(true)->toBe(true)
-      | Error(m) => expect(m)->toBe("expected Ok")
+      | Error(e) => expect(appendErrMsg(e))->toBe("Ok")
       }
       let read = await ops.read(~query=[])
       expect(read.events->Array.length)->toBe(2)
@@ -159,7 +167,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
   testPromise("append with conflicting condition returns Error", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()
-      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      module Storage = LocalDcbEventLogStorage.Make(TestBus)
       let s = Storage.make(
         ~name="dcb-conflict",
         ~indexes=[],
@@ -193,7 +201,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
       let db = SqliteDriver.openDb(~path)
       BackendState.setSqlite(~db, ~path)
       module TestBus = LocalBus.Make()
-      module Storage = DcbEventLogStorage_InMemory.Make(TestBus)
+      module Storage = LocalDcbEventLogStorage.Make(TestBus)
       let s = Storage.make(
         ~name="persist",
         ~indexes=[],
@@ -214,7 +222,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
     let db2 = SqliteDriver.openDb(~path)
     BackendState.setSqlite(~db=db2, ~path)
     module TestBus2 = LocalBus.Make()
-    module Storage2 = DcbEventLogStorage_InMemory.Make(TestBus2)
+    module Storage2 = LocalDcbEventLogStorage.Make(TestBus2)
     let s2 = Storage2.make(
       ~name="persist",
       ~indexes=[],

package/tests/adapter/DcbEventLogStorageSqliteTest.res.mjs

@@ -5,7 +5,7 @@ import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
 import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
 import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
-import * as DcbEventLogStorage_InMemory$ReventlessLocal from "../../src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res.mjs";
+import * as LocalDcbEventLogStorage$ReventlessLocal from "../../src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
 
@@ -28,10 +28,18 @@ function stored(eventType, tags, data) {
   };
 }
 
+function appendErrMsg(e) {
+  if (typeof e !== "object") {
+    return "conflict";
+  } else {
+    return e._0;
+  }
+}
+
 globalThis.describe("DcbEventLogStorage_Sqlite", () => {
   globalThis.test("append + read round-trips events with tags", async () => await runUnderSqlite(async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});
-    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);
     let s = Storage.make("dcb-rt", [], {
       TAG: "Simple",
       _0: {
@@ -50,7 +58,7 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
     if (result.TAG === "Ok") {
       globalThis.expect(true).toBe(true);
     } else {
-      globalThis.expect(result._0).toBe("Ok");
+      globalThis.expect(appendErrMsg(result._0)).toBe("Ok");
     }
     let read = await ops.read([], undefined);
     globalThis.expect(read.events.length).toBe(1);
@@ -62,7 +70,7 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
   }));
   globalThis.test("read filters by tag", async () => await runUnderSqlite(async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});
-    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);
     let s = Storage.make("dcb-tagfilter", [], {
       TAG: "Simple",
       _0: {
@@ -90,7 +98,7 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
   }));
   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 Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);
     let s = Storage.make("dcb-multitag", [], {
       TAG: "Simple",
       _0: {
@@ -141,7 +149,7 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
   }));
   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 Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);
     let s = Storage.make("dcb-noconflict", [], {
       TAG: "Simple",
       _0: {
@@ -169,14 +177,14 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
     if (result.TAG === "Ok") {
       globalThis.expect(true).toBe(true);
     } else {
-      globalThis.expect(result._0).toBe("expected Ok");
+      globalThis.expect(appendErrMsg(result._0)).toBe("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);
+    let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);
     let s = Storage.make("dcb-conflict", [], {
       TAG: "Simple",
       _0: {
@@ -210,7 +218,7 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
     let db = SqliteDriver$ReventlessLocal.openDb(path);
     BackendState$ReventlessLocal.setSqlite(db, path);
     let TestBus = LocalBus$ReventlessLocal.Make({});
-    let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let Storage = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus);
     let s = Storage.make("persist", [], {
       TAG: "Simple",
       _0: {
@@ -228,7 +236,7 @@ globalThis.describe("DcbEventLogStorage_Sqlite", () => {
     let db2 = SqliteDriver$ReventlessLocal.openDb(path);
     BackendState$ReventlessLocal.setSqlite(db2, path);
     let TestBus2 = LocalBus$ReventlessLocal.Make({});
-    let Storage2 = DcbEventLogStorage_InMemory$ReventlessLocal.Make(TestBus2);
+    let Storage2 = LocalDcbEventLogStorage$ReventlessLocal.Make(TestBus2);
     let s2 = Storage2.make("persist", [], {
       TAG: "Simple",
       _0: {
@@ -247,5 +255,6 @@ export {
   opts,
   runUnderSqlite,
   stored,
+  appendErrMsg,
 }
 /*  Not a pure module */

package/tests/adapter/PgProjectionCatchupTest.res

@@ -0,0 +1,149 @@
+// Postgres startup projection catch-up (#1): under Backend.Postgres the read
+// models are in-memory, so on restart they must be rebuilt by replaying the
+// durable pg event log through the projection handlers.
+//
+// Skipped unless PG_URL is set. Verifies:
+//   - every persisted classic + DCB event is redelivered as a well-formed
+//     {id, meta, event} envelope, in order;
+//   - the pre-session head bound excludes events appended after capture (this
+//     session's live-delivered events are never redelivered).
+
+open JestGlobals
+
+@val external processEnv: dict<string> = "process.env"
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+// Flat stored aggregate event — the exact shape EventLog_Operations.encodeEvent'
+// persists (envelope fields + meta flattened to top level).
+let flatEvent = (~id, ~seq, ~eventType, ~data=[], ~msgId, ~service="Products") =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("id", JSON.Encode.string(id)),
+      ("position", JSON.Encode.string(seq->Int.toString->String.padStart(9, "0"))),
+      ("event", JSON.Encode.string(eventType)),
+      ("data", JSON.Encode.object(Dict.fromArray(data))),
+      ("recordedAt", JSON.Encode.string("2026-07-03T00:00:00.000Z")),
+      ("service", JSON.Encode.string(service)),
+      ("time", JSON.Encode.string("2026-07-03T00:00:00.000Z")),
+      ("msgId", JSON.Encode.string(msgId)),
+      ("correlationId", JSON.Encode.string(msgId)),
+    ]),
+  )
+
+let dcbEvent = (~eventType, ~tags, ~data=[], ~msgId): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
+  eventType,
+  data: JSON.Encode.object(Dict.fromArray(data)),
+  tags,
+  meta: {
+    service: "OrderingDcbEventLog",
+    time: "2026-07-03T00:00:00.000Z",
+    msgId,
+    correlationId: msgId,
+  },
+}
+
+let idOf = (json: JSON.t) =>
+  json
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("id"))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.getOr("<none>")
+
+let recorder = () => {
+  let received: array<JSON.t> = []
+  let handler = (json: JSON.t, _ctx: unit) => {
+    received->Array.push(json)
+    Promise.resolve()
+  }
+  (received, handler)
+}
+
+switch processEnv->Dict.get("PG_URL") {
+| None => testSync("Postgres projection catch-up (skipped — set PG_URL)", () => expect(true)->toBe(true))
+| Some(url) =>
+  let pool = ReventlessPostgres.PgDriver.makePool({connectionString: url})
+
+  beforeAllAsync(async () => await ReventlessPostgres.PgSchema.ensureSchema(pool))
+  afterAll(() => ignore(pool->ReventlessPostgres.PgDriver.endPool))
+
+  // No beforeEachAsync binding exists; reset at the top of each test for isolation.
+  let reset = async () => await ReventlessPostgres.PgSchema.truncateAll(pool)
+
+  let classicOps = () => {
+    let (_, ops, _) = ReventlessPostgres.EventLogStorage_Postgres.makeStorage(
+      ~pool,
+      ~name="catchup-agg",
+      ~opts,
+    )
+    ops
+  }
+  let dcbOps = () => {
+    let (_, ops, _) = ReventlessPostgres.DcbEventLogStorage_Postgres.makeStorage(
+      ~pool,
+      ~name="catchup-dcb",
+      ~indexes=[],
+      ~partitionTag=Reventless.DcbTag.Simple({key: "k"}),
+      ~opts,
+    )
+    ops
+  }
+
+  describe("PgProjectionCatchup", () => {
+    testPromise("replays every persisted classic + DCB event as an envelope", async () => {
+      await reset()
+      let agg = classicOps()
+      let _ = await agg.append(0, "p1", [flatEvent(~id="p1", ~seq=0, ~eventType="Added", ~msgId="a0")])
+      let _ = await agg.append(1, "p1", [flatEvent(~id="p1", ~seq=1, ~eventType="Renamed", ~msgId="a1")])
+
+      let dcb = dcbOps()
+      let _ = await dcb.append([dcbEvent(~eventType="Placed", ~tags=[{key: "orderId", value: "o1"}], ~msgId="d0")])
+      let _ = await dcb.append([dcbEvent(~eventType="Paid", ~tags=[{key: "orderId", value: "o2"}], ~msgId="d1")])
+
+      let bounds = await PgProjectionCatchup.captureBounds(pool)
+      let (received, handler) = recorder()
+      await PgProjectionCatchup.runCatchup(~pool, ~bounds, ~handlers=[("rm", handler)])
+
+      // 2 classic + 2 dcb = 4 well-formed envelopes (None envelopes aren't delivered).
+      expect(received->Array.length)->toBe(4)
+      // Classic events keep their aggregate id, in order.
+      expect(idOf(received->Array.getUnsafe(0)))->toBe("p1")
+      expect(idOf(received->Array.getUnsafe(1)))->toBe("p1")
+      // DCB events derive id from the first tag value.
+      expect(idOf(received->Array.getUnsafe(2)))->toBe("o1")
+      expect(idOf(received->Array.getUnsafe(3)))->toBe("o2")
+    })
+
+    testPromise("the pre-session bound excludes events appended after capture", async () => {
+      await reset()
+      let agg = classicOps()
+      let _ = await agg.append(0, "p1", [flatEvent(~id="p1", ~seq=0, ~eventType="Added", ~msgId="a0")])
+      let _ = await agg.append(1, "p1", [flatEvent(~id="p1", ~seq=1, ~eventType="Renamed", ~msgId="a1")])
+
+      // Snapshot the head BEFORE the "this-session" append below.
+      let bounds = await PgProjectionCatchup.captureBounds(pool)
+
+      // This event is > the captured bound — it stands in for a live-delivered
+      // this-session append and must NOT be redelivered by catch-up.
+      let _ = await agg.append(2, "p1", [flatEvent(~id="p1", ~seq=2, ~eventType="Archived", ~msgId="a2")])
+
+      let (received, handler) = recorder()
+      await PgProjectionCatchup.runCatchup(~pool, ~bounds, ~handlers=[("rm", handler)])
+
+      expect(received->Array.length)->toBe(2)
+    })
+
+    testPromise("delivers each event to every handler", async () => {
+      await reset()
+      let agg = classicOps()
+      let _ = await agg.append(0, "p1", [flatEvent(~id="p1", ~seq=0, ~eventType="Added", ~msgId="a0")])
+
+      let bounds = await PgProjectionCatchup.captureBounds(pool)
+      let (r1, h1) = recorder()
+      let (r2, h2) = recorder()
+      await PgProjectionCatchup.runCatchup(~pool, ~bounds, ~handlers=[("rm1", h1), ("rm2", h2)])
+
+      expect(r1->Array.length)->toBe(1)
+      expect(r2->Array.length)->toBe(1)
+    })
+  })
+}

package/tests/adapter/PgProjectionCatchupTest.res.mjs

@@ -0,0 +1,181 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 PgDriver$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgDriver.res.mjs";
+import * as PgSchema$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgSchema.res.mjs";
+import * as PgProjectionCatchup$ReventlessLocal from "../../src/adapter/PgProjectionCatchup.res.mjs";
+import * as EventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/EventLogStorage_Postgres.res.mjs";
+import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres.res.mjs";
+
+let opts = {};
+
+function flatEvent(id, seq, eventType, dataOpt, msgId, serviceOpt) {
+  let data = dataOpt !== undefined ? dataOpt : [];
+  let service = serviceOpt !== undefined ? serviceOpt : "Products";
+  return Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "position",
+      seq.toString().padStart(9, "0")
+    ],
+    [
+      "event",
+      eventType
+    ],
+    [
+      "data",
+      Object.fromEntries(data)
+    ],
+    [
+      "recordedAt",
+      "2026-07-03T00:00:00.000Z"
+    ],
+    [
+      "service",
+      service
+    ],
+    [
+      "time",
+      "2026-07-03T00:00:00.000Z"
+    ],
+    [
+      "msgId",
+      msgId
+    ],
+    [
+      "correlationId",
+      msgId
+    ]
+  ]);
+}
+
+function dcbEvent(eventType, tags, dataOpt, msgId) {
+  let data = dataOpt !== undefined ? dataOpt : [];
+  return {
+    eventType: eventType,
+    data: Object.fromEntries(data),
+    tags: tags,
+    meta: {
+      service: "OrderingDcbEventLog",
+      time: "2026-07-03T00:00:00.000Z",
+      msgId: msgId,
+      correlationId: msgId
+    }
+  };
+}
+
+function idOf(json) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["id"]), Stdlib_JSON.Decode.string), "<none>");
+}
+
+function recorder() {
+  let received = [];
+  let handler = (json, _ctx) => {
+    received.push(json);
+    return Promise.resolve();
+  };
+  return [
+    received,
+    handler
+  ];
+}
+
+let url = process.env["PG_URL"];
+
+if (url !== undefined) {
+  let pool = PgDriver$ReventlessPostgres.makePool({
+    connectionString: url
+  });
+  globalThis.beforeAll(async () => await PgSchema$ReventlessPostgres.ensureSchema(pool));
+  globalThis.afterAll(() => {
+    PgDriver$ReventlessPostgres.endPool(pool);
+  });
+  let reset = async () => await PgSchema$ReventlessPostgres.truncateAll(pool);
+  let classicOps = () => EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "catchup-agg", opts, undefined)[1];
+  let dcbOps = () => DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "catchup-dcb", [], {
+      TAG: "Simple",
+      _0: {
+        key: "k"
+      }
+    }, undefined, opts, undefined, undefined)[1];
+  globalThis.describe("PgProjectionCatchup", () => {
+    globalThis.test("replays every persisted classic + DCB event as an envelope", async () => {
+      await reset();
+      let agg = classicOps();
+      await agg.append(0, "p1", [flatEvent("p1", 0, "Added", undefined, "a0", undefined)]);
+      await agg.append(1, "p1", [flatEvent("p1", 1, "Renamed", undefined, "a1", undefined)]);
+      let dcb = dcbOps();
+      await dcb.append([dcbEvent("Placed", [{
+            key: "orderId",
+            value: "o1"
+          }], undefined, "d0")], undefined);
+      await dcb.append([dcbEvent("Paid", [{
+            key: "orderId",
+            value: "o2"
+          }], undefined, "d1")], undefined);
+      let bounds = await PgProjectionCatchup$ReventlessLocal.captureBounds(pool);
+      let match = recorder();
+      let received = match[0];
+      await PgProjectionCatchup$ReventlessLocal.runCatchup(pool, bounds, [[
+          "rm",
+          match[1]
+        ]]);
+      globalThis.expect(received.length).toBe(4);
+      globalThis.expect(idOf(received[0])).toBe("p1");
+      globalThis.expect(idOf(received[1])).toBe("p1");
+      globalThis.expect(idOf(received[2])).toBe("o1");
+      globalThis.expect(idOf(received[3])).toBe("o2");
+    });
+    globalThis.test("the pre-session bound excludes events appended after capture", async () => {
+      await reset();
+      let agg = classicOps();
+      await agg.append(0, "p1", [flatEvent("p1", 0, "Added", undefined, "a0", undefined)]);
+      await agg.append(1, "p1", [flatEvent("p1", 1, "Renamed", undefined, "a1", undefined)]);
+      let bounds = await PgProjectionCatchup$ReventlessLocal.captureBounds(pool);
+      await agg.append(2, "p1", [flatEvent("p1", 2, "Archived", undefined, "a2", undefined)]);
+      let match = recorder();
+      await PgProjectionCatchup$ReventlessLocal.runCatchup(pool, bounds, [[
+          "rm",
+          match[1]
+        ]]);
+      globalThis.expect(match[0].length).toBe(2);
+    });
+    globalThis.test("delivers each event to every handler", async () => {
+      await reset();
+      let agg = classicOps();
+      await agg.append(0, "p1", [flatEvent("p1", 0, "Added", undefined, "a0", undefined)]);
+      let bounds = await PgProjectionCatchup$ReventlessLocal.captureBounds(pool);
+      let match = recorder();
+      let match$1 = recorder();
+      await PgProjectionCatchup$ReventlessLocal.runCatchup(pool, bounds, [
+        [
+          "rm1",
+          match[1]
+        ],
+        [
+          "rm2",
+          match$1[1]
+        ]
+      ]);
+      globalThis.expect(match[0].length).toBe(1);
+      globalThis.expect(match$1[0].length).toBe(1);
+    });
+  });
+} else {
+  globalThis.test("Postgres projection catch-up (skipped — set PG_URL)", () => {
+    globalThis.expect(true).toBe(true);
+  });
+}
+
+export {
+  opts,
+  flatEvent,
+  dcbEvent,
+  idOf,
+  recorder,
+}
+/* url Not a pure module */

package/tests/adapter/QueryDbGsiTtlTest.res

@@ -196,7 +196,7 @@ describe("QueryDb — indexed equality lookup (B4 push-down)", () => {
   testPromise("in-memory lookup matches the sqlite result (backend parity)", async () => {
     module TestBus = LocalBus.Make()
     module Storage = QueryDbStorage_InMemory.Make(TestBus)
-    let s = Storage.makeMemory(~name="orders", ~indexes=[byOwner], ~api=(), ~apiRole=(), ~opts)
+    let s = Storage.make(~name="orders", ~indexes=[byOwner], ~api=(), ~apiRole=(), ~opts)
     let ops = await s.operations->TestRunner.resolve
     let _ = await ops.save("k1", item("o1"), ReventlessCore.QueryDb.Any, None)
     let _ = await ops.save("k2", item("o2"), ReventlessCore.QueryDb.Any, None)
@@ -211,7 +211,7 @@ describe("QueryDb — indexed equality lookup (B4 push-down)", () => {
 describe("QueryDbStorage_InMemory — lazy scan snapshot (B4 dirty-flag)", () => {
   testPromise("interleaved save/scan reflects each write without stale reads", async () => {
     module TestBus = LocalBus.Make()
-    module Storage = QueryDbStorage_InMemory.Make(TestBus)
+    module Storage = LocalQueryDbStorage.Make(TestBus)
     let s = Storage.make(~name="lazy", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
     let ops = await s.operations->TestRunner.resolve
     let scanFn = TestBus.getQueryDbScan("lazy")->Option.getOrThrow

package/tests/adapter/QueryDbGsiTtlTest.res.mjs

@@ -6,6 +6,7 @@ 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 LocalQueryDbStorage$ReventlessLocal from "../../src/adapter/QueryDb/LocalQueryDbStorage.res.mjs";
 import * as QueryDbStorage_Sqlite$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs";
 import * as QueryDbStorage_InMemory$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
 
@@ -168,7 +169,7 @@ globalThis.describe("QueryDb — indexed equality lookup (B4 push-down)", () =>
   globalThis.test("in-memory lookup matches the sqlite result (backend parity)", async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});
     let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
-    let s = Storage.makeMemory("orders", [byOwner], undefined, undefined, undefined, undefined, opts);
+    let s = Storage.make("orders", [byOwner], undefined, undefined, undefined, undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     await ops.save("k1", item("o1"), "Any", undefined);
     await ops.save("k2", item("o2"), "Any", undefined);
@@ -183,7 +184,7 @@ globalThis.describe("QueryDb — indexed equality lookup (B4 push-down)", () =>
 globalThis.describe("QueryDbStorage_InMemory — lazy scan snapshot (B4 dirty-flag)", () => {
   globalThis.test("interleaved save/scan reflects each write without stale reads", async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});
-    let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
     let s = Storage.make("lazy", [], undefined, undefined, undefined, undefined, opts);
     let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
     let scanFn = Stdlib_Option.getOrThrow(TestBus.getQueryDbScan("lazy"), undefined);

package/tests/adapter/QueryDbListResolverTest.res

@@ -99,7 +99,7 @@ let pageInfoString = (response: JSON.t, key: string): option<string> =>
 
 let buildFixture = async (~name: string) => {
   module Bus = LocalBus.Make()
-  module Storage = QueryDbStorage_InMemory.Make(Bus)
+  module Storage = LocalQueryDbStorage.Make(Bus)
   module Resolvers = QueryDbResolvers_GraphQL.Make(Bus)
 
   module Spec = {

package/tests/adapter/QueryDbListResolverTest.res.mjs

@@ -18,8 +18,8 @@ import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.re
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as QueryDb_Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Adapter.res.mjs";
 import * as QueryDb_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Builder.res.mjs";
+import * as LocalQueryDbStorage$ReventlessLocal from "../../src/adapter/QueryDb/LocalQueryDbStorage.res.mjs";
 import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
-import * as QueryDbStorage_InMemory$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
 import * as QueryDbResolvers_GraphQL$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
@@ -109,7 +109,7 @@ function pageInfoString(response, key) {
 
 async function buildFixture(name) {
   let Bus = LocalBus$ReventlessLocal.Make({});
-  let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
+  let Storage = LocalQueryDbStorage$ReventlessLocal.Make(Bus);
   let Resolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
   let moduleUrl = import.meta.url;
   let config = ReadModel$Reventless.config(undefined, undefined, undefined);