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

Comparing version 0.20.0 to 0.21.0

lib/group.js

@@ -13,3 +13,3 @@ "use strict";
         this.managedPolicies = props.managedPolicyArns || [];
-        const group = new iam_generated_1.cloudformation.GroupResource(this, 'Resource', {
+        const group = new iam_generated_1.CfnGroup(this, 'Resource', {
             groupName: props.groupName,
@@ -56,2 +56,2 @@ managedPolicyArns: util_1.undefinedIfEmpty(() => this.managedPolicies),
 exports.Group = Group;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

lib/iam.generated.d.ts

 import cdk = require('@aws-cdk/cdk');
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html
+ */
+export interface CfnAccessKeyProps {
+    /**
+     * ``AWS::IAM::AccessKey.UserName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html#cfn-iam-accesskey-username
+     */
+    userName: string | cdk.Token;
+    /**
+     * ``AWS::IAM::AccessKey.Serial``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html#cfn-iam-accesskey-serial
+     */
+    serial?: number | cdk.Token;
+    /**
+     * ``AWS::IAM::AccessKey.Status``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html#cfn-iam-accesskey-status
+     */
+    status?: string | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html
+ */
+export declare class CfnAccessKey extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::AccessKey";
+    /**
+     * @cloudformation_attribute SecretAccessKey
+     */
+    readonly accessKeySecretAccessKey: string;
+    readonly accessKeyId: string;
+    /**
+     * Creates a new ``AWS::IAM::AccessKey``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnAccessKey`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnAccessKey``
+     */
+    constructor(parent: cdk.Construct, name: string, properties: CfnAccessKeyProps);
+    readonly propertyOverrides: CfnAccessKeyProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
 export declare namespace cloudformation {
@@ -24,2 +70,3 @@ /**
     /**
+     * @deprecated "cloudformation.AccessKeyResource" will be deprecated in a future release in favor of "CfnAccessKey" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html
@@ -51,2 +98,70 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html
+ */
+export interface CfnGroupProps {
+    /**
+     * ``AWS::IAM::Group.GroupName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html#cfn-iam-group-groupname
+     */
+    groupName?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::Group.ManagedPolicyArns``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html#cfn-iam-group-managepolicyarns
+     */
+    managedPolicyArns?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::Group.Path``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html#cfn-iam-group-path
+     */
+    path?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::Group.Policies``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html#cfn-iam-group-policies
+     */
+    policies?: Array<CfnGroup.PolicyProperty | cdk.Token> | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html
+ */
+export declare class CfnGroup extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::Group";
+    /**
+     * @cloudformation_attribute Arn
+     */
+    readonly groupArn: string;
+    readonly groupName: string;
+    /**
+     * Creates a new ``AWS::IAM::Group``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnGroup`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnGroup``
+     */
+    constructor(parent: cdk.Construct, name: string, properties?: CfnGroupProps);
+    readonly propertyOverrides: CfnGroupProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
+export declare namespace CfnGroup {
+    /**
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html
+     */
+    interface PolicyProperty {
+        /**
+         * ``CfnGroup.PolicyProperty.PolicyDocument``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html#cfn-iam-policies-policydocument
+         */
+        policyDocument: object | cdk.Token;
+        /**
+         * ``CfnGroup.PolicyProperty.PolicyName``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html#cfn-iam-policies-policyname
+         */
+        policyName: string | cdk.Token;
+    }
+}
 export declare namespace cloudformation {
@@ -79,2 +194,3 @@ /**
     /**
+     * @deprecated "cloudformation.GroupResource" will be deprecated in a future release in favor of "CfnGroup" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html
@@ -123,2 +239,48 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html
+ */
+export interface CfnInstanceProfileProps {
+    /**
+     * ``AWS::IAM::InstanceProfile.Roles``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html#cfn-iam-instanceprofile-roles
+     */
+    roles: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::InstanceProfile.InstanceProfileName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html#cfn-iam-instanceprofile-instanceprofilename
+     */
+    instanceProfileName?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::InstanceProfile.Path``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html#cfn-iam-instanceprofile-path
+     */
+    path?: string | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html
+ */
+export declare class CfnInstanceProfile extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::InstanceProfile";
+    /**
+     * @cloudformation_attribute Arn
+     */
+    readonly instanceProfileArn: string;
+    readonly instanceProfileName: string;
+    /**
+     * Creates a new ``AWS::IAM::InstanceProfile``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnInstanceProfile`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnInstanceProfile``
+     */
+    constructor(parent: cdk.Construct, name: string, properties: CfnInstanceProfileProps);
+    readonly propertyOverrides: CfnInstanceProfileProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
 export declare namespace cloudformation {
@@ -146,2 +308,3 @@ /**
     /**
+     * @deprecated "cloudformation.InstanceProfileResource" will be deprecated in a future release in favor of "CfnInstanceProfile" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html
@@ -173,2 +336,64 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html
+ */
+export interface CfnManagedPolicyProps {
+    /**
+     * ``AWS::IAM::ManagedPolicy.PolicyDocument``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html#cfn-iam-managedpolicy-policydocument
+     */
+    policyDocument: object | cdk.Token;
+    /**
+     * ``AWS::IAM::ManagedPolicy.Description``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html#cfn-iam-managedpolicy-description
+     */
+    description?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::ManagedPolicy.Groups``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html#cfn-iam-managedpolicy-groups
+     */
+    groups?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::ManagedPolicy.ManagedPolicyName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html#cfn-iam-managedpolicy-managedpolicyname
+     */
+    managedPolicyName?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::ManagedPolicy.Path``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html#cfn-ec2-dhcpoptions-path
+     */
+    path?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::ManagedPolicy.Roles``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html#cfn-iam-managedpolicy-roles
+     */
+    roles?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::ManagedPolicy.Users``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html#cfn-iam-managedpolicy-users
+     */
+    users?: Array<string | cdk.Token> | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html
+ */
+export declare class CfnManagedPolicy extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::ManagedPolicy";
+    readonly managedPolicyArn: string;
+    /**
+     * Creates a new ``AWS::IAM::ManagedPolicy``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnManagedPolicy`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnManagedPolicy``
+     */
+    constructor(parent: cdk.Construct, name: string, properties: CfnManagedPolicyProps);
+    readonly propertyOverrides: CfnManagedPolicyProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
 export declare namespace cloudformation {
@@ -216,2 +441,3 @@ /**
     /**
+     * @deprecated "cloudformation.ManagedPolicyResource" will be deprecated in a future release in favor of "CfnManagedPolicy" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html
@@ -239,2 +465,54 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html
+ */
+export interface CfnPolicyProps {
+    /**
+     * ``AWS::IAM::Policy.PolicyDocument``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html#cfn-iam-policy-policydocument
+     */
+    policyDocument: object | cdk.Token;
+    /**
+     * ``AWS::IAM::Policy.PolicyName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html#cfn-iam-policy-policyname
+     */
+    policyName: string | cdk.Token;
+    /**
+     * ``AWS::IAM::Policy.Groups``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html#cfn-iam-policy-groups
+     */
+    groups?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::Policy.Roles``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html#cfn-iam-policy-roles
+     */
+    roles?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::Policy.Users``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html#cfn-iam-policy-users
+     */
+    users?: Array<string | cdk.Token> | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html
+ */
+export declare class CfnPolicy extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::Policy";
+    readonly policyName: string;
+    /**
+     * Creates a new ``AWS::IAM::Policy``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnPolicy`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnPolicy``
+     */
+    constructor(parent: cdk.Construct, name: string, properties: CfnPolicyProps);
+    readonly propertyOverrides: CfnPolicyProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
 export declare namespace cloudformation {
@@ -272,2 +550,3 @@ /**
     /**
+     * @deprecated "cloudformation.PolicyResource" will be deprecated in a future release in favor of "CfnPolicy" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-policy.html
@@ -295,2 +574,89 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html
+ */
+export interface CfnRoleProps {
+    /**
+     * ``AWS::IAM::Role.AssumeRolePolicyDocument``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-assumerolepolicydocument
+     */
+    assumeRolePolicyDocument: object | cdk.Token;
+    /**
+     * ``AWS::IAM::Role.ManagedPolicyArns``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-managepolicyarns
+     */
+    managedPolicyArns?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::Role.MaxSessionDuration``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-maxsessionduration
+     */
+    maxSessionDuration?: number | cdk.Token;
+    /**
+     * ``AWS::IAM::Role.Path``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-path
+     */
+    path?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::Role.PermissionsBoundary``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-permissionsboundary
+     */
+    permissionsBoundary?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::Role.Policies``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-policies
+     */
+    policies?: Array<CfnRole.PolicyProperty | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::Role.RoleName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-rolename
+     */
+    roleName?: string | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html
+ */
+export declare class CfnRole extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::Role";
+    /**
+     * @cloudformation_attribute Arn
+     */
+    readonly roleArn: string;
+    /**
+     * @cloudformation_attribute RoleId
+     */
+    readonly roleId: string;
+    readonly roleName: string;
+    /**
+     * Creates a new ``AWS::IAM::Role``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnRole`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnRole``
+     */
+    constructor(parent: cdk.Construct, name: string, properties: CfnRoleProps);
+    readonly propertyOverrides: CfnRoleProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
+export declare namespace CfnRole {
+    /**
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html
+     */
+    interface PolicyProperty {
+        /**
+         * ``CfnRole.PolicyProperty.PolicyDocument``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html#cfn-iam-policies-policydocument
+         */
+        policyDocument: object | cdk.Token;
+        /**
+         * ``CfnRole.PolicyProperty.PolicyName``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html#cfn-iam-policies-policyname
+         */
+        policyName: string | cdk.Token;
+    }
+}
 export declare namespace cloudformation {
@@ -338,2 +704,3 @@ /**
     /**
+     * @deprecated "cloudformation.RoleResource" will be deprecated in a future release in favor of "CfnRole" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html
@@ -386,2 +753,43 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-servicelinkedrole.html
+ */
+export interface CfnServiceLinkedRoleProps {
+    /**
+     * ``AWS::IAM::ServiceLinkedRole.AWSServiceName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-servicelinkedrole.html#cfn-iam-servicelinkedrole-awsservicename
+     */
+    awsServiceName: string | cdk.Token;
+    /**
+     * ``AWS::IAM::ServiceLinkedRole.CustomSuffix``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-servicelinkedrole.html#cfn-iam-servicelinkedrole-customsuffix
+     */
+    customSuffix?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::ServiceLinkedRole.Description``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-servicelinkedrole.html#cfn-iam-servicelinkedrole-description
+     */
+    description?: string | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-servicelinkedrole.html
+ */
+export declare class CfnServiceLinkedRole extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::ServiceLinkedRole";
+    /**
+     * Creates a new ``AWS::IAM::ServiceLinkedRole``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnServiceLinkedRole`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnServiceLinkedRole``
+     */
+    constructor(parent: cdk.Construct, name: string, properties: CfnServiceLinkedRoleProps);
+    readonly propertyOverrides: CfnServiceLinkedRoleProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
 export declare namespace cloudformation {
@@ -409,2 +817,3 @@ /**
     /**
+     * @deprecated "cloudformation.ServiceLinkedRoleResource" will be deprecated in a future release in favor of "CfnServiceLinkedRole" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-servicelinkedrole.html
@@ -431,2 +840,102 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html
+ */
+export interface CfnUserProps {
+    /**
+     * ``AWS::IAM::User.Groups``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html#cfn-iam-user-groups
+     */
+    groups?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::User.LoginProfile``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html#cfn-iam-user-loginprofile
+     */
+    loginProfile?: CfnUser.LoginProfileProperty | cdk.Token;
+    /**
+     * ``AWS::IAM::User.ManagedPolicyArns``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html#cfn-iam-user-managepolicyarns
+     */
+    managedPolicyArns?: Array<string | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::User.Path``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html#cfn-iam-user-path
+     */
+    path?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::User.PermissionsBoundary``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html#cfn-iam-user-permissionsboundary
+     */
+    permissionsBoundary?: string | cdk.Token;
+    /**
+     * ``AWS::IAM::User.Policies``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html#cfn-iam-user-policies
+     */
+    policies?: Array<CfnUser.PolicyProperty | cdk.Token> | cdk.Token;
+    /**
+     * ``AWS::IAM::User.UserName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html#cfn-iam-user-username
+     */
+    userName?: string | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html
+ */
+export declare class CfnUser extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::User";
+    /**
+     * @cloudformation_attribute Arn
+     */
+    readonly userArn: string;
+    readonly userName: string;
+    /**
+     * Creates a new ``AWS::IAM::User``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnUser`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnUser``
+     */
+    constructor(parent: cdk.Construct, name: string, properties?: CfnUserProps);
+    readonly propertyOverrides: CfnUserProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
+export declare namespace CfnUser {
+    /**
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user-loginprofile.html
+     */
+    interface LoginProfileProperty {
+        /**
+         * ``CfnUser.LoginProfileProperty.Password``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user-loginprofile.html#cfn-iam-user-loginprofile-password
+         */
+        password: string | cdk.Token;
+        /**
+         * ``CfnUser.LoginProfileProperty.PasswordResetRequired``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user-loginprofile.html#cfn-iam-user-loginprofile-passwordresetrequired
+         */
+        passwordResetRequired?: boolean | cdk.Token;
+    }
+}
+export declare namespace CfnUser {
+    /**
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html
+     */
+    interface PolicyProperty {
+        /**
+         * ``CfnUser.PolicyProperty.PolicyDocument``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html#cfn-iam-policies-policydocument
+         */
+        policyDocument: object | cdk.Token;
+        /**
+         * ``CfnUser.PolicyProperty.PolicyName``
+         * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html#cfn-iam-policies-policyname
+         */
+        policyName: string | cdk.Token;
+    }
+}
 export declare namespace cloudformation {
@@ -474,2 +983,3 @@ /**
     /**
+     * @deprecated "cloudformation.UserResource" will be deprecated in a future release in favor of "CfnUser" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html
@@ -535,2 +1045,38 @@ */
 }
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html
+ */
+export interface CfnUserToGroupAdditionProps {
+    /**
+     * ``AWS::IAM::UserToGroupAddition.GroupName``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html#cfn-iam-addusertogroup-groupname
+     */
+    groupName: string | cdk.Token;
+    /**
+     * ``AWS::IAM::UserToGroupAddition.Users``
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html#cfn-iam-addusertogroup-users
+     */
+    users: Array<string | cdk.Token> | cdk.Token;
+}
+/**
+ * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html
+ */
+export declare class CfnUserToGroupAddition extends cdk.Resource {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly resourceTypeName = "AWS::IAM::UserToGroupAddition";
+    /**
+     * Creates a new ``AWS::IAM::UserToGroupAddition``.
+     *
+     * @param parent   the ``cdk.Construct`` this ``CfnUserToGroupAddition`` is a part of
+     * @param name     the name of the resource in the ``cdk.Construct`` tree
+     * @param properties the properties of this ``CfnUserToGroupAddition``
+     */
+    constructor(parent: cdk.Construct, name: string, properties: CfnUserToGroupAdditionProps);
+    readonly propertyOverrides: CfnUserToGroupAdditionProps;
+    protected renderProperties(properties: any): {
+        [key: string]: any;
+    };
+}
 export declare namespace cloudformation {
@@ -553,2 +1099,3 @@ /**
     /**
+     * @deprecated "cloudformation.UserToGroupAdditionResource" will be deprecated in a future release in favor of "CfnUserToGroupAddition" (see https://github.com/awslabs/aws-cdk/issues/878)
      * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html
@@ -555,0 +1102,0 @@ */

lib/policy-document.d.ts

@@ -27,3 +27,3 @@ import { Token } from '@aws-cdk/cdk';
      */
-    readonly assumeRoleAction: string;
+    assumeRoleAction: string;
     /**
@@ -42,3 +42,3 @@ * Return the policy fragment that identifies this principal in a Policy.
     readonly principalJson: {
-        [key: string]: any;
+        [key: string]: string[];
     };
@@ -49,3 +49,3 @@ readonly conditions: {
     constructor(principalJson: {
-        [key: string]: any;
+        [key: string]: string[];
     }, conditions?: {
@@ -86,13 +86,13 @@ [key: string]: any;
 export declare class CanonicalUserPrincipal extends PolicyPrincipal {
-    readonly canonicalUserId: any;
-    constructor(canonicalUserId: any);
+    readonly canonicalUserId: string;
+    constructor(canonicalUserId: string);
     policyFragment(): PrincipalPolicyFragment;
 }
 export declare class FederatedPrincipal extends PolicyPrincipal {
-    readonly federated: any;
+    readonly federated: string;
     readonly conditions: {
         [key: string]: any;
     };
-    readonly assumeRoleAction: string;
-    constructor(federated: any, conditions: {
+    assumeRoleAction: string;
+    constructor(federated: string, conditions: {
         [key: string]: any;
@@ -108,6 +108,18 @@ }, assumeRoleAction?: string);
  */
-export declare class Anyone extends ArnPrincipal {
+export declare class AnyPrincipal extends ArnPrincipal {
     constructor();
 }
 /**
+ * A principal representing all identities in all accounts
+ * @deprecated use `AnyPrincipal`
+ */
+export declare class Anyone extends AnyPrincipal {
+}
+export declare class CompositePrincipal extends PolicyPrincipal {
+    private readonly principals;
+    constructor(principal: PolicyPrincipal, ...additionalPrincipals: PolicyPrincipal[]);
+    addPrincipals(...principals: PolicyPrincipal[]): this;
+    policyFragment(): PrincipalPolicyFragment;
+}
+/**
  * Represents a statement in an IAM policy document.
@@ -129,10 +141,13 @@ */
     readonly hasPrincipal: boolean;
-    addPrincipal(principal: PolicyPrincipal): PolicyStatement;
-    addAwsPrincipal(arn: string): PolicyStatement;
-    addAwsAccountPrincipal(accountId: string): PolicyStatement;
-    addServicePrincipal(service: string): PolicyStatement;
+    addPrincipal(principal: PolicyPrincipal): this;
+    addAwsPrincipal(arn: string): this;
+    addArnPrincipal(arn: string): this;
+    addAwsAccountPrincipal(accountId: string): this;
+    addServicePrincipal(service: string): this;
     addFederatedPrincipal(federated: any, conditions: {
         [key: string]: any;
-    }): PolicyStatement;
-    addAccountRootPrincipal(): PolicyStatement;
+    }): this;
+    addAccountRootPrincipal(): this;
+    addCanonicalUserPrincipal(canonicalUserId: string): this;
+    addAnyPrincipal(): this;
     addResource(arn: string): PolicyStatement;
@@ -139,0 +154,0 @@ /**

lib/policy-document.js

@@ -72,3 +72,3 @@ "use strict";
     policyFragment() {
-        return new PrincipalPolicyFragment({ AWS: this.arn });
+        return new PrincipalPolicyFragment({ AWS: [this.arn] });
     }
@@ -93,3 +93,3 @@ }
     policyFragment() {
-        return new PrincipalPolicyFragment({ Service: this.service });
+        return new PrincipalPolicyFragment({ Service: [this.service] });
     }
@@ -117,3 +117,3 @@ }
     policyFragment() {
-        return new PrincipalPolicyFragment({ CanonicalUser: this.canonicalUserId });
+        return new PrincipalPolicyFragment({ CanonicalUser: [this.canonicalUserId] });
     }
@@ -130,3 +130,3 @@ }
     policyFragment() {
-        return new PrincipalPolicyFragment({ Federated: this.federated }, this.conditions);
+        return new PrincipalPolicyFragment({ Federated: [this.federated] }, this.conditions);
     }
@@ -144,3 +144,3 @@ }
  */
-class Anyone extends ArnPrincipal {
+class AnyPrincipal extends ArnPrincipal {
     constructor() {
@@ -150,3 +150,42 @@ super('*');
 }
+exports.AnyPrincipal = AnyPrincipal;
+/**
+ * A principal representing all identities in all accounts
+ * @deprecated use `AnyPrincipal`
+ */
+class Anyone extends AnyPrincipal {
+}
 exports.Anyone = Anyone;
+class CompositePrincipal extends PolicyPrincipal {
+    constructor(principal, ...additionalPrincipals) {
+        super();
+        this.principals = new Array();
+        this.assumeRoleAction = principal.assumeRoleAction;
+        this.addPrincipals(principal);
+        this.addPrincipals(...additionalPrincipals);
+    }
+    addPrincipals(...principals) {
+        for (const p of principals) {
+            if (p.assumeRoleAction !== this.assumeRoleAction) {
+                throw new Error(`Cannot add multiple principals with different "assumeRoleAction". ` +
+                    `Expecting "${this.assumeRoleAction}", got "${p.assumeRoleAction}"`);
+            }
+            const fragment = p.policyFragment();
+            if (fragment.conditions && Object.keys(fragment.conditions).length > 0) {
+                throw new Error(`Components of a CompositePrincipal must not have conditions. ` +
+                    `Tried to add the following fragment: ${JSON.stringify(fragment)}`);
+            }
+            this.principals.push(p);
+        }
+        return this;
+    }
+    policyFragment() {
+        const principalJson = {};
+        for (const p of this.principals) {
+            mergePrincipal(principalJson, p.policyFragment().principalJson);
+        }
+        return new PrincipalPolicyFragment(principalJson);
+    }
+}
+exports.CompositePrincipal = CompositePrincipal;
 /**
@@ -186,15 +225,3 @@ * Represents a statement in an IAM policy document.
         const fragment = principal.policyFragment();
-        for (const key of Object.keys(fragment.principalJson)) {
-            if (Object.keys(this.principal).length > 0 && !(key in this.principal)) {
-                throw new Error(`Attempted to add principal key ${key} in principal of type ${Object.keys(this.principal)[0]}`);
-            }
-            this.principal[key] = this.principal[key] || [];
-            const value = fragment.principalJson[key];
-            if (Array.isArray(value)) {
-                this.principal[key].push(...value);
-            }
-            else {
-                this.principal[key].push(value);
-            }
-        }
+        mergePrincipal(this.principal, fragment.principalJson);
         this.addConditions(fragment.conditions);
@@ -206,2 +233,5 @@ return this;
     }
+    addArnPrincipal(arn) {
+        return this.addAwsPrincipal(arn);
+    }
     addAwsAccountPrincipal(accountId) {
@@ -219,2 +249,8 @@ return this.addPrincipal(new AccountPrincipal(accountId));
     }
+    addCanonicalUserPrincipal(canonicalUserId) {
+        return this.addPrincipal(new CanonicalUserPrincipal(canonicalUserId));
+    }
+    addAnyPrincipal() {
+        return this.addPrincipal(new Anyone());
+    }
     //
@@ -356,2 +392,13 @@ // Resources
 })(PolicyStatementEffect = exports.PolicyStatementEffect || (exports.PolicyStatementEffect = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-document.js","sourceRoot":"","sources":["policy-document.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsAccountId, AwsPartition, Token } from '@aws-cdk/cdk';\n\nexport class PolicyDocument extends Token {\n  private statements = new Array<PolicyStatement>();\n\n  /**\n   * Creates a new IAM policy document.\n   * @param defaultDocument An IAM policy document to use as an initial\n   * policy. All statements of this document will be copied in.\n   */\n  constructor(private readonly baseDocument?: any) {\n    super();\n  }\n\n  public resolve(): any {\n    if (this.isEmpty) {\n      return undefined;\n    }\n\n    const doc = this.baseDocument || { };\n    doc.Statement = doc.Statement || [ ];\n    doc.Version = doc.Version || '2012-10-17';\n    doc.Statement = doc.Statement.concat(this.statements);\n    return doc;\n  }\n\n  get isEmpty(): boolean {\n    return this.statements.length === 0;\n  }\n\n  /**\n   * The number of statements already added to this policy.\n   * Can be used, for example, to generate uniuqe \"sid\"s within the policy.\n   */\n  get statementCount(): number {\n    return this.statements.length;\n  }\n\n  public addStatement(statement: PolicyStatement): PolicyDocument {\n    this.statements.push(statement);\n    return this;\n  }\n}\n\n/**\n * Represents an IAM principal.\n */\nexport abstract class PolicyPrincipal {\n  /**\n   * When this Principal is used in an AssumeRole policy, the action to use.\n   */\n  public readonly assumeRoleAction: string = 'sts:AssumeRole';\n\n  /**\n   * Return the policy fragment that identifies this principal in a Policy.\n   */\n  public abstract policyFragment(): PrincipalPolicyFragment;\n}\n\n/**\n * A collection of the fields in a PolicyStatement that can be used to identify a principal.\n *\n * This consists of the JSON used in the \"Principal\" field, and optionally a\n * set of \"Condition\"s that need to be applied to the policy.\n */\nexport class PrincipalPolicyFragment {\n  constructor(\n    public readonly principalJson: { [key: string]: any },\n    public readonly conditions: {[key: string]: any} = {}) {\n  }\n}\n\nexport class ArnPrincipal extends PolicyPrincipal {\n  constructor(public readonly arn: string) {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ AWS: this.arn });\n  }\n}\n\nexport class AccountPrincipal extends ArnPrincipal {\n  constructor(public readonly accountId: any) {\n    super(`arn:${new AwsPartition()}:iam::${accountId}:root`);\n  }\n}\n\n/**\n * An IAM principal that represents an AWS service (i.e. sqs.amazonaws.com).\n */\nexport class ServicePrincipal extends PolicyPrincipal {\n  constructor(public readonly service: string) {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ Service: this.service });\n  }\n}\n\n/**\n * A policy prinicipal for canonicalUserIds - useful for S3 bucket policies that use\n * Origin Access identities.\n *\n * See https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html\n *\n * and\n *\n * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html\n *\n * for more details.\n *\n */\nexport class CanonicalUserPrincipal extends PolicyPrincipal {\n  constructor(public readonly canonicalUserId: any) {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ CanonicalUser: this.canonicalUserId });\n  }\n}\n\nexport class FederatedPrincipal extends PolicyPrincipal {\n  constructor(\n    public readonly federated: any,\n    public readonly conditions: {[key: string]: any},\n    public readonly assumeRoleAction: string = 'sts:AssumeRole') {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ Federated: this.federated }, this.conditions);\n  }\n}\n\nexport class AccountRootPrincipal extends AccountPrincipal {\n  constructor() {\n    super(new AwsAccountId());\n  }\n}\n\n/**\n * A principal representing all identities in all accounts\n */\nexport class Anyone extends ArnPrincipal {\n  constructor() {\n    super('*');\n  }\n}\n\n/**\n * Represents a statement in an IAM policy document.\n */\nexport class PolicyStatement extends Token {\n  private action = new Array<any>();\n  private principal: { [key: string]: any[] } = {};\n  private resource = new Array<any>();\n  private condition: { [key: string]: any } = { };\n  private effect?: PolicyStatementEffect;\n  private sid?: any;\n\n  constructor(effect: PolicyStatementEffect = PolicyStatementEffect.Allow) {\n    super();\n    this.effect = effect;\n  }\n\n  //\n  // Actions\n  //\n\n  public addAction(action: string): PolicyStatement {\n    this.action.push(action);\n    return this;\n  }\n\n  public addActions(...actions: string[]): PolicyStatement {\n    actions.forEach(action => this.addAction(action));\n    return this;\n  }\n\n  //\n  // Principal\n  //\n\n  /**\n   * Indicates if this permission has a \"Principal\" section.\n   */\n  public get hasPrincipal() {\n    return Object.keys(this.principal).length > 0;\n  }\n\n  public addPrincipal(principal: PolicyPrincipal): PolicyStatement {\n    const fragment = principal.policyFragment();\n    for (const key of Object.keys(fragment.principalJson)) {\n      if (Object.keys(this.principal).length > 0 && !(key in this.principal)) {\n        throw new Error(`Attempted to add principal key ${key} in principal of type ${Object.keys(this.principal)[0]}`);\n      }\n      this.principal[key] = this.principal[key] || [];\n      const value = fragment.principalJson[key];\n      if (Array.isArray(value)) {\n        this.principal[key].push(...value);\n      } else {\n        this.principal[key].push(value);\n      }\n    }\n    this.addConditions(fragment.conditions);\n    return this;\n  }\n\n  public addAwsPrincipal(arn: string): PolicyStatement {\n    return this.addPrincipal(new ArnPrincipal(arn));\n  }\n\n  public addAwsAccountPrincipal(accountId: string): PolicyStatement {\n    return this.addPrincipal(new AccountPrincipal(accountId));\n  }\n\n  public addServicePrincipal(service: string): PolicyStatement {\n    return this.addPrincipal(new ServicePrincipal(service));\n  }\n\n  public addFederatedPrincipal(federated: any, conditions: {[key: string]: any}): PolicyStatement {\n    return this.addPrincipal(new FederatedPrincipal(federated, conditions));\n  }\n\n  public addAccountRootPrincipal(): PolicyStatement {\n    return this.addPrincipal(new AccountRootPrincipal());\n  }\n\n  //\n  // Resources\n  //\n\n  public addResource(arn: string): PolicyStatement {\n    this.resource.push(arn);\n    return this;\n  }\n\n  /**\n   * Adds a ``\"*\"`` resource to this statement.\n   */\n  public addAllResources(): PolicyStatement {\n    return this.addResource('*');\n  }\n\n  public addResources(...arns: string[]): PolicyStatement {\n    arns.forEach(r => this.addResource(r));\n    return this;\n  }\n\n  /**\n   * Indicates if this permission as at least one resource associated with it.\n   */\n  public get hasResource() {\n    return this.resource && this.resource.length > 0;\n  }\n\n  public describe(sid: string): PolicyStatement {\n    this.sid = sid;\n    return this;\n  }\n\n  //\n  // Effect\n  //\n\n  /**\n   * Sets the permission effect to allow access to resources.\n   */\n  public allow(): PolicyStatement {\n    this.effect = PolicyStatementEffect.Allow;\n    return this;\n  }\n\n  /**\n   * Sets the permission effect to deny access to resources.\n   */\n  public deny(): PolicyStatement {\n    this.effect = PolicyStatementEffect.Deny;\n    return this;\n  }\n\n  //\n  // Condition\n  //\n\n  /**\n   * Add a condition to the Policy\n   */\n  public addCondition(key: string, value: any): PolicyStatement {\n    this.condition[key] = value;\n    return this;\n  }\n\n  /**\n   * Add multiple conditions to the Policy\n   */\n  public addConditions(conditions: {[key: string]: any}): PolicyStatement {\n    Object.keys(conditions).map(key => {\n      this.addCondition(key, conditions[key]);\n    });\n    return this;\n  }\n\n  /**\n   * Add a condition to the Policy.\n   *\n   * @deprecated For backwards compatibility. Use addCondition() instead.\n   */\n  public setCondition(key: string, value: any): PolicyStatement {\n    return this.addCondition(key, value);\n  }\n\n  public limitToAccount(accountId: string): PolicyStatement {\n    return this.addCondition('StringEquals', new Token(() => {\n      return { 'sts:ExternalId': accountId };\n    }));\n  }\n\n  //\n  // Serialization\n  //\n\n  public resolve(): any {\n    return this.toJson();\n  }\n\n  public toJson(): any {\n    return {\n      Action: _norm(this.action),\n      Condition: _norm(this.condition),\n      Effect: _norm(this.effect),\n      Principal: _normPrincipal(this.principal),\n      Resource: _norm(this.resource),\n      Sid: _norm(this.sid),\n    };\n\n    function _norm(values: any) {\n\n      if (typeof(values) === 'undefined') {\n        return undefined;\n      }\n\n      if (Array.isArray(values)) {\n        if (!values || values.length === 0) {\n          return undefined;\n        }\n\n        if (values.length === 1) {\n          return values[0];\n        }\n\n        return values;\n      }\n\n      if (typeof(values) === 'object') {\n        if (Object.keys(values).length === 0) {\n          return undefined;\n        }\n      }\n\n      return values;\n    }\n\n    function _normPrincipal(principal: { [key: string]: any[] }) {\n      const keys = Object.keys(principal);\n      if (keys.length === 0) { return undefined; }\n      const result: any = {};\n      for (const key of keys) {\n        const normVal = _norm(principal[key]);\n        if (normVal) {\n          result[key] = normVal;\n        }\n      }\n      if (Object.keys(result).length === 1 && result.AWS === '*') {\n        return '*';\n      }\n      return result;\n    }\n  }\n}\n\nexport enum PolicyStatementEffect {\n  Allow = 'Allow',\n  Deny = 'Deny',\n}\n"]}
+function mergePrincipal(target, source) {
+    for (const key of Object.keys(source)) {
+        target[key] = target[key] || [];
+        const value = source[key];
+        if (!Array.isArray(value)) {
+            throw new Error(`Principal value must be an array (it will be normalized later): ${value}`);
+        }
+        target[key].push(...value);
+    }
+    return target;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-document.js","sourceRoot":"","sources":["policy-document.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsAccountId, AwsPartition, Token } from '@aws-cdk/cdk';\n\nexport class PolicyDocument extends Token {\n  private statements = new Array<PolicyStatement>();\n\n  /**\n   * Creates a new IAM policy document.\n   * @param defaultDocument An IAM policy document to use as an initial\n   * policy. All statements of this document will be copied in.\n   */\n  constructor(private readonly baseDocument?: any) {\n    super();\n  }\n\n  public resolve(): any {\n    if (this.isEmpty) {\n      return undefined;\n    }\n\n    const doc = this.baseDocument || { };\n    doc.Statement = doc.Statement || [ ];\n    doc.Version = doc.Version || '2012-10-17';\n    doc.Statement = doc.Statement.concat(this.statements);\n    return doc;\n  }\n\n  get isEmpty(): boolean {\n    return this.statements.length === 0;\n  }\n\n  /**\n   * The number of statements already added to this policy.\n   * Can be used, for example, to generate uniuqe \"sid\"s within the policy.\n   */\n  get statementCount(): number {\n    return this.statements.length;\n  }\n\n  public addStatement(statement: PolicyStatement): PolicyDocument {\n    this.statements.push(statement);\n    return this;\n  }\n}\n\n/**\n * Represents an IAM principal.\n */\nexport abstract class PolicyPrincipal {\n  /**\n   * When this Principal is used in an AssumeRole policy, the action to use.\n   */\n  public assumeRoleAction: string = 'sts:AssumeRole';\n\n  /**\n   * Return the policy fragment that identifies this principal in a Policy.\n   */\n  public abstract policyFragment(): PrincipalPolicyFragment;\n}\n\n/**\n * A collection of the fields in a PolicyStatement that can be used to identify a principal.\n *\n * This consists of the JSON used in the \"Principal\" field, and optionally a\n * set of \"Condition\"s that need to be applied to the policy.\n */\nexport class PrincipalPolicyFragment {\n  constructor(\n    public readonly principalJson: { [key: string]: string[] },\n    public readonly conditions: { [key: string]: any } = { }) {\n  }\n}\n\nexport class ArnPrincipal extends PolicyPrincipal {\n  constructor(public readonly arn: string) {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ AWS: [ this.arn ] });\n  }\n}\n\nexport class AccountPrincipal extends ArnPrincipal {\n  constructor(public readonly accountId: any) {\n    super(`arn:${new AwsPartition()}:iam::${accountId}:root`);\n  }\n}\n\n/**\n * An IAM principal that represents an AWS service (i.e. sqs.amazonaws.com).\n */\nexport class ServicePrincipal extends PolicyPrincipal {\n  constructor(public readonly service: string) {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ Service: [ this.service ] });\n  }\n}\n\n/**\n * A policy prinicipal for canonicalUserIds - useful for S3 bucket policies that use\n * Origin Access identities.\n *\n * See https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html\n *\n * and\n *\n * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html\n *\n * for more details.\n *\n */\nexport class CanonicalUserPrincipal extends PolicyPrincipal {\n  constructor(public readonly canonicalUserId: string) {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ CanonicalUser: [ this.canonicalUserId ] });\n  }\n}\n\nexport class FederatedPrincipal extends PolicyPrincipal {\n  constructor(\n    public readonly federated: string,\n    public readonly conditions: {[key: string]: any},\n    public assumeRoleAction: string = 'sts:AssumeRole') {\n    super();\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment({ Federated: [ this.federated ] }, this.conditions);\n  }\n}\n\nexport class AccountRootPrincipal extends AccountPrincipal {\n  constructor() {\n    super(new AwsAccountId());\n  }\n}\n\n/**\n * A principal representing all identities in all accounts\n */\nexport class AnyPrincipal extends ArnPrincipal {\n  constructor() {\n    super('*');\n  }\n}\n\n/**\n * A principal representing all identities in all accounts\n * @deprecated use `AnyPrincipal`\n */\nexport class Anyone extends AnyPrincipal { }\n\nexport class CompositePrincipal extends PolicyPrincipal {\n  private readonly principals = new Array<PolicyPrincipal>();\n\n  constructor(principal: PolicyPrincipal, ...additionalPrincipals: PolicyPrincipal[]) {\n    super();\n    this.assumeRoleAction = principal.assumeRoleAction;\n    this.addPrincipals(principal);\n    this.addPrincipals(...additionalPrincipals);\n  }\n\n  public addPrincipals(...principals: PolicyPrincipal[]): this {\n    for (const p of principals) {\n      if (p.assumeRoleAction !== this.assumeRoleAction) {\n        throw new Error(\n          `Cannot add multiple principals with different \"assumeRoleAction\". ` +\n          `Expecting \"${this.assumeRoleAction}\", got \"${p.assumeRoleAction}\"`);\n      }\n\n      const fragment = p.policyFragment();\n      if (fragment.conditions && Object.keys(fragment.conditions).length > 0) {\n        throw new Error(\n          `Components of a CompositePrincipal must not have conditions. ` +\n          `Tried to add the following fragment: ${JSON.stringify(fragment)}`);\n      }\n\n      this.principals.push(p);\n    }\n\n    return this;\n  }\n\n  public policyFragment(): PrincipalPolicyFragment {\n    const principalJson: { [key: string]: string[] } = { };\n\n    for (const p of this.principals) {\n      mergePrincipal(principalJson, p.policyFragment().principalJson);\n    }\n\n    return new PrincipalPolicyFragment(principalJson);\n  }\n}\n\n/**\n * Represents a statement in an IAM policy document.\n */\nexport class PolicyStatement extends Token {\n  private action = new Array<any>();\n  private principal: { [key: string]: any[] } = {};\n  private resource = new Array<any>();\n  private condition: { [key: string]: any } = { };\n  private effect?: PolicyStatementEffect;\n  private sid?: any;\n\n  constructor(effect: PolicyStatementEffect = PolicyStatementEffect.Allow) {\n    super();\n    this.effect = effect;\n  }\n\n  //\n  // Actions\n  //\n\n  public addAction(action: string): PolicyStatement {\n    this.action.push(action);\n    return this;\n  }\n\n  public addActions(...actions: string[]): PolicyStatement {\n    actions.forEach(action => this.addAction(action));\n    return this;\n  }\n\n  //\n  // Principal\n  //\n\n  /**\n   * Indicates if this permission has a \"Principal\" section.\n   */\n  public get hasPrincipal() {\n    return Object.keys(this.principal).length > 0;\n  }\n\n  public addPrincipal(principal: PolicyPrincipal): this {\n    const fragment = principal.policyFragment();\n    mergePrincipal(this.principal, fragment.principalJson);\n    this.addConditions(fragment.conditions);\n    return this;\n  }\n\n  public addAwsPrincipal(arn: string): this {\n    return this.addPrincipal(new ArnPrincipal(arn));\n  }\n\n  public addArnPrincipal(arn: string): this {\n    return this.addAwsPrincipal(arn);\n  }\n\n  public addAwsAccountPrincipal(accountId: string): this {\n    return this.addPrincipal(new AccountPrincipal(accountId));\n  }\n\n  public addServicePrincipal(service: string): this {\n    return this.addPrincipal(new ServicePrincipal(service));\n  }\n\n  public addFederatedPrincipal(federated: any, conditions: {[key: string]: any}): this {\n    return this.addPrincipal(new FederatedPrincipal(federated, conditions));\n  }\n\n  public addAccountRootPrincipal(): this {\n    return this.addPrincipal(new AccountRootPrincipal());\n  }\n\n  public addCanonicalUserPrincipal(canonicalUserId: string): this {\n    return this.addPrincipal(new CanonicalUserPrincipal(canonicalUserId));\n  }\n\n  public addAnyPrincipal(): this {\n    return this.addPrincipal(new Anyone());\n  }\n\n  //\n  // Resources\n  //\n\n  public addResource(arn: string): PolicyStatement {\n    this.resource.push(arn);\n    return this;\n  }\n\n  /**\n   * Adds a ``\"*\"`` resource to this statement.\n   */\n  public addAllResources(): PolicyStatement {\n    return this.addResource('*');\n  }\n\n  public addResources(...arns: string[]): PolicyStatement {\n    arns.forEach(r => this.addResource(r));\n    return this;\n  }\n\n  /**\n   * Indicates if this permission as at least one resource associated with it.\n   */\n  public get hasResource() {\n    return this.resource && this.resource.length > 0;\n  }\n\n  public describe(sid: string): PolicyStatement {\n    this.sid = sid;\n    return this;\n  }\n\n  //\n  // Effect\n  //\n\n  /**\n   * Sets the permission effect to allow access to resources.\n   */\n  public allow(): PolicyStatement {\n    this.effect = PolicyStatementEffect.Allow;\n    return this;\n  }\n\n  /**\n   * Sets the permission effect to deny access to resources.\n   */\n  public deny(): PolicyStatement {\n    this.effect = PolicyStatementEffect.Deny;\n    return this;\n  }\n\n  //\n  // Condition\n  //\n\n  /**\n   * Add a condition to the Policy\n   */\n  public addCondition(key: string, value: any): PolicyStatement {\n    this.condition[key] = value;\n    return this;\n  }\n\n  /**\n   * Add multiple conditions to the Policy\n   */\n  public addConditions(conditions: {[key: string]: any}): PolicyStatement {\n    Object.keys(conditions).map(key => {\n      this.addCondition(key, conditions[key]);\n    });\n    return this;\n  }\n\n  /**\n   * Add a condition to the Policy.\n   *\n   * @deprecated For backwards compatibility. Use addCondition() instead.\n   */\n  public setCondition(key: string, value: any): PolicyStatement {\n    return this.addCondition(key, value);\n  }\n\n  public limitToAccount(accountId: string): PolicyStatement {\n    return this.addCondition('StringEquals', new Token(() => {\n      return { 'sts:ExternalId': accountId };\n    }));\n  }\n\n  //\n  // Serialization\n  //\n\n  public resolve(): any {\n    return this.toJson();\n  }\n\n  public toJson(): any {\n    return {\n      Action: _norm(this.action),\n      Condition: _norm(this.condition),\n      Effect: _norm(this.effect),\n      Principal: _normPrincipal(this.principal),\n      Resource: _norm(this.resource),\n      Sid: _norm(this.sid),\n    };\n\n    function _norm(values: any) {\n\n      if (typeof(values) === 'undefined') {\n        return undefined;\n      }\n\n      if (Array.isArray(values)) {\n        if (!values || values.length === 0) {\n          return undefined;\n        }\n\n        if (values.length === 1) {\n          return values[0];\n        }\n\n        return values;\n      }\n\n      if (typeof(values) === 'object') {\n        if (Object.keys(values).length === 0) {\n          return undefined;\n        }\n      }\n\n      return values;\n    }\n\n    function _normPrincipal(principal: { [key: string]: any[] }) {\n      const keys = Object.keys(principal);\n      if (keys.length === 0) { return undefined; }\n      const result: any = {};\n      for (const key of keys) {\n        const normVal = _norm(principal[key]);\n        if (normVal) {\n          result[key] = normVal;\n        }\n      }\n      if (Object.keys(result).length === 1 && result.AWS === '*') {\n        return '*';\n      }\n      return result;\n    }\n  }\n}\n\nexport enum PolicyStatementEffect {\n  Allow = 'Allow',\n  Deny = 'Deny',\n}\n\nfunction mergePrincipal(target: { [key: string]: string[] }, source: { [key: string]: string[] }) {\n  for (const key of Object.keys(source)) {\n    target[key] = target[key] || [];\n\n    const value = source[key];\n    if (!Array.isArray(value)) {\n      throw new Error(`Principal value must be an array (it will be normalized later): ${value}`);\n    }\n\n    target[key].push(...value);\n  }\n\n  return target;\n}\n"]}

lib/policy.js

@@ -23,3 +23,3 @@ "use strict";
         this.groups = new Array();
-        const resource = new iam_generated_1.cloudformation.PolicyResource(this, 'Resource', {
+        const resource = new iam_generated_1.CfnPolicy(this, 'Resource', {
             policyDocument: this.document,
@@ -99,2 +99,2 @@ policyName: new cdk_1.Token(() => this.policyName),
 exports.Policy = Policy;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy.js","sourceRoot":"","sources":["policy.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, IDependable, Token } from '@aws-cdk/cdk';\nimport { Group } from './group';\nimport { cloudformation } from './iam.generated';\nimport { PolicyDocument, PolicyPrincipal, PolicyStatement } from './policy-document';\nimport { Role } from './role';\nimport { User } from './user';\nimport { generatePolicyName, undefinedIfEmpty } from './util';\n\n/**\n * A construct that represents an IAM principal, such as a user, group or role.\n */\nexport interface IPrincipal {\n  /**\n   * The IAM principal of this identity (i.e. AWS principal, service principal, etc).\n   */\n  readonly principal: PolicyPrincipal;\n\n  /**\n   * Adds an IAM statement to the default inline policy associated with this\n   * principal. If a policy doesn't exist, it is created.\n   */\n  addToPolicy(statement: PolicyStatement): void;\n\n  /**\n   * Attaches an inline policy to this principal.\n   * This is the same as calling `policy.addToXxx(principal)`.\n   * @param policy The policy resource to attach to this principal.\n   */\n  attachInlinePolicy(policy: Policy): void;\n\n  /**\n   * Attaches a managed policy to this principal.\n   * @param arn The ARN of the managed policy\n   */\n  attachManagedPolicy(arn: string): void;\n}\n\n/**\n * @deprecated Use IPrincipal\n */\n// tslint:disable-next-line:no-empty-interface\nexport type IIdentityResource = IPrincipal;\n\nexport interface PolicyProps {\n  /**\n   * The name of the policy. If you specify multiple policies for an entity,\n   * specify unique names. For example, if you specify a list of policies for\n   * an IAM role, each policy must have a unique name.\n   *\n   * @default Uses the logical ID of the policy resource, which is ensured to\n   *      be unique within the stack.\n   */\n  policyName?: string;\n\n  /**\n   * Users to attach this policy to.\n   * You can also use `attachToUser(user)` to attach this policy to a user.\n   */\n  users?: User[];\n\n  /**\n   * Roles to attach this policy to.\n   * You can also use `attachToRole(role)` to attach this policy to a role.\n   */\n  roles?: Role[];\n\n  /**\n   * Groups to attach this policy to.\n   * You can also use `attachToGroup(group)` to attach this policy to a group.\n   */\n  groups?: Group[];\n\n  /**\n   * Initial set of permissions to add to this policy document.\n   * You can also use `addPermission(statement)` to add permissions later.\n   */\n  statements?: PolicyStatement[];\n}\n\n/**\n * The AWS::IAM::Policy resource associates an IAM policy with IAM users, roles,\n * or groups. For more information about IAM policies, see [Overview of IAM\n * Policies](http://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html)\n * in the IAM User Guide guide.\n */\nexport class Policy extends Construct implements IDependable {\n  /**\n   * The policy document.\n   */\n  public readonly document = new PolicyDocument();\n\n  /**\n   * The name of this policy.\n   */\n  public readonly policyName: string;\n\n  /**\n   * Lists all the elements consumers should \"depend-on\".\n   */\n  public readonly dependencyElements: IDependable[];\n\n  private readonly roles = new Array<Role>();\n  private readonly users = new Array<User>();\n  private readonly groups = new Array<Group>();\n\n  constructor(parent: Construct, name: string, props: PolicyProps = {}) {\n    super(parent, name);\n\n    const resource = new cloudformation.PolicyResource(this, 'Resource', {\n      policyDocument: this.document,\n      policyName: new Token(() => this.policyName),\n      roles: undefinedIfEmpty(() => this.roles.map(r => r.roleName)),\n      users: undefinedIfEmpty(() => this.users.map(u => u.userName)),\n      groups: undefinedIfEmpty(() => this.groups.map(g => g.groupName)),\n    });\n\n    // generatePolicyName will take the last 128 characters of the logical id since\n    // policy names are limited to 128. the last 8 chars are a stack-unique hash, so\n    // that shouod be sufficient to ensure uniqueness within a principal.\n    this.policyName = props.policyName || generatePolicyName(resource.logicalId);\n    this.dependencyElements = [ resource ];\n\n    if (props.users) {\n      props.users.forEach(u => this.attachToUser(u));\n    }\n\n    if (props.groups) {\n      props.groups.forEach(g => this.attachToGroup(g));\n    }\n\n    if (props.roles) {\n      props.roles.forEach(r => this.attachToRole(r));\n    }\n\n    if (props.statements) {\n      props.statements.forEach(p => this.addStatement(p));\n    }\n  }\n\n  /**\n   * Adds a statement to the policy document.\n   */\n  public addStatement(statement: PolicyStatement) {\n    this.document.addStatement(statement);\n  }\n\n  /**\n   * Attaches this policy to a user.\n   */\n  public attachToUser(user: User) {\n    if (this.users.find(u => u === user)) { return; }\n    this.users.push(user);\n    user.attachInlinePolicy(this);\n  }\n\n  /**\n   * Attaches this policy to a role.\n   */\n  public attachToRole(role: Role) {\n    if (this.roles.find(r => r === role)) { return; }\n    this.roles.push(role);\n    role.attachInlinePolicy(this);\n  }\n\n  /**\n   * Attaches this policy to a group.\n   */\n  public attachToGroup(group: Group) {\n    if (this.groups.find(g => g === group)) { return; }\n    this.groups.push(group);\n    group.attachInlinePolicy(this);\n  }\n\n  public validate(): string[] {\n    const result = new Array<string>();\n\n    // validate that the policy document is not empty\n    if (this.document.isEmpty) {\n      result.push('Policy is empty. You must add statements to the policy');\n    }\n\n    // validate that the policy is attached to at least one principal (role, user or group).\n    if (this.groups.length + this.users.length + this.roles.length === 0) {\n      result.push(`Policy must be attached to at least one principal: user, group or role`);\n    }\n\n    return result;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy.js","sourceRoot":"","sources":["policy.ts"],"names":[],"mappings":";;AAAA,sCAA6D;AAE7D,mDAA4C;AAC5C,uDAAqF;AAGrF,iCAA8D;AAyE9D;;;;;GAKG;AACH,MAAa,MAAO,SAAQ,eAAS;IAoBnC,YAAY,MAAiB,EAAE,IAAY,EAAE,QAAqB,EAAE;QAClE,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QApBtB;;WAEG;QACa,aAAQ,GAAG,IAAI,gCAAc,EAAE,CAAC;QAY/B,UAAK,GAAG,IAAI,KAAK,EAAQ,CAAC;QAC1B,UAAK,GAAG,IAAI,KAAK,EAAQ,CAAC;QAC1B,WAAM,GAAG,IAAI,KAAK,EAAS,CAAC;QAK3C,MAAM,QAAQ,GAAG,IAAI,yBAAS,CAAC,IAAI,EAAE,UAAU,EAAE;YAC/C,cAAc,EAAE,IAAI,CAAC,QAAQ;YAC7B,UAAU,EAAE,IAAI,WAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC;YAC5C,KAAK,EAAE,uBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC9D,KAAK,EAAE,uBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC9D,MAAM,EAAE,uBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;SAClE,CAAC,CAAC;QAEH,+EAA+E;QAC/E,gFAAgF;QAChF,qEAAqE;QACrE,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,yBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC7E,IAAI,CAAC,kBAAkB,GAAG,CAAE,QAAQ,CAAE,CAAC;QAEvC,IAAI,KAAK,CAAC,KAAK,EAAE;YACf,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;SAChD;QAED,IAAI,KAAK,CAAC,MAAM,EAAE;YAChB,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;SAClD;QAED,IAAI,KAAK,CAAC,KAAK,EAAE;YACf,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;SAChD;QAED,IAAI,KAAK,CAAC,UAAU,EAAE;YACpB,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;SACrD;IACH,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,SAA0B;QAC5C,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,IAAU;QAC5B,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE;YAAE,OAAO;SAAE;QACjD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,IAAU;QAC5B,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE;YAAE,OAAO;SAAE;QACjD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,aAAa,CAAC,KAAY;QAC/B,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,EAAE;YAAE,OAAO;SAAE;QACnD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,KAAK,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAEM,QAAQ;QACb,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QAEnC,iDAAiD;QACjD,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE;YACzB,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;SACvE;QAED,wFAAwF;QACxF,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACpE,MAAM,CAAC,IAAI,CAAC,wEAAwE,CAAC,CAAC;SACvF;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAvGD,wBAuGC","sourcesContent":["import { Construct, IDependable, Token } from '@aws-cdk/cdk';\nimport { Group } from './group';\nimport { CfnPolicy } from './iam.generated';\nimport { PolicyDocument, PolicyPrincipal, PolicyStatement } from './policy-document';\nimport { Role } from './role';\nimport { User } from './user';\nimport { generatePolicyName, undefinedIfEmpty } from './util';\n\n/**\n * A construct that represents an IAM principal, such as a user, group or role.\n */\nexport interface IPrincipal {\n  /**\n   * The IAM principal of this identity (i.e. AWS principal, service principal, etc).\n   */\n  readonly principal: PolicyPrincipal;\n\n  /**\n   * Adds an IAM statement to the default inline policy associated with this\n   * principal. If a policy doesn't exist, it is created.\n   */\n  addToPolicy(statement: PolicyStatement): void;\n\n  /**\n   * Attaches an inline policy to this principal.\n   * This is the same as calling `policy.addToXxx(principal)`.\n   * @param policy The policy resource to attach to this principal.\n   */\n  attachInlinePolicy(policy: Policy): void;\n\n  /**\n   * Attaches a managed policy to this principal.\n   * @param arn The ARN of the managed policy\n   */\n  attachManagedPolicy(arn: string): void;\n}\n\n/**\n * @deprecated Use IPrincipal\n */\n// tslint:disable-next-line:no-empty-interface\nexport type IIdentityResource = IPrincipal;\n\nexport interface PolicyProps {\n  /**\n   * The name of the policy. If you specify multiple policies for an entity,\n   * specify unique names. For example, if you specify a list of policies for\n   * an IAM role, each policy must have a unique name.\n   *\n   * @default Uses the logical ID of the policy resource, which is ensured to\n   *      be unique within the stack.\n   */\n  policyName?: string;\n\n  /**\n   * Users to attach this policy to.\n   * You can also use `attachToUser(user)` to attach this policy to a user.\n   */\n  users?: User[];\n\n  /**\n   * Roles to attach this policy to.\n   * You can also use `attachToRole(role)` to attach this policy to a role.\n   */\n  roles?: Role[];\n\n  /**\n   * Groups to attach this policy to.\n   * You can also use `attachToGroup(group)` to attach this policy to a group.\n   */\n  groups?: Group[];\n\n  /**\n   * Initial set of permissions to add to this policy document.\n   * You can also use `addPermission(statement)` to add permissions later.\n   */\n  statements?: PolicyStatement[];\n}\n\n/**\n * The AWS::IAM::Policy resource associates an IAM policy with IAM users, roles,\n * or groups. For more information about IAM policies, see [Overview of IAM\n * Policies](http://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html)\n * in the IAM User Guide guide.\n */\nexport class Policy extends Construct implements IDependable {\n  /**\n   * The policy document.\n   */\n  public readonly document = new PolicyDocument();\n\n  /**\n   * The name of this policy.\n   */\n  public readonly policyName: string;\n\n  /**\n   * Lists all the elements consumers should \"depend-on\".\n   */\n  public readonly dependencyElements: IDependable[];\n\n  private readonly roles = new Array<Role>();\n  private readonly users = new Array<User>();\n  private readonly groups = new Array<Group>();\n\n  constructor(parent: Construct, name: string, props: PolicyProps = {}) {\n    super(parent, name);\n\n    const resource = new CfnPolicy(this, 'Resource', {\n      policyDocument: this.document,\n      policyName: new Token(() => this.policyName),\n      roles: undefinedIfEmpty(() => this.roles.map(r => r.roleName)),\n      users: undefinedIfEmpty(() => this.users.map(u => u.userName)),\n      groups: undefinedIfEmpty(() => this.groups.map(g => g.groupName)),\n    });\n\n    // generatePolicyName will take the last 128 characters of the logical id since\n    // policy names are limited to 128. the last 8 chars are a stack-unique hash, so\n    // that shouod be sufficient to ensure uniqueness within a principal.\n    this.policyName = props.policyName || generatePolicyName(resource.logicalId);\n    this.dependencyElements = [ resource ];\n\n    if (props.users) {\n      props.users.forEach(u => this.attachToUser(u));\n    }\n\n    if (props.groups) {\n      props.groups.forEach(g => this.attachToGroup(g));\n    }\n\n    if (props.roles) {\n      props.roles.forEach(r => this.attachToRole(r));\n    }\n\n    if (props.statements) {\n      props.statements.forEach(p => this.addStatement(p));\n    }\n  }\n\n  /**\n   * Adds a statement to the policy document.\n   */\n  public addStatement(statement: PolicyStatement) {\n    this.document.addStatement(statement);\n  }\n\n  /**\n   * Attaches this policy to a user.\n   */\n  public attachToUser(user: User) {\n    if (this.users.find(u => u === user)) { return; }\n    this.users.push(user);\n    user.attachInlinePolicy(this);\n  }\n\n  /**\n   * Attaches this policy to a role.\n   */\n  public attachToRole(role: Role) {\n    if (this.roles.find(r => r === role)) { return; }\n    this.roles.push(role);\n    role.attachInlinePolicy(this);\n  }\n\n  /**\n   * Attaches this policy to a group.\n   */\n  public attachToGroup(group: Group) {\n    if (this.groups.find(g => g === group)) { return; }\n    this.groups.push(group);\n    group.attachInlinePolicy(this);\n  }\n\n  public validate(): string[] {\n    const result = new Array<string>();\n\n    // validate that the policy document is not empty\n    if (this.document.isEmpty) {\n      result.push('Policy is empty. You must add statements to the policy');\n    }\n\n    // validate that the policy is attached to at least one principal (role, user or group).\n    if (this.groups.length + this.users.length + this.roles.length === 0) {\n      result.push(`Policy must be attached to at least one principal: user, group or role`);\n    }\n\n    return result;\n  }\n}\n"]}

lib/role.d.ts

@@ -14,2 +14,11 @@ import { Construct, IDependable } from '@aws-cdk/cdk';
     /**
+     * ID that the role assumer needs to provide when assuming this role
+     *
+     * If the configured and provided external IDs do not match, the
+     * AssumeRole operation will fail.
+     *
+     * @default No external ID required
+     */
+    externalId?: string;
+    /**
      * A list of ARNs for managed policies associated with this role.
@@ -16,0 +25,0 @@ * You can add managed policies later using `attachManagedPolicy(arn)`.

lib/role.js

@@ -18,6 +18,6 @@ "use strict";
         this.attachedPolicies = new util_1.AttachedPolicies();
-        this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy);
+        this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy, props.externalId);
         this.managedPolicyArns = props.managedPolicyArns || [];
         validateMaxSessionDuration(props.maxSessionDurationSec);
-        const role = new iam_generated_1.cloudformation.RoleResource(this, 'Resource', {
+        const role = new iam_generated_1.CfnRole(this, 'Resource', {
             assumeRolePolicyDocument: this.assumeRolePolicy,
@@ -82,7 +82,11 @@ managedPolicyArns: util_1.undefinedIfEmpty(() => this.managedPolicyArns),
 exports.Role = Role;
-function createAssumeRolePolicy(principal) {
-    return new policy_document_1.PolicyDocument()
-        .addStatement(new policy_document_1.PolicyStatement()
+function createAssumeRolePolicy(principal, externalId) {
+    const statement = new policy_document_1.PolicyStatement();
+    statement
         .addPrincipal(principal)
-        .addAction(principal.assumeRoleAction));
+        .addAction(principal.assumeRoleAction);
+    if (externalId !== undefined) {
+        statement.addCondition('StringEquals', { 'sts:ExternalId': externalId });
+    }
+    return new policy_document_1.PolicyDocument().addStatement(statement);
 }
@@ -117,2 +121,2 @@ function validateMaxSessionDuration(duration) {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role.js","sourceRoot":"","sources":["role.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, IDependable } from '@aws-cdk/cdk';\nimport { cloudformation } from './iam.generated';\nimport { IPrincipal, Policy } from './policy';\nimport { ArnPrincipal, PolicyDocument, PolicyPrincipal, PolicyStatement } from './policy-document';\nimport { AttachedPolicies, undefinedIfEmpty } from './util';\n\nexport interface RoleProps {\n  /**\n   * The IAM principal (i.e. `new ServicePrincipal('sns.amazonaws.com')`)\n   * which can assume this role.\n   *\n   * You can later modify the assume role policy document by accessing it via\n   * the `assumeRolePolicy` property.\n   */\n  assumedBy: PolicyPrincipal;\n\n  /**\n   * A list of ARNs for managed policies associated with this role.\n   * You can add managed policies later using `attachManagedPolicy(arn)`.\n   * @default No managed policies.\n   */\n  managedPolicyArns?: string[];\n\n  /**\n   * A list of named policies to inline into this role. These policies will be\n   * created with the role, whereas those added by ``addToPolicy`` are added\n   * using a separate CloudFormation resource (allowing a way around circular\n   * dependencies that could otherwise be introduced).\n   * @default No policy is inlined in the Role resource.\n   */\n  inlinePolicies?: { [name: string]: PolicyDocument };\n\n  /**\n   * The path associated with this role. For information about IAM paths, see\n   * Friendly Names and Paths in IAM User Guide.\n   */\n  path?: string;\n\n  /**\n   * A name for the IAM role. For valid values, see the RoleName parameter for\n   * the CreateRole action in the IAM API Reference. If you don't specify a\n   * name, AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the group name.\n   *\n   * IMPORTANT: If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   */\n  roleName?: string;\n\n  /**\n   * The maximum session duration (in seconds) that you want to set for the\n   * specified role. If you do not specify a value for this setting, the\n   * default maximum of one hour is applied. This setting can have a value\n   * from 1 hour (3600sec) to 12 (43200sec) hours.\n   *\n   * Anyone who assumes the role from the AWS CLI or API can use the\n   * DurationSeconds API parameter or the duration-seconds CLI parameter to\n   * request a longer session. The MaxSessionDuration setting determines the\n   * maximum duration that can be requested using the DurationSeconds\n   * parameter.\n   *\n   * If users don't specify a value for the DurationSeconds parameter, their\n   * security credentials are valid for one hour by default. This applies when\n   * you use the AssumeRole* API operations or the assume-role* CLI operations\n   * but does not apply when you use those operations to create a console URL.\n   *\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html\n   */\n  maxSessionDurationSec?: number;\n}\n\n/**\n * IAM Role\n *\n * Defines an IAM role. The role is created with an assume policy document associated with\n * the specified AWS service principal defined in `serviceAssumeRole`.\n */\nexport class Role extends Construct implements IRole {\n  /**\n   * Import a role that already exists\n   */\n  public static import(parent: Construct, id: string, props: ImportedRoleProps): IRole {\n    return new ImportedRole(parent, id, props);\n  }\n\n  /**\n   * The assume role policy document associated with this role.\n   */\n  public readonly assumeRolePolicy?: PolicyDocument;\n\n  /**\n   * Returns the ARN of this role.\n   */\n  public readonly roleArn: string;\n\n  /**\n   * Returns the name of the role.\n   */\n  public readonly roleName: string;\n\n  /**\n   * Returns the ARN of this role.\n   */\n  public readonly principal: PolicyPrincipal;\n\n  /**\n   * Returns the role.\n   */\n  public readonly dependencyElements: IDependable[];\n\n  private defaultPolicy?: Policy;\n  private readonly managedPolicyArns: string[];\n  private readonly attachedPolicies = new AttachedPolicies();\n\n  constructor(parent: Construct, name: string, props: RoleProps) {\n    super(parent, name);\n\n    this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy);\n    this.managedPolicyArns = props.managedPolicyArns || [ ];\n\n    validateMaxSessionDuration(props.maxSessionDurationSec);\n\n    const role = new cloudformation.RoleResource(this, 'Resource', {\n      assumeRolePolicyDocument: this.assumeRolePolicy as any,\n      managedPolicyArns: undefinedIfEmpty(() => this.managedPolicyArns),\n      policies: _flatten(props.inlinePolicies),\n      path: props.path,\n      roleName: props.roleName,\n      maxSessionDuration: props.maxSessionDurationSec,\n    });\n\n    this.roleArn = role.roleArn;\n    this.principal = new ArnPrincipal(this.roleArn);\n    this.roleName = role.roleName;\n    this.dependencyElements = [ role ];\n\n    function _flatten(policies?: { [name: string]: PolicyDocument }) {\n      if (policies == null || Object.keys(policies).length === 0) {\n        return undefined;\n      }\n      const result = new Array<cloudformation.RoleResource.PolicyProperty>();\n      for (const policyName of Object.keys(policies)) {\n        const policyDocument = policies[policyName];\n        result.push({ policyName, policyDocument });\n      }\n      return result;\n    }\n  }\n\n  /**\n   * Adds a permission to the role's default policy document.\n   * If there is no default policy attached to this role, it will be created.\n   * @param permission The permission statement to add to the policy document\n   */\n  public addToPolicy(statement: PolicyStatement) {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.attachInlinePolicy(this.defaultPolicy);\n      this.dependencyElements.push(this.defaultPolicy);\n    }\n    this.defaultPolicy.addStatement(statement);\n  }\n\n  /**\n   * Attaches a managed policy to this role.\n   * @param arn The ARN of the managed policy to attach.\n   */\n  public attachManagedPolicy(arn: string) {\n    this.managedPolicyArns.push(arn);\n  }\n\n  /**\n   * Attaches a policy to this role.\n   * @param policy The policy to attach\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToRole(this);\n  }\n}\n\n/**\n * A Role object\n */\nexport interface IRole extends IPrincipal, IDependable {\n  /**\n   * Returns the ARN of this role.\n   */\n  readonly roleArn: string;\n}\n\nfunction createAssumeRolePolicy(principal: PolicyPrincipal) {\n  return new PolicyDocument()\n    .addStatement(new PolicyStatement()\n      .addPrincipal(principal)\n      .addAction(principal.assumeRoleAction));\n}\n\nfunction validateMaxSessionDuration(duration?: number) {\n  if (duration === undefined) {\n    return;\n  }\n\n  if (duration < 3600 || duration > 43200) {\n    throw new Error(`maxSessionDuration is set to ${duration}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`);\n  }\n}\n\n/**\n * Properties to import a Role\n */\nexport interface ImportedRoleProps {\n  /**\n   * The role's ARN\n   */\n  roleArn: string;\n}\n\n/**\n * A role that already exists\n */\nclass ImportedRole extends Construct implements IRole {\n  public readonly roleArn: string;\n  public readonly principal: PolicyPrincipal;\n  public readonly dependencyElements: IDependable[] = [];\n\n  constructor(parent: Construct, id: string, props: ImportedRoleProps) {\n    super(parent, id);\n    this.roleArn = props.roleArn;\n    this.principal = new ArnPrincipal(this.roleArn);\n  }\n\n  public addToPolicy(_statement: PolicyStatement): void {\n    // FIXME: Add warning that we're ignoring this\n  }\n\n  public attachInlinePolicy(_policy: Policy): void {\n    // FIXME: Add warning that we're ignoring this\n  }\n\n  public attachManagedPolicy(_arn: string): void {\n    // FIXME: Add warning that we're ignoring this\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role.js","sourceRoot":"","sources":["role.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct, IDependable } from '@aws-cdk/cdk';\nimport { CfnRole } from './iam.generated';\nimport { IPrincipal, Policy } from './policy';\nimport { ArnPrincipal, PolicyDocument, PolicyPrincipal, PolicyStatement } from './policy-document';\nimport { AttachedPolicies, undefinedIfEmpty } from './util';\n\nexport interface RoleProps {\n  /**\n   * The IAM principal (i.e. `new ServicePrincipal('sns.amazonaws.com')`)\n   * which can assume this role.\n   *\n   * You can later modify the assume role policy document by accessing it via\n   * the `assumeRolePolicy` property.\n   */\n  assumedBy: PolicyPrincipal;\n\n  /**\n   * ID that the role assumer needs to provide when assuming this role\n   *\n   * If the configured and provided external IDs do not match, the\n   * AssumeRole operation will fail.\n   *\n   * @default No external ID required\n   */\n  externalId?: string;\n\n  /**\n   * A list of ARNs for managed policies associated with this role.\n   * You can add managed policies later using `attachManagedPolicy(arn)`.\n   * @default No managed policies.\n   */\n  managedPolicyArns?: string[];\n\n  /**\n   * A list of named policies to inline into this role. These policies will be\n   * created with the role, whereas those added by ``addToPolicy`` are added\n   * using a separate CloudFormation resource (allowing a way around circular\n   * dependencies that could otherwise be introduced).\n   * @default No policy is inlined in the Role resource.\n   */\n  inlinePolicies?: { [name: string]: PolicyDocument };\n\n  /**\n   * The path associated with this role. For information about IAM paths, see\n   * Friendly Names and Paths in IAM User Guide.\n   */\n  path?: string;\n\n  /**\n   * A name for the IAM role. For valid values, see the RoleName parameter for\n   * the CreateRole action in the IAM API Reference. If you don't specify a\n   * name, AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the group name.\n   *\n   * IMPORTANT: If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   */\n  roleName?: string;\n\n  /**\n   * The maximum session duration (in seconds) that you want to set for the\n   * specified role. If you do not specify a value for this setting, the\n   * default maximum of one hour is applied. This setting can have a value\n   * from 1 hour (3600sec) to 12 (43200sec) hours.\n   *\n   * Anyone who assumes the role from the AWS CLI or API can use the\n   * DurationSeconds API parameter or the duration-seconds CLI parameter to\n   * request a longer session. The MaxSessionDuration setting determines the\n   * maximum duration that can be requested using the DurationSeconds\n   * parameter.\n   *\n   * If users don't specify a value for the DurationSeconds parameter, their\n   * security credentials are valid for one hour by default. This applies when\n   * you use the AssumeRole* API operations or the assume-role* CLI operations\n   * but does not apply when you use those operations to create a console URL.\n   *\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html\n   */\n  maxSessionDurationSec?: number;\n}\n\n/**\n * IAM Role\n *\n * Defines an IAM role. The role is created with an assume policy document associated with\n * the specified AWS service principal defined in `serviceAssumeRole`.\n */\nexport class Role extends Construct implements IRole {\n  /**\n   * Import a role that already exists\n   */\n  public static import(parent: Construct, id: string, props: ImportedRoleProps): IRole {\n    return new ImportedRole(parent, id, props);\n  }\n\n  /**\n   * The assume role policy document associated with this role.\n   */\n  public readonly assumeRolePolicy?: PolicyDocument;\n\n  /**\n   * Returns the ARN of this role.\n   */\n  public readonly roleArn: string;\n\n  /**\n   * Returns the name of the role.\n   */\n  public readonly roleName: string;\n\n  /**\n   * Returns the ARN of this role.\n   */\n  public readonly principal: PolicyPrincipal;\n\n  /**\n   * Returns the role.\n   */\n  public readonly dependencyElements: IDependable[];\n\n  private defaultPolicy?: Policy;\n  private readonly managedPolicyArns: string[];\n  private readonly attachedPolicies = new AttachedPolicies();\n\n  constructor(parent: Construct, name: string, props: RoleProps) {\n    super(parent, name);\n\n    this.assumeRolePolicy = createAssumeRolePolicy(props.assumedBy, props.externalId);\n    this.managedPolicyArns = props.managedPolicyArns || [ ];\n\n    validateMaxSessionDuration(props.maxSessionDurationSec);\n\n    const role = new CfnRole(this, 'Resource', {\n      assumeRolePolicyDocument: this.assumeRolePolicy as any,\n      managedPolicyArns: undefinedIfEmpty(() => this.managedPolicyArns),\n      policies: _flatten(props.inlinePolicies),\n      path: props.path,\n      roleName: props.roleName,\n      maxSessionDuration: props.maxSessionDurationSec,\n    });\n\n    this.roleArn = role.roleArn;\n    this.principal = new ArnPrincipal(this.roleArn);\n    this.roleName = role.roleName;\n    this.dependencyElements = [ role ];\n\n    function _flatten(policies?: { [name: string]: PolicyDocument }) {\n      if (policies == null || Object.keys(policies).length === 0) {\n        return undefined;\n      }\n      const result = new Array<CfnRole.PolicyProperty>();\n      for (const policyName of Object.keys(policies)) {\n        const policyDocument = policies[policyName];\n        result.push({ policyName, policyDocument });\n      }\n      return result;\n    }\n  }\n\n  /**\n   * Adds a permission to the role's default policy document.\n   * If there is no default policy attached to this role, it will be created.\n   * @param permission The permission statement to add to the policy document\n   */\n  public addToPolicy(statement: PolicyStatement) {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.attachInlinePolicy(this.defaultPolicy);\n      this.dependencyElements.push(this.defaultPolicy);\n    }\n    this.defaultPolicy.addStatement(statement);\n  }\n\n  /**\n   * Attaches a managed policy to this role.\n   * @param arn The ARN of the managed policy to attach.\n   */\n  public attachManagedPolicy(arn: string) {\n    this.managedPolicyArns.push(arn);\n  }\n\n  /**\n   * Attaches a policy to this role.\n   * @param policy The policy to attach\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToRole(this);\n  }\n}\n\n/**\n * A Role object\n */\nexport interface IRole extends IPrincipal, IDependable {\n  /**\n   * Returns the ARN of this role.\n   */\n  readonly roleArn: string;\n}\n\nfunction createAssumeRolePolicy(principal: PolicyPrincipal, externalId?: string) {\n  const statement = new PolicyStatement();\n  statement\n      .addPrincipal(principal)\n      .addAction(principal.assumeRoleAction);\n\n  if (externalId !== undefined) {\n    statement.addCondition('StringEquals', { 'sts:ExternalId': externalId });\n  }\n\n  return new PolicyDocument().addStatement(statement);\n}\n\nfunction validateMaxSessionDuration(duration?: number) {\n  if (duration === undefined) {\n    return;\n  }\n\n  if (duration < 3600 || duration > 43200) {\n    throw new Error(`maxSessionDuration is set to ${duration}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`);\n  }\n}\n\n/**\n * Properties to import a Role\n */\nexport interface ImportedRoleProps {\n  /**\n   * The role's ARN\n   */\n  roleArn: string;\n}\n\n/**\n * A role that already exists\n */\nclass ImportedRole extends Construct implements IRole {\n  public readonly roleArn: string;\n  public readonly principal: PolicyPrincipal;\n  public readonly dependencyElements: IDependable[] = [];\n\n  constructor(parent: Construct, id: string, props: ImportedRoleProps) {\n    super(parent, id);\n    this.roleArn = props.roleArn;\n    this.principal = new ArnPrincipal(this.roleArn);\n  }\n\n  public addToPolicy(_statement: PolicyStatement): void {\n    // FIXME: Add warning that we're ignoring this\n  }\n\n  public attachInlinePolicy(_policy: Policy): void {\n    // FIXME: Add warning that we're ignoring this\n  }\n\n  public attachManagedPolicy(_arn: string): void {\n    // FIXME: Add warning that we're ignoring this\n  }\n}\n"]}

lib/user.js

@@ -14,3 +14,3 @@ "use strict";
         this.attachedPolicies = new util_1.AttachedPolicies();
-        const user = new iam_generated_1.cloudformation.UserResource(this, 'Resource', {
+        const user = new iam_generated_1.CfnUser(this, 'Resource', {
             userName: props.userName,
@@ -73,2 +73,2 @@ groups: util_1.undefinedIfEmpty(() => this.groups),
 exports.User = User;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.js","sourceRoot":"","sources":["user.ts"],"names":[],"mappings":";;AAAA,sCAAyC;AAEzC,mDAAiD;AACjD,qCAA8C;AAC9C,uDAAmF;AACnF,iCAA4D;AA2D5D,MAAa,IAAK,SAAQ,eAAS;IAsBjC,YAAY,MAAiB,EAAE,IAAY,EAAE,QAAmB,EAAE;QAChE,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QANL,WAAM,GAAG,IAAI,KAAK,EAAO,CAAC;QAC1B,sBAAiB,GAAG,IAAI,KAAK,EAAU,CAAC;QACxC,qBAAgB,GAAG,IAAI,uBAAgB,EAAE,CAAC;QAMzD,MAAM,IAAI,GAAG,IAAI,8BAAc,CAAC,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE;YAC7D,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,MAAM,EAAE,uBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;YAC3C,iBAAiB,EAAE,uBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC;YACjE,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,YAAY,EAAE,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;SAC5C,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,8BAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhD,IAAI,KAAK,CAAC,MAAM,EAAE;YAChB,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/C;IACH,CAAC;IAED;;OAEG;IACI,UAAU,CAAC,KAAY;QAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;;OAGG;IACI,mBAAmB,CAAC,GAAW;QACpC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,kBAAkB,CAAC,MAAc;QACtC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACrC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,SAA0B;QAC3C,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,IAAI,CAAC,aAAa,GAAG,IAAI,eAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;YACvD,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SACvC;QAED,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IAEO,iBAAiB,CAAC,KAAgB;QACxC,IAAI,KAAK,CAAC,QAAQ,EAAE;YAClB,OAAO;gBACL,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;aACnD,CAAC;SACH;QAED,IAAI,KAAK,CAAC,qBAAqB,EAAE;YAC/B,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;SAC5F;QAED,OAAO,SAAS,CAAC,CAAC,oBAAoB;IACxC,CAAC;CACF;AA3FD,oBA2FC","sourcesContent":["import { Construct } from '@aws-cdk/cdk';\nimport { Group } from './group';\nimport { cloudformation } from './iam.generated';\nimport { IPrincipal, Policy } from './policy';\nimport { ArnPrincipal, PolicyPrincipal, PolicyStatement } from './policy-document';\nimport { AttachedPolicies, undefinedIfEmpty } from './util';\n\nexport interface UserProps {\n  /**\n   * Groups to add this user to. You can also use `addToGroup` to add this\n   * user to a group.\n   */\n  groups?: Group[];\n\n  /**\n   * A list of ARNs for managed policies attacherd to this user.\n   * You can use `addManagedPolicy(arn)` to attach a managed policy to this user.\n   * @default No managed policies.\n   */\n  managedPolicyArns?: any[];\n\n  /**\n   * The path for the user name. For more information about paths, see IAM\n   * Identifiers in the IAM User Guide.\n   */\n  path?: string;\n\n  /**\n   * A name for the IAM user. For valid values, see the UserName parameter for\n   * the CreateUser action in the IAM API Reference. If you don't specify a\n   * name, AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the user name.\n   *\n   * If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default Generated by CloudFormation (recommended)\n   */\n  userName?: string;\n\n  /**\n   * The password for the user. This is required so the user can access the\n   * AWS Management Console.\n   *\n   * @default User won't be able to access the management console without a password.\n   */\n  password?: string;\n\n  /**\n   * Specifies whether the user is required to set a new password the next\n   * time the user logs in to the AWS Management Console.\n   *\n   * If this is set to 'true', you must also specify \"initialPassword\".\n   *\n   * @default false\n   */\n  passwordResetRequired?: boolean;\n}\n\nexport class User extends Construct implements IPrincipal {\n\n  /**\n   * An attribute that represents the user name.\n   */\n  public readonly userName: string;\n\n  /**\n   * An attribute that represents the user's ARN.\n   */\n  public readonly userArn: string;\n\n  /**\n   * Returns the ARN of this user.\n   */\n  public readonly principal: PolicyPrincipal;\n\n  private readonly groups = new Array<any>();\n  private readonly managedPolicyArns = new Array<string>();\n  private readonly attachedPolicies = new AttachedPolicies();\n  private defaultPolicy?: Policy;\n\n  constructor(parent: Construct, name: string, props: UserProps = {}) {\n    super(parent, name);\n\n    const user = new cloudformation.UserResource(this, 'Resource', {\n      userName: props.userName,\n      groups: undefinedIfEmpty(() => this.groups),\n      managedPolicyArns: undefinedIfEmpty(() => this.managedPolicyArns),\n      path: props.path,\n      loginProfile: this.parseLoginProfile(props)\n    });\n\n    this.userName = user.userName;\n    this.userArn = user.userArn;\n    this.principal = new ArnPrincipal(this.userArn);\n\n    if (props.groups) {\n      props.groups.forEach(g => this.addToGroup(g));\n    }\n  }\n\n  /**\n   * Adds this user to a group.\n   */\n  public addToGroup(group: Group) {\n    this.groups.push(group.groupName);\n  }\n\n  /**\n   * Attaches a managed policy to the user.\n   * @param arn The ARN of the managed policy to attach.\n   */\n  public attachManagedPolicy(arn: string) {\n    this.managedPolicyArns.push(arn);\n  }\n\n  /**\n   * Attaches a policy to this user.\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToUser(this);\n  }\n\n  /**\n   * Adds an IAM statement to the default policy.\n   */\n  public addToPolicy(statement: PolicyStatement) {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.defaultPolicy.attachToUser(this);\n    }\n\n    this.defaultPolicy.addStatement(statement);\n  }\n\n  private parseLoginProfile(props: UserProps): cloudformation.UserResource.LoginProfileProperty | undefined {\n    if (props.password) {\n      return {\n        password: props.password,\n        passwordResetRequired: props.passwordResetRequired\n      };\n    }\n\n    if (props.passwordResetRequired) {\n      throw new Error('Cannot set \"passwordResetRequired\" without specifying \"initialPassword\"');\n    }\n\n    return undefined; // no console access\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.js","sourceRoot":"","sources":["user.ts"],"names":[],"mappings":";;AAAA,sCAAyC;AAEzC,mDAA0C;AAC1C,qCAA8C;AAC9C,uDAAmF;AACnF,iCAA4D;AA2D5D,MAAa,IAAK,SAAQ,eAAS;IAsBjC,YAAY,MAAiB,EAAE,IAAY,EAAE,QAAmB,EAAE;QAChE,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QANL,WAAM,GAAG,IAAI,KAAK,EAAO,CAAC;QAC1B,sBAAiB,GAAG,IAAI,KAAK,EAAU,CAAC;QACxC,qBAAgB,GAAG,IAAI,uBAAgB,EAAE,CAAC;QAMzD,MAAM,IAAI,GAAG,IAAI,uBAAO,CAAC,IAAI,EAAE,UAAU,EAAE;YACzC,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,MAAM,EAAE,uBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;YAC3C,iBAAiB,EAAE,uBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC;YACjE,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,YAAY,EAAE,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;SAC5C,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,8BAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhD,IAAI,KAAK,CAAC,MAAM,EAAE;YAChB,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/C;IACH,CAAC;IAED;;OAEG;IACI,UAAU,CAAC,KAAY;QAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;;OAGG;IACI,mBAAmB,CAAC,GAAW;QACpC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,kBAAkB,CAAC,MAAc;QACtC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACrC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,SAA0B;QAC3C,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,IAAI,CAAC,aAAa,GAAG,IAAI,eAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;YACvD,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SACvC;QAED,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IAEO,iBAAiB,CAAC,KAAgB;QACxC,IAAI,KAAK,CAAC,QAAQ,EAAE;YAClB,OAAO;gBACL,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;aACnD,CAAC;SACH;QAED,IAAI,KAAK,CAAC,qBAAqB,EAAE;YAC/B,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;SAC5F;QAED,OAAO,SAAS,CAAC,CAAC,oBAAoB;IACxC,CAAC;CACF;AA3FD,oBA2FC","sourcesContent":["import { Construct } from '@aws-cdk/cdk';\nimport { Group } from './group';\nimport { CfnUser } from './iam.generated';\nimport { IPrincipal, Policy } from './policy';\nimport { ArnPrincipal, PolicyPrincipal, PolicyStatement } from './policy-document';\nimport { AttachedPolicies, undefinedIfEmpty } from './util';\n\nexport interface UserProps {\n  /**\n   * Groups to add this user to. You can also use `addToGroup` to add this\n   * user to a group.\n   */\n  groups?: Group[];\n\n  /**\n   * A list of ARNs for managed policies attacherd to this user.\n   * You can use `addManagedPolicy(arn)` to attach a managed policy to this user.\n   * @default No managed policies.\n   */\n  managedPolicyArns?: any[];\n\n  /**\n   * The path for the user name. For more information about paths, see IAM\n   * Identifiers in the IAM User Guide.\n   */\n  path?: string;\n\n  /**\n   * A name for the IAM user. For valid values, see the UserName parameter for\n   * the CreateUser action in the IAM API Reference. If you don't specify a\n   * name, AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the user name.\n   *\n   * If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to\n   * acknowledge your template's capabilities. For more information, see\n   * Acknowledging IAM Resources in AWS CloudFormation Templates.\n   *\n   * @default Generated by CloudFormation (recommended)\n   */\n  userName?: string;\n\n  /**\n   * The password for the user. This is required so the user can access the\n   * AWS Management Console.\n   *\n   * @default User won't be able to access the management console without a password.\n   */\n  password?: string;\n\n  /**\n   * Specifies whether the user is required to set a new password the next\n   * time the user logs in to the AWS Management Console.\n   *\n   * If this is set to 'true', you must also specify \"initialPassword\".\n   *\n   * @default false\n   */\n  passwordResetRequired?: boolean;\n}\n\nexport class User extends Construct implements IPrincipal {\n\n  /**\n   * An attribute that represents the user name.\n   */\n  public readonly userName: string;\n\n  /**\n   * An attribute that represents the user's ARN.\n   */\n  public readonly userArn: string;\n\n  /**\n   * Returns the ARN of this user.\n   */\n  public readonly principal: PolicyPrincipal;\n\n  private readonly groups = new Array<any>();\n  private readonly managedPolicyArns = new Array<string>();\n  private readonly attachedPolicies = new AttachedPolicies();\n  private defaultPolicy?: Policy;\n\n  constructor(parent: Construct, name: string, props: UserProps = {}) {\n    super(parent, name);\n\n    const user = new CfnUser(this, 'Resource', {\n      userName: props.userName,\n      groups: undefinedIfEmpty(() => this.groups),\n      managedPolicyArns: undefinedIfEmpty(() => this.managedPolicyArns),\n      path: props.path,\n      loginProfile: this.parseLoginProfile(props)\n    });\n\n    this.userName = user.userName;\n    this.userArn = user.userArn;\n    this.principal = new ArnPrincipal(this.userArn);\n\n    if (props.groups) {\n      props.groups.forEach(g => this.addToGroup(g));\n    }\n  }\n\n  /**\n   * Adds this user to a group.\n   */\n  public addToGroup(group: Group) {\n    this.groups.push(group.groupName);\n  }\n\n  /**\n   * Attaches a managed policy to the user.\n   * @param arn The ARN of the managed policy to attach.\n   */\n  public attachManagedPolicy(arn: string) {\n    this.managedPolicyArns.push(arn);\n  }\n\n  /**\n   * Attaches a policy to this user.\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToUser(this);\n  }\n\n  /**\n   * Adds an IAM statement to the default policy.\n   */\n  public addToPolicy(statement: PolicyStatement) {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, 'DefaultPolicy');\n      this.defaultPolicy.attachToUser(this);\n    }\n\n    this.defaultPolicy.addStatement(statement);\n  }\n\n  private parseLoginProfile(props: UserProps): CfnUser.LoginProfileProperty | undefined {\n    if (props.password) {\n      return {\n        password: props.password,\n        passwordResetRequired: props.passwordResetRequired\n      };\n    }\n\n    if (props.passwordResetRequired) {\n      throw new Error('Cannot set \"passwordResetRequired\" without specifying \"initialPassword\"');\n    }\n\n    return undefined; // no console access\n  }\n}\n"]}

package.json

 {
   "name": "@aws-cdk/aws-iam",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "CDK routines for easily assigning correct and minimal IAM permissions",
@@ -57,15 +57,18 @@ "main": "lib/index.js",
   "devDependencies": {
-    "@aws-cdk/assert": "^0.20.0",
-    "cdk-build-tools": "^0.20.0",
-    "cdk-integ-tools": "^0.20.0",
-    "cfn2ts": "^0.20.0",
-    "pkglint": "^0.20.0"
+    "@aws-cdk/assert": "^0.21.0",
+    "cdk-build-tools": "^0.21.0",
+    "cdk-integ-tools": "^0.21.0",
+    "cfn2ts": "^0.21.0",
+    "pkglint": "^0.21.0"
   },
   "dependencies": {
-    "@aws-cdk/cdk": "^0.20.0"
+    "@aws-cdk/cdk": "^0.21.0"
   },
   "homepage": "https://github.com/awslabs/aws-cdk",
   "peerDependencies": {
-    "@aws-cdk/cdk": "^0.20.0"
+    "@aws-cdk/cdk": "^0.21.0"
+  },
+  "engines": {
+    "node": ">= 8.10.0"
   }
 }

README.md

@@ -17,2 +17,64 @@ ## AWS IAM Construct Library
 
+### Configuring an ExternalId
+
+If you need to create roles that will be assumed by 3rd parties, it is generally a good idea to [require an `ExternalId`
+to assume them](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html).  Configuring
+an `ExternalId` works like this:
+
+[supplying an external ID](test/example.external-id.lit.ts)
+
+### IAM Principals
+
+When defining policy statements as part of an AssumeRole policy or as part of a
+resource policy, statements would usually refer to a specific IAM principal
+under `Principal`.
+
+IAM principals are modeled as classes that derive from the `iam.PolicyPrincipal`
+abstract class. Principal objects include principal type (string) and value
+(array of string), optional set of conditions and the action that this principal
+requires when it is used in an assume role policy document.
+
+To add a principal to a policy statement you can either use the abstract
+`statement.addPrincipal`, one of the concrete `addXxxPrincipal` methods:
+
+* `addAwsPrincipal`, `addArnPrincipal` or `new ArnPrincipal(arn)` for `{ "AWS": arn }`
+* `addAwsAccountPrincipal` or `new AccountPrincipal(accountId)` for `{ "AWS": account-arn }`
+* `addServicePrincipal` or `new ServicePrincipal(service)` for `{ "Service": service }`
+* `addAccountRootPrincipal` or `new AccountRootPrincipal()` for `{ "AWS": { "Ref: "AWS::AccountId" } }`
+* `addCanonicalUserPrincipal` or `new CanonicalUserPrincipal(id)` for `{ "CanonicalUser": id }`
+* `addFederatedPrincipal` or `new FederatedPrincipal(federated, conditions, assumeAction)` for
+  `{ "Federated": arn }` and a set of optional conditions and the assume role action to use.
+* `addAnyPrincipal` or `new AnyPrincipal` for `{ "AWS": "*" }`
+
+If multiple principals are added to the policy statement, they will be merged together:
+
+```ts
+const statement = new PolicyStatement();
+statement.addServicePrincipal('cloudwatch.amazonaws.com');
+statement.addServicePrincipal('ec2.amazonaws.com');
+statement.addAwsPrincipal('arn:aws:boom:boom');
+```
+
+Will result in:
+
+```json
+{
+  "Principal": {
+    "Service": [ "cloudwatch.amazonaws.com", "ec2.amazonaws.com" ],
+    "AWS": "arn:aws:boom:boom"
+  }
+}
+```
+
+The `CompositePrincipal` class can also be used to define complex principals, for example:
+
+```ts
+const role = new iam.Role(this, 'MyRole', {
+  assumedBy: new iam.CompositePrincipal(
+    new iam.ServicePrincipal('ec2.amazonawas.com'),
+    new iam.AccountPrincipal('1818188181818187272')
+  )
+});
+```
+
 ### Features
@@ -19,0 +81,0 @@

test/integ.role.expected.json

@@ -61,4 +61,41 @@ {
       }
+    },
+    "TestRole25D98AB21": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "AssumeRolePolicyDocument": {
+          "Statement": [
+            {
+              "Action": "sts:AssumeRole",
+              "Condition": {
+                "StringEquals": {
+                  "sts:ExternalId": "supply-me"
+                }
+              },
+              "Effect": "Allow",
+              "Principal": {
+                "AWS": {
+                  "Fn::Join": [
+                    "",
+                    [
+                      "arn:",
+                      {
+                        "Ref": "AWS::Partition"
+                      },
+                      ":iam::",
+                      {
+                        "Ref": "AWS::AccountId"
+                      },
+                      ":root"
+                    ]
+                  ]
+                }
+              }
+            }
+          ],
+          "Version": "2012-10-17"
+        }
+      }
     }
   }
 }

test/integ.role.js

@@ -14,3 +14,8 @@ "use strict";
 policy.attachToRole(role);
+// Role with an external ID
+new lib_1.Role(stack, 'TestRole2', {
+    assumedBy: new lib_1.AccountRootPrincipal(),
+    externalId: 'supply-me',
+});
 app.run();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWcucm9sZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImludGVnLnJvbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxzQ0FBMEM7QUFDMUMsZ0NBQXlFO0FBRXpFLE1BQU0sR0FBRyxHQUFHLElBQUksU0FBRyxFQUFFLENBQUM7QUFFdEIsTUFBTSxLQUFLLEdBQUcsSUFBSSxXQUFLLENBQUMsR0FBRyxFQUFFLGtCQUFrQixDQUFDLENBQUM7QUFFakQsTUFBTSxJQUFJLEdBQUcsSUFBSSxVQUFJLENBQUMsS0FBSyxFQUFFLFVBQVUsRUFBRTtJQUN2QyxTQUFTLEVBQUUsSUFBSSxzQkFBZ0IsQ0FBQyxtQkFBbUIsQ0FBQztDQUNyRCxDQUFDLENBQUM7QUFFSCxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUkscUJBQWUsRUFBRSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxTQUFTLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxDQUFDO0FBRXRGLE1BQU0sTUFBTSxHQUFHLElBQUksWUFBTSxDQUFDLEtBQUssRUFBRSxhQUFhLEVBQUUsRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQztBQUMzRSxNQUFNLENBQUMsWUFBWSxDQUFDLElBQUkscUJBQWUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztBQUMvRSxNQUFNLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBRTFCLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFwcCwgU3RhY2sgfSBmcm9tIFwiQGF3cy1jZGsvY2RrXCI7XG5pbXBvcnQgeyBQb2xpY3ksIFBvbGljeVN0YXRlbWVudCwgUm9sZSwgU2VydmljZVByaW5jaXBhbCB9IGZyb20gXCIuLi9saWJcIjtcblxuY29uc3QgYXBwID0gbmV3IEFwcCgpO1xuXG5jb25zdCBzdGFjayA9IG5ldyBTdGFjayhhcHAsICdpbnRlZy1pYW0tcm9sZS0xJyk7XG5cbmNvbnN0IHJvbGUgPSBuZXcgUm9sZShzdGFjaywgJ1Rlc3RSb2xlJywge1xuICBhc3N1bWVkQnk6IG5ldyBTZXJ2aWNlUHJpbmNpcGFsKCdzcXMuYW1hem9uYXdzLmNvbScpXG59KTtcblxucm9sZS5hZGRUb1BvbGljeShuZXcgUG9saWN5U3RhdGVtZW50KCkuYWRkUmVzb3VyY2UoJyonKS5hZGRBY3Rpb24oJ3NxczpTZW5kTWVzc2FnZScpKTtcblxuY29uc3QgcG9saWN5ID0gbmV3IFBvbGljeShzdGFjaywgJ0hlbGxvUG9saWN5JywgeyBwb2xpY3lOYW1lOiAnRGVmYXVsdCcgfSk7XG5wb2xpY3kuYWRkU3RhdGVtZW50KG5ldyBQb2xpY3lTdGF0ZW1lbnQoKS5hZGRBY3Rpb24oJ2VjMjoqJykuYWRkUmVzb3VyY2UoJyonKSk7XG5wb2xpY3kuYXR0YWNoVG9Sb2xlKHJvbGUpO1xuXG5hcHAucnVuKCk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

test/test.policy-document.d.ts

@@ -22,6 +22,14 @@ import { Test } from 'nodeunit';
     'statementCount returns the number of statement in the policy document'(test: Test): void;
-    'the { AWS: "*" } principal is represented as "*"'(test: Test): void;
-    'addPrincipal prohibits mixing principal types'(test: Test): void;
+    'the { AWS: "*" } principal is represented as `Anyone` or `AnyPrincipal`'(test: Test): void;
+    'addAwsPrincipal/addArnPrincipal are the aliases'(test: Test): void;
+    'addCanonicalUserPrincipal can be used to add cannonical user principals'(test: Test): void;
     'addPrincipal correctly merges array in'(test: Test): void;
+    'policy statements with multiple principal types can be created using multiple addPrincipal calls'(test: Test): void;
+    'CompositePrincipal can be used to represent a principal that has multiple types': {
+        'with a single principal'(test: Test): void;
+        'conditions are not allowed on individual principals of a composite'(test: Test): void;
+        'principals and conditions are a big nice merge'(test: Test): void;
+        'cannot mix types of assumeRoleAction in a single composite'(test: Test): void;
+    };
 };
 export = _default;

test/test.policy-document.js

 "use strict";
 const cdk_1 = require("@aws-cdk/cdk");
 const lib_1 = require("../lib");
+const lib_2 = require("../lib");
 module.exports = {
@@ -178,17 +179,50 @@ 'the Permission class is a programming model for iam'(test) {
     },
-    'the { AWS: "*" } principal is represented as "*"'(test) {
-        const p = new lib_1.PolicyDocument().addStatement(new lib_1.PolicyStatement().addPrincipal(new lib_1.Anyone()));
-        test.deepEqual(cdk_1.resolve(p), { Statement: [{ Effect: 'Allow', Principal: '*' }], Version: '2012-10-17' });
+    'the { AWS: "*" } principal is represented as `Anyone` or `AnyPrincipal`'(test) {
+        const p = new lib_1.PolicyDocument();
+        p.addStatement(new lib_1.PolicyStatement().addPrincipal(new lib_1.Anyone()));
+        p.addStatement(new lib_1.PolicyStatement().addPrincipal(new lib_1.AnyPrincipal()));
+        p.addStatement(new lib_1.PolicyStatement().addAnyPrincipal());
+        test.deepEqual(cdk_1.resolve(p), {
+            Statement: [
+                { Effect: 'Allow', Principal: '*' },
+                { Effect: 'Allow', Principal: '*' },
+                { Effect: 'Allow', Principal: '*' }
+            ],
+            Version: '2012-10-17'
+        });
         test.done();
     },
-    'addPrincipal prohibits mixing principal types'(test) {
-        const s = new lib_1.PolicyStatement().addAccountRootPrincipal();
-        test.throws(() => { s.addServicePrincipal('rds.amazonaws.com'); }, /Attempted to add principal key Service/);
-        test.throws(() => { s.addFederatedPrincipal('federation', { ConditionOp: { ConditionKey: 'ConditionValue' } }); }, /Attempted to add principal key Federated/);
+    'addAwsPrincipal/addArnPrincipal are the aliases'(test) {
+        const p = new lib_1.PolicyDocument();
+        p.addStatement(new lib_1.PolicyStatement().addAwsPrincipal('111222-A'));
+        p.addStatement(new lib_1.PolicyStatement().addArnPrincipal('111222-B'));
+        p.addStatement(new lib_1.PolicyStatement().addPrincipal(new lib_2.ArnPrincipal('111222-C')));
+        test.deepEqual(cdk_1.resolve(p), {
+            Statement: [{
+                    Effect: 'Allow', Principal: { AWS: '111222-A' }
+                },
+                { Effect: 'Allow', Principal: { AWS: '111222-B' } },
+                { Effect: 'Allow', Principal: { AWS: '111222-C' } }
+            ],
+            Version: '2012-10-17'
+        });
         test.done();
     },
+    'addCanonicalUserPrincipal can be used to add cannonical user principals'(test) {
+        const p = new lib_1.PolicyDocument();
+        p.addStatement(new lib_1.PolicyStatement().addCanonicalUserPrincipal('cannonical-user-1'));
+        p.addStatement(new lib_1.PolicyStatement().addPrincipal(new lib_1.CanonicalUserPrincipal('cannonical-user-2')));
+        test.deepEqual(cdk_1.resolve(p), {
+            Statement: [
+                { Effect: 'Allow', Principal: { CanonicalUser: 'cannonical-user-1' } },
+                { Effect: 'Allow', Principal: { CanonicalUser: 'cannonical-user-2' } }
+            ],
+            Version: '2012-10-17'
+        });
+        test.done();
+    },
     'addPrincipal correctly merges array in'(test) {
         const arrayPrincipal = {
             assumeRoleAction: 'sts:AssumeRole',
-            policyFragment: () => new lib_1.PrincipalPolicyFragment({ AWS: ['foo', 'bar'] }),
+            policyFragment: () => new lib_2.PrincipalPolicyFragment({ AWS: ['foo', 'bar'] }),
         };
@@ -208,3 +242,59 @@ const s = new lib_1.PolicyStatement().addAccountRootPrincipal()
     },
+    // https://github.com/awslabs/aws-cdk/issues/1201
+    'policy statements with multiple principal types can be created using multiple addPrincipal calls'(test) {
+        const s = new lib_1.PolicyStatement()
+            .addAwsPrincipal('349494949494')
+            .addServicePrincipal('ec2.amazonaws.com')
+            .addResource('resource')
+            .addAction('action');
+        test.deepEqual(cdk_1.resolve(s), {
+            Action: 'action',
+            Effect: 'Allow',
+            Principal: { AWS: '349494949494', Service: 'ec2.amazonaws.com' },
+            Resource: 'resource'
+        });
+        test.done();
+    },
+    'CompositePrincipal can be used to represent a principal that has multiple types': {
+        'with a single principal'(test) {
+            const p = new lib_2.CompositePrincipal(new lib_2.ArnPrincipal('i:am:an:arn'));
+            const statement = new lib_1.PolicyStatement().addPrincipal(p);
+            test.deepEqual(cdk_1.resolve(statement), { Effect: 'Allow', Principal: { AWS: 'i:am:an:arn' } });
+            test.done();
+        },
+        'conditions are not allowed on individual principals of a composite'(test) {
+            const p = new lib_2.CompositePrincipal(new lib_2.ArnPrincipal('i:am'));
+            test.throws(() => p.addPrincipals(new lib_2.FederatedPrincipal('federated', { condition: 1 })), /Components of a CompositePrincipal must not have conditions/);
+            test.done();
+        },
+        'principals and conditions are a big nice merge'(test) {
+            // add via ctor
+            const p = new lib_2.CompositePrincipal(new lib_2.ArnPrincipal('i:am:an:arn'), new lib_2.ServicePrincipal('amazon.com'));
+            // add via `addPrincipals` (with condition)
+            p.addPrincipals(new lib_1.Anyone(), new lib_2.ServicePrincipal('another.service'));
+            const statement = new lib_1.PolicyStatement().addPrincipal(p);
+            // add via policy statement
+            statement.addAwsPrincipal('aws-principal-3');
+            statement.addCondition('cond2', { boom: 123 });
+            test.deepEqual(cdk_1.resolve(statement), {
+                Condition: {
+                    cond2: { boom: 123 }
+                },
+                Effect: 'Allow',
+                Principal: {
+                    AWS: ['i:am:an:arn', '*', 'aws-principal-3'],
+                    Service: ['amazon.com', 'another.service'],
+                }
+            });
+            test.done();
+        },
+        'cannot mix types of assumeRoleAction in a single composite'(test) {
+            // GIVEN
+            const p = new lib_2.CompositePrincipal(new lib_2.ArnPrincipal('arn')); // assumeRoleAction is "sts:AssumeRule"
+            // THEN
+            test.throws(() => p.addPrincipals(new lib_2.FederatedPrincipal('fed', {}, 'sts:Boom')), /Cannot add multiple principals with different "assumeRoleAction". Expecting "sts:AssumeRole", got "sts:Boom"/);
+            test.done();
+        }
+    },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.policy-document.js","sourceRoot":"","sources":["test.policy-document.ts"],"names":[],"mappings":"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","sourcesContent":["import { FnConcat, resolve } from '@aws-cdk/cdk';\nimport { Test } from 'nodeunit';\nimport { Anyone, CanonicalUserPrincipal, PolicyDocument, PolicyPrincipal, PolicyStatement, PrincipalPolicyFragment } from '../lib';\n\nexport = {\n  'the Permission class is a programming model for iam'(test: Test) {\n    const p = new PolicyStatement();\n    p.addAction('sqs:SendMessage');\n    p.addActions('dynamodb:CreateTable', 'dynamodb:DeleteTable');\n    p.addResource('myQueue');\n    p.addResource('yourQueue');\n\n    p.addAllResources();\n    p.addAwsAccountPrincipal(new FnConcat('my', { account: 'account' }, 'name').toString());\n    p.limitToAccount('12221121221');\n\n    test.deepEqual(resolve(p), { Action:\n      [ 'sqs:SendMessage',\n        'dynamodb:CreateTable',\n        'dynamodb:DeleteTable' ],\n       Resource: [ 'myQueue', 'yourQueue', '*' ],\n       Effect: 'Allow',\n       Principal:\n      { AWS:\n         { 'Fn::Join':\n          [ '',\n          [ 'arn:',\n            { Ref: 'AWS::Partition' },\n            ':iam::my',\n            { account: 'account' },\n            'name:root' ] ] } },\n       Condition: { StringEquals: { 'sts:ExternalId': '12221121221' } } });\n\n    test.done();\n  },\n\n  'the PolicyDocument class is a dom for iam policy documents'(test: Test) {\n    const doc = new PolicyDocument();\n    const p1 = new PolicyStatement();\n    p1.addAction('sqs:SendMessage');\n    p1.addResource('*');\n\n    const p2 = new PolicyStatement();\n    p2.deny();\n    p2.addActions('cloudformation:CreateStack');\n\n    doc.addStatement(p1);\n    doc.addStatement(p2);\n\n    test.deepEqual(resolve(doc), {\n      Version: '2012-10-17',\n      Statement:\n        [ { Effect: 'Allow', Action: 'sqs:SendMessage', Resource: '*' },\n          { Effect: 'Deny', Action: 'cloudformation:CreateStack' } ] });\n\n    test.done();\n  },\n\n  'A PolicyDocument can be initialized with an existing policy, which is merged upon serialization'(test: Test) {\n    const base = {\n      Version: 'Foo',\n      Something: 123,\n      Statement: [\n        { Statement1: 1 },\n        { Statement2: 2 }\n      ]\n    };\n    const doc = new PolicyDocument(base);\n    doc.addStatement(new PolicyStatement().addResource('resource').addAction('action'));\n\n    test.deepEqual(resolve(doc), { Version: 'Foo',\n    Something: 123,\n    Statement:\n     [ { Statement1: 1 },\n       { Statement2: 2 },\n       { Effect: 'Allow', Action: 'action', Resource: 'resource' } ] });\n    test.done();\n  },\n\n  'Permission allows specifying multiple actions upon construction'(test: Test) {\n    const perm = new PolicyStatement().addResource('MyResource').addActions('Action1', 'Action2', 'Action3');\n    test.deepEqual(resolve(perm), {\n      Effect: 'Allow',\n      Action: [ 'Action1', 'Action2', 'Action3' ],\n      Resource: 'MyResource' });\n    test.done();\n  },\n\n  'PolicyDoc resolves to undefined if there are no permissions'(test: Test) {\n    const p = new PolicyDocument();\n    test.deepEqual(resolve(p), undefined);\n    test.done();\n  },\n\n  'canonicalUserPrincipal adds a principal to a policy with the passed canonical user id'(test: Test) {\n    const p = new PolicyStatement();\n    const canoncialUser = \"averysuperduperlongstringfor\";\n    p.addPrincipal(new CanonicalUserPrincipal(canoncialUser));\n    test.deepEqual(resolve(p), {\n      Effect: \"Allow\",\n      Principal: {\n        CanonicalUser: canoncialUser\n      }\n    });\n    test.done();\n  },\n\n  'addAccountRootPrincipal adds a principal with the current account root'(test: Test) {\n    const p = new PolicyStatement();\n    p.addAccountRootPrincipal();\n    test.deepEqual(resolve(p), {\n      Effect: \"Allow\",\n      Principal: {\n        AWS: {\n        \"Fn::Join\": [\n          \"\",\n          [\n          \"arn:\",\n          { Ref: \"AWS::Partition\" },\n          \":iam::\",\n          { Ref: \"AWS::AccountId\" },\n          \":root\"\n          ]\n        ]\n        }\n      }\n    });\n    test.done();\n  },\n\n  'addFederatedPrincipal adds a Federated principal with the passed value'(test: Test) {\n    const p = new PolicyStatement();\n    p.addFederatedPrincipal(\"com.amazon.cognito\", { StringEquals: { key: 'value' }});\n    test.deepEqual(resolve(p), {\n      Effect: \"Allow\",\n      Principal: {\n        Federated: \"com.amazon.cognito\"\n      },\n      Condition: {\n        StringEquals: { key: 'value' }\n      }\n    });\n    test.done();\n  },\n\n  'addAwsAccountPrincipal can be used multiple times'(test: Test) {\n    const p = new PolicyStatement();\n    p.addAwsAccountPrincipal('1234');\n    p.addAwsAccountPrincipal('5678');\n    test.deepEqual(resolve(p), {\n      Effect: 'Allow',\n      Principal: {\n        AWS: [\n          { 'Fn::Join': ['', ['arn:', { Ref: 'AWS::Partition' }, ':iam::1234:root']] },\n          { 'Fn::Join': ['', ['arn:', { Ref: 'AWS::Partition' }, ':iam::5678:root']] }\n        ]\n      }\n    });\n    test.done();\n  },\n\n  'hasResource': {\n    'false if there are no resources'(test: Test) {\n      test.equal(new PolicyStatement().hasResource, false, 'hasResource should be false for an empty permission');\n      test.done();\n    },\n\n    'true if there is one resource'(test: Test) {\n      test.equal(\n        new PolicyStatement().addResource('one-resource').hasResource,\n        true,\n        'hasResource is true when there is one resource');\n      test.done();\n    },\n\n    'true for multiple resources'(test: Test) {\n      const p = new PolicyStatement();\n      p.addResource('r1');\n      p.addResource('r2');\n      test.equal(p.hasResource, true, 'hasResource is true when there are multiple resource');\n      test.done();\n    },\n  },\n\n  'hasPrincipal': {\n    'false if there is no principal'(test: Test) {\n      test.equal(new PolicyStatement().hasPrincipal, false);\n      test.done();\n    },\n\n    'true if there is a principal'(test: Test) {\n      const p = new PolicyStatement();\n      p.addAwsPrincipal('bla');\n      test.equal(p.hasPrincipal, true);\n      test.done();\n    }\n  },\n\n  'statementCount returns the number of statement in the policy document'(test: Test) {\n    const p = new PolicyDocument();\n    test.equal(p.statementCount, 0);\n    p.addStatement(new PolicyStatement());\n    test.equal(p.statementCount, 1);\n    p.addStatement(new PolicyStatement());\n    test.equal(p.statementCount, 2);\n    test.done();\n  },\n\n  'the { AWS: \"*\" } principal is represented as \"*\"'(test: Test) {\n    const p = new PolicyDocument().addStatement(new PolicyStatement().addPrincipal(new Anyone()));\n    test.deepEqual(resolve(p), { Statement: [{ Effect: 'Allow', Principal: '*' }], Version: '2012-10-17' });\n    test.done();\n  },\n\n  'addPrincipal prohibits mixing principal types'(test: Test) {\n    const s = new PolicyStatement().addAccountRootPrincipal();\n    test.throws(() => { s.addServicePrincipal('rds.amazonaws.com'); },\n                /Attempted to add principal key Service/);\n    test.throws(() => { s.addFederatedPrincipal('federation', { ConditionOp: { ConditionKey: 'ConditionValue' } }); },\n                /Attempted to add principal key Federated/);\n    test.done();\n  },\n\n  'addPrincipal correctly merges array in'(test: Test) {\n    const arrayPrincipal: PolicyPrincipal = {\n      assumeRoleAction: 'sts:AssumeRole',\n      policyFragment: () => new PrincipalPolicyFragment({ AWS: ['foo', 'bar'] }),\n    };\n    const s = new PolicyStatement().addAccountRootPrincipal()\n                                   .addPrincipal(arrayPrincipal);\n    test.deepEqual(resolve(s), {\n      Effect: 'Allow',\n      Principal: {\n        AWS: [\n          { 'Fn::Join': ['', ['arn:', { Ref: 'AWS::Partition' }, ':iam::', { Ref: 'AWS::AccountId' }, ':root']] },\n          'foo', 'bar'\n        ]\n      }\n    });\n    test.done();\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.policy-document.js","sourceRoot":"","sources":["test.policy-document.ts"],"names":[],"mappings":"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","sourcesContent":["import { FnConcat, resolve } from '@aws-cdk/cdk';\nimport { Test } from 'nodeunit';\nimport { Anyone, AnyPrincipal, CanonicalUserPrincipal, PolicyDocument, PolicyPrincipal, PolicyStatement } from '../lib';\nimport { ArnPrincipal, CompositePrincipal, FederatedPrincipal, PrincipalPolicyFragment, ServicePrincipal } from '../lib';\n\nexport = {\n  'the Permission class is a programming model for iam'(test: Test) {\n    const p = new PolicyStatement();\n    p.addAction('sqs:SendMessage');\n    p.addActions('dynamodb:CreateTable', 'dynamodb:DeleteTable');\n    p.addResource('myQueue');\n    p.addResource('yourQueue');\n\n    p.addAllResources();\n    p.addAwsAccountPrincipal(new FnConcat('my', { account: 'account' }, 'name').toString());\n    p.limitToAccount('12221121221');\n\n    test.deepEqual(resolve(p), { Action:\n      [ 'sqs:SendMessage',\n        'dynamodb:CreateTable',\n        'dynamodb:DeleteTable' ],\n       Resource: [ 'myQueue', 'yourQueue', '*' ],\n       Effect: 'Allow',\n       Principal:\n      { AWS:\n         { 'Fn::Join':\n          [ '',\n          [ 'arn:',\n            { Ref: 'AWS::Partition' },\n            ':iam::my',\n            { account: 'account' },\n            'name:root' ] ] } },\n       Condition: { StringEquals: { 'sts:ExternalId': '12221121221' } } });\n\n    test.done();\n  },\n\n  'the PolicyDocument class is a dom for iam policy documents'(test: Test) {\n    const doc = new PolicyDocument();\n    const p1 = new PolicyStatement();\n    p1.addAction('sqs:SendMessage');\n    p1.addResource('*');\n\n    const p2 = new PolicyStatement();\n    p2.deny();\n    p2.addActions('cloudformation:CreateStack');\n\n    doc.addStatement(p1);\n    doc.addStatement(p2);\n\n    test.deepEqual(resolve(doc), {\n      Version: '2012-10-17',\n      Statement:\n        [ { Effect: 'Allow', Action: 'sqs:SendMessage', Resource: '*' },\n          { Effect: 'Deny', Action: 'cloudformation:CreateStack' } ] });\n\n    test.done();\n  },\n\n  'A PolicyDocument can be initialized with an existing policy, which is merged upon serialization'(test: Test) {\n    const base = {\n      Version: 'Foo',\n      Something: 123,\n      Statement: [\n        { Statement1: 1 },\n        { Statement2: 2 }\n      ]\n    };\n    const doc = new PolicyDocument(base);\n    doc.addStatement(new PolicyStatement().addResource('resource').addAction('action'));\n\n    test.deepEqual(resolve(doc), { Version: 'Foo',\n    Something: 123,\n    Statement:\n     [ { Statement1: 1 },\n       { Statement2: 2 },\n       { Effect: 'Allow', Action: 'action', Resource: 'resource' } ] });\n    test.done();\n  },\n\n  'Permission allows specifying multiple actions upon construction'(test: Test) {\n    const perm = new PolicyStatement().addResource('MyResource').addActions('Action1', 'Action2', 'Action3');\n    test.deepEqual(resolve(perm), {\n      Effect: 'Allow',\n      Action: [ 'Action1', 'Action2', 'Action3' ],\n      Resource: 'MyResource' });\n    test.done();\n  },\n\n  'PolicyDoc resolves to undefined if there are no permissions'(test: Test) {\n    const p = new PolicyDocument();\n    test.deepEqual(resolve(p), undefined);\n    test.done();\n  },\n\n  'canonicalUserPrincipal adds a principal to a policy with the passed canonical user id'(test: Test) {\n    const p = new PolicyStatement();\n    const canoncialUser = \"averysuperduperlongstringfor\";\n    p.addPrincipal(new CanonicalUserPrincipal(canoncialUser));\n    test.deepEqual(resolve(p), {\n      Effect: \"Allow\",\n      Principal: {\n        CanonicalUser: canoncialUser\n      }\n    });\n    test.done();\n  },\n\n  'addAccountRootPrincipal adds a principal with the current account root'(test: Test) {\n    const p = new PolicyStatement();\n    p.addAccountRootPrincipal();\n    test.deepEqual(resolve(p), {\n      Effect: \"Allow\",\n      Principal: {\n        AWS: {\n        \"Fn::Join\": [\n          \"\",\n          [\n          \"arn:\",\n          { Ref: \"AWS::Partition\" },\n          \":iam::\",\n          { Ref: \"AWS::AccountId\" },\n          \":root\"\n          ]\n        ]\n        }\n      }\n    });\n    test.done();\n  },\n\n  'addFederatedPrincipal adds a Federated principal with the passed value'(test: Test) {\n    const p = new PolicyStatement();\n    p.addFederatedPrincipal(\"com.amazon.cognito\", { StringEquals: { key: 'value' }});\n    test.deepEqual(resolve(p), {\n      Effect: \"Allow\",\n      Principal: {\n        Federated: \"com.amazon.cognito\"\n      },\n      Condition: {\n        StringEquals: { key: 'value' }\n      }\n    });\n    test.done();\n  },\n\n  'addAwsAccountPrincipal can be used multiple times'(test: Test) {\n    const p = new PolicyStatement();\n    p.addAwsAccountPrincipal('1234');\n    p.addAwsAccountPrincipal('5678');\n    test.deepEqual(resolve(p), {\n      Effect: 'Allow',\n      Principal: {\n        AWS: [\n          { 'Fn::Join': ['', ['arn:', { Ref: 'AWS::Partition' }, ':iam::1234:root']] },\n          { 'Fn::Join': ['', ['arn:', { Ref: 'AWS::Partition' }, ':iam::5678:root']] }\n        ]\n      }\n    });\n    test.done();\n  },\n\n  'hasResource': {\n    'false if there are no resources'(test: Test) {\n      test.equal(new PolicyStatement().hasResource, false, 'hasResource should be false for an empty permission');\n      test.done();\n    },\n\n    'true if there is one resource'(test: Test) {\n      test.equal(\n        new PolicyStatement().addResource('one-resource').hasResource,\n        true,\n        'hasResource is true when there is one resource');\n      test.done();\n    },\n\n    'true for multiple resources'(test: Test) {\n      const p = new PolicyStatement();\n      p.addResource('r1');\n      p.addResource('r2');\n      test.equal(p.hasResource, true, 'hasResource is true when there are multiple resource');\n      test.done();\n    },\n  },\n\n  'hasPrincipal': {\n    'false if there is no principal'(test: Test) {\n      test.equal(new PolicyStatement().hasPrincipal, false);\n      test.done();\n    },\n\n    'true if there is a principal'(test: Test) {\n      const p = new PolicyStatement();\n      p.addAwsPrincipal('bla');\n      test.equal(p.hasPrincipal, true);\n      test.done();\n    }\n  },\n\n  'statementCount returns the number of statement in the policy document'(test: Test) {\n    const p = new PolicyDocument();\n    test.equal(p.statementCount, 0);\n    p.addStatement(new PolicyStatement());\n    test.equal(p.statementCount, 1);\n    p.addStatement(new PolicyStatement());\n    test.equal(p.statementCount, 2);\n    test.done();\n  },\n\n  'the { AWS: \"*\" } principal is represented as `Anyone` or `AnyPrincipal`'(test: Test) {\n    const p = new PolicyDocument();\n\n    p.addStatement(new PolicyStatement().addPrincipal(new Anyone()));\n    p.addStatement(new PolicyStatement().addPrincipal(new AnyPrincipal()));\n    p.addStatement(new PolicyStatement().addAnyPrincipal());\n\n    test.deepEqual(resolve(p), {\n      Statement: [\n        { Effect: 'Allow', Principal: '*' },\n        { Effect: 'Allow', Principal: '*' },\n        { Effect: 'Allow', Principal: '*' }\n      ],\n      Version: '2012-10-17'\n    });\n    test.done();\n  },\n\n  'addAwsPrincipal/addArnPrincipal are the aliases'(test: Test) {\n    const p = new PolicyDocument();\n\n    p.addStatement(new PolicyStatement().addAwsPrincipal('111222-A'));\n    p.addStatement(new PolicyStatement().addArnPrincipal('111222-B'));\n    p.addStatement(new PolicyStatement().addPrincipal(new ArnPrincipal('111222-C')));\n\n    test.deepEqual(resolve(p), {\n      Statement: [ {\n        Effect: 'Allow', Principal: { AWS: '111222-A' } },\n        { Effect: 'Allow', Principal: { AWS: '111222-B' } },\n        { Effect: 'Allow', Principal: { AWS: '111222-C' } }\n      ],\n      Version: '2012-10-17'\n    });\n\n    test.done();\n  },\n\n  'addCanonicalUserPrincipal can be used to add cannonical user principals'(test: Test) {\n    const p = new PolicyDocument();\n\n    p.addStatement(new PolicyStatement().addCanonicalUserPrincipal('cannonical-user-1'));\n    p.addStatement(new PolicyStatement().addPrincipal(new CanonicalUserPrincipal('cannonical-user-2')));\n\n    test.deepEqual(resolve(p), {\n      Statement: [\n        { Effect: 'Allow', Principal: { CanonicalUser: 'cannonical-user-1' } },\n        { Effect: 'Allow', Principal: { CanonicalUser: 'cannonical-user-2' } }\n      ],\n      Version: '2012-10-17'\n    });\n\n    test.done();\n  },\n\n  'addPrincipal correctly merges array in'(test: Test) {\n    const arrayPrincipal: PolicyPrincipal = {\n      assumeRoleAction: 'sts:AssumeRole',\n      policyFragment: () => new PrincipalPolicyFragment({ AWS: ['foo', 'bar'] }),\n    };\n    const s = new PolicyStatement().addAccountRootPrincipal()\n                                   .addPrincipal(arrayPrincipal);\n    test.deepEqual(resolve(s), {\n      Effect: 'Allow',\n      Principal: {\n        AWS: [\n          { 'Fn::Join': ['', ['arn:', { Ref: 'AWS::Partition' }, ':iam::', { Ref: 'AWS::AccountId' }, ':root']] },\n          'foo', 'bar'\n        ]\n      }\n    });\n    test.done();\n  },\n\n  // https://github.com/awslabs/aws-cdk/issues/1201\n  'policy statements with multiple principal types can be created using multiple addPrincipal calls'(test: Test) {\n    const s = new PolicyStatement()\n      .addAwsPrincipal('349494949494')\n      .addServicePrincipal('ec2.amazonaws.com')\n      .addResource('resource')\n      .addAction('action');\n\n    test.deepEqual(resolve(s), {\n      Action: 'action',\n      Effect: 'Allow',\n      Principal: { AWS: '349494949494', Service: 'ec2.amazonaws.com' },\n      Resource: 'resource'\n    });\n\n    test.done();\n  },\n\n  'CompositePrincipal can be used to represent a principal that has multiple types': {\n\n    'with a single principal'(test: Test) {\n      const p = new CompositePrincipal(new ArnPrincipal('i:am:an:arn'));\n      const statement = new PolicyStatement().addPrincipal(p);\n      test.deepEqual(resolve(statement), { Effect: 'Allow', Principal: { AWS: 'i:am:an:arn' } });\n      test.done();\n    },\n\n    'conditions are not allowed on individual principals of a composite'(test: Test) {\n      const p = new CompositePrincipal(new ArnPrincipal('i:am'));\n      test.throws(() => p.addPrincipals(new FederatedPrincipal('federated', { condition: 1 })),\n        /Components of a CompositePrincipal must not have conditions/);\n\n      test.done();\n    },\n\n    'principals and conditions are a big nice merge'(test: Test) {\n      // add via ctor\n      const p = new CompositePrincipal(\n        new ArnPrincipal('i:am:an:arn'),\n        new ServicePrincipal('amazon.com'));\n\n      // add via `addPrincipals` (with condition)\n      p.addPrincipals(\n        new Anyone(),\n        new ServicePrincipal('another.service')\n      );\n\n      const statement = new PolicyStatement().addPrincipal(p);\n\n      // add via policy statement\n      statement.addAwsPrincipal('aws-principal-3');\n      statement.addCondition('cond2', { boom: 123 });\n\n      test.deepEqual(resolve(statement), {\n        Condition: {\n          cond2: { boom: 123 }\n        },\n        Effect: 'Allow',\n        Principal: {\n          AWS: [ 'i:am:an:arn', '*', 'aws-principal-3' ],\n          Service: [ 'amazon.com', 'another.service' ],\n        }\n      });\n      test.done();\n    },\n\n    'cannot mix types of assumeRoleAction in a single composite'(test: Test) {\n      // GIVEN\n      const p = new CompositePrincipal(new ArnPrincipal('arn')); // assumeRoleAction is \"sts:AssumeRule\"\n\n      // THEN\n      test.throws(() => p.addPrincipals(new FederatedPrincipal('fed', {}, 'sts:Boom')),\n        /Cannot add multiple principals with different \"assumeRoleAction\". Expecting \"sts:AssumeRole\", got \"sts:Boom\"/);\n\n      test.done();\n    }\n  },\n};\n"]}

test/test.role.d.ts

 import { Test } from 'nodeunit';
 declare const _default: {
     'default role'(test: Test): void;
+    'can supply externalId'(test: Test): void;
     'policy is created automatically when permissions are added'(test: Test): void;
@@ -13,3 +14,4 @@ 'managed policy arns can be supplied upon initialization and also added later'(test: Test): void;
     };
+    'allow role with multiple principals'(test: Test): void;
 };
 export = _default;

test/test.role.js

@@ -18,2 +18,28 @@ "use strict";
     },
+    'can supply externalId'(test) {
+        // GIVEN
+        const stack = new cdk_1.Stack();
+        // WHEN
+        new lib_1.Role(stack, 'MyRole', {
+            assumedBy: new lib_1.ServicePrincipal('sns.amazonaws.com'),
+            externalId: 'SomeSecret',
+        });
+        // THEN
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::IAM::Role', {
+            AssumeRolePolicyDocument: {
+                Statement: [
+                    {
+                        Action: "sts:AssumeRole",
+                        Condition: {
+                            StringEquals: { "sts:ExternalId": "SomeSecret" }
+                        },
+                        Effect: "Allow",
+                        Principal: { Service: "sns.amazonaws.com" }
+                    }
+                ],
+                Version: "2012-10-17"
+            }
+        }));
+        test.done();
+    },
     'policy is created automatically when permissions are added'(test) {
@@ -129,4 +155,26 @@ const stack = new cdk_1.Stack();
         }
+    },
+    'allow role with multiple principals'(test) {
+        const stack = new cdk_1.Stack();
+        new lib_1.Role(stack, 'MyRole', {
+            assumedBy: new lib_1.CompositePrincipal(new lib_1.ServicePrincipal('boom.amazonaws.com'), new lib_1.ArnPrincipal('1111111'))
+        });
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::IAM::Role', {
+            AssumeRolePolicyDocument: {
+                Statement: [
+                    {
+                        Action: "sts:AssumeRole",
+                        Effect: "Allow",
+                        Principal: {
+                            Service: "boom.amazonaws.com",
+                            AWS: "1111111"
+                        }
+                    }
+                ],
+                Version: "2012-10-17"
+            }
+        }));
+        test.done();
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.role.js","sourceRoot":"","sources":["test.role.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, haveResource } from '@aws-cdk/assert';\nimport { Resource, Stack } from '@aws-cdk/cdk';\nimport { Test } from 'nodeunit';\nimport { FederatedPrincipal, PolicyStatement, Role, ServicePrincipal } from '../lib';\n\nexport = {\n  'default role'(test: Test) {\n    const stack = new Stack();\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com')\n    });\n\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'sns.amazonaws.com' } } ],\n             Version: '2012-10-17' } } } } });\n    test.done();\n  },\n\n  'policy is created automatically when permissions are added'(test: Test) {\n    const stack = new Stack();\n\n    const role = new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com')\n    });\n\n    test.ok(!('MyRoleDefaultPolicyA36BE1DD' in stack.toCloudFormation().Resources), 'initially created without a policy');\n\n    role.addToPolicy(new PolicyStatement().addResource('myresource').addAction('myaction'));\n    test.ok(stack.toCloudFormation().Resources.MyRoleDefaultPolicyA36BE1DD, 'policy resource created');\n\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'sns.amazonaws.com' } } ],\n             Version: '2012-10-17' } } },\n        MyRoleDefaultPolicyA36BE1DD:\n         { Type: 'AWS::IAM::Policy',\n         Properties:\n          { PolicyDocument:\n           { Statement:\n            [ { Action: 'myaction', Effect: 'Allow', Resource: 'myresource' } ],\n             Version: '2012-10-17' },\n          PolicyName: 'MyRoleDefaultPolicyA36BE1DD',\n          Roles: [ { Ref: 'MyRoleF48FFE04' } ] } } } });\n    test.done();\n  },\n\n  'managed policy arns can be supplied upon initialization and also added later'(test: Test) {\n    const stack = new Stack();\n\n    const role = new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('service'),\n      managedPolicyArns: [ 'managed1', 'managed2' ]\n    });\n\n    role.attachManagedPolicy('managed3');\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'service' } } ],\n             Version: '2012-10-17' },\n          ManagedPolicyArns: [ 'managed1', 'managed2', 'managed3' ] } } } });\n    test.done();\n  },\n\n  'role implements IDependable to allow resources to depend on it'(test: Test) {\n    const stack = new Stack();\n    const role = new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('foo') });\n\n    test.equal(role.dependencyElements.length, 1);\n\n    const roleResource = role.dependencyElements[0] as Resource;\n    test.equal(roleResource.resourceType, 'AWS::IAM::Role');\n    test.done();\n  },\n\n  'federated principal can change AssumeRoleAction'(test: Test) {\n    const stack = new Stack();\n    const cognitoPrincipal = new FederatedPrincipal(\n      'foo',\n      { StringEquals: { key: 'value' } },\n      'sts:AssumeSomething');\n\n    new Role(stack, 'MyRole', { assumedBy: cognitoPrincipal });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Version: \"2012-10-17\",\n        Statement: [\n          {\n            Principal: { Federated: \"foo\" },\n            Condition: {\n              StringEquals: { key: \"value\" }\n            },\n            Action: \"sts:AssumeSomething\",\n            Effect: \"Allow\",\n          }\n        ],\n      }\n    }));\n\n    test.done();\n  },\n\n  'maxSessionDuration': {\n\n    'is not specified by default'(test: Test) {\n      const stack = new Stack();\n      new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n      expect(stack).toMatch({\n        Resources: {\n          MyRoleF48FFE04: {\n          Type: \"AWS::IAM::Role\",\n          Properties: {\n            AssumeRolePolicyDocument: {\n            Statement: [\n              {\n              Action: \"sts:AssumeRole\",\n              Effect: \"Allow\",\n              Principal: {\n                Service: \"sns.amazonaws.com\"\n              }\n              }\n            ],\n            Version: \"2012-10-17\"\n            }\n          }\n          }\n        }\n      });\n      test.done();\n    },\n\n    'can be used to specify the maximum session duration for assuming the role'(test: Test) {\n      const stack = new Stack();\n\n      new Role(stack, 'MyRole', { maxSessionDurationSec: 3700, assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n\n      expect(stack).to(haveResource('AWS::IAM::Role', {\n        MaxSessionDuration: 3700\n      }));\n\n      test.done();\n    },\n\n    'must be between 3600 and 43200'(test: Test) {\n      const stack = new Stack();\n\n      const assumedBy = new ServicePrincipal('bla');\n\n      new Role(stack, 'MyRole1', { assumedBy, maxSessionDurationSec: 3600 });\n      new Role(stack, 'MyRole2', { assumedBy, maxSessionDurationSec: 43200 });\n\n      const expected = (val: any) => `maxSessionDuration is set to ${val}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`;\n      test.throws(() => new Role(stack, 'MyRole3', { assumedBy, maxSessionDurationSec: 60 }), expected(60));\n      test.throws(() => new Role(stack, 'MyRole4', { assumedBy, maxSessionDurationSec: 3599 }), expected(3599));\n      test.throws(() => new Role(stack, 'MyRole5', { assumedBy, maxSessionDurationSec: 43201 }), expected(43201));\n\n      test.done();\n    }\n  }\n\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.role.js","sourceRoot":"","sources":["test.role.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, haveResource } from '@aws-cdk/assert';\nimport { Resource, Stack } from '@aws-cdk/cdk';\nimport { Test } from 'nodeunit';\nimport { ArnPrincipal, CompositePrincipal, FederatedPrincipal, PolicyStatement, Role, ServicePrincipal } from '../lib';\n\nexport = {\n  'default role'(test: Test) {\n    const stack = new Stack();\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com')\n    });\n\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'sns.amazonaws.com' } } ],\n             Version: '2012-10-17' } } } } });\n    test.done();\n  },\n\n  'can supply externalId'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com'),\n      externalId: 'SomeSecret',\n    });\n\n    // THEN\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Condition: {\n              StringEquals: { \"sts:ExternalId\": \"SomeSecret\" }\n            },\n            Effect: \"Allow\",\n            Principal: { Service: \"sns.amazonaws.com\" }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  },\n\n  'policy is created automatically when permissions are added'(test: Test) {\n    const stack = new Stack();\n\n    const role = new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('sns.amazonaws.com')\n    });\n\n    test.ok(!('MyRoleDefaultPolicyA36BE1DD' in stack.toCloudFormation().Resources), 'initially created without a policy');\n\n    role.addToPolicy(new PolicyStatement().addResource('myresource').addAction('myaction'));\n    test.ok(stack.toCloudFormation().Resources.MyRoleDefaultPolicyA36BE1DD, 'policy resource created');\n\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'sns.amazonaws.com' } } ],\n             Version: '2012-10-17' } } },\n        MyRoleDefaultPolicyA36BE1DD:\n         { Type: 'AWS::IAM::Policy',\n         Properties:\n          { PolicyDocument:\n           { Statement:\n            [ { Action: 'myaction', Effect: 'Allow', Resource: 'myresource' } ],\n             Version: '2012-10-17' },\n          PolicyName: 'MyRoleDefaultPolicyA36BE1DD',\n          Roles: [ { Ref: 'MyRoleF48FFE04' } ] } } } });\n    test.done();\n  },\n\n  'managed policy arns can be supplied upon initialization and also added later'(test: Test) {\n    const stack = new Stack();\n\n    const role = new Role(stack, 'MyRole', {\n      assumedBy: new ServicePrincipal('service'),\n      managedPolicyArns: [ 'managed1', 'managed2' ]\n    });\n\n    role.attachManagedPolicy('managed3');\n    expect(stack).toMatch({ Resources:\n      { MyRoleF48FFE04:\n         { Type: 'AWS::IAM::Role',\n         Properties:\n          { AssumeRolePolicyDocument:\n           { Statement:\n            [ { Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: { Service: 'service' } } ],\n             Version: '2012-10-17' },\n          ManagedPolicyArns: [ 'managed1', 'managed2', 'managed3' ] } } } });\n    test.done();\n  },\n\n  'role implements IDependable to allow resources to depend on it'(test: Test) {\n    const stack = new Stack();\n    const role = new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('foo') });\n\n    test.equal(role.dependencyElements.length, 1);\n\n    const roleResource = role.dependencyElements[0] as Resource;\n    test.equal(roleResource.resourceType, 'AWS::IAM::Role');\n    test.done();\n  },\n\n  'federated principal can change AssumeRoleAction'(test: Test) {\n    const stack = new Stack();\n    const cognitoPrincipal = new FederatedPrincipal(\n      'foo',\n      { StringEquals: { key: 'value' } },\n      'sts:AssumeSomething');\n\n    new Role(stack, 'MyRole', { assumedBy: cognitoPrincipal });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Version: \"2012-10-17\",\n        Statement: [\n          {\n            Principal: { Federated: \"foo\" },\n            Condition: {\n              StringEquals: { key: \"value\" }\n            },\n            Action: \"sts:AssumeSomething\",\n            Effect: \"Allow\",\n          }\n        ],\n      }\n    }));\n\n    test.done();\n  },\n\n  'maxSessionDuration': {\n\n    'is not specified by default'(test: Test) {\n      const stack = new Stack();\n      new Role(stack, 'MyRole', { assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n      expect(stack).toMatch({\n        Resources: {\n          MyRoleF48FFE04: {\n          Type: \"AWS::IAM::Role\",\n          Properties: {\n            AssumeRolePolicyDocument: {\n            Statement: [\n              {\n              Action: \"sts:AssumeRole\",\n              Effect: \"Allow\",\n              Principal: {\n                Service: \"sns.amazonaws.com\"\n              }\n              }\n            ],\n            Version: \"2012-10-17\"\n            }\n          }\n          }\n        }\n      });\n      test.done();\n    },\n\n    'can be used to specify the maximum session duration for assuming the role'(test: Test) {\n      const stack = new Stack();\n\n      new Role(stack, 'MyRole', { maxSessionDurationSec: 3700, assumedBy: new ServicePrincipal('sns.amazonaws.com') });\n\n      expect(stack).to(haveResource('AWS::IAM::Role', {\n        MaxSessionDuration: 3700\n      }));\n\n      test.done();\n    },\n\n    'must be between 3600 and 43200'(test: Test) {\n      const stack = new Stack();\n\n      const assumedBy = new ServicePrincipal('bla');\n\n      new Role(stack, 'MyRole1', { assumedBy, maxSessionDurationSec: 3600 });\n      new Role(stack, 'MyRole2', { assumedBy, maxSessionDurationSec: 43200 });\n\n      const expected = (val: any) => `maxSessionDuration is set to ${val}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`;\n      test.throws(() => new Role(stack, 'MyRole3', { assumedBy, maxSessionDurationSec: 60 }), expected(60));\n      test.throws(() => new Role(stack, 'MyRole4', { assumedBy, maxSessionDurationSec: 3599 }), expected(3599));\n      test.throws(() => new Role(stack, 'MyRole5', { assumedBy, maxSessionDurationSec: 43201 }), expected(43201));\n\n      test.done();\n    }\n  },\n\n  'allow role with multiple principals'(test: Test) {\n    const stack = new Stack();\n\n    new Role(stack, 'MyRole', {\n      assumedBy: new CompositePrincipal(\n        new ServicePrincipal('boom.amazonaws.com'),\n        new ArnPrincipal('1111111')\n      )\n    });\n\n    expect(stack).to(haveResource('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [\n          {\n            Action: \"sts:AssumeRole\",\n            Effect: \"Allow\",\n            Principal: {\n              Service: \"boom.amazonaws.com\",\n              AWS: \"1111111\"\n            }\n          }\n        ],\n        Version: \"2012-10-17\"\n      }\n    }));\n\n    test.done();\n  }\n\n};\n"]}

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

845606

increased by48.68%

Number of package files

66

increased by11.86%

Lines of code

5601

increased by42.37%

Number of lines in readme file

84

increased by281.82%

Dependency changes

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

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

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

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

• Updated@aws-cdk/cdk@^0.21.0