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

package/tests/adapter/QueryDbListPushdownParityTest.res

@@ -0,0 +1,197 @@
+// Parity harness for the SQLite connection-list push-down (plan B4).
+//
+// The SQLite `registerQueryDbListPage` builds json_extract predicates + ORDER BY
+// … LIMIT to serve a page without materialising the whole read model. Its result
+// MUST equal `QueryDbListQuery.run` (the shared spec the in-memory backend and
+// the resolver fallback use) for every shape it claims to handle. This runs a
+// matrix of (data, args) through BOTH the push-down and the spec-over-full-scan
+// and asserts identical edges + pageInfo — and asserts the push-down returns None
+// (→ fallback) for the shapes it deliberately doesn't reproduce in SQL.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let capability: ReventlessCore.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),
+]
+
+type setup = {
+  listPage: (
+    ~argsDict: dict<JSON.t>,
+    ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
+    ~labelField: string,
+  ) => option<JSON.t>,
+  fullScan: unit => array<JSON.t>,
+}
+
+let build = async (): setup => {
+  module TestBus = LocalBus.Make()
+  module DbProvider = {
+    let db = SqliteDriver.openDb(~path=":memory:")
+  }
+  module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+  let s = Storage.make(~name="items", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+  let ops = await s.operations->TestRunner.resolve
+  for i in 0 to rows->Array.length - 1 {
+    let (id, status, name, qty) = rows->Array.getUnsafe(i)
+    let _ = await ops.save(id, mk(id, status, name, qty), ReventlessCore.QueryDb.Any, None)
+  }
+  {
+    listPage: TestBus.getQueryDbListPage("items")->Option.getOrThrow,
+    fullScan: TestBus.getQueryDbScan("items")->Option.getOrThrow,
+  }
+}
+
+// ── 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
+
+// Assert the push-down serves this shape AND matches the spec exactly.
+let checkPushed = async (~label, args) => {
+  let s = await build()
+  let argsDict = argsOf(args)
+  let expected =
+    QueryDbListQuery.run(
+      ~items=s.fullScan(),
+      ~argsDict,
+      ~capability,
+      ~labelField="name",
+      ~decodeLocalId=_ => None,
+    )->norm
+  switch s.listPage(~argsDict, ~capability, ~labelField="name") {
+  | Some(actual) => expect(actual->norm)->toEqual(expected)
+  | 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 s = await build()
+  expect(s.listPage(~argsDict=argsOf(args), ~capability, ~labelField="name")->Option.isSome)->toBe(false)
+}
+
+describe("QueryDb list push-down parity (SQLite ≡ 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 CAST(... AS 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")))])
+  )
+})

package/tests/adapter/QueryDbListPushdownParityTest.res.mjs

