@reventlessdev/reventless-local 3.0.0-alpha.317 → 3.0.0-alpha.319

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

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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";
@@ -13,6 +14,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "../LocalEventLogRead.res.mjs";
 import * as ProjectionPending$ReventlessLocal from "../ProjectionPending.res.mjs";
 
 function ensureSchema(db) {
@@ -20,6 +22,7 @@ function ensureSchema(db) {
   SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS dcb_tag (log_name TEXT NOT NULL, position INTEGER NOT NULL, tag_key TEXT NOT NULL, tag_value TEXT NOT NULL)");
   SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS dcb_tag_by_kv ON dcb_tag(log_name, tag_key, tag_value, position)");
   SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS dcb_tag_by_pos ON dcb_tag(log_name, position)");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS dcb_event_by_correlation ON dcb_event(log_name, json_extract(meta, '$.correlationId'), position)");
 }
 
 function posToInt(pos) {
@@ -128,8 +131,73 @@ function buildQuerySql(logName, query, after) {
   ];
 }
 
+function readBackSql(name, bound, limit, correlationId) {
+  let parts = ["log_name = ?"];
+  let params = [name];
+  if (bound !== undefined) {
+    if (bound.TAG === "Below") {
+      parts.push("position < ?");
+      params.push(bound._0);
+    } else {
+      parts.push("position <= ?");
+      params.push(bound._0);
+    }
+  }
+  if (correlationId !== undefined) {
+    parts.push("json_extract(meta, '$.correlationId') = ?");
+    params.push(correlationId);
+  }
+  params.push(limit);
+  return [
+    `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ` + parts.join(" AND ") + ` ORDER BY position DESC LIMIT ?`,
+    params
+  ];
+}
+
+function readBack(db, name) {
+  return async (bound, limit, correlationId) => {
+    let match = readBackSql(name, bound, limit, correlationId);
+    let rows = SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, match[0]), match[1]);
+    let positions = rows.map(row => Stdlib_Option.mapOr(row["position"], 0, coercePosition));
+    let tagsByPos = {};
+    if (positions.length !== 0) {
+      let placeholders = positions.map(param => "?").join(",");
+      SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, `SELECT position, tag_key, tag_value FROM dcb_tag WHERE log_name = ? AND position IN (` + placeholders + `) ORDER BY position ASC, rowid ASC`), [name].concat(positions.map(prim => prim))).forEach(row => {
+        let k = Stdlib_Option.mapOr(row["position"], 0, coercePosition).toString();
+        let str = key => Stdlib_Option.getOr(Stdlib_Option.flatMap(row[key], Stdlib_JSON.Decode.string), "");
+        let tag_key = str("tag_key");
+        let tag_value = str("tag_value");
+        let tag = {
+          key: tag_key,
+          value: tag_value
+        };
+        let list = tagsByPos[k];
+        if (list !== undefined) {
+          list.push(tag);
+        } else {
+          tagsByPos[k] = [tag];
+        }
+      });
+    }
+    return rows.map(row => {
+      let position = Stdlib_Option.mapOr(row["position"], 0, coercePosition);
+      let str = key => Stdlib_Option.getOr(Stdlib_Option.flatMap(row[key], Stdlib_JSON.Decode.string), "");
+      return {
+        log: name,
+        position: position,
+        eventType: str("event_type"),
+        tags: Stdlib_Option.getOr(tagsByPos[position.toString()], []),
+        payload: parseDataPayload(str("data")),
+        meta: parseDataPayload(str("meta")),
+        recordedAt: str("recorded_at")
+      };
+    });
+  };
+}
+
 function makeStorage(db, name, param, param$1, param$2) {
   ensureSchema(db);
+  LocalEventLogRead$ReventlessLocal.register(name, "Dcb", readBack(db, name));
   let insertEventStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO dcb_event(log_name, position, event_type, data, meta, recorded_at) VALUES(?,?,?,?,?,?)");
   let lastRowidStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT last_insert_rowid() AS r");
   let insertTagStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO dcb_tag(log_name, position, tag_key, tag_value) VALUES(?,?,?,?)");
@@ -263,6 +331,7 @@ function makeStorage(db, name, param, param$1, param$2) {
       }
     };
     let appended = [];
