@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res

@@ -0,0 +1,434 @@
+open PulumiAws.AppSync
+// Shadow PulumiAws.AppSync.Resolver with the retrying dynamic-provider adapter
+// so resolver creation calls the AppSync SDK directly and retries
+// `NotFoundException: No field named X` (the schema-propagation race) with
+// exponential backoff. Replaces AppSync_Resolver_Native (aws-native provider)
+// which exhibited the same race in production.
+// See docs/plans/appsync-resolver-aws-native-retry.md.
+module Resolver = AppSync_Resolver_Retrying
+open Reventless.ReadModel
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type api = Types.AppSync.api
+type role = Types.AppSync.role
+
+type interceptorConfig = {
+  dataSourceName: Pulumi.Input.t<string>,
+}
+
+/** Deploy-time config for the query interceptor. When set, all top-level Query
+    resolvers become pipeline resolvers with an interceptor Lambda function
+    preceding the DynamoDB query. Set this before calling `make`. */
+let queryInterceptorConfig: ref<option<interceptorConfig>> = ref(None)
+
+let interceptorCode = readModelName =>
+  `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  const isCognito = id != null && id.sub != null;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '${readModelName}',
+      arguments: ctx.args,
+      identity: isCognito
+        ? {
+            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
+    }
+  };
+}
+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: role,
+  ~dataSourceName,
+  ~indexes: array<indexConfig>,
+  ~subIdField,
+  ~idResolverConfigs: array<idResolverConfig>,
+  ~idsResolverConfigs: array<idsResolverConfig>,
+  // AWS path enforces authorization via `@aws_auth(cognito_groups: …)` on the
+  // SDL fields (see Stage E in docs/plans/host-ui-login-core.md). Accepted but
+  // ignored here so the in-memory and AWS resolver maker signatures stay aligned.
+  ~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)
+
+  // In plugin mode, use plugin-prefixed field names from the registry.
+  let fieldNameForSingle = switch registryEntry {
+  | Some({singleFieldName}) => singleFieldName
+  | None => name->Resolver.Functions.uncapitalize
+  }
+
+  // Resolve includeIdParam flag from registry (defaults to true for ReadModels)
+  let includeIdParam = switch registryEntry {
+  | Some({includeIdParam}) => includeIdParam
+  | None => true
+  }
+
+  // Resolve connectionSpec flag from registry (defaults to true)
+  let connectionSpec = switch registryEntry {
+  | Some({connectionSpec}) => connectionSpec
+  | None => true
+  }
+
+  // Resolve returnTypeName for Relay Node type registry
+  let returnTypeName = switch registryEntry {
+  | Some({returnTypeName: rt}) => rt
+  | None => name
+  }
+
+  // Register entity type in the Relay Node type registry for node(id: ID!) resolution
+  if includeIdParam {
+    NodeResolver_AppSync.registerNodeType(~typeName=returnTypeName, ~dataSourceName)
+  }
+
+  // Creates either a unit resolver (no interceptor) or a pipeline resolver
+  // (interceptor Lambda → DynamoDB query) depending on queryInterceptorConfig.
+  let makeQueryResolver = (~resolverName, ~field, ~code) =>
+    switch queryInterceptorConfig.contents {
+    | None =>
+      Resolver.makeUnitJsResolver(
+        ~name=resolverName,
+        ~api,
+        ~dataSourceName,
+        ~type_="Query"->Pulumi.Input.make,
+        ~field,
+        ~code,
+        ~opts,
+      )
+    | Some({dataSourceName: interceptorDsName}) =>
+      let interceptorFn = Function.makeJs(
+        ~name=resolverName ++ "Interceptor",
+        ~api,
+        ~dataSource=interceptorDsName,
+        ~code=interceptorCode(name),
+        ~opts,
+      )
+      let queryFn = Function.makeJs(
+        ~name=resolverName ++ "Query",
+        ~api,
+        ~dataSource=dataSourceName,
+        ~code,
+        ~opts,
+      )
+      Resolver.makePipelineJsResolver(
+        ~name=resolverName,
+        ~api,
+        ~type_="Query"->Pulumi.Input.make,
+        ~field,
+        ~code=Resolver.Functions.pipelinePassThrough,
+        ~functions=[interceptorFn, queryFn],
+        ~opts,
+      )
+    }
+
+  let fieldNameForAll = switch registryEntry {
+  | Some({listFieldName}) => listFieldName
+  | None => name ++ "s"
+  }
+
+  // All resolver resources are deferred into resourcesMaker so they are only
+  // created inside builderOutputs.apply(...) — which depends on schemaPushed.
+  // This prevents a race condition where AppSync resolvers are deployed before
+  // the schema push completes and the new fields are ACTIVE in AppSync.
+  let resourcesMaker: ReventlessCore.QueryDb.resolversResourcesMaker = allQueryDbs => {
+    let resolverByIdSingle = if includeIdParam {
+      makeQueryResolver(
+        ~resolverName=fieldNameForSingle->String.capitalize,
+        ~field=fieldNameForSingle->Pulumi.Input.make,
+        ~code=switch subIdField {
+        | Some(sortField) => Resolver.Functions.queryByIdSort(sortField)
+        | None => Resolver.Functions.getItemById
+        },
+      )
+    } else {
+      makeQueryResolver(
+        ~resolverName=fieldNameForSingle->String.capitalize,
+        ~field=fieldNameForSingle->Pulumi.Input.make,
+        ~code=Resolver.Functions.listAllItems,
+      )
+    }
+    let resolverByIdMultiple = if includeIdParam {
+      subIdField->Option.map(sortField =>
+        makeQueryResolver(
+          ~resolverName=fieldNameForSingle->String.capitalize ++ "Items",
+          ~field=(fieldNameForSingle ++ "Items")->Pulumi.Input.make,
+          ~code=Resolver.Functions.queryItemsWithSortConditions(sortField),
+        )
+      )
+    } else {
+      None
+    }
+    let labelField = switch registryEntry {
+    | Some({labelField: ?lf}) => lf->Option.getOr("id")
+    | None => "id"
+    }
+    // Derive server-side filter / sort capability from the registered state schema
+    // (Phase 1's deriveServerCapability). Empty arrays when the schema isn't
+    // registered or has no indexable fields — the resolver template emits the same
+    // SDL the in-memory adapter does, so the AWS Filter / OrderBy stays in lockstep
+    // with the SDL emitted by GraphQL_FragmentGenerator at runtime.
+    let stateSchemaOpt = ReventlessCore.Plugin_Helpers.stateSchemaRegistry->Dict.get(name)
+    let capability = switch stateSchemaOpt {
+    | Some(s) => ReventlessCore.GraphQL_FragmentGenerator.deriveServerCapability(s)
+    | None => ReventlessCore.GraphQL_FragmentGenerator.emptyCapability
+    }
+    let filterFieldNames = capability.filterFields->Array.map(f => f.name)
+    let rangeFieldNames =
+      capability.filterFields->Array.filterMap(f => f.range ? Some(f.name) : None)
+    let sortFieldNames = capability.sortFields
+    // Deploy-time warning when a `@scanSort` field is not also the sort key of any
+    // table or GSI — the resolver can still serve the request, but it will be a
+    // JS-runtime per-page sort over a full Scan (expensive in production).
+    switch stateSchemaOpt {
+    | Some(s) =>
+      let knownSortFields =
+        switch subIdField {
+        | Some(f) => [f]
+        | None => []
+        }->Array.concat(indexes->Array.filterMap(({subIdField: ?sf}) => sf))
+      ReventlessCore.GraphQL_FragmentGenerator.validateScanSortAlignment(
+        ~schema=s,
+        ~readModelName=name,
+        ~knownSortFields,
+      )->Array.forEach(msg => log.warn(~comp="QueryDbResolvers_AppSync", msg))
+    | None => ()
+    }
+    let resolverAll = makeQueryResolver(
+      ~resolverName=fieldNameForAll->String.capitalize,
+      ~field=fieldNameForAll->Pulumi.Input.make,
+      ~code=if connectionSpec {
+        Resolver.Functions.listAllItemsConnection(
+          ~labelField,
+          ~filterFields=filterFieldNames,
+          ~rangeFields=rangeFieldNames,
+          ~sortFields=sortFieldNames,
+        )
+      } else {
+        Resolver.Functions.listAllItems
+      },
+    )
+    let resolversByIndex = indexes->Array.map(({index} as indexConfig) => {
+      // Strip a leading "by" from the index name before capitalizing to avoid
+      // double "By" in the generated field name (e.g. index "byPlugin" → "ByPlugin",
+      // not "ByByPlugin"). Uses the plugin-prefixed fieldNameForSingle so the
+      // resolver name is properly namespaced (e.g. "schemaHistoryByPlugin", not
+      // "SchemaHistoryByByPlugin" from the raw entity name).
+      let stripLeadingBy = s =>
+        if s->String.startsWith("by") && s->String.length > 2 {
+          s->String.slice(~start=2, ~end=s->String.length)
+        } else {
+          s
+        }
+      let resolverName =
+        fieldNameForSingle->String.capitalize ++
+        "By" ++
+        (index->stripLeadingBy->String.capitalize)
+      let fieldName =
+        fieldNameForSingle ++
+        "By" ++
+        (index->stripLeadingBy->String.capitalize)
+      let idField = indexConfig.idField->Option.getOr(index)
+      switch indexConfig.authorization {
+      | None =>
+        Resolver.makeUnitJsResolver(
+          ~name=resolverName,
+          ~api,
+          ~dataSourceName,
+          ~type_="Query"->Pulumi.Input.make,
+          ~field=fieldName->Pulumi.Input.make,
+          ~code=switch indexConfig.subIdField {
+          | Some(sortField) =>
+            Resolver.Functions.queryByIndexSortFiltered(~index, ~idField, ~sortField)
+          | None => Resolver.Functions.queryByIndexFiltered(~index, ~idField)
+          },
+          ~opts,
+        )
+      | Some({tableName, group}) =>
+        let authDataSource = DataSource.makeDynamoDBDataSourceWithTableName(
+          ~name=resolverName ++ "Auth",
+          ~api,
+          ~tableName=(
+            allQueryDbs
+            ->ReventlessCore.Util.QueryDb.getLocalStorageResources(tableName)
+            ->Util.DynamoDb.findResource
+          ).name,
+          ~serviceRole=apiRole,
+          ~opts,
+        )
+        let authFunction = Function.makeJs(
+          ~name=resolverName ++ "Auth",
+          ~api,
+          ~dataSource=authDataSource.name->Pulumi.Output.asInput,
+          ~code=Resolver.Functions.authorizeIndexedAccess(~index, ~group),
+          ~opts,
+        )
+        let queryFunction = Function.makeJs(
+          ~name=resolverName,
+          ~api,
+          ~dataSource=dataSourceName,
+          ~code=Resolver.Functions.queryByIndexFiltered(~index, ~idField),
+          ~opts,
+        )
+        Resolver.makePipelineJsResolver(
+          ~name=resolverName,
+          ~api,
+          ~type_="Query"->Pulumi.Input.make,
+          ~field=fieldName->Pulumi.Input.make,
+          ~code=Resolver.Functions.pipelinePassThrough,
+          ~functions=[authFunction, queryFunction],
+          ~opts,
+        )
+      }
+    })
+
+    let storageResource = (~pluginName: option<string>, ~tableName: string) =>
+      allQueryDbs
+      ->ReventlessCore.Plugin_Helpers.getStorageResources(pluginName, tableName)
+      ->Util.DynamoDb.findResourceInOutput
+      ->ReventlessCore.Adapter.outputToResource
+
+    let generateCode = (~storageResource: ReventlessInfra.Adapter.resource, ~template) =>
+      storageResource.name
+      ->Pulumi.Output.apply(realTableName => template(realTableName))
+      ->Pulumi.Output.asInput
+
+    // Batched-by-ids field: BatchGetItem against the projection's own DDB
+    // table. Single-key tables only — matches the SDL emitted by
+    // GraphQL_FragmentGenerator (composite tables skip this field). Uses
+    // the storageResource/generateCode helpers above to interpolate the
+    // real DDB table name into the resolver code (BatchGetItem's `tables`
+    // map keys on the literal table name).
+    let resolverByIds = if includeIdParam && subIdField === None {
+      let storage = storageResource(~pluginName=None, ~tableName=name)
+      let byIdsField = fieldNameForAll ++ "ByIds"
+      Some(
+        makeQueryResolver(
+          ~resolverName=byIdsField->String.capitalize,
+          ~field=byIdsField->Pulumi.Input.make,
+          ~code=generateCode(
+            ~storageResource=storage,
+            ~template=Resolver.Functions.batchGetItemsByIds,
+          ),
+        ),
+      )
+    } else {
+      None
+    }
+
+    let idResolvers = idResolverConfigs->Array.map(config => {
+      let {
+        source: {idField: sourceIdField, subId: sourceSubId, resolvedField},
+        target: {tableName, idField: targetId} as target,
+      }: idResolverConfig = config
+      let (index, targetIdField) = switch targetId {
+      | Index(index) => (index, index)
+      | IndexWithId(index, targetIdField) => (index, targetIdField)
+      | _ => ("", "")
+      }
+      let storageResource = storageResource(~pluginName=target.pluginName, ~tableName)
+      switch resolvedField {
+      | Single(field)
+      | Multi(field) =>
+        let dataSourceName =
+          DataSource.makeDynamoDBDataSourceWithTableName(
+            ~name=name ++ (field->String.capitalize ++ "Resolver"),
+            ~api,
+            ~tableName=storageResource.name,
+            ~serviceRole=apiRole,
+            ~opts,
+          ).name->Pulumi.Output.asInput
+
+        Resolver.makeUnitJsResolver(
+          ~name=name ++ field->String.capitalize,
+          ~api,
+          ~dataSourceName,
+          ~type_=name->Pulumi.Input.make,
+          ~field=field->Pulumi.Input.make,
+          ~code=switch (targetId, sourceSubId, target.subIdField) {
+          | (Id, Field(sourceSortField), Some(targetSortField)) =>
+            Resolver.Functions.resolveIdSort(~sourceIdField, ~sourceSortField, ~targetSortField)
+          | (Id, Argument(sourceSortArgument), Some(targetSortField)) =>
+            Resolver.Functions.resolveIdSortArgument(
+              ~sourceIdField,
+              ~sourceSortArgument,
+              ~targetSortField,
+            )
+          | (Id, _, _) => Resolver.Functions.resolveId(~sourceIdField)
+
+          | (_, Field(sourceSortField), Some(targetSortField)) =>
+            Resolver.Functions.resolveIdByIndexSort(
+              ~index,
+              ~sourceIdField,
+              ~targetIdField,
+              ~sourceSortField,
+              ~targetSortField,
+            )
+          | (_, Argument(sourceSortArgument), Some(targetSortField)) =>
+            Resolver.Functions.resolveIdByIndexSortArgument(
+              ~index,
+              ~sourceIdField,
+              ~targetIdField,
+              ~sourceSortArgument,
+              ~targetSortField,
+            )
+          | _ => Resolver.Functions.resolveIdByIndex(~index, ~sourceIdField, ~targetIdField)
+          },
+          ~opts,
+        )
+      }
+    })
+
+    let idsResolvers = idsResolverConfigs->Array.map(config => {
+      let {source: {idsField, resolvedField}, target: {tableName} as target} = config
+      let storageResource = storageResource(~pluginName=target.pluginName, ~tableName)
+
+      Resolver.makeUnitJsResolver(
+        ~name=name ++ idsField->String.capitalize,
+        ~api,
+        ~dataSourceName,
+        ~type_=name->Pulumi.Input.make,
+        ~field=resolvedField->Pulumi.Input.make,
+        ~code=generateCode(
+          ~storageResource,
+          ~template=Resolver.Functions.resolveIds(~idsField, ~sortField=target.subIdField, ...),
+        ),
+        ~opts,
+      )
+    })
+
+    let mainResolvers = switch (resolverByIdMultiple, resolverByIds) {
+    | (Some(r), Some(byIds)) => [resolverByIdSingle, r, resolverAll, byIds]
+    | (Some(r), None) => [resolverByIdSingle, r, resolverAll]
+    | (None, Some(byIds)) => [resolverByIdSingle, resolverAll, byIds]
+    | (None, None) => [resolverByIdSingle, resolverAll]
+    }
+    Array.flat([mainResolvers, resolversByIndex, idResolvers, idsResolvers])
+    ->Array.map(Util.AppSync.toResourceNative)
+  }
+
+  {resources: [], resourcesMaker}
+}

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

@@ -0,0 +1,243 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Adapter.res.mjs";
+import * as AppSync_Function$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Function.res.mjs";
+import * as Util_AppSync$ReventlessAws from "../../util/Util_AppSync.res.mjs";
+import * as Util_DynamoDb$ReventlessAws from "../../util/Util_DynamoDb.res.mjs";
+import * as Util_QueryDb$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_QueryDb.res.mjs";
+import * as AppSync_DataSource$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_DataSource.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as NodeResolver_AppSync$ReventlessAws from "./NodeResolver_AppSync.res.mjs";
+import * as AppSync_Resolver_Functions$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver_Functions.res.mjs";
+import * as AppSync_Resolver_Retrying$ReventlessAws from "../Api/AppSync_Resolver_Retrying.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let queryInterceptorConfig = {
+  contents: undefined
+};
+
+function interceptorCode(readModelName) {
+  return `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  const isCognito = id != null && id.sub != null;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '` + readModelName + `',
+      arguments: ctx.args,
+      identity: isCognito
+        ? {
+            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
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`;
+}
+
+function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, param, 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 connectionSpec = registryEntry !== undefined ? registryEntry.connectionSpec : true;
+  let returnTypeName = registryEntry !== undefined ? registryEntry.returnTypeName : name$1;
+  if (includeIdParam) {
+    NodeResolver_AppSync$ReventlessAws.registerNodeType(returnTypeName, dataSourceName);
+  }
+  let makeQueryResolver = (resolverName, field, code) => {
+    let match = queryInterceptorConfig.contents;
+    if (match === undefined) {
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(resolverName, api, dataSourceName, "Query", field, code, opts);
+    }
+    let interceptorFn = AppSync_Function$PulumiAws.makeJs(resolverName + "Interceptor", api, match.dataSourceName, interceptorCode(name$1), opts);
+    let queryFn = AppSync_Function$PulumiAws.makeJs(resolverName + "Query", api, dataSourceName, code, opts);
+    return AppSync_Resolver_Retrying$ReventlessAws.makePipelineJsResolver(resolverName, api, "Query", field, AppSync_Resolver_Functions$PulumiAws.pipelinePassThrough, [
+      interceptorFn,
+      queryFn
+    ], opts);
+  };
+  let fieldNameForAll = registryEntry !== undefined ? registryEntry.listFieldName : name$1 + "s";
+  let resourcesMaker = allQueryDbs => {
+    let resolverByIdSingle = includeIdParam ? makeQueryResolver(Stdlib_String.capitalize(fieldNameForSingle), fieldNameForSingle, subIdField !== undefined ? AppSync_Resolver_Functions$PulumiAws.queryByIdSort(subIdField) : AppSync_Resolver_Functions$PulumiAws.getItemById) : makeQueryResolver(Stdlib_String.capitalize(fieldNameForSingle), fieldNameForSingle, AppSync_Resolver_Functions$PulumiAws.listAllItems);
+    let resolverByIdMultiple = includeIdParam ? Stdlib_Option.map(subIdField, sortField => makeQueryResolver(Stdlib_String.capitalize(fieldNameForSingle) + "Items", fieldNameForSingle + "Items", AppSync_Resolver_Functions$PulumiAws.queryItemsWithSortConditions(sortField))) : undefined;
+    let labelField = registryEntry !== undefined ? Stdlib_Option.getOr(registryEntry.labelField, "id") : "id";
+    let stateSchemaOpt = Plugin_Helpers$ReventlessCore.stateSchemaRegistry[name$1];
+    let capability = stateSchemaOpt !== undefined ? GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability(stateSchemaOpt) : GraphQL_FragmentGenerator$ReventlessCore.emptyCapability;
+    let filterFieldNames = capability.filterFields.map(f => f.name);
+    let rangeFieldNames = Stdlib_Array.filterMap(capability.filterFields, f => {
+      if (f.range) {
+        return f.name;
+      }
+    });
+    let sortFieldNames = capability.sortFields;
+    if (stateSchemaOpt !== undefined) {
+      let knownSortFields = (
+        subIdField !== undefined ? [subIdField] : []
+      ).concat(Stdlib_Array.filterMap(indexes, param => param.subIdField));
+      GraphQL_FragmentGenerator$ReventlessCore.validateScanSortAlignment(stateSchemaOpt, name$1, knownSortFields).forEach(msg => log.warn("QueryDbResolvers_AppSync", undefined, msg));
+    }
+    let resolverAll = makeQueryResolver(Stdlib_String.capitalize(fieldNameForAll), fieldNameForAll, connectionSpec ? AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection(labelField, filterFieldNames, rangeFieldNames, sortFieldNames) : AppSync_Resolver_Functions$PulumiAws.listAllItems);
+    let resolversByIndex = indexes.map(indexConfig => {
+      let index = indexConfig.index;
+      let stripLeadingBy = s => {
+        if (s.startsWith("by") && s.length > 2) {
+          return s.slice(2, s.length);
+        } else {
+          return s;
+        }
+      };
+      let resolverName = Stdlib_String.capitalize(fieldNameForSingle) + "By" + Stdlib_String.capitalize(stripLeadingBy(index));
+      let fieldName = fieldNameForSingle + "By" + Stdlib_String.capitalize(stripLeadingBy(index));
+      let idField = Stdlib_Option.getOr(indexConfig.idField, index);
+      let match = indexConfig.authorization;
+      if (match !== undefined) {
+        let authDataSource = AppSync_DataSource$PulumiAws.makeDynamoDBDataSourceWithTableName(resolverName + "Auth", api, Util_DynamoDb$ReventlessAws.findResource(Util_QueryDb$ReventlessCore.getLocalStorageResources(allQueryDbs, match.tableName)).name, apiRole, opts);
+        let authFunction = AppSync_Function$PulumiAws.makeJs(resolverName + "Auth", api, authDataSource.name, AppSync_Resolver_Functions$PulumiAws.authorizeIndexedAccess(index, match.group), opts);
+        let queryFunction = AppSync_Function$PulumiAws.makeJs(resolverName, api, dataSourceName, AppSync_Resolver_Functions$PulumiAws.queryByIndexFiltered(index, idField), opts);
+        return AppSync_Resolver_Retrying$ReventlessAws.makePipelineJsResolver(resolverName, api, "Query", fieldName, AppSync_Resolver_Functions$PulumiAws.pipelinePassThrough, [
+          authFunction,
+          queryFunction
+        ], opts);
+      }
+      let sortField = indexConfig.subIdField;
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(resolverName, api, dataSourceName, "Query", fieldName, sortField !== undefined ? AppSync_Resolver_Functions$PulumiAws.queryByIndexSortFiltered(index, idField, sortField) : AppSync_Resolver_Functions$PulumiAws.queryByIndexFiltered(index, idField), opts);
+    });
+    let storageResource = (pluginName, tableName) => Adapter$ReventlessCore.outputToResource(Util_DynamoDb$ReventlessAws.findResourceInOutput(Plugin_Helpers$ReventlessCore.getStorageResources(allQueryDbs, pluginName, tableName)));
+    let generateCode = (storageResource, template) => storageResource.name.apply(realTableName => template(realTableName));
+    let resolverByIds;
+    if (includeIdParam && subIdField === undefined) {
+      let storage = storageResource(undefined, name$1);
+      let byIdsField = fieldNameForAll + "ByIds";
+      resolverByIds = makeQueryResolver(Stdlib_String.capitalize(byIdsField), byIdsField, generateCode(storage, AppSync_Resolver_Functions$PulumiAws.batchGetItemsByIds));
+    } else {
+      resolverByIds = undefined;
+    }
+    let idResolvers = idResolverConfigs.map(config => {
+      let target = config.target;
+      let targetId = target.idField;
+      let match = config.source;
+      let sourceSubId = match.subId;
+      let sourceIdField = match.idField;
+      let match$1;
+      if (typeof targetId !== "object") {
+        match$1 = [
+          "",
+          ""
+        ];
+      } else if (targetId.TAG === "Index") {
+        let index = targetId._0;
+        match$1 = [
+          index,
+          index
+        ];
+      } else {
+        match$1 = [
+          targetId._0,
+          targetId._1
+        ];
+      }
+      let targetIdField = match$1[1];
+      let index$1 = match$1[0];
+      let storageResource$1 = storageResource(target.pluginName, target.tableName);
+      let field = match.resolvedField._0;
+      let dataSourceName = AppSync_DataSource$PulumiAws.makeDynamoDBDataSourceWithTableName(name$1 + (Stdlib_String.capitalize(field) + "Resolver"), api, storageResource$1.name, apiRole, opts).name;
+      let match$2 = target.subIdField;
+      let tmp;
+      let exit = 0;
+      if (typeof targetId !== "object") {
+        tmp = typeof sourceSubId !== "object" ? AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField) : (
+            sourceSubId.TAG === "Field" ? (
+                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdSort(sourceIdField, sourceSubId._0, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField)
+              ) : (
+                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdSortArgument(sourceIdField, sourceSubId._0, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField)
+              )
+          );
+      } else {
+        exit = 1;
+      }
+      if (exit === 1) {
+        tmp = typeof sourceSubId !== "object" ? AppSync_Resolver_Functions$PulumiAws.resolveIdByIndex(index$1, sourceIdField, targetIdField) : (
+            sourceSubId.TAG === "Field" ? (
+                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdByIndexSort(index$1, sourceIdField, sourceSubId._0, targetIdField, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveIdByIndex(index$1, sourceIdField, targetIdField)
+              ) : (
+                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdByIndexSortArgument(index$1, sourceIdField, sourceSubId._0, targetIdField, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveIdByIndex(index$1, sourceIdField, targetIdField)
+              )
+          );
+      }
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(field), api, dataSourceName, name$1, field, tmp, opts);
+    });
+    let idsResolvers = idsResolverConfigs.map(config => {
+      let target = config.target;
+      let match = config.source;
+      let idsField = match.idsField;
+      let storageResource$1 = storageResource(target.pluginName, target.tableName);
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(idsField), api, dataSourceName, name$1, match.resolvedField, generateCode(storageResource$1, none => AppSync_Resolver_Functions$PulumiAws.resolveIds(none, idsField, target.subIdField)), opts);
+    });
+    let mainResolvers = resolverByIdMultiple !== undefined ? (
+        resolverByIds !== undefined ? [
+            resolverByIdSingle,
+            resolverByIdMultiple,
+            resolverAll,
+            resolverByIds
+          ] : [
+            resolverByIdSingle,
+            resolverByIdMultiple,
+            resolverAll
+          ]
+      ) : (
+        resolverByIds !== undefined ? [
+            resolverByIdSingle,
+            resolverAll,
+            resolverByIds
+          ] : [
+            resolverByIdSingle,
+            resolverAll
+          ]
+      );
+    return [
+      mainResolvers,
+      resolversByIndex,
+      idResolvers,
+      idsResolvers
+    ].flat().map(Util_AppSync$ReventlessAws.toResourceNative);
+  };
+  return {
+    resources: [],
+    resourcesMaker: resourcesMaker
+  };
+}
+
+let Resolver;
+
+export {
+  Resolver,
+  log,
+  queryInterceptorConfig,
+  interceptorCode,
+  make,
+}
+/* log Not a pure module */