@@ -0,0 +1,292 @@
+// 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 LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as QueryDbListQuery$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbListQuery.res.mjs";
+import * as QueryDbStorage_Sqlite$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+let capability_filterFields = [
+  {
+    name: "status",
+    gqlType: "String",
+    range: false
+  },
+  {
+    name: "qty",
+    gqlType: "Int",
+    range: true
+  }
+];
+
+let capability_sortFields = [
+  "name",
+  "qty",
+  "status"
+];
+
+let capability = {
+  filterFields: capability_filterFields,
+  sortFields: capability_sortFields
+};
+
+function mk(id, status, name, qty) {
+  let o = {};
+  o["id"] = id;
+  o["status"] = status;
+  o["name"] = name;
+  o["qty"] = qty;
+  return o;
+}
+
+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
+  ]
+];
+
+async function build() {
+  let TestBus = LocalBus$ReventlessLocal.Make({});
+  let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+  let DbProvider = {
+    db: db
+  };
+  let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+  let s = Storage.make("items", [], undefined, undefined, undefined, undefined, opts);
+  let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+  for (let i = 0, i_finish = rows.length; i < i_finish; ++i) {
+    let match = rows[i];
+    let id = match[0];
+    await ops.save(id, mk(id, match[1], match[2], match[3]), "Any", undefined);
+  }
+  return {
+    listPage: Stdlib_Option.getOrThrow(TestBus.getQueryDbListPage("items"), undefined),
+    fullScan: Stdlib_Option.getOrThrow(TestBus.getQueryDbScan("items"), undefined)
+  };
+}
+
+function field(j, k) {
+  return Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d[k]);
+}
+
+function str(j, k) {
+  return Stdlib_Option.flatMap(field(j, k), Stdlib_JSON.Decode.string);
+}
+
+function norm(conn) {
+  let edges = Stdlib_Option.getOr(Stdlib_Option.flatMap(field(conn, "edges"), Stdlib_JSON.Decode.array), []).map(e => ({
+    id: Stdlib_Option.getOr(Stdlib_Option.flatMap(field(e, "node"), n => str(n, "id")), ""),
+    cursor: Stdlib_Option.getOr(str(e, "cursor"), "")
+  }));
+  let pi = Stdlib_Option.getOr(field(conn, "pageInfo"), null);
+  return {
+    edges: edges,
+    hasNext: Stdlib_Option.getOr(Stdlib_Option.flatMap(field(pi, "hasNextPage"), Stdlib_JSON.Decode.bool), false),
+    hasPrev: Stdlib_Option.getOr(Stdlib_Option.flatMap(field(pi, "hasPreviousPage"), Stdlib_JSON.Decode.bool), false),
+    startCursor: str(pi, "startCursor"),
+    endCursor: str(pi, "endCursor")
+  };
+}
+
+function argsOf(entries) {
+  return Object.fromEntries(entries);
+}
+
+function filterOf(entries) {
+  return Object.fromEntries(entries);
+}
+
+function orderBy(f, dir) {
+  return Object.fromEntries([
+    [
+      "field",
+      f
+    ],
+    [
+      "direction",
+      dir
+    ]
+  ]);
+}
+
+async function checkPushed(label, args) {
+  let s = await build();
+  let argsDict = Object.fromEntries(args);
+  let expected = norm(QueryDbListQuery$ReventlessLocal.run(s.fullScan(), argsDict, capability, "name", param => {}));
+  let actual = s.listPage(argsDict, capability, "name");
+  if (actual !== undefined) {
+    globalThis.expect(norm(actual)).toEqual(expected);
+  } else {
+    globalThis.expect("push-down for " + label).toBe("returned None");
+  }
+}
+
+async function checkFallback(args) {
+  let s = await build();
+  globalThis.expect(Stdlib_Option.isSome(s.listPage(Object.fromEntries(args), capability, "name"))).toBe(false);
+}
+
+globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery spec)", () => {
+  globalThis.test("bare page", () => checkPushed("bare", []));
+  globalThis.test("first:2", () => checkPushed("first", [[
+      "first",
+      2
+    ]]));
+  globalThis.test("first:2 + after", () => checkPushed("after", [
+    [
+      "first",
+      2
+    ],
+    [
+      "after",
+      QueryDbListQuery$ReventlessLocal.encodeCursor("p-2")
+    ]
+  ]));
+  globalThis.test("statusEq active", () => checkPushed("eq", [[
+      "filter",
+      Object.fromEntries([[
+          "statusEq",
+          "active"
+        ]])
+    ]]));
+  globalThis.test("statusEq active + first:2", () => checkPushed("eq+first", [
+    [
+      "filter",
+      Object.fromEntries([[
+          "statusEq",
+          "active"
+        ]])
+    ],
+    [
+      "first",
+      2
+    ]
+  ]));
+  globalThis.test("orderBy name ASC", () => checkPushed("order-asc", [[
+      "orderBy",
+      orderBy("name", "ASC")
+    ]]));
+  globalThis.test("orderBy name DESC", () => checkPushed("order-desc", [[
+      "orderBy",
+      orderBy("name", "DESC")
+    ]]));
+  globalThis.test("orderBy name DESC + first:2 + after", () => checkPushed("order-desc-after", [
+    [
+      "orderBy",
+      orderBy("name", "DESC")
+    ],
+    [
+      "first",
+      2
+    ],
+    [
+      "after",
+      QueryDbListQuery$ReventlessLocal.encodeCursor("Delta")
+    ]
+  ]));
+  globalThis.test("orderBy status ASC (tiebreak by id)", () => checkPushed("order-tiebreak", [[
+      "orderBy",
+      orderBy("status", "ASC")
+    ]]));
+  globalThis.test("qty range From/To (numeric-as-string)", () => checkPushed("range", [[
+      "filter",
+      Object.fromEntries([
+        [
+          "qtyFrom",
+          "2"
+        ],
+        [
+          "qtyTo",
+          "4"
+        ]
+      ])
+    ]]));
+  globalThis.test("orderBy qty ASC (numeric-as-string sort)", () => checkPushed("order-qty", [[
+      "orderBy",
+      orderBy("qty", "ASC")
+    ]]));
+  globalThis.test("search → fallback", () => checkFallback([[
+      "filter",
+      Object.fromEntries([[
+          "search",
+          "alp"
+        ]])
+    ]]));
+  globalThis.test("searchPrefix → fallback", () => checkFallback([[
+      "filter",
+      Object.fromEntries([[
+          "searchPrefix",
+          "A"
+        ]])
+    ]]));
+  globalThis.test("ids → fallback", () => checkFallback([[
+      "filter",
+      Object.fromEntries([[
+          "ids",
+          ["p-1"]
+        ]])
+    ]]));
+  globalThis.test("backward (last/before) → fallback", () => checkFallback([
+    [
+      "last",
+      2
+    ],
+    [
+      "before",
+      QueryDbListQuery$ReventlessLocal.encodeCursor("p-4")
+    ]
+  ]));
+});
+
+let cur = QueryDbListQuery$ReventlessLocal.encodeCursor;
+
+export {
+  opts,
+  capability,
+  mk,
+  rows,
+  build,
+  field,
+  str,
+  norm,
+  argsOf,
+  filterOf,
+  orderBy,
+  cur,
+  checkPushed,
+  checkFallback,
+}
+/*  Not a pure module */

