projen-pipelines 0.2.11 → 0.2.13

package/lib/versioning/version-info.d.ts

@@ -0,0 +1,106 @@
+import { IVersionInfo, GitInfoInput, DeploymentInfoInput } from './types';
+/**
+ * Represents complete version information for a deployment
+ */
+export declare class VersionInfo implements IVersionInfo {
+    /**
+     * Create a VersionInfo instance from raw data
+     */
+    static create(props: IVersionInfo): VersionInfo;
+    /**
+     * Create a VersionInfo instance from environment variables
+     */
+    static fromEnvironment(env: {
+        [key: string]: string;
+    }): VersionInfo;
+    /**
+     * Create a VersionInfo instance from a JSON string
+     */
+    static fromJson(json: string): VersionInfo;
+    readonly version: string;
+    readonly commitHash: string;
+    readonly commitHashShort: string;
+    readonly branch: string;
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    readonly commitCount: number;
+    readonly packageVersion?: string;
+    readonly deployedAt: string;
+    readonly deployedBy: string;
+    readonly buildNumber?: string;
+    readonly environment: string;
+    readonly repository?: string;
+    readonly pipelineVersion?: string;
+    private constructor();
+    /**
+     * Convert to plain version string
+     */
+    toString(): string;
+    /**
+     * Convert to JSON string
+     */
+    toJson(pretty?: boolean): string;
+    /**
+     * Convert to object
+     */
+    toObject(): IVersionInfo;
+    /**
+     * Get formatted version for display
+     */
+    displayVersion(): string;
+    /**
+     * Check if this version is from a tagged release
+     */
+    taggedRelease(): boolean;
+    /**
+     * Check if this version is from the main branch
+     */
+    mainBranch(): boolean;
+    /**
+     * Compare with another version
+     * Returns: -1 if this < other, 0 if equal, 1 if this > other
+     */
+    compare(other: VersionInfo): number;
+    /**
+     * Create a parameter name for SSM Parameter Store
+     */
+    parameterName(template: string): string;
+    /**
+     * Create CloudFormation export name
+     */
+    exportName(template: string): string;
+}
+/**
+ * Builder class for creating VersionInfo instances
+ */
+export declare class VersionInfoBuilder {
+    private props;
+    /**
+     * Set the version string
+     */
+    version(version: string): this;
+    /**
+     * Set git information
+     */
+    gitInfo(info: GitInfoInput): this;
+    /**
+     * Set package version
+     */
+    packageVersion(version: string): this;
+    /**
+     * Set deployment metadata
+     */
+    deploymentInfo(info: DeploymentInfoInput): this;
+    /**
+     * Set repository information
+     */
+    repository(repo: string): this;
+    /**
+     * Set pipeline version
+     */
+    pipelineVersion(version: string): this;
+    /**
+     * Build the VersionInfo instance
+     */
+    create(): VersionInfo;
+}

package/lib/versioning/version-info.js

