terraconstructs 0.0.8

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

@@ -0,0 +1,947 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionObject = exports.toConditionJson = exports.toConditions = exports.fromConditionJson = exports.isStringOrArrayOfStrings = exports.deriveEstimateSizeOptions = exports.Effect = exports.PolicyStatement = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const principals_1 = require("./principals");
+/**
+ * An estimate on how long ARNs typically are
+ *
+ * This is used to decide when to start splitting statements into new Managed Policies.
+ * Because we often can't know the length of an ARN (it may be a token and only
+ * available at deployment time) we'll have to estimate it.
+ */
+const DEFAULT_ARN_SIZE_ESTIMATE = 150;
+/**
+ * Represents a statement in an IAM policy document.
+ */
+class PolicyStatement {
+    /**
+     * Creates a new Terraform PolicyStatement based on the AWS IAM Policy Statement format.
+     * This will accept an object created from the `.toStatementJson()` call
+     *
+     * @param obj the PolicyStatement in object form.
+     */
+    static fromJson(obj) {
+        // TODO: What if obj is/has a Token(s)?
+        const ret = new PolicyStatement({
+            sid: obj.Sid,
+            actions: ensureArrayOrUndefined(obj.Action),
+            resources: ensureArrayOrUndefined(obj.Resource),
+            condition: fromConditionJson(obj.Condition),
+            effect: obj.Effect,
+            notActions: ensureArrayOrUndefined(obj.NotAction),
+            notResources: ensureArrayOrUndefined(obj.NotResource),
+            principals: obj.Principal
+                ? [new JsonPrincipal(obj.Principal)]
+                : undefined,
+            notPrincipals: obj.NotPrincipal
+                ? [new JsonPrincipal(obj.NotPrincipal)]
+                : undefined,
+        });
+        // validate that the PolicyStatement has the correct shape
+        const errors = ret.validateForAnyPolicy();
+        if (errors.length > 0) {
+            throw new Error("Incorrect Policy Statement: " + errors.join("\n"));
+        }
+        return ret;
+    }
+    constructor(props = {}) {
+        this._action = new OrderedSet();
+        this._notAction = new OrderedSet();
+        this._principal = [];
+        this._notPrincipal = [];
+        this._resource = new OrderedSet();
+        this._notResource = new OrderedSet();
+        this._conditionMap = {};
+        // Hold on to those principals
+        this._principals = new OrderedSet();
+        this._notPrincipals = new OrderedSet();
+        this._frozen = false;
+        this._sid = props.sid;
+        this._effect = props.effect || Effect.ALLOW;
+        this.addActions(...(props.actions || []));
+        this.addNotActions(...(props.notActions || []));
+        this.addPrincipals(...(props.principals || []));
+        this.addNotPrincipals(...(props.notPrincipals || []));
+        this.addResources(...(props.resources || []));
+        this.addNotResources(...(props.notResources || []));
+        // TODO: Handle IResolvable condition?
+        if (props.condition !== undefined) {
+            this.addConditions(...props.condition);
+        }
+    }
+    /**
+     * Statement ID for this statement
+     */
+    get sid() {
+        return this._sid;
+    }
+    /**
+     * Set Statement ID for this statement
+     */
+    set sid(sid) {
+        this.assertNotFrozen("sid");
+        this._sid = sid;
+    }
+    /**
+     * Whether to allow or deny the actions in this statement
+     */
+    get effect() {
+        return this._effect;
+    }
+    /**
+     * Set effect for this statement
+     */
+    set effect(effect) {
+        this.assertNotFrozen("effect");
+        this._effect = effect;
+    }
+    //
+    // Actions
+    //
+    /**
+     * Specify allowed actions into the "Action" section of the policy statement.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_action.html
+     *
+     * @param actions actions that will be allowed.
+     */
+    addActions(...actions) {
+        this.assertNotFrozen("addActions");
+        if (actions.length > 0 && this._notAction.length > 0) {
+            throw new Error("Cannot add 'Actions' to policy statement if 'NotActions' have been added");
+        }
+        this.validatePolicyActions(actions);
+        this._action.push(...actions);
+    }
+    /**
+     * Explicitly allow all actions except the specified list of actions into the "NotAction" section
+     * of the policy document.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notaction.html
+     *
+     * @param notActions actions that will be denied. All other actions will be permitted.
+     */
+    addNotActions(...notActions) {
+        this.assertNotFrozen("addNotActions");
+        if (notActions.length > 0 && this._action.length > 0) {
+            throw new Error("Cannot add 'NotActions' to policy statement if 'Actions' have been added");
+        }
+        this.validatePolicyActions(notActions);
+        this._notAction.push(...notActions);
+    }
+    //
+    // Principal
+    //
+    /**
+     * Indicates if this permission has a "Principal" section.
+     */
+    get hasPrincipal() {
+        return this._principals.length + this._notPrincipals.length > 0;
+    }
+    /**
+     * Adds principals to the "Principal" section of a policy statement.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html
+     *
+     * @param principals IAM principals that will be added
+     */
+    addPrincipals(...principals) {
+        this.assertNotFrozen("addPrincipals");
+        if (principals.length > 0 && this._notPrincipals.length > 0) {
+            throw new Error("Cannot add 'Principals' to policy statement if 'NotPrincipals' have been added");
+        }
+        // TODO: AWSCDK only ensures Principal is not instanceof Group
+        // for (const principal of principals) {
+        //   this.validatePolicyPrincipal(principal);
+        // }
+        const added = this._principals.push(...principals);
+        for (const principal of added) {
+            const fragment = principal.policyFragment;
+            (0, principals_1.mergePrincipal)(this._principal, fragment.principals);
+            this.addPrincipalConditions(...fragment.conditions);
+        }
+    }
+    /**
+     * Specify principals that is not allowed or denied access to the "NotPrincipal" section of
+     * a policy statement.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notprincipal.html
+     *
+     * @param notPrincipals IAM principals that will be denied access
+     */
+    addNotPrincipals(...notPrincipals) {
+        this.assertNotFrozen("addNotPrincipals");
+        if (notPrincipals.length > 0 && this._principals.length > 0) {
+            throw new Error("Cannot add 'NotPrincipals' to policy statement if 'Principals' have been added");
+        }
+        // for (const notPrincipal of notPrincipals) {
+        //   this.validatePolicyPrincipal(notPrincipal);
+        // }
+        const added = this._notPrincipals.push(...notPrincipals);
+        for (const notPrincipal of added) {
+            const fragment = notPrincipal.policyFragment;
+            (0, principals_1.mergePrincipal)(this._notPrincipal, fragment.principals);
+            this.addPrincipalConditions(...fragment.conditions);
+        }
+    }
+    validatePolicyActions(actions) {
+        // In case of an unresolved list of actions return early
+        if (cdktf_1.Token.isUnresolved(actions))
+            return;
+        for (const action of actions || []) {
+            if (!cdktf_1.Token.isUnresolved(action) &&
+                !/^(\*|[a-zA-Z0-9-]+:[a-zA-Z0-9*]+)$/.test(action)) {
+                throw new Error(`Action '${action}' is invalid. An action string consists of a service namespace, a colon, and the name of an action. Action names can include wildcards.`);
+            }
+        }
+    }
+    /**
+     * Specify AWS account ID as the principal entity to the "Principal" section of a policy statement.
+     */
+    addAwsAccountPrincipal(accountId) {
+        this.addPrincipals(new principals_1.AccountPrincipal(accountId));
+    }
+    /**
+     * Specify a principal using the ARN  identifier of the principal.
+     * You cannot specify IAM groups and instance profiles as principals.
+     *
+     * @param arn ARN identifier of AWS account, IAM user, or IAM role (i.e. arn:aws:iam::123456789012:user/user-name)
+     */
+    addArnPrincipal(arn) {
+        this.addPrincipals(new principals_1.ArnPrincipal(arn));
+    }
+    /**
+     * Adds a service principal to this policy statement.
+     *
+     * @param service the service name for which a service principal is requested (e.g: `s3.amazonaws.com`).
+     * @param opts    options for adding the service principal (such as specifying a principal in a different region)
+     */
+    addServicePrincipal(service, opts) {
+        this.addPrincipals(new principals_1.ServicePrincipal(service, opts));
+    }
+    /**
+     * Adds a federated identity provider such as Amazon Cognito to this policy statement.
+     *
+     * @param federated federated identity provider (i.e. 'cognito-identity.amazonaws.com')
+     * @param conditions The conditions under which the policy is in effect.
+     *   See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
+     */
+    addFederatedPrincipal(federated, conditions) {
+        this.addPrincipals(new principals_1.FederatedPrincipal(federated, conditions));
+    }
+    /**
+     * Adds an AWS account root user principal to this policy statement
+     */
+    addAccountRootPrincipal() {
+        this.addPrincipals(new principals_1.AccountRootPrincipal());
+    }
+    /**
+     * Adds a canonical user ID principal to this policy document
+     *
+     * @param canonicalUserId unique identifier assigned by AWS for every account
+     */
+    addCanonicalUserPrincipal(canonicalUserId) {
+        this.addPrincipals(new principals_1.CanonicalUserPrincipal(canonicalUserId));
+    }
+    /**
+     * Adds all identities in all accounts ("*") to this policy statement
+     */
+    addAnyPrincipal() {
+        this.addPrincipals(new principals_1.AnyPrincipal());
+    }
+    //
+    // Resources
+    //
+    /**
+     * Specify resources that this policy statement applies into the "Resource" section of
+     * this policy statement.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html
+     *
+     * @param arns Amazon Resource Names (ARNs) of the resources that this policy statement applies to
+     */
+    addResources(...arns) {
+        this.assertNotFrozen("addResources");
+        if (arns.length > 0 && this._notResource.length > 0) {
+            throw new Error("Cannot add 'Resources' to policy statement if 'NotResources' have been added");
+        }
+        this._resource.push(...arns);
+    }
+    /**
+     * Specify resources that this policy statement will not apply to in the "NotResource" section
+     * of this policy statement. All resources except the specified list will be matched.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notresource.html
+     *
+     * @param arns Amazon Resource Names (ARNs) of the resources that this policy statement does not apply to
+     */
+    addNotResources(...arns) {
+        this.assertNotFrozen("addNotResources");
+        if (arns.length > 0 && this._resource.length > 0) {
+            throw new Error("Cannot add 'NotResources' to policy statement if 'Resources' have been added");
+        }
+        this._notResource.push(...arns);
+    }
+    /**
+     * Adds a ``"*"`` resource to this statement.
+     */
+    addAllResources() {
+        this.addResources("*");
+    }
+    /**
+     * Indicates if this permission has at least one resource associated with it.
+     */
+    get hasResource() {
+        return this._resource && this._resource.length > 0;
+    }
+    //
+    // Condition
+    //
+    /**
+     * Add a condition to the Policy
+     *
+     * If multiple calls are made to add a condition with the same test and variable, only
+     * the last one wins. For example:
+     *
+     * ```ts
+     * declare const stmt: iam.PolicyStatement;
+     *
+     * stmt.addCondition({ test: 'StringEquals', variable: 'aws:SomeField', values: ['1'] });
+     * stmt.addCondition({ test: 'StringEquals', variable: 'aws:SomeField', values: ['2'] });
+     * ```
+     *
+     * Will end up with the single condition
+     *
+     * ```ts
+     * {
+     *   test: 'StringEquals',
+     *   variable: 'aws:SomeField',
+     *   values: ['2'],
+     * }
+     * ```.
+     *
+     * If you meant to add a condition to say that the field can be *either* `1` or `2`, write
+     * this:
+     *
+     * ```ts
+     * declare const stmt: iam.PolicyStatement;
+     *
+     * stmt.addCondition({ test: 'StringEquals', variable: 'aws:SomeField', values: ['1', '2'] });
+     * ```
+     */
+    addCondition(condition) {
+        this.assertNotFrozen("addCondition");
+        if (!this._conditionMap[condition.test]) {
+            this._conditionMap[condition.test] = {};
+        }
+        const existingCondition = this._conditionMap[condition.test][condition.variable];
+        if (existingCondition) {
+            this._conditionMap[condition.test][condition.variable] = {
+                ...existingCondition,
+                ...condition,
+            };
+        }
+        else {
+            this._conditionMap[condition.test][condition.variable] = condition;
+        }
+    }
+    /**
+     * Add a condition to the Policy
+     *
+     * If multiple calls are made to add a condition with the same operator and field, only
+     * the last one wins. For example:
+     *
+     * ```ts
+     * declare const stmt: iam.PolicyStatement;
+     *
+     * stmt.addCondition('StringEquals', { 'aws:SomeField': '1' });
+     * stmt.addCondition('StringEquals', { 'aws:SomeField': '2' });
+     * ```
+     *
+     * Will end up with the single condition `StringEquals: { 'aws:SomeField': '2' }`.
+     *
+     * If you meant to add a condition to say that the field can be *either* `1` or `2`, write
+     * this:
+     *
+     * ```ts
+     * declare const stmt: iam.PolicyStatement;
+     *
+     * stmt.addCondition('StringEquals', { 'aws:SomeField': ['1', '2'] });
+     * ```
+     */
+    addConditionObject(key, value) {
+        this.assertNotFrozen("addCondition");
+        validateConditionObject(value);
+        for (const [k, v] of Object.entries(value)) {
+            if (!isStringOrArrayOfStrings(v)) {
+                throw new Error(`Fields must be either a string or an array of strings. Got ${v} for key ${k}`);
+            }
+            this.addCondition({
+                test: key,
+                variable: k,
+                values: Array.isArray(v) ? v : [v],
+            });
+        }
+    }
+    /**
+     * Add multiple conditions to the Policy
+     *
+     * See the `addCondition` function for a caveat on calling this method multiple times.
+     */
+    addConditions(...conditions) {
+        conditions.map((c) => {
+            this.addCondition(c);
+        });
+    }
+    /**
+     * Add multiple conditionObjects to the Policy
+     *
+     * See the `addConditionObject` function for a caveat on calling this method multiple times.
+     */
+    addConditionObjects(conditions) {
+        for (const [key, value] of Object.entries(conditions)) {
+            this.addConditionObject(key, value);
+        }
+    }
+    /**
+     * Add a `StringEquals` condition that limits to a given account from `sts:ExternalId`.
+     *
+     * This method can only be called once: subsequent calls will overwrite earlier calls.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html
+     */
+    addAccountCondition(...accountIds) {
+        this.addCondition({
+            test: "StringEquals",
+            variable: "sts:ExternalId",
+            values: accountIds,
+        });
+    }
+    /**
+     * Add an `StringEquals` condition that limits to a given account from `aws:SourceAccount`.
+     *
+     * This method can only be called once: subsequent calls will overwrite earlier calls.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount
+     */
+    addSourceAccountCondition(...accountIds) {
+        this.addCondition({
+            test: "StringEquals",
+            variable: "aws:SourceAccount",
+            values: accountIds,
+        });
+    }
+    /**
+     * Add an `ArnEquals` condition that limits to a given resource arn from `aws:SourceArn`.
+     *
+     * This method can only be called once: subsequent calls will overwrite earlier calls.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn
+     */
+    addSourceArnCondition(...arns) {
+        this.addCondition({
+            test: "ArnEquals",
+            variable: "aws:SourceArn",
+            values: arns,
+        });
+    }
+    /**
+     * Create a new `PolicyStatement` with the same exact properties
+     * as this one, except for the overrides
+     */
+    copy(overrides = {}) {
+        return new PolicyStatement({
+            sid: overrides.sid ?? this.sid,
+            effect: overrides.effect ?? this.effect,
+            actions: overrides.actions ?? this.actions,
+            notActions: overrides.notActions ?? this.notActions,
+            principals: overrides.principals ?? this.principals,
+            notPrincipals: overrides.notPrincipals ?? this.notPrincipals,
+            resources: overrides.resources ?? this.resources,
+            notResources: overrides.notResources ?? this.notResources,
+            condition: overrides.condition ?? this.conditions,
+        });
+    }
+    /**
+     * Get AWS IAM Policy statement JSON
+     */
+    toStatementJson() {
+        return normalizeStatement({
+            Action: this._action.direct(),
+            NotAction: this._notAction.direct(),
+            Condition: toConditionJson(...toConditions(this._conditionMap)),
+            Effect: this.effect,
+            Principal: (0, principals_1.toPrincipalJson)(...this._principal),
+            NotPrincipal: (0, principals_1.toPrincipalJson)(...this._notPrincipal),
+            Resource: this._resource.direct(),
+            NotResource: this._notResource.direct(),
+            Sid: this.sid,
+        });
+    }
+    /**
+     * String representation of this policy statement
+     */
+    toString() {
+        return cdktf_1.Token.asString(this, {
+            displayHint: "PolicyStatement",
+        });
+    }
+    /**
+     * JSON-ify the statement
+     *
+     * Used when JSON.stringify() is called
+     */
+    toJSON() {
+        const principals = this.principals.flatMap((p) => p.policyFragment.principals);
+        const notPrincipals = this.notPrincipals.flatMap((p) => p.policyFragment.principals);
+        return {
+            sid: this.sid,
+            actions: this.actions.length > 0 ? this.actions : undefined,
+            notActions: this.notActions.length > 0 ? this.notActions : undefined,
+            principals: principals.length > 0 ? principals : undefined,
+            notPrincipals: notPrincipals.length > 0 ? notPrincipals : undefined,
+            resources: this.resources.length > 0 ? this.resources : undefined,
+            notResources: this.notResources.length > 0 ? this.notResources : undefined,
+            condition: this.conditions.length > 0 ? this.conditions : undefined,
+            effect: this.effect,
+        };
+    }
+    /**
+     * Add a principal's conditions
+     *
+     * For convenience, principals have been modeled as both a principal
+     * and a set of conditions. This makes it possible to have a single
+     * object represent e.g. an "SNS Topic" (SNS service principal + aws:SourcArn
+     * condition) or an Organization member (* + aws:OrgId condition).
+     *
+     * However, when using multiple principals in the same policy statement,
+     * they must all have the same conditions or the OR samentics
+     * implied by a list of principals cannot be guaranteed (user needs to
+     * add multiple statements in that case).
+     */
+    addPrincipalConditions(...conditions) {
+        // Stringifying the conditions is an easy way to do deep equality
+        const theseConditions = JSON.stringify(conditions);
+        if (this.principalConditionsJson === undefined) {
+            // First principal, anything goes
+            this.principalConditionsJson = theseConditions;
+        }
+        else {
+            if (this.principalConditionsJson !== theseConditions) {
+                throw new Error(`All principals in a PolicyStatement must have the same Conditions (got '${this.principalConditionsJson}' and '${theseConditions}'). Use multiple statements instead.`);
+            }
+        }
+        this.addConditions(...conditions);
+    }
+    /**
+     * Validate that the policy statement satisfies base requirements for a policy.
+     *
+     * @returns An array of validation error messages, or an empty array if the statement is valid.
+     */
+    validateForAnyPolicy() {
+        const errors = new Array();
+        if (this._action.length === 0 && this._notAction.length === 0) {
+            errors.push("A PolicyStatement must specify at least one 'action' or 'notAction'.");
+        }
+        return errors;
+    }
+    /**
+     * Validate that the policy statement satisfies all requirements for a resource-based policy.
+     *
+     * @returns An array of validation error messages, or an empty array if the statement is valid.
+     */
+    validateForResourcePolicy() {
+        const errors = this.validateForAnyPolicy();
+        if (this._principals.length === 0 && this._notPrincipals.length === 0) {
+            errors.push("A PolicyStatement used in a resource-based policy must specify at least one IAM principal.");
+        }
+        return errors;
+    }
+    /**
+     * Validate that the policy statement satisfies all requirements for an identity-based policy.
+     *
+     * @returns An array of validation error messages, or an empty array if the statement is valid.
+     */
+    validateForIdentityPolicy() {
+        const errors = this.validateForAnyPolicy();
+        if (this._principals.length > 0 || this._notPrincipals.length > 0) {
+            errors.push("A PolicyStatement used in an identity-based policy cannot specify any IAM principals.");
+        }
+        if (this._resource.length === 0 && this._notResource.length === 0) {
+            errors.push("A PolicyStatement used in an identity-based policy must specify at least one resource.");
+        }
+        return errors;
+    }
+    /**
+     * The Actions added to this statement
+     */
+    get actions() {
+        return this._action.copy();
+    }
+    /**
+     * The NotActions added to this statement
+     */
+    get notActions() {
+        return this._notAction.copy();
+    }
+    /**
+     * The Principals added to this statement
+     */
+    get principals() {
+        return this._principals.copy();
+    }
+    /**
+     * The NotPrincipals added to this statement
+     */
+    get notPrincipals() {
+        return this._notPrincipals.copy();
+    }
+    /**
+     * The Resources added to this statement
+     */
+    get resources() {
+        return this._resource.copy();
+    }
+    /**
+     * The NotResources added to this statement
+     */
+    get notResources() {
+        return this._notResource.copy();
+    }
+    /**
+     * The conditions added to this statement
+     */
+    get conditions() {
+        return toConditions(this._conditionMap);
+    }
+    /**
+     * Make the PolicyStatement immutable
+     *
+     * After calling this, any of the `addXxx()` methods will throw an exception.
+     *
+     * Libraries that lazily generate statement bodies can override this method to
+     * fill the actual PolicyStatement fields. Be aware that this method may be called
+     * multiple times.
+     */
+    freeze() {
+        this._frozen = true;
+        return this;
+    }
+    /**
+     * Whether the PolicyStatement has been frozen
+     *
+     * The statement object is frozen when `freeze()` is called.
+     */
+    get frozen() {
+        return this._frozen;
+    }
+    /**
+     * Estimate the size of this policy statement
+     *
+     * By necessity, this will not be accurate. We'll do our best to overestimate
+     * so we won't have nasty surprises.
+     *
+     * @internal
+     */
+    _estimateSize(options) {
+        let ret = 0;
+        const { actionEstimate, arnEstimate } = options;
+        ret += `"Effect": "${this.effect}",`.length;
+        count("Action", this.actions, actionEstimate);
+        count("NotAction", this.notActions, actionEstimate);
+        count("Resource", this.resources, arnEstimate);
+        count("NotResource", this.notResources, arnEstimate);
+        ret += this.principals.length * arnEstimate;
+        ret += this.notPrincipals.length * arnEstimate;
+        ret += JSON.stringify(toConditionJson(...this.conditions)).length;
+        return ret;
+        function count(key, values, tokenSize) {
+            if (values.length > 0) {
+                ret +=
+                    key.length +
+                        5 /* quotes, colon, brackets */ +
+                        sum(values.map((v) => (cdktf_1.Token.isUnresolved(v) ? tokenSize : v.length) +
+                            3 /* quotes, separator */));
+            }
+        }
+    }
+    /**
+     * Throw an exception when the object is frozen
+     */
+    assertNotFrozen(method) {
+        if (this._frozen) {
+            throw new Error(`${method}: freeze() has been called on this PolicyStatement previously, so it can no longer be modified`);
+        }
+    }
+}
+exports.PolicyStatement = PolicyStatement;
+_a = JSII_RTTI_SYMBOL_1;
+PolicyStatement[_a] = { fqn: "terraconstructs.aws.iam.PolicyStatement", version: "0.0.8" };
+/**
+ * The Effect element of an IAM policy
+ *
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_effect.html
+ */
+var Effect;
+(function (Effect) {
+    /**
+     * Allows access to a resource in an IAM policy statement. By default, access to resources are denied.
+     */
+    Effect["ALLOW"] = "Allow";
+    /**
+     * Explicitly deny access to a resource. By default, all requests are denied implicitly.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html
+     */
+    Effect["DENY"] = "Deny";
+})(Effect || (exports.Effect = Effect = {}));
+// TODO: Support IResolvable Condition?
+class JsonPrincipal extends principals_1.PrincipalBase {
+    constructor(json = {}) {
+        super();
+        this.principals = [];
+        this.policyFragment = principals_1.PrincipalPolicyFragment.fromJson(json);
+    }
+    dedupeString() {
+        return JSON.stringify(this.policyFragment);
+    }
+}
+/**
+ * Derive the size estimation options from context
+ *
+ * @internal
+ */
+function deriveEstimateSizeOptions(_scope) {
+    const actionEstimate = 20;
+    const arnEstimate = DEFAULT_ARN_SIZE_ESTIMATE;
+    return { actionEstimate, arnEstimate };
+}
+exports.deriveEstimateSizeOptions = deriveEstimateSizeOptions;
+/**
+ * A class that behaves both as a set and an array
+ *
+ * Used for the elements of a PolicyStatement. In practice they behave as sets,
+ * but we have thousands of snapshot tests in existence that will rely on a
+ * particular order so we can't just change the type to `Set<>` wholesale without
+ * causing a lot of churn.
+ */
+class OrderedSet {
+    constructor() {
+        this.set = new Set();
+        this.array = new Array();
+    }
+    /**
+     * Add new elements to the set
+     *
+     * @param xs the elements to be added
+     *
+     * @returns the elements actually added
+     */
+    push(...xs) {
+        const ret = new Array();
+        for (const x of xs) {
+            if (this.set.has(x)) {
+                continue;
+            }
+            this.set.add(x);
+            this.array.push(x);
+            ret.push(x);
+        }
+        return ret;
+    }
+    get length() {
+        return this.array.length;
+    }
+    copy() {
+        return [...this.array];
+    }
+    /**
+     * Direct (read-only) access to the underlying array
+     *
+     * (Saves a copy)
+     */
+    direct() {
+        return this.array;
+    }
+}
+function sum(xs) {
+    return xs.reduce((a, b) => a + b, 0);
+}
+function normalizeStatement(s) {
+    return noUndef({
+        Action: _norm(s.Action, { unique: true }),
+        NotAction: _norm(s.NotAction, { unique: true }),
+        Condition: _norm(s.Condition),
+        Effect: _norm(s.Effect),
+        Principal: _normPrincipal(s.Principal),
+        NotPrincipal: _normPrincipal(s.NotPrincipal),
+        Resource: _norm(s.Resource, { unique: true }),
+        NotResource: _norm(s.NotResource, { unique: true }),
+        Sid: _norm(s.Sid),
+    });
+    function _norm(values, { unique = false } = { unique: false }) {
+        if (values == null) {
+            return undefined;
+        }
+        if (cdktf_1.Token.isUnresolved(values)) {
+            return values;
+        }
+        if (Array.isArray(values)) {
+            if (!values || values.length === 0) {
+                return undefined;
+            }
+            if (values.length === 1) {
+                return values[0];
+            }
+            return unique ? Array.from(new Set(values)) : values;
+        }
+        if (values && typeof values === "object") {
+            if (Object.keys(values).length === 0) {
+                return undefined;
+            }
+        }
+        return values;
+    }
+    function _normPrincipal(principal) {
+        if (!principal) {
+            return undefined;
+        }
+        if (typeof principal === "string") {
+            return principal;
+        }
+        if (Array.isArray(principal) || typeof principal !== "object") {
+            return undefined;
+        }
+        const keys = Object.keys(principal);
+        if (keys.length === 0) {
+            return undefined;
+        }
+        const result = {};
+        for (const key of keys) {
+            const normVal = _norm(principal[key]);
+            if (normVal) {
+                result[key] = normVal;
+            }
+        }
+        return result;
+    }
+}
+function noUndef(x) {
+    const ret = {};
+    for (const [key, value] of Object.entries(x)) {
+        if (value !== undefined) {
+            ret[key] = value;
+        }
+    }
+    return ret;
+}
+function ensureArrayOrUndefined(field) {
+    if (field === undefined) {
+        return undefined;
+    }
+    if (typeof field !== "string" && !Array.isArray(field)) {
+        throw new Error("Fields must be either a string or an array of strings");
+    }
+    if (Array.isArray(field) && !!field.find((f) => typeof f !== "string")) {
+        throw new Error("Fields must be either a string or an array of strings");
+    }
+    return Array.isArray(field) ? field : [field];
+}
+function isStringOrArrayOfStrings(value) {
+    if (typeof value === "string") {
+        return true;
+    }
+    if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+        return true;
+    }
+    return false;
+}
+exports.isStringOrArrayOfStrings = isStringOrArrayOfStrings;
+/**
+ * Convert a condition JSON object to a list of Terraform AWS Policy Statement Conditions
+ *
+ * JSON object is specified in the following structure:
+ *
+ * `{ "Operator": { "keyInRequestContext": "value" } }`
+ *
+ * The value can be either a single string value or an array of string values.
+ *
+ * For more information, including which operators are supported, see [the IAM
+ * documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
+ * @param conditionJson The condition JSON object
+ * @returns The list of Terraform condition objects
+ */
+function fromConditionJson(conditionJson) {
+    if (!conditionJson) {
+        return undefined;
+    }
+    const result = new Array();
+    for (const [test, variables] of Object.entries(conditionJson)) {
+        if (Array.isArray(variables)) {
+            throw new Error(`Invalid event pattern field { ${test}: ${JSON.stringify(variables)} }. All fields must be objects`);
+        }
+        for (const [variable, value] of Object.entries(variables)) {
+            result.push({
+                test,
+                variable,
+                values: Array.isArray(value) ? value : [value],
+            });
+        }
+    }
+    return result;
+}
+exports.fromConditionJson = fromConditionJson;
+/**
+ * flatten Conditions mapped by test and variable to an array of Terraform AWS Policy Statement Conditions
+ * @param conditionMap The condition map
+ * @returns The list of Terraform condition objects
+ */
+function toConditions(conditionMap) {
+    return Object.values(conditionMap).flatMap((variables) => Object.values(variables));
+    // const conditions: Conditions = [];
+    // for (const variablesMap of Object.values(conditionMap)) {
+    //   for (const condition of Object.values(variablesMap)) {
+    //     conditions.push(condition);
+    //   }
+    // }
+    // return conditions;
+}
+exports.toConditions = toConditions;
+/**
+ * Convert a list of Terraform AWS Policy Statement condition objects back to a condition JSON object
+ * @param conditions The list of Terraform condition objects
+ * @returns The condition JSON object
+ */
+function toConditionJson(...conditions) {
+    const conditionJson = {};
+    for (const condition of conditions) {
+        const { test, variable, values } = condition;
+        if (!conditionJson[test]) {
+            conditionJson[test] = {};
+        }
+        if (values.length === 1) {
+            conditionJson[test][variable] = values[0];
+        }
+        else {
+            conditionJson[test][variable] = values;
+        }
+    }
+    return conditionJson;
+}
+exports.toConditionJson = toConditionJson;
+/**
+ * Validate that the given value is a valid Json Condition object
+ *
+ * AWS CDK IAM library relies on being able to pass in a `Json` instance for
+ * a `Condition`.
+ */
+function validateConditionObject(x) {
+    if (!x || typeof x !== "object" || Array.isArray(x)) {
+        throw new Error("A Condition should be represented as a map of operator to value");
+    }
+}
+exports.validateConditionObject = validateConditionObject;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-statement.js","sourceRoot":"","sources":["../../../src/aws/iam/policy-statement.ts"],"names":[],"mappings":"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","sourcesContent":["// ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-iam/lib/policy-statement.ts\nimport { dataAwsIamPolicyDocument } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { IConstruct } from \"constructs\";\nimport { PolicyStatementProps } from \"./policy-statement-props.generated\";\nimport {\n  AccountPrincipal,\n  AccountRootPrincipal,\n  AnyPrincipal,\n  ArnPrincipal,\n  CanonicalUserPrincipal,\n  FederatedPrincipal,\n  PrincipalPolicyFragment,\n  ServicePrincipal,\n  ServicePrincipalOpts,\n  IPrincipal,\n  PrincipalProps,\n  mergePrincipal,\n  toPrincipalJson,\n  PrincipalBase,\n} from \"./principals\";\n\n/**\n * An estimate on how long ARNs typically are\n *\n * This is used to decide when to start splitting statements into new Managed Policies.\n * Because we often can't know the length of an ARN (it may be a token and only\n * available at deployment time) we'll have to estimate it.\n */\nconst DEFAULT_ARN_SIZE_ESTIMATE = 150;\n\nexport type ConditionMap = {\n  [test: string]: { [variable: string]: Condition };\n};\n\n/**\n * Represents a statement in an IAM policy document.\n */\nexport class PolicyStatement {\n  /**\n   * Creates a new Terraform PolicyStatement based on the AWS IAM Policy Statement format.\n   * This will accept an object created from the `.toStatementJson()` call\n   *\n   * @param obj the PolicyStatement in object form.\n   */\n  public static fromJson(obj: any) {\n    // TODO: What if obj is/has a Token(s)?\n    const ret = new PolicyStatement({\n      sid: obj.Sid,\n      actions: ensureArrayOrUndefined(obj.Action),\n      resources: ensureArrayOrUndefined(obj.Resource),\n      condition: fromConditionJson(obj.Condition),\n      effect: obj.Effect,\n      notActions: ensureArrayOrUndefined(obj.NotAction),\n      notResources: ensureArrayOrUndefined(obj.NotResource),\n      principals: obj.Principal\n        ? [new JsonPrincipal(obj.Principal)]\n        : undefined,\n      notPrincipals: obj.NotPrincipal\n        ? [new JsonPrincipal(obj.NotPrincipal)]\n        : undefined,\n    });\n\n    // validate that the PolicyStatement has the correct shape\n    const errors = ret.validateForAnyPolicy();\n    if (errors.length > 0) {\n      throw new Error(\"Incorrect Policy Statement: \" + errors.join(\"\\n\"));\n    }\n\n    return ret;\n  }\n\n  private readonly _action = new OrderedSet<string>();\n  private readonly _notAction = new OrderedSet<string>();\n  private readonly _principal: PrincipalProps[] = [];\n  private readonly _notPrincipal: PrincipalProps[] = [];\n  private readonly _resource = new OrderedSet<string>();\n  private readonly _notResource = new OrderedSet<string>();\n  private readonly _conditionMap: ConditionMap = {};\n  private _sid?: string;\n  private _effect: Effect;\n  private principalConditionsJson?: string;\n\n  // Hold on to those principals\n  private readonly _principals = new OrderedSet<IPrincipal>();\n  private readonly _notPrincipals = new OrderedSet<IPrincipal>();\n  private _frozen = false;\n\n  constructor(props: PolicyStatementProps = {}) {\n    this._sid = props.sid;\n    this._effect = props.effect || Effect.ALLOW;\n\n    this.addActions(...(props.actions || []));\n    this.addNotActions(...(props.notActions || []));\n    this.addPrincipals(...(props.principals || []));\n    this.addNotPrincipals(...(props.notPrincipals || []));\n    this.addResources(...(props.resources || []));\n    this.addNotResources(...(props.notResources || []));\n    // TODO: Handle IResolvable condition?\n    if (props.condition !== undefined) {\n      this.addConditions(...props.condition);\n    }\n  }\n\n  /**\n   * Statement ID for this statement\n   */\n  public get sid(): string | undefined {\n    return this._sid;\n  }\n\n  /**\n   * Set Statement ID for this statement\n   */\n  public set sid(sid: string | undefined) {\n    this.assertNotFrozen(\"sid\");\n    this._sid = sid;\n  }\n\n  /**\n   * Whether to allow or deny the actions in this statement\n   */\n  public get effect(): Effect {\n    return this._effect;\n  }\n\n  /**\n   * Set effect for this statement\n   */\n  public set effect(effect: Effect) {\n    this.assertNotFrozen(\"effect\");\n    this._effect = effect;\n  }\n\n  //\n  // Actions\n  //\n\n  /**\n   * Specify allowed actions into the \"Action\" section of the policy statement.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_action.html\n   *\n   * @param actions actions that will be allowed.\n   */\n  public addActions(...actions: string[]) {\n    this.assertNotFrozen(\"addActions\");\n    if (actions.length > 0 && this._notAction.length > 0) {\n      throw new Error(\n        \"Cannot add 'Actions' to policy statement if 'NotActions' have been added\",\n      );\n    }\n    this.validatePolicyActions(actions);\n    this._action.push(...actions);\n  }\n\n  /**\n   * Explicitly allow all actions except the specified list of actions into the \"NotAction\" section\n   * of the policy document.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notaction.html\n   *\n   * @param notActions actions that will be denied. All other actions will be permitted.\n   */\n  public addNotActions(...notActions: string[]) {\n    this.assertNotFrozen(\"addNotActions\");\n    if (notActions.length > 0 && this._action.length > 0) {\n      throw new Error(\n        \"Cannot add 'NotActions' to policy statement if 'Actions' have been added\",\n      );\n    }\n    this.validatePolicyActions(notActions);\n    this._notAction.push(...notActions);\n  }\n\n  //\n  // Principal\n  //\n\n  /**\n   * Indicates if this permission has a \"Principal\" section.\n   */\n  public get hasPrincipal() {\n    return this._principals.length + this._notPrincipals.length > 0;\n  }\n\n  /**\n   * Adds principals to the \"Principal\" section of a policy statement.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html\n   *\n   * @param principals IAM principals that will be added\n   */\n  public addPrincipals(...principals: IPrincipal[]) {\n    this.assertNotFrozen(\"addPrincipals\");\n    if (principals.length > 0 && this._notPrincipals.length > 0) {\n      throw new Error(\n        \"Cannot add 'Principals' to policy statement if 'NotPrincipals' have been added\",\n      );\n    }\n    // TODO: AWSCDK only ensures Principal is not instanceof Group\n    // for (const principal of principals) {\n    //   this.validatePolicyPrincipal(principal);\n    // }\n\n    const added = this._principals.push(...principals);\n    for (const principal of added) {\n      const fragment = principal.policyFragment;\n      mergePrincipal(this._principal, fragment.principals);\n      this.addPrincipalConditions(...fragment.conditions);\n    }\n  }\n\n  /**\n   * Specify principals that is not allowed or denied access to the \"NotPrincipal\" section of\n   * a policy statement.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notprincipal.html\n   *\n   * @param notPrincipals IAM principals that will be denied access\n   */\n  public addNotPrincipals(...notPrincipals: IPrincipal[]) {\n    this.assertNotFrozen(\"addNotPrincipals\");\n    if (notPrincipals.length > 0 && this._principals.length > 0) {\n      throw new Error(\n        \"Cannot add 'NotPrincipals' to policy statement if 'Principals' have been added\",\n      );\n    }\n    // for (const notPrincipal of notPrincipals) {\n    //   this.validatePolicyPrincipal(notPrincipal);\n    // }\n\n    const added = this._notPrincipals.push(...notPrincipals);\n    for (const notPrincipal of added) {\n      const fragment = notPrincipal.policyFragment;\n      mergePrincipal(this._notPrincipal, fragment.principals);\n      this.addPrincipalConditions(...fragment.conditions);\n    }\n  }\n\n  private validatePolicyActions(actions: string[]) {\n    // In case of an unresolved list of actions return early\n    if (Token.isUnresolved(actions)) return;\n    for (const action of actions || []) {\n      if (\n        !Token.isUnresolved(action) &&\n        !/^(\\*|[a-zA-Z0-9-]+:[a-zA-Z0-9*]+)$/.test(action)\n      ) {\n        throw new Error(\n          `Action '${action}' is invalid. An action string consists of a service namespace, a colon, and the name of an action. Action names can include wildcards.`,\n        );\n      }\n    }\n  }\n\n  /**\n   * Specify AWS account ID as the principal entity to the \"Principal\" section of a policy statement.\n   */\n  public addAwsAccountPrincipal(accountId: string) {\n    this.addPrincipals(new AccountPrincipal(accountId));\n  }\n\n  /**\n   * Specify a principal using the ARN  identifier of the principal.\n   * You cannot specify IAM groups and instance profiles as principals.\n   *\n   * @param arn ARN identifier of AWS account, IAM user, or IAM role (i.e. arn:aws:iam::123456789012:user/user-name)\n   */\n  public addArnPrincipal(arn: string) {\n    this.addPrincipals(new ArnPrincipal(arn));\n  }\n\n  /**\n   * Adds a service principal to this policy statement.\n   *\n   * @param service the service name for which a service principal is requested (e.g: `s3.amazonaws.com`).\n   * @param opts    options for adding the service principal (such as specifying a principal in a different region)\n   */\n  public addServicePrincipal(service: string, opts?: ServicePrincipalOpts) {\n    this.addPrincipals(new ServicePrincipal(service, opts));\n  }\n\n  /**\n   * Adds a federated identity provider such as Amazon Cognito to this policy statement.\n   *\n   * @param federated federated identity provider (i.e. 'cognito-identity.amazonaws.com')\n   * @param conditions The conditions under which the policy is in effect.\n   *   See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).\n   */\n  public addFederatedPrincipal(federated: any, conditions: Conditions) {\n    this.addPrincipals(new FederatedPrincipal(federated, conditions));\n  }\n\n  /**\n   * Adds an AWS account root user principal to this policy statement\n   */\n  public addAccountRootPrincipal() {\n    this.addPrincipals(new AccountRootPrincipal());\n  }\n\n  /**\n   * Adds a canonical user ID principal to this policy document\n   *\n   * @param canonicalUserId unique identifier assigned by AWS for every account\n   */\n  public addCanonicalUserPrincipal(canonicalUserId: string) {\n    this.addPrincipals(new CanonicalUserPrincipal(canonicalUserId));\n  }\n\n  /**\n   * Adds all identities in all accounts (\"*\") to this policy statement\n   */\n  public addAnyPrincipal() {\n    this.addPrincipals(new AnyPrincipal());\n  }\n\n  //\n  // Resources\n  //\n\n  /**\n   * Specify resources that this policy statement applies into the \"Resource\" section of\n   * this policy statement.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html\n   *\n   * @param arns Amazon Resource Names (ARNs) of the resources that this policy statement applies to\n   */\n  public addResources(...arns: string[]) {\n    this.assertNotFrozen(\"addResources\");\n    if (arns.length > 0 && this._notResource.length > 0) {\n      throw new Error(\n        \"Cannot add 'Resources' to policy statement if 'NotResources' have been added\",\n      );\n    }\n    this._resource.push(...arns);\n  }\n\n  /**\n   * Specify resources that this policy statement will not apply to in the \"NotResource\" section\n   * of this policy statement. All resources except the specified list will be matched.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notresource.html\n   *\n   * @param arns Amazon Resource Names (ARNs) of the resources that this policy statement does not apply to\n   */\n  public addNotResources(...arns: string[]) {\n    this.assertNotFrozen(\"addNotResources\");\n    if (arns.length > 0 && this._resource.length > 0) {\n      throw new Error(\n        \"Cannot add 'NotResources' to policy statement if 'Resources' have been added\",\n      );\n    }\n    this._notResource.push(...arns);\n  }\n\n  /**\n   * Adds a ``\"*\"`` resource to this statement.\n   */\n  public addAllResources() {\n    this.addResources(\"*\");\n  }\n\n  /**\n   * Indicates if this permission has at least one resource associated with it.\n   */\n  public get hasResource() {\n    return this._resource && this._resource.length > 0;\n  }\n\n  //\n  // Condition\n  //\n\n  /**\n   * Add a condition to the Policy\n   *\n   * If multiple calls are made to add a condition with the same test and variable, only\n   * the last one wins. For example:\n   *\n   * ```ts\n   * declare const stmt: iam.PolicyStatement;\n   *\n   * stmt.addCondition({ test: 'StringEquals', variable: 'aws:SomeField', values: ['1'] });\n   * stmt.addCondition({ test: 'StringEquals', variable: 'aws:SomeField', values: ['2'] });\n   * ```\n   *\n   * Will end up with the single condition\n   *\n   * ```ts\n   * {\n   *   test: 'StringEquals',\n   *   variable: 'aws:SomeField',\n   *   values: ['2'],\n   * }\n   * ```.\n   *\n   * If you meant to add a condition to say that the field can be *either* `1` or `2`, write\n   * this:\n   *\n   * ```ts\n   * declare const stmt: iam.PolicyStatement;\n   *\n   * stmt.addCondition({ test: 'StringEquals', variable: 'aws:SomeField', values: ['1', '2'] });\n   * ```\n   */\n  public addCondition(condition: Condition) {\n    this.assertNotFrozen(\"addCondition\");\n\n    if (!this._conditionMap[condition.test]) {\n      this._conditionMap[condition.test] = {};\n    }\n\n    const existingCondition =\n      this._conditionMap[condition.test][condition.variable];\n    if (existingCondition) {\n      this._conditionMap[condition.test][condition.variable] = {\n        ...existingCondition,\n        ...condition,\n      };\n    } else {\n      this._conditionMap[condition.test][condition.variable] = condition;\n    }\n  }\n\n  /**\n   * Add a condition to the Policy\n   *\n   * If multiple calls are made to add a condition with the same operator and field, only\n   * the last one wins. For example:\n   *\n   * ```ts\n   * declare const stmt: iam.PolicyStatement;\n   *\n   * stmt.addCondition('StringEquals', { 'aws:SomeField': '1' });\n   * stmt.addCondition('StringEquals', { 'aws:SomeField': '2' });\n   * ```\n   *\n   * Will end up with the single condition `StringEquals: { 'aws:SomeField': '2' }`.\n   *\n   * If you meant to add a condition to say that the field can be *either* `1` or `2`, write\n   * this:\n   *\n   * ```ts\n   * declare const stmt: iam.PolicyStatement;\n   *\n   * stmt.addCondition('StringEquals', { 'aws:SomeField': ['1', '2'] });\n   * ```\n   */\n  public addConditionObject(key: string, value: unknown) {\n    this.assertNotFrozen(\"addCondition\");\n    validateConditionObject(value);\n    for (const [k, v] of Object.entries(value)) {\n      if (!isStringOrArrayOfStrings(v)) {\n        throw new Error(\n          `Fields must be either a string or an array of strings. Got ${v} for key ${k}`,\n        );\n      }\n      this.addCondition({\n        test: key,\n        variable: k,\n        values: Array.isArray(v) ? v : [v],\n      });\n    }\n  }\n\n  /**\n   * Add multiple conditions to the Policy\n   *\n   * See the `addCondition` function for a caveat on calling this method multiple times.\n   */\n  public addConditions(...conditions: Condition[]) {\n    conditions.map((c) => {\n      this.addCondition(c);\n    });\n  }\n\n  /**\n   * Add multiple conditionObjects to the Policy\n   *\n   * See the `addConditionObject` function for a caveat on calling this method multiple times.\n   */\n  public addConditionObjects(conditions: Record<string, unknown>) {\n    for (const [key, value] of Object.entries(conditions)) {\n      this.addConditionObject(key, value);\n    }\n  }\n\n  /**\n   * Add a `StringEquals` condition that limits to a given account from `sts:ExternalId`.\n   *\n   * This method can only be called once: subsequent calls will overwrite earlier calls.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html\n   */\n  public addAccountCondition(...accountIds: string[]) {\n    this.addCondition({\n      test: \"StringEquals\",\n      variable: \"sts:ExternalId\",\n      values: accountIds,\n    });\n  }\n\n  /**\n   * Add an `StringEquals` condition that limits to a given account from `aws:SourceAccount`.\n   *\n   * This method can only be called once: subsequent calls will overwrite earlier calls.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount\n   */\n  public addSourceAccountCondition(...accountIds: string[]) {\n    this.addCondition({\n      test: \"StringEquals\",\n      variable: \"aws:SourceAccount\",\n      values: accountIds,\n    });\n  }\n\n  /**\n   * Add an `ArnEquals` condition that limits to a given resource arn from `aws:SourceArn`.\n   *\n   * This method can only be called once: subsequent calls will overwrite earlier calls.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn\n   */\n  public addSourceArnCondition(...arns: string[]) {\n    this.addCondition({\n      test: \"ArnEquals\",\n      variable: \"aws:SourceArn\",\n      values: arns,\n    });\n  }\n\n  /**\n   * Create a new `PolicyStatement` with the same exact properties\n   * as this one, except for the overrides\n   */\n  public copy(overrides: PolicyStatementProps = {}) {\n    return new PolicyStatement({\n      sid: overrides.sid ?? this.sid,\n      effect: overrides.effect ?? this.effect,\n      actions: overrides.actions ?? this.actions,\n      notActions: overrides.notActions ?? this.notActions,\n\n      principals: overrides.principals ?? this.principals,\n      notPrincipals: overrides.notPrincipals ?? this.notPrincipals,\n\n      resources: overrides.resources ?? this.resources,\n      notResources: overrides.notResources ?? this.notResources,\n\n      condition: overrides.condition ?? this.conditions,\n    });\n  }\n\n  /**\n   * Get AWS IAM Policy statement JSON\n   */\n  public toStatementJson(): any {\n    return normalizeStatement({\n      Action: this._action.direct(),\n      NotAction: this._notAction.direct(),\n      Condition: toConditionJson(...toConditions(this._conditionMap)),\n      Effect: this.effect,\n      Principal: toPrincipalJson(...this._principal),\n      NotPrincipal: toPrincipalJson(...this._notPrincipal),\n      Resource: this._resource.direct(),\n      NotResource: this._notResource.direct(),\n      Sid: this.sid,\n    });\n  }\n\n  /**\n   * String representation of this policy statement\n   */\n  public toString() {\n    return Token.asString(this, {\n      displayHint: \"PolicyStatement\",\n    });\n  }\n\n  /**\n   * JSON-ify the statement\n   *\n   * Used when JSON.stringify() is called\n   */\n  public toJSON(): dataAwsIamPolicyDocument.DataAwsIamPolicyDocumentStatement {\n    const principals = this.principals.flatMap(\n      (p) => p.policyFragment.principals,\n    );\n    const notPrincipals = this.notPrincipals.flatMap(\n      (p) => p.policyFragment.principals,\n    );\n\n    return {\n      sid: this.sid,\n      actions: this.actions.length > 0 ? this.actions : undefined,\n      notActions: this.notActions.length > 0 ? this.notActions : undefined,\n      principals: principals.length > 0 ? principals : undefined,\n      notPrincipals: notPrincipals.length > 0 ? notPrincipals : undefined,\n      resources: this.resources.length > 0 ? this.resources : undefined,\n      notResources:\n        this.notResources.length > 0 ? this.notResources : undefined,\n      condition: this.conditions.length > 0 ? this.conditions : undefined,\n      effect: this.effect,\n    };\n  }\n\n  /**\n   * Add a principal's conditions\n   *\n   * For convenience, principals have been modeled as both a principal\n   * and a set of conditions. This makes it possible to have a single\n   * object represent e.g. an \"SNS Topic\" (SNS service principal + aws:SourcArn\n   * condition) or an Organization member (* + aws:OrgId condition).\n   *\n   * However, when using multiple principals in the same policy statement,\n   * they must all have the same conditions or the OR samentics\n   * implied by a list of principals cannot be guaranteed (user needs to\n   * add multiple statements in that case).\n   */\n  private addPrincipalConditions(\n    ...conditions: dataAwsIamPolicyDocument.DataAwsIamPolicyDocumentStatementCondition[]\n  ) {\n    // Stringifying the conditions is an easy way to do deep equality\n    const theseConditions = JSON.stringify(conditions);\n    if (this.principalConditionsJson === undefined) {\n      // First principal, anything goes\n      this.principalConditionsJson = theseConditions;\n    } else {\n      if (this.principalConditionsJson !== theseConditions) {\n        throw new Error(\n          `All principals in a PolicyStatement must have the same Conditions (got '${this.principalConditionsJson}' and '${theseConditions}'). Use multiple statements instead.`,\n        );\n      }\n    }\n    this.addConditions(...conditions);\n  }\n\n  /**\n   * Validate that the policy statement satisfies base requirements for a policy.\n   *\n   * @returns An array of validation error messages, or an empty array if the statement is valid.\n   */\n  public validateForAnyPolicy(): string[] {\n    const errors = new Array<string>();\n    if (this._action.length === 0 && this._notAction.length === 0) {\n      errors.push(\n        \"A PolicyStatement must specify at least one 'action' or 'notAction'.\",\n      );\n    }\n    return errors;\n  }\n\n  /**\n   * Validate that the policy statement satisfies all requirements for a resource-based policy.\n   *\n   * @returns An array of validation error messages, or an empty array if the statement is valid.\n   */\n  public validateForResourcePolicy(): string[] {\n    const errors = this.validateForAnyPolicy();\n    if (this._principals.length === 0 && this._notPrincipals.length === 0) {\n      errors.push(\n        \"A PolicyStatement used in a resource-based policy must specify at least one IAM principal.\",\n      );\n    }\n    return errors;\n  }\n\n  /**\n   * Validate that the policy statement satisfies all requirements for an identity-based policy.\n   *\n   * @returns An array of validation error messages, or an empty array if the statement is valid.\n   */\n  public validateForIdentityPolicy(): string[] {\n    const errors = this.validateForAnyPolicy();\n    if (this._principals.length > 0 || this._notPrincipals.length > 0) {\n      errors.push(\n        \"A PolicyStatement used in an identity-based policy cannot specify any IAM principals.\",\n      );\n    }\n    if (this._resource.length === 0 && this._notResource.length === 0) {\n      errors.push(\n        \"A PolicyStatement used in an identity-based policy must specify at least one resource.\",\n      );\n    }\n    return errors;\n  }\n\n  /**\n   * The Actions added to this statement\n   */\n  public get actions() {\n    return this._action.copy();\n  }\n\n  /**\n   * The NotActions added to this statement\n   */\n  public get notActions() {\n    return this._notAction.copy();\n  }\n\n  /**\n   * The Principals added to this statement\n   */\n  public get principals(): IPrincipal[] {\n    return this._principals.copy();\n  }\n\n  /**\n   * The NotPrincipals added to this statement\n   */\n  public get notPrincipals(): IPrincipal[] {\n    return this._notPrincipals.copy();\n  }\n\n  /**\n   * The Resources added to this statement\n   */\n  public get resources() {\n    return this._resource.copy();\n  }\n\n  /**\n   * The NotResources added to this statement\n   */\n  public get notResources() {\n    return this._notResource.copy();\n  }\n\n  /**\n   * The conditions added to this statement\n   */\n  public get conditions(): Conditions {\n    return toConditions(this._conditionMap);\n  }\n\n  /**\n   * Make the PolicyStatement immutable\n   *\n   * After calling this, any of the `addXxx()` methods will throw an exception.\n   *\n   * Libraries that lazily generate statement bodies can override this method to\n   * fill the actual PolicyStatement fields. Be aware that this method may be called\n   * multiple times.\n   */\n  public freeze(): PolicyStatement {\n    this._frozen = true;\n    return this;\n  }\n\n  /**\n   * Whether the PolicyStatement has been frozen\n   *\n   * The statement object is frozen when `freeze()` is called.\n   */\n  public get frozen(): boolean {\n    return this._frozen;\n  }\n\n  /**\n   * Estimate the size of this policy statement\n   *\n   * By necessity, this will not be accurate. We'll do our best to overestimate\n   * so we won't have nasty surprises.\n   *\n   * @internal\n   */\n  public _estimateSize(options: EstimateSizeOptions): number {\n    let ret = 0;\n\n    const { actionEstimate, arnEstimate } = options;\n\n    ret += `\"Effect\": \"${this.effect}\",`.length;\n\n    count(\"Action\", this.actions, actionEstimate);\n    count(\"NotAction\", this.notActions, actionEstimate);\n    count(\"Resource\", this.resources, arnEstimate);\n    count(\"NotResource\", this.notResources, arnEstimate);\n\n    ret += this.principals.length * arnEstimate;\n    ret += this.notPrincipals.length * arnEstimate;\n\n    ret += JSON.stringify(toConditionJson(...this.conditions)).length;\n    return ret;\n\n    function count(key: string, values: string[], tokenSize: number) {\n      if (values.length > 0) {\n        ret +=\n          key.length +\n          5 /* quotes, colon, brackets */ +\n          sum(\n            values.map(\n              (v) =>\n                (Token.isUnresolved(v) ? tokenSize : v.length) +\n                3 /* quotes, separator */,\n            ),\n          );\n      }\n    }\n  }\n\n  /**\n   * Throw an exception when the object is frozen\n   */\n  private assertNotFrozen(method: string) {\n    if (this._frozen) {\n      throw new Error(\n        `${method}: freeze() has been called on this PolicyStatement previously, so it can no longer be modified`,\n      );\n    }\n  }\n}\n\n/**\n * The Effect element of an IAM policy\n *\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_effect.html\n */\nexport enum Effect {\n  /**\n   * Allows access to a resource in an IAM policy statement. By default, access to resources are denied.\n   */\n  ALLOW = \"Allow\",\n\n  /**\n   * Explicitly deny access to a resource. By default, all requests are denied implicitly.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html\n   */\n  DENY = \"Deny\",\n}\n\n/**\n * Condition for when an IAM policy is in effect. Maps from the keys in a request's context to\n * a string value or array of string values. See the Conditions interface for more details.\n */\nexport type Condition =\n  dataAwsIamPolicyDocument.DataAwsIamPolicyDocumentStatementCondition;\n\n/**\n * Conditions for when an IAM Policy is in effect, specified in the following structure:\n *\n * `{ \"Operator\": { \"keyInRequestContext\": \"value\" } }`\n *\n * The value can be either a single string value or an array of string values.\n *\n * For more information, including which operators are supported, see [the IAM\n * documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).\n */\nexport type Conditions = Array<Condition>;\n// TODO: Support IResolvable Condition?\n\nclass JsonPrincipal extends PrincipalBase {\n  public readonly policyFragment: PrincipalPolicyFragment;\n  public readonly principals: PrincipalProps[] = [];\n\n  constructor(json: any = {}) {\n    super();\n    this.policyFragment = PrincipalPolicyFragment.fromJson(json);\n  }\n\n  public dedupeString(): string | undefined {\n    return JSON.stringify(this.policyFragment);\n  }\n}\n\n/**\n * Options for _estimateSize\n *\n * These can optionally come from context, but it's too expensive to look\n * them up every time so we bundle them into a struct first.\n *\n * @internal\n */\nexport interface EstimateSizeOptions {\n  /**\n   * Estimated size of an unresolved ARN\n   */\n  readonly arnEstimate: number;\n\n  /**\n   * Estimated size of an unresolved action\n   */\n  readonly actionEstimate: number;\n}\n\n/**\n * Derive the size estimation options from context\n *\n * @internal\n */\nexport function deriveEstimateSizeOptions(\n  _scope: IConstruct,\n): EstimateSizeOptions {\n  const actionEstimate = 20;\n  const arnEstimate = DEFAULT_ARN_SIZE_ESTIMATE;\n  return { actionEstimate, arnEstimate };\n}\n\n/**\n * A class that behaves both as a set and an array\n *\n * Used for the elements of a PolicyStatement. In practice they behave as sets,\n * but we have thousands of snapshot tests in existence that will rely on a\n * particular order so we can't just change the type to `Set<>` wholesale without\n * causing a lot of churn.\n */\nclass OrderedSet<A> {\n  private readonly set = new Set<A>();\n  private readonly array = new Array<A>();\n\n  /**\n   * Add new elements to the set\n   *\n   * @param xs the elements to be added\n   *\n   * @returns the elements actually added\n   */\n  public push(...xs: readonly A[]): A[] {\n    const ret = new Array<A>();\n    for (const x of xs) {\n      if (this.set.has(x)) {\n        continue;\n      }\n      this.set.add(x);\n      this.array.push(x);\n      ret.push(x);\n    }\n    return ret;\n  }\n\n  public get length() {\n    return this.array.length;\n  }\n\n  public copy(): A[] {\n    return [...this.array];\n  }\n\n  /**\n   * Direct (read-only) access to the underlying array\n   *\n   * (Saves a copy)\n   */\n  public direct(): readonly A[] {\n    return this.array;\n  }\n}\n\nfunction sum(xs: number[]) {\n  return xs.reduce((a, b) => a + b, 0);\n}\n\n// ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-iam/lib/private\n\n// An IAM value is a string or an intrinsic value\nexport type IamValue =\n  | string\n  | Record<string, any>\n  | Array<string | Record<string, any>>;\n\ninterface StatementSchema {\n  readonly Sid?: string;\n  readonly Effect?: string;\n  readonly Principal?: string | string[] | Record<string, IamValue>;\n  readonly NotPrincipal?: string | string[] | Record<string, IamValue>;\n  readonly Resource?: IamValue;\n  readonly NotResource?: IamValue;\n  readonly Action?: IamValue;\n  readonly NotAction?: IamValue;\n  readonly Condition?: unknown;\n}\n\nfunction normalizeStatement(s: StatementSchema) {\n  return noUndef({\n    Action: _norm(s.Action, { unique: true }),\n    NotAction: _norm(s.NotAction, { unique: true }),\n    Condition: _norm(s.Condition),\n    Effect: _norm(s.Effect),\n    Principal: _normPrincipal(s.Principal),\n    NotPrincipal: _normPrincipal(s.NotPrincipal),\n    Resource: _norm(s.Resource, { unique: true }),\n    NotResource: _norm(s.NotResource, { unique: true }),\n    Sid: _norm(s.Sid),\n  });\n\n  function _norm(\n    values: any,\n    { unique = false }: { unique: boolean } = { unique: false },\n  ) {\n    if (values == null) {\n      return undefined;\n    }\n\n    if (Token.isUnresolved(values)) {\n      return values;\n    }\n\n    if (Array.isArray(values)) {\n      if (!values || values.length === 0) {\n        return undefined;\n      }\n\n      if (values.length === 1) {\n        return values[0];\n      }\n\n      return unique ? Array.from(new Set(values)) : values;\n    }\n\n    if (values && typeof values === \"object\") {\n      if (Object.keys(values).length === 0) {\n        return undefined;\n      }\n    }\n\n    return values;\n  }\n\n  function _normPrincipal(\n    principal?: string | string[] | { [key: string]: any },\n  ) {\n    if (!principal) {\n      return undefined;\n    }\n    if (typeof principal === \"string\") {\n      return principal;\n    }\n    if (Array.isArray(principal) || typeof principal !== \"object\") {\n      return undefined;\n    }\n    const keys = Object.keys(principal);\n    if (keys.length === 0) {\n      return undefined;\n    }\n\n    const result: any = {};\n    for (const key of keys) {\n      const normVal = _norm(principal[key]);\n      if (normVal) {\n        result[key] = normVal;\n      }\n    }\n    return result;\n  }\n}\n\nfunction noUndef(x: any): any {\n  const ret: any = {};\n  for (const [key, value] of Object.entries(x)) {\n    if (value !== undefined) {\n      ret[key] = value;\n    }\n  }\n  return ret;\n}\n\nfunction ensureArrayOrUndefined(field: any) {\n  if (field === undefined) {\n    return undefined;\n  }\n  if (typeof field !== \"string\" && !Array.isArray(field)) {\n    throw new Error(\"Fields must be either a string or an array of strings\");\n  }\n  if (Array.isArray(field) && !!field.find((f: any) => typeof f !== \"string\")) {\n    throw new Error(\"Fields must be either a string or an array of strings\");\n  }\n  return Array.isArray(field) ? field : [field];\n}\n\nexport function isStringOrArrayOfStrings(\n  value: unknown,\n): value is string | string[] {\n  if (typeof value === \"string\") {\n    return true;\n  }\n  if (Array.isArray(value) && value.every((item) => typeof item === \"string\")) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Convert a condition JSON object to a list of Terraform AWS Policy Statement Conditions\n *\n * JSON object is specified in the following structure:\n *\n * `{ \"Operator\": { \"keyInRequestContext\": \"value\" } }`\n *\n * The value can be either a single string value or an array of string values.\n *\n * For more information, including which operators are supported, see [the IAM\n * documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).\n * @param conditionJson The condition JSON object\n * @returns The list of Terraform condition objects\n */\nexport function fromConditionJson(\n  conditionJson: Record<string, unknown> | undefined,\n): Conditions | undefined {\n  if (!conditionJson) {\n    return undefined;\n  }\n  const result = new Array<Condition>();\n\n  for (const [test, variables] of Object.entries(conditionJson)) {\n    if (Array.isArray(variables)) {\n      throw new Error(\n        `Invalid event pattern field { ${test}: ${JSON.stringify(\n          variables,\n        )} }. All fields must be objects`,\n      );\n    }\n    for (const [variable, value] of Object.entries(variables as any)) {\n      result.push({\n        test,\n        variable,\n        values: Array.isArray(value) ? value : [value],\n      });\n    }\n  }\n\n  return result;\n}\n\n/**\n * flatten Conditions mapped by test and variable to an array of Terraform AWS Policy Statement Conditions\n * @param conditionMap The condition map\n * @returns The list of Terraform condition objects\n */\nexport function toConditions(conditionMap: ConditionMap): Conditions {\n  return Object.values(conditionMap).flatMap((variables) =>\n    Object.values(variables),\n  );\n  // const conditions: Conditions = [];\n  // for (const variablesMap of Object.values(conditionMap)) {\n  //   for (const condition of Object.values(variablesMap)) {\n  //     conditions.push(condition);\n  //   }\n  // }\n  // return conditions;\n}\n\n/**\n * Convert a list of Terraform AWS Policy Statement condition objects back to a condition JSON object\n * @param conditions The list of Terraform condition objects\n * @returns The condition JSON object\n */\nexport function toConditionJson(\n  ...conditions: Conditions\n): Record<string, any> {\n  const conditionJson: Record<string, any> = {};\n\n  for (const condition of conditions) {\n    const { test, variable, values } = condition;\n\n    if (!conditionJson[test]) {\n      conditionJson[test] = {};\n    }\n\n    if (values.length === 1) {\n      conditionJson[test][variable] = values[0];\n    } else {\n      conditionJson[test][variable] = values;\n    }\n  }\n\n  return conditionJson;\n}\n\n/**\n * Validate that the given value is a valid Json Condition object\n *\n * AWS CDK IAM library relies on being able to pass in a `Json` instance for\n * a `Condition`.\n */\nexport function validateConditionObject(\n  x: unknown,\n): asserts x is Record<string, unknown> {\n  if (!x || typeof x !== \"object\" || Array.isArray(x)) {\n    throw new Error(\n      \"A Condition should be represented as a map of operator to value\",\n    );\n  }\n}\n"]}