@liflig/cdk 3.0.21 → 3.1.0

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

@@ -0,0 +1,578 @@
+import * as constructs from "constructs";
+import * as cdk from "aws-cdk-lib";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+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";
+import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
+import * as integrations from "aws-cdk-lib/aws-apigatewayv2-integrations";
+import * as authorizers from "aws-cdk-lib/aws-apigatewayv2-authorizers";
+import * as lambdaNodejs from "aws-cdk-lib/aws-lambda-nodejs";
+import { createHash } from "crypto";
+import * as route53 from "aws-cdk-lib/aws-route53";
+import * as route53Targets from "aws-cdk-lib/aws-route53-targets";
+import * as acm from "aws-cdk-lib/aws-certificatemanager";
+import { tagResources } from "../tags";
+import * as path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * This construct tries to simplify the creation of an API Gateway for a service, by collecting most
+ * of the common setup here.
+ *
+ * The approach followed in this construct is:
+ * 1. One API-GW per service
+ * 3. One subdomain per API-GW / service
+ * 4. Use HTTP API, not REST
+ * 5. Use a $default stage with autodeploy
+ * 6. Support multiple routes (with possible `/{proxy+}` to let all sub-paths through)
+ * 7. Allow custom integration/authorizer for each route, or defaults for the whole gateway
+ *
+ * The route integration is one of these:
+ * - ALB private integration with VPC Link using HTTPS to the ALB
+ * - Lambda integration
+ * - SQS integration
+ *
+ * ### Load Balancer Security Group
+ *
+ * Note that the load balancer used in an {@link AlbIntegrationProps} must allow outbound HTTPS
+ * traffic to its SecurityGroup. Otherwise, the VPC Link used by the API-GW can't get traffic from
+ * the ALB.
+ *
+ * ```
+ * const loadBalancerSecurityGroup = new ec2.SecurityGroup(..., {
+ *   allowAllOutbound: false,
+ * })
+ *
+ * loadBalancerSecurityGroup.addEgressRule(
+ *   loadBalancerSecurityGroup,
+ *   ec2.Port.tcp(443),
+ *   "Outbound to self for ALB to API-GW VPC-Link",
+ * )
+ *
+ * const loadBalancer = new lifligLoadBalancer.LoadBalancer(...,
+ *   {
+ *     overrideLoadBalancerProps: {
+ *       securityGroup: loadBalancerSecurityGroup,
+ *     },
+ *   },
+ * )
+ * ```
+ *
+ * @template AuthScopesT This type parameter allows you to improve type safety on the
+ * `requiredScope` field on {@link CognitoUserPoolOrBasicAuthAuthorizerProps}, by narrowing the type
+ * to specific strings. You can then extend the `ApiGateway` with this type to enforce those scopes
+ * across the application. Remember that auth scopes must be on the format
+ * `{resource server identifier}/{scope name}`.
+ *
+ * Example:
+ * ```
+ * type AuthScopes = "external/read_users" | "internal/create_users"
+ *
+ * export class MyProjectApiGateway extends ApiGateway<AuthScopes> {}
+ * ```
+ * TypeScript will then enforce that `requiredScope` is one of `AuthScopes`, and provide
+ * auto-complete.
+ *
+ * @author Kristian Rekstad <kre@capraconsulting.no>
+ * @author Hermann Mørkrid <hem@liflig.no>
+ */
+export class ApiGateway extends constructs.Construct {
+    /** The API Gateway HTTP API. This is the main construct for API-GW. */
+    httpApi;
+    /** The routes which connect the {@link httpApi} to the backend integration(s). */
+    routes = [];
+    /** The domain which consumers must use.*/
+    domain;
+    /** Access log group. */
+    logGroup;
+    props;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        ApiGateway.validateProps(props, id, cdk.Stack.of(this));
+        const customDomain = new CustomDomain(this, "CustomDomain", props.dns);
+        this.domain = customDomain.customDomainName;
+        let corsOptions;
+        if (props.corsAllowAll) {
+            corsOptions = {
+                allowOrigins: ["*"],
+                // "The Authorization header can't be wildcarded and always needs to be listed explicitly"
+                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers
+                // Content-Type may also require explicit whitelisting: https://stackoverflow.com/a/63567647
+                allowHeaders: ["Authorization", "Content-Type", "*"],
+                // Not using '*' here, because "In requests with credentials, it is treated as the literal
+                // method name '*' without special semantics"
+                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods
+                allowMethods: [
+                    apigw.CorsHttpMethod.GET,
+                    apigw.CorsHttpMethod.POST,
+                    apigw.CorsHttpMethod.PUT,
+                    apigw.CorsHttpMethod.PATCH,
+                    apigw.CorsHttpMethod.DELETE,
+                    apigw.CorsHttpMethod.OPTIONS,
+                    apigw.CorsHttpMethod.HEAD,
+                ],
+                maxAge: cdk.Duration.days(1),
+            };
+        }
+        // The actual API. This holds the routes, authorizers and integrations.
+        const api = new apigw.HttpApi(this, "HttpApi-" + props.dns.subdomain, {
+            // defaultIntegration: defaultIntegration, // This is for a catch-all $default route
+            description: `An HTTP API for ${props.dns.subdomain}.${props.dns.hostedZone.zoneName}.`,
+            disableExecuteApiEndpoint: true, // Force externals to go through custom domain. MUST be true when using Mutual TLS, for security reasons
+            createDefaultStage: true,
+            defaultDomainMapping: { domainName: customDomain.apiGwCustomDomain },
+            corsPreflight: corsOptions,
+            ...props?.propsOverride?.httpApi,
+        });
+        this.httpApi = api;
+        const stage = api.defaultStage?.node.defaultChild;
+        const logs = new ApiGatewayAccessLogs(this, "AccessLogs", stage, props.accessLogs, defaultAccessLogFormat);
+        this.logGroup = logs.logGroup;
+        stage.defaultRouteSettings = {
+            ...stage.defaultRouteSettings,
+            detailedMetricsEnabled: props.detailedMetrics ?? true,
+            throttlingBurstLimit: props.throttling?.burst, // Default for account is 5_000
+            throttlingRateLimit: props.throttling?.rate, // Default for account is 10_000
+        };
+        const defaultIntegration = props.defaultIntegration
+            ? this.createIntegration(props.defaultIntegration, props.dns)
+            : undefined;
+        const defaultAuthorizer = props.defaultAuthorization
+            ? this.createAuthorizer("DefaultAuthorizer", props.defaultAuthorization)
+            : undefined;
+        for (const route of props.routes) {
+            let integration;
+            if (route.integration) {
+                integration = this.createIntegration(route.integration, props.dns);
+            }
+            else {
+                integration = defaultIntegration; // Verified in validateProps
+            }
+            let authorizer;
+            if (route.authorization) {
+                authorizer = this.createAuthorizer(
+                // Using the route path here caused CloudFormation to fail due to resource names being too
+                // long. Therefore, we now hash the route path to get a shorter name.
+                `RouteAuthorizer${shortHash(`${route.method ?? ""}${route.path}`)}`, route.authorization);
+            }
+            else {
+                authorizer = defaultAuthorizer;
+            }
+            const routePaths = [route.path];
+            if (route.includeSubpaths === true) {
+                // If we include sub-paths, we add an additional route with /{proxy+} (the + means it will
+                // match all subroutes). We want both this route and the normal route without /{proxy+},
+                // since /{proxy+} will only match the base path with trailing slash.
+                routePaths.push(route.path + (route.path === "/" ? "" : "/") + "{proxy+}");
+            }
+            for (const routePath of routePaths) {
+                // The previous version of the API Gateway construct had a single route with the ID
+                // 'DefaultProxyRoute', and all gateways we used exposed the route /{proxy+}. When trying to
+                // change to this new version of the construct, deployment failed for gateways exposing
+                // /{proxy+}, because "a route with that key [i.e. path + method] already exists". We think
+                // this may be because we used the same route path, but with a new route ID, causing
+                // confusion for CloudFormation. So we keep the old route ID here for /{proxy+}.
+                const routeId = routePath === "/{proxy+}" ? "DefaultProxyRoute" : `Route-${routePath}`;
+                this.routes.push(new apigw.HttpRoute(this, routeId, {
+                    httpApi: api,
+                    integration: integration,
+                    authorizer: authorizer,
+                    routeKey: apigw.HttpRouteKey.with(routePath, route.method
+                        ? apigw.HttpMethod[route.method]
+                        : apigw.HttpMethod.ANY),
+                }));
+            }
+        }
+        tagResources(this, () => ({ service: props.dns.subdomain }));
+    }
+    /** @throws Error */
+    static validateProps(props, id, stack) {
+        for (const route of props.routes) {
+            if (!route.integration && !props.defaultIntegration) {
+                throw new Error(`No integration defined for route '${route.path}', and no default integration specified for the gateway`);
+            }
+            if (!route.authorization && !props.defaultAuthorization) {
+                throw new Error(`No authorization defined for route '${route.path}', and no default authorization specified for the gateway`);
+            }
+            if (!route.path.startsWith("/")) {
+                throw new Error(`Invalid path '${route.path}': paths must begin with '/' (use '/' for root path)`);
+            }
+            if (route.path !== "/" && route.path.endsWith("/")) {
+                throw new Error(`Invalid path '${route.path}': paths cannot end with '/' (except root path)`);
+            }
+            if (route.integration?.type === "ALB" &&
+                route.integration.hostName.startsWith("https:")) {
+                throw new Error(`The albIntegration.hostHttpsName should not include a protocol: ${route.integration.hostName}`);
+            }
+        }
+        if (props.dns.subdomain === "" || props.dns.subdomain.includes(" ")) {
+            throw new Error(`Subdomain must be set, and not contain spaces: ${props.dns.subdomain}`);
+        }
+        if (props.throttling?.burst && props.throttling.burst > 5_000) {
+            console.warn(`⚠️ Your throttling burst limit '${props.throttling.burst}' is higher than the AWS Account limit. Make sure your account has upgraded this quota! `, stack, id);
+        }
+        if (props.throttling?.rate && props.throttling.rate > 10_000) {
+            console.warn(`⚠️ Your throttling rate limit '${props.throttling.rate}' is higher than the AWS Account limit. Make sure your account has upgraded this quota! `, stack, id);
+        }
+    }
+    /**
+     * The authorizer only accepts requests from external users that are authorized.
+     * Unauthorized users are stopped in the API-GW, and not forwarded to the integration.
+     */
+    createAuthorizer(id, authorization) {
+        switch (authorization.type) {
+            case "NONE": {
+                return undefined;
+            }
+            case "IAM": {
+                // API Gateway invokes your API route only if the client has execute-api permission for the route.
+                // The client has to use AWS SigV4 to identify themselves in the request.
+                // Read this page for help with IAM and API-GW https://docs.aws.amazon.com/apigateway/latest/developerguide/security_iam_service-with-iam.html
+                // Note that [resource policies are not supported yet for HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-access-control-iam.html)
+                return new authorizers.HttpIamAuthorizer();
+            }
+            case "COGNITO_USER_POOL": {
+                // We use a custom lambda authorizer here instead of the `HttpUserPoolAuthorizer` provided
+                // by CDK, in order to support `requiredScope` and setting of custom context variables.
+                const authorizer = new CognitoUserPoolAuthorizer(this, id + "Lambda", authorization);
+                return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {
+                    responseTypes: authorizer.responseTypes,
+                    // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials
+                    resultsCacheTtl: cdk.Duration.hours(1),
+                });
+            }
+            case "BASIC_AUTH": {
+                const authorizer = new BasicAuthAuthorizer(this, id + "Lambda", authorization);
+                return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {
+                    responseTypes: authorizer.responseTypes,
+                    // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials
+                    resultsCacheTtl: cdk.Duration.minutes(30),
+                });
+            }
+            case "COGNITO_USER_POOL_OR_BASIC_AUTH": {
+                const authorizer = new CognitoUserPoolOrBasicAuthAuthorizer(this, id + "Lambda", authorization);
+                return new authorizers.HttpLambdaAuthorizer(id, authorizer.lambda, {
+                    responseTypes: authorizer.responseTypes,
+                    // Max 1h, or disabled (0s). The value only matters when invalidating/dynamic credentials
+                    resultsCacheTtl: cdk.Duration.hours(1),
+                });
+            }
+        }
+    }
+    createIntegration(integration, dns) {
+        switch (integration.type) {
+            case "ALB": {
+                // The VPCLink connects the integration into the ALB's VPC. Must be manually created when
+                // the VPC is imported, which is the case when using CorePlatformConsumer.
+                const vpcLink = new apigw.VpcLink(this, "AlbVpcLink", {
+                    vpc: integration.vpc,
+                    securityGroups: [integration.securityGroup],
+                    subnets: integration.vpc.selectSubnets(), // This correctly selects the private subnets
+                });
+                const parameterMapping = new apigw.ParameterMapping()
+                    /** See {@link AlbIntegrationProps.hostName} */
+                    .overwriteHeader("Host", 
+                // The Host header can NOT use dynamic mapping, like $context.domainName etc.
+                apigw.MappingValue.custom(integration.hostName));
+                if (integration.mapParameters !== undefined) {
+                    integration.mapParameters(parameterMapping);
+                }
+                return new integrations.HttpAlbIntegration("AlbIntegration-" + dns.subdomain, integration.loadBalancerListener, {
+                    secureServerName: integration.hostName,
+                    vpcLink: vpcLink,
+                    method: apigw.HttpMethod.ANY,
+                    parameterMapping,
+                });
+            }
+            case "Lambda": {
+                return new integrations.HttpLambdaIntegration("LambdaIntegration", integration.lambda, {
+                    payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_2_0,
+                    parameterMapping: undefined,
+                });
+            }
+            case "SQS": {
+                // API-GW does not have access to SQS by default
+                const role = new iam.Role(this, `ApiGwTo${integration.queue.node.id}ServiceRole`, {
+                    description: "Allows API-GW to add messages to " + integration.queue.queueArn,
+                    assumedBy: new iam.ServicePrincipal("apigateway.amazonaws.com"),
+                });
+                integration.queue.grantSendMessages(role);
+                let parameterMapping = new apigw.ParameterMapping()
+                    // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-aws-services-reference.html#SQS-SendMessage
+                    .custom("QueueUrl", integration.queue.queueUrl)
+                    .custom("MessageBody", "$request.body")
+                    .custom("Region", "eu-west-1"); // Change this if the SQS queue is in another region!
+                if (integration.messageAttributes) {
+                    parameterMapping = parameterMapping.custom("MessageAttributes", JSON.stringify(integration.messageAttributes));
+                }
+                return new SqsRouteIntegration("SqsIntegration", {
+                    type: apigw.HttpIntegrationType.AWS_PROXY,
+                    subtype: apigw.HttpIntegrationSubtype.SQS_SEND_MESSAGE,
+                    credentials: apigw.IntegrationCredentials.fromRole(role),
+                    parameterMapping: parameterMapping,
+                    payloadFormatVersion: apigw.PayloadFormatVersion.VERSION_1_0,
+                });
+            }
+        }
+    }
+    /**
+     * Allows a grantable target (role, user etc.) permission to invoke the API.
+     * Only works when using `IAM` as {@link ApiGatewayRoute.authorization}.
+     *
+     * @param target A grantable, like {@link iam.Role}
+     */
+    grantInvoke(target) {
+        for (const routeProps of this.props.routes) {
+            const authType = routeProps.authorization?.type ?? this.props.defaultAuthorization?.type;
+            if (authType !== "IAM") {
+                throw new Error(`Cannot grant invoke for an API Gateway when not using IAM auth (found auth '${authType}' on route '${routeProps.path}') [${cdk.Stack.of(this).stackName}]`);
+            }
+        }
+        for (const route of this.routes) {
+            route.grantInvoke(target);
+        }
+    }
+}
+/**
+ * Creates a custom domain for the API-Gateway, a Route53 record and an HTTPS cert.
+ * @author Kristian Rekstad <kre@capraconsulting.no>
+ */
+class CustomDomain extends constructs.Construct {
+    apiGwCustomDomain;
+    /** The Fully Qualified Domain Name (FQDN) like `product.platform.example.no`. */
+    customDomainName;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.customDomainName = `${props.subdomain}.${props.hostedZone.zoneName}`;
+        // Can also use wildcard certs instead! Cheaper
+        /** Allows external users to connect with HTTPS. */
+        const customDomainCert = new acm.Certificate(this, "HttpsCertificate", {
+            domainName: this.customDomainName,
+            validation: acm.CertificateValidation.fromDns(props.hostedZone),
+        });
+        // Note that API-GW can also support wildcard domains! https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-custom-domain-names.html#http-wildcard-custom-domain-names
+        // But this will not work when AWS account X has CustomDomain `staging.platform.example.no` and account Y has CustomDomain `*.platform.example.no`.
+        // Not sure how sub-subdomains are affected: `myservice.staging.platform.example.no` and `*.platform.example.no`.
+        this.apiGwCustomDomain = new apigw.DomainName(this, "DomainName-" + props.subdomain, {
+            domainName: this.customDomainName,
+            certificate: customDomainCert,
+            endpointType: apigw.EndpointType.REGIONAL,
+            securityPolicy: apigw.SecurityPolicy.TLS_1_2,
+        });
+        // This makes the API-GW publicly available on the custom domain name.
+        new route53.ARecord(this, "Route53ARecordApigwAlias", {
+            recordName: props.subdomain,
+            zone: props.hostedZone,
+            target: route53.RecordTarget.fromAlias(new route53Targets.ApiGatewayv2DomainProperties(this.apiGwCustomDomain.regionalDomainName, this.apiGwCustomDomain.regionalHostedZoneId)),
+            ttl: props.ttl ?? cdk.Duration.minutes(5), // Low TTL makes it easier to do changes
+        });
+    }
+}
+/** Acts as glue (between the integration props and the HttpApi) when creating an SqsIntegration. */
+class SqsRouteIntegration 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;
+    }
+}
+/**
+ * Creates a custom authorizer lambda which reads `Authorization: Bearer <token>` header and
+ * verifies the token against a Cognito user pool.
+ */
+class CognitoUserPoolAuthorizer extends constructs.Construct {
+    lambda;
+    /**
+     * Use simple response type (`{ isAuthorized: true/false }`), as opposed to returning an IAM
+     * Policy document.
+     */
+    responseTypes = [
+        authorizers.HttpLambdaResponseType.SIMPLE,
+    ];
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.lambda = new lambdaNodejs.NodejsFunction(this, "AuthorizerFunction", {
+            entry: path.join(__dirname, "authorizer-lambdas/cognito-user-pool-authorizer.ts"),
+            runtime: lambda.Runtime.NODEJS_22_X,
+            timeout: cdk.Duration.seconds(5),
+            environment: {
+                ["USER_POOL_ID"]: props.userPool.userPoolId,
+                ["REQUIRED_SCOPE"]: props.requiredScope ?? "",
+                ["CREDENTIALS_FOR_INTERNAL_AUTHORIZATION"]: props.credentialsForInternalAuthorization
+                    ? props.credentialsForInternalAuthorization
+                    : "",
+            },
+        });
+        if (props.credentialsForInternalAuthorization) {
+            secretsmanager.Secret.fromSecretNameV2(scope, id + "BasicAuthSecret", props.credentialsForInternalAuthorization).grantRead(this.lambda);
+        }
+    }
+}
+/**
+ * Creates a custom authorizer lambda which reads `Authorization: Basic <base64-encoded credentials>`
+ * header and verifies the credentials against a given secret.
+ */
+class BasicAuthAuthorizer extends constructs.Construct {
+    lambda;
+    // Simple is `{ isAuthorized: true/false }`, as opposed to returning an IAM Policy document
+    responseTypes = [
+        authorizers.HttpLambdaResponseType.SIMPLE,
+    ];
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.lambda = new lambdaNodejs.NodejsFunction(this, "BasicAuthLambda", {
+            entry: path.join(__dirname, "authorizer-lambdas/basic-auth-authorizer.ts"),
+            description: "An authorizer for API-Gateway that checks Basic Auth credentials on requests",
+            runtime: lambda.Runtime.NODEJS_22_X,
+            environment: {
+                ["CREDENTIALS_SECRET_NAME"]: props.credentialsSecretName
+                    ? props.credentialsSecretName
+                    : "",
+            },
+        });
+        if (props.credentialsSecretName) {
+            secretsmanager.Secret.fromSecretNameV2(scope, id + "BasicAuthSecret", props.credentialsSecretName).grantRead(this.lambda);
+        }
+    }
+}
+/**
+ * Creates a custom authorizer lambda which allows both:
+ * - `Authorization: Bearer <token>` header, for which the token is checked against the given
+ *   Cognito user pool
+ * - `Authorization: Basic <base64-encoded credentials>` header, for which the credentials are
+ *   checked against the credentials from the given basic auth secret name
+ *
+ * If either of these are given and valid, the request is authenticated.
+ */
+class CognitoUserPoolOrBasicAuthAuthorizer extends constructs.Construct {
+    lambda;
+    /**
+     * Use simple response type (`{ isAuthorized: true/false }`), as opposed to returning an IAM
+     * Policy document.
+     */
+    responseTypes = [
+        authorizers.HttpLambdaResponseType.SIMPLE,
+    ];
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.lambda = new lambdaNodejs.NodejsFunction(this, "AuthorizerFunction", {
+            entry: path.join(__dirname, "authorizer-lambdas/cognito-user-pool-or-basic-auth-authorizer.ts"),
+            runtime: lambda.Runtime.NODEJS_22_X,
+            timeout: cdk.Duration.seconds(5),
+            environment: {
+                ["USER_POOL_ID"]: props.userPool ? props.userPool.userPoolId : "",
+                ["REQUIRED_SCOPE"]: props.requiredScope ?? "",
+                ["BASIC_AUTH_CREDENTIALS_SECRET_NAME"]: props.basicAuthCredentialsSecretName
+                    ? props.basicAuthCredentialsSecretName
+                    : "",
+            },
+        });
+        if (props.basicAuthCredentialsSecretName) {
+            secretsmanager.Secret.fromSecretNameV2(scope, id + "BasicAuthSecret", props.basicAuthCredentialsSecretName).grantRead(this.lambda);
+        }
+    }
+}
+/**
+ * A slightly extended version of the [default JSON format suggested by AWS](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html#http-api-enable-logging.examples).
+ */
+const defaultAccessLogFormat = {
+    requestId: "$context.requestId",
+    userAgent: "$context.identity.userAgent",
+    ip: "$context.identity.sourceIp",
+    /** CLF format: `dd/MMM/yyyy:HH:mm:ss +-hhmm` */
+    requestTime: "$context.requestTime",
+    requestTimeEpoch: "$context.requestTimeEpoch",
+    dataProcessed: "$context.dataProcessed",
+    httpMethod: "$context.httpMethod",
+    path: "$context.path",
+    routeKey: "$context.routeKey",
+    status: "$context.status",
+    protocol: "$context.protocol",
+    responseLength: "$context.responseLength",
+    responseLatency: "$context.responseLatency",
+    domainName: "$context.domainName",
+    //  hostHeaderOverride: "$context.requestOverride.header.Host", //Mapping template overrides cannot be used with proxy integration endpoints, which lack data mappings https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html#:~:text=Mapping%20template%20overrides%20cannot%20be%20used%20with%20proxy%20integration%20endpoints%2C%20which%20lack%20data%20mappings
+    error: {
+        type: "$context.error.responseType",
+        gatewayError: "$context.error.message",
+        integrationError: "$context.integration.error",
+        authorizerError: "$context.authorizer.error",
+    },
+    integration: {
+        latency: "$context.integration.latency",
+        requestId: "$context.integration.requestId",
+        responseStatus: "$context.integration.status",
+    },
+    auth: {
+        iam: {
+            userArn: "$context.identity.userArn",
+            awsAccount: "$context.identity.accountId",
+            awsPrincipal: "$context.identity.caller",
+            awsPrincipalOrg: "$context.identity.principalOrgId",
+        },
+        basic: { user: "$context.authorizer.user" },
+    },
+    awsEndpointRequest: {
+        id: "$context.awsEndpointRequestId",
+        id2: "$context.awsEndpointRequestId2",
+    },
+    // For datadog
+    message: "$context.identity.sourceIp - $context.httpMethod $context.domainName $context.path ($context.routeKey) - $context.status [$context.responseLatency ms]",
+};
+/**
+ * Enables access logs on the API-Gateway.
+ *
+ * @author Kristian Rekstad <kre@capraconsulting.no>
+ */
+class ApiGatewayAccessLogs extends constructs.Construct {
+    logGroup;
+    constructor(scope, id, stage, props, defaultAccessLogFormat) {
+        super(scope, id);
+        // logGroup is set up with help from: https://github.com/aws/aws-cdk/issues/11100#issuecomment-904627081
+        // Not sure if HTTP API actually needs the service role with managed policy: https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html
+        const accessLogs = new logs.LogGroup(this, "AccessLogGroup", {
+            retention: props?.retention,
+            removalPolicy: props?.removalPolicy ?? cdk.RemovalPolicy.RETAIN,
+            // Always use the default encryption key. Otherwise, the key needs special policies:
+            // https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html#cmk-permissions
+            encryptionKey: undefined,
+        });
+        this.logGroup = accessLogs;
+        stage.accessLogSettings = {
+            destinationArn: accessLogs.logGroupArn,
+            format: JSON.stringify(props?.accessLogFormat ?? defaultAccessLogFormat),
+        };
+        const apiGwLogsRole = new iam.Role(this, "ApiGatewayPushToCloudwatchLogsRole", {
+            assumedBy: new iam.ServicePrincipal("apigateway.amazonaws.com"),
+            managedPolicies: [
+                iam.ManagedPolicy.fromAwsManagedPolicyName("service-role/AmazonAPIGatewayPushToCloudWatchLogs"),
+            ],
+        });
+        accessLogs.grantWrite(apiGwLogsRole);
+    }
+}
+/** Returns a short semi-unique hash of the given string. */
+function shortHash(str) {
+    // SHA-1 is no-no when we need cryptographic security, but here we just it for shortening a name,
+    // 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 * as route53 from \"aws-cdk-lib/aws-route53\"\nimport * as route53Targets from \"aws-cdk-lib/aws-route53-targets\"\nimport * as acm from \"aws-cdk-lib/aws-certificatemanager\"\nimport { tagResources } from \"../tags\"\nimport * as path from \"path\"\nimport { fileURLToPath } from \"url\"\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 ApiGatewayDnsProps = {\n  /**\n   * Only the subdomain prefix, which should be the name of the service.\n   * Example: Subdomain `product` would give the end result of an API-GW with\n   * `product.platform.example.no`.\n   */\n  subdomain: string\n\n  /**\n   * Hosted Zone for the external facing domain.\n   * This is where routes will be created, to redirect consumers to the API-GW.\n   * For example a HZ for `platform.example.no`.\n   */\n  hostedZone: route53.IHostedZone\n\n  /**\n   * The Time To Live (TTL) for the public DNS A record that will expose the API-GW.\n   * This is how long DNS servers will cache the record.\n   *\n   * A long TTL (hours) is beneficial to DNS servers, but makes developers (you) wait longer when\n   * doing changes.\n   *\n   * @default 5 minutes\n   */\n  ttl?: cdk.Duration\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 authorizer lambda which reads `Authorization: Bearer <token>` header and\n   * verifies the token against a Cognito user pool.\n   */\n  | ({\n      type: \"COGNITO_USER_POOL\"\n    } & CognitoUserPoolAuthorizerProps<AuthScopesT>)\n  /**\n   * Creates a custom authorizer lambda 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 authorizer lambda which allows both:\n   * - `Authorization: Bearer <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   */\n  | ({\n      type: \"COGNITO_USER_POOL_OR_BASIC_AUTH\"\n    } & CognitoUserPoolOrBasicAuthAuthorizerProps<AuthScopesT>)\n\nexport type CognitoUserPoolAuthorizerProps<\n  AuthScopesT extends string = string,\n> = {\n  userPool: IUserPool\n\n  /**\n   * Verifies that 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. The secret value must\n   * follow this format:\n   * ```json\n   * {\"username\":\"<username>\",\"password\":\"<password>\"}\n   * ```\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. The secret value must\n   * follow this format:\n   * ```json\n   * {\"username\":\"<username>\",\"password\":\"<password>\"}\n   * ```\n   */\n  basicAuthCredentialsSecretName?: string\n\n  /**\n   * Verifies that token claims contain the given scope. Only applicable for `Bearer` token requests\n   * checked against the Cognito User Pool (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\nexport type ApiGatewayAccessLogsProps = {\n  /**\n   * Delete the access logs if this construct is deleted?\n   *\n   * Maybe you want to DESTROY instead. Or for legal reasons, retain for audit.\n   *\n   * @default RemovalPolicy.RETAIN\n   */\n  removalPolicy?: cdk.RemovalPolicy\n\n  /**\n   * How long to keep the logs. If undefined, uses the same default as new AWS log groups.\n   *\n   * @default RetentionDays.TWO_YEARS\n   */\n  retention?: logs.RetentionDays\n\n  /**\n   * A custom JSON log format, which uses variables from `\"$context\"`.\n   *\n   * See [AWS: CloudWatch log formats for API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-logging.html#apigateway-cloudwatch-log-formats)\n   * for formats and rules. It is possible to use other formats like CLF and XML, but this construct\n   * only supports JSON for now.\n   *\n   * For a list of all possible variables to log, see\n   * [AWS: $context Variables for data models, authorizers, mapping templates, and CloudWatch access logging](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html#context-variable-reference)\n   * and\n   * [AWS: $context Variables for access logging only](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html#context-variable-reference-access-logging-only) .\n   *\n   * @default {@link defaultAccessLogFormat}\n   */\n  accessLogFormat?: Record<string, string>\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 * 3. One subdomain per API-GW / service\n * 4. Use HTTP API, not REST\n * 5. Use a $default stage with autodeploy\n * 6. Support multiple routes (with possible `/{proxy+}` to let all sub-paths through)\n * 7. 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 CustomDomain(this, \"CustomDomain\", props.dns)\n    this.domain = customDomain.customDomainName\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.apiGwCustomDomain },\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      defaultAccessLogFormat,\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    }\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/**\n * Creates a custom domain for the API-Gateway, a Route53 record and an HTTPS cert.\n * @author Kristian Rekstad <kre@capraconsulting.no>\n */\nclass CustomDomain extends constructs.Construct {\n  public readonly apiGwCustomDomain: apigw.DomainName\n\n  /** The Fully Qualified Domain Name (FQDN) like `product.platform.example.no`. */\n  public readonly customDomainName: string\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: ApiGatewayDnsProps,\n  ) {\n    super(scope, id)\n    this.customDomainName = `${props.subdomain}.${props.hostedZone.zoneName}`\n\n    // Can also use wildcard certs instead! Cheaper\n    /** Allows external users to connect with HTTPS. */\n    const customDomainCert = new acm.Certificate(this, \"HttpsCertificate\", {\n      domainName: this.customDomainName,\n      validation: acm.CertificateValidation.fromDns(props.hostedZone),\n    })\n\n    // Note that API-GW can also support wildcard domains! https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-custom-domain-names.html#http-wildcard-custom-domain-names\n    // But this will not work when AWS account X has CustomDomain `staging.platform.example.no` and account Y has CustomDomain `*.platform.example.no`.\n    // Not sure how sub-subdomains are affected: `myservice.staging.platform.example.no` and `*.platform.example.no`.\n    this.apiGwCustomDomain = new apigw.DomainName(\n      this,\n      \"DomainName-\" + props.subdomain,\n      {\n        domainName: this.customDomainName,\n        certificate: customDomainCert,\n        endpointType: apigw.EndpointType.REGIONAL,\n        securityPolicy: apigw.SecurityPolicy.TLS_1_2,\n      },\n    )\n\n    // This makes the API-GW publicly available on the custom domain name.\n    new route53.ARecord(this, \"Route53ARecordApigwAlias\", {\n      recordName: props.subdomain,\n      zone: props.hostedZone,\n      target: route53.RecordTarget.fromAlias(\n        new route53Targets.ApiGatewayv2DomainProperties(\n          this.apiGwCustomDomain.regionalDomainName,\n          this.apiGwCustomDomain.regionalHostedZoneId,\n        ),\n      ),\n      ttl: props.ttl ?? cdk.Duration.minutes(5), // Low TTL makes it easier to do changes\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 * Creates a custom authorizer lambda which reads `Authorization: Bearer <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        \"authorizer-lambdas/cognito-user-pool-authorizer.ts\",\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 authorizer lambda 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        \"authorizer-lambdas/basic-auth-authorizer.ts\",\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    if (props.credentialsSecretName) {\n      secretsmanager.Secret.fromSecretNameV2(\n        scope,\n        id + \"BasicAuthSecret\",\n        props.credentialsSecretName,\n      ).grantRead(this.lambda)\n    }\n  }\n}\n\n/**\n * Creates a custom authorizer lambda which allows both:\n * - `Authorization: Bearer <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        \"authorizer-lambdas/cognito-user-pool-or-basic-auth-authorizer.ts\",\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/**\n * A slightly extended version of the [default JSON format suggested by AWS](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html#http-api-enable-logging.examples).\n */\nconst defaultAccessLogFormat = {\n  requestId: \"$context.requestId\",\n  userAgent: \"$context.identity.userAgent\",\n  ip: \"$context.identity.sourceIp\",\n  /** CLF format: `dd/MMM/yyyy:HH:mm:ss +-hhmm` */\n  requestTime: \"$context.requestTime\",\n  requestTimeEpoch: \"$context.requestTimeEpoch\",\n  dataProcessed: \"$context.dataProcessed\",\n  httpMethod: \"$context.httpMethod\",\n  path: \"$context.path\",\n  routeKey: \"$context.routeKey\",\n  status: \"$context.status\",\n  protocol: \"$context.protocol\",\n  responseLength: \"$context.responseLength\",\n  responseLatency: \"$context.responseLatency\",\n  domainName: \"$context.domainName\",\n  //  hostHeaderOverride: \"$context.requestOverride.header.Host\", //Mapping template overrides cannot be used with proxy integration endpoints, which lack data mappings https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html#:~:text=Mapping%20template%20overrides%20cannot%20be%20used%20with%20proxy%20integration%20endpoints%2C%20which%20lack%20data%20mappings\n  error: {\n    type: \"$context.error.responseType\",\n    gatewayError: \"$context.error.message\",\n    integrationError: \"$context.integration.error\",\n    authorizerError: \"$context.authorizer.error\",\n  },\n  integration: {\n    latency: \"$context.integration.latency\",\n    requestId: \"$context.integration.requestId\",\n    responseStatus: \"$context.integration.status\",\n  },\n  auth: {\n    iam: {\n      userArn: \"$context.identity.userArn\",\n      awsAccount: \"$context.identity.accountId\",\n      awsPrincipal: \"$context.identity.caller\",\n      awsPrincipalOrg: \"$context.identity.principalOrgId\",\n    },\n    basic: { user: \"$context.authorizer.user\" },\n  },\n  awsEndpointRequest: {\n    id: \"$context.awsEndpointRequestId\",\n    id2: \"$context.awsEndpointRequestId2\",\n  },\n  // For datadog\n  message:\n    \"$context.identity.sourceIp - $context.httpMethod $context.domainName $context.path ($context.routeKey) - $context.status [$context.responseLatency ms]\",\n}\n\n/**\n * Enables access logs on the API-Gateway.\n *\n * @author Kristian Rekstad <kre@capraconsulting.no>\n */\nclass ApiGatewayAccessLogs extends constructs.Construct {\n  public readonly logGroup: logs.LogGroup\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    stage: apigw.CfnStage,\n    props: ApiGatewayAccessLogsProps | undefined,\n    defaultAccessLogFormat: Record<string, unknown>,\n  ) {\n    super(scope, id)\n\n    // logGroup is set up with help from: https://github.com/aws/aws-cdk/issues/11100#issuecomment-904627081\n    // Not sure if HTTP API actually needs the service role with managed policy: https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html\n    const accessLogs = new logs.LogGroup(this, \"AccessLogGroup\", {\n      retention: props?.retention,\n      removalPolicy: props?.removalPolicy ?? cdk.RemovalPolicy.RETAIN,\n      // Always use the default encryption key. Otherwise, the key needs special policies:\n      // https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html#cmk-permissions\n      encryptionKey: undefined,\n    })\n    this.logGroup = accessLogs\n\n    stage.accessLogSettings = {\n      destinationArn: accessLogs.logGroupArn,\n      format: JSON.stringify(props?.accessLogFormat ?? defaultAccessLogFormat),\n    }\n\n    const apiGwLogsRole = new iam.Role(\n      this,\n      \"ApiGatewayPushToCloudwatchLogsRole\",\n      {\n        assumedBy: new iam.ServicePrincipal(\"apigateway.amazonaws.com\"),\n        managedPolicies: [\n          iam.ManagedPolicy.fromAwsManagedPolicyName(\n            \"service-role/AmazonAPIGatewayPushToCloudWatchLogs\",\n          ),\n        ],\n      },\n    )\n\n    accessLogs.grantWrite(apiGwLogsRole)\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"]}