terraconstructs 0.0.8

package/lib/aws/encryption/private/perms.d.ts

@@ -0,0 +1,5 @@
+export declare const ADMIN_ACTIONS: string[];
+export declare const ENCRYPT_ACTIONS: string[];
+export declare const DECRYPT_ACTIONS: string[];
+export declare const GENERATE_HMAC_ACTIONS: string[];
+export declare const VERIFY_HMAC_ACTIONS: string[];

package/lib/aws/encryption/private/perms.js

@@ -0,0 +1,30 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-kms/lib/private/perms.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERIFY_HMAC_ACTIONS = exports.GENERATE_HMAC_ACTIONS = exports.DECRYPT_ACTIONS = exports.ENCRYPT_ACTIONS = exports.ADMIN_ACTIONS = void 0;
+// https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html
+exports.ADMIN_ACTIONS = [
+    "kms:Create*",
+    "kms:Describe*",
+    "kms:Enable*",
+    "kms:List*",
+    "kms:Put*",
+    "kms:Update*",
+    "kms:Revoke*",
+    "kms:Disable*",
+    "kms:Get*",
+    "kms:Delete*",
+    "kms:TagResource",
+    "kms:UntagResource",
+    "kms:ScheduleKeyDeletion",
+    "kms:CancelKeyDeletion",
+];
+exports.ENCRYPT_ACTIONS = [
+    "kms:Encrypt",
+    "kms:ReEncrypt*",
+    "kms:GenerateDataKey*",
+];
+exports.DECRYPT_ACTIONS = ["kms:Decrypt"];
+exports.GENERATE_HMAC_ACTIONS = ["kms:GenerateMac"];
+exports.VERIFY_HMAC_ACTIONS = ["kms:VerifyMac"];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL2VuY3J5cHRpb24vcHJpdmF0ZS9wZXJtcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsaUdBQWlHOzs7QUFFakcsMEVBQTBFO0FBRTdELFFBQUEsYUFBYSxHQUFHO0lBQzNCLGFBQWE7SUFDYixlQUFlO0lBQ2YsYUFBYTtJQUNiLFdBQVc7SUFDWCxVQUFVO0lBQ1YsYUFBYTtJQUNiLGFBQWE7SUFDYixjQUFjO0lBQ2QsVUFBVTtJQUNWLGFBQWE7SUFDYixpQkFBaUI7SUFDakIsbUJBQW1CO0lBQ25CLHlCQUF5QjtJQUN6Qix1QkFBdUI7Q0FDeEIsQ0FBQztBQUVXLFFBQUEsZUFBZSxHQUFHO0lBQzdCLGFBQWE7SUFDYixnQkFBZ0I7SUFDaEIsc0JBQXNCO0NBQ3ZCLENBQUM7QUFFVyxRQUFBLGVBQWUsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0FBRWxDLFFBQUEscUJBQXFCLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBRTVDLFFBQUEsbUJBQW1CLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIGh0dHBzOi8vZ2l0aHViLmNvbS9hd3MvYXdzLWNkay9ibG9iL3YyLjE3MC4wL3BhY2thZ2VzL2F3cy1jZGstbGliL2F3cy1rbXMvbGliL3ByaXZhdGUvcGVybXMudHNcblxuLy8gaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2ttcy9sYXRlc3QvZGV2ZWxvcGVyZ3VpZGUva2V5LXBvbGljaWVzLmh0bWxcblxuZXhwb3J0IGNvbnN0IEFETUlOX0FDVElPTlMgPSBbXG4gIFwia21zOkNyZWF0ZSpcIixcbiAgXCJrbXM6RGVzY3JpYmUqXCIsXG4gIFwia21zOkVuYWJsZSpcIixcbiAgXCJrbXM6TGlzdCpcIixcbiAgXCJrbXM6UHV0KlwiLFxuICBcImttczpVcGRhdGUqXCIsXG4gIFwia21zOlJldm9rZSpcIixcbiAgXCJrbXM6RGlzYWJsZSpcIixcbiAgXCJrbXM6R2V0KlwiLFxuICBcImttczpEZWxldGUqXCIsXG4gIFwia21zOlRhZ1Jlc291cmNlXCIsXG4gIFwia21zOlVudGFnUmVzb3VyY2VcIixcbiAgXCJrbXM6U2NoZWR1bGVLZXlEZWxldGlvblwiLFxuICBcImttczpDYW5jZWxLZXlEZWxldGlvblwiLFxuXTtcblxuZXhwb3J0IGNvbnN0IEVOQ1JZUFRfQUNUSU9OUyA9IFtcbiAgXCJrbXM6RW5jcnlwdFwiLFxuICBcImttczpSZUVuY3J5cHQqXCIsXG4gIFwia21zOkdlbmVyYXRlRGF0YUtleSpcIixcbl07XG5cbmV4cG9ydCBjb25zdCBERUNSWVBUX0FDVElPTlMgPSBbXCJrbXM6RGVjcnlwdFwiXTtcblxuZXhwb3J0IGNvbnN0IEdFTkVSQVRFX0hNQUNfQUNUSU9OUyA9IFtcImttczpHZW5lcmF0ZU1hY1wiXTtcblxuZXhwb3J0IGNvbnN0IFZFUklGWV9ITUFDX0FDVElPTlMgPSBbXCJrbXM6VmVyaWZ5TWFjXCJdO1xuIl19

