cdk-serverless 3.3.3 → 3.5.0

package/lib/lambda/handler.js

@@ -36,9 +36,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAppSyncHandler = exports.createHttpHandler = exports.createOpenApiHandler = exports.createOpenApiHandlerWithRequestBodyNoResponse = exports.createOpenApiHandlerWithRequestBody = void 0;
+exports.createAppSyncBatchHandler = exports.createAppSyncHandler = exports.createHttpHandler = exports.createOpenApiHandler = exports.createOpenApiHandlerWithRequestBodyNoResponse = exports.createOpenApiHandlerWithRequestBody = void 0;
 const process_1 = require("process");
 const lambda_log_1 = __importDefault(require("lambda-log"));
+const appsyncErrors = __importStar(require("./appsync-errors"));
 const auth_1 = require("./auth");
 const errors = __importStar(require("./errors"));
 /**
@@ -198,6 +199,70 @@ function corsHeader(event) {
         'Access-Control-Allow-Headers': 'Authorization, *', // Allow the Authorization header and any other headers
     };
 }
+/**
+ * Maps an HTTP status code to the GraphQL errorType reported to AppSync.
+ *
+ * Local (non-exported) helper used only by createAppSyncHandler when it
+ * translates an errors.HttpError into a typed AppSync error. The explicit
+ * default keeps any unmapped status (for example a 418 or a 5xx) reported as
+ * the generic 'Error' errorType rather than leaking the raw status code.
+ */
+function httpStatusToErrorType(statusCode) {
+    switch (statusCode) {
+        case 400:
+            return 'BadRequest';
+        case 401:
+            return 'Unauthorized';
+        case 403:
+            return 'Forbidden';
+        case 404:
+            return 'NotFound';
+        default:
+            return 'Error';
+    }
+}
+/**
+ * Normalises the two recognised typed-error shapes to a common
+ * { errorType, message, errorInfo } so the gate, envelope and rethrow are a
+ * single code path across the single and batch handlers. Returns undefined for
+ * anything that is neither (plain Error, Boom), which the callers rethrow.
+ *
+ * - appsyncErrors.AppSyncError carries its own GraphQL errorType and an optional
+ *   errorInfo, which flow through unchanged.
+ * - errors.HttpError (the HTTP base thrown by the shared JwtAuthorizer via
+ *   assertAuthenticated/assertGroup/assertAdmin, and by resolver code directly)
+ *   has no GraphQL errorType, so map its statusCode with httpStatusToErrorType.
+ *   HttpError carries no errorInfo, so errorInfo is undefined.
+ *
+ * The two instanceof checks are disjoint: HttpError and AppSyncError share no
+ * ancestry, so an appsync.ForbiddenError takes the AppSyncError branch and an
+ * errors.ForbiddenError the HttpError branch.
+ */
+function toTypedError(error) {
+    if (error instanceof appsyncErrors.AppSyncError) {
+        return { errorType: error.errorType, message: error.message, errorInfo: error.errorInfo };
+    }
+    else if (error instanceof errors.HttpError) {
+        return { errorType: httpStatusToErrorType(error.statusCode), message: error.message, errorInfo: undefined };
+    }
+    return undefined;
+}
+/**
+ * Builds the direct-Lambda error envelope AppSync surfaces as a typed GraphQL
+ * error. __appSyncError is a reserved sentinel key the resolver response handler
+ * keys on to recognise this envelope. Branching on the sentinel (rather than on
+ * a bare errorMessage) means a legitimate resolver result that merely contains
+ * an errorMessage field is not misclassified as a typed error.
+ */
+function buildErrorEnvelope(typed) {
+    return {
+        __appSyncError: true,
+        data: null,
+        errorType: typed.errorType,
+        errorMessage: typed.message,
+        errorInfo: typed.errorInfo,
+    };
+}
 /**
  * Creates an AppSync resolver handler from the given AppSyncHandler.
  * Returns a function that can be used as an AppSync resolver.
@@ -225,6 +290,26 @@ const createAppSyncHandler = (handler) => {
             return await handler(ctx);
         }
         catch (error) {
+            const typed = toTypedError(error);
+            if (typed && process.env.APPSYNC_TYPED_ERRORS === 'true') {
+                // The envelope-return is gated on APPSYNC_TYPED_ERRORS === 'true'.
+                // GraphQlApi.addLambdaResolver injects that env var only on its
+                // typedErrors: true path, whose APPSYNC_JS resolver has a response
+                // handler that reads this envelope and calls
+                // util.error(errorMessage, errorType, null, errorInfo), turning it into
+                // a GraphQL error on a successful invocation. Returning (not throwing)
+                // keeps the invocation off the Lambda Errors metric.
+                //
+                // When the env var is absent (the default UNIT resolver path, or a
+                // hand-wired handler used without GraphQlApi) the typed error falls
+                // through to the rethrow below, so the invocation fails loudly instead
+                // of surfacing the envelope as field data. Any value other than the
+                // exact string 'true' means rethrow. This is why a default UNIT
+                // resolver whose handler hits an auth assertion (an HttpError) still
+                // fails loudly unless typedErrors is active.
+                ctx.logger.warn(typed.message, { errorType: typed.errorType, errorInfo: typed.errorInfo });
+                return buildErrorEnvelope(typed);
+            }
             // log the error and throw it again
             ctx.logger.error(error);
             throw error;
@@ -232,4 +317,59 @@ const createAppSyncHandler = (handler) => {
     };
 };
 exports.createAppSyncHandler = createAppSyncHandler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/lambda/handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { env } from 'process';\nimport logger, { LambdaLog } from 'lambda-log';\nimport {\n  ApiGatewayv1CognitoAuthorizer,\n  ApiGatewayv1JwtAuthorizer,\n  AppSyncCognitoAuthorizer,\n  CognitoAuthorizer,\n  JwtAuthorizer,\n} from './auth';\nimport * as errors from './errors';\n\n\n/////////////////////////////////\n/// HTTP Api\n/////////////////////////////////\n\n/**\n * An object containing the properties for an HTTP response.\n */\nexport interface HttpResponseContext {\n  statusCode?: number;\n  headers: { [name: string]: string };\n  json: boolean;\n}\n\n/**\n * An object containing the properties for an HTTP request handler.\n */\nexport interface HttpHandlerContext {\n  event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  response: HttpResponseContext;\n  auth: JwtAuthorizer;\n}\n\n/**\n * A type definition for an HTTP handler.\n */\nexport type HttpHandler<T, R> = (\n  context: HttpHandlerContext,\n  body: T,\n) => Promise<R>;\n\n/**\n * An object containing the properties for an OpenAPI operation.\n */\nexport interface Operation {\n  responses: {\n    [statusCode: number]: {\n      content: {\n        'application/json': any;\n      };\n    } | any;\n  };\n}\n\n/**\n * A type definition for an API Gateway v1 request handler.\n */\nexport type APIGatewayv1Handler =\n  AWSLambda.Handler<AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, AWSLambda.APIGatewayProxyResult | undefined>;\n\n/**\n * An object containing the properties for an OpenAPI operation with a request body.\n */\nexport interface OperationWithRequestBody extends Operation {\n  requestBody: { content: { 'application/json': any } };\n}\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body.\n */\nexport const createOpenApiHandlerWithRequestBody = <OP extends OperationWithRequestBody, SC extends number = 200>(handler: HttpHandler<OP['requestBody']['content']['application/json'], OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body and no response.\n */\nexport const createOpenApiHandlerWithRequestBodyNoResponse = <OP extends OperationWithRequestBody>(handler: HttpHandler<OP['requestBody']['content']['application/json'], void>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation.\n */\nexport const createOpenApiHandler = <OP extends Operation, SC extends number = 200>(handler: HttpHandler<any, OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * Create an authorizer for the authentication method chosen (JWT or Cognito).\n */\nconst createAuthorizer = (event: AWSLambda.APIGatewayProxyEventBase<AWSLambda.APIGatewayProxyCognitoAuthorizer>, log: LambdaLog) => {\n  // If Cognito is used, USER_POOL_ID is injected into the function's environment. Currently assumes JWT otherwise.\n  if (env.USER_POOL_ID) {\n    return new ApiGatewayv1CognitoAuthorizer(event, log);\n  } else {\n    // This might need to get more sophisticated if more authorization methods need to be supported.\n    return new ApiGatewayv1JwtAuthorizer(event, 'admin', log);\n  }\n};\n\n/**\n * A factory function that creates an HTTP request handler.\n */\nexport const createHttpHandler =\n  <T, R>(handler: HttpHandler<T, R>): APIGatewayv1Handler => {\n    return async (event, context) => {\n      // Create an object to hold the context for this HTTP request\n      const auth = createAuthorizer(event, logger as unknown as logger.LambdaLog);\n      const ctx: HttpHandlerContext = {\n        event,\n        auth,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        response: { headers: {}, json: true },\n      };\n      // Add the request ID to the logging metadata, and enable debug logging if the DEBUG environment variable is set to \"true\"\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // Log the event object for debugging purposes\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // Authenticate the user using the Cognito authorizer\n        await ctx.auth.authenticate();\n\n        // Call the user-defined handler function, passing in the request context object and the parsed request body\n        const res = await handler(ctx, parseBody(event));\n\n        // Construct and return the HTTP response\n        return {\n          statusCode: ctx.response.statusCode ?? (res ? 200 : 204),\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: res ? (ctx.response.json ? JSON.stringify(res) : res) : '',\n        };\n      } catch (error: any) {\n        // Handle any errors that occur during request processing\n\n        // If the error is an instance of HttpError, return an HTTP response with the error status code and message\n        if (error instanceof errors.HttpError) {\n          return {\n            statusCode: error.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: error.message,\n          };\n        }\n        // If the error is a Boom error (from the hapi.js framework), return an HTTP response with the error status code and payload\n        if (error.isBoom) {\n          return {\n            statusCode: error.output.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...error.output.headers,\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: JSON.stringify(error.output.payload),\n          };\n        }\n        // For all other types of errors, log the error and return a 500 status code with the error message\n        ctx.logger.error(error);\n        return {\n          statusCode: ctx.response.statusCode ?? 500,\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: error.toString(),\n        };\n      }\n    };\n  };\n\n/**\n * Looks up a header value case-insensitively.\n * HTTP header names are case-insensitive per RFC 9110 §5.1.\n */\nfunction headerValue(headers: Record<string, string | undefined> | null | undefined, name: string): string | undefined {\n  if (!headers) return undefined;\n  const key = Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase());\n  return key ? headers[key] : undefined;\n}\n\n/**\n * This function takes an event object representing an API Gateway Proxy event\n * with a Cognito authorizer, and extracts and parses the request body, if present.\n *\n * @param event The API Gateway Proxy event with a Cognito authorizer\n * @returns The parsed request body\n */\nfunction parseBody<T>(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): T {\n  let body = event.body;\n\n  // If the request body is base64-encoded, decode it\n  if (event.body && event.isBase64Encoded) {\n    const buff = Buffer.from(event.body!, 'base64');\n    body = buff.toString('utf8');\n  }\n\n  // If the request body is in JSON format, parse it into a JavaScript object\n  if (headerValue(event.headers, 'content-type')?.includes('application/json')) {\n    return JSON.parse(body ?? '{}');\n  }\n\n  // If the request body is not present or not in JSON format, return it as-is\n  return body as any;\n}\n\n\n/**\n * Returns the CORS headers to be included in the API Gateway response.\n *\n * @param event - The API Gateway event object.\n * @returns An object containing the CORS headers.\n */\nfunction corsHeader(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): { [name: string]: string } {\n  const origin = headerValue(event?.headers, 'origin');\n  return {\n    'Access-Control-Allow-Origin': origin ?? '*', // Allow requests from the origin header, or allow any origin if not present\n    'Access-Control-Allow-Credentials': origin ? 'true' : 'false', // Include cookies in cross-origin requests if the origin header is present\n    'Access-Control-Allow-Methods': '*', // Allow any HTTP method\n    'Access-Control-Allow-Headers': 'Authorization, *', // Allow the Authorization header and any other headers\n  };\n}\n\n/////////////////////////////////\n/// AppSync\n/////////////////////////////////\n\n/**\n * The context for the AppSync resolver function.\n * Contains information about the event, lambda context, logger, and Cognito authorizer.\n */\nexport interface AppSyncHandlerContext<T> {\n  event: AWSLambda.AppSyncResolverEvent<T>;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  cognitoAuth: CognitoAuthorizer;\n}\n\n/**\n * A function that handles an AppSync resolver event.\n * Receives the context object and returns the response.\n */\nexport type AppSyncHandler<T, R> = (\n  context: AppSyncHandlerContext<T>,\n) => Promise<R>;\n\n/**\n * Creates an AppSync resolver handler from the given AppSyncHandler.\n * Returns a function that can be used as an AppSync resolver.\n *\n * @param handler The AppSyncHandler to use as the resolver.\n */\nexport const createAppSyncHandler =\n  <T, R>(handler: AppSyncHandler<T, R>): AWSLambda.AppSyncResolverHandler<T, R> => {\n    return async (event, context) => {\n      const ctx: AppSyncHandlerContext<T> = {\n        event,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        cognitoAuth: new AppSyncCognitoAuthorizer(event),\n      };\n\n      // set the meta information in logger\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      // set the debug flag for logger\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // log the received event\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // authenticate the incoming request\n        await ctx.cognitoAuth.authenticate();\n        // invoke the handler function with the context\n        return await handler(ctx);\n      } catch (error: any) {\n        // log the error and throw it again\n        ctx.logger.error(error);\n        throw error;\n      }\n    };\n  };\n\n"]}
+/**
+ * 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.
+ */
+const createAppSyncBatchHandler = (handler) => {
+    return async (events, context) => {
+        // BatchInvoke always delivers a non-empty array; authenticate and build
+        // the context off the first event, exactly like createAppSyncHandler.
+        const first = events[0];
+        const ctx = {
+            event: first,
+            events,
+            lambdaContext: context,
+            logger: lambda_log_1.default,
+            cognitoAuth: new auth_1.AppSyncCognitoAuthorizer(first),
+        };
+        // set the meta information in logger
+        ctx.logger.options.meta.requestId = context.awsRequestId;
+        // set the debug flag for logger
+        ctx.logger.options.debug = process.env.DEBUG === 'true';
+        // log the received batch of events
+        ctx.logger.debug(JSON.stringify(events));
+        try {
+            // authenticate once per batch off the first event
+            await ctx.cognitoAuth.authenticate();
+            // invoke the handler function with the batch context; it returns R[] in source order
+            return await handler(ctx);
+        }
+        catch (error) {
+            const typed = toTypedError(error);
+            if (typed && process.env.APPSYNC_TYPED_ERRORS === 'true') {
+                // Same gate and envelope as createAppSyncHandler. AppSync expects one
+                // result per event in a BatchInvoke response, so a batch-level typed
+                // error returns an array of envelopes aligned to the batch length;
+                // each item surfaces the same typed error. Returning (not throwing)
+                // keeps the invocation off the Lambda Errors metric. Without the flag
+                // the typed error falls through to the rethrow below.
+                ctx.logger.warn(typed.message, { errorType: typed.errorType, errorInfo: typed.errorInfo });
+                return events.map(() => buildErrorEnvelope(typed));
+            }
+            // log the error and throw it again
+            ctx.logger.error(error);
+            throw error;
+        }
+    };
+};
+exports.createAppSyncBatchHandler = createAppSyncBatchHandler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/lambda/handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { env } from 'process';\nimport logger, { LambdaLog } from 'lambda-log';\nimport * as appsyncErrors from './appsync-errors';\nimport {\n  ApiGatewayv1CognitoAuthorizer,\n  ApiGatewayv1JwtAuthorizer,\n  AppSyncCognitoAuthorizer,\n  CognitoAuthorizer,\n  JwtAuthorizer,\n} from './auth';\nimport * as errors from './errors';\n\n\n/////////////////////////////////\n/// HTTP Api\n/////////////////////////////////\n\n/**\n * An object containing the properties for an HTTP response.\n */\nexport interface HttpResponseContext {\n  statusCode?: number;\n  headers: { [name: string]: string };\n  json: boolean;\n}\n\n/**\n * An object containing the properties for an HTTP request handler.\n */\nexport interface HttpHandlerContext {\n  event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  response: HttpResponseContext;\n  auth: JwtAuthorizer;\n}\n\n/**\n * A type definition for an HTTP handler.\n */\nexport type HttpHandler<T, R> = (\n  context: HttpHandlerContext,\n  body: T,\n) => Promise<R>;\n\n/**\n * An object containing the properties for an OpenAPI operation.\n */\nexport interface Operation {\n  responses: {\n    [statusCode: number]: {\n      content: {\n        'application/json': any;\n      };\n    } | any;\n  };\n}\n\n/**\n * A type definition for an API Gateway v1 request handler.\n */\nexport type APIGatewayv1Handler =\n  AWSLambda.Handler<AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, AWSLambda.APIGatewayProxyResult | undefined>;\n\n/**\n * An object containing the properties for an OpenAPI operation with a request body.\n */\nexport interface OperationWithRequestBody extends Operation {\n  requestBody: { content: { 'application/json': any } };\n}\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body.\n */\nexport const createOpenApiHandlerWithRequestBody = <OP extends OperationWithRequestBody, SC extends number = 200>(handler: HttpHandler<OP['requestBody']['content']['application/json'], OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body and no response.\n */\nexport const createOpenApiHandlerWithRequestBodyNoResponse = <OP extends OperationWithRequestBody>(handler: HttpHandler<OP['requestBody']['content']['application/json'], void>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation.\n */\nexport const createOpenApiHandler = <OP extends Operation, SC extends number = 200>(handler: HttpHandler<any, OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * Create an authorizer for the authentication method chosen (JWT or Cognito).\n */\nconst createAuthorizer = (event: AWSLambda.APIGatewayProxyEventBase<AWSLambda.APIGatewayProxyCognitoAuthorizer>, log: LambdaLog) => {\n  // If Cognito is used, USER_POOL_ID is injected into the function's environment. Currently assumes JWT otherwise.\n  if (env.USER_POOL_ID) {\n    return new ApiGatewayv1CognitoAuthorizer(event, log);\n  } else {\n    // This might need to get more sophisticated if more authorization methods need to be supported.\n    return new ApiGatewayv1JwtAuthorizer(event, 'admin', log);\n  }\n};\n\n/**\n * A factory function that creates an HTTP request handler.\n */\nexport const createHttpHandler =\n  <T, R>(handler: HttpHandler<T, R>): APIGatewayv1Handler => {\n    return async (event, context) => {\n      // Create an object to hold the context for this HTTP request\n      const auth = createAuthorizer(event, logger as unknown as logger.LambdaLog);\n      const ctx: HttpHandlerContext = {\n        event,\n        auth,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        response: { headers: {}, json: true },\n      };\n      // Add the request ID to the logging metadata, and enable debug logging if the DEBUG environment variable is set to \"true\"\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // Log the event object for debugging purposes\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // Authenticate the user using the Cognito authorizer\n        await ctx.auth.authenticate();\n\n        // Call the user-defined handler function, passing in the request context object and the parsed request body\n        const res = await handler(ctx, parseBody(event));\n\n        // Construct and return the HTTP response\n        return {\n          statusCode: ctx.response.statusCode ?? (res ? 200 : 204),\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: res ? (ctx.response.json ? JSON.stringify(res) : res) : '',\n        };\n      } catch (error: any) {\n        // Handle any errors that occur during request processing\n\n        // If the error is an instance of HttpError, return an HTTP response with the error status code and message\n        if (error instanceof errors.HttpError) {\n          return {\n            statusCode: error.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: error.message,\n          };\n        }\n        // If the error is a Boom error (from the hapi.js framework), return an HTTP response with the error status code and payload\n        if (error.isBoom) {\n          return {\n            statusCode: error.output.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...error.output.headers,\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: JSON.stringify(error.output.payload),\n          };\n        }\n        // For all other types of errors, log the error and return a 500 status code with the error message\n        ctx.logger.error(error);\n        return {\n          statusCode: ctx.response.statusCode ?? 500,\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: error.toString(),\n        };\n      }\n    };\n  };\n\n/**\n * Looks up a header value case-insensitively.\n * HTTP header names are case-insensitive per RFC 9110 §5.1.\n */\nfunction headerValue(headers: Record<string, string | undefined> | null | undefined, name: string): string | undefined {\n  if (!headers) return undefined;\n  const key = Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase());\n  return key ? headers[key] : undefined;\n}\n\n/**\n * This function takes an event object representing an API Gateway Proxy event\n * with a Cognito authorizer, and extracts and parses the request body, if present.\n *\n * @param event The API Gateway Proxy event with a Cognito authorizer\n * @returns The parsed request body\n */\nfunction parseBody<T>(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): T {\n  let body = event.body;\n\n  // If the request body is base64-encoded, decode it\n  if (event.body && event.isBase64Encoded) {\n    const buff = Buffer.from(event.body!, 'base64');\n    body = buff.toString('utf8');\n  }\n\n  // If the request body is in JSON format, parse it into a JavaScript object\n  if (headerValue(event.headers, 'content-type')?.includes('application/json')) {\n    return JSON.parse(body ?? '{}');\n  }\n\n  // If the request body is not present or not in JSON format, return it as-is\n  return body as any;\n}\n\n\n/**\n * Returns the CORS headers to be included in the API Gateway response.\n *\n * @param event - The API Gateway event object.\n * @returns An object containing the CORS headers.\n */\nfunction corsHeader(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): { [name: string]: string } {\n  const origin = headerValue(event?.headers, 'origin');\n  return {\n    'Access-Control-Allow-Origin': origin ?? '*', // Allow requests from the origin header, or allow any origin if not present\n    'Access-Control-Allow-Credentials': origin ? 'true' : 'false', // Include cookies in cross-origin requests if the origin header is present\n    'Access-Control-Allow-Methods': '*', // Allow any HTTP method\n    'Access-Control-Allow-Headers': 'Authorization, *', // Allow the Authorization header and any other headers\n  };\n}\n\n/////////////////////////////////\n/// AppSync\n/////////////////////////////////\n\n/**\n * The context for the AppSync resolver function.\n * Contains information about the event, lambda context, logger, and Cognito authorizer.\n */\nexport interface AppSyncHandlerContext<T> {\n  event: AWSLambda.AppSyncResolverEvent<T>;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  cognitoAuth: CognitoAuthorizer;\n}\n\n/**\n * A function that handles an AppSync resolver event.\n * Receives the context object and returns the response.\n */\nexport type AppSyncHandler<T, R> = (\n  context: AppSyncHandlerContext<T>,\n) => Promise<R>;\n\n/**\n * Maps an HTTP status code to the GraphQL errorType reported to AppSync.\n *\n * Local (non-exported) helper used only by createAppSyncHandler when it\n * translates an errors.HttpError into a typed AppSync error. The explicit\n * default keeps any unmapped status (for example a 418 or a 5xx) reported as\n * the generic 'Error' errorType rather than leaking the raw status code.\n */\nfunction httpStatusToErrorType(statusCode: number): string {\n  switch (statusCode) {\n    case 400:\n      return 'BadRequest';\n    case 401:\n      return 'Unauthorized';\n    case 403:\n      return 'Forbidden';\n    case 404:\n      return 'NotFound';\n    default:\n      return 'Error';\n  }\n}\n\n/**\n * The typed-error shape shared by createAppSyncHandler and createAppSyncBatchHandler.\n */\ninterface TypedAppSyncError {\n  errorType: string;\n  message: string;\n  errorInfo?: Record<string, any>;\n}\n\n/**\n * Normalises the two recognised typed-error shapes to a common\n * { errorType, message, errorInfo } so the gate, envelope and rethrow are a\n * single code path across the single and batch handlers. Returns undefined for\n * anything that is neither (plain Error, Boom), which the callers rethrow.\n *\n * - appsyncErrors.AppSyncError carries its own GraphQL errorType and an optional\n *   errorInfo, which flow through unchanged.\n * - errors.HttpError (the HTTP base thrown by the shared JwtAuthorizer via\n *   assertAuthenticated/assertGroup/assertAdmin, and by resolver code directly)\n *   has no GraphQL errorType, so map its statusCode with httpStatusToErrorType.\n *   HttpError carries no errorInfo, so errorInfo is undefined.\n *\n * The two instanceof checks are disjoint: HttpError and AppSyncError share no\n * ancestry, so an appsync.ForbiddenError takes the AppSyncError branch and an\n * errors.ForbiddenError the HttpError branch.\n */\nfunction toTypedError(error: any): TypedAppSyncError | undefined {\n  if (error instanceof appsyncErrors.AppSyncError) {\n    return { errorType: error.errorType, message: error.message, errorInfo: error.errorInfo };\n  } else if (error instanceof errors.HttpError) {\n    return { errorType: httpStatusToErrorType(error.statusCode), message: error.message, errorInfo: undefined };\n  }\n  return undefined;\n}\n\n/**\n * Builds the direct-Lambda error envelope AppSync surfaces as a typed GraphQL\n * error. __appSyncError is a reserved sentinel key the resolver response handler\n * keys on to recognise this envelope. Branching on the sentinel (rather than on\n * a bare errorMessage) means a legitimate resolver result that merely contains\n * an errorMessage field is not misclassified as a typed error.\n */\nfunction buildErrorEnvelope<R>(typed: TypedAppSyncError): R {\n  return {\n    __appSyncError: true,\n    data: null,\n    errorType: typed.errorType,\n    errorMessage: typed.message,\n    errorInfo: typed.errorInfo,\n  } as unknown as R;\n}\n\n/**\n * Creates an AppSync resolver handler from the given AppSyncHandler.\n * Returns a function that can be used as an AppSync resolver.\n *\n * @param handler The AppSyncHandler to use as the resolver.\n */\nexport const createAppSyncHandler =\n  <T, R>(handler: AppSyncHandler<T, R>): AWSLambda.AppSyncResolverHandler<T, R> => {\n    return async (event, context) => {\n      const ctx: AppSyncHandlerContext<T> = {\n        event,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        cognitoAuth: new AppSyncCognitoAuthorizer(event),\n      };\n\n      // set the meta information in logger\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      // set the debug flag for logger\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // log the received event\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // authenticate the incoming request\n        await ctx.cognitoAuth.authenticate();\n        // invoke the handler function with the context\n        return await handler(ctx);\n      } catch (error: any) {\n        const typed = toTypedError(error);\n\n        if (typed && process.env.APPSYNC_TYPED_ERRORS === 'true') {\n          // The envelope-return is gated on APPSYNC_TYPED_ERRORS === 'true'.\n          // GraphQlApi.addLambdaResolver injects that env var only on its\n          // typedErrors: true path, whose APPSYNC_JS resolver has a response\n          // handler that reads this envelope and calls\n          // util.error(errorMessage, errorType, null, errorInfo), turning it into\n          // a GraphQL error on a successful invocation. Returning (not throwing)\n          // keeps the invocation off the Lambda Errors metric.\n          //\n          // When the env var is absent (the default UNIT resolver path, or a\n          // hand-wired handler used without GraphQlApi) the typed error falls\n          // through to the rethrow below, so the invocation fails loudly instead\n          // of surfacing the envelope as field data. Any value other than the\n          // exact string 'true' means rethrow. This is why a default UNIT\n          // resolver whose handler hits an auth assertion (an HttpError) still\n          // fails loudly unless typedErrors is active.\n          ctx.logger.warn(typed.message, { errorType: typed.errorType, errorInfo: typed.errorInfo });\n          return buildErrorEnvelope<R>(typed);\n        }\n        // log the error and throw it again\n        ctx.logger.error(error);\n        throw error;\n      }\n    };\n  };\n\n/**\n * The context for a batched AppSync resolver function.\n * Extends AppSyncHandlerContext so handler code that reads ctx.event.arguments /\n * ctx.event.identity keeps working against the first event, and additionally\n * exposes the full batch of events so the handler can map over it.\n */\nexport interface AppSyncBatchHandlerContext<T, S extends Record<string, any> | null = Record<string, any> | null> extends AppSyncHandlerContext<T> {\n  event: AWSLambda.AppSyncResolverEvent<T, S>;\n  events: AWSLambda.AppSyncResolverEvent<T, S>[];\n}\n\n/**\n * A function that handles an AppSync BatchInvoke event.\n * Receives the batch context and returns the responses in source order.\n */\nexport type AppSyncBatchHandler<T, R, S extends Record<string, any> | null = Record<string, any> | null> = (\n  context: AppSyncBatchHandlerContext<T, S>,\n) => Promise<R[]>;\n\n/**\n * Creates a batched AppSync resolver handler from the given AppSyncBatchHandler.\n * Returns a function that can be used as an AppSync BatchInvoke resolver: array\n * in, array out, order preserved.\n *\n * It mirrors createAppSyncHandler's context and auth plumbing but operates on an\n * array of events. Authentication runs once per batch off the first event, and\n * the context carries both the first event (ctx.event = events[0]) and the full\n * ctx.events array. The handler returns R[] in the same order as the input events.\n *\n * @param handler The AppSyncBatchHandler to use as the resolver.\n */\nexport const createAppSyncBatchHandler =\n  <T, R, S extends Record<string, any> | null = Record<string, any> | null>(\n    handler: AppSyncBatchHandler<T, R, S>,\n  ): AWSLambda.AppSyncBatchResolverHandler<T, R, S> => {\n    return async (events, context) => {\n      // BatchInvoke always delivers a non-empty array; authenticate and build\n      // the context off the first event, exactly like createAppSyncHandler.\n      const first = events[0];\n      const ctx: AppSyncBatchHandlerContext<T, S> = {\n        event: first,\n        events,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        cognitoAuth: new AppSyncCognitoAuthorizer(first),\n      };\n\n      // set the meta information in logger\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      // set the debug flag for logger\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // log the received batch of events\n      ctx.logger.debug(JSON.stringify(events));\n\n      try {\n        // authenticate once per batch off the first event\n        await ctx.cognitoAuth.authenticate();\n        // invoke the handler function with the batch context; it returns R[] in source order\n        return await handler(ctx);\n      } catch (error: any) {\n        const typed = toTypedError(error);\n\n        if (typed && process.env.APPSYNC_TYPED_ERRORS === 'true') {\n          // Same gate and envelope as createAppSyncHandler. AppSync expects one\n          // result per event in a BatchInvoke response, so a batch-level typed\n          // error returns an array of envelopes aligned to the batch length;\n          // each item surfaces the same typed error. Returning (not throwing)\n          // keeps the invocation off the Lambda Errors metric. Without the flag\n          // the typed error falls through to the rethrow below.\n          ctx.logger.warn(typed.message, { errorType: typed.errorType, errorInfo: typed.errorInfo });\n          return events.map(() => buildErrorEnvelope<R>(typed));\n        }\n        // log the error and throw it again\n        ctx.logger.error(error);\n        throw error;\n      }\n    };\n  };\n\n"]}

package/llm.md

@@ -182,6 +182,49 @@ export const handler = createAppSyncHandler<GetItemsQuery, GetItemsResult>(async
 });
 ```
 
+For AppSync BatchInvoke, use `createAppSyncBatchHandler`. It takes an array of resolver events and returns an array of results in the same order (array in, array out, order preserved). It uses the same context as `createAppSyncHandler`, with the logger and the Cognito authorizer resolved once per batch off the first event. The context exposes both the first event as `ctx.event` (so handler code that reads `ctx.event.arguments` / `ctx.event.identity` keeps working) and the full batch as `ctx.events`. The typed-error model is identical to `createAppSyncHandler`: with `APPSYNC_TYPED_ERRORS === 'true'` a thrown `errors.appsync.*` or `errors.HttpError` returns an array of error envelopes aligned to the batch length, and otherwise rethrows. A plain `Error` always fails the invocation.
+
+```typescript
+import { createAppSyncBatchHandler } from 'cdk-serverless/lambda';
+
+export const handler = createAppSyncBatchHandler<GetItemQuery, Item>(async (ctx) => {
+  return Promise.all(ctx.events.map((event) => getItem(event.arguments.id)));
+});
+```
+
+AppSync resolvers can throw typed errors from the `errors.appsync` namespace. `createAppSyncHandler` catches them and logs at `warn`. Whether it returns a `{ data, errorType, errorMessage, errorInfo }` envelope or rethrows is gated on the `APPSYNC_TYPED_ERRORS` environment variable. When `APPSYNC_TYPED_ERRORS === 'true'` the handler returns the envelope so the invocation stays off the Lambda Errors metric. Otherwise it rethrows the typed error, logging at `error`, so the invocation fails. A plain `Error` always fails the invocation regardless of the flag.
+
+```typescript
+import { createAppSyncHandler, errors } from 'cdk-serverless/lambda';
+
+export const handler = createAppSyncHandler<GetItemQuery, Item>(async (ctx) => {
+  const item = await getItem(ctx.arguments.id);
+
+  if (!item) {
+    throw new errors.appsync.NotFoundError('Item not found');
+  }
+
+  return item;
+});
+```
+
+HTTP errors from the shared authorizer are translated the same way. The shared `JwtAuthorizer` base throws `errors.UnauthenticatedError` (401) and `errors.ForbiddenError` (403) from `assertAuthenticated`/`assertGroup`/`assertAdmin`, and `AppSyncCognitoAuthorizer` extends that base, so these reach `createAppSyncHandler`'s catch. `createAppSyncHandler` treats any `errors.HttpError` like a typed error and maps its `statusCode` to an `errorType`: 400 `BadRequest`, 401 `Unauthorized`, 403 `Forbidden`, 404 `NotFound`, any other status `Error`. The mapped error goes through the same `APPSYNC_TYPED_ERRORS` gate and `{ __appSyncError: true, ... }` envelope as `errors.appsync.*` (with `errorInfo` undefined, since `HttpError` carries none). `src/lambda/auth.ts` and the HTTP handler `createHttpHandler` are unchanged. The same rethrow-when-not-activated rule applies, so a default UNIT resolver whose handler hits an auth assertion still fails loudly unless `typedErrors` is active.
+
+The envelope only becomes a GraphQL error when the resolver is wired via `GraphQlApi.addLambdaResolver` and the API opts in with `typedErrors: true`. On that path the method creates an `APPSYNC_JS` pipeline resolver whose response handler reads the envelope and calls `util.error(errorMessage, errorType, null, errorInfo)` (and `util.appendError` for invoke-level errors), turning the typed error into a GraphQL error with the matching `errorType` and `errorInfo`. Without `typedErrors: true`, `addLambdaResolver` creates a plain direct-Lambda UNIT resolver with no response handler, so the envelope is surfaced as the field's data instead. If you build the resolver yourself, replicate that response handler.
+
+The response handler recognises the envelope by a reserved `__appSyncError` sentinel key that `createAppSyncHandler` stamps, not by the presence of an `errorMessage` field. A resolver whose real return type happens to include an `errorMessage` field is therefore passed through unchanged.
+
+Opting in with `typedErrors`: by default `addLambdaResolver` synthesizes a plain direct-Lambda UNIT resolver (the pre-#385 shape), so upgrading consumers who do not opt in see no resolver topology change and no `cdk diff` surprise. Set `typedErrors: true` on the `GraphQlApi` to get the typed `errors.appsync.*` behavior. With the flag enabled, each Lambda-backed field gains a new `AWS::AppSync::FunctionConfiguration` (`LambdaFn${type}.${field}`), and the resolver flips from a `dataSource` UNIT resolver to a `pipelineConfig` + `code` PIPELINE resolver with the response handler described above. The data source and resolver logical IDs are unchanged, so the resolver updates in place rather than being replaced, while the new per-field function resource is additive. The flag applies to all Lambda resolvers on the API, so run `cdk diff` after enabling it to review the topology change.
+
+`maxBatchSize` wins over `typedErrors` per field. When a field passes `maxBatchSize` to `addLambdaResolver`, that field always gets the UNIT BatchInvoke resolver (MaxBatchSize plus the BatchInvoke request template and the `lambdaResult` response template), even when the API has `typedErrors: true`. The batch field gets no APPSYNC_JS pipeline, no `AWS::AppSync::FunctionConfiguration`, and no `APPSYNC_TYPED_ERRORS` env var on its Lambda, so it synthesizes identically whether or not the API enables `typedErrors`. The trade-off is that typed errors thrown by a batch handler are not converted to GraphQL errors. They rethrow and fail the invocation, so do not rely on the typed-error-to-GraphQL-error conversion in a batch handler. Non-batch fields on the same API keep the `typedErrors` pipeline behavior described above.
+
+`APPSYNC_TYPED_ERRORS` is the coupling mechanism between the handler and the pipeline. `createAppSyncHandler` returns the `{ __appSyncError: true, ... }` sentinel envelope only when `APPSYNC_TYPED_ERRORS === 'true'` is set in the Lambda environment, and rethrows the `errors.appsync.*` error otherwise. `GraphQlApi.addLambdaResolver` injects `APPSYNC_TYPED_ERRORS=true` automatically on the `typedErrors: true` path, the same path that carries the response handler to translate the envelope. On the default UNIT path the flag is left unset, so a handler that throws an `errors.appsync.*` error fails the invocation loudly (rethrow) instead of returning a broken envelope as field data. If you wire `createAppSyncHandler` yourself without `GraphQlApi`, set `APPSYNC_TYPED_ERRORS=true` on the Lambda yourself to get envelope behavior and replicate the response handler. Without it, typed errors rethrow.
+
+Two classes share the short names `ForbiddenError` and `NotFoundError`, so pick the namespace deliberately:
+
+- `errors.ForbiddenError` / `errors.NotFoundError` are HTTP errors (HTTP 403 / 404) for `createHttpHandler`. They carry a `statusCode`.
+- `errors.appsync.ForbiddenError` / `errors.appsync.NotFoundError` are AppSync errors for `createAppSyncHandler`. They carry a GraphQL `errorType` (`'Forbidden'` / `'NotFound'`), not an HTTP status code.
+
 #### Error Handling
 
 ```typescript

package/package.json

@@ -101,7 +101,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.3.3",
+  "version": "3.5.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [