deployable-awscdk-app-ts 0.1.680 → 0.1.682

package/lib/steps.js

@@ -1,163 +1,512 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkoutStep = checkoutStep;
-exports.setNodeVersionStep = setNodeVersionStep;
-exports.installDependenciesStep = installDependenciesStep;
-exports.deploymentStep = deploymentStep;
-exports.setAwsCredentialsSteps = setAwsCredentialsSteps;
-exports.setNpmConfig = setNpmConfig;
-exports.checkActiveDeploymentStep = checkActiveDeploymentStep;
-exports.postDeploymentStep = postDeploymentStep;
-exports.preDeploymentStep = preDeploymentStep;
-exports.preInstallDependenciesStep = preInstallDependenciesStep;
-const projen_1 = require("projen");
+exports.DeployableAwsCdkTypeScriptAppStepsFactory = void 0;
+const github_1 = require("projen/lib/github");
+const workflows_model_1 = require("projen/lib/github/workflows-model");
 const javascript_1 = require("projen/lib/javascript");
-function checkoutStep() {
-    return {
-        name: 'Checkout',
-        uses: 'actions/checkout@v4',
-        with: {
-            'ref': '${{ github.sha }}',
-            'fetch-depth': 0,
-        },
-    };
-}
-function setNodeVersionStep(nodeVersion, checkActiveDeployment) {
-    return {
-        ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),
-        name: 'Setup Node.js',
-        uses: 'actions/setup-node@v4',
-        with: {
-            'node-version': nodeVersion,
-        },
-    };
-}
-function installDependenciesStep(command, checkActiveDeployment) {
-    return {
-        ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),
-        name: 'Install dependencies',
-        run: command,
-    };
-}
-function getPackageManagerCommandPrefix(packageManager) {
-    if (packageManager === projen_1.javascript.NodePackageManager.NPM) {
-        return 'npm run';
+const types_1 = require("./types");
+const checkActiveDeploymentStepId = 'deployment-check';
+const skipIfAlreadyActiveDeploymentCondition = `steps.${checkActiveDeploymentStepId}.outputs.has_active_deployment != 'true'`;
+/**
+ * Factory to create reusable steps for the deployment workflow
+ * @experimental
+ */
+class DeployableAwsCdkTypeScriptAppStepsFactory {
+    /**
+     * Validate that the provided environment deployment dependencies are valid
+     * @param deployOptions The deployment options
+     * @param environmentDependencies The environment deployment dependencies to validate
+     */
+    static validateEnvironmentDeploymentDependencies(deployOptions, environmentDependencies) {
+        if (deployOptions.jobStrategy !== types_1.DeployJobStrategy.MULTI_JOB) {
+            throw new Error('Environment deployment dependencies are only supported for MULTI_JOB strategy');
+        }
+        Object.entries(environmentDependencies).forEach(([env, deps]) => {
+            const hasEnvironment = deployOptions.environments.some(e => e.name === env);
+            if (!hasEnvironment) {
+                throw new Error(`Environment "${env}" defined in dependencies does not exist in deployOptions.environments`);
+            }
+            deps.forEach(dep => {
+                const hasDepEnvironment = deployOptions.environments.some(e => e.name === dep);
+                if (!hasDepEnvironment) {
+                    throw new Error(`Dependency environment "${dep}" for environment "${env}" does not exist in deployOptions.environments`);
+                }
+            });
+        });
     }
-    if (packageManager === projen_1.javascript.NodePackageManager.YARN) {
-        return 'yarn';
+    /**
+     * Create a new DeployableAwsCdkTypeScriptAppStepsFactory
+     * @param project The project
+     * @param props The factory properties
+     */
+    constructor(project, props) {
+        this.project = project;
+        this.props = props;
     }
-    if (packageManager === projen_1.javascript.NodePackageManager.PNPM) {
-        return 'pnpm';
+    /**
+     * Condition to skip a step if an active deployment is already present
+     * @returns JobStep condition or undefined if checkActiveDeployment is false
+     */
+    get skipIfAlreadyActiveDeploymentCondition() {
+        return this.props.checkActiveDeployment ? { if: `\${{ ${skipIfAlreadyActiveDeploymentCondition} }}` } : undefined;
     }
-    throw new Error(`Invalid package manager selected (${packageManager})`);
-}
-function deploymentStep(checkActiveDeployment, packageManager) {
-    return {
-        ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),
-        name: 'Deployment',
-        run: `${getPackageManagerCommandPrefix(packageManager)} deploy:workflow`,
-    };
-}
-function setAwsCredentialsInEnvironment(checkActiveDeployment) {
-    const commands = [
-        'echo "AWS_ACCESS_KEY_ID=$accessKeyId" >> $GITHUB_ENV',
-        'echo "AWS_SECRET_ACCESS_KEY=$secretAccessKey" >> $GITHUB_ENV',
-        'echo "AWS_REGION=$region" >> $GITHUB_ENV',
-    ];
-    const condition = checkActiveDeployment ?
-        `\${{ matrix.assumeRole == 'false' && ${skipIfAlreadyActiveDeploymentCondition} }}` :
-        '${{ matrix.assumeRole == \'false\' }}';
-    return {
-        if: condition,
-        name: 'Configure AWS Credentials',
-        run: `${commands.join('\n')}`,
-        env: {
-            accessKeyId: '${{ secrets[matrix.accessKeyIdSecretName] }}',
-            secretAccessKey: '${{ secrets[matrix.secretAccessKeySecretName] }}',
-            region: '${{ matrix.region }}',
-        },
-    };
-}
-function assumeAwsRoleStep(checkActiveDeployment, authProvider) {
-    const condition = checkActiveDeployment ?
-        `\${{ matrix.assumeRole == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :
-        '${{ matrix.assumeRole == \'true\' }}';
-    const secretsParams = authProvider === javascript_1.CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR ?
-        {
-            'aws-access-key-id': '${{ secrets[matrix.accessKeyIdSecretName] }}',
-            'aws-secret-access-key': '${{ secrets[matrix.secretAccessKeySecretName] }}',
+    get checkoutStep() {
+        return github_1.WorkflowSteps.checkout({
+            with: {
+                fetchDepth: 0,
+                ref: '${{ github.sha }}',
+            },
+        });
+    }
+    /**
+     * Step to run before installing dependencies if exists
+     * @returns JobStep or undefined if no preInstallTaskName is provided
+     */
+    get preInstallDependenciesStep() {
+        if (!this.props.preInstallTaskName) {
+            return undefined;
+        }
+        return {
+            ...this.skipIfAlreadyActiveDeploymentCondition,
+            name: this.props.preInstallTaskName,
+            run: `npx projen ${this.props.preInstallTaskName}`,
+        };
+    }
+    /**
+     * Step to check if there is an active deployment for the environment in the matrix strategy
+     * @returns JobStep
+     */
+    get checkActiveDeploymentStepForMatrix() {
+        return this.getCheckActiveDeploymentStepForEnvironment('${{ matrix.environment }}');
+    }
+    /**
+     * Step to check if there is an active deployment for a specific environment
+     * @param environment The environment to check
+     * @returns JobStep
+     */
+    getCheckActiveDeploymentStepForEnvironment(environment) {
+        if (!this.props.checkActiveDeployment) {
+            return undefined;
+        }
+        return {
+            id: checkActiveDeploymentStepId,
+            uses: 'AminFazlMondo/check-deployed-environment@v1',
+            with: {
+                environment: environment,
+            },
+            env: {
+                GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',
+            },
+        };
+    }
+    /**
+     * Step to setup AWS credentials in the environment for the matrix strategy
+     * @returns JobStep[]
+     */
+    get setupAwsCredentialsStepsForMatrix() {
+        return [
+            this.setupAwsCredentialsInEnvironmentForMatrix,
+            this.assumeAwsRoleStepForMatrix,
+        ];
+    }
+    /**
+     * Get the steps to setup AWS credentials for a specific environment
+     * @param environmentOptions The environment options
+     * @returns JobStep[]
+     */
+    getSetupAwsCredentialsStepsForEnvironment(environmentOptions) {
+        const steps = [];
+        const fromEnvVariableStep = this.getSetupAwsCredentialsInEnvironmentForEnvironment(environmentOptions.awsCredentials.roleToAssume ? true : false, environmentOptions.awsCredentials.accessKeyIdSecretName ?? 'AWS_ACCESS_KEY_ID', environmentOptions.awsCredentials.secretAccessKeySecretName ?? 'AWS_SECRET_ACCESS_KEY', environmentOptions.awsCredentials.region);
+        if (fromEnvVariableStep) {
+            steps.push(fromEnvVariableStep);
+        }
+        const assumeRoleStep = this.getAssumeAwsRoleStepForEnvironment(environmentOptions.awsCredentials.roleToAssume ? true : false, environmentOptions.awsCredentials.accessKeyIdSecretName ?? 'AWS_ACCESS_KEY_ID', environmentOptions.awsCredentials.secretAccessKeySecretName ?? 'AWS_SECRET_ACCESS_KEY', environmentOptions.awsCredentials.region, environmentOptions.awsCredentials.roleToAssume ?? '', environmentOptions.awsCredentials.assumeRoleDurationSeconds ?? 900);
+        if (assumeRoleStep) {
+            steps.push(assumeRoleStep);
+        }
+        return steps;
+    }
+    /**
+     * Step to setup AWS credentials in the environment for the matrix strategy
+     * @returns JobStep
+     */
+    get setupAwsCredentialsInEnvironmentForMatrix() {
+        return this.getSetupAwsCredentialsInEnvironmentForEnvironment('matrix.assumeRole', 'matrix.accessKeyIdSecretName', 'matrix.secretAccessKeySecretName', '${{ matrix.region }}');
+    }
+    /**
+     * Step to setup AWS credentials in the environment for a specific environment
+     * @param assumeRoleFlag Whether to assume a role, can be a boolean or a string for matrix strategy
+     * @param accessKeyIdSecretName The GitHub secret name for the access key ID
+     * @param secretAccessKeySecretName The GitHub secret name for the secret access key
+     * @param region The region
+     * @returns JobStep or undefined if no AWS credentials are provided,
+     * if assumeRoleFlag is boolean will be evaluated and return a JobStep only if false
+     * if assumeRoleFlag is string will always return a JobStep (for matrix strategy)
+     */
+    getSetupAwsCredentialsInEnvironmentForEnvironment(assumeRoleFlag, accessKeyIdSecretName, secretAccessKeySecretName, region) {
+        function getCondition(factory) {
+            if (typeof assumeRoleFlag === 'boolean') {
+                if (assumeRoleFlag) {
+                    return undefined;
+                }
+                return factory.props.checkActiveDeployment ? skipIfAlreadyActiveDeploymentCondition : undefined;
+            }
+            return factory.props.checkActiveDeployment ?
+                `\${{ ${assumeRoleFlag} == 'false' && ${skipIfAlreadyActiveDeploymentCondition} }}` :
+                `\${{ ${assumeRoleFlag} == 'false' }}`;
+        }
+        const commands = [
+            'echo "AWS_ACCESS_KEY_ID=$accessKeyId" >> $GITHUB_ENV',
+            'echo "AWS_SECRET_ACCESS_KEY=$secretAccessKey" >> $GITHUB_ENV',
+            'echo "AWS_REGION=$region" >> $GITHUB_ENV',
+        ];
+        if (typeof assumeRoleFlag === 'boolean' && assumeRoleFlag) {
+            return undefined;
+        }
+        const condition = getCondition(this);
+        return {
+            if: condition,
+            name: 'Configure AWS Credentials',
+            run: `${commands.join('\n')}`,
+            env: {
+                accessKeyId: `\${{ secrets[${accessKeyIdSecretName}] }}`,
+                secretAccessKey: `\${{ secrets[${secretAccessKeySecretName}] }}`,
+                region,
+            },
+        };
+    }
+    /**
+     * Step to assume an AWS role for the matrix strategy
+     * @returns JobStep
+     */
+    get assumeAwsRoleStepForMatrix() {
+        return this.getAssumeAwsRoleStepForEnvironment('matrix.assumeRole', 'matrix.accessKeyIdSecretName', 'matrix.secretAccessKeySecretName', '${{ matrix.region }}', '${{ matrix.roleToAssume }}', '${{ matrix.assumeRoleDurationSeconds }}');
+    }
+    /**
+     * Step to assume an AWS role for a specific environment
+     * @param assumeRoleFlag Whether to assume a role, can be a boolean or a string for matrix strategy
+     * @param accessKeyIdSecretName The GitHub secret name for the access key ID
+     * @param secretAccessKeySecretName The GitHub secret name for the secret access key
+     * @param region The region
+     * @param roleToAssume The role to assume
+     * @param assumeRoleDurationSeconds The duration for assuming the role
+     * @returns JobStep or undefined if assumeRoleFlag is boolean and false
+     * if assumeRoleFlag is string will always return a JobStep (for matrix strategy)
+     */
+    getAssumeAwsRoleStepForEnvironment(assumeRoleFlag, accessKeyIdSecretName, secretAccessKeySecretName, region, roleToAssume, assumeRoleDurationSeconds) {
+        function getCondition(factory) {
+            if (typeof assumeRoleFlag === 'boolean') {
+                if (!assumeRoleFlag) {
+                    return undefined;
+                }
+                return factory.props.checkActiveDeployment ? skipIfAlreadyActiveDeploymentCondition : undefined;
+            }
+            return factory.props.checkActiveDeployment ?
+                `\${{ ${assumeRoleFlag} == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :
+                `\${{ ${assumeRoleFlag} == 'true' }}`;
+        }
+        if (typeof assumeRoleFlag === 'boolean' && !assumeRoleFlag) {
+            return undefined;
+        }
+        const condition = getCondition(this);
+        const secretsParams = this.props.authProvider === javascript_1.CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR ?
+            {
+                'aws-access-key-id': `\${{ secrets[${accessKeyIdSecretName}] }}`,
+                'aws-secret-access-key': `\${{ secrets[${secretAccessKeySecretName}] }}`,
+            } : undefined;
+        return {
+            if: condition,
+            name: 'Assume AWS Role',
+            uses: 'aws-actions/configure-aws-credentials@v4',
+            with: {
+                ...secretsParams,
+                'role-to-assume': roleToAssume,
+                'aws-region': region,
+                'role-duration-seconds': assumeRoleDurationSeconds,
+            },
+        };
+    }
+    /**
+     * Step to setup NPM config if provided
+     * @returns JobStep or undefined if no npmConfig is provided
+     */
+    get setupNpmConfigForMatrix() {
+        return this.getSetupNpmConfigForEnvironment('${{ matrix.environment }}');
+    }
+    getSetupNpmConfigForEnvironment(environment) {
+        const { npmConfigEnvironment } = this.props;
+        if (!npmConfigEnvironment) {
+            return undefined;
+        }
+        const environmentVariableName = 'CONFIG_VALUE';
+        return {
+            ...this.skipIfAlreadyActiveDeploymentCondition,
+            name: 'Setting NPM Config',
+            env: {
+                [environmentVariableName]: environment,
+            },
+            run: `npm config set ${npmConfigEnvironment} $${environmentVariableName}`,
+        };
+    }
+    /**
+     * Get the step to run a specific script
+     * @param scriptName The name of the script to run
+     * @param stepName The name of the step in the workflow
+     * @param hasScriptFlag Whether the script should be run
+     * @returns The job step to run the script or undefined if not applicable
+     * If hasScriptFlag is boolean and false will return undefined
+     * If hasScriptFlag is string will always return a JobStep (for matrix strategy)
+     */
+    getRunScriptStep(scriptName, stepName, hasScriptFlag) {
+        function getCondition(factory) {
+            if (typeof hasScriptFlag === 'boolean') {
+                if (!hasScriptFlag) {
+                    return undefined;
+                }
+                return factory.props.checkActiveDeployment ? skipIfAlreadyActiveDeploymentCondition : undefined;
+            }
+            return factory.props.checkActiveDeployment ?
+                `\${{ ${hasScriptFlag} == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :
+                `\${{ ${hasScriptFlag} == 'true' }}`;
+        }
+        if (typeof hasScriptFlag === 'boolean' && !hasScriptFlag) {
+            return undefined;
+        }
+        const condition = getCondition(this);
+        return {
+            if: condition,
+            name: `Run ${stepName}`,
+            run: `${this.project.runScriptCommand} ${scriptName}`,
+        };
+    }
+    /**
+     * Step to deploy the workflow
+     * @returns JobStep
+     */
+    get deploymentStep() {
+        return this.getRunScriptStep('deploy:workflow', 'Deployment', true);
+    }
+    /**
+     * Step to run post deployment script in matrix strategy
+     * @returns JobStep
+     */
+    get preDeploymentStepForMatrix() {
+        return this.getPreDeploymentStepForEnvironment('matrix.hasPreDeployTask', '${{ matrix.preDeploymentScript }}');
+    }
+    /**
+     * Get the pre-deployment step for a specific environment
+     * @param hasPreDeployTaskFlag Whether the pre-deployment task should be run
+     * @param preDeploymentScript The script to run
+     * @returns The job step to run the pre-deployment script or undefined if not applicable
+     * If hasPreDeployTaskFlag is boolean and false will return undefined
+     * If hasPreDeployTaskFlag is string will always return a JobStep (for matrix strategy)
+     */
+    getPreDeploymentStepForEnvironment(hasPreDeployTaskFlag, preDeploymentScript) {
+        return this.getRunScriptStep(preDeploymentScript, 'Pre Deployment', hasPreDeployTaskFlag);
+    }
+    /**
+     * Step to run post deployment script in matrix strategy
+     * @returns JobStep
+     */
+    get postDeploymentStepForMatrix() {
+        return this.getPostDeploymentStepForEnvironment('matrix.hasPostDeployTask', '${{ matrix.postDeploymentScript }}');
+    }
+    /**
+     * Get the post-deployment step for a specific environment
+     * @param hasPostDeployTaskFlag Whether the post-deployment task should be run
+     * @param postDeploymentScript The script to run
+     * @returns The job step to run the post-deployment script or undefined if not applicable
+     * If hasPostDeployTaskFlag is boolean and false will return undefined
+     * If hasPostDeployTaskFlag is string will always return a JobStep (for matrix strategy)
+     */
+    getPostDeploymentStepForEnvironment(hasPostDeployTaskFlag, postDeploymentScript) {
+        return this.getRunScriptStep(postDeploymentScript, 'Post Deployment', hasPostDeployTaskFlag);
+    }
+    /**
+     * Get all deployment jobs whether for matrix strategy or not
+     * @returns Record of jobs
+     */
+    get deploymentJobs() {
+        if (this.props.deployOptions.environments.length === 0) {
+            this.project.logger.warn('The project does not have any environment set, make sure this is desired setting');
+        }
+        return this.props.jobStrategy === types_1.DeployJobStrategy.MATRIX ? this.deploymentJobsForMatrix : this.getDeploymentJobsForMultiJob();
+    }
+    /**
+     * Get deployment jobs for matrix strategy
+     * @returns Record of jobs
+     */
+    get deploymentJobsForMatrix() {
+        const { environments, environmentVariableName } = this.props.deployOptions;
+        const include = environments.map(environmentOptions => {
+            const { awsCredentials } = environmentOptions;
+            const assumeRole = awsCredentials.roleToAssume ? 'true' : 'false';
+            const assumeRoleSettings = awsCredentials.roleToAssume ? {
+                roleToAssume: awsCredentials.roleToAssume,
+                assumeRoleDurationSeconds: awsCredentials.assumeRoleDurationSeconds || 900,
+            } : undefined;
+            const accessKeyIdSecretName = awsCredentials.accessKeyIdSecretName ?? 'AWS_ACCESS_KEY_ID';
+            const secretAccessKeySecretName = awsCredentials.secretAccessKeySecretName ?? 'AWS_SECRET_ACCESS_KEY';
+            const hasPostDeployTask = environmentOptions.postDeployWorkflowScript ? 'true' : 'false';
+            const hasPreDeployTask = environmentOptions.preDeployWorkflowScript ? 'true' : 'false';
+            return {
+                environment: environmentOptions.name,
+                accessKeyIdSecretName,
+                secretAccessKeySecretName,
+                region: awsCredentials.region,
+                assumeRole,
+                hasPostDeployTask,
+                postDeploymentScript: environmentOptions.postDeployWorkflowScript || '',
+                hasPreDeployTask,
+                preDeploymentScript: environmentOptions.preDeployWorkflowScript || '',
+                ...assumeRoleSettings,
+            };
+        });
+        const deployJobEnv = environmentVariableName ? {
+            [environmentVariableName]: '${{ matrix.environment }}',
         } : undefined;
-    return {
-        if: condition,
-        name: 'Assume AWS Role',
-        uses: 'aws-actions/configure-aws-credentials@v4',
-        with: {
-            ...secretsParams,
-            'role-to-assume': '${{ matrix.roleToAssume }}',
-            'aws-region': '${{ matrix.region }}',
-            'role-duration-seconds': '${{ matrix.assumeRoleDurationSeconds }}',
-        },
-    };
-}
-function setAwsCredentialsSteps(checkActiveDeployment, authProvider = javascript_1.CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR) {
-    return [
-        setAwsCredentialsInEnvironment(checkActiveDeployment),
-        assumeAwsRoleStep(checkActiveDeployment, authProvider),
-    ];
-}
-function setNpmConfig(configName, configValue, checkActiveDeployment) {
-    const environmentVariableName = 'CONFIG_VALUE';
-    return {
-        ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),
-        name: 'Setting NPM Config',
-        env: {
-            [environmentVariableName]: configValue,
-        },
-        run: `npm config set ${configName} $${environmentVariableName}`,
-    };
-}
-const checkActiveDeploymentStepId = 'deployment-check';
-function checkActiveDeploymentStep() {
-    return {
-        id: checkActiveDeploymentStepId,
-        uses: 'AminFazlMondo/check-deployed-environment@v1',
-        with: {
-            environment: '${{ matrix.environment }}',
-        },
-        env: {
-            GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',
-        },
-    };
-}
-const skipIfAlreadyActiveDeploymentCondition = `steps.${checkActiveDeploymentStepId}.outputs.has_active_deployment != 'true'`;
-function getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment) {
-    return checkActiveDeployment ? { if: `\${{ ${skipIfAlreadyActiveDeploymentCondition} }}` } : undefined;
-}
-function postDeploymentStep(checkActiveDeployment, packageManager) {
-    const condition = checkActiveDeployment ?
-        `\${{ matrix.hasPostDeployTask == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :
-        '${{ matrix.hasPostDeployTask == \'true\' }}';
-    return {
-        if: condition,
-        name: 'Post Deployment',
-        run: `${getPackageManagerCommandPrefix(packageManager)} \${{ matrix.postDeploymentScript }}`,
-    };
-}
-function preDeploymentStep(checkActiveDeployment, packageManager) {
-    const condition = checkActiveDeployment ?
-        `\${{ matrix.hasPreDeployTask == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :
-        '${{ matrix.hasPreDeployTask == \'true\' }}';
-    return {
-        if: condition,
-        name: 'Pre Deployment',
-        run: `${getPackageManagerCommandPrefix(packageManager)} \${{ matrix.preDeploymentScript }}`,
-    };
+        const jobDefinition = {
+            runsOn: ['ubuntu-latest'],
+            concurrency: {
+                'group': '${{ matrix.environment }}-deploy',
+                'cancel-in-progress': false,
+            },
+            needs: [
+                'release_github',
+            ],
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                deployments: workflows_model_1.JobPermission.READ,
+                idToken: this.props.authProvider === javascript_1.CodeArtifactAuthProvider.GITHUB_OIDC ? workflows_model_1.JobPermission.WRITE : undefined,
+            },
+            strategy: {
+                maxParallel: 1,
+                matrix: {
+                    domain: {
+                        environment: include.map(e => e.environment),
+                    },
+                    include,
+                },
+            },
+            environment: {
+                name: '${{ matrix.environment }}',
+            },
+            env: deployJobEnv,
+            steps: [],
+        };
+        jobDefinition.steps.push(this.checkoutStep);
+        const preInstallDependenciesStep = this.preInstallDependenciesStep;
+        if (preInstallDependenciesStep) {
+            jobDefinition.steps.push(preInstallDependenciesStep);
+        }
+        jobDefinition.steps.push(...(this.project).renderWorkflowSetup());
+        const checkActiveDeploymentStepForMatrix = this.checkActiveDeploymentStepForMatrix;
+        if (checkActiveDeploymentStepForMatrix) {
+            jobDefinition.steps.push(checkActiveDeploymentStepForMatrix);
+        }
+        jobDefinition.steps.push(...this.setupAwsCredentialsStepsForMatrix);
+        const setupNpmConfigStep = this.setupNpmConfigForMatrix;
+        if (setupNpmConfigStep) {
+            jobDefinition.steps.push(setupNpmConfigStep);
+        }
+        jobDefinition.steps.push(this.preDeploymentStepForMatrix);
+        jobDefinition.steps.push(this.deploymentStep);
+        jobDefinition.steps.push(this.postDeploymentStepForMatrix);
+        return { deploy: jobDefinition };
+    }
+    /**
+     * Get the IDs of the jobs that must be completed before the specified environment's deployment job
+     * @param environmentName The name of the environment
+     * @returns An array of job IDs
+     */
+    getDeploymentJobPrerequisiteJobIds(environmentName) {
+        const result = ['release_github'];
+        if (!this.props.environmentDependencies) {
+            const index = this.props.deployOptions.environments.findIndex(env => env.name === environmentName);
+            const prerequisiteEnvironment = index > 0 ? this.props.deployOptions.environments[index - 1] : undefined;
+            if (prerequisiteEnvironment) {
+                result.push(getDeployJobId(prerequisiteEnvironment.name));
+            }
+        }
+        else {
+            const dependencies = this.props.environmentDependencies[environmentName];
+            if (dependencies) {
+                dependencies.forEach(dep => {
+                    result.push(getDeployJobId(dep));
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Get deployment jobs for multi-job strategy
+     * @returns Record of jobs
+     */
+    getDeploymentJobsForMultiJob() {
+        const { environmentVariableName, environments } = this.props.deployOptions;
+        const jobs = environments.map((environmentOptions) => {
+            return [getDeployJobId(environmentOptions.name), this.getJobForEnvironment(environmentOptions, environmentVariableName)];
+        });
+        return Object.fromEntries(jobs);
+    }
+    /**
+     * Get the job definition for a specific environment
+     * @param environmentOptions The environment options
+     * @param environmentVariableName The name of the environment variable to set with the environment name, if any
+     * @returns The job definition for the environment
+     */
+    getJobForEnvironment(environmentOptions, environmentVariableName) {
+        const { name } = environmentOptions;
+        const deployJobEnv = environmentVariableName ? {
+            [environmentVariableName]: name,
+        } : undefined;
+        const jobDefinition = {
+            runsOn: ['ubuntu-latest'],
+            concurrency: {
+                'group': `${name}-deploy`,
+                'cancel-in-progress': false,
+            },
+            needs: this.getDeploymentJobPrerequisiteJobIds(name),
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                deployments: workflows_model_1.JobPermission.READ,
+                idToken: this.props.authProvider === javascript_1.CodeArtifactAuthProvider.GITHUB_OIDC ? workflows_model_1.JobPermission.WRITE : undefined,
+            },
+            environment: {
+                name: name,
+            },
+            env: deployJobEnv,
+            steps: [],
+        };
+        jobDefinition.steps.push(this.checkoutStep);
+        const preInstallDependenciesStep = this.preInstallDependenciesStep;
+        if (preInstallDependenciesStep) {
+            jobDefinition.steps.push(preInstallDependenciesStep);
+        }
+        jobDefinition.steps.push(...(this.project).renderWorkflowSetup());
+        const checkActiveDeploymentStep = this.getCheckActiveDeploymentStepForEnvironment(name);
+        if (checkActiveDeploymentStep) {
+            jobDefinition.steps.push(checkActiveDeploymentStep);
+        }
+        jobDefinition.steps.push(...this.getSetupAwsCredentialsStepsForEnvironment(environmentOptions));
+        const setupNpmConfigStep = this.getSetupNpmConfigForEnvironment(name);
+        if (setupNpmConfigStep) {
+            jobDefinition.steps.push(setupNpmConfigStep);
+        }
+        const preDeploymentStep = this.getPreDeploymentStepForEnvironment(environmentOptions.preDeployWorkflowScript ? true : false, environmentOptions.preDeployWorkflowScript || '');
+        if (preDeploymentStep) {
+            jobDefinition.steps.push(preDeploymentStep);
+        }
+        jobDefinition.steps.push(this.deploymentStep);
+        const postDeploymentStep = this.getPostDeploymentStepForEnvironment(environmentOptions.postDeployWorkflowScript ? true : false, environmentOptions.postDeployWorkflowScript || '');
+        if (postDeploymentStep) {
+            jobDefinition.steps.push(postDeploymentStep);
+        }
+        return jobDefinition;
+    }
 }
-function preInstallDependenciesStep(taskName, checkActiveDeployment) {
-    return {
-        ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),
-        name: taskName,
-        run: `npx projen ${taskName}`,
-    };
+exports.DeployableAwsCdkTypeScriptAppStepsFactory = DeployableAwsCdkTypeScriptAppStepsFactory;
+function getDeployJobId(environmentName) {
+    return `Deploy-${environmentName}`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"steps.js","sourceRoot":"","sources":["../src/steps.ts"],"names":[],"mappings":"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","sourcesContent":["import { javascript } from 'projen';\nimport { JobStep } from 'projen/lib/github/workflows-model';\nimport { CodeArtifactAuthProvider } from 'projen/lib/javascript';\n\nexport function checkoutStep(): JobStep {\n  return {\n    name: 'Checkout',\n    uses: 'actions/checkout@v4',\n    with: {\n      'ref': '${{ github.sha }}',\n      'fetch-depth': 0,\n    },\n  };\n}\n\nexport function setNodeVersionStep(nodeVersion: string, checkActiveDeployment: boolean): JobStep {\n  return {\n    ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),\n    name: 'Setup Node.js',\n    uses: 'actions/setup-node@v4',\n    with: {\n      'node-version': nodeVersion,\n    },\n  };\n}\n\nexport function installDependenciesStep(command: string, checkActiveDeployment: boolean): JobStep {\n  return {\n    ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),\n    name: 'Install dependencies',\n    run: command,\n  };\n}\n\nfunction getPackageManagerCommandPrefix(packageManager: javascript.NodePackageManager): string {\n  if (packageManager === javascript.NodePackageManager.NPM) {return 'npm run';}\n\n  if (packageManager === javascript.NodePackageManager.YARN) {return 'yarn';}\n\n  if (packageManager === javascript.NodePackageManager.PNPM) {return 'pnpm';}\n\n  throw new Error(`Invalid package manager selected (${packageManager})`);\n}\n\nexport function deploymentStep(checkActiveDeployment: boolean, packageManager: javascript.NodePackageManager): JobStep {\n\n  return {\n    ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),\n    name: 'Deployment',\n    run: `${getPackageManagerCommandPrefix(packageManager)} deploy:workflow`,\n  };\n}\n\nfunction setAwsCredentialsInEnvironment(checkActiveDeployment: boolean): JobStep {\n  const commands = [\n    'echo \"AWS_ACCESS_KEY_ID=$accessKeyId\" >> $GITHUB_ENV',\n    'echo \"AWS_SECRET_ACCESS_KEY=$secretAccessKey\" >> $GITHUB_ENV',\n    'echo \"AWS_REGION=$region\" >> $GITHUB_ENV',\n  ];\n\n  const condition =\n    checkActiveDeployment ?\n      `\\${{ matrix.assumeRole == 'false' && ${skipIfAlreadyActiveDeploymentCondition} }}` :\n      '${{ matrix.assumeRole == \\'false\\' }}';\n\n  return {\n    if: condition,\n    name: 'Configure AWS Credentials',\n    run: `${commands.join('\\n')}`,\n    env: {\n      accessKeyId: '${{ secrets[matrix.accessKeyIdSecretName] }}',\n      secretAccessKey: '${{ secrets[matrix.secretAccessKeySecretName] }}',\n      region: '${{ matrix.region }}',\n    },\n  };\n}\n\nfunction assumeAwsRoleStep(checkActiveDeployment: boolean, authProvider: CodeArtifactAuthProvider): JobStep {\n  const condition =\n    checkActiveDeployment ?\n      `\\${{ matrix.assumeRole == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :\n      '${{ matrix.assumeRole == \\'true\\' }}';\n\n  const secretsParams =\n    authProvider === CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR ?\n      {\n        'aws-access-key-id': '${{ secrets[matrix.accessKeyIdSecretName] }}',\n        'aws-secret-access-key': '${{ secrets[matrix.secretAccessKeySecretName] }}',\n      } : undefined;\n  return {\n    if: condition,\n    name: 'Assume AWS Role',\n    uses: 'aws-actions/configure-aws-credentials@v4',\n    with: {\n      ...secretsParams,\n      'role-to-assume': '${{ matrix.roleToAssume }}',\n      'aws-region': '${{ matrix.region }}',\n      'role-duration-seconds': '${{ matrix.assumeRoleDurationSeconds }}',\n    },\n  };\n}\n\nexport function setAwsCredentialsSteps(\n  checkActiveDeployment: boolean,\n  authProvider: CodeArtifactAuthProvider = CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR)\n  : JobStep[] {\n  return [\n    setAwsCredentialsInEnvironment(checkActiveDeployment),\n    assumeAwsRoleStep(checkActiveDeployment, authProvider),\n  ];\n}\n\nexport function setNpmConfig(configName: string, configValue: string, checkActiveDeployment: boolean): JobStep {\n  const environmentVariableName = 'CONFIG_VALUE';\n  return {\n    ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),\n    name: 'Setting NPM Config',\n    env: {\n      [environmentVariableName]: configValue,\n    },\n    run: `npm config set ${configName} $${environmentVariableName}`,\n  };\n}\n\nconst checkActiveDeploymentStepId = 'deployment-check';\nexport function checkActiveDeploymentStep(): JobStep {\n  return {\n    id: checkActiveDeploymentStepId,\n    uses: 'AminFazlMondo/check-deployed-environment@v1',\n    with: {\n      environment: '${{ matrix.environment }}',\n    },\n    env: {\n      GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n    },\n  };\n}\n\nconst skipIfAlreadyActiveDeploymentCondition= `steps.${checkActiveDeploymentStepId}.outputs.has_active_deployment != 'true'`;\n\nfunction getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment: boolean): JobStep | undefined {\n  return checkActiveDeployment ? { if: `\\${{ ${skipIfAlreadyActiveDeploymentCondition} }}` } : undefined;\n}\n\nexport function postDeploymentStep(checkActiveDeployment: boolean, packageManager: javascript.NodePackageManager): JobStep {\n  const condition =\n  checkActiveDeployment ?\n    `\\${{ matrix.hasPostDeployTask == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :\n    '${{ matrix.hasPostDeployTask == \\'true\\' }}';\n  return {\n    if: condition,\n    name: 'Post Deployment',\n    run: `${getPackageManagerCommandPrefix(packageManager)} \\${{ matrix.postDeploymentScript }}`,\n  };\n}\n\nexport function preDeploymentStep(checkActiveDeployment: boolean, packageManager: javascript.NodePackageManager): JobStep {\n  const condition =\n  checkActiveDeployment ?\n    `\\${{ matrix.hasPreDeployTask == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :\n    '${{ matrix.hasPreDeployTask == \\'true\\' }}';\n  return {\n    if: condition,\n    name: 'Pre Deployment',\n    run: `${getPackageManagerCommandPrefix(packageManager)} \\${{ matrix.preDeploymentScript }}`,\n  };\n}\n\nexport function preInstallDependenciesStep(taskName: string, checkActiveDeployment: boolean): JobStep {\n  return {\n    ...getSkipIfAlreadyActiveDeploymentCondition(checkActiveDeployment),\n    name: taskName,\n    run: `npx projen ${taskName}`,\n  };\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"steps.js","sourceRoot":"","sources":["../src/steps.ts"],"names":[],"mappings":"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","sourcesContent":["import { javascript } from 'projen';\nimport { WorkflowSteps } from 'projen/lib/github';\nimport { JobPermission, JobStep, Job } from 'projen/lib/github/workflows-model';\nimport { CodeArtifactAuthProvider } from 'projen/lib/javascript';\nimport { DeployJobStrategy, DeployOptions, EnvironmentDeploymentDependencies, EnvironmentOptions } from './types';\n\nconst checkActiveDeploymentStepId = 'deployment-check';\nconst skipIfAlreadyActiveDeploymentCondition= `steps.${checkActiveDeploymentStepId}.outputs.has_active_deployment != 'true'`;\n\nexport interface DeployableAwsCdkTypeScriptAppStepsFactoryProps {\n  /**\n   * Deployment options\n   */\n  readonly deployOptions: DeployOptions;\n\n  /**\n   * Whether to check for active deployments before proceeding with deployment\n   */\n  readonly checkActiveDeployment: boolean;\n\n  /**\n   * The name of the task to run before installing dependencies, if any\n   */\n  readonly preInstallTaskName?: string;\n\n  /**\n   * The authentication provider for CodeArtifact, if any\n   */\n  readonly authProvider?: CodeArtifactAuthProvider;\n\n  /**\n   * The npm config to set with the environment that is being deployed, if any\n   * Note: This is not supported for node versions above 18\n   */\n  readonly npmConfigEnvironment?: string;\n\n  /**\n   * Deployment job strategy, whether to use a matrix job or multiple jobs for each environment\n   */\n  readonly jobStrategy: DeployJobStrategy;\n\n  /**\n   * Environment deployment dependencies, if any\n   */\n  readonly environmentDependencies?: EnvironmentDeploymentDependencies;\n}\n\n/**\n * Factory to create reusable steps for the deployment workflow\n * @experimental\n */\nexport class DeployableAwsCdkTypeScriptAppStepsFactory {\n\n  /**\n   * Validate that the provided environment deployment dependencies are valid\n   * @param deployOptions The deployment options\n   * @param environmentDependencies The environment deployment dependencies to validate\n   */\n  public static validateEnvironmentDeploymentDependencies(\n    deployOptions: DeployOptions,\n    environmentDependencies: EnvironmentDeploymentDependencies,\n  ): void {\n\n    if (deployOptions.jobStrategy !== DeployJobStrategy.MULTI_JOB) {\n      throw new Error('Environment deployment dependencies are only supported for MULTI_JOB strategy');\n    }\n\n    Object.entries(environmentDependencies).forEach(([env, deps]) => {\n      const hasEnvironment = deployOptions.environments.some(e => e.name === env);\n      if (!hasEnvironment) {\n        throw new Error(`Environment \"${env}\" defined in dependencies does not exist in deployOptions.environments`);\n      }\n      deps.forEach(dep => {\n        const hasDepEnvironment = deployOptions.environments.some(e => e.name === dep);\n        if (!hasDepEnvironment) {\n          throw new Error(`Dependency environment \"${dep}\" for environment \"${env}\" does not exist in deployOptions.environments`);\n        }\n      });\n    });\n  }\n\n  /**\n   * Create a new DeployableAwsCdkTypeScriptAppStepsFactory\n   * @param project The project\n   * @param props The factory properties\n   */\n  constructor(\n    private readonly project: javascript.NodeProject,\n    private readonly props: DeployableAwsCdkTypeScriptAppStepsFactoryProps,\n  ) {}\n\n  /**\n   * Condition to skip a step if an active deployment is already present\n   * @returns JobStep condition or undefined if checkActiveDeployment is false\n   */\n  public get skipIfAlreadyActiveDeploymentCondition(): JobStep | undefined {\n    return this.props.checkActiveDeployment ? { if: `\\${{ ${skipIfAlreadyActiveDeploymentCondition} }}` } : undefined;\n  }\n\n  public get checkoutStep(): JobStep {\n    return WorkflowSteps.checkout({\n      with: {\n        fetchDepth: 0,\n        ref: '${{ github.sha }}',\n      },\n    });\n  }\n\n  /**\n   * Step to run before installing dependencies if exists\n   * @returns JobStep or undefined if no preInstallTaskName is provided\n   */\n  public get preInstallDependenciesStep(): JobStep | undefined {\n    if (!this.props.preInstallTaskName) {\n      return undefined;\n    }\n\n    return {\n      ...this.skipIfAlreadyActiveDeploymentCondition,\n      name: this.props.preInstallTaskName,\n      run: `npx projen ${this.props.preInstallTaskName}`,\n    };\n  }\n\n  /**\n   * Step to check if there is an active deployment for the environment in the matrix strategy\n   * @returns JobStep\n   */\n  public get checkActiveDeploymentStepForMatrix(): JobStep | undefined {\n    return this.getCheckActiveDeploymentStepForEnvironment('${{ matrix.environment }}');\n  }\n\n  /**\n   * Step to check if there is an active deployment for a specific environment\n   * @param environment The environment to check\n   * @returns JobStep\n   */\n  public getCheckActiveDeploymentStepForEnvironment(environment: string): JobStep | undefined {\n    if (!this.props.checkActiveDeployment) {\n      return undefined;\n    }\n\n    return {\n      id: checkActiveDeploymentStepId,\n      uses: 'AminFazlMondo/check-deployed-environment@v1',\n      with: {\n        environment: environment,\n      },\n      env: {\n        GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n      },\n    };\n  }\n\n  /**\n   * Step to setup AWS credentials in the environment for the matrix strategy\n   * @returns JobStep[]\n   */\n  public get setupAwsCredentialsStepsForMatrix(): JobStep[] {\n    return [\n      this.setupAwsCredentialsInEnvironmentForMatrix,\n      this.assumeAwsRoleStepForMatrix,\n    ];\n  }\n\n  /**\n   * Get the steps to setup AWS credentials for a specific environment\n   * @param environmentOptions The environment options\n   * @returns JobStep[]\n   */\n  public getSetupAwsCredentialsStepsForEnvironment(environmentOptions: EnvironmentOptions): JobStep[] {\n    const steps: JobStep[] = [];\n\n    const fromEnvVariableStep = this.getSetupAwsCredentialsInEnvironmentForEnvironment(\n      environmentOptions.awsCredentials.roleToAssume ? true : false,\n      environmentOptions.awsCredentials.accessKeyIdSecretName ?? 'AWS_ACCESS_KEY_ID',\n      environmentOptions.awsCredentials.secretAccessKeySecretName ?? 'AWS_SECRET_ACCESS_KEY',\n      environmentOptions.awsCredentials.region,\n    );\n\n    if (fromEnvVariableStep) {\n      steps.push(fromEnvVariableStep);\n    }\n\n    const assumeRoleStep = this.getAssumeAwsRoleStepForEnvironment(\n      environmentOptions.awsCredentials.roleToAssume ? true : false,\n      environmentOptions.awsCredentials.accessKeyIdSecretName ?? 'AWS_ACCESS_KEY_ID',\n      environmentOptions.awsCredentials.secretAccessKeySecretName ?? 'AWS_SECRET_ACCESS_KEY',\n      environmentOptions.awsCredentials.region,\n      environmentOptions.awsCredentials.roleToAssume ?? '',\n      environmentOptions.awsCredentials.assumeRoleDurationSeconds ?? 900,\n    );\n\n    if (assumeRoleStep) {\n      steps.push(assumeRoleStep);\n    }\n\n    return steps;\n  }\n\n  /**\n   * Step to setup AWS credentials in the environment for the matrix strategy\n   * @returns JobStep\n   */\n  public get setupAwsCredentialsInEnvironmentForMatrix(): JobStep {\n    return this.getSetupAwsCredentialsInEnvironmentForEnvironment(\n      'matrix.assumeRole',\n      'matrix.accessKeyIdSecretName',\n      'matrix.secretAccessKeySecretName',\n      '${{ matrix.region }}',\n    )!;\n  }\n\n  /**\n   * Step to setup AWS credentials in the environment for a specific environment\n   * @param assumeRoleFlag Whether to assume a role, can be a boolean or a string for matrix strategy\n   * @param accessKeyIdSecretName The GitHub secret name for the access key ID\n   * @param secretAccessKeySecretName The GitHub secret name for the secret access key\n   * @param region The region\n   * @returns JobStep or undefined if no AWS credentials are provided,\n   * if assumeRoleFlag is boolean will be evaluated and return a JobStep only if false\n   * if assumeRoleFlag is string will always return a JobStep (for matrix strategy)\n   */\n  public getSetupAwsCredentialsInEnvironmentForEnvironment(\n    assumeRoleFlag: boolean | string,\n    accessKeyIdSecretName: string,\n    secretAccessKeySecretName: string,\n    region: string,\n  ): JobStep | undefined {\n\n    function getCondition(factory: DeployableAwsCdkTypeScriptAppStepsFactory) {\n      if (typeof assumeRoleFlag === 'boolean') {\n        if (assumeRoleFlag) {\n          return undefined;\n        }\n        return factory.props.checkActiveDeployment ? skipIfAlreadyActiveDeploymentCondition : undefined;\n      }\n      return factory.props.checkActiveDeployment ?\n        `\\${{ ${assumeRoleFlag} == 'false' && ${skipIfAlreadyActiveDeploymentCondition} }}` :\n        `\\${{ ${assumeRoleFlag} == 'false' }}`;\n    }\n\n    const commands = [\n      'echo \"AWS_ACCESS_KEY_ID=$accessKeyId\" >> $GITHUB_ENV',\n      'echo \"AWS_SECRET_ACCESS_KEY=$secretAccessKey\" >> $GITHUB_ENV',\n      'echo \"AWS_REGION=$region\" >> $GITHUB_ENV',\n    ];\n\n    if (typeof assumeRoleFlag === 'boolean' && assumeRoleFlag) {\n      return undefined;\n    }\n\n    const condition = getCondition(this);\n\n    return {\n      if: condition,\n      name: 'Configure AWS Credentials',\n      run: `${commands.join('\\n')}`,\n      env: {\n        accessKeyId: `\\${{ secrets[${accessKeyIdSecretName}] }}`,\n        secretAccessKey: `\\${{ secrets[${secretAccessKeySecretName}] }}`,\n        region,\n      },\n    };\n  }\n\n  /**\n   * Step to assume an AWS role for the matrix strategy\n   * @returns JobStep\n   */\n  public get assumeAwsRoleStepForMatrix(): JobStep {\n    return this.getAssumeAwsRoleStepForEnvironment(\n      'matrix.assumeRole',\n      'matrix.accessKeyIdSecretName',\n      'matrix.secretAccessKeySecretName',\n      '${{ matrix.region }}',\n      '${{ matrix.roleToAssume }}',\n      '${{ matrix.assumeRoleDurationSeconds }}',\n    )!;\n  }\n\n  /**\n   * Step to assume an AWS role for a specific environment\n   * @param assumeRoleFlag Whether to assume a role, can be a boolean or a string for matrix strategy\n   * @param accessKeyIdSecretName The GitHub secret name for the access key ID\n   * @param secretAccessKeySecretName The GitHub secret name for the secret access key\n   * @param region The region\n   * @param roleToAssume The role to assume\n   * @param assumeRoleDurationSeconds The duration for assuming the role\n   * @returns JobStep or undefined if assumeRoleFlag is boolean and false\n   * if assumeRoleFlag is string will always return a JobStep (for matrix strategy)\n   */\n  public getAssumeAwsRoleStepForEnvironment(\n    assumeRoleFlag: boolean | string,\n    accessKeyIdSecretName: string,\n    secretAccessKeySecretName: string,\n    region: string,\n    roleToAssume: string,\n    assumeRoleDurationSeconds?: string | number,\n  ): JobStep | undefined {\n    function getCondition(factory: DeployableAwsCdkTypeScriptAppStepsFactory) {\n      if (typeof assumeRoleFlag === 'boolean') {\n        if (!assumeRoleFlag) {\n          return undefined;\n        }\n        return factory.props.checkActiveDeployment ? skipIfAlreadyActiveDeploymentCondition : undefined;\n      }\n      return factory.props.checkActiveDeployment ?\n        `\\${{ ${assumeRoleFlag} == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :\n        `\\${{ ${assumeRoleFlag} == 'true' }}`;\n    }\n\n    if (typeof assumeRoleFlag === 'boolean' && !assumeRoleFlag) {\n      return undefined;\n    }\n\n    const condition = getCondition(this);\n\n    const secretsParams =\n      this.props.authProvider === CodeArtifactAuthProvider.ACCESS_AND_SECRET_KEY_PAIR ?\n        {\n          'aws-access-key-id': `\\${{ secrets[${accessKeyIdSecretName}] }}`,\n          'aws-secret-access-key': `\\${{ secrets[${secretAccessKeySecretName}] }}`,\n        } : undefined;\n    return {\n      if: condition,\n      name: 'Assume AWS Role',\n      uses: 'aws-actions/configure-aws-credentials@v4',\n      with: {\n        ...secretsParams,\n        'role-to-assume': roleToAssume,\n        'aws-region': region,\n        'role-duration-seconds': assumeRoleDurationSeconds,\n      },\n    };\n  }\n\n  /**\n   * Step to setup NPM config if provided\n   * @returns JobStep or undefined if no npmConfig is provided\n   */\n  public get setupNpmConfigForMatrix(): JobStep | undefined {\n    return this.getSetupNpmConfigForEnvironment('${{ matrix.environment }}');\n  }\n\n  public getSetupNpmConfigForEnvironment(environment: string): JobStep | undefined {\n    const { npmConfigEnvironment } = this.props;\n    if (!npmConfigEnvironment) {\n      return undefined;\n    }\n\n    const environmentVariableName = 'CONFIG_VALUE';\n    return {\n      ...this.skipIfAlreadyActiveDeploymentCondition,\n      name: 'Setting NPM Config',\n      env: {\n        [environmentVariableName]: environment,\n      },\n      run: `npm config set ${npmConfigEnvironment} $${environmentVariableName}`,\n    };\n  }\n\n  /**\n   * Get the step to run a specific script\n   * @param scriptName The name of the script to run\n   * @param stepName The name of the step in the workflow\n   * @param hasScriptFlag Whether the script should be run\n   * @returns The job step to run the script or undefined if not applicable\n   * If hasScriptFlag is boolean and false will return undefined\n   * If hasScriptFlag is string will always return a JobStep (for matrix strategy)\n   */\n  public getRunScriptStep(\n    scriptName: string,\n    stepName: string,\n    hasScriptFlag: boolean | string,\n  ): JobStep | undefined {\n    function getCondition(factory: DeployableAwsCdkTypeScriptAppStepsFactory) {\n      if (typeof hasScriptFlag === 'boolean') {\n        if (!hasScriptFlag) {\n          return undefined;\n        }\n        return factory.props.checkActiveDeployment ? skipIfAlreadyActiveDeploymentCondition : undefined;\n      }\n      return factory.props.checkActiveDeployment ?\n        `\\${{ ${hasScriptFlag} == 'true' && ${skipIfAlreadyActiveDeploymentCondition} }}` :\n        `\\${{ ${hasScriptFlag} == 'true' }}`;\n    }\n    if (typeof hasScriptFlag === 'boolean' && !hasScriptFlag) {\n      return undefined;\n    }\n\n    const condition = getCondition(this);\n\n    return {\n      if: condition,\n      name: `Run ${stepName}`,\n      run: `${this.project.runScriptCommand} ${scriptName}`,\n    };\n  }\n\n  /**\n   * Step to deploy the workflow\n   * @returns JobStep\n   */\n  public get deploymentStep(): JobStep {\n    return this.getRunScriptStep(\n      'deploy:workflow',\n      'Deployment',\n      true,\n    )!;\n  }\n\n  /**\n   * Step to run post deployment script in matrix strategy\n   * @returns JobStep\n   */\n  public get preDeploymentStepForMatrix(): JobStep {\n    return this.getPreDeploymentStepForEnvironment(\n      'matrix.hasPreDeployTask',\n      '${{ matrix.preDeploymentScript }}',\n    )!;\n  }\n\n  /**\n   * Get the pre-deployment step for a specific environment\n   * @param hasPreDeployTaskFlag Whether the pre-deployment task should be run\n   * @param preDeploymentScript The script to run\n   * @returns The job step to run the pre-deployment script or undefined if not applicable\n   * If hasPreDeployTaskFlag is boolean and false will return undefined\n   * If hasPreDeployTaskFlag is string will always return a JobStep (for matrix strategy)\n   */\n  public getPreDeploymentStepForEnvironment(\n    hasPreDeployTaskFlag: boolean | string,\n    preDeploymentScript: string,\n  ): JobStep | undefined {\n\n    return this.getRunScriptStep(\n      preDeploymentScript,\n      'Pre Deployment',\n      hasPreDeployTaskFlag,\n    );\n  }\n\n  /**\n   * Step to run post deployment script in matrix strategy\n   * @returns JobStep\n   */\n  public get postDeploymentStepForMatrix(): JobStep {\n    return this.getPostDeploymentStepForEnvironment(\n      'matrix.hasPostDeployTask',\n      '${{ matrix.postDeploymentScript }}',\n    )!;\n  }\n\n  /**\n   * Get the post-deployment step for a specific environment\n   * @param hasPostDeployTaskFlag Whether the post-deployment task should be run\n   * @param postDeploymentScript The script to run\n   * @returns The job step to run the post-deployment script or undefined if not applicable\n   * If hasPostDeployTaskFlag is boolean and false will return undefined\n   * If hasPostDeployTaskFlag is string will always return a JobStep (for matrix strategy)\n   */\n  public getPostDeploymentStepForEnvironment(\n    hasPostDeployTaskFlag: boolean | string,\n    postDeploymentScript: string,\n  ): JobStep | undefined {\n\n    return this.getRunScriptStep(\n      postDeploymentScript,\n      'Post Deployment',\n      hasPostDeployTaskFlag,\n    );\n  }\n\n  /**\n   * Get all deployment jobs whether for matrix strategy or not\n   * @returns Record of jobs\n   */\n  public get deploymentJobs(): Record<string, Job> {\n\n    if (this.props.deployOptions.environments.length === 0) {\n      this.project.logger.warn('The project does not have any environment set, make sure this is desired setting');\n    }\n    return this.props.jobStrategy === DeployJobStrategy.MATRIX ? this.deploymentJobsForMatrix : this.getDeploymentJobsForMultiJob();\n  }\n\n  /**\n   * Get deployment jobs for matrix strategy\n   * @returns Record of jobs\n   */\n  public get deploymentJobsForMatrix(): Record<string, Job> {\n\n    const { environments, environmentVariableName } = this.props.deployOptions;\n\n    const include = environments.map(environmentOptions => {\n      const { awsCredentials } = environmentOptions;\n\n      const assumeRole = awsCredentials.roleToAssume ? 'true' : 'false';\n\n      const assumeRoleSettings = awsCredentials.roleToAssume ? {\n        roleToAssume: awsCredentials.roleToAssume,\n        assumeRoleDurationSeconds: awsCredentials.assumeRoleDurationSeconds || 900,\n      }: undefined;\n\n      const accessKeyIdSecretName = awsCredentials.accessKeyIdSecretName ?? 'AWS_ACCESS_KEY_ID';\n      const secretAccessKeySecretName = awsCredentials.secretAccessKeySecretName ?? 'AWS_SECRET_ACCESS_KEY';\n\n      const hasPostDeployTask = environmentOptions.postDeployWorkflowScript ? 'true' : 'false';\n      const hasPreDeployTask = environmentOptions.preDeployWorkflowScript ? 'true' : 'false';\n\n      return {\n        environment: environmentOptions.name,\n        accessKeyIdSecretName,\n        secretAccessKeySecretName,\n        region: awsCredentials.region,\n        assumeRole,\n        hasPostDeployTask,\n        postDeploymentScript: environmentOptions.postDeployWorkflowScript || '',\n        hasPreDeployTask,\n        preDeploymentScript: environmentOptions.preDeployWorkflowScript || '',\n        ...assumeRoleSettings,\n      };\n    });\n\n    const deployJobEnv = environmentVariableName ? {\n      [environmentVariableName]: '${{ matrix.environment }}',\n    } : undefined;\n\n    const jobDefinition: Job = {\n      runsOn: ['ubuntu-latest'],\n      concurrency: {\n        'group': '${{ matrix.environment }}-deploy',\n        'cancel-in-progress': false,\n      },\n      needs: [\n        'release_github',\n      ],\n      permissions: {\n        contents: JobPermission.READ,\n        deployments: JobPermission.READ,\n        idToken: this.props.authProvider === CodeArtifactAuthProvider.GITHUB_OIDC ? JobPermission.WRITE : undefined,\n      },\n      strategy: {\n        maxParallel: 1,\n        matrix: {\n          domain: {\n            environment: include.map(e => e.environment),\n          },\n          include,\n        },\n      },\n      environment: {\n        name: '${{ matrix.environment }}',\n      },\n      env: deployJobEnv,\n      steps: [],\n    };\n\n    jobDefinition.steps.push(this.checkoutStep);\n\n    const preInstallDependenciesStep = this.preInstallDependenciesStep;\n    if (preInstallDependenciesStep) {\n      jobDefinition.steps.push(preInstallDependenciesStep);\n    }\n\n    jobDefinition.steps.push(...(this.project).renderWorkflowSetup());\n\n    const checkActiveDeploymentStepForMatrix = this.checkActiveDeploymentStepForMatrix;\n    if (checkActiveDeploymentStepForMatrix) {\n      jobDefinition.steps.push(checkActiveDeploymentStepForMatrix);\n    }\n\n    jobDefinition.steps.push(...this.setupAwsCredentialsStepsForMatrix);\n\n    const setupNpmConfigStep = this.setupNpmConfigForMatrix;\n    if (setupNpmConfigStep) {\n      jobDefinition.steps.push(setupNpmConfigStep);\n    }\n\n    jobDefinition.steps.push(this.preDeploymentStepForMatrix);\n    jobDefinition.steps.push(this.deploymentStep);\n    jobDefinition.steps.push(this.postDeploymentStepForMatrix);\n\n    return { deploy: jobDefinition };\n  }\n\n  /**\n   * Get the IDs of the jobs that must be completed before the specified environment's deployment job\n   * @param environmentName The name of the environment\n   * @returns An array of job IDs\n   */\n  public getDeploymentJobPrerequisiteJobIds(environmentName: string): string[] {\n    const result = ['release_github'];\n    if (!this.props.environmentDependencies) {\n      const index = this.props.deployOptions.environments.findIndex(env => env.name === environmentName);\n      const prerequisiteEnvironment = index > 0 ? this.props.deployOptions.environments[index - 1] : undefined;\n      if (prerequisiteEnvironment) {\n        result.push(getDeployJobId(prerequisiteEnvironment.name));\n      }\n    } else {\n      const dependencies = this.props.environmentDependencies[environmentName];\n      if (dependencies) {\n        dependencies.forEach(dep => {\n          result.push(getDeployJobId(dep));\n        });\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Get deployment jobs for multi-job strategy\n   * @returns Record of jobs\n   */\n  public getDeploymentJobsForMultiJob(): Record<string, Job> {\n    const { environmentVariableName, environments } = this.props.deployOptions;\n    const jobs = environments.map((environmentOptions): [string, Job] => {\n      return [getDeployJobId(environmentOptions.name), this.getJobForEnvironment(environmentOptions, environmentVariableName)];\n    });\n    return Object.fromEntries(jobs);\n  }\n\n  /**\n   * Get the job definition for a specific environment\n   * @param environmentOptions The environment options\n   * @param environmentVariableName The name of the environment variable to set with the environment name, if any\n   * @returns The job definition for the environment\n   */\n  public getJobForEnvironment(\n    environmentOptions: EnvironmentOptions,\n    environmentVariableName: string | undefined,\n  ): Job {\n    const { name } = environmentOptions;\n    const deployJobEnv = environmentVariableName ? {\n      [environmentVariableName]: name,\n    } : undefined;\n\n    const jobDefinition: Job = {\n      runsOn: ['ubuntu-latest'],\n      concurrency: {\n        'group': `${name}-deploy`,\n        'cancel-in-progress': false,\n      },\n      needs: this.getDeploymentJobPrerequisiteJobIds(name),\n      permissions: {\n        contents: JobPermission.READ,\n        deployments: JobPermission.READ,\n        idToken: this.props.authProvider === CodeArtifactAuthProvider.GITHUB_OIDC ? JobPermission.WRITE : undefined,\n      },\n      environment: {\n        name: name,\n      },\n      env: deployJobEnv,\n      steps: [],\n    };\n\n    jobDefinition.steps.push(this.checkoutStep);\n\n    const preInstallDependenciesStep = this.preInstallDependenciesStep;\n    if (preInstallDependenciesStep) {\n      jobDefinition.steps.push(preInstallDependenciesStep);\n    }\n\n    jobDefinition.steps.push(...(this.project).renderWorkflowSetup());\n\n    const checkActiveDeploymentStep = this.getCheckActiveDeploymentStepForEnvironment(name);\n    if (checkActiveDeploymentStep) {\n      jobDefinition.steps.push(checkActiveDeploymentStep);\n    }\n\n    jobDefinition.steps.push(...this.getSetupAwsCredentialsStepsForEnvironment(environmentOptions));\n\n    const setupNpmConfigStep = this.getSetupNpmConfigForEnvironment(name);\n    if (setupNpmConfigStep) {\n      jobDefinition.steps.push(setupNpmConfigStep);\n    }\n\n    const preDeploymentStep = this.getPreDeploymentStepForEnvironment(\n      environmentOptions.preDeployWorkflowScript ? true : false,\n      environmentOptions.preDeployWorkflowScript || '',\n    );\n    if (preDeploymentStep) {\n      jobDefinition.steps.push(preDeploymentStep);\n    }\n\n    jobDefinition.steps.push(this.deploymentStep);\n\n    const postDeploymentStep = this.getPostDeploymentStepForEnvironment(\n      environmentOptions.postDeployWorkflowScript ? true : false,\n      environmentOptions.postDeployWorkflowScript || '',\n    );\n    if (postDeploymentStep) {\n      jobDefinition.steps.push(postDeploymentStep);\n    }\n\n    return jobDefinition;\n  }\n\n}\n\nfunction getDeployJobId(environmentName: string): string {\n  return `Deploy-${environmentName}`;\n}\n"]}