package/lib/aws/encryption/via-service-principal.d.ts

@@ -0,0 +1,11 @@
+import * as iam from "../iam";
+/**
+ * A principal to allow access to a key if it's being used through another AWS service
+ */
+export declare class ViaServicePrincipal extends iam.PrincipalBase {
+    private readonly serviceName;
+    private readonly basePrincipal;
+    constructor(serviceName: string, basePrincipal?: iam.IPrincipal);
+    get policyFragment(): iam.PrincipalPolicyFragment;
+    dedupeString(): string | undefined;
+}

package/lib/aws/encryption/via-service-principal.js

@@ -0,0 +1,39 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViaServicePrincipal = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/2.170.0/packages/aws-cdk-lib/aws-kms/lib/via-service-principal.ts
+const iam = require("../iam");
+/**
+ * A principal to allow access to a key if it's being used through another AWS service
+ */
+class ViaServicePrincipal extends iam.PrincipalBase {
+    constructor(serviceName, basePrincipal) {
+        super();
+        this.serviceName = serviceName;
+        this.basePrincipal = basePrincipal ? basePrincipal : new iam.AnyPrincipal();
+    }
+    get policyFragment() {
+        // Make a copy of the base policyFragment to add a condition to it
+        const base = this.basePrincipal.policyFragment;
+        const conditions = [...base.conditions];
+        const principals = [...base.principals];
+        conditions.push({
+            test: "StringEquals",
+            variable: "kms:ViaService",
+            values: [this.serviceName],
+        });
+        return new iam.PrincipalPolicyFragment(principals, conditions);
+    }
+    dedupeString() {
+        const base = iam.ComparablePrincipal.dedupeStringFor(this.basePrincipal);
+        return base !== undefined
+            ? `ViaServicePrincipal:${this.serviceName}:${base}`
+            : undefined;
+    }
+}
+exports.ViaServicePrincipal = ViaServicePrincipal;
+_a = JSII_RTTI_SYMBOL_1;
+ViaServicePrincipal[_a] = { fqn: "terraconstructs.aws.encryption.ViaServicePrincipal", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,221 @@
+import { IConstruct, IDependable } from "constructs";
+import { IAwsConstruct } from "../aws-construct";
+import { PolicyStatement, Conditions } from "./policy-statement";
+import { IGrantable, IPrincipal } from "./principals";
+/**
+ * Basic options for a grant operation
+ *
+ */
+export interface CommonGrantOptions {
+    /**
+     * The principal to grant to
+     *
+     * @default if principal is undefined, no work is done.
+     */
+    readonly grantee: IGrantable;
+    /**
+     * The actions to grant
+     */
+    readonly actions: string[];
+    /**
+     * The resource ARNs to grant to
+     */
+    readonly resourceArns: string[];
+    /**
+     * Any conditions to attach to the grant
+     *
+     * @default - No conditions
+     */
+    readonly conditions?: Conditions;
+}
+/**
+ * Options for a grant operation
+ *
+ */
+export interface GrantWithResourceOptions extends CommonGrantOptions {
+    /**
+     * The resource with a resource policy
+     *
+     * The statement will be added to the resource policy if it couldn't be
+     * added to the principal policy.
+     */
+    readonly resource: IAwsConstructWithPolicy;
+    /**
+     * When referring to the resource in a resource policy, use this as ARN.
+     *
+     * (Depending on the resource type, this needs to be '*' in a resource policy).
+     *
+     * @default Same as regular resource ARNs
+     */
+    readonly resourceSelfArns?: string[];
+}
+/**
+ * Options for a grant operation that only applies to principals
+ *
+ */
+export interface GrantOnPrincipalOptions extends CommonGrantOptions {
+    /**
+     * Construct to report warnings on in case grant could not be registered
+     *
+     * @default - the construct in which this construct is defined
+     */
+    readonly scope?: IConstruct;
+}
+/**
+ * Options for a grant operation to both identity and resource
+ *
+ */
+export interface GrantOnPrincipalAndResourceOptions extends CommonGrantOptions {
+    /**
+     * The resource with a resource policy
+     *
+     * The statement will always be added to the resource policy.
+     */
+    readonly resource: IAwsConstructWithPolicy;
+    /**
+     * When referring to the resource in a resource policy, use this as ARN.
+     *
+     * (Depending on the resource type, this needs to be '*' in a resource policy).
+     *
+     * @default Same as regular resource ARNs
+     */
+    readonly resourceSelfArns?: string[];
+    /**
+     * The principal to use in the statement for the resource policy.
+     *
+     * @default - the principal of the grantee will be used
+     */
+    readonly resourcePolicyPrincipal?: IPrincipal;
+}
+/**
+ * Result of a grant() operation
+ *
+ * This class is not instantiable by consumers on purpose, so that they will be
+ * required to call the Grant factory functions.
+ */
+export declare class Grant implements IDependable {
+    /**
+     * Grant the given permissions to the principal
+     *
+     * The permissions will be added to the principal policy primarily, falling
+     * back to the resource policy if necessary. The permissions must be granted
+     * somewhere.
+     *
+     * - Trying to grant permissions to a principal that does not admit adding to
+     *   the principal policy while not providing a resource with a resource policy
+     *   is an error.
+     * - Trying to grant permissions to an absent principal (possible in the
+     *   case of imported resources) leads to a warning being added to the
+     *   resource construct.
+     */
+    static addToPrincipalOrResource(options: GrantWithResourceOptions): Grant;
+    /**
+     * Try to grant the given permissions to the given principal
+     *
+     * Absence of a principal leads to a warning, but failing to add
+     * the permissions to a present principal is not an error.
+     */
+    static addToPrincipal(options: GrantOnPrincipalOptions): Grant;
+    /**
+     * Add a grant both on the principal and on the resource
+     *
+     * As long as any principal is given, granting on the principal may fail (in
+     * case of a non-identity principal), but granting on the resource will
+     * never fail.
+     *
+     * Statement will be the resource statement.
+     */
+    static addToPrincipalAndResource(options: GrantOnPrincipalAndResourceOptions): Grant;
+    /**
+     * Returns a "no-op" `Grant` object which represents a "dropped grant".
+     *
+     * This can be used for e.g. imported resources where you may not be able to modify
+     * the resource's policy or some underlying policy which you don't know about.
+     *
+     * @param grantee The intended grantee
+     * @param _intent The user's intent (will be ignored at the moment)
+     */
+    static drop(grantee: IGrantable, _intent: string): Grant;
+    /**
+     * The statement that was added to the principal's policy
+     *
+     * @deprecated Use `principalStatements` instead
+     */
+    readonly principalStatement?: PolicyStatement;
+    /**
+     * The statements that were added to the principal's policy
+     */
+    readonly principalStatements: PolicyStatement[];
+    /**
+     * The statement that was added to the resource policy
+     *
+     * @deprecated Use `resourceStatements` instead
+     */
+    readonly resourceStatement?: PolicyStatement;
+    /**
+     * The statements that were added to the principal's policy
+     */
+    readonly resourceStatements: PolicyStatement[];
+    /**
+     * The options originally used to set this result
+     *
+     * Private member doubles as a way to make it impossible for an object literal to
+     * be structurally the same as this class.
+     */
+    private readonly options;
+    private readonly dependables;
+    private constructor();
+    /**
+     * Whether the grant operation was successful
+     */
+    get success(): boolean;
+    /**
+     * Throw an error if this grant wasn't successful
+     */
+    assertSuccess(): void;
+    /**
+     * Make sure this grant is applied before the given constructs are deployed
+     *
+     * The same as construct.node.addDependency(grant), but slightly nicer to read.
+     */
+    applyBefore(...constructs: IConstruct[]): void;
+    /**
+     * Combine two grants into a new one
+     */
+    combine(rhs: Grant): Grant;
+}
+/**
+ * A resource with a resource policy that can be added to
+ */
+export interface IAwsConstructWithPolicy extends IAwsConstruct {
+    /**
+     * Add a statement to the resource's resource policy
+     */
+    addToResourcePolicy(statement: PolicyStatement): AddToResourcePolicyResult;
+}
+/**
+ * Result of calling addToResourcePolicy
+ */
+export interface AddToResourcePolicyResult {
+    /**
+     * Whether the statement was added
+     */
+    readonly statementAdded: boolean;
+    /**
+     * Dependable which allows depending on the policy change being applied
+     *
+     * @default - If `statementAdded` is true, the resource object itself.
+     * Otherwise, no dependable.
+     */
+    readonly policyDependable?: IDependable;
+}
+/**
+ * Composite dependable
+ *
+ * Not as simple as eagerly getting the dependency roots from the
+ * inner dependables, as they may be mutable so we need to defer
+ * the query.
+ */
+export declare class CompositeDependable implements IDependable {
+    constructor(...dependables: IDependable[]);
+}

package/lib/aws/iam/grant.js

@@ -0,0 +1,239 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeDependable = exports.Grant = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constructs_1 = require("constructs");
+const policy_statement_1 = require("./policy-statement");
+const token_1 = require("../../token");
+/**
+ * Result of a grant() operation
+ *
+ * This class is not instantiable by consumers on purpose, so that they will be
+ * required to call the Grant factory functions.
+ */
+class Grant {
+    /**
+     * Grant the given permissions to the principal
+     *
+     * The permissions will be added to the principal policy primarily, falling
+     * back to the resource policy if necessary. The permissions must be granted
+     * somewhere.
+     *
+     * - Trying to grant permissions to a principal that does not admit adding to
+     *   the principal policy while not providing a resource with a resource policy
+     *   is an error.
+     * - Trying to grant permissions to an absent principal (possible in the
+     *   case of imported resources) leads to a warning being added to the
+     *   resource construct.
+     */
+    static addToPrincipalOrResource(options) {
+        const result = Grant.addToPrincipal({
+            ...options,
+            scope: options.resource,
+        });
+        const resourceAndPrincipalAccountComparison = options.grantee.grantPrincipal
+            .principalAccount
+            ? (0, token_1.tokenCompareStrings)(options.resource.env.account, options.grantee.grantPrincipal.principalAccount)
+            : undefined;
+        // if both accounts are tokens, we assume here they are the same
+        const equalOrBothUnresolved = resourceAndPrincipalAccountComparison === token_1.TokenComparison.SAME ||
+            resourceAndPrincipalAccountComparison == token_1.TokenComparison.BOTH_UNRESOLVED;
+        const sameAccount = resourceAndPrincipalAccountComparison
+            ? equalOrBothUnresolved
+            : // if the principal doesn't have an account (for example, a service principal),
+                // we should modify the resource's trust policy
+                false;
+        // If we added to the principal AND we're in the same account, then we're done.
+        // If not, it's a different account and we must also add a trust policy on the resource.
+        if (result.success && sameAccount) {
+            return result;
+        }
+        const statement = new policy_statement_1.PolicyStatement({
+            actions: options.actions,
+            resources: options.resourceSelfArns || options.resourceArns,
+            principals: [options.grantee.grantPrincipal],
+        });
+        const resourceResult = options.resource.addToResourcePolicy(statement);
+        return new Grant({
+            resourceStatement: statement,
+            options,
+            policyDependable: resourceResult.statementAdded
+                ? (resourceResult.policyDependable ?? options.resource)
+                : undefined,
+        });
+    }
+    /**
+     * Try to grant the given permissions to the given principal
+     *
+     * Absence of a principal leads to a warning, but failing to add
+     * the permissions to a present principal is not an error.
+     */
+    static addToPrincipal(options) {
+        const statement = new policy_statement_1.PolicyStatement({
+            actions: options.actions,
+            resources: options.resourceArns,
+            condition: options.conditions,
+        });
+        const addedToPrincipal = options.grantee.grantPrincipal.addToPrincipalPolicy(statement);
+        if (!addedToPrincipal.statementAdded) {
+            return new Grant({ principalStatement: undefined, options });
+        }
+        if (!addedToPrincipal.policyDependable) {
+            throw new Error("Contract violation: when Principal returns statementAdded=true, it should return a dependable");
+        }
+        return new Grant({
+            principalStatement: statement,
+            options,
+            policyDependable: addedToPrincipal.policyDependable,
+        });
+    }
+    /**
+     * Add a grant both on the principal and on the resource
+     *
+     * As long as any principal is given, granting on the principal may fail (in
+     * case of a non-identity principal), but granting on the resource will
+     * never fail.
+     *
+     * Statement will be the resource statement.
+     */
+    static addToPrincipalAndResource(options) {
+        const result = Grant.addToPrincipal({
+            ...options,
+            scope: options.resource,
+        });
+        const statement = new policy_statement_1.PolicyStatement({
+            actions: options.actions,
+            resources: options.resourceSelfArns || options.resourceArns,
+            principals: [
+                options.resourcePolicyPrincipal || options.grantee.grantPrincipal,
+            ],
+        });
+        const resourceResult = options.resource.addToResourcePolicy(statement);
+        const resourceDependable = resourceResult.statementAdded
+            ? (resourceResult.policyDependable ?? options.resource)
+            : undefined;
+        return new Grant({
+            principalStatement: statement,
+            resourceStatement: result.resourceStatement,
+            options,
+            policyDependable: resourceDependable
+                ? new CompositeDependable(result, resourceDependable)
+                : result,
+        });
+    }
+    /**
+     * Returns a "no-op" `Grant` object which represents a "dropped grant".
+     *
+     * This can be used for e.g. imported resources where you may not be able to modify
+     * the resource's policy or some underlying policy which you don't know about.
+     *
+     * @param grantee The intended grantee
+     * @param _intent The user's intent (will be ignored at the moment)
+     */
+    static drop(grantee, _intent) {
+        return new Grant({
+            options: { grantee, actions: [], resourceArns: [] },
+        });
+    }
+    constructor(props) {
+        /**
+         * The statements that were added to the principal's policy
+         */
+        this.principalStatements = new Array();
+        /**
+         * The statements that were added to the principal's policy
+         */
+        this.resourceStatements = new Array();
+        this.dependables = new Array();
+        this.options = props.options;
+        this.principalStatement = props.principalStatement;
+        this.resourceStatement = props.resourceStatement;
+        if (this.principalStatement) {
+            this.principalStatements.push(this.principalStatement);
+        }
+        if (this.resourceStatement) {
+            this.resourceStatements.push(this.resourceStatement);
+        }
+        if (props.policyDependable) {
+            this.dependables.push(props.policyDependable);
+        }
+        const self = this;
+        constructs_1.Dependable.implement(this, {
+            get dependencyRoots() {
+                return Array.from(new Set(self.dependables.flatMap((d) => constructs_1.Dependable.of(d).dependencyRoots)));
+            },
+        });
+    }
+    /**
+     * Whether the grant operation was successful
+     */
+    get success() {
+        return (this.principalStatement !== undefined ||
+            this.resourceStatement !== undefined);
+    }
+    /**
+     * Throw an error if this grant wasn't successful
+     */
+    assertSuccess() {
+        if (!this.success) {
+            // eslint-disable-next-line max-len
+            throw new Error(`${describeGrant(this.options)} could not be added on either identity or resource policy.`);
+        }
+    }
+    /**
+     * Make sure this grant is applied before the given constructs are deployed
+     *
+     * The same as construct.node.addDependency(grant), but slightly nicer to read.
+     */
+    applyBefore(...constructs) {
+        for (const construct of constructs) {
+            construct.node.addDependency(this);
+        }
+    }
+    /**
+     * Combine two grants into a new one
+     */
+    combine(rhs) {
+        const combinedPrinc = [
+            ...this.principalStatements,
+            ...rhs.principalStatements,
+        ];
+        const combinedRes = [...this.resourceStatements, ...rhs.resourceStatements];
+        const ret = new Grant({
+            options: this.options,
+            principalStatement: combinedPrinc[0],
+            resourceStatement: combinedRes[0],
+        });
+        ret.principalStatements.splice(0, ret.principalStatements.length, ...combinedPrinc);
+        ret.resourceStatements.splice(0, ret.resourceStatements.length, ...combinedRes);
+        ret.dependables.push(...this.dependables, ...rhs.dependables);
+        return ret;
+    }
+}
+exports.Grant = Grant;
+_a = JSII_RTTI_SYMBOL_1;
+Grant[_a] = { fqn: "terraconstructs.aws.iam.Grant", version: "0.0.8" };
+function describeGrant(options) {
+    return `Permissions for '${options.grantee}' to call '${options.actions}' on '${options.resourceArns}'`;
+}
+/**
+ * Composite dependable
+ *
+ * Not as simple as eagerly getting the dependency roots from the
+ * inner dependables, as they may be mutable so we need to defer
+ * the query.
+ */
+class CompositeDependable {
+    constructor(...dependables) {
+        constructs_1.Dependable.implement(this, {
+            get dependencyRoots() {
+                return Array.prototype.concat.apply([], dependables.map((d) => constructs_1.Dependable.of(d).dependencyRoots));
+            },
+        });
+    }
+}
+exports.CompositeDependable = CompositeDependable;
+_b = JSII_RTTI_SYMBOL_1;
+CompositeDependable[_b] = { fqn: "terraconstructs.aws.iam.CompositeDependable", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grant.js","sourceRoot":"","sources":["../../../src/aws/iam/grant.ts"],"names":[],"mappings":"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","sourcesContent":["import { Dependable, IConstruct, IDependable } from \"constructs\";\nimport { IAwsConstruct } from \"../aws-construct\";\nimport { PolicyStatement, Conditions } from \"./policy-statement\";\nimport { IGrantable, IPrincipal } from \"./principals\";\nimport { TokenComparison, tokenCompareStrings } from \"../../token\";\n\n/**\n * Basic options for a grant operation\n *\n */\nexport interface CommonGrantOptions {\n  /**\n   * The principal to grant to\n   *\n   * @default if principal is undefined, no work is done.\n   */\n  readonly grantee: IGrantable;\n\n  /**\n   * The actions to grant\n   */\n  readonly actions: string[];\n\n  /**\n   * The resource ARNs to grant to\n   */\n  readonly resourceArns: string[];\n\n  /**\n   * Any conditions to attach to the grant\n   *\n   * @default - No conditions\n   */\n  readonly conditions?: Conditions;\n}\n\n/**\n * Options for a grant operation\n *\n */\nexport interface GrantWithResourceOptions extends CommonGrantOptions {\n  /**\n   * The resource with a resource policy\n   *\n   * The statement will be added to the resource policy if it couldn't be\n   * added to the principal policy.\n   */\n  readonly resource: IAwsConstructWithPolicy;\n\n  /**\n   * When referring to the resource in a resource policy, use this as ARN.\n   *\n   * (Depending on the resource type, this needs to be '*' in a resource policy).\n   *\n   * @default Same as regular resource ARNs\n   */\n  readonly resourceSelfArns?: string[];\n}\n\n/**\n * Options for a grant operation that only applies to principals\n *\n */\nexport interface GrantOnPrincipalOptions extends CommonGrantOptions {\n  /**\n   * Construct to report warnings on in case grant could not be registered\n   *\n   * @default - the construct in which this construct is defined\n   */\n  readonly scope?: IConstruct;\n}\n\n/**\n * Options for a grant operation to both identity and resource\n *\n */\nexport interface GrantOnPrincipalAndResourceOptions extends CommonGrantOptions {\n  /**\n   * The resource with a resource policy\n   *\n   * The statement will always be added to the resource policy.\n   */\n  readonly resource: IAwsConstructWithPolicy;\n\n  /**\n   * When referring to the resource in a resource policy, use this as ARN.\n   *\n   * (Depending on the resource type, this needs to be '*' in a resource policy).\n   *\n   * @default Same as regular resource ARNs\n   */\n  readonly resourceSelfArns?: string[];\n\n  /**\n   * The principal to use in the statement for the resource policy.\n   *\n   * @default - the principal of the grantee will be used\n   */\n  readonly resourcePolicyPrincipal?: IPrincipal;\n}\n\n/**\n * Result of a grant() operation\n *\n * This class is not instantiable by consumers on purpose, so that they will be\n * required to call the Grant factory functions.\n */\nexport class Grant implements IDependable {\n  /**\n   * Grant the given permissions to the principal\n   *\n   * The permissions will be added to the principal policy primarily, falling\n   * back to the resource policy if necessary. The permissions must be granted\n   * somewhere.\n   *\n   * - Trying to grant permissions to a principal that does not admit adding to\n   *   the principal policy while not providing a resource with a resource policy\n   *   is an error.\n   * - Trying to grant permissions to an absent principal (possible in the\n   *   case of imported resources) leads to a warning being added to the\n   *   resource construct.\n   */\n  public static addToPrincipalOrResource(\n    options: GrantWithResourceOptions,\n  ): Grant {\n    const result = Grant.addToPrincipal({\n      ...options,\n      scope: options.resource,\n    });\n\n    const resourceAndPrincipalAccountComparison = options.grantee.grantPrincipal\n      .principalAccount\n      ? tokenCompareStrings(\n          options.resource.env.account,\n          options.grantee.grantPrincipal.principalAccount,\n        )\n      : undefined;\n    // if both accounts are tokens, we assume here they are the same\n    const equalOrBothUnresolved =\n      resourceAndPrincipalAccountComparison === TokenComparison.SAME ||\n      resourceAndPrincipalAccountComparison == TokenComparison.BOTH_UNRESOLVED;\n    const sameAccount: boolean = resourceAndPrincipalAccountComparison\n      ? equalOrBothUnresolved\n      : // if the principal doesn't have an account (for example, a service principal),\n        // we should modify the resource's trust policy\n        false;\n    // If we added to the principal AND we're in the same account, then we're done.\n    // If not, it's a different account and we must also add a trust policy on the resource.\n    if (result.success && sameAccount) {\n      return result;\n    }\n\n    const statement = new PolicyStatement({\n      actions: options.actions,\n      resources: options.resourceSelfArns || options.resourceArns,\n      principals: [options.grantee!.grantPrincipal],\n    });\n\n    const resourceResult = options.resource.addToResourcePolicy(statement);\n\n    return new Grant({\n      resourceStatement: statement,\n      options,\n      policyDependable: resourceResult.statementAdded\n        ? (resourceResult.policyDependable ?? options.resource)\n        : undefined,\n    });\n  }\n\n  /**\n   * Try to grant the given permissions to the given principal\n   *\n   * Absence of a principal leads to a warning, but failing to add\n   * the permissions to a present principal is not an error.\n   */\n  public static addToPrincipal(options: GrantOnPrincipalOptions): Grant {\n    const statement = new PolicyStatement({\n      actions: options.actions,\n      resources: options.resourceArns,\n      condition: options.conditions,\n    });\n\n    const addedToPrincipal =\n      options.grantee.grantPrincipal.addToPrincipalPolicy(statement);\n    if (!addedToPrincipal.statementAdded) {\n      return new Grant({ principalStatement: undefined, options });\n    }\n\n    if (!addedToPrincipal.policyDependable) {\n      throw new Error(\n        \"Contract violation: when Principal returns statementAdded=true, it should return a dependable\",\n      );\n    }\n\n    return new Grant({\n      principalStatement: statement,\n      options,\n      policyDependable: addedToPrincipal.policyDependable,\n    });\n  }\n\n  /**\n   * Add a grant both on the principal and on the resource\n   *\n   * As long as any principal is given, granting on the principal may fail (in\n   * case of a non-identity principal), but granting on the resource will\n   * never fail.\n   *\n   * Statement will be the resource statement.\n   */\n  public static addToPrincipalAndResource(\n    options: GrantOnPrincipalAndResourceOptions,\n  ): Grant {\n    const result = Grant.addToPrincipal({\n      ...options,\n      scope: options.resource,\n    });\n\n    const statement = new PolicyStatement({\n      actions: options.actions,\n      resources: options.resourceSelfArns || options.resourceArns,\n      principals: [\n        options.resourcePolicyPrincipal || options.grantee!.grantPrincipal,\n      ],\n    });\n\n    const resourceResult = options.resource.addToResourcePolicy(statement);\n    const resourceDependable = resourceResult.statementAdded\n      ? (resourceResult.policyDependable ?? options.resource)\n      : undefined;\n\n    return new Grant({\n      principalStatement: statement,\n      resourceStatement: result.resourceStatement,\n      options,\n      policyDependable: resourceDependable\n        ? new CompositeDependable(result, resourceDependable)\n        : result,\n    });\n  }\n\n  /**\n   * Returns a \"no-op\" `Grant` object which represents a \"dropped grant\".\n   *\n   * This can be used for e.g. imported resources where you may not be able to modify\n   * the resource's policy or some underlying policy which you don't know about.\n   *\n   * @param grantee The intended grantee\n   * @param _intent The user's intent (will be ignored at the moment)\n   */\n  public static drop(grantee: IGrantable, _intent: string): Grant {\n    return new Grant({\n      options: { grantee, actions: [], resourceArns: [] },\n    });\n  }\n\n  /**\n   * The statement that was added to the principal's policy\n   *\n   * @deprecated Use `principalStatements` instead\n   */\n  public readonly principalStatement?: PolicyStatement;\n\n  /**\n   * The statements that were added to the principal's policy\n   */\n  public readonly principalStatements = new Array<PolicyStatement>();\n\n  /**\n   * The statement that was added to the resource policy\n   *\n   * @deprecated Use `resourceStatements` instead\n   */\n  public readonly resourceStatement?: PolicyStatement;\n\n  /**\n   * The statements that were added to the principal's policy\n   */\n  public readonly resourceStatements = new Array<PolicyStatement>();\n\n  /**\n   * The options originally used to set this result\n   *\n   * Private member doubles as a way to make it impossible for an object literal to\n   * be structurally the same as this class.\n   */\n  private readonly options: CommonGrantOptions;\n\n  private readonly dependables = new Array<IDependable>();\n\n  private constructor(props: GrantProps) {\n    this.options = props.options;\n    this.principalStatement = props.principalStatement;\n    this.resourceStatement = props.resourceStatement;\n    if (this.principalStatement) {\n      this.principalStatements.push(this.principalStatement);\n    }\n    if (this.resourceStatement) {\n      this.resourceStatements.push(this.resourceStatement);\n    }\n    if (props.policyDependable) {\n      this.dependables.push(props.policyDependable);\n    }\n\n    const self = this;\n    Dependable.implement(this, {\n      get dependencyRoots() {\n        return Array.from(\n          new Set(\n            self.dependables.flatMap((d) => Dependable.of(d).dependencyRoots),\n          ),\n        );\n      },\n    });\n  }\n\n  /**\n   * Whether the grant operation was successful\n   */\n  public get success(): boolean {\n    return (\n      this.principalStatement !== undefined ||\n      this.resourceStatement !== undefined\n    );\n  }\n\n  /**\n   * Throw an error if this grant wasn't successful\n   */\n  public assertSuccess(): void {\n    if (!this.success) {\n      // eslint-disable-next-line max-len\n      throw new Error(\n        `${describeGrant(this.options)} could not be added on either identity or resource policy.`,\n      );\n    }\n  }\n\n  /**\n   * Make sure this grant is applied before the given constructs are deployed\n   *\n   * The same as construct.node.addDependency(grant), but slightly nicer to read.\n   */\n  public applyBefore(...constructs: IConstruct[]) {\n    for (const construct of constructs) {\n      construct.node.addDependency(this);\n    }\n  }\n\n  /**\n   * Combine two grants into a new one\n   */\n  public combine(rhs: Grant) {\n    const combinedPrinc = [\n      ...this.principalStatements,\n      ...rhs.principalStatements,\n    ];\n    const combinedRes = [...this.resourceStatements, ...rhs.resourceStatements];\n\n    const ret = new Grant({\n      options: this.options,\n      principalStatement: combinedPrinc[0],\n      resourceStatement: combinedRes[0],\n    });\n    ret.principalStatements.splice(\n      0,\n      ret.principalStatements.length,\n      ...combinedPrinc,\n    );\n    ret.resourceStatements.splice(\n      0,\n      ret.resourceStatements.length,\n      ...combinedRes,\n    );\n    ret.dependables.push(...this.dependables, ...rhs.dependables);\n    return ret;\n  }\n}\n\nfunction describeGrant(options: CommonGrantOptions) {\n  return `Permissions for '${options.grantee}' to call '${options.actions}' on '${options.resourceArns}'`;\n}\n\ninterface GrantProps {\n  readonly options: CommonGrantOptions;\n  readonly principalStatement?: PolicyStatement;\n  readonly resourceStatement?: PolicyStatement;\n\n  /**\n   * Constructs whose deployment applies the grant\n   *\n   * Used to add dependencies on grants\n   */\n  readonly policyDependable?: IDependable;\n}\n\n/**\n * A resource with a resource policy that can be added to\n */\nexport interface IAwsConstructWithPolicy extends IAwsConstruct {\n  /**\n   * Add a statement to the resource's resource policy\n   */\n  addToResourcePolicy(statement: PolicyStatement): AddToResourcePolicyResult;\n}\n\n/**\n * Result of calling addToResourcePolicy\n */\nexport interface AddToResourcePolicyResult {\n  /**\n   * Whether the statement was added\n   */\n  readonly statementAdded: boolean;\n\n  /**\n   * Dependable which allows depending on the policy change being applied\n   *\n   * @default - If `statementAdded` is true, the resource object itself.\n   * Otherwise, no dependable.\n   */\n  readonly policyDependable?: IDependable;\n}\n\n/**\n * Composite dependable\n *\n * Not as simple as eagerly getting the dependency roots from the\n * inner dependables, as they may be mutable so we need to defer\n * the query.\n */\nexport class CompositeDependable implements IDependable {\n  constructor(...dependables: IDependable[]) {\n    Dependable.implement(this, {\n      get dependencyRoots(): IConstruct[] {\n        return Array.prototype.concat.apply(\n          [],\n          dependables.map((d) => Dependable.of(d).dependencyRoots),\n        );\n      },\n    });\n  }\n}\n"]}

