@liflig/cdk 3.5.4 → 3.5.5

package/lib/api-gateway/access-logs.d.ts

@@ -0,0 +1,44 @@
+import * as constructs from "constructs";
+import * as cdk from "aws-cdk-lib";
+import * as apigw from "aws-cdk-lib/aws-apigatewayv2";
+import * as logs from "aws-cdk-lib/aws-logs";
+export type ApiGatewayAccessLogsProps = {
+    /**
+     * Delete the access logs if this construct is deleted?
+     *
+     * Maybe you want to DESTROY instead. Or for legal reasons, retain for audit.
+     *
+     * @default RemovalPolicy.RETAIN
+     */
+    removalPolicy?: cdk.RemovalPolicy;
+    /**
+     * How long to keep the logs. If undefined, uses the same default as new AWS log groups.
+     *
+     * @default RetentionDays.TWO_YEARS
+     */
+    retention?: logs.RetentionDays;
+    /**
+     * A custom JSON log format, which uses variables from `"$context"`.
+     *
+     * See [AWS: CloudWatch log formats for API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-logging.html#apigateway-cloudwatch-log-formats)
+     * for formats and rules. It is possible to use other formats like CLF and XML, but this construct
+     * only supports JSON for now.
+     *
+     * For a list of all possible variables to log, see
+     * [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)
+     * and
+     * [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) .
+     *
+     * @default {@link defaultAccessLogFormat}
+     */
+    accessLogFormat?: Record<string, string>;
+};
+/**
+ * Enables access logs on the API-Gateway.
+ *
+ * @author Kristian Rekstad <kre@capraconsulting.no>
+ */
+export declare class ApiGatewayAccessLogs extends constructs.Construct {
+    readonly logGroup: logs.LogGroup;
+    constructor(scope: constructs.Construct, id: string, stage: apigw.CfnStage, props: ApiGatewayAccessLogsProps | undefined);
+}

package/lib/api-gateway/access-logs.js

