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

package/src/adapter/QueryDb/PgQueryResolver_Lambda.res

@@ -19,12 +19,28 @@
 
 let log = ReventlessCore.Logger.fromEnv()
 
+@val external atob: string => string = "atob"
+
+// Where a cross-table resolver reads the target's sort-key value from.
+// `kind`: "field" (the parent object) | "arg" (the GraphQL arguments).
+type subIdSource = {kind: string, name: string}
+
 // Wire payload from the resolver template. `arguments` mirrors the field name the
 // other Invoke templates use (QueryInterceptor_Lambda, invokeCommandGenerator).
+// The cross-table fields (B3.2c) are present only for resolveOne/resolveMany:
 type payload = {
   readModelName: string,
   kind: string,
   index?: string,
+  // Cross-table (@resolves/@resolvesMany) — see B3.2c dispatch below.
+  target?: string,
+  source?: JSON.t,
+  sourceIdField?: string,
+  sourceIdsField?: string,
+  sourceSubId?: subIdSource,
+  targetIndex?: string,
+  targetIndexIdField?: string,
+  multi?: bool,
   arguments: JSON.t,
   identity: Reventless.Identity.t,
 }
@@ -40,6 +56,13 @@ type pushdowns = {
     ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
     ~labelField: string,
   ) => promise<option<JSON.t>>,
+  // Sub-id connection ({single}Items) — keyset over sub_key within a partition.
+  itemsPage: (
+    ~readModelName: string,
+    ~subIdField: string,
+    ~id: string,
+    ~argsDict: dict<JSON.t>,
+  ) => promise<JSON.t>,
   // Full materialisation for the list fallback (shapes listPage declines).
   scanAll: (~readModelName: string) => promise<array<JSON.t>>,
 }