@@ -0,0 +1,269 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionInfoBuilder = exports.VersionInfo = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Represents complete version information for a deployment
+ */
+class VersionInfo {
+    /**
+     * Create a VersionInfo instance from raw data
+     */
+    static create(props) {
+        return new VersionInfo(props);
+    }
+    /**
+     * Create a VersionInfo instance from environment variables
+     */
+    static fromEnvironment(env) {
+        const commitHash = env.GITHUB_SHA || env.GIT_COMMIT_HASH || '';
+        const commitHashShort = commitHash.substring(0, 8);
+        const props = {
+            version: env.VERSION || '0.0.0',
+            commitHash,
+            commitHashShort,
+            branch: env.GIT_BRANCH || env.GITHUB_REF_NAME || 'unknown',
+            commitCount: parseInt(env.GIT_COMMIT_COUNT || '0', 10),
+            deployedAt: new Date().toISOString(),
+            deployedBy: env.GITHUB_ACTOR || env.GITLAB_USER_LOGIN || env.USER || 'unknown',
+            environment: env.STAGE || env.ENVIRONMENT || 'unknown',
+        };
+        // Add optional fields only if they exist
+        if (env.GIT_TAG)
+            props.tag = env.GIT_TAG;
+        if (env.COMMITS_SINCE_TAG)
+            props.commitsSinceTag = parseInt(env.COMMITS_SINCE_TAG, 10);
+        if (env.PACKAGE_VERSION)
+            props.packageVersion = env.PACKAGE_VERSION;
+        if (env.GITHUB_RUN_NUMBER)
+            props.buildNumber = env.GITHUB_RUN_NUMBER;
+        else if (env.CI_PIPELINE_ID)
+            props.buildNumber = env.CI_PIPELINE_ID;
+        if (env.GITHUB_REPOSITORY)
+            props.repository = env.GITHUB_REPOSITORY;
+        else if (env.CI_PROJECT_PATH)
+            props.repository = env.CI_PROJECT_PATH;
+        if (env.PIPELINE_VERSION)
+            props.pipelineVersion = env.PIPELINE_VERSION;
+        return new VersionInfo(props);
+    }
+    /**
+     * Create a VersionInfo instance from a JSON string
+     */
+    static fromJson(json) {
+        const data = JSON.parse(json);
+        return new VersionInfo(data);
+    }
+    constructor(props) {
+        this.version = props.version;
+        this.commitHash = props.commitHash;
+        this.commitHashShort = props.commitHashShort;
+        this.branch = props.branch;
+        this.tag = props.tag;
+        this.commitsSinceTag = props.commitsSinceTag;
+        this.commitCount = props.commitCount;
+        this.packageVersion = props.packageVersion;
+        this.deployedAt = props.deployedAt;
+        this.deployedBy = props.deployedBy;
+        this.buildNumber = props.buildNumber;
+        this.environment = props.environment;
+        this.repository = props.repository;
+        this.pipelineVersion = props.pipelineVersion;
+    }
+    /**
+     * Convert to plain version string
+     */
+    toString() {
+        return this.version;
+    }
+    /**
+     * Convert to JSON string
+     */
+    toJson(pretty = false) {
+        const data = {
+            version: this.version,
+            commitHash: this.commitHash,
+            commitHashShort: this.commitHashShort,
+            branch: this.branch,
+            commitCount: this.commitCount,
+            deployedAt: this.deployedAt,
+            deployedBy: this.deployedBy,
+            environment: this.environment,
+        };
+        if (this.tag !== undefined)
+            data.tag = this.tag;
+        if (this.commitsSinceTag !== undefined)
+            data.commitsSinceTag = this.commitsSinceTag;
+        if (this.packageVersion !== undefined)
+            data.packageVersion = this.packageVersion;
+        if (this.buildNumber !== undefined)
+            data.buildNumber = this.buildNumber;
+        if (this.repository !== undefined)
+            data.repository = this.repository;
+        if (this.pipelineVersion !== undefined)
+            data.pipelineVersion = this.pipelineVersion;
+        return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    }
+    /**
+     * Convert to object
+     */
+    toObject() {
+        return JSON.parse(this.toJson());
+    }
+    /**
+     * Get formatted version for display
+     */
+    displayVersion() {
+        if (this.tag && this.commitsSinceTag === 0) {
+            return this.tag;
+        }
+        return this.version;
+    }
+    /**
+     * Check if this version is from a tagged release
+     */
+    taggedRelease() {
+        return this.tag !== undefined && this.commitsSinceTag === 0;
+    }
+    /**
+     * Check if this version is from the main branch
+     */
+    mainBranch() {
+        return this.branch === 'main' || this.branch === 'master';
+    }
+    /**
+     * Compare with another version
+     * Returns: -1 if this < other, 0 if equal, 1 if this > other
+     */
+    compare(other) {
+        // First compare by commit count
+        if (this.commitCount < other.commitCount)
+            return -1;
+        if (this.commitCount > other.commitCount)
+            return 1;
+        // Then by version string
+        return this.version.localeCompare(other.version);
+    }
+    /**
+     * Create a parameter name for SSM Parameter Store
+     */
+    parameterName(template) {
+        return template
+            .replace('{stage}', this.environment)
+            .replace('{environment}', this.environment)
+            .replace('{branch}', this.branch)
+            .replace('{version}', this.version);
+    }
+    /**
+     * Create CloudFormation export name
+     */
+    exportName(template) {
+        return template
+            .replace('{stage}', this.environment)
+            .replace('{environment}', this.environment)
+            .replace('{branch}', this.branch)
+            .replace('{version}', this.version);
+    }
+}
+exports.VersionInfo = VersionInfo;
+_a = JSII_RTTI_SYMBOL_1;
+VersionInfo[_a] = { fqn: "projen-pipelines.VersionInfo", version: "0.2.13" };
+/**
+ * Builder class for creating VersionInfo instances
+ */
+class VersionInfoBuilder {
+    constructor() {
+        this.props = {};
+    }
+    /**
+     * Set the version string
+     */
+    version(version) {
+        this.props.version = version;
+        return this;
+    }
+    /**
+     * Set git information
+     */
+    gitInfo(info) {
+        this.props.commitHash = info.commitHash;
+        this.props.commitHashShort = info.commitHash.substring(0, 8);
+        this.props.branch = info.branch;
+        this.props.tag = info.tag;
+        this.props.commitsSinceTag = info.commitsSinceTag;
+        this.props.commitCount = info.commitCount;
+        return this;
+    }
+    /**
+     * Set package version
+     */
+    packageVersion(version) {
+        this.props.packageVersion = version;
+        return this;
+    }
+    /**
+     * Set deployment metadata
+     */
+    deploymentInfo(info) {
+        this.props.environment = info.environment;
+        this.props.deployedBy = info.deployedBy ?? 'unknown';
+        this.props.buildNumber = info.buildNumber;
+        this.props.deployedAt = new Date().toISOString();
+        return this;
+    }
+    /**
+     * Set repository information
+     */
+    repository(repo) {
+        this.props.repository = repo;
+        return this;
+    }
+    /**
+     * Set pipeline version
+     */
+    pipelineVersion(version) {
+        this.props.pipelineVersion = version;
+        return this;
+    }
+    /**
+     * Build the VersionInfo instance
+     */
+    create() {
+        if (!this.props.version) {
+            throw new Error('Version is required');
+        }
+        if (!this.props.commitHash) {
+            throw new Error('Commit hash is required');
+        }
+        if (!this.props.branch) {
+            throw new Error('Branch is required');
+        }
+        if (this.props.commitCount === undefined) {
+            throw new Error('Commit count is required');
+        }
+        if (!this.props.environment) {
+            throw new Error('Environment is required');
+        }
+        return VersionInfo.create({
+            version: this.props.version,
+            commitHash: this.props.commitHash,
+            commitHashShort: this.props.commitHashShort,
+            branch: this.props.branch,
+            tag: this.props.tag,
+            commitsSinceTag: this.props.commitsSinceTag,
+            commitCount: this.props.commitCount,
+            packageVersion: this.props.packageVersion,
+            deployedAt: this.props.deployedAt ?? new Date().toISOString(),
+            deployedBy: this.props.deployedBy ?? 'unknown',
+            buildNumber: this.props.buildNumber,
+            environment: this.props.environment,
+            repository: this.props.repository,
+            pipelineVersion: this.props.pipelineVersion,
+        });
+    }
+}
+exports.VersionInfoBuilder = VersionInfoBuilder;
+_b = JSII_RTTI_SYMBOL_1;
+VersionInfoBuilder[_b] = { fqn: "projen-pipelines.VersionInfoBuilder", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version-info.js","sourceRoot":"","sources":["../../src/versioning/version-info.ts"],"names":[],"mappings":"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","sourcesContent":["import { IVersionInfo, GitInfoInput, DeploymentInfoInput } from './types';\n\n\ninterface MutableVersionInfo {\n  version?: string;\n  commitHash?: string;\n  commitHashShort?: string;\n  branch?: string;\n  tag?: string;\n  commitsSinceTag?: number;\n  commitCount?: number;\n  packageVersion?: string;\n  deployedAt?: string;\n  deployedBy?: string;\n  buildNumber?: string;\n  environment?: string;\n  repository?: string;\n  pipelineVersion?: string;\n}\n/**\n * Represents complete version information for a deployment\n */\nexport class VersionInfo implements IVersionInfo {\n\n  /**\n   * Create a VersionInfo instance from raw data\n   */\n  public static create(props: IVersionInfo): VersionInfo {\n    return new VersionInfo(props);\n  }\n\n  /**\n   * Create a VersionInfo instance from environment variables\n   */\n  public static fromEnvironment(env: { [key: string]: string }): VersionInfo {\n    const commitHash = env.GITHUB_SHA || env.GIT_COMMIT_HASH || '';\n    const commitHashShort = commitHash.substring(0, 8);\n\n    const props: MutableVersionInfo = {\n      version: env.VERSION || '0.0.0',\n      commitHash,\n      commitHashShort,\n      branch: env.GIT_BRANCH || env.GITHUB_REF_NAME || 'unknown',\n      commitCount: parseInt(env.GIT_COMMIT_COUNT || '0', 10),\n      deployedAt: new Date().toISOString(),\n      deployedBy: env.GITHUB_ACTOR || env.GITLAB_USER_LOGIN || env.USER || 'unknown',\n      environment: env.STAGE || env.ENVIRONMENT || 'unknown',\n    };\n\n    // Add optional fields only if they exist\n    if (env.GIT_TAG) props.tag = env.GIT_TAG;\n    if (env.COMMITS_SINCE_TAG) props.commitsSinceTag = parseInt(env.COMMITS_SINCE_TAG, 10);\n    if (env.PACKAGE_VERSION) props.packageVersion = env.PACKAGE_VERSION;\n    if (env.GITHUB_RUN_NUMBER) props.buildNumber = env.GITHUB_RUN_NUMBER;\n    else if (env.CI_PIPELINE_ID) props.buildNumber = env.CI_PIPELINE_ID;\n    if (env.GITHUB_REPOSITORY) props.repository = env.GITHUB_REPOSITORY;\n    else if (env.CI_PROJECT_PATH) props.repository = env.CI_PROJECT_PATH;\n    if (env.PIPELINE_VERSION) props.pipelineVersion = env.PIPELINE_VERSION;\n\n    return new VersionInfo(props as IVersionInfo);\n  }\n\n  /**\n   * Create a VersionInfo instance from a JSON string\n   */\n  public static fromJson(json: string): VersionInfo {\n    const data = JSON.parse(json);\n    return new VersionInfo(data);\n  }\n\n  public readonly version: string;\n  public readonly commitHash: string;\n  public readonly commitHashShort: string;\n  public readonly branch: string;\n  public readonly tag?: string;\n  public readonly commitsSinceTag?: number;\n  public readonly commitCount: number;\n  public readonly packageVersion?: string;\n  public readonly deployedAt: string;\n  public readonly deployedBy: string;\n  public readonly buildNumber?: string;\n  public readonly environment: string;\n  public readonly repository?: string;\n  public readonly pipelineVersion?: string;\n\n  private constructor(props: IVersionInfo) {\n    this.version = props.version;\n    this.commitHash = props.commitHash;\n    this.commitHashShort = props.commitHashShort;\n    this.branch = props.branch;\n    this.tag = props.tag;\n    this.commitsSinceTag = props.commitsSinceTag;\n    this.commitCount = props.commitCount;\n    this.packageVersion = props.packageVersion;\n    this.deployedAt = props.deployedAt;\n    this.deployedBy = props.deployedBy;\n    this.buildNumber = props.buildNumber;\n    this.environment = props.environment;\n    this.repository = props.repository;\n    this.pipelineVersion = props.pipelineVersion;\n  }\n\n  /**\n   * Convert to plain version string\n   */\n  public toString(): string {\n    return this.version;\n  }\n\n  /**\n   * Convert to JSON string\n   */\n  public toJson(pretty = false): string {\n    const data: MutableVersionInfo = {\n      version: this.version,\n      commitHash: this.commitHash,\n      commitHashShort: this.commitHashShort,\n      branch: this.branch,\n      commitCount: this.commitCount,\n      deployedAt: this.deployedAt,\n      deployedBy: this.deployedBy,\n      environment: this.environment,\n    };\n\n    if (this.tag !== undefined) data.tag = this.tag;\n    if (this.commitsSinceTag !== undefined) data.commitsSinceTag = this.commitsSinceTag;\n    if (this.packageVersion !== undefined) data.packageVersion = this.packageVersion;\n    if (this.buildNumber !== undefined) data.buildNumber = this.buildNumber;\n    if (this.repository !== undefined) data.repository = this.repository;\n    if (this.pipelineVersion !== undefined) data.pipelineVersion = this.pipelineVersion;\n\n    return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);\n  }\n\n  /**\n   * Convert to object\n   */\n  public toObject(): IVersionInfo {\n    return JSON.parse(this.toJson());\n  }\n\n  /**\n   * Get formatted version for display\n   */\n  public displayVersion(): string {\n    if (this.tag && this.commitsSinceTag === 0) {\n      return this.tag;\n    }\n    return this.version;\n  }\n\n  /**\n   * Check if this version is from a tagged release\n   */\n  public taggedRelease(): boolean {\n    return this.tag !== undefined && this.commitsSinceTag === 0;\n  }\n\n  /**\n   * Check if this version is from the main branch\n   */\n  public mainBranch(): boolean {\n    return this.branch === 'main' || this.branch === 'master';\n  }\n\n  /**\n   * Compare with another version\n   * Returns: -1 if this < other, 0 if equal, 1 if this > other\n   */\n  public compare(other: VersionInfo): number {\n    // First compare by commit count\n    if (this.commitCount < other.commitCount) return -1;\n    if (this.commitCount > other.commitCount) return 1;\n\n    // Then by version string\n    return this.version.localeCompare(other.version);\n  }\n\n  /**\n   * Create a parameter name for SSM Parameter Store\n   */\n  public parameterName(template: string): string {\n    return template\n      .replace('{stage}', this.environment)\n      .replace('{environment}', this.environment)\n      .replace('{branch}', this.branch)\n      .replace('{version}', this.version);\n  }\n\n  /**\n   * Create CloudFormation export name\n   */\n  public exportName(template: string): string {\n    return template\n      .replace('{stage}', this.environment)\n      .replace('{environment}', this.environment)\n      .replace('{branch}', this.branch)\n      .replace('{version}', this.version);\n  }\n}\n\n/**\n * Builder class for creating VersionInfo instances\n */\nexport class VersionInfoBuilder {\n  private props: MutableVersionInfo = {};\n\n  /**\n   * Set the version string\n   */\n  public version(version: string): this {\n    this.props.version = version;\n    return this;\n  }\n\n  /**\n   * Set git information\n   */\n  public gitInfo(info: GitInfoInput): this {\n    this.props.commitHash = info.commitHash;\n    this.props.commitHashShort = info.commitHash.substring(0, 8);\n    this.props.branch = info.branch;\n    this.props.tag = info.tag;\n    this.props.commitsSinceTag = info.commitsSinceTag;\n    this.props.commitCount = info.commitCount;\n    return this;\n  }\n\n  /**\n   * Set package version\n   */\n  public packageVersion(version: string): this {\n    this.props.packageVersion = version;\n    return this;\n  }\n\n  /**\n   * Set deployment metadata\n   */\n  public deploymentInfo(info: DeploymentInfoInput): this {\n    this.props.environment = info.environment;\n    this.props.deployedBy = info.deployedBy ?? 'unknown';\n    this.props.buildNumber = info.buildNumber;\n    this.props.deployedAt = new Date().toISOString();\n    return this;\n  }\n\n  /**\n   * Set repository information\n   */\n  public repository(repo: string): this {\n    this.props.repository = repo;\n    return this;\n  }\n\n  /**\n   * Set pipeline version\n   */\n  public pipelineVersion(version: string): this {\n    this.props.pipelineVersion = version;\n    return this;\n  }\n\n  /**\n   * Build the VersionInfo instance\n   */\n  public create(): VersionInfo {\n    if (!this.props.version) {\n      throw new Error('Version is required');\n    }\n    if (!this.props.commitHash) {\n      throw new Error('Commit hash is required');\n    }\n    if (!this.props.branch) {\n      throw new Error('Branch is required');\n    }\n    if (this.props.commitCount === undefined) {\n      throw new Error('Commit count is required');\n    }\n    if (!this.props.environment) {\n      throw new Error('Environment is required');\n    }\n\n    return VersionInfo.create({\n      version: this.props.version,\n      commitHash: this.props.commitHash,\n      commitHashShort: this.props.commitHashShort!,\n      branch: this.props.branch,\n      tag: this.props.tag,\n      commitsSinceTag: this.props.commitsSinceTag,\n      commitCount: this.props.commitCount,\n      packageVersion: this.props.packageVersion,\n      deployedAt: this.props.deployedAt ?? new Date().toISOString(),\n      deployedBy: this.props.deployedBy ?? 'unknown',\n      buildNumber: this.props.buildNumber,\n      environment: this.props.environment,\n      repository: this.props.repository,\n      pipelineVersion: this.props.pipelineVersion,\n    });\n  }\n}"]}

package/llm.md

@@ -44,9 +44,10 @@ For AWS CDK applications, the library provides:
 
 - `CDKPipeline` (abstract base class)
 - Platform-specific implementations (e.g., `GithubCDKPipeline`)
-- Support for multi-stage deployments (dev, prod, personal)
+- Support for multi-stage deployments (dev, prod, personal, feature)
 - Asset publishing and versioning
 - Automated CloudFormation deployment
+- Feature branch deployments with automatic lifecycle management
 
 ## Usage Example
 
@@ -128,6 +129,7 @@ When creating a CDK pipeline, these are key configuration options:
 | `pkgNamespace` | Namespace for published packages |
 | `stages` | Array of deployment stages with environment settings |
 | `useGithubPackagesForAssembly` | Use GitHub Packages for assembly storage |
+| `featureStages` | Configuration for feature branch deployments |
 
 ## Deployment Stages
 
@@ -186,6 +188,26 @@ The CDK pipeline adds these tasks to your projen project:
 | `bump` | Bump version based on git tags |
 | `release:push-assembly` | Publish cloud assembly to registry |
 
+## Feature Branch Deployments
+
+When `featureStages` is configured, the library creates automated workflows for feature branch lifecycle management:
+
+### GitHub Actions Implementation
+
+- **deploy-feature workflow**: Triggered when a PR is labeled with 'feature-deployment'
+- **destroy-feature workflow**: Triggered when PR is closed or 'feature-deployment' label is removed
+- Uses branch name in stack naming for isolation
+
+### Configuration Example
+
+```typescript
+{
+  featureStages: {
+    env: { account: '123456789013', region: 'eu-central-1' }
+  }
+}
+```
+
 ## Best Practices
 
 1. **IAM Role Setup**: Create minimal permission IAM roles for deployment

package/package.json

@@ -83,7 +83,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.11",
+  "version": "0.2.13",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [