@reventlessdev/reventless-aws 3.0.0-alpha.175 → 3.0.0-alpha.177

package/tests/PgQueryResolver_LambdaTest.res

@@ -0,0 +1,308 @@
+// Unit tests for the Postgres GraphQL-read Lambda dispatcher (B3.2a-2).
+//
+// `PgQueryResolver_Lambda.dispatch` is pure over a `binding`, so this exercises
+// kind routing, arg extraction, spec-level authorization, the queryInterceptor
+// hook, and the list push-down/fallback split with an IN-MEMORY mock binding —
+// no Postgres. SQL correctness lives in QueryEnginePostgres and is covered by
+// its PG_URL-gated parity test.
+
+open JestGlobals
+open ReventlessCore
+
+@val external btoa: string => string = "btoa"
+
+let mk = (id, status, name) => {
+  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))
+  JSON.Encode.object(o)
+}
+
+let store = Dict.fromArray([
+  ("p-1", mk("p-1", "active", "Alpha")),
+  ("p-2", mk("p-2", "inactive", "Bravo")),
+  ("p-3", mk("p-3", "active", "Charlie")),
+])
+let allItems = () => store->Dict.valuesToArray
+
+let fieldEq = (item, field, value) =>
+  item
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(field))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.mapOr(false, v => v == value)
+
+// Records whether listPage was consulted, and what it returns (sentinel or None).
+let listPageReturn: ref<option<JSON.t>> = ref(None)
+
+let ops: QueryDb_Adapter.operations = {
+  load: async id => Ok(store->Dict.get(id)->Option.mapOr([], i => [i])),
+  loadStream: Obj.magic(0), // never called by dispatch
+  save: Obj.magic(0),
+  saveBatch: Obj.magic(0),
+  count: Obj.magic(0),
+  delete: Obj.magic(0),
+  deleteBatch: Obj.magic(0),
+}
+
+let pushdowns: PgQueryResolver_Lambda.pushdowns = {
+  indexLookup: async (~readModelName as _, field, value) =>
+    allItems()->Array.filter(i => fieldEq(i, field, value)),
+  byIds: async (~readModelName as _, ids) =>
+    ids->Array.filterMap(id => store->Dict.get(id)),
+  listPage: async (~readModelName as _, ~argsDict as _, ~capability as _, ~labelField as _) =>
+    listPageReturn.contents,
+  itemsPage: async (~readModelName as _, ~subIdField as _, ~id, ~argsDict as _) =>
+    // Sentinel echoing the requested id, so the dispatch routing is observable.
+    JSON.Encode.object(Dict.fromArray([("itemsFor", JSON.Encode.string(id))])),
+  scanAll: async (~readModelName as _) => allItems(),
+}
+
+let capability: GraphQL_FragmentGenerator.serverCapability = {
+  filterFields: [{name: "status", gqlType: "String", range: false}],
+  sortFields: ["name", "status"],
+}
+
+let makeBinding = (
+  ~authorization=Reventless.Authorization.AllowAnonymous,
+  ~subIdField=None,
+  (),
+): PgQueryResolver_Lambda.binding => {
+  ops,
+  pushdowns,
+  // "byStatus" index stored on the `status` field.
+  indexes: [
+    {index: "byStatus", type_: "S", idField: "status", projectionType: Reventless.ReadModel.ALL},
+  ],
+  subIdField,
+  capability,
+  labelField: "name",
+  includeIdParam: true,
+  authorization,
+}
+
+let mkPayload = (~kind, ~index=?, ~args=JSON.Encode.object(Dict.make()), ()): PgQueryResolver_Lambda.payload => {
+  readModelName: "Things",
+  kind,
+  ?index,
+  arguments: args,
+  identity: Reventless.Identity.anonymous,
+}
+
+let objArgs = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+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 ids = (arr: JSON.t) =>
+  arr
+  ->JSON.Decode.array
+  ->Option.getOr([])
+  ->Array.filterMap(i => i->str("id"))
+  ->Array.toSorted(String.compare)
+
+describe("PgQueryResolver_Lambda.dispatch", () => {
+  testPromise("getById returns the item (id-carrying)", async () => {
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(~kind="getById", ~args=objArgs([("id", JSON.Encode.string("p-2"))]), ()),
+    )
+    expect(r->str("id"))->toEqual(Some("p-2"))
+    expect(r->str("name"))->toEqual(Some("Bravo"))
+  })
+
+  testPromise("getById miss → null", async () => {
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(~kind="getById", ~args=objArgs([("id", JSON.Encode.string("absent"))]), ()),
+    )
+    expect(r)->toBe(JSON.Encode.null)
+  })
+
+  testPromise("byIds returns matches, drops missing", async () => {
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(
+        ~kind="byIds",
+        ~args=objArgs([
+          ("ids", JSON.Encode.array(["p-1", "absent", "p-3"]->Array.map(JSON.Encode.string))),
+        ]),
+        (),
+      ),
+    )
+    expect(r->ids)->toEqual(["p-1", "p-3"])
+  })
+
+  testPromise("index routes to indexLookup on the idField", async () => {
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(
+        ~kind="index",
+        ~index="byStatus",
+        // arg name is the index name; value looked up against idField `status`
+        ~args=objArgs([("byStatus", JSON.Encode.string("active"))]),
+        (),
+      ),
+    )
+    expect(r->ids)->toEqual(["p-1", "p-3"])
+  })
+
+  testPromise("list with push-down → returns the connection listPage gives", async () => {
+    listPageReturn := Some(JSON.Encode.string("PUSHED"))
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(~kind="list", ()),
+    )
+    listPageReturn := None
+    expect(r)->toEqual(JSON.Encode.string("PUSHED"))
+  })
+
+  testPromise("list without push-down → falls back to the shared spec", async () => {
+    listPageReturn := None
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(~kind="list", ()),
+    )
+    // A connection object: edges present, all 3 items, sorted by id.
+    let edgeIds =
+      r
+      ->field("edges")
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.getOr([])
+      ->Array.filterMap(e => e->field("node")->Option.flatMap(n => n->str("id")))
+    expect(edgeIds)->toEqual(["p-1", "p-2", "p-3"])
+  })
+
+  testPromise("items with subId routes to itemsPage (id echoed)", async () => {
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(~subIdField=Some("seq"), ()),
+      ~payload=mkPayload(~kind="items", ~args=objArgs([("id", JSON.Encode.string("p-2"))]), ()),
+    )
+    expect(r->str("itemsFor"))->toEqual(Some("p-2"))
+  })
+
+  testPromise("items without subId → empty connection", async () => {
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(~kind="items", ~args=objArgs([("id", JSON.Encode.string("p-2"))]), ()),
+    )
+    expect(r->field("edges")->Option.flatMap(JSON.Decode.array)->Option.getOr([])->Array.length)->toBe(0)
+  })
+
+  testPromise("authorization DenyAll → empty shape per kind", async () => {
+    let b = makeBinding(~authorization=DenyAll, ())
+    let single = await PgQueryResolver_Lambda.dispatch(
+      ~binding=b,
+      ~payload=mkPayload(~kind="getById", ~args=objArgs([("id", JSON.Encode.string("p-1"))]), ()),
+    )
+    expect(single)->toBe(JSON.Encode.null)
+    let list = await PgQueryResolver_Lambda.dispatch(~binding=b, ~payload=mkPayload(~kind="list", ()))
+    expect(list->field("edges")->Option.flatMap(JSON.Decode.array)->Option.getOr([])->Array.length)->toBe(0)
+    let byIds = await PgQueryResolver_Lambda.dispatch(
+      ~binding=b,
+      ~payload=mkPayload(~kind="byIds", ~args=objArgs([("ids", JSON.Encode.array([]))]), ()),
+    )
+    expect(byIds->JSON.Decode.array->Option.getOr([])->Array.length)->toBe(0)
+  })
+
+  testPromise("queryInterceptor hook Deny → empty shape (auth allowed)", async () => {
+    QueryDb_Callback.registerQueryInterceptor(async (~identity as _, ~readModelName as _, ~args as _) =>
+      Deny("nope")
+    )
+    let r = await PgQueryResolver_Lambda.dispatch(
+      ~binding=makeBinding(),
+      ~payload=mkPayload(~kind="getById", ~args=objArgs([("id", JSON.Encode.string("p-1"))]), ()),
+    )
+    QueryDb_Callback.clearQueryInterceptor()
+    expect(r)->toBe(JSON.Encode.null)
+  })
+
+  // ── cross-table (@resolves / @resolvesMany / node) ────────────────────────
+  // For resolveOne/resolveMany the dispatch binding IS the target binding
+  // (the handler selects it); source carries the parent object's key(s).
+  testPromise("resolveOne loads target by parent's id field", async () => {
+    let payload: PgQueryResolver_Lambda.payload = {
+      readModelName: "Things",
+      kind: "resolveOne",
+      target: "Things",
+      source: objArgs([("ref", JSON.Encode.string("p-2"))]),
+      sourceIdField: "ref",
+      multi: false,
+      arguments: objArgs([]),
+      identity: Reventless.Identity.anonymous,
+    }
+    let r = await PgQueryResolver_Lambda.dispatch(~binding=makeBinding(), ~payload)
+    expect(r->str("id"))->toEqual(Some("p-2"))
+  })
+
+  testPromise("resolveOne multi via target index → array", async () => {
+    let payload: PgQueryResolver_Lambda.payload = {
+      readModelName: "Things",
+      kind: "resolveOne",
+      target: "Things",
+      source: objArgs([("st", JSON.Encode.string("active"))]),
+      sourceIdField: "st",
+      targetIndex: "byStatus",
+      targetIndexIdField: "status",
+      multi: true,
+      arguments: objArgs([]),
+      identity: Reventless.Identity.anonymous,
+    }
+    let r = await PgQueryResolver_Lambda.dispatch(~binding=makeBinding(), ~payload)
+    expect(r->ids)->toEqual(["p-1", "p-3"])
+  })
+
+  testPromise("resolveMany batch-loads target by parent's ids field", async () => {
+    let payload: PgQueryResolver_Lambda.payload = {
+      readModelName: "Things",
+      kind: "resolveMany",
+      target: "Things",
+      source: objArgs([
+        ("refs", JSON.Encode.array(["p-1", "x", "p-3"]->Array.map(JSON.Encode.string))),
+      ]),
+      sourceIdsField: "refs",
+      arguments: objArgs([]),
+      identity: Reventless.Identity.anonymous,
+    }
+    let r = await PgQueryResolver_Lambda.dispatch(~binding=makeBinding(), ~payload)
+    expect(r->ids)->toEqual(["p-1", "p-3"])
+  })
+
+  testPromise("node decodes global id → __typename + item", async () => {
+    // Register a binding + node type in the module-level registries.
+    PgQueryResolver_Lambda.register(~readModelName="Things", makeBinding())
+    PgQueryResolver_Lambda.registerNodeType(~typeName="Thing", ~readModelName="Things")
+    let payload: PgQueryResolver_Lambda.payload = {
+      readModelName: "",
+      kind: "node",
+      arguments: objArgs([("id", JSON.Encode.string(btoa("Thing:p-2")))]),
+      identity: Reventless.Identity.anonymous,
+    }
+    let r = await PgQueryResolver_Lambda.handler(payload, Obj.magic(Nullable.null))
+    expect(r->str("__typename"))->toEqual(Some("Thing"))
+    expect(r->str("name"))->toEqual(Some("Bravo"))
+  })
+
+  testPromise("node with unknown type → null", async () => {
+    let payload: PgQueryResolver_Lambda.payload = {
+      readModelName: "",
+      kind: "node",
+      arguments: objArgs([("id", JSON.Encode.string(btoa("Nope:p-1")))]),
+      identity: Reventless.Identity.anonymous,
+    }
+    let r = await PgQueryResolver_Lambda.handler(payload, Obj.magic(Nullable.null))
+    expect(r)->toBe(JSON.Encode.null)
+  })
+
+  testPromise("unmapped kind throws", async () => {
+    let threw = try {
+      let _ = await PgQueryResolver_Lambda.dispatch(
+        ~binding=makeBinding(),
+        ~payload=mkPayload(~kind="frobnicate", ()),
+      )
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+  })
+})

