@liflig/cdk 2.18.10 → 2.19.1

package/lib/build-artifacts/github-actions-role.d.ts

@@ -0,0 +1,68 @@
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as constructs from "constructs";
+export interface Props {
+    /**
+     * A list of trusted GitHub repository owners.
+     *
+     * This functions as a sort of whitelist to catch
+     * potential typos in {@link repositories}.
+     */
+    trustedOwners: string[];
+    /**
+     * The name of the trusted branch.
+     *
+     * The wildcard characters '*' and '?' can be used to
+     * represent any combination of characters and any single
+     * character, respectively.
+     *
+     * @default "master"
+     */
+    trustedBranch?: string;
+    /**
+     * The name of the role to create.
+     *
+     * @default "github-actions-role"
+     */
+    roleName?: string;
+    /**
+     * The GitHub repositories that the principal trusts.
+     */
+    repositories: {
+        /**
+         * The name of the GitHub repository.
+         *
+         * The wildcard characters '*' and '?' can be used to
+         * represent any combination of characters and any single
+         * character, respectively.
+         *
+         * NOTE: Be careful when using wildcard characters as you
+         * may grant access to repositories you did not intend.
+         *
+         * @example "my-repository"
+         * @example "my-team-*"
+         */
+        name: string;
+        /**
+         * The name of the owner of the GitHub repository.
+         *
+         * NOTE: The owner must explicitly be whitelisted in {@link trustedOwners}.
+         */
+        owner: string;
+    }[];
+    /**
+     * An existing OpenID Connect Provider for GitHub Actions.
+     */
+    oidcProvider: iam.IOpenIdConnectProvider;
+}
+/**
+ * Utility function for validating the construct properties.
+ */
+export declare const validateProps: (props: Props) => boolean;
+/**
+ * Creates an IAM role that can be assumed by GitHub Actions workflows
+ * in specific GitHub repositories and branches using OpenID Connect.
+ */
+export declare class GithubActionsRole extends constructs.Construct {
+    readonly role: iam.Role;
+    constructor(scope: constructs.Construct, id: string, props: Props);
+}

