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

package/src/adapter/DcbEventLog/DcbEventLogStorage_Sqlite.res.mjs

@@ -322,21 +322,35 @@ function makeStorage(db, name, param, param$1, param$2) {
     } catch (raw_msg) {
       let msg = Primitive_exceptions.internalToException(raw_msg);
       if (msg.RE_EXN_ID === "Failure") {
-        return {
-          TAG: "Error",
-          _0: msg._1
-        };
+        let msg$1 = msg._1;
+        if (msg$1.includes("conflict")) {
+          return {
+            TAG: "Error",
+            _0: "Conflict"
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: {
+              TAG: "StorageFailure",
+              _0: msg$1
+            }
+          };
+        }
       }
-      let msg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(msg), Stdlib_JsExn.message), "");
-      if (msg$1.includes("constraint failed")) {
+      let msg$2 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(msg), Stdlib_JsExn.message), "");
+      if (msg$2.includes("constraint failed")) {
         return {
           TAG: "Error",
-          _0: "conflict"
+          _0: "Conflict"
         };
       } else {
         return {
           TAG: "Error",
-          _0: msg$1 === "" ? "storage error" : msg$1
+          _0: {
+            TAG: "StorageFailure",
+            _0: msg$2 === "" ? "storage error" : msg$2
+          }
         };
       }
     }

package/src/adapter/DcbEventLog/LocalDcbEventLogStorage.res

@@ -0,0 +1,52 @@
+// DCB EventLog storage dispatcher.
+//
+// Selects the concrete backend at `make` time by consulting BackendState:
+//   - Sqlite   → DcbEventLogStorage_Sqlite (true DCB semantics on SQL)
+//   - Postgres → ReventlessPostgres.DcbEventLogStorage_Postgres (exact DCB
+//                semantics: scoped advisory locks + atomic condition check)
+//   - Memory   → DcbEventLogStorage_InMemory (pure in-memory)
+//
+// Registers each backend's read with the Bus so the LocalBus DCB event-tap can
+// stream historical events uniformly.
+
+module Make = (Bus: LocalBus.T) => {
+  let make: ReventlessCore.DcbEventLog_Adapter.storageMaker = (
+    ~name,
+    ~indexes,
+    ~partitionTag,
+    ~crossPartitionTagKeys as _=?,
+    ~opts,
+  ) => {
+    switch (BackendState.getSqliteDb(), BackendState.getPostgresPool()) {
+    | (Some(db), _) =>
+      let (storageName, read, storage) = DcbEventLogStorage_Sqlite.makeStorage(
+        ~db,
+        ~name,
+        ~indexes,
+        ~partitionTag,
+        ~opts,
+      )
+      Bus.registerDcbEventLogRead(storageName, read)
+      storage
+    | (_, Some(pool)) =>
+      let (storageName, ops, storage) = ReventlessPostgres.DcbEventLogStorage_Postgres.makeStorage(
+        ~pool,
+        ~name,
+        ~indexes,
+        ~partitionTag,
+        ~opts,
+      )
+      Bus.registerDcbEventLogRead(storageName, ops.read)
+      storage
+    | (None, None) =>
+      let (storageName, read, storage) = DcbEventLogStorage_InMemory.makeStorage(
+        ~name,
+        ~indexes,
+        ~partitionTag,
+        ~opts,
+      )
+      Bus.registerDcbEventLogRead(storageName, read)
+      storage
+    }
+  }
+}

package/src/adapter/DcbEventLog/LocalDcbEventLogStorage.res.mjs

