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

package/src/adapter/QueryDb/QueryDbResolvers_Lambda.res.mjs

@@ -0,0 +1,164 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Util_AppSync$ReventlessAws from "../../util/Util_AppSync.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as AppSync_Resolver_Functions$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver_Functions.res.mjs";
+import * as PgQueryResolver_Builder$ReventlessAws from "./PgQueryResolver_Builder.res.mjs";
+import * as AppSync_Resolver_Retrying$ReventlessAws from "../Api/AppSync_Resolver_Retrying.res.mjs";
+
+let identityBlock = `id != null && id.sub != null
+      ? { userId: id.sub, username: id.username, groups: id.claims?.['cognito:groups'] ?? [], claims: id.claims, provider: 'Cognito' }
+      : id != null
+        ? { userArn: id.userArn ?? null, accountId: id.accountId ?? null, username: id.username ?? null, provider: 'IAM' }
+        : null`;
+
+function invokeTemplate(readModelName, kind, index) {
+  let indexFrag = index !== undefined ? `\n      index: '` + index + `',` : "";
+  return `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '` + readModelName + `',
+      kind: '` + kind + `',` + indexFrag + `
+      arguments: ctx.args,
+      identity: ` + identityBlock + `
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`;
+}
+
+function invokeFieldTemplate(sourceType, kind, target, extra) {
+  return `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '` + sourceType + `',
+      kind: '` + kind + `',
+      target: '` + target + `',
+      source: ctx.source,
+      arguments: ctx.args,` + extra + `
+      identity: ` + identityBlock + `
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`;
+}
+
+function make(name, api, param, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, param$1, opts) {
+  let name$1 = Stdlib_String.capitalize(name);
+  let registryEntry = Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[name$1];
+  let fieldNameForSingle = registryEntry !== undefined ? registryEntry.singleFieldName : AppSync_Resolver_Functions$PulumiAws.uncapitalize(name$1);
+  let includeIdParam = registryEntry !== undefined ? registryEntry.includeIdParam : true;
+  let fieldNameForAll = registryEntry !== undefined ? registryEntry.listFieldName : name$1 + "s";
+  let labelField = registryEntry !== undefined ? Stdlib_Option.getOr(registryEntry.labelField, "id") : "id";
+  let returnTypeName = registryEntry !== undefined ? registryEntry.returnTypeName : name$1;
+  PgQueryResolver_Builder$ReventlessAws.register({
+    readModelName: name$1,
+    labelField: labelField,
+    includeIdParam: includeIdParam
+  });
+  if (includeIdParam) {
+    PgQueryResolver_Builder$ReventlessAws.registerNodeType(returnTypeName, name$1);
+  }
+  let mkResolver = (resolverName, field, kind, index) => AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(resolverName, api, dataSourceName, "Query", field, invokeTemplate(name$1, kind, index), opts);
+  let stripLeadingBy = s => {
+    if (s.startsWith("by") && s.length > 2) {
+      return s.slice(2, s.length);
+    } else {
+      return s;
+    }
+  };
+  let resourcesMaker = _allQueryDbs => {
+    let byId = mkResolver(Stdlib_String.capitalize(fieldNameForSingle), fieldNameForSingle, includeIdParam ? "getById" : "list", undefined);
+    let all = mkResolver(Stdlib_String.capitalize(fieldNameForAll), fieldNameForAll, "list", undefined);
+    let items = subIdField !== undefined ? [mkResolver(Stdlib_String.capitalize(fieldNameForSingle) + "Items", fieldNameForSingle + "Items", "items", undefined)] : [];
+    let byIds;
+    if (includeIdParam && subIdField === undefined) {
+      let byIdsField = fieldNameForAll + "ByIds";
+      byIds = [mkResolver(Stdlib_String.capitalize(byIdsField), byIdsField, "byIds", undefined)];
+    } else {
+      byIds = [];
+    }
+    let byIndex = indexes.map(param => {
+      let index = param.index;
+      let resolverName = Stdlib_String.capitalize(fieldNameForSingle) + "By" + Stdlib_String.capitalize(stripLeadingBy(index));
+      let field = fieldNameForSingle + "By" + Stdlib_String.capitalize(stripLeadingBy(index));
+      return mkResolver(resolverName, field, "index", index);
+    });
+    let idResolvers = idResolverConfigs.map(config => {
+      let target = config.target;
+      let match = config.source;
+      let resolvedField = match.resolvedField;
+      let subId = match.subId;
+      let targetKey = Stdlib_String.capitalize(target.tableName);
+      let match$1;
+      match$1 = resolvedField.TAG === "Single" ? [
+          resolvedField._0,
+          false
+        ] : [
+          resolvedField._0,
+          true
+        ];
+      let field = match$1[0];
+      let ix = target.idField;
+      let targetFrag;
+      if (typeof ix !== "object") {
+        targetFrag = "";
+      } else if (ix.TAG === "Index") {
+        let ix$1 = ix._0;
+        targetFrag = `\n      targetIndex: '` + ix$1 + `',\n      targetIndexIdField: '` + ix$1 + `',`;
+      } else {
+        targetFrag = `\n      targetIndex: '` + ix._0 + `',\n      targetIndexIdField: '` + ix._1 + `',`;
+      }
+      let subIdFrag;
+      subIdFrag = typeof subId !== "object" ? "" : (
+          subId.TAG === "Field" ? `\n      sourceSubId: { kind: 'field', name: '` + subId._0 + `' },` : `\n      sourceSubId: { kind: 'arg', name: '` + subId._0 + `' },`
+        );
+      let extra = `\n      sourceIdField: '` + match.idField + `',\n      multi: ` + (
+        match$1[1] ? "true" : "false"
+      ) + `,` + targetFrag + subIdFrag;
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(field), api, dataSourceName, name$1, field, invokeFieldTemplate(name$1, "resolveOne", targetKey, extra), opts);
+    });
+    let idsResolvers = idsResolverConfigs.map(config => {
+      let match = config.source;
+      let resolvedField = match.resolvedField;
+      let targetKey = Stdlib_String.capitalize(config.target.tableName);
+      let extra = `\n      sourceIdsField: '` + match.idsField + `',`;
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(resolvedField), api, dataSourceName, name$1, resolvedField, invokeFieldTemplate(name$1, "resolveMany", targetKey, extra), opts);
+    });
+    return [
+      byId,
+      all
+    ].concat(items).concat(byIds).concat(byIndex).concat(idResolvers).concat(idsResolvers).map(Util_AppSync$ReventlessAws.toResourceNative);
+  };
+  return {
+    resources: [],
+    resourcesMaker: resourcesMaker
+  };
+}
+
+let Resolver;
+
+export {
+  Resolver,
+  identityBlock,
+  invokeTemplate,
+  invokeFieldTemplate,
+  make,
+}
+/* Util_AppSync-ReventlessAws Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage_Postgres.res

@@ -37,7 +37,11 @@ let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
   }
   {
     ReventlessCore.QueryDb_Adapter.resources: [],
-    dataSourceName: ""->Pulumi.Output.make,
+    // B3.2b: the shared PgQueryResolver Lambda data source. Deferred — resolved
+    // by PgQueryResolver_Builder.provision after every plugin is built (the
+    // resolvers that read it are created even later, inside the schema-pushed
+    // resourcesMaker). Same value for every Postgres read model.
+    dataSourceName: PgQueryResolver_Builder.dataSourceName,
     operations,
   }
 }

package/src/adapter/QueryDb/QueryDbStorage_Postgres.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as QueryDbBackend$ReventlessAws from "./QueryDbBackend.res.mjs";
+import * as PgQueryResolver_Builder$ReventlessAws from "./PgQueryResolver_Builder.res.mjs";
 import * as QueryDbStorage_Postgres_Runtime$ReventlessAws from "./QueryDbStorage_Postgres_Runtime.res.mjs";
 
 function make(name, indexes, subIdField, param, param$1, param$2, param$3) {
@@ -10,7 +10,7 @@ function make(name, indexes, subIdField, param, param$1, param$2, param$3) {
   let operations = match !== undefined ? match.connectionConfig.apply(config => QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(config, name, indexes, subIdField)) : Stdlib_JsError.throwWithMessage("QueryDbStorage_Postgres.make called without a QueryDbBackend selection");
   return {
     resources: [],
-    dataSourceName: Pulumi.output(""),
+    dataSourceName: PgQueryResolver_Builder$ReventlessAws.dataSourceName,
     operations: operations
   };
 }
@@ -18,4 +18,4 @@ function make(name, indexes, subIdField, param, param$1, param$2, param$3) {
 export {
   make,
 }
-/* @pulumi/pulumi Not a pure module */
+/* PgQueryResolver_Builder-ReventlessAws Not a pure module */

