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

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res

@@ -69,6 +69,8 @@ module Make = (Bus: LocalBus.T) => {
     registerQueryDb: Bus.registerQueryDb,
     registerQueryDbScan: Bus.registerQueryDbScan,
     registerQueryDbStream: Bus.registerQueryDbStream,
+    registerQueryDbIndexLookup: Bus.registerQueryDbIndexLookup,
+    registerQueryDbListPage: Bus.registerQueryDbListPage,
   }
 
   let makeMemory: QueryDb_Adapter.storageMaker<unit, unit> = (
@@ -81,10 +83,20 @@ module Make = (Bus: LocalBus.T) => {
     ~opts as _,
   ) => {
     let store: ref<dict<dict<JSON.t>>> = ref(Dict.make())
-    let allItems: ref<array<JSON.t>> = ref([])
-
-    let syncAll = () => {
-      allItems.contents = flattenStore(store.contents)
+    // Lazy flattened snapshot for the registered scan/stream closures. The old
+    // shape reflattened+resorted the *entire* store on every single-row write
+    // (`syncAll`), so a projection replaying N events was O(n²). Instead each
+    // mutation just marks the snapshot dirty; the scan closure reflattens once,
+    // on demand, and only when something changed since the last read.
+    let snapshot: ref<array<JSON.t>> = ref([])
+    let dirty = ref(false)
+    let syncAll = () => dirty := true
+    let currentItems = () => {
+      if dirty.contents {
+        snapshot.contents = flattenStore(store.contents)
+        dirty := false
+      }
+      snapshot.contents
     }
 
     // TTL parity with the SQLite backend (which filters on `expires_at`). We
@@ -303,11 +315,25 @@ module Make = (Bus: LocalBus.T) => {
     Bus.registerQueryDb(name, ops)
     Bus.registerQueryDbScan(name, () => {
       purgeExpired()
-      allItems.contents
+      currentItems()
     })
     Bus.registerQueryDbStream(name, () => {
       purgeExpired()
-      allItems.contents->Stream.fromIterable
+      currentItems()->Stream.fromIterable
+    })
+    // Equality lookup on an indexed field. No real in-memory index (dev scale),
+    // but reusing the lazy snapshot avoids reflattening per call and keeps result
+    // parity with the SQLite `json_extract` push-down (both match string fields).
+    Bus.registerQueryDbIndexLookup(name, (field, value) => {
+      purgeExpired()
+      currentItems()->Array.filter(item =>
+        item
+        ->JSON.Decode.object
+        ->Option.flatMap(d => d->Dict.get(field))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.map(v => v == value)
+        ->Option.getOr(false)
+      )
     })
 
     {

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

@@ -60,21 +60,32 @@ function Make(Bus) {
   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
+    registerQueryDbStream: sqliteBusCallbacks_registerQueryDbStream,
+    registerQueryDbIndexLookup: sqliteBusCallbacks_registerQueryDbIndexLookup,
+    registerQueryDbListPage: sqliteBusCallbacks_registerQueryDbListPage
   };
   let makeMemory = (name, param, subIdField, param$1, param$2, param$3, param$4) => {
     let store = {
       contents: {}
     };
-    let allItems = {
+    let snapshot = {
       contents: []
     };
-    let syncAll = () => {
-      allItems.contents = flattenStore(store.contents);
+    let dirty = {
+      contents: false
+    };
+    let currentItems = () => {
+      if (dirty.contents) {
+        snapshot.contents = flattenStore(store.contents);
+        dirty.contents = false;
+      }
+      return snapshot.contents;
     };
     let expiries = {
       contents: {}
@@ -125,7 +136,8 @@ function Make(Bus) {
         });
       });
       if (removedAny.contents) {
-        return syncAll();
+        dirty.contents = true;
+        return;
       }
     };
     let getOrCreateSubMap = partitionKey => {
@@ -169,7 +181,7 @@ function Make(Bus) {
       let subMap = getOrCreateSubMap(id);
       subMap[subKey] = state;
       recordExpiry(id, subKey, ttl);
-      syncAll();
+      dirty.contents = true;
       publishUpdated(id, state);
       return {
         TAG: "Ok",
@@ -185,7 +197,7 @@ function Make(Bus) {
         subMap[subKey] = state;
         recordExpiry(id, subKey, param[2]);
       });
-      syncAll();
+      dirty.contents = true;
       batch.forEach(param => publishUpdated(param[0], param[1]));
       return {
         TAG: "Ok",
@@ -206,7 +218,7 @@ function Make(Bus) {
       obj["id"] = id;
       obj[fieldName] = next;
       subMap[""] = obj;
-      syncAll();
+      dirty.contents = true;
       publishUpdated(id, obj);
       return {
         TAG: "Ok",
@@ -220,18 +232,18 @@ function Make(Bus) {
         if (subMap !== undefined) {
           let hadIt = Stdlib_Option.isSome(subMap[subValue]);
           Stdlib_Dict.$$delete(subMap, subValue);
-          syncAll();
+          dirty.contents = true;
           if (hadIt) {
             publishRemoved(id, subValue);
           }
         } else {
-          syncAll();
+          dirty.contents = true;
         }
       } else {
         let subMap$1 = store.contents[id];
         let subKeys = subMap$1 !== undefined ? Object.keys(subMap$1) : [];
         Stdlib_Dict.$$delete(store.contents, id);
-        syncAll();
+        dirty.contents = true;
         subKeys.forEach(subKey => publishRemoved(id, subKey));
       }
       return {
@@ -270,7 +282,7 @@ function Make(Bus) {
         }
         Stdlib_Dict.$$delete(store.contents, id);
       });
-      syncAll();
+      dirty.contents = true;
       removed.forEach(param => publishRemoved(param[0], param[1]));
       return {
         TAG: "Ok",
@@ -289,11 +301,15 @@ function Make(Bus) {
     Bus.registerQueryDb(name, ops);
     Bus.registerQueryDbScan(name, () => {
       purgeExpired();
-      return allItems.contents;
+      return currentItems();
     });
     Bus.registerQueryDbStream(name, () => {
       purgeExpired();
-      return Stream.fromIterable(allItems.contents);
+      return Stream.fromIterable(currentItems());
+    });
+    Bus.registerQueryDbIndexLookup(name, (field, value) => {
+      purgeExpired();
+      return currentItems().filter(item => Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[field]), Stdlib_JSON.Decode.string), v => v === value), false));
     });
     return {
       resources: [],

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res

@@ -139,6 +139,15 @@ type busCallbacks = {
   registerQueryDb: (string, QueryDb_Adapter.operations) => unit,
   registerQueryDbScan: (string, unit => array<JSON.t>) => unit,
   registerQueryDbStream: (string, unit => Stream.t<JSON.t, string, unit>) => unit,
+  registerQueryDbIndexLookup: (string, (string, string) => array<JSON.t>) => unit,
+  registerQueryDbListPage: (
+    string,
+    (
+      ~argsDict: dict<JSON.t>,
+      ~capability: GraphQL_FragmentGenerator.serverCapability,
+      ~labelField: string,
+    ) => option<JSON.t>,
+  ) => unit,
 }
 
 // SQL fragment that excludes expired rows. Uses unix-epoch seconds via
@@ -178,17 +187,38 @@ let makeStorage = (
     ->SqliteDriver.all([JSON.Encode.string(id)])
     ->Array.map(decodeItem)
 
-  let allRows = (): array<JSON.t> =>
-    scanAllStmt
-    ->SqliteDriver.all([])
-    ->Array.map(row => {
-      let item = decodeItem(row)
-      let partition = switch row->Dict.get("partition_key") {
-      | Some(JSON.String(s)) => s
-      | _ => ""
-      }
-      withId(item, partition)
-    })
+  let rowToItem = (row: dict<JSON.t>): JSON.t => {
+    let item = decodeItem(row)
+    let partition = switch row->Dict.get("partition_key") {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+    withId(item, partition)
+  }
+
+  let allRows = (): array<JSON.t> => scanAllStmt->SqliteDriver.all([])->Array.map(rowToItem)
+
+  // Equality lookup on an indexed JSON field, pushed down to SQLite so the query
+  // rides the `json_extract` GSI index (`ensureIndexes`) instead of scanning +
+  // parsing every row in the resolver. Statements are prepared once per field and
+  // cached. String comparison mirrors the resolver's JS path (which only matched
+  // string-typed fields), so results are identical.
+  let indexLookupStmts: Dict.t<SqliteDriver.statement> = Dict.make()
+  let lookupByField = (field: string, value: string): array<JSON.t> => {
+    let stmt = switch indexLookupStmts->Dict.get(field) {
+    | Some(s) => s
+    | None =>
+      // Escape single quotes in the JSON path literal so an odd field name can't
+      // break out of the string (bound `?` already covers the value).
+      let escapedField = field->String.replaceAll("'", "''")
+      let s = db->SqliteDriver.prepare(
+        `SELECT partition_key, sub_key, item FROM ${table} WHERE json_extract(item, '$.${escapedField}') = ? AND ${notExpiredClause}`,
+      )
+      indexLookupStmts->Dict.set(field, s)
+      s
+    }
+    stmt->SqliteDriver.all([JSON.Encode.string(value)])->Array.map(rowToItem)
+  }
 
   let saveOne = (id: string, state: JSON.t, ttl: option<int>) => {
     let subKey = computeSubKey(state, subIdField)
@@ -331,6 +361,126 @@ let makeStorage = (
   bus.registerQueryDb(name, ops)
   bus.registerQueryDbScan(name, () => allRows())
   bus.registerQueryDbStream(name, () => allRows()->Stream.fromIterable)
+  bus.registerQueryDbIndexLookup(name, lookupByField)
+
+  // Connection-list push-down. Builds `json_extract` predicates + `ORDER BY …
+  // LIMIT pageSize+1` so a page fetch reads only what it returns rather than the
+  // whole read model. Reproduces `QueryDbListQuery` semantics exactly for the
+  // shapes it handles; returns None (→ the resolver falls back to that shared
+  // spec over a full scan) for shapes not bit-exact in SQL: case-insensitive
+  // search/searchPrefix, Relay-global-id `ids`, and backward pagination
+  // (last/before). Cursor values, edges, and pageInfo are built by the SAME
+  // `QueryDbListQuery` helpers the fallback uses, so only the WHERE/ORDER/LIMIT
+  // needs to match — which the parity harness asserts across a data + args
+  // matrix. Comparisons use TEXT (CAST) to mirror the JS string-comparison
+  // semantics; BINARY collation agrees with JS `<` for the ASCII id/status/name
+  // fields used as sort/filter keys.
+  let listStmtCache: Dict.t<SqliteDriver.statement> = Dict.make()
+  let preparedList = (sql: string): SqliteDriver.statement =>
+    switch listStmtCache->Dict.get(sql) {
+    | Some(s) => s
+    | None =>
+      let s = db->SqliteDriver.prepare(sql)
+      listStmtCache->Dict.set(sql, s)
+      s
+    }
+  let jsonText = (field: string): string =>
+    `CAST(json_extract(item, '$.${field->String.replaceAll("'", "''")}') AS TEXT)`
+  let idExpr = "COALESCE(json_extract(item, '$.id'), partition_key)"
+  let listPage = (
+    ~argsDict: dict<JSON.t>,
+    ~capability: GraphQL_FragmentGenerator.serverCapability,
+    ~labelField as _,
+  ): option<JSON.t> => {
+    let filterDict =
+      argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+    let strNonEmpty = k =>
+      filterDict->Dict.get(k)->Option.flatMap(JSON.Decode.string)->Option.mapOr(false, s => s->String.length > 0)
+    let hasIds =
+      filterDict->Dict.get("ids")->Option.flatMap(JSON.Decode.array)->Option.mapOr(false, a => a->Array.length > 0)
+    let last = argsDict->Dict.get("last")->Option.flatMap(JSON.Decode.float)
+    let before = argsDict->Dict.get("before")->Option.flatMap(JSON.Decode.string)
+    if strNonEmpty("search") || strNonEmpty("searchPrefix") || hasIds || last->Option.isSome || before->Option.isSome {
+      None
+    } else {
+      let whereParts = [notExpiredClause]
+      let params = []
+      let valString = v =>
+        switch v->JSON.Decode.string {
+        | Some(s) => Some(s)
+        | None => v->JSON.Decode.float->Option.map(f => Float.toString(f))
+        }
+      capability.filterFields->Array.forEach(f => {
+        switch filterDict->Dict.get(f.name ++ "Eq") {
+        | Some(v) when v != JSON.Encode.null =>
+          whereParts->Array.push(`${jsonText(f.name)} = ?`)
+          params->Array.push(JSON.Encode.string(valString(v)->Option.getOr("")))
+        | _ => ()
+        }
+        if f.range {
+          switch filterDict->Dict.get(f.name ++ "From") {
+          | Some(v) when v != JSON.Encode.null =>
+            whereParts->Array.push(`${jsonText(f.name)} >= ?`)
+            params->Array.push(JSON.Encode.string(valString(v)->Option.getOr("")))
+          | _ => ()
+          }
+          switch filterDict->Dict.get(f.name ++ "To") {
+          | Some(v) when v != JSON.Encode.null =>
+            whereParts->Array.push(`${jsonText(f.name)} <= ?`)
+            params->Array.push(JSON.Encode.string(valString(v)->Option.getOr("")))
+          | _ => ()
+          }
+        }
+      })
+      let orderByDict = argsDict->Dict.get("orderBy")->Option.flatMap(JSON.Decode.object)
+      let orderByField =
+        orderByDict->Option.flatMap(ob => ob->Dict.get("field"))->Option.flatMap(JSON.Decode.string)
+      let isDesc =
+        orderByDict
+        ->Option.flatMap(ob => ob->Dict.get("direction"))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.getOr("ASC") == "DESC"
+      let cursorExpr = switch orderByField {
+      | Some(f) => jsonText(f)
+      | None => idExpr
+      }
+      switch argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string) {
+      | Some(c) =>
+        whereParts->Array.push(`${cursorExpr} ${isDesc ? "<" : ">"} ?`)
+        params->Array.push(JSON.Encode.string(QueryDbListQuery.decodeCursor(c)))
+      | None => ()
+      }
+      let orderClause = switch orderByField {
+      | Some(f) => `${jsonText(f)} ${isDesc ? "DESC" : "ASC"}, ${idExpr} ASC`
+      | None => `${idExpr} ASC`
+      }
+      let pageSize =
+        argsDict
+        ->Dict.get("first")
+        ->Option.flatMap(JSON.Decode.float)
+        ->Option.map(Float.toInt)
+        ->Option.getOr(QueryDbListQuery.defaultListPageSize)
+      let sql = `SELECT partition_key, item FROM ${table} WHERE ${whereParts->Array.join(" AND ")} ORDER BY ${orderClause} LIMIT ?`
+      let rows =
+        preparedList(sql)
+        ->SqliteDriver.all(params->Array.concat([JSON.Encode.int(pageSize + 1)]))
+        ->Array.map(rowToItem)
+      let hasMore = rows->Array.length > pageSize
+      let pageItems = rows->Array.slice(~start=0, ~end=pageSize)
+      let cursorField = orderByField->Option.getOr("id")
+      let cursorValueOf = item =>
+        QueryDbListQuery.getFieldString(item, cursorField)->Option.getOr(QueryDbListQuery.getId(item))
+      Some(
+        QueryDbListQuery.buildConnection(
+          ~pageItems,
+          ~hasNextPage=hasMore,
+          ~hasPreviousPage=false,
+          ~cursorValueOf,
+        ),
+      )
+    }
+  }
+  bus.registerQueryDbListPage(name, listPage)
 
   {
     resources: [],
@@ -348,6 +498,8 @@ module Make = (Bus: LocalBus.T, DbProvider: {let db: SqliteDriver.t}) => {
     registerQueryDb: Bus.registerQueryDb,
     registerQueryDbScan: Bus.registerQueryDbScan,
     registerQueryDbStream: Bus.registerQueryDbStream,
+    registerQueryDbIndexLookup: Bus.registerQueryDbIndexLookup,
+    registerQueryDbListPage: Bus.registerQueryDbListPage,
   }
 
   let make: QueryDb_Adapter.storageMaker<unit, unit> = (

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

@@ -4,8 +4,10 @@ import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stream from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as LocalBus$ReventlessLocal from "../LocalBus.res.mjs";
 import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+import * as QueryDbListQuery$ReventlessLocal from "./QueryDbListQuery.res.mjs";
 
 function tableName(name) {
   return "qdb_" + name.replaceAll("-", "_");
@@ -146,12 +148,27 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   let deleteBySubKeyStmt = SqliteDriver$ReventlessLocal.prepare(db, `DELETE FROM ` + table + ` WHERE partition_key = ? AND sub_key = ?`);
   let scanAllStmt = SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE ` + notExpiredClause + ` ORDER BY partition_key, sub_key`);
   let rowsFor = id => SqliteDriver$ReventlessLocal.all(selectByPartitionStmt, [id]).map(decodeItem);
-  let allRows = () => SqliteDriver$ReventlessLocal.all(scanAllStmt, []).map(row => {
+  let rowToItem = row => {
     let item = decodeItem(row);
     let match = row["partition_key"];
     let partition = typeof match === "string" ? match : "";
     return withId(item, partition);
-  });
+  };
+  let allRows = () => SqliteDriver$ReventlessLocal.all(scanAllStmt, []).map(rowToItem);
+  let indexLookupStmts = {};
+  let lookupByField = (field, value) => {
+    let s = indexLookupStmts[field];
+    let stmt;
+    if (s !== undefined) {
+      stmt = Primitive_option.valFromOption(s);
+    } else {
+      let escapedField = field.replaceAll("'", "''");
+      let s$1 = SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE json_extract(item, '$.` + escapedField + `') = ? AND ` + notExpiredClause);
+      indexLookupStmts[field] = s$1;
+      stmt = s$1;
+    }
+    return SqliteDriver$ReventlessLocal.all(stmt, [value]).map(rowToItem);
+  };
   let saveOne = (id, state, ttl) => {
     let subKey = computeSubKey(state, subIdField);
     let expiresAt = ttl !== undefined ? ttl : null;
@@ -287,6 +304,83 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   bus.registerQueryDb(name, ops);
   bus.registerQueryDbScan(name, () => allRows());
   bus.registerQueryDbStream(name, () => Stream.fromIterable(allRows()));
+  bus.registerQueryDbIndexLookup(name, lookupByField);
+  let listStmtCache = {};
+  let preparedList = sql => {
+    let s = listStmtCache[sql];
+    if (s !== undefined) {
+      return Primitive_option.valFromOption(s);
+    }
+    let s$1 = SqliteDriver$ReventlessLocal.prepare(db, sql);
+    listStmtCache[sql] = s$1;
+    return s$1;
+  };
+  let jsonText = field => `CAST(json_extract(item, '$.` + field.replaceAll("'", "''") + `') AS TEXT)`;
+  let idExpr = "COALESCE(json_extract(item, '$.id'), partition_key)";
+  let listPage = (argsDict, capability, param) => {
+    let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
+    let strNonEmpty = k => Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict[k], Stdlib_JSON.Decode.string), false, s => s.length > 0);
+    let hasIds = Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict["ids"], Stdlib_JSON.Decode.array), false, a => a.length !== 0);
+    let last = Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float);
+    let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+    if (strNonEmpty("search") || strNonEmpty("searchPrefix") || hasIds || Stdlib_Option.isSome(last) || Stdlib_Option.isSome(before)) {
+      return;
+    }
+    let whereParts = [notExpiredClause];
+    let params = [];
+    let valString = v => {
+      let s = Stdlib_JSON.Decode.string(v);
+      if (s !== undefined) {
+        return s;
+      } else {
+        return Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString());
+      }
+    };
+    capability.filterFields.forEach(f => {
+      let v = filterDict[f.name + "Eq"];
+      if (v !== undefined && v !== null) {
+        whereParts.push(jsonText(f.name) + ` = ?`);
+        params.push(Stdlib_Option.getOr(valString(v), ""));
+      }
+      if (!f.range) {
+        return;
+      }
+      let v$1 = filterDict[f.name + "From"];
+      if (v$1 !== undefined && v$1 !== null) {
+        whereParts.push(jsonText(f.name) + ` >= ?`);
+        params.push(Stdlib_Option.getOr(valString(v$1), ""));
+      }
+      let v$2 = filterDict[f.name + "To"];
+      if (v$2 !== undefined && v$2 !== null) {
+        whereParts.push(jsonText(f.name) + ` <= ?`);
+        params.push(Stdlib_Option.getOr(valString(v$2), ""));
+        return;
+      }
+    });
+    let orderByDict = Stdlib_Option.flatMap(argsDict["orderBy"], Stdlib_JSON.Decode.object);
+    let orderByField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["field"]), Stdlib_JSON.Decode.string);
+    let isDesc = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["direction"]), Stdlib_JSON.Decode.string), "ASC") === "DESC";
+    let cursorExpr = orderByField !== undefined ? jsonText(orderByField) : idExpr;
+    let c = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+    if (c !== undefined) {
+      whereParts.push(cursorExpr + ` ` + (
+        isDesc ? "<" : ">"
+      ) + ` ?`);
+      params.push(QueryDbListQuery$ReventlessLocal.decodeCursor(c));
+    }
+    let orderClause = orderByField !== undefined ? jsonText(orderByField) + ` ` + (
+        isDesc ? "DESC" : "ASC"
+      ) + `, ` + idExpr + ` ASC` : idExpr + ` ASC`;
+    let pageSize = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0), QueryDbListQuery$ReventlessLocal.defaultListPageSize);
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + whereParts.join(" AND ") + ` ORDER BY ` + orderClause + ` LIMIT ?`;
+    let rows = SqliteDriver$ReventlessLocal.all(preparedList(sql), params.concat([pageSize + 1 | 0])).map(rowToItem);
+    let hasMore = rows.length > pageSize;
+    let pageItems = rows.slice(0, pageSize);
+    let cursorField = Stdlib_Option.getOr(orderByField, "id");
+    let cursorValueOf = item => Stdlib_Option.getOr(QueryDbListQuery$ReventlessLocal.getFieldString(item, cursorField), QueryDbListQuery$ReventlessLocal.getId(item));
+    return QueryDbListQuery$ReventlessLocal.buildConnection(pageItems, hasMore, false, cursorValueOf);
+  };
+  bus.registerQueryDbListPage(name, listPage);
   return {
     resources: [],
     dataSourceName: Pulumi.output(""),
@@ -300,11 +394,15 @@ function Make(Bus) {
     let busCallbacks_registerQueryDb = Bus.registerQueryDb;
     let busCallbacks_registerQueryDbScan = Bus.registerQueryDbScan;
     let busCallbacks_registerQueryDbStream = Bus.registerQueryDbStream;
+    let busCallbacks_registerQueryDbIndexLookup = Bus.registerQueryDbIndexLookup;
+    let busCallbacks_registerQueryDbListPage = Bus.registerQueryDbListPage;
     let busCallbacks = {
       publishStateChange: busCallbacks_publishStateChange,
       registerQueryDb: busCallbacks_registerQueryDb,
       registerQueryDbScan: busCallbacks_registerQueryDbScan,
-      registerQueryDbStream: busCallbacks_registerQueryDbStream
+      registerQueryDbStream: busCallbacks_registerQueryDbStream,
+      registerQueryDbIndexLookup: busCallbacks_registerQueryDbIndexLookup,
+      registerQueryDbListPage: busCallbacks_registerQueryDbListPage
     };
     let make = (name, indexes, subIdField, param, param$1, param$2, param$3) => makeStorage(DbProvider.db, busCallbacks, name, indexes, subIdField);
     return {

package/src/adapter/SqliteDriver.res

@@ -27,7 +27,17 @@ let openDb = (~path) => {
   if path !== ":memory:" {
     mkdirSync(dirname(path), {recursive: true})
   }
-  openDatabaseSync(path)
+  let db = openDatabaseSync(path)
+  // Connection pragmas. WAL lets readers proceed concurrently with a writer and
+  // batches fsyncs into the write-ahead log (a no-op for `:memory:`, which stays
+  // on its MEMORY journal); `synchronous=NORMAL` is the safe WAL companion —
+  // durable across app crashes, only a power-loss window remains — and cuts the
+  // per-commit fsync cost that dominated replay-heavy dev sessions;
+  // `busy_timeout` makes a momentarily-locked db wait rather than throw SQLITE_BUSY.
+  _exec(db, "PRAGMA journal_mode=WAL")
+  _exec(db, "PRAGMA synchronous=NORMAL")
+  _exec(db, "PRAGMA busy_timeout=5000")
+  db
 }
 let close = db => _close(db)
 let exec = (db, sql) => _exec(db, sql)

package/src/adapter/SqliteDriver.res.mjs

@@ -19,7 +19,11 @@ function openDb(path) {
       recursive: true
     });
   }
-  return new Nodesqlite.DatabaseSync(path);
+  let db = new Nodesqlite.DatabaseSync(path);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA synchronous=NORMAL");
+  db.exec("PRAGMA busy_timeout=5000");
+  return db;
 }
 
 function close(db) {

package/src/components/ReadModel_Builder.res

@@ -2,7 +2,9 @@
 
 module Make = (Bus: LocalBus.T) => {
   module RuntimeEnvironment = LocalRuntimeEnvironment
-  module EventCollectorChannel = LocalEventCollectorChannel.Make(Bus)
+  // MakeProjection (not Make): also registers the resolved handler for the
+  // SQLite backend's startup projection catch-up (ProjectionCheckpoint).
+  module EventCollectorChannel = LocalEventCollectorChannel.MakeProjection(Bus)
   module EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder.Make(
     Bus,
     EventCollectorChannel,

package/src/components/ReadModel_Builder.res.mjs

@@ -9,8 +9,11 @@ import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCol
 import * as LocalEventCollectorRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs";
 
 function Make(Bus) {
-  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
-  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)(EventCollectorChannel);
+  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.MakeProjection(Bus);
+  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  });
   let QueryDbStorage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
   let QueryDbResolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
   let Make$1 = Spec => (Mappings => ReadModel_Builder$ReventlessCore.Make(Spec)(Mappings)({
@@ -23,7 +26,10 @@ function Make(Bus) {
     make: QueryDbStorage.make
   })({
     make: QueryDbResolvers.make
-  })(EventCollectorChannel)(EventCollectorRuntimeBuilder));
+  })({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  })(EventCollectorRuntimeBuilder));
   let NoResolvers = QueryDb_Adapter$ReventlessCore.NoResolvers({
     make: QueryDbStorage.make
   });
