terraconstructs 0.0.25 → 0.1.0

package/lib/aws/compute/stage.js

@@ -0,0 +1,304 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stage = exports.StageBase = exports.MethodLoggingLevel = 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 access_log_1 = require("./access-log");
+const api_key_1 = require("./api-key");
+const apigateway_canned_metrics_generated_1 = require("./apigateway-canned-metrics.generated");
+const apigateway_util_1 = require("./apigateway-util");
+const restapi_1 = require("./restapi");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const cloudwatch = require("../cloudwatch");
+var MethodLoggingLevel;
+(function (MethodLoggingLevel) {
+    MethodLoggingLevel["OFF"] = "OFF";
+    MethodLoggingLevel["ERROR"] = "ERROR";
+    MethodLoggingLevel["INFO"] = "INFO";
+})(MethodLoggingLevel || (exports.MethodLoggingLevel = MethodLoggingLevel = {}));
+/**
+ * Base class for an ApiGateway Stage
+ */
+class StageBase extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {
+            stageName: this.stageName,
+            stageArn: this.stageArn,
+            invokeUrl: this.urlForPath(),
+        };
+    }
+    /**
+     * Add an ApiKey to this stage
+     *
+     * Note: direct stage association is deprecated.
+     * Stage association should be handled via Usage Plans.
+     */
+    addApiKey(id, options) {
+        return new api_key_1.ApiKey(this, id, {
+            stages: [this],
+            ...options,
+        });
+    }
+    /**
+     * Returns the invoke URL for a certain path.
+     * @param path The resource path
+     */
+    urlForPath(path = "/") {
+        if (!path.startsWith("/")) {
+            // TODO: Use ValidationError from core/lib/errors
+            throw new Error(`Path must begin with \"/\": ${path}`);
+        }
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        // For imported APIs, restApiId might be a token. For new APIs, it's resolved.
+        // The URL structure is https://{restapi-id}.execute-api.{region}.{dns-suffix}/{stageName}/{path}
+        return `https://${this.restApi.restApiId}.execute-api.${stack.region}.${stack.urlSuffix}/${this.stageName}${path}`;
+    }
+    /**
+     * Returns the resource ARN for this stage:
+     *
+     *   arn:aws:apigateway:{region}::/restapis/{restApiId}/stages/{stageName}
+     *
+     * Note that this is separate from the execute-api ARN for methods and resources
+     * within this stage.
+     *
+     * @attribute
+     */
+    get stageArn() {
+        return aws_stack_1.AwsStack.ofAwsConstruct(this).formatArn({
+            arnFormat: arn_1.ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME,
+            service: "apigateway",
+            account: "", // APIGateway ARNs for stages don't include account in this part
+            resource: "restapis",
+            resourceName: `${this.restApi.restApiId}/stages/${this.stageName}`,
+        });
+    }
+    /**
+     * Returns the given named metric for this stage
+     */
+    metric(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/ApiGateway",
+            metricName,
+            dimensionsMap: {
+                ApiName: this.restApi.restApiName,
+                Stage: this.stageName,
+            },
+            ...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);
+    }
+    cannedMetric(fn, props) {
+        return new cloudwatch.Metric({
+            ...fn({ ApiName: this.restApi.restApiName, Stage: this.stageName }),
+            ...props,
+        }).attachTo(this);
+    }
+}
+exports.StageBase = StageBase;
+_a = JSII_RTTI_SYMBOL_1;
+StageBase[_a] = { fqn: "terraconstructs.aws.compute.StageBase", version: "0.1.0" };
+class Stage extends StageBase {
+    /**
+     * Import a Stage by its attributes
+     */
+    static fromStageAttributes(scope, id, attrs) {
+        class Import extends StageBase {
+            constructor() {
+                super(...arguments);
+                this.stageName = attrs.stageName;
+                this.restApi = attrs.restApi;
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.restApi = props.deployment.api;
+        this.enableCacheCluster = props.cacheClusterEnabled;
+        // Determine if cache cluster needs to be enabled based on method options
+        const commonCachingEnabled = props.cachingEnabled;
+        if (commonCachingEnabled) {
+            if (this.enableCacheCluster === false) {
+                throw new Error("Cannot enable caching for common methods since cache cluster is disabled on stage");
+            }
+            this.enableCacheCluster = true;
+        }
+        if (props.methodOptions) {
+            for (const path of Object.keys(props.methodOptions)) {
+                if (props.methodOptions[path].cachingEnabled) {
+                    if (this.enableCacheCluster === false) {
+                        throw new Error(`Cannot enable caching for method ${path} since cache cluster is disabled on stage`);
+                    }
+                    this.enableCacheCluster = true;
+                }
+            }
+        }
+        // custom access logging
+        let accessLogSettings;
+        const accessLogDestination = props.accessLogDestination;
+        const accessLogFormat = props.accessLogFormat;
+        if (accessLogDestination || accessLogFormat) {
+            if (accessLogFormat !== undefined &&
+                !cdktf_1.Token.isUnresolved(accessLogFormat.toString()) &&
+                !/.*\$context.(requestId|extendedRequestId)\b.*/.test(accessLogFormat.toString())) {
+                // TODO: Use ValidationError from core/lib/errors
+                throw new Error("Access log must include either `AccessLogFormat.contextRequestId()` or `AccessLogFormat.contextExtendedRequestId()`");
+            }
+            if (accessLogFormat !== undefined && accessLogDestination === undefined) {
+                // TODO: Use ValidationError from core/lib/errors
+                throw new Error("Access log format is specified without a destination");
+            }
+            accessLogSettings = {
+                destinationArn: accessLogDestination.bind(this).destinationArn, // accessLogDestination must be defined if format is
+                format: accessLogFormat?.toString() ?? access_log_1.AccessLogFormat.clf().toString(),
+            };
+        }
+        // enable cache cluster if cacheClusterSize is set
+        if (props.cacheClusterSize !== undefined) {
+            if (this.enableCacheCluster === undefined) {
+                this.enableCacheCluster = true;
+            }
+            else if (this.enableCacheCluster === false) {
+                // TODO: Use ValidationError from core/lib/errors
+                throw new Error(`Cannot set "cacheClusterSize" to ${props.cacheClusterSize} and "cacheClusterEnabled" to "false". (${this.node.path})`);
+            }
+        }
+        const cacheClusterSize = this.enableCacheCluster
+            ? props.cacheClusterSize || "0.5"
+            : undefined;
+        this.resource = new provider_aws_1.apiGatewayStage.ApiGatewayStage(this, "Resource", {
+            stageName: props.stageName || "prod",
+            accessLogSettings,
+            cacheClusterEnabled: this.enableCacheCluster,
+            cacheClusterSize,
+            clientCertificateId: props.clientCertificateId,
+            deploymentId: props.deployment.deploymentId,
+            restApiId: props.deployment.api.restApiId,
+            description: props.description,
+            documentationVersion: props.documentationVersion,
+            variables: props.variables,
+            xrayTracingEnabled: props.tracingEnabled,
+        });
+        this.stageName = this.resource.stageName;
+        this.applyMethodSettings(props, this.resource);
+        if (restapi_1.RestApiBase._isRestApiBase(this.restApi)) {
+            this.restApi._attachStage(this);
+        }
+    }
+    applyMethodSettings(props, stageResource) {
+        const commonMethodOptions = {
+            metricsEnabled: props.metricsEnabled,
+            loggingLevel: props.loggingLevel,
+            dataTraceEnabled: props.dataTraceEnabled,
+            throttlingBurstLimit: props.throttlingBurstLimit,
+            throttlingRateLimit: props.throttlingRateLimit,
+            cachingEnabled: props.cachingEnabled,
+            cacheTtl: props.cacheTtl,
+            cacheDataEncrypted: props.cacheDataEncrypted,
+        };
+        const hasCommonOptions = Object.values(commonMethodOptions).some((v) => v !== undefined);
+        if (hasCommonOptions) {
+            this.createMethodSettingsResource("/*/*", commonMethodOptions, stageResource);
+        }
+        if (props.methodOptions) {
+            for (const path of Object.keys(props.methodOptions)) {
+                this.createMethodSettingsResource(path, props.methodOptions[path], stageResource);
+            }
+        }
+    }
+    createMethodSettingsResource(path, options, stageRes) {
+        // Validation for caching already happened in constructor before ApiGatewayStage creation
+        const { httpMethod, resourcePath } = (0, apigateway_util_1.parseMethodOptionsPath)(path);
+        // Sanitize the ID for the method settings resource
+        // Replace non-alphanumeric characters with hyphen, ensure it's a valid TF ID part
+        const safePathForId = resourcePath
+            .replace(/[^a-zA-Z0-9_]/g, "-")
+            .replace(/^-+|-+$/g, "");
+        const methodSettingsId = `MethodSettings-${safePathForId || "Root"}`;
+        new provider_aws_1.apiGatewayMethodSettings.ApiGatewayMethodSettings(this, methodSettingsId, {
+            restApiId: stageRes.restApiId,
+            stageName: stageRes.stageName,
+            methodPath: `${resourcePath}/${httpMethod}`,
+            settings: {
+                metricsEnabled: options.metricsEnabled,
+                loggingLevel: options.loggingLevel,
+                dataTraceEnabled: options.dataTraceEnabled,
+                throttlingBurstLimit: options.throttlingBurstLimit,
+                throttlingRateLimit: options.throttlingRateLimit,
+                cachingEnabled: options.cachingEnabled,
+                cacheTtlInSeconds: options.cacheTtl?.toSeconds(),
+                cacheDataEncrypted: options.cacheDataEncrypted,
+            },
+        });
+    }
+}
+exports.Stage = Stage;
+_b = JSII_RTTI_SYMBOL_1;
+Stage[_b] = { fqn: "terraconstructs.aws.compute.Stage", version: "0.1.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stage.js","sourceRoot":"","sources":["../../../src/aws/compute/stage.ts"],"names":[],"mappings":";;;;;AAAA,sDAAgF;AAChF,iCAA8B;AAE9B,6CAAsE;AACtE,uCAA2D;AAC3D,+FAA0E;AAC1E,uDAA2D;AAE3D,uCAAkD;AAElD,gCAAmC;AACnC,oDAI0B;AAC1B,4CAAwC;AACxC,4CAA4C;AAoM5C,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,iCAAW,CAAA;IACX,qCAAe,CAAA;IACf,mCAAa,CAAA;AACf,CAAC,EAJW,kBAAkB,kCAAlB,kBAAkB,QAI7B;AAoFD;;GAEG;AACH,MAAsB,SAAU,SAAQ,gCAAgB;IAItD,IAAW,OAAO;QAChB,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE;SAC7B,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACI,SAAS,CAAC,EAAU,EAAE,OAAuB;QAClD,OAAO,IAAI,gBAAM,CAAC,IAAI,EAAE,EAAE,EAAE;YAC1B,MAAM,EAAE,CAAC,IAAI,CAAC;YACd,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,OAAe,GAAG;QAClC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,iDAAiD;YACjD,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,EAAE,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,KAAK,GAAG,oBAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAC5C,8EAA8E;QAC9E,iGAAiG;QACjG,OAAO,WAAW,IAAI,CAAC,OAAO,CAAC,SAAS,gBAAgB,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,GAAG,IAAI,EAAE,CAAC;IACrH,CAAC;IAED;;;;;;;;;OASG;IACH,IAAW,QAAQ;QACjB,OAAO,oBAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;YAC7C,SAAS,EAAE,eAAS,CAAC,kCAAkC;YACvD,OAAO,EAAE,YAAY;YACrB,OAAO,EAAE,EAAE,EAAE,gEAAgE;YAC7E,QAAQ,EAAE,UAAU;YACpB,YAAY,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,WAAW,IAAI,CAAC,SAAS,EAAE;SACnE,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,MAAM,CACX,UAAkB,EAClB,KAAgC;QAEhC,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC;YAC3B,SAAS,EAAE,gBAAgB;YAC3B,UAAU;YACV,aAAa,EAAE;gBACb,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;gBACjC,KAAK,EAAE,IAAI,CAAC,SAAS;aACtB;YACD,GAAG,KAAK;SACT,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACI,iBAAiB,CACtB,KAAgC;QAEhC,OAAO,IAAI,CAAC,YAAY,CAAC,uDAAiB,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IAClE,CAAC;IAED;;;;OAIG;IACI,iBAAiB,CACtB,KAAgC;QAEhC,OAAO,IAAI,CAAC,YAAY,CAAC,uDAAiB,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IAClE,CAAC;IAED;;;;OAIG;IACI,mBAAmB,CACxB,KAAgC;QAEhC,OAAO,IAAI,CAAC,YAAY,CAAC,uDAAiB,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;IACtE,CAAC;IAED;;;;;OAKG;IACI,oBAAoB,CACzB,KAAgC;QAEhC,OAAO,IAAI,CAAC,YAAY,CAAC,uDAAiB,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;IACvE,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,KAAgC;QACjD,OAAO,IAAI,CAAC,YAAY,CAAC,uDAAiB,CAAC,QAAQ,EAAE;YACnD,SAAS,EAAE,aAAa;YACxB,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,wBAAwB,CAC7B,KAAgC;QAEhC,OAAO,IAAI,CAAC,YAAY,CACtB,uDAAiB,CAAC,yBAAyB,EAC3C,KAAK,CACN,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACI,aAAa,CAAC,KAAgC;QACnD,OAAO,IAAI,CAAC,YAAY,CAAC,uDAAiB,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC;IAEO,YAAY,CAClB,EAAwE,EACxE,KAAgC;QAEhC,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC;YAC3B,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;YACnE,GAAG,KAAK;SACT,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC;;AAzKH,8BA0KC;;;AAED,MAAa,KAAM,SAAQ,SAAS;IAClC;;OAEG;IACI,MAAM,CAAC,mBAAmB,CAC/B,KAAgB,EAChB,EAAU,EACV,KAAsB;QAEtB,MAAM,MAAO,SAAQ,SAAS;YAA9B;;gBACkB,cAAS,GAAG,KAAK,CAAC,SAAS,CAAC;gBAC5B,YAAO,GAAG,KAAK,CAAC,OAAO,CAAC;YAC1C,CAAC;SAAA;QACD,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;IAQD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAiB;QACzD,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;QACpC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,mBAAmB,CAAC;QAEpD,yEAAyE;QACzE,MAAM,oBAAoB,GAAG,KAAK,CAAC,cAAc,CAAC;QAClD,IAAI,oBAAoB,EAAE,CAAC;YACzB,IAAI,IAAI,CAAC,kBAAkB,KAAK,KAAK,EAAE,CAAC;gBACtC,MAAM,IAAI,KAAK,CACb,mFAAmF,CACpF,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QACjC,CAAC;QACD,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;YACxB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;gBACpD,IAAI,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,CAAC;oBAC7C,IAAI,IAAI,CAAC,kBAAkB,KAAK,KAAK,EAAE,CAAC;wBACtC,MAAM,IAAI,KAAK,CACb,oCAAoC,IAAI,2CAA2C,CACpF,CAAC;oBACJ,CAAC;oBACD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;gBACjC,CAAC;YACH,CAAC;QACH,CAAC;QAED,wBAAwB;QACxB,IAAI,iBAES,CAAC;QACd,MAAM,oBAAoB,GAAG,KAAK,CAAC,oBAAoB,CAAC;QACxD,MAAM,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;QAE9C,IAAI,oBAAoB,IAAI,eAAe,EAAE,CAAC;YAC5C,IACE,eAAe,KAAK,SAAS;gBAC7B,CAAC,aAAK,CAAC,YAAY,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;gBAC/C,CAAC,+CAA+C,CAAC,IAAI,CACnD,eAAe,CAAC,QAAQ,EAAE,CAC3B,EACD,CAAC;gBACD,iDAAiD;gBACjD,MAAM,IAAI,KAAK,CACb,qHAAqH,CACtH,CAAC;YACJ,CAAC;YACD,IAAI,eAAe,KAAK,SAAS,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;gBACxE,iDAAiD;gBACjD,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;YAC1E,CAAC;YAED,iBAAiB,GAAG;gBAClB,cAAc,EAAE,oBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,oDAAoD;gBACrH,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,IAAI,4BAAe,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;aACxE,CAAC;QACJ,CAAC;QAED,kDAAkD;QAClD,IAAI,KAAK,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACzC,IAAI,IAAI,CAAC,kBAAkB,KAAK,SAAS,EAAE,CAAC;gBAC1C,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YACjC,CAAC;iBAAM,IAAI,IAAI,CAAC,kBAAkB,KAAK,KAAK,EAAE,CAAC;gBAC7C,iDAAiD;gBACjD,MAAM,IAAI,KAAK,CACb,oCAAoC,KAAK,CAAC,gBAAgB,2CAA2C,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,CACvH,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,gBAAgB,GAAG,IAAI,CAAC,kBAAkB;YAC9C,CAAC,CAAC,KAAK,CAAC,gBAAgB,IAAI,KAAK;YACjC,CAAC,CAAC,SAAS,CAAC;QAEd,IAAI,CAAC,QAAQ,GAAG,IAAI,8BAAe,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE;YACpE,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,MAAM;YACpC,iBAAiB;YACjB,mBAAmB,EAAE,IAAI,CAAC,kBAAkB;YAC5C,gBAAgB;YAChB,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,YAAY;YAC3C,SAAS,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS;YACzC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;YAChD,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,kBAAkB,EAAE,KAAK,CAAC,cAAc;SACzC,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;QAEzC,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE/C,IAAI,qBAAW,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAEO,mBAAmB,CACzB,KAAiB,EACjB,aAA8C;QAE9C,MAAM,mBAAmB,GAA4B;YACnD,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;YAChD,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;SAC7C,CAAC;QAEF,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAC9D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,SAAS,CACvB,CAAC;QACF,IAAI,gBAAgB,EAAE,CAAC;YACrB,IAAI,CAAC,4BAA4B,CAC/B,MAAM,EACN,mBAAmB,EACnB,aAAa,CACd,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;YACxB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;gBACpD,IAAI,CAAC,4BAA4B,CAC/B,IAAI,EACJ,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,EACzB,aAAa,CACd,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAEO,4BAA4B,CAClC,IAAY,EACZ,OAAgC,EAChC,QAAyC;QAEzC,yFAAyF;QAEzF,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,IAAA,wCAAsB,EAAC,IAAI,CAAC,CAAC;QAElE,mDAAmD;QACnD,kFAAkF;QAClF,MAAM,aAAa,GAAG,YAAY;aAC/B,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC;aAC9B,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QAC3B,MAAM,gBAAgB,GAAG,kBAAkB,aAAa,IAAI,MAAM,EAAE,CAAC;QAErE,IAAI,uCAAwB,CAAC,wBAAwB,CACnD,IAAI,EACJ,gBAAgB,EAChB;YACE,SAAS,EAAE,QAAQ,CAAC,SAAS;YAC7B,SAAS,EAAE,QAAQ,CAAC,SAAS;YAC7B,UAAU,EAAE,GAAG,YAAY,IAAI,UAAU,EAAE;YAC3C,QAAQ,EAAE;gBACR,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,YAAY,EAAE,OAAO,CAAC,YAAY;gBAClC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;gBAC1C,oBAAoB,EAAE,OAAO,CAAC,oBAAoB;gBAClD,mBAAmB,EAAE,OAAO,CAAC,mBAAmB;gBAChD,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,iBAAiB,EAAE,OAAO,CAAC,QAAQ,EAAE,SAAS,EAAE;gBAChD,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;aAC/C;SACF,CACF,CAAC;IACJ,CAAC;;AAjMH,sBAkMC","sourcesContent":["import { apiGatewayStage, apiGatewayMethodSettings } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AccessLogFormat, IAccessLogDestination } from \"./access-log\";\nimport { IApiKey, ApiKeyOptions, ApiKey } from \"./api-key\";\nimport { ApiGatewayMetrics } from \"./apigateway-canned-metrics.generated\";\nimport { parseMethodOptionsPath } from \"./apigateway-util\";\nimport { Deployment } from \"./deployment\";\nimport { IRestApi, RestApiBase } from \"./restapi\";\nimport { Duration } from \"../../duration\";\nimport { ArnFormat } from \"../arn\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as cloudwatch from \"../cloudwatch\";\n// import { ValidationError } from \"../../core/lib/errors\"; // Use throw new Error()\n\n/**\n * Represents an APIGateway Stage.\n */\nexport interface IStage extends IAwsConstruct {\n  /**\n   * Name of this stage.\n   * @attribute\n   */\n  readonly stageName: string;\n\n  /**\n   * RestApi to which this stage is associated.\n   */\n  readonly restApi: IRestApi;\n\n  /**\n   * Returns the resource ARN for this stage.\n   *\n   * @attribute\n   */\n  readonly stageArn: string;\n\n  /**\n   * Add an ApiKey to this Stage\n   */\n  addApiKey(id: string, options?: ApiKeyOptions): IApiKey;\n\n  /**\n   * Returns the invoke URL for a certain path.\n   * @param path The resource path\n   */\n  urlForPath(path?: string): string;\n\n  /**\n   * Returns the given named metric for this stage\n   */\n  metric(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\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  metricClientError(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\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  metricServerError(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\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  metricCacheHitCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\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  metricCacheMissCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the total number API requests in a given period.\n   *\n   * @default - sample count over 5 minutes\n   */\n  metricCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\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  metricIntegrationLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\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  metricLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\nexport interface StageOptions extends MethodDeploymentOptions {\n  /**\n   * The name of the stage, which API Gateway uses as the first path segment\n   * in the invoked Uniform Resource Identifier (URI).\n   *\n   * @default - \"prod\"\n   */\n  readonly stageName?: string;\n\n  /**\n   * The CloudWatch Logs log group or Firehose delivery stream where to write access logs.\n   *\n   * @default - No destination\n   */\n  readonly accessLogDestination?: IAccessLogDestination;\n\n  /**\n   * A single line format of access logs of data, as specified by selected $content variables.\n   * The format must include either `AccessLogFormat.contextRequestId()`\n   * or `AccessLogFormat.contextExtendedRequestId()`.\n   *\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html#context-variable-reference\n   *\n   * @default - Common Log Format\n   */\n  readonly accessLogFormat?: AccessLogFormat;\n\n  /**\n   * Specifies whether Amazon X-Ray tracing is enabled for this method.\n   *\n   * @default false\n   */\n  readonly tracingEnabled?: boolean;\n\n  /**\n   * Indicates whether cache clustering is enabled for the stage.\n   *\n   * @default - Disabled for the stage.\n   */\n  readonly cacheClusterEnabled?: boolean;\n\n  /**\n   * The stage's cache cluster size.\n   * @default 0.5\n   */\n  readonly cacheClusterSize?: string;\n\n  /**\n   * The identifier of the client certificate that API Gateway uses to call\n   * your integration endpoints in the stage.\n   *\n   * @default - None.\n   */\n  readonly clientCertificateId?: string;\n\n  /**\n   * A description of the purpose of the stage.\n   *\n   * @default - No description.\n   */\n  readonly description?: string;\n\n  /**\n   * The version identifier of the API documentation snapshot.\n   *\n   * @default - No documentation version.\n   */\n  readonly documentationVersion?: string;\n\n  /**\n   * A map that defines the stage variables. Variable names must consist of\n   * alphanumeric characters, and the values must match the following regular\n   * expression: [A-Za-z0-9-._~:/?#&=,]+.\n   *\n   * @default - No stage variables.\n   */\n  readonly variables?: { [key: string]: string };\n\n  /**\n   * Method deployment options for specific resources/methods. These will\n   * override common options defined in `StageOptions#methodOptions`.\n   *\n   * @param path is {resource_path}/{http_method} (i.e. /api/toys/GET) for an\n   * individual method override. You can use `*` for both {resource_path} and {http_method}\n   * to define options for all methods/resources.\n   *\n   * @default - Common options will be used.\n   */\n  readonly methodOptions?: { [path: string]: MethodDeploymentOptions };\n}\n\nexport interface StageProps extends StageOptions, AwsConstructProps {\n  /**\n   * The deployment that this stage points to.\n   */\n  readonly deployment: Deployment;\n}\n\nexport enum MethodLoggingLevel {\n  OFF = \"OFF\",\n  ERROR = \"ERROR\",\n  INFO = \"INFO\",\n}\n\nexport interface MethodDeploymentOptions {\n  /**\n   * Specifies whether Amazon CloudWatch metrics are enabled for this method.\n   *\n   * @default false\n   */\n  readonly metricsEnabled?: boolean;\n\n  /**\n   * Specifies the logging level for this method, which effects the log\n   * entries pushed to Amazon CloudWatch Logs.\n   *\n   * @default - Off\n   */\n  readonly loggingLevel?: MethodLoggingLevel;\n\n  /**\n   * Specifies whether data trace logging is enabled for this method.\n   * When enabled, API gateway will log the full API requests and responses.\n   * This can be useful to troubleshoot APIs, but can result in logging sensitive data.\n   * We recommend that you don't enable this feature for production APIs.\n   *\n   * @default false\n   */\n  readonly dataTraceEnabled?: boolean;\n\n  /**\n   * Specifies the throttling burst limit.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html\n   *\n   * @default - No additional restriction.\n   */\n  readonly throttlingBurstLimit?: number;\n\n  /**\n   * Specifies the throttling rate limit.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html\n   *\n   * @default - No additional restriction.\n   */\n  readonly throttlingRateLimit?: number;\n\n  /**\n   * Specifies whether responses should be cached and returned for requests. A\n   * cache cluster must be enabled on the stage for responses to be cached.\n   *\n   * @default - Caching is Disabled.\n   */\n  readonly cachingEnabled?: boolean;\n\n  /**\n   * Specifies the time to live (TTL), in seconds, for cached responses. The\n   * higher the TTL, the longer the response will be cached.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-caching.html\n   *\n   * @default Duration.minutes(5)\n   */\n  readonly cacheTtl?: Duration;\n\n  /**\n   * Indicates whether the cached responses are encrypted.\n   *\n   * @default false\n   */\n  readonly cacheDataEncrypted?: boolean;\n}\n\n/**\n * The attributes of an imported Stage\n */\nexport interface StageAttributes {\n  /**\n   * The name of the stage\n   */\n  readonly stageName: string;\n\n  /**\n   * The RestApi that the stage belongs to\n   */\n  readonly restApi: IRestApi;\n}\n\n/**\n * Base class for an ApiGateway Stage\n */\nexport abstract class StageBase extends AwsConstructBase implements IStage {\n  public abstract readonly stageName: string;\n  public abstract readonly restApi: IRestApi;\n\n  public get outputs(): Record<string, any> {\n    return {\n      stageName: this.stageName,\n      stageArn: this.stageArn,\n      invokeUrl: this.urlForPath(),\n    };\n  }\n\n  /**\n   * Add an ApiKey to this stage\n   *\n   * Note: direct stage association is deprecated.\n   * Stage association should be handled via Usage Plans.\n   */\n  public addApiKey(id: string, options?: ApiKeyOptions): IApiKey {\n    return new ApiKey(this, id, {\n      stages: [this],\n      ...options,\n    });\n  }\n\n  /**\n   * Returns the invoke URL for a certain path.\n   * @param path The resource path\n   */\n  public urlForPath(path: string = \"/\"): string {\n    if (!path.startsWith(\"/\")) {\n      // TODO: Use ValidationError from core/lib/errors\n      throw new Error(`Path must begin with \\\"/\\\": ${path}`);\n    }\n    const stack = AwsStack.ofAwsConstruct(this);\n    // For imported APIs, restApiId might be a token. For new APIs, it's resolved.\n    // The URL structure is https://{restapi-id}.execute-api.{region}.{dns-suffix}/{stageName}/{path}\n    return `https://${this.restApi.restApiId}.execute-api.${stack.region}.${stack.urlSuffix}/${this.stageName}${path}`;\n  }\n\n  /**\n   * Returns the resource ARN for this stage:\n   *\n   *   arn:aws:apigateway:{region}::/restapis/{restApiId}/stages/{stageName}\n   *\n   * Note that this is separate from the execute-api ARN for methods and resources\n   * within this stage.\n   *\n   * @attribute\n   */\n  public get stageArn(): string {\n    return AwsStack.ofAwsConstruct(this).formatArn({\n      arnFormat: ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME,\n      service: \"apigateway\",\n      account: \"\", // APIGateway ARNs for stages don't include account in this part\n      resource: \"restapis\",\n      resourceName: `${this.restApi.restApiId}/stages/${this.stageName}`,\n    });\n  }\n\n  /**\n   * Returns the given named metric for this stage\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: {\n        ApiName: this.restApi.restApiName,\n        Stage: this.stageName,\n      },\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  private cannedMetric(\n    fn: (dims: { ApiName: string; Stage: string }) => cloudwatch.MetricProps,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...fn({ ApiName: this.restApi.restApiName, Stage: this.stageName }),\n      ...props,\n    }).attachTo(this);\n  }\n}\n\nexport class Stage extends StageBase {\n  /**\n   * Import a Stage by its attributes\n   */\n  public static fromStageAttributes(\n    scope: Construct,\n    id: string,\n    attrs: StageAttributes,\n  ): IStage {\n    class Import extends StageBase {\n      public readonly stageName = attrs.stageName;\n      public readonly restApi = attrs.restApi;\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly stageName: string;\n  public readonly restApi: IRestApi;\n  public readonly resource: apiGatewayStage.ApiGatewayStage;\n\n  private enableCacheCluster?: boolean;\n\n  constructor(scope: Construct, id: string, props: StageProps) {\n    super(scope, id, props);\n\n    this.restApi = props.deployment.api;\n    this.enableCacheCluster = props.cacheClusterEnabled;\n\n    // Determine if cache cluster needs to be enabled based on method options\n    const commonCachingEnabled = props.cachingEnabled;\n    if (commonCachingEnabled) {\n      if (this.enableCacheCluster === false) {\n        throw new Error(\n          \"Cannot enable caching for common methods since cache cluster is disabled on stage\",\n        );\n      }\n      this.enableCacheCluster = true;\n    }\n    if (props.methodOptions) {\n      for (const path of Object.keys(props.methodOptions)) {\n        if (props.methodOptions[path].cachingEnabled) {\n          if (this.enableCacheCluster === false) {\n            throw new Error(\n              `Cannot enable caching for method ${path} since cache cluster is disabled on stage`,\n            );\n          }\n          this.enableCacheCluster = true;\n        }\n      }\n    }\n\n    // custom access logging\n    let accessLogSettings:\n      | apiGatewayStage.ApiGatewayStageAccessLogSettings\n      | undefined;\n    const accessLogDestination = props.accessLogDestination;\n    const accessLogFormat = props.accessLogFormat;\n\n    if (accessLogDestination || accessLogFormat) {\n      if (\n        accessLogFormat !== undefined &&\n        !Token.isUnresolved(accessLogFormat.toString()) &&\n        !/.*\\$context.(requestId|extendedRequestId)\\b.*/.test(\n          accessLogFormat.toString(),\n        )\n      ) {\n        // TODO: Use ValidationError from core/lib/errors\n        throw new Error(\n          \"Access log must include either `AccessLogFormat.contextRequestId()` or `AccessLogFormat.contextExtendedRequestId()`\",\n        );\n      }\n      if (accessLogFormat !== undefined && accessLogDestination === undefined) {\n        // TODO: Use ValidationError from core/lib/errors\n        throw new Error(\"Access log format is specified without a destination\");\n      }\n\n      accessLogSettings = {\n        destinationArn: accessLogDestination!.bind(this).destinationArn, // accessLogDestination must be defined if format is\n        format: accessLogFormat?.toString() ?? AccessLogFormat.clf().toString(),\n      };\n    }\n\n    // enable cache cluster if cacheClusterSize is set\n    if (props.cacheClusterSize !== undefined) {\n      if (this.enableCacheCluster === undefined) {\n        this.enableCacheCluster = true;\n      } else if (this.enableCacheCluster === false) {\n        // TODO: Use ValidationError from core/lib/errors\n        throw new Error(\n          `Cannot set \"cacheClusterSize\" to ${props.cacheClusterSize} and \"cacheClusterEnabled\" to \"false\". (${this.node.path})`,\n        );\n      }\n    }\n\n    const cacheClusterSize = this.enableCacheCluster\n      ? props.cacheClusterSize || \"0.5\"\n      : undefined;\n\n    this.resource = new apiGatewayStage.ApiGatewayStage(this, \"Resource\", {\n      stageName: props.stageName || \"prod\",\n      accessLogSettings,\n      cacheClusterEnabled: this.enableCacheCluster,\n      cacheClusterSize,\n      clientCertificateId: props.clientCertificateId,\n      deploymentId: props.deployment.deploymentId,\n      restApiId: props.deployment.api.restApiId,\n      description: props.description,\n      documentationVersion: props.documentationVersion,\n      variables: props.variables,\n      xrayTracingEnabled: props.tracingEnabled,\n    });\n\n    this.stageName = this.resource.stageName;\n\n    this.applyMethodSettings(props, this.resource);\n\n    if (RestApiBase._isRestApiBase(this.restApi)) {\n      this.restApi._attachStage(this);\n    }\n  }\n\n  private applyMethodSettings(\n    props: StageProps,\n    stageResource: apiGatewayStage.ApiGatewayStage,\n  ): void {\n    const commonMethodOptions: MethodDeploymentOptions = {\n      metricsEnabled: props.metricsEnabled,\n      loggingLevel: props.loggingLevel,\n      dataTraceEnabled: props.dataTraceEnabled,\n      throttlingBurstLimit: props.throttlingBurstLimit,\n      throttlingRateLimit: props.throttlingRateLimit,\n      cachingEnabled: props.cachingEnabled,\n      cacheTtl: props.cacheTtl,\n      cacheDataEncrypted: props.cacheDataEncrypted,\n    };\n\n    const hasCommonOptions = Object.values(commonMethodOptions).some(\n      (v) => v !== undefined,\n    );\n    if (hasCommonOptions) {\n      this.createMethodSettingsResource(\n        \"/*/*\",\n        commonMethodOptions,\n        stageResource,\n      );\n    }\n\n    if (props.methodOptions) {\n      for (const path of Object.keys(props.methodOptions)) {\n        this.createMethodSettingsResource(\n          path,\n          props.methodOptions[path],\n          stageResource,\n        );\n      }\n    }\n  }\n\n  private createMethodSettingsResource(\n    path: string,\n    options: MethodDeploymentOptions,\n    stageRes: apiGatewayStage.ApiGatewayStage,\n  ): void {\n    // Validation for caching already happened in constructor before ApiGatewayStage creation\n\n    const { httpMethod, resourcePath } = parseMethodOptionsPath(path);\n\n    // Sanitize the ID for the method settings resource\n    // Replace non-alphanumeric characters with hyphen, ensure it's a valid TF ID part\n    const safePathForId = resourcePath\n      .replace(/[^a-zA-Z0-9_]/g, \"-\")\n      .replace(/^-+|-+$/g, \"\");\n    const methodSettingsId = `MethodSettings-${safePathForId || \"Root\"}`;\n\n    new apiGatewayMethodSettings.ApiGatewayMethodSettings(\n      this,\n      methodSettingsId,\n      {\n        restApiId: stageRes.restApiId,\n        stageName: stageRes.stageName,\n        methodPath: `${resourcePath}/${httpMethod}`,\n        settings: {\n          metricsEnabled: options.metricsEnabled,\n          loggingLevel: options.loggingLevel,\n          dataTraceEnabled: options.dataTraceEnabled,\n          throttlingBurstLimit: options.throttlingBurstLimit,\n          throttlingRateLimit: options.throttlingRateLimit,\n          cachingEnabled: options.cachingEnabled,\n          cacheTtlInSeconds: options.cacheTtl?.toSeconds(),\n          cacheDataEncrypted: options.cacheDataEncrypted,\n        },\n      },\n    );\n  }\n}\n"]}

package/lib/aws/compute/state-graph.js

@@ -173,5 +173,5 @@ class StateGraph {
 }
 exports.StateGraph = StateGraph;
 _a = JSII_RTTI_SYMBOL_1;
-StateGraph[_a] = { fqn: "terraconstructs.aws.compute.StateGraph", version: "0.0.25" };
+StateGraph[_a] = { fqn: "terraconstructs.aws.compute.StateGraph", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-graph.js","sourceRoot":"","sources":["../../../src/aws/compute/state-graph.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/state-graph.ts\nimport { StateMachine } from \"./state-machine\";\nimport { Duration } from \"../..\";\nimport * as iam from \"../iam\";\nimport { DistributedMap } from \"./states/distributed-map\";\nimport { State } from \"./states/state\";\n\n/**\n * A collection of connected states\n *\n * A StateGraph is used to keep track of all states that are connected (have\n * transitions between them). It does not include the substatemachines in\n * a Parallel's branches: those are their own StateGraphs, but the graphs\n * themselves have a hierarchical relationship as well.\n *\n * By assigning states to a definitive StateGraph, we verify that no state\n * machines are constructed. In particular:\n *\n * - Every state object can only ever be in 1 StateGraph, and not inadvertently\n *   be used in two graphs.\n * - Every stateId must be unique across all states in the entire state\n *   machine.\n *\n * All policy statements in all states in all substatemachines are bubbled so\n * that the top-level StateMachine instantiation can read them all and add\n * them to the IAM Role.\n *\n * You do not need to instantiate this class; it is used internally.\n */\nexport class StateGraph {\n  /**\n   * Set a timeout to render into the graph JSON.\n   *\n   * Read/write. Only makes sense on the top-level graph, subgraphs\n   * do not support this feature.\n   *\n   * @default No timeout\n   */\n  public timeout?: Duration;\n\n  /**\n   * The accumulated policy statements\n   */\n  public readonly policyStatements = new Array<iam.PolicyStatement>();\n\n  /**\n   * All states in this graph\n   */\n  private readonly allStates = new Set<State>();\n\n  /**\n   * A mapping of stateId -> Graph for all states in this graph and subgraphs\n   */\n  private readonly allContainedStates = new Map<string, StateGraph>();\n\n  /**\n   * Containing graph of this graph\n   */\n  private superGraph?: StateGraph;\n\n  /**\n   * @param startState state that gets executed when the state machine is launched\n   * @param graphDescription description of the state machine\n   */\n  constructor(\n    public readonly startState: State,\n    private readonly graphDescription: string,\n  ) {\n    this.allStates.add(startState);\n    startState.bindToGraph(this);\n  }\n\n  /**\n   * Register a state as part of this graph\n   *\n   * Called by State.bindToGraph().\n   */\n  public registerState(state: State) {\n    this.registerContainedState(state.stateId, this);\n    this.allStates.add(state);\n  }\n\n  /**\n   * Register a Policy Statement used by states in this graph\n   */\n  public registerPolicyStatement(statement: iam.PolicyStatement) {\n    if (this.superGraph) {\n      this.superGraph.registerPolicyStatement(statement);\n    } else {\n      this.policyStatements.push(statement);\n    }\n  }\n\n  /**\n   * Register this graph as a child of the given graph\n   *\n   * Resource changes will be bubbled up to the given graph.\n   */\n  public registerSuperGraph(graph: StateGraph) {\n    if (this.superGraph === graph) {\n      return;\n    }\n    if (this.superGraph) {\n      throw new Error(\n        \"Every StateGraph can only be registered into one other StateGraph\",\n      );\n    }\n    this.superGraph = graph;\n    this.pushContainedStatesUp(graph);\n    this.pushPolicyStatementsUp(graph);\n  }\n\n  /**\n   * Return the Amazon States Language JSON for this graph\n   */\n  public toGraphJson(): object {\n    const states: any = {};\n    for (const state of this.allStates) {\n      states[state.stateId] = state.toStateJson();\n    }\n\n    return {\n      StartAt: this.startState.stateId,\n      States: states,\n      TimeoutSeconds: this.timeout && this.timeout.toSeconds(),\n    };\n  }\n\n  /**\n   * Return a string description of this graph\n   */\n  public toString() {\n    const someNodes = Array.from(this.allStates)\n      .slice(0, 3)\n      .map((x) => x.stateId);\n    if (this.allStates.size > 3) {\n      someNodes.push(\"...\");\n    }\n    return `${this.graphDescription} (${someNodes.join(\", \")})`;\n  }\n\n  /**\n   * Register a stateId and graph where it was registered\n   */\n  private registerContainedState(stateId: string, graph: StateGraph) {\n    if (this.superGraph) {\n      this.superGraph.registerContainedState(stateId, graph);\n    } else {\n      const existingGraph = this.allContainedStates.get(stateId);\n      if (existingGraph) {\n        throw new Error(\n          `State with name '${stateId}' occurs in both ${graph} and ${existingGraph}. All states must have unique names.`,\n        );\n      }\n\n      this.allContainedStates.set(stateId, graph);\n    }\n  }\n\n  /**\n   * Push all contained state info up to the given super graph\n   */\n  private pushContainedStatesUp(superGraph: StateGraph) {\n    for (const [stateId, graph] of this.allContainedStates) {\n      superGraph.registerContainedState(stateId, graph);\n    }\n  }\n\n  /**\n   * Push all policy statements to into the given super graph\n   */\n  private pushPolicyStatementsUp(superGraph: StateGraph) {\n    for (const policyStatement of this.policyStatements) {\n      superGraph.registerPolicyStatement(policyStatement);\n    }\n  }\n\n  /**\n   * Binds this StateGraph to the StateMachine it defines and updates state machine permissions\n   */\n  public bind(stateMachine: StateMachine) {\n    for (const state of this.allStates) {\n      if (DistributedMap.isDistributedMap(state)) {\n        stateMachine.role.attachInlinePolicy(\n          new iam.Policy(stateMachine, \"DistributedMapPolicy\", {\n            document: new iam.PolicyDocument(\n              stateMachine,\n              \"DistributedMapPolicyDocument\",\n              {\n                statement: [\n                  new iam.PolicyStatement({\n                    actions: [\"states:StartExecution\"],\n                    resources: [stateMachine.stateMachineArn],\n                  }),\n                  new iam.PolicyStatement({\n                    actions: [\n                      \"states:DescribeExecution\",\n                      \"states:StopExecution\",\n                    ],\n                    resources: [`${stateMachine.stateMachineArn}:*`],\n                  }),\n                ],\n              },\n            ),\n          }),\n        );\n\n        break;\n      }\n    }\n  }\n}\n"]}

package/lib/aws/compute/state-machine-fragment.js

@@ -52,5 +52,5 @@ class StateMachineFragment extends constructs_1.Construct {
 }
 exports.StateMachineFragment = StateMachineFragment;
 _a = JSII_RTTI_SYMBOL_1;
-StateMachineFragment[_a] = { fqn: "terraconstructs.aws.compute.StateMachineFragment", version: "0.0.25" };
+StateMachineFragment[_a] = { fqn: "terraconstructs.aws.compute.StateMachineFragment", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/state-machine.js

@@ -303,7 +303,7 @@ class StateMachine extends StateMachineBase {
 }
 exports.StateMachine = StateMachine;
 _a = JSII_RTTI_SYMBOL_1;
-StateMachine[_a] = { fqn: "terraconstructs.aws.compute.StateMachine", version: "0.0.25" };
+StateMachine[_a] = { fqn: "terraconstructs.aws.compute.StateMachine", version: "0.1.0" };
 class DefinitionBody {
     static fromString(definition) {
         return new StringDefinitionBody(definition);
@@ -314,7 +314,7 @@ class DefinitionBody {
 }
 exports.DefinitionBody = DefinitionBody;
 _b = JSII_RTTI_SYMBOL_1;
-DefinitionBody[_b] = { fqn: "terraconstructs.aws.compute.DefinitionBody", version: "0.0.25" };
+DefinitionBody[_b] = { fqn: "terraconstructs.aws.compute.DefinitionBody", version: "0.1.0" };
 class StringDefinitionBody extends DefinitionBody {
     constructor(body) {
         super();
@@ -328,7 +328,7 @@ class StringDefinitionBody extends DefinitionBody {
 }
 exports.StringDefinitionBody = StringDefinitionBody;
 _c = JSII_RTTI_SYMBOL_1;
-StringDefinitionBody[_c] = { fqn: "terraconstructs.aws.compute.StringDefinitionBody", version: "0.0.25" };
+StringDefinitionBody[_c] = { fqn: "terraconstructs.aws.compute.StringDefinitionBody", version: "0.1.0" };
 class ChainDefinitionBody extends DefinitionBody {
     constructor(chainable) {
         super();
@@ -346,7 +346,7 @@ class ChainDefinitionBody extends DefinitionBody {
 }
 exports.ChainDefinitionBody = ChainDefinitionBody;
 _d = JSII_RTTI_SYMBOL_1;
-ChainDefinitionBody[_d] = { fqn: "terraconstructs.aws.compute.ChainDefinitionBody", version: "0.0.25" };
+ChainDefinitionBody[_d] = { fqn: "terraconstructs.aws.compute.ChainDefinitionBody", version: "0.1.0" };
 /**
  * Two types of state machines are available in AWS Step Functions: EXPRESS AND STANDARD.
  *

package/lib/aws/compute/states/choice.js

@@ -65,7 +65,7 @@ class Choice extends state_1.State {
 }
 exports.Choice = Choice;
 _a = JSII_RTTI_SYMBOL_1;
-Choice[_a] = { fqn: "terraconstructs.aws.compute.Choice", version: "0.0.25" };
+Choice[_a] = { fqn: "terraconstructs.aws.compute.Choice", version: "0.1.0" };
 /**
  * Adapter to make the .otherwise() transition settable through .next()
  */

package/lib/aws/compute/states/custom-state.js

@@ -110,5 +110,5 @@ class CustomState extends state_1.State {
 }
 exports.CustomState = CustomState;
 _a = JSII_RTTI_SYMBOL_1;
-CustomState[_a] = { fqn: "terraconstructs.aws.compute.CustomState", version: "0.0.25" };
+CustomState[_a] = { fqn: "terraconstructs.aws.compute.CustomState", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-state.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/custom-state.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/custom-state.ts\n\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Chain } from \"..\";\nimport { State } from \"./state\";\nimport { CatchProps, IChainable, INextable, RetryProps } from \"../types\";\n\n/**\n * Properties for defining a custom state definition\n */\nexport interface CustomStateProps {\n  /**\n   * Amazon States Language (JSON-based) definition of the state\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html\n   */\n  readonly stateJson: { [key: string]: any };\n}\n\n/**\n * State defined by supplying Amazon States Language (ASL) in the state machine.\n *\n */\nexport class CustomState extends State implements IChainable, INextable {\n  public readonly endStates: INextable[];\n\n  /**\n   * Amazon States Language (JSON-based) definition of the state\n   */\n  private readonly stateJson: { [key: string]: any };\n\n  constructor(scope: Construct, id: string, props: CustomStateProps) {\n    super(scope, id, {});\n\n    this.endStates = [this];\n    this.stateJson = props.stateJson;\n  }\n\n  /**\n   * Add retry configuration for this state\n   *\n   * This controls if and how the execution will be retried if a particular\n   * error occurs.\n   */\n  public addRetry(props: RetryProps = {}): CustomState {\n    super._addRetry(props);\n    return this;\n  }\n\n  /**\n   * Add a recovery handler for this state\n   *\n   * When a particular error occurs, execution will continue at the error\n   * handler instead of failing the state machine execution.\n   */\n  public addCatch(handler: IChainable, props: CatchProps = {}): CustomState {\n    super._addCatch(handler.startState, props);\n    return this;\n  }\n\n  /**\n   * Continue normal execution with the given state\n   */\n  public next(next: IChainable): Chain {\n    super.makeNext(next.startState);\n    return Chain.sequence(this, next);\n  }\n\n  /**\n   * Returns the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    const state = {\n      ...this.renderNextEnd(),\n      ...this.stateJson,\n      ...this.renderRetryCatch(),\n    };\n\n    if (this.hasMultipleRetrySources(state)) {\n      this.addMultipleRetrySourcesWarning();\n    }\n\n    if (this.hasMultipleCatchSources(state)) {\n      this.addMultipleCatchSourcesWarning();\n    }\n\n    // Retriers and Catchers can be specified directly in the stateJson or indirectly to the construct with addRetry() and addCatch().\n    // renderRetryCatch() only renders the indirectly supplied Retriers and Catchers, so we need to manually merge in those directly in the stateJson\n    if (Array.isArray(this.stateJson.Retry)) {\n      state.Retry = Array.isArray(state.Retry)\n        ? [...state.Retry, ...this.stateJson.Retry]\n        : [...this.stateJson.Retry];\n    }\n\n    if (Array.isArray(this.stateJson.Catch)) {\n      state.Catch = Array.isArray(state.Catch)\n        ? [...state.Catch, ...this.stateJson.Catch]\n        : [...this.stateJson.Catch];\n    }\n\n    return state;\n  }\n\n  private hasMultipleRetrySources(state: any): boolean {\n    if (!Array.isArray(state.Retry)) {\n      return false;\n    }\n\n    if (!Array.isArray(this.stateJson.Retry)) {\n      return false;\n    }\n\n    return state.Retry.length > 0 && this.stateJson.Retry.length > 0;\n  }\n\n  private hasMultipleCatchSources(state: any): boolean {\n    if (!Array.isArray(state.Catch)) {\n      return false;\n    }\n\n    if (!Array.isArray(this.stateJson.Catch)) {\n      return false;\n    }\n\n    return state.Catch.length > 0 && this.stateJson.Catch.length > 0;\n  }\n\n  private addMultipleRetrySourcesWarning(): void {\n    // \"@aws-cdk/aws-stepfunctions:multipleRetrySources\", // TODO: CDKTF does not support acknowledgeable warnings\n    Annotations.of(this).addWarning(\n      [\n        \"CustomState constructs can configure state retries using the stateJson property or by using the addRetry() function.\",\n        \"When retries are configured using both of these, the state definition's Retry field is generated \",\n        \"by first rendering retries from addRetry(), then rendering retries from the stateJson.\",\n      ].join(\"\\n\"),\n    );\n  }\n\n  private addMultipleCatchSourcesWarning(): void {\n    // \"@aws-cdk/aws-stepfunctions:multipleCatchSources\", // TODO: CDKTF does not support acknowledgeable warnings\n    Annotations.of(this).addWarning(\n      [\n        \"CustomState constructs can configure state catchers using the stateJson property or by using the addCatch() function.\",\n        \"When catchers are configured using both of these, the state definition's Catch field is generated \",\n        \"by first rendering catchers from addCatch(), then rendering catchers from the stateJson.\",\n      ].join(\"\\n\"),\n    );\n  }\n}\n"]}

package/lib/aws/compute/states/distributed-map/item-batcher.js

@@ -54,5 +54,5 @@ class ItemBatcher {
 }
 exports.ItemBatcher = ItemBatcher;
 _a = JSII_RTTI_SYMBOL_1;
-ItemBatcher[_a] = { fqn: "terraconstructs.aws.compute.ItemBatcher", version: "0.0.25" };
+ItemBatcher[_a] = { fqn: "terraconstructs.aws.compute.ItemBatcher", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/states/distributed-map/item-reader.js

@@ -77,7 +77,7 @@ class S3ObjectsItemReader {
 }
 exports.S3ObjectsItemReader = S3ObjectsItemReader;
 _a = JSII_RTTI_SYMBOL_1;
-S3ObjectsItemReader[_a] = { fqn: "terraconstructs.aws.compute.S3ObjectsItemReader", version: "0.0.25" };
+S3ObjectsItemReader[_a] = { fqn: "terraconstructs.aws.compute.S3ObjectsItemReader", version: "0.1.0" };
 /**
  * Base Item Reader configuration for iterating over entries in a S3 file
  */
@@ -172,7 +172,7 @@ class S3JsonItemReader extends S3FileItemReader {
 }
 exports.S3JsonItemReader = S3JsonItemReader;
 _b = JSII_RTTI_SYMBOL_1;
-S3JsonItemReader[_b] = { fqn: "terraconstructs.aws.compute.S3JsonItemReader", version: "0.0.25" };
+S3JsonItemReader[_b] = { fqn: "terraconstructs.aws.compute.S3JsonItemReader", version: "0.1.0" };
 /**
  * CSV header location options
  */
@@ -213,7 +213,7 @@ class CsvHeaders {
 }
 exports.CsvHeaders = CsvHeaders;
 _c = JSII_RTTI_SYMBOL_1;
-CsvHeaders[_c] = { fqn: "terraconstructs.aws.compute.CsvHeaders", version: "0.0.25" };
+CsvHeaders[_c] = { fqn: "terraconstructs.aws.compute.CsvHeaders", version: "0.1.0" };
 /**
  * Item Reader configuration for iterating over items in a CSV file stored in S3
  */
@@ -237,7 +237,7 @@ class S3CsvItemReader extends S3FileItemReader {
 }
 exports.S3CsvItemReader = S3CsvItemReader;
 _d = JSII_RTTI_SYMBOL_1;
-S3CsvItemReader[_d] = { fqn: "terraconstructs.aws.compute.S3CsvItemReader", version: "0.0.25" };
+S3CsvItemReader[_d] = { fqn: "terraconstructs.aws.compute.S3CsvItemReader", version: "0.1.0" };
 /**
  * Item Reader configuration for iterating over items in a S3 inventory manifest file stored in S3
  */
@@ -249,5 +249,5 @@ class S3ManifestItemReader extends S3FileItemReader {
 }
 exports.S3ManifestItemReader = S3ManifestItemReader;
 _e = JSII_RTTI_SYMBOL_1;
-S3ManifestItemReader[_e] = { fqn: "terraconstructs.aws.compute.S3ManifestItemReader", version: "0.0.25" };
+S3ManifestItemReader[_e] = { fqn: "terraconstructs.aws.compute.S3ManifestItemReader", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item-reader.js","sourceRoot":"","sources":["../../../../../src/aws/compute/states/distributed-map/item-reader.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/item-reader.ts\n\nimport { Construct } from \"constructs\";\nimport { Arn, ArnFormat, AwsStack } from \"../../..\";\nimport * as iam from \"../../../iam\";\nimport { IBucket } from \"../../../storage\";\nimport { FieldUtils } from \"../../fields\";\n\n/**\n * Base interface for Item Reader configurations\n */\nexport interface IItemReader {\n  /**\n   * S3 Bucket containing objects to iterate over or a file with a list to iterate over\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * The Amazon S3 API action that Step Functions must invoke depending on the specified dataset.\n   */\n  readonly resource: string;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - Distributed Map state will iterate over all items provided by the ItemReader\n   */\n  readonly maxItems?: number;\n\n  /**\n   * Render the ItemReader as JSON object\n   */\n  render(): any;\n\n  /**\n   * Compile policy statements to provide relevent permissions to the state machine\n   */\n  providePolicyStatements(): iam.PolicyStatement[];\n\n  /**\n   * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath\n   */\n  validateItemReader(): string[];\n}\n\n/**\n * Base interface for Item Reader configuration properties\n */\nexport interface ItemReaderProps {\n  /**\n   * S3 Bucket containing objects to iterate over or a file with a list to iterate over\n   *\n   * @default - S3 bucket will be determined from @see bucketNamePath\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   *\n   * @default - S3 bucket will be determined from @see bucket\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * S3 bucket name scope, only required if @see bucketNamePath is provided\n   */\n  readonly bucketNameScope?: Construct;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - Distributed Map state will iterate over all items provided by the ItemReader\n   */\n  readonly maxItems?: number;\n}\n\n/**\n * Properties for configuring an Item Reader that iterates over objects in an S3 bucket\n */\nexport interface S3ObjectsItemReaderProps extends ItemReaderProps {\n  /**\n   * S3 prefix used to limit objects to iterate over\n   *\n   * @default - No prefix\n   */\n  readonly prefix?: string;\n}\n\n/**\n * Item Reader configuration for iterating over objects in an S3 bucket\n */\nexport class S3ObjectsItemReader implements IItemReader {\n  /**\n   * S3 Bucket containing objects to iterate over\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * ARN for the `listObjectsV2` method of the S3 API\n   * This API method is used to iterate all objects in the S3 bucket/prefix\n   */\n  readonly resource: string;\n\n  /**\n   * S3 prefix used to limit objects to iterate over\n   *\n   * @default - No prefix\n   */\n  readonly prefix?: string;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - Distributed Map state will iterate over all items provided by the ItemReader\n   */\n  readonly maxItems?: number;\n\n  /**\n   * S3 bucket name scope\n   */\n  readonly bucketNameScope?: Construct;\n  protected get partition(): string {\n    if (this.bucket) {\n      return this.bucket.env.partition;\n    }\n    if (this.bucketNameScope) {\n      return AwsStack.ofAwsConstruct(this.bucketNameScope).partition;\n    }\n    throw new Error(\"Cannot determine partition\");\n  }\n\n  constructor(props: S3ObjectsItemReaderProps) {\n    this.bucket = props.bucket;\n    this.bucketNamePath = props.bucketNamePath;\n    this.bucketNameScope = props.bucketNameScope;\n    this.prefix = props.prefix;\n    this.maxItems = props.maxItems;\n    this.resource = Arn.format({\n      region: \"\",\n      account: \"\",\n      partition: this.partition,\n      service: \"states\",\n      resource: \"s3\",\n      resourceName: \"listObjectsV2\",\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n  }\n\n  /**\n   * Renders the ItemReader configuration as JSON object\n   * @returns - JSON object\n   */\n  public render(): any {\n    return FieldUtils.renderObject({\n      Resource: this.resource,\n      ...(this.maxItems && { ReaderConfig: { MaxItems: this.maxItems } }),\n      Parameters: {\n        ...(this.bucket && { Bucket: this.bucket.bucketName }),\n        ...(this.bucketNamePath && { Bucket: this.bucketNamePath }),\n        ...(this.prefix && { Prefix: this.prefix }),\n      },\n    });\n  }\n\n  /**\n   * Compile policy statements to provide relevent permissions to the state machine\n   */\n  public providePolicyStatements(): iam.PolicyStatement[] {\n    return [\n      new iam.PolicyStatement({\n        actions: [\"s3:ListBucket\"],\n        resources: [this.bucket ? this.bucket.bucketArn : \"*\"],\n      }),\n    ];\n  }\n\n  /**\n   * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath\n   */\n  public validateItemReader(): string[] {\n    const errors: string[] = [];\n    if (this.bucket && this.bucketNamePath) {\n      errors.push(\"Provide either `bucket` or `bucketNamePath`, but not both\");\n    } else if (!this.bucket && !this.bucketNamePath) {\n      errors.push(\"Provide either `bucket` or `bucketNamePath`\");\n    }\n    return errors;\n  }\n}\n\n/**\n * Base interface for Item Reader configuration properties the iterate over entries in a S3 file\n */\nexport interface S3FileItemReaderProps extends ItemReaderProps {\n  /**\n   * Key of file stored in S3 bucket containing an array to iterate over\n   */\n  readonly key: string;\n}\n\n/**\n * Base Item Reader configuration for iterating over entries in a S3 file\n */\nabstract class S3FileItemReader implements IItemReader {\n  /**\n   * S3 Bucket containing a file with a list to iterate over\n   */\n  readonly bucket?: IBucket;\n\n  /**\n   * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath\n   */\n  readonly bucketNamePath?: string;\n\n  /**\n   * S3 key of a file with a list to iterate over\n   */\n  readonly key: string;\n\n  /**\n   * ARN for the `getObject` method of the S3 API\n   * This API method is used to iterate all objects in the S3 bucket/prefix\n   */\n  readonly resource: string;\n\n  /**\n   * Limits the number of items passed to the Distributed Map state\n   *\n   * @default - No maxItems\n   */\n  readonly maxItems?: number;\n\n  /**\n   * S3 bucket name scope\n   */\n  readonly bucketNameScope?: Construct;\n  protected get partition(): string {\n    if (this.bucket) {\n      return this.bucket.env.partition;\n    }\n    if (this.bucketNameScope) {\n      return AwsStack.ofAwsConstruct(this.bucketNameScope).partition;\n    }\n    throw new Error(\"Cannot determine partition\");\n  }\n\n  protected abstract readonly inputType: string;\n\n  constructor(props: S3FileItemReaderProps) {\n    this.bucket = props.bucket;\n    this.bucketNamePath = props.bucketNamePath;\n    this.bucketNameScope = props.bucketNameScope;\n    this.key = props.key;\n    this.maxItems = props.maxItems;\n    this.resource = Arn.format({\n      region: \"\",\n      account: \"\",\n      partition: this.partition,\n      service: \"states\",\n      resource: \"s3\",\n      resourceName: \"getObject\",\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n  }\n\n  /**\n   * Renders the ItemReader configuration as JSON object\n   * @returns - JSON object\n   */\n  public render(): any {\n    return FieldUtils.renderObject({\n      Resource: this.resource,\n      ReaderConfig: {\n        InputType: this.inputType,\n        ...(this.maxItems && { MaxItems: this.maxItems }),\n      },\n      Parameters: {\n        ...(this.bucket && { Bucket: this.bucket.bucketName }),\n        ...(this.bucketNamePath && { Bucket: this.bucketNamePath }),\n        Key: this.key,\n      },\n    });\n  }\n\n  /**\n   * Compile policy statements to provide relevent permissions to the state machine\n   */\n  public providePolicyStatements(): iam.PolicyStatement[] {\n    if (!this.bucket) return [];\n    const resource = Arn.format({\n      region: \"\",\n      account: \"\",\n      partition: this.bucket.env.partition,\n      service: \"s3\",\n      resource: this.bucket.bucketName,\n      resourceName: \"*\",\n    });\n\n    return [\n      new iam.PolicyStatement({\n        actions: [\"s3:GetObject\"],\n        resources: [resource],\n      }),\n    ];\n  }\n\n  /**\n   * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath and @see bucketNameScope\n   */\n  public validateItemReader(): string[] {\n    const errors: string[] = [];\n    if (this.bucket && (this.bucketNamePath || this.bucketNameScope)) {\n      errors.push(\n        \"Provide either `bucket` or `bucketNamePath` and `bucketNameScope`, but not both\",\n      );\n    } else if (\n      !this.bucket &&\n      (!this.bucketNamePath || !this.bucketNameScope)\n    ) {\n      errors.push(\n        \"Provide either `bucket` or `bucketNamePath` && `bucketNameScope`\",\n      );\n    }\n    return errors;\n  }\n}\n\n/**\n * Item Reader configuration for iterating over items in a JSON array stored in a S3 file\n */\nexport class S3JsonItemReader extends S3FileItemReader {\n  protected readonly inputType: string = \"JSON\";\n}\n\n/**\n * CSV header location options\n */\nexport enum CsvHeaderLocation {\n  /**\n   * Headers will be read from first row of CSV file\n   */\n  FIRST_ROW = \"FIRST_ROW\",\n\n  /**\n   * Headers are provided in CSVHeaders property\n   */\n  GIVEN = \"GIVEN\",\n}\n\n/**\n * Configuration for CSV header options for a CSV Item Reader\n */\nexport class CsvHeaders {\n  /**\n   * Configures S3CsvItemReader to read headers from the first row of the CSV file\n   * @returns - CsvHeaders\n   */\n  public static useFirstRow(): CsvHeaders {\n    return new CsvHeaders(CsvHeaderLocation.FIRST_ROW);\n  }\n\n  /**\n   * Configures S3CsvItemReader to use the headers provided in the `headers` parameter\n   * @param headers - List of headers\n   * @returns - CsvHeaders\n   */\n  public static use(headers: string[]): CsvHeaders {\n    return new CsvHeaders(CsvHeaderLocation.GIVEN, headers);\n  }\n\n  /**\n   * Location of headers in CSV file\n   */\n  public readonly headerLocation: CsvHeaderLocation;\n\n  /**\n   * List of headers if `headerLocation` is `GIVEN`\n   */\n  public readonly headers?: string[];\n\n  private constructor(headerLocation: CsvHeaderLocation, headers?: string[]) {\n    this.headerLocation = headerLocation;\n    this.headers = headers;\n  }\n}\n\n/**\n * Properties for configuring an Item Reader that iterates over items in a CSV file in S3\n */\nexport interface S3CsvItemReaderProps extends S3FileItemReaderProps {\n  /**\n   * CSV file header configuration\n   *\n   * @default - CsvHeaders with CsvHeadersLocation.FIRST_ROW\n   */\n  readonly csvHeaders?: CsvHeaders;\n}\n\n/**\n * Item Reader configuration for iterating over items in a CSV file stored in S3\n */\nexport class S3CsvItemReader extends S3FileItemReader {\n  /**\n   * CSV headers configuration\n   */\n  readonly csvHeaders: CsvHeaders;\n  protected readonly inputType: string = \"CSV\";\n\n  constructor(props: S3CsvItemReaderProps) {\n    super(props);\n    this.csvHeaders = props.csvHeaders ?? CsvHeaders.useFirstRow();\n  }\n\n  public render(): any {\n    const rendered = super.render();\n\n    rendered.ReaderConfig = FieldUtils.renderObject({\n      ...rendered.ReaderConfig,\n      ...{\n        CSVHeaderLocation: this.csvHeaders.headerLocation,\n        ...(this.csvHeaders.headers && { CSVHeaders: this.csvHeaders.headers }),\n      },\n    });\n\n    return rendered;\n  }\n}\n\n/**\n * Item Reader configuration for iterating over items in a S3 inventory manifest file stored in S3\n */\nexport class S3ManifestItemReader extends S3FileItemReader {\n  protected readonly inputType: string = \"MANIFEST\";\n}\n"]}