terraconstructs 0.0.8

package/lib/aws/iam/private/adapter.d.ts

@@ -0,0 +1,21 @@
+import { AwsConstructBase } from "../../aws-construct";
+import { IPolicyDocument, PolicyDocumentOutputs } from "../policy-document";
+import { PolicyStatement } from "../policy-statement";
+/**
+ * A PolicyDocument adapter that can modify statements flowing through it
+ */
+export declare class MutatingPolicyDocumentAdapter extends AwsConstructBase implements IPolicyDocument {
+    private readonly wrapped;
+    private readonly mutator;
+    constructor(wrapped: IPolicyDocument, mutator: (s: PolicyStatement) => PolicyStatement);
+    get policyDocumentOutputs(): PolicyDocumentOutputs;
+    get isEmpty(): boolean;
+    get outputs(): Record<string, any>;
+    get statementCount(): number;
+    get json(): string;
+    addStatements(...statements: PolicyStatement[]): void;
+    validateForAnyPolicy(): string[];
+    validateForIdentityPolicy(): string[];
+    validateForResourcePolicy(): string[];
+    toDocumentJson(): any;
+}

package/lib/aws/iam/private/adapter.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutatingPolicyDocumentAdapter = void 0;
+const aws_construct_1 = require("../../aws-construct");
+/**
+ * A PolicyDocument adapter that can modify statements flowing through it
+ */
+class MutatingPolicyDocumentAdapter extends aws_construct_1.AwsConstructBase {
+    constructor(wrapped, mutator) {
+        if (wrapped.node.scope === undefined) {
+            throw new Error("The wrapped PolicyDocument must have a scope");
+        }
+        super(wrapped.node.scope, `Mutating${wrapped.node.id}`, {});
+        this.wrapped = wrapped;
+        this.mutator = mutator;
+    }
+    get policyDocumentOutputs() {
+        return this.wrapped.policyDocumentOutputs;
+    }
+    get isEmpty() {
+        return this.wrapped.isEmpty;
+    }
+    get outputs() {
+        return this.wrapped.outputs;
+    }
+    get statementCount() {
+        return this.wrapped.statementCount;
+    }
+    get json() {
+        return this.wrapped.json;
+    }
+    addStatements(...statements) {
+        for (const st of statements) {
+            this.wrapped.addStatements(this.mutator(st));
+        }
+    }
+    validateForAnyPolicy() {
+        return this.wrapped.validateForAnyPolicy();
+    }
+    validateForIdentityPolicy() {
+        return this.wrapped.validateForIdentityPolicy();
+    }
+    validateForResourcePolicy() {
+        return this.wrapped.validateForResourcePolicy();
+    }
+    toDocumentJson() {
+        return this.wrapped.toDocumentJson();
+    }
+}
+exports.MutatingPolicyDocumentAdapter = MutatingPolicyDocumentAdapter;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/iam/private/assume-role-policy.d.ts

@@ -0,0 +1,8 @@
+import { IPolicyDocument } from "../policy-document";
+import { IPrincipal } from "../principals";
+/**
+ * Add a principal to an AssumeRolePolicyDocument in the right way
+ *
+ * Delegate to the principal if it can do the job itself, do a default job if it can't.
+ */
+export declare function defaultAddPrincipalToAssumeRole(principal: IPrincipal, doc: IPolicyDocument): void;

