cdk-serverless 3.4.0 → 3.5.1

package/lib/constructs/graphql.d.ts

@@ -27,10 +27,15 @@ export interface GraphQlApiProps extends BaseApiProps {
      * response handler converts the errors.appsync.* envelope returned by
      * createAppSyncHandler into a typed GraphQL error.
      *
+     * Untyped errors still fail the invocation, and the pipeline function raises
+     * them as GraphQL errors with AppSync's invoke error type (e.g.
+     * `Lambda:Unhandled`), as a UNIT direct-Lambda resolver does.
+     *
      * When false (the default), addLambdaResolver synthesizes a plain UNIT
-     * direct-Lambda resolver (the pre-#385 behavior) with no response handler. On
-     * that path, if a handler throws an AppSyncError the sentinel envelope is
-     * returned as field data instead of becoming a GraphQL error.
+     * direct-Lambda resolver (the pre-#385 behavior) with no response handler.
+     * The Lambda gets no APPSYNC_TYPED_ERRORS flag, so createAppSyncHandler
+     * rethrows an AppSyncError and AppSync reports it as `Lambda:Unhandled`
+     * without the typed errorType and errorInfo.
      *
      * This flag applies to ALL Lambda resolvers on the API. Enabling it changes
      * the resolver topology from UNIT to PIPELINE, which produces a cdk diff for
@@ -40,6 +45,28 @@ export interface GraphQlApiProps extends BaseApiProps {
      */
     typedErrors?: boolean;
 }
+export interface LambdaResolverOptions {
+    /**
+     * If set, addLambdaResolver wires an AppSync BatchInvoke resolver instead of a
+     * single invoke. The generated UNIT resolver gets MaxBatchSize set to this
+     * value, a BatchInvoke request template
+     * (MappingTemplate.lambdaRequest('$utils.toJson($context)', 'BatchInvoke')) and
+     * a MappingTemplate.lambdaResult() response template, so AppSync groups up to
+     * this many field invocations into one Lambda call. Pair this with
+     * createAppSyncBatchHandler, whose handler receives the batched events.
+     *
+     * When both maxBatchSize and `typedErrors` are set, maxBatchSize wins for this
+     * field. The field gets the UNIT BatchInvoke resolver rather than the
+     * typedErrors APPSYNC_JS pipeline, because the BatchInvoke mapping templates
+     * have no equivalent on that pipeline. Typed errors thrown by a batch handler
+     * are not converted to GraphQL errors. They rethrow and fail the invocation,
+     * so a batch handler should not rely on the typed-error-to-GraphQL-error
+     * conversion.
+     *
+     * @default - undefined (single invoke, the pre-batch behaviour; no MaxBatchSize and no mapping templates)
+     */
+    readonly maxBatchSize?: number;
+}
 export interface VtlResolverOptions {
     /**
      * The datasource the VTL resolver targets
@@ -139,7 +166,7 @@ export declare class GraphQlApi<RESOLVERS> extends BaseApi {
      * getFunctionForOperation
      */
     getFunctionForOperation<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(typeName: TYPE, fieldName: keyof FIELDTYPE): LambdaFunction;
-    addLambdaResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(typeName: TYPE, fieldName: keyof FIELDTYPE): LambdaFunction;
+    addLambdaResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(typeName: TYPE, fieldName: keyof FIELDTYPE, options?: LambdaResolverOptions): LambdaFunction;
     addDynamoDbVtlResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(typeName: TYPE, fieldName: keyof FIELDTYPE, options?: Omit<VtlResolverOptions, 'dataSource'>): void;
     addDynamoDbJSResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(typeName: TYPE, fieldName: keyof FIELDTYPE, options?: JsResolverOptions): void;
     addJSResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(typeName: TYPE, fieldName: keyof FIELDTYPE, dataSource: aws_appsync.BaseDataSource, options?: JsResolverOptions): void;

package/lib/constructs/graphql.js

@@ -218,7 +218,8 @@ class GraphQlApi extends base_api_1.BaseApi {
     getFunctionForOperation(typeName, fieldName) {
         return this._functions[`${typeName}.${fieldName}`];
     }
-    addLambdaResolver(typeName, fieldName) {
+    addLambdaResolver(typeName, fieldName, options) {
+        const isBatch = options?.maxBatchSize !== undefined;
         const operationId = `${typeName}.${fieldName}`;
         const description = `Type ${typeName} Field ${fieldName} Resolver`;
         const entryFile = `./src/lambda/${operationId}.ts`;
@@ -259,6 +260,29 @@ class GraphQlApi extends base_api_1.BaseApi {
             name: `Lambda_${typeName}_${fieldName}`,
             lambdaFunction: fn,
         });
+        if (isBatch) {
+            // A batch field always takes the UNIT BatchInvoke path, even when the API
+            // has typedErrors enabled. maxBatchSize wins over typedErrors for this
+            // field because the BatchInvoke mapping templates have no equivalent on
+            // the APPSYNC_JS pipeline resolver. AppSync batches up to maxBatchSize
+            // field invocations into a single Lambda call handled by
+            // createAppSyncBatchHandler. The L2 BaseResolverProps.maxBatchSize sets
+            // MaxBatchSize directly, so no escape hatch is needed.
+            //
+            // APPSYNC_TYPED_ERRORS is intentionally not set here. A batch handler that
+            // throws a typed error rethrows and fails the invocation loudly instead of
+            // having the error envelope returned as field data.
+            new aws_cdk_lib_1.aws_appsync.Resolver(scope, `Resolver${operationId}`, {
+                api: this.api,
+                typeName: typeName,
+                fieldName: fieldName,
+                dataSource,
+                maxBatchSize: options.maxBatchSize,
+                requestMappingTemplate: aws_cdk_lib_1.aws_appsync.MappingTemplate.lambdaRequest('$utils.toJson($context)', 'BatchInvoke'),
+                responseMappingTemplate: aws_cdk_lib_1.aws_appsync.MappingTemplate.lambdaResult(),
+            });
+            return fn;
+        }
         if (!this.props.typedErrors) {
             // Default (pre-#385) shape: a plain UNIT resolver with the Lambda data
             // source set directly. No response handler, so the error envelope from
@@ -300,9 +324,16 @@ export function request(ctx) {
   };
 }
 
-// Pass the Lambda result through unchanged; the resolver response handler
-// converts the error envelope into a GraphQL error.
+// A failed invoke (an untyped error rethrown by createAppSyncHandler, a timeout,
+// a missing permission) lands in this function's ctx.error. AppSync drops it
+// unless this handler raises it, and the field would resolve to null with no
+// GraphQL error. Raise it with the same message and type a UNIT direct-Lambda
+// resolver reports. Otherwise pass the result through; the resolver response
+// handler converts the typed error envelope into a GraphQL error.
 export function response(ctx) {
+  if (ctx.error) {
+    util.error(ctx.error.message, ctx.error.type);
+  }
   return ctx.result;
 }
 `),
@@ -328,11 +359,10 @@ export function request(ctx) {
 // createAppSyncHandler stamps. Branching on the sentinel (not on a bare
 // errorMessage) means a legitimate result that merely has an errorMessage field
 // is returned unchanged instead of being misread as a typed error.
+//
+// Invoke-level errors are raised by the pipeline function itself: an error left
+// in a function's ctx.error never reaches this handler's ctx.error.
 export function response(ctx) {
-  if (ctx.error) {
-    util.appendError(ctx.error.message, ctx.error.type, ctx.result);
-    return ctx.result;
-  }
   const result = ctx.prev.result;
   if (result && result.__appSyncError) {
     util.error(result.errorMessage, result.errorType, null, result.errorInfo);
@@ -565,4 +595,4 @@ function exec(cmd, args, options) {
     }
     return proc;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphql.js","sourceRoot":"","sources":["../../src/constructs/graphql.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport { SpawnSyncOptions, spawnSync } from 'child_process';\nimport * as fs from 'node:fs';\nimport * as os from 'node:os';\nimport { AssetHashType, BundlingOptions, BundlingOutput, CfnOutput, DockerImage, NestedStack, Tags, aws_appsync, aws_certificatemanager, aws_iam, aws_logs, aws_route53 } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { CognitoAuthentication } from './authentication';\nimport { BaseApi, BaseApiProps } from './base-api';\nimport { LambdaFunction } from './func';\nimport { CFN_OUTPUT_SUFFIX_GRAPHQL_DOMAINNAME } from '../shared/outputs';\n\nexport interface GraphQlApiProps extends BaseApiProps {\n  definitionFileName: string;\n\n  /**\n   * If true, resolvers and Lambda functions will be created in nested stacks\n   * grouped by type (Query, Mutation, Subscription, Field).\n   *\n   * WARNING: Only enable this if you are approaching or hitting CloudFormation's\n   * 500 resource limit. Nested stacks have significant downsides:\n   * - Slower deployments due to additional stack operations\n   * - More complex debugging and error tracing\n   * - Harder to navigate in the CloudFormation console\n   * - Cross-stack references add complexity\n   *\n   * WARNING: Changing this setting on an existing stack requires manual intervention.\n   * CloudFormation cannot automatically move resources between stacks. You may need\n   * to delete and recreate resolvers, or perform a two-step deployment.\n   *\n   * @default false\n   */\n  useNestedStacks?: boolean;\n\n  /**\n   * If true, addLambdaResolver synthesizes an APPSYNC_JS pipeline resolver whose\n   * response handler converts the errors.appsync.* envelope returned by\n   * createAppSyncHandler into a typed GraphQL error.\n   *\n   * When false (the default), addLambdaResolver synthesizes a plain UNIT\n   * direct-Lambda resolver (the pre-#385 behavior) with no response handler. On\n   * that path, if a handler throws an AppSyncError the sentinel envelope is\n   * returned as field data instead of becoming a GraphQL error.\n   *\n   * This flag applies to ALL Lambda resolvers on the API. Enabling it changes\n   * the resolver topology from UNIT to PIPELINE, which produces a cdk diff for\n   * every Lambda resolver, so opt in deliberately.\n   *\n   * @default false\n   */\n  typedErrors?: boolean;\n}\n\nexport interface VtlResolverOptions {\n  /**\n   * The datasource the VTL resolver targets\n   */\n  dataSource: aws_appsync.BaseDataSource;\n\n  /**\n   * string replacements to process on the VTL\n   *\n   * @default no variable expansions\n   */\n  variables?: { [name: string]: string };\n}\n\nexport interface JsResolverOptions {\n  /**\n   * Variables that will be put into the \"stash\" of the resolver pipeline\n   *\n   * @default none\n   */\n  readonly stashValues?: { [key: string]: string };\n\n  /**\n   * name of the pipeline steps to create\n   *\n   * @default - only a default step will be created\n   */\n  readonly pipelineStepNames?: string[];\n}\n\ninterface JsResolverConfig {\n  name: string;\n  index: number;\n  stepCount: number;\n  entryFile: string;\n  functionId: string;\n}\n\n/**\n * The GraphQlApi construct sets up an AWS AppSync GraphQL API integrated with Cognito for authentication and DynamoDB for data storage.\n * This construct facilitates the creation of a GraphQL API with various configurations, including custom domain, logging, schema definition,\n * and authorization using Cognito User Pool and Identity Pool. It also provides methods to dynamically add resolvers and grant access to specific fields.\n *\n * @template RESOLVERS - The type definition for the GraphQL resolvers.\n *\n * @example\n * const api = new GraphQlApi(this, 'MyGraphQlApi', {\n *   apiName: 'MyAPI',\n *   stageName: 'dev',\n *   definitionFileName: 'schema.graphql',\n *   authentication: myCognitoAuth,\n *   singleTableDatastore: myDynamoDBTable,\n * });\n *\n * // Add a Lambda resolver\n * api.addLambdaResolver('Query', 'getItem');\n *\n * // Grant access to unauthenticated users for a specific query\n * api.grantAccessUnAuth('Query', 'getItem');\n */\nexport class GraphQlApi<RESOLVERS> extends BaseApi {\n\n  /**\n   * The AWS AppSync GraphQL API instance.\n   */\n  public readonly api: aws_appsync.GraphqlApi;\n\n  /**\n   * The optional DynamoDB data source for the GraphQL API.\n   */\n  public readonly tableDataSource?: aws_appsync.DynamoDbDataSource;\n\n  /**\n   * A collection of Lambda functions used as resolvers for the GraphQL API.\n   */\n  private _functions: { [operationId: string]: LambdaFunction } = {};\n\n  /**\n   * Nested stacks for resolvers, grouped by type name.\n   * Only used when useNestedStacks is true.\n   */\n  private readonly nestedStacks: { [typeName: string]: NestedStack } = {};\n\n  /**\n   * The Cognito authentication configuration.\n   */\n  private readonly cognitoAuth: CognitoAuthentication;\n\n  /**\n   * Creates an instance of GraphQlApi.\n   *\n   * @param scope - The scope in which this construct is defined.\n   * @param id - The scoped construct ID.\n   * @param props - The properties of the GraphQlApi construct.\n   */\n  constructor(scope: Construct, id: string, private readonly props: GraphQlApiProps) {\n    super(scope, id, props);\n\n    this.cognitoAuth = props.authentication as CognitoAuthentication;\n\n    let customDomainName: aws_appsync.DomainOptions | undefined;\n    if (this.apiFQDN) {\n      customDomainName = {\n        domainName: this.apiFQDN,\n        certificate: new aws_certificatemanager.DnsValidatedCertificate(this, 'Cert', {\n          hostedZone: this.hostedZone!,\n          region: 'us-east-1',\n          domainName: this.apiFQDN,\n          validation: aws_certificatemanager.CertificateValidation.fromDns(this.hostedZone),\n        }),\n      };\n      new CfnOutput(this, 'GraphQlApiDomainName', {\n        key: `${this.props.apiName}${CFN_OUTPUT_SUFFIX_GRAPHQL_DOMAINNAME}`,\n        value: this.apiFQDN,\n      });\n    }\n\n    this.api = new aws_appsync.GraphqlApi(this, 'Resource', {\n      name: `${props.apiName} [${props.stageName}]`,\n      logConfig: {\n        fieldLogLevel: aws_appsync.FieldLogLevel.ALL,\n        retention: aws_logs.RetentionDays.TWO_MONTHS,\n      },\n      schema: aws_appsync.SchemaFile.fromAsset(props.definitionFileName),\n      domainName: customDomainName,\n      ...this.cognitoAuth && {\n        authorizationConfig: {\n          additionalAuthorizationModes: [\n            {\n              authorizationType: aws_appsync.AuthorizationType.USER_POOL,\n              userPoolConfig: {\n                userPool: this.cognitoAuth.userpool,\n                defaultAction: aws_appsync.UserPoolDefaultAction.DENY,\n              },\n            },\n            ...this.cognitoAuth.identityPool ? [{ authorizationType: aws_appsync.AuthorizationType.IAM }] : [],\n          ],\n        },\n      },\n    });\n    if (customDomainName && this.api.appSyncDomainName) {\n      new aws_route53.CnameRecord(this, 'DnsRecord', {\n        zone: this.hostedZone!,\n        recordName: customDomainName.domainName,\n        domainName: this.api.appSyncDomainName,\n      });\n    }\n\n    // if ((props.monitoring ?? true) && this.monitoring) {\n    //   this.monitoring.apiErrorsWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: '5XXError',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'sum',\n    //   }));\n    //   this.monitoring.apiErrorsWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: '4XXError',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'sum',\n    //   }));\n    //   this.monitoring.apiLatencyWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'Average',\n    //   }));\n    //   this.monitoring.apiLatencyWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'p90',\n    //   }));\n    //   this.monitoring.apiLatencyTailWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'p95',\n    //   }));\n    //   this.monitoring.apiLatencyTailWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'p99',\n    //   }));\n    // }\n\n    if (props.singleTableDatastore) {\n      this.tableDataSource = new aws_appsync.DynamoDbDataSource(this, 'SingleTableSource', {\n        api: this.api,\n        table: props.singleTableDatastore?.table,\n      });\n    }\n  }\n\n  /**\n   *\n   */\n  public grantAccess<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    grantee: aws_iam.IGrantable,\n    typeName: TYPE,\n    ...fieldNames: (keyof FIELDTYPE)[]): void {\n    this.api.grant(grantee, aws_appsync.IamResource.ofType(typeName as string, ...fieldNames as string[]), 'appsync:GraphQL');\n  }\n\n  /**\n   *\n   */\n  public grantAccessUnAuth<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    ...fieldNames: (keyof FIELDTYPE)[]\n  ): void {\n    if (!this.cognitoAuth.identityPool) {\n      throw new Error('Cannot grant to Cognito identity pool as none is provided');\n    }\n    this.grantAccess(this.cognitoAuth.identityPool.unauthenticatedRole, typeName, ...fieldNames);\n  }\n\n  /**\n   *\n   */\n  public grantAccessAuth<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    ...fieldNames: (keyof FIELDTYPE)[]\n  ): void {\n    if (!this.cognitoAuth.identityPool) {\n      throw new Error('Cannot grant to Cognito identity pool as none is provided');\n    }\n    this.grantAccess(this.cognitoAuth.identityPool.authenticatedRole, typeName, ...fieldNames);\n  }\n\n\n  /**\n   * getFunctionForOperation\n   */\n  public getFunctionForOperation<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n  ): LambdaFunction {\n    return this._functions[`${typeName as string}.${fieldName as String}`];\n  }\n\n  public addLambdaResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n  ): LambdaFunction {\n    const operationId = `${typeName as string}.${fieldName as String}`;\n    const description = `Type ${typeName as string} Field ${fieldName as String} Resolver`;\n\n    const entryFile = `./src/lambda/${operationId}.ts`;\n    if (!fs.existsSync(entryFile)) {\n      fs.mkdirSync('./src/lambda/', { recursive: true });\n      this.createEntryFile(entryFile, typeName as string, fieldName as string);\n    }\n\n    const scope = this.getScopeForTypeName(typeName as string);\n\n    const fn = new LambdaFunction(scope, `Fn${operationId}`, {\n      stageName: this.props.stageName,\n      additionalEnv: this.props.additionalEnv,\n      entry: entryFile,\n      description: `[${this.props.stageName}] ${description}`,\n      ...this.props.authentication && {\n        userPool: (this.props.authentication as CognitoAuthentication).userpool,\n      },\n      ...this.props.singleTableDatastore && {\n        table: this.props.singleTableDatastore.table,\n        tableWrites: typeName === 'Mutation',\n      },\n      ...this.props.assetCdn && {\n        assetDomainName: this.props.assetCdn.assetDomainName,\n        assetBucket: this.props.assetCdn.assetBucket,\n      },\n      lambdaOptions: this.props.lambdaOptions,\n      lambdaTracing: this.props.lambdaTracing,\n    });\n    this._functions[operationId] = fn;\n    Tags.of(fn).add('GraphQL', description);\n\n    // if (this.monitoring) {\n    //   this.monitoring.lambdaDurationsWidget.addLeftMetric(fn.metricDuration());\n    //   this.monitoring.lambdaInvokesWidget.addLeftMetric(fn.metricInvocations());\n    //   this.monitoring.lambdaErrorsWidget.addLeftMetric(fn.metricErrors());\n    //   this.monitoring.lambdaErrorsWidget.addLeftMetric(fn.metricThrottles());\n    // }\n\n    const dataSource = new aws_appsync.LambdaDataSource(scope, `LambdaDS${operationId}`, {\n      api: this.api,\n      name: `Lambda_${typeName as string}_${fieldName as String}`,\n      lambdaFunction: fn,\n    });\n\n    if (!this.props.typedErrors) {\n      // Default (pre-#385) shape: a plain UNIT resolver with the Lambda data\n      // source set directly. No response handler, so the error envelope from\n      // createAppSyncHandler would be surfaced as field data rather than a\n      // GraphQL error. Opt in via `typedErrors: true` to get the pipeline below.\n      new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n        api: this.api,\n        typeName: typeName as string,\n        fieldName: fieldName as string,\n        dataSource,\n      });\n      return fn;\n    }\n\n    // Couple the handler to this pipeline. createAppSyncHandler returns the\n    // error envelope only when APPSYNC_TYPED_ERRORS === 'true'; otherwise it\n    // rethrows the typed error. Inject the flag here (and only here) so the\n    // envelope behavior is active exactly on the path that has the response\n    // handler to interpret it. The default UNIT path above leaves the env var\n    // unset, so a handler that throws an AppSyncError there fails loudly.\n    fn.addEnvironment('APPSYNC_TYPED_ERRORS', 'true');\n\n    // The Lambda invoke runs as a pipeline function (a single Invoke passthrough),\n    // and the resolver's response handler interprets the error envelope that\n    // createAppSyncHandler returns. A direct-Lambda resolver without a response\n    // handler would surface the { data, errorType, errorMessage, errorInfo }\n    // envelope as plain field data, so the typed errors.appsync.* errors only\n    // become GraphQL errors because of the response handler attached below.\n    const invokeFunction = new aws_appsync.AppsyncFunction(scope, `LambdaFn${operationId}`, {\n      api: this.api,\n      name: `Lambda_${(typeName as string).replace(/[^A-Za-z0-9]/g, '')}_${(fieldName as String).replace(/[^A-Za-z0-9]/g, '')}`,\n      dataSource,\n      runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      code: aws_appsync.Code.fromInline(`import { util } from '@aws-appsync/utils';\n\n// Invoke the Lambda data source with the full resolver context as the payload.\nexport function request(ctx) {\n  return {\n    operation: 'Invoke',\n    payload: ctx,\n  };\n}\n\n// Pass the Lambda result through unchanged; the resolver response handler\n// converts the error envelope into a GraphQL error.\nexport function response(ctx) {\n  return ctx.result;\n}\n`),\n    });\n\n    new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n      api: this.api,\n      typeName: typeName as string,\n      fieldName: fieldName as string,\n      runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      pipelineConfig: [invokeFunction],\n      code: aws_appsync.Code.fromInline(`import { util } from '@aws-appsync/utils';\n\nexport function request(ctx) {\n  return {};\n}\n\n// Convert the error envelope returned by createAppSyncHandler into a GraphQL error.\n// util.error / util.appendError take (message, errorType, data, errorInfo), so\n// errorType and errorInfo reach the client. Without this, AppSync would surface\n// the envelope object as the field result instead of as a GraphQL error.\n//\n// The envelope is recognised by its reserved __appSyncError sentinel key, which\n// createAppSyncHandler stamps. Branching on the sentinel (not on a bare\n// errorMessage) means a legitimate result that merely has an errorMessage field\n// is returned unchanged instead of being misread as a typed error.\nexport function response(ctx) {\n  if (ctx.error) {\n    util.appendError(ctx.error.message, ctx.error.type, ctx.result);\n    return ctx.result;\n  }\n  const result = ctx.prev.result;\n  if (result && result.__appSyncError) {\n    util.error(result.errorMessage, result.errorType, null, result.errorInfo);\n  }\n  return result;\n}\n`),\n    });\n    return fn;\n  }\n\n  public addDynamoDbVtlResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    options?: Omit<VtlResolverOptions, 'dataSource'>): void {\n    if (!this.tableDataSource) {\n      throw new Error('DynamoDB is not initialized');\n    }\n    this.addVtlResolver(typeName, fieldName, {\n      dataSource: this.tableDataSource,\n      ...options,\n    });\n  }\n\n  public addDynamoDbJSResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    options?: JsResolverOptions): void {\n    if (!this.tableDataSource) {\n      throw new Error('DynamoDB is not initialized');\n    }\n    this.addJSResolver(typeName, fieldName, this.tableDataSource, {\n      ...options,\n      stashValues: {\n        ...options?.stashValues ?? {},\n        table: this.props.singleTableDatastore!.table.tableName,\n      },\n    });\n  }\n\n  public addJSResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    dataSource: aws_appsync.BaseDataSource, options?: JsResolverOptions): void {\n    const operationId = `${typeName as string}.${fieldName as String}`;\n    const description = `Type ${typeName as string} Field ${fieldName as String} Resolver`;\n\n    const scope = this.getScopeForTypeName(typeName as string);\n\n    const resolverDir = './src/js-resolver/';\n    const functions: JsResolverConfig[] = [];\n\n    if (!options || !options.pipelineStepNames || options.pipelineStepNames.length == 0) {\n      functions.push({\n        name: 'default',\n        index: 0,\n        stepCount: 1,\n        entryFile: `${resolverDir}/${operationId}.ts`,\n        functionId: `JSFunction${operationId}`,\n      });\n    } else {\n      functions.push(...options.pipelineStepNames.map((name, index) => ({\n        name,\n        index,\n        stepCount: options.pipelineStepNames!.length,\n        entryFile: `${resolverDir}/${operationId}.${name}.ts`,\n        functionId: `JSFunction${operationId}${name}`,\n      })));\n    }\n\n    const pipelineConfig = [];\n\n    for (const fn of functions) {\n      if (!fs.existsSync(fn.entryFile)) {\n        fs.mkdirSync(resolverDir, { recursive: true });\n        this.createJSResolverFile(fn, typeName as string, fieldName as string);\n      }\n\n      const jsFunction = new aws_appsync.AppsyncFunction(scope, fn.functionId, {\n        api: this.api,\n        name: operationId.replace(/\\./g, ''),\n        description,\n        dataSource,\n        code: aws_appsync.Code.fromAsset('.', {\n          assetHashType: AssetHashType.OUTPUT,\n          deployTime: true,\n          bundling: {\n            image: DockerImage.fromRegistry('dummy'), // Will never be used due to local bundling\n            outputType: BundlingOutput.SINGLE_FILE,\n            functionId: fn.functionId,\n            local: {\n              tryBundle(outputDir) {\n                const osPlatform = os.platform();\n                exec(\n                  osPlatform === 'win32' ? 'cmd' : 'bash',\n                  [\n                    osPlatform === 'win32' ? '/c' : '-c',\n                    `esbuild --bundle --sourcemap=inline --sources-content=false --target=esnext --platform=node --format=esm --external:@aws-appsync/utils --outdir=${outputDir} ${fn.entryFile}`,\n                  ],\n                  {\n                    env: { ...process.env },\n                    stdio: [ // show output\n                      'ignore', // ignore stdio\n                      process.stderr, // redirect stdout to stderr\n                      'inherit', // inherit stderr\n                    ],\n                    windowsVerbatimArguments: osPlatform === 'win32',\n                  });\n\n                return true;\n              },\n            },\n          } as BundlingOptions,\n        }),\n        runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      });\n      pipelineConfig.push(jsFunction);\n    }\n\n    new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n      api: this.api,\n      typeName: typeName as string,\n      fieldName: fieldName as string,\n      runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      pipelineConfig,\n      code: aws_appsync.Code.fromInline(`\n    // The before step\n    export function request(ctx) {\n      console.log(ctx);\n${Object.entries(options?.stashValues ?? []).map(val => `      ctx.stash.${val[0]} = '${val[1]}'`).join('\\n')}\n      return {}\n    }\n\n    // The after step\n    export function response(ctx) {\n      return ctx.prev.result\n    }\n  `),\n    });\n  }\n\n  public addVtlResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    options: VtlResolverOptions): void {\n    const operationId = `${typeName as string}.${fieldName as String}`;\n\n    const mappingReqFile = `./src/vtl/${operationId}.req.vtl`;\n    if (!fs.existsSync(mappingReqFile)) {\n      fs.mkdirSync('./src/vtl/', { recursive: true });\n      fs.writeFileSync(mappingReqFile, '## Request mapping', { encoding: 'utf-8' });\n    }\n    const mappingResFile = `./src/vtl/${operationId}.res.vtl`;\n    if (!fs.existsSync(mappingResFile)) {\n      fs.mkdirSync('./src/vtl/', { recursive: true });\n      fs.writeFileSync(mappingResFile, '$util.toJson($ctx.result)', { encoding: 'utf-8' });\n    }\n\n    const scope = this.getScopeForTypeName(typeName as string);\n\n    new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n      api: this.api,\n      typeName: typeName as string,\n      fieldName: fieldName as string,\n      dataSource: options.dataSource,\n      requestMappingTemplate: aws_appsync.MappingTemplate.fromString(this.substVariables(fs.readFileSync(mappingReqFile).toString('utf-8'), options.variables)),\n      responseMappingTemplate: aws_appsync.MappingTemplate.fromString(this.substVariables(fs.readFileSync(mappingResFile).toString('utf-8'), options.variables)),\n    });\n  }\n\n  /**\n   * Returns the appropriate scope for creating resources for the given type name.\n   * If useNestedStacks is enabled, returns a nested stack for the type name,\n   * creating it if it doesn't exist. Otherwise, returns this construct.\n   *\n   * Query, Mutation, and Subscription each get their own nested stack.\n   * All other types (field resolvers) share a single \"Field\" nested stack.\n   *\n   * @param typeName - The GraphQL type name (e.g., 'Query', 'Mutation', 'Subscription', or a custom type)\n   * @returns The construct to use as scope for creating resources\n   */\n  private getScopeForTypeName(typeName: string): Construct {\n    if (!this.props.useNestedStacks) {\n      return this;\n    }\n\n    const rootTypes = ['Query', 'Mutation', 'Subscription'];\n    const stackKey = rootTypes.includes(typeName) ? typeName : 'Field';\n\n    if (!this.nestedStacks[stackKey]) {\n      this.nestedStacks[stackKey] = new NestedStack(this, `${stackKey}Resolvers`, {\n        description: `Nested stack for ${stackKey} resolvers`,\n      });\n    }\n\n    return this.nestedStacks[stackKey];\n  }\n\n  private substVariables(data: string, vars: { [name: string]: string } = {}): string {\n    let res = data;\n    for (const name in vars) {\n      if (Object.prototype.hasOwnProperty.call(vars, name)) {\n        const value = vars[name];\n        res = res.replace(new RegExp(`\\\\$\\{${name}\\}`, 'g'), value);\n      }\n    }\n    return res;\n  }\n\n  private createEntryFile(entryFile: string, typeName: string, fieldName: string) {\n    const argType = `${typeName}${uppercaseFirst(fieldName)}Args`;\n    fs.writeFileSync(entryFile, `import { api } from 'cdk-serverless/lib/lambda';\nimport { ${typeName}, ${argType} } from '../generated/graphql.${this.props.apiName.toLowerCase()}-model.generated';\n\nexport const handler = api.createAppSyncHandler<${argType}, ${typeName}['${fieldName}']>(async (ctx) => {\n  ctx.logger.info(JSON.stringify(ctx.event));\n  throw new Error('Not yet implemented');\n});`, {\n      encoding: 'utf-8',\n    });\n  }\n\n  private createJSResolverFile(fn: JsResolverConfig, typeName: string, fieldName: string) {\n    const argType = `${typeName}${uppercaseFirst(fieldName)}Args`;\n    const returnType = (fn.index == (fn.stepCount - 1)) ? `${typeName}['${fieldName}']` : 'any';\n\n    fs.writeFileSync(fn.entryFile, `import { Context, util } from '@aws-appsync/utils';\nimport { ${typeName}, ${argType} } from '../generated/graphql.${this.props.apiName.toLowerCase()}-model.generated';\n\n/**\n * Request for ${typeName}.${fieldName} (Step: ${fn.name} ${fn.index + 1}/${fn.stepCount})\n */\nexport function request(ctx: Context<${argType}>): any {\n  console.log(ctx);\n  return {};\n}\n\n/**\n * Response for ${typeName}.${fieldName} (Step: ${fn.name} ${fn.index + 1}/${fn.stepCount})\n */\nexport function response(ctx: Context<${argType}>): ${returnType} {\n  console.log(ctx);\n  return ctx.result.items;\n}`, {\n      encoding: 'utf-8',\n    });\n  }\n\n}\n\nfunction uppercaseFirst(value: string): string {\n  return value.substring(0, 1).toUpperCase() + value.substring(1);\n}\n\n/**\n * Copied from https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/aws-lambda-nodejs/lib/util.ts\n * as it is not exported by aws-cdk-lib\n */\nfunction exec(cmd: string, args: string[], options?: SpawnSyncOptions) {\n  const proc = spawnSync(cmd, args, options);\n\n  if (proc.error) {\n    throw proc.error;\n  }\n\n  if (proc.status !== 0) {\n    if (proc.stdout || proc.stderr) {\n      throw new Error(`[Status ${proc.status}] stdout: ${proc.stdout?.toString().trim()}\\n\\n\\nstderr: ${proc.stderr?.toString().trim()}`);\n    }\n    throw new Error(`${cmd} ${args.join(' ')} ${options?.cwd ? `run in directory ${options.cwd}` : ''} exited with status ${proc.status}`);\n  }\n\n  return proc;\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphql.js","sourceRoot":"","sources":["../../src/constructs/graphql.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport { SpawnSyncOptions, spawnSync } from 'child_process';\nimport * as fs from 'node:fs';\nimport * as os from 'node:os';\nimport { AssetHashType, BundlingOptions, BundlingOutput, CfnOutput, DockerImage, NestedStack, Tags, aws_appsync, aws_certificatemanager, aws_iam, aws_logs, aws_route53 } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { CognitoAuthentication } from './authentication';\nimport { BaseApi, BaseApiProps } from './base-api';\nimport { LambdaFunction } from './func';\nimport { CFN_OUTPUT_SUFFIX_GRAPHQL_DOMAINNAME } from '../shared/outputs';\n\nexport interface GraphQlApiProps extends BaseApiProps {\n  definitionFileName: string;\n\n  /**\n   * If true, resolvers and Lambda functions will be created in nested stacks\n   * grouped by type (Query, Mutation, Subscription, Field).\n   *\n   * WARNING: Only enable this if you are approaching or hitting CloudFormation's\n   * 500 resource limit. Nested stacks have significant downsides:\n   * - Slower deployments due to additional stack operations\n   * - More complex debugging and error tracing\n   * - Harder to navigate in the CloudFormation console\n   * - Cross-stack references add complexity\n   *\n   * WARNING: Changing this setting on an existing stack requires manual intervention.\n   * CloudFormation cannot automatically move resources between stacks. You may need\n   * to delete and recreate resolvers, or perform a two-step deployment.\n   *\n   * @default false\n   */\n  useNestedStacks?: boolean;\n\n  /**\n   * If true, addLambdaResolver synthesizes an APPSYNC_JS pipeline resolver whose\n   * response handler converts the errors.appsync.* envelope returned by\n   * createAppSyncHandler into a typed GraphQL error.\n   *\n   * Untyped errors still fail the invocation, and the pipeline function raises\n   * them as GraphQL errors with AppSync's invoke error type (e.g.\n   * `Lambda:Unhandled`), as a UNIT direct-Lambda resolver does.\n   *\n   * When false (the default), addLambdaResolver synthesizes a plain UNIT\n   * direct-Lambda resolver (the pre-#385 behavior) with no response handler.\n   * The Lambda gets no APPSYNC_TYPED_ERRORS flag, so createAppSyncHandler\n   * rethrows an AppSyncError and AppSync reports it as `Lambda:Unhandled`\n   * without the typed errorType and errorInfo.\n   *\n   * This flag applies to ALL Lambda resolvers on the API. Enabling it changes\n   * the resolver topology from UNIT to PIPELINE, which produces a cdk diff for\n   * every Lambda resolver, so opt in deliberately.\n   *\n   * @default false\n   */\n  typedErrors?: boolean;\n}\n\nexport interface LambdaResolverOptions {\n  /**\n   * If set, addLambdaResolver wires an AppSync BatchInvoke resolver instead of a\n   * single invoke. The generated UNIT resolver gets MaxBatchSize set to this\n   * value, a BatchInvoke request template\n   * (MappingTemplate.lambdaRequest('$utils.toJson($context)', 'BatchInvoke')) and\n   * a MappingTemplate.lambdaResult() response template, so AppSync groups up to\n   * this many field invocations into one Lambda call. Pair this with\n   * createAppSyncBatchHandler, whose handler receives the batched events.\n   *\n   * When both maxBatchSize and `typedErrors` are set, maxBatchSize wins for this\n   * field. The field gets the UNIT BatchInvoke resolver rather than the\n   * typedErrors APPSYNC_JS pipeline, because the BatchInvoke mapping templates\n   * have no equivalent on that pipeline. Typed errors thrown by a batch handler\n   * are not converted to GraphQL errors. They rethrow and fail the invocation,\n   * so a batch handler should not rely on the typed-error-to-GraphQL-error\n   * conversion.\n   *\n   * @default - undefined (single invoke, the pre-batch behaviour; no MaxBatchSize and no mapping templates)\n   */\n  readonly maxBatchSize?: number;\n}\n\nexport interface VtlResolverOptions {\n  /**\n   * The datasource the VTL resolver targets\n   */\n  dataSource: aws_appsync.BaseDataSource;\n\n  /**\n   * string replacements to process on the VTL\n   *\n   * @default no variable expansions\n   */\n  variables?: { [name: string]: string };\n}\n\nexport interface JsResolverOptions {\n  /**\n   * Variables that will be put into the \"stash\" of the resolver pipeline\n   *\n   * @default none\n   */\n  readonly stashValues?: { [key: string]: string };\n\n  /**\n   * name of the pipeline steps to create\n   *\n   * @default - only a default step will be created\n   */\n  readonly pipelineStepNames?: string[];\n}\n\ninterface JsResolverConfig {\n  name: string;\n  index: number;\n  stepCount: number;\n  entryFile: string;\n  functionId: string;\n}\n\n/**\n * The GraphQlApi construct sets up an AWS AppSync GraphQL API integrated with Cognito for authentication and DynamoDB for data storage.\n * This construct facilitates the creation of a GraphQL API with various configurations, including custom domain, logging, schema definition,\n * and authorization using Cognito User Pool and Identity Pool. It also provides methods to dynamically add resolvers and grant access to specific fields.\n *\n * @template RESOLVERS - The type definition for the GraphQL resolvers.\n *\n * @example\n * const api = new GraphQlApi(this, 'MyGraphQlApi', {\n *   apiName: 'MyAPI',\n *   stageName: 'dev',\n *   definitionFileName: 'schema.graphql',\n *   authentication: myCognitoAuth,\n *   singleTableDatastore: myDynamoDBTable,\n * });\n *\n * // Add a Lambda resolver\n * api.addLambdaResolver('Query', 'getItem');\n *\n * // Grant access to unauthenticated users for a specific query\n * api.grantAccessUnAuth('Query', 'getItem');\n */\nexport class GraphQlApi<RESOLVERS> extends BaseApi {\n\n  /**\n   * The AWS AppSync GraphQL API instance.\n   */\n  public readonly api: aws_appsync.GraphqlApi;\n\n  /**\n   * The optional DynamoDB data source for the GraphQL API.\n   */\n  public readonly tableDataSource?: aws_appsync.DynamoDbDataSource;\n\n  /**\n   * A collection of Lambda functions used as resolvers for the GraphQL API.\n   */\n  private _functions: { [operationId: string]: LambdaFunction } = {};\n\n  /**\n   * Nested stacks for resolvers, grouped by type name.\n   * Only used when useNestedStacks is true.\n   */\n  private readonly nestedStacks: { [typeName: string]: NestedStack } = {};\n\n  /**\n   * The Cognito authentication configuration.\n   */\n  private readonly cognitoAuth: CognitoAuthentication;\n\n  /**\n   * Creates an instance of GraphQlApi.\n   *\n   * @param scope - The scope in which this construct is defined.\n   * @param id - The scoped construct ID.\n   * @param props - The properties of the GraphQlApi construct.\n   */\n  constructor(scope: Construct, id: string, private readonly props: GraphQlApiProps) {\n    super(scope, id, props);\n\n    this.cognitoAuth = props.authentication as CognitoAuthentication;\n\n    let customDomainName: aws_appsync.DomainOptions | undefined;\n    if (this.apiFQDN) {\n      customDomainName = {\n        domainName: this.apiFQDN,\n        certificate: new aws_certificatemanager.DnsValidatedCertificate(this, 'Cert', {\n          hostedZone: this.hostedZone!,\n          region: 'us-east-1',\n          domainName: this.apiFQDN,\n          validation: aws_certificatemanager.CertificateValidation.fromDns(this.hostedZone),\n        }),\n      };\n      new CfnOutput(this, 'GraphQlApiDomainName', {\n        key: `${this.props.apiName}${CFN_OUTPUT_SUFFIX_GRAPHQL_DOMAINNAME}`,\n        value: this.apiFQDN,\n      });\n    }\n\n    this.api = new aws_appsync.GraphqlApi(this, 'Resource', {\n      name: `${props.apiName} [${props.stageName}]`,\n      logConfig: {\n        fieldLogLevel: aws_appsync.FieldLogLevel.ALL,\n        retention: aws_logs.RetentionDays.TWO_MONTHS,\n      },\n      schema: aws_appsync.SchemaFile.fromAsset(props.definitionFileName),\n      domainName: customDomainName,\n      ...this.cognitoAuth && {\n        authorizationConfig: {\n          additionalAuthorizationModes: [\n            {\n              authorizationType: aws_appsync.AuthorizationType.USER_POOL,\n              userPoolConfig: {\n                userPool: this.cognitoAuth.userpool,\n                defaultAction: aws_appsync.UserPoolDefaultAction.DENY,\n              },\n            },\n            ...this.cognitoAuth.identityPool ? [{ authorizationType: aws_appsync.AuthorizationType.IAM }] : [],\n          ],\n        },\n      },\n    });\n    if (customDomainName && this.api.appSyncDomainName) {\n      new aws_route53.CnameRecord(this, 'DnsRecord', {\n        zone: this.hostedZone!,\n        recordName: customDomainName.domainName,\n        domainName: this.api.appSyncDomainName,\n      });\n    }\n\n    // if ((props.monitoring ?? true) && this.monitoring) {\n    //   this.monitoring.apiErrorsWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: '5XXError',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'sum',\n    //   }));\n    //   this.monitoring.apiErrorsWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: '4XXError',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'sum',\n    //   }));\n    //   this.monitoring.apiLatencyWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'Average',\n    //   }));\n    //   this.monitoring.apiLatencyWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'p90',\n    //   }));\n    //   this.monitoring.apiLatencyTailWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'p95',\n    //   }));\n    //   this.monitoring.apiLatencyTailWidget.addLeftMetric(new cloudwatch.Metric({\n    //     namespace: 'AWS/AppSync',\n    //     metricName: 'Latency',\n    //     dimensionsMap: {\n    //       GraphQLAPIId: this.api.apiId,\n    //     },\n    //     statistic: 'p99',\n    //   }));\n    // }\n\n    if (props.singleTableDatastore) {\n      this.tableDataSource = new aws_appsync.DynamoDbDataSource(this, 'SingleTableSource', {\n        api: this.api,\n        table: props.singleTableDatastore?.table,\n      });\n    }\n  }\n\n  /**\n   *\n   */\n  public grantAccess<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    grantee: aws_iam.IGrantable,\n    typeName: TYPE,\n    ...fieldNames: (keyof FIELDTYPE)[]): void {\n    this.api.grant(grantee, aws_appsync.IamResource.ofType(typeName as string, ...fieldNames as string[]), 'appsync:GraphQL');\n  }\n\n  /**\n   *\n   */\n  public grantAccessUnAuth<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    ...fieldNames: (keyof FIELDTYPE)[]\n  ): void {\n    if (!this.cognitoAuth.identityPool) {\n      throw new Error('Cannot grant to Cognito identity pool as none is provided');\n    }\n    this.grantAccess(this.cognitoAuth.identityPool.unauthenticatedRole, typeName, ...fieldNames);\n  }\n\n  /**\n   *\n   */\n  public grantAccessAuth<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    ...fieldNames: (keyof FIELDTYPE)[]\n  ): void {\n    if (!this.cognitoAuth.identityPool) {\n      throw new Error('Cannot grant to Cognito identity pool as none is provided');\n    }\n    this.grantAccess(this.cognitoAuth.identityPool.authenticatedRole, typeName, ...fieldNames);\n  }\n\n\n  /**\n   * getFunctionForOperation\n   */\n  public getFunctionForOperation<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n  ): LambdaFunction {\n    return this._functions[`${typeName as string}.${fieldName as String}`];\n  }\n\n  public addLambdaResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    options?: LambdaResolverOptions,\n  ): LambdaFunction {\n    const isBatch = options?.maxBatchSize !== undefined;\n\n    const operationId = `${typeName as string}.${fieldName as String}`;\n    const description = `Type ${typeName as string} Field ${fieldName as String} Resolver`;\n\n    const entryFile = `./src/lambda/${operationId}.ts`;\n    if (!fs.existsSync(entryFile)) {\n      fs.mkdirSync('./src/lambda/', { recursive: true });\n      this.createEntryFile(entryFile, typeName as string, fieldName as string);\n    }\n\n    const scope = this.getScopeForTypeName(typeName as string);\n\n    const fn = new LambdaFunction(scope, `Fn${operationId}`, {\n      stageName: this.props.stageName,\n      additionalEnv: this.props.additionalEnv,\n      entry: entryFile,\n      description: `[${this.props.stageName}] ${description}`,\n      ...this.props.authentication && {\n        userPool: (this.props.authentication as CognitoAuthentication).userpool,\n      },\n      ...this.props.singleTableDatastore && {\n        table: this.props.singleTableDatastore.table,\n        tableWrites: typeName === 'Mutation',\n      },\n      ...this.props.assetCdn && {\n        assetDomainName: this.props.assetCdn.assetDomainName,\n        assetBucket: this.props.assetCdn.assetBucket,\n      },\n      lambdaOptions: this.props.lambdaOptions,\n      lambdaTracing: this.props.lambdaTracing,\n    });\n    this._functions[operationId] = fn;\n    Tags.of(fn).add('GraphQL', description);\n\n    // if (this.monitoring) {\n    //   this.monitoring.lambdaDurationsWidget.addLeftMetric(fn.metricDuration());\n    //   this.monitoring.lambdaInvokesWidget.addLeftMetric(fn.metricInvocations());\n    //   this.monitoring.lambdaErrorsWidget.addLeftMetric(fn.metricErrors());\n    //   this.monitoring.lambdaErrorsWidget.addLeftMetric(fn.metricThrottles());\n    // }\n\n    const dataSource = new aws_appsync.LambdaDataSource(scope, `LambdaDS${operationId}`, {\n      api: this.api,\n      name: `Lambda_${typeName as string}_${fieldName as String}`,\n      lambdaFunction: fn,\n    });\n\n    if (isBatch) {\n      // A batch field always takes the UNIT BatchInvoke path, even when the API\n      // has typedErrors enabled. maxBatchSize wins over typedErrors for this\n      // field because the BatchInvoke mapping templates have no equivalent on\n      // the APPSYNC_JS pipeline resolver. AppSync batches up to maxBatchSize\n      // field invocations into a single Lambda call handled by\n      // createAppSyncBatchHandler. The L2 BaseResolverProps.maxBatchSize sets\n      // MaxBatchSize directly, so no escape hatch is needed.\n      //\n      // APPSYNC_TYPED_ERRORS is intentionally not set here. A batch handler that\n      // throws a typed error rethrows and fails the invocation loudly instead of\n      // having the error envelope returned as field data.\n      new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n        api: this.api,\n        typeName: typeName as string,\n        fieldName: fieldName as string,\n        dataSource,\n        maxBatchSize: options!.maxBatchSize,\n        requestMappingTemplate: aws_appsync.MappingTemplate.lambdaRequest('$utils.toJson($context)', 'BatchInvoke'),\n        responseMappingTemplate: aws_appsync.MappingTemplate.lambdaResult(),\n      });\n      return fn;\n    }\n\n    if (!this.props.typedErrors) {\n      // Default (pre-#385) shape: a plain UNIT resolver with the Lambda data\n      // source set directly. No response handler, so the error envelope from\n      // createAppSyncHandler would be surfaced as field data rather than a\n      // GraphQL error. Opt in via `typedErrors: true` to get the pipeline below.\n      new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n        api: this.api,\n        typeName: typeName as string,\n        fieldName: fieldName as string,\n        dataSource,\n      });\n      return fn;\n    }\n\n    // Couple the handler to this pipeline. createAppSyncHandler returns the\n    // error envelope only when APPSYNC_TYPED_ERRORS === 'true'; otherwise it\n    // rethrows the typed error. Inject the flag here (and only here) so the\n    // envelope behavior is active exactly on the path that has the response\n    // handler to interpret it. The default UNIT path above leaves the env var\n    // unset, so a handler that throws an AppSyncError there fails loudly.\n    fn.addEnvironment('APPSYNC_TYPED_ERRORS', 'true');\n\n    // The Lambda invoke runs as a pipeline function (a single Invoke passthrough),\n    // and the resolver's response handler interprets the error envelope that\n    // createAppSyncHandler returns. A direct-Lambda resolver without a response\n    // handler would surface the { data, errorType, errorMessage, errorInfo }\n    // envelope as plain field data, so the typed errors.appsync.* errors only\n    // become GraphQL errors because of the response handler attached below.\n    const invokeFunction = new aws_appsync.AppsyncFunction(scope, `LambdaFn${operationId}`, {\n      api: this.api,\n      name: `Lambda_${(typeName as string).replace(/[^A-Za-z0-9]/g, '')}_${(fieldName as String).replace(/[^A-Za-z0-9]/g, '')}`,\n      dataSource,\n      runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      code: aws_appsync.Code.fromInline(`import { util } from '@aws-appsync/utils';\n\n// Invoke the Lambda data source with the full resolver context as the payload.\nexport function request(ctx) {\n  return {\n    operation: 'Invoke',\n    payload: ctx,\n  };\n}\n\n// A failed invoke (an untyped error rethrown by createAppSyncHandler, a timeout,\n// a missing permission) lands in this function's ctx.error. AppSync drops it\n// unless this handler raises it, and the field would resolve to null with no\n// GraphQL error. Raise it with the same message and type a UNIT direct-Lambda\n// resolver reports. Otherwise pass the result through; the resolver response\n// handler converts the typed error envelope into a GraphQL error.\nexport function response(ctx) {\n  if (ctx.error) {\n    util.error(ctx.error.message, ctx.error.type);\n  }\n  return ctx.result;\n}\n`),\n    });\n\n    new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n      api: this.api,\n      typeName: typeName as string,\n      fieldName: fieldName as string,\n      runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      pipelineConfig: [invokeFunction],\n      code: aws_appsync.Code.fromInline(`import { util } from '@aws-appsync/utils';\n\nexport function request(ctx) {\n  return {};\n}\n\n// Convert the error envelope returned by createAppSyncHandler into a GraphQL error.\n// util.error / util.appendError take (message, errorType, data, errorInfo), so\n// errorType and errorInfo reach the client. Without this, AppSync would surface\n// the envelope object as the field result instead of as a GraphQL error.\n//\n// The envelope is recognised by its reserved __appSyncError sentinel key, which\n// createAppSyncHandler stamps. Branching on the sentinel (not on a bare\n// errorMessage) means a legitimate result that merely has an errorMessage field\n// is returned unchanged instead of being misread as a typed error.\n//\n// Invoke-level errors are raised by the pipeline function itself: an error left\n// in a function's ctx.error never reaches this handler's ctx.error.\nexport function response(ctx) {\n  const result = ctx.prev.result;\n  if (result && result.__appSyncError) {\n    util.error(result.errorMessage, result.errorType, null, result.errorInfo);\n  }\n  return result;\n}\n`),\n    });\n    return fn;\n  }\n\n  public addDynamoDbVtlResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    options?: Omit<VtlResolverOptions, 'dataSource'>): void {\n    if (!this.tableDataSource) {\n      throw new Error('DynamoDB is not initialized');\n    }\n    this.addVtlResolver(typeName, fieldName, {\n      dataSource: this.tableDataSource,\n      ...options,\n    });\n  }\n\n  public addDynamoDbJSResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    options?: JsResolverOptions): void {\n    if (!this.tableDataSource) {\n      throw new Error('DynamoDB is not initialized');\n    }\n    this.addJSResolver(typeName, fieldName, this.tableDataSource, {\n      ...options,\n      stashValues: {\n        ...options?.stashValues ?? {},\n        table: this.props.singleTableDatastore!.table.tableName,\n      },\n    });\n  }\n\n  public addJSResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    dataSource: aws_appsync.BaseDataSource, options?: JsResolverOptions): void {\n    const operationId = `${typeName as string}.${fieldName as String}`;\n    const description = `Type ${typeName as string} Field ${fieldName as String} Resolver`;\n\n    const scope = this.getScopeForTypeName(typeName as string);\n\n    const resolverDir = './src/js-resolver/';\n    const functions: JsResolverConfig[] = [];\n\n    if (!options || !options.pipelineStepNames || options.pipelineStepNames.length == 0) {\n      functions.push({\n        name: 'default',\n        index: 0,\n        stepCount: 1,\n        entryFile: `${resolverDir}/${operationId}.ts`,\n        functionId: `JSFunction${operationId}`,\n      });\n    } else {\n      functions.push(...options.pipelineStepNames.map((name, index) => ({\n        name,\n        index,\n        stepCount: options.pipelineStepNames!.length,\n        entryFile: `${resolverDir}/${operationId}.${name}.ts`,\n        functionId: `JSFunction${operationId}${name}`,\n      })));\n    }\n\n    const pipelineConfig = [];\n\n    for (const fn of functions) {\n      if (!fs.existsSync(fn.entryFile)) {\n        fs.mkdirSync(resolverDir, { recursive: true });\n        this.createJSResolverFile(fn, typeName as string, fieldName as string);\n      }\n\n      const jsFunction = new aws_appsync.AppsyncFunction(scope, fn.functionId, {\n        api: this.api,\n        name: operationId.replace(/\\./g, ''),\n        description,\n        dataSource,\n        code: aws_appsync.Code.fromAsset('.', {\n          assetHashType: AssetHashType.OUTPUT,\n          deployTime: true,\n          bundling: {\n            image: DockerImage.fromRegistry('dummy'), // Will never be used due to local bundling\n            outputType: BundlingOutput.SINGLE_FILE,\n            functionId: fn.functionId,\n            local: {\n              tryBundle(outputDir) {\n                const osPlatform = os.platform();\n                exec(\n                  osPlatform === 'win32' ? 'cmd' : 'bash',\n                  [\n                    osPlatform === 'win32' ? '/c' : '-c',\n                    `esbuild --bundle --sourcemap=inline --sources-content=false --target=esnext --platform=node --format=esm --external:@aws-appsync/utils --outdir=${outputDir} ${fn.entryFile}`,\n                  ],\n                  {\n                    env: { ...process.env },\n                    stdio: [ // show output\n                      'ignore', // ignore stdio\n                      process.stderr, // redirect stdout to stderr\n                      'inherit', // inherit stderr\n                    ],\n                    windowsVerbatimArguments: osPlatform === 'win32',\n                  });\n\n                return true;\n              },\n            },\n          } as BundlingOptions,\n        }),\n        runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      });\n      pipelineConfig.push(jsFunction);\n    }\n\n    new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n      api: this.api,\n      typeName: typeName as string,\n      fieldName: fieldName as string,\n      runtime: aws_appsync.FunctionRuntime.JS_1_0_0,\n      pipelineConfig,\n      code: aws_appsync.Code.fromInline(`\n    // The before step\n    export function request(ctx) {\n      console.log(ctx);\n${Object.entries(options?.stashValues ?? []).map(val => `      ctx.stash.${val[0]} = '${val[1]}'`).join('\\n')}\n      return {}\n    }\n\n    // The after step\n    export function response(ctx) {\n      return ctx.prev.result\n    }\n  `),\n    });\n  }\n\n  public addVtlResolver<TYPE extends keyof RESOLVERS, FIELDTYPE extends NonNullable<RESOLVERS[TYPE]>>(\n    typeName: TYPE,\n    fieldName: keyof FIELDTYPE,\n    options: VtlResolverOptions): void {\n    const operationId = `${typeName as string}.${fieldName as String}`;\n\n    const mappingReqFile = `./src/vtl/${operationId}.req.vtl`;\n    if (!fs.existsSync(mappingReqFile)) {\n      fs.mkdirSync('./src/vtl/', { recursive: true });\n      fs.writeFileSync(mappingReqFile, '## Request mapping', { encoding: 'utf-8' });\n    }\n    const mappingResFile = `./src/vtl/${operationId}.res.vtl`;\n    if (!fs.existsSync(mappingResFile)) {\n      fs.mkdirSync('./src/vtl/', { recursive: true });\n      fs.writeFileSync(mappingResFile, '$util.toJson($ctx.result)', { encoding: 'utf-8' });\n    }\n\n    const scope = this.getScopeForTypeName(typeName as string);\n\n    new aws_appsync.Resolver(scope, `Resolver${operationId}`, {\n      api: this.api,\n      typeName: typeName as string,\n      fieldName: fieldName as string,\n      dataSource: options.dataSource,\n      requestMappingTemplate: aws_appsync.MappingTemplate.fromString(this.substVariables(fs.readFileSync(mappingReqFile).toString('utf-8'), options.variables)),\n      responseMappingTemplate: aws_appsync.MappingTemplate.fromString(this.substVariables(fs.readFileSync(mappingResFile).toString('utf-8'), options.variables)),\n    });\n  }\n\n  /**\n   * Returns the appropriate scope for creating resources for the given type name.\n   * If useNestedStacks is enabled, returns a nested stack for the type name,\n   * creating it if it doesn't exist. Otherwise, returns this construct.\n   *\n   * Query, Mutation, and Subscription each get their own nested stack.\n   * All other types (field resolvers) share a single \"Field\" nested stack.\n   *\n   * @param typeName - The GraphQL type name (e.g., 'Query', 'Mutation', 'Subscription', or a custom type)\n   * @returns The construct to use as scope for creating resources\n   */\n  private getScopeForTypeName(typeName: string): Construct {\n    if (!this.props.useNestedStacks) {\n      return this;\n    }\n\n    const rootTypes = ['Query', 'Mutation', 'Subscription'];\n    const stackKey = rootTypes.includes(typeName) ? typeName : 'Field';\n\n    if (!this.nestedStacks[stackKey]) {\n      this.nestedStacks[stackKey] = new NestedStack(this, `${stackKey}Resolvers`, {\n        description: `Nested stack for ${stackKey} resolvers`,\n      });\n    }\n\n    return this.nestedStacks[stackKey];\n  }\n\n  private substVariables(data: string, vars: { [name: string]: string } = {}): string {\n    let res = data;\n    for (const name in vars) {\n      if (Object.prototype.hasOwnProperty.call(vars, name)) {\n        const value = vars[name];\n        res = res.replace(new RegExp(`\\\\$\\{${name}\\}`, 'g'), value);\n      }\n    }\n    return res;\n  }\n\n  private createEntryFile(entryFile: string, typeName: string, fieldName: string) {\n    const argType = `${typeName}${uppercaseFirst(fieldName)}Args`;\n    fs.writeFileSync(entryFile, `import { api } from 'cdk-serverless/lib/lambda';\nimport { ${typeName}, ${argType} } from '../generated/graphql.${this.props.apiName.toLowerCase()}-model.generated';\n\nexport const handler = api.createAppSyncHandler<${argType}, ${typeName}['${fieldName}']>(async (ctx) => {\n  ctx.logger.info(JSON.stringify(ctx.event));\n  throw new Error('Not yet implemented');\n});`, {\n      encoding: 'utf-8',\n    });\n  }\n\n  private createJSResolverFile(fn: JsResolverConfig, typeName: string, fieldName: string) {\n    const argType = `${typeName}${uppercaseFirst(fieldName)}Args`;\n    const returnType = (fn.index == (fn.stepCount - 1)) ? `${typeName}['${fieldName}']` : 'any';\n\n    fs.writeFileSync(fn.entryFile, `import { Context, util } from '@aws-appsync/utils';\nimport { ${typeName}, ${argType} } from '../generated/graphql.${this.props.apiName.toLowerCase()}-model.generated';\n\n/**\n * Request for ${typeName}.${fieldName} (Step: ${fn.name} ${fn.index + 1}/${fn.stepCount})\n */\nexport function request(ctx: Context<${argType}>): any {\n  console.log(ctx);\n  return {};\n}\n\n/**\n * Response for ${typeName}.${fieldName} (Step: ${fn.name} ${fn.index + 1}/${fn.stepCount})\n */\nexport function response(ctx: Context<${argType}>): ${returnType} {\n  console.log(ctx);\n  return ctx.result.items;\n}`, {\n      encoding: 'utf-8',\n    });\n  }\n\n}\n\nfunction uppercaseFirst(value: string): string {\n  return value.substring(0, 1).toUpperCase() + value.substring(1);\n}\n\n/**\n * Copied from https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/aws-lambda-nodejs/lib/util.ts\n * as it is not exported by aws-cdk-lib\n */\nfunction exec(cmd: string, args: string[], options?: SpawnSyncOptions) {\n  const proc = spawnSync(cmd, args, options);\n\n  if (proc.error) {\n    throw proc.error;\n  }\n\n  if (proc.status !== 0) {\n    if (proc.stdout || proc.stderr) {\n      throw new Error(`[Status ${proc.status}] stdout: ${proc.stdout?.toString().trim()}\\n\\n\\nstderr: ${proc.stderr?.toString().trim()}`);\n    }\n    throw new Error(`${cmd} ${args.join(' ')} ${options?.cwd ? `run in directory ${options.cwd}` : ''} exited with status ${proc.status}`);\n  }\n\n  return proc;\n}\n\n"]}

package/lib/lambda/handler.d.ts

@@ -88,3 +88,31 @@ export type AppSyncHandler<T, R> = (context: AppSyncHandlerContext<T>) => Promis
  * @param handler The AppSyncHandler to use as the resolver.
  */
 export declare const createAppSyncHandler: <T, R>(handler: AppSyncHandler<T, R>) => AWSLambda.AppSyncResolverHandler<T, R>;
+/**
+ * The context for a batched AppSync resolver function.
+ * Extends AppSyncHandlerContext so handler code that reads ctx.event.arguments /
+ * ctx.event.identity keeps working against the first event, and additionally
+ * exposes the full batch of events so the handler can map over it.
+ */
+export interface AppSyncBatchHandlerContext<T, S extends Record<string, any> | null = Record<string, any> | null> extends AppSyncHandlerContext<T> {
+    event: AWSLambda.AppSyncResolverEvent<T, S>;
+    events: AWSLambda.AppSyncResolverEvent<T, S>[];
+}
+/**
+ * A function that handles an AppSync BatchInvoke event.
+ * Receives the batch context and returns the responses in source order.
+ */
+export type AppSyncBatchHandler<T, R, S extends Record<string, any> | null = Record<string, any> | null> = (context: AppSyncBatchHandlerContext<T, S>) => Promise<R[]>;
+/**
+ * Creates a batched AppSync resolver handler from the given AppSyncBatchHandler.
+ * Returns a function that can be used as an AppSync BatchInvoke resolver: array
+ * in, array out, order preserved.
+ *
+ * It mirrors createAppSyncHandler's context and auth plumbing but operates on an
+ * array of events. Authentication runs once per batch off the first event, and
+ * the context carries both the first event (ctx.event = events[0]) and the full
+ * ctx.events array. The handler returns R[] in the same order as the input events.
+ *
+ * @param handler The AppSyncBatchHandler to use as the resolver.
+ */
+export declare const createAppSyncBatchHandler: <T, R, S extends Record<string, any> | null = Record<string, any> | null>(handler: AppSyncBatchHandler<T, R, S>) => AWSLambda.AppSyncBatchResolverHandler<T, R, S>;