@@ -0,0 +1,35 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as DcbEventLogStorage_Sqlite$ReventlessLocal from "./DcbEventLogStorage_Sqlite.res.mjs";
+import * as DcbEventLogStorage_InMemory$ReventlessLocal from "./DcbEventLogStorage_InMemory.res.mjs";
+import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres.res.mjs";
+
+function Make(Bus) {
+  let make = (name, indexes, partitionTag, param, opts) => {
+    let match = BackendState$ReventlessLocal.getSqliteDb();
+    let match$1 = BackendState$ReventlessLocal.getPostgresPool();
+    if (match !== undefined) {
+      let match$2 = DcbEventLogStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(match), name, indexes, partitionTag, opts);
+      Bus.registerDcbEventLogRead(match$2[0], match$2[1]);
+      return match$2[2];
+    }
+    if (match$1 !== undefined) {
+      let match$3 = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(Primitive_option.valFromOption(match$1), name, indexes, partitionTag, undefined, opts, undefined, undefined);
+      Bus.registerDcbEventLogRead(match$3[0], match$3[1].read);
+      return match$3[2];
+    }
+    let match$4 = DcbEventLogStorage_InMemory$ReventlessLocal.makeStorage(name, indexes, partitionTag, opts);
+    Bus.registerDcbEventLogRead(match$4[0], match$4[1]);
+    return match$4[2];
+  };
+  return {
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* DcbEventLogStorage_Sqlite-ReventlessLocal Not a pure module */

package/src/adapter/EventLog/EventLogStorage_InMemory.res

@@ -105,22 +105,10 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
 // Alias retained for tests that still want the pure-memory implementation.
 let makeStorage = makeMemoryStorage
 
+// Pure in-memory storageMaker (no BackendState dispatch, no Bus). Backend
+// selection lives in LocalEventLogStorage.Make — this file holds only the
+// in-memory implementation, as its name says.
 let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~opts) => {
   let (_, _, storage) = makeMemoryStorage(~name, ~opts)
   storage
 }
-
-module Make = (Bus: LocalBus.T) => {
-  let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~opts) => {
-    switch BackendState.getDb() {
-    | Some(db) =>
-      let (storageName, replay, storage) = EventLogStorage_Sqlite.makeStorage(~db, ~name, ~opts)
-      Bus.registerEventLogReplay(storageName, replay)
-      storage
-    | None =>
-      let (storageName, replay, storage) = makeMemoryStorage(~name, ~opts)
-      Bus.registerEventLogReplay(storageName, replay)
-      storage
-    }
-  }
-}

package/src/adapter/EventLog/EventLogStorage_InMemory.res.mjs

@@ -7,9 +7,6 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stream$1 from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
-import * as EventLogStorage_Sqlite$ReventlessLocal from "./EventLogStorage_Sqlite.res.mjs";
 
 function makeMemoryStorage(_name, param) {
   let eventsRef = Effect.runSync(STM.commit(TRef.make({})));
@@ -106,29 +103,11 @@ function make(name, opts) {
   return makeMemoryStorage(name, opts)[2];
 }
 
-function Make(Bus) {
-  let make = (name, opts) => {
-    let db = BackendState$ReventlessLocal.getDb();
-    if (db !== undefined) {
-      let match = EventLogStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(db), name, opts);
-      Bus.registerEventLogReplay(match[0], match[1]);
-      return match[2];
-    }
-    let match$1 = makeMemoryStorage(name, opts);
-    Bus.registerEventLogReplay(match$1[0], match$1[1]);
-    return match$1[2];
-  };
-  return {
-    make: make
-  };
-}
-
 let makeStorage = makeMemoryStorage;
 
 export {
   makeMemoryStorage,
   makeStorage,
   make,
-  Make,
 }
 /* Stream Not a pure module */

package/src/adapter/EventLog/LocalEventLogStorage.res