package/lib/aws/iam/private/assume-role-policy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAddPrincipalToAssumeRole = void 0;
+const policy_statement_1 = require("../policy-statement");
+/**
+ * Add a principal to an AssumeRolePolicyDocument in the right way
+ *
+ * Delegate to the principal if it can do the job itself, do a default job if it can't.
+ */
+function defaultAddPrincipalToAssumeRole(principal, doc) {
+    if (isAssumeRolePrincipal(principal)) {
+        // Principal knows how to add itself
+        principal.addToAssumeRolePolicy(doc);
+    }
+    else {
+        // Principal can't add itself, we do it for them
+        doc.addStatements(new policy_statement_1.PolicyStatement({
+            actions: [principal.assumeRoleAction],
+            principals: [principal],
+        }));
+    }
+}
+exports.defaultAddPrincipalToAssumeRole = defaultAddPrincipalToAssumeRole;
+function isAssumeRolePrincipal(principal) {
+    return !!principal.addToAssumeRolePolicy;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/iam/private/comparable-principal.d.ts

@@ -0,0 +1,6 @@
+import { IPrincipal } from "../principals";
+export declare function partitionPrincipals(xs: IPrincipal[]): PartitionResult;
+export interface PartitionResult {
+    readonly nonComparable: IPrincipal[];
+    readonly comparable: Record<string, IPrincipal>;
+}

package/lib/aws/iam/private/comparable-principal.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partitionPrincipals = void 0;
+const principals_1 = require("../principals");
+function partitionPrincipals(xs) {
+    const nonComparable = [];
+    const comparable = {};
+    for (const x of xs) {
+        const dedupe = principals_1.ComparablePrincipal.dedupeStringFor(x);
+        if (dedupe) {
+            comparable[dedupe] = x;
+        }
+        else {
+            nonComparable.push(x);
+        }
+    }
+    return { comparable, nonComparable };
+}
+exports.partitionPrincipals = partitionPrincipals;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGFyYWJsZS1wcmluY2lwYWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL2lhbS9wcml2YXRlL2NvbXBhcmFibGUtcHJpbmNpcGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDhDQUFnRTtBQUVoRSxTQUFnQixtQkFBbUIsQ0FBQyxFQUFnQjtJQUNsRCxNQUFNLGFBQWEsR0FBaUIsRUFBRSxDQUFDO0lBQ3ZDLE1BQU0sVUFBVSxHQUErQixFQUFFLENBQUM7SUFFbEQsS0FBSyxNQUFNLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQztRQUNuQixNQUFNLE1BQU0sR0FBRyxnQ0FBbUIsQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDdEQsSUFBSSxNQUFNLEVBQUUsQ0FBQztZQUNYLFVBQVUsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDekIsQ0FBQzthQUFNLENBQUM7WUFDTixhQUFhLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3hCLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxhQUFhLEVBQUUsQ0FBQztBQUN2QyxDQUFDO0FBZEQsa0RBY0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUHJpbmNpcGFsLCBDb21wYXJhYmxlUHJpbmNpcGFsIH0gZnJvbSBcIi4uL3ByaW5jaXBhbHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHBhcnRpdGlvblByaW5jaXBhbHMoeHM6IElQcmluY2lwYWxbXSk6IFBhcnRpdGlvblJlc3VsdCB7XG4gIGNvbnN0IG5vbkNvbXBhcmFibGU6IElQcmluY2lwYWxbXSA9IFtdO1xuICBjb25zdCBjb21wYXJhYmxlOiBSZWNvcmQ8c3RyaW5nLCBJUHJpbmNpcGFsPiA9IHt9O1xuXG4gIGZvciAoY29uc3QgeCBvZiB4cykge1xuICAgIGNvbnN0IGRlZHVwZSA9IENvbXBhcmFibGVQcmluY2lwYWwuZGVkdXBlU3RyaW5nRm9yKHgpO1xuICAgIGlmIChkZWR1cGUpIHtcbiAgICAgIGNvbXBhcmFibGVbZGVkdXBlXSA9IHg7XG4gICAgfSBlbHNlIHtcbiAgICAgIG5vbkNvbXBhcmFibGUucHVzaCh4KTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4geyBjb21wYXJhYmxlLCBub25Db21wYXJhYmxlIH07XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGFydGl0aW9uUmVzdWx0IHtcbiAgcmVhZG9ubHkgbm9uQ29tcGFyYWJsZTogSVByaW5jaXBhbFtdO1xuICByZWFkb25seSBjb21wYXJhYmxlOiBSZWNvcmQ8c3RyaW5nLCBJUHJpbmNpcGFsPjtcbn1cbiJdfQ==

package/lib/aws/iam/private/immutable-role.d.ts

@@ -0,0 +1,43 @@
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsStack } from "../..";
+import { Grant } from "../grant";
+import { IManagedPolicy } from "../managed-policy";
+import { Policy } from "../policy";
+import { PolicyStatement } from "../policy-statement";
+import { AddToPrincipalPolicyResult, IPrincipal, PrincipalPolicyFragment } from "../principals";
+import { IRole, RoleOutputs } from "../role";
+/**
+ * An immutable wrapper around an IRole
+ *
+ * This wrapper ignores all mutating operations, like attaching policies or
+ * adding policy statements.
+ *
+ * Useful in cases where you want to turn off CDK's automatic permissions
+ * management, and instead have full control over all permissions.
+ *
+ * Note: if you want to ignore all mutations for an externally defined role
+ * which was imported into the CDK with `Role.fromRoleArn`, you don't have to use this class -
+ * simply pass the property mutable = false when calling `Role.fromRoleArn`.
+ */
+export declare class ImmutableRole extends AwsConstructBase implements IRole {
+    private readonly addGrantsToResources;
+    readonly assumeRoleAction: string;
+    readonly policyFragment: PrincipalPolicyFragment;
+    readonly grantPrincipal: this;
+    readonly principalAccount: string | undefined;
+    readonly roleArn: string;
+    readonly roleName: string;
+    readonly stack: AwsStack;
+    private readonly _roleOutputs;
+    get roleOutputs(): RoleOutputs;
+    get outputs(): RoleOutputs;
+    private readonly role;
+    constructor(scope: Construct, id: string, role: IRole, addGrantsToResources: boolean);
+    attachInlinePolicy(_policy: Policy): void;
+    addManagedPolicy(_policy: IManagedPolicy): void;
+    addToPolicy(statement: PolicyStatement): boolean;
+    addToPrincipalPolicy(_statement: PolicyStatement): AddToPrincipalPolicyResult;
+    grant(grantee: IPrincipal, ...actions: string[]): Grant;
+    grantPassRole(grantee: IPrincipal): Grant;
+    grantAssumeRole(identity: IPrincipal): Grant;
+}