@@ -111,10 +134,12 @@ let dispatch = async (~binding: binding, ~payload: payload): JSON.t => {
   let rm = payload.readModelName
   switch await runInterceptor(~binding, ~payload) {
   | Deny(_) =>
-    // Empty shape per kind (null for single, [] for lists, empty connection).
+    // Empty shape per kind (null for single, connection for list/items, [] else).
+    let isMulti = payload.multi->Option.getOr(false)
     switch payload.kind {
     | "getById" => JSON.Encode.null
-    | "list" => emptyConnection()
+    | "resolveOne" if !isMulti => JSON.Encode.null
+    | "list" | "items" => emptyConnection()
     | _ => JSON.Encode.array([])
     }
   | Allow =>
@@ -134,6 +159,21 @@ let dispatch = async (~binding: binding, ~payload: payload): JSON.t => {
       let ids = payload.arguments->argStrs("ids")
       JSON.Encode.array(await binding.pushdowns.byIds(~readModelName=rm, ids))
 
+    | "items" =>
+      // Sub-id connection: {single}Items(id, filter, first/after/last/before).
+      // Requires a subIdField; without one it's an empty connection.
+      switch binding.subIdField {
+      | Some(subIdField) =>
+        let id = payload.arguments->argStr("id")->Option.getOr("")
+        await binding.pushdowns.itemsPage(
+          ~readModelName=rm,
+          ~subIdField,
+          ~id,
+          ~argsDict=payload.arguments->argObj,
+        )
+      | None => emptyConnection()
+      }
+
     | "index" =>
       // The index arg name is the index; its stored field is idField ?? index.
       let indexName = payload.index->Option.getOr("")
@@ -169,6 +209,55 @@ let dispatch = async (~binding: binding, ~payload: payload): JSON.t => {
         )
       }
 
+    // Cross-table single-ID field resolver (@resolves). `binding` is the TARGET
+    // binding (the handler looks it up by payload.target); the key comes from the
+    // parent object (payload.source[sourceIdField]).
+    | "resolveOne" =>
+      let target = payload.target->Option.getOr(rm)
+      let source = payload.source->Option.getOr(JSON.Encode.null)
+      let key = source->argStr(payload.sourceIdField->Option.getOr(""))->Option.getOr("")
+      let items = switch payload.targetIndex {
+      | Some(ix) =>
+        await binding.pushdowns.indexLookup(
+          ~readModelName=target,
+          payload.targetIndexIdField->Option.getOr(ix),
+          key,
+        )
+      | None =>
+        switch await binding.ops.load(key) {
+        | Ok(items) => items
+        | Error(_) => []
+        }
+      }
+      // Optional target sort-key filter (source field or GraphQL arg).
+      let filtered = switch (payload.sourceSubId, binding.subIdField) {
+      | (Some({kind, name}), Some(subField)) =>
+        let subVal =
+          switch kind {
+          | "arg" => payload.arguments->argStr(name)
+          | _ => source->argStr(name)
+          }->Option.getOr("")
+        items->Array.filter(it => it->argStr(subField)->Option.getOr("") == subVal)
+      | _ => items
+      }
+      if payload.multi->Option.getOr(false) {
+        JSON.Encode.array(filtered)
+      } else {
+        switch filtered->Array.get(0) {
+        | Some(item) => item
+        | None => JSON.Encode.null
+        }
+      }
+
+    // Cross-table batch field resolver (@resolvesMany). ids come from the parent
+    // object (payload.source[sourceIdsField]); BatchGet the target by partition
+    // key (missing ids drop out).
+    | "resolveMany" =>
+      let target = payload.target->Option.getOr(rm)
+      let source = payload.source->Option.getOr(JSON.Encode.null)
+      let ids = source->argStrs(payload.sourceIdsField->Option.getOr(""))
+      JSON.Encode.array(await binding.pushdowns.byIds(~readModelName=target, ids))
+
     | other =>
       // Fail loudly on unmapped kinds (feature-parity guard, per the B3.2 plan).
       log.error(~comp="PgQueryResolver_Lambda", `unmapped resolver kind '${other}' for ${rm}`)
@@ -182,11 +271,65 @@ let bindings: dict<binding> = Dict.make()
 let register = (~readModelName: string, binding: binding): unit =>
   bindings->Dict.set(readModelName, binding)
 
-let handler = async (payload: payload, _context) =>
-  switch bindings->Dict.get(payload.readModelName) {
-  | Some(binding) => await dispatch(~binding, ~payload)
-  | None =>
-    JsError.throwWithMessage(
-      "PgQueryResolver: no binding registered for read model " ++ payload.readModelName,
-    )
+// Relay node type → read-model-name map (B3.2c), populated at Lambda init from
+// the deploy-time registerNodeType calls.
+let nodeTypeMap: dict<string> = Dict.make()
+let registerNodeType = (~typeName: string, ~readModelName: string): unit =>
+  nodeTypeMap->Dict.set(typeName, readModelName)
+
+// node(id: ID!) — decode the global id (base64 of `typeName:localId`, matching
+// AppSync's nodeDecodeGlobalId), map typeName → read model, load by localId,
+// return the item tagged with __typename and the original global id. Runs the
+// target's authorization/interceptor. Self-contained (getById returns raw ids,
+// so no encoding elsewhere is affected).
+let handleNode = async (~payload: payload): JSON.t => {
+  let globalId = payload.arguments->argStr("id")->Option.getOr("")
+  let decoded = try atob(globalId) catch {
+  | _ => ""
+  }
+  let colonIdx = decoded->String.indexOf(":")
+  if colonIdx <= 0 {
+    JSON.Encode.null
+  } else {
+    let typeName = decoded->String.slice(~start=0, ~end=colonIdx)
+    let localId = decoded->String.slice(~start=colonIdx + 1, ~end=decoded->String.length)
+    switch nodeTypeMap->Dict.get(typeName)->Option.flatMap(rm => bindings->Dict.get(rm)) {
+    | Some(binding) =>
+      switch await runInterceptor(~binding, ~payload) {
+      | Deny(_) => JSON.Encode.null
+      | Allow =>
+        switch await binding.ops.load(localId) {
+        | Ok(items) =>
+          switch items->Array.get(0) {
+          | Some(item) =>
+            let obj = item->JSON.Decode.object->Option.getOr(Dict.make())->Dict.copy
+            obj->Dict.set("__typename", JSON.Encode.string(typeName))
+            obj->Dict.set("id", JSON.Encode.string(globalId))
+            JSON.Encode.object(obj)
+          | None => JSON.Encode.null
+          }
+        | Error(_) => JSON.Encode.null
+        }
+      }
+    | None => JSON.Encode.null
+    }
+  }
+}
+
+let handler = async (payload: payload, _context) => {
+  // node decodes its own target; the cross-table field resolvers dispatch against
+  // the TARGET binding; everything else against the payload's own read model.
+  let bindingKey = switch payload.kind {
+  | "resolveOne" | "resolveMany" => payload.target->Option.getOr(payload.readModelName)
+  | _ => payload.readModelName
   }
+  switch payload.kind {
+  | "node" => await handleNode(~payload)
+  | _ =>
+    switch bindings->Dict.get(bindingKey) {
+    | Some(binding) => await dispatch(~binding, ~payload)
+    | None =>
+      JsError.throwWithMessage("PgQueryResolver: no binding registered for read model " ++ bindingKey)
+    }
+  }
+}

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

@@ -85,6 +85,13 @@ async function dispatch(binding, payload) {
         let field = Stdlib_Option.getOr(Stdlib_Option.flatMap(binding.indexes.find(ic => ic.index === indexName), ic => ic.idField), indexName);
         let value = Stdlib_Option.getOr(argStr(payload.arguments, indexName), "");
         return await binding.pushdowns.indexLookup(rm, field, value);
+      case "items" :
+        let subIdField = binding.subIdField;
+        if (subIdField === undefined) {
+          return emptyConnection();
+        }
+        let id$1 = Stdlib_Option.getOr(argStr(payload.arguments, "id"), "");
+        return await binding.pushdowns.itemsPage(rm, subIdField, id$1, argObj(payload.arguments));
       case "list" :
         let argsDict = argObj(payload.arguments);
         let conn = await binding.pushdowns.listPage(rm, argsDict, binding.capability, binding.labelField);
@@ -93,17 +100,62 @@ async function dispatch(binding, payload) {
         }
         let items$1 = await binding.pushdowns.scanAll(rm);
         return QueryDbListQuery$ReventlessCore.run(items$1, argsDict, binding.capability, binding.labelField, param => {});
+      case "resolveMany" :
+        let target = Stdlib_Option.getOr(payload.target, rm);
+        let source = Stdlib_Option.getOr(payload.source, null);
+        let ids$1 = argStrs(source, Stdlib_Option.getOr(payload.sourceIdsField, ""));
+        return await binding.pushdowns.byIds(target, ids$1);
+      case "resolveOne" :
+        let target$1 = Stdlib_Option.getOr(payload.target, rm);
+        let source$1 = Stdlib_Option.getOr(payload.source, null);
+        let key = Stdlib_Option.getOr(argStr(source$1, Stdlib_Option.getOr(payload.sourceIdField, "")), "");
+        let ix = payload.targetIndex;
+        let items$2;
+        if (ix !== undefined) {
+          items$2 = await binding.pushdowns.indexLookup(target$1, Stdlib_Option.getOr(payload.targetIndexIdField, ix), key);
+        } else {
+          let items$3 = await binding.ops.load(key);
+          items$2 = items$3.TAG === "Ok" ? items$3._0 : [];
+        }
+        let match$1 = payload.sourceSubId;
+        let match$2 = binding.subIdField;
+        let filtered;
+        if (match$1 !== undefined && match$2 !== undefined) {
+          let name = match$1.name;
+          let tmp = match$1.kind === "arg" ? argStr(payload.arguments, name) : argStr(source$1, name);
+          let subVal = Stdlib_Option.getOr(tmp, "");
+          filtered = items$2.filter(it => Stdlib_Option.getOr(argStr(it, match$2), "") === subVal);
+        } else {
+          filtered = items$2;
+        }
+        if (Stdlib_Option.getOr(payload.multi, false)) {
+          return filtered;
+        }
+        let item$1 = filtered[0];
+        if (item$1 !== undefined) {
+          return item$1;
+        } else {
+          return null;
+        }
       default:
         log.error("PgQueryResolver_Lambda", undefined, `unmapped resolver kind '` + other + `' for ` + rm);
         return Stdlib_JsError.throwWithMessage(`PgQueryResolver: unmapped resolver kind '` + other + `' for ` + rm);
     }
   } else {
-    let match$1 = payload.kind;
-    switch (match$1) {
+    let isMulti = Stdlib_Option.getOr(payload.multi, false);
+    let match$3 = payload.kind;
+    switch (match$3) {
       case "getById" :
         return null;
+      case "items" :
       case "list" :
         return emptyConnection();
+      case "resolveOne" :
+        if (isMulti) {
+          return [];
+        } else {
+          return null;
+        }
       default:
         return [];
     }
@@ -116,12 +168,68 @@ function register(readModelName, binding) {
   bindings[readModelName] = binding;
 }
 
+let nodeTypeMap = {};
+
+function registerNodeType(typeName, readModelName) {
+  nodeTypeMap[typeName] = readModelName;
+}
+
+async function handleNode(payload) {
+  let globalId = Stdlib_Option.getOr(argStr(payload.arguments, "id"), "");
+  let decoded;
+  try {
+    decoded = atob(globalId);
+  } catch (exn) {
+    decoded = "";
+  }
+  let colonIdx = decoded.indexOf(":");
+  if (colonIdx <= 0) {
+    return null;
+  }
+  let typeName = decoded.slice(0, colonIdx);
+  let localId = decoded.slice(colonIdx + 1 | 0, decoded.length);
+  let binding = Stdlib_Option.flatMap(nodeTypeMap[typeName], rm => bindings[rm]);
+  if (binding === undefined) {
+    return null;
+  }
+  let match = await runInterceptor(binding, payload);
+  if (typeof match === "object") {
+    return null;
+  }
+  let items = await binding.ops.load(localId);
+  if (items.TAG !== "Ok") {
+    return null;
+  }
+  let item = items._0[0];
+  if (item === undefined) {
+    return null;
+  }
+  let obj = Object.assign({}, Stdlib_Option.getOr(Stdlib_JSON.Decode.object(item), {}));
+  obj["__typename"] = typeName;
+  obj["id"] = globalId;
+  return obj;
+}
+
 async function handler(payload, _context) {
-  let binding = bindings[payload.readModelName];
+  let match = payload.kind;
+  let bindingKey;
+  switch (match) {
+    case "resolveMany" :
+    case "resolveOne" :
+      bindingKey = Stdlib_Option.getOr(payload.target, payload.readModelName);
+      break;
+    default:
+      bindingKey = payload.readModelName;
+  }
+  let match$1 = payload.kind;
+  if (match$1 === "node") {
+    return await handleNode(payload);
+  }
+  let binding = bindings[bindingKey];
   if (binding !== undefined) {
     return await dispatch(binding, payload);
   } else {
-    return Stdlib_JsError.throwWithMessage("PgQueryResolver: no binding registered for read model " + payload.readModelName);
+    return Stdlib_JsError.throwWithMessage("PgQueryResolver: no binding registered for read model " + bindingKey);
   }
 }
 
@@ -136,6 +244,9 @@ export {
   dispatch,
   bindings,
   register,
+  nodeTypeMap,
+  registerNodeType,
+  handleNode,
   handler,
 }
 /* log Not a pure module */

package/src/adapter/QueryDb/QueryDbResolvers.res

@@ -1,10 +1,11 @@
 module AppSync = QueryDbResolvers_AppSync
 module NoOp = QueryDbResolvers_NoOp
+module Lambda = QueryDbResolvers_Lambda
 
-// B3.1: Postgres-backed read models have no DynamoDB data source — suppress the
-// direct AppSync resolvers (their GraphQL fields stay unresolved until B3.2's
-// Lambda data source). DynamoDB-backed (incl. admin-exempt) read models keep the
-// full resolver set.
+// B3.2b: Postgres-backed read models have no DynamoDB data source — their
+// GraphQL Query fields are served by the shared PgQueryResolver Lambda data
+// source (`QueryDbResolvers_Lambda`, Invoke templates → PgQueryResolver_Lambda).
+// DynamoDB-backed (incl. admin-exempt) read models keep the direct resolver set.
 module Selectable = {
   type api = QueryDbResolvers_AppSync_NoOp.api
   type role = QueryDbResolvers_AppSync_NoOp.role
@@ -21,7 +22,7 @@ module Selectable = {
     ~opts,
   ) =>
     if QueryDbBackend.isPostgresFor(name) {
-      QueryDbResolvers_AppSync_NoOp.make(
+      QueryDbResolvers_Lambda.make(
         ~name,
         ~api,
         ~apiRole,

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

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as QueryDbBackend$ReventlessAws from "./QueryDbBackend.res.mjs";
+import * as QueryDbResolvers_Lambda$ReventlessAws from "./QueryDbResolvers_Lambda.res.mjs";
 import * as QueryDbResolvers_AppSync$ReventlessAws from "./QueryDbResolvers_AppSync.res.mjs";
-import * as QueryDbResolvers_AppSync_NoOp$ReventlessAws from "./QueryDbResolvers_AppSync_NoOp.res.mjs";
 
 function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts) {
   if (QueryDbBackend$ReventlessAws.isPostgresFor(name)) {
-    return QueryDbResolvers_AppSync_NoOp$ReventlessAws.make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts);
+    return QueryDbResolvers_Lambda$ReventlessAws.make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts);
   } else {
     return QueryDbResolvers_AppSync$ReventlessAws.make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts);
   }
@@ -20,9 +20,12 @@ let AppSync;
 
 let NoOp;
 
+let Lambda;
+
 export {
   AppSync,
   NoOp,
+  Lambda,
   Selectable,
 }
-/* QueryDbResolvers_AppSync-ReventlessAws Not a pure module */
+/* QueryDbResolvers_Lambda-ReventlessAws Not a pure module */

package/src/adapter/QueryDb/QueryDbResolvers_Lambda.res

@@ -0,0 +1,264 @@
+// AppSync resolvers for Postgres-backed read models (B3.2b) — the Lambda-data-
+// source parallel to QueryDbResolvers_AppSync's direct DynamoDB resolvers.
+//
+// Every Query field becomes a thin APPSYNC_JS unit resolver whose `Invoke`
+// template carries { readModelName, kind, index?, arguments, identity } to the
+// ONE shared PgQueryResolver Lambda (PgQueryResolver_Builder), which dispatches
+// via PgQueryResolver_Lambda.dispatch. `dataSourceName` is the shared data
+// source's (deferred) name, the same for every Postgres read model.
+//
+// Field names / includeIdParam / connectionSpec come from the same registry the
+// AppSync path reads, so the SDL emitted by GraphQL_FragmentGenerator stays in
+// lockstep. Kinds covered: getById, list (connection), index, byIds. Deferred to
+// B3.2c: items (sub-id connection), @resolves/@resolvesMany, node, auth-table.
+
+module Resolver = AppSync_Resolver_Retrying
+open Reventless.ReadModel
+
+type api = Types.AppSync.api
+type role = Types.AppSync.role
+
+// Identity block shared by every Invoke template (Cognito vs IAM), matching the
+// shape PgQueryResolver_Lambda decodes (Reventless.Identity.t).
+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`
+
+let invokeTemplate = (~readModelName: string, ~kind: string, ~index: option<string>=?) => {
+  let indexFrag = switch index {
+  | Some(ix) => `\n      index: '${ix}',`
+  | None => ""
+  }
+  `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;
+}
+`->Pulumi.Input.make
+}
+
+// Cross-table field resolver (@resolves/@resolvesMany, B3.2c): on a parent
+// entity type's field, carrying the parent object (ctx.source) + baked target
+// metadata (`extra`). `sourceType` is the parent read model (used only for auth
+// scoping in dispatch); `target` is the target read model's binding key.
+let invokeFieldTemplate = (~sourceType: string, ~kind: string, ~target: string, ~extra: string) =>
+  `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;
+}
+`->Pulumi.Input.make
+
+let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
+  ~name: string,
+  ~api: api,
+  ~apiRole as _: role,
+  ~dataSourceName,
+  ~indexes: array<indexConfig>,
+  ~subIdField,
+  ~idResolverConfigs: array<idResolverConfig>,
+  ~idsResolverConfigs: array<idsResolverConfig>,
+  ~authorization as _: Reventless.Authorization.permission,
+  ~opts,
+) => {
+  let dataSourceName = dataSourceName->Pulumi.Output.asInput
+  let name = name->String.capitalize
+  let registryEntry = ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry->Dict.get(name)
+
+  let fieldNameForSingle = switch registryEntry {
+  | Some({singleFieldName}) => singleFieldName
+  | None => name->Resolver.Functions.uncapitalize
+  }
+  let includeIdParam = switch registryEntry {
+  | Some({includeIdParam}) => includeIdParam
+  | None => true
+  }
+  let connectionSpec = switch registryEntry {
+  | Some({connectionSpec}) => connectionSpec
+  | None => true
+  }
+  let fieldNameForAll = switch registryEntry {
+  | Some({listFieldName}) => listFieldName
+  | None => name ++ "s"
+  }
+  let labelField = switch registryEntry {
+  | Some({labelField: ?lf}) => lf->Option.getOr("id")
+  | None => "id"
+  }
+  let returnTypeName = switch registryEntry {
+  | Some({returnTypeName: rt}) => rt
+  | None => name
+  }
+
+  // Register the binding info the shared Lambda's env config needs (the entry
+  // point gets indexes/subIdField/schema from the spec module; labelField and
+  // includeIdParam come from this deploy-time registry). Keyed by spec name.
+  PgQueryResolver_Builder.register({readModelName: name, labelField, includeIdParam})
+
+  // Relay node type → this read model (for the shared node(id) resolver, B3.2c).
+  // Only entities addressable by id participate in node resolution.
+  if includeIdParam {
+    PgQueryResolver_Builder.registerNodeType(~typeName=returnTypeName, ~readModelName=name)
+  }
+
+  let mkResolver = (~resolverName, ~field, ~kind, ~index=?) =>
+    Resolver.makeUnitJsResolver(
+      ~name=resolverName,
+      ~api,
+      ~dataSourceName,
+      ~type_="Query"->Pulumi.Input.make,
+      ~field=field->Pulumi.Input.make,
+      ~code=invokeTemplate(~readModelName=name, ~kind, ~index?),
+      ~opts,
+    )
+
+  let stripLeadingBy = s =>
+    if s->String.startsWith("by") && s->String.length > 2 {
+      s->String.slice(~start=2, ~end=s->String.length)
+    } else {
+      s
+    }
+
+  // Resolvers are deferred into resourcesMaker (created inside the schema-pushed
+  // builderOutputs.apply, like the AppSync path) — so they only exist after the
+  // fields are ACTIVE and after PgQueryResolver_Builder.provision has resolved
+  // the shared data source name.
+  let resourcesMaker: ReventlessCore.QueryDb.resolversResourcesMaker = _allQueryDbs => {
+    // getById (or listAll when the read model has no id param, e.g. singletons).
+    let byId = mkResolver(
+      ~resolverName=fieldNameForSingle->String.capitalize,
+      ~field=fieldNameForSingle,
+      ~kind=includeIdParam ? "getById" : "list",
+    )
+
+    // Main list — Relay connection (or legacy list when connectionSpec=false).
+    let all = mkResolver(
+      ~resolverName=fieldNameForAll->String.capitalize,
+      ~field=fieldNameForAll,
+      ~kind=connectionSpec ? "list" : "list",
+    )
+
+    // Sub-id connection — {single}Items(id, filter, …); only when subId configured.
+    let items = switch subIdField {
+    | Some(_) => [
+        mkResolver(
+          ~resolverName=fieldNameForSingle->String.capitalize ++ "Items",
+          ~field=fieldNameForSingle ++ "Items",
+          ~kind="items",
+        ),
+      ]
+    | None => []
+    }
+
+    // Batched-by-ids — single-key projections only (mirrors the SDL).
+    let byIds = if includeIdParam && subIdField === None {
+      let byIdsField = fieldNameForAll ++ "ByIds"
+      [
+        mkResolver(
+          ~resolverName=byIdsField->String.capitalize,
+          ~field=byIdsField,
+          ~kind="byIds",
+        ),
+      ]
+    } else {
+      []
+    }
+
+    // Per-index equality queries: {single}By{Index}.
+    let byIndex = indexes->Array.map(({index}) => {
+      let resolverName =
+        fieldNameForSingle->String.capitalize ++ "By" ++ index->stripLeadingBy->String.capitalize
+      let field = fieldNameForSingle ++ "By" ++ index->stripLeadingBy->String.capitalize
+      mkResolver(~resolverName, ~field, ~kind="index", ~index)
+    })
+
+    // @resolves — single cross-table field resolver on this (parent) type. The
+    // target's binding key is its capitalized spec name (mirrors how the binding
+    // registry is keyed); the parent object flows via ctx.source.
+    let idResolvers = idResolverConfigs->Array.map(config => {
+      let {source: {idField, subId, resolvedField}, target} = config
+      let targetKey = target.tableName->String.capitalize
+      let (field, multi) = switch resolvedField {
+      | Single(f) => (f, false)
+      | Multi(f) => (f, true)
+      }
+      let targetFrag = switch target.idField {
+      | Index(ix) => `\n      targetIndex: '${ix}',\n      targetIndexIdField: '${ix}',`
+      | IndexWithId(ix, idf) => `\n      targetIndex: '${ix}',\n      targetIndexIdField: '${idf}',`
+      | Id => ""
+      }
+      let subIdFrag = switch subId {
+      | Field(f) => `\n      sourceSubId: { kind: 'field', name: '${f}' },`
+      | Argument(a) => `\n      sourceSubId: { kind: 'arg', name: '${a}' },`
+      | NoSubId => ""
+      }
+      let extra =
+        `\n      sourceIdField: '${idField}',\n      multi: ${multi ? "true" : "false"},` ++
+        targetFrag ++
+        subIdFrag
+      Resolver.makeUnitJsResolver(
+        ~name=name ++ field->String.capitalize,
+        ~api,
+        ~dataSourceName,
+        ~type_=name->Pulumi.Input.make,
+        ~field=field->Pulumi.Input.make,
+        ~code=invokeFieldTemplate(~sourceType=name, ~kind="resolveOne", ~target=targetKey, ~extra),
+        ~opts,
+      )
+    })
+
+    // @resolvesMany — batch cross-table field resolver (BatchGet by ids).
+    let idsResolvers = idsResolverConfigs->Array.map(config => {
+      let {source: {idsField, resolvedField}, target} = config
+      let targetKey = target.tableName->String.capitalize
+      let extra = `\n      sourceIdsField: '${idsField}',`
+      Resolver.makeUnitJsResolver(
+        ~name=name ++ resolvedField->String.capitalize,
+        ~api,
+        ~dataSourceName,
+        ~type_=name->Pulumi.Input.make,
+        ~field=resolvedField->Pulumi.Input.make,
+        ~code=invokeFieldTemplate(~sourceType=name, ~kind="resolveMany", ~target=targetKey, ~extra),
+        ~opts,
+      )
+    })
+
+    [byId, all]
+    ->Array.concat(items)
+    ->Array.concat(byIds)
+    ->Array.concat(byIndex)
+    ->Array.concat(idResolvers)
+    ->Array.concat(idsResolvers)
+    ->Array.map(Util.AppSync.toResourceNative)
+  }
+
+  {ReventlessCore.QueryDb_Adapter.resources: [], resourcesMaker}
+}