terraconstructs 0.0.8

package/lib/aws/iam/private/merge-statements.js

@@ -0,0 +1,214 @@
+"use strict";
+// IAM Statement merging
+// copied from https://github.com/aws/aws-cdk/blob/v2.161.1/packages/aws-cdk-lib/aws-iam/lib/private/merge-statements.ts
+//
+// See https://github.com/aws/aws-cdk/blob/v2.161.1/packages/aws-cdk-lib/aws-iam/docs/policy-merging.als
+// for a formal model of the logic implemented here.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeStatements = void 0;
+const comparable_principal_1 = require("./comparable-principal");
+const policy_statement_1 = require("../policy-statement");
+// import { LITERAL_STRING_KEY } from "../util";
+/*
+ * Don't produce any merged statements larger than this.
+ *
+ * They will become impossible to divide across managed policies if we do,
+ * and this is the maximum size for User policies.
+ */
+const MAX_MERGE_SIZE = 2000;
+/**
+ * Merge as many statements as possible to shrink the total policy doc, modifying the input array in place
+ *
+ * We compare and merge all pairs of statements (O(N^2) complexity), opportunistically
+ * merging them. This is not guaranteed to produce the optimal output, but it's probably
+ * Good Enough(tm). If it merges anything, it's at least going to produce a smaller output
+ * than the input.
+ */
+function mergeStatements(statements, options) {
+    const sizeOptions = (0, policy_statement_1.deriveEstimateSizeOptions)(options.scope);
+    const compStatements = statements.map(makeComparable);
+    const mergeFn = (options?.mergeIfCombinable ?? true) ? mergeIfCombinable : mergeIfEqual;
+    // Keep trying until nothing changes anymore
+    while (onePass()) {
+        /* again */
+    }
+    const mergedStatements = new Array();
+    const originsMap = new Map();
+    for (const comp of compStatements) {
+        const statement = renderComparable(comp);
+        mergedStatements.push(statement);
+        originsMap.set(statement, comp.originals);
+    }
+    return { mergedStatements, originsMap };
+    // Do one optimization pass, return 'true' if we merged anything
+    function onePass() {
+        let ret = false;
+        for (let i = 0; i < compStatements.length; i++) {
+            let j = i + 1;
+            while (j < compStatements.length) {
+                const merged = mergeFn(compStatements[i], compStatements[j], !!options.limitSize, sizeOptions);
+                if (merged) {
+                    compStatements[i] = merged;
+                    compStatements.splice(j, 1);
+                    ret = true;
+                }
+                else {
+                    j++;
+                }
+            }
+        }
+        return ret;
+    }
+}
+exports.mergeStatements = mergeStatements;
+/**
+ * Given two statements, return their merging (if possible)
+ *
+ * We can merge two statements if:
+ *
+ * - Their effects are the same
+ * - They don't have Sids (not really a hard requirement, but just a simplification and an escape hatch)
+ * - Their Conditions are the same
+ * - Their NotAction, NotResource and NotPrincipal sets are the same (empty sets is fine).
+ * - From their Action, Resource and Principal sets, 2 are subsets of each other
+ *   (empty sets are fine).
+ */
+function mergeIfCombinable(a, b, limitSize, options) {
+    // Effects must be the same
+    if (a.statement.effect !== b.statement.effect) {
+        return;
+    }
+    // We don't merge Sids (for now)
+    if (a.statement.sid || b.statement.sid) {
+        return;
+    }
+    if (a.conditionString !== b.conditionString) {
+        return;
+    }
+    if (!setEqual(a.statement.notActions, b.statement.notActions) ||
+        !setEqual(a.statement.notResources, b.statement.notResources) ||
+        !setEqualPrincipals(a.statement.notPrincipals, b.statement.notPrincipals)) {
+        return;
+    }
+    // We can merge these statements if 2 out of the 3 sets of Action, Resource, Principal
+    // are the same.
+    const setsEqual = (setEqual(a.statement.actions, b.statement.actions) ? 1 : 0) +
+        (setEqual(a.statement.resources, b.statement.resources) ? 1 : 0) +
+        (setEqualPrincipals(a.statement.principals, b.statement.principals)
+            ? 1
+            : 0);
+    if (setsEqual < 2 || unmergeablePrincipals(a, b)) {
+        return;
+    }
+    const combined = a.statement.copy({
+        actions: setMerge(a.statement.actions, b.statement.actions),
+        resources: setMerge(a.statement.resources, b.statement.resources),
+        principals: setMergePrincipals(a.statement.principals, b.statement.principals),
+    });
+    if (limitSize && combined._estimateSize(options) > MAX_MERGE_SIZE) {
+        return undefined;
+    }
+    return {
+        originals: [...a.originals, ...b.originals],
+        statement: combined,
+        conditionString: a.conditionString,
+    };
+}
+/**
+ * We merge two statements only if they are exactly the same
+ */
+function mergeIfEqual(a, b) {
+    if (a.statement.effect !== b.statement.effect) {
+        return;
+    }
+    if (a.statement.sid !== b.statement.sid) {
+        return;
+    }
+    if (a.conditionString !== b.conditionString) {
+        return;
+    }
+    if (!setEqual(a.statement.notActions, b.statement.notActions) ||
+        !setEqual(a.statement.notResources, b.statement.notResources) ||
+        !setEqualPrincipals(a.statement.notPrincipals, b.statement.notPrincipals)) {
+        return;
+    }
+    if (!setEqual(a.statement.actions, b.statement.actions) ||
+        !setEqual(a.statement.resources, b.statement.resources) ||
+        !setEqualPrincipals(a.statement.principals, b.statement.principals)) {
+        return;
+    }
+    return {
+        originals: [...a.originals, ...b.originals],
+        statement: a.statement,
+        conditionString: a.conditionString,
+    };
+}
+/**
+ * Calculate and return cached string set representation of the statement elements
+ *
+ * This is to be able to do comparisons on these sets quickly.
+ */
+function makeComparable(s) {
+    return {
+        originals: [s],
+        statement: s,
+        ...(s.conditions
+            ? {
+                conditionString: JSON.stringify((0, policy_statement_1.toConditionJson)(...s.conditions)),
+            }
+            : {}),
+    };
+}
+/**
+ * Return 'true' if the two principals are unmergeable
+ *
+ * This only happens if one of them is a literal, untyped principal (typically,
+ * `Principal: '*'`) and the other one is typed.
+ *
+ * `Principal: '*'` behaves subtly different than `Principal: { AWS: '*' }` and must
+ * therefore be preserved.
+ */
+function unmergeablePrincipals(a, b) {
+    const aHasStarPrincipal = a.statement.principals.some((v) => typeof v.policyFragment.principalJson === "string" &&
+        v.policyFragment.principalJson == "*");
+    const bHasLiteral = b.statement.principals.some((v) => typeof v.policyFragment.principalJson === "string" &&
+        v.policyFragment.principalJson == "*");
+    return aHasStarPrincipal !== bHasLiteral;
+}
+/**
+ * Turn a ComparableStatement back into a Statement
+ */
+function renderComparable(s) {
+    return s.statement;
+}
+/**
+ * Whether the given sets are equal
+ */
+function setEqual(a, b) {
+    const bSet = new Set(b);
+    return a.length === b.length && a.every((k) => bSet.has(k));
+}
+/**
+ * Merge two value sets
+ */
+function setMerge(x, y) {
+    return Array.from(new Set([...x, ...y])).sort();
+}
+function setEqualPrincipals(xs, ys) {
+    const xPrincipals = (0, comparable_principal_1.partitionPrincipals)(xs);
+    const yPrincipals = (0, comparable_principal_1.partitionPrincipals)(ys);
+    const nonComp = setEqual(xPrincipals.nonComparable, yPrincipals.nonComparable);
+    const comp = setEqual(Object.keys(xPrincipals.comparable), Object.keys(yPrincipals.comparable));
+    return nonComp && comp;
+}
+function setMergePrincipals(xs, ys) {
+    const xPrincipals = (0, comparable_principal_1.partitionPrincipals)(xs);
+    const yPrincipals = (0, comparable_principal_1.partitionPrincipals)(ys);
+    const comparable = { ...xPrincipals.comparable, ...yPrincipals.comparable };
+    return [
+        ...Object.values(comparable),
+        ...xPrincipals.nonComparable,
+        ...yPrincipals.nonComparable,
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merge-statements.js","sourceRoot":"","sources":["../../../../src/aws/iam/private/merge-statements.ts"],"names":[],"mappings":"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","sourcesContent":["// IAM Statement merging\n// copied from https://github.com/aws/aws-cdk/blob/v2.161.1/packages/aws-cdk-lib/aws-iam/lib/private/merge-statements.ts\n//\n// See https://github.com/aws/aws-cdk/blob/v2.161.1/packages/aws-cdk-lib/aws-iam/docs/policy-merging.als\n// for a formal model of the logic implemented here.\n\nimport { IConstruct } from \"constructs\";\nimport { partitionPrincipals } from \"./comparable-principal\";\nimport {\n  PolicyStatement,\n  EstimateSizeOptions,\n  deriveEstimateSizeOptions,\n  toConditionJson,\n} from \"../policy-statement\";\nimport { IPrincipal } from \"../principals\";\n// import { LITERAL_STRING_KEY } from \"../util\";\n\n/*\n * Don't produce any merged statements larger than this.\n *\n * They will become impossible to divide across managed policies if we do,\n * and this is the maximum size for User policies.\n */\nconst MAX_MERGE_SIZE = 2000;\n\n/**\n * Options for the mergeStatement command\n */\nexport interface MergeStatementOptions {\n  /**\n   * Scope to derive configuration flags from\n   */\n  readonly scope: IConstruct;\n\n  /**\n   * Do not merge statements if the result would be bigger than MAX_MERGE_SIZE\n   *\n   * @default false\n   */\n  readonly limitSize?: boolean;\n\n  /**\n   * Merge statements if they can be combined to produce the same effects.\n   *\n   * If false, statements are only merged if they are exactly equal.\n   *\n   * @default true\n   */\n  readonly mergeIfCombinable?: boolean;\n}\n\n/**\n * Merge as many statements as possible to shrink the total policy doc, modifying the input array in place\n *\n * We compare and merge all pairs of statements (O(N^2) complexity), opportunistically\n * merging them. This is not guaranteed to produce the optimal output, but it's probably\n * Good Enough(tm). If it merges anything, it's at least going to produce a smaller output\n * than the input.\n */\nexport function mergeStatements(\n  statements: PolicyStatement[],\n  options: MergeStatementOptions,\n): MergeStatementResult {\n  const sizeOptions = deriveEstimateSizeOptions(options.scope);\n  const compStatements = statements.map(makeComparable);\n  const mergeFn =\n    (options?.mergeIfCombinable ?? true) ? mergeIfCombinable : mergeIfEqual;\n\n  // Keep trying until nothing changes anymore\n  while (onePass()) {\n    /* again */\n  }\n\n  const mergedStatements = new Array<PolicyStatement>();\n  const originsMap = new Map<PolicyStatement, PolicyStatement[]>();\n  for (const comp of compStatements) {\n    const statement = renderComparable(comp);\n    mergedStatements.push(statement);\n    originsMap.set(statement, comp.originals);\n  }\n\n  return { mergedStatements, originsMap };\n\n  // Do one optimization pass, return 'true' if we merged anything\n  function onePass() {\n    let ret = false;\n\n    for (let i = 0; i < compStatements.length; i++) {\n      let j = i + 1;\n      while (j < compStatements.length) {\n        const merged = mergeFn(\n          compStatements[i],\n          compStatements[j],\n          !!options.limitSize,\n          sizeOptions,\n        );\n\n        if (merged) {\n          compStatements[i] = merged;\n          compStatements.splice(j, 1);\n          ret = true;\n        } else {\n          j++;\n        }\n      }\n    }\n\n    return ret;\n  }\n}\n\nexport interface MergeStatementResult {\n  /**\n   * The list of maximally merged statements\n   */\n  readonly mergedStatements: PolicyStatement[];\n\n  /**\n   * Mapping of old to new statements\n   */\n  readonly originsMap: Map<PolicyStatement, PolicyStatement[]>;\n}\n\n/**\n * Given two statements, return their merging (if possible)\n *\n * We can merge two statements if:\n *\n * - Their effects are the same\n * - They don't have Sids (not really a hard requirement, but just a simplification and an escape hatch)\n * - Their Conditions are the same\n * - Their NotAction, NotResource and NotPrincipal sets are the same (empty sets is fine).\n * - From their Action, Resource and Principal sets, 2 are subsets of each other\n *   (empty sets are fine).\n */\nfunction mergeIfCombinable(\n  a: ComparableStatement,\n  b: ComparableStatement,\n  limitSize: boolean,\n  options: EstimateSizeOptions,\n): ComparableStatement | undefined {\n  // Effects must be the same\n  if (a.statement.effect !== b.statement.effect) {\n    return;\n  }\n  // We don't merge Sids (for now)\n  if (a.statement.sid || b.statement.sid) {\n    return;\n  }\n\n  if (a.conditionString !== b.conditionString) {\n    return;\n  }\n  if (\n    !setEqual(a.statement.notActions, b.statement.notActions) ||\n    !setEqual(a.statement.notResources, b.statement.notResources) ||\n    !setEqualPrincipals(a.statement.notPrincipals, b.statement.notPrincipals)\n  ) {\n    return;\n  }\n\n  // We can merge these statements if 2 out of the 3 sets of Action, Resource, Principal\n  // are the same.\n  const setsEqual =\n    (setEqual(a.statement.actions, b.statement.actions) ? 1 : 0) +\n    (setEqual(a.statement.resources, b.statement.resources) ? 1 : 0) +\n    (setEqualPrincipals(a.statement.principals, b.statement.principals)\n      ? 1\n      : 0);\n\n  if (setsEqual < 2 || unmergeablePrincipals(a, b)) {\n    return;\n  }\n\n  const combined = a.statement.copy({\n    actions: setMerge(a.statement.actions, b.statement.actions),\n    resources: setMerge(a.statement.resources, b.statement.resources),\n    principals: setMergePrincipals(\n      a.statement.principals,\n      b.statement.principals,\n    ),\n  });\n\n  if (limitSize && combined._estimateSize(options) > MAX_MERGE_SIZE) {\n    return undefined;\n  }\n\n  return {\n    originals: [...a.originals, ...b.originals],\n    statement: combined,\n    conditionString: a.conditionString,\n  };\n}\n\n/**\n * We merge two statements only if they are exactly the same\n */\nfunction mergeIfEqual(\n  a: ComparableStatement,\n  b: ComparableStatement,\n): ComparableStatement | undefined {\n  if (a.statement.effect !== b.statement.effect) {\n    return;\n  }\n  if (a.statement.sid !== b.statement.sid) {\n    return;\n  }\n  if (a.conditionString !== b.conditionString) {\n    return;\n  }\n  if (\n    !setEqual(a.statement.notActions, b.statement.notActions) ||\n    !setEqual(a.statement.notResources, b.statement.notResources) ||\n    !setEqualPrincipals(a.statement.notPrincipals, b.statement.notPrincipals)\n  ) {\n    return;\n  }\n  if (\n    !setEqual(a.statement.actions, b.statement.actions) ||\n    !setEqual(a.statement.resources, b.statement.resources) ||\n    !setEqualPrincipals(a.statement.principals, b.statement.principals)\n  ) {\n    return;\n  }\n\n  return {\n    originals: [...a.originals, ...b.originals],\n    statement: a.statement,\n    conditionString: a.conditionString,\n  };\n}\n\n/**\n * Calculate and return cached string set representation of the statement elements\n *\n * This is to be able to do comparisons on these sets quickly.\n */\nfunction makeComparable(s: PolicyStatement): ComparableStatement {\n  return {\n    originals: [s],\n    statement: s,\n    ...(s.conditions\n      ? {\n          conditionString: JSON.stringify(toConditionJson(...s.conditions)),\n        }\n      : {}),\n  };\n}\n\n/**\n * Return 'true' if the two principals are unmergeable\n *\n * This only happens if one of them is a literal, untyped principal (typically,\n * `Principal: '*'`) and the other one is typed.\n *\n * `Principal: '*'` behaves subtly different than `Principal: { AWS: '*' }` and must\n * therefore be preserved.\n */\nfunction unmergeablePrincipals(a: ComparableStatement, b: ComparableStatement) {\n  const aHasStarPrincipal = a.statement.principals.some(\n    (v) =>\n      typeof v.policyFragment.principalJson === \"string\" &&\n      v.policyFragment.principalJson == \"*\",\n  );\n  const bHasLiteral = b.statement.principals.some(\n    (v) =>\n      typeof v.policyFragment.principalJson === \"string\" &&\n      v.policyFragment.principalJson == \"*\",\n  );\n  return aHasStarPrincipal !== bHasLiteral;\n}\n\n/**\n * Turn a ComparableStatement back into a Statement\n */\nfunction renderComparable(s: ComparableStatement): PolicyStatement {\n  return s.statement;\n}\n\n/**\n * An analyzed version of a statement that makes it easier to do comparisons and merging on\n */\ninterface ComparableStatement {\n  readonly statement: PolicyStatement;\n  readonly originals: PolicyStatement[];\n  readonly conditionString?: string;\n}\n\n/**\n * Whether the given sets are equal\n */\nfunction setEqual<A>(a: A[], b: A[]) {\n  const bSet = new Set(b);\n  return a.length === b.length && a.every((k) => bSet.has(k));\n}\n\n/**\n * Merge two value sets\n */\nfunction setMerge<A>(x: A[], y: A[]): A[] {\n  return Array.from(new Set([...x, ...y])).sort();\n}\n\nfunction setEqualPrincipals(xs: IPrincipal[], ys: IPrincipal[]): boolean {\n  const xPrincipals = partitionPrincipals(xs);\n  const yPrincipals = partitionPrincipals(ys);\n\n  const nonComp = setEqual(\n    xPrincipals.nonComparable,\n    yPrincipals.nonComparable,\n  );\n  const comp = setEqual(\n    Object.keys(xPrincipals.comparable),\n    Object.keys(yPrincipals.comparable),\n  );\n\n  return nonComp && comp;\n}\n\nfunction setMergePrincipals(xs: IPrincipal[], ys: IPrincipal[]): IPrincipal[] {\n  const xPrincipals = partitionPrincipals(xs);\n  const yPrincipals = partitionPrincipals(ys);\n\n  const comparable = { ...xPrincipals.comparable, ...yPrincipals.comparable };\n  return [\n    ...Object.values(comparable),\n    ...xPrincipals.nonComparable,\n    ...yPrincipals.nonComparable,\n  ];\n}\n"]}

package/lib/aws/iam/private/postprocess-policy-document.d.ts

@@ -0,0 +1,15 @@
+import { IPostProcessor, IResolveContext } from "cdktf";
+/**
+ * A Token postprocesser for policy documents
+ *
+ * Removes duplicate statements, and assign Sids if necessary
+ *
+ * Because policy documents can contain all kinds of crazy things,
+ * we do all the necessary work here after the document has been mostly resolved
+ * into a predictable Terraform form.
+ */
+export declare class PostProcessPolicyDocument implements IPostProcessor {
+    private readonly autoAssignSids;
+    constructor(autoAssignSids: boolean);
+    postProcess(input: any, _context: IResolveContext): any;
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostProcessPolicyDocument = void 0;
+/**
+ * A Token postprocesser for policy documents
+ *
+ * Removes duplicate statements, and assign Sids if necessary
+ *
+ * Because policy documents can contain all kinds of crazy things,
+ * we do all the necessary work here after the document has been mostly resolved
+ * into a predictable Terraform form.
+ */
+class PostProcessPolicyDocument {
+    constructor(autoAssignSids) {
+        this.autoAssignSids = autoAssignSids;
+    }
+    // this is called with an array of statements
+    postProcess(input, _context) {
+        if (!input || !Array.isArray(input)) {
+            return input;
+        }
+        // Also remove full-on duplicates (this will not be necessary if
+        // we minimized, but it might still dedupe statements we didn't
+        // minimize like if they contained tokens, and definitely is still necessary
+        // if we didn't minimize)
+        const jsonStatements = new Set();
+        const uniqueStatements = [];
+        for (const statement of input) {
+            const jsonStatement = JSON.stringify(statement);
+            if (!jsonStatements.has(jsonStatement)) {
+                uniqueStatements.push(statement);
+                jsonStatements.add(jsonStatement);
+            }
+        }
+        // assign unique SIDs (the statement index) if `autoAssignSids` is enabled
+        const statements = uniqueStatements.map((s, i) => {
+            if (this.autoAssignSids && !s.sid) {
+                s.sid = i.toString();
+            }
+            // TODO: re-add sorting support
+            // ref: https://github.com/aws/aws-cdk/tree/v2.161.1/packages/aws-cdk-lib/aws-iam/lib/private/postprocess-policy-document.ts
+            // if (this.sort) {
+            //   // Don't act on the values if they are 'undefined'
+            //   s = s.copy({
+            //     sid: s.sid,
+            //     actions: s.actions ? sortByJson(s.actions) : undefined,
+            //     resources: s.resources ? sortByJson(s.resources) : undefined,
+            //     condition: s.conditions,
+            //     effect: s.effect,
+            //     notActions: s.notActions,
+            //     notResources: s.notResources,
+            //     principals: s.principals ? sortPrincipals(s.principals) : undefined,
+            //     notPrincipals: s.notPrincipals,
+            //   }
+            // }
+            return s;
+        });
+        return statements;
+    }
+}
+exports.PostProcessPolicyDocument = PostProcessPolicyDocument;
+// function noUndef(x: any): any {
+//   const ret: any = {};
+//   for (const [key, value] of Object.entries(x)) {
+//     if (value !== undefined) {
+//       ret[key] = value;
+//     }
+//   }
+//   return ret;
+// }
+// function sortPrincipals<A>(
+//   xs?: string | string[] | Record<string, A | A[]>,
+// ): typeof xs {
+//   if (!xs || Array.isArray(xs) || typeof xs !== "object") {
+//     return xs;
+//   }
+//   const ret: NonNullable<typeof xs> = {};
+//   for (const k of Object.keys(xs).sort()) {
+//     ret[k] = sortByJson(xs[k]);
+//   }
+//   return ret;
+// }
+// /**
+//  * Sort the values in the list by the JSON representation, removing duplicates.
+//  *
+//  * Mutates in place AND returns the mutated list.
+//  */
+// function sortByJson<B, A extends B | B[] | undefined>(xs: A): A {
+//   if (!Array.isArray(xs)) {
+//     return xs;
+//   }
+//   const intermediate = new Map<string, A>();
+//   for (const x of xs) {
+//     intermediate.set(JSON.stringify(x), x);
+//   }
+//   const sorted = Array.from(intermediate.keys())
+//     .sort()
+//     .map((k) => intermediate.get(k)!);
+//   xs.splice(0, xs.length, ...sorted);
+//   return xs.length !== 1 ? xs : xs[0];
+// }
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,37 @@
+import { IPostProcessor, IResolvable, IResolveContext } from "cdktf";
+import { IPolicy } from "../policy";
+export declare const MAX_POLICY_NAME_LEN = 128;
+export declare function undefinedIfEmpty(f: () => string[]): string[];
+/**
+ * Helper class that maintains the set of attached policies for a principal.
+ */
+export declare class AttachedPolicies {
+    private policies;
+    /**
+     * Adds a policy to the list of attached policies.
+     *
+     * If this policy is already, attached, returns false.
+     * If there is another policy attached with the same name, throws an exception.
+     */
+    attach(policy: IPolicy): void;
+}
+/**
+ * Lazy string set token that dedupes entries
+ *
+ * Needs to operate post-resolve, because the inputs could be
+ * `[ '${Token[TOKEN.9]}', '${Token[TOKEN.10]}', '${Token[TOKEN.20]}' ]`, which
+ * still all resolve to the same string value.
+ *
+ * Needs to JSON.stringify() results because strings could resolve to literal
+ * strings but could also resolve to `${index(...)}`.
+ */
+export declare class UniqueStringSet implements IResolvable, IPostProcessor {
+    private readonly fn;
+    static from(fn: () => string[]): string[];
+    readonly creationStack: string[];
+    private constructor();
+    resolve(context: IResolveContext): string[];
+    postProcess(input: any, _context: IResolveContext): any;
+    toString(): string;
+}
+export declare function sum(xs: number[]): number;

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = exports.UniqueStringSet = exports.AttachedPolicies = exports.undefinedIfEmpty = exports.MAX_POLICY_NAME_LEN = void 0;
+const cdktf_1 = require("cdktf");
+exports.MAX_POLICY_NAME_LEN = 128;
+function undefinedIfEmpty(f) {
+    return cdktf_1.Lazy.listValue({
+        produce: () => {
+            const array = f();
+            return array && array.length > 0 ? array : undefined;
+        },
+    });
+}
+exports.undefinedIfEmpty = undefinedIfEmpty;
+/**
+ * Helper class that maintains the set of attached policies for a principal.
+ */
+class AttachedPolicies {
+    constructor() {
+        this.policies = new Array();
+    }
+    /**
+     * Adds a policy to the list of attached policies.
+     *
+     * If this policy is already, attached, returns false.
+     * If there is another policy attached with the same name, throws an exception.
+     */
+    attach(policy) {
+        if (this.policies.find((p) => p === policy)) {
+            return; // already attached
+        }
+        if (this.policies.find((p) => p.policyName === policy.policyName)) {
+            throw new Error(`A policy named "${policy.policyName}" is already attached`);
+        }
+        this.policies.push(policy);
+    }
+}
+exports.AttachedPolicies = AttachedPolicies;
+/**
+ * Lazy string set token that dedupes entries
+ *
+ * Needs to operate post-resolve, because the inputs could be
+ * `[ '${Token[TOKEN.9]}', '${Token[TOKEN.10]}', '${Token[TOKEN.20]}' ]`, which
+ * still all resolve to the same string value.
+ *
+ * Needs to JSON.stringify() results because strings could resolve to literal
+ * strings but could also resolve to `${index(...)}`.
+ */
+class UniqueStringSet {
+    static from(fn) {
+        return cdktf_1.Token.asList(new UniqueStringSet(fn));
+    }
+    constructor(fn) {
+        this.fn = fn;
+        // TODO: Implement stack traces
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.7/packages/cdktf/lib/app.ts#L111
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9
+        // ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22
+        this.creationStack = ["stack traces disabled"];
+    }
+    resolve(context) {
+        context.registerPostProcessor(this);
+        return this.fn();
+    }
+    postProcess(input, _context) {
+        if (!Array.isArray(input)) {
+            return input;
+        }
+        if (input.length === 0) {
+            return undefined;
+        }
+        const uniq = {};
+        for (const el of input) {
+            uniq[JSON.stringify(el)] = el;
+        }
+        return Object.values(uniq);
+    }
+    toString() {
+        return cdktf_1.Token.asString(this);
+    }
+}
+exports.UniqueStringSet = UniqueStringSet;
+function sum(xs) {
+    return xs.reduce((a, b) => a + b, 0);
+}
+exports.sum = sum;
+//# sourceMappingURL=data:application/json;base64,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