package/lib/aws/iam/private/immutable-role.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImmutableRole = void 0;
+const constructs_1 = require("constructs");
+const __1 = require("../..");
+/**
+ * An immutable wrapper around an IRole
+ *
+ * This wrapper ignores all mutating operations, like attaching policies or
+ * adding policy statements.
+ *
+ * Useful in cases where you want to turn off CDK's automatic permissions
+ * management, and instead have full control over all permissions.
+ *
+ * Note: if you want to ignore all mutations for an externally defined role
+ * which was imported into the CDK with `Role.fromRoleArn`, you don't have to use this class -
+ * simply pass the property mutable = false when calling `Role.fromRoleArn`.
+ */
+class ImmutableRole extends __1.AwsConstructBase {
+    get roleOutputs() {
+        return this._roleOutputs;
+    }
+    get outputs() {
+        return this.roleOutputs;
+    }
+    constructor(scope, id, role, addGrantsToResources) {
+        super(scope, id, {
+            account: role.env.account,
+            region: role.env.region,
+        });
+        this.addGrantsToResources = addGrantsToResources;
+        this.grantPrincipal = this;
+        this.role = role;
+        this.assumeRoleAction = role.assumeRoleAction;
+        this.policyFragment = this.role.policyFragment;
+        this.principalAccount = this.role.principalAccount;
+        this.roleArn = this.role.roleArn;
+        this.roleName = this.role.roleName;
+        this.stack = this.role.stack;
+        // implement IDependable privately
+        constructs_1.Dependable.implement(this, {
+            dependencyRoots: [role],
+        });
+        this.node.defaultChild = role.node.defaultChild;
+        this._roleOutputs = this.role.roleOutputs;
+    }
+    attachInlinePolicy(_policy) {
+        // do nothing
+    }
+    addManagedPolicy(_policy) {
+        // do nothing
+    }
+    addToPolicy(statement) {
+        return this.addToPrincipalPolicy(statement).statementAdded;
+    }
+    addToPrincipalPolicy(_statement) {
+        // If we return `false`, the grants will try to add the statement to the resource
+        // (if possible).
+        const pretendSuccess = !this.addGrantsToResources;
+        return {
+            statementAdded: pretendSuccess,
+            policyDependable: this.role,
+        };
+    }
+    grant(grantee, ...actions) {
+        return this.role.grant(grantee, ...actions);
+    }
+    grantPassRole(grantee) {
+        return this.role.grantPassRole(grantee);
+    }
+    grantAssumeRole(identity) {
+        return this.role.grantAssumeRole(identity);
+    }
+}
+exports.ImmutableRole = ImmutableRole;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1tdXRhYmxlLXJvbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL2lhbS9wcml2YXRlL2ltbXV0YWJsZS1yb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJDQUFtRDtBQUNuRCw2QkFBbUQ7QUFZbkQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsTUFBYSxhQUFjLFNBQVEsb0JBQWdCO0lBVWpELElBQVcsV0FBVztRQUNwQixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7SUFDM0IsQ0FBQztJQUNELElBQVcsT0FBTztRQUNoQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUlELFlBQ0UsS0FBZ0IsRUFDaEIsRUFBVSxFQUNWLElBQVcsRUFDTSxvQkFBNkI7UUFFOUMsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFFLEVBQUU7WUFDZixPQUFPLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxPQUFPO1lBQ3pCLE1BQU0sRUFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU07U0FDeEIsQ0FBQyxDQUFDO1FBTGMseUJBQW9CLEdBQXBCLG9CQUFvQixDQUFTO1FBcEJoQyxtQkFBYyxHQUFHLElBQUksQ0FBQztRQTBCcEMsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLGdCQUFnQixHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQztRQUM5QyxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDO1FBQy9DLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDO1FBQ25ELElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDakMsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUNuQyxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQzdCLGtDQUFrQztRQUNsQyx1QkFBVSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUU7WUFDekIsZUFBZSxFQUFFLENBQUMsSUFBSSxDQUFDO1NBQ3hCLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDO1FBQ2hELElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDNUMsQ0FBQztJQUVNLGtCQUFrQixDQUFDLE9BQWU7UUFDdkMsYUFBYTtJQUNmLENBQUM7SUFFTSxnQkFBZ0IsQ0FBQyxPQUF1QjtRQUM3QyxhQUFhO0lBQ2YsQ0FBQztJQUVNLFdBQVcsQ0FBQyxTQUEwQjtRQUMzQyxPQUFPLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxTQUFTLENBQUMsQ0FBQyxjQUFjLENBQUM7SUFDN0QsQ0FBQztJQUVNLG9CQUFvQixDQUN6QixVQUEyQjtRQUUzQixpRkFBaUY7UUFDakYsaUJBQWlCO1FBQ2pCLE1BQU0sY0FBYyxHQUFHLENBQUMsSUFBSSxDQUFDLG9CQUFvQixDQUFDO1FBQ2xELE9BQU87WUFDTCxjQUFjLEVBQUUsY0FBYztZQUM5QixnQkFBZ0IsRUFBRSxJQUFJLENBQUMsSUFBSTtTQUM1QixDQUFDO0lBQ0osQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFtQixFQUFFLEdBQUcsT0FBaUI7UUFDcEQsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsR0FBRyxPQUFPLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBRU0sYUFBYSxDQUFDLE9BQW1CO1FBQ3RDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUVNLGVBQWUsQ0FBQyxRQUFvQjtRQUN6QyxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzdDLENBQUM7Q0FDRjtBQS9FRCxzQ0ErRUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25zdHJ1Y3QsIERlcGVuZGFibGUgfSBmcm9tIFwiY29uc3RydWN0c1wiO1xuaW1wb3J0IHsgQXdzQ29uc3RydWN0QmFzZSwgQXdzU3RhY2sgfSBmcm9tIFwiLi4vLi5cIjtcbmltcG9ydCB7IEdyYW50IH0gZnJvbSBcIi4uL2dyYW50XCI7XG5pbXBvcnQgeyBJTWFuYWdlZFBvbGljeSB9IGZyb20gXCIuLi9tYW5hZ2VkLXBvbGljeVwiO1xuaW1wb3J0IHsgUG9saWN5IH0gZnJvbSBcIi4uL3BvbGljeVwiO1xuaW1wb3J0IHsgUG9saWN5U3RhdGVtZW50IH0gZnJvbSBcIi4uL3BvbGljeS1zdGF0ZW1lbnRcIjtcbmltcG9ydCB7XG4gIEFkZFRvUHJpbmNpcGFsUG9saWN5UmVzdWx0LFxuICBJUHJpbmNpcGFsLFxuICBQcmluY2lwYWxQb2xpY3lGcmFnbWVudCxcbn0gZnJvbSBcIi4uL3ByaW5jaXBhbHNcIjtcbmltcG9ydCB7IElSb2xlLCBSb2xlT3V0cHV0cyB9IGZyb20gXCIuLi9yb2xlXCI7XG5cbi8qKlxuICogQW4gaW1tdXRhYmxlIHdyYXBwZXIgYXJvdW5kIGFuIElSb2xlXG4gKlxuICogVGhpcyB3cmFwcGVyIGlnbm9yZXMgYWxsIG11dGF0aW5nIG9wZXJhdGlvbnMsIGxpa2UgYXR0YWNoaW5nIHBvbGljaWVzIG9yXG4gKiBhZGRpbmcgcG9saWN5IHN0YXRlbWVudHMuXG4gKlxuICogVXNlZnVsIGluIGNhc2VzIHdoZXJlIHlvdSB3YW50IHRvIHR1cm4gb2ZmIENESydzIGF1dG9tYXRpYyBwZXJtaXNzaW9uc1xuICogbWFuYWdlbWVudCwgYW5kIGluc3RlYWQgaGF2ZSBmdWxsIGNvbnRyb2wgb3ZlciBhbGwgcGVybWlzc2lvbnMuXG4gKlxuICogTm90ZTogaWYgeW91IHdhbnQgdG8gaWdub3JlIGFsbCBtdXRhdGlvbnMgZm9yIGFuIGV4dGVybmFsbHkgZGVmaW5lZCByb2xlXG4gKiB3aGljaCB3YXMgaW1wb3J0ZWQgaW50byB0aGUgQ0RLIHdpdGggYFJvbGUuZnJvbVJvbGVBcm5gLCB5b3UgZG9uJ3QgaGF2ZSB0byB1c2UgdGhpcyBjbGFzcyAtXG4gKiBzaW1wbHkgcGFzcyB0aGUgcHJvcGVydHkgbXV0YWJsZSA9IGZhbHNlIHdoZW4gY2FsbGluZyBgUm9sZS5mcm9tUm9sZUFybmAuXG4gKi9cbmV4cG9ydCBjbGFzcyBJbW11dGFibGVSb2xlIGV4dGVuZHMgQXdzQ29uc3RydWN0QmFzZSBpbXBsZW1lbnRzIElSb2xlIHtcbiAgcHVibGljIHJlYWRvbmx5IGFzc3VtZVJvbGVBY3Rpb246IHN0cmluZztcbiAgcHVibGljIHJlYWRvbmx5IHBvbGljeUZyYWdtZW50OiBQcmluY2lwYWxQb2xpY3lGcmFnbWVudDtcbiAgcHVibGljIHJlYWRvbmx5IGdyYW50UHJpbmNpcGFsID0gdGhpcztcbiAgcHVibGljIHJlYWRvbmx5IHByaW5jaXBhbEFjY291bnQ6IHN0cmluZyB8IHVuZGVmaW5lZDtcbiAgcHVibGljIHJlYWRvbmx5IHJvbGVBcm46IHN0cmluZztcbiAgcHVibGljIHJlYWRvbmx5IHJvbGVOYW1lOiBzdHJpbmc7XG4gIHB1YmxpYyByZWFkb25seSBzdGFjazogQXdzU3RhY2s7XG5cbiAgcHJpdmF0ZSByZWFkb25seSBfcm9sZU91dHB1dHM6IFJvbGVPdXRwdXRzO1xuICBwdWJsaWMgZ2V0IHJvbGVPdXRwdXRzKCk6IFJvbGVPdXRwdXRzIHtcbiAgICByZXR1cm4gdGhpcy5fcm9sZU91dHB1dHM7XG4gIH1cbiAgcHVibGljIGdldCBvdXRwdXRzKCkge1xuICAgIHJldHVybiB0aGlzLnJvbGVPdXRwdXRzO1xuICB9XG5cbiAgcHJpdmF0ZSByZWFkb25seSByb2xlOiBJUm9sZTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBzY29wZTogQ29uc3RydWN0LFxuICAgIGlkOiBzdHJpbmcsXG4gICAgcm9sZTogSVJvbGUsXG4gICAgcHJpdmF0ZSByZWFkb25seSBhZGRHcmFudHNUb1Jlc291cmNlczogYm9vbGVhbixcbiAgKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkLCB7XG4gICAgICBhY2NvdW50OiByb2xlLmVudi5hY2NvdW50LFxuICAgICAgcmVnaW9uOiByb2xlLmVudi5yZWdpb24sXG4gICAgfSk7XG4gICAgdGhpcy5yb2xlID0gcm9sZTtcbiAgICB0aGlzLmFzc3VtZVJvbGVBY3Rpb24gPSByb2xlLmFzc3VtZVJvbGVBY3Rpb247XG4gICAgdGhpcy5wb2xpY3lGcmFnbWVudCA9IHRoaXMucm9sZS5wb2xpY3lGcmFnbWVudDtcbiAgICB0aGlzLnByaW5jaXBhbEFjY291bnQgPSB0aGlzLnJvbGUucHJpbmNpcGFsQWNjb3VudDtcbiAgICB0aGlzLnJvbGVBcm4gPSB0aGlzLnJvbGUucm9sZUFybjtcbiAgICB0aGlzLnJvbGVOYW1lID0gdGhpcy5yb2xlLnJvbGVOYW1lO1xuICAgIHRoaXMuc3RhY2sgPSB0aGlzLnJvbGUuc3RhY2s7XG4gICAgLy8gaW1wbGVtZW50IElEZXBlbmRhYmxlIHByaXZhdGVseVxuICAgIERlcGVuZGFibGUuaW1wbGVtZW50KHRoaXMsIHtcbiAgICAgIGRlcGVuZGVuY3lSb290czogW3JvbGVdLFxuICAgIH0pO1xuICAgIHRoaXMubm9kZS5kZWZhdWx0Q2hpbGQgPSByb2xlLm5vZGUuZGVmYXVsdENoaWxkO1xuICAgIHRoaXMuX3JvbGVPdXRwdXRzID0gdGhpcy5yb2xlLnJvbGVPdXRwdXRzO1xuICB9XG5cbiAgcHVibGljIGF0dGFjaElubGluZVBvbGljeShfcG9saWN5OiBQb2xpY3kpOiB2b2lkIHtcbiAgICAvLyBkbyBub3RoaW5nXG4gIH1cblxuICBwdWJsaWMgYWRkTWFuYWdlZFBvbGljeShfcG9saWN5OiBJTWFuYWdlZFBvbGljeSk6IHZvaWQge1xuICAgIC8vIGRvIG5vdGhpbmdcbiAgfVxuXG4gIHB1YmxpYyBhZGRUb1BvbGljeShzdGF0ZW1lbnQ6IFBvbGljeVN0YXRlbWVudCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmFkZFRvUHJpbmNpcGFsUG9saWN5KHN0YXRlbWVudCkuc3RhdGVtZW50QWRkZWQ7XG4gIH1cblxuICBwdWJsaWMgYWRkVG9QcmluY2lwYWxQb2xpY3koXG4gICAgX3N0YXRlbWVudDogUG9saWN5U3RhdGVtZW50LFxuICApOiBBZGRUb1ByaW5jaXBhbFBvbGljeVJlc3VsdCB7XG4gICAgLy8gSWYgd2UgcmV0dXJuIGBmYWxzZWAsIHRoZSBncmFudHMgd2lsbCB0cnkgdG8gYWRkIHRoZSBzdGF0ZW1lbnQgdG8gdGhlIHJlc291cmNlXG4gICAgLy8gKGlmIHBvc3NpYmxlKS5cbiAgICBjb25zdCBwcmV0ZW5kU3VjY2VzcyA9ICF0aGlzLmFkZEdyYW50c1RvUmVzb3VyY2VzO1xuICAgIHJldHVybiB7XG4gICAgICBzdGF0ZW1lbnRBZGRlZDogcHJldGVuZFN1Y2Nlc3MsXG4gICAgICBwb2xpY3lEZXBlbmRhYmxlOiB0aGlzLnJvbGUsXG4gICAgfTtcbiAgfVxuXG4gIHB1YmxpYyBncmFudChncmFudGVlOiBJUHJpbmNpcGFsLCAuLi5hY3Rpb25zOiBzdHJpbmdbXSk6IEdyYW50IHtcbiAgICByZXR1cm4gdGhpcy5yb2xlLmdyYW50KGdyYW50ZWUsIC4uLmFjdGlvbnMpO1xuICB9XG5cbiAgcHVibGljIGdyYW50UGFzc1JvbGUoZ3JhbnRlZTogSVByaW5jaXBhbCk6IEdyYW50IHtcbiAgICByZXR1cm4gdGhpcy5yb2xlLmdyYW50UGFzc1JvbGUoZ3JhbnRlZSk7XG4gIH1cblxuICBwdWJsaWMgZ3JhbnRBc3N1bWVSb2xlKGlkZW50aXR5OiBJUHJpbmNpcGFsKTogR3JhbnQge1xuICAgIHJldHVybiB0aGlzLnJvbGUuZ3JhbnRBc3N1bWVSb2xlKGlkZW50aXR5KTtcbiAgfVxufVxuIl19