@@ -0,0 +1,33 @@
+// EventLog storage dispatcher.
+//
+// Selects the concrete backend at `make` time by consulting BackendState, so the
+// core EventLog builder wires a single storageMaker module regardless of backend:
+//   - Sqlite   → EventLogStorage_Sqlite (on-disk / :memory:)
+//   - Postgres → ReventlessPostgres.EventLogStorage_Postgres (durable, async)
+//   - Memory   → EventLogStorage_InMemory (pure in-memory)
+//
+// The `Make(Bus)` functor also registers each backend's replay with the Bus so
+// the LocalBus event-tap can stream historical events uniformly.
+
+module Make = (Bus: LocalBus.T) => {
+  let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~opts) => {
+    switch (BackendState.getSqliteDb(), BackendState.getPostgresPool()) {
+    | (Some(db), _) =>
+      let (storageName, replay, storage) = EventLogStorage_Sqlite.makeStorage(~db, ~name, ~opts)
+      Bus.registerEventLogReplay(storageName, replay)
+      storage
+    | (_, Some(pool)) =>
+      let (storageName, ops, storage) = ReventlessPostgres.EventLogStorage_Postgres.makeStorage(
+        ~pool,
+        ~name,
+        ~opts,
+      )
+      Bus.registerEventLogReplay(storageName, ops.replay)
+      storage
+    | (None, None) =>
+      let (storageName, replay, storage) = EventLogStorage_InMemory.makeMemoryStorage(~name, ~opts)
+      Bus.registerEventLogReplay(storageName, replay)
+      storage
+    }
+  }
+}

package/src/adapter/EventLog/LocalEventLogStorage.res.mjs

