projen-pipelines 0.0.17 → 0.0.18

package/lib/{pipeline.d.ts → awscdk/base.d.ts}

@@ -1,5 +1,4 @@
 import { Component, awscdk } from 'projen';
-import { BaseEngine, GithubEngineConfig } from './engine';
 /**
  * The Environment interface is designed to hold AWS related information
  * for a specific deployment environment within your infrastructure.
@@ -78,14 +77,6 @@ export interface CDKPipelineOptions {
      * @default CONTINUOUS_DELIVERY
      */
     readonly deploymentType?: DeploymentType;
-    /**
-     * This field determines the CI/CD tooling that will be used to run the pipeline. The component
-     * will render workflows for the given system. Options include GitHub and GitLab.
-     *
-     * @default - tries to derive it from the projects configuration
-     */
-    readonly engine?: PipelineEngine;
-    readonly githubConfig?: GithubEngineConfig;
     readonly preInstallCommands?: string[];
     readonly preSynthCommands?: string[];
     readonly postSynthCommands?: string[];
@@ -94,13 +85,17 @@ export interface CDKPipelineOptions {
  * The CDKPipeline class extends the Component class and sets up the necessary configuration for deploying AWS CDK (Cloud Development Kit) applications across multiple stages.
  * It also manages tasks such as publishing CDK assets, bumping version based on git tags, and cleaning up conflicting tasks.
  */
-export declare class CDKPipeline extends Component {
-    private app;
-    private props;
+export declare abstract class CDKPipeline extends Component {
+    protected app: awscdk.AwsCdkTypeScriptApp;
+    private baseOptions;
     readonly stackPrefix: string;
-    readonly engine: BaseEngine;
-    constructor(app: awscdk.AwsCdkTypeScriptApp, props: CDKPipelineOptions);
-    private createSynthStage;
+    constructor(app: awscdk.AwsCdkTypeScriptApp, baseOptions: CDKPipelineOptions);
+    protected getInstallCommands(): string[];
+    protected getInstallPackageCommands(packageName: string, runPreInstallCommands?: boolean): string[];
+    protected getSynthCommands(): string[];
+    protected getAssetUploadCommands(needsVersionedArtifacts: boolean): string[];
+    protected getDeployCommands(stageName: string): string[];
+    protected getDiffCommands(stageName: string): string[];
     /**
      * This method generates the entry point for the application, including interfaces and classes
      * necessary to set up the pipeline and define the AWS CDK stacks for different environments.

package/lib/awscdk/base.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDKPipeline = exports.DeploymentType = exports.PipelineEngine = void 0;
+const projen_1 = require("projen");
+const common_1 = require("projen/lib/common");
+const javascript_1 = require("projen/lib/javascript");
+/**
+ * The CI/CD tooling used to run your pipeline.
+ * The component will render workflows for the given system
+ */
+var PipelineEngine;
+(function (PipelineEngine) {
+    /** Create GitHub actions */
+    PipelineEngine[PipelineEngine["GITHUB"] = 0] = "GITHUB";
+    /** Create a .gitlab-ci.yaml file */
+    PipelineEngine[PipelineEngine["GITLAB"] = 1] = "GITLAB";
+    // /** Create AWS CodeCatalyst workflows */
+    // CODE_CATALYST,
+})(PipelineEngine || (exports.PipelineEngine = PipelineEngine = {}));
+/**
+ * Describes the type of pipeline that will be created
+ */
+var DeploymentType;
+(function (DeploymentType) {
+    /** Deploy every commit as far as possible; hopefully into production */
+    DeploymentType[DeploymentType["CONTINUOUS_DEPLOYMENT"] = 0] = "CONTINUOUS_DEPLOYMENT";
+    /** Build every commit and prepare all assets for a later deployment */
+    DeploymentType[DeploymentType["CONTINUOUS_DELIVERY"] = 1] = "CONTINUOUS_DELIVERY";
+})(DeploymentType || (exports.DeploymentType = DeploymentType = {}));
+/**
+ * The CDKPipeline class extends the Component class and sets up the necessary configuration for deploying AWS CDK (Cloud Development Kit) applications across multiple stages.
+ * It also manages tasks such as publishing CDK assets, bumping version based on git tags, and cleaning up conflicting tasks.
+ */
+class CDKPipeline extends projen_1.Component {
+    constructor(app, baseOptions) {
+        var _a, _b, _c;
+        super(app);
+        this.app = app;
+        this.baseOptions = baseOptions;
+        // Add development dependencies
+        this.app.addDevDeps('@types/standard-version', 'standard-version', 'cdk-assets');
+        // this.app.addDeps(
+        // );
+        this.stackPrefix = (_a = baseOptions.stackPrefix) !== null && _a !== void 0 ? _a : app.name;
+        // Removes the compiled cloud assembly before each synth
+        (_b = this.project.tasks.tryFind('synth')) === null || _b === void 0 ? void 0 : _b.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);
+        (_c = this.project.tasks.tryFind('synth:silent')) === null || _c === void 0 ? void 0 : _c.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);
+        // Remove tasks that might conflict with the pipeline process
+        this.project.removeTask('deploy');
+        this.project.removeTask('diff');
+        this.project.removeTask('destroy');
+        this.project.removeTask('watch');
+        // Creates different deployment stages
+        if (baseOptions.personalStage) {
+            this.createPersonalStage();
+        }
+        if (baseOptions.featureStages) {
+            this.createFeatureStage();
+        }
+        for (const stage of baseOptions.stages) {
+            this.createPipelineStage(stage);
+        }
+        // Creates tasks to handle the release process
+        this.createReleaseTasks();
+        // Creates a specialized CDK App class
+        this.createApplicationEntrypoint();
+    }
+    getInstallCommands() {
+        var _a;
+        return [
+            ...((_a = this.baseOptions.preInstallCommands) !== null && _a !== void 0 ? _a : []),
+            `npx projen ${this.app.package.installCiTask.name}`,
+        ];
+    }
+    getInstallPackageCommands(packageName, runPreInstallCommands = false) {
+        var _a;
+        const commands = runPreInstallCommands ? (_a = this.baseOptions.preInstallCommands) !== null && _a !== void 0 ? _a : [] : [];
+        switch (this.app.package.packageManager) {
+            case javascript_1.NodePackageManager.YARN:
+            case javascript_1.NodePackageManager.YARN2:
+                commands.push(`yarn add ${packageName}`);
+                break;
+            case javascript_1.NodePackageManager.NPM:
+                commands.push(`npm install ${packageName}`);
+                break;
+            default:
+                throw new Error('No install scripts for packageManager: ' + this.app.package.packageManager);
+        }
+        return commands;
+    }
+    getSynthCommands() {
+        var _a, _b;
+        return [
+            ...this.getInstallCommands(),
+            ...((_a = this.baseOptions.preSynthCommands) !== null && _a !== void 0 ? _a : []),
+            'npx projen build',
+            ...((_b = this.baseOptions.postSynthCommands) !== null && _b !== void 0 ? _b : []),
+        ];
+    }
+    getAssetUploadCommands(needsVersionedArtifacts) {
+        return [
+            ...this.getInstallCommands(),
+            'npx projen publish:assets',
+            ...(needsVersionedArtifacts ? [
+                'npx projen bump',
+                'npx projen release:push-assembly',
+            ] : []),
+        ];
+    }
+    getDeployCommands(stageName) {
+        return [
+            `npx projen deploy:${stageName}`,
+        ];
+    }
+    getDiffCommands(stageName) {
+        return [
+            `npx projen diff:${stageName}`,
+        ];
+    }
+    /**
+     * This method generates the entry point for the application, including interfaces and classes
+     * necessary to set up the pipeline and define the AWS CDK stacks for different environments.
+     */
+    createApplicationEntrypoint() {
+        let propsCode = '';
+        let appCode = '';
+        if (this.baseOptions.personalStage) {
+            propsCode += `  /** This function will be used to generate a personal stack. */
+  providePersonalStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;
+`;
+            appCode += `    // If the environment variable USER is set and a function is provided for creating a personal stack, it is called with necessary arguments.
+    if (props.providePersonalStack && process.env.USER) {
+      const stageName = 'personal-' + process.env.USER.toLowerCase().replace(/\\\//g, '-');
+      props.providePersonalStack(this, '${this.stackPrefix}-personal', { env: ${JSON.stringify(this.baseOptions.personalStage.env)}, stackName: \`${this.stackPrefix}-\${stageName}\`, stageName });
+    }
+`;
+        }
+        if (this.baseOptions.featureStages) {
+            propsCode += `  /** This function will be used to generate a feature stack. */
+  provideFeatureStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;
+`;
+            appCode += `    // If the environment variable BRANCH is set and a function is provided for creating a feature stack, it is called with necessary arguments.
+    if (props.provideFeatureStack && process.env.BRANCH) {
+      const stageName = 'feature-' + process.env.BRANCH.toLowerCase().replace(/\\\//g, '-');
+      props.provideFeatureStack(this, '${this.stackPrefix}-feature', { env: ${JSON.stringify(this.baseOptions.featureStages.env)}, stackName: \`${this.stackPrefix}-\${stageName}\`, stageName });
+    }
+`;
+        }
+        for (const stage of this.baseOptions.stages) {
+            const nameUpperFirst = `${stage.name.charAt(0).toUpperCase()}${stage.name.substring(1)}`;
+            propsCode += `  /** This function will be used to generate a ${stage.name} stack. */
+  provide${nameUpperFirst}Stack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;
+`;
+            appCode += `    // If a function is provided for creating a ${stage.name} stack, it is called with necessary arguments.
+    if (props.provide${nameUpperFirst}Stack) {
+      props.provide${nameUpperFirst}Stack(this, '${this.stackPrefix}-${stage.name}', { env: ${JSON.stringify(stage.env)}, stackName: '${this.stackPrefix}-${stage.name}', stageName: '${stage.name}' });
+    }
+`;
+        }
+        const appFile = new projen_1.TextFile(this.project, `${this.app.srcdir}/app.ts`);
+        appFile.addLine(`// ${common_1.PROJEN_MARKER}
+/* eslint-disable */
+import { App, AppProps, Stack, StackProps } from 'aws-cdk-lib';
+
+/**
+ * PipelineAppProps is an extension of AppProps, which is part of the AWS CDK core.
+ * It includes optional functions to provide AWS Stacks for different stages.
+ *
+ * Use these functions to instantiate your application stacks with the parameters for
+ * each stage
+ */
+export interface PipelineAppProps extends AppProps {
+${propsCode}
+}
+
+/**
+ * PipelineAppStackProps is an extension of StackProps, which is part of the AWS CDK core.
+ * It includes an additional property to specify the stage name.
+ */
+export interface PipelineAppStackProps extends StackProps {
+  stageName: string;
+}
+
+/**
+ * The PipelineApp class extends the App class from AWS CDK and overrides the constructor to support
+ * different stages of the application (development, production, personal, feature) by invoking the provided
+ * stack-providing functions from the props.
+ */
+export class PipelineApp extends App {
+  constructor(props: PipelineAppProps) {
+    super(props);
+
+${appCode}
+
+  }
+}
+`);
+    }
+    /**
+     * This method sets up tasks to publish CDK assets to all accounts and handle versioning, including bumping the version
+     * based on the latest git tag and pushing the CDK assembly to the package repository.
+     */
+    createReleaseTasks() {
+        // Task to publish the CDK assets to all accounts
+        this.project.addTask('publish:assets', {
+            steps: this.baseOptions.stages.map(stage => ({
+                exec: `npx cdk-assets -p ${this.app.cdkConfig.cdkout}/${this.stackPrefix}-${stage.name}.assets.json publish`,
+            })),
+        });
+        this.project.addTask('bump', {
+            description: 'Bumps version based on latest git tag',
+            steps: [
+                {
+                    exec: 'pipelines-release bump',
+                },
+                {
+                    exec: 'git push --tags',
+                },
+            ],
+        });
+        this.project.addTask('release:push-assembly', {
+            steps: [
+                {
+                    exec: `pipelines-release create-manifest "${this.app.cdkConfig.cdkout}"  "${this.baseOptions.pkgNamespace}"`,
+                },
+                {
+                    cwd: this.app.cdkConfig.cdkout,
+                    exec: 'npm version --no-git-tag-version from-git',
+                },
+                {
+                    cwd: this.app.cdkConfig.cdkout,
+                    exec: 'npm publish',
+                },
+            ],
+        });
+    }
+    /**
+     * This method sets up tasks for the personal deployment stage, including deployment, watching for changes,
+     * comparing changes (diff), and destroying the stack when no longer needed.
+     */
+    createPersonalStage() {
+        this.project.addTask('deploy:personal', {
+            exec: `cdk deploy ${this.stackPrefix}-personal`,
+        });
+        this.project.addTask('watch:personal', {
+            exec: `cdk deploy --watch --hotswap ${this.stackPrefix}-personal`,
+        });
+        this.project.addTask('diff:personal', {
+            exec: `cdk diff ${this.stackPrefix}-personal`,
+        });
+        this.project.addTask('destroy:personal', {
+            exec: `cdk destroy ${this.stackPrefix}-personal`,
+        });
+    }
+    /**
+     * This method sets up tasks for the feature deployment stage, including deployment, comparing changes (diff),
+     * and destroying the stack when no longer needed.
+     */
+    createFeatureStage() {
+        this.project.addTask('deploy:feature', {
+            exec: `cdk --progress events --require-approval never deploy ${this.stackPrefix}-feature`,
+        });
+        this.project.addTask('diff:feature', {
+            exec: `cdk diff ${this.stackPrefix}-feature`,
+        });
+        this.project.addTask('destroy:feature', {
+            exec: `cdk destroy ${this.stackPrefix}-feature`,
+        });
+    }
+    /**
+     * This method sets up tasks for the general pipeline stages (dev, prod), including deployment and comparing changes (diff).
+     * @param {DeployStageOptions} stage - The stage to create
+     */
+    createPipelineStage(stage) {
+        this.project.addTask(`deploy:${stage.name}`, {
+            exec: `cdk --app ${this.app.cdkConfig.cdkout} --progress events --require-approval never deploy ${this.stackPrefix}-${stage.name}`,
+        });
+        this.project.addTask(`diff:${stage.name}`, {
+            exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${this.stackPrefix}-${stage.name}`,
+        });
+    }
+}
+exports.CDKPipeline = CDKPipeline;
+//# 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';\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 * The CI/CD tooling used to run your pipeline.\n * The component will render workflows for the given system\n */\nexport enum PipelineEngine {\n  /** Create GitHub actions */\n  GITHUB,\n  /** Create a .gitlab-ci.yaml file */\n  GITLAB,\n  // /** Create AWS CodeCatalyst workflows */\n  // CODE_CATALYST,\n}\n\n/**\n * Describes the type of pipeline that will be created\n */\nexport 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 interface DeploymentStage {\n  readonly name: string;\n  readonly env: Environment;\n  readonly manualApproval?: boolean;\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   * 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   * 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  readonly pkgNamespace: string;\n\n  readonly stages: DeploymentStage[];\n\n  readonly personalStage?: {\n    readonly env: Environment;\n  };\n\n  readonly featureStages?: {\n    readonly env: Environment;\n  };\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}\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\n  public readonly stackPrefix: string;\n\n  constructor(protected app: awscdk.AwsCdkTypeScriptApp, private 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\n    this.stackPrefix = baseOptions.stackPrefix ?? app.name;\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\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  protected getInstallCommands(): string[] {\n    return [\n      ...(this.baseOptions.preInstallCommands ?? []),\n      `npx projen ${this.app.package.installCiTask.name}`,\n    ];\n  }\n\n  protected getInstallPackageCommands(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        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 getSynthCommands(): string[] {\n    return [\n      ...this.getInstallCommands(),\n      ...(this.baseOptions.preSynthCommands ?? []),\n      'npx projen build',\n      ...(this.baseOptions.postSynthCommands ?? []),\n    ];\n  }\n\n  protected getAssetUploadCommands(needsVersionedArtifacts: boolean): string[] {\n    return [\n      ...this.getInstallCommands(),\n      'npx projen publish:assets',\n      ...(needsVersionedArtifacts ? [\n        'npx projen bump',\n        'npx projen release:push-assembly',\n      ] : []),\n    ];\n  }\n\n  protected getDeployCommands(stageName: string): string[] {\n    return [\n      `npx projen deploy:${stageName}`,\n    ];\n  }\n\n  protected getDiffCommands(stageName: string): string[] {\n    return [\n      `npx projen diff:${stageName}`,\n    ];\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  private createApplicationEntrypoint() {\n    let propsCode = '';\n    let appCode = '';\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}-personal', { env: ${JSON.stringify(this.baseOptions.personalStage.env)}, stackName: \\`${this.stackPrefix}-\\${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}-feature', { env: ${JSON.stringify(this.baseOptions.featureStages.env)}, stackName: \\`${this.stackPrefix}-\\${stageName}\\`, stageName });\n    }\n`;\n    }\n\n    for (const stage of this.baseOptions.stages) {\n      const nameUpperFirst = `${stage.name.charAt(0).toUpperCase()}${stage.name.substring(1)}`;\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}-${stage.name}', { env: ${JSON.stringify(stage.env)}, stackName: '${this.stackPrefix}-${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  private createReleaseTasks() {\n    // Task to publish the CDK assets to all accounts\n    this.project.addTask('publish:assets', {\n      steps: this.baseOptions.stages.map(stage => ({\n        exec: `npx cdk-assets -p ${this.app.cdkConfig.cdkout}/${this.stackPrefix}-${stage.name}.assets.json publish`,\n      })),\n    });\n\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   * 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  private createPersonalStage() {\n    this.project.addTask('deploy:personal', {\n      exec: `cdk deploy ${this.stackPrefix}-personal`,\n    });\n    this.project.addTask('watch:personal', {\n      exec: `cdk deploy --watch --hotswap ${this.stackPrefix}-personal`,\n    });\n    this.project.addTask('diff:personal', {\n      exec: `cdk diff ${this.stackPrefix}-personal`,\n    });\n    this.project.addTask('destroy:personal', {\n      exec: `cdk destroy ${this.stackPrefix}-personal`,\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  private createFeatureStage() {\n    this.project.addTask('deploy:feature', {\n      exec: `cdk --progress events --require-approval never deploy ${this.stackPrefix}-feature`,\n    });\n    this.project.addTask('diff:feature', {\n      exec: `cdk diff ${this.stackPrefix}-feature`,\n    });\n    this.project.addTask('destroy:feature', {\n      exec: `cdk destroy ${this.stackPrefix}-feature`,\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  private createPipelineStage(stage: DeploymentStage) {\n    this.project.addTask(`deploy:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} --progress events --require-approval never deploy ${this.stackPrefix}-${stage.name}`,\n    });\n    this.project.addTask(`diff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${this.stackPrefix}-${stage.name}`,\n    });\n  }\n}"]}

package/lib/awscdk/github.d.ts

@@ -0,0 +1,22 @@
+import { awscdk } from 'projen';
+import { CDKPipeline, CDKPipelineOptions, DeploymentStage } from './base';
+export interface GithubCDKPipelineOptions extends CDKPipelineOptions {
+    readonly iamRoleArns: {
+        readonly default?: string;
+        readonly synth?: string;
+        readonly assetPublishing?: string;
+        readonly deployment?: {
+            [stage: string]: string;
+        };
+    };
+}
+export declare class GithubCDKPipeline extends CDKPipeline {
+    private options;
+    readonly needsVersionedArtifacts: boolean;
+    private deploymentWorkflow;
+    private deploymentStages;
+    constructor(app: awscdk.AwsCdkTypeScriptApp, options: GithubCDKPipelineOptions);
+    private createSynth;
+    createAssetUpload(): void;
+    createDeployment(stage: DeploymentStage): void;
+}

package/lib/awscdk/github.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubCDKPipeline = void 0;
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+const base_1 = require("./base");
+class GithubCDKPipeline extends base_1.CDKPipeline {
+    constructor(app, options) {
+        super(app, options);
+        this.options = options;
+        this.deploymentStages = [];
+        this.deploymentWorkflow = this.app.github.addWorkflow('deploy');
+        this.deploymentWorkflow.on({
+            push: {
+                branches: ['main'], // TODO use defaultReleaseBranch
+            },
+            workflowDispatch: {},
+        });
+        this.needsVersionedArtifacts = this.options.stages.find(s => s.manualApproval === true) !== undefined;
+        this.createSynth();
+        this.createAssetUpload();
+        for (const stage of options.stages) {
+            this.createDeployment(stage);
+        }
+    }
+    createSynth() {
+        var _a;
+        const steps = [{
+                name: 'Checkout',
+                uses: 'actions/checkout@v3',
+            }];
+        if ((_a = this.options.iamRoleArns) === null || _a === void 0 ? void 0 : _a.synth) {
+            steps.push({
+                name: 'AWS Credentials',
+                uses: 'aws-actions/configure-aws-credentials@master',
+                with: {
+                    'role-to-assume': this.options.iamRoleArns.synth,
+                    'role-session-name': 'GitHubAction',
+                    'aws-region': 'us-east-1',
+                },
+            });
+        }
+        steps.push(...this.getSynthCommands().map(cmd => ({
+            run: cmd,
+        })));
+        steps.push({
+            uses: 'actions/upload-artifact@v3',
+            with: {
+                name: 'cloud-assembly',
+                path: `${this.app.cdkConfig.cdkout}/`,
+            },
+        });
+        this.deploymentWorkflow.addJob('synth', {
+            name: 'Synth CDK application',
+            runsOn: ['ubuntu-latest'],
+            env: {
+                CI: 'true',
+            },
+            permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: workflows_model_1.JobPermission.READ },
+            steps,
+        });
+    }
+    createAssetUpload() {
+        var _a, _b, _c;
+        this.deploymentWorkflow.addJob('assetUpload', {
+            name: 'Publish assets to AWS',
+            needs: ['synth'],
+            runsOn: ['ubuntu-latest'],
+            env: {
+                CI: 'true',
+            },
+            permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: this.needsVersionedArtifacts ? workflows_model_1.JobPermission.WRITE : workflows_model_1.JobPermission.READ },
+            steps: [{
+                    name: 'Checkout',
+                    uses: 'actions/checkout@v3',
+                    with: {
+                        'fetch-depth': 0,
+                    },
+                }, {
+                    name: 'Setup GIT identity',
+                    run: 'git config --global user.name "github-actions" && git config --global user.email "github-actions@github.com"',
+                }, {
+                    name: 'AWS Credentials',
+                    uses: 'aws-actions/configure-aws-credentials@master',
+                    with: {
+                        'role-to-assume': (_b = (_a = this.options.iamRoleArns) === null || _a === void 0 ? void 0 : _a.assetPublishing) !== null && _b !== void 0 ? _b : (_c = this.options.iamRoleArns) === null || _c === void 0 ? void 0 : _c.default,
+                        'role-session-name': 'GitHubAction',
+                        'aws-region': 'us-east-1',
+                    },
+                }, {
+                    uses: 'actions/download-artifact@v3',
+                    with: {
+                        name: 'cloud-assembly',
+                        path: `${this.app.cdkConfig.cdkout}/`,
+                    },
+                },
+                ...this.getAssetUploadCommands(this.needsVersionedArtifacts).map(cmd => ({
+                    run: cmd,
+                }))],
+        });
+    }
+    createDeployment(stage) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (stage.manualApproval === true) {
+            // Create new workflow for deployment
+            const stageWorkflow = this.app.github.addWorkflow(`release-${stage.name}`);
+            stageWorkflow.on({
+                workflowDispatch: {
+                    inputs: {
+                        version: {
+                            description: 'Package version',
+                            required: true,
+                        },
+                    },
+                },
+            });
+            stageWorkflow.addJob('deploy', {
+                name: `Release stage ${stage.name} to AWS`,
+                runsOn: ['ubuntu-latest'],
+                env: {
+                    CI: 'true',
+                },
+                permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: workflows_model_1.JobPermission.READ },
+                steps: [{
+                        name: 'Checkout',
+                        uses: 'actions/checkout@v3',
+                    }, {
+                        name: 'AWS Credentials',
+                        uses: 'aws-actions/configure-aws-credentials@master',
+                        with: {
+                            'role-to-assume': (_c = (_b = (_a = this.options.iamRoleArns) === null || _a === void 0 ? void 0 : _a.deployment) === null || _b === void 0 ? void 0 : _b[stage.name]) !== null && _c !== void 0 ? _c : (_d = this.options.iamRoleArns) === null || _d === void 0 ? void 0 : _d.default,
+                            'role-session-name': 'GitHubAction',
+                            'aws-region': stage.env.region,
+                        },
+                    },
+                    ...this.getInstallCommands().map(cmd => ({
+                        run: cmd,
+                    })),
+                    ...this.getInstallPackageCommands(`${this.options.pkgNamespace}/${this.app.name}@\${{github.event.inputs.version}}`).map(cmd => ({
+                        run: cmd,
+                    })),
+                    {
+                        run: `mv ./node_modules/${this.options.pkgNamespace}/${this.app.name} ${this.app.cdkConfig.cdkout}`,
+                    },
+                    ...this.getDeployCommands(stage.name).map(cmd => ({
+                        run: cmd,
+                    }))],
+            });
+        }
+        else {
+            // Add deployment to CI/CD workflow
+            this.deploymentWorkflow.addJob(`deploy-${stage.name}`, {
+                name: `Deploy stage ${stage.name} to AWS`,
+                needs: this.deploymentStages.length > 0 ? ['assetUpload', `deploy-${this.deploymentStages.at(-1)}`] : ['assetUpload'],
+                runsOn: ['ubuntu-latest'],
+                env: {
+                    CI: 'true',
+                },
+                permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: workflows_model_1.JobPermission.READ },
+                steps: [{
+                        name: 'Checkout',
+                        uses: 'actions/checkout@v3',
+                    }, {
+                        name: 'AWS Credentials',
+                        uses: 'aws-actions/configure-aws-credentials@master',
+                        with: {
+                            'role-to-assume': (_g = (_f = (_e = this.options.iamRoleArns) === null || _e === void 0 ? void 0 : _e.deployment) === null || _f === void 0 ? void 0 : _f[stage.name]) !== null && _g !== void 0 ? _g : (_h = this.options.iamRoleArns) === null || _h === void 0 ? void 0 : _h.default,
+                            'role-session-name': 'GitHubAction',
+                            'aws-region': stage.env.region,
+                        },
+                    }, {
+                        uses: 'actions/download-artifact@v3',
+                        with: {
+                            name: 'cloud-assembly',
+                            path: `${this.app.cdkConfig.cdkout}/`,
+                        },
+                    },
+                    ...this.getInstallCommands().map(cmd => ({
+                        run: cmd,
+                    })),
+                    ...this.getDeployCommands(stage.name).map(cmd => ({
+                        run: cmd,
+                    }))],
+            });
+            this.deploymentStages.push(stage.name);
+        }
+    }
+}
+exports.GithubCDKPipeline = GithubCDKPipeline;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github.js","sourceRoot":"","sources":["../../src/awscdk/github.ts"],"names":[],"mappings":"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","sourcesContent":["import { awscdk } from 'projen';\nimport { GithubWorkflow } from 'projen/lib/github';\nimport { JobPermission, JobStep } from 'projen/lib/github/workflows-model';\nimport { CDKPipeline, CDKPipelineOptions, DeploymentStage } from './base';\n\n\nexport interface GithubCDKPipelineOptions extends CDKPipelineOptions {\n  readonly iamRoleArns: {\n    readonly default?: string;\n    readonly synth?: string;\n    readonly assetPublishing?: string;\n    readonly deployment?: { [stage: string]: string };\n  };\n}\n\nexport class GithubCDKPipeline extends CDKPipeline {\n\n  public readonly needsVersionedArtifacts: boolean;\n\n  private deploymentWorkflow: GithubWorkflow;\n  private deploymentStages: string[] = [];\n\n  constructor(app: awscdk.AwsCdkTypeScriptApp, private options: GithubCDKPipelineOptions) {\n    super(app, options);\n\n    this.deploymentWorkflow = this.app.github!.addWorkflow('deploy');\n    this.deploymentWorkflow.on({\n      push: {\n        branches: ['main'], // TODO use defaultReleaseBranch\n      },\n      workflowDispatch: {},\n    });\n\n    this.needsVersionedArtifacts = this.options.stages.find(s => s.manualApproval === true) !== undefined;\n\n    this.createSynth();\n\n    this.createAssetUpload();\n\n    for (const stage of options.stages) {\n      this.createDeployment(stage);\n    }\n  }\n\n  private createSynth(): void {\n    const steps: JobStep[] = [{\n      name: 'Checkout',\n      uses: 'actions/checkout@v3',\n    }];\n\n    if (this.options.iamRoleArns?.synth) {\n      steps.push({\n        name: 'AWS Credentials',\n        uses: 'aws-actions/configure-aws-credentials@master',\n        with: {\n          'role-to-assume': this.options.iamRoleArns.synth,\n          'role-session-name': 'GitHubAction',\n          'aws-region': 'us-east-1',\n        },\n      });\n    }\n\n    steps.push(...this.getSynthCommands().map(cmd => ({\n      run: cmd,\n    })));\n\n    steps.push({\n      uses: 'actions/upload-artifact@v3',\n      with: {\n        name: 'cloud-assembly',\n        path: `${this.app.cdkConfig.cdkout}/`,\n      },\n    });\n\n    this.deploymentWorkflow.addJob('synth', {\n      name: 'Synth CDK application',\n      runsOn: ['ubuntu-latest'],\n      env: {\n        CI: 'true',\n      },\n      permissions: { idToken: JobPermission.WRITE, contents: JobPermission.READ },\n      steps,\n    });\n  }\n\n  public createAssetUpload(): void {\n    this.deploymentWorkflow.addJob('assetUpload', {\n      name: 'Publish assets to AWS',\n      needs: ['synth'],\n      runsOn: ['ubuntu-latest'],\n      env: {\n        CI: 'true',\n      },\n      permissions: { idToken: JobPermission.WRITE, contents: this.needsVersionedArtifacts ? JobPermission.WRITE : JobPermission.READ },\n      steps: [{\n        name: 'Checkout',\n        uses: 'actions/checkout@v3',\n        with: {\n          'fetch-depth': 0,\n        },\n      }, {\n        name: 'Setup GIT identity',\n        run: 'git config --global user.name \"github-actions\" && git config --global user.email \"github-actions@github.com\"',\n      }, {\n        name: 'AWS Credentials',\n        uses: 'aws-actions/configure-aws-credentials@master',\n        with: {\n          'role-to-assume': this.options.iamRoleArns?.assetPublishing ?? this.options.iamRoleArns?.default,\n          'role-session-name': 'GitHubAction',\n          'aws-region': 'us-east-1',\n        },\n      }, {\n        uses: 'actions/download-artifact@v3',\n        with: {\n          name: 'cloud-assembly',\n          path: `${this.app.cdkConfig.cdkout}/`,\n        },\n      },\n      ...this.getAssetUploadCommands(this.needsVersionedArtifacts).map(cmd => ({\n        run: cmd,\n      }))],\n    });\n  }\n\n  public createDeployment(stage: DeploymentStage): void {\n    if (stage.manualApproval === true) {\n      // Create new workflow for deployment\n      const stageWorkflow = this.app.github!.addWorkflow(`release-${stage.name}`);\n      stageWorkflow.on({\n        workflowDispatch: {\n          inputs: {\n            version: {\n              description: 'Package version',\n              required: true,\n            },\n          },\n        },\n      });\n      stageWorkflow.addJob('deploy', {\n        name: `Release stage ${stage.name} to AWS`,\n        runsOn: ['ubuntu-latest'],\n        env: {\n          CI: 'true',\n        },\n        permissions: { idToken: JobPermission.WRITE, contents: JobPermission.READ },\n        steps: [{\n          name: 'Checkout',\n          uses: 'actions/checkout@v3',\n        }, {\n          name: 'AWS Credentials',\n          uses: 'aws-actions/configure-aws-credentials@master',\n          with: {\n            'role-to-assume': this.options.iamRoleArns?.deployment?.[stage.name] ?? this.options.iamRoleArns?.default,\n            'role-session-name': 'GitHubAction',\n            'aws-region': stage.env.region,\n          },\n        },\n        ...this.getInstallCommands().map(cmd => ({\n          run: cmd,\n        })),\n        ...this.getInstallPackageCommands(`${this.options.pkgNamespace}/${this.app.name}@\\${{github.event.inputs.version}}`).map(cmd => ({\n          run: cmd,\n        })),\n        {\n          run: `mv ./node_modules/${this.options.pkgNamespace}/${this.app.name} ${this.app.cdkConfig.cdkout}`,\n        },\n        ...this.getDeployCommands(stage.name).map(cmd => ({\n          run: cmd,\n        }))],\n      });\n\n    } else {\n      // Add deployment to CI/CD workflow\n      this.deploymentWorkflow.addJob(`deploy-${stage.name}`, {\n        name: `Deploy stage ${stage.name} to AWS`,\n        needs: this.deploymentStages.length > 0 ? ['assetUpload', `deploy-${this.deploymentStages.at(-1)!}`] : ['assetUpload'],\n        runsOn: ['ubuntu-latest'],\n        env: {\n          CI: 'true',\n        },\n        permissions: { idToken: JobPermission.WRITE, contents: JobPermission.READ },\n        steps: [{\n          name: 'Checkout',\n          uses: 'actions/checkout@v3',\n        }, {\n          name: 'AWS Credentials',\n          uses: 'aws-actions/configure-aws-credentials@master',\n          with: {\n            'role-to-assume': this.options.iamRoleArns?.deployment?.[stage.name] ?? this.options.iamRoleArns?.default,\n            'role-session-name': 'GitHubAction',\n            'aws-region': stage.env.region,\n          },\n        }, {\n          uses: 'actions/download-artifact@v3',\n          with: {\n            name: 'cloud-assembly',\n            path: `${this.app.cdkConfig.cdkout}/`,\n          },\n        },\n        ...this.getInstallCommands().map(cmd => ({\n          run: cmd,\n        })),\n        ...this.getDeployCommands(stage.name).map(cmd => ({\n          run: cmd,\n        }))],\n      });\n      this.deploymentStages.push(stage.name);\n    }\n  }\n}\n"]}

package/lib/{engine → awscdk}/index.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./base"), exports);
 __exportStar(require("./github"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW5naW5lL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx5Q0FBdUI7QUFDdkIsMkNBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9iYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vZ2l0aHViJzsiXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXdzY2RrL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx5Q0FBdUI7QUFDdkIsMkNBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9iYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vZ2l0aHViJzsiXX0=

package/lib/index.d.ts

@@ -1,2 +1 @@
-export * from './pipeline';
-export * from './engine';
+export * from './awscdk';

package/lib/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./pipeline"), exports);
-__exportStar(require("./engine"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZDQUEyQjtBQUMzQiwyQ0FBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lJztcbmV4cG9ydCAqIGZyb20gJy4vZW5naW5lJzsiXX0=
+__exportStar(require("./awscdk"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJDQUF5QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXdzY2RrJzsiXX0=

package/package.json

@@ -67,7 +67,7 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",

package/lib/engine/base.d.ts

@@ -1,23 +0,0 @@
-import { awscdk } from 'projen';
-import { CDKPipeline, CDKPipelineOptions, DeploymentStage } from '../pipeline';
-export interface SynthStageOptions {
-    readonly commands: string[];
-}
-export interface AssetUploadStageOptions {
-    readonly commands: string[];
-}
-export interface DeployStageOptions {
-    readonly config: DeploymentStage;
-    readonly installCommands: string[];
-    readonly deployCommands: string[];
-}
-export declare abstract class BaseEngine {
-    protected app: awscdk.AwsCdkTypeScriptApp;
-    protected props: CDKPipelineOptions;
-    protected pipeline: CDKPipeline;
-    abstract readonly needsVersionedArtifacts: boolean;
-    constructor(app: awscdk.AwsCdkTypeScriptApp, props: CDKPipelineOptions, pipeline: CDKPipeline);
-    abstract createSynth(options: SynthStageOptions): void;
-    abstract createAssetUpload(options: AssetUploadStageOptions): void;
-    abstract createDeployment(options: DeployStageOptions): void;
-}

package/lib/engine/base.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEngine = void 0;
-class BaseEngine {
-    constructor(app, props, pipeline) {
-        this.app = app;
-        this.props = props;
-        this.pipeline = pipeline;
-        //
-    }
-}
-exports.BaseEngine = BaseEngine;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbmdpbmUvYmFzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFpQkEsTUFBc0IsVUFBVTtJQUk5QixZQUFzQixHQUErQixFQUFZLEtBQXlCLEVBQVksUUFBcUI7UUFBckcsUUFBRyxHQUFILEdBQUcsQ0FBNEI7UUFBWSxVQUFLLEdBQUwsS0FBSyxDQUFvQjtRQUFZLGFBQVEsR0FBUixRQUFRLENBQWE7UUFDekgsRUFBRTtJQUNKLENBQUM7Q0FNRjtBQVpELGdDQVlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXdzY2RrIH0gZnJvbSAncHJvamVuJztcbmltcG9ydCB7IENES1BpcGVsaW5lLCBDREtQaXBlbGluZU9wdGlvbnMsIERlcGxveW1lbnRTdGFnZSB9IGZyb20gJy4uL3BpcGVsaW5lJztcblxuZXhwb3J0IGludGVyZmFjZSBTeW50aFN0YWdlT3B0aW9ucyB7XG4gIHJlYWRvbmx5IGNvbW1hbmRzOiBzdHJpbmdbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBBc3NldFVwbG9hZFN0YWdlT3B0aW9ucyB7XG4gIHJlYWRvbmx5IGNvbW1hbmRzOiBzdHJpbmdbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEZXBsb3lTdGFnZU9wdGlvbnMge1xuICByZWFkb25seSBjb25maWc6IERlcGxveW1lbnRTdGFnZTtcbiAgcmVhZG9ubHkgaW5zdGFsbENvbW1hbmRzOiBzdHJpbmdbXTtcbiAgcmVhZG9ubHkgZGVwbG95Q29tbWFuZHM6IHN0cmluZ1tdO1xufVxuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZUVuZ2luZSB7XG5cbiAgcHVibGljIGFic3RyYWN0IHJlYWRvbmx5IG5lZWRzVmVyc2lvbmVkQXJ0aWZhY3RzOiBib29sZWFuO1xuXG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBhcHA6IGF3c2Nkay5Bd3NDZGtUeXBlU2NyaXB0QXBwLCBwcm90ZWN0ZWQgcHJvcHM6IENES1BpcGVsaW5lT3B0aW9ucywgcHJvdGVjdGVkIHBpcGVsaW5lOiBDREtQaXBlbGluZSkge1xuICAgIC8vXG4gIH1cblxuICBhYnN0cmFjdCBjcmVhdGVTeW50aChvcHRpb25zOiBTeW50aFN0YWdlT3B0aW9ucyk6IHZvaWQ7XG4gIGFic3RyYWN0IGNyZWF0ZUFzc2V0VXBsb2FkKG9wdGlvbnM6IEFzc2V0VXBsb2FkU3RhZ2VPcHRpb25zKTogdm9pZDtcbiAgYWJzdHJhY3QgY3JlYXRlRGVwbG95bWVudChvcHRpb25zOiBEZXBsb3lTdGFnZU9wdGlvbnMpOiB2b2lkO1xuXG59Il19

package/lib/engine/github.d.ts

@@ -1,20 +0,0 @@
-import { awscdk } from 'projen';
-import { AssetUploadStageOptions, BaseEngine, DeployStageOptions, SynthStageOptions } from './base';
-import { CDKPipeline, CDKPipelineOptions } from '../pipeline';
-export interface GithubEngineConfig {
-    readonly defaultAwsRoleArn?: string;
-    readonly awsRoleArnForSynth?: string;
-    readonly awsRoleArnForAssetPublishing?: string;
-    readonly awsRoleArnForDeployment?: {
-        [stage: string]: string;
-    };
-}
-export declare class GitHubEngine extends BaseEngine {
-    readonly needsVersionedArtifacts: boolean;
-    private deploymentWorkflow;
-    private deploymentStages;
-    constructor(app: awscdk.AwsCdkTypeScriptApp, props: CDKPipelineOptions, pipeline: CDKPipeline);
-    createSynth(options: SynthStageOptions): void;
-    createAssetUpload(options: AssetUploadStageOptions): void;
-    createDeployment(options: DeployStageOptions): void;
-}

package/lib/engine/github.js

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitHubEngine = void 0;
-const workflows_model_1 = require("projen/lib/github/workflows-model");
-const base_1 = require("./base");
-class GitHubEngine extends base_1.BaseEngine {
-    constructor(app, props, pipeline) {
-        super(app, props, pipeline);
-        this.deploymentStages = [];
-        this.deploymentWorkflow = this.app.github.addWorkflow('deploy');
-        this.deploymentWorkflow.on({
-            push: {
-                branches: ['main'], // TODO use defaultReleaseBranch
-            },
-            workflowDispatch: {},
-        });
-        this.needsVersionedArtifacts = this.props.stages.find(s => s.manualApproval === true) !== undefined;
-    }
-    createSynth(options) {
-        var _a;
-        const steps = [{
-                name: 'Checkout',
-                uses: 'actions/checkout@v3',
-            }];
-        if ((_a = this.props.githubConfig) === null || _a === void 0 ? void 0 : _a.awsRoleArnForSynth) {
-            steps.push({
-                name: 'AWS Credentials',
-                uses: 'aws-actions/configure-aws-credentials@master',
-                with: {
-                    'role-to-assume': this.props.githubConfig.awsRoleArnForSynth,
-                    'role-session-name': 'GitHubAction',
-                    'aws-region': 'us-east-1',
-                },
-            });
-        }
-        steps.push(...options.commands.map(cmd => ({
-            run: cmd,
-        })));
-        steps.push({
-            uses: 'actions/upload-artifact@v3',
-            with: {
-                name: 'cloud-assembly',
-                path: `${this.app.cdkConfig.cdkout}/`,
-            },
-        });
-        this.deploymentWorkflow.addJob('synth', {
-            name: 'Synth CDK application',
-            runsOn: ['ubuntu-latest'],
-            env: {
-                CI: 'true',
-            },
-            permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: workflows_model_1.JobPermission.READ },
-            steps,
-        });
-    }
-    createAssetUpload(options) {
-        var _a, _b, _c;
-        this.deploymentWorkflow.addJob('assetUpload', {
-            name: 'Publish assets to AWS',
-            needs: ['synth'],
-            runsOn: ['ubuntu-latest'],
-            env: {
-                CI: 'true',
-            },
-            permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: this.needsVersionedArtifacts ? workflows_model_1.JobPermission.WRITE : workflows_model_1.JobPermission.READ },
-            steps: [{
-                    name: 'Checkout',
-                    uses: 'actions/checkout@v3',
-                    with: {
-                        'fetch-depth': 0,
-                    },
-                }, {
-                    name: 'Setup GIT identity',
-                    run: 'git config --global user.name "projen pipeline" && git config --global user.email "info@taimos.de"',
-                }, {
-                    name: 'AWS Credentials',
-                    uses: 'aws-actions/configure-aws-credentials@master',
-                    with: {
-                        'role-to-assume': (_b = (_a = this.props.githubConfig) === null || _a === void 0 ? void 0 : _a.awsRoleArnForAssetPublishing) !== null && _b !== void 0 ? _b : (_c = this.props.githubConfig) === null || _c === void 0 ? void 0 : _c.defaultAwsRoleArn,
-                        'role-session-name': 'GitHubAction',
-                        'aws-region': 'us-east-1',
-                    },
-                }, {
-                    uses: 'actions/download-artifact@v3',
-                    with: {
-                        name: 'cloud-assembly',
-                        path: `${this.app.cdkConfig.cdkout}/`,
-                    },
-                },
-                ...options.commands.map(cmd => ({
-                    run: cmd,
-                }))],
-        });
-    }
-    createDeployment(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        if (options.config.manualApproval === true) {
-            // Create new workflow for deployment
-            const stageWorkflow = this.app.github.addWorkflow(`release-${options.config.name}`);
-            stageWorkflow.on({
-                workflowDispatch: {
-                    inputs: {
-                        version: {
-                            description: 'Package version',
-                            required: true,
-                        },
-                    },
-                },
-            });
-            stageWorkflow.addJob('deploy', {
-                name: `Release stage ${options.config.name} to AWS`,
-                runsOn: ['ubuntu-latest'],
-                env: {
-                    CI: 'true',
-                },
-                permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: workflows_model_1.JobPermission.READ },
-                steps: [{
-                        name: 'Checkout',
-                        uses: 'actions/checkout@v3',
-                    }, {
-                        name: 'AWS Credentials',
-                        uses: 'aws-actions/configure-aws-credentials@master',
-                        with: {
-                            'role-to-assume': (_c = (_b = (_a = this.props.githubConfig) === null || _a === void 0 ? void 0 : _a.awsRoleArnForDeployment) === null || _b === void 0 ? void 0 : _b[options.config.name]) !== null && _c !== void 0 ? _c : (_d = this.props.githubConfig) === null || _d === void 0 ? void 0 : _d.defaultAwsRoleArn,
-                            'role-session-name': 'GitHubAction',
-                            'aws-region': options.config.env.region,
-                        },
-                    },
-                    ...options.installCommands.map(cmd => ({
-                        run: cmd,
-                    })),
-                    {
-                        run: `yarn add ${this.props.pkgNamespace}/${this.app.name}@\${{github.event.inputs.version}} && mv ./node_modules/${this.props.pkgNamespace}/${this.app.name} ${this.app.cdkConfig.cdkout}`,
-                    },
-                    ...options.deployCommands.map(cmd => ({
-                        run: cmd,
-                    }))],
-            });
-        }
-        else {
-            // Add deployment to CI/CD workflow
-            this.deploymentWorkflow.addJob(`deploy-${options.config.name}`, {
-                name: `Deploy stage ${options.config.name} to AWS`,
-                needs: this.deploymentStages.length > 0 ? ['assetUpload', `deploy-${this.deploymentStages.at(-1)}`] : ['assetUpload'],
-                runsOn: ['ubuntu-latest'],
-                env: {
-                    CI: 'true',
-                },
-                permissions: { idToken: workflows_model_1.JobPermission.WRITE, contents: workflows_model_1.JobPermission.READ },
-                steps: [{
-                        name: 'Checkout',
-                        uses: 'actions/checkout@v3',
-                    }, {
-                        name: 'AWS Credentials',
-                        uses: 'aws-actions/configure-aws-credentials@master',
-                        with: {
-                            'role-to-assume': (_g = (_f = (_e = this.props.githubConfig) === null || _e === void 0 ? void 0 : _e.awsRoleArnForDeployment) === null || _f === void 0 ? void 0 : _f[options.config.name]) !== null && _g !== void 0 ? _g : (_h = this.props.githubConfig) === null || _h === void 0 ? void 0 : _h.defaultAwsRoleArn,
-                            'role-session-name': 'GitHubAction',
-                            'aws-region': options.config.env.region,
-                        },
-                    }, {
-                        uses: 'actions/download-artifact@v3',
-                        with: {
-                            name: 'cloud-assembly',
-                            path: `${this.app.cdkConfig.cdkout}/`,
-                        },
-                    },
-                    ...options.installCommands.map(cmd => ({
-                        run: cmd,
-                    })),
-                    ...options.deployCommands.map(cmd => ({
-                        run: cmd,
-                    }))],
-            });
-            this.deploymentStages.push(options.config.name);
-        }
-    }
-}
-exports.GitHubEngine = GitHubEngine;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github.js","sourceRoot":"","sources":["../../src/engine/github.ts"],"names":[],"mappings":"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","sourcesContent":["import { awscdk } from 'projen';\nimport { GithubWorkflow } from 'projen/lib/github';\nimport { JobPermission, JobStep } from 'projen/lib/github/workflows-model';\nimport { AssetUploadStageOptions, BaseEngine, DeployStageOptions, SynthStageOptions } from './base';\nimport { CDKPipeline, CDKPipelineOptions } from '../pipeline';\n\nexport interface GithubEngineConfig {\n  readonly defaultAwsRoleArn?: string;\n  readonly awsRoleArnForSynth?: string;\n  readonly awsRoleArnForAssetPublishing?: string;\n  readonly awsRoleArnForDeployment?: { [stage: string]: string };\n}\n\nexport class GitHubEngine extends BaseEngine {\n\n  public readonly needsVersionedArtifacts: boolean;\n\n  private deploymentWorkflow: GithubWorkflow;\n  private deploymentStages: string[] = [];\n\n  constructor(app: awscdk.AwsCdkTypeScriptApp, props: CDKPipelineOptions, pipeline: CDKPipeline) {\n    super(app, props, pipeline);\n\n    this.deploymentWorkflow = this.app.github!.addWorkflow('deploy');\n    this.deploymentWorkflow.on({\n      push: {\n        branches: ['main'], // TODO use defaultReleaseBranch\n      },\n      workflowDispatch: {},\n    });\n\n    this.needsVersionedArtifacts = this.props.stages.find(s => s.manualApproval === true) !== undefined;\n  }\n\n  public createSynth(options: SynthStageOptions): void {\n    const steps: JobStep[] = [{\n      name: 'Checkout',\n      uses: 'actions/checkout@v3',\n    }];\n\n    if (this.props.githubConfig?.awsRoleArnForSynth) {\n      steps.push({\n        name: 'AWS Credentials',\n        uses: 'aws-actions/configure-aws-credentials@master',\n        with: {\n          'role-to-assume': this.props.githubConfig.awsRoleArnForSynth,\n          'role-session-name': 'GitHubAction',\n          'aws-region': 'us-east-1',\n        },\n      });\n    }\n\n    steps.push(...options.commands.map(cmd => ({\n      run: cmd,\n    })));\n\n    steps.push({\n      uses: 'actions/upload-artifact@v3',\n      with: {\n        name: 'cloud-assembly',\n        path: `${this.app.cdkConfig.cdkout}/`,\n      },\n    });\n\n    this.deploymentWorkflow.addJob('synth', {\n      name: 'Synth CDK application',\n      runsOn: ['ubuntu-latest'],\n      env: {\n        CI: 'true',\n      },\n      permissions: { idToken: JobPermission.WRITE, contents: JobPermission.READ },\n      steps,\n    });\n  }\n\n  public createAssetUpload(options: AssetUploadStageOptions): void {\n    this.deploymentWorkflow.addJob('assetUpload', {\n      name: 'Publish assets to AWS',\n      needs: ['synth'],\n      runsOn: ['ubuntu-latest'],\n      env: {\n        CI: 'true',\n      },\n      permissions: { idToken: JobPermission.WRITE, contents: this.needsVersionedArtifacts ? JobPermission.WRITE : JobPermission.READ },\n      steps: [{\n        name: 'Checkout',\n        uses: 'actions/checkout@v3',\n        with: {\n          'fetch-depth': 0,\n        },\n      }, {\n        name: 'Setup GIT identity',\n        run: 'git config --global user.name \"projen pipeline\" && git config --global user.email \"info@taimos.de\"',\n      }, {\n        name: 'AWS Credentials',\n        uses: 'aws-actions/configure-aws-credentials@master',\n        with: {\n          'role-to-assume': this.props.githubConfig?.awsRoleArnForAssetPublishing ?? this.props.githubConfig?.defaultAwsRoleArn,\n          'role-session-name': 'GitHubAction',\n          'aws-region': 'us-east-1',\n        },\n      }, {\n        uses: 'actions/download-artifact@v3',\n        with: {\n          name: 'cloud-assembly',\n          path: `${this.app.cdkConfig.cdkout}/`,\n        },\n      },\n      ...options.commands.map(cmd => ({\n        run: cmd,\n      }))],\n    });\n  }\n\n  public createDeployment(options: DeployStageOptions): void {\n    if (options.config.manualApproval === true) {\n      // Create new workflow for deployment\n      const stageWorkflow = this.app.github!.addWorkflow(`release-${options.config.name}`);\n      stageWorkflow.on({\n        workflowDispatch: {\n          inputs: {\n            version: {\n              description: 'Package version',\n              required: true,\n            },\n          },\n        },\n      });\n      stageWorkflow.addJob('deploy', {\n        name: `Release stage ${options.config.name} to AWS`,\n        runsOn: ['ubuntu-latest'],\n        env: {\n          CI: 'true',\n        },\n        permissions: { idToken: JobPermission.WRITE, contents: JobPermission.READ },\n        steps: [{\n          name: 'Checkout',\n          uses: 'actions/checkout@v3',\n        }, {\n          name: 'AWS Credentials',\n          uses: 'aws-actions/configure-aws-credentials@master',\n          with: {\n            'role-to-assume': this.props.githubConfig?.awsRoleArnForDeployment?.[options.config.name] ?? this.props.githubConfig?.defaultAwsRoleArn,\n            'role-session-name': 'GitHubAction',\n            'aws-region': options.config.env.region,\n          },\n        },\n        ...options.installCommands.map(cmd => ({\n          run: cmd,\n        })),\n        {\n          run: `yarn add ${this.props.pkgNamespace}/${this.app.name}@\\${{github.event.inputs.version}} && mv ./node_modules/${this.props.pkgNamespace}/${this.app.name} ${this.app.cdkConfig.cdkout}`,\n        },\n        ...options.deployCommands.map(cmd => ({\n          run: cmd,\n        }))],\n      });\n\n    } else {\n      // Add deployment to CI/CD workflow\n      this.deploymentWorkflow.addJob(`deploy-${options.config.name}`, {\n        name: `Deploy stage ${options.config.name} to AWS`,\n        needs: this.deploymentStages.length > 0 ? ['assetUpload', `deploy-${this.deploymentStages.at(-1)!}`] : ['assetUpload'],\n        runsOn: ['ubuntu-latest'],\n        env: {\n          CI: 'true',\n        },\n        permissions: { idToken: JobPermission.WRITE, contents: JobPermission.READ },\n        steps: [{\n          name: 'Checkout',\n          uses: 'actions/checkout@v3',\n        }, {\n          name: 'AWS Credentials',\n          uses: 'aws-actions/configure-aws-credentials@master',\n          with: {\n            'role-to-assume': this.props.githubConfig?.awsRoleArnForDeployment?.[options.config.name] ?? this.props.githubConfig?.defaultAwsRoleArn,\n            'role-session-name': 'GitHubAction',\n            'aws-region': options.config.env.region,\n          },\n        }, {\n          uses: 'actions/download-artifact@v3',\n          with: {\n            name: 'cloud-assembly',\n            path: `${this.app.cdkConfig.cdkout}/`,\n          },\n        },\n        ...options.installCommands.map(cmd => ({\n          run: cmd,\n        })),\n        ...options.deployCommands.map(cmd => ({\n          run: cmd,\n        }))],\n      });\n      this.deploymentStages.push(options.config.name);\n    }\n  }\n}"]}

package/lib/pipeline.js

@@ -1,277 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CDKPipeline = exports.DeploymentType = exports.PipelineEngine = void 0;
-const projen_1 = require("projen");
-const common_1 = require("projen/lib/common");
-const engine_1 = require("./engine");
-/**
- * The CI/CD tooling used to run your pipeline.
- * The component will render workflows for the given system
- */
-var PipelineEngine;
-(function (PipelineEngine) {
-    /** Create GitHub actions */
-    PipelineEngine[PipelineEngine["GITHUB"] = 0] = "GITHUB";
-    /** Create a .gitlab-ci.yaml file */
-    PipelineEngine[PipelineEngine["GITLAB"] = 1] = "GITLAB";
-    // /** Create AWS CodeCatalyst workflows */
-    // CODE_CATALYST,
-})(PipelineEngine || (exports.PipelineEngine = PipelineEngine = {}));
-/**
- * Describes the type of pipeline that will be created
- */
-var DeploymentType;
-(function (DeploymentType) {
-    /** Deploy every commit as far as possible; hopefully into production */
-    DeploymentType[DeploymentType["CONTINUOUS_DEPLOYMENT"] = 0] = "CONTINUOUS_DEPLOYMENT";
-    /** Build every commit and prepare all assets for a later deployment */
-    DeploymentType[DeploymentType["CONTINUOUS_DELIVERY"] = 1] = "CONTINUOUS_DELIVERY";
-})(DeploymentType || (exports.DeploymentType = DeploymentType = {}));
-/**
- * The CDKPipeline class extends the Component class and sets up the necessary configuration for deploying AWS CDK (Cloud Development Kit) applications across multiple stages.
- * It also manages tasks such as publishing CDK assets, bumping version based on git tags, and cleaning up conflicting tasks.
- */
-class CDKPipeline extends projen_1.Component {
-    constructor(app, props) {
-        var _a, _b, _c;
-        super(app);
-        this.app = app;
-        this.props = props;
-        // Add development dependencies
-        this.app.addDevDeps('@types/standard-version', 'standard-version', 'cdk-assets');
-        // this.app.addDeps(
-        // );
-        this.stackPrefix = (_a = props.stackPrefix) !== null && _a !== void 0 ? _a : app.name;
-        // Create engine instance to use
-        switch (props.engine) {
-            case PipelineEngine.GITHUB:
-                this.engine = new engine_1.GitHubEngine(app, props, this);
-                break;
-            default:
-                throw new Error('Invalid engine');
-        }
-        // Removes the compiled cloud assembly before each synth
-        (_b = this.project.tasks.tryFind('synth')) === null || _b === void 0 ? void 0 : _b.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);
-        (_c = this.project.tasks.tryFind('synth:silent')) === null || _c === void 0 ? void 0 : _c.prependExec(`rm -rf ${this.app.cdkConfig.cdkout}`);
-        // Remove tasks that might conflict with the pipeline process
-        this.project.removeTask('deploy');
-        this.project.removeTask('diff');
-        this.project.removeTask('destroy');
-        this.project.removeTask('watch');
-        this.createSynthStage();
-        // Creates different deployment stages
-        if (props.personalStage) {
-            this.createPersonalStage();
-        }
-        if (props.featureStages) {
-            this.createFeatureStage();
-        }
-        for (const stage of props.stages) {
-            this.createPipelineStage(stage);
-        }
-        // Creates tasks to handle the release process
-        this.createReleaseTasks();
-        // Creates a specialized CDK App class
-        this.createApplicationEntrypoint();
-    }
-    createSynthStage() {
-        var _a, _b, _c, _d;
-        this.engine.createSynth({
-            commands: [
-                ...((_a = this.props.preInstallCommands) !== null && _a !== void 0 ? _a : []),
-                `npx projen ${this.app.package.installCiTask.name}`,
-                ...((_b = this.props.preSynthCommands) !== null && _b !== void 0 ? _b : []),
-                'npx projen build',
-                ...((_c = this.props.postSynthCommands) !== null && _c !== void 0 ? _c : []),
-            ],
-        });
-        this.engine.createAssetUpload({
-            commands: [
-                ...((_d = this.props.preInstallCommands) !== null && _d !== void 0 ? _d : []),
-                `npx projen ${this.app.package.installCiTask.name}`,
-                'npx projen publish:assets',
-                ...(this.engine.needsVersionedArtifacts ? [
-                    'npx projen bump',
-                    'npx projen release:push-assembly',
-                ] : []),
-            ],
-        });
-    }
-    /**
-     * This method generates the entry point for the application, including interfaces and classes
-     * necessary to set up the pipeline and define the AWS CDK stacks for different environments.
-     */
-    createApplicationEntrypoint() {
-        let propsCode = '';
-        let appCode = '';
-        if (this.props.personalStage) {
-            propsCode += `  /** This function will be used to generate a personal stack. */
-  providePersonalStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;
-`;
-            appCode += `    // If the environment variable USER is set and a function is provided for creating a personal stack, it is called with necessary arguments.
-    if (props.providePersonalStack && process.env.USER) {
-      const stageName = 'personal-' + process.env.USER.toLowerCase().replace(/\\\//g, '-');
-      props.providePersonalStack(this, '${this.stackPrefix}-personal', { env: ${JSON.stringify(this.props.personalStage.env)}, stackName: \`${this.stackPrefix}-\${stageName}\`, stageName });
-    }
-`;
-        }
-        if (this.props.featureStages) {
-            propsCode += `  /** This function will be used to generate a feature stack. */
-  provideFeatureStack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;
-`;
-            appCode += `    // If the environment variable BRANCH is set and a function is provided for creating a feature stack, it is called with necessary arguments.
-    if (props.provideFeatureStack && process.env.BRANCH) {
-      const stageName = 'feature-' + process.env.BRANCH.toLowerCase().replace(/\\\//g, '-');
-      props.provideFeatureStack(this, '${this.stackPrefix}-feature', { env: ${JSON.stringify(this.props.featureStages.env)}, stackName: \`${this.stackPrefix}-\${stageName}\`, stageName });
-    }
-`;
-        }
-        for (const stage of this.props.stages) {
-            const nameUpperFirst = `${stage.name.charAt(0).toUpperCase()}${stage.name.substring(1)}`;
-            propsCode += `  /** This function will be used to generate a ${stage.name} stack. */
-  provide${nameUpperFirst}Stack: (app: App, stackId: string, props: PipelineAppStackProps) => Stack;
-`;
-            appCode += `    // If a function is provided for creating a ${stage.name} stack, it is called with necessary arguments.
-    if (props.provide${nameUpperFirst}Stack) {
-      props.provide${nameUpperFirst}Stack(this, '${this.stackPrefix}-${stage.name}', { env: ${JSON.stringify(stage.env)}, stackName: '${this.stackPrefix}-${stage.name}', stageName: '${stage.name}' });
-    }
-`;
-        }
-        const appFile = new projen_1.TextFile(this.project, `${this.app.srcdir}/app.ts`);
-        appFile.addLine(`// ${common_1.PROJEN_MARKER}
-/* eslint-disable */
-import { App, AppProps, Stack, StackProps } from 'aws-cdk-lib';
-
-/**
- * PipelineAppProps is an extension of AppProps, which is part of the AWS CDK core.
- * It includes optional functions to provide AWS Stacks for different stages.
- *
- * Use these functions to instantiate your application stacks with the parameters for
- * each stage
- */
-export interface PipelineAppProps extends AppProps {
-${propsCode}
-}
-
-/**
- * PipelineAppStackProps is an extension of StackProps, which is part of the AWS CDK core.
- * It includes an additional property to specify the stage name.
- */
-export interface PipelineAppStackProps extends StackProps {
-  stageName: string;
-}
-
-/**
- * The PipelineApp class extends the App class from AWS CDK and overrides the constructor to support
- * different stages of the application (development, production, personal, feature) by invoking the provided
- * stack-providing functions from the props.
- */
-export class PipelineApp extends App {
-  constructor(props: PipelineAppProps) {
-    super(props);
-
-${appCode}
-
-  }
-}
-`);
-    }
-    /**
-     * This method sets up tasks to publish CDK assets to all accounts and handle versioning, including bumping the version
-     * based on the latest git tag and pushing the CDK assembly to the package repository.
-     */
-    createReleaseTasks() {
-        // Task to publish the CDK assets to all accounts
-        this.project.addTask('publish:assets', {
-            steps: this.props.stages.map(stage => ({
-                exec: `npx cdk-assets -p ${this.app.cdkConfig.cdkout}/${this.stackPrefix}-${stage.name}.assets.json publish`,
-            })),
-        });
-        this.project.addTask('bump', {
-            description: 'Bumps version based on latest git tag',
-            steps: [
-                {
-                    exec: 'pipelines-release bump',
-                },
-                {
-                    exec: 'git push --tags',
-                },
-            ],
-        });
-        this.project.addTask('release:push-assembly', {
-            steps: [
-                {
-                    exec: `pipelines-release create-manifest "${this.app.cdkConfig.cdkout}"  "${this.props.pkgNamespace}"`,
-                },
-                {
-                    cwd: this.app.cdkConfig.cdkout,
-                    exec: 'npm version --no-git-tag-version from-git',
-                },
-                {
-                    cwd: this.app.cdkConfig.cdkout,
-                    exec: 'npm publish',
-                },
-            ],
-        });
-    }
-    /**
-     * This method sets up tasks for the personal deployment stage, including deployment, watching for changes,
-     * comparing changes (diff), and destroying the stack when no longer needed.
-     */
-    createPersonalStage() {
-        this.project.addTask('deploy:personal', {
-            exec: `cdk deploy ${this.stackPrefix}-personal`,
-        });
-        this.project.addTask('watch:personal', {
-            exec: `cdk deploy --watch --hotswap ${this.stackPrefix}-personal`,
-        });
-        this.project.addTask('diff:personal', {
-            exec: `cdk diff ${this.stackPrefix}-personal`,
-        });
-        this.project.addTask('destroy:personal', {
-            exec: `cdk destroy ${this.stackPrefix}-personal`,
-        });
-    }
-    /**
-     * This method sets up tasks for the feature deployment stage, including deployment, comparing changes (diff),
-     * and destroying the stack when no longer needed.
-     */
-    createFeatureStage() {
-        this.project.addTask('deploy:feature', {
-            exec: `cdk --progress events --require-approval never deploy ${this.stackPrefix}-feature`,
-        });
-        this.project.addTask('diff:feature', {
-            exec: `cdk diff ${this.stackPrefix}-feature`,
-        });
-        this.project.addTask('destroy:feature', {
-            exec: `cdk destroy ${this.stackPrefix}-feature`,
-        });
-    }
-    /**
-     * This method sets up tasks for the general pipeline stages (dev, prod), including deployment and comparing changes (diff).
-     * @param {DeployStageOptions} stage - The stage to create
-     */
-    createPipelineStage(stage) {
-        var _a;
-        this.project.addTask(`deploy:${stage.name}`, {
-            exec: `cdk --app ${this.app.cdkConfig.cdkout} --progress events --require-approval never deploy ${this.stackPrefix}-${stage.name}`,
-        });
-        this.project.addTask(`diff:${stage.name}`, {
-            exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${this.stackPrefix}-${stage.name}`,
-        });
-        this.engine.createDeployment({
-            config: stage,
-            installCommands: [
-                ...((_a = this.props.preInstallCommands) !== null && _a !== void 0 ? _a : []),
-                `npx projen ${this.app.package.installCiTask.name}`,
-            ],
-            deployCommands: [
-                // TODO pre deploy steps
-                `npx projen deploy:${stage.name}`,
-                // TODO post deploy steps
-            ],
-        });
-    }
-}
-exports.CDKPipeline = CDKPipeline;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, TextFile, awscdk } from 'projen';\nimport { PROJEN_MARKER } from 'projen/lib/common';\nimport { BaseEngine, GitHubEngine, GithubEngineConfig } from './engine';\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 * The CI/CD tooling used to run your pipeline.\n * The component will render workflows for the given system\n */\nexport enum PipelineEngine {\n  /** Create GitHub actions */\n  GITHUB,\n  /** Create a .gitlab-ci.yaml file */\n  GITLAB,\n  // /** Create AWS CodeCatalyst workflows */\n  // CODE_CATALYST,\n}\n\n/**\n * Describes the type of pipeline that will be created\n */\nexport 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 interface DeploymentStage {\n  readonly name: string;\n  readonly env: Environment;\n  readonly manualApproval?: boolean;\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   * 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   * 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  readonly pkgNamespace: string;\n\n  readonly stages: DeploymentStage[];\n\n  readonly personalStage?: {\n    readonly env: Environment;\n  };\n\n  readonly featureStages?: {\n    readonly env: Environment;\n  };\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  /**\n   * This field determines the CI/CD tooling that will be used to run the pipeline. The component\n   * will render workflows for the given system. Options include GitHub and GitLab.\n   *\n   * @default - tries to derive it from the projects configuration\n   */\n  readonly engine?: PipelineEngine;\n\n  readonly githubConfig?: GithubEngineConfig;\n\n  readonly preInstallCommands?: string[];\n  readonly preSynthCommands?: string[];\n  readonly postSynthCommands?: string[];\n\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 class CDKPipeline extends Component {\n\n  public readonly stackPrefix: string;\n  public readonly engine: BaseEngine;\n\n  constructor(private app: awscdk.AwsCdkTypeScriptApp, private props: 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\n    this.stackPrefix = props.stackPrefix ?? app.name;\n\n    // Create engine instance to use\n    switch (props.engine) {\n      case PipelineEngine.GITHUB:\n        this.engine = new GitHubEngine(app, props, this);\n        break;\n      default:\n        throw new Error('Invalid engine');\n    }\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    this.createSynthStage();\n\n    // Creates different deployment stages\n    if (props.personalStage) {\n      this.createPersonalStage();\n    }\n    if (props.featureStages) {\n      this.createFeatureStage();\n    }\n    for (const stage of props.stages) {\n      this.createPipelineStage(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  private createSynthStage() {\n    this.engine.createSynth({\n      commands: [\n        ...(this.props.preInstallCommands ?? []),\n        `npx projen ${this.app.package.installCiTask.name}`,\n        ...(this.props.preSynthCommands ?? []),\n        'npx projen build',\n        ...(this.props.postSynthCommands ?? []),\n      ],\n    });\n    this.engine.createAssetUpload({\n      commands: [\n        ...(this.props.preInstallCommands ?? []),\n        `npx projen ${this.app.package.installCiTask.name}`,\n        'npx projen publish:assets',\n        ...(this.engine.needsVersionedArtifacts ? [\n          'npx projen bump',\n          'npx projen release:push-assembly',\n        ] : []),\n      ],\n    });\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  private createApplicationEntrypoint() {\n    let propsCode = '';\n    let appCode = '';\n\n    if (this.props.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}-personal', { env: ${JSON.stringify(this.props.personalStage.env)}, stackName: \\`${this.stackPrefix}-\\${stageName}\\`, stageName });\n    }\n`;\n    }\n\n    if (this.props.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}-feature', { env: ${JSON.stringify(this.props.featureStages.env)}, stackName: \\`${this.stackPrefix}-\\${stageName}\\`, stageName });\n    }\n`;\n    }\n\n    for (const stage of this.props.stages) {\n      const nameUpperFirst = `${stage.name.charAt(0).toUpperCase()}${stage.name.substring(1)}`;\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}-${stage.name}', { env: ${JSON.stringify(stage.env)}, stackName: '${this.stackPrefix}-${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  private createReleaseTasks() {\n    // Task to publish the CDK assets to all accounts\n    this.project.addTask('publish:assets', {\n      steps: this.props.stages.map(stage => ({\n        exec: `npx cdk-assets -p ${this.app.cdkConfig.cdkout}/${this.stackPrefix}-${stage.name}.assets.json publish`,\n      })),\n    });\n\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.props.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   * 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  private createPersonalStage() {\n    this.project.addTask('deploy:personal', {\n      exec: `cdk deploy ${this.stackPrefix}-personal`,\n    });\n    this.project.addTask('watch:personal', {\n      exec: `cdk deploy --watch --hotswap ${this.stackPrefix}-personal`,\n    });\n    this.project.addTask('diff:personal', {\n      exec: `cdk diff ${this.stackPrefix}-personal`,\n    });\n    this.project.addTask('destroy:personal', {\n      exec: `cdk destroy ${this.stackPrefix}-personal`,\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  private createFeatureStage() {\n    this.project.addTask('deploy:feature', {\n      exec: `cdk --progress events --require-approval never deploy ${this.stackPrefix}-feature`,\n    });\n    this.project.addTask('diff:feature', {\n      exec: `cdk diff ${this.stackPrefix}-feature`,\n    });\n    this.project.addTask('destroy:feature', {\n      exec: `cdk destroy ${this.stackPrefix}-feature`,\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  private createPipelineStage(stage: DeploymentStage) {\n    this.project.addTask(`deploy:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} --progress events --require-approval never deploy ${this.stackPrefix}-${stage.name}`,\n    });\n    this.project.addTask(`diff:${stage.name}`, {\n      exec: `cdk --app ${this.app.cdkConfig.cdkout} diff ${this.stackPrefix}-${stage.name}`,\n    });\n\n    this.engine.createDeployment({\n      config: stage,\n      installCommands: [\n        ...(this.props.preInstallCommands ?? []),\n        `npx projen ${this.app.package.installCiTask.name}`,\n      ],\n      deployCommands: [\n        // TODO pre deploy steps\n        `npx projen deploy:${stage.name}`,\n        // TODO post deploy steps\n      ],\n    });\n  }\n}"]}