package/lib/aws/iam/private/imported-role.d.ts

@@ -0,0 +1,49 @@
+import { Construct } from "constructs";
+import { AwsConstructBase } from "../..";
+import { Grant } from "../grant";
+import { IManagedPolicy } from "../managed-policy";
+import { Policy, IPolicy } from "../policy";
+import { PolicyStatement } from "../policy-statement";
+import { IComparablePrincipal, IPrincipal, AddToPrincipalPolicyResult, PrincipalPolicyFragment } from "../principals";
+import { IRole, FromRoleArnOptions, RoleOutputs } from "../role";
+export interface ImportedRoleProps extends FromRoleArnOptions {
+    readonly roleArn: string;
+    readonly roleName: string;
+    readonly account?: string;
+}
+export declare class ImportedRole extends AwsConstructBase implements IRole, IComparablePrincipal {
+    readonly grantPrincipal: IPrincipal;
+    readonly principalAccount?: string;
+    readonly assumeRoleAction: string;
+    readonly policyFragment: PrincipalPolicyFragment;
+    readonly roleArn: string;
+    readonly roleName: string;
+    private readonly attachedPolicies;
+    private readonly defaultPolicyName?;
+    private defaultPolicy?;
+    private _roleOutputs;
+    get roleOutputs(): RoleOutputs;
+    get outputs(): RoleOutputs;
+    constructor(scope: Construct, id: string, props: ImportedRoleProps);
+    addToPolicy(statement: PolicyStatement): boolean;
+    addToPrincipalPolicy(statement: PolicyStatement): AddToPrincipalPolicyResult;
+    attachInlinePolicy(policy: Policy): void;
+    addManagedPolicy(policy: IManagedPolicy): void;
+    grantPassRole(identity: IPrincipal): Grant;
+    grantAssumeRole(identity: IPrincipal): Grant;
+    grant(grantee: IPrincipal, ...actions: string[]): Grant;
+    dedupeString(): string | undefined;
+}
+/**
+ * Helper class that maintains the set of attached policies for a principal.
+ */
+export declare class AttachedPolicies {
+    private policies;
+    /**
+     * Adds a policy to the list of attached policies.
+     *
+     * If this policy is already, attached, returns false.
+     * If there is another policy attached with the same name, throws an exception.
+     */
+    attach(policy: IPolicy): void;
+}

