@reventlessdev/reventless-postgres 3.0.0-alpha.1 → 3.0.0-alpha.100

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

package/tests/PostgresIntegrationTest.res.mjs

@@ -1,328 +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 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);
-    });
-  });
-} 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 */