terraconstructs 0.0.24 → 0.1.0

package/lib/aws/compute/restapi.js

@@ -0,0 +1,626 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointType = exports.ApiKeySourceType = exports.RestApi = exports.SpecRestApi = exports.RestApiBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const api_key_1 = require("./api-key");
+const apigateway_canned_metrics_generated_1 = require("./apigateway-canned-metrics.generated");
+const deployment_1 = require("./deployment");
+const domain_name_1 = require("./domain-name");
+const gateway_response_1 = require("./gateway-response");
+const model_1 = require("./model");
+const requestvalidator_1 = require("./requestvalidator");
+const resource_1 = require("./resource");
+const stage_1 = require("./stage");
+const arn_1 = require("../arn");
+const usage_plan_1 = require("./usage-plan");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const cloudwatch = require("../cloudwatch");
+const iam = require("../iam");
+const RESTAPI_SYMBOL = Symbol.for("terraconstructs/lib/aws/compute.RestApiBase");
+const APIGATEWAY_RESTAPI_SYMBOL = Symbol.for("terraconstructs/lib/aws/compute.RestApi");
+/**
+ * Base implementation that are common to various implementations of IRestApi
+ */
+class RestApiBase extends aws_construct_1.AwsConstructBase {
+    /**
+     * Checks if the given object is an instance of RestApiBase.
+     * @internal
+     */
+    static _isRestApiBase(x) {
+        return x !== null && typeof x === "object" && RESTAPI_SYMBOL in x;
+    }
+    /**
+     * API Gateway deployment that represents the latest changes of the API.
+     * This resource will be automatically updated every time the REST API model changes.
+     * This will be undefined if `deploy` is false.
+     */
+    get latestDeployment() {
+        return this._latestDeployment;
+    }
+    /**
+     * The first domain name mapped to this API, if defined through the `domainName`
+     * configuration prop, or added via `addDomainName`
+     */
+    get domainName() {
+        return this._domainName;
+    }
+    /**
+     * The deployed root URL of this REST API.
+     */
+    get url() {
+        return this.urlForPath();
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this._allowedVpcEndpoints = new Set();
+        this.restApiName = props.restApiName ?? this.stack.uniqueResourceName(this);
+        Object.defineProperty(this, RESTAPI_SYMBOL, { value: true });
+    }
+    /**
+     * Returns the URL for an HTTP path.
+     *
+     * Fails if `deploymentStage` is not set either by `deploy` or explicitly.
+     */
+    urlForPath(path = "/") {
+        if (!this.deploymentStage) {
+            // TODO throw new ValidationError(
+            throw new Error('Cannot determine deployment stage for API from "deploymentStage". Use "deploy" or explicitly set "deploymentStage"');
+        }
+        return this.deploymentStage.urlForPath(path);
+    }
+    /**
+     * Defines an API Gateway domain name and maps it to this API.
+     * @param id The construct id
+     * @param options custom domain options
+     */
+    addDomainName(id, options) {
+        const domainName = new domain_name_1.DomainName(this, id, {
+            ...options,
+            mapping: this,
+        });
+        if (!this._domainName) {
+            this._domainName = domainName;
+        }
+        return domainName;
+    }
+    /**
+     * Adds a usage plan.
+     */
+    addUsagePlan(id, props = {}) {
+        return new usage_plan_1.UsagePlan(this, id, props);
+    }
+    arnForExecuteApi(method = "*", path = "/*", stage = "*") {
+        if (!cdktf_1.Token.isUnresolved(path) && !path.startsWith("/")) {
+            throw new Error(`"path" must begin with a "/": '${path}'`);
+        }
+        if (method.toUpperCase() === "ANY") {
+            method = "*";
+        }
+        return aws_stack_1.AwsStack.ofAwsConstruct(this).formatArn({
+            service: "execute-api",
+            resource: this.restApiId,
+            arnFormat: arn_1.ArnFormat.SLASH_RESOURCE_NAME,
+            resourceName: `${stage}/${method}${path}`,
+        });
+    }
+    /**
+     * Adds a new gateway response.
+     */
+    addGatewayResponse(id, options) {
+        return new gateway_response_1.GatewayResponse(this, id, {
+            restApi: this,
+            ...options,
+        });
+    }
+    /**
+     * Add an ApiKey to the deploymentStage
+     */
+    addApiKey(id, options) {
+        if (!this.deploymentStage) {
+            throw new Error("Cannot add API key without a deployment stage. Enable `deploy` or set `deploymentStage`");
+        }
+        return new api_key_1.ApiKey(this, id, {
+            stages: [this.deploymentStage],
+            ...options,
+        });
+    }
+    /**
+     * Add a resource policy that only allows API execution from a VPC Endpoint to create a private API.
+     *
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies-examples.html#apigateway-resource-policies-source-vpc-example
+     *
+     * @param vpcEndpoints the interface VPC endpoints to grant access to
+     */
+    grantInvokeFromVpcEndpointsOnly(vpcEndpoints) {
+        vpcEndpoints.forEach((endpoint) => this._allowedVpcEndpoints.add(endpoint));
+        const endpoints = cdktf_1.Lazy.listValue({
+            produce: () => {
+                return Array.from(this._allowedVpcEndpoints).map((endpoint) => endpoint.vpcEndpointId);
+            },
+        });
+        this.addToResourcePolicy(new iam.PolicyStatement({
+            principals: [new iam.AnyPrincipal()],
+            actions: ["execute-api:Invoke"],
+            resources: ["execute-api:/*"],
+            effect: iam.Effect.DENY,
+            condition: [
+                {
+                    test: "StringNotEquals",
+                    variable: "aws:SourceVpce",
+                    values: endpoints,
+                },
+            ],
+        }));
+        this.addToResourcePolicy(new iam.PolicyStatement({
+            principals: [new iam.AnyPrincipal()],
+            actions: ["execute-api:Invoke"],
+            resources: ["execute-api:/*"],
+            effect: iam.Effect.ALLOW,
+        }));
+    }
+    /**
+     * Returns the given named metric for this API
+     */
+    metric(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/ApiGateway",
+            metricName,
+            dimensionsMap: { ApiName: this.restApiName },
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * Metric for the number of client-side errors captured in a given period.
+     *
+     * Default: sum over 5 minutes
+     */
+    metricClientError(props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics._4XxErrorSum, props);
+    }
+    /**
+     * Metric for the number of server-side errors captured in a given period.
+     *
+     * Default: sum over 5 minutes
+     */
+    metricServerError(props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics._5XxErrorSum, props);
+    }
+    /**
+     * Metric for the number of requests served from the API cache in a given period.
+     *
+     * Default: sum over 5 minutes
+     */
+    metricCacheHitCount(props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.cacheHitCountSum, props);
+    }
+    /**
+     * Metric for the number of requests served from the backend in a given period,
+     * when API caching is enabled.
+     *
+     * Default: sum over 5 minutes
+     */
+    metricCacheMissCount(props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.cacheMissCountSum, props);
+    }
+    /**
+     * Metric for the total number API requests in a given period.
+     *
+     * Default: sample count over 5 minutes
+     */
+    metricCount(props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.countSum, {
+            statistic: "SampleCount",
+            ...props,
+        });
+    }
+    /**
+     * Metric for the time between when API Gateway relays a request to the backend
+     * and when it receives a response from the backend.
+     *
+     * Default: average over 5 minutes.
+     */
+    metricIntegrationLatency(props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.integrationLatencyAverage, props);
+    }
+    /**
+     * The time between when API Gateway receives a request from a client
+     * and when it returns a response to the client.
+     * The latency includes the integration latency and other API Gateway overhead.
+     *
+     * Default: average over 5 minutes.
+     */
+    metricLatency(props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.latencyAverage, props);
+    }
+    /**
+     * Internal API used by `Method` to keep an inventory of methods at the API
+     * level for validation purposes.
+     *
+     * @internal
+     */
+    _attachMethod(_method) {
+        // This method is used in the CDK to manage dependencies for deployments.
+        // In TerraConstructs, this might be handled differently, e.g., by passing method ARNs to deployment triggers.
+    }
+    /**
+     * Associates a Deployment resource with this REST API.
+     *
+     * @internal
+     */
+    _attachDeployment(_deployment) {
+        // Similar to _attachMethod, for managing deployment dependencies.
+    }
+    /**
+     * Associates a Stage with this REST API
+     *
+     * @internal
+     */
+    _attachStage(stage) {
+        if (this.cloudWatchAccount) {
+            stage.node.addDependency(this.cloudWatchAccount);
+        }
+    }
+    /**
+     * @internal
+     */
+    _configureCloudWatchRole(apiResource, cloudWatchRoleEnabled) {
+        // Default to true, as APIGATEWAY_DISABLE_CLOUDWATCH_ROLE feature flag is not available here.
+        const shouldCreateRole = cloudWatchRoleEnabled ?? true;
+        if (!shouldCreateRole) {
+            return;
+        }
+        const role = new iam.Role(this, "CloudWatchRole", {
+            assumedBy: new iam.ServicePrincipal("apigateway.amazonaws.com"),
+            managedPolicies: [
+                iam.ManagedPolicy.fromAwsManagedPolicyName(this, "AmazonAPIGatewayPushToCloudWatchLogs", "service-role/AmazonAPIGatewayPushToCloudWatchLogs"),
+            ],
+        });
+        // role.applyRemovalPolicy(cloudWatchRoleRemovalPolicy); // Handled by Terraform lifecycle if needed
+        this.cloudWatchAccount = new provider_aws_1.apiGatewayAccount.ApiGatewayAccount(this, "Account", {
+            cloudwatchRoleArn: role.roleArn,
+        });
+        // this.cloudWatchAccount.applyRemovalPolicy(cloudWatchRoleRemovalPolicy); // Handled by Terraform lifecycle
+        this.cloudWatchAccount.node.addDependency(apiResource);
+    }
+    /**
+     * @internal
+     */
+    _configureDeployment(props) {
+        const deploy = props.deploy ?? true;
+        if (deploy) {
+            this._latestDeployment = new deployment_1.Deployment(this, "Deployment", {
+                description: props.deployOptions?.description ??
+                    props.description ??
+                    "Automatically created by the RestApi construct",
+                api: this,
+                // TODO: Implement RemovalPolicy.RETAIN through removed block in Terraform.
+                // retainDeployments: props.retainDeployments,
+                // In Terraform, triggers are used to manage redeployment.
+                // A hash of the API definition or relevant parts would go here.
+                // For simplicity, a placeholder or a dependency on the API resource itself might be used.
+                // triggers: { redeploy = "" },
+            });
+            const stageName = (props.deployOptions && props.deployOptions.stageName) || "prod";
+            this.deploymentStage = new stage_1.Stage(this, `DeploymentStage.${stageName}`, {
+                deployment: this._latestDeployment,
+                ...props.deployOptions,
+            });
+        }
+        else {
+            if (props.deployOptions) {
+                throw new Error("Cannot set 'deployOptions' if 'deploy' is disabled");
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    _configureEndpoints(props) {
+        if (props.endpointTypes && props.endpointConfiguration) {
+            // TODO: throw new ValidationError(
+            throw new Error("Only one of the RestApi props, endpointTypes or endpointConfiguration, is allowed");
+        }
+        if (props.endpointConfiguration) {
+            return {
+                types: props.endpointConfiguration.types,
+                vpcEndpointIds: props.endpointConfiguration?.vpcEndpoints?.map((vpcEndpoint) => vpcEndpoint.vpcEndpointId),
+            };
+        }
+        if (props.endpointTypes) {
+            return { types: props.endpointTypes };
+        }
+        return undefined;
+    }
+    cannedMetric(fn, props) {
+        return new cloudwatch.Metric({
+            ...fn({ ApiName: this.restApiName }),
+            ...props,
+        }).attachTo(this);
+    }
+    get outputs() {
+        return {
+            restApiId: this.restApiId,
+            restApiName: this.restApiName,
+            restApiRootResourceId: this.restApiRootResourceId,
+            // this is equal to AWSCDK's "Endpoint" output
+            url: this.deploymentStage ? this.url : undefined,
+        };
+    }
+}
+exports.RestApiBase = RestApiBase;
+_a = JSII_RTTI_SYMBOL_1;
+RestApiBase[_a] = { fqn: "terraconstructs.aws.compute.RestApiBase", version: "0.1.0" };
+/**
+ * Represents a REST API in Amazon API Gateway, created with an OpenAPI specification.
+ *
+ * Some properties normally accessible on @see `RestApi` - such as the description -
+ * must be declared in the specification. All Resources and Methods need to be defined as
+ * part of the OpenAPI specification file, and cannot be added via the CDK.
+ *
+ * By default, the API will automatically be deployed and accessible from a
+ * public endpoint.
+ *
+ *
+ * @resource aws_api_gateway_rest_api
+ */
+class SpecRestApi extends RestApiBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const apiDefConfig = props.apiDefinition.bind(this);
+        this.internalPolicy = props.policy;
+        this.resource = new provider_aws_1.apiGatewayRestApi.ApiGatewayRestApi(this, "Resource", {
+            name: this.restApiName,
+            policy: cdktf_1.Lazy.stringValue({
+                produce: () => this.internalPolicy?.json,
+            }),
+            failOnWarnings: props.failOnWarnings,
+            minimumCompressionSize: props.minCompressionSize?.toBytes()?.toString(),
+            body: apiDefConfig.inlineDefinition, // ?? apiDefConfig.s3Location, // TF body can be inline or S3 URI
+            endpointConfiguration: this._configureEndpoints(props),
+            parameters: props.parameters,
+            disableExecuteApiEndpoint: props.disableExecuteApiEndpoint,
+            description: props.description, // Description can be set here if not in spec, or will be overridden by spec
+        });
+        // This CDK lifecycle hook is largely unused in Terraform, but can be used for custom logic after the API is created.
+        props.apiDefinition.bindAfterCreate(this, this);
+        this.node.defaultChild = this.resource;
+        this.restApiId = this.resource.id;
+        this.restApiRootResourceId = this.resource.rootResourceId;
+        this.root = new RootResource(this, {}, this.restApiRootResourceId);
+        this._configureCloudWatchRole(this.resource, props.cloudWatchRole);
+        this._configureDeployment(props);
+        if (props.domainName) {
+            this.addDomainName("CustomDomain", props.domainName);
+        }
+    }
+    addToResourcePolicy(statement) {
+        if (!this.internalPolicy) {
+            this.internalPolicy = new iam.PolicyDocument(this, "PolicyDocument");
+        }
+        if (!this.policyAttachment) {
+            this.policyAttachment =
+                new provider_aws_1.apiGatewayRestApiPolicy.ApiGatewayRestApiPolicy(this, "Policy", {
+                    restApiId: this.restApiId,
+                    policy: this.internalPolicy.json,
+                });
+        }
+        this.internalPolicy.addStatements(statement);
+        // Note: The policy on apiGatewayRestApi will be updated due to Lazy evaluation.
+        // If a separate ApiGatewayRestApiPolicy resource is preferred, this logic would change.
+        return { statementAdded: true, policyDependable: this.resource }; // or this
+    }
+}
+exports.SpecRestApi = SpecRestApi;
+_b = JSII_RTTI_SYMBOL_1;
+SpecRestApi[_b] = { fqn: "terraconstructs.aws.compute.SpecRestApi", version: "0.1.0" };
+/**
+ * Represents a REST API in Amazon API Gateway.
+ *
+ * Use `addResource` and `addMethod` to configure the API model.
+ *
+ * By default, the API will automatically be deployed and accessible from a
+ * public endpoint.
+ */
+class RestApi extends RestApiBase {
+    /**
+     * Return whether the given object is a `RestApi`
+     */
+    static isRestApi(x) {
+        return (x !== null && typeof x === "object" && APIGATEWAY_RESTAPI_SYMBOL in x);
+    }
+    /**
+     * Import an existing RestApi.
+     */
+    static fromRestApiId(scope, id, restApiId) {
+        class Import extends RestApiBase {
+            constructor() {
+                super(...arguments);
+                this.restApiId = restApiId;
+                this.restApiName = id; // Defaulting to construct ID for name
+                this.restApiRootResourceId = cdktf_1.Lazy.stringValue({
+                    produce: () => {
+                        // This would ideally come from a data source lookup if not provided
+                        throw new Error("restApiRootResourceId is not available when importing with fromRestApiId. Use fromRestApiAttributes or provide it.");
+                    },
+                });
+                this.root = new RootResource(this, {}, this.restApiRootResourceId);
+            }
+            addToResourcePolicy(_statement) {
+                // Cannot add to policy of an imported RestApi through this interface
+                return { statementAdded: false };
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Import an existing RestApi that can be configured with additional Methods and Resources.
+     */
+    static fromRestApiAttributes(scope, id, attrs) {
+        class Import extends RestApiBase {
+            constructor() {
+                super(...arguments);
+                this.restApiId = attrs.restApiId;
+                this.restApiName = attrs.restApiName ?? id;
+                this.restApiRootResourceId = attrs.rootResourceId;
+                this.root = new RootResource(this, {}, this.restApiRootResourceId);
+            }
+            addToResourcePolicy(_statement) {
+                return { statementAdded: false };
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        /**
+         * The list of methods bound to this RestApi
+         */
+        this.methods = new Array();
+        /**
+         * This list of deployments bound to this RestApi
+         */
+        this.deployments = new Array();
+        if (props.minCompressionSize === undefined) {
+            // No equivalent for minimumCompressionSize being deprecated in favor of minCompressionSize
+        }
+        this.internalPolicy = props.policy;
+        this.resource = new provider_aws_1.apiGatewayRestApi.ApiGatewayRestApi(this, "Resource", {
+            name: this.restApiName,
+            description: props.description,
+            policy: cdktf_1.Lazy.stringValue({
+                produce: () => this.internalPolicy?.json,
+            }),
+            failOnWarnings: props.failOnWarnings,
+            minimumCompressionSize: props.minCompressionSize?.toBytes()?.toString(),
+            binaryMediaTypes: props.binaryMediaTypes,
+            endpointConfiguration: this._configureEndpoints(props),
+            apiKeySource: props.apiKeySourceType,
+            // cloneFrom: props.cloneFrom?.restApiId, // Not supported in TF aws_api_gateway_rest_api
+            parameters: props.parameters,
+            disableExecuteApiEndpoint: props.disableExecuteApiEndpoint,
+        });
+        this.node.defaultChild = this.resource;
+        this.restApiId = this.resource.id;
+        this.restApiRootResourceId = this.resource.rootResourceId;
+        // ensure the iam policy is associated with the resource.
+        if (this.internalPolicy) {
+            this.policyAttachment =
+                new provider_aws_1.apiGatewayRestApiPolicy.ApiGatewayRestApiPolicy(this, "Policy", {
+                    restApiId: this.restApiId,
+                    policy: this.internalPolicy.json,
+                });
+        }
+        this._configureCloudWatchRole(this.resource, props.cloudWatchRole);
+        this._configureDeployment(props);
+        if (props.domainName) {
+            this.addDomainName("CustomDomain", props.domainName);
+        }
+        this.root = new RootResource(this, props, this.restApiRootResourceId);
+        this.node.addValidation({ validate: () => this.validateRestApi() });
+        Object.defineProperty(this, APIGATEWAY_RESTAPI_SYMBOL, { value: true });
+    }
+    addToResourcePolicy(statement) {
+        if (!this.internalPolicy) {
+            this.internalPolicy = new iam.PolicyDocument(this, "PolicyDocument");
+        }
+        if (!this.policyAttachment) {
+            this.policyAttachment =
+                new provider_aws_1.apiGatewayRestApiPolicy.ApiGatewayRestApiPolicy(this, "Policy", {
+                    restApiId: this.restApiId,
+                    policy: this.internalPolicy.json,
+                });
+        }
+        this.internalPolicy.addStatements(statement);
+        return { statementAdded: true, policyDependable: this.resource };
+    }
+    addModel(id, props) {
+        return new model_1.Model(this, id, {
+            ...props,
+            restApi: this,
+        });
+    }
+    addRequestValidator(id, props) {
+        return new requestvalidator_1.RequestValidator(this, id, {
+            ...props,
+            restApi: this,
+        });
+    }
+    /**
+     * Internal API used by `Method` to keep an inventory of methods at the API
+     * level for validation purposes.
+     *
+     * @internal
+     */
+    _attachMethod(method) {
+        // In TF, deployment triggers would handle this implicitly or explicitly
+        this.methods.push(method);
+        // add this method as a dependency to all deployments defined for this api
+        // when additional deployments are added, _attachDeployment is called and
+        // this method will be added there.
+        for (const dep of this.deployments) {
+            dep._addMethodDependency(method);
+        }
+    }
+    /** @internal */
+    _attachDeployment(deployment) {
+        // In TF, deployment triggers would handle this implicitly or explicitly
+        this.deployments.push(deployment);
+        for (const method of this.methods) {
+            deployment._addMethodDependency(method);
+        }
+    }
+    validateRestApi() {
+        if (this.methods.length === 0) {
+            return ["The REST API doesn't contain any methods"];
+        }
+        return [];
+    }
+}
+exports.RestApi = RestApi;
+_c = JSII_RTTI_SYMBOL_1;
+RestApi[_c] = { fqn: "terraconstructs.aws.compute.RestApi", version: "0.1.0" };
+var ApiKeySourceType;
+(function (ApiKeySourceType) {
+    ApiKeySourceType["HEADER"] = "HEADER";
+    ApiKeySourceType["AUTHORIZER"] = "AUTHORIZER";
+})(ApiKeySourceType || (exports.ApiKeySourceType = ApiKeySourceType = {}));
+var EndpointType;
+(function (EndpointType) {
+    EndpointType["EDGE"] = "EDGE";
+    EndpointType["REGIONAL"] = "REGIONAL";
+    EndpointType["PRIVATE"] = "PRIVATE";
+})(EndpointType || (exports.EndpointType = EndpointType = {}));
+class RootResource extends resource_1.ResourceBase {
+    constructor(api, props, resourceId) {
+        super(api, "Default"); // ID 'Default' for the root resource wrapper
+        this.parentResource = undefined;
+        this.defaultIntegration = props.defaultIntegration;
+        this.defaultMethodOptions = props.defaultMethodOptions;
+        this.defaultCorsPreflightOptions = props.defaultCorsPreflightOptions;
+        this.api = api;
+        this.resourceId = resourceId;
+        this.path = "/";
+        if (RestApi.isRestApi(api)) {
+            // Check if it's the non-spec RestApi to avoid type errors if api is SpecRestApi
+            this._restApi = api;
+        }
+        if (this.defaultCorsPreflightOptions) {
+            this.addCorsPreflight(this.defaultCorsPreflightOptions);
+        }
+    }
+    /**
+     * Get the RestApi associated with this Resource.
+     * @deprecated - Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.
+     */
+    get restApi() {
+        if (!this._restApi) {
+            throw new Error("RestApi is not available on Resource not connected to an instance of RestApi. Use `api` instead");
+        }
+        return this._restApi;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restapi.js","sourceRoot":"","sources":["../../../src/aws/compute/restapi.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  apiGatewayAccount,\n  apiGatewayRestApi,\n  apiGatewayRestApiPolicy,\n} from \"@cdktf/provider-aws\";\nimport { Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ApiDefinition } from \"./api-definition\";\nimport { ApiKey, ApiKeyOptions, IApiKey } from \"./api-key\";\nimport { ApiGatewayMetrics } from \"./apigateway-canned-metrics.generated\";\nimport { CorsOptions } from \"./cors\";\nimport { Deployment } from \"./deployment\";\nimport { DomainName, DomainNameOptions } from \"./domain-name\";\nimport { GatewayResponse, GatewayResponseOptions } from \"./gateway-response\";\nimport { Integration } from \"./integration\";\nimport { Method, MethodOptions } from \"./method\";\nimport { Model, ModelOptions } from \"./model\";\nimport { RequestValidator, RequestValidatorOptions } from \"./requestvalidator\";\nimport { IResource, ResourceBase, ResourceOptions } from \"./resource\";\nimport { Stage, StageOptions } from \"./stage\";\nimport { Size } from \"../../size\";\nimport { ArnFormat } from \"../arn\";\nimport { UsagePlan, UsagePlanProps } from \"./usage-plan\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as cloudwatch from \"../cloudwatch\";\nimport * as ec2 from \"../compute\";\nimport * as iam from \"../iam\";\n\nconst RESTAPI_SYMBOL = Symbol.for(\n  \"terraconstructs/lib/aws/compute.RestApiBase\",\n);\nconst APIGATEWAY_RESTAPI_SYMBOL = Symbol.for(\n  \"terraconstructs/lib/aws/compute.RestApi\",\n);\n\nexport interface IRestApi extends iam.IAwsConstructWithPolicy {\n  /**\n   * The ID of this API Gateway RestApi.\n   * @attribute\n   */\n  readonly restApiId: string;\n\n  /**\n   * The name of this API Gateway RestApi.\n   * @attribute\n   */\n  readonly restApiName: string;\n\n  /**\n   * The resource ID of the root resource.\n   * @attribute\n   */\n  readonly restApiRootResourceId: string;\n\n  /**\n   * API Gateway deployment that represents the latest changes of the API.\n   * This resource will be automatically updated every time the REST API model changes.\n   * `undefined` when no deployment is configured.\n   */\n  readonly latestDeployment?: Deployment;\n\n  /**\n   * API Gateway stage that points to the latest deployment (if defined).\n   */\n  deploymentStage: Stage;\n\n  /**\n   * Represents the root resource (\"/\") of this API. Use it to define the API model:\n   *\n   *    api.root.addMethod('ANY', redirectToHomePage); // \"ANY /\"\n   *    api.root.addResource('friends').addMethod('GET', getFriendsHandler); // \"GET /friends\"\n   *\n   */\n  readonly root: IResource;\n\n  /**\n   * Gets the \"execute-api\" ARN\n   * @returns The \"execute-api\" ARN.\n   * @default \"*\" returns the execute API ARN for all methods/resources in\n   * this API.\n   * @param method The method (default `*`)\n   * @param path The resource path. Must start with '/' (default `*`)\n   * @param stage The stage (default `*`)\n   */\n  arnForExecuteApi(method?: string, path?: string, stage?: string): string;\n}\n\n/**\n * Represents the props that all Rest APIs share\n */\nexport interface RestApiBaseProps extends AwsConstructProps {\n  /**\n   * Indicates if a Deployment should be automatically created for this API,\n   * and recreated when the API model (resources, methods) changes.\n   *\n   * Since API Gateway deployments are immutable, When this option is enabled\n   * (by default), an AWS::ApiGateway::Deployment resource will automatically\n   * created with a logical ID that hashes the API model (methods, resources\n   * and options). This means that when the model changes, the logical ID of\n   * this CloudFormation resource will change, and a new deployment will be\n   * created.\n   *\n   * If this is set, `latestDeployment` will refer to the `Deployment` object\n   * and `deploymentStage` will refer to a `Stage` that points to this\n   * deployment. To customize the stage options, use the `deployOptions`\n   * property.\n   *\n   * A CloudFormation Output will also be defined with the root URL endpoint\n   * of this REST API.\n   *\n   * @default true\n   */\n  readonly deploy?: boolean;\n\n  /**\n   * Options for the API Gateway stage that will always point to the latest\n   * deployment when `deploy` is enabled. If `deploy` is disabled,\n   * this value cannot be set.\n   *\n   * @default - Based on defaults of `StageOptions`.\n   */\n  readonly deployOptions?: StageOptions;\n\n  // TODO: Implement RemovalPolicy.RETAIN through removed block in Terraform.\n  // /**\n  //  * Retains old deployment resources when the API changes. This allows\n  //  * manually reverting stages to point to old deployments via the AWS\n  //  * Console.\n  //  *\n  //  * @default false\n  //  */\n  // readonly retainDeployments?: boolean;\n\n  /**\n   * A name for the API Gateway RestApi resource.\n   *\n   * @default - ID of the RestApi construct.\n   */\n  readonly restApiName?: string;\n\n  /**\n   * Custom header parameters for the request.\n   * @see https://docs.aws.amazon.com/cli/latest/reference/apigateway/import-rest-api.html\n   *\n   * @default - No parameters.\n   */\n  readonly parameters?: { [key: string]: string };\n\n  /**\n   * A policy document that contains the permissions for this RestApi\n   *\n   * @default - No policy.\n   */\n  readonly policy?: iam.PolicyDocument;\n\n  /**\n   * Indicates whether to roll back the resource if a warning occurs while API\n   * Gateway is creating the RestApi resource.\n   *\n   * @default false\n   */\n  readonly failOnWarnings?: boolean;\n\n  /**\n   * Configure a custom domain name and map it to this API.\n   *\n   * @default - no domain name is defined, use `addDomainName` or directly define a `DomainName`.\n   */\n  readonly domainName?: DomainNameOptions;\n\n  /**\n   * Automatically configure an AWS CloudWatch role for API Gateway.\n   *\n   * @default true\n   */\n  readonly cloudWatchRole?: boolean;\n\n  // cloudWatchRoleRemovalPolicy is not directly applicable in Terraform as it manages DeletionPolicy.\n  // Terraform's `prevent_destroy` in `lifecycle` can be used for similar effect on the role.\n\n  // Terraform outputs don't have direct exportName like CFN\n  // /**\n  //  * Export name for the TerraformOutput containing the API endpoint\n  //  *\n  //  * @default - when no export name is given, output will be created without export\n  //  */\n  // readonly endpointExportName?: string;\n\n  /**\n   * A list of the endpoint types of the API. Use this property when creating\n   * an API.\n   *\n   * @default EndpointType.EDGE\n   */\n  readonly endpointTypes?: EndpointType[];\n\n  /**\n   * The EndpointConfiguration property type specifies the endpoint types of a REST API\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-restapi-endpointconfiguration.html\n   *\n   * @default EndpointType.EDGE\n   */\n  readonly endpointConfiguration?: EndpointConfiguration;\n\n  /**\n   * Specifies whether clients can invoke the API using the default execute-api\n   * endpoint. To require that clients use a custom domain name to invoke the\n   * API, disable the default endpoint.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-restapi.html\n   *\n   * @default false\n   */\n  readonly disableExecuteApiEndpoint?: boolean;\n\n  /**\n   * A description of the RestApi construct.\n   *\n   * @default - 'Automatically created by the RestApi construct'\n   */\n  readonly description?: string;\n}\n\n/**\n * Props to create a new instance of RestApi\n */\nexport interface RestApiProps extends RestApiBaseProps, ResourceOptions {\n  /**\n   * The list of binary media mime-types that are supported by the RestApi\n   * resource, such as \"image/png\" or \"application/octet-stream\"\n   *\n   * @default - RestApi supports only UTF-8-encoded text payloads.\n   */\n  readonly binaryMediaTypes?: string[];\n\n  /**\n   * A Size(in bytes, kibibytes, mebibytes etc) that is used to enable compression (with non-negative\n   * between 0 and 10485760 (10M) bytes, inclusive) or disable compression\n   * (when undefined) on an API. When compression is enabled, compression or\n   * decompression is not applied on the payload if the payload size is\n   * smaller than this value. Setting it to zero allows compression for any\n   * payload size.\n   *\n   * @default - Compression is disabled.\n   */\n  readonly minCompressionSize?: Size;\n\n  // cloneFrom is not supported by aws_api_gateway_rest_api in Terraform.\n  // readonly cloneFrom?: IRestApi;\n\n  /**\n   * The source of the API key for metering requests according to a usage\n   * plan.\n   *\n   * @default - Metering is disabled.\n   */\n  readonly apiKeySourceType?: ApiKeySourceType;\n}\n\n/**\n * Props to instantiate a new SpecRestApi\n */\nexport interface SpecRestApiProps extends RestApiBaseProps {\n  /**\n   * An OpenAPI definition compatible with API Gateway.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-import-api.html\n   */\n  readonly apiDefinition: ApiDefinition;\n\n  /**\n   * A Size(in bytes, kibibytes, mebibytes etc) that is used to enable compression (with non-negative\n   * between 0 and 10485760 (10M) bytes, inclusive) or disable compression\n   * (when undefined) on an API. When compression is enabled, compression or\n   * decompression is not applied on the payload if the payload size is\n   * smaller than this value. Setting it to zero allows compression for any\n   * payload size.\n   *\n   * @default - Compression is disabled.\n   */\n  readonly minCompressionSize?: Size;\n}\n\n/**\n * Base implementation that are common to various implementations of IRestApi\n */\nexport abstract class RestApiBase\n  extends AwsConstructBase\n  implements IRestApi, iam.IAwsConstructWithPolicy\n{\n  /**\n   * Checks if the given object is an instance of RestApiBase.\n   * @internal\n   */\n  public static _isRestApiBase(x: any): x is RestApiBase {\n    return x !== null && typeof x === \"object\" && RESTAPI_SYMBOL in x;\n  }\n\n  /**\n   * API Gateway deployment that represents the latest changes of the API.\n   * This resource will be automatically updated every time the REST API model changes.\n   * This will be undefined if `deploy` is false.\n   */\n  public get latestDeployment() {\n    return this._latestDeployment;\n  }\n\n  /**\n   * The first domain name mapped to this API, if defined through the `domainName`\n   * configuration prop, or added via `addDomainName`\n   */\n  public get domainName() {\n    return this._domainName;\n  }\n\n  /**\n   * The deployed root URL of this REST API.\n   */\n  public get url() {\n    return this.urlForPath();\n  }\n\n  /**\n   * The ID of this API Gateway RestApi.\n   */\n  public abstract readonly restApiId: string;\n\n  /**\n   * The resource ID of the root resource.\n   *\n   * @attribute\n   */\n  public abstract readonly restApiRootResourceId: string;\n\n  /**\n   * Represents the root resource of this API endpoint ('/').\n   * Resources and Methods are added to this resource.\n   */\n  public abstract readonly root: IResource;\n\n  /**\n   * API Gateway stage that points to the latest deployment (if defined).\n   *\n   * If `deploy` is disabled, you will need to explicitly assign this value in order to\n   * set up integrations.\n   */\n  public deploymentStage!: Stage;\n\n  /**\n   * A human friendly name for this Rest API. Note that this is different from `restApiId`.\n   * @attribute\n   */\n  public readonly restApiName: string;\n\n  private _latestDeployment?: Deployment;\n  private _domainName?: DomainName;\n  private _allowedVpcEndpoints: Set<ec2.IVpcEndpoint> = new Set();\n\n  protected cloudWatchAccount?: apiGatewayAccount.ApiGatewayAccount;\n  protected internalPolicy?: iam.PolicyDocument;\n  protected policyAttachment?: apiGatewayRestApiPolicy.ApiGatewayRestApiPolicy;\n\n  constructor(scope: Construct, id: string, props: RestApiBaseProps = {}) {\n    super(scope, id, props);\n    this.restApiName = props.restApiName ?? this.stack.uniqueResourceName(this);\n\n    Object.defineProperty(this, RESTAPI_SYMBOL, { value: true });\n  }\n\n  public abstract addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult;\n\n  /**\n   * Returns the URL for an HTTP path.\n   *\n   * Fails if `deploymentStage` is not set either by `deploy` or explicitly.\n   */\n  public urlForPath(path: string = \"/\"): string {\n    if (!this.deploymentStage) {\n      // TODO throw new ValidationError(\n      throw new Error(\n        'Cannot determine deployment stage for API from \"deploymentStage\". Use \"deploy\" or explicitly set \"deploymentStage\"',\n      );\n    }\n    return this.deploymentStage.urlForPath(path);\n  }\n\n  /**\n   * Defines an API Gateway domain name and maps it to this API.\n   * @param id The construct id\n   * @param options custom domain options\n   */\n  public addDomainName(id: string, options: DomainNameOptions): DomainName {\n    const domainName = new DomainName(this, id, {\n      ...options,\n      mapping: this,\n    });\n    if (!this._domainName) {\n      this._domainName = domainName;\n    }\n    return domainName;\n  }\n\n  /**\n   * Adds a usage plan.\n   */\n  public addUsagePlan(id: string, props: UsagePlanProps = {}): UsagePlan {\n    return new UsagePlan(this, id, props);\n  }\n\n  public arnForExecuteApi(\n    method: string = \"*\",\n    path: string = \"/*\",\n    stage: string = \"*\",\n  ) {\n    if (!Token.isUnresolved(path) && !path.startsWith(\"/\")) {\n      throw new Error(`\"path\" must begin with a \"/\": '${path}'`);\n    }\n\n    if (method.toUpperCase() === \"ANY\") {\n      method = \"*\";\n    }\n\n    return AwsStack.ofAwsConstruct(this).formatArn({\n      service: \"execute-api\",\n      resource: this.restApiId,\n      arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n      resourceName: `${stage}/${method}${path}`,\n    });\n  }\n\n  /**\n   * Adds a new gateway response.\n   */\n  public addGatewayResponse(\n    id: string,\n    options: GatewayResponseOptions,\n  ): GatewayResponse {\n    return new GatewayResponse(this, id, {\n      restApi: this,\n      ...options,\n    });\n  }\n\n  /**\n   * Add an ApiKey to the deploymentStage\n   */\n  public addApiKey(id: string, options?: ApiKeyOptions): IApiKey {\n    if (!this.deploymentStage) {\n      throw new Error(\n        \"Cannot add API key without a deployment stage. Enable `deploy` or set `deploymentStage`\",\n      );\n    }\n    return new ApiKey(this, id, {\n      stages: [this.deploymentStage],\n      ...options,\n    });\n  }\n\n  /**\n   * Add a resource policy that only allows API execution from a VPC Endpoint to create a private API.\n   *\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies-examples.html#apigateway-resource-policies-source-vpc-example\n   *\n   * @param vpcEndpoints the interface VPC endpoints to grant access to\n   */\n  public grantInvokeFromVpcEndpointsOnly(\n    vpcEndpoints: ec2.IVpcEndpoint[],\n  ): void {\n    vpcEndpoints.forEach((endpoint) => this._allowedVpcEndpoints.add(endpoint));\n\n    const endpoints = Lazy.listValue({\n      produce: () => {\n        return Array.from(this._allowedVpcEndpoints).map(\n          (endpoint) => endpoint.vpcEndpointId,\n        );\n      },\n    });\n\n    this.addToResourcePolicy(\n      new iam.PolicyStatement({\n        principals: [new iam.AnyPrincipal()],\n        actions: [\"execute-api:Invoke\"],\n        resources: [\"execute-api:/*\"],\n        effect: iam.Effect.DENY,\n        condition: [\n          {\n            test: \"StringNotEquals\",\n            variable: \"aws:SourceVpce\",\n            values: endpoints,\n          },\n        ],\n      }),\n    );\n    this.addToResourcePolicy(\n      new iam.PolicyStatement({\n        principals: [new iam.AnyPrincipal()],\n        actions: [\"execute-api:Invoke\"],\n        resources: [\"execute-api:/*\"],\n        effect: iam.Effect.ALLOW,\n      }),\n    );\n  }\n\n  /**\n   * Returns the given named metric for this API\n   */\n  public metric(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/ApiGateway\",\n      metricName,\n      dimensionsMap: { ApiName: this.restApiName },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the number of client-side errors captured in a given period.\n   *\n   * Default: sum over 5 minutes\n   */\n  public metricClientError(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics._4XxErrorSum, props);\n  }\n\n  /**\n   * Metric for the number of server-side errors captured in a given period.\n   *\n   * Default: sum over 5 minutes\n   */\n  public metricServerError(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics._5XxErrorSum, props);\n  }\n\n  /**\n   * Metric for the number of requests served from the API cache in a given period.\n   *\n   * Default: sum over 5 minutes\n   */\n  public metricCacheHitCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.cacheHitCountSum, props);\n  }\n\n  /**\n   * Metric for the number of requests served from the backend in a given period,\n   * when API caching is enabled.\n   *\n   * Default: sum over 5 minutes\n   */\n  public metricCacheMissCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.cacheMissCountSum, props);\n  }\n\n  /**\n   * Metric for the total number API requests in a given period.\n   *\n   * Default: sample count over 5 minutes\n   */\n  public metricCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.countSum, {\n      statistic: \"SampleCount\",\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the time between when API Gateway relays a request to the backend\n   * and when it receives a response from the backend.\n   *\n   * Default: average over 5 minutes.\n   */\n  public metricIntegrationLatency(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(\n      ApiGatewayMetrics.integrationLatencyAverage,\n      props,\n    );\n  }\n\n  /**\n   * The time between when API Gateway receives a request from a client\n   * and when it returns a response to the client.\n   * The latency includes the integration latency and other API Gateway overhead.\n   *\n   * Default: average over 5 minutes.\n   */\n  public metricLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.latencyAverage, props);\n  }\n\n  /**\n   * Internal API used by `Method` to keep an inventory of methods at the API\n   * level for validation purposes.\n   *\n   * @internal\n   */\n  public _attachMethod(_method: Method) {\n    // This method is used in the CDK to manage dependencies for deployments.\n    // In TerraConstructs, this might be handled differently, e.g., by passing method ARNs to deployment triggers.\n  }\n\n  /**\n   * Associates a Deployment resource with this REST API.\n   *\n   * @internal\n   */\n  public _attachDeployment(_deployment: Deployment) {\n    // Similar to _attachMethod, for managing deployment dependencies.\n  }\n\n  /**\n   * Associates a Stage with this REST API\n   *\n   * @internal\n   */\n  public _attachStage(stage: Stage) {\n    if (this.cloudWatchAccount) {\n      stage.node.addDependency(this.cloudWatchAccount);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  protected _configureCloudWatchRole(\n    apiResource: apiGatewayRestApi.ApiGatewayRestApi,\n    cloudWatchRoleEnabled?: boolean,\n    // cloudWatchRoleRemovalPolicy?: RemovalPolicy, // RemovalPolicy is a CDK concept\n  ) {\n    // Default to true, as APIGATEWAY_DISABLE_CLOUDWATCH_ROLE feature flag is not available here.\n    const shouldCreateRole = cloudWatchRoleEnabled ?? true;\n    if (!shouldCreateRole) {\n      return;\n    }\n\n    const role = new iam.Role(this, \"CloudWatchRole\", {\n      assumedBy: new iam.ServicePrincipal(\"apigateway.amazonaws.com\"),\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          this,\n          \"AmazonAPIGatewayPushToCloudWatchLogs\",\n          \"service-role/AmazonAPIGatewayPushToCloudWatchLogs\",\n        ),\n      ],\n    });\n    // role.applyRemovalPolicy(cloudWatchRoleRemovalPolicy); // Handled by Terraform lifecycle if needed\n\n    this.cloudWatchAccount = new apiGatewayAccount.ApiGatewayAccount(\n      this,\n      \"Account\",\n      {\n        cloudwatchRoleArn: role.roleArn,\n      },\n    );\n    // this.cloudWatchAccount.applyRemovalPolicy(cloudWatchRoleRemovalPolicy); // Handled by Terraform lifecycle\n\n    this.cloudWatchAccount.node.addDependency(apiResource);\n  }\n\n  /**\n   * @internal\n   */\n  protected _configureDeployment(props: RestApiBaseProps) {\n    const deploy = props.deploy ?? true;\n    if (deploy) {\n      this._latestDeployment = new Deployment(this, \"Deployment\", {\n        description:\n          props.deployOptions?.description ??\n          props.description ??\n          \"Automatically created by the RestApi construct\",\n        api: this,\n        // TODO: Implement RemovalPolicy.RETAIN through removed block in Terraform.\n        // retainDeployments: props.retainDeployments,\n        // In Terraform, triggers are used to manage redeployment.\n        // A hash of the API definition or relevant parts would go here.\n        // For simplicity, a placeholder or a dependency on the API resource itself might be used.\n        // triggers: { redeploy = \"\" },\n      });\n\n      const stageName =\n        (props.deployOptions && props.deployOptions.stageName) || \"prod\";\n\n      this.deploymentStage = new Stage(this, `DeploymentStage.${stageName}`, {\n        deployment: this._latestDeployment,\n        ...props.deployOptions,\n      });\n    } else {\n      if (props.deployOptions) {\n        throw new Error(\"Cannot set 'deployOptions' if 'deploy' is disabled\");\n      }\n    }\n  }\n\n  /**\n   * @internal\n   */\n  protected _configureEndpoints(\n    props: RestApiBaseProps,\n  ): apiGatewayRestApi.ApiGatewayRestApiEndpointConfiguration | undefined {\n    if (props.endpointTypes && props.endpointConfiguration) {\n      // TODO: throw new ValidationError(\n      throw new Error(\n        \"Only one of the RestApi props, endpointTypes or endpointConfiguration, is allowed\",\n      );\n    }\n    if (props.endpointConfiguration) {\n      return {\n        types: props.endpointConfiguration.types,\n        vpcEndpointIds: props.endpointConfiguration?.vpcEndpoints?.map(\n          (vpcEndpoint) => vpcEndpoint.vpcEndpointId,\n        ),\n      };\n    }\n    if (props.endpointTypes) {\n      return { types: props.endpointTypes };\n    }\n    return undefined;\n  }\n\n  private cannedMetric(\n    fn: (dims: { ApiName: string }) => cloudwatch.MetricProps,\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return new cloudwatch.Metric({\n      ...fn({ ApiName: this.restApiName }),\n      ...props,\n    }).attachTo(this);\n  }\n\n  public get outputs(): Record<string, any> {\n    return {\n      restApiId: this.restApiId,\n      restApiName: this.restApiName,\n      restApiRootResourceId: this.restApiRootResourceId,\n      // this is equal to AWSCDK's \"Endpoint\" output\n      url: this.deploymentStage ? this.url : undefined,\n    };\n  }\n}\n\n/**\n * Represents a REST API in Amazon API Gateway, created with an OpenAPI specification.\n *\n * Some properties normally accessible on @see `RestApi` - such as the description -\n * must be declared in the specification. All Resources and Methods need to be defined as\n * part of the OpenAPI specification file, and cannot be added via the CDK.\n *\n * By default, the API will automatically be deployed and accessible from a\n * public endpoint.\n *\n *\n * @resource aws_api_gateway_rest_api\n */\nexport class SpecRestApi extends RestApiBase {\n  public readonly restApiId: string;\n  public readonly restApiRootResourceId: string;\n  public readonly root: IResource;\n  private readonly resource: apiGatewayRestApi.ApiGatewayRestApi;\n\n  constructor(scope: Construct, id: string, props: SpecRestApiProps) {\n    super(scope, id, props);\n\n    const apiDefConfig = props.apiDefinition.bind(this);\n    this.internalPolicy = props.policy;\n\n    this.resource = new apiGatewayRestApi.ApiGatewayRestApi(this, \"Resource\", {\n      name: this.restApiName,\n      policy: Lazy.stringValue({\n        produce: () => this.internalPolicy?.json,\n      }),\n      failOnWarnings: props.failOnWarnings,\n      minimumCompressionSize: props.minCompressionSize?.toBytes()?.toString(),\n      body: apiDefConfig.inlineDefinition, // ?? apiDefConfig.s3Location, // TF body can be inline or S3 URI\n      endpointConfiguration: this._configureEndpoints(props),\n      parameters: props.parameters,\n      disableExecuteApiEndpoint: props.disableExecuteApiEndpoint,\n      description: props.description, // Description can be set here if not in spec, or will be overridden by spec\n    });\n\n    // This CDK lifecycle hook is largely unused in Terraform, but can be used for custom logic after the API is created.\n    props.apiDefinition.bindAfterCreate(this, this);\n\n    this.node.defaultChild = this.resource;\n    this.restApiId = this.resource.id;\n    this.restApiRootResourceId = this.resource.rootResourceId;\n    this.root = new RootResource(this, {}, this.restApiRootResourceId);\n\n    this._configureCloudWatchRole(this.resource, props.cloudWatchRole);\n    this._configureDeployment(props);\n\n    if (props.domainName) {\n      this.addDomainName(\"CustomDomain\", props.domainName);\n    }\n  }\n\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.internalPolicy) {\n      this.internalPolicy = new iam.PolicyDocument(this, \"PolicyDocument\");\n    }\n    if (!this.policyAttachment) {\n      this.policyAttachment =\n        new apiGatewayRestApiPolicy.ApiGatewayRestApiPolicy(this, \"Policy\", {\n          restApiId: this.restApiId,\n          policy: this.internalPolicy.json,\n        });\n    }\n    this.internalPolicy.addStatements(statement);\n    // Note: The policy on apiGatewayRestApi will be updated due to Lazy evaluation.\n    // If a separate ApiGatewayRestApiPolicy resource is preferred, this logic would change.\n    return { statementAdded: true, policyDependable: this.resource }; // or this\n  }\n}\n\n/**\n * Attributes that can be specified when importing a RestApi\n */\nexport interface RestApiAttributes {\n  /**\n   * The ID of the API Gateway RestApi.\n   */\n  readonly restApiId: string;\n\n  /**\n   * The name of the API Gateway RestApi.\n   *\n   * @default - ID of the RestApi construct.\n   */\n  readonly restApiName?: string;\n\n  /**\n   * The resource ID of the root resource.\n   */\n  readonly rootResourceId: string;\n}\n\n/**\n * Represents a REST API in Amazon API Gateway.\n *\n * Use `addResource` and `addMethod` to configure the API model.\n *\n * By default, the API will automatically be deployed and accessible from a\n * public endpoint.\n */\nexport class RestApi extends RestApiBase {\n  /**\n   * Return whether the given object is a `RestApi`\n   */\n  public static isRestApi(x: any): x is RestApi {\n    return (\n      x !== null && typeof x === \"object\" && APIGATEWAY_RESTAPI_SYMBOL in x\n    );\n  }\n\n  /**\n   * Import an existing RestApi.\n   */\n  public static fromRestApiId(\n    scope: Construct,\n    id: string,\n    restApiId: string,\n  ): IRestApi {\n    class Import extends RestApiBase {\n      public readonly restApiId = restApiId;\n      public readonly restApiName = id; // Defaulting to construct ID for name\n      public readonly restApiRootResourceId = Lazy.stringValue({\n        produce: () => {\n          // This would ideally come from a data source lookup if not provided\n          throw new Error(\n            \"restApiRootResourceId is not available when importing with fromRestApiId. Use fromRestApiAttributes or provide it.\",\n          );\n        },\n      });\n      public readonly root: IResource = new RootResource(\n        this,\n        {},\n        this.restApiRootResourceId,\n      );\n\n      public addToResourcePolicy(\n        _statement: iam.PolicyStatement,\n      ): iam.AddToResourcePolicyResult {\n        // Cannot add to policy of an imported RestApi through this interface\n        return { statementAdded: false };\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import an existing RestApi that can be configured with additional Methods and Resources.\n   */\n  public static fromRestApiAttributes(\n    scope: Construct,\n    id: string,\n    attrs: RestApiAttributes,\n  ): IRestApi {\n    class Import extends RestApiBase {\n      public readonly restApiId = attrs.restApiId;\n      public readonly restApiName = attrs.restApiName ?? id;\n      public readonly restApiRootResourceId = attrs.rootResourceId;\n      public readonly root: IResource = new RootResource(\n        this,\n        {},\n        this.restApiRootResourceId,\n      );\n\n      public addToResourcePolicy(\n        _statement: iam.PolicyStatement,\n      ): iam.AddToResourcePolicyResult {\n        return { statementAdded: false };\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  public readonly restApiId: string;\n  public readonly root: IResource;\n  public readonly restApiRootResourceId: string;\n  private readonly resource: apiGatewayRestApi.ApiGatewayRestApi;\n\n  /**\n   * The list of methods bound to this RestApi\n   */\n  public readonly methods = new Array<Method>();\n\n  /**\n   * This list of deployments bound to this RestApi\n   */\n  private readonly deployments = new Array<Deployment>();\n\n  constructor(scope: Construct, id: string, props: RestApiProps = {}) {\n    super(scope, id, props);\n\n    if (props.minCompressionSize === undefined) {\n      // No equivalent for minimumCompressionSize being deprecated in favor of minCompressionSize\n    }\n\n    this.internalPolicy = props.policy;\n\n    this.resource = new apiGatewayRestApi.ApiGatewayRestApi(this, \"Resource\", {\n      name: this.restApiName,\n      description: props.description,\n      policy: Lazy.stringValue({\n        produce: () => this.internalPolicy?.json,\n      }),\n      failOnWarnings: props.failOnWarnings,\n      minimumCompressionSize: props.minCompressionSize?.toBytes()?.toString(),\n      binaryMediaTypes: props.binaryMediaTypes,\n      endpointConfiguration: this._configureEndpoints(props),\n      apiKeySource: props.apiKeySourceType,\n      // cloneFrom: props.cloneFrom?.restApiId, // Not supported in TF aws_api_gateway_rest_api\n      parameters: props.parameters,\n      disableExecuteApiEndpoint: props.disableExecuteApiEndpoint,\n    });\n    this.node.defaultChild = this.resource;\n    this.restApiId = this.resource.id;\n    this.restApiRootResourceId = this.resource.rootResourceId;\n\n    // ensure the iam policy is associated with the resource.\n    if (this.internalPolicy) {\n      this.policyAttachment =\n        new apiGatewayRestApiPolicy.ApiGatewayRestApiPolicy(this, \"Policy\", {\n          restApiId: this.restApiId,\n          policy: this.internalPolicy.json,\n        });\n    }\n\n    this._configureCloudWatchRole(this.resource, props.cloudWatchRole);\n    this._configureDeployment(props);\n\n    if (props.domainName) {\n      this.addDomainName(\"CustomDomain\", props.domainName);\n    }\n\n    this.root = new RootResource(this, props, this.restApiRootResourceId);\n\n    this.node.addValidation({ validate: () => this.validateRestApi() });\n\n    Object.defineProperty(this, APIGATEWAY_RESTAPI_SYMBOL, { value: true });\n  }\n\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.internalPolicy) {\n      this.internalPolicy = new iam.PolicyDocument(this, \"PolicyDocument\");\n    }\n    if (!this.policyAttachment) {\n      this.policyAttachment =\n        new apiGatewayRestApiPolicy.ApiGatewayRestApiPolicy(this, \"Policy\", {\n          restApiId: this.restApiId,\n          policy: this.internalPolicy.json,\n        });\n    }\n    this.internalPolicy.addStatements(statement);\n    return { statementAdded: true, policyDependable: this.resource };\n  }\n\n  public addModel(id: string, props: ModelOptions): Model {\n    return new Model(this, id, {\n      ...props,\n      restApi: this,\n    });\n  }\n\n  public addRequestValidator(\n    id: string,\n    props: RequestValidatorOptions,\n  ): RequestValidator {\n    return new RequestValidator(this, id, {\n      ...props,\n      restApi: this,\n    });\n  }\n\n  /**\n   * Internal API used by `Method` to keep an inventory of methods at the API\n   * level for validation purposes.\n   *\n   * @internal\n   */\n  public _attachMethod(method: Method) {\n    // In TF, deployment triggers would handle this implicitly or explicitly\n    this.methods.push(method);\n    // add this method as a dependency to all deployments defined for this api\n    // when additional deployments are added, _attachDeployment is called and\n    // this method will be added there.\n    for (const dep of this.deployments) {\n      dep._addMethodDependency(method);\n    }\n  }\n\n  /** @internal */\n  public _attachDeployment(deployment: Deployment) {\n    // In TF, deployment triggers would handle this implicitly or explicitly\n    this.deployments.push(deployment);\n    for (const method of this.methods) {\n      deployment._addMethodDependency(method);\n    }\n  }\n\n  private validateRestApi(): string[] {\n    if (this.methods.length === 0) {\n      return [\"The REST API doesn't contain any methods\"];\n    }\n    return [];\n  }\n}\n\n/**\n * The endpoint configuration of a REST API, including VPCs and endpoint types.\n *\n * EndpointConfiguration is a property of the AWS::ApiGateway::RestApi resource.\n */\nexport interface EndpointConfiguration {\n  /**\n   * A list of endpoint types of an API or its custom domain name.\n   *\n   * @default EndpointType.EDGE\n   */\n  readonly types: EndpointType[];\n\n  /**\n   * A list of VPC Endpoints against which to create Route53 ALIASes\n   *\n   * @default - no ALIASes are created for the endpoint.\n   */\n  readonly vpcEndpoints?: ec2.IVpcEndpoint[];\n}\n\nexport enum ApiKeySourceType {\n  HEADER = \"HEADER\",\n  AUTHORIZER = \"AUTHORIZER\",\n}\n\nexport enum EndpointType {\n  EDGE = \"EDGE\",\n  REGIONAL = \"REGIONAL\",\n  PRIVATE = \"PRIVATE\",\n}\n\nclass RootResource extends ResourceBase {\n  public readonly parentResource?: IResource;\n  public readonly api: RestApiBase;\n  public readonly resourceId: string;\n  public readonly path: string;\n  public readonly defaultIntegration?: Integration | undefined;\n  public readonly defaultMethodOptions?: MethodOptions | undefined;\n  public readonly defaultCorsPreflightOptions?: CorsOptions | undefined;\n\n  private readonly _restApi?: RestApi;\n\n  constructor(api: RestApiBase, props: ResourceOptions, resourceId: string) {\n    super(api, \"Default\"); // ID 'Default' for the root resource wrapper\n\n    this.parentResource = undefined;\n    this.defaultIntegration = props.defaultIntegration;\n    this.defaultMethodOptions = props.defaultMethodOptions;\n    this.defaultCorsPreflightOptions = props.defaultCorsPreflightOptions;\n    this.api = api;\n    this.resourceId = resourceId;\n    this.path = \"/\";\n\n    if (RestApi.isRestApi(api)) {\n      // Check if it's the non-spec RestApi to avoid type errors if api is SpecRestApi\n      this._restApi = api as RestApi;\n    }\n\n    if (this.defaultCorsPreflightOptions) {\n      this.addCorsPreflight(this.defaultCorsPreflightOptions);\n    }\n  }\n\n  /**\n   * Get the RestApi associated with this Resource.\n   * @deprecated - Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.\n   */\n  public get restApi(): RestApi {\n    if (!this._restApi) {\n      throw new Error(\n        \"RestApi is not available on Resource not connected to an instance of RestApi. Use `api` instead\",\n      );\n    }\n    return this._restApi;\n  }\n}\n"]}