@@ -0,0 +1,35 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as EventLogStorage_Sqlite$ReventlessLocal from "./EventLogStorage_Sqlite.res.mjs";
+import * as EventLogStorage_InMemory$ReventlessLocal from "./EventLogStorage_InMemory.res.mjs";
+import * as EventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/EventLogStorage_Postgres.res.mjs";
+
+function Make(Bus) {
+  let make = (name, opts) => {
+    let match = BackendState$ReventlessLocal.getSqliteDb();
+    let match$1 = BackendState$ReventlessLocal.getPostgresPool();
+    if (match !== undefined) {
+      let match$2 = EventLogStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(match), name, opts);
+      Bus.registerEventLogReplay(match$2[0], match$2[1]);
+      return match$2[2];
+    }
+    if (match$1 !== undefined) {
+      let match$3 = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(Primitive_option.valFromOption(match$1), name, opts, undefined);
+      Bus.registerEventLogReplay(match$3[0], match$3[1].replay);
+      return match$3[2];
+    }
+    let match$4 = EventLogStorage_InMemory$ReventlessLocal.makeMemoryStorage(name, opts);
+    Bus.registerEventLogReplay(match$4[0], match$4[1]);
+    return match$4[2];
+  };
+  return {
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* EventLogStorage_Sqlite-ReventlessLocal Not a pure module */

package/src/adapter/LocalBus.res

@@ -145,7 +145,7 @@ module type T = {
   let registerCommandHandler: (string, (JSON.t, unit) => promise<unit>) => unit
 
   // QueryDb registry: read model name → storage ops and scan function
-  // Populated by QueryDbStorage_InMemory.Make(Bus) during component construction.
+  // Populated by LocalQueryDbStorage.Make(Bus) during component construction.
   let registerQueryDb: (string, ReventlessCore.QueryDb_Adapter.operations) => unit
   let getQueryDb: string => option<ReventlessCore.QueryDb_Adapter.operations>
   let registerQueryDbScan: (string, unit => array<JSON.t>) => unit

package/src/adapter/PgProjectionCatchup.res

@@ -0,0 +1,146 @@
+// Startup projection catch-up for the Postgres backend.
+//
+// Under Backend.Postgres the event logs (classic + DCB) persist durably, but read
+// models run on the in-memory live-query arm (LocalQueryDbStorage — the sync
+// LocalBus registrations can't consume async pg). So on every startup the
+// in-memory read models begin EMPTY and must be rebuilt by replaying the durable
+// event log through the projection handlers — read models are derived data, the
+// log is the source of truth.
+//
+// Unlike the SQLite ProjectionCheckpoint, there is no persisted checkpoint here:
+// in-memory read models always start at position 0, so the full history
+// `(0, head]` is replayed once. The `head` bound is captured BEFORE the plugins
+// build (and before this session's Connect dispatches / commands append), so this
+// session's own events — which are live-delivered — are never redelivered.
+//
+// The {id, meta, event} envelopes are reconstructed by ProjectionCheckpoint's
+// builders so they match live topic delivery byte-for-byte.
+
+module Pg = ReventlessPostgres.PgDriver
+
+// Head positions captured before the session appends anything.
+type bounds = {aggBound: int, dcbBound: int}
+
+let intCol = (row: dict<JSON.t>, key: string): int =>
+  switch row->Dict.get(key) {
+  | Some(JSON.Number(n)) => Float.toInt(n)
+  | Some(JSON.String(s)) => s->Int.fromString->Option.getOr(0)
+  | _ => 0
+  }
+
+// Snapshot the current head of each axis. Dispatched before plugin build so the
+// bound excludes this session's live-delivered appends.
+let captureBounds = async (pool: Pg.pool): bounds => {
+  let agg = switch await pool->Pg.queryOne(
+    "SELECT COALESCE(MAX(global_seq), 0)::bigint AS m FROM event_log",
+    [],
+  ) {
+  | Some(row) => intCol(row, "m")
+  | None => 0
+  }
+  let dcb = switch await pool->Pg.queryOne(
+    "SELECT COALESCE(MAX(position), 0)::bigint AS m FROM dcb_event",
+    [],
+  ) {
+  | Some(row) => intCol(row, "m")
+  | None => 0
+  }
+  {aggBound: agg, dcbBound: dcb}
+}
+
+// First tag value of a DCB event's text[] `tags` column ('key=value' → value),
+// reproducing publish-time entityId derivation (the first tag).
+let firstTagValue = (row: dict<JSON.t>): option<string> =>
+  switch row->Dict.get("tags") {
+  | Some(JSON.Array(arr)) =>
+    switch arr->Array.get(0) {
+    | Some(JSON.String(kv)) =>
+      switch kv->String.indexOf("=") {
+      | -1 => Some(kv)
+      | i => Some(kv->String.slice(~start=i + 1, ~end=kv->String.length))
+      }
+    | _ => None
+    }
+  | _ => None
+  }
+
+// Deliver `envelope` to every handler in registration order (handlers dispatch by
+// meta.service and no-op on events none of their mappings consume, so delivering
+// both axes to every projection is safe — same at-least-once contract the
+// deployed adapters impose).
+let deliver = async (
+  handlers: array<(string, ProjectionCheckpoint.catchupHandler)>,
+  envelope: JSON.t,
+) =>
+  for i in 0 to handlers->Array.length - 1 {
+    let (_name, handler) = handlers->Array.getUnsafe(i)
+    switch await handler(envelope, ()) {
+    | () => ()
+    | exception _ => ()
+    }
+  }
+
+let runCatchup = async (
+  ~pool: Pg.pool,
+  ~bounds: bounds,
+  ~handlers: array<(string, ProjectionCheckpoint.catchupHandler)>,
+) => {
+  // --- Aggregate axis: flat stored events, global_seq order ---
+  let aggRows = await pool->Pg.query(
+    "SELECT payload FROM event_log WHERE global_seq <= $1::bigint ORDER BY global_seq ASC",
+    [JSON.Encode.int(bounds.aggBound)],
+  )
+  for i in 0 to aggRows->Array.length - 1 {
+    let row = aggRows->Array.getUnsafe(i)
+    switch row->Dict.get("payload") {
+    | Some(payload) =>
+      switch ProjectionCheckpoint.catchupEnvelope(payload) {
+      | Some(envelope) => await deliver(handlers, envelope)
+      | None => ()
+      }
+    | None => ()
+    }
+  }
+
+  // --- DCB axis: reconstruct the published envelope, position order ---
+  let dcbRows = await pool->Pg.query(
+    "SELECT log_name, event_type, data, meta, tags FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC",
+    [JSON.Encode.int(bounds.dcbBound)],
+  )
+  for i in 0 to dcbRows->Array.length - 1 {
+    let row = dcbRows->Array.getUnsafe(i)
+    switch (
+      row->Dict.get("log_name"),
+      row->Dict.get("event_type"),
+      row->Dict.get("data"),
+      row->Dict.get("meta"),
+    ) {
+    | (Some(JSON.String(logName)), Some(JSON.String(eventType)), Some(data), Some(meta)) =>
+      switch ProjectionCheckpoint.dcbCatchupEnvelope(
+        ~logName,
+        ~eventType,
+        ~dataText=JSON.stringify(data),
+        ~metaText=JSON.stringify(meta),
+        ~firstTagValue=firstTagValue(row),
+      ) {
+      | Some(envelope) => await deliver(handlers, envelope)
+      | None => ()
+      }
+    | _ => ()
+    }
+  }
+}
+
+// Platform entry point: waits one macrotask so the just-built plugins' Output.apply
+// chains register their collector handlers (mirrors ProjectionCheckpoint.startupCatchup),
+// then replays the captured history.
+let startupCatchup = async (
+  ~pool: Pg.pool,
+  ~bounds: bounds,
+  ~handlers: unit => array<(string, ProjectionCheckpoint.catchupHandler)>,
+) => {
+  await Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), 0)
+  })
+  await runCatchup(~pool, ~bounds, ~handlers=handlers())
+}

