projen-pipelines 0.2.11 → 0.2.13

package/lib/awscdk/base.js

@@ -7,6 +7,7 @@ const projen_1 = require("projen");
 const common_1 = require("projen/lib/common");
 const javascript_1 = require("projen/lib/javascript");
 const steps_1 = require("../steps");
+const versioning_1 = require("../versioning");
 // /**
 //  * Describes the type of pipeline that will be created
 //  */
@@ -49,6 +50,10 @@ class CDKPipeline extends projen_1.Component {
         this.project.removeTask('diff');
         this.project.removeTask('destroy');
         this.project.removeTask('watch');
+        // Setup versioning if enabled
+        if (baseOptions.versioning?.enabled) {
+            new versioning_1.VersioningSetup(this.project, baseOptions.versioning).setup();
+        }
         // Creates different deployment stages
         if (baseOptions.personalStage) {
             this.createPersonalStage();
@@ -234,10 +239,29 @@ class CDKPipeline extends projen_1.Component {
     }
 `;
         }
+        // Add versioning logic to apply to all stacks
+        if (this.baseOptions.versioning?.enabled) {
+            appCode += this.generateVersioningAppCode(this.baseOptions.versioning);
+        }
         const appFile = new projen_1.TextFile(this.project, `${this.app.srcdir}/app.ts`);
+        // Generate versioning-aware imports and utilities
+        const versioningImports = this.baseOptions.versioning?.enabled
+            ? this.generateVersioningImports()
+            : '';
+        const versioningUtilities = this.baseOptions.versioning?.enabled
+            ? this.generateVersioningUtilities()
+            : '';
+        const versioningConfigDeclaration = this.baseOptions.versioning?.enabled
+            ? `
+const versioningConfig = ${JSON.stringify(this.baseOptions.versioning, null, 2)};
+`
+            : '';
         appFile.addLine(`// ${common_1.PROJEN_MARKER}
 /* eslint-disable */
 import { App, AppProps, Stack, StackProps } from 'aws-cdk-lib';
+${versioningImports}
+${versioningConfigDeclaration}
+${versioningUtilities}
 
 /**
  * PipelineAppProps is an extension of AppProps, which is part of the AWS CDK core.
@@ -363,7 +387,7 @@ ${appCode}
             exec: `cdk diff --no-changeset ${stackId}`,
         });
         this.project.addTask('destroy:feature', {
-            exec: `cdk destroy ${stackId}`,
+            exec: `cdk destroy --force ${stackId}`,
         });
         this.project.addTask('watch:feature', {
             exec: `cdk deploy --outputs-file cdk-outputs-feature.json --watch --hotswap ${stackId}`,
@@ -389,6 +413,10 @@ ${appCode}
                 exec: `cdk deploy --outputs-file cdk-outputs-${stage.name}.json --watch --hotswap ${stackId}`,
             });
         }
+        // Add version fetch task if versioning is enabled
+        if (this.baseOptions.versioning?.enabled) {
+            this.createVersionFetchTask(stage);
+        }
     }
     /**
      * This method sets up tasks for the independent stages including deployment and comparing changes (diff).
@@ -410,6 +438,10 @@ ${appCode}
                 exec: `cdk deploy --outputs-file cdk-outputs-${stage.name}.json --watch --hotswap ${stackId}`,
             });
         }
+        // Add version fetch task if versioning is enabled
+        if (this.baseOptions.versioning?.enabled) {
+            this.createVersionFetchTask(stage);
+        }
     }
     getCliStackPattern(stage) {
         let sep = '-';
@@ -418,8 +450,220 @@ ${appCode}
         }
         return this.baseOptions.deploySubStacks ? `${this.stackPrefix}${sep}${stage} ${this.stackPrefix}${sep}${stage}/*` : `${this.stackPrefix}${sep}${stage}`;
     }
+    /**
+     * Create version:fetch:<stage> task to fetch version data from deployed stack
+     */
+    createVersionFetchTask(stage) {
+        const stackName = `${this.stackPrefix}${this.stackPrefix ? '-' : ''}${stage.name}`;
+        const stageConfig = this.baseOptions.versioning?.stageOverrides?.[stage.name] || this.baseOptions.versioning;
+        if (!stageConfig?.outputs)
+            return;
+        const commands = [];
+        // Fetch from CloudFormation outputs
+        if (stageConfig.outputs.cloudFormation?.enabled) {
+            commands.push(`echo "Fetching version data from CloudFormation outputs for ${stage.name}..."`, `aws cloudformation describe-stacks --stack-name ${stackName} --region ${stage.env.region} --query "Stacks[0].Outputs[?starts_with(OutputKey, 'AppVersion')].{Key:OutputKey,Value:OutputValue}" --output table`);
+        }
+        // Fetch from SSM Parameter Store
+        if (stageConfig.outputs.parameterStore?.enabled) {
+            const parameterName = (stageConfig.outputs.parameterStore.parameterName || '/{stackName}/version')
+                .replace('{stackName}', stackName)
+                .replace('{stageName}', stage.name);
+            if (stageConfig.outputs.parameterStore?.hierarchical) {
+                commands.push(`echo "Fetching version data from SSM Parameter Store (hierarchical) for ${stage.name}..."`, `aws ssm get-parameters-by-path --path "${parameterName}" --region ${stage.env.region} --recursive --query "Parameters[].{Name:Name,Value:Value}" --output table`);
+            }
+            else {
+                commands.push(`echo "Fetching version data from SSM Parameter Store for ${stage.name}..."`, `aws ssm get-parameter --name "${parameterName}" --region ${stage.env.region} --query "Parameter.{Name:Name,Value:Value}" --output table`);
+            }
+        }
+        if (commands.length > 0) {
+            this.project.addTask(`version:fetch:${stage.name}`, {
+                description: `Fetch version data from deployed ${stage.name} stack`,
+                exec: commands.join(' && '),
+            });
+        }
+    }
+    /**
+     * Generate CDK application code for versioning
+     */
+    generateVersioningAppCode(config) {
+        return `
+    // Apply versioning to all stacks
+    this.node.children.forEach((child) => {
+      if (child instanceof Stack) {
+        const stageName = child.stackName.split('-').pop() || 'default';
+        addVersioningToStack(child, stageName, ${config.stageOverrides ? 'versioningConfig.stageOverrides' : 'undefined'});
+      }
+    });`;
+    }
+    /**
+     * Generate versioning imports for CDK application
+     */
+    generateVersioningImports() {
+        const imports = [];
+        imports.push("import { CfnOutput } from 'aws-cdk-lib';");
+        imports.push("import { StringParameter } from 'aws-cdk-lib/aws-ssm';");
+        imports.push("import * as fs from 'fs';");
+        return imports.join('\n');
+    }
+    /**
+     * Generate versioning utility functions for CDK application
+     */
+    generateVersioningUtilities() {
+        return `
+/**
+ * Version information interface
+ */
+export interface VersionInfo {
+  version: string;
+  commitHash: string;
+  commitHashShort: string;
+  branch: string;
+  commitCount: number;
+  packageVersion: string;
+  deployedAt: string;
+  deployedBy: string;
+  environment: string;
+}
+
+/**
+ * Load version information from generated file
+ */
+export function loadVersionInfo(): VersionInfo {
+  try {
+    return JSON.parse(fs.readFileSync('~version.json', 'utf8'));
+  } catch (error) {
+    console.warn('Could not load version info, using fallback');
+    return {
+      version: '0.0.0',
+      commitHash: 'unknown',
+      commitHashShort: 'unknown',
+      branch: 'unknown',
+      commitCount: 0,
+      packageVersion: '0.0.0',
+      deployedAt: new Date().toISOString(),
+      deployedBy: 'unknown',
+      environment: 'unknown'
+    };
+  }
+}
+
+/**
+ * Get versioning configuration for a specific stage
+ */
+function getStageConfig(stageName: string, baseConfig: any, stageOverrides?: Record<string, any>): any {
+  if (!stageOverrides || !stageOverrides[stageName]) {
+    return baseConfig;
+  }
+  
+  // Merge stage override with base config
+  const override = stageOverrides[stageName];
+  return {
+    ...baseConfig,
+    outputs: {
+      cloudFormation: override.outputs?.cloudFormation || baseConfig.outputs.cloudFormation,
+      parameterStore: override.outputs?.parameterStore || baseConfig.outputs.parameterStore,
+    }
+  };
+}
+
+/**
+ * Add versioning outputs to a stack
+ */
+function addVersioningToStack(stack: Stack, stageName: string, stageOverrides?: any): void {
+  const versionInfo = loadVersionInfo();
+  const baseConfig = versioningConfig;
+  const config = getStageConfig(stageName, baseConfig, stageOverrides);
+  
+  // Check if format is specified in CloudFormation or ParameterStore configs
+  const cfFormat = config.outputs.cloudFormation?.format || 'structured';
+  const ssmFormat = config.outputs.parameterStore?.format || 'structured';
+  
+  // Add CloudFormation outputs
+  if (config.outputs.cloudFormation?.enabled) {
+    if (cfFormat === 'plain') {
+      // Plain format - single output with version string
+      new CfnOutput(stack, 'AppVersion', {
+        value: versionInfo.version,
+        description: 'Application version',
+        exportName: config.outputs.cloudFormation.exportName,
+      });
+    } else {
+      // Structured format - multiple outputs
+      new CfnOutput(stack, 'AppVersion', {
+        value: versionInfo.version,
+        description: 'Application version',
+        exportName: config.outputs.cloudFormation.exportName,
+      });
+      
+      new CfnOutput(stack, 'AppVersionCommitHash', {
+        value: versionInfo.commitHash,
+        description: 'Git commit hash',
+        exportName: config.outputs.cloudFormation.exportName ? \`\${config.outputs.cloudFormation.exportName}CommitHash\` : undefined,
+      });
+      
+      new CfnOutput(stack, 'AppVersionBranch', {
+        value: versionInfo.branch,
+        description: 'Git branch',
+        exportName: config.outputs.cloudFormation.exportName ? \`\${config.outputs.cloudFormation.exportName}Branch\` : undefined,
+      });
+
+      new CfnOutput(stack, 'AppVersionInfo', {
+        value: JSON.stringify(versionInfo),
+        description: 'Complete version information',
+        exportName: config.outputs.cloudFormation.exportName ? \`\${config.outputs.cloudFormation.exportName}Info\` : undefined,
+      });
+    }
+  }
+  
+  // Add SSM Parameter Store parameters
+  if (config.outputs.parameterStore?.enabled) {
+    if (config.outputs.parameterStore.hierarchical) {
+      // Hierarchical parameters
+      const baseParameterName = (config.outputs.parameterStore.parameterName || '/{stackName}/version')
+        .replace('{stackName}', stack.stackName)
+        .replace('{stageName}', stageName);
+        
+      // Create hierarchical parameters
+      new StringParameter(stack, 'VersionParameterVersion', {
+        parameterName: \`\${baseParameterName}/version\`,
+        stringValue: versionInfo.version,
+        description: 'Application version',
+      });
+      
+      new StringParameter(stack, 'VersionParameterCommitHash', {
+        parameterName: \`\${baseParameterName}/commitHash\`,
+        stringValue: versionInfo.commitHash,
+        description: 'Git commit hash',
+      });
+      
+      new StringParameter(stack, 'VersionParameterBranch', {
+        parameterName: \`\${baseParameterName}/branch\`,
+        stringValue: versionInfo.branch,
+        description: 'Git branch',
+      });
+      
+      new StringParameter(stack, 'VersionParameterInfo', {
+        parameterName: \`\${baseParameterName}/info\`,
+        stringValue: JSON.stringify(versionInfo),
+        description: 'Complete version information',
+      });
+    } else {
+      // Single parameter
+      const parameterName = (config.outputs.parameterStore.parameterName || '/{stackName}/version')
+        .replace('{stackName}', stack.stackName)
+        .replace('{stageName}', stageName);
+        
+      new StringParameter(stack, 'VersionParameter', {
+        parameterName,
+        stringValue: ssmFormat === 'plain' ? versionInfo.version : JSON.stringify(versionInfo),
+        description: ssmFormat === 'plain' ? 'Application version' : 'Complete version information',
+      });
+    }
+  }
+}`;
+    }
 }
 exports.CDKPipeline = CDKPipeline;
 _a = JSII_RTTI_SYMBOL_1;
-CDKPipeline[_a] = { fqn: "projen-pipelines.CDKPipeline", version: "0.2.11" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/awscdk/base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, TextFile, awscdk } from 'projen';\nimport { PROJEN_MARKER } from 'projen/lib/common';\nimport { NodePackageManager } from 'projen/lib/javascript';\nimport { PipelineEngine } from '../engine';\nimport { AwsAssumeRoleStep, PipelineStep, ProjenScriptStep, SimpleCommandStep, StepSequence } from '../steps';\n\n/**\n * The Environment interface is designed to hold AWS related information\n * for a specific deployment environment within your infrastructure.\n * Each environment requires a specific account and region for its resources.\n */\nexport interface Environment {\n  /**\n   * The AWS Account ID associated with the environment. It's important because\n   * different services or features could have distinct permissions and settings\n   * in different accounts.\n   */\n  readonly account: string;\n\n  /**\n   * The AWS Region for the environment. This determines where your resources\n   * are created and where your application will run. It can affect latency,\n   * availability, and pricing.\n   */\n  readonly region: string;\n}\n\n// /**\n//  * Describes the type of pipeline that will be created\n//  */\n// export enum DeploymentType {\n//   /** Deploy every commit as far as possible; hopefully into production */\n//   CONTINUOUS_DEPLOYMENT,\n//   /** Build every commit and prepare all assets for a later deployment */\n//   CONTINUOUS_DELIVERY,\n// }\n\nexport enum CdkDiffType {\n  /** Do not perform a diff */\n  NONE,\n  /** Perform a fast template diff (--no-changeset) */\n  FAST,\n  /** Perform a full CloudFormation diff (--changeset) */\n  FULL,\n}\n\n/**\n * Options for stages that are part of the pipeline\n */\nexport interface DeploymentStage extends NamedStageOptions {\n  readonly manualApproval?: boolean;\n}\n\n/**\n * Options for stages that are not part of the pipeline\n */\nexport interface IndependentStage extends NamedStageOptions {\n  /**\n   * This specifies whether the stage should be deployed on push\n   *\n   * @default false\n   */\n  readonly deployOnPush?: boolean;\n}\n\n/**\n * Options for a CDK stage with a name\n */\nexport interface NamedStageOptions extends StageOptions {\n  readonly name: string;\n  readonly watchable?: boolean;\n  readonly diffType?: CdkDiffType;\n  readonly postDiffSteps?: PipelineStep[];\n  readonly postDeploySteps?: PipelineStep[];\n}\n\n/**\n * Options for a CDK stage like the target environment\n */\nexport interface StageOptions {\n  readonly env: Environment;\n}\n\n/**\n * Configuration interface for IAM roles used in the CDK pipeline.\n */\nexport interface IamRoleConfig {\n\n  /** Default IAM role ARN used if no specific role is provided. */\n  readonly default?: string;\n  /** IAM role ARN for the synthesis step. */\n  readonly synth?: string;\n  /** IAM role ARN for the asset publishing step. */\n  readonly assetPublishing?: string;\n  /** IAM role ARN for the asset publishing step for a specific stage. */\n  readonly assetPublishingPerStage?: { [stage: string]: string };\n  /** IAM role ARNs for different diff stages. */\n  readonly diff?: { [stage: string]: string };\n  /** IAM role ARNs for different deployment stages. */\n  readonly deployment?: { [stage: string]: string };\n}\n\n/**\n * The CDKPipelineOptions interface is designed to provide configuration\n * options for a CDK (Cloud Development Kit) pipeline. It allows the definition\n * of settings such as the stack prefix and package namespace to be used in the\n * AWS stack, along with the environments configuration to be used.\n */\nexport interface CDKPipelineOptions {\n\n  /**\n   * the name of the branch to deploy from\n   * @default main\n   */\n  readonly branchName?: string;\n\n  /**\n   * This field is used to define a prefix for the AWS Stack resources created\n   * during the pipeline's operation.\n   *\n   * @default project name\n   */\n  readonly stackPrefix?: string;\n\n  /**\n   * If set to true all CDK actions will also include <stackName>/* to deploy/diff/destroy sub stacks of the main stack.\n   * You can use this to deploy CDk applications containing multiple stacks.\n   *\n   * @default false\n   */\n  readonly deploySubStacks?: boolean;\n\n  /**\n   * This field determines the NPM namespace to be used when packaging CDK cloud\n   * assemblies. A namespace helps group related resources together, providing\n   * better organization and ease of management.\n   *\n   * This is only needed if you need to version and upload the cloud assembly to a package repository.\n   *\n   * @default -\n   */\n  readonly pkgNamespace?: string;\n\n  /** IAM config */\n  readonly iamRoleArns: IamRoleConfig;\n\n  /**\n   * This field specifies a list of stages that should be deployed using a CI/CD pipeline\n   */\n  readonly stages: DeploymentStage[];\n\n  /** This specifies details for independent stages */\n  readonly independentStages?: IndependentStage[];\n\n  /** This specifies details for a personal stage */\n  readonly personalStage?: StageOptions;\n\n  /** This specifies details for feature stages */\n  readonly featureStages?: StageOptions;\n\n  // /**\n  //  * This field specifies the type of pipeline to create. If set to CONTINUOUS_DEPLOYMENT,\n  //  * every commit is deployed as far as possible, hopefully into production. If set to\n  //  * CONTINUOUS_DELIVERY, every commit is built and all assets are prepared for a later deployment.\n  //  *\n  //  * @default CONTINUOUS_DELIVERY\n  //  */\n  // readonly deploymentType?: DeploymentType;\n\n  readonly preInstallCommands?: string[];\n  readonly preSynthCommands?: string[];\n  readonly postSynthCommands?: string[];\n\n  readonly preInstallSteps?: PipelineStep[];\n  readonly preSynthSteps?: PipelineStep[];\n  readonly postSynthSteps?: PipelineStep[];\n}\n\n/**\n * The CDKPipeline class extends the Component class and sets up the necessary configuration for deploying AWS CDK (Cloud Development Kit) applications across multiple stages.\n * It also manages tasks such as publishing CDK assets, bumping version based on git tags, and cleaning up conflicting tasks.\n */\nexport abstract class CDKPipeline extends Component {\n  public readonly stackPrefix: string;\n  public readonly branchName: string;\n\n  constructor(protected app: awscdk.AwsCdkTypeScriptApp, protected baseOptions: CDKPipelineOptions) {\n    super(app);\n\n    // Add development dependencies\n    this.app.addDevDeps(\n      '@types/standard-version',\n      'standard-version',\n      'cdk-assets',\n    );\n    // this.app.addDeps(\n    // );\n    this.project.gitignore.exclude('/cdk-outputs-*.json');\n\n    this.stackPrefix = baseOptions.stackPrefix ?? app.name;\n    this.branchName = baseOptions.branchName ?? 'main'; // TODO use defaultReleaseBranch of NodeProject\n\n    // Removes the compiled cloud assembly before each synth\n    this.project.tasks.tryFind('synth')?.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);\n    this.project.tasks.tryFind('synth:silent')?.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);\n\n    // Remove tasks that might conflict with the pipeline process\n    this.project.removeTask('deploy');\n    this.project.removeTask('diff');\n    this.project.removeTask('destroy');\n    this.project.removeTask('watch');\n\n    // Creates different deployment stages\n    if (baseOptions.personalStage) {\n      this.createPersonalStage();\n    }\n    if (baseOptions.featureStages) {\n      this.createFeatureStage();\n    }\n    for (const stage of baseOptions.stages) {\n      this.createPipelineStage(stage);\n    }\n    for (const stage of (baseOptions.independentStages ?? [])) {\n      this.createIndependentStage(stage);\n    }\n\n    // Creates tasks to handle the release process\n    this.createReleaseTasks();\n\n    // Creates a specialized CDK App class\n    this.createApplicationEntrypoint();\n\n  }\n\n  public abstract engineType(): PipelineEngine;\n\n  protected provideInstallStep(): PipelineStep {\n    const seq = new StepSequence(this.project, this.baseOptions.preInstallSteps ?? []);\n    if (this.baseOptions.preInstallCommands) {\n      seq.addSteps(new SimpleCommandStep(this.project, this.baseOptions.preInstallCommands));\n    }\n    seq.addSteps(new ProjenScriptStep(this.project, this.app.package.installCiTask.name));\n    return seq;\n  }\n\n  protected provideSynthStep(): PipelineStep {\n    const seq = new StepSequence(this.project, []);\n\n    if (this.baseOptions.iamRoleArns?.synth) {\n      seq.addSteps(new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns.synth,\n      }));\n    }\n\n    seq.addSteps(...this.baseOptions.preSynthSteps ?? []);\n    if (this.baseOptions.preSynthCommands) {\n      seq.addSteps(new SimpleCommandStep(this.project, this.baseOptions.preSynthCommands));\n    }\n\n    seq.addSteps(new ProjenScriptStep(this.project, 'build'));\n\n    seq.addSteps(...this.baseOptions.postSynthSteps ?? []);\n    if (this.baseOptions.postSynthCommands) {\n      seq.addSteps(new SimpleCommandStep(this.project, this.baseOptions.postSynthCommands));\n    }\n    return seq;\n  }\n\n  protected provideAssetUploadStep(stageName?: string): PipelineStep {\n    const seq = new StepSequence(this.project, []);\n\n    const globalPublishRole = this.baseOptions.iamRoleArns.assetPublishing ?? this.baseOptions.iamRoleArns.default!;\n    if (stageName) {\n      seq.addSteps(new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns.assetPublishingPerStage ?\n          (this.baseOptions.iamRoleArns.assetPublishingPerStage[stageName] ?? globalPublishRole) :\n          globalPublishRole,\n      }));\n      seq.addSteps(new ProjenScriptStep(this.project, `publish:assets:${stageName}`));\n    } else {\n      if (this.baseOptions.iamRoleArns.assetPublishingPerStage) {\n        const stages = [...this.baseOptions.stages, ...this.baseOptions.independentStages ?? []];\n        for (const stage of stages) {\n          seq.addSteps(new AwsAssumeRoleStep(this.project, {\n            roleArn: this.baseOptions.iamRoleArns.assetPublishingPerStage[stage.name] ?? globalPublishRole,\n          }));\n          seq.addSteps(new ProjenScriptStep(this.project, `publish:assets:${stage.name}`));\n        }\n      } else {\n        seq.addSteps(new AwsAssumeRoleStep(this.project, {\n          roleArn: globalPublishRole,\n        }));\n        seq.addSteps(new ProjenScriptStep(this.project, 'publish:assets'));\n      }\n    }\n\n    return seq;\n  }\n\n  protected provideAssemblyUploadStep(): PipelineStep {\n    if (!this.baseOptions.pkgNamespace) {\n      throw new Error('pkgNamespace is required when using versioned artifacts (e.g. manual approvals)');\n    }\n    return new StepSequence(this.project, [\n      new ProjenScriptStep(this.project, 'bump'),\n      new ProjenScriptStep(this.project, 'release:push-assembly'),\n    ]);\n  }\n\n  protected provideDeployStep(stage: NamedStageOptions): PipelineStep {\n    return new StepSequence(this.project, [\n      new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns?.deployment?.[stage.name] ?? this.baseOptions.iamRoleArns?.default!,\n        region: stage.env.region,\n      }),\n      new ProjenScriptStep(this.project, `deploy:${stage.name}`),\n      ...stage.postDeploySteps ?? [],\n    ]);\n  }\n\n  protected provideDiffStep(stage: NamedStageOptions, fast?: boolean): PipelineStep {\n    return new StepSequence(this.project, [\n      new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns?.diff?.[stage.name] ??\n          this.baseOptions.iamRoleArns?.deployment?.[stage.name] ??\n          this.baseOptions.iamRoleArns?.default!,\n        region: stage.env.region,\n      }),\n      new ProjenScriptStep(this.project, fast ? `fastdiff:${stage.name}` : `diff:${stage.name}`),\n      ...stage.postDiffSteps ?? [],\n    ]);\n  }\n\n  protected renderInstallPackageCommands(packageName: string, runPreInstallCommands: boolean = false): string[] {\n    const commands = runPreInstallCommands ? this.baseOptions.preInstallCommands ?? [] : [];\n\n    switch (this.app.package.packageManager) {\n      case NodePackageManager.YARN:\n      case NodePackageManager.YARN2:\n      case NodePackageManager.YARN_BERRY:\n      case NodePackageManager.YARN_CLASSIC:\n        commands.push(`yarn add ${packageName}`);\n        break;\n      case NodePackageManager.NPM:\n        commands.push(`npm install ${packageName}`);\n        break;\n      default:\n        throw new Error('No install scripts for packageManager: ' + this.app.package.packageManager);\n    }\n    return commands;\n  }\n\n  protected createSafeStageName(name: string): string {\n    // Remove non-alphanumeric characters and split into words\n    const words = name.replace(/[^a-zA-Z0-9]+/g, ' ').trim().split(/\\s+/);\n\n    // Capitalize the first letter of each word and join them\n    return words.map((word) => {\n      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\n    }).join('');\n  }\n\n  /**\n   * This method generates the entry point for the application, including interfaces and classes\n   * necessary to set up the pipeline and define the AWS CDK stacks for different environments.\n   */\n  protected createApplicationEntrypoint() {\n    let propsCode = '';\n    let appCode = '';\n    let sep = '-';\n    if (this.stackPrefix === '') {\n      sep = '';\n    }\n\n\n    if (this.baseOptions.personalStage) {\n      propsCode += `  /** This function will be used to generate a personal stack. */\n  providePersonalStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If the environment variable USER is set and a function is provided for creating a personal stack, it is called with necessary arguments.\n    if (props.providePersonalStack && process.env.USER) {\n      const stageName = 'personal-' + process.env.USER.toLowerCase().replace(/\\\\\\//g, '-');\n      props.providePersonalStack(this, '${this.stackPrefix}${sep}personal', { env: { account: '${this.baseOptions.personalStage.env.account}', region: '${this.baseOptions.personalStage.env.region}' }, stackName: \\`${this.stackPrefix}${sep}\\${stageName}\\`, stageName });\n    }\n`;\n    }\n\n    if (this.baseOptions.featureStages) {\n      propsCode += `  /** This function will be used to generate a feature stack. */\n  provideFeatureStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If the environment variable BRANCH is set and a function is provided for creating a feature stack, it is called with necessary arguments.\n    if (props.provideFeatureStack && process.env.BRANCH) {\n      const stageName = 'feature-' + process.env.BRANCH.toLowerCase().replace(/\\\\\\//g, '-');\n      props.provideFeatureStack(this, '${this.stackPrefix}${sep}feature', { env: { account: '${this.baseOptions.featureStages.env.account}', region: '${this.baseOptions.featureStages.env.region}' }, stackName: \\`${this.stackPrefix}${sep}\\${stageName}\\`, stageName });\n    }\n`;\n    }\n\n    for (const stage of this.baseOptions.stages) {\n      const nameUpperFirst = this.createSafeStageName(stage.name);\n\n      propsCode += `  /** This function will be used to generate a ${stage.name} stack. */\n  provide${nameUpperFirst}Stack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If a function is provided for creating a ${stage.name} stack, it is called with necessary arguments.\n    if (props.provide${nameUpperFirst}Stack) {\n      props.provide${nameUpperFirst}Stack(this, '${this.stackPrefix}${sep}${stage.name}', { env: { account: '${stage.env.account}', region: '${stage.env.region}' }, stackName: '${this.stackPrefix}${sep}${stage.name}', stageName: '${stage.name}' });\n    }\n`;\n    }\n\n    for (const stage of (this.baseOptions.independentStages ?? [])) {\n      const nameUpperFirst = this.createSafeStageName(stage.name);\n\n      propsCode += `  /** This function will be used to generate a ${stage.name} stack. */\n  provide${nameUpperFirst}Stack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If a function is provided for creating a ${stage.name} stack, it is called with necessary arguments.\n    if (props.provide${nameUpperFirst}Stack) {\n      props.provide${nameUpperFirst}Stack(this, '${this.stackPrefix}${sep}${stage.name}', { env: { account: '${stage.env.account}', region: '${stage.env.region}' }, stackName: '${this.stackPrefix}${sep}${stage.name}', stageName: '${stage.name}' });\n    }\n`;\n    }\n\n    const appFile = new TextFile(this.project, `${this.app.srcdir}/app.ts`);\n    appFile.addLine(`// ${PROJEN_MARKER}\n/* eslint-disable */\nimport { App, AppProps, Stack, StackProps } from 'aws-cdk-lib';\n\n/**\n * PipelineAppProps is an extension of AppProps, which is part of the AWS CDK core.\n * It includes optional functions to provide AWS Stacks for different stages.\n *\n * Use these functions to instantiate your application stacks with the parameters for\n * each stage\n */\nexport interface PipelineAppProps extends AppProps {\n${propsCode}\n}\n\n/**\n * PipelineAppStackProps is an extension of StackProps, which is part of the AWS CDK core.\n * It includes an additional property to specify the stage name.\n */\nexport interface PipelineAppStackProps extends StackProps {\n  stageName: string;\n}\n\n/**\n * The PipelineApp class extends the App class from AWS CDK and overrides the constructor to support\n * different stages of the application (development, production, personal, feature) by invoking the provided\n * stack-providing functions from the props.\n */\nexport class PipelineApp extends App {\n  constructor(props: PipelineAppProps) {\n    super(props);\n\n${appCode}\n\n  }\n}\n`);\n  }\n\n  /**\n   * This method sets up tasks to publish CDK assets to all accounts and handle versioning, including bumping the version\n   * based on the latest git tag and pushing the CDK assembly to the package repository.\n   */\n  protected createReleaseTasks() {\n    const stages = [...this.baseOptions.stages, ...this.baseOptions.independentStages ?? []];\n    let sep = '-';\n    if (this.stackPrefix === '') {\n      sep = '';\n    }\n    // Task to publish the CDK assets to all accounts\n    for (const stage of stages) {\n      this.project.addTask(`publish:assets:${stage.name}`, {\n        steps: [{\n          exec: `npx cdk-assets -p ${this.app.cdkConfig.cdkout}/${this.stackPrefix}${sep}${stage.name}.assets.json publish`,\n        }],\n      });\n    }\n    this.project.addTask('publish:assets', {\n      steps: stages.map(stage => ({\n        spawn: `publish:assets:${stage.name}`,\n      })),\n    });\n\n    if (this.baseOptions.pkgNamespace) {\n      this.project.addTask('bump', {\n        description: 'Bumps version based on latest git tag',\n        steps: [\n          {\n            exec: 'pipelines-release bump',\n          },\n          {\n            exec: 'git push --tags',\n          },\n        ],\n      });\n      this.project.addTask('release:push-assembly', {\n        steps: [\n          {\n            exec: `pipelines-release create-manifest \"${this.app.cdkConfig.cdkout}\"  \"${this.baseOptions.pkgNamespace}\"`,\n          },\n          {\n            cwd: this.app.cdkConfig.cdkout,\n            exec: 'npm version --no-git-tag-version from-git',\n          },\n          {\n            cwd: this.app.cdkConfig.cdkout,\n            exec: 'npm publish',\n          },\n        ],\n      });\n    }\n\n  }\n\n  /**\n   * This method sets up tasks for the personal deployment stage, including deployment, watching for changes,\n   * comparing changes (diff), and destroying the stack when no longer needed.\n   */\n  protected createPersonalStage() {\n    const stackId = this.getCliStackPattern('personal');\n    this.project.addTask('deploy:personal', {\n      exec: `cdk deploy --outputs-file cdk-outputs-personal.json ${stackId}`,\n    });\n    this.project.addTask('watch:personal', {\n      exec: `cdk deploy --outputs-file cdk-outputs-personal.json --watch --hotswap ${stackId}`,\n    });\n    this.project.addTask('diff:personal', {\n      exec: `cdk diff ${stackId}`,\n    });\n    this.project.addTask('fastdiff:personal', {\n      exec: `cdk diff --no-changeset ${stackId}`,\n    });\n    this.project.addTask('destroy:personal', {\n      exec: `cdk destroy ${stackId}`,\n    });\n  }\n\n  /**\n   * This method sets up tasks for the feature deployment stage, including deployment, comparing changes (diff),\n   * and destroying the stack when no longer needed.\n   */\n  protected createFeatureStage() {\n    const stackId = this.getCliStackPattern('feature');\n    this.project.addTask('deploy:feature', {\n      exec: `cdk --outputs-file cdk-outputs-feature.json --progress events --require-approval never deploy ${stackId}`,\n    });\n    this.project.addTask('diff:feature', {\n      exec: `cdk diff ${stackId}`,\n    });\n    this.project.addTask('fastdiff:feature', {\n      exec: `cdk diff --no-changeset ${stackId}`,\n    });\n    this.project.addTask('destroy:feature', {\n      exec: `cdk destroy ${stackId}`,\n    });\n    this.project.addTask('watch:feature', {\n      exec: `cdk deploy --outputs-file cdk-outputs-feature.json --watch --hotswap ${stackId}`,\n    });\n  }\n\n  /**\n   * This method sets up tasks for the general pipeline stages (dev, prod), including deployment and comparing changes (diff).\n   * @param {DeployStageOptions} stage - The stage to create\n   */\n  protected createPipelineStage(stage: DeploymentStage) {\n    const stackId = this.getCliStackPattern(stage.name);\n    this.project.addTask(`deploy:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} --outputs-file cdk-outputs-${stage.name}.json --progress events --require-approval never deploy ${stackId}`,\n    });\n    this.project.addTask(`diff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${stackId}`,\n    });\n    this.project.addTask(`fastdiff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff --no-changeset ${stackId}`,\n    });\n    if (stage.watchable) {\n      this.project.addTask(`watch:${stage.name}`, {\n        exec: `cdk deploy --outputs-file cdk-outputs-${stage.name}.json --watch --hotswap ${stackId}`,\n      });\n    }\n  }\n\n  /**\n   * This method sets up tasks for the independent stages including deployment and comparing changes (diff).\n   * @param {NamedStageOptions} stage - The stage to create\n   */\n  protected createIndependentStage(stage: IndependentStage) {\n    const stackId = this.getCliStackPattern(stage.name);\n    this.project.addTask(`deploy:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} --outputs-file cdk-outputs-${stage.name}.json --progress events --require-approval never deploy ${stackId}`,\n    });\n    this.project.addTask(`diff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${stackId}`,\n    });\n    this.project.addTask(`fastdiff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff --no-changeset ${stackId}`,\n    });\n    if (stage.watchable) {\n      this.project.addTask(`watch:${stage.name}`, {\n        exec: `cdk deploy --outputs-file cdk-outputs-${stage.name}.json --watch --hotswap ${stackId}`,\n      });\n    }\n  }\n\n  protected getCliStackPattern(stage: string) {\n    let sep = '-';\n    if (this.stackPrefix === '') {\n      sep = '';\n    }\n    return this.baseOptions.deploySubStacks ? `${this.stackPrefix}${sep}${stage} ${this.stackPrefix}${sep}${stage}/*` : `${this.stackPrefix}${sep}${stage}`;\n  }\n}\n"]}
+CDKPipeline[_a] = { fqn: "projen-pipelines.CDKPipeline", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/awscdk/base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, TextFile, awscdk } from 'projen';\nimport { PROJEN_MARKER } from 'projen/lib/common';\nimport { NodePackageManager } from 'projen/lib/javascript';\nimport { PipelineEngine } from '../engine';\nimport { AwsAssumeRoleStep, PipelineStep, ProjenScriptStep, SimpleCommandStep, StepSequence } from '../steps';\nimport { VersioningConfig, VersioningSetup } from '../versioning';\n\n/**\n * The Environment interface is designed to hold AWS related information\n * for a specific deployment environment within your infrastructure.\n * Each environment requires a specific account and region for its resources.\n */\nexport interface Environment {\n  /**\n   * The AWS Account ID associated with the environment. It's important because\n   * different services or features could have distinct permissions and settings\n   * in different accounts.\n   */\n  readonly account: string;\n\n  /**\n   * The AWS Region for the environment. This determines where your resources\n   * are created and where your application will run. It can affect latency,\n   * availability, and pricing.\n   */\n  readonly region: string;\n}\n\n// /**\n//  * Describes the type of pipeline that will be created\n//  */\n// export enum DeploymentType {\n//   /** Deploy every commit as far as possible; hopefully into production */\n//   CONTINUOUS_DEPLOYMENT,\n//   /** Build every commit and prepare all assets for a later deployment */\n//   CONTINUOUS_DELIVERY,\n// }\n\nexport enum CdkDiffType {\n  /** Do not perform a diff */\n  NONE,\n  /** Perform a fast template diff (--no-changeset) */\n  FAST,\n  /** Perform a full CloudFormation diff (--changeset) */\n  FULL,\n}\n\n/**\n * Options for stages that are part of the pipeline\n */\nexport interface DeploymentStage extends NamedStageOptions {\n  readonly manualApproval?: boolean;\n}\n\n/**\n * Options for stages that are not part of the pipeline\n */\nexport interface IndependentStage extends NamedStageOptions {\n  /**\n   * This specifies whether the stage should be deployed on push\n   *\n   * @default false\n   */\n  readonly deployOnPush?: boolean;\n}\n\n/**\n * Options for a CDK stage with a name\n */\nexport interface NamedStageOptions extends StageOptions {\n  readonly name: string;\n  readonly watchable?: boolean;\n  readonly diffType?: CdkDiffType;\n  readonly postDiffSteps?: PipelineStep[];\n  readonly postDeploySteps?: PipelineStep[];\n}\n\n/**\n * Options for a CDK stage like the target environment\n */\nexport interface StageOptions {\n  readonly env: Environment;\n}\n\n/**\n * Configuration interface for IAM roles used in the CDK pipeline.\n */\nexport interface IamRoleConfig {\n\n  /** Default IAM role ARN used if no specific role is provided. */\n  readonly default?: string;\n  /** IAM role ARN for the synthesis step. */\n  readonly synth?: string;\n  /** IAM role ARN for the asset publishing step. */\n  readonly assetPublishing?: string;\n  /** IAM role ARN for the asset publishing step for a specific stage. */\n  readonly assetPublishingPerStage?: { [stage: string]: string };\n  /** IAM role ARNs for different diff stages. */\n  readonly diff?: { [stage: string]: string };\n  /** IAM role ARNs for different deployment stages. */\n  readonly deployment?: { [stage: string]: string };\n}\n\n/**\n * The CDKPipelineOptions interface is designed to provide configuration\n * options for a CDK (Cloud Development Kit) pipeline. It allows the definition\n * of settings such as the stack prefix and package namespace to be used in the\n * AWS stack, along with the environments configuration to be used.\n */\nexport interface CDKPipelineOptions {\n\n  /**\n   * the name of the branch to deploy from\n   * @default main\n   */\n  readonly branchName?: string;\n\n  /**\n   * This field is used to define a prefix for the AWS Stack resources created\n   * during the pipeline's operation.\n   *\n   * @default project name\n   */\n  readonly stackPrefix?: string;\n\n  /**\n   * If set to true all CDK actions will also include <stackName>/* to deploy/diff/destroy sub stacks of the main stack.\n   * You can use this to deploy CDk applications containing multiple stacks.\n   *\n   * @default false\n   */\n  readonly deploySubStacks?: boolean;\n\n  /**\n   * This field determines the NPM namespace to be used when packaging CDK cloud\n   * assemblies. A namespace helps group related resources together, providing\n   * better organization and ease of management.\n   *\n   * This is only needed if you need to version and upload the cloud assembly to a package repository.\n   *\n   * @default -\n   */\n  readonly pkgNamespace?: string;\n\n  /** IAM config */\n  readonly iamRoleArns: IamRoleConfig;\n\n  /**\n   * This field specifies a list of stages that should be deployed using a CI/CD pipeline\n   */\n  readonly stages: DeploymentStage[];\n\n  /** This specifies details for independent stages */\n  readonly independentStages?: IndependentStage[];\n\n  /** This specifies details for a personal stage */\n  readonly personalStage?: StageOptions;\n\n  /** This specifies details for feature stages */\n  readonly featureStages?: StageOptions;\n\n  // /**\n  //  * This field specifies the type of pipeline to create. If set to CONTINUOUS_DEPLOYMENT,\n  //  * every commit is deployed as far as possible, hopefully into production. If set to\n  //  * CONTINUOUS_DELIVERY, every commit is built and all assets are prepared for a later deployment.\n  //  *\n  //  * @default CONTINUOUS_DELIVERY\n  //  */\n  // readonly deploymentType?: DeploymentType;\n\n  readonly preInstallCommands?: string[];\n  readonly preSynthCommands?: string[];\n  readonly postSynthCommands?: string[];\n\n  readonly preInstallSteps?: PipelineStep[];\n  readonly preSynthSteps?: PipelineStep[];\n  readonly postSynthSteps?: PipelineStep[];\n\n  /**\n   * Versioning configuration\n   */\n  readonly versioning?: VersioningConfig;\n}\n\n/**\n * The CDKPipeline class extends the Component class and sets up the necessary configuration for deploying AWS CDK (Cloud Development Kit) applications across multiple stages.\n * It also manages tasks such as publishing CDK assets, bumping version based on git tags, and cleaning up conflicting tasks.\n */\nexport abstract class CDKPipeline extends Component {\n  public readonly stackPrefix: string;\n  public readonly branchName: string;\n\n  constructor(protected app: awscdk.AwsCdkTypeScriptApp, protected baseOptions: CDKPipelineOptions) {\n    super(app);\n\n    // Add development dependencies\n    this.app.addDevDeps(\n      '@types/standard-version',\n      'standard-version',\n      'cdk-assets',\n    );\n    // this.app.addDeps(\n    // );\n    this.project.gitignore.exclude('/cdk-outputs-*.json');\n\n    this.stackPrefix = baseOptions.stackPrefix ?? app.name;\n    this.branchName = baseOptions.branchName ?? 'main'; // TODO use defaultReleaseBranch of NodeProject\n\n    // Removes the compiled cloud assembly before each synth\n    this.project.tasks.tryFind('synth')?.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);\n    this.project.tasks.tryFind('synth:silent')?.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);\n\n    // Remove tasks that might conflict with the pipeline process\n    this.project.removeTask('deploy');\n    this.project.removeTask('diff');\n    this.project.removeTask('destroy');\n    this.project.removeTask('watch');\n\n    // Setup versioning if enabled\n    if (baseOptions.versioning?.enabled) {\n      new VersioningSetup(this.project, baseOptions.versioning).setup();\n    }\n\n    // Creates different deployment stages\n    if (baseOptions.personalStage) {\n      this.createPersonalStage();\n    }\n    if (baseOptions.featureStages) {\n      this.createFeatureStage();\n    }\n    for (const stage of baseOptions.stages) {\n      this.createPipelineStage(stage);\n    }\n    for (const stage of (baseOptions.independentStages ?? [])) {\n      this.createIndependentStage(stage);\n    }\n\n    // Creates tasks to handle the release process\n    this.createReleaseTasks();\n\n    // Creates a specialized CDK App class\n    this.createApplicationEntrypoint();\n\n  }\n\n  public abstract engineType(): PipelineEngine;\n\n  protected provideInstallStep(): PipelineStep {\n    const seq = new StepSequence(this.project, this.baseOptions.preInstallSteps ?? []);\n    if (this.baseOptions.preInstallCommands) {\n      seq.addSteps(new SimpleCommandStep(this.project, this.baseOptions.preInstallCommands));\n    }\n    seq.addSteps(new ProjenScriptStep(this.project, this.app.package.installCiTask.name));\n    return seq;\n  }\n\n  protected provideSynthStep(): PipelineStep {\n    const seq = new StepSequence(this.project, []);\n\n    if (this.baseOptions.iamRoleArns?.synth) {\n      seq.addSteps(new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns.synth,\n      }));\n    }\n\n    seq.addSteps(...this.baseOptions.preSynthSteps ?? []);\n    if (this.baseOptions.preSynthCommands) {\n      seq.addSteps(new SimpleCommandStep(this.project, this.baseOptions.preSynthCommands));\n    }\n\n    seq.addSteps(new ProjenScriptStep(this.project, 'build'));\n\n    seq.addSteps(...this.baseOptions.postSynthSteps ?? []);\n    if (this.baseOptions.postSynthCommands) {\n      seq.addSteps(new SimpleCommandStep(this.project, this.baseOptions.postSynthCommands));\n    }\n    return seq;\n  }\n\n  protected provideAssetUploadStep(stageName?: string): PipelineStep {\n    const seq = new StepSequence(this.project, []);\n\n    const globalPublishRole = this.baseOptions.iamRoleArns.assetPublishing ?? this.baseOptions.iamRoleArns.default!;\n    if (stageName) {\n      seq.addSteps(new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns.assetPublishingPerStage ?\n          (this.baseOptions.iamRoleArns.assetPublishingPerStage[stageName] ?? globalPublishRole) :\n          globalPublishRole,\n      }));\n      seq.addSteps(new ProjenScriptStep(this.project, `publish:assets:${stageName}`));\n    } else {\n      if (this.baseOptions.iamRoleArns.assetPublishingPerStage) {\n        const stages = [...this.baseOptions.stages, ...this.baseOptions.independentStages ?? []];\n        for (const stage of stages) {\n          seq.addSteps(new AwsAssumeRoleStep(this.project, {\n            roleArn: this.baseOptions.iamRoleArns.assetPublishingPerStage[stage.name] ?? globalPublishRole,\n          }));\n          seq.addSteps(new ProjenScriptStep(this.project, `publish:assets:${stage.name}`));\n        }\n      } else {\n        seq.addSteps(new AwsAssumeRoleStep(this.project, {\n          roleArn: globalPublishRole,\n        }));\n        seq.addSteps(new ProjenScriptStep(this.project, 'publish:assets'));\n      }\n    }\n\n    return seq;\n  }\n\n  protected provideAssemblyUploadStep(): PipelineStep {\n    if (!this.baseOptions.pkgNamespace) {\n      throw new Error('pkgNamespace is required when using versioned artifacts (e.g. manual approvals)');\n    }\n    return new StepSequence(this.project, [\n      new ProjenScriptStep(this.project, 'bump'),\n      new ProjenScriptStep(this.project, 'release:push-assembly'),\n    ]);\n  }\n\n  protected provideDeployStep(stage: NamedStageOptions): PipelineStep {\n    return new StepSequence(this.project, [\n      new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns?.deployment?.[stage.name] ?? this.baseOptions.iamRoleArns?.default!,\n        region: stage.env.region,\n      }),\n      new ProjenScriptStep(this.project, `deploy:${stage.name}`),\n      ...stage.postDeploySteps ?? [],\n    ]);\n  }\n\n  protected provideDiffStep(stage: NamedStageOptions, fast?: boolean): PipelineStep {\n    return new StepSequence(this.project, [\n      new AwsAssumeRoleStep(this.project, {\n        roleArn: this.baseOptions.iamRoleArns?.diff?.[stage.name] ??\n          this.baseOptions.iamRoleArns?.deployment?.[stage.name] ??\n          this.baseOptions.iamRoleArns?.default!,\n        region: stage.env.region,\n      }),\n      new ProjenScriptStep(this.project, fast ? `fastdiff:${stage.name}` : `diff:${stage.name}`),\n      ...stage.postDiffSteps ?? [],\n    ]);\n  }\n\n  protected renderInstallPackageCommands(packageName: string, runPreInstallCommands: boolean = false): string[] {\n    const commands = runPreInstallCommands ? this.baseOptions.preInstallCommands ?? [] : [];\n\n    switch (this.app.package.packageManager) {\n      case NodePackageManager.YARN:\n      case NodePackageManager.YARN2:\n      case NodePackageManager.YARN_BERRY:\n      case NodePackageManager.YARN_CLASSIC:\n        commands.push(`yarn add ${packageName}`);\n        break;\n      case NodePackageManager.NPM:\n        commands.push(`npm install ${packageName}`);\n        break;\n      default:\n        throw new Error('No install scripts for packageManager: ' + this.app.package.packageManager);\n    }\n    return commands;\n  }\n\n  protected createSafeStageName(name: string): string {\n    // Remove non-alphanumeric characters and split into words\n    const words = name.replace(/[^a-zA-Z0-9]+/g, ' ').trim().split(/\\s+/);\n\n    // Capitalize the first letter of each word and join them\n    return words.map((word) => {\n      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\n    }).join('');\n  }\n\n  /**\n   * This method generates the entry point for the application, including interfaces and classes\n   * necessary to set up the pipeline and define the AWS CDK stacks for different environments.\n   */\n  protected createApplicationEntrypoint() {\n    let propsCode = '';\n    let appCode = '';\n    let sep = '-';\n    if (this.stackPrefix === '') {\n      sep = '';\n    }\n\n\n    if (this.baseOptions.personalStage) {\n      propsCode += `  /** This function will be used to generate a personal stack. */\n  providePersonalStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If the environment variable USER is set and a function is provided for creating a personal stack, it is called with necessary arguments.\n    if (props.providePersonalStack && process.env.USER) {\n      const stageName = 'personal-' + process.env.USER.toLowerCase().replace(/\\\\\\//g, '-');\n      props.providePersonalStack(this, '${this.stackPrefix}${sep}personal', { env: { account: '${this.baseOptions.personalStage.env.account}', region: '${this.baseOptions.personalStage.env.region}' }, stackName: \\`${this.stackPrefix}${sep}\\${stageName}\\`, stageName });\n    }\n`;\n    }\n\n    if (this.baseOptions.featureStages) {\n      propsCode += `  /** This function will be used to generate a feature stack. */\n  provideFeatureStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If the environment variable BRANCH is set and a function is provided for creating a feature stack, it is called with necessary arguments.\n    if (props.provideFeatureStack && process.env.BRANCH) {\n      const stageName = 'feature-' + process.env.BRANCH.toLowerCase().replace(/\\\\\\//g, '-');\n      props.provideFeatureStack(this, '${this.stackPrefix}${sep}feature', { env: { account: '${this.baseOptions.featureStages.env.account}', region: '${this.baseOptions.featureStages.env.region}' }, stackName: \\`${this.stackPrefix}${sep}\\${stageName}\\`, stageName });\n    }\n`;\n    }\n\n    for (const stage of this.baseOptions.stages) {\n      const nameUpperFirst = this.createSafeStageName(stage.name);\n\n      propsCode += `  /** This function will be used to generate a ${stage.name} stack. */\n  provide${nameUpperFirst}Stack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If a function is provided for creating a ${stage.name} stack, it is called with necessary arguments.\n    if (props.provide${nameUpperFirst}Stack) {\n      props.provide${nameUpperFirst}Stack(this, '${this.stackPrefix}${sep}${stage.name}', { env: { account: '${stage.env.account}', region: '${stage.env.region}' }, stackName: '${this.stackPrefix}${sep}${stage.name}', stageName: '${stage.name}' });\n    }\n`;\n    }\n\n    for (const stage of (this.baseOptions.independentStages ?? [])) {\n      const nameUpperFirst = this.createSafeStageName(stage.name);\n\n      propsCode += `  /** This function will be used to generate a ${stage.name} stack. */\n  provide${nameUpperFirst}Stack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;\n`;\n      appCode += `    // If a function is provided for creating a ${stage.name} stack, it is called with necessary arguments.\n    if (props.provide${nameUpperFirst}Stack) {\n      props.provide${nameUpperFirst}Stack(this, '${this.stackPrefix}${sep}${stage.name}', { env: { account: '${stage.env.account}', region: '${stage.env.region}' }, stackName: '${this.stackPrefix}${sep}${stage.name}', stageName: '${stage.name}' });\n    }\n`;\n    }\n\n    // Add versioning logic to apply to all stacks\n    if (this.baseOptions.versioning?.enabled) {\n      appCode += this.generateVersioningAppCode(this.baseOptions.versioning);\n    }\n\n    const appFile = new TextFile(this.project, `${this.app.srcdir}/app.ts`);\n\n    // Generate versioning-aware imports and utilities\n    const versioningImports = this.baseOptions.versioning?.enabled\n      ? this.generateVersioningImports()\n      : '';\n\n    const versioningUtilities = this.baseOptions.versioning?.enabled\n      ? this.generateVersioningUtilities()\n      : '';\n\n    const versioningConfigDeclaration = this.baseOptions.versioning?.enabled\n      ? `\nconst versioningConfig = ${JSON.stringify(this.baseOptions.versioning, null, 2)};\n`\n      : '';\n\n    appFile.addLine(`// ${PROJEN_MARKER}\n/* eslint-disable */\nimport { App, AppProps, Stack, StackProps } from 'aws-cdk-lib';\n${versioningImports}\n${versioningConfigDeclaration}\n${versioningUtilities}\n\n/**\n * PipelineAppProps is an extension of AppProps, which is part of the AWS CDK core.\n * It includes optional functions to provide AWS Stacks for different stages.\n *\n * Use these functions to instantiate your application stacks with the parameters for\n * each stage\n */\nexport interface PipelineAppProps extends AppProps {\n${propsCode}\n}\n\n/**\n * PipelineAppStackProps is an extension of StackProps, which is part of the AWS CDK core.\n * It includes an additional property to specify the stage name.\n */\nexport interface PipelineAppStackProps extends StackProps {\n  stageName: string;\n}\n\n/**\n * The PipelineApp class extends the App class from AWS CDK and overrides the constructor to support\n * different stages of the application (development, production, personal, feature) by invoking the provided\n * stack-providing functions from the props.\n */\nexport class PipelineApp extends App {\n  constructor(props: PipelineAppProps) {\n    super(props);\n\n${appCode}\n\n  }\n}\n`);\n  }\n\n\n  /**\n   * This method sets up tasks to publish CDK assets to all accounts and handle versioning, including bumping the version\n   * based on the latest git tag and pushing the CDK assembly to the package repository.\n   */\n  protected createReleaseTasks() {\n    const stages = [...this.baseOptions.stages, ...this.baseOptions.independentStages ?? []];\n    let sep = '-';\n    if (this.stackPrefix === '') {\n      sep = '';\n    }\n    // Task to publish the CDK assets to all accounts\n    for (const stage of stages) {\n      this.project.addTask(`publish:assets:${stage.name}`, {\n        steps: [{\n          exec: `npx cdk-assets -p ${this.app.cdkConfig.cdkout}/${this.stackPrefix}${sep}${stage.name}.assets.json publish`,\n        }],\n      });\n    }\n    this.project.addTask('publish:assets', {\n      steps: stages.map(stage => ({\n        spawn: `publish:assets:${stage.name}`,\n      })),\n    });\n\n    if (this.baseOptions.pkgNamespace) {\n      this.project.addTask('bump', {\n        description: 'Bumps version based on latest git tag',\n        steps: [\n          {\n            exec: 'pipelines-release bump',\n          },\n          {\n            exec: 'git push --tags',\n          },\n        ],\n      });\n      this.project.addTask('release:push-assembly', {\n        steps: [\n          {\n            exec: `pipelines-release create-manifest \"${this.app.cdkConfig.cdkout}\"  \"${this.baseOptions.pkgNamespace}\"`,\n          },\n          {\n            cwd: this.app.cdkConfig.cdkout,\n            exec: 'npm version --no-git-tag-version from-git',\n          },\n          {\n            cwd: this.app.cdkConfig.cdkout,\n            exec: 'npm publish',\n          },\n        ],\n      });\n    }\n\n  }\n\n  /**\n   * This method sets up tasks for the personal deployment stage, including deployment, watching for changes,\n   * comparing changes (diff), and destroying the stack when no longer needed.\n   */\n  protected createPersonalStage() {\n    const stackId = this.getCliStackPattern('personal');\n    this.project.addTask('deploy:personal', {\n      exec: `cdk deploy --outputs-file cdk-outputs-personal.json ${stackId}`,\n    });\n    this.project.addTask('watch:personal', {\n      exec: `cdk deploy --outputs-file cdk-outputs-personal.json --watch --hotswap ${stackId}`,\n    });\n    this.project.addTask('diff:personal', {\n      exec: `cdk diff ${stackId}`,\n    });\n    this.project.addTask('fastdiff:personal', {\n      exec: `cdk diff --no-changeset ${stackId}`,\n    });\n    this.project.addTask('destroy:personal', {\n      exec: `cdk destroy ${stackId}`,\n    });\n  }\n\n  /**\n   * This method sets up tasks for the feature deployment stage, including deployment, comparing changes (diff),\n   * and destroying the stack when no longer needed.\n   */\n  protected createFeatureStage() {\n    const stackId = this.getCliStackPattern('feature');\n    this.project.addTask('deploy:feature', {\n      exec: `cdk --outputs-file cdk-outputs-feature.json --progress events --require-approval never deploy ${stackId}`,\n    });\n    this.project.addTask('diff:feature', {\n      exec: `cdk diff ${stackId}`,\n    });\n    this.project.addTask('fastdiff:feature', {\n      exec: `cdk diff --no-changeset ${stackId}`,\n    });\n    this.project.addTask('destroy:feature', {\n      exec: `cdk destroy --force ${stackId}`,\n    });\n    this.project.addTask('watch:feature', {\n      exec: `cdk deploy --outputs-file cdk-outputs-feature.json --watch --hotswap ${stackId}`,\n    });\n  }\n\n  /**\n   * This method sets up tasks for the general pipeline stages (dev, prod), including deployment and comparing changes (diff).\n   * @param {DeployStageOptions} stage - The stage to create\n   */\n  protected createPipelineStage(stage: DeploymentStage) {\n    const stackId = this.getCliStackPattern(stage.name);\n    this.project.addTask(`deploy:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} --outputs-file cdk-outputs-${stage.name}.json --progress events --require-approval never deploy ${stackId}`,\n    });\n    this.project.addTask(`diff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${stackId}`,\n    });\n    this.project.addTask(`fastdiff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff --no-changeset ${stackId}`,\n    });\n    if (stage.watchable) {\n      this.project.addTask(`watch:${stage.name}`, {\n        exec: `cdk deploy --outputs-file cdk-outputs-${stage.name}.json --watch --hotswap ${stackId}`,\n      });\n    }\n    // Add version fetch task if versioning is enabled\n    if (this.baseOptions.versioning?.enabled) {\n      this.createVersionFetchTask(stage);\n    }\n  }\n\n  /**\n   * This method sets up tasks for the independent stages including deployment and comparing changes (diff).\n   * @param {NamedStageOptions} stage - The stage to create\n   */\n  protected createIndependentStage(stage: IndependentStage) {\n    const stackId = this.getCliStackPattern(stage.name);\n    this.project.addTask(`deploy:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} --outputs-file cdk-outputs-${stage.name}.json --progress events --require-approval never deploy ${stackId}`,\n    });\n    this.project.addTask(`diff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${stackId}`,\n    });\n    this.project.addTask(`fastdiff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff --no-changeset ${stackId}`,\n    });\n    if (stage.watchable) {\n      this.project.addTask(`watch:${stage.name}`, {\n        exec: `cdk deploy --outputs-file cdk-outputs-${stage.name}.json --watch --hotswap ${stackId}`,\n      });\n    }\n    // Add version fetch task if versioning is enabled\n    if (this.baseOptions.versioning?.enabled) {\n      this.createVersionFetchTask(stage);\n    }\n  }\n\n  protected getCliStackPattern(stage: string) {\n    let sep = '-';\n    if (this.stackPrefix === '') {\n      sep = '';\n    }\n    return this.baseOptions.deploySubStacks ? `${this.stackPrefix}${sep}${stage} ${this.stackPrefix}${sep}${stage}/*` : `${this.stackPrefix}${sep}${stage}`;\n  }\n\n  /**\n   * Create version:fetch:<stage> task to fetch version data from deployed stack\n   */\n  protected createVersionFetchTask(stage: NamedStageOptions): void {\n    const stackName = `${this.stackPrefix}${this.stackPrefix ? '-' : ''}${stage.name}`;\n    const stageConfig = this.baseOptions.versioning?.stageOverrides?.[stage.name] || this.baseOptions.versioning;\n\n    if (!stageConfig?.outputs) return;\n\n    const commands: string[] = [];\n\n    // Fetch from CloudFormation outputs\n    if (stageConfig.outputs.cloudFormation?.enabled) {\n      commands.push(\n        `echo \"Fetching version data from CloudFormation outputs for ${stage.name}...\"`,\n        `aws cloudformation describe-stacks --stack-name ${stackName} --region ${stage.env.region} --query \"Stacks[0].Outputs[?starts_with(OutputKey, 'AppVersion')].{Key:OutputKey,Value:OutputValue}\" --output table`,\n      );\n    }\n\n    // Fetch from SSM Parameter Store\n    if (stageConfig.outputs.parameterStore?.enabled) {\n      const parameterName = (stageConfig.outputs.parameterStore.parameterName || '/{stackName}/version')\n        .replace('{stackName}', stackName)\n        .replace('{stageName}', stage.name);\n\n      if ((stageConfig.outputs.parameterStore as any)?.hierarchical) {\n        commands.push(\n          `echo \"Fetching version data from SSM Parameter Store (hierarchical) for ${stage.name}...\"`,\n          `aws ssm get-parameters-by-path --path \"${parameterName}\" --region ${stage.env.region} --recursive --query \"Parameters[].{Name:Name,Value:Value}\" --output table`,\n        );\n      } else {\n        commands.push(\n          `echo \"Fetching version data from SSM Parameter Store for ${stage.name}...\"`,\n          `aws ssm get-parameter --name \"${parameterName}\" --region ${stage.env.region} --query \"Parameter.{Name:Name,Value:Value}\" --output table`,\n        );\n      }\n    }\n\n    if (commands.length > 0) {\n      this.project.addTask(`version:fetch:${stage.name}`, {\n        description: `Fetch version data from deployed ${stage.name} stack`,\n        exec: commands.join(' && '),\n      });\n    }\n  }\n\n  /**\n   * Generate CDK application code for versioning\n   */\n  public generateVersioningAppCode(config: VersioningConfig): string {\n    return `\n    // Apply versioning to all stacks\n    this.node.children.forEach((child) => {\n      if (child instanceof Stack) {\n        const stageName = child.stackName.split('-').pop() || 'default';\n        addVersioningToStack(child, stageName, ${config.stageOverrides ? 'versioningConfig.stageOverrides' : 'undefined'});\n      }\n    });`;\n  }\n\n  /**\n   * Generate versioning imports for CDK application\n   */\n  public generateVersioningImports(): string {\n    const imports: string[] = [];\n\n    imports.push(\"import { CfnOutput } from 'aws-cdk-lib';\");\n    imports.push(\"import { StringParameter } from 'aws-cdk-lib/aws-ssm';\");\n    imports.push(\"import * as fs from 'fs';\");\n\n    return imports.join('\\n');\n  }\n\n  /**\n   * Generate versioning utility functions for CDK application\n   */\n  public generateVersioningUtilities(): string {\n    return `\n/**\n * Version information interface\n */\nexport interface VersionInfo {\n  version: string;\n  commitHash: string;\n  commitHashShort: string;\n  branch: string;\n  commitCount: number;\n  packageVersion: string;\n  deployedAt: string;\n  deployedBy: string;\n  environment: string;\n}\n\n/**\n * Load version information from generated file\n */\nexport function loadVersionInfo(): VersionInfo {\n  try {\n    return JSON.parse(fs.readFileSync('~version.json', 'utf8'));\n  } catch (error) {\n    console.warn('Could not load version info, using fallback');\n    return {\n      version: '0.0.0',\n      commitHash: 'unknown',\n      commitHashShort: 'unknown',\n      branch: 'unknown',\n      commitCount: 0,\n      packageVersion: '0.0.0',\n      deployedAt: new Date().toISOString(),\n      deployedBy: 'unknown',\n      environment: 'unknown'\n    };\n  }\n}\n\n/**\n * Get versioning configuration for a specific stage\n */\nfunction getStageConfig(stageName: string, baseConfig: any, stageOverrides?: Record<string, any>): any {\n  if (!stageOverrides || !stageOverrides[stageName]) {\n    return baseConfig;\n  }\n  \n  // Merge stage override with base config\n  const override = stageOverrides[stageName];\n  return {\n    ...baseConfig,\n    outputs: {\n      cloudFormation: override.outputs?.cloudFormation || baseConfig.outputs.cloudFormation,\n      parameterStore: override.outputs?.parameterStore || baseConfig.outputs.parameterStore,\n    }\n  };\n}\n\n/**\n * Add versioning outputs to a stack\n */\nfunction addVersioningToStack(stack: Stack, stageName: string, stageOverrides?: any): void {\n  const versionInfo = loadVersionInfo();\n  const baseConfig = versioningConfig;\n  const config = getStageConfig(stageName, baseConfig, stageOverrides);\n  \n  // Check if format is specified in CloudFormation or ParameterStore configs\n  const cfFormat = config.outputs.cloudFormation?.format || 'structured';\n  const ssmFormat = config.outputs.parameterStore?.format || 'structured';\n  \n  // Add CloudFormation outputs\n  if (config.outputs.cloudFormation?.enabled) {\n    if (cfFormat === 'plain') {\n      // Plain format - single output with version string\n      new CfnOutput(stack, 'AppVersion', {\n        value: versionInfo.version,\n        description: 'Application version',\n        exportName: config.outputs.cloudFormation.exportName,\n      });\n    } else {\n      // Structured format - multiple outputs\n      new CfnOutput(stack, 'AppVersion', {\n        value: versionInfo.version,\n        description: 'Application version',\n        exportName: config.outputs.cloudFormation.exportName,\n      });\n      \n      new CfnOutput(stack, 'AppVersionCommitHash', {\n        value: versionInfo.commitHash,\n        description: 'Git commit hash',\n        exportName: config.outputs.cloudFormation.exportName ? \\`\\${config.outputs.cloudFormation.exportName}CommitHash\\` : undefined,\n      });\n      \n      new CfnOutput(stack, 'AppVersionBranch', {\n        value: versionInfo.branch,\n        description: 'Git branch',\n        exportName: config.outputs.cloudFormation.exportName ? \\`\\${config.outputs.cloudFormation.exportName}Branch\\` : undefined,\n      });\n\n      new CfnOutput(stack, 'AppVersionInfo', {\n        value: JSON.stringify(versionInfo),\n        description: 'Complete version information',\n        exportName: config.outputs.cloudFormation.exportName ? \\`\\${config.outputs.cloudFormation.exportName}Info\\` : undefined,\n      });\n    }\n  }\n  \n  // Add SSM Parameter Store parameters\n  if (config.outputs.parameterStore?.enabled) {\n    if (config.outputs.parameterStore.hierarchical) {\n      // Hierarchical parameters\n      const baseParameterName = (config.outputs.parameterStore.parameterName || '/{stackName}/version')\n        .replace('{stackName}', stack.stackName)\n        .replace('{stageName}', stageName);\n        \n      // Create hierarchical parameters\n      new StringParameter(stack, 'VersionParameterVersion', {\n        parameterName: \\`\\${baseParameterName}/version\\`,\n        stringValue: versionInfo.version,\n        description: 'Application version',\n      });\n      \n      new StringParameter(stack, 'VersionParameterCommitHash', {\n        parameterName: \\`\\${baseParameterName}/commitHash\\`,\n        stringValue: versionInfo.commitHash,\n        description: 'Git commit hash',\n      });\n      \n      new StringParameter(stack, 'VersionParameterBranch', {\n        parameterName: \\`\\${baseParameterName}/branch\\`,\n        stringValue: versionInfo.branch,\n        description: 'Git branch',\n      });\n      \n      new StringParameter(stack, 'VersionParameterInfo', {\n        parameterName: \\`\\${baseParameterName}/info\\`,\n        stringValue: JSON.stringify(versionInfo),\n        description: 'Complete version information',\n      });\n    } else {\n      // Single parameter\n      const parameterName = (config.outputs.parameterStore.parameterName || '/{stackName}/version')\n        .replace('{stackName}', stack.stackName)\n        .replace('{stageName}', stageName);\n        \n      new StringParameter(stack, 'VersionParameter', {\n        parameterName,\n        stringValue: ssmFormat === 'plain' ? versionInfo.version : JSON.stringify(versionInfo),\n        description: ssmFormat === 'plain' ? 'Application version' : 'Complete version information',\n      });\n    }\n  }\n}`;\n  }\n}\n"]}

package/lib/awscdk/bash.js

@@ -72,5 +72,5 @@ class BashCDKPipeline extends base_1.CDKPipeline {
 }
 exports.BashCDKPipeline = BashCDKPipeline;
 _a = JSII_RTTI_SYMBOL_1;
-BashCDKPipeline[_a] = { fqn: "projen-pipelines.BashCDKPipeline", version: "0.2.11" };
+BashCDKPipeline[_a] = { fqn: "projen-pipelines.BashCDKPipeline", version: "0.2.13" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bash.js","sourceRoot":"","sources":["../../src/awscdk/bash.ts"],"names":[],"mappings":"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","sourcesContent":["import { TextFile, awscdk } from 'projen';\nimport { CdkDiffType, CDKPipeline, CDKPipelineOptions } from './base';\nimport { PipelineEngine } from '../engine';\n\nexport interface BashCDKPipelineOptions extends CDKPipelineOptions {\n  //\n}\n\nexport class BashCDKPipeline extends CDKPipeline {\n\n  constructor(app: awscdk.AwsCdkTypeScriptApp, options: BashCDKPipelineOptions) {\n    super(app, options);\n\n    const readme = new TextFile(this, 'pipeline.md', { lines: [] });\n\n    readme.addLine('# How to run your pipeline');\n    readme.addLine('');\n    readme.addLine('## Build phase');\n    readme.addLine('');\n\n    readme.addLine('Synthesize your CDK project:');\n    readme.addLine('```bash');\n    readme.addLine(`${this.provideInstallStep().toBash().commands.join('\\n')}`);\n    readme.addLine(`${this.provideSynthStep().toBash().commands.join('\\n')}`);\n    readme.addLine('```');\n    readme.addLine('');\n\n    readme.addLine('Publish all your CDK assets like Lambda function code and container images:');\n    readme.addLine('```bash');\n    readme.addLine(`${this.provideInstallStep().toBash().commands.join('\\n')}`);\n    readme.addLine(`${this.provideAssetUploadStep().toBash().commands.join('\\n')}`);\n    readme.addLine('```');\n    readme.addLine('');\n    readme.addLine('If you want to store your cloud assembly and assets for future use or compliance reasons, use:');\n    readme.addLine('```bash');\n    readme.addLine(`${this.provideInstallStep().toBash().commands.join('\\n')}`);\n    readme.addLine(`${this.provideAssetUploadStep().toBash().commands.join('\\n')}`);\n    if (this.baseOptions.pkgNamespace) {\n      readme.addLine(`${this.provideAssemblyUploadStep().toBash().commands.join('\\n')}`);\n    }\n    readme.addLine('```');\n    readme.addLine('');\n    readme.addLine('## Deployment phase');\n    readme.addLine('');\n    readme.addLine('For every stage some scripts are generated for diff and deploy');\n    readme.addLine('');\n\n    for (const stage of options.stages) {\n      readme.addLine(`Stage: ${stage.name}`);\n      readme.addLine('```bash');\n      if (stage.diffType !== CdkDiffType.NONE) {\n        readme.addLine(`${this.provideDiffStep(stage, stage.diffType == CdkDiffType.FAST).toBash().commands.join('\\n')}`);\n        readme.addLine('');\n      }\n      readme.addLine(`${this.provideDeployStep(stage).toBash().commands.join('\\n')}`);\n      readme.addLine('```');\n      readme.addLine('');\n    }\n\n    readme.addLine('The stage `personal` is meant to be deployed manually by the developer and also has a watch script for live updates.');\n    readme.addLine('```bash');\n    readme.addLine('npx projen diff:personal');\n    readme.addLine('npx projen deploy:personal');\n    readme.addLine('npx projen destroy:personal');\n    readme.addLine('npx projen watch:personal');\n    readme.addLine('```');\n    readme.addLine('');\n    readme.addLine('The stage `feature` is meant to be deployed for feature branches.');\n    readme.addLine('```bash');\n    readme.addLine('npx projen diff:feature');\n    readme.addLine('npx projen deploy:feature');\n    readme.addLine('npx projen destroy:feature');\n    readme.addLine('```');\n    readme.addLine('');\n\n  }\n\n  public engineType(): PipelineEngine {\n    return PipelineEngine.BASH;\n  }\n\n}\n"]}

package/lib/awscdk/github.d.ts

@@ -43,6 +43,18 @@ export declare class GithubCDKPipeline extends CDKPipeline {
     constructor(app: awscdk.AwsCdkTypeScriptApp, options: GithubCDKPipelineOptions);
     /** the type of engine this implementation of CDKPipeline is for */
     engineType(): PipelineEngine;
+    /**
+     * Creates feature branch workflows for deploying and destroying feature environments.
+     */
+    protected createFeatureWorkflows(): void;
+    /**
+     * Creates a workflow for deploying feature branches when PRs are labeled with 'feature-deployment'.
+     */
+    private createFeatureDeployWorkflow;
+    /**
+     * Creates a workflow for destroying feature branches when PRs are closed or unlabeled.
+     */
+    private createFeatureDestroyWorkflow;
     /**
      * Creates a synthesis job for the pipeline using GitHub Actions.
      */