@reventlessdev/reventless-postgres 3.0.0-alpha.34 → 3.0.0-alpha.36

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.36 (2026-07-17)
+
+**Note:** Version bump only for package @reventlessdev/reventless-postgres
+
+
+
+
+
+# 3.0.0-alpha.35 (2026-07-17)
+
+**Note:** Version bump only for package @reventlessdev/reventless-postgres
+
+
+
+
+
 # 3.0.0-alpha.34 (2026-07-16)
 
 **Note:** Version bump only for package @reventlessdev/reventless-postgres

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1784243180918)
-#Done(1784243185489)
+#Start(1784318654913)
+#Done(1784318659353)

package/lib/bs/compiler-info.json

@@ -4,5 +4,5 @@
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
   "rescript_config_hash": "af2af60a0fa33b8249a96ff2758f36482843126dc4e07b9302842d011e0ad8c6",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1784243185491"
+  "generated_at": "1784318659363"
 }

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1784243180918)
-#Done(1784243185489)
+#Start(1784318654913)
+#Done(1784318659353)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-postgres",
-  "version": "3.0.0-alpha.34",
+  "version": "3.0.0-alpha.36",
   "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-jest": "1.0.0-alpha.8",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.28",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.16",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.170",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.101",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.78"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.29",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.172",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.102",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.79"
   },
   "devDependencies": {
     "@types/pg": "^8.11.10",
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.53"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.54"
   },
   "peerDependencies": {
     "rescript": "12.3.0"
@@ -44,7 +44,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ReventlessDev/reventless-core.git",
-    "directory": "reventless/reventless-postgres"
+    "directory": "reventless/postgres"
   },
   "scripts": {
     "build": "rescript build",

package/tests/PostgresIntegrationTest.res.mjs

@@ -1,377 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
-import * as PgDriver$ReventlessPostgres from "../src/PgDriver.res.mjs";
-import * as PgSchema$ReventlessPostgres from "../src/PgSchema.res.mjs";
-import * as PgChangeFeed$ReventlessPostgres from "../src/PgChangeFeed.res.mjs";
-import * as EventLogChangeFeed$ReventlessPostgres from "../src/EventLogChangeFeed.res.mjs";
-import * as EventLogStorage_Postgres$ReventlessPostgres from "../src/EventLogStorage_Postgres.res.mjs";
-import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "../src/DcbEventLogStorage_Postgres.res.mjs";
-
-let opts = {};
-
-function jsonObj(pairs) {
-  return Object.fromEntries(pairs);
-}
-
-function stored(eventType, tags, data) {
-  return {
-    eventType: eventType,
-    data: data,
-    tags: tags,
-    meta: Message$ReventlessCore.generateMeta("pg-test", undefined, undefined, undefined, undefined, undefined, undefined, undefined)
-  };
-}
-
-function evJson(msgId, v) {
-  return Object.fromEntries([
-    [
-      "msgId",
-      msgId
-    ],
-    [
-      "v",
-      v
-    ]
-  ]);
-}
-
-let url = process.env["PG_URL"];
-
-if (url !== undefined) {
-  let pool = PgDriver$ReventlessPostgres.makePool({
-    connectionString: url
-  });
-  globalThis.beforeAll(async () => {
-    await PgSchema$ReventlessPostgres.ensureSchema(pool);
-    return await PgSchema$ReventlessPostgres.truncateAll(pool);
-  });
-  globalThis.afterAll(() => {
-    PgDriver$ReventlessPostgres.endPool(pool);
-  });
-  globalThis.describe("classic OCC event log", () => {
-    globalThis.test("append, replay, and conflict on wrong seq", async () => {
-      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "ct-orders", opts, undefined);
-      let ops = match[1];
-      let r0 = await ops.append(0, "agg-1", [
-        evJson("m0", 1),
-        evJson("m1", 2)
-      ]);
-      if (r0.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect("append").toBe("ok");
-      }
-      let rStale = await ops.append(0, "agg-1", [evJson("m2", 3)]);
-      if (rStale.TAG === "Ok") {
-        globalThis.expect("stale").toBe("conflict");
-      } else {
-        let tmp = rStale._0;
-        if (typeof tmp !== "object") {
-          globalThis.expect(true).toBe(true);
-        } else {
-          globalThis.expect("stale").toBe("conflict");
-        }
-      }
-      let rGap = await ops.append(5, "agg-1", [evJson("m3", 4)]);
-      if (rGap.TAG === "Ok") {
-        globalThis.expect("gap").toBe("conflict");
-      } else {
-        let tmp$1 = rGap._0;
-        if (typeof tmp$1 !== "object") {
-          globalThis.expect(true).toBe(true);
-        } else {
-          globalThis.expect("gap").toBe("conflict");
-        }
-      }
-      let rNext = await ops.append(2, "agg-1", [evJson("m4", 5)]);
-      if (rNext.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect("next").toBe("ok");
-      }
-      let evs = await ops.replay("agg-1");
-      globalThis.expect(evs.length).toBe(3);
-      let rEmpty = await ops.append(3, "agg-1", []);
-      if (rEmpty.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-        return;
-      }
-      globalThis.expect("empty").toBe("ok");
-    });
-  });
-  globalThis.describe("DCB event log", () => {
-    let makeLog = name => DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, name, [], {
-      TAG: "Simple",
-      _0: {
-        key: "k"
-      }
-    }, undefined, opts, undefined, undefined);
-    globalThis.test("append + read round-trips events with tags", async () => {
-      let match = makeLog("dcb-rt");
-      let ops = match[1];
-      let e1 = stored("ItemAdded", [{
-          key: "itemId",
-          value: "x1"
-        }], Object.fromEntries([[
-          "n",
-          "w"
-        ]]));
-      let r = await ops.append([e1], undefined);
-      if (r.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect(r._0).toBe("ok");
-      }
-      let read = await ops.read([], undefined);
-      globalThis.expect(read.events.length).toBe(1);
-      let first = read.events[0];
-      globalThis.expect(first.eventType).toBe("ItemAdded");
-      globalThis.expect(first.tags[0].key).toBe("itemId");
-      globalThis.expect(first.tags[0].value).toBe("x1");
-    });
-    globalThis.test("conditional append conflicts when the boundary already has an event", async () => {
-      let match = makeLog("dcb-cond");
-      let ops = match[1];
-      let mk = who => stored("Reserved", [{
-          key: "seatId",
-          value: "s1"
-        }], Object.fromEntries([[
-          "who",
-          who
-        ]]));
-      let r1 = await ops.append([mk("a")], undefined);
-      if (r1.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect("first").toBe("ok");
-      }
-      let cond_query = [{
-          eventTypes: ["Reserved"],
-          tags: [{
-              key: "seatId",
-              value: "s1"
-            }]
-        }];
-      let cond = {
-        query: cond_query
-      };
-      let r2 = await ops.append([mk("b")], cond);
-      if (r2.TAG === "Ok") {
-        globalThis.expect("second").toBe("conflict");
-        return;
-      }
-      let tmp = r2._0;
-      if (typeof tmp !== "object") {
-        globalThis.expect(true).toBe(true);
-        return;
-      }
-      globalThis.expect("second").toBe("conflict");
-    });
-    let writeSkew = (strategy, logName) => {
-      globalThis.test(`write-skew: exactly one of two concurrent appends wins (` + logName + `)`, async () => {
-        let match = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, logName, [], {
-          TAG: "Simple",
-          _0: {
-            key: "k"
-          }
-        }, undefined, opts, strategy, undefined);
-        let ops = match[1];
-        let cond_query = [{
-            eventTypes: ["Reserved"],
-            tags: [{
-                key: "seatId",
-                value: "hot"
-              }]
-          }];
-        let cond = {
-          query: cond_query
-        };
-        let mk = who => stored("Reserved", [{
-            key: "seatId",
-            value: "hot"
-          }], Object.fromEntries([[
-            "who",
-            who
-          ]]));
-        let p1 = ops.append([mk("a")], cond);
-        let p2 = ops.append([mk("b")], cond);
-        let r1 = await p1;
-        let r2 = await p2;
-        let isOk = r => r.TAG === "Ok";
-        let isConflict = r => Primitive_object.equal(r, {
-          TAG: "Error",
-          _0: "Conflict"
-        });
-        let oks = [
-          r1,
-          r2
-        ].filter(isOk).length;
-        let conflicts = [
-          r1,
-          r2
-        ].filter(isConflict).length;
-        globalThis.expect(oks).toBe(1);
-        globalThis.expect(conflicts).toBe(1);
-        let read = await ops.read([{
-            tags: [{
-                key: "seatId",
-                value: "hot"
-              }]
-          }], undefined);
-        globalThis.expect(read.events.length).toBe(1);
-      });
-    };
-    writeSkew("AdvisoryLocks", "dcb-skew-advisory");
-    writeSkew("RowLocks", "dcb-skew-rows");
-    globalThis.test("hot tag: N concurrent conditional appends, exactly one wins", async () => {
-      let match = makeLog("dcb-hot");
-      let ops = match[1];
-      let cond_query = [{
-          eventTypes: ["Claimed"],
-          tags: [{
-              key: "prizeId",
-              value: "p1"
-            }]
-        }];
-      let cond = {
-        query: cond_query
-      };
-      let promises = Stdlib_Array.make(12, 0).map((param, i) => ops.append([stored("Claimed", [{
-            key: "prizeId",
-            value: "p1"
-          }], Object.fromEntries([[
-            "who",
-            i
-          ]]))], cond));
-      let results = await Promise.all(promises);
-      let oks = results.filter(r => r.TAG === "Ok").length;
-      globalThis.expect(oks).toBe(1);
-      let read = await ops.read([{
-          tags: [{
-              key: "prizeId",
-              value: "p1"
-            }]
-        }], undefined);
-      globalThis.expect(read.events.length).toBe(1);
-    });
-    globalThis.test("cursors are monotonic and usable as `after`", async () => {
-      let match = makeLog("dcb-cursor");
-      let ops = match[1];
-      let mk = i => stored("Tick", [{
-          key: "streamId",
-          value: "c1"
-        }], Object.fromEntries([[
-          "i",
-          i
-        ]]));
-      await ops.append([mk(0)], undefined);
-      let pos = await ops.append([mk(1)], undefined);
-      let mid;
-      mid = pos.TAG === "Ok" ? pos._0 : "";
-      await ops.append([mk(2)], undefined);
-      let read = await ops.read([{
-          tags: [{
-              key: "streamId",
-              value: "c1"
-            }]
-        }], mid);
-      globalThis.expect(read.events.length).toBe(1);
-      globalThis.expect(read.events[0].eventType).toBe("Tick");
-    });
-  });
-  globalThis.describe("change feed", () => {
-    globalThis.test("drains all events and checkpoints", async () => {
-      let match = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "feed-log", [], {
-        TAG: "Simple",
-        _0: {
-          key: "k"
-        }
-      }, undefined, opts, undefined, undefined);
-      let mk = i => stored("Fed", [{
-          key: "id",
-          value: "f"
-        }], Object.fromEntries([[
-          "i",
-          i
-        ]]));
-      await match[1].append([
-        mk(0),
-        mk(1),
-        mk(2)
-      ], undefined);
-      let collected = {
-        contents: 0
-      };
-      let processed = await PgChangeFeed$ReventlessPostgres.drain(pool, "feed-log", "sub-1", undefined, async evs => {
-        collected.contents = collected.contents + evs.length | 0;
-      });
-      globalThis.expect(processed).toBe(3);
-      globalThis.expect(collected.contents).toBe(3);
-      let again = await PgChangeFeed$ReventlessPostgres.drain(pool, "feed-log", "sub-1", undefined, async param => {});
-      globalThis.expect(again).toBe(0);
-    });
-  });
-  globalThis.describe("classic change feed (event_log, B2.5)", () => {
-    globalThis.test("drains classic events in commit order, with fields, then checkpoints", async () => {
-      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "cf-orders", opts, undefined);
-      let ops = match[1];
-      await ops.append(0, "agg-1", [
-        evJson("m0", 1),
-        evJson("m1", 2)
-      ]);
-      await ops.append(0, "agg-2", [evJson("m2", 3)]);
-      let collected = {
-        contents: []
-      };
-      let processed = await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-orders", "cf-sub", undefined, async evs => {
-        collected.contents = collected.contents.concat(evs);
-      });
-      globalThis.expect(processed).toBe(3);
-      globalThis.expect(collected.contents.length).toBe(3);
-      let first = collected.contents[0];
-      globalThis.expect(first.aggregateId).toBe("agg-1");
-      globalThis.expect(first.seqNr).toBe(0);
-      globalThis.expect(first.msgId).toEqual("m0");
-      let cursors = collected.contents.map(e => e.cursor);
-      let increasing = true;
-      for (let i = 1, i_finish = cursors.length; i < i_finish; ++i) {
-        if (cursors[i] <= cursors[i - 1 | 0]) {
-          increasing = false;
-        }
-      }
-      globalThis.expect(increasing).toBe(true);
-      let again = await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-orders", "cf-sub", undefined, async param => {});
-      globalThis.expect(again).toBe(0);
-    });
-    globalThis.test("concurrent appends across aggregates: every event drained exactly once", async () => {
-      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "cf-concurrent", opts, undefined);
-      let ops = match[1];
-      let promises = Stdlib_Array.make(20, 0).map((param, i) => ops.append(0, "agg-" + i.toString(), [evJson("m" + i.toString(), i)]));
-      await Promise.all(promises);
-      let collected = {
-        contents: []
-      };
-      await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-concurrent", "cf-conc-sub", undefined, async evs => {
-        collected.contents = collected.contents.concat(evs);
-      });
-      globalThis.expect(collected.contents.length).toBe(20);
-      let distinctCursors = new Set(collected.contents.map(e => e.cursor));
-      globalThis.expect(distinctCursors.size).toBe(20);
-    });
-  });
-} else {
-  globalThis.test("Postgres integration (skipped — set PG_URL to run)", () => {
-    globalThis.expect(true).toBe(true);
-  });
-}
-
-export {
-  opts,
-  jsonObj,
-  stored,
-  evJson,
-}
-/* url Not a pure module */