package/src/adapter/PgProjectionCatchup.res.mjs

@@ -0,0 +1,114 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.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 ProjectionCheckpoint$ReventlessLocal from "./ProjectionCheckpoint.res.mjs";
+
+function intCol(row, key) {
+  let match = row[key];
+  if (match === undefined) {
+    return 0;
+  }
+  switch (typeof match) {
+    case "string" :
+      return Stdlib_Option.getOr(Stdlib_Int.fromString(match, undefined), 0);
+    case "number" :
+      return match | 0;
+    default:
+      return 0;
+  }
+}
+
+async function captureBounds(pool) {
+  let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT COALESCE(MAX(global_seq), 0)::bigint AS m FROM event_log", []);
+  let agg = row !== undefined ? intCol(row, "m") : 0;
+  let row$1 = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT COALESCE(MAX(position), 0)::bigint AS m FROM dcb_event", []);
+  let dcb = row$1 !== undefined ? intCol(row$1, "m") : 0;
+  return {
+    aggBound: agg,
+    dcbBound: dcb
+  };
+}
+
+function firstTagValue(row) {
+  let match = row["tags"];
+  if (match === undefined) {
+    return;
+  }
+  if (!Array.isArray(match)) {
+    return;
+  }
+  let match$1 = match[0];
+  if (match$1 === undefined) {
+    return;
+  }
+  if (typeof match$1 !== "string") {
+    return;
+  }
+  let i = match$1.indexOf("=");
+  if (i !== -1) {
+    return match$1.slice(i + 1 | 0, match$1.length);
+  } else {
+    return match$1;
+  }
+}
+
+async function deliver(handlers, envelope) {
+  for (let i = 0, i_finish = handlers.length; i < i_finish; ++i) {
+    let match = handlers[i];
+    try {
+      await match[1](envelope, undefined);
+    } catch (exn) {
+      
+    }
+  }
+}
+
+async function runCatchup(pool, bounds, handlers) {
+  let aggRows = await PgDriver$ReventlessPostgres.query(pool, "SELECT payload FROM event_log WHERE global_seq <= $1::bigint ORDER BY global_seq ASC", [bounds.aggBound]);
+  for (let i = 0, i_finish = aggRows.length; i < i_finish; ++i) {
+    let row = aggRows[i];
+    let payload = row["payload"];
+    if (payload !== undefined) {
+      let envelope = ProjectionCheckpoint$ReventlessLocal.catchupEnvelope(payload);
+      if (envelope !== undefined) {
+        await deliver(handlers, envelope);
+      }
+    }
+  }
+  let dcbRows = await PgDriver$ReventlessPostgres.query(pool, "SELECT log_name, event_type, data, meta, tags FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC", [bounds.dcbBound]);
+  for (let i$1 = 0, i_finish$1 = dcbRows.length; i$1 < i_finish$1; ++i$1) {
+    let row$1 = dcbRows[i$1];
+    let match = row$1["log_name"];
+    let match$1 = row$1["event_type"];
+    let match$2 = row$1["data"];
+    let match$3 = row$1["meta"];
+    if (typeof match === "string" && typeof match$1 === "string" && match$2 !== undefined && match$3 !== undefined) {
+      let envelope$1 = ProjectionCheckpoint$ReventlessLocal.dcbCatchupEnvelope(match, match$1, JSON.stringify(match$2), JSON.stringify(match$3), firstTagValue(row$1));
+      if (envelope$1 !== undefined) {
+        await deliver(handlers, envelope$1);
+      }
+    }
+  }
+}
+
+async function startupCatchup(pool, bounds, handlers) {
+  await new Promise((resolve, param) => {
+    setTimeout(() => resolve(), 0);
+  });
+  return await runCatchup(pool, bounds, handlers());
+}
+
+let Pg;
+
+export {
+  Pg,
+  intCol,
+  captureBounds,
+  firstTagValue,
+  deliver,
+  runCatchup,
+  startupCatchup,
+}
+/* PgDriver-ReventlessPostgres Not a pure module */

