terraconstructs 0.0.14 → 0.0.15

package/lib/aws/iam/group.d.ts

@@ -0,0 +1,146 @@
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "../aws-construct";
+import { IIdentity } from "./identity-base";
+import { IManagedPolicy } from "./managed-policy";
+import { Policy } from "./policy";
+import { PolicyStatement } from "./policy-statement";
+import { AddToPrincipalPolicyResult, IPrincipal, PrincipalPolicyFragment } from "./principals";
+import { IUser } from "./user";
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface GroupOutputs {
+    readonly arn: string;
+    readonly name: string;
+}
+/**
+ * Represents an IAM Group.
+ *
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html
+ */
+export interface IGroup extends IIdentity, IAwsConstruct {
+    /**
+     * strongly typed roleOutputs
+     *
+     * @attribute
+     */
+    readonly groupOutputs: GroupOutputs;
+    /**
+     * Returns the IAM Group Name
+     *
+     * @attribute
+     */
+    readonly groupName: string;
+    /**
+     * Returns the IAM Group ARN
+     *
+     * @attribute
+     */
+    readonly groupArn: string;
+}
+/**
+ * Properties for defining an IAM group.
+ */
+export interface GroupProps extends AwsConstructProps {
+    /**
+     * A name for the IAM group. For valid values, see the GroupName parameter
+     * for the CreateGroup action in the IAM API Reference. If you don't specify
+     * a name, a unique physical name will be generated.
+     *
+     * @default Generated by the framework (recommended)
+     */
+    readonly groupName?: string;
+    /**
+     * A list of managed policies to associate with this group.
+     *
+     * You can later add managed policies by calling addManagedPolicy.
+     *
+     * @default - No managed policies.
+     */
+    readonly managedPolicies?: IManagedPolicy[];
+    /**
+     * The path to the group. For more information about paths, see
+     * "IAM Identifiers" in the IAM User Guide.
+     *
+     * @default "/"
+     */
+    readonly path?: string;
+}
+/**
+ * Base class for IAM Groups.
+ */
+declare abstract class GroupBase extends AwsConstructBase implements IGroup {
+    abstract readonly groupName: string;
+    abstract readonly groupArn: string;
+    get groupOutputs(): GroupOutputs;
+    get outputs(): Record<string, any>;
+    readonly grantPrincipal: IPrincipal;
+    readonly principalAccount: string | undefined;
+    readonly assumeRoleAction: string;
+    private readonly attachedPolicies;
+    private defaultPolicy?;
+    get policyFragment(): PrincipalPolicyFragment;
+    /**
+     * Attaches an inline policy to this group.
+     * @param policy The policy to attach.
+     */
+    attachInlinePolicy(policy: Policy): void;
+    /**
+     * Adds a managed policy to this group.
+     * (Note: In TerraConstructs managed policies are attached separately so this method just tracks them.)
+     */
+    addManagedPolicy(_policy: IManagedPolicy): void;
+    /**
+     * Adds a user to this group.
+     */
+    addUser(user: IUser): void;
+    /**
+     * Adds an IAM statement to the default policy.
+     */
+    addToPrincipalPolicy(statement: PolicyStatement): AddToPrincipalPolicyResult;
+    addToPolicy(statement: PolicyStatement): boolean;
+}
+/**
+ * An IAM Group (a collection of IAM users) which lets you specify permissions for multiple users.
+ *
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html
+ */
+export declare class Group extends GroupBase {
+    /**
+     * Import an external group by ARN.
+     *
+     * Note: If the imported Group ARN is a Token and contains a path,
+     * the groupName property may not resolve correctly. In that case supply an ARN without a path.
+     *
+     * @param scope construct scope
+     * @param id construct id
+     * @param groupArn the ARN of the group to import (e.g. arn:aws:iam::account-id:group/group-name)
+     */
+    static fromGroupArn(scope: Construct, id: string, groupArn: string): IGroup;
+    /**
+     * Import an existing group by given name (including path).
+     *
+     * @param scope construct scope
+     * @param id construct id
+     * @param groupName the full group name (with path) of the existing group to import
+     */
+    static fromGroupName(scope: Construct, id: string, groupName: string): IGroup;
+    readonly groupName: string;
+    readonly groupArn: string;
+    private readonly managedPolicies;
+    private readonly physicalName;
+    constructor(scope: Construct, id: string, props?: GroupProps);
+    /**
+     * Attaches a managed policy to this group.
+     * @param policy The managed policy to attach.
+     */
+    addManagedPolicy(policy: IManagedPolicy): void;
+    private managedPoliciesExceededWarning;
+    /**
+     * Adds resource to the terraform JSON output.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform(): any;
+}
+export {};

package/lib/aws/iam/group.js

@@ -0,0 +1,199 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Group = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/dd912daf2b91a4a32064341e92863afbd9eeebdd/packages/aws-cdk-lib/aws-iam/lib/group.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const policy_1 = require("./policy");
+const principals_1 = require("./principals");
+const util_1 = require("./private/util");
+/**
+ * Base class for IAM Groups.
+ */
+class GroupBase extends aws_construct_1.AwsConstructBase {
+    constructor() {
+        super(...arguments);
+        this.grantPrincipal = this;
+        this.principalAccount = this.env.account;
+        this.assumeRoleAction = "sts:AssumeRole";
+        this.attachedPolicies = new util_1.AttachedPolicies();
+    }
+    get groupOutputs() {
+        return {
+            arn: this.groupArn,
+            name: this.groupName,
+        };
+    }
+    get outputs() {
+        return this.groupOutputs;
+    }
+    get policyFragment() {
+        return new principals_1.ArnPrincipal(this.groupArn).policyFragment;
+    }
+    /**
+     * Attaches an inline policy to this group.
+     * @param policy The policy to attach.
+     */
+    attachInlinePolicy(policy) {
+        this.attachedPolicies.attach(policy);
+        policy.attachToGroup(this);
+    }
+    /**
+     * Adds a managed policy to this group.
+     * (Note: In TerraConstructs managed policies are attached separately so this method just tracks them.)
+     */
+    addManagedPolicy(_policy) {
+        // No-op here; managed policies are attached externally via separate resources.
+    }
+    /**
+     * Adds a user to this group.
+     */
+    addUser(user) {
+        user.addToGroup(this);
+    }
+    /**
+     * Adds an IAM statement to the default policy.
+     */
+    addToPrincipalPolicy(statement) {
+        if (!this.defaultPolicy) {
+            this.defaultPolicy = new policy_1.Policy(this, "DefaultPolicy");
+            this.defaultPolicy.attachToGroup(this);
+        }
+        this.defaultPolicy.addStatements(statement);
+        return { statementAdded: true, policyDependable: this.defaultPolicy };
+    }
+    addToPolicy(statement) {
+        return this.addToPrincipalPolicy(statement).statementAdded;
+    }
+}
+/**
+ * An IAM Group (a collection of IAM users) which lets you specify permissions for multiple users.
+ *
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html
+ */
+class Group extends GroupBase {
+    /**
+     * Import an external group by ARN.
+     *
+     * Note: If the imported Group ARN is a Token and contains a path,
+     * the groupName property may not resolve correctly. In that case supply an ARN without a path.
+     *
+     * @param scope construct scope
+     * @param id construct id
+     * @param groupArn the ARN of the group to import (e.g. arn:aws:iam::account-id:group/group-name)
+     */
+    static fromGroupArn(scope, id, groupArn) {
+        const arnComponents = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(groupArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        const groupName = arnComponents.resourceName;
+        class Import extends GroupBase {
+            constructor() {
+                super(...arguments);
+                this.groupName = groupName;
+                this.groupArn = groupArn;
+                this.principalAccount = arnComponents.account;
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Import an existing group by given name (including path).
+     *
+     * @param scope construct scope
+     * @param id construct id
+     * @param groupName the full group name (with path) of the existing group to import
+     */
+    static fromGroupName(scope, id, groupName) {
+        const groupArn = aws_stack_1.AwsStack.ofAwsConstruct(scope).formatArn({
+            service: "iam",
+            region: "",
+            resource: "group",
+            resourceName: groupName,
+        });
+        return Group.fromGroupArn(scope, id, groupArn);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.managedPolicies = [];
+        this.physicalName =
+            props.groupName ||
+                this.stack.uniqueResourceName(this, {
+                    prefix: this.gridUUID,
+                });
+        if (props.managedPolicies) {
+            this.managedPolicies.push(...props.managedPolicies);
+        }
+        // Create the IAM Group using Terraform AWS Provider's IAM Group.
+        const groupResource = new provider_aws_1.iamGroup.IamGroup(this, "Resource", {
+            name: this.physicalName,
+            path: props.path,
+        });
+        this.groupName = groupResource.name;
+        this.groupArn = groupResource.arn;
+        // this.getResourceArnAttribute(groupResource.arn, {
+        //   region: "", // IAM is global per partition.
+        //   service: "iam",
+        //   resource: "group",
+        //   resourceName: `${props.path ? (props.path.startsWith("/") ? props.path.substring(1) : props.path) : ""}${this.physicalName}`,
+        // });
+        this.managedPoliciesExceededWarning();
+    }
+    /**
+     * Attaches a managed policy to this group.
+     * @param policy The managed policy to attach.
+     */
+    addManagedPolicy(policy) {
+        if (this.managedPolicies.indexOf(policy) >= 0) {
+            return;
+        }
+        this.managedPolicies.push(policy);
+        this.managedPoliciesExceededWarning();
+    }
+    managedPoliciesExceededWarning() {
+        if (this.managedPolicies.length > 10) {
+            // "@aws-cdk/aws-iam:groupMaxPoliciesExceeded",
+            cdktf_1.Annotations.of(this).addWarning(`You added ${this.managedPolicies.length} managed policies to IAM Group ${this.physicalName}. The maximum number of managed policies attached to an IAM group is 10.`);
+        }
+    }
+    /**
+     * Adds resource to the terraform JSON output.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        /**
+         * A preparing resolve run might add new resources to the stack
+         *
+         * should not add resources if `force` is `false` and the policy
+         * document is empty or not attached
+         * ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-iam/lib/policy.ts#L149
+         */
+        if (this.managedPolicies.length === 0) {
+            return {};
+        }
+        // add iamGroupPolicyAttachment resource for each referenced ManagedPolicy
+        // NOTE: The TerraformDependendableAspect will propgate construct dependencies on this policy to its IamRolePolicy resources
+        // not sure if time.sleep is still necessary?
+        // https://github.com/pulumi/pulumi-aws/issues/2260#issuecomment-1977606509
+        // else need: https://github.com/hashicorp/terraform-provider-aws/issues/29828#issuecomment-1693307500
+        for (let i = 0; i < this.managedPolicies.length; i++) {
+            const id = `ResourceManagedPolicy${i}`; // unique id for each managed policy
+            // ignore if already generated
+            if (this.node.tryFindChild(id))
+                continue;
+            new provider_aws_1.iamGroupPolicyAttachment.IamGroupPolicyAttachment(this, id, {
+                group: this.groupName,
+                policyArn: this.managedPolicies[i].managedPolicyArn,
+            });
+        }
+        return {};
+    }
+}
+exports.Group = Group;
+_a = JSII_RTTI_SYMBOL_1;
+Group[_a] = { fqn: "terraconstructs.aws.iam.Group", version: "0.0.15" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group.js","sourceRoot":"","sources":["../../../src/aws/iam/group.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/dd912daf2b91a4a32064341e92863afbd9eeebdd/packages/aws-cdk-lib/aws-iam/lib/group.ts\n\nimport {\n  iamGroupPolicyAttachment,\n  iamGroup as tfIamGroup,\n} from \"@cdktf/provider-aws\";\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { IIdentity } from \"./identity-base\";\nimport { IManagedPolicy } from \"./managed-policy\";\nimport { Policy } from \"./policy\";\nimport { PolicyStatement } from \"./policy-statement\";\nimport {\n  AddToPrincipalPolicyResult,\n  ArnPrincipal,\n  IPrincipal,\n  PrincipalPolicyFragment,\n} from \"./principals\";\nimport { AttachedPolicies } from \"./private/util\";\nimport { IUser } from \"./user\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface GroupOutputs {\n  readonly arn: string;\n  readonly name: string;\n}\n\n/**\n * Represents an IAM Group.\n *\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html\n */\nexport interface IGroup extends IIdentity, IAwsConstruct {\n  /**\n   * strongly typed roleOutputs\n   *\n   * @attribute\n   */\n  readonly groupOutputs: GroupOutputs;\n\n  /**\n   * Returns the IAM Group Name\n   *\n   * @attribute\n   */\n  readonly groupName: string;\n\n  /**\n   * Returns the IAM Group ARN\n   *\n   * @attribute\n   */\n  readonly groupArn: string;\n}\n\n/**\n * Properties for defining an IAM group.\n */\nexport interface GroupProps extends AwsConstructProps {\n  /**\n   * A name for the IAM group. For valid values, see the GroupName parameter\n   * for the CreateGroup action in the IAM API Reference. If you don't specify\n   * a name, a unique physical name will be generated.\n   *\n   * @default Generated by the framework (recommended)\n   */\n  readonly groupName?: string;\n\n  /**\n   * A list of managed policies to associate with this group.\n   *\n   * You can later add managed policies by calling addManagedPolicy.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * The path to the group. For more information about paths, see\n   * \"IAM Identifiers\" in the IAM User Guide.\n   *\n   * @default \"/\"\n   */\n  readonly path?: string;\n}\n\n/**\n * Base class for IAM Groups.\n */\nabstract class GroupBase extends AwsConstructBase implements IGroup {\n  public abstract readonly groupName: string;\n  public abstract readonly groupArn: string;\n  public get groupOutputs(): GroupOutputs {\n    return {\n      arn: this.groupArn,\n      name: this.groupName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.groupOutputs;\n  }\n\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly principalAccount: string | undefined = this.env.account;\n  public readonly assumeRoleAction: string = \"sts:AssumeRole\";\n\n  private readonly attachedPolicies = new AttachedPolicies();\n  private defaultPolicy?: Policy;\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new ArnPrincipal(this.groupArn).policyFragment;\n  }\n\n  /**\n   * Attaches an inline policy to this group.\n   * @param policy The policy to attach.\n   */\n  public attachInlinePolicy(policy: Policy): void {\n    this.attachedPolicies.attach(policy);\n    policy.attachToGroup(this);\n  }\n\n  /**\n   * Adds a managed policy to this group.\n   * (Note: In TerraConstructs managed policies are attached separately so this method just tracks them.)\n   */\n  public addManagedPolicy(_policy: IManagedPolicy): void {\n    // No-op here; managed policies are attached externally via separate resources.\n  }\n\n  /**\n   * Adds a user to this group.\n   */\n  public addUser(user: IUser): void {\n    user.addToGroup(this);\n  }\n\n  /**\n   * Adds an IAM statement to the default policy.\n   */\n  public addToPrincipalPolicy(\n    statement: PolicyStatement,\n  ): AddToPrincipalPolicyResult {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, \"DefaultPolicy\");\n      this.defaultPolicy.attachToGroup(this);\n    }\n    this.defaultPolicy.addStatements(statement);\n    return { statementAdded: true, policyDependable: this.defaultPolicy };\n  }\n\n  public addToPolicy(statement: PolicyStatement): boolean {\n    return this.addToPrincipalPolicy(statement).statementAdded;\n  }\n}\n\n/**\n * An IAM Group (a collection of IAM users) which lets you specify permissions for multiple users.\n *\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html\n */\nexport class Group extends GroupBase {\n  /**\n   * Import an external group by ARN.\n   *\n   * Note: If the imported Group ARN is a Token and contains a path,\n   * the groupName property may not resolve correctly. In that case supply an ARN without a path.\n   *\n   * @param scope construct scope\n   * @param id construct id\n   * @param groupArn the ARN of the group to import (e.g. arn:aws:iam::account-id:group/group-name)\n   */\n  public static fromGroupArn(\n    scope: Construct,\n    id: string,\n    groupArn: string,\n  ): IGroup {\n    const arnComponents = AwsStack.ofAwsConstruct(scope).splitArn(\n      groupArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n    const groupName = arnComponents.resourceName!;\n    class Import extends GroupBase {\n      public groupName = groupName;\n      public groupArn = groupArn;\n      public principalAccount = arnComponents.account;\n    }\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import an existing group by given name (including path).\n   *\n   * @param scope construct scope\n   * @param id construct id\n   * @param groupName the full group name (with path) of the existing group to import\n   */\n  public static fromGroupName(\n    scope: Construct,\n    id: string,\n    groupName: string,\n  ): IGroup {\n    const groupArn = AwsStack.ofAwsConstruct(scope).formatArn({\n      service: \"iam\",\n      region: \"\",\n      resource: \"group\",\n      resourceName: groupName,\n    });\n    return Group.fromGroupArn(scope, id, groupArn);\n  }\n\n  public readonly groupName: string;\n  public readonly groupArn: string;\n\n  private readonly managedPolicies: IManagedPolicy[] = [];\n\n  private readonly physicalName: string;\n  constructor(scope: Construct, id: string, props: GroupProps = {}) {\n    super(scope, id, props);\n    this.physicalName =\n      props.groupName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    if (props.managedPolicies) {\n      this.managedPolicies.push(...props.managedPolicies);\n    }\n\n    // Create the IAM Group using Terraform AWS Provider's IAM Group.\n    const groupResource = new tfIamGroup.IamGroup(this, \"Resource\", {\n      name: this.physicalName,\n      path: props.path,\n    });\n\n    this.groupName = groupResource.name;\n    this.groupArn = groupResource.arn;\n    // this.getResourceArnAttribute(groupResource.arn, {\n    //   region: \"\", // IAM is global per partition.\n    //   service: \"iam\",\n    //   resource: \"group\",\n    //   resourceName: `${props.path ? (props.path.startsWith(\"/\") ? props.path.substring(1) : props.path) : \"\"}${this.physicalName}`,\n    // });\n\n    this.managedPoliciesExceededWarning();\n  }\n\n  /**\n   * Attaches a managed policy to this group.\n   * @param policy The managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy): void {\n    if (this.managedPolicies.indexOf(policy) >= 0) {\n      return;\n    }\n    this.managedPolicies.push(policy);\n    this.managedPoliciesExceededWarning();\n  }\n\n  private managedPoliciesExceededWarning(): void {\n    if (this.managedPolicies.length > 10) {\n      // \"@aws-cdk/aws-iam:groupMaxPoliciesExceeded\",\n      Annotations.of(this).addWarning(\n        `You added ${this.managedPolicies.length} managed policies to IAM Group ${this.physicalName}. The maximum number of managed policies attached to an IAM group is 10.`,\n      );\n    }\n  }\n  /**\n   * Adds resource to the terraform JSON output.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    /**\n     * A preparing resolve run might add new resources to the stack\n     *\n     * should not add resources if `force` is `false` and the policy\n     * document is empty or not attached\n     * ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-iam/lib/policy.ts#L149\n     */\n    if (this.managedPolicies.length === 0) {\n      return {};\n    }\n\n    // add iamGroupPolicyAttachment resource for each referenced ManagedPolicy\n    // NOTE: The TerraformDependendableAspect will propgate construct dependencies on this policy to its IamRolePolicy resources\n    // not sure if time.sleep is still necessary?\n    // https://github.com/pulumi/pulumi-aws/issues/2260#issuecomment-1977606509\n    // else need: https://github.com/hashicorp/terraform-provider-aws/issues/29828#issuecomment-1693307500\n    for (let i = 0; i < this.managedPolicies.length; i++) {\n      const id = `ResourceManagedPolicy${i}`; // unique id for each managed policy\n      // ignore if already generated\n      if (this.node.tryFindChild(id)) continue;\n\n      new iamGroupPolicyAttachment.IamGroupPolicyAttachment(this, id, {\n        group: this.groupName,\n        policyArn: this.managedPolicies[i].managedPolicyArn,\n      });\n    }\n    return {};\n  }\n}\n"]}

package/lib/aws/iam/index.d.ts

@@ -13,5 +13,7 @@ export * from "./saml-provider";
 export * from "./unknown-principal";
 export * from "./utils";
 export * from "./instance-profile";
+export * from "./group";
+export * from "./user";
 export * from "./policy-statement-props.generated";
 export * from "./policy-document-config.generated";

package/lib/aws/iam/index.js

@@ -29,7 +29,9 @@ __exportStar(require("./saml-provider"), exports);
 __exportStar(require("./unknown-principal"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./instance-profile"), exports);
+__exportStar(require("./group"), exports);
+__exportStar(require("./user"), exports);
 // auto generated by struct-builder
 __exportStar(require("./policy-statement-props.generated"), exports);
 __exportStar(require("./policy-document-config.generated"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL2lhbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMENBQXdCO0FBQ3hCLGtEQUFnQztBQUNoQyxtREFBaUM7QUFDakMsa0RBQWdDO0FBQ2hDLHFFQUFtRDtBQUNuRCxvREFBa0M7QUFDbEMscUVBQW1EO0FBQ25ELHFEQUFtQztBQUNuQywyQ0FBeUI7QUFDekIsK0NBQTZCO0FBQzdCLHlDQUF1QjtBQUN2QixrREFBZ0M7QUFDaEMsc0RBQW9DO0FBQ3BDLDBDQUF3QjtBQUN4QixxREFBbUM7QUFFbkMsbUNBQW1DO0FBQ25DLHFFQUFtRDtBQUNuRCxxRUFBbUQiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9ncmFudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vaWRlbnRpdHktYmFzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbWFuYWdlZC1wb2xpY3lcIjtcbmV4cG9ydCAqIGZyb20gXCIuL29pZGMtcHJvdmlkZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1kb2N1bWVudC1jb25maWcuZ2VuZXJhdGVkXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wb2xpY3ktZG9jdW1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1zdGF0ZW1lbnQtcHJvcHMuZ2VuZXJhdGVkXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wb2xpY3ktc3RhdGVtZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wb2xpY3lcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ByaW5jaXBhbHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3JvbGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NhbWwtcHJvdmlkZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Vua25vd24tcHJpbmNpcGFsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW5zdGFuY2UtcHJvZmlsZVwiO1xuXG4vLyBhdXRvIGdlbmVyYXRlZCBieSBzdHJ1Y3QtYnVpbGRlclxuZXhwb3J0ICogZnJvbSBcIi4vcG9saWN5LXN0YXRlbWVudC1wcm9wcy5nZW5lcmF0ZWRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1kb2N1bWVudC1jb25maWcuZ2VuZXJhdGVkXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL2lhbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMENBQXdCO0FBQ3hCLGtEQUFnQztBQUNoQyxtREFBaUM7QUFDakMsa0RBQWdDO0FBQ2hDLHFFQUFtRDtBQUNuRCxvREFBa0M7QUFDbEMscUVBQW1EO0FBQ25ELHFEQUFtQztBQUNuQywyQ0FBeUI7QUFDekIsK0NBQTZCO0FBQzdCLHlDQUF1QjtBQUN2QixrREFBZ0M7QUFDaEMsc0RBQW9DO0FBQ3BDLDBDQUF3QjtBQUN4QixxREFBbUM7QUFDbkMsMENBQXdCO0FBQ3hCLHlDQUF1QjtBQUV2QixtQ0FBbUM7QUFDbkMscUVBQW1EO0FBQ25ELHFFQUFtRCIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2dyYW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pZGVudGl0eS1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tYW5hZ2VkLXBvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vb2lkYy1wcm92aWRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcG9saWN5LWRvY3VtZW50LWNvbmZpZy5nZW5lcmF0ZWRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1kb2N1bWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcG9saWN5LXN0YXRlbWVudC1wcm9wcy5nZW5lcmF0ZWRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1zdGF0ZW1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHJpbmNpcGFsc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcm9sZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2FtbC1wcm92aWRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdW5rbm93bi1wcmluY2lwYWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pbnN0YW5jZS1wcm9maWxlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ncm91cFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXNlclwiO1xuXG4vLyBhdXRvIGdlbmVyYXRlZCBieSBzdHJ1Y3QtYnVpbGRlclxuZXhwb3J0ICogZnJvbSBcIi4vcG9saWN5LXN0YXRlbWVudC1wcm9wcy5nZW5lcmF0ZWRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1kb2N1bWVudC1jb25maWcuZ2VuZXJhdGVkXCI7XG4iXX0=

package/lib/aws/iam/instance-profile.js

@@ -120,5 +120,5 @@ class InstanceProfile extends InstanceProfileBase {
 }
 exports.InstanceProfile = InstanceProfile;
 _a = JSII_RTTI_SYMBOL_1;
-InstanceProfile[_a] = { fqn: "terraconstructs.aws.iam.InstanceProfile", version: "0.0.14" };
+InstanceProfile[_a] = { fqn: "terraconstructs.aws.iam.InstanceProfile", version: "0.0.15" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instance-profile.js","sourceRoot":"","sources":["../../../src/aws/iam/instance-profile.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-iam/lib/instance-profile.ts\n\nimport { iamInstanceProfile } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { Arn } from \"../arn\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { ServicePrincipal } from \"./principals\";\nimport { IRole, Role } from \"./role\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface InstanceProfileOutputs {\n  /**\n   * The InstanceProfile's name.\n   * @attribute\n   */\n  readonly instanceProfileName: string;\n\n  /**\n   * The InstanceProfile's ARN.\n   * @attribute\n   */\n  readonly instanceProfileArn: string;\n\n  /**\n   * The role associated with the InstanceProfile.\n   */\n  readonly roleArn?: string;\n}\n\n/**\n * Represents an IAM Instance Profile\n */\nexport interface IInstanceProfile extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly instanceProfileOutputs: InstanceProfileOutputs;\n\n  /**\n   * The InstanceProfile's name.\n   * @attribute\n   */\n  readonly instanceProfileName: string;\n\n  /**\n   * The InstanceProfile's ARN.\n   * @attribute\n   */\n  readonly instanceProfileArn: string;\n\n  /**\n   * The role associated with the InstanceProfile.\n   */\n  readonly role?: IRole;\n}\n\n/**\n * Properties of an Instance Profile\n */\nexport interface InstanceProfileProps extends AwsConstructProps {\n  /**\n   * An IAM role to associate with the instance profile that is used by EC2 instances.\n   *\n   * The role must be assumable by the service principal `ec2.amazonaws.com`:\n   *\n   * @example\n   * const role = new iam.Role(this, 'MyRole', {\n   *   assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com')\n   * });\n   *\n   * @default - a role will be automatically created, it can be accessed via the `role` property\n   */\n  readonly role?: IRole;\n\n  /**\n   * The name of the InstanceProfile to create.\n   *\n   * @default - generated by CloudFormation\n   */\n  readonly instanceProfileName?: string;\n\n  /**\n   * The path to the InstanceProfile.\n   *\n   * @default /\n   */\n  readonly path?: string;\n}\n\n/**\n * Attributes of an Instance Profile\n */\nexport interface InstanceProfileAttributes {\n  /**\n   * The ARN of the InstanceProfile.\n   *\n   * Format: arn:<partition>:iam::<account-id>:instance-profile/<instance-profile-name-with-path>\n   */\n  readonly instanceProfileArn: string;\n\n  /**\n   * The role associated with the InstanceProfile.\n   *\n   * @default - no role\n   */\n  readonly role?: IRole;\n}\n\n/**\n * Base class for an Instance Profile\n */\nabstract class InstanceProfileBase\n  extends AwsConstructBase\n  implements IInstanceProfile\n{\n  public abstract readonly instanceProfileName: string;\n  public abstract readonly instanceProfileArn: string;\n\n  /**\n   * The role associated with the InstanceProfile.\n   * @internal\n   */\n  protected _role?: IRole;\n\n  public get instanceProfileOutputs(): InstanceProfileOutputs {\n    return {\n      instanceProfileName: this.instanceProfileName,\n      instanceProfileArn: this.instanceProfileArn,\n      roleArn: this.role?.roleArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.instanceProfileOutputs;\n  }\n  /**\n   * Returns the role associated with this InstanceProfile.\n   */\n  public get role(): IRole | undefined {\n    return this._role;\n  }\n}\n\n/**\n * IAM Instance Profile\n */\nexport class InstanceProfile extends InstanceProfileBase {\n  /**\n   * Import an existing InstanceProfile from an InstanceProfile name.\n   *\n   * @param scope construct scope\n   * @param id construct id\n   * @param instanceProfileName the name of the existing InstanceProfile to import\n   */\n  public static fromInstanceProfileName(\n    scope: Construct,\n    id: string,\n    instanceProfileName: string,\n  ): IInstanceProfile {\n    const instanceProfileArn = AwsStack.ofAwsConstruct(scope).formatArn({\n      service: \"iam\",\n      region: \"\",\n      resource: \"instance-profile\",\n      resourceName: instanceProfileName,\n    });\n    return InstanceProfile.fromInstanceProfileAttributes(scope, id, {\n      instanceProfileArn,\n    });\n  }\n\n  /**\n   * Import an existing InstanceProfile from an InstanceProfile ARN.\n   *\n   * If the ARN comes from a Token, the InstanceProfile cannot have a path; if so, any attempt\n   * to reference its instanceProfileName will fail.\n   *\n   * @param scope construct scope\n   * @param id construct id\n   * @param instanceProfileArn the ARN of the exiting InstanceProfile to import\n   */\n  public static fromInstanceProfileArn(\n    scope: Construct,\n    id: string,\n    instanceProfileArn: string,\n  ): IInstanceProfile {\n    return InstanceProfile.fromInstanceProfileAttributes(scope, id, {\n      instanceProfileArn,\n    });\n  }\n\n  /**\n   * Import an existing InstanceProfile from given InstanceProfile attributes.\n   *\n   * If the ARN comes from a Token, the InstanceProfile cannot have a path; if so, any attempt\n   * to reference its instanceProfileName will fail.\n   *\n   * @param scope construct scope\n   * @param id construct id\n   * @param attrs the attributes of the InstanceProfile to import\n   */\n  public static fromInstanceProfileAttributes(\n    scope: Construct,\n    id: string,\n    attrs: InstanceProfileAttributes,\n  ): IInstanceProfile {\n    class Import extends InstanceProfileBase {\n      public readonly instanceProfileName: string = Arn.extractResourceName(\n        attrs.instanceProfileArn,\n        \"instance-profile\",\n      )\n        .split(\"/\")\n        .pop()!;\n      public readonly instanceProfileArn: string = attrs.instanceProfileArn;\n\n      constructor(s: Construct, i: string) {\n        super(s, i);\n        this._role = attrs.role;\n      }\n    }\n    return new Import(scope, id);\n  }\n\n  /**\n   * Returns the name of this InstanceProfile.\n   */\n  public readonly instanceProfileName: string;\n\n  /**\n   * Returns the ARN of this InstanceProfile.\n   */\n  public readonly instanceProfileArn: string;\n\n  public resource: iamInstanceProfile.IamInstanceProfile;\n\n  constructor(scope: Construct, id: string, props: InstanceProfileProps = {}) {\n    super(scope, id, props);\n    const instanceProfileName =\n      props.instanceProfileName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    this._role =\n      props.role ||\n      new Role(this, \"InstanceRole\", {\n        roleName: `${instanceProfileName}-role`,\n        assumedBy: new ServicePrincipal(\"ec2.amazonaws.com\"),\n      });\n\n    this.resource = new iamInstanceProfile.IamInstanceProfile(\n      this,\n      \"Resource\",\n      {\n        name: instanceProfileName,\n        role: this._role.roleName,\n        path: props.path,\n      },\n    );\n\n    this.instanceProfileName = this.resource.id;\n    this.instanceProfileArn = this.resource.arn;\n    // this.getResourceArnAttribute(this.resource.arn, {\n    //   region: \"\",\n    //   service: \"iam\",\n    //   resource: \"instance-profile\",\n    //   resourceName: `${props.path ? props.path.substring(props.path.charAt(0) === \"/\" ? 1 : 0) : \"\"}${this.physicalName}`,\n    // });\n  }\n}\n"]}

package/lib/aws/iam/managed-policy.js

@@ -212,7 +212,7 @@ class ManagedPolicy extends ManagedPolicyBase {
 }
 exports.ManagedPolicy = ManagedPolicy;
 _a = JSII_RTTI_SYMBOL_1;
-ManagedPolicy[_a] = { fqn: "terraconstructs.aws.iam.ManagedPolicy", version: "0.0.14" };
+ManagedPolicy[_a] = { fqn: "terraconstructs.aws.iam.ManagedPolicy", version: "0.0.15" };
 class ManagedPolicyGrantPrincipal {
     constructor(_managedPolicy) {
         this._managedPolicy = _managedPolicy;

package/lib/aws/iam/oidc-provider.js

@@ -78,5 +78,5 @@ class OpenIdConnectProvider extends aws_construct_1.AwsConstructBase {
 }
 exports.OpenIdConnectProvider = OpenIdConnectProvider;
 _a = JSII_RTTI_SYMBOL_1;
-OpenIdConnectProvider[_a] = { fqn: "terraconstructs.aws.iam.OpenIdConnectProvider", version: "0.0.14" };
+OpenIdConnectProvider[_a] = { fqn: "terraconstructs.aws.iam.OpenIdConnectProvider", version: "0.0.15" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oidc-provider.js","sourceRoot":"","sources":["../../../src/aws/iam/oidc-provider.ts"],"names":[],"mappings":";;;;;AAAA,sDAA+D;AAE/D,gCAA6B;AAC7B,oDAI0B;AAqF1B;;;;;;;;;;;;;GAaG;AACH,MAAa,qBACX,SAAQ,gCAAgB;IAGxB;;;;;OAKG;IACI,MAAM,CAAC,4BAA4B,CACxC,KAAgB,EAChB,EAAU,EACV,wBAAgC;QAEhC,MAAM,YAAY,GAAG,SAAG,CAAC,mBAAmB,CAC1C,wBAAwB,EACxB,eAAe,CAChB,CAAC;QAEF,MAAM,MAAO,SAAQ,gCAAgB;YAArC;;gBACkB,6BAAwB,GAAG,wBAAwB,CAAC;gBACpD,gCAA2B,GAAG,YAAY,CAAC;gBAC3C,iCAA4B,GAAG;oBAC7C,GAAG,EAAE,wBAAwB;oBAC7B,MAAM,EAAE,YAAY;iBACrB,CAAC;YAIJ,CAAC;YAHC,IAAW,OAAO;gBAChB,OAAO,IAAI,CAAC,4BAA4B,CAAC;YAC3C,CAAC;SACF;QAED,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,4BAA4B,CAAC;IAC3C,CAAC;IAeD;;;;;OAKG;IACH,YACE,KAAgB,EAChB,EAAU,EACV,KAAiC;QAEjC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACxB,0EAA0E;QAC1E,mEAAmE;QACnE,IAAI,cAAc,GAAG,KAAK,CAAC,WAAW,IAAI;YACxC,0CAA0C;SAC3C,CAAC;QACF,yEAAyE;QAEzE,IAAI,CAAC,QAAQ,GAAG,IAAI,uCAAwB,CAAC,wBAAwB,CACnE,IAAI,EACJ,UAAU,EACV;YACE,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,YAAY,EAAE,KAAK,CAAC,SAAS;YAC7B,cAAc;SACf,CACF,CAAC;QACF,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAClD,IAAI,CAAC,2BAA2B,GAAG,SAAG,CAAC,mBAAmB,CACxD,IAAI,CAAC,wBAAwB,EAC7B,eAAe,CAChB,CAAC;QACF,IAAI,CAAC,gCAAgC,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;QACrE,IAAI,CAAC,4BAA4B,GAAG;YAClC,GAAG,EAAE,IAAI,CAAC,wBAAwB;YAClC,MAAM,EAAE,IAAI,CAAC,2BAA2B;SACzC,CAAC;IACJ,CAAC;;AA1FH,sDA2FC","sourcesContent":["import { iamOpenidConnectProvider } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { Arn } from \"../arn\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\n\nexport interface OpenIdConnectProviderOutputs {\n  /**\n   * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.\n   * @stability stable\n   */\n  readonly arn: string;\n  /**\n   * The issuer for OIDC Provider\n   * @stability stable\n   */\n  readonly issuer: string;\n}\n\n/**\n * Represents an IAM OpenID Connect provider.\n *\n */\nexport interface IOpenIdConnectProvider extends IAwsConstruct {\n  // strongly typed outputs\n  readonly openIdConnectProviderOutputs: OpenIdConnectProviderOutputs;\n\n  /**\n   * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.\n   */\n  readonly openIdConnectProviderArn: string;\n\n  /**\n   * The issuer for OIDC Provider\n   */\n  readonly openIdConnectProviderIssuer: string;\n}\n\n/**\n * Initialization properties for `OpenIdConnectProvider`.\n */\nexport interface OpenIdConnectProviderProps extends AwsConstructProps {\n  /**\n   * The URL of the identity provider. The URL must begin with https:// and\n   * should correspond to the iss claim in the provider's OpenID Connect ID\n   * tokens. Per the OIDC standard, path components are allowed but query\n   * parameters are not. Typically the URL consists of only a hostname, like\n   * https://server.example.org or https://example.com.\n   *\n   * You cannot register the same provider multiple times in a single AWS\n   * account. If you try to submit a URL that has already been used for an\n   * OpenID Connect provider in the AWS account, you will get an error.\n   */\n  readonly url: string;\n\n  /**\n   * A list of client IDs (also known as audiences). When a mobile or web app\n   * registers with an OpenID Connect provider, they establish a value that\n   * identifies the application. (This is the value that's sent as the client_id\n   * parameter on OAuth requests.)\n   *\n   * You can register multiple client IDs with the same provider. For example,\n   * you might have multiple applications that use the same OIDC provider. You\n   * cannot register more than 100 client IDs with a single IAM OIDC provider.\n   *\n   * Client IDs are up to 255 characters long.\n   */\n  readonly clientIds: string[];\n\n  /**\n   * A list of server certificate thumbprints for the OpenID Connect (OIDC)\n   * identity provider's server certificates.\n   *\n   * AWS secures communication with OIDC identity providers (IdPs) using our\n   * library of trusted root certificate authorities (CAs) to verify the\n   * JSON Web Key Set (JWKS) endpoint's TLS certificate.\n   *\n   * If your OIDC IdP relies on a certificate that is not signed by one of\n   * these trusted CAs, only then we secure communication using the\n   * thumbprints set in the IdP's configuration.\n   *\n   * AWS will fall back to thumbprint verification if we are unable to retrieve\n   * the TLS certificate or if TLS v1.3 is required.\n   *\n   * See [AWS OIDC Docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html#manage-oidc-provider-console)\n   */\n  readonly thumbprints?: string[];\n}\n\n/**\n * IAM OIDC identity providers are entities in IAM that describe an external\n * identity provider (IdP) service that supports the OpenID Connect (OIDC)\n * standard, such as Google or Salesforce. You use an IAM OIDC identity provider\n * when you want to establish trust between an OIDC-compatible IdP and your AWS\n * account. This is useful when creating a mobile app or web application that\n * requires access to AWS resources, but you don't want to create custom sign-in\n * code or manage your own user identities.\n *\n * @see http://openid.net/connect\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html\n *\n * @resource AWS::CloudFormation::CustomResource\n */\nexport class OpenIdConnectProvider\n  extends AwsConstructBase\n  implements IOpenIdConnectProvider\n{\n  /**\n   * Imports an Open ID connect provider from an ARN.\n   * @param scope The definition scope\n   * @param id ID of the construct\n   * @param openIdConnectProviderArn the ARN to import\n   */\n  public static fromOpenIdConnectProviderArn(\n    scope: Construct,\n    id: string,\n    openIdConnectProviderArn: string,\n  ): IOpenIdConnectProvider {\n    const resourceName = Arn.extractResourceName(\n      openIdConnectProviderArn,\n      \"oidc-provider\",\n    );\n\n    class Import extends AwsConstructBase implements IOpenIdConnectProvider {\n      public readonly openIdConnectProviderArn = openIdConnectProviderArn;\n      public readonly openIdConnectProviderIssuer = resourceName;\n      public readonly openIdConnectProviderOutputs = {\n        arn: openIdConnectProviderArn,\n        issuer: resourceName,\n      };\n      public get outputs() {\n        return this.openIdConnectProviderOutputs;\n      }\n    }\n\n    return new Import(scope, id, {});\n  }\n  public readonly openIdConnectProviderOutputs: OpenIdConnectProviderOutputs;\n  public get outputs(): Record<string, any> {\n    return this.openIdConnectProviderOutputs;\n  }\n  public readonly resource: iamOpenidConnectProvider.IamOpenidConnectProvider;\n\n  /**\n   * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.\n   */\n  public readonly openIdConnectProviderArn: string;\n\n  public readonly openIdConnectProviderIssuer: string;\n\n  /**\n   * The thumbprints configured for this provider.\n   */\n  public readonly openIdConnectProviderthumbprints: string[];\n\n  /**\n   * Defines an OpenID Connect provider.\n   * @param scope The definition scope\n   * @param id Construct ID\n   * @param props Initialization properties\n   */\n  public constructor(\n    scope: Construct,\n    id: string,\n    props: OpenIdConnectProviderProps,\n  ) {\n    super(scope, id, props);\n    // thumbprints is still required for terraform-provider-aws, use dummy ...\n    // https://github.com/hashicorp/terraform-provider-aws/issues/35112\n    let thumbprintList = props.thumbprints ?? [\n      \"afafafafafafafafafafafafafafafafafafafaf\",\n    ];\n    // TODO: this may cause unexpected errors if thumbprints are not provided\n\n    this.resource = new iamOpenidConnectProvider.IamOpenidConnectProvider(\n      this,\n      \"Resource\",\n      {\n        url: props.url,\n        clientIdList: props.clientIds,\n        thumbprintList,\n      },\n    );\n    this.openIdConnectProviderArn = this.resource.arn;\n    this.openIdConnectProviderIssuer = Arn.extractResourceName(\n      this.openIdConnectProviderArn,\n      \"oidc-provider\",\n    );\n    this.openIdConnectProviderthumbprints = this.resource.thumbprintList;\n    this.openIdConnectProviderOutputs = {\n      arn: this.openIdConnectProviderArn,\n      issuer: this.openIdConnectProviderIssuer,\n    };\n  }\n}\n"]}

package/lib/aws/iam/policy-document.js

@@ -168,5 +168,5 @@ class PolicyDocument extends aws_construct_1.AwsConstructBase {
 }
 exports.PolicyDocument = PolicyDocument;
 _a = JSII_RTTI_SYMBOL_1;
-PolicyDocument[_a] = { fqn: "terraconstructs.aws.iam.PolicyDocument", version: "0.0.14" };
+PolicyDocument[_a] = { fqn: "terraconstructs.aws.iam.PolicyDocument", version: "0.0.15" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-document.js","sourceRoot":"","sources":["../../../src/aws/iam/policy-document.ts"],"names":[],"mappings":";;;;;AAAA,wGAAwG;AACxG,sGAAsG;AACtG,4FAA4F;AAC5F,2DAA2D;AAC3D,6DAA6D;AAC7D,sDAA+D;AAC/D,iCAA8C;AAG9C,yDAAqD;AACrD,oDAAmE;AACnE,iEAA6D;AAC7D,uFAAkF;AAiFlF,MAAa,cACX,SAAQ,gCAAgB;IAGxB;;;;OAIG;IACI,MAAM,CAAC,QAAQ,CACpB,KAAgB,EAChB,EAAU,EACV,GAAQ;QAER,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACxD,MAAM,SAAS,GAAG,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC;QACtC,IAAI,SAAS,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QACD,iBAAiB,CAAC,aAAa,CAC7B,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,kCAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAC1D,CAAC;QACF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAID,4CAA4C;IAC5C,uCAAuC;IAEvC,IAAW,qBAAqB;QAC9B,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;IAC/B,CAAC;IACD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAED,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC5B,CAAC;IAID,YAAY,KAAgB,EAAE,EAAU,EAAE,QAA6B,EAAE;QACvE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAnBV,eAAU,GAAG,IAAI,KAAK,EAAmB,CAAC;QAoBxD,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC;QACxC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,CAAC;QAC/C,MAAM,IAAI,GAAG,IAAI,CAAC;QAClB,wEAAwE;QACxE,IAAI,CAAC,QAAQ,GAAG,IAAI,uCAAwB,CAAC,wBAAwB,CACnE,IAAI,EACJ,UAAU,EACV;YACE,GAAG,KAAK;YACR,SAAS,EAAE,YAAI,CAAC,QAAQ,CAAC;gBACvB,OAAO,EAAE,CAAC,OAAwB,EAAE,EAAE;oBACpC,IAAI,CAAC,qBAAqB,EAAE,CAAC;oBAC7B,OAAO,CAAC,qBAAqB,CAC3B,IAAI,uDAAyB,CAAC,IAAI,CAAC,cAAc,CAAC,CACnD,CAAC;oBACF,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC/B,uCAAwB,CAAC,4CAA4C,CACnE,CAAC,CAAC,MAAM,EAAE,CACX,CACF,CAAC;gBACJ,CAAC;aACF,CAAC;SACH,CACF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,qBAAqB;QAC1B,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChD,MAAM,MAAM,GAAG,IAAA,kCAAe,EAAC,IAAI,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YACjE,IAAI,CAAC,UAAU,CAAC,MAAM,CACpB,CAAC,EACD,IAAI,CAAC,UAAU,CAAC,MAAM,EACtB,GAAG,MAAM,CAAC,gBAAgB,CAC3B,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM;IACN,2BAA2B;IAC3B,KAAK;IACL,0CAA0C;IAC1C,MAAM;IACN,yBAAyB;IACzB,aAAa;IACb,yDAAyD;IACzD,OAAO;IACP,IAAI;IAEJ,0DAA0D;IAC1D,qDAAqD;IAErD;;;;OAIG;IACI,cAAc;QACnB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,4BAA4B;QAC5B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG;YACV,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC;YAC1D,OAAO,EAAE,YAAY;SACtB,CAAC;QAEF,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACH,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC;IACtC,CAAC;IAED;;;OAGG;IACH,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,GAAG,SAA4B;QAClD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;OAOG;IACI,oBAAoB;QACzB,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QACnC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,oBAAoB,EAAE,CAAC,CAAC;QACnD,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,yBAAyB;QAC9B,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QACnC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,yBAAyB,EAAE,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,yBAAyB;QAC9B,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QACnC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,yBAAyB,EAAE,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;;AAhMH,wCA0MC","sourcesContent":["// ref: https://github.com/aws/aws-cdk/tree/v2.161.1/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts\n// CAVEAT: instead of using IResolvable, this is a Construct and its constructor requires scope and id\n// This synths directly to the terraform-provider-aws `aws_iam_policy_document` data source.\n// This is not undefined when the policy document is empty.\n// TODO: Add validation and errors for empty policy documents\nimport { dataAwsIamPolicyDocument } from \"@cdktf/provider-aws\";\nimport { Lazy, IResolveContext } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { PolicyDocumentConfig } from \"./policy-document-config.generated\";\nimport { PolicyStatement } from \"./policy-statement\";\nimport { AwsConstructBase, IAwsConstruct } from \"../aws-construct\";\nimport { mergeStatements } from \"./private/merge-statements\";\nimport { PostProcessPolicyDocument } from \"./private/postprocess-policy-document\";\n\nexport interface PolicyDocumentOutputs {\n  /**\n   * The policy document JSON\n   */\n  readonly policy: any;\n}\n\nexport interface IPolicyDocument extends IAwsConstruct {\n  // strongly typed access to outputs\n  readonly policyDocumentOutputs: PolicyDocumentOutputs;\n  readonly isEmpty: boolean;\n  readonly statementCount: number;\n  readonly json: string;\n  /**\n   * Adds a statement to the policy document.\n   *\n   * @param statement the statement to add.\n   */\n  addStatements(...statement: PolicyStatement[]): void;\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for any policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  validateForAnyPolicy(): string[];\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for a resource-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  validateForResourcePolicy(): string[] /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for an identity-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */;\n  validateForIdentityPolicy(): string[];\n  /**\n   * Get AWS IAM Policy document JSON\n   *\n   * NOTE: This may contain unresolved tokens, use spec.resolve() to resolve them.\n   */\n  toDocumentJson(): any;\n}\n\nexport interface PolicyDocumentProps extends PolicyDocumentConfig {\n  /**\n   * Try to minimize the policy by merging statements\n   *\n   * To avoid overrunning the maximum policy size, combine statements if they produce\n   * the same result. Merging happens according to the following rules:\n   *\n   * - The Effect of both statements is the same\n   * - Neither of the statements have a 'Sid'\n   * - Combine Principals if the rest of the statement is exactly the same.\n   * - Combine Resources if the rest of the statement is exactly the same.\n   * - Combine Actions if the rest of the statement is exactly the same.\n   * - We will never combine NotPrincipals, NotResources or NotActions, because doing\n   *   so would change the meaning of the policy document.\n   *\n   * @default - false, unless the feature flag `@aws-cdk/aws-iam:minimizePolicies` is set\n   */\n  readonly minimize?: boolean;\n  /**\n   * Automatically assign Statement Ids to all statements\n   *\n   * @default false\n   */\n  readonly assignSids?: boolean;\n}\n\nexport class PolicyDocument\n  extends AwsConstructBase\n  implements IPolicyDocument\n{\n  /**\n   * Creates a new PolicyDocument based on the object provided.\n   * This will accept an object created from the `.toDocumentJson()` call\n   * @param obj the PolicyDocument in object form.\n   */\n  public static fromJson(\n    scope: Construct,\n    id: string,\n    obj: any,\n  ): PolicyDocument {\n    const newPolicyDocument = new PolicyDocument(scope, id);\n    const statement = obj.Statement ?? [];\n    if (statement && !Array.isArray(statement)) {\n      throw new Error(\"Statement must be an array\");\n    }\n    newPolicyDocument.addStatements(\n      ...statement.map((s: any) => PolicyStatement.fromJson(s)),\n    );\n    return newPolicyDocument;\n  }\n\n  public readonly statements = new Array<PolicyStatement>();\n  public readonly resource: dataAwsIamPolicyDocument.DataAwsIamPolicyDocument;\n  // private readonly autoAssignSids: boolean;\n  // private readonly minimize?: boolean;\n\n  public get policyDocumentOutputs(): PolicyDocumentOutputs {\n    return { policy: this.json };\n  }\n  public get outputs(): Record<string, any> {\n    return this.policyDocumentOutputs;\n  }\n\n  public get json(): string {\n    return this.resource.json;\n  }\n  private readonly autoAssignSids: boolean;\n  private readonly minimize?: boolean;\n\n  constructor(scope: Construct, id: string, props: PolicyDocumentProps = {}) {\n    super(scope, id, props);\n    this.autoAssignSids = !!props.assignSids;\n    this.minimize = props.minimize ?? false;\n    this.addStatements(...(props.statement || []));\n    const self = this;\n    // TODO: move in toTerraform() and don't generate anything if isEmpty()?\n    this.resource = new dataAwsIamPolicyDocument.DataAwsIamPolicyDocument(\n      this,\n      \"Resource\",\n      {\n        ...props,\n        statement: Lazy.anyValue({\n          produce: (context: IResolveContext) => {\n            this._maybeMergeStatements();\n            context.registerPostProcessor(\n              new PostProcessPolicyDocument(self.autoAssignSids),\n            );\n            return this.statements.map((s) =>\n              dataAwsIamPolicyDocument.dataAwsIamPolicyDocumentStatementToTerraform(\n                s.toJSON(),\n              ),\n            );\n          },\n        }),\n      },\n    );\n  }\n\n  /**\n   * Perform statement merging (if enabled and not done yet)\n   *\n   * @internal\n   */\n  public _maybeMergeStatements(): void {\n    if (this.minimize && this.statements.length > 1) {\n      const result = mergeStatements(this.statements, { scope: this });\n      this.statements.splice(\n        0,\n        this.statements.length,\n        ...result.mergedStatements,\n      );\n    }\n  }\n\n  // /**\n  //  * JSON-ify the document\n  //  *\n  //  * Used when JSON.stringify() is called\n  //  */\n  // public toJSON(): any {\n  //   return {\n  //     statement: this.statements.map((s) => s.toJSON()),\n  //   };\n  // }\n\n  //TODO: Caution - toTerraform() returns nothing by design!\n  // Adding toTerraform() will cause infinite recursion\n\n  /**\n   * Get AWS IAM Policy document JSON\n   *\n   * NOTE: May contain tokens, use spec.resolve() to resolve them.\n   */\n  public toDocumentJson(): any {\n    if (this.isEmpty) {\n      return undefined;\n    }\n\n    // merge resolved statements\n    this._maybeMergeStatements();\n    const doc = {\n      Statement: this.statements.map((s) => s.toStatementJson()),\n      Version: \"2012-10-17\",\n    };\n\n    return doc;\n  }\n\n  /**\n   * Whether the policy document contains any statements.\n   */\n  public 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 unique \"sid\"s within the policy.\n   */\n  public get statementCount(): number {\n    return this.statements.length;\n  }\n\n  /**\n   * Adds a statement to the policy document.\n   *\n   * @param statement the statement to add.\n   */\n  public addStatements(...statement: PolicyStatement[]) {\n    this.statements.push(...statement);\n  }\n\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for any policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  public validateForAnyPolicy(): string[] {\n    const errors = new Array<string>();\n    for (const statement of this.statements) {\n      errors.push(...statement.validateForAnyPolicy());\n    }\n    return errors;\n  }\n\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for a resource-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  public validateForResourcePolicy(): string[] {\n    const errors = new Array<string>();\n    for (const statement of this.statements) {\n      errors.push(...statement.validateForResourcePolicy());\n    }\n    return errors;\n  }\n\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for an identity-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  public validateForIdentityPolicy(): string[] {\n    const errors = new Array<string>();\n    for (const statement of this.statements) {\n      errors.push(...statement.validateForIdentityPolicy());\n    }\n    return errors;\n  }\n\n  // /**\n  //  * Freeze all statements\n  //  */\n  // private freezeStatements() {\n  //   for (const statement of this.statements) {\n  //     statement.freeze();\n  //   }\n  // }\n}\n"]}

package/lib/aws/iam/policy-statement.js

@@ -685,7 +685,7 @@ class PolicyStatement {
 }
 exports.PolicyStatement = PolicyStatement;
 _a = JSII_RTTI_SYMBOL_1;
-PolicyStatement[_a] = { fqn: "terraconstructs.aws.iam.PolicyStatement", version: "0.0.14" };
+PolicyStatement[_a] = { fqn: "terraconstructs.aws.iam.PolicyStatement", version: "0.0.15" };
 /**
  * The Effect element of an IAM policy
  *

package/lib/aws/iam/policy.d.ts

@@ -1,9 +1,11 @@
 import { Construct } from "constructs";
 import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { IGroup } from "./group";
 import { IPolicyDocument } from "./policy-document";
 import { PolicyStatement } from "./policy-statement";
 import { IGrantable, IPrincipal } from "./principals";
 import { IRole } from "./role";
+import { IUser } from "./user";
 export declare const MAX_POLICY_NAME_LEN = 128;
 /**
  * Represents an IAM Policy
@@ -31,6 +33,13 @@ export interface PolicyProps extends AwsConstructProps {
      * to be unique within the stack.
      */
     readonly policyName?: string;
+    /**
+     * Users to attach this policy to.
+     * You can also use `attachToUser(user)` to attach this policy to a user.
+     *
+     * @default - No users.
+     */
+    readonly users?: IUser[];
     /**
      * Roles to attach this policy to.
      * You can also use `attachToRole(role)` to attach this policy to a role.
@@ -38,6 +47,13 @@ export interface PolicyProps extends AwsConstructProps {
      * @default - No roles.
      */
     readonly roles?: IRole[];
+    /**
+     * Groups to attach this policy to.
+     * You can also use `attachToGroup(group)` to attach this policy to a group.
+     *
+     * @default - No groups.
+     */
+    readonly groups?: IGroup[];
     /**
      * Initial set of permissions to add to this policy document.
      * You can also use `addStatements(...statement)` to add permissions later.
@@ -85,6 +101,8 @@ export declare class Policy extends AwsConstructBase implements IPolicy, IGranta
     get outputs(): Record<string, any>;
     private readonly _policyName;
     private readonly roles;
+    private readonly users;
+    private readonly groups;
     private readonly force;
     private referenceTaken;
     constructor(scope: Construct, id: string, props?: PolicyProps);
@@ -92,6 +110,10 @@ export declare class Policy extends AwsConstructBase implements IPolicy, IGranta
      * Adds a statement to the policy document.
      */
     addStatements(...statement: PolicyStatement[]): void;
+    /**
+     * Attaches this policy to a user.
+     */
+    attachToUser(user: IUser): void;
     /**
      * Attaches this policy to a role.
      *
@@ -102,6 +124,10 @@ export declare class Policy extends AwsConstructBase implements IPolicy, IGranta
      * you will get resource cycling and/or errors.
      */
     attachToRole(role: IRole): void;
+    /**
+     * Attaches this policy to a group.
+     */
+    attachToGroup(group: IGroup): void;
     /**
      * The name of this policy.
      *