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

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

@@ -1,13 +1,20 @@
 // 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_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
+import * as Stream$1 from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+import * as ProjectionPending$ReventlessLocal from "../ProjectionPending.res.mjs";
 
 function ensureSchema(db) {
   SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS snapshot (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, state TEXT NOT NULL, schema_hash TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id))");
 }
 
 function decodePayload(row) {
@@ -26,7 +33,7 @@ function decodePayload(row) {
 }
 
 function countAll(db) {
-  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  ensureSchema(db);
   let row = SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM event_log"), []);
   if (row === undefined) {
     return 0;
@@ -40,12 +47,15 @@ function countAll(db) {
 }
 
 function makeStorage(db, name, param) {
-  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  ensureSchema(db);
   let insertStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)");
-  let countStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM event_log WHERE log_name=? AND aggregate_id=?");
-  let selectByIdStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? ORDER BY seq_nr ASC");
-  let currentCount = id => {
-    let row = SqliteDriver$ReventlessLocal.get(countStmt, [
+  let nextSeqStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT COALESCE(MAX(seq_nr), -1) + 1 AS c FROM event_log WHERE log_name=? AND aggregate_id=?");
+  let selectByIdStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? AND seq_nr >= ? ORDER BY seq_nr ASC");
+  let lastRowidStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT last_insert_rowid() AS r");
+  let upsertSnapshotStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT OR REPLACE INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash) VALUES(?,?,?,?,?)");
+  let selectSnapshotStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name=? AND aggregate_id=?");
+  let expectedNextSeq = id => {
+    let row = SqliteDriver$ReventlessLocal.get(nextSeqStmt, [
       name,
       id
     ]);
@@ -59,10 +69,10 @@ function makeStorage(db, name, param) {
       return 0;
     }
   };
-  let append = async (seqNr, id, jsons) => {
+  let appendTracked = async (track, seqNr, id, jsons) => {
     try {
-      SqliteDriver$ReventlessLocal.transaction(db, () => {
-        let existing = currentCount(id);
+      let lastRowid = SqliteDriver$ReventlessLocal.transaction(db, () => {
+        let existing = expectedNextSeq(id);
         if (seqNr !== existing) {
           throw {
             RE_EXN_ID: "Failure",
@@ -76,7 +86,24 @@ function makeStorage(db, name, param) {
           seqNr + i | 0,
           JSON.stringify(json)
         ]));
+        let row = SqliteDriver$ReventlessLocal.get(lastRowidStmt, []);
+        if (row === undefined) {
+          return 0;
+        }
+        let match = row["r"];
+        if (typeof match === "number") {
+          return match | 0;
+        } else {
+          return 0;
+        }
       });
+      if (track && lastRowid > 0) {
+        let count = jsons.length;
+        ProjectionPending$ReventlessLocal.trackAppended("Aggregate", Stdlib_Array.filterMap(jsons.map((json, i) => Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string), msgId => [
+          msgId,
+          ((lastRowid - count | 0) + 1 | 0) + i | 0
+        ])), x => x));
+      }
       return {
         TAG: "Ok",
         _0: undefined
@@ -84,39 +111,120 @@ function makeStorage(db, name, param) {
     } catch (raw_msg) {
       let msg = Primitive_exceptions.internalToException(raw_msg);
       if (msg.RE_EXN_ID === "Failure") {
+        let msg$1 = msg._1;
+        if (msg$1 === "conflict") {
+          return {
+            TAG: "Error",
+            _0: "Conflict"
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: {
+              TAG: "StorageFailure",
+              _0: msg$1
+            }
+          };
+        }
+      }
+      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: msg._1
+          _0: "Conflict"
         };
       } else {
         return {
           TAG: "Error",
-          _0: "conflict"
+          _0: {
+            TAG: "StorageFailure",
+            _0: msg$2 === "" ? "storage error" : msg$2
+          }
         };
       }
     }
   };
-  let replayArray = id => SqliteDriver$ReventlessLocal.all(selectByIdStmt, [
-    name,
-    id
-  ]).map(decodePayload);
-  let replay = replayArray;
-  let replayStream = id => Stream.fromIterable(replayArray(id));
-  let appendStream = (startingSeqNr, id, stream) => {
-    let seqNrRef = {
-      contents: startingSeqNr
-    };
-    return Stream.runForEach(stream, json => {
-      let currentSeq = seqNrRef.contents;
-      return Effect.flatMap(Effect.promise(() => append(currentSeq, id, [json])), result => {
-        if (result.TAG !== "Ok") {
-          return Effect.fail(result._0);
-        }
-        seqNrRef.contents = currentSeq + 1 | 0;
-        return Effect.succeed();
-      });
-    });
+  let append = (seqNr, id, jsons) => appendTracked(true, seqNr, id, jsons);
+  let replayArray = (id, fromSeqOpt) => {
+    let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+    return SqliteDriver$ReventlessLocal.all(selectByIdStmt, [
+      name,
+      id,
+      fromSeq
+    ]).map(decodePayload);
   };
+  let replay = async id => replayArray(id, undefined);
+  let replayStream = (id, fromSeq) => Stream$1.fromIterable(replayArray(id, fromSeq));
+  let latestSnapshot = async id => {
+    try {
+      let row = SqliteDriver$ReventlessLocal.get(selectSnapshotStmt, [
+        name,
+        id
+      ]);
+      if (row === undefined) {
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+      let match = row["seq_nr"];
+      let match$1 = row["state"];
+      let match$2 = row["schema_hash"];
+      if (typeof match === "number" && typeof match$1 === "string" && typeof match$2 === "string") {
+        return {
+          TAG: "Ok",
+          _0: {
+            seqNr: match | 0,
+            state: JSON.parse(match$1),
+            schemaHash: match$2
+          }
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: "snapshot row has unexpected shape"
+        };
+      }
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "snapshot read error")
+      };
+    }
+  };
+  let writeSnapshot = async (id, snap) => {
+    try {
+      SqliteDriver$ReventlessLocal.run(upsertSnapshotStmt, [
+        name,
+        id,
+        snap.seqNr,
+        JSON.stringify(snap.state),
+        snap.schemaHash
+      ]);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "snapshot write error")
+      };
+    }
+  };
+  let appendStream = (startingSeqNr, id, stream) => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.flatMap(Effect.promise(() => appendTracked(false, startingSeqNr, id, jsons)), result => {
+    if (result.TAG === "Ok") {
+      return Effect.succeed();
+    }
+    let msg = result._0;
+    if (typeof msg !== "object") {
+      return Effect.fail("conflict");
+    } else {
+      return Effect.fail(msg._0);
+    }
+  }));
   return [
     name,
     replay,
@@ -126,7 +234,9 @@ function makeStorage(db, name, param) {
         append: append,
         replay: replay,
         replayStream: replayStream,
-        appendStream: appendStream
+        appendStream: appendStream,
+        latestSnapshot: latestSnapshot,
+        writeSnapshot: writeSnapshot
       })
     }
   ];
@@ -152,4 +262,4 @@ export {
   makeStorage,
   Make,
 }
-/* effect/Effect Not a pure module */
+/* Stream Not a pure module */

package/src/adapter/LocalBus.res

@@ -154,6 +154,33 @@ module type T = {
   // Used by LocalQueryEngine to honour ~limit via Stream.take without loading all items.
   let registerQueryDbStream: (string, unit => Stream.t<JSON.t, string, unit>) => unit
   let getQueryDbStream: string => option<unit => Stream.t<JSON.t, string, unit>>
+  // Indexed equality lookup: (field, value) → matching items. The SQLite backend
+  // registers a closure that pushes the predicate down to a `json_extract` GSI
+  // index instead of materialising + parsing the whole table; the in-memory
+  // backend registers a scan+filter. The `{name}By{Index}` resolvers use this
+  // when present and fall back to `getQueryDbScan` otherwise.
+  let registerQueryDbIndexLookup: (string, (string, string) => array<JSON.t>) => unit
+  let getQueryDbIndexLookup: string => option<(string, string) => array<JSON.t>>
+  // Connection-list push-down: given the GraphQL args + derived capability +
+  // label field, a backend may return a ready Relay connection object computed
+  // entirely in storage (SQLite: json_extract predicates + ORDER BY … LIMIT), or
+  // `None` when it can't serve that query shape — the resolver then falls back to
+  // materialise + `QueryDbListQuery.run`. Only the SQLite backend registers one.
+  let registerQueryDbListPage: (
+    string,
+    (
+      ~argsDict: dict<JSON.t>,
+      ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
+      ~labelField: string,
+    ) => option<JSON.t>,
+  ) => unit
+  let getQueryDbListPage: string => option<
+    (
+      ~argsDict: dict<JSON.t>,
+      ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
+      ~labelField: string,
+    ) => option<JSON.t>,
+  >
 
   // Event log replay registry: aggregate EventLog name → replay function (entityId → events)
   let registerEventLogReplay: (string, string => promise<array<JSON.t>>) => unit
@@ -196,6 +223,15 @@ module type T = {
   let registerEventCollectorHandler: (string, (JSON.t, unit) => promise<unit>) => unit
   let subscribeEventCollectorToTopic: (string, string) => unit
 
+  // Projection catch-up registry: collector name → its resolved JSON event
+  // handler, registered only by projection-type collectors (the ReadModel
+  // builders, via LocalEventCollectorChannel.MakeProjection). The SQLite
+  // backend's startup catch-up (ProjectionCheckpoint.runCatchup) replays missed
+  // stored events into these handlers; automation/translation collectors are
+  // deliberately NOT in this registry so catch-up can never re-run side effects.
+  let registerProjectionCatchupHandler: (string, (JSON.t, unit) => promise<unit>) => unit
+  let projectionCatchupHandlers: unit => array<(string, (JSON.t, unit) => promise<unit>)>
+
   let reset: unit => unit
 }
 
@@ -227,6 +263,16 @@ module Impl = (C: BusConfig): T => {
   let queryDbRegistry: ref<dict<ReventlessCore.QueryDb_Adapter.operations>> = ref(Dict.make())
   let queryDbScanRegistry: ref<dict<unit => array<JSON.t>>> = ref(Dict.make())
   let queryDbStreamRegistry: ref<dict<unit => Stream.t<JSON.t, string, unit>>> = ref(Dict.make())
+  let queryDbIndexLookupRegistry: ref<dict<(string, string) => array<JSON.t>>> = ref(Dict.make())
+  let queryDbListPageRegistry: ref<
+    dict<
+      (
+        ~argsDict: dict<JSON.t>,
+        ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
+        ~labelField: string,
+      ) => option<JSON.t>,
+    >,
+  > = ref(Dict.make())
   let eventLogReplayRegistry: ref<dict<string => promise<array<JSON.t>>>> = ref(Dict.make())
   let dcbEventLogReadRegistry: ref<
     dict<
@@ -265,7 +311,19 @@ module Impl = (C: BusConfig): T => {
     let drainLoop = Effect.scoped(
       PubSub.subscribe(hub)->Effect.flatMap(queue =>
         Stream.fromQueue(queue)->Stream.runForEach(msg =>
-          Effect.promise(() => handler(msg.service, msg.meta, msg.json))->Effect.zipRight(msg.done_)
+          // A throwing/rejecting handler must not (a) leave `done_` uncalled —
+          // the publisher's countdown would never reach zero and every publish
+          // on this topic would hang — nor (b) kill this drain fiber, which
+          // would stop consuming while the subscriber stays counted, hanging all
+          // future publishes too. So: convert a rejection into a typed error
+          // (`tryPromise`), log-and-recover (`catchAll`) so the stream keeps
+          // draining, and run `done_` via `ensuring` so the countdown always
+          // advances regardless of outcome.
+          Effect.tryPromise(~catch=e => e, () => handler(msg.service, msg.meta, msg.json))
+          ->Effect.catchAll(err =>
+            Effect.sync(() => Console.error2("[LocalBus] subscriber handler failed:", err))
+          )
+          ->Effect.ensuring(msg.done_)
         )
       ),
     )
@@ -372,7 +430,11 @@ module Impl = (C: BusConfig): T => {
       let pending = queue.contents
       queue.contents = []
       pending->Array.forEach(json => {
-        let _ = handler(json, ())
+        let _ =
+          handler(json, ())->Promise.catch(e => {
+            Console.error2("[LocalBus] parked command handler failed:", e)
+            Promise.resolve()
+          })
       })
     | None => ()
     }
@@ -385,6 +447,12 @@ module Impl = (C: BusConfig): T => {
   let registerQueryDbStream = (name, streamFn) =>
     queryDbStreamRegistry.contents->Dict.set(name, streamFn)
   let getQueryDbStream = name => queryDbStreamRegistry.contents->Dict.get(name)
+  let registerQueryDbIndexLookup = (name, lookup) =>
+    queryDbIndexLookupRegistry.contents->Dict.set(name, lookup)
+  let getQueryDbIndexLookup = name => queryDbIndexLookupRegistry.contents->Dict.get(name)
+  let registerQueryDbListPage = (name, listPage) =>
+    queryDbListPageRegistry.contents->Dict.set(name, listPage)
+  let getQueryDbListPage = name => queryDbListPageRegistry.contents->Dict.get(name)
 
   let registerEventLogReplay = (name, replay) =>
     eventLogReplayRegistry.contents->Dict.set(name, replay)
@@ -414,7 +482,11 @@ module Impl = (C: BusConfig): T => {
   // and done_ is called immediately. This prevents a deadlock where publishEvent on the
   // EP topic would block until the downstream aggregate command chain completes.
   let makeFireAndForgetHandler = handler => (_, _, json) => {
-    let _ = handler(json, ())
+    let _ =
+      handler(json, ())->Promise.catch(e => {
+        Console.error2("[LocalBus] fire-and-forget handler failed:", e)
+        Promise.resolve()
+      })
     Promise.resolve()
   }
 
@@ -440,6 +512,13 @@ module Impl = (C: BusConfig): T => {
     }
   }
 
+  let projectionCatchupRegistry: ref<dict<(JSON.t, unit) => promise<unit>>> = ref(Dict.make())
+
+  let registerProjectionCatchupHandler = (name, handler) =>
+    projectionCatchupRegistry.contents->Dict.set(name, handler)
+
+  let projectionCatchupHandlers = () => projectionCatchupRegistry.contents->Dict.toArray
+
   let reset = () => {
     // Shut down all hubs — PubSub.shutdown interrupts Stream.fromQueue consumers,
     // causing Stream.runForEach to complete and Effect.scoped to close the subscription.
@@ -457,11 +536,14 @@ module Impl = (C: BusConfig): T => {
     queryDbRegistry := Dict.make()
     queryDbScanRegistry := Dict.make()
     queryDbStreamRegistry := Dict.make()
+    queryDbIndexLookupRegistry := Dict.make()
+    queryDbListPageRegistry := Dict.make()
     eventLogReplayRegistry := Dict.make()
     dcbEventLogReadRegistry := Dict.make()
     stateChangeListeners := Dict.make()
     eventCollectorHandlers := Dict.make()
     eventCollectorPendingTopics := Dict.make()
+    projectionCatchupRegistry := Dict.make()
   }
 }