package/src/adapter/QueryDb/LocalQueryDbStorage.res

@@ -0,0 +1,43 @@
+// QueryDb storage dispatcher.
+//
+// Selects the concrete backend at `make` time by consulting BackendState:
+//   - Sqlite → QueryDbStorage_Sqlite (JSON tables + json_extract indexes)
+//   - Memory → QueryDbStorage_InMemory (pure in-memory, Bus-registered)
+//
+// Postgres note: the LocalBus scan/stream/index registrations are SYNCHRONOUS
+// (`unit => array<JSON.t>`), which async pg cannot satisfy without a broader bus
+// refactor. So under Backend.Postgres the read-model live-query path uses the
+// in-memory arm (getDb() is None for Postgres → Memory), rebuilt by replay from
+// the durable pg event log; the deploy-usable ReventlessPostgres.QueryDbStorage_Postgres
+// serves non-local compute layers. See docs/plans/postgres-storage-adapter.md §E.
+
+module Make = (Bus: LocalBus.T) => {
+  module Mem = QueryDbStorage_InMemory.Make(Bus)
+
+  type api = unit
+  type role = unit
+
+  let sqliteBusCallbacks: QueryDbStorage_Sqlite.busCallbacks = {
+    publishStateChange: Bus.publishStateChange,
+    registerQueryDb: Bus.registerQueryDb,
+    registerQueryDbScan: Bus.registerQueryDbScan,
+    registerQueryDbStream: Bus.registerQueryDbStream,
+    registerQueryDbIndexLookup: Bus.registerQueryDbIndexLookup,
+    registerQueryDbListPage: Bus.registerQueryDbListPage,
+  }
+
+  let make: ReventlessCore.QueryDb_Adapter.storageMaker<unit, unit> = (
+    ~name,
+    ~indexes,
+    ~subIdField=?,
+    ~ttl=?,
+    ~api,
+    ~apiRole,
+    ~opts,
+  ) =>
+    switch BackendState.getSqliteDb() {
+    | Some(db) =>
+      QueryDbStorage_Sqlite.makeStorage(~db, ~bus=sqliteBusCallbacks, ~name, ~indexes, ~subIdField)
+    | None => Mem.make(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~opts)
+    }
+}