package/tests/adapter/QueryDbListResolverTest.res

@@ -359,3 +359,79 @@ describe("QueryDb list resolver — keyset pagination", () => {
     expect(pageInfoBool(response, "hasPreviousPage"))->toBe(false)
   })
 })
+
+// End-to-end under SQLite: the storage registers the list push-down, so the
+// resolver takes the pushed path (json_extract + ORDER BY … LIMIT) rather than
+// the JS fallback. Same fixture, same expectations → proves the resolver wiring
+// (capability derivation + args → push-down) yields identical output. Unit-level
+// SQL≡spec parity across the full arg matrix lives in QueryDbListPushdownParityTest.
+describe("QueryDb list resolver — SQLite push-down path", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.reset()
+  })
+
+  let withSqlite = async fn => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    BackendState.setSqlite(~db, ~path=":memory:")
+    let r = await fn()
+    BackendState.setMemory()
+    db->SqliteDriver.close
+    r
+  }
+
+  testPromise("first:2 then after walks forward without overlap", () =>
+    withSqlite(async () => {
+      let (resolver, _) = await buildFixture(~name="SqlPageA")
+      let page1 = await resolver(JSON.Encode.null, argsOf([("first", numJson(2))]), emptyCtx)
+      let edges1 = getEdges(page1)
+      expect(edges1->Array.length)->toBe(2)
+      expect(edgeNodeField(edges1->Array.getUnsafe(0), "productId"))->toBe("p-1")
+      expect(edgeNodeField(edges1->Array.getUnsafe(1), "productId"))->toBe("p-2")
+      expect(pageInfoBool(page1, "hasNextPage"))->toBe(true)
+
+      let endCursor1 = pageInfoString(page1, "endCursor")->Option.getOr("")
+      let page2 =
+        await resolver(
+          JSON.Encode.null,
+          argsOf([("first", numJson(2)), ("after", strJson(endCursor1))]),
+          emptyCtx,
+        )
+      let edges2 = getEdges(page2)
+      expect(edges2->Array.length)->toBe(2)
+      expect(edgeNodeField(edges2->Array.getUnsafe(0), "productId"))->toBe("p-3")
+      expect(edgeNodeField(edges2->Array.getUnsafe(1), "productId"))->toBe("p-4")
+    })
+  )
+
+  testPromise("orderBy name DESC + first:2 returns the reverse-sorted head", () =>
+    withSqlite(async () => {
+      let (resolver, _) = await buildFixture(~name="SqlPageB")
+      let orderBy = JSON.Encode.object(
+        Dict.fromArray([("field", strJson("name")), ("direction", strJson("DESC"))]),
+      )
+      let page1 =
+        await resolver(
+          JSON.Encode.null,
+          argsOf([("orderBy", orderBy), ("first", numJson(2))]),
+          emptyCtx,
+        )
+      let edges1 = getEdges(page1)
+      expect(edges1->Array.length)->toBe(2)
+      expect(edgeNodeField(edges1->Array.getUnsafe(0), "name"))->toBe("Echo")
+      expect(edgeNodeField(edges1->Array.getUnsafe(1), "name"))->toBe("Delta")
+    })
+  )
+
+  testPromise("statusEq active narrows the pushed page", () =>
+    withSqlite(async () => {
+      let (resolver, _) = await buildFixture(~name="SqlPageC")
+      let activeFilter = JSON.Encode.object(Dict.fromArray([("statusEq", strJson("active"))]))
+      let response =
+        await resolver(JSON.Encode.null, argsOf([("filter", activeFilter)]), emptyCtx)
+      let edges = getEdges(response)
+      expect(edges->Array.length)->toBe(3)
+      expect(edgeNodeField(edges->Array.getUnsafe(0), "productId"))->toBe("p-1")
+      expect(edgeNodeField(edges->Array.getUnsafe(2), "productId"))->toBe("p-4")
+    })
+  )
+})

