@reventlessdev/reventless-postgres 3.0.0-alpha.4 → 3.0.0-alpha.6

package/lib/bs/src/QueryEnginePostgres.res.mjs

@@ -1,8 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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 Pulumi from "@pulumi/pulumi";
+import * as Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
 import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
 import * as QueryDbStorage_Postgres$ReventlessPostgres from "./QueryDbStorage_Postgres.res.mjs";
 
 function valueToText(v) {
@@ -145,6 +148,162 @@ function Make(P) {
     let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + where.join(" AND ") + ` ORDER BY partition_key, sub_key LIMIT ` + param(b, limit);
     return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
   };
+  let indexLookup = async (readModelName, field, value) => {
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let b = {
+      params: []
+    };
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + col(field) + ` = ` + param(b, value) + ` AND ` + QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+    return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
+  };
+  let byIds = async (readModelName, ids) => {
+    if (ids.length === 0) {
+      return [];
+    }
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let b = {
+      params: []
+    };
+    let idsJson = ids.map(prim => prim);
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE partition_key = ANY(` + param(b, idsJson) + `::text[]) AND ` + QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+    return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
+  };
+  let idExprC = `COALESCE(item->>'id', partition_key) COLLATE "C"`;
+  let jsonTextC = field => col(field) + ` COLLATE "C"`;
+  let listPage = async (readModelName, argsDict, capability, param$1) => {
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    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 b = {
+      params: []
+    };
+    let whereParts = [QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause];
+    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(jsonTextC(f.name) + ` = ` + param(b, 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(jsonTextC(f.name) + ` >= ` + param(b, Stdlib_Option.getOr(valString(v$1), "")));
+      }
+      let v$2 = filterDict[f.name + "To"];
+      if (v$2 !== undefined && v$2 !== null) {
+        whereParts.push(jsonTextC(f.name) + ` <= ` + param(b, 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 ? jsonTextC(orderByField) : idExprC;
+    let c = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+    if (c !== undefined) {
+      whereParts.push(cursorExpr + ` ` + (
+        isDesc ? "<" : ">"
+      ) + ` ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(c)));
+    }
+    let orderClause = orderByField !== undefined ? jsonTextC(orderByField) + ` ` + (
+        isDesc ? "DESC" : "ASC"
+      ) + `, ` + idExprC + ` ASC` : idExprC + ` ASC`;
+    let pageSize = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0), QueryDbListQuery$ReventlessCore.defaultListPageSize);
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + whereParts.join(" AND ") + ` ORDER BY ` + orderClause + ` LIMIT ` + param(b, pageSize + 1 | 0);
+    let rows = (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
+    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$ReventlessCore.getFieldString(item, cursorField), QueryDbListQuery$ReventlessCore.getId(item));
+    return QueryDbListQuery$ReventlessCore.buildConnection(pageItems, hasMore, false, cursorValueOf);
+  };
+  let itemsPage = async (readModelName, param$1, id, argsDict) => {
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
+    let fstr = k => Stdlib_Option.flatMap(filterDict[k], Stdlib_JSON.Decode.string);
+    let orderDesc = Stdlib_Option.mapOr(fstr("order"), false, o => o === "DESC");
+    let last = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float), prim => prim | 0);
+    let first = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0);
+    let after = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+    let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+    let isBackward = Stdlib_Option.isSome(last);
+    let sk = `sub_key COLLATE "C"`;
+    let b = {
+      params: []
+    };
+    let where = [
+      `partition_key = ` + param(b, id),
+      QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause
+    ];
+    Stdlib_Option.forEach(fstr("prefix"), p => {
+      where.push(`starts_with(sub_key, ` + param(b, p) + `)`);
+    });
+    Stdlib_Option.forEach(fstr("from"), f => {
+      where.push(sk + ` >= ` + param(b, f));
+    });
+    Stdlib_Option.forEach(fstr("to"), t => {
+      where.push(sk + ` <= ` + param(b, t));
+    });
+    Stdlib_Option.forEach(fstr("eq"), e => {
+      where.push(sk + ` = ` + param(b, e));
+    });
+    if (isBackward) {
+      if (before !== undefined) {
+        where.push(sk + ` < ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(before)));
+      }
+    } else if (after !== undefined) {
+      where.push(sk + ` > ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(after)));
+    }
+    let fetchDesc = isBackward ? !orderDesc : orderDesc;
+    let pageSize = Stdlib_Option.getOr(isBackward ? last : first, QueryDbListQuery$ReventlessCore.defaultListPageSize);
+    let sql = `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE ` + where.join(" AND ") + ` ORDER BY ` + sk + ` ` + (
+      fetchDesc ? "DESC" : "ASC"
+    ) + ` LIMIT ` + param(b, pageSize + 1 | 0);
+    let rows = await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params);
+    let hasMore = rows.length > pageSize;
+    let taken = rows.slice(0, pageSize);
+    let logical = isBackward ? taken.toReversed() : taken;
+    let pageItems = logical.map(extra => decodeRow(false, extra));
+    let subKeyOf = row => {
+      let match = row["sub_key"];
+      if (typeof match === "string") {
+        return match;
+      } else {
+        return "";
+      }
+    };
+    let cursors = logical.map(subKeyOf);
+    let edges = pageItems.map((item, i) => ({
+      node: item,
+      cursor: QueryDbListQuery$ReventlessCore.encodeCursor(cursors[i])
+    }));
+    let startCursor = Stdlib_Option.map(cursors[0], QueryDbListQuery$ReventlessCore.encodeCursor);
+    let endCursor = Stdlib_Option.map(cursors[cursors.length - 1 | 0], QueryDbListQuery$ReventlessCore.encodeCursor);
+    return {
+      edges: edges,
+      pageInfo: {
+        hasNextPage: !isBackward && hasMore,
+        hasPreviousPage: isBackward && hasMore,
+        startCursor: Stdlib_Nullable.fromOption(startCursor),
+        endCursor: Stdlib_Nullable.fromOption(endCursor)
+      }
+    };
+  };
   let make = _allQueryDbs => Pulumi.output({
     scan: scan,
     query: query
@@ -152,6 +311,12 @@ function Make(P) {
   return {
     query: query,
     scan: scan,
+    indexLookup: indexLookup,
+    byIds: byIds,
+    idExprC: idExprC,
+    jsonTextC: jsonTextC,
+    listPage: listPage,
+    itemsPage: itemsPage,
     make: make
   };
 }

package/lib/bs/tests/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)
+    })
+  })
+}