package/src/adapter/QueryDb/LocalQueryDbStorage.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as QueryDbStorage_Sqlite$ReventlessLocal from "./QueryDbStorage_Sqlite.res.mjs";
+import * as QueryDbStorage_InMemory$ReventlessLocal from "./QueryDbStorage_InMemory.res.mjs";
+
+function Make(Bus) {
+  let Mem = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
+  let sqliteBusCallbacks_publishStateChange = Bus.publishStateChange;
+  let sqliteBusCallbacks_registerQueryDb = Bus.registerQueryDb;
+  let sqliteBusCallbacks_registerQueryDbScan = Bus.registerQueryDbScan;
+  let sqliteBusCallbacks_registerQueryDbStream = Bus.registerQueryDbStream;
+  let sqliteBusCallbacks_registerQueryDbIndexLookup = Bus.registerQueryDbIndexLookup;
+  let sqliteBusCallbacks_registerQueryDbListPage = Bus.registerQueryDbListPage;
+  let sqliteBusCallbacks = {
+    publishStateChange: sqliteBusCallbacks_publishStateChange,
+    registerQueryDb: sqliteBusCallbacks_registerQueryDb,
+    registerQueryDbScan: sqliteBusCallbacks_registerQueryDbScan,
+    registerQueryDbStream: sqliteBusCallbacks_registerQueryDbStream,
+    registerQueryDbIndexLookup: sqliteBusCallbacks_registerQueryDbIndexLookup,
+    registerQueryDbListPage: sqliteBusCallbacks_registerQueryDbListPage
+  };
+  let make = (name, indexes, subIdField, ttl, api, apiRole, opts) => {
+    let db = BackendState$ReventlessLocal.getSqliteDb();
+    if (db !== undefined) {
+      return QueryDbStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(db), sqliteBusCallbacks, name, indexes, subIdField);
+    } else {
+      return Mem.make(name, indexes, subIdField, ttl, api, apiRole, opts);
+    }
+  };
+  return {
+    Mem: Mem,
+    sqliteBusCallbacks: sqliteBusCallbacks,
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* QueryDbStorage_Sqlite-ReventlessLocal Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res

@@ -64,16 +64,9 @@ module Make = (Bus: LocalBus.T) => {
   type api = unit
   type role = unit
 
-  let sqliteBusCallbacks: QueryDbStorage_Sqlite.busCallbacks = {
-    publishStateChange: Bus.publishStateChange,
-    registerQueryDb: Bus.registerQueryDb,
-    registerQueryDbScan: Bus.registerQueryDbScan,
-    registerQueryDbStream: Bus.registerQueryDbStream,
-    registerQueryDbIndexLookup: Bus.registerQueryDbIndexLookup,
-    registerQueryDbListPage: Bus.registerQueryDbListPage,
-  }
-
-  let makeMemory: QueryDb_Adapter.storageMaker<unit, unit> = (
+  // Pure in-memory storageMaker (registers with Bus for live reads). Backend
+  // selection lives in LocalQueryDbStorage.Make.
+  let make: QueryDb_Adapter.storageMaker<unit, unit> = (
     ~name,
     ~indexes as _,
     ~subIdField=?,
@@ -343,18 +336,4 @@ module Make = (Bus: LocalBus.T) => {
     }
   }
 
-  let make: QueryDb_Adapter.storageMaker<unit, unit> = (
-    ~name,
-    ~indexes,
-    ~subIdField=?,
-    ~ttl=?,
-    ~api,
-    ~apiRole,
-    ~opts,
-  ) =>
-    switch BackendState.getDb() {
-    | Some(db) =>
-      QueryDbStorage_Sqlite.makeStorage(~db, ~bus=sqliteBusCallbacks, ~name, ~indexes, ~subIdField)
-    | None => makeMemory(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~opts)
-    }
 }