package/lib/aws/iam/private/imported-role.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachedPolicies = exports.ImportedRole = void 0;
+const cdktf_1 = require("cdktf");
+const __1 = require("../..");
+const token_1 = require("../../../token");
+const grant_1 = require("../grant");
+const policy_1 = require("../policy");
+const principals_1 = require("../principals");
+class ImportedRole extends __1.AwsConstructBase {
+    get roleOutputs() {
+        return this._roleOutputs;
+    }
+    get outputs() {
+        return this.roleOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, {
+            account: props.account,
+        });
+        this.grantPrincipal = this;
+        this.assumeRoleAction = "sts:AssumeRole";
+        this.attachedPolicies = new AttachedPolicies();
+        this.roleArn = props.roleArn;
+        this.roleName = props.roleName;
+        this.policyFragment = new principals_1.ArnPrincipal(this.roleArn).policyFragment;
+        this.defaultPolicyName = props.defaultPolicyName;
+        this.principalAccount = props.account;
+        this._roleOutputs = {
+            name: this.roleName,
+            arn: this.roleArn,
+        };
+    }
+    addToPolicy(statement) {
+        return this.addToPrincipalPolicy(statement).statementAdded;
+    }
+    addToPrincipalPolicy(statement) {
+        if (!this.defaultPolicy) {
+            this.defaultPolicy = new policy_1.Policy(this, this.defaultPolicyName ?? "Policy", {
+                policyName: undefined, // let the policy name be auto-generated
+            });
+            this.attachInlinePolicy(this.defaultPolicy);
+        }
+        this.defaultPolicy.addStatements(statement);
+        return { statementAdded: true, policyDependable: this.defaultPolicy };
+    }
+    attachInlinePolicy(policy) {
+        const thisAndPolicyAccountComparison = (0, token_1.tokenCompareStrings)(this.env.account, policy.env.account);
+        const equalOrAnyUnresolved = thisAndPolicyAccountComparison === token_1.TokenComparison.SAME ||
+            thisAndPolicyAccountComparison === token_1.TokenComparison.BOTH_UNRESOLVED ||
+            thisAndPolicyAccountComparison === token_1.TokenComparison.ONE_UNRESOLVED;
+        if (equalOrAnyUnresolved) {
+            this.attachedPolicies.attach(policy);
+            policy.attachToRole(this);
+        }
+    }
+    addManagedPolicy(policy) {
+        cdktf_1.Annotations.of(this).addWarning(`Not adding managed policy: ${policy.managedPolicyArn} to imported role: ${this.roleName}`);
+    }
+    grantPassRole(identity) {
+        return this.grant(identity, "iam:PassRole");
+    }
+    grantAssumeRole(identity) {
+        return this.grant(identity, "sts:AssumeRole");
+    }
+    grant(grantee, ...actions) {
+        return grant_1.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.roleArn],
+            scope: this,
+        });
+    }
+    dedupeString() {
+        return `ImportedRole:${this.roleArn}`;
+    }
+}
+exports.ImportedRole = ImportedRole;
+/**
+ * Helper class that maintains the set of attached policies for a principal.
+ */
+class AttachedPolicies {
+    constructor() {
+        this.policies = new Array();
+    }
+    /**
+     * Adds a policy to the list of attached policies.
+     *
+     * If this policy is already, attached, returns false.
+     * If there is another policy attached with the same name, throws an exception.
+     */
+    attach(policy) {
+        if (this.policies.find((p) => p === policy)) {
+            return; // already attached
+        }
+        if (this.policies.find((p) => p.policyName === policy.policyName)) {
+            throw new Error(`A policy named "${policy.policyName}" is already attached`);
+        }
+        this.policies.push(policy);
+    }
+}
+exports.AttachedPolicies = AttachedPolicies;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"imported-role.js","sourceRoot":"","sources":["../../../../src/aws/iam/private/imported-role.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AwsConstructBase } from \"../..\";\nimport { TokenComparison, tokenCompareStrings } from \"../../../token\";\nimport { Grant } from \"../grant\";\nimport { IManagedPolicy } from \"../managed-policy\";\nimport { Policy, IPolicy } from \"../policy\";\nimport { PolicyStatement } from \"../policy-statement\";\nimport {\n  IComparablePrincipal,\n  IPrincipal,\n  ArnPrincipal,\n  AddToPrincipalPolicyResult,\n  PrincipalPolicyFragment,\n} from \"../principals\";\nimport { IRole, FromRoleArnOptions, RoleOutputs } from \"../role\";\n\nexport interface ImportedRoleProps extends FromRoleArnOptions {\n  readonly roleArn: string;\n  readonly roleName: string;\n  readonly account?: string;\n}\n\nexport class ImportedRole\n  extends AwsConstructBase\n  implements IRole, IComparablePrincipal\n{\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly principalAccount?: string;\n  public readonly assumeRoleAction: string = \"sts:AssumeRole\";\n  public readonly policyFragment: PrincipalPolicyFragment;\n  public readonly roleArn: string;\n  public readonly roleName: string;\n  private readonly attachedPolicies = new AttachedPolicies();\n  private readonly defaultPolicyName?: string;\n  private defaultPolicy?: Policy;\n\n  private _roleOutputs: RoleOutputs;\n  public get roleOutputs(): RoleOutputs {\n    return this._roleOutputs;\n  }\n  public get outputs() {\n    return this.roleOutputs;\n  }\n\n  constructor(scope: Construct, id: string, props: ImportedRoleProps) {\n    super(scope, id, {\n      account: props.account,\n    });\n    this.roleArn = props.roleArn;\n    this.roleName = props.roleName;\n    this.policyFragment = new ArnPrincipal(this.roleArn).policyFragment;\n    this.defaultPolicyName = props.defaultPolicyName;\n    this.principalAccount = props.account;\n    this._roleOutputs = {\n      name: this.roleName,\n      arn: this.roleArn,\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    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(\n        this,\n        this.defaultPolicyName ?? \"Policy\",\n        {\n          policyName: undefined, // let the policy name be auto-generated\n        },\n      );\n      this.attachInlinePolicy(this.defaultPolicy);\n    }\n    this.defaultPolicy.addStatements(statement);\n    return { statementAdded: true, policyDependable: this.defaultPolicy };\n  }\n\n  public attachInlinePolicy(policy: Policy): void {\n    const thisAndPolicyAccountComparison = tokenCompareStrings(\n      this.env.account,\n      policy.env.account,\n    );\n    const equalOrAnyUnresolved =\n      thisAndPolicyAccountComparison === TokenComparison.SAME ||\n      thisAndPolicyAccountComparison === TokenComparison.BOTH_UNRESOLVED ||\n      thisAndPolicyAccountComparison === TokenComparison.ONE_UNRESOLVED;\n    if (equalOrAnyUnresolved) {\n      this.attachedPolicies.attach(policy);\n      policy.attachToRole(this);\n    }\n  }\n\n  public addManagedPolicy(policy: IManagedPolicy): void {\n    Annotations.of(this).addWarning(\n      `Not adding managed policy: ${policy.managedPolicyArn} to imported role: ${this.roleName}`,\n    );\n  }\n\n  public grantPassRole(identity: IPrincipal): Grant {\n    return this.grant(identity, \"iam:PassRole\");\n  }\n\n  public grantAssumeRole(identity: IPrincipal): Grant {\n    return this.grant(identity, \"sts:AssumeRole\");\n  }\n\n  public grant(grantee: IPrincipal, ...actions: string[]): Grant {\n    return Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.roleArn],\n      scope: this,\n    });\n  }\n\n  public dedupeString(): string | undefined {\n    return `ImportedRole:${this.roleArn}`;\n  }\n}\n\n/**\n * Helper class that maintains the set of attached policies for a principal.\n */\nexport class AttachedPolicies {\n  private policies = new Array<IPolicy>();\n\n  /**\n   * Adds a policy to the list of attached policies.\n   *\n   * If this policy is already, attached, returns false.\n   * If there is another policy attached with the same name, throws an exception.\n   */\n  public attach(policy: IPolicy) {\n    if (this.policies.find((p) => p === policy)) {\n      return; // already attached\n    }\n\n    if (this.policies.find((p) => p.policyName === policy.policyName)) {\n      throw new Error(\n        `A policy named \"${policy.policyName}\" is already attached`,\n      );\n    }\n\n    this.policies.push(policy);\n  }\n}\n"]}

