cdk-serverless 3.3.2 → 3.4.0

package/lib/lambda/handler.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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,28 @@ 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';
+    }
+}
 /**
  * Creates an AppSync resolver handler from the given AppSyncHandler.
  * Returns a function that can be used as an AppSync resolver.
@@ -225,6 +248,60 @@ const createAppSyncHandler = (handler) => {
             return await handler(ctx);
         }
         catch (error) {
+            // Normalise the two recognised typed-error shapes to a common
+            // { errorType, message, errorInfo } so the gate, envelope and rethrow
+            // below are a single code path.
+            //
+            // - 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. Anything that
+            // is neither (plain Error, Boom) leaves typed undefined and rethrows.
+            let typed;
+            if (error instanceof appsyncErrors.AppSyncError) {
+                typed = { errorType: error.errorType, message: error.message, errorInfo: error.errorInfo };
+            }
+            else if (error instanceof errors.HttpError) {
+                typed = { errorType: httpStatusToErrorType(error.statusCode), message: error.message, errorInfo: undefined };
+            }
+            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.
+                //
+                // __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.
+                ctx.logger.warn(typed.message, { errorType: typed.errorType, errorInfo: typed.errorInfo });
+                return {
+                    __appSyncError: true,
+                    data: null,
+                    errorType: typed.errorType,
+                    errorMessage: typed.message,
+                    errorInfo: typed.errorInfo,
+                };
+            }
             // log the error and throw it again
             ctx.logger.error(error);
             throw error;
@@ -232,4 +309,4 @@ 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"]}
+//# 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 * 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        // Normalise the two recognised typed-error shapes to a common\n        // { errorType, message, errorInfo } so the gate, envelope and rethrow\n        // below are a single code path.\n        //\n        // - appsyncErrors.AppSyncError carries its own GraphQL errorType and an\n        //   optional errorInfo, which flow through unchanged.\n        // - errors.HttpError (the HTTP base thrown by the shared JwtAuthorizer\n        //   via assertAuthenticated/assertGroup/assertAdmin, and by resolver\n        //   code directly) has no GraphQL errorType, so map its statusCode with\n        //   httpStatusToErrorType. HttpError carries no errorInfo, so errorInfo\n        //   is undefined.\n        //\n        // The two instanceof checks are disjoint: HttpError and AppSyncError\n        // share no ancestry, so an appsync.ForbiddenError takes the AppSyncError\n        // branch and an errors.ForbiddenError the HttpError branch. Anything that\n        // is neither (plain Error, Boom) leaves typed undefined and rethrows.\n        let typed: { errorType: string; message: string; errorInfo?: Record<string, any> } | undefined;\n        if (error instanceof appsyncErrors.AppSyncError) {\n          typed = { errorType: error.errorType, message: error.message, errorInfo: error.errorInfo };\n        } else if (error instanceof errors.HttpError) {\n          typed = { errorType: httpStatusToErrorType(error.statusCode), message: error.message, errorInfo: undefined };\n        }\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          //\n          // __appSyncError is a reserved sentinel key the resolver response\n          // handler keys on to recognise this envelope. Branching on the sentinel\n          // (rather than on a bare errorMessage) means a legitimate resolver result\n          // that merely contains an errorMessage field is not misclassified as a\n          // typed error.\n          ctx.logger.warn(typed.message, { errorType: typed.errorType, errorInfo: typed.errorInfo });\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        // 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,37 @@ export const handler = createAppSyncHandler<GetItemsQuery, GetItemsResult>(async
 });
 ```
 
+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.
+
+`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

@@ -7,6 +7,7 @@
   "scripts": {
     "build": "projen build",
     "bump": "projen bump",
+    "bump:releasable-commits": "projen bump:releasable-commits",
     "clobber": "projen clobber",
     "compile": "projen compile",
     "default": "projen default",
@@ -32,13 +33,13 @@
     "organization": true
   },
   "devDependencies": {
-    "@aws-sdk/client-cognito-identity-provider": "3.1029.0",
-    "@aws-sdk/client-dynamodb": "3.1029.0",
-    "@aws-sdk/client-s3": "3.1029.0",
-    "@aws-sdk/lib-dynamodb": "3.1029.0",
+    "@aws-sdk/client-cognito-identity-provider": "3.1150.0",
+    "@aws-sdk/client-dynamodb": "3.1150.0",
+    "@aws-sdk/client-s3": "3.1150.0",
+    "@aws-sdk/lib-dynamodb": "3.1150.0",
     "@hapi/boom": "^10.0.1",
     "@stylistic/eslint-plugin": "^2",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30",
     "@types/js-yaml": "^4.0.9",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/jwk-to-pem": "^2.0.3",
@@ -46,37 +47,37 @@
     "@types/node": "^18",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
-    "aws-cdk-lib": "2.248.0",
-    "commit-and-tag-version": "^12",
+    "aws-cdk-lib": "2.273.0",
+    "commit-and-tag-version": "^13",
     "constructs": "^10.0.0",
     "dynamodb-onetable": "2.7.7",
     "eslint": "^9",
-    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "jest": "^29.7.0",
-    "jest-junit": "^16",
+    "jest": "^30",
+    "jest-junit": "^17",
     "openapi-typescript": "7.13.0",
-    "projen": "0.99.47",
-    "ts-jest": "^29.4.9",
+    "projen": "0.104.5",
+    "ts-jest": "^29",
     "ts-node": "^10.9.2",
-    "typedoc": "0.28.19",
+    "typedoc": "0.28.20",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@aws-sdk/client-cognito-identity-provider": "^3.1014.0",
-    "@aws-sdk/client-dynamodb": "^3.1014.0",
-    "@aws-sdk/client-s3": "^3.1014.0",
-    "@aws-sdk/lib-dynamodb": "^3.1014.0",
-    "aws-cdk-lib": ">=2.248.0 <3.0.0",
+    "@aws-sdk/client-cognito-identity-provider": "^3.1150.0",
+    "@aws-sdk/client-dynamodb": "^3.1150.0",
+    "@aws-sdk/client-s3": "^3.1150.0",
+    "@aws-sdk/lib-dynamodb": "^3.1150.0",
+    "aws-cdk-lib": ">=2.273.0 <3.0.0",
     "dynamodb-onetable": "2.7.7",
     "openapi-typescript": "^7.13.0",
-    "projen": ">=0.99.47 <1.0.0"
+    "projen": ">=0.104.5 <1.0.0"
   },
   "dependencies": {
-    "@types/aws-lambda": "^8.10.161",
+    "@types/aws-lambda": "^8.10.164",
     "constructs": "^10.5.1",
-    "date-fns": "^4.1.0",
-    "js-yaml": "^4.1.1",
+    "date-fns": "^4.4.0",
+    "js-yaml": "^4.3.2",
     "jsonwebtoken": "^9.0.3",
     "jwk-to-pem": "^2.0.7",
     "lambda-log": "^3.1.0"
@@ -96,10 +97,11 @@
   },
   "main": "lib/index.js",
   "license": "Apache-2.0",
+  "stability": "experimental",
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.3.2",
+  "version": "3.4.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [
@@ -140,7 +142,7 @@
       "^.+\\.[t]sx?$": [
         "ts-jest",
         {
-          "tsconfig": "tsconfig.dev.json"
+          "tsconfig": "test/tsconfig.json"
         }
       ]
     }