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

package/lib/bs/tests/QueryEnginePostgresListPageTest.res

@@ -0,0 +1,236 @@
+// 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)
+    })
+  })
+}

package/lib/bs/tests/QueryEnginePostgresListPageTest.res.mjs

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

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1783258950748)
-#Done(1783258952632)
+#Start(1783298008858)
+#Done(1783298010813)