@@ -35,7 +41,10 @@ function Make(Bus) {
     asEffectHandler: prim => prim
   })({
     make: QueryDbStorage.make
-  })(NoResolvers)(EventCollectorChannel)(EventCollectorRuntimeBuilder));
+  })(NoResolvers)({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  })(EventCollectorRuntimeBuilder));
   return {
     RuntimeEnvironment: undefined,
     EventCollectorChannel: EventCollectorChannel,

package/src/components/StateViewSlice_Builder.res

@@ -3,7 +3,10 @@
 
 module Make = (Bus: LocalBus.T) => {
   module RuntimeEnvironment = LocalRuntimeEnvironment
-  module EventCollectorChannel = LocalEventCollectorChannel.Make(Bus)
+  // MakeProjection (not Make): also registers the resolved handler for the
+  // SQLite backend's startup projection catch-up (ProjectionCheckpoint) —
+  // StateViewSlices are pure projections fed by DCB events.
+  module EventCollectorChannel = LocalEventCollectorChannel.MakeProjection(Bus)
   module EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder.Make(
     Bus,
     EventCollectorChannel,

package/src/components/StateViewSlice_Builder.res.mjs

@@ -9,8 +9,11 @@ import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCol
 import * as LocalEventCollectorRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs";
 
 function Make(Bus) {
-  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
-  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)(EventCollectorChannel);
+  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.MakeProjection(Bus);
+  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  });
   let QueryDbStorage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
   let QueryDbResolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
   let api = () => {};
@@ -29,7 +32,10 @@ function Make(Bus) {
     make: QueryDbStorage.make
   })({
     make: QueryDbResolvers.make
-  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api);
+  })({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  })(EventCollectorRuntimeBuilder)(Api);
   let Make$1 = Spec => (Projection => {
     let Inner = CoreMaker.Make(Spec)(Projection);
     return {