terraconstructs 0.0.25 → 0.1.0

package/lib/aws/compute/access-log.js

@@ -0,0 +1,649 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessLogFormat = exports.AccessLogField = exports.FirehoseLogDestination = exports.LogGroupLogDestination = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Use CloudWatch Logs as a custom access log destination for API Gateway.
+ */
+class LogGroupLogDestination {
+    constructor(logGroup) {
+        this.logGroup = logGroup;
+    }
+    /**
+     * Binds this destination to the CloudWatch Logs.
+     */
+    bind(_stage) {
+        return {
+            destinationArn: this.logGroup.logGroupArn,
+        };
+    }
+}
+exports.LogGroupLogDestination = LogGroupLogDestination;
+_a = JSII_RTTI_SYMBOL_1;
+LogGroupLogDestination[_a] = { fqn: "terraconstructs.aws.compute.LogGroupLogDestination", version: "0.1.0" };
+/**
+ * Use a Firehose delivery stream as a custom access log destination for API Gateway.
+ */
+class FirehoseLogDestination {
+    constructor(stream) {
+        this.stream = stream;
+    }
+    /**
+     * Binds this destination to the Firehose delivery stream.
+     */
+    bind(_stage) {
+        if (!this.stream.nameInput?.startsWith("amazon-apigateway-")) {
+            // throw new ValidationError(
+            throw new Error(`Firehose delivery stream name for access log destination must begin with 'amazon-apigateway-', got '${this.stream.nameInput}'`);
+        }
+        return {
+            destinationArn: this.stream.arn,
+        };
+    }
+}
+exports.FirehoseLogDestination = FirehoseLogDestination;
+_b = JSII_RTTI_SYMBOL_1;
+FirehoseLogDestination[_b] = { fqn: "terraconstructs.aws.compute.FirehoseLogDestination", version: "0.1.0" };
+/**
+ * $context variables that can be used to customize access log pattern.
+ */
+class AccessLogField {
+    /**
+     * The API callers AWS account ID.
+     * @deprecated Use `contextCallerAccountId` or `contextOwnerAccountId` instead
+     */
+    static contextAccountId() {
+        return "$context.identity.accountId";
+    }
+    /**
+     * The API callers AWS account ID.
+     */
+    static contextCallerAccountId() {
+        return "$context.identity.accountId";
+    }
+    /**
+     * The API owner's AWS account ID.
+     */
+    static contextOwnerAccountId() {
+        return "$context.accountId";
+    }
+    /**
+     * The identifier API Gateway assigns to your API.
+     */
+    static contextApiId() {
+        return "$context.apiId";
+    }
+    /**
+     * A property of the claims returned from the Amazon Cognito user pool after the method caller is successfully authenticated.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html
+     *
+     * @param property A property key of the claims.
+     */
+    static contextAuthorizerClaims(property) {
+        return `$context.authorizer.claims.${property}`;
+    }
+    /**
+     * The principal user identification associated with the token sent by the client and returned
+     * from an API Gateway Lambda authorizer (formerly known as a custom authorizer).
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html
+     */
+    static contextAuthorizerPrincipalId() {
+        return "$context.authorizer.principalId";
+    }
+    /**
+     * The stringified value of the specified key-value pair of the `context` map returned from an API Gateway Lambda authorizer function.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html
+     * @param property key of the context map.
+     */
+    static contextAuthorizer(property) {
+        return `$context.authorizer.${property}`;
+    }
+    /**
+     * The AWS endpoint's request ID.
+     */
+    static contextAwsEndpointRequestId() {
+        return "$context.awsEndpointRequestId";
+    }
+    /**
+     * The full domain name used to invoke the API. This should be the same as the incoming `Host` header.
+     */
+    static contextDomainName() {
+        return "$context.domainName";
+    }
+    /**
+     * The first label of the `$context.domainName`. This is often used as a caller/customer identifier.
+     */
+    static contextDomainPrefix() {
+        return "$context.domainPrefix";
+    }
+    /**
+     * A string containing an API Gateway error message.
+     */
+    static contextErrorMessage() {
+        return "$context.error.message";
+    }
+    /**
+     * The quoted value of $context.error.message, namely "$context.error.message".
+     */
+    static contextErrorMessageString() {
+        return "$context.error.messageString";
+    }
+    /**
+     * A type of GatewayResponse. This variable can only be used for simple variable substitution in a GatewayResponse body-mapping template,
+     * which is not processed by the Velocity Template Language engine, and in access logging.
+     *
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-logging.html
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/customize-gateway-responses.html
+     */
+    static contextErrorResponseType() {
+        return "$context.error.responseType";
+    }
+    /**
+     * A string containing a detailed validation error message.
+     */
+    static contextErrorValidationErrorString() {
+        return "$context.error.validationErrorString";
+    }
+    /**
+     * The extended ID that API Gateway assigns to the API request, which contains more useful information for debugging/troubleshooting.
+     */
+    static contextExtendedRequestId() {
+        return "$context.extendedRequestId";
+    }
+    /**
+     * The HTTP method used. Valid values include: `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST`, and `PUT`.
+     */
+    static contextHttpMethod() {
+        return "$context.httpMethod";
+    }
+    /**
+     * The AWS account ID associated with the request.
+     */
+    static contextIdentityAccountId() {
+        return "$context.identity.accountId";
+    }
+    /**
+     * For API methods that require an API key, this variable is the API key associated with the method request.
+     * For methods that don't require an API key, this variable is
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html
+     */
+    static contextIdentityApiKey() {
+        return "$context.identity.apiKey";
+    }
+    /**
+     * The API key ID associated with an API request that requires an API key.
+     */
+    static contextIdentityApiKeyId() {
+        return "$context.identity.apiKeyId";
+    }
+    /**
+     * The principal identifier of the caller making the request.
+     */
+    static contextIdentityCaller() {
+        return "$context.identity.caller";
+    }
+    /**
+     * The Amazon Cognito authentication provider used by the caller making the request.
+     * Available only if the request was signed with Amazon Cognito credentials.
+     * @see https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html
+     */
+    static contextIdentityCognitoAuthenticationProvider() {
+        return "$context.identity.cognitoAuthenticationProvider";
+    }
+    /**
+     * The Amazon Cognito authentication type of the caller making the request.
+     * Available only if the request was signed with Amazon Cognito credentials.
+     */
+    static contextIdentityCognitoAuthenticationType() {
+        return "$context.identity.cognitoAuthenticationType";
+    }
+    /**
+     * The Amazon Cognito identity ID of the caller making the request. Available only if the request was signed with Amazon Cognito credentials.
+     */
+    static contextIdentityCognitoIdentityId() {
+        return "$context.identity.cognitoIdentityId";
+    }
+    /**
+     * The Amazon Cognito identity pool ID of the caller making the request.
+     * Available only if the request was signed with Amazon Cognito credentials.
+     */
+    static contextIdentityCognitoIdentityPoolId() {
+        return "$context.identity.cognitoIdentityPoolId";
+    }
+    /**
+     * The AWS organization ID.
+     */
+    static contextIdentityPrincipalOrgId() {
+        return "$context.identity.principalOrgId";
+    }
+    /**
+     * The source IP address of the TCP connection making the request to API Gateway.
+     * Warning: You should not trust this value if there is any chance that the `X-Forwarded-For` header could be forged.
+     */
+    static contextIdentitySourceIp() {
+        return "$context.identity.sourceIp";
+    }
+    /**
+     * The PEM-encoded client certificate that the client presented during mutual TLS authentication.
+     * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.
+     * Present only in access logs if mutual TLS authentication fails.
+     */
+    static contextIdentityClientCertPem() {
+        return "$context.identity.clientCert.clientCertPem";
+    }
+    /**
+     * The distinguished name of the subject of the certificate that a client presents.
+     * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.
+     * Present only in access logs if mutual TLS authentication fails.
+     */
+    static contextIdentityClientCertSubjectDN() {
+        return "$context.identity.clientCert.subjectDN";
+    }
+    /**
+     * The distinguished name of the issuer of the certificate that a client presents.
+     * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.
+     * Present only in access logs if mutual TLS authentication fails.
+     */
+    static contextIdentityClientCertIssunerDN() {
+        return "$context.identity.clientCert.issuerDN";
+    }
+    /**
+     * The serial number of the certificate.
+     * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.
+     * Present only in access logs if mutual TLS authentication fails.
+     */
+    static contextIdentityClientCertSerialNumber() {
+        return "$context.identity.clientCert.serialNumber";
+    }
+    /**
+     * The date before which the certificate is invalid.
+     * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.
+     * Present only in access logs if mutual TLS authentication fails.
+     */
+    static contextIdentityClientCertValidityNotBefore() {
+        return "$context.identity.clientCert.validity.notBefore";
+    }
+    /**
+     * The date after which the certificate is invalid.
+     * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.
+     * Present only in access logs if mutual TLS authentication fails.
+     */
+    static contextIdentityClientCertValidityNotAfter() {
+        return "$context.identity.clientCert.validity.notAfter";
+    }
+    /**
+     * The principal identifier of the user making the request. Used in Lambda authorizers.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-lambda-authorizer-output.html
+     */
+    static contextIdentityUser() {
+        return "$context.identity.user";
+    }
+    /**
+     * The User-Agent header of the API caller.
+     */
+    static contextIdentityUserAgent() {
+        return "$context.identity.userAgent";
+    }
+    /**
+     * The Amazon Resource Name (ARN) of the effective user identified after authentication.
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html
+     */
+    static contextIdentityUserArn() {
+        return "$context.identity.userArn";
+    }
+    /**
+     * The request path.
+     * For example, for a non-proxy request URL of https://{rest-api-id.execute-api.{region}.amazonaws.com/{stage}/root/child,
+     * this value is /{stage}/root/child.
+     */
+    static contextPath() {
+        return "$context.path";
+    }
+    /**
+     * The request protocol, for example, HTTP/1.1.
+     */
+    static contextProtocol() {
+        return "$context.protocol";
+    }
+    /**
+     * The ID that API Gateway assigns to the API request.
+     */
+    static contextRequestId() {
+        return "$context.requestId";
+    }
+    /**
+     * The request header override.
+     * If this parameter is defined, it contains the headers to be used instead of the HTTP Headers that are defined in the Integration Request pane.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html
+     */
+    static contextRequestOverrideHeader(headerName) {
+        return `$context.requestOverride.header.${headerName}`;
+    }
+    /**
+     * The request path override. If this parameter is defined,
+     * it contains the request path to be used instead of the URL Path Parameters that are defined in the Integration Request pane.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html
+     */
+    static contextRequestOverridePath(pathName) {
+        return `$context.requestOverride.path.${pathName}`;
+    }
+    /**
+     * The request query string override.
+     * If this parameter is defined, it contains the request query strings to be used instead
+     * of the URL Query String Parameters that are defined in the Integration Request pane.
+     */
+    static contextRequestOverrideQuerystring(querystringName) {
+        return `$context.requestOverride.querystring.${querystringName}`;
+    }
+    /**
+     * The response header override.
+     * If this parameter is defined, it contains the header to be returned instead of the Response header
+     * that is defined as the Default mapping in the Integration Response pane.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html
+     */
+    static contextResponseOverrideHeader(headerName) {
+        return `$context.responseOverride.header.${headerName}`;
+    }
+    /**
+     * The response status code override.
+     * If this parameter is defined, it contains the status code to be returned instead of the Method response status
+     * that is defined as the Default mapping in the Integration Response pane.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html
+     */
+    static contextResponseOverrideStatus() {
+        return "$context.responseOverride.status";
+    }
+    /**
+     * The CLF-formatted request time (dd/MMM/yyyy:HH:mm:ss +-hhmm).
+     */
+    static contextRequestTime() {
+        return "$context.requestTime";
+    }
+    /**
+     * The Epoch-formatted request time.
+     */
+    static contextRequestTimeEpoch() {
+        return "$context.requestTimeEpoch";
+    }
+    /**
+     * The identifier that API Gateway assigns to your resource.
+     */
+    static contextResourceId() {
+        return "$context.resourceId";
+    }
+    /**
+     * The path to your resource.
+     * For example, for the non-proxy request URI of `https://{rest-api-id.execute-api.{region}.amazonaws.com/{stage}/root/child`,
+     * The $context.resourcePath value is `/root/child`.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-api-step-by-step.html
+     */
+    static contextResourcePath() {
+        return "$context.resourcePath";
+    }
+    /**
+     * The deployment stage of the API request (for example, `Beta` or `Prod`).
+     */
+    static contextStage() {
+        return "$context.stage";
+    }
+    /**
+     * The response received from AWS WAF: `WAF_ALLOW` or `WAF_BLOCK`. Will not be set if the stage is not associated with a web ACL.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html
+     */
+    static contextWafResponseCode() {
+        return "$context.wafResponseCode";
+    }
+    /**
+     * The complete ARN of the web ACL that is used to decide whether to allow or block the request.
+     * Will not be set if the stage is not associated with a web ACL.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html
+     */
+    static contextWebaclArn() {
+        return "$context.webaclArn";
+    }
+    /**
+     * The trace ID for the X-Ray trace.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-enabling-xray.html
+     */
+    static contextXrayTraceId() {
+        return "$context.xrayTraceId";
+    }
+    /**
+     * The authorizer latency in ms.
+     */
+    static contextAuthorizerIntegrationLatency() {
+        return "$context.authorizer.integrationLatency";
+    }
+    /**
+     * The integration latency in ms.
+     */
+    static contextIntegrationLatency() {
+        return "$context.integrationLatency";
+    }
+    /**
+     * For Lambda proxy integration, this parameter represents the status code returned from AWS Lambda,
+     * not from the backend Lambda function.
+     */
+    static contextIntegrationStatus() {
+        return "$context.integrationStatus";
+    }
+    /**
+     * The response latency in ms.
+     */
+    static contextResponseLatency() {
+        return "$context.responseLatency";
+    }
+    /**
+     * The response payload length.
+     */
+    static contextResponseLength() {
+        return "$context.responseLength";
+    }
+    /**
+     * The method response status.
+     */
+    static contextStatus() {
+        return "$context.status";
+    }
+    /**
+     * The authorization error message.
+     */
+    static contextAuthorizeError() {
+        return "$context.authorize.error";
+    }
+    /**
+     * The authorization latency in ms.
+     */
+    static contextAuthorizeLatency() {
+        return "$context.authorize.latency";
+    }
+    /**
+     * The status code returned from an authorization attempt.
+     */
+    static contextAuthorizeStatus() {
+        return "$context.authorize.status";
+    }
+    /**
+     * The error message returned from an authorizer.
+     */
+    static contextAuthorizerError() {
+        return "$context.authorizer.error";
+    }
+    /**
+     * The status code returned from a Lambda authorizer.
+     */
+    static contextAuthorizerIntegrationStatus() {
+        return "$context.authorizer.integrationStatus";
+    }
+    /**
+     * The authorizer latency in ms.
+     */
+    static contextAuthorizerLatency() {
+        return "$context.authorizer.latency";
+    }
+    /**
+     * The AWS endpoint's request ID.
+     */
+    static contextAuthorizerRequestId() {
+        return "$context.authorizer.requestId";
+    }
+    /**
+     * The status code returned from an authorizer.
+     */
+    static contextAuthorizerStatus() {
+        return "$context.authorizer.status";
+    }
+    /**
+     * The error message returned from an authentication attempt.
+     */
+    static contextAuthenticateError() {
+        return "$context.authenticate.error";
+    }
+    /**
+     * The authentication latency in ms.
+     */
+    static contextAuthenticateLatency() {
+        return "$context.authenticate.latency";
+    }
+    /**
+     * The status code returned from an authentication attempt.
+     */
+    static contextAuthenticateStatus() {
+        return "$context.authenticate.status";
+    }
+    /**
+     * The path for an API mapping that an incoming request matched.
+     * Applicable when a client uses a custom domain name to access an API. For example if a client sends a request to
+     * https://api.example.com/v1/orders/1234, and the request matches the API mapping with the path v1/orders, the value is v1/orders.
+     * @see https://docs.aws.amazon.com/en_jp/apigateway/latest/developerguide/rest-api-mappings.html
+     */
+    static contextCustomDomainBasePathMatched() {
+        return "$context.customDomain.basePathMatched";
+    }
+    /**
+     * A string that contains an integration error message.
+     */
+    static contextIntegrationErrorMessage() {
+        return "$context.integrationErrorMessage";
+    }
+    /**
+     * The error message returned from AWS WAF.
+     */
+    static contextWafError() {
+        return "$context.waf.error";
+    }
+    /**
+     * The AWS WAF latency in ms.
+     */
+    static contextWafLatency() {
+        return "$context.waf.latency";
+    }
+    /**
+     * The status code returned from AWS WAF.
+     */
+    static contextWafStatus() {
+        return "$context.waf.status";
+    }
+}
+exports.AccessLogField = AccessLogField;
+_c = JSII_RTTI_SYMBOL_1;
+AccessLogField[_c] = { fqn: "terraconstructs.aws.compute.AccessLogField", version: "0.1.0" };
+/**
+ * factory methods for access log format.
+ */
+class AccessLogFormat {
+    /**
+     * Custom log format.
+     * You can create any log format string. You can easily get the $ context variable by using the methods of AccessLogField.
+     * @example
+     *
+     *  apigateway.AccessLogFormat.custom(JSON.stringify({
+     *      requestId: apigateway.AccessLogField.contextRequestId(),
+     *      sourceIp: apigateway.AccessLogField.contextIdentitySourceIp(),
+     *      method: apigateway.AccessLogField.contextHttpMethod(),
+     *      userContext: {
+     *        sub: apigateway.AccessLogField.contextAuthorizerClaims('sub'),
+     *        email: apigateway.AccessLogField.contextAuthorizerClaims('email')
+     *      }
+     *   }))
+     */
+    static custom(format) {
+        return new AccessLogFormat(format);
+    }
+    /**
+     * Generate Common Log Format.
+     */
+    static clf() {
+        const requester = [
+            AccessLogField.contextIdentitySourceIp(),
+            AccessLogField.contextIdentityCaller(),
+            AccessLogField.contextIdentityUser(),
+        ].join(" ");
+        const requestTime = AccessLogField.contextRequestTime();
+        const request = [
+            AccessLogField.contextHttpMethod(),
+            AccessLogField.contextResourcePath(),
+            AccessLogField.contextProtocol(),
+        ].join(" ");
+        const status = [
+            AccessLogField.contextStatus(),
+            AccessLogField.contextResponseLength(),
+            AccessLogField.contextRequestId(),
+        ].join(" ");
+        return new AccessLogFormat(`${requester} [${requestTime}] "${request}" ${status}`);
+    }
+    /**
+     * Access log will be produced in the JSON format with a set of fields most useful in the access log. All fields are turned on by default with the
+     * option to turn off specific fields.
+     */
+    static jsonWithStandardFields(fields = {
+        ip: true,
+        user: true,
+        caller: true,
+        requestTime: true,
+        httpMethod: true,
+        resourcePath: true,
+        status: true,
+        protocol: true,
+        responseLength: true,
+    }) {
+        return this.custom(JSON.stringify({
+            requestId: AccessLogField.contextRequestId(),
+            ip: fields.ip ? AccessLogField.contextIdentitySourceIp() : undefined,
+            user: fields.user ? AccessLogField.contextIdentityUser() : undefined,
+            caller: fields.caller
+                ? AccessLogField.contextIdentityCaller()
+                : undefined,
+            requestTime: fields.requestTime
+                ? AccessLogField.contextRequestTime()
+                : undefined,
+            httpMethod: fields.httpMethod
+                ? AccessLogField.contextHttpMethod()
+                : undefined,
+            resourcePath: fields.resourcePath
+                ? AccessLogField.contextResourcePath()
+                : undefined,
+            status: fields.status ? AccessLogField.contextStatus() : undefined,
+            protocol: fields.protocol
+                ? AccessLogField.contextProtocol()
+                : undefined,
+            responseLength: fields.responseLength
+                ? AccessLogField.contextResponseLength()
+                : undefined,
+        }));
+    }
+    constructor(format) {
+        this.format = format;
+    }
+    /**
+     * Output a format string to be used with CloudFormation.
+     */
+    toString() {
+        return this.format;
+    }
+}
+exports.AccessLogFormat = AccessLogFormat;
+_d = JSII_RTTI_SYMBOL_1;
+AccessLogFormat[_d] = { fqn: "terraconstructs.aws.compute.AccessLogFormat", version: "0.1.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"access-log.js","sourceRoot":"","sources":["../../../src/aws/compute/access-log.ts"],"names":[],"mappings":"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","sourcesContent":["import { kinesisFirehoseDeliveryStream } from \"@cdktf/provider-aws\";\nimport { IStage } from \"./stage\";\n// import * as firehose from \"../../aws-kinesisfirehose\";\n// import * as firehose from \"../notify/firehose\";\nimport { ILogGroup } from \"../cloudwatch\";\n\n// TODO: Adopt UnscopedValidationError\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import { ValidationError } from '../../core/lib/errors';\n\n/**\n * Access log destination for a RestApi Stage.\n */\nexport interface IAccessLogDestination {\n  /**\n   * Binds this destination to the RestApi Stage.\n   */\n  bind(stage: IStage): AccessLogDestinationConfig;\n}\n\n/**\n * Options when binding a log destination to a RestApi Stage.\n */\nexport interface AccessLogDestinationConfig {\n  /**\n   * The Amazon Resource Name (ARN) of the destination resource\n   */\n  readonly destinationArn: string;\n}\n\n/**\n * Use CloudWatch Logs as a custom access log destination for API Gateway.\n */\nexport class LogGroupLogDestination implements IAccessLogDestination {\n  constructor(private readonly logGroup: ILogGroup) {}\n\n  /**\n   * Binds this destination to the CloudWatch Logs.\n   */\n  public bind(_stage: IStage): AccessLogDestinationConfig {\n    return {\n      destinationArn: this.logGroup.logGroupArn,\n    };\n  }\n}\n\n/**\n * Use a Firehose delivery stream as a custom access log destination for API Gateway.\n */\nexport class FirehoseLogDestination implements IAccessLogDestination {\n  constructor(\n    private readonly stream: kinesisFirehoseDeliveryStream.KinesisFirehoseDeliveryStream,\n  ) {}\n\n  /**\n   * Binds this destination to the Firehose delivery stream.\n   */\n  public bind(_stage: IStage): AccessLogDestinationConfig {\n    if (!this.stream.nameInput?.startsWith(\"amazon-apigateway-\")) {\n      // throw new ValidationError(\n      throw new Error(\n        `Firehose delivery stream name for access log destination must begin with 'amazon-apigateway-', got '${this.stream.nameInput}'`,\n        // _stage,\n      );\n    }\n    return {\n      destinationArn: this.stream.arn,\n    };\n  }\n}\n\n/**\n * $context variables that can be used to customize access log pattern.\n */\nexport class AccessLogField {\n  /**\n   * The API callers AWS account ID.\n   * @deprecated Use `contextCallerAccountId` or `contextOwnerAccountId` instead\n   */\n  public static contextAccountId() {\n    return \"$context.identity.accountId\";\n  }\n\n  /**\n   * The API callers AWS account ID.\n   */\n  public static contextCallerAccountId() {\n    return \"$context.identity.accountId\";\n  }\n\n  /**\n   * The API owner's AWS account ID.\n   */\n  public static contextOwnerAccountId() {\n    return \"$context.accountId\";\n  }\n\n  /**\n   * The identifier API Gateway assigns to your API.\n   */\n  public static contextApiId() {\n    return \"$context.apiId\";\n  }\n\n  /**\n   * A property of the claims returned from the Amazon Cognito user pool after the method caller is successfully authenticated.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html\n   *\n   * @param property A property key of the claims.\n   */\n  public static contextAuthorizerClaims(property: string) {\n    return `$context.authorizer.claims.${property}`;\n  }\n\n  /**\n   * The principal user identification associated with the token sent by the client and returned\n   * from an API Gateway Lambda authorizer (formerly known as a custom authorizer).\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html\n   */\n  public static contextAuthorizerPrincipalId() {\n    return \"$context.authorizer.principalId\";\n  }\n\n  /**\n   * The stringified value of the specified key-value pair of the `context` map returned from an API Gateway Lambda authorizer function.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html\n   * @param property key of the context map.\n   */\n  public static contextAuthorizer(property: string) {\n    return `$context.authorizer.${property}`;\n  }\n\n  /**\n   * The AWS endpoint's request ID.\n   */\n  public static contextAwsEndpointRequestId() {\n    return \"$context.awsEndpointRequestId\";\n  }\n\n  /**\n   * The full domain name used to invoke the API. This should be the same as the incoming `Host` header.\n   */\n  public static contextDomainName() {\n    return \"$context.domainName\";\n  }\n\n  /**\n   * The first label of the `$context.domainName`. This is often used as a caller/customer identifier.\n   */\n  public static contextDomainPrefix() {\n    return \"$context.domainPrefix\";\n  }\n\n  /**\n   * A string containing an API Gateway error message.\n   */\n  public static contextErrorMessage() {\n    return \"$context.error.message\";\n  }\n\n  /**\n   * The quoted value of $context.error.message, namely \"$context.error.message\".\n   */\n  public static contextErrorMessageString() {\n    return \"$context.error.messageString\";\n  }\n\n  /**\n   * A type of GatewayResponse. This variable can only be used for simple variable substitution in a GatewayResponse body-mapping template,\n   * which is not processed by the Velocity Template Language engine, and in access logging.\n   *\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-logging.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/customize-gateway-responses.html\n   */\n  public static contextErrorResponseType() {\n    return \"$context.error.responseType\";\n  }\n\n  /**\n   * A string containing a detailed validation error message.\n   */\n  public static contextErrorValidationErrorString() {\n    return \"$context.error.validationErrorString\";\n  }\n\n  /**\n   * The extended ID that API Gateway assigns to the API request, which contains more useful information for debugging/troubleshooting.\n   */\n  public static contextExtendedRequestId() {\n    return \"$context.extendedRequestId\";\n  }\n\n  /**\n   * The HTTP method used. Valid values include: `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST`, and `PUT`.\n   */\n  public static contextHttpMethod() {\n    return \"$context.httpMethod\";\n  }\n\n  /**\n   * The AWS account ID associated with the request.\n   */\n  public static contextIdentityAccountId() {\n    return \"$context.identity.accountId\";\n  }\n\n  /**\n   * For API methods that require an API key, this variable is the API key associated with the method request.\n   * For methods that don't require an API key, this variable is\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html\n   */\n  public static contextIdentityApiKey() {\n    return \"$context.identity.apiKey\";\n  }\n\n  /**\n   * The API key ID associated with an API request that requires an API key.\n   */\n  public static contextIdentityApiKeyId() {\n    return \"$context.identity.apiKeyId\";\n  }\n\n  /**\n   * The principal identifier of the caller making the request.\n   */\n  public static contextIdentityCaller() {\n    return \"$context.identity.caller\";\n  }\n\n  /**\n   * The Amazon Cognito authentication provider used by the caller making the request.\n   * Available only if the request was signed with Amazon Cognito credentials.\n   * @see https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html\n   */\n  public static contextIdentityCognitoAuthenticationProvider() {\n    return \"$context.identity.cognitoAuthenticationProvider\";\n  }\n\n  /**\n   * The Amazon Cognito authentication type of the caller making the request.\n   * Available only if the request was signed with Amazon Cognito credentials.\n   */\n  public static contextIdentityCognitoAuthenticationType() {\n    return \"$context.identity.cognitoAuthenticationType\";\n  }\n\n  /**\n   * The Amazon Cognito identity ID of the caller making the request. Available only if the request was signed with Amazon Cognito credentials.\n   */\n  public static contextIdentityCognitoIdentityId() {\n    return \"$context.identity.cognitoIdentityId\";\n  }\n\n  /**\n   * The Amazon Cognito identity pool ID of the caller making the request.\n   * Available only if the request was signed with Amazon Cognito credentials.\n   */\n  public static contextIdentityCognitoIdentityPoolId() {\n    return \"$context.identity.cognitoIdentityPoolId\";\n  }\n\n  /**\n   * The AWS organization ID.\n   */\n  public static contextIdentityPrincipalOrgId() {\n    return \"$context.identity.principalOrgId\";\n  }\n\n  /**\n   * The source IP address of the TCP connection making the request to API Gateway.\n   * Warning: You should not trust this value if there is any chance that the `X-Forwarded-For` header could be forged.\n   */\n  public static contextIdentitySourceIp() {\n    return \"$context.identity.sourceIp\";\n  }\n\n  /**\n   * The PEM-encoded client certificate that the client presented during mutual TLS authentication.\n   * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.\n   * Present only in access logs if mutual TLS authentication fails.\n   */\n\n  public static contextIdentityClientCertPem() {\n    return \"$context.identity.clientCert.clientCertPem\";\n  }\n\n  /**\n   * The distinguished name of the subject of the certificate that a client presents.\n   * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.\n   * Present only in access logs if mutual TLS authentication fails.\n   */\n\n  public static contextIdentityClientCertSubjectDN() {\n    return \"$context.identity.clientCert.subjectDN\";\n  }\n\n  /**\n   * The distinguished name of the issuer of the certificate that a client presents.\n   * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.\n   * Present only in access logs if mutual TLS authentication fails.\n   */\n\n  public static contextIdentityClientCertIssunerDN() {\n    return \"$context.identity.clientCert.issuerDN\";\n  }\n\n  /**\n   * The serial number of the certificate.\n   * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.\n   * Present only in access logs if mutual TLS authentication fails.\n   */\n\n  public static contextIdentityClientCertSerialNumber() {\n    return \"$context.identity.clientCert.serialNumber\";\n  }\n\n  /**\n   * The date before which the certificate is invalid.\n   * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.\n   * Present only in access logs if mutual TLS authentication fails.\n   */\n\n  public static contextIdentityClientCertValidityNotBefore() {\n    return \"$context.identity.clientCert.validity.notBefore\";\n  }\n\n  /**\n   * The date after which the certificate is invalid.\n   * Present when a client accesses an API by using a custom domain name that has mutual TLS enabled.\n   * Present only in access logs if mutual TLS authentication fails.\n   */\n\n  public static contextIdentityClientCertValidityNotAfter() {\n    return \"$context.identity.clientCert.validity.notAfter\";\n  }\n\n  /**\n   * The principal identifier of the user making the request. Used in Lambda authorizers.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-lambda-authorizer-output.html\n   */\n  public static contextIdentityUser() {\n    return \"$context.identity.user\";\n  }\n\n  /**\n   * The User-Agent header of the API caller.\n   */\n  public static contextIdentityUserAgent() {\n    return \"$context.identity.userAgent\";\n  }\n\n  /**\n   * The Amazon Resource Name (ARN) of the effective user identified after authentication.\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html\n   */\n  public static contextIdentityUserArn() {\n    return \"$context.identity.userArn\";\n  }\n\n  /**\n   * The request path.\n   * For example, for a non-proxy request URL of https://{rest-api-id.execute-api.{region}.amazonaws.com/{stage}/root/child,\n   * this value is /{stage}/root/child.\n   */\n  public static contextPath() {\n    return \"$context.path\";\n  }\n\n  /**\n   * The request protocol, for example, HTTP/1.1.\n   */\n  public static contextProtocol() {\n    return \"$context.protocol\";\n  }\n\n  /**\n   * The ID that API Gateway assigns to the API request.\n   */\n  public static contextRequestId() {\n    return \"$context.requestId\";\n  }\n\n  /**\n   * The request header override.\n   * If this parameter is defined, it contains the headers to be used instead of the HTTP Headers that are defined in the Integration Request pane.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html\n   */\n  public static contextRequestOverrideHeader(headerName: string) {\n    return `$context.requestOverride.header.${headerName}`;\n  }\n\n  /**\n   * The request path override. If this parameter is defined,\n   * it contains the request path to be used instead of the URL Path Parameters that are defined in the Integration Request pane.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html\n   */\n  public static contextRequestOverridePath(pathName: string) {\n    return `$context.requestOverride.path.${pathName}`;\n  }\n\n  /**\n   * The request query string override.\n   * If this parameter is defined, it contains the request query strings to be used instead\n   * of the URL Query String Parameters that are defined in the Integration Request pane.\n   */\n  public static contextRequestOverrideQuerystring(querystringName: string) {\n    return `$context.requestOverride.querystring.${querystringName}`;\n  }\n\n  /**\n   * The response header override.\n   * If this parameter is defined, it contains the header to be returned instead of the Response header\n   * that is defined as the Default mapping in the Integration Response pane.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html\n   */\n  public static contextResponseOverrideHeader(headerName: string) {\n    return `$context.responseOverride.header.${headerName}`;\n  }\n\n  /**\n   * The response status code override.\n   * If this parameter is defined, it contains the status code to be returned instead of the Method response status\n   * that is defined as the Default mapping in the Integration Response pane.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-override-request-response-parameters.html\n   */\n  public static contextResponseOverrideStatus() {\n    return \"$context.responseOverride.status\";\n  }\n\n  /**\n   * The CLF-formatted request time (dd/MMM/yyyy:HH:mm:ss +-hhmm).\n   */\n  public static contextRequestTime() {\n    return \"$context.requestTime\";\n  }\n\n  /**\n   * The Epoch-formatted request time.\n   */\n  public static contextRequestTimeEpoch() {\n    return \"$context.requestTimeEpoch\";\n  }\n\n  /**\n   * The identifier that API Gateway assigns to your resource.\n   */\n  public static contextResourceId() {\n    return \"$context.resourceId\";\n  }\n\n  /**\n   * The path to your resource.\n   * For example, for the non-proxy request URI of `https://{rest-api-id.execute-api.{region}.amazonaws.com/{stage}/root/child`,\n   * The $context.resourcePath value is `/root/child`.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-api-step-by-step.html\n   */\n  public static contextResourcePath() {\n    return \"$context.resourcePath\";\n  }\n\n  /**\n   * The deployment stage of the API request (for example, `Beta` or `Prod`).\n   */\n  public static contextStage() {\n    return \"$context.stage\";\n  }\n\n  /**\n   * The response received from AWS WAF: `WAF_ALLOW` or `WAF_BLOCK`. Will not be set if the stage is not associated with a web ACL.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html\n   */\n  public static contextWafResponseCode() {\n    return \"$context.wafResponseCode\";\n  }\n\n  /**\n   * The complete ARN of the web ACL that is used to decide whether to allow or block the request.\n   * Will not be set if the stage is not associated with a web ACL.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html\n   */\n  public static contextWebaclArn() {\n    return \"$context.webaclArn\";\n  }\n\n  /**\n   * The trace ID for the X-Ray trace.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-enabling-xray.html\n   */\n  public static contextXrayTraceId() {\n    return \"$context.xrayTraceId\";\n  }\n\n  /**\n   * The authorizer latency in ms.\n   */\n  public static contextAuthorizerIntegrationLatency() {\n    return \"$context.authorizer.integrationLatency\";\n  }\n\n  /**\n   * The integration latency in ms.\n   */\n  public static contextIntegrationLatency() {\n    return \"$context.integrationLatency\";\n  }\n\n  /**\n   * For Lambda proxy integration, this parameter represents the status code returned from AWS Lambda,\n   * not from the backend Lambda function.\n   */\n  public static contextIntegrationStatus() {\n    return \"$context.integrationStatus\";\n  }\n\n  /**\n   * The response latency in ms.\n   */\n  public static contextResponseLatency() {\n    return \"$context.responseLatency\";\n  }\n\n  /**\n   * The response payload length.\n   */\n  public static contextResponseLength() {\n    return \"$context.responseLength\";\n  }\n\n  /**\n   * The method response status.\n   */\n  public static contextStatus() {\n    return \"$context.status\";\n  }\n\n  /**\n   * The authorization error message.\n   */\n  public static contextAuthorizeError() {\n    return \"$context.authorize.error\";\n  }\n\n  /**\n   * The authorization latency in ms.\n   */\n  public static contextAuthorizeLatency() {\n    return \"$context.authorize.latency\";\n  }\n\n  /**\n   * The status code returned from an authorization attempt.\n   */\n  public static contextAuthorizeStatus() {\n    return \"$context.authorize.status\";\n  }\n\n  /**\n   * The error message returned from an authorizer.\n   */\n  public static contextAuthorizerError() {\n    return \"$context.authorizer.error\";\n  }\n\n  /**\n   * The status code returned from a Lambda authorizer.\n   */\n  public static contextAuthorizerIntegrationStatus() {\n    return \"$context.authorizer.integrationStatus\";\n  }\n\n  /**\n   * The authorizer latency in ms.\n   */\n  public static contextAuthorizerLatency() {\n    return \"$context.authorizer.latency\";\n  }\n\n  /**\n   * The AWS endpoint's request ID.\n   */\n  public static contextAuthorizerRequestId() {\n    return \"$context.authorizer.requestId\";\n  }\n\n  /**\n   * The status code returned from an authorizer.\n   */\n  public static contextAuthorizerStatus() {\n    return \"$context.authorizer.status\";\n  }\n\n  /**\n   * The error message returned from an authentication attempt.\n   */\n  public static contextAuthenticateError() {\n    return \"$context.authenticate.error\";\n  }\n\n  /**\n   * The authentication latency in ms.\n   */\n  public static contextAuthenticateLatency() {\n    return \"$context.authenticate.latency\";\n  }\n\n  /**\n   * The status code returned from an authentication attempt.\n   */\n  public static contextAuthenticateStatus() {\n    return \"$context.authenticate.status\";\n  }\n\n  /**\n   * The path for an API mapping that an incoming request matched.\n   * Applicable when a client uses a custom domain name to access an API. For example if a client sends a request to\n   * https://api.example.com/v1/orders/1234, and the request matches the API mapping with the path v1/orders, the value is v1/orders.\n   * @see https://docs.aws.amazon.com/en_jp/apigateway/latest/developerguide/rest-api-mappings.html\n   */\n  public static contextCustomDomainBasePathMatched() {\n    return \"$context.customDomain.basePathMatched\";\n  }\n\n  /**\n   * A string that contains an integration error message.\n   */\n  public static contextIntegrationErrorMessage() {\n    return \"$context.integrationErrorMessage\";\n  }\n\n  /**\n   * The error message returned from AWS WAF.\n   */\n  public static contextWafError() {\n    return \"$context.waf.error\";\n  }\n\n  /**\n   * The AWS WAF latency in ms.\n   */\n  public static contextWafLatency() {\n    return \"$context.waf.latency\";\n  }\n\n  /**\n   * The status code returned from AWS WAF.\n   */\n  public static contextWafStatus() {\n    return \"$context.waf.status\";\n  }\n}\n\n/**\n * Properties for controlling items output in JSON standard format\n */\nexport interface JsonWithStandardFieldProps {\n  /**\n   * If this flag is enabled, the source IP of request will be output to the log\n   */\n  readonly ip: boolean;\n  /**\n   * If this flag is enabled, the principal identifier of the caller will be output to the log\n   */\n  readonly caller: boolean;\n  /**\n   * If this flag is enabled, the principal identifier of the user will be output to the log\n   */\n  readonly user: boolean;\n  /**\n   * If this flag is enabled, the CLF-formatted request time((dd/MMM/yyyy:HH:mm:ss +-hhmm) will be output to the log\n   */\n  readonly requestTime: boolean;\n  /**\n   * If this flag is enabled, the http method will be output to the log\n   */\n  readonly httpMethod: boolean;\n  /**\n   * If this flag is enabled, the path to your resource will be output to the log\n   */\n  readonly resourcePath: boolean;\n  /**\n   * If this flag is enabled, the method response status will be output to the log\n   */\n  readonly status: boolean;\n  /**\n   * If this flag is enabled, the request protocol will be output to the log\n   */\n  readonly protocol: boolean;\n  /**\n   * If this flag is enabled, the response payload length will be output to the log\n   */\n  readonly responseLength: boolean;\n}\n\n/**\n * factory methods for access log format.\n */\nexport class AccessLogFormat {\n  /**\n   * Custom log format.\n   * You can create any log format string. You can easily get the $ context variable by using the methods of AccessLogField.\n   * @example\n   *\n   *  apigateway.AccessLogFormat.custom(JSON.stringify({\n   *      requestId: apigateway.AccessLogField.contextRequestId(),\n   *      sourceIp: apigateway.AccessLogField.contextIdentitySourceIp(),\n   *      method: apigateway.AccessLogField.contextHttpMethod(),\n   *      userContext: {\n   *        sub: apigateway.AccessLogField.contextAuthorizerClaims('sub'),\n   *        email: apigateway.AccessLogField.contextAuthorizerClaims('email')\n   *      }\n   *   }))\n   */\n  public static custom(format: string): AccessLogFormat {\n    return new AccessLogFormat(format);\n  }\n\n  /**\n   * Generate Common Log Format.\n   */\n  public static clf(): AccessLogFormat {\n    const requester = [\n      AccessLogField.contextIdentitySourceIp(),\n      AccessLogField.contextIdentityCaller(),\n      AccessLogField.contextIdentityUser(),\n    ].join(\" \");\n    const requestTime = AccessLogField.contextRequestTime();\n    const request = [\n      AccessLogField.contextHttpMethod(),\n      AccessLogField.contextResourcePath(),\n      AccessLogField.contextProtocol(),\n    ].join(\" \");\n    const status = [\n      AccessLogField.contextStatus(),\n      AccessLogField.contextResponseLength(),\n      AccessLogField.contextRequestId(),\n    ].join(\" \");\n\n    return new AccessLogFormat(\n      `${requester} [${requestTime}] \"${request}\" ${status}`,\n    );\n  }\n\n  /**\n   * Access log will be produced in the JSON format with a set of fields most useful in the access log. All fields are turned on by default with the\n   * option to turn off specific fields.\n   */\n  public static jsonWithStandardFields(\n    fields: JsonWithStandardFieldProps = {\n      ip: true,\n      user: true,\n      caller: true,\n      requestTime: true,\n      httpMethod: true,\n      resourcePath: true,\n      status: true,\n      protocol: true,\n      responseLength: true,\n    },\n  ): AccessLogFormat {\n    return this.custom(\n      JSON.stringify({\n        requestId: AccessLogField.contextRequestId(),\n        ip: fields.ip ? AccessLogField.contextIdentitySourceIp() : undefined,\n        user: fields.user ? AccessLogField.contextIdentityUser() : undefined,\n        caller: fields.caller\n          ? AccessLogField.contextIdentityCaller()\n          : undefined,\n        requestTime: fields.requestTime\n          ? AccessLogField.contextRequestTime()\n          : undefined,\n        httpMethod: fields.httpMethod\n          ? AccessLogField.contextHttpMethod()\n          : undefined,\n        resourcePath: fields.resourcePath\n          ? AccessLogField.contextResourcePath()\n          : undefined,\n        status: fields.status ? AccessLogField.contextStatus() : undefined,\n        protocol: fields.protocol\n          ? AccessLogField.contextProtocol()\n          : undefined,\n        responseLength: fields.responseLength\n          ? AccessLogField.contextResponseLength()\n          : undefined,\n      }),\n    );\n  }\n\n  /**\n   * A API Gateway custom access log format\n   */\n  private readonly format: string;\n\n  private constructor(format: string) {\n    this.format = format;\n  }\n\n  /**\n   * Output a format string to be used with CloudFormation.\n   */\n  public toString(): string {\n    return this.format;\n  }\n}\n"]}