+    let positionsOf = [];
     try {
       SqliteDriver$ReventlessLocal.transaction(db, () => {
         if (condition !== undefined) {
@@ -310,6 +379,10 @@ function makeStorage(db, name, param, param$1, param$2) {
             tag.key,
             tag.value
           ]));
+          positionsOf.push([
+            event.meta.msgId,
+            pos
+          ]);
           lastPos.contents = pos;
         });
         result.contents = {
@@ -318,6 +391,7 @@ function makeStorage(db, name, param, param$1, param$2) {
         };
       });
       ProjectionPending$ReventlessLocal.trackAppended("Dcb", appended);
+      positionsOf.forEach(param => LocalEventLogRead$ReventlessLocal.note(name, param[0], param[1]));
       return result.contents;
     } catch (raw_msg) {
       let msg = Primitive_exceptions.internalToException(raw_msg);
@@ -380,6 +454,8 @@ export {
   buildClauseSql,
   buildQueryWhere,
   buildQuerySql,
+  readBackSql,
+  readBack,
   makeStorage,
 }
 /* Stdlib_JsExn Not a pure module */

package/src/adapter/DcbEventLog/LocalDcbEventLogStorage.res

@@ -37,7 +37,14 @@ module Make = (Bus: LocalBus.T) => {
         ~opts,
       )
       Bus.registerDcbEventLogRead(storageName, ops.read)
-      storage
+      LocalPgEventLogRead.registerDcb(~pool, ~name=storageName)
+      {
+        ReventlessCore.DcbEventLog_Adapter.resources: storage.resources,
+        operations: Pulumi.Output.make({
+          ...ops,
+          append: LocalPgEventLogRead.notingDcbAppend(~pool, ~name=storageName, ops.append),
+        }),
+      }
     | (None, None) =>
       let (storageName, read, storage) = DcbEventLogStorage_InMemory.makeStorage(
         ~name,

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

@@ -1,7 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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 LocalPgEventLogRead$ReventlessLocal from "../LocalPgEventLogRead.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";
@@ -16,9 +18,20 @@ function Make(Bus) {
       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 pool = Primitive_option.valFromOption(match$1);
+      let match$3 = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, name, indexes, partitionTag, undefined, opts, undefined, undefined);
+      let ops = match$3[1];
+      let storageName = match$3[0];
+      Bus.registerDcbEventLogRead(storageName, ops.read);
+      LocalPgEventLogRead$ReventlessLocal.registerDcb(pool, storageName);
+      return {
+        resources: match$3[2].resources,
+        operations: Pulumi.output({
+          read: ops.read,
+          append: LocalPgEventLogRead$ReventlessLocal.notingDcbAppend(pool, storageName, ops.append),
+          readStream: ops.readStream
+        })
+      };
     }
     let match$4 = DcbEventLogStorage_InMemory$ReventlessLocal.makeStorage(name, indexes, partitionTag, opts);
     Bus.registerDcbEventLogRead(match$4[0], match$4[1]);
@@ -32,4 +45,4 @@ function Make(Bus) {
 export {
   Make,
 }
-/* BackendState-ReventlessLocal Not a pure module */
+/* @pulumi/pulumi Not a pure module */

package/src/adapter/EventLog/EventLogStorage_InMemory.res

@@ -7,6 +7,46 @@
 // both backends.
 
 let makeMemoryStorage = (~name as _name, ~opts as _) => {
+  // Every event of the log in the order it was appended, across entities, for
+  // the read that runs newest first. The insertion number is its position.
+  let ordered: array<LocalEventLogRead.stored> = []
+  let keepOrdered = (~track: bool, id: string, jsons: array<JSON.t>) =>
+    jsons->Array.forEach(json => {
+      let position = (ordered->Array.length + 1)->Int.toFloat
+      ordered->Array.push(LocalEventLogRead.storedOfFlat(~log=_name, ~position, ~entityId=id, json))
+      if track {
+        json
+        ->JSON.Decode.object
+        ->Option.flatMap(d => d->Dict.get("msgId"))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.forEach(msgId => LocalEventLogRead.note(~log=_name, ~msgId, ~position))
+      }
+    })
+  LocalEventLogRead.register(~log=_name, ~kind=Aggregate, async (
+    ~bound,
+    ~limit,
+    ~correlationId,
+  ) => {
+    let out = []
+    let i = ref(ordered->Array.length - 1)
+    while i.contents >= 0 && out->Array.length < limit {
+      let r = ordered->Array.getUnsafe(i.contents)
+      let inBound = switch bound {
+      | Some(LocalEventLogRead.Below(p)) => r.position < p
+      | Some(AtMost(p)) => r.position <= p
+      | None => true
+      }
+      let inFlow =
+        correlationId->Option.mapOr(true, id =>
+          LocalEventLogRead.metaString(r.meta, "correlationId") == Some(id)
+        )
+      if inBound && inFlow {
+        out->Array.push(r)
+      }
+      i := i.contents - 1
+    }
+    out
+  })
   let eventsRef =
     Stm.TRef.make(Dict.make())
     ->Stm.commit
@@ -16,8 +56,8 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
   // writes are fire-and-forget upserts, so a plain dict suffices (no Stm).
   let snapshots: dict<ReventlessCore.EventLog.snapshot> = Dict.make()
 
-  let append: ReventlessCore.EventLog.append<string, JSON.t> = (seqNr, id, jsons) =>
-    Stm.TRef.modify(eventsRef, events => {
+  let append: ReventlessCore.EventLog.append<string, JSON.t> = async (seqNr, id, jsons) => {
+    let result = await Stm.TRef.modify(eventsRef, events => {
       let existing = events->Dict.get(id)->Option.getOr([])
       let currentCount = existing->Array.length
       if seqNr != currentCount {
@@ -29,6 +69,12 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
     })
     ->Stm.commit
     ->Effect.runPromise
+    switch result {
+    | Ok() => keepOrdered(~track=true, id, jsons)
+    | Error(_) => ()
+    }
+    result
+  }
 
   // The in-memory array is already resident; expose it as a stream for API uniformity.
   // The real performance gain from streaming comes from the DynamoDB adapter.
@@ -83,6 +129,7 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
         switch result {
         | Ok() =>
           seqNrRef := seqNrRef.contents + 1
+          keepOrdered(~track=false, id, [json])
           Effect.succeed()
         | Error(msg) => Effect.fail(msg)
         }

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

@@ -2,37 +2,72 @@
 
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as STM from "effect/STM";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as TRef from "effect/TRef";
 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_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as LocalEventLogRead$ReventlessLocal from "../LocalEventLogRead.res.mjs";
 
 function makeMemoryStorage(_name, param) {
+  let ordered = [];
+  let keepOrdered = (track, id, jsons) => {
+    jsons.forEach(json => {
+      let position = ordered.length + 1 | 0;
+      ordered.push(LocalEventLogRead$ReventlessLocal.storedOfFlat(_name, position, id, json));
+      if (track) {
+        return Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string), msgId => LocalEventLogRead$ReventlessLocal.note(_name, msgId, position));
+      }
+    });
+  };
+  LocalEventLogRead$ReventlessLocal.register(_name, "Aggregate", async (bound, limit, correlationId) => {
+    let out = [];
+    let i = ordered.length - 1 | 0;
+    while (i >= 0 && out.length < limit) {
+      let r = ordered[i];
+      let inBound = bound !== undefined ? (
+          bound.TAG === "Below" ? r.position < bound._0 : r.position <= bound._0
+        ) : true;
+      let inFlow = Stdlib_Option.mapOr(correlationId, true, id => Primitive_object.equal(LocalEventLogRead$ReventlessLocal.metaString(r.meta, "correlationId"), id));
+      if (inBound && inFlow) {
+        out.push(r);
+      }
+      i = i - 1 | 0;
+    };
+    return out;
+  });
   let eventsRef = Effect.runSync(STM.commit(TRef.make({})));
   let snapshots = {};
-  let append = (seqNr, id, jsons) => Effect.runPromise(STM.commit(TRef.modify(eventsRef, events => {
-    let existing = Stdlib_Option.getOr(events[id], []);
-    let currentCount = existing.length;
-    if (seqNr !== currentCount) {
-      return [
-        {
-          TAG: "Error",
-          _0: "Conflict"
-        },
-        events
-      ];
-    } else {
-      events[id] = existing.concat(jsons);
-      return [
-        {
-          TAG: "Ok",
-          _0: undefined
-        },
-        events
-      ];
+  let append = async (seqNr, id, jsons) => {
+    let result = await Effect.runPromise(STM.commit(TRef.modify(eventsRef, events => {
+      let existing = Stdlib_Option.getOr(events[id], []);
+      let currentCount = existing.length;
+      if (seqNr !== currentCount) {
+        return [
+          {
+            TAG: "Error",
+            _0: "Conflict"
+          },
+          events
+        ];
+      } else {
+        events[id] = existing.concat(jsons);
+        return [
+          {
+            TAG: "Ok",
+            _0: undefined
+          },
+          events
+        ];
+      }
+    })));
+    if (result.TAG === "Ok") {
+      keepOrdered(true, id, jsons);
     }
-  })));
+    return result;
+  };
   let replayStream = (id, fromSeqOpt) => {
     let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
     return Stream$1.flatMap(Stream$1.fromEffect(Effect.map(STM.commit(TRef.get(eventsRef)), events => Stdlib_Option.getOr(events[id], []).filter((param, i) => i >= fromSeq))), arr => Stream$1.fromIterable(arr));
@@ -79,6 +114,7 @@ function makeMemoryStorage(_name, param) {
         return Effect.fail(result._0);
       }
       seqNrRef.contents = seqNrRef.contents + 1 | 0;
+      keepOrdered(false, id, [json]);
       return Effect.succeed();
     }));
   };

package/src/adapter/EventLog/EventLogStorage_Sqlite.res

@@ -27,8 +27,78 @@ let ensureSchema = (db: SqliteDriver.t) => {
   db->SqliteDriver.exec(
     "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))",
   )
+  // Reading one log newest first across its entities walks this index by row id
+  // (an index on log_name holds the row id after it).
+  db->SqliteDriver.exec("CREATE INDEX IF NOT EXISTS event_log_by_log ON event_log(log_name)")
+  // Finding every event of one flow in one log. Created on open, so an existing
+  // store gains it; a query must use this exact expression for the index to
+  // apply. The stored event is flat, so the correlation id is a top-level key.
+  db->SqliteDriver.exec(
+    "CREATE INDEX IF NOT EXISTS event_log_by_correlation ON event_log(log_name, json_extract(payload, '$.correlationId'))",
+  )
+}
+
+/** The SQL of one backwards read, and its parameters. */
+let readBackSql = (
+  ~name: string,
+  ~bound: option<LocalEventLogRead.bound>,
+  ~limit: int,
+  ~correlationId: option<string>,
+): (string, array<JSON.t>) => {
+  let parts = ["log_name = ?"]
+  let params = [JSON.Encode.string(name)]
+  switch bound {
+  | Some(LocalEventLogRead.Below(p)) =>
+    parts->Array.push("rowid < ?")
+    params->Array.push(JSON.Encode.float(p))
+  | Some(AtMost(p)) =>
+    parts->Array.push("rowid <= ?")
+    params->Array.push(JSON.Encode.float(p))
+  | None => ()
+  }
+  switch correlationId {
+  | Some(id) =>
+    parts->Array.push("json_extract(payload, '$.correlationId') = ?")
+    params->Array.push(JSON.Encode.string(id))
+  | None => ()
+  }
+  params->Array.push(JSON.Encode.int(limit))
+  (
+    `SELECT rowid AS pos, aggregate_id, payload FROM event_log WHERE ${parts->Array.join(
+        " AND ",
+      )} ORDER BY rowid DESC LIMIT ?`,
+    params,
+  )
 }
 
+/** Reads one log newest first, across its entities, by row id. */
+let readBack = (~db: SqliteDriver.t, ~name: string): LocalEventLogRead.readBack =>
+  async (~bound, ~limit, ~correlationId) => {
+    let (sql, params) = readBackSql(~name, ~bound, ~limit, ~correlationId)
+    db
+    ->SqliteDriver.prepare(sql)
+    ->SqliteDriver.all(params)
+    ->Array.map(row => {
+      let payload = switch row->Dict.get("payload") {
+      | Some(JSON.String(s)) =>
+        switch JSON.parseOrThrow(s) {
+        | json => json
+        | exception _ => JSON.Encode.null
+        }
+      | _ => JSON.Encode.null
+      }
+      LocalEventLogRead.storedOfFlat(
+        ~log=name,
+        ~position=LocalEventLogRead.numberOf(row->Dict.get("pos")),
+        ~entityId=row
+        ->Dict.get("aggregate_id")
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.getOr(""),
+        payload,
+      )
+    })
+  }
+
 // Decodes the JSON column to a JSON.t. Returns JSON.Null on unparseable input
 // (should not happen for data we wrote ourselves).
 let decodePayload = (row: dict<JSON.t>): JSON.t =>
@@ -57,6 +127,7 @@ let countAll = (db: SqliteDriver.t): int => {
 
 let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
   ensureSchema(db)
+  LocalEventLogRead.register(~log=name, ~kind=Aggregate, readBack(~db, ~name))
 
   let insertStmt =
     db->SqliteDriver.prepare(
@@ -130,6 +201,20 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
       // inserts get contiguous rowids ending at lastRowid.
       if track && lastRowid > 0 {
         let count = jsons->Array.length
+        // Where each event sits, for the tap line that publishes it.
+        jsons->Array.forEachWithIndex((json, i) =>
+          json
+          ->JSON.Decode.object
+          ->Option.flatMap(d => d->Dict.get("msgId"))
+          ->Option.flatMap(JSON.Decode.string)
+          ->Option.forEach(msgId =>
+            LocalEventLogRead.note(
+              ~log=name,
+              ~msgId,
+              ~position=(lastRowid - count + 1 + i)->Int.toFloat,
+            )
+          )
+        )
         ProjectionPending.trackAppended(
           ~axis=ProjectionPending.Aggregate,
           jsons

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

@@ -10,11 +10,57 @@ 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 LocalEventLogRead$ReventlessLocal from "../LocalEventLogRead.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))");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS event_log_by_log ON event_log(log_name)");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS event_log_by_correlation ON event_log(log_name, json_extract(payload, '$.correlationId'))");
+}
+
+function readBackSql(name, bound, limit, correlationId) {
+  let parts = ["log_name = ?"];
+  let params = [name];
+  if (bound !== undefined) {
+    if (bound.TAG === "Below") {
+      parts.push("rowid < ?");
+      params.push(bound._0);
+    } else {
+      parts.push("rowid <= ?");
+      params.push(bound._0);
+    }
+  }
+  if (correlationId !== undefined) {
+    parts.push("json_extract(payload, '$.correlationId') = ?");
+    params.push(correlationId);
+  }
+  params.push(limit);
+  return [
+    `SELECT rowid AS pos, aggregate_id, payload FROM event_log WHERE ` + parts.join(" AND ") + ` ORDER BY rowid DESC LIMIT ?`,
+    params
+  ];
+}
+
+function readBack(db, name) {
+  return async (bound, limit, correlationId) => {
+    let match = readBackSql(name, bound, limit, correlationId);
+    return SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, match[0]), match[1]).map(row => {
+      let match = row["payload"];
+      let payload;
+      if (typeof match === "string") {
+        try {
+          payload = JSON.parse(match);
+        } catch (exn) {
+          payload = null;
+        }
+      } else {
+        payload = null;
+      }
+      return LocalEventLogRead$ReventlessLocal.storedOfFlat(name, LocalEventLogRead$ReventlessLocal.numberOf(row["pos"]), Stdlib_Option.getOr(Stdlib_Option.flatMap(row["aggregate_id"], Stdlib_JSON.Decode.string), ""), payload);
+    });
+  };
 }
 
 function decodePayload(row) {
@@ -48,6 +94,7 @@ function countAll(db) {
 
 function makeStorage(db, name, param) {
   ensureSchema(db);
+  LocalEventLogRead$ReventlessLocal.register(name, "Aggregate", readBack(db, name));
   let insertStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)");
   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");
@@ -99,6 +146,7 @@ function makeStorage(db, name, param) {
       });
       if (track && lastRowid > 0) {
         let count = jsons.length;
+        jsons.forEach((json, i) => Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string), msgId => LocalEventLogRead$ReventlessLocal.note(name, msgId, ((lastRowid - count | 0) + 1 | 0) + i | 0)));
         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
@@ -257,6 +305,8 @@ function Make(Bus) {
 
 export {
   ensureSchema,
+  readBackSql,
+  readBack,
   decodePayload,
   countAll,
   makeStorage,

package/src/adapter/EventLog/LocalEventLogStorage.res

@@ -21,8 +21,11 @@ module Make = (Bus: LocalBus.T) => {
         ~pool,
         ~name,
         ~opts,
+        // Where each event sits, for the tap line that publishes it.
+        ~onAppended=LocalPgEventLogRead.noteAppended(~name),
       )
       Bus.registerEventLogReplay(storageName, ops.replay)
+      LocalPgEventLogRead.registerAggregate(~pool, ~name=storageName)
       storage
     | (None, None) =>
       let (storageName, replay, storage) = EventLogStorage_InMemory.makeMemoryStorage(~name, ~opts)

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

@@ -2,6 +2,7 @@
 
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as BackendState$ReventlessLocal from "../BackendState.res.mjs";
+import * as LocalPgEventLogRead$ReventlessLocal from "../LocalPgEventLogRead.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";
@@ -16,8 +17,11 @@ function Make(Bus) {
       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);
+      let pool = Primitive_option.valFromOption(match$1);
+      let match$3 = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, name, opts, LocalPgEventLogRead$ReventlessLocal.noteAppended(name));
+      let storageName = match$3[0];
+      Bus.registerEventLogReplay(storageName, match$3[1].replay);
+      LocalPgEventLogRead$ReventlessLocal.registerAggregate(pool, storageName);
       return match$3[2];
     }
     let match$4 = EventLogStorage_InMemory$ReventlessLocal.makeMemoryStorage(name, opts);

package/src/adapter/LocalBus.res

@@ -61,29 +61,56 @@ type queuedEvent = {
 let eventTapSeq = ref(0)
 // Continues the timeline's #N across restarts for a persistent store.
 let seedEventTapSeq = (n: int) => eventTapSeq := n
-let emitEventTap = (~topic: string, ~service: string, ~payload: JSON.t) => {
+let emitEventTap = (
+  ~topic: string,
+  ~service: string,
+  ~meta: ReventlessCore.Message.meta,
+  ~payload: JSON.t,
+) => {
   // Counted even when nothing is listening, so the sequence a reader that connects
   // later sees is the event's ordinal rather than the ordinal of its own arrival.
   eventTapSeq := eventTapSeq.contents + 1
+  // Taken whether or not anyone reads, so the note does not wait for a reader.
+  let stored = LocalEventLogRead.take(meta.msgId)
   let toStdout = LocalEventTap.stdoutEnabled()
 
   // The line is built only for somebody: serialising every event for no reader is
   // pure cost on the publish path.
   if toStdout || LocalEventTap.hasReaders() {
+    // Where the event is stored — its log and the log's own position — so a
+    // reader can join a live line to the read across every log by a key that
+    // survives a restart. Absent for an event published without a log.
+    let where = switch stored {
+    | Some((log, position)) => [
+        ("log", JSON.Encode.string(log)),
+        ("position", JSON.Encode.string(position->LocalEventLogRead.positionToString)),
+      ]
+    | None => []
+    }
     let line =
-      Dict.fromArray([
+      [
         ("event", JSON.Encode.string("domainEvent")),
         ("seq", JSON.Encode.int(eventTapSeq.contents)),
         ("topic", JSON.Encode.string(topic)),
         ("service", JSON.Encode.string(service)),
         ("payload", payload),
         ("ts", JSON.Encode.string(Date.make()->Date.toISOString)),
-      ])->JSON.Encode.object
+      ]
+      ->Array.concat(where)
+      ->Dict.fromArray
+      ->JSON.Encode.object
     let tapLine = "@@RVLESS_EVT@@ " ++ line->JSON.stringify
     if toStdout {
       Console.log(tapLine)
     }
-    LocalEventTap.broadcast(tapLine)
+    LocalEventTap.publish({
+      line: tapLine,
+      facets: {
+        plugin: ?(stored->Option.flatMap(((log, _)) => LocalEventLogRead.pluginOf(log))),
+        eventType: ReventlessCore.Message.eventNameOfEvent'Json(payload),
+        correlationId: meta.correlationId,
+      },
+    })
   }
 }
 
@@ -338,7 +365,7 @@ module Impl = (C: BusConfig): T => {
     if Reventless.Pii.needsPrepare([json]) {
       await Reventless.Pii.prepareOrThrow([json])
     }
-    emitEventTap(~topic=topicName, ~service, ~payload=json)
+    emitEventTap(~topic=topicName, ~service, ~meta, ~payload=json)
     switch eventHubs.contents->Dict.get(topicName) {
     | None => ()
     | Some(hub) =>