@reventlessdev/reventless-local 3.0.0-alpha.114 → 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,74 @@ module Make = (Bus: LocalBus.T) => {
     ~opts as _,
   ) => {
     let store: ref<dict<dict<JSON.t>>> = ref(Dict.make())
-    let allItems: ref<array<JSON.t>> = ref([])
+    // 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
+    }
 
-    let syncAll = () => {
-      allItems.contents = flattenStore(store.contents)
+    // TTL parity with the SQLite backend (which filters on `expires_at`). We
+    // record an absolute expiry (epoch seconds, the same value SQLite stores) per
+    // (partition, sub-key) and drop expired entries lazily on read — a session
+    // without reads never spends cycles expiring, matching SQLite's read-time
+    // `notExpiredClause`. Previously `~ttl` was ignored entirely in memory.
+    let expiries: ref<dict<dict<float>>> = ref(Dict.make())
+    let nowSecs = () => Date.now() /. 1000.0
+    let recordExpiry = (id: string, subKey: string, ttl: option<int>) =>
+      switch ttl {
+      | Some(t) =>
+        let subExp = switch expiries.contents->Dict.get(id) {
+        | Some(m) => m
+        | None =>
+          let m = Dict.make()
+          expiries.contents->Dict.set(id, m)
+          m
+        }
+        subExp->Dict.set(subKey, Int.toFloat(t))
+      | None =>
+        switch expiries.contents->Dict.get(id) {
+        | Some(m) => m->Dict.delete(subKey)
+        | None => ()
+        }
+      }
+    let purgeExpired = () => {
+      let now = nowSecs()
+      let removedAny = ref(false)
+      expiries.contents
+      ->Dict.toArray
+      ->Array.forEach(((id, subExp)) =>
+        subExp
+        ->Dict.toArray
+        ->Array.forEach(((subKey, exp)) =>
+          if exp <= now {
+            switch store.contents->Dict.get(id) {
+            | Some(sm) =>
+              if sm->Dict.get(subKey)->Option.isSome {
+                sm->Dict.delete(subKey)
+                removedAny := true
+              }
+              if sm->Dict.keysToArray->Array.length == 0 {
+                store.contents->Dict.delete(id)
+              }
+            | None => ()
+            }
+            subExp->Dict.delete(subKey)
+          }
+        )
+      )
+      if removedAny.contents {
+        syncAll()
+      }
     }
 
     let getOrCreateSubMap = (partitionKey: string): dict<JSON.t> =>
@@ -96,11 +162,15 @@ module Make = (Bus: LocalBus.T) => {
         m
       }
 
-    let load: QueryDb.load<string, JSON.t> = async id =>
+    let load: QueryDb.load<string, JSON.t> = async id => {
+      purgeExpired()
       Ok(sortedItems(store.contents, id))
+    }
 
-    let loadStream: QueryDb.loadStream<string, JSON.t> = id =>
+    let loadStream: QueryDb.loadStream<string, JSON.t> = id => {
+      purgeExpired()
       sortedItems(store.contents, id)->Stream.fromIterable
+    }
 
     // Entity key matches the AWS StateTopic Lambda output (Phase 1):
     // single-key tables → partition value; composite tables → `pk-sk`.
@@ -129,20 +199,22 @@ module Make = (Bus: LocalBus.T) => {
       Bus.publishStateChange(~name, ~descriptor)
     }
 
-    let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, _ttl) => {
+    let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, ttl) => {
       let subKey = getSubKey(state, subIdField)
       let subMap = getOrCreateSubMap(id)
       subMap->Dict.set(subKey, state)
+      recordExpiry(id, subKey, ttl)
       syncAll()
       publishUpdated(id, state)
       Ok()
     }
 
     let saveBatch: QueryDb.saveBatch<string, JSON.t> = async batch => {
-      batch->Array.forEach(((id, state, _ttl)) => {
+      batch->Array.forEach(((id, state, ttl)) => {
         let subKey = getSubKey(state, subIdField)
         let subMap = getOrCreateSubMap(id)
         subMap->Dict.set(subKey, state)
+        recordExpiry(id, subKey, ttl)
       })
       syncAll()
       // Notify subscribers for each saved item
@@ -150,7 +222,33 @@ module Make = (Bus: LocalBus.T) => {
       Ok()
     }
 
-    let count: QueryDb.count<string> = async (_id, _fieldName, inc) => Ok(inc)
+    // Atomic-ish counter, mirroring DynamoDB's `ADD #fieldName :inc` on key {id}:
+    // read the field on the partition-key item (counters are single-state, so the
+    // implicit sub-key ""), add `inc`, persist, and return the NEW total. The
+    // previous `Ok(inc)` echoed the increment and never touched the store, so the
+    // running total was wrong and `loadStream` never reflected the counter.
+    let count: QueryDb.count<string> = async (id, fieldName, inc) => {
+      let subMap = getOrCreateSubMap(id)
+      let existing = subMap->Dict.get("")->Option.flatMap(JSON.Decode.object)
+      let current =
+        existing
+        ->Option.flatMap(o => o->Dict.get(fieldName))
+        ->Option.flatMap(JSON.Decode.float)
+        ->Option.mapOr(0, Float.toInt)
+      let next = current + inc
+      let obj = Dict.make()
+      switch existing {
+      | Some(o) => o->Dict.toArray->Array.forEach(((k, v)) => obj->Dict.set(k, v))
+      | None => ()
+      }
+      obj->Dict.set("id", JSON.Encode.string(id))
+      obj->Dict.set(fieldName, JSON.Encode.int(next))
+      let newItem = JSON.Encode.object(obj)
+      subMap->Dict.set("", newItem)
+      syncAll()
+      publishUpdated(id, newItem)
+      Ok(next)
+    }
 
     let delete: QueryDb.delete<string> = async (id, subIdOpt) => {
       switch subIdOpt {
@@ -215,8 +313,28 @@ module Make = (Bus: LocalBus.T) => {
     }
 
     Bus.registerQueryDb(name, ops)
-    Bus.registerQueryDbScan(name, () => allItems.contents)
-    Bus.registerQueryDbStream(name, () => allItems.contents->Stream.fromIterable)
+    Bus.registerQueryDbScan(name, () => {
+      purgeExpired()
+      currentItems()
+    })
+    Bus.registerQueryDbStream(name, () => {
+      purgeExpired()
+      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)
+      )
+    })
 
     {
       resources: [],

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

@@ -60,21 +60,85 @@ 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: {}
+    };
+    let recordExpiry = (id, subKey, ttl) => {
+      if (ttl !== undefined) {
+        let m = expiries.contents[id];
+        let subExp;
+        if (m !== undefined) {
+          subExp = m;
+        } else {
+          let m$1 = {};
+          expiries.contents[id] = m$1;
+          subExp = m$1;
+        }
+        subExp[subKey] = ttl;
+        return;
+      }
+      let m$2 = expiries.contents[id];
+      if (m$2 !== undefined) {
+        return Stdlib_Dict.$$delete(m$2, subKey);
+      }
+    };
+    let purgeExpired = () => {
+      let now = Date.now() / 1000.0;
+      let removedAny = {
+        contents: false
+      };
+      Object.entries(expiries.contents).forEach(param => {
+        let subExp = param[1];
+        let id = param[0];
+        Object.entries(subExp).forEach(param => {
+          if (param[1] > now) {
+            return;
+          }
+          let subKey = param[0];
+          let sm = store.contents[id];
+          if (sm !== undefined) {
+            if (Stdlib_Option.isSome(sm[subKey])) {
+              Stdlib_Dict.$$delete(sm, subKey);
+              removedAny.contents = true;
+            }
+            if (Object.keys(sm).length === 0) {
+              Stdlib_Dict.$$delete(store.contents, id);
+            }
+          }
+          Stdlib_Dict.$$delete(subExp, subKey);
+        });
+      });
+      if (removedAny.contents) {
+        dirty.contents = true;
+        return;
+      }
     };
     let getOrCreateSubMap = partitionKey => {
       let m = store.contents[partitionKey];
@@ -85,11 +149,17 @@ function Make(Bus) {
       store.contents[partitionKey] = m$1;
       return m$1;
     };
-    let load = async id => ({
-      TAG: "Ok",
-      _0: sortedItems(store.contents, id)
-    });
-    let loadStream = id => Stream.fromIterable(sortedItems(store.contents, id));
+    let load = async id => {
+      purgeExpired();
+      return {
+        TAG: "Ok",
+        _0: sortedItems(store.contents, id)
+      };
+    };
+    let loadStream = id => {
+      purgeExpired();
+      return Stream.fromIterable(sortedItems(store.contents, id));
+    };
     let entityKeyFor = (id, subKey) => {
       if (subIdField !== undefined) {
         return id + "-" + subKey;
@@ -106,11 +176,12 @@ function Make(Bus) {
       let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Removed", entityKeyFor(id, subKey), undefined);
       Bus.publishStateChange(name, descriptor);
     };
-    let save = async (id, state, _saveMode, _ttl) => {
+    let save = async (id, state, _saveMode, ttl) => {
       let subKey = getSubKey(state, subIdField);
       let subMap = getOrCreateSubMap(id);
       subMap[subKey] = state;
-      syncAll();
+      recordExpiry(id, subKey, ttl);
+      dirty.contents = true;
       publishUpdated(id, state);
       return {
         TAG: "Ok",
@@ -120,21 +191,40 @@ function Make(Bus) {
     let saveBatch = async batch => {
       batch.forEach(param => {
         let state = param[1];
+        let id = param[0];
         let subKey = getSubKey(state, subIdField);
-        let subMap = getOrCreateSubMap(param[0]);
+        let subMap = getOrCreateSubMap(id);
         subMap[subKey] = state;
+        recordExpiry(id, subKey, param[2]);
       });
-      syncAll();
+      dirty.contents = true;
       batch.forEach(param => publishUpdated(param[0], param[1]));
       return {
         TAG: "Ok",
         _0: undefined
       };
     };
-    let count = async (_id, _fieldName, inc) => ({
-      TAG: "Ok",
-      _0: inc
-    });
+    let count = async (id, fieldName, inc) => {
+      let subMap = getOrCreateSubMap(id);
+      let existing = Stdlib_Option.flatMap(subMap[""], Stdlib_JSON.Decode.object);
+      let current = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(existing, o => o[fieldName]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+      let next = current + inc | 0;
+      let obj = {};
+      if (existing !== undefined) {
+        Object.entries(existing).forEach(param => {
+          obj[param[0]] = param[1];
+        });
+      }
+      obj["id"] = id;
+      obj[fieldName] = next;
+      subMap[""] = obj;
+      dirty.contents = true;
+      publishUpdated(id, obj);
+      return {
+        TAG: "Ok",
+        _0: next
+      };
+    };
     let $$delete = async (id, subIdOpt) => {
       if (subIdOpt !== undefined) {
         let subValue = subIdOpt[1];
@@ -142,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 {
@@ -192,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",
@@ -209,8 +299,18 @@ function Make(Bus) {
       deleteBatch: deleteBatch
     };
     Bus.registerQueryDb(name, ops);
-    Bus.registerQueryDbScan(name, () => allItems.contents);
-    Bus.registerQueryDbStream(name, () => Stream.fromIterable(allItems.contents));
+    Bus.registerQueryDbScan(name, () => {
+      purgeExpired();
+      return currentItems();
+    });
+    Bus.registerQueryDbStream(name, () => {
+      purgeExpired();
+      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: [],
       dataSourceName: Pulumi.output(""),

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)
@@ -260,7 +290,30 @@ let makeStorage = (
     Ok()
   }
 
-  let count: QueryDb.count<string> = async (_id, _fieldName, inc) => Ok(inc)
+  // Mirror DynamoDB's `ADD #fieldName :inc` on key {id}: read the counter field
+  // on the partition-key item (counters are single-state, sub_key=""), add `inc`,
+  // upsert, and return the NEW total. The previous `Ok(inc)` echoed the increment
+  // and never persisted, so the total was wrong and `loadStream` never saw it.
+  let count: QueryDb.count<string> = async (id, fieldName, inc) => {
+    let existing = rowsFor(id)->Array.get(0)->Option.flatMap(JSON.Decode.object)
+    let current =
+      existing
+      ->Option.flatMap(o => o->Dict.get(fieldName))
+      ->Option.flatMap(JSON.Decode.float)
+      ->Option.mapOr(0, Float.toInt)
+    let next = current + inc
+    let obj = Dict.make()
+    switch existing {
+    | Some(o) => o->Dict.toArray->Array.forEach(((k, v)) => obj->Dict.set(k, v))
+    | None => ()
+    }
+    obj->Dict.set("id", JSON.Encode.string(id))
+    obj->Dict.set(fieldName, JSON.Encode.int(next))
+    let newItem = JSON.Encode.object(obj)
+    saveOne(id, newItem, None)
+    publishUpdated(id, newItem)
+    Ok(next)
+  }
 
   let deleteOne = (id: string, subIdOpt) =>
     switch subIdOpt {
@@ -308,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: [],
@@ -325,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> = (