package/lib/aws/iam/private/merge-statements.d.ts

@@ -0,0 +1,44 @@
+import { IConstruct } from "constructs";
+import { PolicyStatement } from "../policy-statement";
+/**
+ * Options for the mergeStatement command
+ */
+export interface MergeStatementOptions {
+    /**
+     * Scope to derive configuration flags from
+     */
+    readonly scope: IConstruct;
+    /**
+     * Do not merge statements if the result would be bigger than MAX_MERGE_SIZE
+     *
+     * @default false
+     */
+    readonly limitSize?: boolean;
+    /**
+     * Merge statements if they can be combined to produce the same effects.
+     *
+     * If false, statements are only merged if they are exactly equal.
+     *
+     * @default true
+     */
+    readonly mergeIfCombinable?: boolean;
+}
+/**
+ * Merge as many statements as possible to shrink the total policy doc, modifying the input array in place
+ *
+ * We compare and merge all pairs of statements (O(N^2) complexity), opportunistically
+ * merging them. This is not guaranteed to produce the optimal output, but it's probably
+ * Good Enough(tm). If it merges anything, it's at least going to produce a smaller output
+ * than the input.
+ */
+export declare function mergeStatements(statements: PolicyStatement[], options: MergeStatementOptions): MergeStatementResult;
+export interface MergeStatementResult {
+    /**
+     * The list of maximally merged statements
+     */
+    readonly mergedStatements: PolicyStatement[];
+    /**
+     * Mapping of old to new statements
+     */
+    readonly originsMap: Map<PolicyStatement, PolicyStatement[]>;
+}