@liflig/cdk 3.5.9 → 3.6.0

package/lib/api-gateway/http-api-gateway.d.ts

@@ -3,6 +3,7 @@ import type * as elb from "aws-cdk-lib/aws-elasticloadbalancingv2";
 import type * as ec2 from "aws-cdk-lib/aws-ec2";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import type * as sqs from "aws-cdk-lib/aws-sqs";
+import type * as events from "aws-cdk-lib/aws-events";
 import * as apigw from "aws-cdk-lib/aws-apigatewayv2";
 import * as logs from "aws-cdk-lib/aws-logs";
 import * as iam from "aws-cdk-lib/aws-iam";
@@ -130,7 +131,11 @@ export type IntegrationProps =
 /** Use this when connecting a route to send to an SQS queue. */
  | ({
     type: "SQS";
-} & SqsIntegrationProps);
+} & SqsIntegrationProps)
+/** Use this when connecting a route to send to an EventBridge event bus. */
+ | ({
+    type: "EventBridge";
+} & EventBridgeIntegrationProps);
 /**
  * Props for the API-GW -> ALB (Application Load Balancer) integration.
  *
@@ -241,6 +246,21 @@ export type SqsIntegrationProps = {
         };
     };
 };
+export type EventBridgeIntegrationProps = {
+    /**
+     * An EventBridge event bus. Request bodies sent to the route will be forwarded to this event bus,
+     * in the `Detail` field (see
+     * https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html).
+     */
+    eventBus: events.IEventBus;
+    /**
+     * Sets the `DetailType` field (i.e., event type) on events published to the event bus.
+     *
+     * See AWS docs for more on this:
+     * https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
+     */
+    detailType: string;
+};
 export type AuthorizationProps<AuthScopesT extends string = string> = 
 /**
  * No authentication, for when you want a fully public route (or handle authentication in the

package/lib/api-gateway/http-api-gateway.js

@@ -324,6 +324,27 @@ export class ApiGateway extends constructs.Construct {
                     payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_1_0,
                 });
             }
+            case "EventBridge": {
+                // API-GW does not have access to put events to event bus by default
+                const role = new iam.Role(this, `ApiGwTo${integration.eventBus.node.id}ServiceRole`, {
+                    description: `Allows API-GW to put events to ${integration.eventBus.eventBusArn}`,
+                    assumedBy: new iam.ServicePrincipal("apigateway.amazonaws.com"),
+                });
+                integration.eventBus.grantPutEventsTo(role);
+                const parameterMapping = new apigw.ParameterMapping()
+                    // https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
+                    .custom("EventBusName", integration.eventBus.eventBusName)
+                    .custom("Detail", "$request.body")
+                    .custom("DetailType", integration.detailType)
+                    .custom("Source", "$context.apiId");
+                return new EventBridgeRouteIntegration("EventBridgeIntegration", {
+                    type: apigw.HttpIntegrationType.AWS_PROXY,
+                    subtype: apigw.HttpIntegrationSubtype.EVENTBRIDGE_PUT_EVENTS,
+                    credentials: apigw.IntegrationCredentials.fromRole(role),
+                    parameterMapping: parameterMapping,
+                    payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_1_0,
+                });
+            }
         }
     }
     /**
@@ -367,6 +388,29 @@ class SqsRouteIntegration extends apigw.HttpRouteIntegration {
         return this.integrationProps;
     }
 }
+/** Acts as glue (between the integration props and the HttpApi) when creating an EventBridge integration. */
+class EventBridgeRouteIntegration extends apigw.HttpRouteIntegration {
+    integrationProps;
+    /**
+     * @param id The id used in the {@link apigw.HttpIntegration} construct
+     *    created internally by {@link apigw.HttpRouteIntegration._bindToRoute}.
+     *    [Source code](https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L321)
+     * @param integrationProps The props to pass to the {@link apigw.HttpIntegration} construct.
+     */
+    constructor(id, integrationProps) {
+        super(id);
+        this.integrationProps = integrationProps;
+    }
+    /**
+     * This sends the properties needed for creating a {@link apigw.HttpIntegration} to the
+     * {@link apigw.HttpRouteIntegration}.
+     */
+    bind() {
+        // This method is called by:
+        // https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L319
+        return this.integrationProps;
+    }
+}
 /**
  * When using `NodejsFunction` with `entry`, we point CDK to a file with our lambda code. This can
  * either be a TypeScript or JavaScript file. When creating constructs in tests inside this library,
@@ -478,4 +522,4 @@ function shortHash(str) {
     // which is fine
     return createHash("sha1").update(str).digest("hex").substring(0, 10);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-api-gateway.js","sourceRoot":"","sources":["../../src/api-gateway/http-api-gateway.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as cdk from \"aws-cdk-lib\"\nimport type * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\"\nimport type * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport type * as sqs from \"aws-cdk-lib/aws-sqs\"\nimport * as apigw from \"aws-cdk-lib/aws-apigatewayv2\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport * as integrations from \"aws-cdk-lib/aws-apigatewayv2-integrations\"\nimport * as authorizers from \"aws-cdk-lib/aws-apigatewayv2-authorizers\"\nimport type { IUserPool } from \"aws-cdk-lib/aws-cognito\"\nimport * as lambdaNodejs from \"aws-cdk-lib/aws-lambda-nodejs\"\nimport { createHash } from \"crypto\"\nimport { tagResources } from \"../tags\"\nimport * as path from \"path\"\nimport { fileURLToPath } from \"url\"\nimport { ApiGatewayDnsProps, ApiGatewayDomain } from \"./domain\"\nimport { ApiGatewayAccessLogs, ApiGatewayAccessLogsProps } from \"./access-logs\"\n\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\n\n/**\n * Props for the {@link ApiGateway} construct.\n *\n * @author Kristian Rekstad <kre@capraconsulting.no>\n * @author Hermann Mørkrid <hem@liflig.no>\n */\nexport type ApiGatewayProps<AuthScopesT extends string = string> = {\n  /** Settings for the external-facing part of the API-GW. */\n  dns: ApiGatewayDnsProps\n\n  /**\n   * If no integration is specified for a route, this integration is used.\n   *\n   * See {@link IntegrationProps} for the available options.\n   */\n  defaultIntegration?: IntegrationProps\n\n  /**\n   * If no authorization is specified for a route, this authorization is used.\n   *\n   * See {@link AuthorizationProps} for the available options.\n   */\n  defaultAuthorization?: AuthorizationProps<AuthScopesT>\n\n  routes: ApiGatewayRoute<AuthScopesT>[]\n\n  /**\n   * The API-GW access logs for the `$default` stage are kept.\n   * This has options for the logs.\n   */\n  accessLogs?: ApiGatewayAccessLogsProps\n\n  /**\n   * Set to false to disable route-level metrics.\n   * This can increase CloudWatch costs when not disabled.\n   *\n   * See [AWS: Working with metrics for HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-metrics.html?icmpid=apigateway_console_help#:~:text=and%20stage%20ID.-,ApiId%2C%20Stage%2C%20Route,-Filters%20API%20Gateway)\n   * for more info.\n   *\n   * @default true\n   */\n  detailedMetrics?: boolean\n\n  /**\n   * Throttling of requests.\n   * If not set, the AWS default of 5000 burst and 10000 rate is used.\n   *\n   * The default throttling is per-account, and counts all APIs in the account and region.\n   * If you have another API in this region getting 10_000 request rate, it may impact this API as well.\n   */\n  throttling?: {\n    /**\n     * Going over `5_000` may require you to contact AWS Support - they are account bound.\n     */\n    burst?: number\n    /**\n     * Going over `10_000` may require you to contact AWS Support - they are account bound.\n     */\n    rate?: number\n  }\n\n  /**\n   * Sets CORS headers on responses from the API Gateway to allow all origins, headers and methods.\n   * Useful if your API should be accessed by any browser.\n   */\n  corsAllowAll?: boolean\n\n  /**\n   * If some settings in this construct do not work for you, this is an escape hatch mechanism to\n   * override anything.\n   */\n  propsOverride?: {\n    /**\n     * Override settings for the {@link apigw.HttpApi} (accessible in {@link ApiGateway.httpApi}).\n     *\n     * For example, if you have a frontend accessing this API, you might want to set\n     * [CORS preflight](https://docs.aws.amazon.com/cdk/api/v1/docs/aws-apigatewayv2-readme.html#cross-origin-resource-sharing-cors)\n     * settings.\n     */\n    httpApi?: Partial<apigw.HttpApiProps>\n  }\n}\n\nexport type ApiGatewayRoute<AuthScopesT extends string = string> = {\n  /** The path of the route to expose through the API Gateway. Use \"/\" for the root route. */\n  path: string\n\n  /**\n   * By default, we only forward requests that match the route's path exactly. So for a route with\n   * path `/api/users`, a request to `/api/users` will be forwarded, but a request to\n   * `/api/users/admin` will not. If you want to forward requests to all sub-paths under the route's\n   * path, you can set this to true.\n   *\n   * @default false\n   */\n  includeSubpaths?: boolean\n\n  /**\n   * The HTTP method to expose. `ANY` exposes all HTTP methods on the path.\n   *\n   * @default \"ANY\"\n   */\n  method?: HttpMethod\n\n  /**\n   * The integration that the route will forward to. See {@link IntegrationProps} for the available\n   * options.\n   *\n   * If undefined, uses the {@link ApiGatewayProps.defaultIntegration}.\n   */\n  integration?: IntegrationProps\n\n  /**\n   * How requests on the route are authenticated. See {@link AuthorizationProps} for the available\n   * options.\n   *\n   * If undefined, uses the {@link ApiGatewayProps.defaultAuthorization}.\n   */\n  authorization?: AuthorizationProps<AuthScopesT>\n}\n\nexport type HttpMethod =\n  | \"ANY\"\n  | \"GET\"\n  | \"POST\"\n  | \"PUT\"\n  | \"PATCH\"\n  | \"DELETE\"\n  | \"OPTIONS\"\n  | \"HEAD\"\n\nexport type IntegrationProps =\n  /** Use this when connecting the route to an ALB (Application Load Balancer). */\n  | ({ type: \"ALB\" } & AlbIntegrationProps)\n  /** Use this when connecting route to a Lambda. */\n  | ({ type: \"Lambda\" } & LambdaIntegrationProps)\n  /** Use this when connecting a route to send to an SQS queue. */\n  | ({ type: \"SQS\" } & SqsIntegrationProps)\n\n/**\n * Props for the API-GW -> ALB (Application Load Balancer) integration.\n *\n * See the note on {@link ApiGateway} about the load balancer security group.\n */\nexport type AlbIntegrationProps = {\n  /**\n   * A listener on e.g. port 443 (HTTPS).\n   *\n   * See the note on {@link ApiGateway} about the load balancer security group.\n   */\n  loadBalancerListener: elb.IApplicationListener\n\n  /**\n   * The host name (domain name) of the backend service that we want to reach through the ALB.\n   *\n   * This is used to:\n   * - Verify the HTTPS certificate of the backend service, so that the request forwarded from\n   *   API-GW can use TLS\n   * - Set the `Host` header on the request when forwarding to the ALB, so that requests can be\n   *   routed to the correct Target Group\n   *\n   * Example value: `<service>.staging.my-project.liflig.io` (not prefixed by `https://`).\n   */\n  hostName: string\n\n  /**\n   * The VPC used by the ALB. The API-GW integration will connect to the ALB using a VPC Link for\n   * this VPC.\n   *\n   * See the note on {@link ApiGateway} about the load balancer security group.\n   */\n  vpc: ec2.IVpc\n\n  /**\n   * A security group (SG) that allows incoming traffic to the ALB. Will be used by the VPC link, so\n   * the API-GW integration can connect.\n   *\n   * This is usually the same SG as the ALB uses, because they have a rule that allows traffic from\n   * others in the same SG.\n   *\n   * See the note on {@link ApiGateway} about the load balancer security group.\n   */\n  securityGroup: ec2.ISecurityGroup\n\n  /**\n   * Map request parameters (add/overwrite path/headers/query params) before forwarding to the\n   * backend.\n   *\n   * See {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-parameter-mapping.html}\n   * for more on this. Read the 'Reserved headers' section for which headers cannot be overridden.\n   * In addition to the AWS-reserved headers, you should not override the 'Host' header either, as\n   * that's used for routing the request to the correct service behind the load balancer.\n   *\n   * ### Example:\n   *\n   * Adding a header:\n   * ```\n   * mapParameters: (parameters) => parameters.overwriteHeader(\n   *    \"X-My-Custom-Header\",\n   *    apigw.MappingValue.custom(\"my-custom-value\"),\n   * )\n   * ```\n   *\n   * Overwriting the path (if, for example, you configure a `/users` route on the API Gateway that\n   * you want to forward to `/api/users` on the backend):\n   * ```\n   * mapParameters: (parameters) => parameters.overwritePath(\"/api/users\")\n   * ```\n   */\n  mapParameters?: (parameters: apigw.ParameterMapping) => void\n}\n\nexport type LambdaIntegrationProps = {\n  /**\n   * The Lambda integration uses the V2 payload format:\n   * {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html}\n   *\n   * If writing the Lambda in TypeScript, this means you should use `APIGatewayProxyEventV2` as the\n   * request type, and `APIGatewayProxyResultV2` as the response type.\n   */\n  lambda: lambda.IFunction\n}\n\nexport type SqsIntegrationProps = {\n  queue: sqs.IQueue\n\n  /**\n   * Message attributes to pass on to SQS. The keys in this object are the names of the attributes.\n   * Each attribute has a DataType field, and either a StringValue or BinaryValue field depending on\n   * its type. See AWS docs:\n   * https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_MessageAttributeValue.html\n   *\n   * In the StringValue field, you can do API Gateway parameter mapping:\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-parameter-mapping.html\n   *\n   * Example:\n   * ```\n   * messageAttributes: {\n   *   clientId: {\n   *     DataType: \"String\",\n   *     StringValue: \"${context.authorizer.clientId}\",\n   *   },\n   * },\n   * ```\n   */\n  messageAttributes?: {\n    [attributeName: string]:\n      | { DataType: \"String\" | \"Number\"; StringValue: string }\n      | {\n          DataType: \"Binary\"\n          /** Base64-encoded binary data object. */\n          BinaryValue: string\n        }\n  }\n}\n\nexport type AuthorizationProps<AuthScopesT extends string = string> =\n  /**\n   * No authentication, for when you want a fully public route (or handle authentication in the\n   * backend integration).\n   */\n  | { type: \"NONE\" }\n  /**\n   * AWS IAM authorization.\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-access-control-iam.html\n   */\n  | { type: \"IAM\" }\n  /**\n   * Creates a custom Lambda authorizer which reads `Authorization: Bearer <access token>` header\n   * and verifies the token against a Cognito user pool.\n   */\n  | ({\n      type: \"COGNITO_USER_POOL\"\n    } & CognitoUserPoolAuthorizerProps<AuthScopesT>)\n  /**\n   * Creates a custom Lambda authorizer which reads `Authorization: Basic <base64-encoded credentials>`\n   * header and verifies the credentials against a given secret.\n   */\n  | ({ type: \"BASIC_AUTH\" } & BasicAuthAuthorizerProps)\n  /**\n   * Creates a custom Lambda authorizer which allows both:\n   * - `Authorization: Bearer <access token>` header, for which the token is checked against the\n   *   given Cognito user pool\n   * - `Authorization: Basic <base64-encoded credentials>` header, for which the credentials are\n   *   checked against the credentials from the given basic auth secret name\n   *\n   * If either of these are given and valid, the request is authenticated.\n   */\n  | ({\n      type: \"COGNITO_USER_POOL_OR_BASIC_AUTH\"\n    } & CognitoUserPoolOrBasicAuthAuthorizerProps<AuthScopesT>)\n  /**\n   * Creates a custom authorizer with the given Lambda function. Use this if you have custom\n   * authorization logic, and the other authorizers from this construct don't meet your needs.\n   *\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html\n   */\n  | ({ type: \"CUSTOM_LAMBDA_AUTHORIZER\" } & CustomLambdaAuthorizerProps)\n\nexport type CognitoUserPoolAuthorizerProps<\n  AuthScopesT extends string = string,\n> = {\n  userPool: IUserPool\n\n  /**\n   * Verifies that access token claims contain the given scope.\n   *\n   * When defined as part of a resource server, scopes are on the format:\n   * `{resource server identifier}/{scope name}`, e.g. `external/view_users`.\n   *\n   * To get more type safety on this parameter, see the docs for the `AuthScopesT` type parameter on\n   * {@link ApiGateway}.\n   */\n  requiredScope?: AuthScopesT\n\n  /**\n   * Name of secret in AWS Secrets Manager that stores basic auth credentials for the backend\n   * service, to be forwarded to the backend if Cognito user pool authentication succeeded.\n   *\n   * The secret value must follow this format:\n   * ```json\n   * { \"username\": \"<username>\", \"password\": \"<password>\" }\n   * ```\n   *\n   * This prop solves the following use-case:\n   * - You want to do Cognito user pool authentication in the API Gateway\n   * - You want an additional auth check in the backend, but you don't want to deal with Cognito\n   *   there\n   * - The backend uses basic auth\n   *\n   * This prop solves this by letting you specify credentials to pass to the backend after API-GW\n   * authentication succeeds. You can pass the encoded credentials through\n   * {@link AlbIntegrationProps.mapParameters}, using the `authorizer.internalAuthorizationHeader`\n   * context variable, like so:\n   * ```\n   * mapParameters: (parameters) => parameters.overwriteHeader(\n   *   // 'Authorization' header cannot be overridden, so we use a custom header\n   *   \"X-Internal-Authorization\",\n   *   apigw.MappingValue.contextVariable(\"authorizer.internalAuthorizationHeader\"),\n   * )\n   * ```\n   * The backend can then check the `X-Internal-Authorization` header.\n   */\n  credentialsForInternalAuthorization?: string\n}\n\nexport type BasicAuthAuthorizerProps = {\n  /**\n   * Name of secret in AWS Secrets Manager that stores basic auth credentials.\n   *\n   * The following formats are supported for the secret value:\n   * - Single username and password:\n   *   ```json\n   *   { \"username\": \"<username>\", \"password\": \"<password>\" }\n   *   ```\n   * - Array of username + password objects:\n   *   ```json\n   *   { \"credentials\": \"[{\\\"username\\\":\\\"<user-1>\\\",\\\"password\\\":\\\"password-1\\\"},{\\\"username\\\":\\\"<user-2>\\\",\\\"password\\\":\\\"<password-2>\\\"}]\" }\n   *   ```\n   *   - The value of the `credentials` field is a string, with a stringified, escaped JSON array of\n   *     objects with `username` and `password` fields.\n   *   - The reason that this second format stores stringified JSON _inside_ JSON, is due to a\n   *     limitation in Liflig's `load-secrets` library, which only allows storing string values.\n   * - Array of base64-encoded credentials:\n   *   ```json\n   *   { \"credentials\": \"[\\\"<encoded-credential-1>\\\",\\\"<encoded-credential-2>\\\"]\" }\n   *   ```\n   *   - Each element is encoded from `<username>:<password>`.\n   *   - The array is stringified for the same reason as above.\n   *\n   * If the secret uses one of the array formats, the authorizer will match the request's\n   * Authorization header against any one of the credentials.\n   */\n  credentialsSecretName: string\n}\n\nexport type CognitoUserPoolOrBasicAuthAuthorizerProps<\n  AuthScopesT extends string = string,\n> = {\n  userPool: IUserPool\n\n  /**\n   * Name of secret in AWS Secrets Manager that stores basic auth credentials.\n   *\n   * See {@link BasicAuthAuthorizerProps.credentialsSecretName} for the supported formats.\n   */\n  basicAuthCredentialsSecretName?: string\n\n  /**\n   * Verifies that access token claims contain the given scope. Only applicable for requests that\n   * use `Authorization: Bearer <access token>` (not applicable for basic auth).\n   *\n   * When defined as part of a resource server, scopes are on the format:\n   * `{resource server identifier}/{scope name}`, e.g. `external/view_users`.\n   *\n   * To get more type safety on this parameter, see the docs for the `AuthScopesT` type parameter on\n   * {@link ApiGateway}.\n   */\n  requiredScope?: AuthScopesT\n}\n\ntype CustomLambdaAuthorizerProps = {\n  /**\n   * The Lambda function that will be run whenever the API Gateway route is invoked, to authenticate\n   * the request. See AWS docs for more on how to write the Lambda:\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html\n   *\n   * The default response format used is `HttpLambdaResponseType.SIMPLE` (format 2.0). If you write\n   * your Lambda in TypeScript, this means that your handler must return\n   * `APIGatewaySimpleAuthorizerResult` (from the `aws-lambda` package). The request event will also\n   * use format 2.0 (`APIGatewayRequestAuthorizerEventV2` in TypeScript). See the AWS docs linked\n   * above for more details on these formats.\n   *\n   * You can override the response format type in\n   * {@link CustomLambdaAuthorizerProps.authorizerProps}.\n   *\n   * See the Lambdas under the `authorizers` folder next to the `ApiGateway` construct in\n   * `liflig-cdk` for examples.\n   */\n  lambdaAuthorizer: lambda.IFunction\n\n  /**\n   * Props for the `HttpLambdaAuthorizer` construct. We provide some different defaults:\n   * - `responseTypes` defaults to `[HttpLambdaResponseType.SIMPLE]`\n   * - `resultsCacheTtl` defaults to `Duration.hours(1)`\n   */\n  authorizerProps?: Partial<authorizers.HttpLambdaAuthorizerProps>\n}\n\n/**\n * This construct tries to simplify the creation of an API Gateway for a service, by collecting most\n * of the common setup here.\n *\n * The approach followed in this construct is:\n * 1. One API-GW per service\n * 2. One subdomain per API-GW / service\n * 3. Use HTTP API, not REST\n * 4. Use a $default stage with autodeploy\n * 5. Support multiple routes (with possible `/{proxy+}` to let all sub-paths through)\n * 6. Allow custom integration/authorizer for each route, or defaults for the whole gateway\n *\n * The route integration is one of these:\n * - ALB private integration with VPC Link using HTTPS to the ALB\n * - Lambda integration\n * - SQS integration\n *\n * ### Load Balancer Security Group\n *\n * Note that the load balancer used in an {@link AlbIntegrationProps} must allow outbound HTTPS\n * traffic to its SecurityGroup. Otherwise, the VPC Link used by the API-GW can't get traffic from\n * the ALB.\n *\n * ```\n * const loadBalancerSecurityGroup = new ec2.SecurityGroup(..., {\n *   allowAllOutbound: false,\n * })\n *\n * loadBalancerSecurityGroup.addEgressRule(\n *   loadBalancerSecurityGroup,\n *   ec2.Port.tcp(443),\n *   \"Outbound to self for ALB to API-GW VPC-Link\",\n * )\n *\n * const loadBalancer = new lifligLoadBalancer.LoadBalancer(...,\n *   {\n *     overrideLoadBalancerProps: {\n *       securityGroup: loadBalancerSecurityGroup,\n *     },\n *   },\n * )\n * ```\n *\n * @template AuthScopesT This type parameter allows you to improve type safety on the\n * `requiredScope` field on {@link CognitoUserPoolOrBasicAuthAuthorizerProps}, by narrowing the type\n * to specific strings. You can then extend the `ApiGateway` with this type to enforce those scopes\n * across the application. Remember that auth scopes must be on the format\n * `{resource server identifier}/{scope name}`.\n *\n * Example:\n * ```\n * type AuthScopes = \"external/read_users\" | \"internal/create_users\"\n *\n * export class MyProjectApiGateway extends ApiGateway<AuthScopes> {}\n * ```\n * TypeScript will then enforce that `requiredScope` is one of `AuthScopes`, and provide\n * auto-complete.\n *\n * @author Kristian Rekstad <kre@capraconsulting.no>\n * @author Hermann Mørkrid <hem@liflig.no>\n */\nexport class ApiGateway<\n  AuthScopesT extends string = string,\n> extends constructs.Construct {\n  /** The API Gateway HTTP API. This is the main construct for API-GW. */\n  public readonly httpApi: apigw.HttpApi\n\n  /** The routes which connect the {@link httpApi} to the backend integration(s). */\n  public readonly routes: apigw.HttpRoute[] = []\n\n  /** The domain which consumers must use.*/\n  public readonly domain: string\n\n  /** Access log group. */\n  public readonly logGroup: logs.LogGroup\n\n  private readonly props: ApiGatewayProps<AuthScopesT>\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: ApiGatewayProps<AuthScopesT>,\n  ) {\n    super(scope, id)\n    this.props = props\n\n    ApiGateway.validateProps(props, id, cdk.Stack.of(this))\n\n    const customDomain = new ApiGatewayDomain(this, \"CustomDomain\", props.dns)\n    this.domain = customDomain.fullDomainName\n\n    let corsOptions: apigw.CorsPreflightOptions | undefined\n    if (props.corsAllowAll) {\n      corsOptions = {\n        allowOrigins: [\"*\"],\n        // \"The Authorization header can't be wildcarded and always needs to be listed explicitly\"\n        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers\n        // Content-Type may also require explicit whitelisting: https://stackoverflow.com/a/63567647\n        allowHeaders: [\"Authorization\", \"Content-Type\", \"*\"],\n        // Not using '*' here, because \"In requests with credentials, it is treated as the literal\n        // method name '*' without special semantics\"\n        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods\n        allowMethods: [\n          apigw.CorsHttpMethod.GET,\n          apigw.CorsHttpMethod.POST,\n          apigw.CorsHttpMethod.PUT,\n          apigw.CorsHttpMethod.PATCH,\n          apigw.CorsHttpMethod.DELETE,\n          apigw.CorsHttpMethod.OPTIONS,\n          apigw.CorsHttpMethod.HEAD,\n        ],\n        maxAge: cdk.Duration.days(1),\n      }\n    }\n\n    // The actual API. This holds the routes, authorizers and integrations.\n    const api = new apigw.HttpApi(this, \"HttpApi-\" + props.dns.subdomain, {\n      // defaultIntegration: defaultIntegration, // This is for a catch-all $default route\n      description: `An HTTP API for ${props.dns.subdomain}.${props.dns.hostedZone.zoneName}.`,\n      disableExecuteApiEndpoint: true, // Force externals to go through custom domain. MUST be true when using Mutual TLS, for security reasons\n      createDefaultStage: true,\n      defaultDomainMapping: { domainName: customDomain.apiGwDomainName },\n      corsPreflight: corsOptions,\n      ...props?.propsOverride?.httpApi,\n    })\n    this.httpApi = api\n\n    const stage = api.defaultStage?.node.defaultChild as apigw.CfnStage\n\n    const logs = new ApiGatewayAccessLogs(\n      this,\n      \"AccessLogs\",\n      stage,\n      props.accessLogs,\n    )\n    this.logGroup = logs.logGroup\n\n    stage.defaultRouteSettings = {\n      ...stage.defaultRouteSettings,\n      detailedMetricsEnabled: props.detailedMetrics ?? true,\n      throttlingBurstLimit: props.throttling?.burst, // Default for account is 5_000\n      throttlingRateLimit: props.throttling?.rate, // Default for account is 10_000\n    }\n\n    const defaultIntegration = props.defaultIntegration\n      ? this.createIntegration(props.defaultIntegration, props.dns)\n      : undefined\n\n    const defaultAuthorizer = props.defaultAuthorization\n      ? this.createAuthorizer(\"DefaultAuthorizer\", props.defaultAuthorization)\n      : undefined\n\n    for (const route of props.routes) {\n      let integration: apigw.HttpRouteIntegration\n      if (route.integration) {\n        integration = this.createIntegration(route.integration, props.dns)\n      } else {\n        integration = defaultIntegration! // Verified in validateProps\n      }\n\n      let authorizer: apigw.IHttpRouteAuthorizer | undefined\n      if (route.authorization) {\n        authorizer = this.createAuthorizer(\n          // Using the route path here caused CloudFormation to fail due to resource names being too\n          // long. Therefore, we now hash the route path to get a shorter name.\n          `RouteAuthorizer${shortHash(`${route.method ?? \"\"}${route.path}`)}`,\n          route.authorization,\n        )\n      } else {\n        authorizer = defaultAuthorizer\n      }\n\n      const routePaths = [route.path]\n      if (route.includeSubpaths === true) {\n        // If we include sub-paths, we add an additional route with /{proxy+} (the + means it will\n        // match all subroutes). We want both this route and the normal route without /{proxy+},\n        // since /{proxy+} will only match the base path with trailing slash.\n        routePaths.push(\n          route.path + (route.path === \"/\" ? \"\" : \"/\") + \"{proxy+}\",\n        )\n      }\n\n      for (const routePath of routePaths) {\n        // The previous version of the API Gateway construct had a single route with the ID\n        // 'DefaultProxyRoute', and all gateways we used exposed the route /{proxy+}. When trying to\n        // change to this new version of the construct, deployment failed for gateways exposing\n        // /{proxy+}, because \"a route with that key [i.e. path + method] already exists\". We think\n        // this may be because we used the same route path, but with a new route ID, causing\n        // confusion for CloudFormation. So we keep the old route ID here for /{proxy+}.\n        const routeId =\n          routePath === \"/{proxy+}\" ? \"DefaultProxyRoute\" : `Route-${routePath}`\n\n        this.routes.push(\n          new apigw.HttpRoute(this, routeId, {\n            httpApi: api,\n            integration: integration,\n            authorizer: authorizer,\n            routeKey: apigw.HttpRouteKey.with(\n              routePath,\n              route.method\n                ? apigw.HttpMethod[route.method]\n                : apigw.HttpMethod.ANY,\n            ),\n          }),\n        )\n      }\n    }\n\n    tagResources(this, () => ({ service: props.dns.subdomain }))\n  }\n\n  /** @throws Error */\n  private static validateProps(\n    props: ApiGatewayProps,\n    id: string,\n    stack: cdk.Stack,\n  ) {\n    for (const route of props.routes) {\n      if (!route.integration && !props.defaultIntegration) {\n        throw new Error(\n          `No integration defined for route '${route.path}', and no default integration specified for the gateway`,\n        )\n      }\n      if (!route.authorization && !props.defaultAuthorization) {\n        throw new Error(\n          `No authorization defined for route '${route.path}', and no default authorization specified for the gateway`,\n        )\n      }\n      if (!route.path.startsWith(\"/\")) {\n        throw new Error(\n          `Invalid path '${route.path}': paths must begin with '/' (use '/' for root path)`,\n        )\n      }\n      if (route.path !== \"/\" && route.path.endsWith(\"/\")) {\n        throw new Error(\n          `Invalid path '${route.path}': paths cannot end with '/' (except root path)`,\n        )\n      }\n      if (\n        route.integration?.type === \"ALB\" &&\n        route.integration.hostName.startsWith(\"https:\")\n      ) {\n        throw new Error(\n          `The albIntegration.hostHttpsName should not include a protocol: ${route.integration.hostName}`,\n        )\n      }\n    }\n    if (props.dns.subdomain === \"\" || props.dns.subdomain.includes(\" \")) {\n      throw new Error(\n        `Subdomain must be set, and not contain spaces: ${props.dns.subdomain}`,\n      )\n    }\n    if (props.throttling?.burst && props.throttling.burst > 5_000) {\n      console.warn(\n        `⚠️ Your throttling burst limit '${props.throttling.burst}' is higher than the AWS Account limit. Make sure your account has upgraded this quota! `,\n        stack,\n        id,\n      )\n    }\n    if (props.throttling?.rate && props.throttling.rate > 10_000) {\n      console.warn(\n        `⚠️ Your throttling rate limit '${props.throttling.rate}' is higher than the AWS Account limit. Make sure your account has upgraded this quota! `,\n        stack,\n        id,\n      )\n    }\n  }\n\n  /**\n   * The authorizer only accepts requests from external users that are authorized.\n   * Unauthorized users are stopped in the API-GW, and not forwarded to the integration.\n   */\n  private createAuthorizer<AuthScopesT extends string>(\n    id: string,\n    authorization: AuthorizationProps<AuthScopesT>,\n  ): apigw.IHttpRouteAuthorizer | undefined {\n    switch (authorization.type) {\n      case \"NONE\": {\n        return undefined\n      }\n      case \"IAM\": {\n        // API Gateway invokes your API route only if the client has execute-api permission for the route.\n        // The client has to use AWS SigV4 to identify themselves in the request.\n        // Read this page for help with IAM and API-GW https://docs.aws.amazon.com/apigateway/latest/developerguide/security_iam_service-with-iam.html\n        // Note that [resource policies are not supported yet for HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-access-control-iam.html)\n        return new authorizers.HttpIamAuthorizer()\n      }\n      case \"COGNITO_USER_POOL\": {\n        // We use a custom lambda authorizer here instead of the `HttpUserPoolAuthorizer` provided\n        // by CDK, in order to support `requiredScope` and setting of custom context variables.\n        const authorizer = new CognitoUserPoolAuthorizer(\n          this,\n          id + \"Lambda\",\n          authorization,\n        )\n\n        return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {\n          responseTypes: authorizer.responseTypes,\n          // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials\n          resultsCacheTtl: cdk.Duration.hours(1),\n        })\n      }\n      case \"BASIC_AUTH\": {\n        const authorizer = new BasicAuthAuthorizer(\n          this,\n          id + \"Lambda\",\n          authorization,\n        )\n\n        return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {\n          responseTypes: authorizer.responseTypes,\n          // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials\n          resultsCacheTtl: cdk.Duration.minutes(30),\n        })\n      }\n      case \"COGNITO_USER_POOL_OR_BASIC_AUTH\": {\n        const authorizer = new CognitoUserPoolOrBasicAuthAuthorizer(\n          this,\n          id + \"Lambda\",\n          authorization,\n        )\n\n        return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {\n          responseTypes: authorizer.responseTypes,\n          // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials\n          resultsCacheTtl: cdk.Duration.hours(1),\n        })\n      }\n      case \"CUSTOM_LAMBDA_AUTHORIZER\": {\n        return new authorizers.HttpLambdaAuthorizer(\n          id,\n          authorization.lambdaAuthorizer,\n          {\n            ...authorization.authorizerProps,\n            responseTypes: authorization.authorizerProps?.responseTypes ?? [\n              authorizers.HttpLambdaResponseType.SIMPLE,\n            ],\n            resultsCacheTtl:\n              authorization.authorizerProps?.resultsCacheTtl ??\n              cdk.Duration.hours(1),\n          },\n        )\n      }\n    }\n  }\n\n  private createIntegration(\n    integration: IntegrationProps,\n    dns: ApiGatewayProps[\"dns\"],\n  ): apigw.HttpRouteIntegration {\n    switch (integration.type) {\n      case \"ALB\": {\n        // The VPCLink connects the integration into the ALB's VPC. Must be manually created when\n        // the VPC is imported, which is the case when using CorePlatformConsumer.\n        const vpcLink = new apigw.VpcLink(this, \"AlbVpcLink\", {\n          vpc: integration.vpc,\n          securityGroups: [integration.securityGroup],\n          subnets: integration.vpc.selectSubnets(), // This correctly selects the private subnets\n        })\n\n        const parameterMapping = new apigw.ParameterMapping()\n          /** See {@link AlbIntegrationProps.hostName} */\n          .overwriteHeader(\n            \"Host\",\n            // The Host header can NOT use dynamic mapping, like $context.domainName etc.\n            apigw.MappingValue.custom(integration.hostName),\n          )\n        if (integration.mapParameters !== undefined) {\n          integration.mapParameters(parameterMapping)\n        }\n\n        return new integrations.HttpAlbIntegration(\n          \"AlbIntegration-\" + dns.subdomain,\n          integration.loadBalancerListener,\n          {\n            secureServerName: integration.hostName,\n            vpcLink: vpcLink,\n            method: apigw.HttpMethod.ANY,\n            parameterMapping,\n          },\n        )\n      }\n      case \"Lambda\": {\n        return new integrations.HttpLambdaIntegration(\n          \"LambdaIntegration\",\n          integration.lambda,\n          {\n            payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_2_0,\n            parameterMapping: undefined,\n          },\n        )\n      }\n      case \"SQS\": {\n        // API-GW does not have access to SQS by default\n        const role = new iam.Role(\n          this,\n          `ApiGwTo${integration.queue.node.id}ServiceRole`,\n          {\n            description:\n              \"Allows API-GW to add messages to \" + integration.queue.queueArn,\n            assumedBy: new iam.ServicePrincipal(\"apigateway.amazonaws.com\"),\n          },\n        )\n        integration.queue.grantSendMessages(role)\n\n        let parameterMapping = new apigw.ParameterMapping()\n          // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-aws-services-reference.html#SQS-SendMessage\n          .custom(\"QueueUrl\", integration.queue.queueUrl)\n          .custom(\"MessageBody\", \"$request.body\")\n          .custom(\"Region\", \"eu-west-1\") // Change this if the SQS queue is in another region!\n\n        if (integration.messageAttributes) {\n          parameterMapping = parameterMapping.custom(\n            \"MessageAttributes\",\n            JSON.stringify(integration.messageAttributes),\n          )\n        }\n\n        return new SqsRouteIntegration(\"SqsIntegration\", {\n          type: apigw.HttpIntegrationType.AWS_PROXY,\n          subtype: apigw.HttpIntegrationSubtype.SQS_SEND_MESSAGE,\n          credentials: apigw.IntegrationCredentials.fromRole(role),\n          parameterMapping: parameterMapping,\n          payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_1_0,\n        })\n      }\n    }\n  }\n\n  /**\n   * Allows a grantable target (role, user etc.) permission to invoke the API.\n   * Only works when using `IAM` as {@link ApiGatewayRoute.authorization}.\n   *\n   * @param target A grantable, like {@link iam.Role}\n   */\n  public grantInvoke(target: iam.IGrantable) {\n    for (const routeProps of this.props.routes) {\n      const authType =\n        routeProps.authorization?.type ?? this.props.defaultAuthorization?.type\n\n      if (authType !== \"IAM\") {\n        throw new Error(\n          `Cannot grant invoke for an API Gateway when not using IAM auth (found auth '${authType}' on route '${routeProps.path}') [${cdk.Stack.of(this).stackName}]`,\n        )\n      }\n    }\n\n    for (const route of this.routes) {\n      route.grantInvoke(target)\n    }\n  }\n}\n\n/** Acts as glue (between the integration props and the HttpApi) when creating an SqsIntegration. */\nclass SqsRouteIntegration extends apigw.HttpRouteIntegration {\n  /**\n   * @param id The id used in the {@link apigw.HttpIntegration} construct\n   *    created internally by {@link apigw.HttpRouteIntegration._bindToRoute}.\n   *    [Source code](https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L321)\n   * @param integrationProps The props to pass to the {@link apigw.HttpIntegration} construct.\n   */\n  constructor(\n    id: string,\n    private integrationProps: apigw.HttpRouteIntegrationConfig,\n  ) {\n    super(id)\n  }\n\n  /**\n   * This sends the properties needed for creating a {@link apigw.HttpIntegration} to the\n   * {@link apigw.HttpRouteIntegration}.\n   */\n  bind(): apigw.HttpRouteIntegrationConfig {\n    // This method is called by:\n    // https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L319\n    return this.integrationProps\n  }\n}\n\n/**\n * When using `NodejsFunction` with `entry`, we point CDK to a file with our lambda code. This can\n * either be a TypeScript or JavaScript file. When creating constructs in tests inside this library,\n * the entry will point to the TypeScript file in the source code. But when a library consumer uses\n * this, it will instead point to the transpiled JavaScript file. So to set the correct file\n * extension, we must check if we're being run in the context of the TypeScript source code\n * (src/api-gateway), otherwise we're being run by a consumer as transpiled JavaScript.\n */\nconst authorizerFileExtension = __dirname.endsWith(\"src/api-gateway\")\n  ? \"ts\"\n  : \"js\"\n\n/**\n * Creates a custom Lambda authorizer which reads `Authorization: Bearer <access token>` header and\n * verifies the token against a Cognito user pool.\n */\nclass CognitoUserPoolAuthorizer<\n  AuthScopesT extends string,\n> extends constructs.Construct {\n  public readonly lambda: lambda.IFunction\n\n  /**\n   * Use simple response type (`{ isAuthorized: true/false }`), as opposed to returning an IAM\n   * Policy document.\n   */\n  public readonly responseTypes: authorizers.HttpLambdaResponseType[] = [\n    authorizers.HttpLambdaResponseType.SIMPLE,\n  ]\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: CognitoUserPoolAuthorizerProps<AuthScopesT>,\n  ) {\n    super(scope, id)\n\n    this.lambda = new lambdaNodejs.NodejsFunction(this, \"AuthorizerFunction\", {\n      entry: path.join(\n        __dirname,\n        `authorizers/cognito-user-pool-authorizer.${authorizerFileExtension}`,\n      ),\n      runtime: lambda.Runtime.NODEJS_22_X,\n      timeout: cdk.Duration.seconds(5),\n      environment: {\n        [\"USER_POOL_ID\"]: props.userPool.userPoolId,\n        [\"REQUIRED_SCOPE\"]: props.requiredScope ?? \"\",\n        [\"CREDENTIALS_FOR_INTERNAL_AUTHORIZATION\"]:\n          props.credentialsForInternalAuthorization\n            ? props.credentialsForInternalAuthorization\n            : \"\",\n      },\n    })\n\n    if (props.credentialsForInternalAuthorization) {\n      secretsmanager.Secret.fromSecretNameV2(\n        scope,\n        id + \"BasicAuthSecret\",\n        props.credentialsForInternalAuthorization,\n      ).grantRead(this.lambda)\n    }\n  }\n}\n\n/**\n * Creates a custom Lambda authorizer which reads `Authorization: Basic <base64-encoded credentials>`\n * header and verifies the credentials against a given secret.\n */\nclass BasicAuthAuthorizer extends constructs.Construct {\n  public readonly lambda: lambda.IFunction\n\n  // Simple is `{ isAuthorized: true/false }`, as opposed to returning an IAM Policy document\n  public readonly responseTypes: authorizers.HttpLambdaResponseType[] = [\n    authorizers.HttpLambdaResponseType.SIMPLE,\n  ]\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: BasicAuthAuthorizerProps,\n  ) {\n    super(scope, id)\n\n    this.lambda = new lambdaNodejs.NodejsFunction(this, \"BasicAuthLambda\", {\n      entry: path.join(\n        __dirname,\n        `authorizers/basic-auth-authorizer.${authorizerFileExtension}`,\n      ),\n      description:\n        \"An authorizer for API-Gateway that checks Basic Auth credentials on requests\",\n      runtime: lambda.Runtime.NODEJS_22_X,\n      environment: {\n        [\"CREDENTIALS_SECRET_NAME\"]: props.credentialsSecretName\n          ? props.credentialsSecretName\n          : \"\",\n      },\n    })\n\n    secretsmanager.Secret.fromSecretNameV2(\n      scope,\n      id + \"BasicAuthSecret\",\n      props.credentialsSecretName,\n    ).grantRead(this.lambda)\n  }\n}\n\n/**\n * Creates a custom Lambda authorizer which allows both:\n * - `Authorization: Bearer <access token>` header, for which the token is checked against the given\n *   Cognito user pool\n * - `Authorization: Basic <base64-encoded credentials>` header, for which the credentials are\n *   checked against the credentials from the given basic auth secret name\n *\n * If either of these are given and valid, the request is authenticated.\n */\nclass CognitoUserPoolOrBasicAuthAuthorizer<\n  AuthScopesT extends string,\n> extends constructs.Construct {\n  public readonly lambda: lambda.IFunction\n\n  /**\n   * Use simple response type (`{ isAuthorized: true/false }`), as opposed to returning an IAM\n   * Policy document.\n   */\n  public readonly responseTypes: authorizers.HttpLambdaResponseType[] = [\n    authorizers.HttpLambdaResponseType.SIMPLE,\n  ]\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: CognitoUserPoolOrBasicAuthAuthorizerProps<AuthScopesT>,\n  ) {\n    super(scope, id)\n\n    this.lambda = new lambdaNodejs.NodejsFunction(this, \"AuthorizerFunction\", {\n      entry: path.join(\n        __dirname,\n        `authorizers/cognito-user-pool-or-basic-auth-authorizer.${authorizerFileExtension}`,\n      ),\n      runtime: lambda.Runtime.NODEJS_22_X,\n      timeout: cdk.Duration.seconds(5),\n      environment: {\n        [\"USER_POOL_ID\"]: props.userPool ? props.userPool.userPoolId : \"\",\n        [\"REQUIRED_SCOPE\"]: props.requiredScope ?? \"\",\n        [\"BASIC_AUTH_CREDENTIALS_SECRET_NAME\"]:\n          props.basicAuthCredentialsSecretName\n            ? props.basicAuthCredentialsSecretName\n            : \"\",\n      },\n    })\n\n    if (props.basicAuthCredentialsSecretName) {\n      secretsmanager.Secret.fromSecretNameV2(\n        scope,\n        id + \"BasicAuthSecret\",\n        props.basicAuthCredentialsSecretName,\n      ).grantRead(this.lambda)\n    }\n  }\n}\n\n/** Returns a short semi-unique hash of the given string. */\nfunction shortHash(str: string): string {\n  // SHA-1 is no-no when we need cryptographic security, but here we just it for shortening a name,\n  // which is fine\n  return createHash(\"sha1\").update(str).digest(\"hex\").substring(0, 10)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-api-gateway.js","sourceRoot":"","sources":["../../src/api-gateway/http-api-gateway.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as cdk from \"aws-cdk-lib\"\nimport type * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\"\nimport type * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport type * as sqs from \"aws-cdk-lib/aws-sqs\"\nimport type * as events from \"aws-cdk-lib/aws-events\"\nimport * as apigw from \"aws-cdk-lib/aws-apigatewayv2\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport * as integrations from \"aws-cdk-lib/aws-apigatewayv2-integrations\"\nimport * as authorizers from \"aws-cdk-lib/aws-apigatewayv2-authorizers\"\nimport type { IUserPool } from \"aws-cdk-lib/aws-cognito\"\nimport * as lambdaNodejs from \"aws-cdk-lib/aws-lambda-nodejs\"\nimport { createHash } from \"crypto\"\nimport { tagResources } from \"../tags\"\nimport * as path from \"path\"\nimport { fileURLToPath } from \"url\"\nimport { ApiGatewayDnsProps, ApiGatewayDomain } from \"./domain\"\nimport { ApiGatewayAccessLogs, ApiGatewayAccessLogsProps } from \"./access-logs\"\n\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\n\n/**\n * Props for the {@link ApiGateway} construct.\n *\n * @author Kristian Rekstad <kre@capraconsulting.no>\n * @author Hermann Mørkrid <hem@liflig.no>\n */\nexport type ApiGatewayProps<AuthScopesT extends string = string> = {\n  /** Settings for the external-facing part of the API-GW. */\n  dns: ApiGatewayDnsProps\n\n  /**\n   * If no integration is specified for a route, this integration is used.\n   *\n   * See {@link IntegrationProps} for the available options.\n   */\n  defaultIntegration?: IntegrationProps\n\n  /**\n   * If no authorization is specified for a route, this authorization is used.\n   *\n   * See {@link AuthorizationProps} for the available options.\n   */\n  defaultAuthorization?: AuthorizationProps<AuthScopesT>\n\n  routes: ApiGatewayRoute<AuthScopesT>[]\n\n  /**\n   * The API-GW access logs for the `$default` stage are kept.\n   * This has options for the logs.\n   */\n  accessLogs?: ApiGatewayAccessLogsProps\n\n  /**\n   * Set to false to disable route-level metrics.\n   * This can increase CloudWatch costs when not disabled.\n   *\n   * See [AWS: Working with metrics for HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-metrics.html?icmpid=apigateway_console_help#:~:text=and%20stage%20ID.-,ApiId%2C%20Stage%2C%20Route,-Filters%20API%20Gateway)\n   * for more info.\n   *\n   * @default true\n   */\n  detailedMetrics?: boolean\n\n  /**\n   * Throttling of requests.\n   * If not set, the AWS default of 5000 burst and 10000 rate is used.\n   *\n   * The default throttling is per-account, and counts all APIs in the account and region.\n   * If you have another API in this region getting 10_000 request rate, it may impact this API as well.\n   */\n  throttling?: {\n    /**\n     * Going over `5_000` may require you to contact AWS Support - they are account bound.\n     */\n    burst?: number\n    /**\n     * Going over `10_000` may require you to contact AWS Support - they are account bound.\n     */\n    rate?: number\n  }\n\n  /**\n   * Sets CORS headers on responses from the API Gateway to allow all origins, headers and methods.\n   * Useful if your API should be accessed by any browser.\n   */\n  corsAllowAll?: boolean\n\n  /**\n   * If some settings in this construct do not work for you, this is an escape hatch mechanism to\n   * override anything.\n   */\n  propsOverride?: {\n    /**\n     * Override settings for the {@link apigw.HttpApi} (accessible in {@link ApiGateway.httpApi}).\n     *\n     * For example, if you have a frontend accessing this API, you might want to set\n     * [CORS preflight](https://docs.aws.amazon.com/cdk/api/v1/docs/aws-apigatewayv2-readme.html#cross-origin-resource-sharing-cors)\n     * settings.\n     */\n    httpApi?: Partial<apigw.HttpApiProps>\n  }\n}\n\nexport type ApiGatewayRoute<AuthScopesT extends string = string> = {\n  /** The path of the route to expose through the API Gateway. Use \"/\" for the root route. */\n  path: string\n\n  /**\n   * By default, we only forward requests that match the route's path exactly. So for a route with\n   * path `/api/users`, a request to `/api/users` will be forwarded, but a request to\n   * `/api/users/admin` will not. If you want to forward requests to all sub-paths under the route's\n   * path, you can set this to true.\n   *\n   * @default false\n   */\n  includeSubpaths?: boolean\n\n  /**\n   * The HTTP method to expose. `ANY` exposes all HTTP methods on the path.\n   *\n   * @default \"ANY\"\n   */\n  method?: HttpMethod\n\n  /**\n   * The integration that the route will forward to. See {@link IntegrationProps} for the available\n   * options.\n   *\n   * If undefined, uses the {@link ApiGatewayProps.defaultIntegration}.\n   */\n  integration?: IntegrationProps\n\n  /**\n   * How requests on the route are authenticated. See {@link AuthorizationProps} for the available\n   * options.\n   *\n   * If undefined, uses the {@link ApiGatewayProps.defaultAuthorization}.\n   */\n  authorization?: AuthorizationProps<AuthScopesT>\n}\n\nexport type HttpMethod =\n  | \"ANY\"\n  | \"GET\"\n  | \"POST\"\n  | \"PUT\"\n  | \"PATCH\"\n  | \"DELETE\"\n  | \"OPTIONS\"\n  | \"HEAD\"\n\nexport type IntegrationProps =\n  /** Use this when connecting the route to an ALB (Application Load Balancer). */\n  | ({ type: \"ALB\" } & AlbIntegrationProps)\n  /** Use this when connecting route to a Lambda. */\n  | ({ type: \"Lambda\" } & LambdaIntegrationProps)\n  /** Use this when connecting a route to send to an SQS queue. */\n  | ({ type: \"SQS\" } & SqsIntegrationProps)\n  /** Use this when connecting a route to send to an EventBridge event bus. */\n  | ({ type: \"EventBridge\" } & EventBridgeIntegrationProps)\n\n/**\n * Props for the API-GW -> ALB (Application Load Balancer) integration.\n *\n * See the note on {@link ApiGateway} about the load balancer security group.\n */\nexport type AlbIntegrationProps = {\n  /**\n   * A listener on e.g. port 443 (HTTPS).\n   *\n   * See the note on {@link ApiGateway} about the load balancer security group.\n   */\n  loadBalancerListener: elb.IApplicationListener\n\n  /**\n   * The host name (domain name) of the backend service that we want to reach through the ALB.\n   *\n   * This is used to:\n   * - Verify the HTTPS certificate of the backend service, so that the request forwarded from\n   *   API-GW can use TLS\n   * - Set the `Host` header on the request when forwarding to the ALB, so that requests can be\n   *   routed to the correct Target Group\n   *\n   * Example value: `<service>.staging.my-project.liflig.io` (not prefixed by `https://`).\n   */\n  hostName: string\n\n  /**\n   * The VPC used by the ALB. The API-GW integration will connect to the ALB using a VPC Link for\n   * this VPC.\n   *\n   * See the note on {@link ApiGateway} about the load balancer security group.\n   */\n  vpc: ec2.IVpc\n\n  /**\n   * A security group (SG) that allows incoming traffic to the ALB. Will be used by the VPC link, so\n   * the API-GW integration can connect.\n   *\n   * This is usually the same SG as the ALB uses, because they have a rule that allows traffic from\n   * others in the same SG.\n   *\n   * See the note on {@link ApiGateway} about the load balancer security group.\n   */\n  securityGroup: ec2.ISecurityGroup\n\n  /**\n   * Map request parameters (add/overwrite path/headers/query params) before forwarding to the\n   * backend.\n   *\n   * See {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-parameter-mapping.html}\n   * for more on this. Read the 'Reserved headers' section for which headers cannot be overridden.\n   * In addition to the AWS-reserved headers, you should not override the 'Host' header either, as\n   * that's used for routing the request to the correct service behind the load balancer.\n   *\n   * ### Example:\n   *\n   * Adding a header:\n   * ```\n   * mapParameters: (parameters) => parameters.overwriteHeader(\n   *    \"X-My-Custom-Header\",\n   *    apigw.MappingValue.custom(\"my-custom-value\"),\n   * )\n   * ```\n   *\n   * Overwriting the path (if, for example, you configure a `/users` route on the API Gateway that\n   * you want to forward to `/api/users` on the backend):\n   * ```\n   * mapParameters: (parameters) => parameters.overwritePath(\"/api/users\")\n   * ```\n   */\n  mapParameters?: (parameters: apigw.ParameterMapping) => void\n}\n\nexport type LambdaIntegrationProps = {\n  /**\n   * The Lambda integration uses the V2 payload format:\n   * {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html}\n   *\n   * If writing the Lambda in TypeScript, this means you should use `APIGatewayProxyEventV2` as the\n   * request type, and `APIGatewayProxyResultV2` as the response type.\n   */\n  lambda: lambda.IFunction\n}\n\nexport type SqsIntegrationProps = {\n  queue: sqs.IQueue\n\n  /**\n   * Message attributes to pass on to SQS. The keys in this object are the names of the attributes.\n   * Each attribute has a DataType field, and either a StringValue or BinaryValue field depending on\n   * its type. See AWS docs:\n   * https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_MessageAttributeValue.html\n   *\n   * In the StringValue field, you can do API Gateway parameter mapping:\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-parameter-mapping.html\n   *\n   * Example:\n   * ```\n   * messageAttributes: {\n   *   clientId: {\n   *     DataType: \"String\",\n   *     StringValue: \"${context.authorizer.clientId}\",\n   *   },\n   * },\n   * ```\n   */\n  messageAttributes?: {\n    [attributeName: string]:\n      | { DataType: \"String\" | \"Number\"; StringValue: string }\n      | {\n          DataType: \"Binary\"\n          /** Base64-encoded binary data object. */\n          BinaryValue: string\n        }\n  }\n}\n\nexport type EventBridgeIntegrationProps = {\n  /**\n   * An EventBridge event bus. Request bodies sent to the route will be forwarded to this event bus,\n   * in the `Detail` field (see\n   * https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html).\n   */\n  eventBus: events.IEventBus\n  /**\n   * Sets the `DetailType` field (i.e., event type) on events published to the event bus.\n   *\n   * See AWS docs for more on this:\n   * https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html\n   */\n  detailType: string\n}\n\nexport type AuthorizationProps<AuthScopesT extends string = string> =\n  /**\n   * No authentication, for when you want a fully public route (or handle authentication in the\n   * backend integration).\n   */\n  | { type: \"NONE\" }\n  /**\n   * AWS IAM authorization.\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-access-control-iam.html\n   */\n  | { type: \"IAM\" }\n  /**\n   * Creates a custom Lambda authorizer which reads `Authorization: Bearer <access token>` header\n   * and verifies the token against a Cognito user pool.\n   */\n  | ({\n      type: \"COGNITO_USER_POOL\"\n    } & CognitoUserPoolAuthorizerProps<AuthScopesT>)\n  /**\n   * Creates a custom Lambda authorizer which reads `Authorization: Basic <base64-encoded credentials>`\n   * header and verifies the credentials against a given secret.\n   */\n  | ({ type: \"BASIC_AUTH\" } & BasicAuthAuthorizerProps)\n  /**\n   * Creates a custom Lambda authorizer which allows both:\n   * - `Authorization: Bearer <access token>` header, for which the token is checked against the\n   *   given Cognito user pool\n   * - `Authorization: Basic <base64-encoded credentials>` header, for which the credentials are\n   *   checked against the credentials from the given basic auth secret name\n   *\n   * If either of these are given and valid, the request is authenticated.\n   */\n  | ({\n      type: \"COGNITO_USER_POOL_OR_BASIC_AUTH\"\n    } & CognitoUserPoolOrBasicAuthAuthorizerProps<AuthScopesT>)\n  /**\n   * Creates a custom authorizer with the given Lambda function. Use this if you have custom\n   * authorization logic, and the other authorizers from this construct don't meet your needs.\n   *\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html\n   */\n  | ({ type: \"CUSTOM_LAMBDA_AUTHORIZER\" } & CustomLambdaAuthorizerProps)\n\nexport type CognitoUserPoolAuthorizerProps<\n  AuthScopesT extends string = string,\n> = {\n  userPool: IUserPool\n\n  /**\n   * Verifies that access token claims contain the given scope.\n   *\n   * When defined as part of a resource server, scopes are on the format:\n   * `{resource server identifier}/{scope name}`, e.g. `external/view_users`.\n   *\n   * To get more type safety on this parameter, see the docs for the `AuthScopesT` type parameter on\n   * {@link ApiGateway}.\n   */\n  requiredScope?: AuthScopesT\n\n  /**\n   * Name of secret in AWS Secrets Manager that stores basic auth credentials for the backend\n   * service, to be forwarded to the backend if Cognito user pool authentication succeeded.\n   *\n   * The secret value must follow this format:\n   * ```json\n   * { \"username\": \"<username>\", \"password\": \"<password>\" }\n   * ```\n   *\n   * This prop solves the following use-case:\n   * - You want to do Cognito user pool authentication in the API Gateway\n   * - You want an additional auth check in the backend, but you don't want to deal with Cognito\n   *   there\n   * - The backend uses basic auth\n   *\n   * This prop solves this by letting you specify credentials to pass to the backend after API-GW\n   * authentication succeeds. You can pass the encoded credentials through\n   * {@link AlbIntegrationProps.mapParameters}, using the `authorizer.internalAuthorizationHeader`\n   * context variable, like so:\n   * ```\n   * mapParameters: (parameters) => parameters.overwriteHeader(\n   *   // 'Authorization' header cannot be overridden, so we use a custom header\n   *   \"X-Internal-Authorization\",\n   *   apigw.MappingValue.contextVariable(\"authorizer.internalAuthorizationHeader\"),\n   * )\n   * ```\n   * The backend can then check the `X-Internal-Authorization` header.\n   */\n  credentialsForInternalAuthorization?: string\n}\n\nexport type BasicAuthAuthorizerProps = {\n  /**\n   * Name of secret in AWS Secrets Manager that stores basic auth credentials.\n   *\n   * The following formats are supported for the secret value:\n   * - Single username and password:\n   *   ```json\n   *   { \"username\": \"<username>\", \"password\": \"<password>\" }\n   *   ```\n   * - Array of username + password objects:\n   *   ```json\n   *   { \"credentials\": \"[{\\\"username\\\":\\\"<user-1>\\\",\\\"password\\\":\\\"password-1\\\"},{\\\"username\\\":\\\"<user-2>\\\",\\\"password\\\":\\\"<password-2>\\\"}]\" }\n   *   ```\n   *   - The value of the `credentials` field is a string, with a stringified, escaped JSON array of\n   *     objects with `username` and `password` fields.\n   *   - The reason that this second format stores stringified JSON _inside_ JSON, is due to a\n   *     limitation in Liflig's `load-secrets` library, which only allows storing string values.\n   * - Array of base64-encoded credentials:\n   *   ```json\n   *   { \"credentials\": \"[\\\"<encoded-credential-1>\\\",\\\"<encoded-credential-2>\\\"]\" }\n   *   ```\n   *   - Each element is encoded from `<username>:<password>`.\n   *   - The array is stringified for the same reason as above.\n   *\n   * If the secret uses one of the array formats, the authorizer will match the request's\n   * Authorization header against any one of the credentials.\n   */\n  credentialsSecretName: string\n}\n\nexport type CognitoUserPoolOrBasicAuthAuthorizerProps<\n  AuthScopesT extends string = string,\n> = {\n  userPool: IUserPool\n\n  /**\n   * Name of secret in AWS Secrets Manager that stores basic auth credentials.\n   *\n   * See {@link BasicAuthAuthorizerProps.credentialsSecretName} for the supported formats.\n   */\n  basicAuthCredentialsSecretName?: string\n\n  /**\n   * Verifies that access token claims contain the given scope. Only applicable for requests that\n   * use `Authorization: Bearer <access token>` (not applicable for basic auth).\n   *\n   * When defined as part of a resource server, scopes are on the format:\n   * `{resource server identifier}/{scope name}`, e.g. `external/view_users`.\n   *\n   * To get more type safety on this parameter, see the docs for the `AuthScopesT` type parameter on\n   * {@link ApiGateway}.\n   */\n  requiredScope?: AuthScopesT\n}\n\ntype CustomLambdaAuthorizerProps = {\n  /**\n   * The Lambda function that will be run whenever the API Gateway route is invoked, to authenticate\n   * the request. See AWS docs for more on how to write the Lambda:\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html\n   *\n   * The default response format used is `HttpLambdaResponseType.SIMPLE` (format 2.0). If you write\n   * your Lambda in TypeScript, this means that your handler must return\n   * `APIGatewaySimpleAuthorizerResult` (from the `aws-lambda` package). The request event will also\n   * use format 2.0 (`APIGatewayRequestAuthorizerEventV2` in TypeScript). See the AWS docs linked\n   * above for more details on these formats.\n   *\n   * You can override the response format type in\n   * {@link CustomLambdaAuthorizerProps.authorizerProps}.\n   *\n   * See the Lambdas under the `authorizers` folder next to the `ApiGateway` construct in\n   * `liflig-cdk` for examples.\n   */\n  lambdaAuthorizer: lambda.IFunction\n\n  /**\n   * Props for the `HttpLambdaAuthorizer` construct. We provide some different defaults:\n   * - `responseTypes` defaults to `[HttpLambdaResponseType.SIMPLE]`\n   * - `resultsCacheTtl` defaults to `Duration.hours(1)`\n   */\n  authorizerProps?: Partial<authorizers.HttpLambdaAuthorizerProps>\n}\n\n/**\n * This construct tries to simplify the creation of an API Gateway for a service, by collecting most\n * of the common setup here.\n *\n * The approach followed in this construct is:\n * 1. One API-GW per service\n * 2. One subdomain per API-GW / service\n * 3. Use HTTP API, not REST\n * 4. Use a $default stage with autodeploy\n * 5. Support multiple routes (with possible `/{proxy+}` to let all sub-paths through)\n * 6. Allow custom integration/authorizer for each route, or defaults for the whole gateway\n *\n * The route integration is one of these:\n * - ALB private integration with VPC Link using HTTPS to the ALB\n * - Lambda integration\n * - SQS integration\n *\n * ### Load Balancer Security Group\n *\n * Note that the load balancer used in an {@link AlbIntegrationProps} must allow outbound HTTPS\n * traffic to its SecurityGroup. Otherwise, the VPC Link used by the API-GW can't get traffic from\n * the ALB.\n *\n * ```\n * const loadBalancerSecurityGroup = new ec2.SecurityGroup(..., {\n *   allowAllOutbound: false,\n * })\n *\n * loadBalancerSecurityGroup.addEgressRule(\n *   loadBalancerSecurityGroup,\n *   ec2.Port.tcp(443),\n *   \"Outbound to self for ALB to API-GW VPC-Link\",\n * )\n *\n * const loadBalancer = new lifligLoadBalancer.LoadBalancer(...,\n *   {\n *     overrideLoadBalancerProps: {\n *       securityGroup: loadBalancerSecurityGroup,\n *     },\n *   },\n * )\n * ```\n *\n * @template AuthScopesT This type parameter allows you to improve type safety on the\n * `requiredScope` field on {@link CognitoUserPoolOrBasicAuthAuthorizerProps}, by narrowing the type\n * to specific strings. You can then extend the `ApiGateway` with this type to enforce those scopes\n * across the application. Remember that auth scopes must be on the format\n * `{resource server identifier}/{scope name}`.\n *\n * Example:\n * ```\n * type AuthScopes = \"external/read_users\" | \"internal/create_users\"\n *\n * export class MyProjectApiGateway extends ApiGateway<AuthScopes> {}\n * ```\n * TypeScript will then enforce that `requiredScope` is one of `AuthScopes`, and provide\n * auto-complete.\n *\n * @author Kristian Rekstad <kre@capraconsulting.no>\n * @author Hermann Mørkrid <hem@liflig.no>\n */\nexport class ApiGateway<\n  AuthScopesT extends string = string,\n> extends constructs.Construct {\n  /** The API Gateway HTTP API. This is the main construct for API-GW. */\n  public readonly httpApi: apigw.HttpApi\n\n  /** The routes which connect the {@link httpApi} to the backend integration(s). */\n  public readonly routes: apigw.HttpRoute[] = []\n\n  /** The domain which consumers must use.*/\n  public readonly domain: string\n\n  /** Access log group. */\n  public readonly logGroup: logs.LogGroup\n\n  private readonly props: ApiGatewayProps<AuthScopesT>\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: ApiGatewayProps<AuthScopesT>,\n  ) {\n    super(scope, id)\n    this.props = props\n\n    ApiGateway.validateProps(props, id, cdk.Stack.of(this))\n\n    const customDomain = new ApiGatewayDomain(this, \"CustomDomain\", props.dns)\n    this.domain = customDomain.fullDomainName\n\n    let corsOptions: apigw.CorsPreflightOptions | undefined\n    if (props.corsAllowAll) {\n      corsOptions = {\n        allowOrigins: [\"*\"],\n        // \"The Authorization header can't be wildcarded and always needs to be listed explicitly\"\n        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers\n        // Content-Type may also require explicit whitelisting: https://stackoverflow.com/a/63567647\n        allowHeaders: [\"Authorization\", \"Content-Type\", \"*\"],\n        // Not using '*' here, because \"In requests with credentials, it is treated as the literal\n        // method name '*' without special semantics\"\n        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods\n        allowMethods: [\n          apigw.CorsHttpMethod.GET,\n          apigw.CorsHttpMethod.POST,\n          apigw.CorsHttpMethod.PUT,\n          apigw.CorsHttpMethod.PATCH,\n          apigw.CorsHttpMethod.DELETE,\n          apigw.CorsHttpMethod.OPTIONS,\n          apigw.CorsHttpMethod.HEAD,\n        ],\n        maxAge: cdk.Duration.days(1),\n      }\n    }\n\n    // The actual API. This holds the routes, authorizers and integrations.\n    const api = new apigw.HttpApi(this, \"HttpApi-\" + props.dns.subdomain, {\n      // defaultIntegration: defaultIntegration, // This is for a catch-all $default route\n      description: `An HTTP API for ${props.dns.subdomain}.${props.dns.hostedZone.zoneName}.`,\n      disableExecuteApiEndpoint: true, // Force externals to go through custom domain. MUST be true when using Mutual TLS, for security reasons\n      createDefaultStage: true,\n      defaultDomainMapping: { domainName: customDomain.apiGwDomainName },\n      corsPreflight: corsOptions,\n      ...props?.propsOverride?.httpApi,\n    })\n    this.httpApi = api\n\n    const stage = api.defaultStage?.node.defaultChild as apigw.CfnStage\n\n    const logs = new ApiGatewayAccessLogs(\n      this,\n      \"AccessLogs\",\n      stage,\n      props.accessLogs,\n    )\n    this.logGroup = logs.logGroup\n\n    stage.defaultRouteSettings = {\n      ...stage.defaultRouteSettings,\n      detailedMetricsEnabled: props.detailedMetrics ?? true,\n      throttlingBurstLimit: props.throttling?.burst, // Default for account is 5_000\n      throttlingRateLimit: props.throttling?.rate, // Default for account is 10_000\n    }\n\n    const defaultIntegration = props.defaultIntegration\n      ? this.createIntegration(props.defaultIntegration, props.dns)\n      : undefined\n\n    const defaultAuthorizer = props.defaultAuthorization\n      ? this.createAuthorizer(\"DefaultAuthorizer\", props.defaultAuthorization)\n      : undefined\n\n    for (const route of props.routes) {\n      let integration: apigw.HttpRouteIntegration\n      if (route.integration) {\n        integration = this.createIntegration(route.integration, props.dns)\n      } else {\n        integration = defaultIntegration! // Verified in validateProps\n      }\n\n      let authorizer: apigw.IHttpRouteAuthorizer | undefined\n      if (route.authorization) {\n        authorizer = this.createAuthorizer(\n          // Using the route path here caused CloudFormation to fail due to resource names being too\n          // long. Therefore, we now hash the route path to get a shorter name.\n          `RouteAuthorizer${shortHash(`${route.method ?? \"\"}${route.path}`)}`,\n          route.authorization,\n        )\n      } else {\n        authorizer = defaultAuthorizer\n      }\n\n      const routePaths = [route.path]\n      if (route.includeSubpaths === true) {\n        // If we include sub-paths, we add an additional route with /{proxy+} (the + means it will\n        // match all subroutes). We want both this route and the normal route without /{proxy+},\n        // since /{proxy+} will only match the base path with trailing slash.\n        routePaths.push(\n          route.path + (route.path === \"/\" ? \"\" : \"/\") + \"{proxy+}\",\n        )\n      }\n\n      for (const routePath of routePaths) {\n        // The previous version of the API Gateway construct had a single route with the ID\n        // 'DefaultProxyRoute', and all gateways we used exposed the route /{proxy+}. When trying to\n        // change to this new version of the construct, deployment failed for gateways exposing\n        // /{proxy+}, because \"a route with that key [i.e. path + method] already exists\". We think\n        // this may be because we used the same route path, but with a new route ID, causing\n        // confusion for CloudFormation. So we keep the old route ID here for /{proxy+}.\n        const routeId =\n          routePath === \"/{proxy+}\" ? \"DefaultProxyRoute\" : `Route-${routePath}`\n\n        this.routes.push(\n          new apigw.HttpRoute(this, routeId, {\n            httpApi: api,\n            integration: integration,\n            authorizer: authorizer,\n            routeKey: apigw.HttpRouteKey.with(\n              routePath,\n              route.method\n                ? apigw.HttpMethod[route.method]\n                : apigw.HttpMethod.ANY,\n            ),\n          }),\n        )\n      }\n    }\n\n    tagResources(this, () => ({ service: props.dns.subdomain }))\n  }\n\n  /** @throws Error */\n  private static validateProps(\n    props: ApiGatewayProps,\n    id: string,\n    stack: cdk.Stack,\n  ) {\n    for (const route of props.routes) {\n      if (!route.integration && !props.defaultIntegration) {\n        throw new Error(\n          `No integration defined for route '${route.path}', and no default integration specified for the gateway`,\n        )\n      }\n      if (!route.authorization && !props.defaultAuthorization) {\n        throw new Error(\n          `No authorization defined for route '${route.path}', and no default authorization specified for the gateway`,\n        )\n      }\n      if (!route.path.startsWith(\"/\")) {\n        throw new Error(\n          `Invalid path '${route.path}': paths must begin with '/' (use '/' for root path)`,\n        )\n      }\n      if (route.path !== \"/\" && route.path.endsWith(\"/\")) {\n        throw new Error(\n          `Invalid path '${route.path}': paths cannot end with '/' (except root path)`,\n        )\n      }\n      if (\n        route.integration?.type === \"ALB\" &&\n        route.integration.hostName.startsWith(\"https:\")\n      ) {\n        throw new Error(\n          `The albIntegration.hostHttpsName should not include a protocol: ${route.integration.hostName}`,\n        )\n      }\n    }\n    if (props.dns.subdomain === \"\" || props.dns.subdomain.includes(\" \")) {\n      throw new Error(\n        `Subdomain must be set, and not contain spaces: ${props.dns.subdomain}`,\n      )\n    }\n    if (props.throttling?.burst && props.throttling.burst > 5_000) {\n      console.warn(\n        `⚠️ Your throttling burst limit '${props.throttling.burst}' is higher than the AWS Account limit. Make sure your account has upgraded this quota! `,\n        stack,\n        id,\n      )\n    }\n    if (props.throttling?.rate && props.throttling.rate > 10_000) {\n      console.warn(\n        `⚠️ Your throttling rate limit '${props.throttling.rate}' is higher than the AWS Account limit. Make sure your account has upgraded this quota! `,\n        stack,\n        id,\n      )\n    }\n  }\n\n  /**\n   * The authorizer only accepts requests from external users that are authorized.\n   * Unauthorized users are stopped in the API-GW, and not forwarded to the integration.\n   */\n  private createAuthorizer<AuthScopesT extends string>(\n    id: string,\n    authorization: AuthorizationProps<AuthScopesT>,\n  ): apigw.IHttpRouteAuthorizer | undefined {\n    switch (authorization.type) {\n      case \"NONE\": {\n        return undefined\n      }\n      case \"IAM\": {\n        // API Gateway invokes your API route only if the client has execute-api permission for the route.\n        // The client has to use AWS SigV4 to identify themselves in the request.\n        // Read this page for help with IAM and API-GW https://docs.aws.amazon.com/apigateway/latest/developerguide/security_iam_service-with-iam.html\n        // Note that [resource policies are not supported yet for HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-access-control-iam.html)\n        return new authorizers.HttpIamAuthorizer()\n      }\n      case \"COGNITO_USER_POOL\": {\n        // We use a custom lambda authorizer here instead of the `HttpUserPoolAuthorizer` provided\n        // by CDK, in order to support `requiredScope` and setting of custom context variables.\n        const authorizer = new CognitoUserPoolAuthorizer(\n          this,\n          id + \"Lambda\",\n          authorization,\n        )\n\n        return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {\n          responseTypes: authorizer.responseTypes,\n          // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials\n          resultsCacheTtl: cdk.Duration.hours(1),\n        })\n      }\n      case \"BASIC_AUTH\": {\n        const authorizer = new BasicAuthAuthorizer(\n          this,\n          id + \"Lambda\",\n          authorization,\n        )\n\n        return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {\n          responseTypes: authorizer.responseTypes,\n          // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials\n          resultsCacheTtl: cdk.Duration.minutes(30),\n        })\n      }\n      case \"COGNITO_USER_POOL_OR_BASIC_AUTH\": {\n        const authorizer = new CognitoUserPoolOrBasicAuthAuthorizer(\n          this,\n          id + \"Lambda\",\n          authorization,\n        )\n\n        return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {\n          responseTypes: authorizer.responseTypes,\n          // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials\n          resultsCacheTtl: cdk.Duration.hours(1),\n        })\n      }\n      case \"CUSTOM_LAMBDA_AUTHORIZER\": {\n        return new authorizers.HttpLambdaAuthorizer(\n          id,\n          authorization.lambdaAuthorizer,\n          {\n            ...authorization.authorizerProps,\n            responseTypes: authorization.authorizerProps?.responseTypes ?? [\n              authorizers.HttpLambdaResponseType.SIMPLE,\n            ],\n            resultsCacheTtl:\n              authorization.authorizerProps?.resultsCacheTtl ??\n              cdk.Duration.hours(1),\n          },\n        )\n      }\n    }\n  }\n\n  private createIntegration(\n    integration: IntegrationProps,\n    dns: ApiGatewayProps[\"dns\"],\n  ): apigw.HttpRouteIntegration {\n    switch (integration.type) {\n      case \"ALB\": {\n        // The VPCLink connects the integration into the ALB's VPC. Must be manually created when\n        // the VPC is imported, which is the case when using CorePlatformConsumer.\n        const vpcLink = new apigw.VpcLink(this, \"AlbVpcLink\", {\n          vpc: integration.vpc,\n          securityGroups: [integration.securityGroup],\n          subnets: integration.vpc.selectSubnets(), // This correctly selects the private subnets\n        })\n\n        const parameterMapping = new apigw.ParameterMapping()\n          /** See {@link AlbIntegrationProps.hostName} */\n          .overwriteHeader(\n            \"Host\",\n            // The Host header can NOT use dynamic mapping, like $context.domainName etc.\n            apigw.MappingValue.custom(integration.hostName),\n          )\n        if (integration.mapParameters !== undefined) {\n          integration.mapParameters(parameterMapping)\n        }\n\n        return new integrations.HttpAlbIntegration(\n          \"AlbIntegration-\" + dns.subdomain,\n          integration.loadBalancerListener,\n          {\n            secureServerName: integration.hostName,\n            vpcLink: vpcLink,\n            method: apigw.HttpMethod.ANY,\n            parameterMapping,\n          },\n        )\n      }\n      case \"Lambda\": {\n        return new integrations.HttpLambdaIntegration(\n          \"LambdaIntegration\",\n          integration.lambda,\n          {\n            payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_2_0,\n            parameterMapping: undefined,\n          },\n        )\n      }\n      case \"SQS\": {\n        // API-GW does not have access to SQS by default\n        const role = new iam.Role(\n          this,\n          `ApiGwTo${integration.queue.node.id}ServiceRole`,\n          {\n            description:\n              \"Allows API-GW to add messages to \" + integration.queue.queueArn,\n            assumedBy: new iam.ServicePrincipal(\"apigateway.amazonaws.com\"),\n          },\n        )\n        integration.queue.grantSendMessages(role)\n\n        let parameterMapping = new apigw.ParameterMapping()\n          // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-aws-services-reference.html#SQS-SendMessage\n          .custom(\"QueueUrl\", integration.queue.queueUrl)\n          .custom(\"MessageBody\", \"$request.body\")\n          .custom(\"Region\", \"eu-west-1\") // Change this if the SQS queue is in another region!\n\n        if (integration.messageAttributes) {\n          parameterMapping = parameterMapping.custom(\n            \"MessageAttributes\",\n            JSON.stringify(integration.messageAttributes),\n          )\n        }\n\n        return new SqsRouteIntegration(\"SqsIntegration\", {\n          type: apigw.HttpIntegrationType.AWS_PROXY,\n          subtype: apigw.HttpIntegrationSubtype.SQS_SEND_MESSAGE,\n          credentials: apigw.IntegrationCredentials.fromRole(role),\n          parameterMapping: parameterMapping,\n          payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_1_0,\n        })\n      }\n      case \"EventBridge\": {\n        // API-GW does not have access to put events to event bus by default\n        const role = new iam.Role(\n          this,\n          `ApiGwTo${integration.eventBus.node.id}ServiceRole`,\n          {\n            description: `Allows API-GW to put events to ${integration.eventBus.eventBusArn}`,\n            assumedBy: new iam.ServicePrincipal(\"apigateway.amazonaws.com\"),\n          },\n        )\n        integration.eventBus.grantPutEventsTo(role)\n\n        const parameterMapping = new apigw.ParameterMapping()\n          // https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html\n          .custom(\"EventBusName\", integration.eventBus.eventBusName)\n          .custom(\"Detail\", \"$request.body\")\n          .custom(\"DetailType\", integration.detailType)\n          .custom(\"Source\", \"$context.apiId\")\n\n        return new EventBridgeRouteIntegration(\"EventBridgeIntegration\", {\n          type: apigw.HttpIntegrationType.AWS_PROXY,\n          subtype: apigw.HttpIntegrationSubtype.EVENTBRIDGE_PUT_EVENTS,\n          credentials: apigw.IntegrationCredentials.fromRole(role),\n          parameterMapping: parameterMapping,\n          payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_1_0,\n        })\n      }\n    }\n  }\n\n  /**\n   * Allows a grantable target (role, user etc.) permission to invoke the API.\n   * Only works when using `IAM` as {@link ApiGatewayRoute.authorization}.\n   *\n   * @param target A grantable, like {@link iam.Role}\n   */\n  public grantInvoke(target: iam.IGrantable) {\n    for (const routeProps of this.props.routes) {\n      const authType =\n        routeProps.authorization?.type ?? this.props.defaultAuthorization?.type\n\n      if (authType !== \"IAM\") {\n        throw new Error(\n          `Cannot grant invoke for an API Gateway when not using IAM auth (found auth '${authType}' on route '${routeProps.path}') [${cdk.Stack.of(this).stackName}]`,\n        )\n      }\n    }\n\n    for (const route of this.routes) {\n      route.grantInvoke(target)\n    }\n  }\n}\n\n/** Acts as glue (between the integration props and the HttpApi) when creating an SqsIntegration. */\nclass SqsRouteIntegration extends apigw.HttpRouteIntegration {\n  /**\n   * @param id The id used in the {@link apigw.HttpIntegration} construct\n   *    created internally by {@link apigw.HttpRouteIntegration._bindToRoute}.\n   *    [Source code](https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L321)\n   * @param integrationProps The props to pass to the {@link apigw.HttpIntegration} construct.\n   */\n  constructor(\n    id: string,\n    private integrationProps: apigw.HttpRouteIntegrationConfig,\n  ) {\n    super(id)\n  }\n\n  /**\n   * This sends the properties needed for creating a {@link apigw.HttpIntegration} to the\n   * {@link apigw.HttpRouteIntegration}.\n   */\n  bind(): apigw.HttpRouteIntegrationConfig {\n    // This method is called by:\n    // https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L319\n    return this.integrationProps\n  }\n}\n\n/** Acts as glue (between the integration props and the HttpApi) when creating an EventBridge integration. */\nclass EventBridgeRouteIntegration extends apigw.HttpRouteIntegration {\n  /**\n   * @param id The id used in the {@link apigw.HttpIntegration} construct\n   *    created internally by {@link apigw.HttpRouteIntegration._bindToRoute}.\n   *    [Source code](https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L321)\n   * @param integrationProps The props to pass to the {@link apigw.HttpIntegration} construct.\n   */\n  constructor(\n    id: string,\n    private integrationProps: apigw.HttpRouteIntegrationConfig,\n  ) {\n    super(id)\n  }\n\n  /**\n   * This sends the properties needed for creating a {@link apigw.HttpIntegration} to the\n   * {@link apigw.HttpRouteIntegration}.\n   */\n  bind(): apigw.HttpRouteIntegrationConfig {\n    // This method is called by:\n    // https://github.com/aws/aws-cdk/blob/b5ae37782bc3cb637eeef9fbb1fbe2c5efdfc068/packages/%40aws-cdk/aws-apigatewayv2/lib/http/integration.ts#L319\n    return this.integrationProps\n  }\n}\n\n/**\n * When using `NodejsFunction` with `entry`, we point CDK to a file with our lambda code. This can\n * either be a TypeScript or JavaScript file. When creating constructs in tests inside this library,\n * the entry will point to the TypeScript file in the source code. But when a library consumer uses\n * this, it will instead point to the transpiled JavaScript file. So to set the correct file\n * extension, we must check if we're being run in the context of the TypeScript source code\n * (src/api-gateway), otherwise we're being run by a consumer as transpiled JavaScript.\n */\nconst authorizerFileExtension = __dirname.endsWith(\"src/api-gateway\")\n  ? \"ts\"\n  : \"js\"\n\n/**\n * Creates a custom Lambda authorizer which reads `Authorization: Bearer <access token>` header and\n * verifies the token against a Cognito user pool.\n */\nclass CognitoUserPoolAuthorizer<\n  AuthScopesT extends string,\n> extends constructs.Construct {\n  public readonly lambda: lambda.IFunction\n\n  /**\n   * Use simple response type (`{ isAuthorized: true/false }`), as opposed to returning an IAM\n   * Policy document.\n   */\n  public readonly responseTypes: authorizers.HttpLambdaResponseType[] = [\n    authorizers.HttpLambdaResponseType.SIMPLE,\n  ]\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: CognitoUserPoolAuthorizerProps<AuthScopesT>,\n  ) {\n    super(scope, id)\n\n    this.lambda = new lambdaNodejs.NodejsFunction(this, \"AuthorizerFunction\", {\n      entry: path.join(\n        __dirname,\n        `authorizers/cognito-user-pool-authorizer.${authorizerFileExtension}`,\n      ),\n      runtime: lambda.Runtime.NODEJS_22_X,\n      timeout: cdk.Duration.seconds(5),\n      environment: {\n        [\"USER_POOL_ID\"]: props.userPool.userPoolId,\n        [\"REQUIRED_SCOPE\"]: props.requiredScope ?? \"\",\n        [\"CREDENTIALS_FOR_INTERNAL_AUTHORIZATION\"]:\n          props.credentialsForInternalAuthorization\n            ? props.credentialsForInternalAuthorization\n            : \"\",\n      },\n    })\n\n    if (props.credentialsForInternalAuthorization) {\n      secretsmanager.Secret.fromSecretNameV2(\n        scope,\n        id + \"BasicAuthSecret\",\n        props.credentialsForInternalAuthorization,\n      ).grantRead(this.lambda)\n    }\n  }\n}\n\n/**\n * Creates a custom Lambda authorizer which reads `Authorization: Basic <base64-encoded credentials>`\n * header and verifies the credentials against a given secret.\n */\nclass BasicAuthAuthorizer extends constructs.Construct {\n  public readonly lambda: lambda.IFunction\n\n  // Simple is `{ isAuthorized: true/false }`, as opposed to returning an IAM Policy document\n  public readonly responseTypes: authorizers.HttpLambdaResponseType[] = [\n    authorizers.HttpLambdaResponseType.SIMPLE,\n  ]\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: BasicAuthAuthorizerProps,\n  ) {\n    super(scope, id)\n\n    this.lambda = new lambdaNodejs.NodejsFunction(this, \"BasicAuthLambda\", {\n      entry: path.join(\n        __dirname,\n        `authorizers/basic-auth-authorizer.${authorizerFileExtension}`,\n      ),\n      description:\n        \"An authorizer for API-Gateway that checks Basic Auth credentials on requests\",\n      runtime: lambda.Runtime.NODEJS_22_X,\n      environment: {\n        [\"CREDENTIALS_SECRET_NAME\"]: props.credentialsSecretName\n          ? props.credentialsSecretName\n          : \"\",\n      },\n    })\n\n    secretsmanager.Secret.fromSecretNameV2(\n      scope,\n      id + \"BasicAuthSecret\",\n      props.credentialsSecretName,\n    ).grantRead(this.lambda)\n  }\n}\n\n/**\n * Creates a custom Lambda authorizer which allows both:\n * - `Authorization: Bearer <access token>` header, for which the token is checked against the given\n *   Cognito user pool\n * - `Authorization: Basic <base64-encoded credentials>` header, for which the credentials are\n *   checked against the credentials from the given basic auth secret name\n *\n * If either of these are given and valid, the request is authenticated.\n */\nclass CognitoUserPoolOrBasicAuthAuthorizer<\n  AuthScopesT extends string,\n> extends constructs.Construct {\n  public readonly lambda: lambda.IFunction\n\n  /**\n   * Use simple response type (`{ isAuthorized: true/false }`), as opposed to returning an IAM\n   * Policy document.\n   */\n  public readonly responseTypes: authorizers.HttpLambdaResponseType[] = [\n    authorizers.HttpLambdaResponseType.SIMPLE,\n  ]\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: CognitoUserPoolOrBasicAuthAuthorizerProps<AuthScopesT>,\n  ) {\n    super(scope, id)\n\n    this.lambda = new lambdaNodejs.NodejsFunction(this, \"AuthorizerFunction\", {\n      entry: path.join(\n        __dirname,\n        `authorizers/cognito-user-pool-or-basic-auth-authorizer.${authorizerFileExtension}`,\n      ),\n      runtime: lambda.Runtime.NODEJS_22_X,\n      timeout: cdk.Duration.seconds(5),\n      environment: {\n        [\"USER_POOL_ID\"]: props.userPool ? props.userPool.userPoolId : \"\",\n        [\"REQUIRED_SCOPE\"]: props.requiredScope ?? \"\",\n        [\"BASIC_AUTH_CREDENTIALS_SECRET_NAME\"]:\n          props.basicAuthCredentialsSecretName\n            ? props.basicAuthCredentialsSecretName\n            : \"\",\n      },\n    })\n\n    if (props.basicAuthCredentialsSecretName) {\n      secretsmanager.Secret.fromSecretNameV2(\n        scope,\n        id + \"BasicAuthSecret\",\n        props.basicAuthCredentialsSecretName,\n      ).grantRead(this.lambda)\n    }\n  }\n}\n\n/** Returns a short semi-unique hash of the given string. */\nfunction shortHash(str: string): string {\n  // SHA-1 is no-no when we need cryptographic security, but here we just it for shortening a name,\n  // which is fine\n  return createHash(\"sha1\").update(str).digest(\"hex\").substring(0, 10)\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk",
-  "version": "3.5.9",
+  "version": "3.6.0",
   "description": "CDK library for Liflig",
   "type": "module",
   "repository": {
@@ -42,44 +42,44 @@
   },
   "devDependencies": {
     "@aws-cdk/assert": "2.68.0",
-    "@aws-sdk/client-cloudwatch-logs": "3.758.0",
-    "@aws-sdk/client-codebuild": "3.758.0",
+    "@aws-sdk/client-cloudwatch-logs": "3.767.0",
+    "@aws-sdk/client-codebuild": "3.767.0",
     "@aws-sdk/client-codepipeline": "3.758.0",
-    "@aws-sdk/client-ecs": "3.758.0",
+    "@aws-sdk/client-ecs": "3.766.0",
     "@aws-sdk/client-s3": "3.758.0",
     "@aws-sdk/client-secrets-manager": "3.758.0",
     "@aws-sdk/client-ses": "3.758.0",
     "@aws-sdk/client-sesv2": "3.758.0",
     "@aws-sdk/client-sfn": "3.758.0",
     "@aws-sdk/lib-storage": "3.758.0",
-    "@commitlint/cli": "19.7.1",
-    "@commitlint/config-conventional": "19.7.1",
+    "@commitlint/cli": "19.8.0",
+    "@commitlint/config-conventional": "19.8.0",
     "@eslint/eslintrc": "3.3.0",
-    "@eslint/js": "9.21.0",
+    "@eslint/js": "9.22.0",
     "@types/aws-lambda": "8.10.147",
     "@types/jest": "29.5.14",
-    "@types/node": "22.13.5",
-    "@typescript-eslint/eslint-plugin": "8.25.0",
-    "@typescript-eslint/parser": "8.25.0",
-    "aws-cdk": "2.1001.0",
-    "aws-cdk-lib": "2.181.0",
+    "@types/node": "22.13.10",
+    "@typescript-eslint/eslint-plugin": "8.26.1",
+    "@typescript-eslint/parser": "8.26.1",
+    "aws-cdk": "2.1004.0",
+    "aws-cdk-lib": "2.183.0",
     "constructs": "10.4.2",
-    "esbuild": "0.25.0",
-    "eslint": "9.21.0",
-    "eslint-config-prettier": "10.0.2",
+    "esbuild": "0.25.1",
+    "eslint": "9.22.0",
+    "eslint-config-prettier": "10.1.1",
     "eslint-plugin-prettier": "5.2.3",
     "husky": "9.1.7",
     "jest": "29.7.0",
     "jest-cdk-snapshot": "2.2.5",
-    "prettier": "3.5.2",
+    "prettier": "3.5.3",
     "semantic-release": "24.2.3",
     "ts-jest": "29.2.6",
     "tsx": "4.19.3",
-    "typedoc": "0.27.9",
-    "typescript": "5.7.3"
+    "typedoc": "0.28.0",
+    "typescript": "5.8.2"
   },
   "dependencies": {
-    "@aws-sdk/client-ssm": "3.758.0",
+    "@aws-sdk/client-ssm": "3.759.0",
     "@capraconsulting/webapp-deploy-lambda": "2.4.1",
     "aws-jwt-verify": "5.0.0",
     "del": "8.0.0",