package/lib/aws/iam/identity-base.d.ts

@@ -0,0 +1,20 @@
+import { IManagedPolicy } from "./managed-policy";
+import { Policy } from "./policy";
+import { IPrincipal } from "./principals";
+import { IAwsConstruct } from "../";
+/**
+ * A construct that represents an IAM principal, such as a user, group or role.
+ */
+export interface IIdentity extends IPrincipal, IAwsConstruct {
+    /**
+     * Attaches an inline policy to this principal.
+     * This is the same as calling `policy.addToXxx(principal)`.
+     * @param policy The policy resource to attach to this principal [disable-awslint:ref-via-interface]
+     */
+    attachInlinePolicy(policy: Policy): void;
+    /**
+     * Attaches a managed policy to this principal.
+     * @param policy The managed policy
+     */
+    addManagedPolicy(policy: IManagedPolicy): void;
+}

package/lib/aws/iam/identity-base.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRlbnRpdHktYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hd3MvaWFtL2lkZW50aXR5LWJhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElNYW5hZ2VkUG9saWN5IH0gZnJvbSBcIi4vbWFuYWdlZC1wb2xpY3lcIjtcbmltcG9ydCB7IFBvbGljeSB9IGZyb20gXCIuL3BvbGljeVwiO1xuaW1wb3J0IHsgSVByaW5jaXBhbCB9IGZyb20gXCIuL3ByaW5jaXBhbHNcIjtcbmltcG9ydCB7IElBd3NDb25zdHJ1Y3QgfSBmcm9tIFwiLi4vXCI7XG5cbi8qKlxuICogQSBjb25zdHJ1Y3QgdGhhdCByZXByZXNlbnRzIGFuIElBTSBwcmluY2lwYWwsIHN1Y2ggYXMgYSB1c2VyLCBncm91cCBvciByb2xlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIElJZGVudGl0eSBleHRlbmRzIElQcmluY2lwYWwsIElBd3NDb25zdHJ1Y3Qge1xuICAvKipcbiAgICogQXR0YWNoZXMgYW4gaW5saW5lIHBvbGljeSB0byB0aGlzIHByaW5jaXBhbC5cbiAgICogVGhpcyBpcyB0aGUgc2FtZSBhcyBjYWxsaW5nIGBwb2xpY3kuYWRkVG9YeHgocHJpbmNpcGFsKWAuXG4gICAqIEBwYXJhbSBwb2xpY3kgVGhlIHBvbGljeSByZXNvdXJjZSB0byBhdHRhY2ggdG8gdGhpcyBwcmluY2lwYWwgW2Rpc2FibGUtYXdzbGludDpyZWYtdmlhLWludGVyZmFjZV1cbiAgICovXG4gIGF0dGFjaElubGluZVBvbGljeShwb2xpY3k6IFBvbGljeSk6IHZvaWQ7XG5cbiAgLyoqXG4gICAqIEF0dGFjaGVzIGEgbWFuYWdlZCBwb2xpY3kgdG8gdGhpcyBwcmluY2lwYWwuXG4gICAqIEBwYXJhbSBwb2xpY3kgVGhlIG1hbmFnZWQgcG9saWN5XG4gICAqL1xuICBhZGRNYW5hZ2VkUG9saWN5KHBvbGljeTogSU1hbmFnZWRQb2xpY3kpOiB2b2lkO1xufVxuIl19

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

@@ -0,0 +1,16 @@
+export * from "./grant";
+export * from "./identity-base";
+export * from "./managed-policy";
+export * from "./oidc-provider";
+export * from "./policy-document-config.generated";
+export * from "./policy-document";
+export * from "./policy-statement-props.generated";
+export * from "./policy-statement";
+export * from "./policy";
+export * from "./principals";
+export * from "./role";
+export * from "./saml-provider";
+export * from "./unknown-principal";
+export * from "./utils";
+export * from "./policy-statement-props.generated";
+export * from "./policy-document-config.generated";