package/tests/adapter/QueryDbListResolverTest.res.mjs

@@ -13,6 +13,8 @@ import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/co
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as QueryDb_Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Adapter.res.mjs";
 import * as QueryDb_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Builder.res.mjs";
@@ -406,6 +408,88 @@ globalThis.describe("QueryDb list resolver — keyset pagination", () => {
   });
 });
 
+globalThis.describe("QueryDb list resolver — SQLite push-down path", () => {
+  globalThis.beforeEach(() => DomainGraphQL_Server$ReventlessLocal.reset());
+  let withSqlite = async fn => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    BackendState$ReventlessLocal.setSqlite(db, ":memory:");
+    let r = await fn();
+    BackendState$ReventlessLocal.setMemory();
+    SqliteDriver$ReventlessLocal.close(db);
+    return r;
+  };
+  globalThis.test("first:2 then after walks forward without overlap", () => withSqlite(async () => {
+    let match = await buildFixture("SqlPageA");
+    let resolver = match[0];
+    let page1 = await resolver(null, Object.fromEntries([[
+        "first",
+        2
+      ]]), emptyCtx);
+    let edges1 = getEdges(page1);
+    globalThis.expect(edges1.length).toBe(2);
+    globalThis.expect(edgeNodeField(edges1[0], "productId")).toBe("p-1");
+    globalThis.expect(edgeNodeField(edges1[1], "productId")).toBe("p-2");
+    globalThis.expect(pageInfoBool(page1, "hasNextPage")).toBe(true);
+    let endCursor1 = Stdlib_Option.getOr(getString(pageInfo(page1), "endCursor"), "");
+    let page2 = await resolver(null, Object.fromEntries([
+      [
+        "first",
+        2
+      ],
+      [
+        "after",
+        endCursor1
+      ]
+    ]), emptyCtx);
+    let edges2 = getEdges(page2);
+    globalThis.expect(edges2.length).toBe(2);
+    globalThis.expect(edgeNodeField(edges2[0], "productId")).toBe("p-3");
+    globalThis.expect(edgeNodeField(edges2[1], "productId")).toBe("p-4");
+  }));
+  globalThis.test("orderBy name DESC + first:2 returns the reverse-sorted head", () => withSqlite(async () => {
+    let match = await buildFixture("SqlPageB");
+    let orderBy = Object.fromEntries([
+      [
+        "field",
+        "name"
+      ],
+      [
+        "direction",
+        "DESC"
+      ]
+    ]);
+    let page1 = await match[0](null, Object.fromEntries([
+      [
+        "orderBy",
+        orderBy
+      ],
+      [
+        "first",
+        2
+      ]
+    ]), emptyCtx);
+    let edges1 = getEdges(page1);
+    globalThis.expect(edges1.length).toBe(2);
+    globalThis.expect(edgeNodeField(edges1[0], "name")).toBe("Echo");
+    globalThis.expect(edgeNodeField(edges1[1], "name")).toBe("Delta");
+  }));
+  globalThis.test("statusEq active narrows the pushed page", () => withSqlite(async () => {
+    let match = await buildFixture("SqlPageC");
+    let activeFilter = Object.fromEntries([[
+        "statusEq",
+        "active"
+      ]]);
+    let response = await match[0](null, Object.fromEntries([[
+        "filter",
+        activeFilter
+      ]]), emptyCtx);
+    let edges = getEdges(response);
+    globalThis.expect(edges.length).toBe(3);
+    globalThis.expect(edgeNodeField(edges[0], "productId")).toBe("p-1");
+    globalThis.expect(edgeNodeField(edges[2], "productId")).toBe("p-4");
+  }));
+});
+
 export {
   rowStateSchema,
   rowStateSchemaWithAnnotations,

package/tests/components/aggregate/AggregateFixtures.res

@@ -30,6 +30,10 @@ module ItemBehavior: ReventlessCore.Behavior.T with module Spec := ItemSpec = {
 
   let initialState = false
 
+  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
+  // Behavior.T snapshot field manually.
+  let snapshot = None
+
   let moduleUrl: string = %raw(`import.meta.url`)
 
   let evolve = (_state, _event: ItemSpec.event) => true

package/tests/components/aggregate/AggregateFixtures.res.mjs

@@ -64,6 +64,7 @@ let ItemBehavior = {
   initialState: false,
   evolve: evolve,
   decide: decide,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1
 };