@@ -0,0 +1,84 @@
+import * as constructs from "constructs";
+import * as cdk from "aws-cdk-lib";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as iam from "aws-cdk-lib/aws-iam";
+/**
+ * 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",
+    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",
+        },
+        // We output these context variables from our Lambda authorizers
+        basic: { username: "$context.authorizer.username" },
+        cognito: { clientId: "$context.authorizer.clientId" },
+    },
+    awsEndpointRequest: {
+        id: "$context.awsEndpointRequestId",
+        id2: "$context.awsEndpointRequestId2",
+    },
+    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>
+ */
+export class ApiGatewayAccessLogs extends constructs.Construct {
+    logGroup;
+    constructor(scope, id, stage, props) {
+        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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"access-logs.js","sourceRoot":"","sources":["../../src/api-gateway/access-logs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,GAAG,MAAM,aAAa,CAAA;AAElC,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,OAAO,KAAK,GAAG,MAAM,qBAAqB,CAAA;AAoC1C;;GAEG;AACH,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,oBAAoB;IAC/B,SAAS,EAAE,6BAA6B;IACxC,EAAE,EAAE,4BAA4B;IAChC,gDAAgD;IAChD,WAAW,EAAE,sBAAsB;IACnC,gBAAgB,EAAE,2BAA2B;IAC7C,aAAa,EAAE,wBAAwB;IACvC,UAAU,EAAE,qBAAqB;IACjC,IAAI,EAAE,eAAe;IACrB,QAAQ,EAAE,mBAAmB;IAC7B,MAAM,EAAE,iBAAiB;IACzB,QAAQ,EAAE,mBAAmB;IAC7B,cAAc,EAAE,yBAAyB;IACzC,eAAe,EAAE,0BAA0B;IAC3C,UAAU,EAAE,qBAAqB;IACjC,KAAK,EAAE;QACL,IAAI,EAAE,6BAA6B;QACnC,YAAY,EAAE,wBAAwB;QACtC,gBAAgB,EAAE,4BAA4B;QAC9C,eAAe,EAAE,2BAA2B;KAC7C;IACD,WAAW,EAAE;QACX,OAAO,EAAE,8BAA8B;QACvC,SAAS,EAAE,gCAAgC;QAC3C,cAAc,EAAE,6BAA6B;KAC9C;IACD,IAAI,EAAE;QACJ,GAAG,EAAE;YACH,OAAO,EAAE,2BAA2B;YACpC,UAAU,EAAE,6BAA6B;YACzC,YAAY,EAAE,0BAA0B;YACxC,eAAe,EAAE,kCAAkC;SACpD;QACD,gEAAgE;QAChE,KAAK,EAAE,EAAE,QAAQ,EAAE,8BAA8B,EAAE;QACnD,OAAO,EAAE,EAAE,QAAQ,EAAE,8BAA8B,EAAE;KACtD;IACD,kBAAkB,EAAE;QAClB,EAAE,EAAE,+BAA+B;QACnC,GAAG,EAAE,gCAAgC;KACtC;IACD,OAAO,EACL,wJAAwJ;CAC3J,CAAA;AAED;;;;GAIG;AACH,MAAM,OAAO,oBAAqB,SAAQ,UAAU,CAAC,SAAS;IAC5C,QAAQ,CAAe;IAEvC,YACE,KAA2B,EAC3B,EAAU,EACV,KAAqB,EACrB,KAA4C;QAE5C,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;QAEhB,wGAAwG;QACxG,+JAA+J;QAC/J,MAAM,UAAU,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAC3D,SAAS,EAAE,KAAK,EAAE,SAAS;YAC3B,aAAa,EAAE,KAAK,EAAE,aAAa,IAAI,GAAG,CAAC,aAAa,CAAC,MAAM;YAC/D,oFAAoF;YACpF,qGAAqG;YACrG,aAAa,EAAE,SAAS;SACzB,CAAC,CAAA;QACF,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAA;QAE1B,KAAK,CAAC,iBAAiB,GAAG;YACxB,cAAc,EAAE,UAAU,CAAC,WAAW;YACtC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,eAAe,IAAI,sBAAsB,CAAC;SACzE,CAAA;QAED,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,IAAI,CAChC,IAAI,EACJ,oCAAoC,EACpC;YACE,SAAS,EAAE,IAAI,GAAG,CAAC,gBAAgB,CAAC,0BAA0B,CAAC;YAC/D,eAAe,EAAE;gBACf,GAAG,CAAC,aAAa,CAAC,wBAAwB,CACxC,mDAAmD,CACpD;aACF;SACF,CACF,CAAA;QAED,UAAU,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;IACtC,CAAC;CACF","sourcesContent":["import * as constructs from \"constructs\"\nimport * as cdk from \"aws-cdk-lib\"\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\"\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 * 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  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    // We output these context variables from our Lambda authorizers\n    basic: { username: \"$context.authorizer.username\" },\n    cognito: { clientId: \"$context.authorizer.clientId\" },\n  },\n  awsEndpointRequest: {\n    id: \"$context.awsEndpointRequestId\",\n    id2: \"$context.awsEndpointRequestId2\",\n  },\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 */\nexport class 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  ) {\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"]}

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

@@ -0,0 +1,39 @@
+import * as constructs from "constructs";
+import * as cdk from "aws-cdk-lib";
+import * as apigw from "aws-cdk-lib/aws-apigatewayv2";
+import * as route53 from "aws-cdk-lib/aws-route53";
+export type ApiGatewayDnsProps = {
+    /**
+     * Only the subdomain prefix, which should be the name of the service.
+     * Example: Subdomain `product` would give the end result of an API-GW with
+     * `product.platform.example.no`.
+     */
+    subdomain: string;
+    /**
+     * Hosted Zone for the external facing domain.
+     * This is where routes will be created, to redirect consumers to the API-GW.
+     * For example a HZ for `platform.example.no`.
+     */
+    hostedZone: route53.IHostedZone;
+    /**
+     * The Time To Live (TTL) for the public DNS A record that will expose the API-GW.
+     * This is how long DNS servers will cache the record.
+     *
+     * A long TTL (hours) is beneficial to DNS servers, but makes developers (you) wait longer when
+     * doing changes.
+     *
+     * @default 5 minutes
+     */
+    ttl?: cdk.Duration;
+};
+/**
+ * Creates a custom domain for the API-Gateway, a Route53 record and an HTTPS cert.
+ *
+ * @author Kristian Rekstad <kre@capraconsulting.no>
+ */
+export declare class ApiGatewayDomain extends constructs.Construct {
+    /** The Fully Qualified Domain Name (FQDN) like `product.platform.example.no`. */
+    readonly fullDomainName: string;
+    readonly apiGwDomainName: apigw.DomainName;
+    constructor(scope: constructs.Construct, id: string, props: ApiGatewayDnsProps);
+}

package/lib/api-gateway/domain.js

@@ -0,0 +1,43 @@
+import * as constructs from "constructs";
+import * as cdk from "aws-cdk-lib";
+import * as apigw from "aws-cdk-lib/aws-apigatewayv2";
+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";
+/**
+ * Creates a custom domain for the API-Gateway, a Route53 record and an HTTPS cert.
+ *
+ * @author Kristian Rekstad <kre@capraconsulting.no>
+ */
+export class ApiGatewayDomain extends constructs.Construct {
+    /** The Fully Qualified Domain Name (FQDN) like `product.platform.example.no`. */
+    fullDomainName;
+    apiGwDomainName;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.fullDomainName = `${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.fullDomainName,
+            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.apiGwDomainName = new apigw.DomainName(this, "DomainName-" + props.subdomain, {
+            domainName: this.fullDomainName,
+            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.apiGwDomainName.regionalDomainName, this.apiGwDomainName.regionalHostedZoneId)),
+            ttl: props.ttl ?? cdk.Duration.minutes(5), // Low TTL makes it easier to do changes
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,4 @@
 import * as constructs from "constructs";
-import * as cdk from "aws-cdk-lib";
 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";
@@ -9,7 +8,8 @@ import * as logs from "aws-cdk-lib/aws-logs";
 import * as iam from "aws-cdk-lib/aws-iam";
 import * as authorizers from "aws-cdk-lib/aws-apigatewayv2-authorizers";
 import type { IUserPool } from "aws-cdk-lib/aws-cognito";
-import * as route53 from "aws-cdk-lib/aws-route53";
+import { ApiGatewayDnsProps } from "./domain";
+import { ApiGatewayAccessLogsProps } from "./access-logs";
 /**
  * Props for the {@link ApiGateway} construct.
  *
@@ -84,30 +84,6 @@ export type ApiGatewayProps<AuthScopesT extends string = string> = {
         httpApi?: Partial<apigw.HttpApiProps>;
     };
 };
-export type ApiGatewayDnsProps = {
-    /**
-     * Only the subdomain prefix, which should be the name of the service.
-     * Example: Subdomain `product` would give the end result of an API-GW with
-     * `product.platform.example.no`.
-     */
-    subdomain: string;
-    /**
-     * Hosted Zone for the external facing domain.
-     * This is where routes will be created, to redirect consumers to the API-GW.
-     * For example a HZ for `platform.example.no`.
-     */
-    hostedZone: route53.IHostedZone;
-    /**
-     * The Time To Live (TTL) for the public DNS A record that will expose the API-GW.
-     * This is how long DNS servers will cache the record.
-     *
-     * A long TTL (hours) is beneficial to DNS servers, but makes developers (you) wait longer when
-     * doing changes.
-     *
-     * @default 5 minutes
-     */
-    ttl?: cdk.Duration;
-};
 export type ApiGatewayRoute<AuthScopesT extends string = string> = {
     /** The path of the route to expose through the API Gateway. Use "/" for the root route. */
     path: string;
@@ -432,37 +408,6 @@ type CustomLambdaAuthorizerProps = {
      */
     authorizerProps?: Partial<authorizers.HttpLambdaAuthorizerProps>;
 };
-export type ApiGatewayAccessLogsProps = {
-    /**
-     * Delete the access logs if this construct is deleted?
-     *
-     * Maybe you want to DESTROY instead. Or for legal reasons, retain for audit.
-     *
-     * @default RemovalPolicy.RETAIN
-     */
-    removalPolicy?: cdk.RemovalPolicy;
-    /**
-     * How long to keep the logs. If undefined, uses the same default as new AWS log groups.
-     *
-     * @default RetentionDays.TWO_YEARS
-     */
-    retention?: logs.RetentionDays;
-    /**
-     * A custom JSON log format, which uses variables from `"$context"`.
-     *
-     * See [AWS: CloudWatch log formats for API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-logging.html#apigateway-cloudwatch-log-formats)
-     * for formats and rules. It is possible to use other formats like CLF and XML, but this construct
-     * only supports JSON for now.
-     *
-     * For a list of all possible variables to log, see
-     * [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)
-     * and
-     * [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) .
-     *
-     * @default {@link defaultAccessLogFormat}
-     */
-    accessLogFormat?: Record<string, string>;
-};
 /**
  * This construct tries to simplify the creation of an API Gateway for a service, by collecting most
  * of the common setup here.

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

@@ -2,19 +2,17 @@ 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";
+import { ApiGatewayDomain } from "./domain";
+import { ApiGatewayAccessLogs } from "./access-logs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
@@ -92,8 +90,8 @@ export class ApiGateway extends constructs.Construct {
         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;
+        const customDomain = new ApiGatewayDomain(this, "CustomDomain", props.dns);
+        this.domain = customDomain.fullDomainName;
         let corsOptions;
         if (props.corsAllowAll) {
             corsOptions = {
@@ -123,13 +121,13 @@ export class ApiGateway extends constructs.Construct {
             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 },
+            defaultDomainMapping: { domainName: customDomain.apiGwDomainName },
             corsPreflight: corsOptions,
             ...props?.propsOverride?.httpApi,
         });
         this.httpApi = api;
         const stage = api.defaultStage?.node.defaultChild;
-        const logs = new ApiGatewayAccessLogs(this, "AccessLogs", stage, props.accessLogs, defaultAccessLogFormat);
+        const logs = new ApiGatewayAccessLogs(this, "AccessLogs", stage, props.accessLogs);
         this.logGroup = logs.logGroup;
         stage.defaultRouteSettings = {
             ...stage.defaultRouteSettings,
@@ -346,41 +344,6 @@ export class ApiGateway extends constructs.Construct {
         }
     }
 }
-/**
- * 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;
@@ -509,88 +472,10 @@ class CognitoUserPoolOrBasicAuthAuthorizer extends constructs.Construct {
         }
     }
 }
-/**
- * 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",
-    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: { username: "$context.authorizer.username" },
-        cognito: { clientId: "$context.authorizer.clientId" },
-    },
-    awsEndpointRequest: {
-        id: "$context.awsEndpointRequestId",
-        id2: "$context.awsEndpointRequestId2",
-    },
-    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 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\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 * 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 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      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/**\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 * 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/**\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  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: { username: \"$context.authorizer.username\" },\n    cognito: { clientId: \"$context.authorizer.clientId\" },\n  },\n  awsEndpointRequest: {\n    id: \"$context.awsEndpointRequestId\",\n    id2: \"$context.awsEndpointRequestId2\",\n  },\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"]}
+//# 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"]}

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

@@ -1 +1,3 @@
-export { ApiGateway, type ApiGatewayProps, type ApiGatewayDnsProps, type ApiGatewayRoute, type HttpMethod, type IntegrationProps, type AlbIntegrationProps, type LambdaIntegrationProps, type SqsIntegrationProps, type AuthorizationProps, type CognitoUserPoolAuthorizerProps, type BasicAuthAuthorizerProps, type CognitoUserPoolOrBasicAuthAuthorizerProps, type ApiGatewayAccessLogsProps, } from "./http-api-gateway";
+export { ApiGateway, type ApiGatewayProps, type ApiGatewayRoute, type HttpMethod, type IntegrationProps, type AlbIntegrationProps, type LambdaIntegrationProps, type SqsIntegrationProps, type AuthorizationProps, type CognitoUserPoolAuthorizerProps, type BasicAuthAuthorizerProps, type CognitoUserPoolOrBasicAuthAuthorizerProps, } from "./http-api-gateway";
+export { ApiGatewayAccessLogs, type ApiGatewayAccessLogsProps, } from "./access-logs";
+export { ApiGatewayDomain, type ApiGatewayDnsProps } from "./domain";

package/lib/api-gateway/index.js

@@ -1,2 +1,4 @@
 export { ApiGateway, } from "./http-api-gateway";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBpLWdhdGV3YXkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFVBQVUsR0FjWCxNQUFNLG9CQUFvQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgQXBpR2F0ZXdheSxcbiAgdHlwZSBBcGlHYXRld2F5UHJvcHMsXG4gIHR5cGUgQXBpR2F0ZXdheURuc1Byb3BzLFxuICB0eXBlIEFwaUdhdGV3YXlSb3V0ZSxcbiAgdHlwZSBIdHRwTWV0aG9kLFxuICB0eXBlIEludGVncmF0aW9uUHJvcHMsXG4gIHR5cGUgQWxiSW50ZWdyYXRpb25Qcm9wcyxcbiAgdHlwZSBMYW1iZGFJbnRlZ3JhdGlvblByb3BzLFxuICB0eXBlIFNxc0ludGVncmF0aW9uUHJvcHMsXG4gIHR5cGUgQXV0aG9yaXphdGlvblByb3BzLFxuICB0eXBlIENvZ25pdG9Vc2VyUG9vbEF1dGhvcml6ZXJQcm9wcyxcbiAgdHlwZSBCYXNpY0F1dGhBdXRob3JpemVyUHJvcHMsXG4gIHR5cGUgQ29nbml0b1VzZXJQb29sT3JCYXNpY0F1dGhBdXRob3JpemVyUHJvcHMsXG4gIHR5cGUgQXBpR2F0ZXdheUFjY2Vzc0xvZ3NQcm9wcyxcbn0gZnJvbSBcIi4vaHR0cC1hcGktZ2F0ZXdheVwiXG4iXX0=
+export { ApiGatewayAccessLogs, } from "./access-logs";
+export { ApiGatewayDomain } from "./domain";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBpLWdhdGV3YXkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFVBQVUsR0FZWCxNQUFNLG9CQUFvQixDQUFBO0FBRTNCLE9BQU8sRUFDTCxvQkFBb0IsR0FFckIsTUFBTSxlQUFlLENBQUE7QUFFdEIsT0FBTyxFQUFFLGdCQUFnQixFQUEyQixNQUFNLFVBQVUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIEFwaUdhdGV3YXksXG4gIHR5cGUgQXBpR2F0ZXdheVByb3BzLFxuICB0eXBlIEFwaUdhdGV3YXlSb3V0ZSxcbiAgdHlwZSBIdHRwTWV0aG9kLFxuICB0eXBlIEludGVncmF0aW9uUHJvcHMsXG4gIHR5cGUgQWxiSW50ZWdyYXRpb25Qcm9wcyxcbiAgdHlwZSBMYW1iZGFJbnRlZ3JhdGlvblByb3BzLFxuICB0eXBlIFNxc0ludGVncmF0aW9uUHJvcHMsXG4gIHR5cGUgQXV0aG9yaXphdGlvblByb3BzLFxuICB0eXBlIENvZ25pdG9Vc2VyUG9vbEF1dGhvcml6ZXJQcm9wcyxcbiAgdHlwZSBCYXNpY0F1dGhBdXRob3JpemVyUHJvcHMsXG4gIHR5cGUgQ29nbml0b1VzZXJQb29sT3JCYXNpY0F1dGhBdXRob3JpemVyUHJvcHMsXG59IGZyb20gXCIuL2h0dHAtYXBpLWdhdGV3YXlcIlxuXG5leHBvcnQge1xuICBBcGlHYXRld2F5QWNjZXNzTG9ncyxcbiAgdHlwZSBBcGlHYXRld2F5QWNjZXNzTG9nc1Byb3BzLFxufSBmcm9tIFwiLi9hY2Nlc3MtbG9nc1wiXG5cbmV4cG9ydCB7IEFwaUdhdGV3YXlEb21haW4sIHR5cGUgQXBpR2F0ZXdheURuc1Byb3BzIH0gZnJvbSBcIi4vZG9tYWluXCJcbiJdfQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk",
-  "version": "3.5.4",
+  "version": "3.5.5",
   "description": "CDK library for Liflig",
   "type": "module",
   "repository": {