package/tests/PgQueryResolver_LambdaTest.res.mjs

@@ -0,0 +1,392 @@
+// 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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as QueryDb_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Callback.res.mjs";
+import * as PgQueryResolver_Lambda$ReventlessAws from "../src/adapter/QueryDb/PgQueryResolver_Lambda.res.mjs";
+
+function mk(id, status, name) {
+  let o = {};
+  o["id"] = id;
+  o["status"] = status;
+  o["name"] = name;
+  return o;
+}
+
+let store = Object.fromEntries([
+  [
+    "p-1",
+    mk("p-1", "active", "Alpha")
+  ],
+  [
+    "p-2",
+    mk("p-2", "inactive", "Bravo")
+  ],
+  [
+    "p-3",
+    mk("p-3", "active", "Charlie")
+  ]
+]);
+
+function allItems() {
+  return Object.values(store);
+}
+
+function fieldEq(item, field, value) {
+  return Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[field]), Stdlib_JSON.Decode.string), false, v => v === value);
+}
+
+let listPageReturn = {
+  contents: undefined
+};
+
+async function ops_load(id) {
+  return {
+    TAG: "Ok",
+    _0: Stdlib_Option.mapOr(store[id], [], i => [i])
+  };
+}
+
+let ops = {
+  load: ops_load,
+  loadStream: 0,
+  save: 0,
+  saveBatch: 0,
+  count: 0,
+  delete: 0,
+  deleteBatch: 0
+};
+
+async function pushdowns_indexLookup(param, field, value) {
+  return Object.values(store).filter(i => fieldEq(i, field, value));
+}
+
+async function pushdowns_byIds(param, ids) {
+  return Stdlib_Array.filterMap(ids, id => store[id]);
+}
+
+async function pushdowns_listPage(param, param$1, param$2, param$3) {
+  return listPageReturn.contents;
+}
+
+async function pushdowns_itemsPage(param, param$1, id, param$2) {
+  return Object.fromEntries([[
+      "itemsFor",
+      id
+    ]]);
+}
+
+async function pushdowns_scanAll(param) {
+  return Object.values(store);
+}
+
+let pushdowns = {
+  indexLookup: pushdowns_indexLookup,
+  byIds: pushdowns_byIds,
+  listPage: pushdowns_listPage,
+  itemsPage: pushdowns_itemsPage,
+  scanAll: pushdowns_scanAll
+};
+
+let capability_filterFields = [{
+    name: "status",
+    gqlType: "String",
+    range: false
+  }];
+
+let capability_sortFields = [
+  "name",
+  "status"
+];
+
+let capability = {
+  filterFields: capability_filterFields,
+  sortFields: capability_sortFields
+};
+
+function makeBinding(authorizationOpt, subIdFieldOpt, param) {
+  let authorization = authorizationOpt !== undefined ? authorizationOpt : "AllowAnonymous";
+  let subIdField = subIdFieldOpt !== undefined ? Primitive_option.valFromOption(subIdFieldOpt) : undefined;
+  return {
+    ops: ops,
+    pushdowns: pushdowns,
+    indexes: [{
+        index: "byStatus",
+        type_: "S",
+        idField: "status",
+        projectionType: "ALL"
+      }],
+    subIdField: subIdField,
+    capability: capability,
+    labelField: "name",
+    includeIdParam: true,
+    authorization: authorization
+  };
+}
+
+function mkPayload(kind, index, argsOpt, param) {
+  let args = argsOpt !== undefined ? argsOpt : ({});
+  return {
+    readModelName: "Things",
+    kind: kind,
+    index: index,
+    arguments: args,
+    identity: Identity$Reventless.anonymous
+  };
+}
+
+function objArgs(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+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 ids(arr) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(arr), []), i => str(i, "id")).toSorted(Primitive_string.compare);
+}
+
+globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
+  globalThis.test("getById returns the item (id-carrying)", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("getById", undefined, Object.fromEntries([[
+        "id",
+        "p-2"
+      ]]), undefined));
+    globalThis.expect(str(r, "id")).toEqual("p-2");
+    globalThis.expect(str(r, "name")).toEqual("Bravo");
+  });
+  globalThis.test("getById miss → null", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("getById", undefined, Object.fromEntries([[
+        "id",
+        "absent"
+      ]]), undefined));
+    globalThis.expect(r).toBe(null);
+  });
+  globalThis.test("byIds returns matches, drops missing", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("byIds", undefined, Object.fromEntries([[
+        "ids",
+        [
+          "p-1",
+          "absent",
+          "p-3"
+        ].map(prim => prim)
+      ]]), undefined));
+    globalThis.expect(ids(r)).toEqual([
+      "p-1",
+      "p-3"
+    ]);
+  });
+  globalThis.test("index routes to indexLookup on the idField", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("index", "byStatus", Object.fromEntries([[
+        "byStatus",
+        "active"
+      ]]), undefined));
+    globalThis.expect(ids(r)).toEqual([
+      "p-1",
+      "p-3"
+    ]);
+  });
+  globalThis.test("list with push-down → returns the connection listPage gives", async () => {
+    listPageReturn.contents = "PUSHED";
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("list", undefined, undefined, undefined));
+    listPageReturn.contents = undefined;
+    globalThis.expect(r).toEqual("PUSHED");
+  });
+  globalThis.test("list without push-down → falls back to the shared spec", async () => {
+    listPageReturn.contents = undefined;
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("list", undefined, undefined, undefined));
+    let edgeIds = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(field(r, "edges"), Stdlib_JSON.Decode.array), []), e => Stdlib_Option.flatMap(field(e, "node"), n => str(n, "id")));
+    globalThis.expect(edgeIds).toEqual([
+      "p-1",
+      "p-2",
+      "p-3"
+    ]);
+  });
+  globalThis.test("items with subId routes to itemsPage (id echoed)", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, "seq", undefined), mkPayload("items", undefined, Object.fromEntries([[
+        "id",
+        "p-2"
+      ]]), undefined));
+    globalThis.expect(str(r, "itemsFor")).toEqual("p-2");
+  });
+  globalThis.test("items without subId → empty connection", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("items", undefined, Object.fromEntries([[
+        "id",
+        "p-2"
+      ]]), undefined));
+    globalThis.expect(Stdlib_Option.getOr(Stdlib_Option.flatMap(field(r, "edges"), Stdlib_JSON.Decode.array), []).length).toBe(0);
+  });
+  globalThis.test("authorization DenyAll → empty shape per kind", async () => {
+    let b = makeBinding("DenyAll", undefined, undefined);
+    let single = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, mkPayload("getById", undefined, Object.fromEntries([[
+        "id",
+        "p-1"
+      ]]), undefined));
+    globalThis.expect(single).toBe(null);
+    let list = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, mkPayload("list", undefined, undefined, undefined));
+    globalThis.expect(Stdlib_Option.getOr(Stdlib_Option.flatMap(field(list, "edges"), Stdlib_JSON.Decode.array), []).length).toBe(0);
+    let byIds = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, mkPayload("byIds", undefined, Object.fromEntries([[
+        "ids",
+        []
+      ]]), undefined));
+    globalThis.expect(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(byIds), []).length).toBe(0);
+  });
+  globalThis.test("queryInterceptor hook Deny → empty shape (auth allowed)", async () => {
+    QueryDb_Callback$ReventlessCore.registerQueryInterceptor(async (param, param$1, param$2) => ({
+      TAG: "Deny",
+      _0: "nope"
+    }));
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("getById", undefined, Object.fromEntries([[
+        "id",
+        "p-1"
+      ]]), undefined));
+    QueryDb_Callback$ReventlessCore.clearQueryInterceptor();
+    globalThis.expect(r).toBe(null);
+  });
+  globalThis.test("resolveOne loads target by parent's id field", async () => {
+    let payload_target = "Things";
+    let payload_source = Object.fromEntries([[
+        "ref",
+        "p-2"
+      ]]);
+    let payload_sourceIdField = "ref";
+    let payload_multi = false;
+    let payload_arguments = Object.fromEntries([]);
+    let payload = {
+      readModelName: "Things",
+      kind: "resolveOne",
+      target: payload_target,
+      source: payload_source,
+      sourceIdField: payload_sourceIdField,
+      multi: payload_multi,
+      arguments: payload_arguments,
+      identity: Identity$Reventless.anonymous
+    };
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), payload);
+    globalThis.expect(str(r, "id")).toEqual("p-2");
+  });
+  globalThis.test("resolveOne multi via target index → array", async () => {
+    let payload_target = "Things";
+    let payload_source = Object.fromEntries([[
+        "st",
+        "active"
+      ]]);
+    let payload_sourceIdField = "st";
+    let payload_targetIndex = "byStatus";
+    let payload_targetIndexIdField = "status";
+    let payload_multi = true;
+    let payload_arguments = Object.fromEntries([]);
+    let payload = {
+      readModelName: "Things",
+      kind: "resolveOne",
+      target: payload_target,
+      source: payload_source,
+      sourceIdField: payload_sourceIdField,
+      targetIndex: payload_targetIndex,
+      targetIndexIdField: payload_targetIndexIdField,
+      multi: payload_multi,
+      arguments: payload_arguments,
+      identity: Identity$Reventless.anonymous
+    };
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), payload);
+    globalThis.expect(ids(r)).toEqual([
+      "p-1",
+      "p-3"
+    ]);
+  });
+  globalThis.test("resolveMany batch-loads target by parent's ids field", async () => {
+    let payload_target = "Things";
+    let payload_source = Object.fromEntries([[
+        "refs",
+        [
+          "p-1",
+          "x",
+          "p-3"
+        ].map(prim => prim)
+      ]]);
+    let payload_sourceIdsField = "refs";
+    let payload_arguments = Object.fromEntries([]);
+    let payload = {
+      readModelName: "Things",
+      kind: "resolveMany",
+      target: payload_target,
+      source: payload_source,
+      sourceIdsField: payload_sourceIdsField,
+      arguments: payload_arguments,
+      identity: Identity$Reventless.anonymous
+    };
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), payload);
+    globalThis.expect(ids(r)).toEqual([
+      "p-1",
+      "p-3"
+    ]);
+  });
+  globalThis.test("node decodes global id → __typename + item", async () => {
+    PgQueryResolver_Lambda$ReventlessAws.register("Things", makeBinding(undefined, undefined, undefined));
+    PgQueryResolver_Lambda$ReventlessAws.registerNodeType("Thing", "Things");
+    let payload_arguments = Object.fromEntries([[
+        "id",
+        btoa("Thing:p-2")
+      ]]);
+    let payload = {
+      readModelName: "",
+      kind: "node",
+      arguments: payload_arguments,
+      identity: Identity$Reventless.anonymous
+    };
+    let r = await PgQueryResolver_Lambda$ReventlessAws.handler(payload, null);
+    globalThis.expect(str(r, "__typename")).toEqual("Thing");
+    globalThis.expect(str(r, "name")).toEqual("Bravo");
+  });
+  globalThis.test("node with unknown type → null", async () => {
+    let payload_arguments = Object.fromEntries([[
+        "id",
+        btoa("Nope:p-1")
+      ]]);
+    let payload = {
+      readModelName: "",
+      kind: "node",
+      arguments: payload_arguments,
+      identity: Identity$Reventless.anonymous
+    };
+    let r = await PgQueryResolver_Lambda$ReventlessAws.handler(payload, null);
+    globalThis.expect(r).toBe(null);
+  });
+  globalThis.test("unmapped kind throws", async () => {
+    let threw;
+    try {
+      await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("frobnicate", undefined, undefined, undefined));
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+  });
+});
+
+export {
+  mk,
+  store,
+  allItems,
+  fieldEq,
+  listPageReturn,
+  ops,
+  pushdowns,
+  capability,
+  makeBinding,
+  mkPayload,
+  objArgs,
+  field,
+  str,
+  ids,
+}
+/* store Not a pure module */