package/tests/QueryEnginePostgresListPageTest.res.mjs

@@ -1,461 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
-import * as PgDriver$ReventlessPostgres from "../src/PgDriver.res.mjs";
-import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
-import * as QueryEnginePostgres$ReventlessPostgres from "../src/QueryEnginePostgres.res.mjs";
-import * as QueryDbStorage_Postgres$ReventlessPostgres from "../src/QueryDbStorage_Postgres.res.mjs";
-
-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
-  ]
-];
-
-let seededItems = rows.map(param => mk(param[0], param[1], param[2], param[3]));
-
-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
-    ]
-  ]);
-}
-
-function expectedFor(argsDict) {
-  return norm(QueryDbListQuery$ReventlessCore.run(seededItems, argsDict, capability, "name", param => {}));
-}
-
-let url = process.env["PG_URL"];
-
-if (url !== undefined) {
-  let pool = PgDriver$ReventlessPostgres.makePool({
-    connectionString: url
-  });
-  let Eng = QueryEnginePostgres$ReventlessPostgres.Make({
-    pool: pool
-  });
-  let name = "listparity";
-  globalThis.beforeAll(async () => {
-    let ops = QueryDbStorage_Postgres$ReventlessPostgres.makeOperations(pool, name, [], undefined);
-    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);
-    }
-  });
-  globalThis.afterAll(() => {
-    PgDriver$ReventlessPostgres.endPool(pool);
-  });
-  let checkPushed = async (label, args) => {
-    let argsDict = Object.fromEntries(args);
-    let actual = await Eng.listPage(name, argsDict, capability, "name");
-    if (actual !== undefined) {
-      globalThis.expect(norm(actual)).toEqual(expectedFor(argsDict));
-    } else {
-      globalThis.expect("push-down for " + label).toBe("returned None");
-    }
-  };
-  let checkFallback = async args => {
-    let r = await Eng.listPage(name, Object.fromEntries(args), capability, "name");
-    globalThis.expect(Stdlib_Option.isSome(r)).toBe(false);
-  };
-  globalThis.describe("QueryDb list push-down parity (Postgres ≡ 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$ReventlessCore.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$ReventlessCore.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$ReventlessCore.encodeCursor("p-4")
-      ]
-    ]));
-  });
-  let idsOf = items => Stdlib_Array.filterMap(items, i => str(i, "id")).toSorted(Primitive_string.compare);
-  globalThis.describe("QueryEnginePostgres index / batch push-downs", () => {
-    globalThis.test("indexLookup by status = active", async () => {
-      let items = await Eng.indexLookup(name, "status", "active");
-      globalThis.expect(idsOf(items)).toEqual([
-        "p-1",
-        "p-2",
-        "p-4"
-      ]);
-    });
-    globalThis.test("indexLookup miss → empty", async () => {
-      let items = await Eng.indexLookup(name, "status", "nope");
-      globalThis.expect(items.length).toBe(0);
-    });
-    globalThis.test("byIds returns matches, drops missing", async () => {
-      let items = await Eng.byIds(name, [
-        "p-1",
-        "p-3",
-        "absent"
-      ]);
-      globalThis.expect(idsOf(items)).toEqual([
-        "p-1",
-        "p-3"
-      ]);
-    });
-    globalThis.test("byIds [] → empty (no query)", async () => {
-      let items = await Eng.byIds(name, []);
-      globalThis.expect(items.length).toBe(0);
-    });
-  });
-  let itemsName = "itemsparity";
-  let mkLine = seq => {
-    let o = {};
-    o["id"] = "order-1";
-    o["seq"] = seq;
-    return o;
-  };
-  let seqs = [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e"
-  ];
-  globalThis.beforeAll(async () => {
-    let ops = QueryDbStorage_Postgres$ReventlessPostgres.makeOperations(pool, itemsName, [], "seq");
-    for (let i = 0, i_finish = seqs.length; i < i_finish; ++i) {
-      await ops.save("order-1", mkLine(seqs[i]), "Any", undefined);
-    }
-  });
-  let itemSeqs = conn => Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(field(conn, "edges"), Stdlib_JSON.Decode.array), []), e => Stdlib_Option.flatMap(field(e, "node"), n => str(n, "seq")));
-  let pageInfoBool = (conn, key) => Stdlib_Option.getOr(Stdlib_Option.flatMap(field(Stdlib_Option.getOr(field(conn, "pageInfo"), null), key), Stdlib_JSON.Decode.bool), false);
-  let itemsPage = args => Eng.itemsPage(itemsName, "seq", "order-1", Object.fromEntries(args));
-  globalThis.describe("QueryEnginePostgres itemsPage (sub-id keyset)", () => {
-    globalThis.test("bare → all lines ASC, no next page", async () => {
-      let r = await itemsPage([]);
-      globalThis.expect(itemSeqs(r)).toEqual([
-        "a",
-        "b",
-        "c",
-        "d",
-        "e"
-      ]);
-      globalThis.expect(pageInfoBool(r, "hasNextPage")).toBe(false);
-    });
-    globalThis.test("first:2 → [a,b], hasNextPage", async () => {
-      let r = await itemsPage([[
-          "first",
-          2
-        ]]);
-      globalThis.expect(itemSeqs(r)).toEqual([
-        "a",
-        "b"
-      ]);
-      globalThis.expect(pageInfoBool(r, "hasNextPage")).toBe(true);
-    });
-    globalThis.test("first:2 after b → [c,d]", async () => {
-      let r = await itemsPage([
-        [
-          "first",
-          2
-        ],
-        [
-          "after",
-          QueryDbListQuery$ReventlessCore.encodeCursor("b")
-        ]
-      ]);
-      globalThis.expect(itemSeqs(r)).toEqual([
-        "c",
-        "d"
-      ]);
-    });
-    globalThis.test("order DESC → [e..a]", async () => {
-      let r = await itemsPage([[
-          "filter",
-          Object.fromEntries([[
-              "order",
-              "DESC"
-            ]])
-        ]]);
-      globalThis.expect(itemSeqs(r)).toEqual([
-        "e",
-        "d",
-        "c",
-        "b",
-        "a"
-      ]);
-    });
-    globalThis.test("filter eq c → [c]", async () => {
-      let r = await itemsPage([[
-          "filter",
-          Object.fromEntries([[
-              "eq",
-              "c"
-            ]])
-        ]]);
-      globalThis.expect(itemSeqs(r)).toEqual(["c"]);
-    });
-    globalThis.test("filter from b to d → [b,c,d]", async () => {
-      let r = await itemsPage([[
-          "filter",
-          Object.fromEntries([
-            [
-              "from",
-              "b"
-            ],
-            [
-              "to",
-              "d"
-            ]
-          ])
-        ]]);
-      globalThis.expect(itemSeqs(r)).toEqual([
-        "b",
-        "c",
-        "d"
-      ]);
-    });
-    globalThis.test("prefix c → [c]", async () => {
-      let r = await itemsPage([[
-          "filter",
-          Object.fromEntries([[
-              "prefix",
-              "c"
-            ]])
-        ]]);
-      globalThis.expect(itemSeqs(r)).toEqual(["c"]);
-    });
-    globalThis.test("backward last:2 before d → [b,c] (logical ASC)", async () => {
-      let r = await itemsPage([
-        [
-          "last",
-          2
-        ],
-        [
-          "before",
-          QueryDbListQuery$ReventlessCore.encodeCursor("d")
-        ]
-      ]);
-      globalThis.expect(itemSeqs(r)).toEqual([
-        "b",
-        "c"
-      ]);
-      globalThis.expect(pageInfoBool(r, "hasPreviousPage")).toBe(true);
-    });
-  });
-} else {
-  globalThis.test("Postgres list push-down parity (skipped — set PG_URL to run)", () => {
-    globalThis.expect(true).toBe(true);
-  });
-}
-
-let cur = QueryDbListQuery$ReventlessCore.encodeCursor;
-
-export {
-  capability,
-  mk,
-  rows,
-  seededItems,
-  field,
-  str,
-  norm,
-  argsOf,
-  filterOf,
-  orderBy,
-  cur,
-  expectedFor,
-}
-/* seededItems Not a pure module */