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

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

@@ -0,0 +1,461 @@
+// 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 */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1783261249645)
-#Done(1783261251603)
+#Start(1783334804845)
+#Done(1783334806753)

package/lib/ocaml/QueryDbStorage_Postgres.res

@@ -97,23 +97,36 @@ let withId = (item: JSON.t, partitionKey: string): JSON.t =>
   | _ => item
   }
 
-let makeStorage = (
+// Plain operation set for a read model's qdb table. Exposed separately from
+// `makeStorage` so the deployed-Lambda runtime (reventless-aws) can bind ops
+// without touching the Pulumi-shaped `storage` record.
+let makeOperations = (
   ~pool: PgDriver.pool,
   ~name: string,
   ~indexes: array<indexConfig>,
   ~subIdField: option<string>,
-): QueryDb_Adapter.storage => {
+): QueryDb_Adapter.operations => {
   let table = tableName(name)
-  // Schema setup is async but makeStorage is synchronous; gate every operation on
-  // this promise so the first access waits for table + index creation exactly
-  // once (subsequent awaits resolve immediately).
-  let ready = {
-    open Promise
-    ensureTable(~pool, ~table)->then(() => ensureIndexes(~pool, ~table, ~indexes))
-  }
+  // Schema setup is async and LAZY: kicked off by the first operation, not at
+  // construction. A deploy-time caller may build the ops on a machine that
+  // cannot reach the database (VPC-private RDS) — only the runtime, which
+  // actually calls an operation, may open a connection. Subsequent operations
+  // await the same promise (table + index creation runs exactly once).
+  let readyRef: ref<option<promise<unit>>> = ref(None)
+  let ready = () =>
+    switch readyRef.contents {
+    | Some(p) => p
+    | None =>
+      let p = {
+        open Promise
+        ensureTable(~pool, ~table)->then(() => ensureIndexes(~pool, ~table, ~indexes))
+      }
+      readyRef := Some(p)
+      p
+    }
 
   let rowsFor = async (id: string): array<JSON.t> => {
-    await ready
+    await ready()
     (await pool->PgDriver.query(
       `SELECT item FROM ${table} WHERE partition_key = $1 AND ${notExpiredClause} ORDER BY sub_key ASC`,
       [JSON.Encode.string(id)],
@@ -121,7 +134,7 @@ let makeStorage = (
   }
 
   let saveOne = async (id: string, state: JSON.t, ttl: option<int>) => {
-    await ready
+    await ready()
     let subKey = computeSubKey(state, subIdField)
     let expiresAt = switch ttl {
     | Some(t) => JSON.Encode.int(t)
@@ -167,7 +180,7 @@ let makeStorage = (
   // Mirror DynamoDB's `ADD #field :inc`: read the counter on the partition item
   // (counters are single-state, sub_key=""), add inc, upsert, return NEW total.
   let count: QueryDb.count<string> = async (id, fieldName, inc) => {
-    await ready
+    await ready()
     let existing = (await rowsFor(id))->Array.get(0)->Option.flatMap(JSON.Decode.object)
     let current =
       existing
@@ -186,7 +199,7 @@ let makeStorage = (
   }
 
   let delete: QueryDb.delete<string> = async (id, subIdOpt) => {
-    await ready
+    await ready()
     let _ = switch subIdOpt {
     | None =>
       await pool->PgDriver.query(
@@ -219,11 +232,19 @@ let makeStorage = (
     delete,
     deleteBatch,
   }
+  ops
+}
 
+let makeStorage = (
+  ~pool: PgDriver.pool,
+  ~name: string,
+  ~indexes: array<indexConfig>,
+  ~subIdField: option<string>,
+): QueryDb_Adapter.storage => {
   {
     QueryDb_Adapter.resources: [],
     dataSourceName: ""->Pulumi.Output.make,
-    operations: Pulumi.Output.make(ops),
+    operations: Pulumi.Output.make(makeOperations(~pool, ~name, ~indexes, ~subIdField)),
   }
 }