terraconstructs 0.0.24 → 0.1.0

package/lib/aws/storage/ecr-repository.js

@@ -0,0 +1,685 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryEncryption = exports.TagMutability = exports.Repository = exports.RepositoryBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-ecr/lib/repository.ts
+const node_os_1 = require("node:os");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const ecr_lifecycle_1 = require("./ecr-lifecycle");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const iam = require("../iam");
+const events = require("../notify");
+/**
+ * Base class for ECR repository. Reused between imported repositories and owned repositories.
+ */
+class RepositoryBase extends aws_construct_1.AwsConstructBase {
+    constructor() {
+        super(...arguments);
+        this.REPO_PULL_ACTIONS = [
+            "ecr:BatchCheckLayerAvailability",
+            "ecr:GetDownloadUrlForLayer",
+            "ecr:BatchGetImage",
+        ];
+        // https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-push.html#image-push-iam
+        this.REPO_PUSH_ACTIONS = [
+            "ecr:CompleteLayerUpload",
+            "ecr:UploadLayerPart",
+            "ecr:InitiateLayerUpload",
+            "ecr:BatchCheckLayerAvailability",
+            "ecr:PutImage",
+        ];
+    }
+    get outputs() {
+        return {
+            repositoryName: this.repositoryName,
+            repositoryArn: this.repositoryArn,
+            repositoryUri: this.repositoryUri,
+        };
+    }
+    /**
+     * The URI of this repository (represents the latest image):
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY
+     *
+     */
+    get repositoryUri() {
+        return this.repositoryUriForTag();
+    }
+    /**
+     * The URI of this repository's registry:
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com
+     *
+     */
+    get registryUri() {
+        const parts = this.stack.splitArn(this.repositoryArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        return `${parts.account}.dkr.ecr.${parts.region}.${this.stack.urlSuffix}`;
+    }
+    /**
+     * Returns the URL of the repository. Can be used in `docker push/pull`.
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]
+     *
+     * @param tag Optional image tag
+     */
+    repositoryUriForTag(tag) {
+        const tagSuffix = tag ? `:${tag}` : "";
+        return this.repositoryUriWithSuffix(tagSuffix);
+    }
+    /**
+     * Returns the URL of the repository. Can be used in `docker push/pull`.
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]
+     *
+     * @param digest Optional image digest
+     */
+    repositoryUriForDigest(digest) {
+        const digestSuffix = digest ? `@${digest}` : "";
+        return this.repositoryUriWithSuffix(digestSuffix);
+    }
+    /**
+     * Returns the URL of the repository. Can be used in `docker push/pull`.
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]
+     *
+     * @param tagOrDigest Optional image tag or digest (digests must start with `sha256:`)
+     */
+    repositoryUriForTagOrDigest(tagOrDigest) {
+        if (tagOrDigest?.startsWith("sha256:")) {
+            return this.repositoryUriForDigest(tagOrDigest);
+        }
+        else {
+            return this.repositoryUriForTag(tagOrDigest);
+        }
+    }
+    /**
+     * Returns the repository URI, with an appended suffix, if provided.
+     * @param suffix An image tag or an image digest.
+     * @private
+     */
+    repositoryUriWithSuffix(suffix) {
+        const parts = this.stack.splitArn(this.repositoryArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        return `${parts.account}.dkr.ecr.${parts.region}.${this.stack.urlSuffix}/${this.repositoryName}${suffix}`;
+    }
+    /**
+     * Define a CloudWatch event that triggers when something happens to this repository
+     *
+     * Requires that there exists at least one CloudTrail Trail in your account
+     * that captures the event. This method will not create the Trail.
+     *
+     * @param id The id of the rule
+     * @param options Options for adding the rule
+     */
+    onCloudTrailEvent(id, options = {}) {
+        const rule = new events.Rule(this, id, options);
+        rule.addTarget(options.target);
+        rule.addEventPattern({
+            source: ["aws.ecr"],
+            detailType: ["AWS API Call via CloudTrail"],
+            detail: {
+                requestParameters: {
+                    repositoryName: [this.repositoryName],
+                },
+            },
+        });
+        return rule;
+    }
+    /**
+     * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this
+     * repository.
+     *
+     * Requires that there exists at least one CloudTrail Trail in your account
+     * that captures the event. This method will not create the Trail.
+     *
+     * @param id The id of the rule
+     * @param options Options for adding the rule
+     */
+    onCloudTrailImagePushed(id, options = {}) {
+        const rule = this.onCloudTrailEvent(id, options);
+        rule.addEventPattern({
+            detail: {
+                eventName: ["PutImage"],
+                requestParameters: {
+                    imageTag: options.imageTag ? [options.imageTag] : undefined,
+                },
+            },
+        });
+        return rule;
+    }
+    /**
+     * Defines an AWS CloudWatch event rule that can trigger a target when an image scan is completed
+     *
+     *
+     * @param id The id of the rule
+     * @param options Options for adding the rule
+     */
+    onImageScanCompleted(id, options = {}) {
+        const rule = new events.Rule(this, id, options);
+        rule.addTarget(options.target);
+        rule.addEventPattern({
+            source: ["aws.ecr"],
+            detailType: ["ECR Image Scan"],
+            detail: {
+                "repository-name": [this.repositoryName],
+                "scan-status": ["COMPLETE"],
+                "image-tags": options.imageTags ?? undefined,
+            },
+        });
+        return rule;
+    }
+    /**
+     * Defines a CloudWatch event rule which triggers for repository events. Use
+     * `rule.addEventPattern(pattern)` to specify a filter.
+     */
+    onEvent(id, options = {}) {
+        const rule = new events.Rule(this, id, options);
+        rule.addEventPattern({
+            source: ["aws.ecr"],
+            detail: {
+                "repository-name": [this.repositoryName],
+            },
+        });
+        rule.addTarget(options.target);
+        return rule;
+    }
+    /**
+     * Grant the given principal identity permissions to perform the actions on this repository
+     */
+    grant(grantee, ...actions) {
+        // TODO: Implement cross-account principal logic from CDK
+        return iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions,
+            resourceArns: [this.repositoryArn],
+            resource: this,
+        });
+    }
+    /**
+     * Grant the given identity permissions to read the images in this repository
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, "ecr:DescribeRepositories", "ecr:DescribeImages");
+    }
+    /**
+     * Grant the given identity permissions to use the images in this repository
+     */
+    grantPull(grantee) {
+        const ret = this.grant(grantee, ...this.REPO_PULL_ACTIONS);
+        iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["ecr:GetAuthorizationToken"],
+            resourceArns: ["*"],
+            scope: this,
+        });
+        return ret;
+    }
+    /**
+     * Grant the given identity permissions to use the images in this repository
+     */
+    grantPush(grantee) {
+        const ret = this.grant(grantee, ...this.REPO_PUSH_ACTIONS);
+        iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["ecr:GetAuthorizationToken"],
+            resourceArns: ["*"],
+            scope: this,
+        });
+        return ret;
+    }
+    /**
+     * Grant the given identity permissions to pull and push images to this repository.
+     */
+    grantPullPush(grantee) {
+        const ret = this.grant(grantee, ...this.REPO_PULL_ACTIONS, ...this.REPO_PUSH_ACTIONS);
+        iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["ecr:GetAuthorizationToken"],
+            resourceArns: ["*"],
+            scope: this,
+        });
+        return ret;
+    }
+}
+exports.RepositoryBase = RepositoryBase;
+_a = JSII_RTTI_SYMBOL_1;
+RepositoryBase[_a] = { fqn: "terraconstructs.aws.storage.RepositoryBase", version: "0.1.0" };
+/**
+ * Define an ECR repository
+ */
+class Repository extends RepositoryBase {
+    /**
+     * Import a repository
+     */
+    static fromRepositoryAttributes(scope, id, attrs) {
+        class Import extends RepositoryBase {
+            constructor() {
+                super(...arguments);
+                this.repositoryName = attrs.repositoryName;
+                this.repositoryArn = attrs.repositoryArn;
+            }
+            addToResourcePolicy(_statement) {
+                // dropped
+                return { statementAdded: false };
+            }
+        }
+        return new Import(scope, id);
+    }
+    static fromRepositoryArn(scope, id, repositoryArn) {
+        if (cdktf_1.Token.isUnresolved(repositoryArn)) {
+            // TODO: UnscopedValidationError
+            throw new Error('"repositoryArn" is a late-bound value, and therefore "repositoryName" is required. Use `fromRepositoryAttributes` instead');
+        }
+        validateRepositoryArn();
+        const repositoryName = repositoryArn.split("/").slice(1).join("/");
+        class Import extends RepositoryBase {
+            constructor() {
+                super(...arguments);
+                this.repositoryName = repositoryName;
+                this.repositoryArn = repositoryArn;
+            }
+            addToResourcePolicy(_statement) {
+                // dropped
+                return { statementAdded: false };
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: repositoryArn,
+        });
+        function validateRepositoryArn() {
+            const splitArn = repositoryArn.split(":");
+            if (!splitArn[splitArn.length - 1].startsWith("repository/")) {
+                // TODO: UnscopedValidationError
+                throw new Error(`Repository arn should be in the format 'arn:<PARTITION>:ecr:<REGION>:<ACCOUNT>:repository/<NAME>', got ${repositoryArn}.`);
+            }
+        }
+    }
+    static fromRepositoryName(scope, id, repositoryName) {
+        class Import extends RepositoryBase {
+            constructor() {
+                super(...arguments);
+                this.repositoryName = repositoryName;
+                this.repositoryArn = Repository.arnForLocalRepository(repositoryName, scope);
+            }
+            addToResourcePolicy(_statement) {
+                // dropped
+                return { statementAdded: false };
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Returns an ECR ARN for a repository that resides in the same account/region
+     * as the current stack.
+     */
+    static arnForLocalRepository(repositoryName, scope, account) {
+        return aws_stack_1.AwsStack.ofAwsConstruct(scope).formatArn({
+            account,
+            service: "ecr",
+            resource: "repository",
+            resourceName: repositoryName,
+        });
+    }
+    static validateRepositoryName(physicalName) {
+        const repositoryName = physicalName;
+        if (!repositoryName || cdktf_1.Token.isUnresolved(repositoryName)) {
+            // the name is a late-bound value, not a defined string,
+            // so skip validation
+            return;
+        }
+        const errors = [];
+        // Rules codified from https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html
+        if (repositoryName.length < 2 || repositoryName.length > 256) {
+            errors.push("Repository name must be at least 2 and no more than 256 characters");
+        }
+        const isPatternMatch = /^(?:[a-z0-9]+(?:[._-][a-z0-9]+)*\/)*[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(repositoryName);
+        if (!isPatternMatch) {
+            errors.push("Repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, periods and forward slashes");
+        }
+        if (errors.length > 0) {
+            // TODO: UnscopedValidationError
+            throw new Error(`Invalid ECR repository name (value: ${repositoryName})${node_os_1.EOL}${errors.join(node_os_1.EOL)}`);
+        }
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.lifecycleRules = new Array();
+        const name = props.repositoryName ||
+            this.stack.uniqueResourceName(this, {
+                // TODO: Repo name can't start with a number...
+                // prefix: this.gridUUID,
+                //Repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, periods and forward slashes
+                maxLength: 256,
+                lowerCase: true,
+                allowedSpecialCharacters: "-_./",
+                separator: "-",
+            });
+        Repository.validateRepositoryName(name);
+        this.resource = new provider_aws_1.ecrRepository.EcrRepository(this, "Resource", {
+            name: name,
+            imageScanningConfiguration: props.imageScanOnPush !== undefined
+                ? { scanOnPush: props.imageScanOnPush }
+                : undefined,
+            imageTagMutability: props.imageTagMutability || undefined,
+            encryptionConfiguration: this.parseEncryption(props),
+            forceDelete: props.emptyOnDelete,
+            // TODO: implement retain policy by default?
+            // lifecycle: {
+            //   preventDestroy: props.emptyOnDelete === false,
+            // },
+        });
+        if (props.lifecycleRegistryId) {
+            // TODO: Annotations.of(this).addWarningV2(...)
+            cdktf_1.Annotations.of(this).addWarning("lifecycleRegistryId is not supported by the Terraform AWS provider and will be ignored.");
+        }
+        if (props.lifecycleRules) {
+            props.lifecycleRules.forEach(this.addLifecycleRule.bind(this));
+        }
+        this.repositoryName = this.resource.name;
+        this.repositoryArn = this.resource.arn;
+        if (props.emptyOnDelete === false && props.autoDeleteImages) {
+            // TODO: ValidationError
+            throw new Error("Cannot use 'autoDeleteImages' property on a repository without setting forceDelete to 'true'.");
+        }
+        else if (props.autoDeleteImages) {
+            // TODO: Implement Custom Resource for auto-deleting images.
+            // this.enableAutoDeleteImages();
+            cdktf_1.Annotations.of(this).addWarning("autoDeleteImages is deprecated and not implemented. Use forceDelete instead.");
+        }
+        this.node.addValidation({
+            validate: () => this.policyDocument?.validateForResourcePolicy() ?? [],
+        });
+    }
+    /**
+     * Add a policy statement to the repository's resource policy.
+     */
+    addToResourcePolicy(statement) {
+        if (statement.resources.length) {
+            // TODO: Annotations.of(this).addWarningV2('@aws-cdk/aws-ecr:noResourceStatements, ...)
+            cdktf_1.Annotations.of(this).addWarning("ECR resource policy does not allow resource statements.");
+        }
+        if (this.policyDocument === undefined) {
+            this.policyDocument = new iam.PolicyDocument(this, "PolicyDocument");
+            new provider_aws_1.ecrRepositoryPolicy.EcrRepositoryPolicy(this, "Policy", {
+                repository: this.repositoryName,
+                policy: this.policyDocument.json,
+            });
+        }
+        this.policyDocument.addStatements(statement);
+        return { statementAdded: true, policyDependable: this.policyDocument };
+    }
+    /**
+     * The URI of this repository's registry:
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com
+     *
+     */
+    get registryUri() {
+        return this.resource.registryId;
+    }
+    /**
+     * Returns the URL of the repository. Can be used in `docker push/pull`.
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]
+     *
+     * @param tag Optional image tag
+     */
+    repositoryUriForTag(tag) {
+        const tagSuffix = tag ? `:${tag}` : "";
+        return this.resource.repositoryUrl + tagSuffix;
+    }
+    /**
+     * Returns the URL of the repository. Can be used in `docker push/pull`.
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]
+     *
+     * @param digest Optional image digest
+     */
+    repositoryUriForDigest(digest) {
+        const digestSuffix = digest ? `@${digest}` : "";
+        return this.resource.repositoryUrl + digestSuffix;
+    }
+    /**
+     * Add a life cycle rule to the repository
+     *
+     * Life cycle rules automatically expire images from the repository that match
+     * certain conditions.
+     */
+    addLifecycleRule(rule) {
+        // Validate rule here so users get errors at the expected location
+        if (rule.tagStatus === undefined) {
+            rule = {
+                ...rule,
+                tagStatus: rule.tagPrefixList === undefined && rule.tagPatternList === undefined
+                    ? ecr_lifecycle_1.TagStatus.ANY
+                    : ecr_lifecycle_1.TagStatus.TAGGED,
+            };
+        }
+        if (rule.tagStatus === ecr_lifecycle_1.TagStatus.TAGGED &&
+            (rule.tagPrefixList === undefined || rule.tagPrefixList.length === 0) &&
+            (rule.tagPatternList === undefined || rule.tagPatternList.length === 0)) {
+            // TODO: ValidationError
+            throw new Error("TagStatus.Tagged requires the specification of a tagPrefixList or a tagPatternList");
+        }
+        if (rule.tagStatus !== ecr_lifecycle_1.TagStatus.TAGGED &&
+            (rule.tagPrefixList !== undefined || rule.tagPatternList !== undefined)) {
+            // TODO: ValidationError
+            throw new Error("tagPrefixList and tagPatternList can only be specified when tagStatus is set to Tagged");
+        }
+        if (rule.tagPrefixList !== undefined && rule.tagPatternList !== undefined) {
+            // TODO: ValidationError
+            throw new Error("Both tagPrefixList and tagPatternList cannot be specified together in a rule");
+        }
+        if (rule.tagPatternList !== undefined) {
+            rule.tagPatternList.forEach((pattern) => {
+                const splitPatternLength = pattern.split("*").length;
+                if (splitPatternLength > 5) {
+                    // TODO: ValidationError
+                    throw new Error(`A tag pattern cannot contain more than four wildcard characters (*), pattern: ${pattern}, counts: ${splitPatternLength - 1}`);
+                }
+            });
+        }
+        if ((rule.maxImageAge !== undefined) ===
+            (rule.maxImageCount !== undefined)) {
+            // TODO: ValidationError
+            throw new Error(`Life cycle rule must contain exactly one of 'maxImageAge' and 'maxImageCount', got: ${JSON.stringify(rule)}`);
+        }
+        if (rule.tagStatus === ecr_lifecycle_1.TagStatus.ANY &&
+            this.lifecycleRules.filter((r) => r.tagStatus === ecr_lifecycle_1.TagStatus.ANY).length >
+                0) {
+            // TODO: ValidationError
+            throw new Error("Life cycle can only have one TagStatus.Any rule");
+        }
+        this.lifecycleRules.push({ ...rule });
+    }
+    /**
+     * Render the life cycle policy object
+     */
+    renderLifecyclePolicy() {
+        if (this.lifecycleRules.length === 0) {
+            return undefined;
+        }
+        const policy = {
+            rules: this.orderedLifecycleRules().map(renderLifecycleRule),
+        };
+        return this.stack.toJsonString(policy);
+    }
+    /**
+     * Return life cycle rules with automatic ordering applied.
+     *
+     * Also applies validation of the 'any' rule.
+     */
+    orderedLifecycleRules() {
+        if (this.lifecycleRules.length === 0) {
+            return [];
+        }
+        const prioritizedRules = this.lifecycleRules.filter((r) => r.rulePriority !== undefined && r.tagStatus !== ecr_lifecycle_1.TagStatus.ANY);
+        const autoPrioritizedRules = this.lifecycleRules.filter((r) => r.rulePriority === undefined && r.tagStatus !== ecr_lifecycle_1.TagStatus.ANY);
+        const anyRules = this.lifecycleRules.filter((r) => r.tagStatus === ecr_lifecycle_1.TagStatus.ANY);
+        if (anyRules.length > 0 &&
+            anyRules[0].rulePriority !== undefined &&
+            autoPrioritizedRules.length > 0) {
+            // Supporting this is too complex for very little value. We just prohibit it.
+            // TODO: ValidationError
+            throw new Error("Cannot combine prioritized TagStatus.Any rule with unprioritized rules. Remove rulePriority from the 'Any' rule.");
+        }
+        const prios = prioritizedRules.map((r) => r.rulePriority);
+        let autoPrio = (prios.length > 0 ? Math.max(...prios) : 0) + 1;
+        const ret = new Array();
+        for (const rule of prioritizedRules
+            .concat(autoPrioritizedRules)
+            .concat(anyRules)) {
+            ret.push({
+                ...rule,
+                rulePriority: rule.rulePriority ?? autoPrio++,
+            });
+        }
+        // Do validation on the final array--might still be wrong because the user supplied all prios, but incorrectly.
+        validateAnyRuleLast(ret);
+        return ret;
+    }
+    /**
+     * Set up key properties and return the Repository encryption property from the
+     * user's configuration.
+     */
+    parseEncryption(props) {
+        // default based on whether encryptionKey is specified
+        const encryptionType = props.encryption ??
+            (props.encryptionKey
+                ? RepositoryEncryption.KMS
+                : RepositoryEncryption.AES_256);
+        // if encryption key is set, encryption must be set to KMS.
+        if (encryptionType !== RepositoryEncryption.KMS && props.encryptionKey) {
+            // TODO: ValidationError
+            throw new Error(`encryptionKey is specified, so 'encryption' must be set to KMS (value: ${encryptionType.value})`);
+        }
+        if (encryptionType === RepositoryEncryption.AES_256) {
+            return undefined;
+        }
+        if (encryptionType === RepositoryEncryption.KMS) {
+            return [
+                {
+                    encryptionType: "KMS",
+                    kmsKey: props.encryptionKey?.keyArn,
+                },
+            ];
+        }
+        // TODO: ValidationError
+        throw new Error(`Unexpected 'encryptionType': ${encryptionType}`);
+    }
+    /**
+     * Adds resource to the Terraform JSON output at Synth time.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        /**
+         * A preparing resolve might add new resources to the stack
+         */
+        const lifeCyclePolicy = this.renderLifecyclePolicy();
+        // ignore if undefined or already generated
+        if (lifeCyclePolicy && !this.node.tryFindChild("LifecyclePolicy")) {
+            new provider_aws_1.ecrLifecyclePolicy.EcrLifecyclePolicy(this, "LifecyclePolicy", {
+                repository: this.repositoryName,
+                policy: lifeCyclePolicy,
+            });
+        }
+        return {};
+    }
+}
+exports.Repository = Repository;
+_b = JSII_RTTI_SYMBOL_1;
+Repository[_b] = { fqn: "terraconstructs.aws.storage.Repository", version: "0.1.0" };
+function validateAnyRuleLast(rules) {
+    const anyRules = rules.filter((r) => r.tagStatus === ecr_lifecycle_1.TagStatus.ANY);
+    if (anyRules.length === 1) {
+        const maxPrio = Math.max(...rules.map((r) => r.rulePriority));
+        if (anyRules[0].rulePriority !== maxPrio) {
+            // TODO: UnscopedValidationError
+            throw new Error(`TagStatus.Any rule must have highest priority, has ${anyRules[0].rulePriority} which is smaller than ${maxPrio}`);
+        }
+    }
+}
+/**
+ * Render the lifecycle rule to JSON
+ */
+function renderLifecycleRule(rule) {
+    return {
+        rulePriority: rule.rulePriority,
+        description: rule.description,
+        selection: {
+            tagStatus: rule.tagStatus || ecr_lifecycle_1.TagStatus.ANY,
+            tagPrefixList: rule.tagPrefixList,
+            tagPatternList: rule.tagPatternList,
+            countType: rule.maxImageAge !== undefined
+                ? CountType.SINCE_IMAGE_PUSHED
+                : CountType.IMAGE_COUNT_MORE_THAN,
+            countNumber: rule.maxImageAge?.toDays() ?? rule.maxImageCount,
+            countUnit: rule.maxImageAge !== undefined ? "days" : undefined,
+        },
+        action: {
+            type: "expire",
+        },
+    };
+}
+/**
+ * Select images based on counts
+ */
+var CountType;
+(function (CountType) {
+    /**
+     * Set a limit on the number of images in your repository
+     */
+    CountType["IMAGE_COUNT_MORE_THAN"] = "imageCountMoreThan";
+    /**
+     * Set an age limit on the images in your repository
+     */
+    CountType["SINCE_IMAGE_PUSHED"] = "sinceImagePushed";
+})(CountType || (CountType = {}));
+/**
+ * The tag mutability setting for your repository.
+ */
+var TagMutability;
+(function (TagMutability) {
+    /**
+     * allow image tags to be overwritten.
+     */
+    TagMutability["MUTABLE"] = "MUTABLE";
+    /**
+     * all image tags within the repository will be immutable which will prevent them from being overwritten.
+     */
+    TagMutability["IMMUTABLE"] = "IMMUTABLE";
+})(TagMutability || (exports.TagMutability = TagMutability = {}));
+/**
+ * Indicates whether server-side encryption is enabled for the object, and whether that encryption is
+ * from the AWS Key Management Service (AWS KMS) or from Amazon S3 managed encryption (SSE-S3).
+ * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#SysMetadata
+ */
+class RepositoryEncryption {
+    /**
+     * @param value the string value of the encryption
+     */
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.RepositoryEncryption = RepositoryEncryption;
+_c = JSII_RTTI_SYMBOL_1;
+RepositoryEncryption[_c] = { fqn: "terraconstructs.aws.storage.RepositoryEncryption", version: "0.1.0" };
+/**
+ * 'AES256'
+ */
+RepositoryEncryption.AES_256 = new RepositoryEncryption("AES256");
+/**
+ * 'KMS'
+ */
+RepositoryEncryption.KMS = new RepositoryEncryption("KMS");
+/**
+ * 'KMS_DSSE'
+ */
+RepositoryEncryption.KMS_DSSE = new RepositoryEncryption("KMS_DSSE");
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecr-repository.js","sourceRoot":"","sources":["../../../src/aws/storage/ecr-repository.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-ecr/lib/repository.ts\n\nimport { EOL } from \"node:os\";\nimport {\n  ecrLifecyclePolicy,\n  ecrRepository,\n  ecrRepositoryPolicy,\n} from \"@cdktf/provider-aws\";\nimport { Annotations, Token } from \"cdktf\";\nimport { IConstruct, Construct } from \"constructs\";\nimport { LifecycleRule, TagStatus } from \"./ecr-lifecycle\";\nimport { ArnFormat } from \"../arn\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as encryption from \"../encryption\";\nimport * as iam from \"../iam\";\nimport * as events from \"../notify\";\n\n/**\n * Represents an ECR repository.\n */\nexport interface IRepository extends iam.IAwsConstructWithPolicy {\n  /**\n   * The name of the repository\n   * @attribute\n   */\n  readonly repositoryName: string;\n\n  /**\n   * The ARN of the repository\n   * @attribute\n   */\n  readonly repositoryArn: string;\n\n  /**\n   * The URI of this repository (represents the latest image):\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY\n   *\n   * @attribute\n   */\n  readonly repositoryUri: string;\n\n  /**\n   * The URI of this repository's registry:\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com\n   *\n   * @attribute\n   */\n  readonly registryUri: string;\n\n  /**\n   * Returns the URI of the repository for a certain tag. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]\n   *\n   * @param tag Image tag to use (tools usually default to \"latest\" if omitted)\n   */\n  repositoryUriForTag(tag?: string): string;\n\n  /**\n   * Returns the URI of the repository for a certain digest. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]\n   *\n   * @param digest Image digest to use (tools usually default to the image with the \"latest\" tag if omitted)\n   */\n  repositoryUriForDigest(digest?: string): string;\n\n  /**\n   * Returns the URI of the repository for a certain tag or digest, inferring based on the syntax of the tag. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]\n   *\n   * @param tagOrDigest Image tag or digest to use (tools usually default to the image with the \"latest\" tag if omitted)\n   */\n  repositoryUriForTagOrDigest(tagOrDigest?: string): string;\n\n  /**\n   * Grant the given identity permissions to read images in this repository.\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity permissions to pull images in this repository.\n   */\n  grantPull(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity permissions to push images in this repository.\n   */\n  grantPush(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity permissions to pull and push images to this repository.\n   */\n  grantPullPush(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Define a CloudWatch event that triggers when something happens to this repository\n   *\n   * Requires that there exists at least one CloudTrail Trail in your account\n   * that captures the event. This method will not create the Trail.\n   *\n   * @param id The id of the rule\n   * @param options Options for adding the rule\n   */\n  onCloudTrailEvent(id: string, options?: events.OnEventOptions): events.Rule;\n\n  /**\n   * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this\n   * repository.\n   *\n   * Requires that there exists at least one CloudTrail Trail in your account\n   * that captures the event. This method will not create the Trail.\n   *\n   * @param id The id of the rule\n   * @param options Options for adding the rule\n   */\n  onCloudTrailImagePushed(\n    id: string,\n    options?: OnCloudTrailImagePushedOptions,\n  ): events.Rule;\n\n  /**\n   * Defines an AWS CloudWatch event rule that can trigger a target when the image scan is completed\n   *\n   *\n   * @param id The id of the rule\n   * @param options Options for adding the rule\n   */\n  onImageScanCompleted(\n    id: string,\n    options?: OnImageScanCompletedOptions,\n  ): events.Rule;\n\n  /**\n   * Defines a CloudWatch event rule which triggers for repository events. Use\n   * `rule.addEventPattern(pattern)` to specify a filter.\n   */\n  onEvent(id: string, options?: events.OnEventOptions): events.Rule;\n}\n\n/**\n * Base class for ECR repository. Reused between imported repositories and owned repositories.\n */\nexport abstract class RepositoryBase\n  extends AwsConstructBase\n  implements IRepository\n{\n  private readonly REPO_PULL_ACTIONS: string[] = [\n    \"ecr:BatchCheckLayerAvailability\",\n    \"ecr:GetDownloadUrlForLayer\",\n    \"ecr:BatchGetImage\",\n  ];\n\n  // https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-push.html#image-push-iam\n  private readonly REPO_PUSH_ACTIONS: string[] = [\n    \"ecr:CompleteLayerUpload\",\n    \"ecr:UploadLayerPart\",\n    \"ecr:InitiateLayerUpload\",\n    \"ecr:BatchCheckLayerAvailability\",\n    \"ecr:PutImage\",\n  ];\n\n  /**\n   * The name of the repository\n   */\n  public abstract readonly repositoryName: string;\n\n  /**\n   * The ARN of the repository\n   */\n  public abstract readonly repositoryArn: string;\n\n  public get outputs(): Record<string, any> {\n    return {\n      repositoryName: this.repositoryName,\n      repositoryArn: this.repositoryArn,\n      repositoryUri: this.repositoryUri,\n    };\n  }\n\n  /**\n   * Add a policy statement to the repository's resource policy\n   */\n  public abstract addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult;\n\n  /**\n   * The URI of this repository (represents the latest image):\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY\n   *\n   */\n  public get repositoryUri() {\n    return this.repositoryUriForTag();\n  }\n\n  /**\n   * The URI of this repository's registry:\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com\n   *\n   */\n  public get registryUri(): string {\n    const parts = this.stack.splitArn(\n      this.repositoryArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n    return `${parts.account}.dkr.ecr.${parts.region}.${this.stack.urlSuffix}`;\n  }\n\n  /**\n   * Returns the URL of the repository. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]\n   *\n   * @param tag Optional image tag\n   */\n  public repositoryUriForTag(tag?: string): string {\n    const tagSuffix = tag ? `:${tag}` : \"\";\n    return this.repositoryUriWithSuffix(tagSuffix);\n  }\n\n  /**\n   * Returns the URL of the repository. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]\n   *\n   * @param digest Optional image digest\n   */\n  public repositoryUriForDigest(digest?: string): string {\n    const digestSuffix = digest ? `@${digest}` : \"\";\n    return this.repositoryUriWithSuffix(digestSuffix);\n  }\n\n  /**\n   * Returns the URL of the repository. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]\n   *\n   * @param tagOrDigest Optional image tag or digest (digests must start with `sha256:`)\n   */\n  public repositoryUriForTagOrDigest(tagOrDigest?: string): string {\n    if (tagOrDigest?.startsWith(\"sha256:\")) {\n      return this.repositoryUriForDigest(tagOrDigest);\n    } else {\n      return this.repositoryUriForTag(tagOrDigest);\n    }\n  }\n\n  /**\n   * Returns the repository URI, with an appended suffix, if provided.\n   * @param suffix An image tag or an image digest.\n   * @private\n   */\n  private repositoryUriWithSuffix(suffix?: string): string {\n    const parts = this.stack.splitArn(\n      this.repositoryArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n    return `${parts.account}.dkr.ecr.${parts.region}.${this.stack.urlSuffix}/${this.repositoryName}${suffix}`;\n  }\n\n  /**\n   * Define a CloudWatch event that triggers when something happens to this repository\n   *\n   * Requires that there exists at least one CloudTrail Trail in your account\n   * that captures the event. This method will not create the Trail.\n   *\n   * @param id The id of the rule\n   * @param options Options for adding the rule\n   */\n  public onCloudTrailEvent(\n    id: string,\n    options: events.OnEventOptions = {},\n  ): events.Rule {\n    const rule = new events.Rule(this, id, options);\n    rule.addTarget(options.target);\n    rule.addEventPattern({\n      source: [\"aws.ecr\"],\n      detailType: [\"AWS API Call via CloudTrail\"],\n      detail: {\n        requestParameters: {\n          repositoryName: [this.repositoryName],\n        },\n      },\n    });\n    return rule;\n  }\n\n  /**\n   * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this\n   * repository.\n   *\n   * Requires that there exists at least one CloudTrail Trail in your account\n   * that captures the event. This method will not create the Trail.\n   *\n   * @param id The id of the rule\n   * @param options Options for adding the rule\n   */\n  public onCloudTrailImagePushed(\n    id: string,\n    options: OnCloudTrailImagePushedOptions = {},\n  ): events.Rule {\n    const rule = this.onCloudTrailEvent(id, options);\n    rule.addEventPattern({\n      detail: {\n        eventName: [\"PutImage\"],\n        requestParameters: {\n          imageTag: options.imageTag ? [options.imageTag] : undefined,\n        },\n      },\n    });\n    return rule;\n  }\n  /**\n   * Defines an AWS CloudWatch event rule that can trigger a target when an image scan is completed\n   *\n   *\n   * @param id The id of the rule\n   * @param options Options for adding the rule\n   */\n  public onImageScanCompleted(\n    id: string,\n    options: OnImageScanCompletedOptions = {},\n  ): events.Rule {\n    const rule = new events.Rule(this, id, options);\n    rule.addTarget(options.target);\n    rule.addEventPattern({\n      source: [\"aws.ecr\"],\n      detailType: [\"ECR Image Scan\"],\n      detail: {\n        \"repository-name\": [this.repositoryName],\n        \"scan-status\": [\"COMPLETE\"],\n        \"image-tags\": options.imageTags ?? undefined,\n      },\n    });\n    return rule;\n  }\n\n  /**\n   * Defines a CloudWatch event rule which triggers for repository events. Use\n   * `rule.addEventPattern(pattern)` to specify a filter.\n   */\n  public onEvent(id: string, options: events.OnEventOptions = {}) {\n    const rule = new events.Rule(this, id, options);\n    rule.addEventPattern({\n      source: [\"aws.ecr\"],\n      detail: {\n        \"repository-name\": [this.repositoryName],\n      },\n    });\n    rule.addTarget(options.target);\n    return rule;\n  }\n\n  /**\n   * Grant the given principal identity permissions to perform the actions on this repository\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]) {\n    // TODO: Implement cross-account principal logic from CDK\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions,\n      resourceArns: [this.repositoryArn],\n      resource: this,\n    });\n  }\n\n  /**\n   * Grant the given identity permissions to read the images in this repository\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(\n      grantee,\n      \"ecr:DescribeRepositories\",\n      \"ecr:DescribeImages\",\n    );\n  }\n\n  /**\n   * Grant the given identity permissions to use the images in this repository\n   */\n  public grantPull(grantee: iam.IGrantable) {\n    const ret = this.grant(grantee, ...this.REPO_PULL_ACTIONS);\n\n    iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"ecr:GetAuthorizationToken\"],\n      resourceArns: [\"*\"],\n      scope: this,\n    });\n\n    return ret;\n  }\n\n  /**\n   * Grant the given identity permissions to use the images in this repository\n   */\n  public grantPush(grantee: iam.IGrantable) {\n    const ret = this.grant(grantee, ...this.REPO_PUSH_ACTIONS);\n    iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"ecr:GetAuthorizationToken\"],\n      resourceArns: [\"*\"],\n      scope: this,\n    });\n\n    return ret;\n  }\n\n  /**\n   * Grant the given identity permissions to pull and push images to this repository.\n   */\n  public grantPullPush(grantee: iam.IGrantable) {\n    const ret = this.grant(\n      grantee,\n      ...this.REPO_PULL_ACTIONS,\n      ...this.REPO_PUSH_ACTIONS,\n    );\n    iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"ecr:GetAuthorizationToken\"],\n      resourceArns: [\"*\"],\n      scope: this,\n    });\n\n    return ret;\n  }\n}\n\n/**\n * Options for the onCloudTrailImagePushed method\n */\nexport interface OnCloudTrailImagePushedOptions extends events.OnEventOptions {\n  /**\n   * Only watch changes to this image tag\n   *\n   * @default - Watch changes to all tags\n   */\n  readonly imageTag?: string;\n}\n\n/**\n * Options for the OnImageScanCompleted method\n */\nexport interface OnImageScanCompletedOptions extends events.OnEventOptions {\n  /**\n   * Only watch changes to the image tags specified.\n   * Leave it undefined to watch the full repository.\n   *\n   * @default - Watch the changes to the repository with all image tags\n   */\n  readonly imageTags?: string[];\n}\n\nexport interface RepositoryProps extends AwsConstructProps {\n  /**\n   * Name for this repository.\n   *\n   * The repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, and forward slashes.\n   *\n   * > If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.\n   *\n   * @default Automatically generated name.\n   */\n  readonly repositoryName?: string;\n\n  /**\n   * The kind of server-side encryption to apply to this repository.\n   *\n   * If you choose KMS, you can specify a KMS key via `encryptionKey`. If\n   * encryptionKey is not specified, an AWS managed KMS key is used.\n   *\n   * @default - `KMS` if `encryptionKey` is specified, or `AES256` otherwise.\n   */\n  readonly encryption?: RepositoryEncryption;\n\n  /**\n   * External KMS key to use for repository encryption.\n   *\n   * The 'encryption' property must be either not specified or set to \"KMS\".\n   * An error will be emitted if encryption is set to \"AES256\".\n   *\n   * @default - If encryption is set to `KMS` and this property is undefined,\n   * an AWS managed KMS key is used.\n   */\n  readonly encryptionKey?: encryption.IKey;\n\n  /**\n   * Life cycle rules to apply to this registry\n   *\n   * @default No life cycle rules\n   */\n  readonly lifecycleRules?: LifecycleRule[];\n\n  /**\n   * The AWS account ID associated with the registry that contains the repository.\n   *\n   * @see https://docs.aws.amazon.com/AmazonECR/latest/APIReference/API_PutLifecyclePolicy.html\n   * @default The default registry is assumed.\n   * @deprecated This property is not supported by the Terraform AWS provider for ECR lifecycle policies.\n   */\n  readonly lifecycleRegistryId?: string;\n\n  /**\n   * Enable the scan on push when creating the repository\n   *\n   *  @default false\n   */\n  readonly imageScanOnPush?: boolean;\n\n  /**\n   * The tag mutability setting for the repository. If this parameter is omitted, the default setting of MUTABLE will be used which will allow image tags to be overwritten.\n   *\n   *  @default TagMutability.MUTABLE\n   */\n  readonly imageTagMutability?: TagMutability;\n\n  /**\n   * Whether all images should be automatically deleted when the repository is\n   * removed from the stack or when the stack is deleted.\n   *\n   * Requires the `forceDelete` property to be set to `true`.\n   *\n   * @default false\n   * @deprecated Use `forceDelete` instead. This functionality is not implemented in TerraConstructs as it requires a custom resource.\n   */\n  readonly autoDeleteImages?: boolean;\n\n  /**\n   * If true, deleting the repository force deletes the contents of the repository. If false, the repository must be empty before attempting to delete it.\n   *\n   * @default false\n   */\n  readonly emptyOnDelete?: boolean;\n}\n\nexport interface RepositoryAttributes {\n  readonly repositoryName: string;\n  readonly repositoryArn: string;\n}\n\n/**\n * Define an ECR repository\n */\nexport class Repository extends RepositoryBase {\n  /**\n   * Import a repository\n   */\n  public static fromRepositoryAttributes(\n    scope: Construct,\n    id: string,\n    attrs: RepositoryAttributes,\n  ): IRepository {\n    class Import extends RepositoryBase {\n      public readonly repositoryName = attrs.repositoryName;\n      public readonly repositoryArn = attrs.repositoryArn;\n\n      public addToResourcePolicy(\n        _statement: iam.PolicyStatement,\n      ): iam.AddToResourcePolicyResult {\n        // dropped\n        return { statementAdded: false };\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  public static fromRepositoryArn(\n    scope: Construct,\n    id: string,\n    repositoryArn: string,\n  ): IRepository {\n    if (Token.isUnresolved(repositoryArn)) {\n      // TODO: UnscopedValidationError\n      throw new Error(\n        '\"repositoryArn\" is a late-bound value, and therefore \"repositoryName\" is required. Use `fromRepositoryAttributes` instead',\n      );\n    }\n\n    validateRepositoryArn();\n\n    const repositoryName = repositoryArn.split(\"/\").slice(1).join(\"/\");\n\n    class Import extends RepositoryBase {\n      public repositoryName = repositoryName;\n      public repositoryArn = repositoryArn;\n\n      public addToResourcePolicy(\n        _statement: iam.PolicyStatement,\n      ): iam.AddToResourcePolicyResult {\n        // dropped\n        return { statementAdded: false };\n      }\n    }\n\n    return new Import(scope, id, {\n      environmentFromArn: repositoryArn,\n    });\n\n    function validateRepositoryArn() {\n      const splitArn = repositoryArn.split(\":\");\n\n      if (!splitArn[splitArn.length - 1].startsWith(\"repository/\")) {\n        // TODO: UnscopedValidationError\n        throw new Error(\n          `Repository arn should be in the format 'arn:<PARTITION>:ecr:<REGION>:<ACCOUNT>:repository/<NAME>', got ${repositoryArn}.`,\n        );\n      }\n    }\n  }\n\n  public static fromRepositoryName(\n    scope: Construct,\n    id: string,\n    repositoryName: string,\n  ): IRepository {\n    class Import extends RepositoryBase {\n      public repositoryName = repositoryName;\n      public repositoryArn = Repository.arnForLocalRepository(\n        repositoryName,\n        scope,\n      );\n\n      public addToResourcePolicy(\n        _statement: iam.PolicyStatement,\n      ): iam.AddToResourcePolicyResult {\n        // dropped\n        return { statementAdded: false };\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Returns an ECR ARN for a repository that resides in the same account/region\n   * as the current stack.\n   */\n  public static arnForLocalRepository(\n    repositoryName: string,\n    scope: IConstruct,\n    account?: string,\n  ): string {\n    return AwsStack.ofAwsConstruct(scope).formatArn({\n      account,\n      service: \"ecr\",\n      resource: \"repository\",\n      resourceName: repositoryName,\n    });\n  }\n\n  private static validateRepositoryName(physicalName: string) {\n    const repositoryName = physicalName;\n    if (!repositoryName || Token.isUnresolved(repositoryName)) {\n      // the name is a late-bound value, not a defined string,\n      // so skip validation\n      return;\n    }\n\n    const errors: string[] = [];\n\n    // Rules codified from https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html\n    if (repositoryName.length < 2 || repositoryName.length > 256) {\n      errors.push(\n        \"Repository name must be at least 2 and no more than 256 characters\",\n      );\n    }\n    const isPatternMatch =\n      /^(?:[a-z0-9]+(?:[._-][a-z0-9]+)*\\/)*[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(\n        repositoryName,\n      );\n    if (!isPatternMatch) {\n      errors.push(\n        \"Repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, periods and forward slashes\",\n      );\n    }\n\n    if (errors.length > 0) {\n      // TODO: UnscopedValidationError\n      throw new Error(\n        `Invalid ECR repository name (value: ${repositoryName})${EOL}${errors.join(\n          EOL,\n        )}`,\n      );\n    }\n  }\n\n  public readonly repositoryName: string;\n  public readonly repositoryArn: string;\n  private readonly lifecycleRules = new Array<LifecycleRule>();\n  private policyDocument?: iam.PolicyDocument;\n  private readonly resource: ecrRepository.EcrRepository;\n\n  constructor(scope: Construct, id: string, props: RepositoryProps = {}) {\n    super(scope, id, props);\n\n    const name =\n      props.repositoryName ||\n      this.stack.uniqueResourceName(this, {\n        // TODO: Repo name can't start with a number...\n        // prefix: this.gridUUID,\n        //Repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, periods and forward slashes\n        maxLength: 256,\n        lowerCase: true,\n        allowedSpecialCharacters: \"-_./\",\n        separator: \"-\",\n      });\n    Repository.validateRepositoryName(name);\n\n    this.resource = new ecrRepository.EcrRepository(this, \"Resource\", {\n      name: name,\n      imageScanningConfiguration:\n        props.imageScanOnPush !== undefined\n          ? { scanOnPush: props.imageScanOnPush }\n          : undefined,\n      imageTagMutability: props.imageTagMutability || undefined,\n      encryptionConfiguration: this.parseEncryption(props),\n      forceDelete: props.emptyOnDelete,\n      // TODO: implement retain policy by default?\n      // lifecycle: {\n      //   preventDestroy: props.emptyOnDelete === false,\n      // },\n    });\n\n    if (props.lifecycleRegistryId) {\n      // TODO: Annotations.of(this).addWarningV2(...)\n      Annotations.of(this).addWarning(\n        \"lifecycleRegistryId is not supported by the Terraform AWS provider and will be ignored.\",\n      );\n    }\n\n    if (props.lifecycleRules) {\n      props.lifecycleRules.forEach(this.addLifecycleRule.bind(this));\n    }\n\n    this.repositoryName = this.resource.name;\n    this.repositoryArn = this.resource.arn;\n\n    if (props.emptyOnDelete === false && props.autoDeleteImages) {\n      // TODO: ValidationError\n      throw new Error(\n        \"Cannot use 'autoDeleteImages' property on a repository without setting forceDelete to 'true'.\",\n      );\n    } else if (props.autoDeleteImages) {\n      // TODO: Implement Custom Resource for auto-deleting images.\n      // this.enableAutoDeleteImages();\n      Annotations.of(this).addWarning(\n        \"autoDeleteImages is deprecated and not implemented. Use forceDelete instead.\",\n      );\n    }\n\n    this.node.addValidation({\n      validate: () => this.policyDocument?.validateForResourcePolicy() ?? [],\n    });\n  }\n\n  /**\n   * Add a policy statement to the repository's resource policy.\n   */\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (statement.resources.length) {\n      // TODO: Annotations.of(this).addWarningV2('@aws-cdk/aws-ecr:noResourceStatements, ...)\n      Annotations.of(this).addWarning(\n        \"ECR resource policy does not allow resource statements.\",\n      );\n    }\n    if (this.policyDocument === undefined) {\n      this.policyDocument = new iam.PolicyDocument(this, \"PolicyDocument\");\n      new ecrRepositoryPolicy.EcrRepositoryPolicy(this, \"Policy\", {\n        repository: this.repositoryName,\n        policy: this.policyDocument.json,\n      });\n    }\n    this.policyDocument.addStatements(statement);\n    return { statementAdded: true, policyDependable: this.policyDocument };\n  }\n\n  /**\n   * The URI of this repository's registry:\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com\n   *\n   */\n  public get registryUri(): string {\n    return this.resource.registryId;\n  }\n\n  /**\n   * Returns the URL of the repository. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]\n   *\n   * @param tag Optional image tag\n   */\n  public repositoryUriForTag(tag?: string): string {\n    const tagSuffix = tag ? `:${tag}` : \"\";\n    return this.resource.repositoryUrl + tagSuffix;\n  }\n\n  /**\n   * Returns the URL of the repository. Can be used in `docker push/pull`.\n   *\n   *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[@DIGEST]\n   *\n   * @param digest Optional image digest\n   */\n  public repositoryUriForDigest(digest?: string): string {\n    const digestSuffix = digest ? `@${digest}` : \"\";\n    return this.resource.repositoryUrl + digestSuffix;\n  }\n\n  /**\n   * Add a life cycle rule to the repository\n   *\n   * Life cycle rules automatically expire images from the repository that match\n   * certain conditions.\n   */\n  public addLifecycleRule(rule: LifecycleRule) {\n    // Validate rule here so users get errors at the expected location\n    if (rule.tagStatus === undefined) {\n      rule = {\n        ...rule,\n        tagStatus:\n          rule.tagPrefixList === undefined && rule.tagPatternList === undefined\n            ? TagStatus.ANY\n            : TagStatus.TAGGED,\n      };\n    }\n\n    if (\n      rule.tagStatus === TagStatus.TAGGED &&\n      (rule.tagPrefixList === undefined || rule.tagPrefixList.length === 0) &&\n      (rule.tagPatternList === undefined || rule.tagPatternList.length === 0)\n    ) {\n      // TODO: ValidationError\n      throw new Error(\n        \"TagStatus.Tagged requires the specification of a tagPrefixList or a tagPatternList\",\n      );\n    }\n    if (\n      rule.tagStatus !== TagStatus.TAGGED &&\n      (rule.tagPrefixList !== undefined || rule.tagPatternList !== undefined)\n    ) {\n      // TODO: ValidationError\n      throw new Error(\n        \"tagPrefixList and tagPatternList can only be specified when tagStatus is set to Tagged\",\n      );\n    }\n    if (rule.tagPrefixList !== undefined && rule.tagPatternList !== undefined) {\n      // TODO: ValidationError\n      throw new Error(\n        \"Both tagPrefixList and tagPatternList cannot be specified together in a rule\",\n      );\n    }\n    if (rule.tagPatternList !== undefined) {\n      rule.tagPatternList.forEach((pattern) => {\n        const splitPatternLength = pattern.split(\"*\").length;\n        if (splitPatternLength > 5) {\n          // TODO: ValidationError\n          throw new Error(\n            `A tag pattern cannot contain more than four wildcard characters (*), pattern: ${pattern}, counts: ${\n              splitPatternLength - 1\n            }`,\n          );\n        }\n      });\n    }\n    if (\n      (rule.maxImageAge !== undefined) ===\n      (rule.maxImageCount !== undefined)\n    ) {\n      // TODO: ValidationError\n      throw new Error(\n        `Life cycle rule must contain exactly one of 'maxImageAge' and 'maxImageCount', got: ${JSON.stringify(\n          rule,\n        )}`,\n      );\n    }\n\n    if (\n      rule.tagStatus === TagStatus.ANY &&\n      this.lifecycleRules.filter((r) => r.tagStatus === TagStatus.ANY).length >\n        0\n    ) {\n      // TODO: ValidationError\n      throw new Error(\"Life cycle can only have one TagStatus.Any rule\");\n    }\n\n    this.lifecycleRules.push({ ...rule });\n  }\n\n  /**\n   * Render the life cycle policy object\n   */\n  private renderLifecyclePolicy(): string | undefined {\n    if (this.lifecycleRules.length === 0) {\n      return undefined;\n    }\n\n    const policy = {\n      rules: this.orderedLifecycleRules().map(renderLifecycleRule),\n    };\n\n    return this.stack.toJsonString(policy);\n  }\n\n  /**\n   * Return life cycle rules with automatic ordering applied.\n   *\n   * Also applies validation of the 'any' rule.\n   */\n  private orderedLifecycleRules(): LifecycleRule[] {\n    if (this.lifecycleRules.length === 0) {\n      return [];\n    }\n\n    const prioritizedRules = this.lifecycleRules.filter(\n      (r) => r.rulePriority !== undefined && r.tagStatus !== TagStatus.ANY,\n    );\n    const autoPrioritizedRules = this.lifecycleRules.filter(\n      (r) => r.rulePriority === undefined && r.tagStatus !== TagStatus.ANY,\n    );\n    const anyRules = this.lifecycleRules.filter(\n      (r) => r.tagStatus === TagStatus.ANY,\n    );\n    if (\n      anyRules.length > 0 &&\n      anyRules[0].rulePriority !== undefined &&\n      autoPrioritizedRules.length > 0\n    ) {\n      // Supporting this is too complex for very little value. We just prohibit it.\n      // TODO: ValidationError\n      throw new Error(\n        \"Cannot combine prioritized TagStatus.Any rule with unprioritized rules. Remove rulePriority from the 'Any' rule.\",\n      );\n    }\n\n    const prios = prioritizedRules.map((r) => r.rulePriority!);\n    let autoPrio = (prios.length > 0 ? Math.max(...prios) : 0) + 1;\n\n    const ret = new Array<LifecycleRule>();\n    for (const rule of prioritizedRules\n      .concat(autoPrioritizedRules)\n      .concat(anyRules)) {\n      ret.push({\n        ...rule,\n        rulePriority: rule.rulePriority ?? autoPrio++,\n      });\n    }\n\n    // Do validation on the final array--might still be wrong because the user supplied all prios, but incorrectly.\n    validateAnyRuleLast(ret);\n    return ret;\n  }\n\n  /**\n   * Set up key properties and return the Repository encryption property from the\n   * user's configuration.\n   */\n  private parseEncryption(\n    props: RepositoryProps,\n  ): ecrRepository.EcrRepositoryEncryptionConfiguration[] | undefined {\n    // default based on whether encryptionKey is specified\n    const encryptionType =\n      props.encryption ??\n      (props.encryptionKey\n        ? RepositoryEncryption.KMS\n        : RepositoryEncryption.AES_256);\n\n    // if encryption key is set, encryption must be set to KMS.\n    if (encryptionType !== RepositoryEncryption.KMS && props.encryptionKey) {\n      // TODO: ValidationError\n      throw new Error(\n        `encryptionKey is specified, so 'encryption' must be set to KMS (value: ${encryptionType.value})`,\n      );\n    }\n\n    if (encryptionType === RepositoryEncryption.AES_256) {\n      return undefined;\n    }\n\n    if (encryptionType === RepositoryEncryption.KMS) {\n      return [\n        {\n          encryptionType: \"KMS\",\n          kmsKey: props.encryptionKey?.keyArn,\n        },\n      ];\n    }\n\n    // TODO: ValidationError\n    throw new Error(`Unexpected 'encryptionType': ${encryptionType}`);\n  }\n\n  /**\n   * Adds resource to the Terraform JSON output at Synth time.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    /**\n     * A preparing resolve might add new resources to the stack\n     */\n    const lifeCyclePolicy = this.renderLifecyclePolicy();\n    // ignore if undefined or already generated\n    if (lifeCyclePolicy && !this.node.tryFindChild(\"LifecyclePolicy\")) {\n      new ecrLifecyclePolicy.EcrLifecyclePolicy(this, \"LifecyclePolicy\", {\n        repository: this.repositoryName,\n        policy: lifeCyclePolicy,\n      });\n    }\n    return {};\n  }\n}\n\nfunction validateAnyRuleLast(rules: LifecycleRule[]) {\n  const anyRules = rules.filter((r) => r.tagStatus === TagStatus.ANY);\n  if (anyRules.length === 1) {\n    const maxPrio = Math.max(...rules.map((r) => r.rulePriority!));\n    if (anyRules[0].rulePriority !== maxPrio) {\n      // TODO: UnscopedValidationError\n      throw new Error(\n        `TagStatus.Any rule must have highest priority, has ${anyRules[0].rulePriority} which is smaller than ${maxPrio}`,\n      );\n    }\n  }\n}\n\n/**\n * Render the lifecycle rule to JSON\n */\nfunction renderLifecycleRule(rule: LifecycleRule) {\n  return {\n    rulePriority: rule.rulePriority,\n    description: rule.description,\n    selection: {\n      tagStatus: rule.tagStatus || TagStatus.ANY,\n      tagPrefixList: rule.tagPrefixList,\n      tagPatternList: rule.tagPatternList,\n      countType:\n        rule.maxImageAge !== undefined\n          ? CountType.SINCE_IMAGE_PUSHED\n          : CountType.IMAGE_COUNT_MORE_THAN,\n      countNumber: rule.maxImageAge?.toDays() ?? rule.maxImageCount,\n      countUnit: rule.maxImageAge !== undefined ? \"days\" : undefined,\n    },\n    action: {\n      type: \"expire\",\n    },\n  };\n}\n\n/**\n * Select images based on counts\n */\nenum CountType {\n  /**\n   * Set a limit on the number of images in your repository\n   */\n  IMAGE_COUNT_MORE_THAN = \"imageCountMoreThan\",\n\n  /**\n   * Set an age limit on the images in your repository\n   */\n  SINCE_IMAGE_PUSHED = \"sinceImagePushed\",\n}\n\n/**\n * The tag mutability setting for your repository.\n */\nexport enum TagMutability {\n  /**\n   * allow image tags to be overwritten.\n   */\n  MUTABLE = \"MUTABLE\",\n\n  /**\n   * all image tags within the repository will be immutable which will prevent them from being overwritten.\n   */\n  IMMUTABLE = \"IMMUTABLE\",\n}\n\n/**\n * Indicates whether server-side encryption is enabled for the object, and whether that encryption is\n * from the AWS Key Management Service (AWS KMS) or from Amazon S3 managed encryption (SSE-S3).\n * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#SysMetadata\n */\nexport class RepositoryEncryption {\n  /**\n   * 'AES256'\n   */\n  public static readonly AES_256 = new RepositoryEncryption(\"AES256\");\n  /**\n   * 'KMS'\n   */\n  public static readonly KMS = new RepositoryEncryption(\"KMS\");\n  /**\n   * 'KMS_DSSE'\n   */\n  public static readonly KMS_DSSE = new RepositoryEncryption(\"KMS_DSSE\");\n\n  /**\n   * @param value the string value of the encryption\n   */\n  protected constructor(public readonly value: string) {}\n}\n"]}