@aws-cdk/aws-ecr - npm Package Compare versions

Comparing version 0.29.0 to 0.30.0

lib/ecr.generated.js

@@ -5,3 +5,3 @@ "use strict";
 // See: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html
-// @cfn2ts:meta@ {"generated":"2019-04-24T20:52:50.819Z","fingerprint":"N67PFxR19yYitu5tfF0kuZYloDQ23OgKz720XpBZYRQ="}
+// @cfn2ts:meta@ {"generated":"2019-05-02T09:56:39.052Z","fingerprint":"N67PFxR19yYitu5tfF0kuZYloDQ23OgKz720XpBZYRQ="}
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -111,2 +111,2 @@ // tslint:disable:max-line-length | This is generated code - line lengths are difficult to control
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecr.generated.js","sourceRoot":"","sources":["ecr.generated.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// Generated from the AWS CloudFormation Resource Specification\n// See: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html\n// @cfn2ts:meta@ {\"generated\":\"2019-04-24T20:52:50.819Z\",\"fingerprint\":\"N67PFxR19yYitu5tfF0kuZYloDQ23OgKz720XpBZYRQ=\"}\n\n// tslint:disable:max-line-length | This is generated code - line lengths are difficult to control\n\nimport cdk = require('@aws-cdk/cdk');\n\n/**\n * Properties for defining a `AWS::ECR::Repository`\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html\n */\nexport interface CfnRepositoryProps {\n    /**\n     * `AWS::ECR::Repository.LifecyclePolicy`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html#cfn-ecr-repository-lifecyclepolicy\n     */\n    readonly lifecyclePolicy?: CfnRepository.LifecyclePolicyProperty | cdk.Token;\n    /**\n     * `AWS::ECR::Repository.RepositoryName`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html#cfn-ecr-repository-repositoryname\n     */\n    readonly repositoryName?: string;\n    /**\n     * `AWS::ECR::Repository.RepositoryPolicyText`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html#cfn-ecr-repository-repositorypolicytext\n     */\n    readonly repositoryPolicyText?: object | cdk.Token;\n}\n\n/**\n * Determine whether the given properties match those of a `CfnRepositoryProps`\n *\n * @param properties - the TypeScript properties of a `CfnRepositoryProps`\n *\n * @returns the result of the validation.\n */\nfunction CfnRepositoryPropsValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('lifecyclePolicy', CfnRepository_LifecyclePolicyPropertyValidator)(properties.lifecyclePolicy));\n    errors.collect(cdk.propertyValidator('repositoryName', cdk.validateString)(properties.repositoryName));\n    errors.collect(cdk.propertyValidator('repositoryPolicyText', cdk.validateObject)(properties.repositoryPolicyText));\n    return errors.wrap('supplied properties not correct for \"CfnRepositoryProps\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::ECR::Repository` resource\n *\n * @param properties - the TypeScript properties of a `CfnRepositoryProps`\n *\n * @returns the AWS CloudFormation properties of an `AWS::ECR::Repository` resource.\n */\n// @ts-ignore TS6133\nfunction cfnRepositoryPropsToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnRepositoryPropsValidator(properties).assertSuccess();\n    return {\n      LifecyclePolicy: cfnRepositoryLifecyclePolicyPropertyToCloudFormation(properties.lifecyclePolicy),\n      RepositoryName: cdk.stringToCloudFormation(properties.repositoryName),\n      RepositoryPolicyText: cdk.objectToCloudFormation(properties.repositoryPolicyText),\n    };\n}\n\n/**\n * A CloudFormation `AWS::ECR::Repository`\n *\n * @cloudformationResource AWS::ECR::Repository\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html\n */\nexport class CfnRepository extends cdk.CfnResource {\n    /**\n     * The CloudFormation resource type name for this resource class.\n     */\n    public static readonly resourceTypeName = \"AWS::ECR::Repository\";\n\n    /**\n     * @cloudformationAttribute Arn\n     */\n    public readonly repositoryArn: string;\n    public readonly repositoryName: string;\n\n    /**\n     * Create a new `AWS::ECR::Repository`.\n     *\n     * @param scope - scope in which this resource is defined\n     * @param id    - scoped id of the resource\n     * @param props - resource properties\n     */\n    constructor(scope: cdk.Construct, id: string, props?: CfnRepositoryProps) {\n        super(scope, id, { type: CfnRepository.resourceTypeName, properties: props });\n        this.repositoryArn = this.getAtt('Arn').toString();\n        this.repositoryName = this.ref.toString();\n    }\n\n    public get propertyOverrides(): CfnRepositoryProps {\n        return this.untypedPropertyOverrides;\n    }\n    protected renderProperties(properties: any): { [key: string]: any }  {\n        return cfnRepositoryPropsToCloudFormation(this.node.resolve(properties));\n    }\n}\n\nexport namespace CfnRepository {\n    /**\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecr-repository-lifecyclepolicy.html\n     */\n    export interface LifecyclePolicyProperty {\n        /**\n         * `CfnRepository.LifecyclePolicyProperty.LifecyclePolicyText`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecr-repository-lifecyclepolicy.html#cfn-ecr-repository-lifecyclepolicy-lifecyclepolicytext\n         */\n        readonly lifecyclePolicyText?: string;\n        /**\n         * `CfnRepository.LifecyclePolicyProperty.RegistryId`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecr-repository-lifecyclepolicy.html#cfn-ecr-repository-lifecyclepolicy-registryid\n         */\n        readonly registryId?: string;\n    }\n}\n\n/**\n * Determine whether the given properties match those of a `LifecyclePolicyProperty`\n *\n * @param properties - the TypeScript properties of a `LifecyclePolicyProperty`\n *\n * @returns the result of the validation.\n */\nfunction CfnRepository_LifecyclePolicyPropertyValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('lifecyclePolicyText', cdk.validateString)(properties.lifecyclePolicyText));\n    errors.collect(cdk.propertyValidator('registryId', cdk.validateString)(properties.registryId));\n    return errors.wrap('supplied properties not correct for \"LifecyclePolicyProperty\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::ECR::Repository.LifecyclePolicy` resource\n *\n * @param properties - the TypeScript properties of a `LifecyclePolicyProperty`\n *\n * @returns the AWS CloudFormation properties of an `AWS::ECR::Repository.LifecyclePolicy` resource.\n */\n// @ts-ignore TS6133\nfunction cfnRepositoryLifecyclePolicyPropertyToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnRepository_LifecyclePolicyPropertyValidator(properties).assertSuccess();\n    return {\n      LifecyclePolicyText: cdk.stringToCloudFormation(properties.lifecyclePolicyText),\n      RegistryId: cdk.stringToCloudFormation(properties.registryId),\n    };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecr.generated.js","sourceRoot":"","sources":["ecr.generated.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// Generated from the AWS CloudFormation Resource Specification\n// See: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html\n// @cfn2ts:meta@ {\"generated\":\"2019-05-02T09:56:39.052Z\",\"fingerprint\":\"N67PFxR19yYitu5tfF0kuZYloDQ23OgKz720XpBZYRQ=\"}\n\n// tslint:disable:max-line-length | This is generated code - line lengths are difficult to control\n\nimport cdk = require('@aws-cdk/cdk');\n\n/**\n * Properties for defining a `AWS::ECR::Repository`\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html\n */\nexport interface CfnRepositoryProps {\n    /**\n     * `AWS::ECR::Repository.LifecyclePolicy`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html#cfn-ecr-repository-lifecyclepolicy\n     */\n    readonly lifecyclePolicy?: CfnRepository.LifecyclePolicyProperty | cdk.Token;\n    /**\n     * `AWS::ECR::Repository.RepositoryName`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html#cfn-ecr-repository-repositoryname\n     */\n    readonly repositoryName?: string;\n    /**\n     * `AWS::ECR::Repository.RepositoryPolicyText`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html#cfn-ecr-repository-repositorypolicytext\n     */\n    readonly repositoryPolicyText?: object | cdk.Token;\n}\n\n/**\n * Determine whether the given properties match those of a `CfnRepositoryProps`\n *\n * @param properties - the TypeScript properties of a `CfnRepositoryProps`\n *\n * @returns the result of the validation.\n */\nfunction CfnRepositoryPropsValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('lifecyclePolicy', CfnRepository_LifecyclePolicyPropertyValidator)(properties.lifecyclePolicy));\n    errors.collect(cdk.propertyValidator('repositoryName', cdk.validateString)(properties.repositoryName));\n    errors.collect(cdk.propertyValidator('repositoryPolicyText', cdk.validateObject)(properties.repositoryPolicyText));\n    return errors.wrap('supplied properties not correct for \"CfnRepositoryProps\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::ECR::Repository` resource\n *\n * @param properties - the TypeScript properties of a `CfnRepositoryProps`\n *\n * @returns the AWS CloudFormation properties of an `AWS::ECR::Repository` resource.\n */\n// @ts-ignore TS6133\nfunction cfnRepositoryPropsToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnRepositoryPropsValidator(properties).assertSuccess();\n    return {\n      LifecyclePolicy: cfnRepositoryLifecyclePolicyPropertyToCloudFormation(properties.lifecyclePolicy),\n      RepositoryName: cdk.stringToCloudFormation(properties.repositoryName),\n      RepositoryPolicyText: cdk.objectToCloudFormation(properties.repositoryPolicyText),\n    };\n}\n\n/**\n * A CloudFormation `AWS::ECR::Repository`\n *\n * @cloudformationResource AWS::ECR::Repository\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecr-repository.html\n */\nexport class CfnRepository extends cdk.CfnResource {\n    /**\n     * The CloudFormation resource type name for this resource class.\n     */\n    public static readonly resourceTypeName = \"AWS::ECR::Repository\";\n\n    /**\n     * @cloudformationAttribute Arn\n     */\n    public readonly repositoryArn: string;\n    public readonly repositoryName: string;\n\n    /**\n     * Create a new `AWS::ECR::Repository`.\n     *\n     * @param scope - scope in which this resource is defined\n     * @param id    - scoped id of the resource\n     * @param props - resource properties\n     */\n    constructor(scope: cdk.Construct, id: string, props?: CfnRepositoryProps) {\n        super(scope, id, { type: CfnRepository.resourceTypeName, properties: props });\n        this.repositoryArn = this.getAtt('Arn').toString();\n        this.repositoryName = this.ref.toString();\n    }\n\n    public get propertyOverrides(): CfnRepositoryProps {\n        return this.untypedPropertyOverrides;\n    }\n    protected renderProperties(properties: any): { [key: string]: any }  {\n        return cfnRepositoryPropsToCloudFormation(this.node.resolve(properties));\n    }\n}\n\nexport namespace CfnRepository {\n    /**\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecr-repository-lifecyclepolicy.html\n     */\n    export interface LifecyclePolicyProperty {\n        /**\n         * `CfnRepository.LifecyclePolicyProperty.LifecyclePolicyText`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecr-repository-lifecyclepolicy.html#cfn-ecr-repository-lifecyclepolicy-lifecyclepolicytext\n         */\n        readonly lifecyclePolicyText?: string;\n        /**\n         * `CfnRepository.LifecyclePolicyProperty.RegistryId`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecr-repository-lifecyclepolicy.html#cfn-ecr-repository-lifecyclepolicy-registryid\n         */\n        readonly registryId?: string;\n    }\n}\n\n/**\n * Determine whether the given properties match those of a `LifecyclePolicyProperty`\n *\n * @param properties - the TypeScript properties of a `LifecyclePolicyProperty`\n *\n * @returns the result of the validation.\n */\nfunction CfnRepository_LifecyclePolicyPropertyValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('lifecyclePolicyText', cdk.validateString)(properties.lifecyclePolicyText));\n    errors.collect(cdk.propertyValidator('registryId', cdk.validateString)(properties.registryId));\n    return errors.wrap('supplied properties not correct for \"LifecyclePolicyProperty\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::ECR::Repository.LifecyclePolicy` resource\n *\n * @param properties - the TypeScript properties of a `LifecyclePolicyProperty`\n *\n * @returns the AWS CloudFormation properties of an `AWS::ECR::Repository.LifecyclePolicy` resource.\n */\n// @ts-ignore TS6133\nfunction cfnRepositoryLifecyclePolicyPropertyToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnRepository_LifecyclePolicyPropertyValidator(properties).assertSuccess();\n    return {\n      LifecyclePolicyText: cdk.stringToCloudFormation(properties.lifecyclePolicyText),\n      RegistryId: cdk.stringToCloudFormation(properties.registryId),\n    };\n}\n"]}

