terraconstructs 0.0.8

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

@@ -0,0 +1,122 @@
+import { Construct } from "constructs";
+import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { IPolicyDocument } from "./policy-document";
+import { PolicyStatement } from "./policy-statement";
+import { IGrantable, IPrincipal } from "./principals";
+import { IRole } from "./role";
+export declare const MAX_POLICY_NAME_LEN = 128;
+/**
+ * Represents an IAM Policy
+ *
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html
+ */
+export interface IPolicy extends IAwsConstruct {
+    /**
+     * The name of this policy.
+     *
+     * @attribute
+     */
+    readonly policyName: string;
+}
+/**
+ * Properties for defining an IAM inline policy document
+ */
+export interface PolicyProps extends AwsConstructProps {
+    /**
+     * The name of the policy. If you specify multiple policies for an entity,
+     * specify unique names. For example, if you specify a list of policies for
+     * an IAM role, each policy must have a unique name.
+     *
+     * @default - Uses the logical ID of the policy resource, which is ensured
+     * to be unique within the stack.
+     */
+    readonly policyName?: string;
+    /**
+     * Roles to attach this policy to.
+     * You can also use `attachToRole(role)` to attach this policy to a role.
+     *
+     * @default - No roles.
+     */
+    readonly roles?: IRole[];
+    /**
+     * Initial set of permissions to add to this policy document.
+     * You can also use `addStatements(...statement)` to add permissions later.
+     *
+     * @default - No statements.
+     */
+    readonly statements?: PolicyStatement[];
+    /**
+     * In cases where you know the policy must be created and it is actually
+     * an error if no statements have been added to it or it remains unattached to
+     * an IAM identity, you can set this to `true`.
+     *
+     * @default false
+     */
+    readonly force?: boolean;
+    /**
+     * Initial PolicyDocument to use for this Policy. If omited, any
+     * `PolicyStatement` provided in the `statements` property will be applied
+     * against the empty default `PolicyDocument`.
+     *
+     * @default - An empty policy.
+     */
+    readonly document?: IPolicyDocument;
+}
+/**
+ * The Policy resource associates an [inline](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#inline)
+ * IAM policy with IAM users, roles, or groups. For more information about IAM policies, see
+ * [Overview of IAM Policies](http://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html)
+ * in the IAM User Guide guide.
+ *
+ * Also refer to:
+ * - [Iam Role Policy](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_role_policy)
+ * - [Iam Group Policy](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_group_policy)
+ */
+export declare class Policy extends AwsConstructBase implements IPolicy, IGrantable {
+    /**
+     * Import a policy in this app based on its name
+     */
+    static fromPolicyName(scope: Construct, id: string, policyName: string): IPolicy;
+    /**
+     * The policy document.
+     */
+    readonly document: IPolicyDocument;
+    readonly grantPrincipal: IPrincipal;
+    get outputs(): Record<string, any>;
+    private readonly _policyName;
+    private readonly roles;
+    private readonly force;
+    private referenceTaken;
+    constructor(scope: Construct, id: string, props?: PolicyProps);
+    /**
+     * Adds a statement to the policy document.
+     */
+    addStatements(...statement: PolicyStatement[]): void;
+    /**
+     * Attaches this policy to a role.
+     *
+     * NOTE: Using this method will conflict with a role that has
+     * exclusive management of the role's policy attachments.
+     *
+     * If you attempt to manage a role's policies by multiple means,
+     * you will get resource cycling and/or errors.
+     */
+    attachToRole(role: IRole): void;
+    /**
+     * The name of this policy.
+     *
+     * @attribute
+     */
+    get policyName(): string;
+    private validatePolicy;
+    /**
+     * Whether the policy resource has been attached to any identity
+     */
+    private get isAttached();
+    /**
+     * Adds resource to the terraform JSON output.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform(): any;
+}

package/lib/aws/iam/policy.js

@@ -0,0 +1,192 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Policy = exports.MAX_POLICY_NAME_LEN = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const policy_document_1 = require("./policy-document");
+exports.MAX_POLICY_NAME_LEN = 128;
+/**
+ * The Policy resource associates an [inline](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#inline)
+ * IAM policy with IAM users, roles, or groups. For more information about IAM policies, see
+ * [Overview of IAM Policies](http://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html)
+ * in the IAM User Guide guide.
+ *
+ * Also refer to:
+ * - [Iam Role Policy](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_role_policy)
+ * - [Iam Group Policy](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_group_policy)
+ */
+class Policy extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import a policy in this app based on its name
+     */
+    static fromPolicyName(scope, id, policyName) {
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.policyName = policyName;
+            }
+            get outputs() {
+                // TODO: Support undefined outputs?
+                return {};
+            }
+        }
+        return new Import(scope, id);
+    }
+    get outputs() {
+        // TODO: Support undefined outputs?
+        return {};
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.roles = new Array();
+        this.referenceTaken = false; // TODO: do we actually use this?
+        this.document = props.document ?? new policy_document_1.PolicyDocument(this, "Resource");
+        // TODO: This is a logical ID within a resource, no need to use GridUUID
+        this._policyName =
+            props.policyName ||
+                this.stack.uniqueResourceName(this, {
+                    maxLength: exports.MAX_POLICY_NAME_LEN,
+                });
+        this.force = props.force ?? false;
+        if (props.roles) {
+            props.roles.forEach((r) => this.attachToRole(r));
+        }
+        if (props.statements) {
+            props.statements.forEach((s) => this.addStatements(s));
+        }
+        this.grantPrincipal = new PolicyGrantPrincipal(this);
+        this.node.addValidation({ validate: () => this.validatePolicy() });
+    }
+    /**
+     * Adds a statement to the policy document.
+     */
+    addStatements(...statement) {
+        this.document.addStatements(...statement);
+    }
+    /**
+     * Attaches this policy to a role.
+     *
+     * NOTE: Using this method will conflict with a role that has
+     * exclusive management of the role's policy attachments.
+     *
+     * If you attempt to manage a role's policies by multiple means,
+     * you will get resource cycling and/or errors.
+     */
+    attachToRole(role) {
+        if (this.roles.find((r) => r.roleArn === role.roleArn)) {
+            return;
+        }
+        this.roles.push(role);
+        role.attachInlinePolicy(this);
+    }
+    /**
+     * The name of this policy.
+     *
+     * @attribute
+     */
+    get policyName() {
+        this.referenceTaken = true;
+        return this._policyName;
+    }
+    validatePolicy() {
+        const result = new Array();
+        // validate that the policy document is not empty
+        if (this.document.isEmpty) {
+            if (this.force) {
+                result.push("Policy created with force=true is empty. You must add statements to the policy");
+            }
+            if (!this.force && this.referenceTaken) {
+                result.push("This Policy has been referenced by a resource, so it must contain at least one statement.");
+            }
+        }
+        // validate that the policy is attached to at least one principal (role, user or group).
+        if (!this.isAttached) {
+            if (this.force) {
+                result.push("Policy created with force=true must be attached to at least one principal: user, group or role");
+            }
+            if (!this.force && this.referenceTaken) {
+                result.push("This Policy has been referenced by a resource, so it must be attached to at least one user, group or role.");
+            }
+        }
+        result.push(...this.document.validateForIdentityPolicy());
+        return result;
+    }
+    /**
+     * Whether the policy resource has been attached to any identity
+     */
+    get isAttached() {
+        // return this.groups.length + this.users.length + this.roles.length > 0;
+        return this.roles.length > 0;
+    }
+    /**
+     * 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.force && (this.document.isEmpty || !this.isAttached)) {
+            return {};
+        }
+        // add iamRolePolicy resource for each referenced role
+        // 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.roles.length; i++) {
+            const id = `ResourceRoles${i}`;
+            // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag
+            // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48
+            if (this.node.tryFindChild(id))
+                continue; // ignore if already generated
+            const rolePolicy = new provider_aws_1.iamRolePolicy.IamRolePolicy(this, id, {
+                policy: this.document.json,
+                role: this.roles[i].roleName,
+                name: this.policyName,
+            });
+            // copy any overrides to the underlying L0 resources
+            for (const [key, value] of Object.entries(this.rawOverrides)) {
+                rolePolicy.addOverride(key, value);
+                const policyDocument = this.document.node
+                    .defaultChild;
+                policyDocument.addOverride(key, value);
+            }
+        }
+        return {};
+    }
+}
+exports.Policy = Policy;
+_a = JSII_RTTI_SYMBOL_1;
+Policy[_a] = { fqn: "terraconstructs.aws.iam.Policy", version: "0.0.8" };
+class PolicyGrantPrincipal {
+    constructor(_policy) {
+        this._policy = _policy;
+        this.assumeRoleAction = "sts:AssumeRole";
+        this.grantPrincipal = this;
+        this.principalAccount = _policy.env.account;
+    }
+    get policyFragment() {
+        // This property is referenced to add policy statements as a resource-based policy.
+        // We should fail because a policy cannot be used as a principal of a policy document.
+        // cf. https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying
+        throw new Error(`Cannot use a Policy '${this._policy.node.path}' as the 'Principal' or 'NotPrincipal' in an IAM Policy`);
+    }
+    addToPolicy(statement) {
+        return this.addToPrincipalPolicy(statement).statementAdded;
+    }
+    addToPrincipalPolicy(statement) {
+        this._policy.addStatements(statement);
+        // TODO: How to support dependency group?
+        // TODO: Dependable should be IResolvable for the group of policy attachments created (if any)
+        return { statementAdded: true, policyDependable: this._policy };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../../src/aws/iam/policy.ts"],"names":[],"mappings":"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","sourcesContent":["import { iamRolePolicy } from \"@cdktf/provider-aws\";\nimport { TerraformElement } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { IPolicyDocument, PolicyDocument } from \"./policy-document\";\nimport { PolicyStatement } from \"./policy-statement\";\nimport {\n  AddToPrincipalPolicyResult,\n  IGrantable,\n  IPrincipal,\n  PrincipalPolicyFragment,\n} from \"./principals\";\nimport { IRole } from \"./role\";\n\nexport const MAX_POLICY_NAME_LEN = 128;\n\n/**\n * Represents an IAM Policy\n *\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html\n */\nexport interface IPolicy extends IAwsConstruct {\n  /**\n   * The name of this policy.\n   *\n   * @attribute\n   */\n  readonly policyName: string;\n}\n\n/**\n * Properties for defining an IAM inline policy document\n */\nexport interface PolicyProps extends AwsConstructProps {\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\n   * to be unique within the stack.\n   */\n  readonly policyName?: string;\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   * @default - No roles.\n   */\n  readonly roles?: IRole[];\n\n  /**\n   * Initial set of permissions to add to this policy document.\n   * You can also use `addStatements(...statement)` to add permissions later.\n   *\n   * @default - No statements.\n   */\n  readonly statements?: PolicyStatement[];\n\n  /**\n   * In cases where you know the policy must be created and it is actually\n   * an error if no statements have been added to it or it remains unattached to\n   * an IAM identity, you can set this to `true`.\n   *\n   * @default false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Initial PolicyDocument to use for this Policy. If omited, any\n   * `PolicyStatement` provided in the `statements` property will be applied\n   * against the empty default `PolicyDocument`.\n   *\n   * @default - An empty policy.\n   */\n  readonly document?: IPolicyDocument;\n}\n\n/**\n * The Policy resource associates an [inline](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#inline)\n * IAM policy with IAM users, roles, or groups. For more information about IAM policies, see\n * [Overview of IAM Policies](http://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html)\n * in the IAM User Guide guide.\n *\n * Also refer to:\n * - [Iam Role Policy](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_role_policy)\n * - [Iam Group Policy](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_group_policy)\n */\nexport class Policy extends AwsConstructBase implements IPolicy, IGrantable {\n  /**\n   * Import a policy in this app based on its name\n   */\n  public static fromPolicyName(\n    scope: Construct,\n    id: string,\n    policyName: string,\n  ): IPolicy {\n    class Import extends AwsConstructBase implements IPolicy {\n      public readonly policyName = policyName;\n      public get outputs(): Record<string, any> {\n        // TODO: Support undefined outputs?\n        return {};\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The policy document.\n   */\n  public readonly document: IPolicyDocument;\n  public readonly grantPrincipal: IPrincipal;\n\n  public get outputs(): Record<string, any> {\n    // TODO: Support undefined outputs?\n    return {};\n  }\n\n  private readonly _policyName: string;\n  private readonly roles = new Array<IRole>();\n  private readonly force: boolean;\n  private referenceTaken = false; // TODO: do we actually use this?\n\n  constructor(scope: Construct, id: string, props: PolicyProps = {}) {\n    super(scope, id, props);\n    this.document = props.document ?? new PolicyDocument(this, \"Resource\");\n    // TODO: This is a logical ID within a resource, no need to use GridUUID\n    this._policyName =\n      props.policyName ||\n      this.stack.uniqueResourceName(this, {\n        maxLength: MAX_POLICY_NAME_LEN,\n      });\n    this.force = props.force ?? false;\n\n    if (props.roles) {\n      props.roles.forEach((r) => this.attachToRole(r));\n    }\n\n    if (props.statements) {\n      props.statements.forEach((s) => this.addStatements(s));\n    }\n\n    this.grantPrincipal = new PolicyGrantPrincipal(this);\n\n    this.node.addValidation({ validate: () => this.validatePolicy() });\n  }\n\n  /**\n   * Adds a statement to the policy document.\n   */\n  public addStatements(...statement: PolicyStatement[]) {\n    this.document.addStatements(...statement);\n  }\n\n  /**\n   * Attaches this policy to a role.\n   *\n   * NOTE: Using this method will conflict with a role that has\n   * exclusive management of the role's policy attachments.\n   *\n   * If you attempt to manage a role's policies by multiple means,\n   * you will get resource cycling and/or errors.\n   */\n  public attachToRole(role: IRole) {\n    if (this.roles.find((r) => r.roleArn === role.roleArn)) {\n      return;\n    }\n    this.roles.push(role);\n    role.attachInlinePolicy(this);\n  }\n\n  /**\n   * The name of this policy.\n   *\n   * @attribute\n   */\n  public get policyName(): string {\n    this.referenceTaken = true;\n    return this._policyName;\n  }\n\n  private validatePolicy(): string[] {\n    const result = new Array<string>();\n\n    // validate that the policy document is not empty\n    if (this.document.isEmpty) {\n      if (this.force) {\n        result.push(\n          \"Policy created with force=true is empty. You must add statements to the policy\",\n        );\n      }\n      if (!this.force && this.referenceTaken) {\n        result.push(\n          \"This Policy has been referenced by a resource, so it must contain at least one statement.\",\n        );\n      }\n    }\n\n    // validate that the policy is attached to at least one principal (role, user or group).\n    if (!this.isAttached) {\n      if (this.force) {\n        result.push(\n          \"Policy created with force=true must be attached to at least one principal: user, group or role\",\n        );\n      }\n      if (!this.force && this.referenceTaken) {\n        result.push(\n          \"This Policy has been referenced by a resource, so it must be attached to at least one user, group or role.\",\n        );\n      }\n    }\n\n    result.push(...this.document.validateForIdentityPolicy());\n\n    return result;\n  }\n\n  /**\n   * Whether the policy resource has been attached to any identity\n   */\n  private get isAttached() {\n    // return this.groups.length + this.users.length + this.roles.length > 0;\n    return this.roles.length > 0;\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.force && (this.document.isEmpty || !this.isAttached)) {\n      return {};\n    }\n\n    // add iamRolePolicy resource for each referenced role\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.roles.length; i++) {\n      const id = `ResourceRoles${i}`;\n      // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag\n      // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48\n      if (this.node.tryFindChild(id)) continue; // ignore if already generated\n\n      const rolePolicy = new iamRolePolicy.IamRolePolicy(this, id, {\n        policy: this.document.json,\n        role: this.roles[i].roleName,\n        name: this.policyName,\n      });\n      // copy any overrides to the underlying L0 resources\n      for (const [key, value] of Object.entries(this.rawOverrides)) {\n        rolePolicy.addOverride(key, value);\n        const policyDocument = this.document.node\n          .defaultChild as TerraformElement;\n        policyDocument.addOverride(key, value);\n      }\n    }\n    return {};\n  }\n}\n\nclass PolicyGrantPrincipal implements IPrincipal {\n  public readonly assumeRoleAction = \"sts:AssumeRole\";\n  public readonly grantPrincipal: IPrincipal;\n  public readonly principalAccount?: string;\n\n  constructor(private _policy: Policy) {\n    this.grantPrincipal = this;\n    this.principalAccount = _policy.env.account;\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    // This property is referenced to add policy statements as a resource-based policy.\n    // We should fail because a policy cannot be used as a principal of a policy document.\n    // cf. https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying\n    throw new Error(\n      `Cannot use a Policy '${this._policy.node.path}' as the 'Principal' or 'NotPrincipal' in an IAM Policy`,\n    );\n  }\n\n  public addToPolicy(statement: PolicyStatement): boolean {\n    return this.addToPrincipalPolicy(statement).statementAdded;\n  }\n\n  public addToPrincipalPolicy(\n    statement: PolicyStatement,\n  ): AddToPrincipalPolicyResult {\n    this._policy.addStatements(statement);\n    // TODO: How to support dependency group?\n    // TODO: Dependable should be IResolvable for the group of policy attachments created (if any)\n    return { statementAdded: true, policyDependable: this._policy };\n  }\n}\n"]}