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

package/src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.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_Array from "@rescript/runtime/lib/es6/Stdlib_Array.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";
@@ -38,6 +39,30 @@ function matchesQuery(event, query) {
   }
 }
 
+function tagPostingKey(key, value) {
+  return key + "\x00" + value;
+}
+
+function intersectSorted(a, b) {
+  let out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    let av = a[i];
+    let bv = b[j];
+    if (av === bv) {
+      out.push(av);
+      i = i + 1 | 0;
+      j = j + 1 | 0;
+    } else if (av < bv) {
+      i = i + 1 | 0;
+    } else {
+      j = j + 1 | 0;
+    }
+  };
+  return out;
+}
+
 function makeStorage(_name, param, param$1, param$2) {
   let events = {
     contents: []
@@ -45,15 +70,71 @@ function makeStorage(_name, param, param$1, param$2) {
   let position = {
     contents: 0
   };
-  let read = async (query, after) => {
-    let filtered = events.contents.filter(event => {
-      let afterMatch = after !== undefined ? posToInt(event.position) > posToInt(after) : true;
+  let byTag = {};
+  let byType = {};
+  let pushInto = (dict, key, idx) => {
+    let list = dict[key];
+    if (list !== undefined) {
+      list.push(idx);
+    } else {
+      dict[key] = [idx];
+    }
+  };
+  let indexEvent = (idx, ev) => {
+    pushInto(byType, ev.eventType, idx);
+    ev.tags.forEach(t => pushInto(byTag, tagPostingKey(t.key, t.value), idx));
+  };
+  let candidateIndices = query => {
+    let acc = {};
+    let addAll = arr => {
+      arr.forEach(i => {
+        acc[i.toString()] = i;
+      });
+    };
+    query.forEach(clause => {
+      let tags = clause.tags;
+      if (tags !== undefined && tags.length !== 0) {
+        let lists = tags.map(t => Stdlib_Option.getOr(byTag[tagPostingKey(t.key, t.value)], []));
+        if (lists.some(l => l.length === 0)) {
+          return;
+        }
+        let sorted = lists.toSorted((a, b) => a.length - b.length | 0);
+        let acc0 = sorted[0];
+        return addAll(Stdlib_Array.reduce(sorted.slice(1, sorted.length), acc0, intersectSorted));
+      }
+      let types = clause.eventTypes;
+      if (types !== undefined) {
+        types.forEach(t => addAll(Stdlib_Option.getOr(byType[t], [])));
+      } else {
+        events.contents.forEach((param, i) => {
+          acc[i.toString()] = i;
+        });
+      }
+    });
+    return Object.values(acc).toSorted((a, b) => a - b | 0);
+  };
+  let matchingEvents = (query, after) => {
+    let pass = ev => {
+      let afterMatch = after !== undefined ? posToInt(ev.position) > posToInt(after) : true;
       if (afterMatch) {
-        return matchesQuery(event, query);
+        return matchesQuery(ev, query);
       } else {
         return false;
       }
-    });
+    };
+    if (query.length === 0) {
+      return events.contents.filter(pass);
+    } else {
+      return Stdlib_Array.filterMap(candidateIndices(query), i => {
+        let ev = events.contents[i];
+        if (pass(ev)) {
+          return ev;
+        }
+      });
+    }
+  };
+  let read = async (query, after) => {
+    let filtered = matchingEvents(query, after);
     let headPosition = Stdlib_Option.map(events.contents[events.contents.length - 1 | 0], e => e.position);
     return {
       events: filtered,
@@ -61,32 +142,32 @@ function makeStorage(_name, param, param$1, param$2) {
     };
   };
   let append = async (newEvents, condition) => {
-    let conflictDetected = condition !== undefined ? events.contents.some(event => {
-        let pos = condition.after;
-        let afterMatch = pos !== undefined ? posToInt(event.position) > posToInt(pos) : true;
-        if (afterMatch) {
-          return matchesQuery(event, condition.query);
-        } else {
-          return false;
-        }
-      }) : false;
+    let conflictDetected = condition !== undefined ? matchingEvents(condition.query, condition.after).length !== 0 : false;
     if (conflictDetected) {
       return {
         TAG: "Error",
         _0: "conflict: condition check failed"
       };
     }
-    let storedEvents = newEvents.map(event => {
+    let base = events.contents.length;
+    let storedEvents = newEvents.map((event, j) => {
       position.contents = position.contents + 1 | 0;
       let pos = position.contents.toString();
-      return {
+      let stored_eventType = event.eventType;
+      let stored_data = event.data;
+      let stored_tags = event.tags;
+      let stored_meta = event.meta;
+      let stored_recordedAt = Message$ReventlessCore.nowAsISOString();
+      let stored = {
         position: pos,
-        eventType: event.eventType,
-        data: event.data,
-        tags: event.tags,
-        meta: event.meta,
-        recordedAt: Message$ReventlessCore.nowAsISOString()
+        eventType: stored_eventType,
+        data: stored_data,
+        tags: stored_tags,
+        meta: stored_meta,
+        recordedAt: stored_recordedAt
       };
+      indexEvent(base + j | 0, stored);
+      return stored;
     });
     events.contents = events.contents.concat(storedEvents);
     return {
@@ -117,7 +198,7 @@ function Make(Bus) {
   let make = (name, indexes, partitionTag, param, opts) => {
     let db = BackendState$ReventlessLocal.getDb();
     if (db !== undefined) {
-      let match = DcbEventLogStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(db), (param, param$1) => {}, (param, param$1) => {}, name, indexes, partitionTag, opts);
+      let match = DcbEventLogStorage_Sqlite$ReventlessLocal.makeStorage(Primitive_option.valFromOption(db), name, indexes, partitionTag, opts);
       Bus.registerDcbEventLogRead(match[0], match[1]);
       return match[2];
     }
@@ -133,6 +214,8 @@ function Make(Bus) {
 export {
   posToInt,
   matchesQuery,
+  tagPostingKey,
+  intersectSorted,
   makeStorage,
   make,
   Make,

package/src/adapter/DcbEventLog/DcbEventLogStorage_Sqlite.res

@@ -34,6 +34,12 @@ let ensureSchema = (db: SqliteDriver.t) => {
   db->SqliteDriver.exec(
     "CREATE INDEX IF NOT EXISTS dcb_tag_by_kv ON dcb_tag(log_name, tag_key, tag_value, position)",
   )
+  // Serves the per-position tag hydration (the `WHERE log_name = ? AND position
+  // IN (...)` batch). The `_by_kv` index leads with tag_key/tag_value, so it
+  // cannot answer a position lookup — without this the batch scanned dcb_tag.
+  db->SqliteDriver.exec(
+    "CREATE INDEX IF NOT EXISTS dcb_tag_by_pos ON dcb_tag(log_name, position)",
+  )
 }
 
 let posToInt = (pos: string) => pos->Int.fromString->Option.getOr(0)
@@ -117,7 +123,10 @@ let buildClauseSql = (
   ("(" ++ parts.contents->Array.join(" AND ") ++ ")", params.contents)
 }
 
-let buildQuerySql = (
+// The WHERE expression (+ bound params) for a query — shared by the row-fetching
+// read path and the LIMIT-1 existence check the append-condition uses, so both
+// match the exact same rows.
+let buildQueryWhere = (
   ~logName: string,
   ~query: DcbTag.query,
   ~after: option<int>,
@@ -132,26 +141,29 @@ let buildQuerySql = (
     | None => [JSON.Encode.string(logName)]
     }
     let _ = sqlEscape
-    (
-      `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ${baseWhere} ORDER BY position ASC`,
-      baseParams,
-    )
+    (baseWhere, baseParams)
   } else {
     let clauses = query->Array.map(c => buildClauseSql(~logName, ~clause=c, ~after))
-    let combinedWhere =
-      clauses->Array.map(((sql, _)) => sql)->Array.join(" OR ")
+    let combinedWhere = clauses->Array.map(((sql, _)) => sql)->Array.join(" OR ")
     let combinedParams = clauses->Array.flatMap(((_, p)) => p)
-    (
-      `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ${combinedWhere} ORDER BY position ASC`,
-      combinedParams,
-    )
+    (combinedWhere, combinedParams)
   }
 }
 
+let buildQuerySql = (
+  ~logName: string,
+  ~query: DcbTag.query,
+  ~after: option<int>,
+): (string, array<JSON.t>) => {
+  let (where, params) = buildQueryWhere(~logName, ~query, ~after)
+  (
+    `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ${where} ORDER BY position ASC`,
+    params,
+  )
+}
+
 let makeStorage = (
   ~db: SqliteDriver.t,
-  ~bus: ('a, JSON.t) => unit,
-  ~publishToTopic: (~topicName: string, ~json: JSON.t) => unit,
   ~name: string,
   ~indexes as _,
   ~partitionTag as _,
@@ -162,6 +174,7 @@ let makeStorage = (
   let insertEventStmt = db->SqliteDriver.prepare(
     "INSERT INTO dcb_event(log_name, position, event_type, data, meta, recorded_at) VALUES(?,?,?,?,?,?)",
   )
+  let lastRowidStmt = db->SqliteDriver.prepare("SELECT last_insert_rowid() AS r")
   let insertTagStmt = db->SqliteDriver.prepare(
     "INSERT INTO dcb_tag(log_name, position, tag_key, tag_value) VALUES(?,?,?,?)",
   )
@@ -171,12 +184,21 @@ let makeStorage = (
   let headPositionStmt = db->SqliteDriver.prepare(
     "SELECT MAX(position) AS m FROM dcb_event WHERE log_name = ?",
   )
-  let tagsForPositionsStmt = db->SqliteDriver.prepare(
-    "SELECT position, tag_key, tag_value FROM dcb_tag WHERE log_name = ? AND position = ?",
-  )
 
-  let _ = bus
-  let _ = publishToTopic
+  // Prepared-statement cache keyed on SQL text. `runQuery`, the batched tag
+  // hydration, and the conflict check all build SQL whose shape varies with the
+  // clause/position count; preparing per call (the old `runQuery`) recompiled the
+  // same handful of shapes on every read. node:sqlite statements are re-runnable
+  // with fresh params, so one prepare per distinct shape suffices.
+  let stmtCache: Dict.t<SqliteDriver.statement> = Dict.make()
+  let preparedFor = (sql: string): SqliteDriver.statement =>
+    switch stmtCache->Dict.get(sql) {
+    | Some(s) => s
+    | None =>
+      let s = db->SqliteDriver.prepare(sql)
+      stmtCache->Dict.set(sql, s)
+      s
+    }
 
   let currentMaxPosition = (): int =>
     switch maxPositionStmt->SqliteDriver.get([JSON.Encode.string(name)]) {
@@ -188,27 +210,56 @@ let makeStorage = (
     | None => 0
     }
 
-  let tagsForPosition = (pos: int): array<DcbTag.tag> =>
-    tagsForPositionsStmt
-    ->SqliteDriver.all([JSON.Encode.string(name), JSON.Encode.int(pos)])
-    ->Array.map(row => {
-      let key = switch row->Dict.get("tag_key") {
-      | Some(JSON.String(s)) => s
-      | _ => ""
-      }
-      let value = switch row->Dict.get("tag_value") {
-      | Some(JSON.String(s)) => s
-      | _ => ""
-      }
-      ({key, value}: DcbTag.tag)
-    })
+  // Hydrate tags for a batch of positions in ONE query, grouped by position, in
+  // insertion order (`rowid`) within each position — the same order the old
+  // per-position query returned. Replaces the N+1 `tagsForPosition` per event.
+  let tagsForPositions = (positions: array<int>): Dict.t<array<DcbTag.tag>> => {
+    let byPos: Dict.t<array<DcbTag.tag>> = Dict.make()
+    if positions->Array.length > 0 {
+      let placeholders = positions->Array.map(_ => "?")->Array.join(",")
+      let sql = `SELECT position, tag_key, tag_value FROM dcb_tag WHERE log_name = ? AND position IN (${placeholders}) ORDER BY position ASC, rowid ASC`
+      let params =
+        [JSON.Encode.string(name)]->Array.concat(positions->Array.map(JSON.Encode.int))
+      preparedFor(sql)
+      ->SqliteDriver.all(params)
+      ->Array.forEach(row => {
+        let pos = switch row->Dict.get("position") {
+        | Some(v) => coercePosition(v)
+        | None => 0
+        }
+        let key = switch row->Dict.get("tag_key") {
+        | Some(JSON.String(s)) => s
+        | _ => ""
+        }
+        let value = switch row->Dict.get("tag_value") {
+        | Some(JSON.String(s)) => s
+        | _ => ""
+        }
+        let k = Int.toString(pos)
+        let arr = switch byPos->Dict.get(k) {
+        | Some(a) => a
+        | None =>
+          let a = []
+          byPos->Dict.set(k, a)
+          a
+        }
+        arr->Array.push(({key, value}: DcbTag.tag))
+      })
+    }
+    byPos
+  }
 
   let runQuery = (~query: DcbTag.query, ~after: option<int>): array<DcbEventLog_Adapter.rawSequencedEvent> => {
     let (sql, params) = buildQuerySql(~logName=name, ~query, ~after)
-    let stmt = db->SqliteDriver.prepare(sql)
-    stmt
-    ->SqliteDriver.all(params)
-    ->Array.map(row => {
+    let rows = preparedFor(sql)->SqliteDriver.all(params)
+    let positions = rows->Array.map(row =>
+      switch row->Dict.get("position") {
+      | Some(v) => coercePosition(v)
+      | None => 0
+      }
+    )
+    let tagsByPos = tagsForPositions(positions)
+    rows->Array.map(row => {
       let position = switch row->Dict.get("position") {
       | Some(v) => coercePosition(v)
       | None => 0
@@ -237,13 +288,23 @@ let makeStorage = (
         DcbEventLog_Adapter.position: Int.toString(position),
         eventType,
         data,
-        tags: tagsForPosition(position),
+        tags: tagsByPos->Dict.get(Int.toString(position))->Option.getOr([]),
         meta,
         recordedAt,
       }: DcbEventLog_Adapter.rawSequencedEvent)
     })
   }
 
+  // Does any event match the query? The append-condition only needs existence,
+  // so avoid materialising + tag-hydrating every conflicting row (the old
+  // `runQuery(...)->Array.length > 0`): a `SELECT 1 … LIMIT 1` short-circuits.
+  let anyMatch = (~query: DcbTag.query, ~after: option<int>): bool => {
+    let (where, params) = buildQueryWhere(~logName=name, ~query, ~after)
+    preparedFor(`SELECT 1 FROM dcb_event WHERE ${where} LIMIT 1`)
+    ->SqliteDriver.get(params)
+    ->Option.isSome
+  }
+
   let read = async (
     ~query: DcbTag.query,
     ~after=?,
@@ -263,13 +324,17 @@ let makeStorage = (
     ~condition=?,
   ): result<DcbTag.sequencePosition, string> => {
     let result = ref(Ok(""))
+    // (msgId, dcb_event rowid) per inserted event, for the projection
+    // checkpoint's DCB-axis pending set. The rowid is read immediately after
+    // each event insert — before the tag inserts move last_insert_rowid() to
+    // the dcb_tag table. Registered only after the transaction commits.
+    let appended: array<(string, int)> = []
     try {
       db->SqliteDriver.transaction(() => {
         switch condition {
         | Some(cond: DcbTag.appendCondition) =>
           let afterInt = cond.after->Option.map(posToInt)
-          let conflicting = runQuery(~query=cond.query, ~after=afterInt)
-          if conflicting->Array.length > 0 {
+          if anyMatch(~query=cond.query, ~after=afterInt) {
             throw(Failure("conflict: condition check failed"))
           }
         | None => ()
@@ -290,6 +355,14 @@ let makeStorage = (
             JSON.Encode.string(JSON.stringify(metaJson)),
             JSON.Encode.string(recordedAt),
           ])
+          switch lastRowidStmt->SqliteDriver.get([]) {
+          | Some(row) =>
+            switch row->Dict.get("r") {
+            | Some(JSON.Number(n)) => appended->Array.push((event.meta.msgId, Float.toInt(n)))
+            | _ => ()
+            }
+          | None => ()
+          }
           event.tags->Array.forEach(tag => {
             insertTagStmt->SqliteDriver.run([
               JSON.Encode.string(name),
@@ -303,6 +376,7 @@ let makeStorage = (
 
         result := Ok(Int.toString(lastPos.contents))
       })
+      ProjectionPending.trackAppended(~axis=ProjectionPending.Dcb, appended)
       result.contents
     } catch {
     | Failure(msg) => Error(msg)

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

@@ -8,15 +8,18 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 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 dcb_event (log_name TEXT NOT NULL, position INTEGER NOT NULL, event_type TEXT NOT NULL, data TEXT NOT NULL, meta TEXT NOT NULL, recorded_at TEXT NOT NULL, PRIMARY KEY (log_name, position))");
   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)");
 }
 
 function posToInt(pos) {
@@ -96,7 +99,7 @@ function buildClauseSql(logName, clause, after) {
   ];
 }
 
-function buildQuerySql(logName, query, after) {
+function buildQueryWhere(logName, query, after) {
   if (query.length === 0) {
     let baseWhere = after !== undefined ? "log_name = ? AND position > ?" : "log_name = ?";
     let baseParams = after !== undefined ? [
@@ -104,7 +107,7 @@ function buildQuerySql(logName, query, after) {
         after
       ] : [logName];
     return [
-      `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ` + baseWhere + ` ORDER BY position ASC`,
+      baseWhere,
       baseParams
     ];
   }
@@ -112,18 +115,36 @@ function buildQuerySql(logName, query, after) {
   let combinedWhere = clauses.map(param => param[0]).join(" OR ");
   let combinedParams = clauses.flatMap(param => param[1]);
   return [
-    `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ` + combinedWhere + ` ORDER BY position ASC`,
+    combinedWhere,
     combinedParams
   ];
 }
 
-function makeStorage(db, bus, publishToTopic, name, param, param$1, param$2) {
+function buildQuerySql(logName, query, after) {
+  let match = buildQueryWhere(logName, query, after);
+  return [
+    `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ` + match[0] + ` ORDER BY position ASC`,
+    match[1]
+  ];
+}
+
+function makeStorage(db, name, param, param$1, param$2) {
   ensureSchema(db);
   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(?,?,?,?)");
   let maxPositionStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT COALESCE(MAX(position), 0) AS m FROM dcb_event WHERE log_name = ?");
   SqliteDriver$ReventlessLocal.prepare(db, "SELECT MAX(position) AS m FROM dcb_event WHERE log_name = ?");
-  let tagsForPositionsStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT position, tag_key, tag_value FROM dcb_tag WHERE log_name = ? AND position = ?");
+  let stmtCache = {};
+  let preparedFor = sql => {
+    let s = stmtCache[sql];
+    if (s !== undefined) {
+      return Primitive_option.valFromOption(s);
+    }
+    let s$1 = SqliteDriver$ReventlessLocal.prepare(db, sql);
+    stmtCache[sql] = s$1;
+    return s$1;
+  };
   let currentMaxPosition = () => {
     let row = SqliteDriver$ReventlessLocal.get(maxPositionStmt, [name]);
     if (row === undefined) {
@@ -136,23 +157,50 @@ function makeStorage(db, bus, publishToTopic, name, param, param$1, param$2) {
       return 0;
     }
   };
-  let tagsForPosition = pos => SqliteDriver$ReventlessLocal.all(tagsForPositionsStmt, [
-    name,
-    pos
-  ]).map(row => {
-    let match = row["tag_key"];
-    let key = typeof match === "string" ? match : "";
-    let match$1 = row["tag_value"];
-    let value = typeof match$1 === "string" ? match$1 : "";
-    return {
-      key: key,
-      value: value
-    };
-  });
+  let tagsForPositions = positions => {
+    let byPos = {};
+    if (positions.length !== 0) {
+      let placeholders = positions.map(param => "?").join(",");
+      let sql = `SELECT position, tag_key, tag_value FROM dcb_tag WHERE log_name = ? AND position IN (` + placeholders + `) ORDER BY position ASC, rowid ASC`;
+      let params = [name].concat(positions.map(prim => prim));
+      SqliteDriver$ReventlessLocal.all(preparedFor(sql), params).forEach(row => {
+        let v = row["position"];
+        let pos = v !== undefined ? coercePosition(v) : 0;
+        let match = row["tag_key"];
+        let key = typeof match === "string" ? match : "";
+        let match$1 = row["tag_value"];
+        let value = typeof match$1 === "string" ? match$1 : "";
+        let k = pos.toString();
+        let a = byPos[k];
+        let arr;
+        if (a !== undefined) {
+          arr = a;
+        } else {
+          let a$1 = [];
+          byPos[k] = a$1;
+          arr = a$1;
+        }
+        arr.push({
+          key: key,
+          value: value
+        });
+      });
+    }
+    return byPos;
+  };
   let runQuery = (query, after) => {
     let match = buildQuerySql(name, query, after);
-    let stmt = SqliteDriver$ReventlessLocal.prepare(db, match[0]);
-    return SqliteDriver$ReventlessLocal.all(stmt, match[1]).map(row => {
+    let rows = SqliteDriver$ReventlessLocal.all(preparedFor(match[0]), match[1]);
+    let positions = rows.map(row => {
+      let v = row["position"];
+      if (v !== undefined) {
+        return coercePosition(v);
+      } else {
+        return 0;
+      }
+    });
+    let tagsByPos = tagsForPositions(positions);
+    return rows.map(row => {
       let v = row["position"];
       let position = v !== undefined ? coercePosition(v) : 0;
       let match = row["event_type"];
@@ -182,12 +230,16 @@ function makeStorage(db, bus, publishToTopic, name, param, param$1, param$2) {
         position: position.toString(),
         eventType: eventType,
         data: data,
-        tags: tagsForPosition(position),
+        tags: Stdlib_Option.getOr(tagsByPos[position.toString()], []),
         meta: meta,
         recordedAt: recordedAt
       };
     });
   };
+  let anyMatch = (query, after) => {
+    let match = buildQueryWhere(name, query, after);
+    return Stdlib_Option.isSome(SqliteDriver$ReventlessLocal.get(preparedFor(`SELECT 1 FROM dcb_event WHERE ` + match[0] + ` LIMIT 1`), match[1]));
+  };
   let read = async (query, after) => {
     let afterInt = Stdlib_Option.map(after, posToInt);
     let events = runQuery(query, afterInt);
@@ -210,12 +262,12 @@ function makeStorage(db, bus, publishToTopic, name, param, param$1, param$2) {
         _0: ""
       }
     };
+    let appended = [];
     try {
       SqliteDriver$ReventlessLocal.transaction(db, () => {
         if (condition !== undefined) {
           let afterInt = Stdlib_Option.map(condition.after, posToInt);
-          let conflicting = runQuery(condition.query, afterInt);
-          if (conflicting.length !== 0) {
+          if (anyMatch(condition.query, afterInt)) {
             throw {
               RE_EXN_ID: "Failure",
               _1: "conflict: condition check failed",
@@ -242,6 +294,16 @@ function makeStorage(db, bus, publishToTopic, name, param, param$1, param$2) {
             JSON.stringify(metaJson),
             recordedAt
           ]);
+          let row = SqliteDriver$ReventlessLocal.get(lastRowidStmt, []);
+          if (row !== undefined) {
+            let match = row["r"];
+            if (typeof match === "number") {
+              appended.push([
+                event.meta.msgId,
+                match | 0
+              ]);
+            }
+          }
           event.tags.forEach(tag => SqliteDriver$ReventlessLocal.run(insertTagStmt, [
             name,
             pos,
@@ -255,6 +317,7 @@ function makeStorage(db, bus, publishToTopic, name, param, param$1, param$2) {
           _0: lastPos.contents.toString()
         };
       });
+      ProjectionPending$ReventlessLocal.trackAppended("Dcb", appended);
       return result.contents;
     } catch (raw_msg) {
       let msg = Primitive_exceptions.internalToException(raw_msg);
@@ -301,6 +364,7 @@ export {
   coercePosition,
   sqlEscape,
   buildClauseSql,
+  buildQueryWhere,
   buildQuerySql,
   makeStorage,
 }

package/src/adapter/EventCollector/LocalEventCollectorChannel.res

@@ -85,3 +85,36 @@ module Make = (Bus: LocalBus.T) => {
     []
   }
 }
+
+// Projection-flavoured channel: identical wiring to `Make`, plus registers the
+// resolved handler in the Bus projection catch-up registry so the SQLite
+// backend's startup catch-up (ProjectionCheckpoint) can replay missed stored
+// events into it. Only projection collectors (the ReadModel builders) use this
+// — automation/translation collectors must never receive catch-up events (they
+// would re-run side effects and re-dispatch commands), so they stay on `Make`.
+module MakeProjection = (Bus: LocalBus.T) => {
+  module Base = Make(Bus)
+
+  type callbackEvent = Base.callbackEvent
+  type channelParts = Base.channelParts
+  type runtimeParts = Base.runtimeParts
+
+  let make = Base.make
+
+  let connect: ReventlessCore.EventCollector_Adapter.connect<
+    callbackEvent,
+    'context,
+    channelParts,
+    runtimeParts,
+  > = (~name, ~channelSpecs, ~runtime, ~opts) => {
+    let _reg =
+      runtime.parts.handlerDeferred
+      ->Deferred.await_
+      ->Effect.flatMap(handler =>
+        Effect.sync(() => Bus.registerProjectionCatchupHandler(name, handler))
+      )
+      ->Effect.runPromise
+      ->ignore
+    Base.connect(~name, ~channelSpecs, ~runtime, ~opts)
+  }
+}