lib/index.d.ts

 export * from './ecr.generated';
 export * from './repository';
-export * from './repository-ref';
 export * from './lifecycle';

lib/index.js

@@ -9,4 +9,3 @@ "use strict";
 __export(require("./repository"));
-__export(require("./repository-ref"));
 __export(require("./lifecycle"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHFDQUFxQztBQUNyQyxxQ0FBZ0M7QUFFaEMsa0NBQTZCO0FBQzdCLHNDQUFpQztBQUNqQyxpQ0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBBV1M6OkVDUiBDbG91ZEZvcm1hdGlvbiBSZXNvdXJjZXM6XG5leHBvcnQgKiBmcm9tICcuL2Vjci5nZW5lcmF0ZWQnO1xuXG5leHBvcnQgKiBmcm9tICcuL3JlcG9zaXRvcnknO1xuZXhwb3J0ICogZnJvbSAnLi9yZXBvc2l0b3J5LXJlZic7XG5leHBvcnQgKiBmcm9tICcuL2xpZmVjeWNsZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHFDQUFxQztBQUNyQyxxQ0FBZ0M7QUFFaEMsa0NBQTZCO0FBQzdCLGlDQUE0QiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEFXUzo6RUNSIENsb3VkRm9ybWF0aW9uIFJlc291cmNlczpcbmV4cG9ydCAqIGZyb20gJy4vZWNyLmdlbmVyYXRlZCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vcmVwb3NpdG9yeSc7XG5leHBvcnQgKiBmcm9tICcuL2xpZmVjeWNsZSc7XG4iXX0=

lib/repository.d.ts

@@ -0,5 +1,149 @@
+import events = require('@aws-cdk/aws-events');
 import iam = require('@aws-cdk/aws-iam');
-import { Construct } from '@aws-cdk/cdk';
+import { Construct, IConstruct, IResource, Resource } from '@aws-cdk/cdk';
 import { LifecycleRule } from './lifecycle';
-import { RepositoryBase, RepositoryImportProps } from "./repository-ref";
+/**
+ * Represents an ECR repository.
+ */
+export interface IRepository extends IResource {
+    /**
+     * The name of the repository
+     */
+    readonly repositoryName: string;
+    /**
+     * The ARN of the repository
+     */
+    readonly repositoryArn: string;
+    /**
+     * The URI of this repository (represents the latest image):
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY
+     *
+     */
+    readonly repositoryUri: string;
+    /**
+     * Returns the URI of the repository for a certain tag. Can be used in `docker push/pull`.
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY[:TAG]
+     *
+     * @param tag Image tag to use (tools usually default to "latest" if omitted)
+     */
+    repositoryUriForTag(tag?: string): string;
+    /**
+     * Add a policy statement to the repository's resource policy
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): void;
+    /**
+     * Grant the given principal identity permissions to perform the actions on this repository
+     */
+    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Grant the given identity permissions to pull images in this repository.
+     */
+    grantPull(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to pull and push images to this repository.
+     */
+    grantPullPush(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this
+     * repository.
+     * @param name The name of the rule
+     * @param target An IEventRuleTarget to invoke when this event happens (you can add more targets using `addTarget`)
+     * @param imageTag Only trigger on the specific image tag
+     */
+    onImagePushed(name: string, target?: events.IEventRuleTarget, imageTag?: string): events.EventRule;
+    /**
+     * Export this repository from the stack
+     */
+    export(): RepositoryImportProps;
+}
+export interface RepositoryImportProps {
+    /**
+     * The ARN of the repository to import.
+     *
+     * At least one of `repositoryArn` or `repositoryName` is required.
+     *
+     * @default If you only have a repository name and the repository is in the same
+     * account/region as the current stack, you can set `repositoryName` instead
+     * and the ARN will be formatted with the current region and account.
+     */
+    readonly repositoryArn?: string;
+    /**
+     * The full name of the repository to import.
+     *
+     * This is only needed if the repository ARN is not a concrete string, in which
+     * case it is impossible to safely parse the ARN and extract full repository
+     * names from it if it includes multiple components (e.g. `foo/bar/myrepo`).
+     *
+     * If the repository is in the same region/account as the stack, it is sufficient
+     * to only specify the repository name.
+     */
+    readonly repositoryName?: string;
+}
+/**
+ * Base class for ECR repository. Reused between imported repositories and owned repositories.
+ */
+export declare abstract class RepositoryBase extends Resource implements IRepository {
+    /**
+     * Import a repository
+     */
+    static import(scope: Construct, id: string, props: RepositoryImportProps): IRepository;
+    /**
+     * Returns an ECR ARN for a repository that resides in the same account/region
+     * as the current stack.
+     */
+    static arnForLocalRepository(repositoryName: string, scope: IConstruct): string;
+    /**
+     * The name of the repository
+     */
+    abstract readonly repositoryName: string;
+    /**
+     * The ARN of the repository
+     */
+    abstract readonly repositoryArn: string;
+    /**
+     * Add a policy statement to the repository's resource policy
+     */
+    abstract addToResourcePolicy(statement: iam.PolicyStatement): void;
+    /**
+     * The URI of this repository (represents the latest image):
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY
+     *
+     */
+    readonly repositoryUri: string;
+    /**
+     * 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?: string): string;
+    /**
+     * Export this repository from the stack
+     */
+    abstract export(): RepositoryImportProps;
+    /**
+     * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this
+     * repository.
+     * @param name The name of the rule
+     * @param target An IEventRuleTarget to invoke when this event happens (you can add more targets using `addTarget`)
+     * @param imageTag Only trigger on the specific image tag
+     */
+    onImagePushed(name: string, target?: events.IEventRuleTarget, imageTag?: string): events.EventRule;
+    /**
+     * Grant the given principal identity permissions to perform the actions on this repository
+     */
+    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Grant the given identity permissions to use the images in this repository
+     */
+    grantPull(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to pull and push images to this repository.
+     */
+    grantPullPush(grantee: iam.IGrantable): iam.Grant;
+}
 export interface RepositoryProps {
@@ -6,0 +150,0 @@ /**

lib/repository.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const events = require("@aws-cdk/aws-events");
 const iam = require("@aws-cdk/aws-iam");
@@ -7,7 +8,144 @@ const cdk_1 = require("@aws-cdk/cdk");
 const lifecycle_1 = require("./lifecycle");
-const repository_ref_1 = require("./repository-ref");
 /**
+ * Base class for ECR repository. Reused between imported repositories and owned repositories.
+ */
+class RepositoryBase extends cdk_1.Resource {
+    /**
+     * Import a repository
+     */
+    static import(scope, id, props) {
+        return new ImportedRepository(scope, id, props);
+    }
+    /**
+     * Returns an ECR ARN for a repository that resides in the same account/region
+     * as the current stack.
+     */
+    static arnForLocalRepository(repositoryName, scope) {
+        return scope.node.stack.formatArn({
+            service: 'ecr',
+            resource: 'repository',
+            resourceName: repositoryName
+        });
+    }
+    /**
+     * The URI of this repository (represents the latest image):
+     *
+     *    ACCOUNT.dkr.ecr.REGION.amazonaws.com/REPOSITORY
+     *
+     */
+    get repositoryUri() {
+        return this.repositoryUriForTag();
+    }
+    /**
+     * 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}` : '';
+        const parts = this.node.stack.parseArn(this.repositoryArn);
+        return `${parts.account}.dkr.ecr.${parts.region}.amazonaws.com/${this.repositoryName}${tagSuffix}`;
+    }
+    /**
+     * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this
+     * repository.
+     * @param name The name of the rule
+     * @param target An IEventRuleTarget to invoke when this event happens (you can add more targets using `addTarget`)
+     * @param imageTag Only trigger on the specific image tag
+     */
+    onImagePushed(name, target, imageTag) {
+        return new events.EventRule(this, name, {
+            targets: target ? [target] : undefined,
+            eventPattern: {
+                source: ['aws.ecr'],
+                detail: {
+                    eventName: [
+                        'PutImage',
+                    ],
+                    requestParameters: {
+                        repositoryName: [
+                            this.repositoryName,
+                        ],
+                        imageTag: imageTag ? [imageTag] : undefined,
+                    },
+                },
+            },
+        });
+    }
+    /**
+     * Grant the given principal identity permissions to perform the actions on this repository
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions,
+            resourceArns: [this.repositoryArn],
+            resource: this,
+        });
+    }
+    /**
+     * Grant the given identity permissions to use the images in this repository
+     */
+    grantPull(grantee) {
+        const ret = this.grant(grantee, "ecr:BatchCheckLayerAvailability", "ecr:GetDownloadUrlForLayer", "ecr:BatchGetImage");
+        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) {
+        this.grantPull(grantee);
+        return this.grant(grantee, "ecr:PutImage", "ecr:InitiateLayerUpload", "ecr:UploadLayerPart", "ecr:CompleteLayerUpload");
+    }
+}
+exports.RepositoryBase = RepositoryBase;
+/**
+ * An already existing repository
+ */
+class ImportedRepository extends RepositoryBase {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        if (props.repositoryArn) {
+            this.repositoryArn = props.repositoryArn;
+        }
+        else {
+            if (!props.repositoryName) {
+                throw new Error('If "repositoryArn" is not specified, you must specify "repositoryName", ' +
+                    'which also implies that the repository resides in the same region/account as this stack');
+            }
+            this.repositoryArn = RepositoryBase.arnForLocalRepository(props.repositoryName, this);
+        }
+        if (props.repositoryName) {
+            this.repositoryName = props.repositoryName;
+        }
+        else {
+            // if repositoryArn is a token, the repository name is also required. this is because
+            // repository names can include "/" (e.g. foo/bar/myrepo) and it is impossible to
+            // parse the name from an ARN using CloudFormation's split/select.
+            if (cdk_1.Token.unresolved(this.repositoryArn)) {
+                throw new Error('repositoryArn is a late-bound value, and therefore repositoryName is required');
+            }
+            this.repositoryName = this.repositoryArn.split('/').slice(1).join('/');
+        }
+    }
+    export() {
+        return this.props;
+    }
+    addToResourcePolicy(_statement) {
+        // FIXME: Add annotation about policy we dropped on the floor
+    }
+}
+/**
  * Define an ECR repository
  */
-class Repository extends repository_ref_1.RepositoryBase {
+class Repository extends RepositoryBase {
     constructor(scope, id, props = {}) {
@@ -149,2 +287,2 @@ super(scope, id);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repository.js","sourceRoot":"","sources":["repository.ts"],"names":[],"mappings":"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","sourcesContent":["import iam = require('@aws-cdk/aws-iam');\nimport { CfnOutput, Construct, DeletionPolicy, Token } from '@aws-cdk/cdk';\nimport { CfnRepository } from './ecr.generated';\nimport { CountType, LifecycleRule, TagStatus } from './lifecycle';\nimport { RepositoryBase, RepositoryImportProps } from \"./repository-ref\";\n\nexport interface RepositoryProps {\n  /**\n   * Name for this repository\n   *\n   * @default Automatically generated name.\n   */\n  readonly repositoryName?: string;\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   */\n  readonly lifecycleRegistryId?: string;\n\n  /**\n   * Retain the repository on stack deletion\n   *\n   * If you don't set this to true, the registry must be empty, otherwise\n   * your stack deletion will fail.\n   *\n   * @default false\n   */\n  readonly retain?: boolean;\n}\n\n/**\n * Define an ECR repository\n */\nexport class Repository extends RepositoryBase {\n  public readonly repositoryName: string;\n  public readonly repositoryArn: string;\n  private readonly lifecycleRules = new Array<LifecycleRule>();\n  private readonly registryId?: string;\n  private policyDocument?: iam.PolicyDocument;\n\n  constructor(scope: Construct, id: string, props: RepositoryProps = {}) {\n    super(scope, id);\n\n    const resource = new CfnRepository(this, 'Resource', {\n      repositoryName: props.repositoryName,\n      // It says \"Text\", but they actually mean \"Object\".\n      repositoryPolicyText: new Token(() => this.policyDocument),\n      lifecyclePolicy: new Token(() => this.renderLifecyclePolicy()),\n    });\n\n    if (props.retain) {\n      resource.options.deletionPolicy = DeletionPolicy.Retain;\n    }\n\n    this.registryId = props.lifecycleRegistryId;\n    if (props.lifecycleRules) {\n      props.lifecycleRules.forEach(this.addLifecycleRule.bind(this));\n    }\n\n    this.repositoryName = resource.repositoryName;\n    this.repositoryArn = resource.repositoryArn;\n  }\n\n  /**\n   * Export this repository from the stack\n   */\n  public export(): RepositoryImportProps {\n    return {\n      repositoryArn: new CfnOutput(this, 'RepositoryArn', { value: this.repositoryArn }).makeImportValue().toString(),\n      repositoryName: new CfnOutput(this, 'RepositoryName', { value: this.repositoryName }).makeImportValue().toString()\n    };\n  }\n\n  public addToResourcePolicy(statement: iam.PolicyStatement) {\n    if (this.policyDocument === undefined) {\n      this.policyDocument = new iam.PolicyDocument();\n    }\n    this.policyDocument.addStatement(statement);\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 = { ...rule, tagStatus: rule.tagPrefixList === undefined ? TagStatus.Any : TagStatus.Tagged };\n    }\n\n    if (rule.tagStatus === TagStatus.Tagged && (rule.tagPrefixList === undefined || rule.tagPrefixList.length === 0)) {\n      throw new Error('TagStatus.Tagged requires the specification of a tagPrefixList');\n    }\n    if (rule.tagStatus !== TagStatus.Tagged && rule.tagPrefixList !== undefined) {\n      throw new Error('tagPrefixList can only be specified when tagStatus is set to Tagged');\n    }\n    if ((rule.maxImageAgeDays !== undefined) === (rule.maxImageCount !== undefined)) {\n      throw new Error(`Life cycle rule must contain exactly one of 'maxImageAgeDays' and 'maxImageCount', got: ${JSON.stringify(rule)}`);\n    }\n\n    if (rule.tagStatus === TagStatus.Any && this.lifecycleRules.filter(r => r.tagStatus === TagStatus.Any).length > 0) {\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(): CfnRepository.LifecyclePolicyProperty | undefined {\n    let lifecyclePolicyText: any;\n\n    if (this.lifecycleRules.length === 0 && !this.registryId) { return undefined; }\n\n    if (this.lifecycleRules.length > 0) {\n      lifecyclePolicyText = JSON.stringify(this.node.resolve({\n        rules: this.orderedLifecycleRules().map(renderLifecycleRule),\n      }));\n    }\n\n    return {\n      lifecyclePolicyText,\n      registryId: this.registryId,\n    };\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) { return []; }\n\n    const prioritizedRules = this.lifecycleRules.filter(r => r.rulePriority !== undefined && r.tagStatus !== TagStatus.Any);\n    const autoPrioritizedRules = this.lifecycleRules.filter(r => r.rulePriority === undefined && r.tagStatus !== TagStatus.Any);\n    const anyRules = this.lifecycleRules.filter(r => r.tagStatus === TagStatus.Any);\n    if (anyRules.length > 0 && anyRules[0].rulePriority !== undefined && autoPrioritizedRules.length > 0) {\n      // Supporting this is too complex for very little value. We just prohibit it.\n      throw new Error(\"Cannot combine prioritized TagStatus.Any rule with unprioritized rules. Remove rulePriority from the 'Any' rule.\");\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.concat(autoPrioritizedRules).concat(anyRules)) {\n      ret.push({\n        ...rule,\n        rulePriority: rule.rulePriority !== undefined ? 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\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      throw new Error(`TagStatus.Any rule must have highest priority, has ${anyRules[0].rulePriority} which is smaller than ${maxPrio}`);\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      countType: rule.maxImageAgeDays !== undefined ? CountType.SinceImagePushed : CountType.ImageCountMoreThan,\n      countNumber: rule.maxImageAgeDays !== undefined ? rule.maxImageAgeDays : rule.maxImageCount,\n      countUnit: rule.maxImageAgeDays !== undefined ? 'days' : undefined,\n    },\n    action: {\n      type: 'expire'\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repository.js","sourceRoot":"","sources":["repository.ts"],"names":[],"mappings":";;AAAA,8CAA+C;AAC/C,wCAAyC;AACzC,sCAA4G;AAC5G,mDAAgD;AAChD,2CAAkE;AA6FlE;;GAEG;AACH,MAAsB,cAAe,SAAQ,cAAQ;IACnD;;OAEG;IACI,MAAM,CAAC,MAAM,CAAC,KAAgB,EAAE,EAAU,EAAE,KAA4B;QAC7E,OAAO,IAAI,kBAAkB,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,qBAAqB,CAAC,cAAsB,EAAE,KAAiB;QAC3E,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;YAChC,OAAO,EAAE,KAAK;YACd,QAAQ,EAAE,YAAY;YACtB,YAAY,EAAE,cAAc;SAC7B,CAAC,CAAC;IACL,CAAC;IAiBD;;;;;OAKG;IACH,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,mBAAmB,EAAE,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACI,mBAAmB,CAAC,GAAY;QACrC,MAAM,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC3D,OAAO,GAAG,KAAK,CAAC,OAAO,YAAY,KAAK,CAAC,MAAM,kBAAkB,IAAI,CAAC,cAAc,GAAG,SAAS,EAAE,CAAC;IACrG,CAAC;IAOD;;;;;;OAMG;IACI,aAAa,CAAC,IAAY,EAAE,MAAgC,EAAE,QAAiB;QACpF,OAAO,IAAI,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE;YACtC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS;YACtC,YAAY,EAAE;gBACZ,MAAM,EAAE,CAAC,SAAS,CAAC;gBACnB,MAAM,EAAE;oBACN,SAAS,EAAE;wBACT,UAAU;qBACX;oBACD,iBAAiB,EAAE;wBACjB,cAAc,EAAE;4BACd,IAAI,CAAC,cAAc;yBACpB;wBACD,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;qBAC5C;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAuB,EAAE,GAAG,OAAiB;QACxD,OAAO,GAAG,CAAC,KAAK,CAAC,wBAAwB,CAAC;YACxC,OAAO;YACP,OAAO;YACP,YAAY,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC;YAClC,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,OAAuB;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,iCAAiC,EAAE,4BAA4B,EAAE,mBAAmB,CAAC,CAAC;QAEtH,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC;YACvB,OAAO;YACP,OAAO,EAAE,CAAC,2BAA2B,CAAC;YACtC,YAAY,EAAE,CAAC,GAAG,CAAC;YACnB,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;QAEH,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACI,aAAa,CAAC,OAAuB;QAC1C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EACvB,cAAc,EACd,yBAAyB,EACzB,qBAAqB,EACrB,yBAAyB,CAAC,CAAC;IAC/B,CAAC;CACF;AAjID,wCAiIC;AAED;;GAEG;AACH,MAAM,kBAAmB,SAAQ,cAAc;IAI7C,YAAY,KAAgB,EAAE,EAAU,EAAmB,KAA4B;QACrF,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QADwC,UAAK,GAAL,KAAK,CAAuB;QAGrF,IAAI,KAAK,CAAC,aAAa,EAAE;YACvB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;SAC1C;aAAM;YACL,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE;gBACzB,MAAM,IAAI,KAAK,CAAC,0EAA0E;oBACxF,yFAAyF,CAAC,CAAC;aAC9F;YAED,IAAI,CAAC,aAAa,GAAG,cAAc,CAAC,qBAAqB,CAAC,KAAK,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;SACvF;QAED,IAAI,KAAK,CAAC,cAAc,EAAE;YACxB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;SAC5C;aAAM;YACL,qFAAqF;YACrF,iFAAiF;YACjF,kEAAkE;YAClE,IAAI,WAAK,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;gBACxC,MAAM,IAAI,KAAK,CAAC,+EAA+E,CAAC,CAAC;aAClG;YAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACxE;IACH,CAAC;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAEM,mBAAmB,CAAC,UAA+B;QACxD,6DAA6D;IAC/D,CAAC;CACF;AAoCD;;GAEG;AACH,MAAa,UAAW,SAAQ,cAAc;IAO5C,YAAY,KAAgB,EAAE,EAAU,EAAE,QAAyB,EAAE;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QALF,mBAAc,GAAG,IAAI,KAAK,EAAiB,CAAC;QAO3D,MAAM,QAAQ,GAAG,IAAI,6BAAa,CAAC,IAAI,EAAE,UAAU,EAAE;YACnD,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,mDAAmD;YACnD,oBAAoB,EAAE,IAAI,WAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC;YAC1D,eAAe,EAAE,IAAI,WAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC/D,CAAC,CAAC;QAEH,IAAI,KAAK,CAAC,MAAM,EAAE;YAChB,QAAQ,CAAC,OAAO,CAAC,cAAc,GAAG,oBAAc,CAAC,MAAM,CAAC;SACzD;QAED,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,mBAAmB,CAAC;QAC5C,IAAI,KAAK,CAAC,cAAc,EAAE;YACxB,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;SAChE;QAED,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,cAAc,CAAC;QAC9C,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC;IAC9C,CAAC;IAED;;OAEG;IACI,MAAM;QACX,OAAO;YACL,aAAa,EAAE,IAAI,eAAS,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,QAAQ,EAAE;YAC/G,cAAc,EAAE,IAAI,eAAS,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,QAAQ,EAAE;SACnH,CAAC;IACJ,CAAC;IAEM,mBAAmB,CAAC,SAA8B;QACvD,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE;YACrC,IAAI,CAAC,cAAc,GAAG,IAAI,GAAG,CAAC,cAAc,EAAE,CAAC;SAChD;QACD,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACI,gBAAgB,CAAC,IAAmB;QACzC,kEAAkE;QAClE,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE;YAChC,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,qBAAS,CAAC,GAAG,CAAC,CAAC,CAAC,qBAAS,CAAC,MAAM,EAAE,CAAC;SACpG;QAED,IAAI,IAAI,CAAC,SAAS,KAAK,qBAAS,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;YAChH,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;SACnF;QACD,IAAI,IAAI,CAAC,SAAS,KAAK,qBAAS,CAAC,MAAM,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE;YAC3E,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;SACxF;QACD,IAAI,CAAC,IAAI,CAAC,eAAe,KAAK,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC,EAAE;YAC/E,MAAM,IAAI,KAAK,CAAC,2FAA2F,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACpI;QAED,IAAI,IAAI,CAAC,SAAS,KAAK,qBAAS,CAAC,GAAG,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,qBAAS,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YACjH,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;SACpE;QAED,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACK,qBAAqB;QAC3B,IAAI,mBAAwB,CAAC;QAE7B,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAAE,OAAO,SAAS,CAAC;SAAE;QAE/E,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE;YAClC,mBAAmB,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;gBACrD,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,CAAC,GAAG,CAAC,mBAAmB,CAAC;aAC7D,CAAC,CAAC,CAAC;SACL;QAED,OAAO;YACL,mBAAmB;YACnB,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,qBAAqB;QAC3B,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE;YAAE,OAAO,EAAE,CAAC;SAAE;QAEpD,MAAM,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC,SAAS,KAAK,qBAAS,CAAC,GAAG,CAAC,CAAC;QACxH,MAAM,oBAAoB,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC,SAAS,KAAK,qBAAS,CAAC,GAAG,CAAC,CAAC;QAC5H,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,qBAAS,CAAC,GAAG,CAAC,CAAC;QAChF,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,KAAK,SAAS,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE;YACpG,6EAA6E;YAC7E,MAAM,IAAI,KAAK,CAAC,kHAAkH,CAAC,CAAC;SACrI;QAED,MAAM,KAAK,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAa,CAAC,CAAC;QACzD,IAAI,QAAQ,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAE/D,MAAM,GAAG,GAAG,IAAI,KAAK,EAAiB,CAAC;QACvC,KAAK,MAAM,IAAI,IAAI,gBAAgB,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;YACjF,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,YAAY,EAAE,IAAI,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,EAAE;aAC/E,CAAC,CAAC;SACJ;QAED,+GAA+G;QAC/G,mBAAmB,CAAC,GAAG,CAAC,CAAC;QACzB,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AA/HD,gCA+HC;AAED,SAAS,mBAAmB,CAAC,KAAsB;IACjD,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,qBAAS,CAAC,GAAG,CAAC,CAAC;IAClE,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAa,CAAC,CAAC,CAAC;QAC7D,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,KAAK,OAAO,EAAE;YACxC,MAAM,IAAI,KAAK,CAAC,sDAAsD,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,0BAA0B,OAAO,EAAE,CAAC,CAAC;SACpI;KACF;AACH,CAAC;AAED;;GAEG;AACH,SAAS,mBAAmB,CAAC,IAAmB;IAC9C,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,SAAS,EAAE;YACT,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,qBAAS,CAAC,GAAG;YAC1C,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,SAAS,EAAE,IAAI,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,qBAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC,qBAAS,CAAC,kBAAkB;YACzG,WAAW,EAAE,IAAI,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa;YAC3F,SAAS,EAAE,IAAI,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;SACnE;QACD,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;SACf;KACF,CAAC;AACJ,CAAC","sourcesContent":["import events = require('@aws-cdk/aws-events');\nimport iam = require('@aws-cdk/aws-iam');\nimport { CfnOutput, Construct, DeletionPolicy, IConstruct, IResource, Resource, Token } from '@aws-cdk/cdk';\nimport { CfnRepository } from './ecr.generated';\nimport { CountType, LifecycleRule, TagStatus } from './lifecycle';\n\n/**\n * Represents an ECR repository.\n */\nexport interface IRepository extends IResource {\n  /**\n   * The name of the repository\n   */\n  readonly repositoryName: string;\n\n  /**\n   * The ARN of the repository\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   */\n  readonly repositoryUri: 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   * Add a policy statement to the repository's resource policy\n   */\n  addToResourcePolicy(statement: iam.PolicyStatement): void;\n\n  /**\n   * Grant the given principal identity permissions to perform the actions on this repository\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): 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 pull and push images to this repository.\n   */\n  grantPullPush(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this\n   * repository.\n   * @param name The name of the rule\n   * @param target An IEventRuleTarget to invoke when this event happens (you can add more targets using `addTarget`)\n   * @param imageTag Only trigger on the specific image tag\n   */\n  onImagePushed(name: string, target?: events.IEventRuleTarget, imageTag?: string): events.EventRule;\n\n  /**\n   * Export this repository from the stack\n   */\n  export(): RepositoryImportProps;\n}\n\nexport interface RepositoryImportProps {\n  /**\n   * The ARN of the repository to import.\n   *\n   * At least one of `repositoryArn` or `repositoryName` is required.\n   *\n   * @default If you only have a repository name and the repository is in the same\n   * account/region as the current stack, you can set `repositoryName` instead\n   * and the ARN will be formatted with the current region and account.\n   */\n  readonly repositoryArn?: string;\n\n  /**\n   * The full name of the repository to import.\n   *\n   * This is only needed if the repository ARN is not a concrete string, in which\n   * case it is impossible to safely parse the ARN and extract full repository\n   * names from it if it includes multiple components (e.g. `foo/bar/myrepo`).\n   *\n   * If the repository is in the same region/account as the stack, it is sufficient\n   * to only specify the repository name.\n   */\n  readonly repositoryName?: string;\n}\n\n/**\n * Base class for ECR repository. Reused between imported repositories and owned repositories.\n */\nexport abstract class RepositoryBase extends Resource implements IRepository {\n  /**\n   * Import a repository\n   */\n  public static import(scope: Construct, id: string, props: RepositoryImportProps): IRepository {\n    return new ImportedRepository(scope, id, props);\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(repositoryName: string, scope: IConstruct): string {\n    return scope.node.stack.formatArn({\n      service: 'ecr',\n      resource: 'repository',\n      resourceName: repositoryName\n    });\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  /**\n   * Add a policy statement to the repository's resource policy\n   */\n  public abstract addToResourcePolicy(statement: iam.PolicyStatement): void;\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   * 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    const parts = this.node.stack.parseArn(this.repositoryArn);\n    return `${parts.account}.dkr.ecr.${parts.region}.amazonaws.com/${this.repositoryName}${tagSuffix}`;\n  }\n\n  /**\n   * Export this repository from the stack\n   */\n  public abstract export(): RepositoryImportProps;\n\n  /**\n   * Defines an AWS CloudWatch event rule that can trigger a target when an image is pushed to this\n   * repository.\n   * @param name The name of the rule\n   * @param target An IEventRuleTarget to invoke when this event happens (you can add more targets using `addTarget`)\n   * @param imageTag Only trigger on the specific image tag\n   */\n  public onImagePushed(name: string, target?: events.IEventRuleTarget, imageTag?: string): events.EventRule {\n    return new events.EventRule(this, name, {\n      targets: target ? [target] : undefined,\n      eventPattern: {\n        source: ['aws.ecr'],\n        detail: {\n          eventName: [\n            'PutImage',\n          ],\n          requestParameters: {\n            repositoryName: [\n              this.repositoryName,\n            ],\n            imageTag: imageTag ? [imageTag] : undefined,\n          },\n        },\n      },\n    });\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    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 use the images in this repository\n   */\n  public grantPull(grantee: iam.IGrantable) {\n    const ret = this.grant(grantee, \"ecr:BatchCheckLayerAvailability\", \"ecr:GetDownloadUrlForLayer\", \"ecr:BatchGetImage\");\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 pull and push images to this repository.\n   */\n  public grantPullPush(grantee: iam.IGrantable) {\n    this.grantPull(grantee);\n    return this.grant(grantee,\n      \"ecr:PutImage\",\n      \"ecr:InitiateLayerUpload\",\n      \"ecr:UploadLayerPart\",\n      \"ecr:CompleteLayerUpload\");\n  }\n}\n\n/**\n * An already existing repository\n */\nclass ImportedRepository extends RepositoryBase {\n  public readonly repositoryName: string;\n  public readonly repositoryArn: string;\n\n  constructor(scope: Construct, id: string, private readonly props: RepositoryImportProps) {\n    super(scope, id);\n\n    if (props.repositoryArn) {\n      this.repositoryArn = props.repositoryArn;\n    } else {\n      if (!props.repositoryName) {\n        throw new Error('If \"repositoryArn\" is not specified, you must specify \"repositoryName\", ' +\n          'which also implies that the repository resides in the same region/account as this stack');\n      }\n\n      this.repositoryArn = RepositoryBase.arnForLocalRepository(props.repositoryName, this);\n    }\n\n    if (props.repositoryName) {\n      this.repositoryName = props.repositoryName;\n    } else {\n      // if repositoryArn is a token, the repository name is also required. this is because\n      // repository names can include \"/\" (e.g. foo/bar/myrepo) and it is impossible to\n      // parse the name from an ARN using CloudFormation's split/select.\n      if (Token.unresolved(this.repositoryArn)) {\n        throw new Error('repositoryArn is a late-bound value, and therefore repositoryName is required');\n      }\n\n      this.repositoryName = this.repositoryArn.split('/').slice(1).join('/');\n    }\n  }\n\n  public export(): RepositoryImportProps {\n    return this.props;\n  }\n\n  public addToResourcePolicy(_statement: iam.PolicyStatement) {\n    // FIXME: Add annotation about policy we dropped on the floor\n  }\n}\n\nexport interface RepositoryProps {\n  /**\n   * Name for this repository\n   *\n   * @default Automatically generated name.\n   */\n  readonly repositoryName?: string;\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   */\n  readonly lifecycleRegistryId?: string;\n\n  /**\n   * Retain the repository on stack deletion\n   *\n   * If you don't set this to true, the registry must be empty, otherwise\n   * your stack deletion will fail.\n   *\n   * @default false\n   */\n  readonly retain?: boolean;\n}\n\n/**\n * Define an ECR repository\n */\nexport class Repository extends RepositoryBase {\n  public readonly repositoryName: string;\n  public readonly repositoryArn: string;\n  private readonly lifecycleRules = new Array<LifecycleRule>();\n  private readonly registryId?: string;\n  private policyDocument?: iam.PolicyDocument;\n\n  constructor(scope: Construct, id: string, props: RepositoryProps = {}) {\n    super(scope, id);\n\n    const resource = new CfnRepository(this, 'Resource', {\n      repositoryName: props.repositoryName,\n      // It says \"Text\", but they actually mean \"Object\".\n      repositoryPolicyText: new Token(() => this.policyDocument),\n      lifecyclePolicy: new Token(() => this.renderLifecyclePolicy()),\n    });\n\n    if (props.retain) {\n      resource.options.deletionPolicy = DeletionPolicy.Retain;\n    }\n\n    this.registryId = props.lifecycleRegistryId;\n    if (props.lifecycleRules) {\n      props.lifecycleRules.forEach(this.addLifecycleRule.bind(this));\n    }\n\n    this.repositoryName = resource.repositoryName;\n    this.repositoryArn = resource.repositoryArn;\n  }\n\n  /**\n   * Export this repository from the stack\n   */\n  public export(): RepositoryImportProps {\n    return {\n      repositoryArn: new CfnOutput(this, 'RepositoryArn', { value: this.repositoryArn }).makeImportValue().toString(),\n      repositoryName: new CfnOutput(this, 'RepositoryName', { value: this.repositoryName }).makeImportValue().toString()\n    };\n  }\n\n  public addToResourcePolicy(statement: iam.PolicyStatement) {\n    if (this.policyDocument === undefined) {\n      this.policyDocument = new iam.PolicyDocument();\n    }\n    this.policyDocument.addStatement(statement);\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 = { ...rule, tagStatus: rule.tagPrefixList === undefined ? TagStatus.Any : TagStatus.Tagged };\n    }\n\n    if (rule.tagStatus === TagStatus.Tagged && (rule.tagPrefixList === undefined || rule.tagPrefixList.length === 0)) {\n      throw new Error('TagStatus.Tagged requires the specification of a tagPrefixList');\n    }\n    if (rule.tagStatus !== TagStatus.Tagged && rule.tagPrefixList !== undefined) {\n      throw new Error('tagPrefixList can only be specified when tagStatus is set to Tagged');\n    }\n    if ((rule.maxImageAgeDays !== undefined) === (rule.maxImageCount !== undefined)) {\n      throw new Error(`Life cycle rule must contain exactly one of 'maxImageAgeDays' and 'maxImageCount', got: ${JSON.stringify(rule)}`);\n    }\n\n    if (rule.tagStatus === TagStatus.Any && this.lifecycleRules.filter(r => r.tagStatus === TagStatus.Any).length > 0) {\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(): CfnRepository.LifecyclePolicyProperty | undefined {\n    let lifecyclePolicyText: any;\n\n    if (this.lifecycleRules.length === 0 && !this.registryId) { return undefined; }\n\n    if (this.lifecycleRules.length > 0) {\n      lifecyclePolicyText = JSON.stringify(this.node.resolve({\n        rules: this.orderedLifecycleRules().map(renderLifecycleRule),\n      }));\n    }\n\n    return {\n      lifecyclePolicyText,\n      registryId: this.registryId,\n    };\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) { return []; }\n\n    const prioritizedRules = this.lifecycleRules.filter(r => r.rulePriority !== undefined && r.tagStatus !== TagStatus.Any);\n    const autoPrioritizedRules = this.lifecycleRules.filter(r => r.rulePriority === undefined && r.tagStatus !== TagStatus.Any);\n    const anyRules = this.lifecycleRules.filter(r => r.tagStatus === TagStatus.Any);\n    if (anyRules.length > 0 && anyRules[0].rulePriority !== undefined && autoPrioritizedRules.length > 0) {\n      // Supporting this is too complex for very little value. We just prohibit it.\n      throw new Error(\"Cannot combine prioritized TagStatus.Any rule with unprioritized rules. Remove rulePriority from the 'Any' rule.\");\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.concat(autoPrioritizedRules).concat(anyRules)) {\n      ret.push({\n        ...rule,\n        rulePriority: rule.rulePriority !== undefined ? 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\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      throw new Error(`TagStatus.Any rule must have highest priority, has ${anyRules[0].rulePriority} which is smaller than ${maxPrio}`);\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      countType: rule.maxImageAgeDays !== undefined ? CountType.SinceImagePushed : CountType.ImageCountMoreThan,\n      countNumber: rule.maxImageAgeDays !== undefined ? rule.maxImageAgeDays : rule.maxImageCount,\n      countUnit: rule.maxImageAgeDays !== undefined ? 'days' : undefined,\n    },\n    action: {\n      type: 'expire'\n    }\n  };\n}\n"]}

package.json

 {
   "name": "@aws-cdk/aws-ecr",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "The CDK Construct Library for AWS::ECR",
@@ -66,18 +66,18 @@ "main": "lib/index.js",
   "devDependencies": {
-    "@aws-cdk/assert": "^0.29.0",
-    "cdk-build-tools": "^0.29.0",
-    "cdk-integ-tools": "^0.29.0",
-    "cfn2ts": "^0.29.0",
-    "pkglint": "^0.29.0"
+    "@aws-cdk/assert": "^0.30.0",
+    "cdk-build-tools": "^0.30.0",
+    "cdk-integ-tools": "^0.30.0",
+    "cfn2ts": "^0.30.0",
+    "pkglint": "^0.30.0"
   },
   "dependencies": {
-    "@aws-cdk/aws-events": "^0.29.0",
-    "@aws-cdk/aws-iam": "^0.29.0",
-    "@aws-cdk/cdk": "^0.29.0"
+    "@aws-cdk/aws-events": "^0.30.0",
+    "@aws-cdk/aws-iam": "^0.30.0",
+    "@aws-cdk/cdk": "^0.30.0"
   },
   "homepage": "https://github.com/awslabs/aws-cdk",
   "peerDependencies": {
-    "@aws-cdk/aws-events": "^0.29.0",
-    "@aws-cdk/aws-iam": "^0.29.0",
-    "@aws-cdk/cdk": "^0.29.0"
+    "@aws-cdk/aws-events": "^0.30.0",
+    "@aws-cdk/aws-iam": "^0.30.0",
+    "@aws-cdk/cdk": "^0.30.0"
   },
@@ -89,5 +89,6 @@ "engines": {
     "exclude": [
-      "import:@aws-cdk/aws-ecr.Repository"
+      "import:@aws-cdk/aws-ecr.Repository",
+      "construct-base-is-private:@aws-cdk/aws-ecr.RepositoryBase"
     ]
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

185108

Lines of code

1247

increased by3.4%

Worsened metrics

Number of package files

19

decreased by-5%

Dependency changes

• + Added@aws-cdk/aws-events@0.30.0(transitive)

• + Added@aws-cdk/aws-iam@0.30.0(transitive)

• + Added@aws-cdk/cdk@0.30.0(transitive)

• + Added@aws-cdk/cx-api@0.30.0(transitive)

• + Added@aws-cdk/region-info@0.30.0(transitive)

• - Removed@aws-cdk/aws-events@0.29.0(transitive)

• - Removed@aws-cdk/aws-iam@0.29.0(transitive)

• - Removed@aws-cdk/cdk@0.29.0(transitive)

• - Removed@aws-cdk/cx-api@0.29.0(transitive)

• - Removed@aws-cdk/region-info@0.29.0(transitive)

• Updated@aws-cdk/aws-events@^0.30.0

• Updated@aws-cdk/aws-iam@^0.30.0

• Updated@aws-cdk/cdk@^0.30.0