package/lib/build-artifacts/github-actions-role.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubActionsRole = exports.validateProps = void 0;
+const iam = require("aws-cdk-lib/aws-iam");
+const constructs = require("constructs");
+/**
+ * Utility function for validating the construct properties.
+ */
+const validateProps = (props) => {
+    let valid = true;
+    if (props.trustedOwners.length === 0) {
+        console.error("At least 1 trusted owner must be supplied, but 0 were given");
+        valid = false;
+    }
+    if (props.repositories.length === 0) {
+        console.error("At least 1 repository must be supplied, but 0 were given");
+        valid = false;
+    }
+    props.trustedOwners.forEach((owner) => {
+        if (!owner.match(/^[a-zA-Z0-9-]+$/)) {
+            console.error(`Trusted owner ${owner} contains invalid characters`);
+            valid = false;
+        }
+    });
+    props.repositories.forEach((repository) => {
+        if (!props.trustedOwners.includes(repository.owner)) {
+            console.error(`Owner ${repository.owner} of repository ${repository.name} not configured as a trusted owner`);
+            valid = false;
+        }
+    });
+    return valid;
+};
+exports.validateProps = validateProps;
+/**
+ * Creates an IAM role that can be assumed by GitHub Actions workflows
+ * in specific GitHub repositories and branches using OpenID Connect.
+ */
+class GithubActionsRole extends constructs.Construct {
+    constructor(scope, id, props) {
+        var _a;
+        super(scope, id);
+        if (!(0, exports.validateProps)(props)) {
+            throw new Error("Invalid props were supplied");
+        }
+        const subjects = props.repositories.map((repository) => { var _a; return `repo:${repository.owner}/${repository.name}:ref:refs/heads/${(_a = props.trustedBranch) !== null && _a !== void 0 ? _a : "master"}`; });
+        const fullyQualifiedSubjects = subjects.filter((subject) => !(subject.includes("?") || subject.includes("*")));
+        const wildcardSubjects = subjects.filter((subject) => subject.includes("?") || subject.includes("*"));
+        const principalConditions = {
+            ...(fullyQualifiedSubjects.length && {
+                StringEquals: {
+                    "token.actions.githubusercontent.com:sub": fullyQualifiedSubjects,
+                },
+            }),
+            ...(wildcardSubjects.length && {
+                StringLike: {
+                    "token.actions.githubusercontent.com:sub": wildcardSubjects,
+                },
+            }),
+        };
+        const principal = new iam.FederatedPrincipal(props.oidcProvider.openIdConnectProviderArn, principalConditions, "sts:AssumeRoleWithWebIdentity");
+        // Verify that the principal is configured with a trust relationship
+        // that contains at least one IAM condition with a context key and values
+        if (!Object.values(principalConditions).some((conditionElement) => Object.entries(conditionElement).some(([conditionKey, conditionValue]) => conditionKey && conditionValue.length))) {
+            throw new Error("The principal's trust policy needs to be configured with at least one IAM condition");
+        }
+        this.role = new iam.Role(this, "Role", {
+            roleName: (_a = props.roleName) !== null && _a !== void 0 ? _a : "github-actions-role",
+            assumedBy: principal,
+        });
+    }
+}
+exports.GithubActionsRole = GithubActionsRole;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github-actions-role.js","sourceRoot":"","sources":["../../src/build-artifacts/github-actions-role.ts"],"names":[],"mappings":"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","sourcesContent":["import * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as constructs from \"constructs\"\n\nexport interface Props {\n  /**\n   * A list of trusted GitHub repository owners.\n   *\n   * This functions as a sort of whitelist to catch\n   * potential typos in {@link repositories}.\n   */\n  trustedOwners: string[]\n  /**\n   * The name of the trusted branch.\n   *\n   * The wildcard characters '*' and '?' can be used to\n   * represent any combination of characters and any single\n   * character, respectively.\n   *\n   * @default \"master\"\n   */\n  trustedBranch?: string\n  /**\n   * The name of the role to create.\n   *\n   * @default \"github-actions-role\"\n   */\n  roleName?: string\n  /**\n   * The GitHub repositories that the principal trusts.\n   */\n  repositories: {\n    /**\n     * The name of the GitHub repository.\n     *\n     * The wildcard characters '*' and '?' can be used to\n     * represent any combination of characters and any single\n     * character, respectively.\n     *\n     * NOTE: Be careful when using wildcard characters as you\n     * may grant access to repositories you did not intend.\n     *\n     * @example \"my-repository\"\n     * @example \"my-team-*\"\n     */\n    name: string\n    /**\n     * The name of the owner of the GitHub repository.\n     *\n     * NOTE: The owner must explicitly be whitelisted in {@link trustedOwners}.\n     */\n    owner: string\n  }[]\n  /**\n   * An existing OpenID Connect Provider for GitHub Actions.\n   */\n  oidcProvider: iam.IOpenIdConnectProvider\n}\n\n/**\n * Utility function for validating the construct properties.\n */\nexport const validateProps = (props: Props) => {\n  let valid = true\n  if (props.trustedOwners.length === 0) {\n    console.error(\"At least 1 trusted owner must be supplied, but 0 were given\")\n    valid = false\n  }\n  if (props.repositories.length === 0) {\n    console.error(\"At least 1 repository must be supplied, but 0 were given\")\n    valid = false\n  }\n  props.trustedOwners.forEach((owner) => {\n    if (!owner.match(/^[a-zA-Z0-9-]+$/)) {\n      console.error(`Trusted owner ${owner} contains invalid characters`)\n      valid = false\n    }\n  })\n\n  props.repositories.forEach((repository) => {\n    if (!props.trustedOwners.includes(repository.owner)) {\n      console.error(\n        `Owner ${repository.owner} of repository ${repository.name} not configured as a trusted owner`,\n      )\n      valid = false\n    }\n  })\n  return valid\n}\n\n/**\n * Creates an IAM role that can be assumed by GitHub Actions workflows\n * in specific GitHub repositories and branches using OpenID Connect.\n */\nexport class GithubActionsRole extends constructs.Construct {\n  public readonly role: iam.Role\n\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n    if (!validateProps(props)) {\n      throw new Error(\"Invalid props were supplied\")\n    }\n\n    const subjects = props.repositories.map(\n      (repository) =>\n        `repo:${repository.owner}/${repository.name}:ref:refs/heads/${props.trustedBranch ?? \"master\"}`,\n    )\n    const fullyQualifiedSubjects = subjects.filter(\n      (subject) => !(subject.includes(\"?\") || subject.includes(\"*\")),\n    )\n\n    const wildcardSubjects = subjects.filter(\n      (subject) => subject.includes(\"?\") || subject.includes(\"*\"),\n    )\n    const principalConditions = {\n      ...(fullyQualifiedSubjects.length && {\n        StringEquals: {\n          \"token.actions.githubusercontent.com:sub\": fullyQualifiedSubjects,\n        },\n      }),\n      ...(wildcardSubjects.length && {\n        StringLike: {\n          \"token.actions.githubusercontent.com:sub\": wildcardSubjects,\n        },\n      }),\n    }\n\n    const principal = new iam.FederatedPrincipal(\n      props.oidcProvider.openIdConnectProviderArn,\n      principalConditions,\n      \"sts:AssumeRoleWithWebIdentity\",\n    )\n\n    // Verify that the principal is configured with a trust relationship\n    // that contains at least one IAM condition with a context key and values\n    if (\n      !Object.values(principalConditions).some((conditionElement) =>\n        Object.entries(conditionElement).some(\n          ([conditionKey, conditionValue]) =>\n            conditionKey && conditionValue.length,\n        ),\n      )\n    ) {\n      throw new Error(\n        \"The principal's trust policy needs to be configured with at least one IAM condition\",\n      )\n    }\n    this.role = new iam.Role(this, \"Role\", {\n      roleName: props.roleName ?? \"github-actions-role\",\n      assumedBy: principal,\n    })\n  }\n}\n"]}

package/lib/build-artifacts/index.d.ts

@@ -1,57 +1,94 @@
 import * as constructs from "constructs";
 import * as ecr from "aws-cdk-lib/aws-ecr";