package/src/adapter/Runtime/PgQueryResolverEntryPoint.mjs

@@ -0,0 +1,88 @@
+// Shared PgQueryResolver Lambda entry point (B3.2b).
+//
+// One in-VPC Lambda serves every Postgres-backed read model's GraphQL Query
+// fields (they have no per-table AppSync data source). At cold start it reads
+// QUERY_RESOLVER_CONFIG (one shared pgConnection + one handler per read model),
+// dynamically imports each spec package, and registers a per-read-model
+// `binding` (ops + QueryEnginePostgres push-downs + indexes/subIdField/capability
+// + baked labelField/includeIdParam + authorization) into
+// PgQueryResolver_Lambda. AppSync invokes `handler` with the resolver payload
+// { readModelName, kind, index?, arguments, identity }, which
+// PgQueryResolver_Lambda.dispatch routes.
+//
+// ReScript labeled args compile positionally, so the engine push-downs
+// (indexLookup/byIds/listPage/scan) are assigned straight into the `pushdowns`
+// record — same calling convention PgQueryResolver_Lambda.dispatch invokes them
+// with (verified against the compiled QueryEnginePostgres output).
+
+import { poolFor } from "@reventlessdev/reventless-aws/src/adapter/Postgres/PgRuntime.res.mjs";
+import { Make as makeEngine } from "@reventlessdev/reventless-postgres/src/QueryEnginePostgres.res.mjs";
+import { opsFor as pgQdbOpsFor } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
+import { deriveServerCapability } from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+import { register, registerNodeType, handler as dispatchHandler } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/PgQueryResolver_Lambda.res.mjs";
+import { patchSpecId, log } from "./HandlerFactoryHelpers.mjs";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// A bounded full-materialisation for the list fallback (shapes listPage
+// declines). Kept high; the fallback is only hit for search/searchPrefix/ids/
+// backward pagination, which the AutoUI does not issue for large models.
+const SCAN_ALL_LIMIT = 100000;
+
+async function buildAllBindings() {
+  const configStr = process.env["QUERY_RESOLVER_CONFIG"] || '{"handlers":[]}';
+  const config = JSON.parse(configStr);
+  const pgConnection = config.pgConnection;
+  if (!pgConnection) {
+    log.warn("no pgConnection in QUERY_RESOLVER_CONFIG", { comp: "PgQueryResolver" });
+    return;
+  }
+  // Container-lifetime pool (memoised by poolFor); the engine and the ops set
+  // share it, so a Lambda holds one pool regardless of read model count.
+  const pool = poolFor(pgConnection);
+  const engine = makeEngine({ pool });
+
+  // Relay node type → read-model map (B3.2c), baked into the config.
+  for (const [typeName, rm] of Object.entries(config.nodeTypes || {})) {
+    registerNodeType(typeName, rm);
+  }
+
+  const pushdowns = {
+    indexLookup: engine.indexLookup,
+    byIds: engine.byIds,
+    listPage: engine.listPage,
+    itemsPage: engine.itemsPage,
+    scanAll: (readModelName) => engine.scan(readModelName, [], SCAN_ALL_LIMIT),
+  };
+
+  await Promise.all((config.handlers || []).map(async h => {
+    const specModule = patchSpecId(await dynamicImport(h.specModule));
+    const indexes = (specModule.config && specModule.config.indexes) || [];
+    const subIdField = specModule.subIdConfig ? specModule.subIdConfig.subIdField : undefined;
+    const capability = deriveServerCapability(specModule.stateSchema);
+    const ops = pgQdbOpsFor(pgConnection, h.readModelName, indexes, subIdField);
+
+    register(h.readModelName, {
+      ops,
+      pushdowns,
+      indexes,
+      subIdField,
+      capability,
+      labelField: h.labelField,
+      includeIdParam: h.includeIdParam,
+      // Compiled string variant (e.g. "AllowAuthenticated"), injected on the
+      // spec by @@reventless.spec — the shape Reventless.Authorization.isAllowed
+      // matches on.
+      authorization: specModule.authorization,
+    });
+    log.debug("registered resolver binding for " + h.readModelName, { comp: "PgQueryResolver" });
+  }));
+}
+
+const initPromise = buildAllBindings();
+
+// AppSync Lambda data source: the invocation payload IS the event.
+export async function handler(event, context) {
+  await initPromise;
+  return dispatchHandler(event, context);
+}

package/tests/PgQueryResolver_LambdaTest.res

@@ -9,6 +9,8 @@
 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))
@@ -51,6 +53,9 @@ let pushdowns: PgQueryResolver_Lambda.pushdowns = {
     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(),
 }
 
@@ -59,14 +64,18 @@ let capability: GraphQL_FragmentGenerator.serverCapability = {
   sortFields: ["name", "status"],
 }
 
-let makeBinding = (~authorization=Reventless.Authorization.AllowAnonymous, ()): PgQueryResolver_Lambda.binding => {
+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: None,
+  subIdField,
   capability,
   labelField: "name",
   includeIdParam: true,
@@ -163,6 +172,22 @@ describe("PgQueryResolver_Lambda.dispatch", () => {
     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(
@@ -191,6 +216,83 @@ describe("PgQueryResolver_Lambda.dispatch", () => {
     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(