@reventlessdev/reventless-postgres 3.0.0-alpha.3 → 3.0.0-alpha.30

package/lib/ocaml/QueryEnginePostgres.res

@@ -122,6 +122,265 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
   }
 
+  // ---------------------------------------------------------------------------
+  // GraphQL resolver push-downs (B3.2). The Postgres resolver Lambda dispatches
+  // these; they parallel the SQLite backend's `lookupByField` / `listPage` (the
+  // ones registered on LocalBus). All return `id`-carrying items (COALESCE from
+  // partition_key), matching the shape `QueryDbListQuery.run` operates over so
+  // the connection helpers agree.
+  //
+  // Text comparisons use `COLLATE "C"` (byte order — memcmp), the Postgres
+  // analogue of SQLite's BINARY collation, so cursor/order comparisons match
+  // JS string `<` for the ASCII id/status/name fields used as sort/filter keys.
+  // ---------------------------------------------------------------------------
+
+  // Equality lookup on an indexed JSON field — rides the expression index
+  // (`ensureIndexes`) instead of scanning. String comparison mirrors the
+  // resolver's JS path (which only matched string-typed fields).
+  let indexLookup = async (~readModelName, field: string, value: string): array<JSON.t> => {
+    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let b = {params: []}
+    let sql = `SELECT partition_key, item FROM ${table} WHERE ${col(field)} = ${b->param(
+        JSON.Encode.string(value),
+      )} AND ${notExpired}`
+    (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+  }
+
+  // Batched-by-ids lookup: BatchGetItem analogue over the projection's own
+  // table. Single-key projections only (partition_key = the id). Missing ids
+  // drop out of the response (no cardinality preservation), matching
+  // BatchGetItem semantics.
+  let byIds = async (~readModelName, ids: array<string>): array<JSON.t> => {
+    if ids->Array.length == 0 {
+      []
+    } else {
+      let table = QueryDbStorage_Postgres.tableName(readModelName)
+      let b = {params: []}
+      let idsJson = JSON.Encode.array(ids->Array.map(JSON.Encode.string))
+      let sql = `SELECT partition_key, item FROM ${table} WHERE partition_key = ANY(${b->param(
+          idsJson,
+        )}::text[]) AND ${notExpired}`
+      (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+    }
+  }
+
+  // COALESCE(item->>'id', partition_key) — the effective id, byte-ordered.
+  let idExprC = `COALESCE(item->>'id', partition_key) COLLATE "C"`
+  let jsonTextC = (field: string): string => `${col(field)} COLLATE "C"`
+
+  // Connection-list push-down. Builds `item->>'field'` predicates + keyset
+  // WHERE + `ORDER BY … LIMIT pageSize+1` so a page reads only what it returns
+  // rather than the whole read model. Reproduces `QueryDbListQuery` semantics
+  // exactly for the shapes it handles; returns `None` (→ the resolver Lambda
+  // falls back to `scan` + the shared spec) 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 — the parity harness asserts it does
+  // (SQLite ≡ Postgres ≡ spec). Mirrors QueryDbStorage_Sqlite.listPage.
+  let listPage = async (
+    ~readModelName,
+    ~argsDict: dict<JSON.t>,
+    ~capability: GraphQL_FragmentGenerator.serverCapability,
+    ~labelField as _,
+  ): option<JSON.t> => {
+    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    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 b = {params: []}
+      let whereParts = [notExpired]
+      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(
+            `${jsonTextC(f.name)} = ${b->param(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(
+              `${jsonTextC(f.name)} >= ${b->param(
+                  JSON.Encode.string(valString(v)->Option.getOr("")),
+                )}`,
+            )
+          | _ => ()
+          }
+          switch filterDict->Dict.get(f.name ++ "To") {
+          | Some(v) when v != JSON.Encode.null =>
+            whereParts->Array.push(
+              `${jsonTextC(f.name)} <= ${b->param(
+                  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) => jsonTextC(f)
+      | None => idExprC
+      }
+      switch argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string) {
+      | Some(c) =>
+        whereParts->Array.push(
+          `${cursorExpr} ${isDesc ? "<" : ">"} ${b->param(
+              JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)),
+            )}`,
+        )
+      | None => ()
+      }
+      let orderClause = switch orderByField {
+      | Some(f) => `${jsonTextC(f)} ${isDesc ? "DESC" : "ASC"}, ${idExprC} ASC`
+      | None => `${idExprC} ASC`
+      }
+      let pageSize =
+        argsDict
+        ->Dict.get("first")
+        ->Option.flatMap(JSON.Decode.float)
+        ->Option.map(Float.toInt)
+        ->Option.getOr(ReventlessCore.QueryDbListQuery.defaultListPageSize)
+      let sql = `SELECT partition_key, item FROM ${table} WHERE ${whereParts->Array.join(
+          " AND ",
+        )} ORDER BY ${orderClause} LIMIT ${b->param(JSON.Encode.int(pageSize + 1))}`
+      let rows = (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+      let hasMore = rows->Array.length > pageSize
+      let pageItems = rows->Array.slice(~start=0, ~end=pageSize)
+      let cursorField = orderByField->Option.getOr("id")
+      let cursorValueOf = item =>
+        ReventlessCore.QueryDbListQuery.getFieldString(item, cursorField)->Option.getOr(
+          ReventlessCore.QueryDbListQuery.getId(item),
+        )
+      Some(
+        ReventlessCore.QueryDbListQuery.buildConnection(
+          ~pageItems,
+          ~hasNextPage=hasMore,
+          ~hasPreviousPage=false,
+          ~cursorValueOf,
+        ),
+      )
+    }
+  }
+
+  // Sub-id connection push-down: the `{single}Items(id, filter, first/after/
+  // last/before)` query. Keyset over `sub_key` WITHIN one partition — a page
+  // reads only what it returns. Reproduces QueryDbResolvers_GraphQL's items
+  // resolver (SortKey_Filter + forward/backward keyset), entirely in SQL since
+  // sub_key IS the sort key. Cursor = base64 of the sub_key value; comparisons
+  // use COLLATE "C" (byte order) to match JS string `<`. Unlike the main list
+  // there is no declined-shape fallback — every items shape maps to SQL.
+  let itemsPage = async (
+    ~readModelName,
+    ~subIdField as _: string,
+    ~id: string,
+    ~argsDict: dict<JSON.t>,
+  ): JSON.t => {
+    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let filterDict =
+      argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+    let fstr = k => filterDict->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+    let orderDesc = fstr("order")->Option.mapOr(false, o => o == "DESC")
+    let last = argsDict->Dict.get("last")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+    let first = argsDict->Dict.get("first")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+    let after = argsDict->Dict.get("after")->Option.flatMap(JSON.Decode.string)
+    let before = argsDict->Dict.get("before")->Option.flatMap(JSON.Decode.string)
+    let isBackward = last->Option.isSome
+
+    let sk = `sub_key COLLATE "C"`
+    let b = {params: []}
+    let where = [`partition_key = ${b->param(JSON.Encode.string(id))}`, notExpired]
+    fstr("prefix")->Option.forEach(p =>
+      where->Array.push(`starts_with(sub_key, ${b->param(JSON.Encode.string(p))})`)
+    )
+    fstr("from")->Option.forEach(f => where->Array.push(`${sk} >= ${b->param(JSON.Encode.string(f))}`))
+    fstr("to")->Option.forEach(t => where->Array.push(`${sk} <= ${b->param(JSON.Encode.string(t))}`))
+    fstr("eq")->Option.forEach(e => where->Array.push(`${sk} = ${b->param(JSON.Encode.string(e))}`))
+    // Keyset: forward excludes ≤ after; backward excludes ≥ before.
+    switch (isBackward, after, before) {
+    | (false, Some(c), _) =>
+      where->Array.push(`${sk} > ${b->param(JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)))}`)
+    | (true, _, Some(c)) =>
+      where->Array.push(`${sk} < ${b->param(JSON.Encode.string(ReventlessCore.QueryDbListQuery.decodeCursor(c)))}`)
+    | _ => ()
+    }
+    // Page-fetch direction is the LOGICAL order forward, and its OPPOSITE
+    // backward (take the N nearest `before`, then reverse to logical) — mirrors
+    // the resolver's `reverse = isBackward ? !orderDesc : orderDesc`.
+    let fetchDesc = isBackward ? !orderDesc : orderDesc
+    let pageSize = (isBackward ? last : first)->Option.getOr(ReventlessCore.QueryDbListQuery.defaultListPageSize)
+    let sql = `SELECT partition_key, sub_key, item FROM ${table} WHERE ${where->Array.join(
+        " AND ",
+      )} ORDER BY ${sk} ${fetchDesc ? "DESC" : "ASC"} LIMIT ${b->param(JSON.Encode.int(pageSize + 1))}`
+    let rows = await P.pool->PgDriver.query(sql, b.params)
+    let hasMore = rows->Array.length > pageSize
+    let taken = rows->Array.slice(~start=0, ~end=pageSize)
+    // Backward fetched in reverse-logical order → flip back to logical.
+    let logical = isBackward ? taken->Array.toReversed : taken
+    let pageItems = logical->Array.map(decodeRow(~withId=false, ...))
+    // Cursor = the row's sub_key (== the item's subIdField value).
+    let subKeyOf = (row: dict<JSON.t>) =>
+      switch row->Dict.get("sub_key") {
+      | Some(JSON.String(s)) => s
+      | _ => ""
+      }
+    let cursors = logical->Array.map(subKeyOf)
+    let edges =
+      pageItems->Array.mapWithIndex((item, i) =>
+        Obj.magic({
+          "node": item,
+          "cursor": ReventlessCore.QueryDbListQuery.encodeCursor(cursors->Array.getUnsafe(i)),
+        })
+      )
+    let startCursor =
+      cursors->Array.get(0)->Option.map(ReventlessCore.QueryDbListQuery.encodeCursor)
+    let endCursor =
+      cursors->Array.get(cursors->Array.length - 1)->Option.map(ReventlessCore.QueryDbListQuery.encodeCursor)
+    Obj.magic({
+      "edges": edges,
+      "pageInfo": {
+        "hasNextPage": !isBackward && hasMore,
+        "hasPreviousPage": isBackward && hasMore,
+        "startCursor": startCursor->Nullable.fromOption,
+        "endCursor": endCursor->Nullable.fromOption,
+      },
+    })
+  }
+
   let make: QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
     Pulumi.Output.make({QueryEngine.scan, query})
 }

package/lib/ocaml/QueryEnginePostgresListPageTest.res

@@ -0,0 +1,312 @@
+// Parity harness for the Postgres connection-list push-down (B3.2a-1).
+//
+// `QueryEnginePostgres.listPage` builds `item->>'field'` predicates + keyset
+// WHERE + ORDER BY … LIMIT to serve a page without materialising the whole read
+// model. Its result MUST equal `QueryDbListQuery.run` (the shared spec in
+// reventless-core that the in-memory backend, the SQLite push-down, and the
+// resolver fallback all use) for every shape it claims to handle. This is the
+// Postgres twin of reventless-local's `QueryDbListPushdownParityTest` — same
+// capability, same rows, same (data, args) matrix — so all three backends are
+// held to one spec.
+//
+// Skipped unless PG_URL is set (like PostgresIntegrationTest), so the default
+// `pnpm test` stays dependency-free. Run with e.g.:
+//   PG_URL=postgres://postgres:postgres@localhost:5432/postgres pnpm test
+
+open JestGlobals
+open ReventlessCore
+
+@val external processEnv: dict<string> = "process.env"
+
+let capability: GraphQL_FragmentGenerator.serverCapability = {
+  filterFields: [
+    {name: "status", gqlType: "String", range: false},
+    {name: "qty", gqlType: "Int", range: true},
+  ],
+  sortFields: ["name", "qty", "status"],
+}
+
+let mk = (id, status, name, qty) => {
+  let o = Dict.make()
+  o->Dict.set("id", JSON.Encode.string(id))
+  o->Dict.set("status", JSON.Encode.string(status))
+  o->Dict.set("name", JSON.Encode.string(name))
+  o->Dict.set("qty", JSON.Encode.int(qty))
+  JSON.Encode.object(o)
+}
+
+// Names differ from id-order; status has duplicates (tiebreak); qty exercises the
+// numeric-field-as-string comparison the push-down must match.
+let rows = [
+  ("p-1", "active", "Charlie", 3),
+  ("p-2", "active", "Alpha", 1),
+  ("p-3", "inactive", "Echo", 5),
+  ("p-4", "active", "Bravo", 2),
+  ("p-5", "inactive", "Delta", 4),
+]
+
+// The exact items seeded, in memory — the spec runs over these (equivalent to a
+// full scan of the table, since every save upserts one of these by id).
+let seededItems = rows->Array.map(((id, status, name, qty)) => mk(id, status, name, qty))
+
+// ── normalise a connection to a comparable value ────────────────────────────
+type normEdge = {id: string, cursor: string}
+type normConn = {
+  edges: array<normEdge>,
+  hasNext: bool,
+  hasPrev: bool,
+  startCursor: option<string>,
+  endCursor: option<string>,
+}
+
+let field = (j, k) => j->JSON.Decode.object->Option.flatMap(d => d->Dict.get(k))
+let str = (j, k) => j->field(k)->Option.flatMap(JSON.Decode.string)
+
+let norm = (conn: JSON.t): normConn => {
+  let edges =
+    conn
+    ->field("edges")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.getOr([])
+    ->Array.map(e => {
+      id: e->field("node")->Option.flatMap(n => n->str("id"))->Option.getOr(""),
+      cursor: e->str("cursor")->Option.getOr(""),
+    })
+  let pi = conn->field("pageInfo")->Option.getOr(JSON.Encode.null)
+  {
+    edges,
+    hasNext: pi->field("hasNextPage")->Option.flatMap(JSON.Decode.bool)->Option.getOr(false),
+    hasPrev: pi->field("hasPreviousPage")->Option.flatMap(JSON.Decode.bool)->Option.getOr(false),
+    startCursor: pi->str("startCursor"),
+    endCursor: pi->str("endCursor"),
+  }
+}
+
+let argsOf = (entries: array<(string, JSON.t)>): dict<JSON.t> => Dict.fromArray(entries)
+let filterOf = (entries: array<(string, JSON.t)>): JSON.t =>
+  JSON.Encode.object(Dict.fromArray(entries))
+let orderBy = (f, dir) =>
+  JSON.Encode.object(
+    Dict.fromArray([("field", JSON.Encode.string(f)), ("direction", JSON.Encode.string(dir))]),
+  )
+let cur = QueryDbListQuery.encodeCursor
+
+let expectedFor = argsDict =>
+  QueryDbListQuery.run(
+    ~items=seededItems,
+    ~argsDict,
+    ~capability,
+    ~labelField="name",
+    ~decodeLocalId=_ => None,
+  )->norm
+
+switch processEnv->Dict.get("PG_URL") {
+| None =>
+  testSync("Postgres list push-down parity (skipped — set PG_URL to run)", () =>
+    expect(true)->toBe(true)
+  )
+| Some(url) =>
+  let pool = PgDriver.makePool({connectionString: url})
+  module Eng = QueryEnginePostgres.Make({
+    let pool = pool
+  })
+  let name = "listparity"
+
+  // Seed via the real storage ops (upsert by id → table converges to the 5 rows).
+  beforeAllAsync(async () => {
+    let ops = QueryDbStorage_Postgres.makeOperations(~pool, ~name, ~indexes=[], ~subIdField=None)
+    for i in 0 to rows->Array.length - 1 {
+      let (id, status, nm, qty) = rows->Array.getUnsafe(i)
+      let _ = await ops.save(id, mk(id, status, nm, qty), QueryDb.Any, None)
+    }
+  })
+  afterAll(() => {
+    let _ = pool->PgDriver.endPool
+  })
+
+  // Assert the push-down serves this shape AND matches the spec exactly.
+  let checkPushed = async (~label, args) => {
+    let argsDict = argsOf(args)
+    switch await Eng.listPage(~readModelName=name, ~argsDict, ~capability, ~labelField="name") {
+    | Some(actual) => expect(actual->norm)->toEqual(expectedFor(argsDict))
+    | None => expect("push-down for " ++ label)->toBe("returned None")
+    }
+  }
+
+  // Assert the push-down declines this shape (resolver falls back to the spec).
+  let checkFallback = async args => {
+    let r = await Eng.listPage(~readModelName=name, ~argsDict=argsOf(args), ~capability, ~labelField="name")
+    expect(r->Option.isSome)->toBe(false)
+  }
+
+  describe("QueryDb list push-down parity (Postgres ≡ QueryDbListQuery spec)", () => {
+    testPromise("bare page", () => checkPushed(~label="bare", []))
+    testPromise("first:2", () => checkPushed(~label="first", [("first", JSON.Encode.int(2))]))
+    testPromise("first:2 + after", () =>
+      checkPushed(
+        ~label="after",
+        [("first", JSON.Encode.int(2)), ("after", JSON.Encode.string(cur("p-2")))],
+      )
+    )
+    testPromise("statusEq active", () =>
+      checkPushed(~label="eq", [("filter", filterOf([("statusEq", JSON.Encode.string("active"))]))])
+    )
+    testPromise("statusEq active + first:2", () =>
+      checkPushed(
+        ~label="eq+first",
+        [
+          ("filter", filterOf([("statusEq", JSON.Encode.string("active"))])),
+          ("first", JSON.Encode.int(2)),
+        ],
+      )
+    )
+    testPromise("orderBy name ASC", () =>
+      checkPushed(~label="order-asc", [("orderBy", orderBy("name", "ASC"))])
+    )
+    testPromise("orderBy name DESC", () =>
+      checkPushed(~label="order-desc", [("orderBy", orderBy("name", "DESC"))])
+    )
+    testPromise("orderBy name DESC + first:2 + after", () =>
+      checkPushed(
+        ~label="order-desc-after",
+        [
+          ("orderBy", orderBy("name", "DESC")),
+          ("first", JSON.Encode.int(2)),
+          ("after", JSON.Encode.string(cur("Delta"))),
+        ],
+      )
+    )
+    // status has duplicate values → exercises the id tiebreak in ORDER BY.
+    testPromise("orderBy status ASC (tiebreak by id)", () =>
+      checkPushed(~label="order-tiebreak", [("orderBy", orderBy("status", "ASC"))])
+    )
+    // qty is numeric → exercises `item->>'qty'` (text) vs Float.toString string parity.
+    testPromise("qty range From/To (numeric-as-string)", () =>
+      checkPushed(
+        ~label="range",
+        [
+          (
+            "filter",
+            filterOf([("qtyFrom", JSON.Encode.string("2")), ("qtyTo", JSON.Encode.string("4"))]),
+          ),
+        ],
+      )
+    )
+    testPromise("orderBy qty ASC (numeric-as-string sort)", () =>
+      checkPushed(~label="order-qty", [("orderBy", orderBy("qty", "ASC"))])
+    )
+
+    // Shapes the push-down declines → resolver uses the JS fallback.
+    testPromise("search → fallback", () =>
+      checkFallback([("filter", filterOf([("search", JSON.Encode.string("alp"))]))])
+    )
+    testPromise("searchPrefix → fallback", () =>
+      checkFallback([("filter", filterOf([("searchPrefix", JSON.Encode.string("A"))]))])
+    )
+    testPromise("ids → fallback", () =>
+      checkFallback([("filter", filterOf([("ids", JSON.Encode.array([JSON.Encode.string("p-1")]))]))])
+    )
+    testPromise("backward (last/before) → fallback", () =>
+      checkFallback([("last", JSON.Encode.int(2)), ("before", JSON.Encode.string(cur("p-4")))])
+    )
+  })
+
+  // ── indexLookup / byIds push-downs ────────────────────────────────────────
+  let idsOf = (items: array<JSON.t>): array<string> =>
+    items->Array.filterMap(i => i->str("id"))->Array.toSorted(String.compare)
+
+  describe("QueryEnginePostgres index / batch push-downs", () => {
+    testPromise("indexLookup by status = active", async () => {
+      let items = await Eng.indexLookup(~readModelName=name, "status", "active")
+      expect(items->idsOf)->toEqual(["p-1", "p-2", "p-4"])
+    })
+    testPromise("indexLookup miss → empty", async () => {
+      let items = await Eng.indexLookup(~readModelName=name, "status", "nope")
+      expect(items->Array.length)->toBe(0)
+    })
+    testPromise("byIds returns matches, drops missing", async () => {
+      let items = await Eng.byIds(~readModelName=name, ["p-1", "p-3", "absent"])
+      expect(items->idsOf)->toEqual(["p-1", "p-3"])
+    })
+    testPromise("byIds [] → empty (no query)", async () => {
+      let items = await Eng.byIds(~readModelName=name, [])
+      expect(items->Array.length)->toBe(0)
+    })
+  })
+
+  // ── itemsPage (sub-id connection) ─────────────────────────────────────────
+  // A sub-id read model: partition "order-1" holds 5 lines keyed by `seq`.
+  let itemsName = "itemsparity"
+  let mkLine = seq => {
+    let o = Dict.make()
+    o->Dict.set("id", JSON.Encode.string("order-1"))
+    o->Dict.set("seq", JSON.Encode.string(seq))
+    JSON.Encode.object(o)
+  }
+  let seqs = ["a", "b", "c", "d", "e"]
+  beforeAllAsync(async () => {
+    let ops = QueryDbStorage_Postgres.makeOperations(
+      ~pool,
+      ~name=itemsName,
+      ~indexes=[],
+      ~subIdField=Some("seq"),
+    )
+    for i in 0 to seqs->Array.length - 1 {
+      let _ = await ops.save("order-1", mkLine(seqs->Array.getUnsafe(i)), QueryDb.Any, None)
+    }
+  })
+
+  // Extract node `seq` values in edge order.
+  let itemSeqs = (conn: JSON.t) =>
+    conn
+    ->field("edges")
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.getOr([])
+    ->Array.filterMap(e => e->field("node")->Option.flatMap(n => n->str("seq")))
+
+  let pageInfoBool = (conn, key) =>
+    conn->field("pageInfo")->Option.getOr(JSON.Encode.null)->field(key)->Option.flatMap(JSON.Decode.bool)->Option.getOr(false)
+
+  let itemsPage = args =>
+    Eng.itemsPage(~readModelName=itemsName, ~subIdField="seq", ~id="order-1", ~argsDict=argsOf(args))
+
+  describe("QueryEnginePostgres itemsPage (sub-id keyset)", () => {
+    testPromise("bare → all lines ASC, no next page", async () => {
+      let r = await itemsPage([])
+      expect(r->itemSeqs)->toEqual(["a", "b", "c", "d", "e"])
+      expect(pageInfoBool(r, "hasNextPage"))->toBe(false)
+    })
+    testPromise("first:2 → [a,b], hasNextPage", async () => {
+      let r = await itemsPage([("first", JSON.Encode.int(2))])
+      expect(r->itemSeqs)->toEqual(["a", "b"])
+      expect(pageInfoBool(r, "hasNextPage"))->toBe(true)
+    })
+    testPromise("first:2 after b → [c,d]", async () => {
+      let r = await itemsPage([("first", JSON.Encode.int(2)), ("after", JSON.Encode.string(cur("b")))])
+      expect(r->itemSeqs)->toEqual(["c", "d"])
+    })
+    testPromise("order DESC → [e..a]", async () => {
+      let r = await itemsPage([("filter", filterOf([("order", JSON.Encode.string("DESC"))]))])
+      expect(r->itemSeqs)->toEqual(["e", "d", "c", "b", "a"])
+    })
+    testPromise("filter eq c → [c]", async () => {
+      let r = await itemsPage([("filter", filterOf([("eq", JSON.Encode.string("c"))]))])
+      expect(r->itemSeqs)->toEqual(["c"])
+    })
+    testPromise("filter from b to d → [b,c,d]", async () => {
+      let r = await itemsPage([
+        ("filter", filterOf([("from", JSON.Encode.string("b")), ("to", JSON.Encode.string("d"))])),
+      ])
+      expect(r->itemSeqs)->toEqual(["b", "c", "d"])
+    })
+    testPromise("prefix c → [c]", async () => {
+      let r = await itemsPage([("filter", filterOf([("prefix", JSON.Encode.string("c"))]))])
+      expect(r->itemSeqs)->toEqual(["c"])
+    })
+    testPromise("backward last:2 before d → [b,c] (logical ASC)", async () => {
+      let r = await itemsPage([("last", JSON.Encode.int(2)), ("before", JSON.Encode.string(cur("d")))])
+      expect(r->itemSeqs)->toEqual(["b", "c"])
+      expect(pageInfoBool(r, "hasPreviousPage"))->toBe(true)
+    })
+  })
+}

package/lib/ocaml/ReventlessPostgres.mlmap

@@ -1,9 +1,14 @@
 randjbuildsystem
 DcbEventLogStorage_Postgres
+DcbEventLogStorage_Postgres_Ops
+EventLogChangeFeed
 EventLogStorage_Postgres
+EventLogStorage_Postgres_Ops
 PgChangeFeed
 PgDriver
 PgSchema
 PostgresIntegrationTest
 QueryDbStorage_Postgres
+QueryDbStorage_Postgres_Ops
 QueryEnginePostgres
+QueryEnginePostgresListPageTest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-postgres",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.30",
   "description": "Postgres storage backend for Reventless (classic + DCB event logs, query DB, change feed). Connection-string only — RDS/Aurora, any managed provider, or a local container.",
   "license": "Apache-2.0",
   "jest": {
@@ -22,18 +22,18 @@
   "dependencies": {
     "pg": "^8.13.1",
     "sury": "11.0.0-alpha.4",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.141",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.87",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.65"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.166",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.98",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },
   "devDependencies": {
     "@types/pg": "^8.11.10",
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.51"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.53"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"
@@ -50,7 +50,7 @@
     "build": "rescript build",
     "start": "rescript watch",
     "clean": "rescript clean",
-    "rebuild": "pnpm run clean && pnpm run build -- -with-deps",
+    "rebuild": "pnpm run clean && pnpm run build",
     "test": "NODE_OPTIONS='--experimental-vm-modules' npx jest"
   }
 }

package/rescript.json

@@ -19,7 +19,8 @@
     },
     {
       "dir": "tests",
-      "subdirs": true
+      "subdirs": true,
+      "type": "dev"
     }
   ],
   "dependencies": [