+import * as iam from "aws-cdk-lib/aws-iam";
+import { Props as GithubActionsRoleProps } from "./github-actions-role";
 interface Props {
     /**
-     * The name to use for the S3 Bucket. Should include both account and region
-     * so that it will not conflict with other accounts/regions.
+     * The name to use for the S3 Bucket.
      *
-     * @default - no bucket will be created
+     * NOTE: Should include both account and region so that it will
+     * not conflict with other accounts/regions.
      */
-    bucketName?: string;
+    bucketName: string;
     /**
      * The name to use for the ECR Repository.
      */
     ecrRepositoryName: string;
     /**
-     * The lifecycle rules to apply to images stored in the ECR repository.
-     *
-     * @default - Expire images after 180 days
-     */
-    ecrRepositoryLifecycleRules?: ecr.LifecycleRule[];
-    /**
-     * Reference to the IAM Role that will be granted permission to
-     * assume the CI role. This role must have permission to assume
-     * the CI role.
+     * Create a role that can be assumed by Liflig Jenkins.
      *
-     * @default - use Liflig Jenkins role
+     * @deprecated
+     * @default - no role will be created
      */
-    externalRoleArn?: string;
+    ciRoleName?: string;
     /**
-     * The name of the role that will be created that will be assumed
-     * from the CI system.
+     * The lifecycle rules to apply to images stored in the ECR repository.
      *
-     * @default - no role will be created
+     * @default - Expire images after 180 days
      */
-    ciRoleName?: string;
+    ecrRepositoryLifecycleRules?: ecr.LifecycleRule[];
     /**
-     * The AWS Accounts that will be granted permission to read from
+     * ID of AWS accounts that will be granted permission to read from
      * the artifact repos.
      */
-    targetAccountIds: string[];
+    targetAccountIds?: string[];
     /**
-     * Flag if Griid is bootstrapped and the account this construct is
-     * deployed to is the build account. Will attach policies and
-     * reference existing artifacts and roles.
+     * Configuration for creating IAM roles that can be assumed
+     * by GitHub Actions in specific GitHub repositories.
      *
-     * @default false
+     * @default - no roles are created.
      */
-    griid?: boolean;
+    githubActions?: Omit<GithubActionsRoleProps, "trustedOwners" | "trustedBranch" | "oidcProvider" | "roleName"> & {
+        /**
+         * A list of trusted GitHub repository owners.
+         *
+         * @default ["capralifecycle"]
+         */
+        trustedOwners?: string[];
+        /**
+         * The name of the role to create.
+         *
+         * @default "github-actions-role"
+         */
+        roleName?: string;
+        /**
+         * The name of the default branch in all repositories.
+         *
+         * @default "master"
+         */
+        defaultBranch?: string;
+        /**
+         * Configuration for a limited role that can be used on non-default
+         * branches with less IAM permissions than the main role.
+         *
+         * @default - a limited role is created.
+         */
+        limitedRoleConfiguration?: {
+            /**
+             * Whether to create the role or not.
+             *
+             * @default true
+             */
+            enabled?: boolean;
+            /**
+             * The name of the role to create.
+             *
+             * @default "github-actions-limited-role"
+             */
+            roleName?: string;
+        };
+    };
 }
 /**
- * Build artifacts.
+ * Utility function for validating the construct properties.
+ */
+export declare const validateProps: (props: Props) => boolean;
+/**
+ * Create various artifacts used as part of Continuous Integration (CI).
  *
- * This holds a S3 Bucket, a ECR Repository and roles to be used
- * from CI system for uploading.
+ * This includes artifact repositories such as S3 bucket and ECR
+ * repository, as well as IAM role(s) that grant the CI server write
+ * access to these repositories.
  *
  * TODO: How can we cleanup stuff that goes into this S3 Bucket and
  *  ECR Repository? Can we ever reliably cleanup? We probably need
@@ -63,6 +100,8 @@ export declare class BuildArtifacts extends constructs.Construct {
     readonly bucketName: string | undefined;
     readonly ecrRepositoryArn: string;
     readonly ecrRepositoryName: string;
+    readonly role?: iam.Role;
+    readonly limitedRole?: iam.Role;
     constructor(scope: constructs.Construct, id: string, props: Props);
 }
 export {};

package/lib/build-artifacts/index.js

@@ -1,17 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildArtifacts = void 0;
+exports.BuildArtifacts = exports.validateProps = void 0;
 const constructs = require("constructs");
 const ecr = require("aws-cdk-lib/aws-ecr");
 const iam = require("aws-cdk-lib/aws-iam");
 const s3 = require("aws-cdk-lib/aws-s3");
 const cdk = require("aws-cdk-lib");
-const griid_1 = require("../griid");
+const github_actions_role_1 = require("./github-actions-role");
 /**
- * Build artifacts.
+ * Utility functions for generating IAM statements.
+ */
+const policyStatements = {
+    allowPipelineVariables: (scope, prefix) => new iam.PolicyStatement({
+        effect: iam.Effect.ALLOW,
+        actions: ["ssm:PutParameter"],
+        resources: [
+            `arn:aws:ssm:${cdk.Stack.of(scope).region}:${cdk.Stack.of(scope).account}:parameter/liflig-cdk/*/pipeline-variables/${prefix !== null && prefix !== void 0 ? prefix : "*"}`,
+        ],
+    }),
+    denyProdPipelines: (scope, bucket) => new iam.PolicyStatement({
+        effect: iam.Effect.DENY,
+        actions: ["s3:*"],
+        resources: [
+            bucket.arnForObjects("pipelines/*-prod/*"),
+            bucket.arnForObjects("pipelines/*-prod-*/*"),
+        ],
+    }),
+    denyProdPipelineVariables: (scope) => new iam.PolicyStatement({
+        effect: iam.Effect.DENY,
+        actions: ["ssm:PutParameter"],
+        resources: [
+            `arn:aws:ssm:${cdk.Stack.of(scope).region}:${cdk.Stack.of(scope).account}:parameter/liflig-cdk/*/pipeline-variables/prod*`,
+        ],
+    }),
+};
+/**
+ * Utility function for validating the construct properties.
+ */
+const validateProps = (props) => {
+    var _a;
+    let valid = true;
+    if (((_a = props.githubActions) === null || _a === void 0 ? void 0 : _a.defaultBranch) &&
+        !props.githubActions.defaultBranch.match(/^[a-zA-Z0-9-]+$/)) {
+        console.error(`Default branch ${props.githubActions.defaultBranch} contains invalid characters`);
+        valid = false;
+    }
+    return valid;
+};
+exports.validateProps = validateProps;
+/**
+ * Create various artifacts used as part of Continuous Integration (CI).
  *
- * This holds a S3 Bucket, a ECR Repository and roles to be used
- * from CI system for uploading.
+ * This includes artifact repositories such as S3 bucket and ECR
+ * repository, as well as IAM role(s) that grant the CI server write
+ * access to these repositories.
  *
  * TODO: How can we cleanup stuff that goes into this S3 Bucket and
  *  ECR Repository? Can we ever reliably cleanup? We probably need
@@ -21,8 +63,11 @@ const griid_1 = require("../griid");
  */
 class BuildArtifacts extends constructs.Construct {
     constructor(scope, id, props) {
-        var _a;
+        var _a, _b, _c, _d, _e, _f, _g;
         super(scope, id);
+        if (!(0, exports.validateProps)(props)) {
+            throw new Error("Invalid props were supplied");
+        }
         this.bucketName = props.bucketName;
         this.ecrRepositoryName = props.ecrRepositoryName;
         this.ecrRepositoryArn = cdk.Arn.format({
@@ -30,38 +75,19 @@ class BuildArtifacts extends constructs.Construct {
             resource: "repository",
             resourceName: this.ecrRepositoryName,
         }, cdk.Stack.of(this));
-        const externalRoleArn = (_a = props.externalRoleArn) !== null && _a !== void 0 ? _a : "arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5";
         const ecrRepositoryName = props.ecrRepositoryName;
-        let bucket = undefined;
-        if (props.bucketName) {
-            bucket = new s3.Bucket(this, "S3Bucket", {
-                bucketName: props.bucketName,
-                encryption: s3.BucketEncryption.S3_MANAGED,
-                eventBridgeEnabled: true,
-                blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
-                versioned: true,
-                lifecycleRules: [
-                    {
-                        noncurrentVersionExpiration: cdk.Duration.days(10),
-                    },
-                ],
-            });
-        }
-        const ciRole = props.ciRoleName
-            ? new iam.Role(this, "CiRole", {
-                roleName: props.ciRoleName,
-                assumedBy: new iam.ArnPrincipal(externalRoleArn),
-            })
-            : undefined;
-        const griidCiRole = props.griid
-            ? (0, griid_1.getGriidCiRole)(this)
-            : undefined;
-        if (bucket && ciRole) {
-            bucket.grantReadWrite(ciRole);
-        }
-        if (bucket && griidCiRole) {
-            bucket.grantReadWrite(griidCiRole);
-        }
+        const bucket = new s3.Bucket(this, "S3Bucket", {
+            bucketName: props.bucketName,
+            encryption: s3.BucketEncryption.S3_MANAGED,
+            eventBridgeEnabled: true,
+            blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+            versioned: true,
+            lifecycleRules: [
+                {
+                    noncurrentVersionExpiration: cdk.Duration.days(10),
+                },
+            ],
+        });
         const ecrRepo = new ecr.Repository(this, "EcrRepository", {
             repositoryName: ecrRepositoryName,
             lifecycleRules: props.ecrRepositoryLifecycleRules || [
@@ -71,48 +97,89 @@ class BuildArtifacts extends constructs.Construct {
                 },
             ],
         });
-        if (ciRole) {
-            ecrRepo.grantPullPush(ciRole);
-        }
-        if (griidCiRole) {
-            ecrRepo.grantPullPush(griidCiRole);
-        }
         // Allow a target to read from the repos. As any specific roles need
         // to exist before we can grant access, we delegate that responsibility
         // to the target account.
-        for (const targetAccountId of props.targetAccountIds) {
-            if (bucket) {
-                bucket.grantRead(new iam.AccountPrincipal(targetAccountId));
-            }
+        for (const targetAccountId of props.targetAccountIds || []) {
+            bucket.grantRead(new iam.AccountPrincipal(targetAccountId));
             ecrRepo.grantPull(new iam.AccountPrincipal(targetAccountId));
         }
-        // Grant permissions to write pipeline variables.
-        if (ciRole || griidCiRole) {
-            const account = cdk.Stack.of(this).account;
-            const region = cdk.Stack.of(this).region;
-            const statement = new iam.PolicyStatement({
-                actions: ["ssm:PutParameter"],
-                resources: [
-                    `arn:aws:ssm:${region}:${account}:parameter/liflig-cdk/*/pipeline-variables/*`,
-                ],
+        if (props.githubActions) {
+            const trustedOwners = (_a = props.githubActions.trustedOwners) !== null && _a !== void 0 ? _a : [
+                "capralifecycle",
+            ];
+            // NOTE: There's an L2 construct that predates the official CloudFormation resource,
+            // and it is therefore implemented as a custom resource.
+            // We use the L1 CloudFormation resource instead because:
+            // 1) it's simpler
+            // 2) there's a chance the L2 construct will be deprecated in the future in favor
+            // of the official CloudFormation resource.
+            const cfnOidcProvider = new iam.CfnOIDCProvider(this, "OpenIdConnectProvider", {
+                url: "https://token.actions.githubusercontent.com",
+                clientIdList: ["sts.amazonaws.com"],
+                // NOTE: The thumbprint isn't actually used, but the AWS API still requires us to supply it.
+                // More details here: https://web.archive.org/web/20240122155758/https://github.com/aws-actions/configure-aws-credentials/issues/357#issuecomment-1626357333
+                thumbprintList: ["1c58a3a8518e8759bf075b76b750d4f2df264fcd"],
             });
-            ciRole === null || ciRole === void 0 ? void 0 : ciRole.grantPrincipal.addToPrincipalPolicy(statement);
-            griidCiRole === null || griidCiRole === void 0 ? void 0 : griidCiRole.grantPrincipal.addToPrincipalPolicy(statement);
+            const oidcProvider = iam.OpenIdConnectProvider.fromOpenIdConnectProviderArn(this, "Provider", cfnOidcProvider.ref);
+            const createLimitedRole = (_c = (_b = props.githubActions.limitedRoleConfiguration) === null || _b === void 0 ? void 0 : _b.enabled) !== null && _c !== void 0 ? _c : true;
+            const role = new github_actions_role_1.GithubActionsRole(this, "GithubActionsRole", {
+                oidcProvider,
+                trustedOwners,
+                roleName: (_d = props.githubActions.roleName) !== null && _d !== void 0 ? _d : "github-actions-role",
+                trustedBranch: createLimitedRole
+                    ? (_e = props.githubActions.defaultBranch) !== null && _e !== void 0 ? _e : "master"
+                    : // NOTE: If the limited role is disabled, only one role will be created
+                        // and that role then needs to be assumable from all branches.
+                        "*",
+                repositories: props.githubActions.repositories,
+            });
+            this.role = role.role;
+            this.role.addToPolicy(policyStatements.allowPipelineVariables(this));
+            bucket.grantPut(this.role);
+            ecrRepo.grantPullPush(this.role);
+            if (createLimitedRole) {
+                const limitedRole = new github_actions_role_1.GithubActionsRole(this, "GithubActionsLimitedRole", {
+                    oidcProvider,
+                    trustedOwners,
+                    roleName: (_g = (_f = props.githubActions.limitedRoleConfiguration) === null || _f === void 0 ? void 0 : _f.roleName) !== null && _g !== void 0 ? _g : "github-actions-limited-role",
+                    // NOTE: The limited role can be assumed from all branches.
+                    trustedBranch: "*",
+                    repositories: props.githubActions.repositories,
+                });
+                this.limitedRole = limitedRole.role;
+                this.limitedRole.addToPolicy(policyStatements.allowPipelineVariables(this, "dev*"));
+                this.limitedRole.addToPolicy(policyStatements.denyProdPipelines(scope, bucket));
+                bucket.grantPut(this.limitedRole);
+                ecrRepo.grantPullPush(this.limitedRole);
+            }
+        }
+        if (props.ciRoleName) {
+            const legacyRoleForJenkins = new iam.Role(this, "CiRole", {
+                roleName: props.ciRoleName,
+                assumedBy: new iam.ArnPrincipal("arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5"),
+            });
+            legacyRoleForJenkins.addToPolicy(policyStatements.allowPipelineVariables(this));
+            bucket.grantPut(legacyRoleForJenkins);
+            ecrRepo.grantPullPush(legacyRoleForJenkins);
         }
         new cdk.CfnOutput(this, "EcrRepoUri", {
             value: ecrRepo.repositoryUri,
         });
-        if (bucket) {
-            new cdk.CfnOutput(this, "BucketName", {
-                value: bucket.bucketName,
+        new cdk.CfnOutput(this, "BucketName", {
+            value: bucket.bucketName,
+        });
+        if (this.role) {
+            new cdk.CfnOutput(this, "RoleArn", {
+                value: this.role.roleArn,
             });
         }
-        if (ciRole) {
-            new cdk.CfnOutput(this, "CiRoleArn", {
-                value: ciRole.roleArn,
+        if (this.limitedRole) {
+            new cdk.CfnOutput(this, "LimitedRoleArn", {
+                value: this.limitedRole.roleArn,
             });
         }
     }
 }
 exports.BuildArtifacts = BuildArtifacts;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/build-artifacts/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ecr from \"aws-cdk-lib/aws-ecr\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as cdk from \"aws-cdk-lib\"\nimport { getGriidCiRole } from \"../griid\"\n\ninterface Props {\n  /**\n   * The name to use for the S3 Bucket. Should include both account and region\n   * so that it will not conflict with other accounts/regions.\n   *\n   * @default - no bucket will be created\n   */\n  bucketName?: string\n  /**\n   * The name to use for the ECR Repository.\n   */\n  ecrRepositoryName: string\n  /**\n   * The lifecycle rules to apply to images stored in the ECR repository.\n   *\n   * @default - Expire images after 180 days\n   */\n  ecrRepositoryLifecycleRules?: ecr.LifecycleRule[]\n  /**\n   * Reference to the IAM Role that will be granted permission to\n   * assume the CI role. This role must have permission to assume\n   * the CI role.\n   *\n   * @default - use Liflig Jenkins role\n   */\n  externalRoleArn?: string\n  /**\n   * The name of the role that will be created that will be assumed\n   * from the CI system.\n   *\n   * @default - no role will be created\n   */\n  ciRoleName?: string\n  /**\n   * The AWS Accounts that will be granted permission to read from\n   * the artifact repos.\n   */\n  targetAccountIds: string[]\n  /**\n   * Flag if Griid is bootstrapped and the account this construct is\n   * deployed to is the build account. Will attach policies and\n   * reference existing artifacts and roles.\n   *\n   * @default false\n   */\n  griid?: boolean\n}\n\n/**\n * Build artifacts.\n *\n * This holds a S3 Bucket, a ECR Repository and roles to be used\n * from CI system for uploading.\n *\n * TODO: How can we cleanup stuff that goes into this S3 Bucket and\n *  ECR Repository? Can we ever reliably cleanup? We probably need\n *  some strategy for how we put stuff here to be able to do it.\n *\n * @experimental\n */\nexport class BuildArtifacts extends constructs.Construct {\n  readonly bucketName: string | undefined\n  readonly ecrRepositoryArn: string\n  readonly ecrRepositoryName: string\n\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    this.bucketName = props.bucketName\n    this.ecrRepositoryName = props.ecrRepositoryName\n    this.ecrRepositoryArn = cdk.Arn.format(\n      {\n        service: \"ecr\",\n        resource: \"repository\",\n        resourceName: this.ecrRepositoryName,\n      },\n      cdk.Stack.of(this),\n    )\n\n    const externalRoleArn =\n      props.externalRoleArn ??\n      \"arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5\"\n\n    const ecrRepositoryName = props.ecrRepositoryName\n\n    let bucket: s3.Bucket | undefined = undefined\n\n    if (props.bucketName) {\n      bucket = new s3.Bucket(this, \"S3Bucket\", {\n        bucketName: props.bucketName,\n        encryption: s3.BucketEncryption.S3_MANAGED,\n        eventBridgeEnabled: true,\n        blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n        versioned: true,\n        lifecycleRules: [\n          {\n            noncurrentVersionExpiration: cdk.Duration.days(10),\n          },\n        ],\n      })\n    }\n\n    const ciRole: iam.Role | undefined = props.ciRoleName\n      ? new iam.Role(this, \"CiRole\", {\n          roleName: props.ciRoleName,\n          assumedBy: new iam.ArnPrincipal(externalRoleArn),\n        })\n      : undefined\n\n    const griidCiRole: iam.IRole | undefined = props.griid\n      ? getGriidCiRole(this)\n      : undefined\n\n    if (bucket && ciRole) {\n      bucket.grantReadWrite(ciRole)\n    }\n\n    if (bucket && griidCiRole) {\n      bucket.grantReadWrite(griidCiRole)\n    }\n\n    const ecrRepo = new ecr.Repository(this, \"EcrRepository\", {\n      repositoryName: ecrRepositoryName,\n      lifecycleRules: props.ecrRepositoryLifecycleRules || [\n        {\n          maxImageAge: cdk.Duration.days(180),\n          tagStatus: ecr.TagStatus.ANY,\n        },\n      ],\n    })\n\n    if (ciRole) {\n      ecrRepo.grantPullPush(ciRole)\n    }\n\n    if (griidCiRole) {\n      ecrRepo.grantPullPush(griidCiRole)\n    }\n\n    // Allow a target to read from the repos. As any specific roles need\n    // to exist before we can grant access, we delegate that responsibility\n    // to the target account.\n    for (const targetAccountId of props.targetAccountIds) {\n      if (bucket) {\n        bucket.grantRead(new iam.AccountPrincipal(targetAccountId))\n      }\n      ecrRepo.grantPull(new iam.AccountPrincipal(targetAccountId))\n    }\n\n    // Grant permissions to write pipeline variables.\n    if (ciRole || griidCiRole) {\n      const account = cdk.Stack.of(this).account\n      const region = cdk.Stack.of(this).region\n      const statement = new iam.PolicyStatement({\n        actions: [\"ssm:PutParameter\"],\n        resources: [\n          `arn:aws:ssm:${region}:${account}:parameter/liflig-cdk/*/pipeline-variables/*`,\n        ],\n      })\n\n      ciRole?.grantPrincipal.addToPrincipalPolicy(statement)\n      griidCiRole?.grantPrincipal.addToPrincipalPolicy(statement)\n    }\n\n    new cdk.CfnOutput(this, \"EcrRepoUri\", {\n      value: ecrRepo.repositoryUri,\n    })\n\n    if (bucket) {\n      new cdk.CfnOutput(this, \"BucketName\", {\n        value: bucket.bucketName,\n      })\n    }\n\n    if (ciRole) {\n      new cdk.CfnOutput(this, \"CiRoleArn\", {\n        value: ciRole.roleArn,\n      })\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/build-artifacts/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ecr from \"aws-cdk-lib/aws-ecr\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as cdk from \"aws-cdk-lib\"\nimport {\n  GithubActionsRole,\n  Props as GithubActionsRoleProps,\n} from \"./github-actions-role\"\n\ninterface Props {\n  /**\n   * The name to use for the S3 Bucket.\n   *\n   * NOTE: Should include both account and region so that it will\n   * not conflict with other accounts/regions.\n   */\n  bucketName: string\n  /**\n   * The name to use for the ECR Repository.\n   */\n  ecrRepositoryName: string\n  /**\n   * Create a role that can be assumed by Liflig Jenkins.\n   *\n   * @deprecated\n   * @default - no role will be created\n   */\n  ciRoleName?: string\n  /**\n   * The lifecycle rules to apply to images stored in the ECR repository.\n   *\n   * @default - Expire images after 180 days\n   */\n  ecrRepositoryLifecycleRules?: ecr.LifecycleRule[]\n  /**\n   * ID of AWS accounts that will be granted permission to read from\n   * the artifact repos.\n   */\n  targetAccountIds?: string[]\n  /**\n   * Configuration for creating IAM roles that can be assumed\n   * by GitHub Actions in specific GitHub repositories.\n   *\n   * @default - no roles are created.\n   */\n  githubActions?: Omit<\n    GithubActionsRoleProps,\n    \"trustedOwners\" | \"trustedBranch\" | \"oidcProvider\" | \"roleName\"\n  > & {\n    /**\n     * A list of trusted GitHub repository owners.\n     *\n     * @default [\"capralifecycle\"]\n     */\n    trustedOwners?: string[]\n    /**\n     * The name of the role to create.\n     *\n     * @default \"github-actions-role\"\n     */\n    roleName?: string\n    /**\n     * The name of the default branch in all repositories.\n     *\n     * @default \"master\"\n     */\n    defaultBranch?: string\n    /**\n     * Configuration for a limited role that can be used on non-default\n     * branches with less IAM permissions than the main role.\n     *\n     * @default - a limited role is created.\n     */\n    limitedRoleConfiguration?: {\n      /**\n       * Whether to create the role or not.\n       *\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * The name of the role to create.\n       *\n       * @default \"github-actions-limited-role\"\n       */\n      roleName?: string\n    }\n  }\n}\n\n/**\n * Utility functions for generating IAM statements.\n */\nconst policyStatements = {\n  allowPipelineVariables: (scope: constructs.Construct, prefix?: string) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: [\"ssm:PutParameter\"],\n      resources: [\n        `arn:aws:ssm:${cdk.Stack.of(scope).region}:${cdk.Stack.of(scope).account}:parameter/liflig-cdk/*/pipeline-variables/${prefix ?? \"*\"}`,\n      ],\n    }),\n  denyProdPipelines: (scope: constructs.Construct, bucket: s3.IBucket) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.DENY,\n      actions: [\"s3:*\"],\n      resources: [\n        bucket.arnForObjects(\"pipelines/*-prod/*\"),\n        bucket.arnForObjects(\"pipelines/*-prod-*/*\"),\n      ],\n    }),\n  denyProdPipelineVariables: (scope: constructs.Construct) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.DENY,\n      actions: [\"ssm:PutParameter\"],\n      resources: [\n        `arn:aws:ssm:${cdk.Stack.of(scope).region}:${\n          cdk.Stack.of(scope).account\n        }:parameter/liflig-cdk/*/pipeline-variables/prod*`,\n      ],\n    }),\n}\n\n/**\n * Utility function for validating the construct properties.\n */\nexport const validateProps = (props: Props) => {\n  let valid = true\n  if (\n    props.githubActions?.defaultBranch &&\n    !props.githubActions.defaultBranch.match(/^[a-zA-Z0-9-]+$/)\n  ) {\n    console.error(\n      `Default branch ${props.githubActions.defaultBranch} contains invalid characters`,\n    )\n    valid = false\n  }\n  return valid\n}\n\n/**\n * Create various artifacts used as part of Continuous Integration (CI).\n *\n * This includes artifact repositories such as S3 bucket and ECR\n * repository, as well as IAM role(s) that grant the CI server write\n * access to these repositories.\n *\n * TODO: How can we cleanup stuff that goes into this S3 Bucket and\n *  ECR Repository? Can we ever reliably cleanup? We probably need\n *  some strategy for how we put stuff here to be able to do it.\n *\n * @experimental\n */\nexport class BuildArtifacts extends constructs.Construct {\n  public readonly bucketName: string | undefined\n  public readonly ecrRepositoryArn: string\n  public readonly ecrRepositoryName: string\n  public readonly role?: iam.Role\n  public readonly limitedRole?: iam.Role\n\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    if (!validateProps(props)) {\n      throw new Error(\"Invalid props were supplied\")\n    }\n\n    this.bucketName = props.bucketName\n    this.ecrRepositoryName = props.ecrRepositoryName\n    this.ecrRepositoryArn = cdk.Arn.format(\n      {\n        service: \"ecr\",\n        resource: \"repository\",\n        resourceName: this.ecrRepositoryName,\n      },\n      cdk.Stack.of(this),\n    )\n\n    const ecrRepositoryName = props.ecrRepositoryName\n\n    const bucket = new s3.Bucket(this, \"S3Bucket\", {\n      bucketName: props.bucketName,\n      encryption: s3.BucketEncryption.S3_MANAGED,\n      eventBridgeEnabled: true,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n      versioned: true,\n      lifecycleRules: [\n        {\n          noncurrentVersionExpiration: cdk.Duration.days(10),\n        },\n      ],\n    })\n\n    const ecrRepo = new ecr.Repository(this, \"EcrRepository\", {\n      repositoryName: ecrRepositoryName,\n      lifecycleRules: props.ecrRepositoryLifecycleRules || [\n        {\n          maxImageAge: cdk.Duration.days(180),\n          tagStatus: ecr.TagStatus.ANY,\n        },\n      ],\n    })\n\n    // Allow a target to read from the repos. As any specific roles need\n    // to exist before we can grant access, we delegate that responsibility\n    // to the target account.\n    for (const targetAccountId of props.targetAccountIds || []) {\n      bucket.grantRead(new iam.AccountPrincipal(targetAccountId))\n      ecrRepo.grantPull(new iam.AccountPrincipal(targetAccountId))\n    }\n\n    if (props.githubActions) {\n      const trustedOwners = props.githubActions.trustedOwners ?? [\n        \"capralifecycle\",\n      ]\n      // NOTE: There's an L2 construct that predates the official CloudFormation resource,\n      // and it is therefore implemented as a custom resource.\n      // We use the L1 CloudFormation resource instead because:\n      // 1) it's simpler\n      // 2) there's a chance the L2 construct will be deprecated in the future in favor\n      // of the official CloudFormation resource.\n      const cfnOidcProvider = new iam.CfnOIDCProvider(\n        this,\n        \"OpenIdConnectProvider\",\n        {\n          url: \"https://token.actions.githubusercontent.com\",\n          clientIdList: [\"sts.amazonaws.com\"],\n          // NOTE: The thumbprint isn't actually used, but the AWS API still requires us to supply it.\n          // More details here: https://web.archive.org/web/20240122155758/https://github.com/aws-actions/configure-aws-credentials/issues/357#issuecomment-1626357333\n          thumbprintList: [\"1c58a3a8518e8759bf075b76b750d4f2df264fcd\"],\n        },\n      )\n      const oidcProvider =\n        iam.OpenIdConnectProvider.fromOpenIdConnectProviderArn(\n          this,\n          \"Provider\",\n          cfnOidcProvider.ref,\n        )\n      const createLimitedRole =\n        props.githubActions.limitedRoleConfiguration?.enabled ?? true\n      const role = new GithubActionsRole(this, \"GithubActionsRole\", {\n        oidcProvider,\n        trustedOwners,\n        roleName: props.githubActions.roleName ?? \"github-actions-role\",\n        trustedBranch: createLimitedRole\n          ? props.githubActions.defaultBranch ?? \"master\"\n          : // NOTE: If the limited role is disabled, only one role will be created\n            // and that role then needs to be assumable from all branches.\n            \"*\",\n        repositories: props.githubActions.repositories,\n      })\n      this.role = role.role\n      this.role.addToPolicy(policyStatements.allowPipelineVariables(this))\n      bucket.grantPut(this.role)\n      ecrRepo.grantPullPush(this.role)\n      if (createLimitedRole) {\n        const limitedRole = new GithubActionsRole(\n          this,\n          \"GithubActionsLimitedRole\",\n          {\n            oidcProvider,\n            trustedOwners,\n            roleName:\n              props.githubActions.limitedRoleConfiguration?.roleName ??\n              \"github-actions-limited-role\",\n            // NOTE: The limited role can be assumed from all branches.\n            trustedBranch: \"*\",\n            repositories: props.githubActions.repositories,\n          },\n        )\n        this.limitedRole = limitedRole.role\n        this.limitedRole.addToPolicy(\n          policyStatements.allowPipelineVariables(this, \"dev*\"),\n        )\n        this.limitedRole.addToPolicy(\n          policyStatements.denyProdPipelines(scope, bucket),\n        )\n        bucket.grantPut(this.limitedRole)\n        ecrRepo.grantPullPush(this.limitedRole)\n      }\n    }\n    if (props.ciRoleName) {\n      const legacyRoleForJenkins = new iam.Role(this, \"CiRole\", {\n        roleName: props.ciRoleName,\n        assumedBy: new iam.ArnPrincipal(\n          \"arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5\",\n        ),\n      })\n      legacyRoleForJenkins.addToPolicy(\n        policyStatements.allowPipelineVariables(this),\n      )\n      bucket.grantPut(legacyRoleForJenkins)\n      ecrRepo.grantPullPush(legacyRoleForJenkins)\n    }\n\n    new cdk.CfnOutput(this, \"EcrRepoUri\", {\n      value: ecrRepo.repositoryUri,\n    })\n\n    new cdk.CfnOutput(this, \"BucketName\", {\n      value: bucket.bucketName,\n    })\n\n    if (this.role) {\n      new cdk.CfnOutput(this, \"RoleArn\", {\n        value: this.role.roleArn,\n      })\n    }\n    if (this.limitedRole) {\n      new cdk.CfnOutput(this, \"LimitedRoleArn\", {\n        value: this.limitedRole.roleArn,\n      })\n    }\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk",
-  "version": "2.18.10",
+  "version": "2.19.1",
   "description": "CDK library for Liflig",
   "repository": {
     "type": "git",
@@ -40,11 +40,11 @@
   },
   "devDependencies": {
     "@aws-cdk/assert": "2.68.0",
-    "@commitlint/cli": "18.4.3",
-    "@commitlint/config-conventional": "18.4.3",
-    "@types/aws-lambda": "8.10.130",
+    "@commitlint/cli": "18.6.0",
+    "@commitlint/config-conventional": "18.6.0",
+    "@types/aws-lambda": "8.10.132",
     "@types/jest": "29.5.11",
-    "@types/node": "18.19.3",
+    "@types/node": "18.19.10",
     "@typescript-eslint/eslint-plugin": "5.62.0",
     "@typescript-eslint/parser": "5.62.0",
     "aws-cdk": "2.111.0",
@@ -52,19 +52,19 @@
     "constructs": "10.3.0",
     "eslint": "8.56.0",
     "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-prettier": "5.1.2",
+    "eslint-plugin-prettier": "5.1.3",
     "husky": "8.0.3",
     "jest": "29.7.0",
     "jest-cdk-snapshot": "2.0.1",
-    "prettier": "3.1.1",
+    "prettier": "3.2.4",
     "semantic-release": "22.0.12",
-    "ts-jest": "29.1.1",
+    "ts-jest": "29.1.2",
     "ts-node": "10.9.2",
     "typescript": "5.3.3"
   },
   "dependencies": {
     "@capraconsulting/webapp-deploy-lambda": "2.1.5",
-    "aws-sdk": "2.1527.0",
+    "aws-sdk": "2.1545.0",
     "cpy": "8.1.2",
     "del": "6.1.1",
     "execa": "5.1.1",