projen-pipelines 0.2.11 → 0.2.13

package/lib/versioning/outputs.js

@@ -0,0 +1,166 @@
+"use strict";
+var _a, _b, _c, _d, _e;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningOutputs = exports.OutputFormat = exports.ParameterStoreOutput = exports.CloudFormationOutput = exports.OutputConfigBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Base class for output configurations
+ */
+class OutputConfigBase {
+    constructor(type) {
+        this.type = type;
+    }
+}
+exports.OutputConfigBase = OutputConfigBase;
+_a = JSII_RTTI_SYMBOL_1;
+OutputConfigBase[_a] = { fqn: "projen-pipelines.OutputConfigBase", version: "0.2.13" };
+/**
+ * CloudFormation output configuration
+ */
+class CloudFormationOutput extends OutputConfigBase {
+    /**
+     * Enable CloudFormation outputs with default configuration
+     */
+    static enabled() {
+        return new CloudFormationOutput({ enabled: true });
+    }
+    /**
+     * Disable CloudFormation outputs
+     */
+    static disabled() {
+        return new CloudFormationOutput({ enabled: false });
+    }
+    /**
+     * Configure CloudFormation outputs with custom settings
+     */
+    static withConfig(config) {
+        return new CloudFormationOutput({ ...config });
+    }
+    constructor(config) {
+        super(CloudFormationOutput.TYPE);
+        this.config = config;
+    }
+    toConfig() {
+        if (!this.config) {
+            return { enabled: true };
+        }
+        return this.config;
+    }
+}
+exports.CloudFormationOutput = CloudFormationOutput;
+_b = JSII_RTTI_SYMBOL_1;
+CloudFormationOutput[_b] = { fqn: "projen-pipelines.CloudFormationOutput", version: "0.2.13" };
+CloudFormationOutput.TYPE = 'cloudformation';
+/**
+ * SSM Parameter Store output configuration
+ */
+class ParameterStoreOutput extends OutputConfigBase {
+    /**
+     * Enable Parameter Store outputs with parameter name
+     */
+    static enabled(parameterName) {
+        return new ParameterStoreOutput({ enabled: true, parameterName });
+    }
+    /**
+     * Disable Parameter Store outputs
+     */
+    static disabled() {
+        return new ParameterStoreOutput({ enabled: false, parameterName: '' });
+    }
+    /**
+     * Configure Parameter Store outputs with custom settings
+     */
+    static withConfig(config) {
+        return new ParameterStoreOutput({ ...config });
+    }
+    /**
+     * Configure Parameter Store with hierarchical parameters
+     */
+    static hierarchical(basePath, options) {
+        return new ParameterStoreOutput({
+            enabled: true,
+            parameterName: basePath,
+            hierarchical: true,
+            splitParameters: true,
+            ...options,
+        });
+    }
+    constructor(config) {
+        super(ParameterStoreOutput.TYPE);
+        this.config = config;
+    }
+    toConfig() {
+        if (!this.config) {
+            return { enabled: false, parameterName: '' };
+        }
+        return this.config;
+    }
+}
+exports.ParameterStoreOutput = ParameterStoreOutput;
+_c = JSII_RTTI_SYMBOL_1;
+ParameterStoreOutput[_c] = { fqn: "projen-pipelines.ParameterStoreOutput", version: "0.2.13" };
+ParameterStoreOutput.TYPE = 'parameterStore';
+/**
+ * Output format types
+ */
+class OutputFormat {
+    constructor() { }
+}
+exports.OutputFormat = OutputFormat;
+_d = JSII_RTTI_SYMBOL_1;
+OutputFormat[_d] = { fqn: "projen-pipelines.OutputFormat", version: "0.2.13" };
+OutputFormat.PLAIN = 'plain';
+OutputFormat.STRUCTURED = 'structured';
+/**
+ * Factory class for output configurations
+ */
+class VersioningOutputs {
+    /**
+     * Create output configuration with CloudFormation and SSM Parameter Store
+     */
+    static standard(options) {
+        return {
+            cloudFormation: CloudFormationOutput.enabled().toConfig(),
+            parameterStore: options?.parameterName
+                ? ParameterStoreOutput.enabled(options.parameterName).toConfig()
+                : ParameterStoreOutput.disabled().toConfig(),
+        };
+    }
+    /**
+     * Create output configuration with only CloudFormation
+     */
+    static cloudFormationOnly(options) {
+        const cfConfig = options?.stackOutputName || options?.exportName
+            ? CloudFormationOutput.withConfig({
+                enabled: true,
+                exportName: options.exportName,
+            }).toConfig()
+            : CloudFormationOutput.enabled().toConfig();
+        return {
+            cloudFormation: cfConfig,
+            parameterStore: ParameterStoreOutput.disabled().toConfig(),
+        };
+    }
+    /**
+     * Create output configuration with hierarchical SSM parameters
+     */
+    static hierarchicalParameters(basePath, options) {
+        return {
+            cloudFormation: options?.includeCloudFormation ? CloudFormationOutput.enabled().toConfig() : CloudFormationOutput.disabled().toConfig(),
+            parameterStore: ParameterStoreOutput.hierarchical(basePath, {}).toConfig(),
+        };
+    }
+    /**
+     * Create minimal output configuration (CloudFormation only, plain format)
+     */
+    static minimal() {
+        return {
+            cloudFormation: CloudFormationOutput.enabled().toConfig(),
+            parameterStore: ParameterStoreOutput.disabled().toConfig(),
+        };
+    }
+}
+exports.VersioningOutputs = VersioningOutputs;
+_e = JSII_RTTI_SYMBOL_1;
+VersioningOutputs[_e] = { fqn: "projen-pipelines.VersioningOutputs", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"outputs.js","sourceRoot":"","sources":["../../src/versioning/outputs.ts"],"names":[],"mappings":"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","sourcesContent":["import { CloudFormationOutputConfig, ParameterStoreConfig, VersioningOutputConfig, StandardOutputOptions, CloudFormationOnlyOptions, HierarchicalParametersOptions } from './types';\n\n/**\n * Base class for output configurations\n */\nexport abstract class OutputConfigBase {\n  protected constructor(public readonly type: string) { }\n\n  /**\n   * Convert to configuration object\n   */\n  abstract toConfig(): any;\n}\n\n/**\n * CloudFormation output configuration\n */\nexport class CloudFormationOutput extends OutputConfigBase {\n  public static readonly TYPE = 'cloudformation';\n\n  /**\n   * Enable CloudFormation outputs with default configuration\n   */\n  public static enabled(): CloudFormationOutput {\n    return new CloudFormationOutput({ enabled: true });\n  }\n\n  /**\n   * Disable CloudFormation outputs\n   */\n  public static disabled(): CloudFormationOutput {\n    return new CloudFormationOutput({ enabled: false });\n  }\n\n  /**\n   * Configure CloudFormation outputs with custom settings\n   */\n  public static withConfig(config: CloudFormationOutputConfig): CloudFormationOutput {\n    return new CloudFormationOutput({ ...config });\n  }\n\n  private constructor(private readonly config?: CloudFormationOutputConfig) {\n    super(CloudFormationOutput.TYPE);\n  }\n\n  public toConfig(): any {\n    if (!this.config) {\n      return { enabled: true };\n    }\n    return this.config;\n  }\n}\n\n/**\n * SSM Parameter Store output configuration\n */\nexport class ParameterStoreOutput extends OutputConfigBase {\n  public static readonly TYPE = 'parameterStore';\n\n  /**\n   * Enable Parameter Store outputs with parameter name\n   */\n  public static enabled(parameterName: string): ParameterStoreOutput {\n    return new ParameterStoreOutput({ enabled: true, parameterName });\n  }\n\n  /**\n   * Disable Parameter Store outputs\n   */\n  public static disabled(): ParameterStoreOutput {\n    return new ParameterStoreOutput({ enabled: false, parameterName: '' });\n  }\n\n  /**\n   * Configure Parameter Store outputs with custom settings\n   */\n  public static withConfig(config: ParameterStoreConfig): ParameterStoreOutput {\n    return new ParameterStoreOutput({ ...config });\n  }\n\n  /**\n   * Configure Parameter Store with hierarchical parameters\n   */\n  public static hierarchical(basePath: string, options?: HierarchicalParametersOptions): ParameterStoreOutput {\n    return new ParameterStoreOutput({\n      enabled: true,\n      parameterName: basePath,\n      hierarchical: true,\n      splitParameters: true,\n      ...options,\n    });\n  }\n\n  private constructor(private readonly config?: ParameterStoreConfig) {\n    super(ParameterStoreOutput.TYPE);\n  }\n\n  public toConfig(): any {\n    if (!this.config) {\n      return { enabled: false, parameterName: '' };\n    }\n    return this.config;\n  }\n}\n\n/**\n * Output format types\n */\nexport class OutputFormat {\n  public static readonly PLAIN = 'plain' as const;\n  public static readonly STRUCTURED = 'structured' as const;\n\n  private constructor() { }\n}\n\n/**\n * Factory class for output configurations\n */\nexport class VersioningOutputs {\n  /**\n   * Create output configuration with CloudFormation and SSM Parameter Store\n   */\n  public static standard(options?: StandardOutputOptions): VersioningOutputConfig {\n    return {\n      cloudFormation: CloudFormationOutput.enabled().toConfig(),\n      parameterStore: options?.parameterName\n        ? ParameterStoreOutput.enabled(options.parameterName).toConfig()\n        : ParameterStoreOutput.disabled().toConfig(),\n    };\n  }\n\n  /**\n   * Create output configuration with only CloudFormation\n   */\n  public static cloudFormationOnly(options?: CloudFormationOnlyOptions): VersioningOutputConfig {\n    const cfConfig = options?.stackOutputName || options?.exportName\n      ? CloudFormationOutput.withConfig({\n        enabled: true,\n        exportName: options.exportName,\n      }).toConfig()\n      : CloudFormationOutput.enabled().toConfig();\n\n    return {\n      cloudFormation: cfConfig,\n      parameterStore: ParameterStoreOutput.disabled().toConfig(),\n    };\n  }\n\n  /**\n   * Create output configuration with hierarchical SSM parameters\n   */\n  public static hierarchicalParameters(basePath: string, options?: HierarchicalParametersOptions): VersioningOutputConfig {\n    return {\n      cloudFormation: options?.includeCloudFormation ? CloudFormationOutput.enabled().toConfig() : CloudFormationOutput.disabled().toConfig(),\n      parameterStore: ParameterStoreOutput.hierarchical(basePath, {}).toConfig(),\n    };\n  }\n\n  /**\n   * Create minimal output configuration (CloudFormation only, plain format)\n   */\n  public static minimal(): VersioningOutputConfig {\n    return {\n      cloudFormation: CloudFormationOutput.enabled().toConfig(),\n      parameterStore: ParameterStoreOutput.disabled().toConfig(),\n    };\n  }\n}"]}

package/lib/versioning/setup.d.ts

@@ -0,0 +1,30 @@
+import { Project } from 'projen';
+import { VersioningConfig } from './types';
+/**
+ * Sets up versioning tasks and integration for a project
+ */
+export declare class VersioningSetup {
+    private readonly project;
+    private readonly config;
+    constructor(project: Project, config: VersioningConfig);
+    /**
+     * Set up all versioning-related tasks and configurations
+     */
+    setup(): void;
+    /**
+     * Create the version:compute task
+     */
+    private createVersionComputeTask;
+    /**
+     * Create the version:print task
+     */
+    private createVersionPrintTask;
+    /**
+     * Integrate version computation with the build process
+     */
+    private integrateWithBuildProcess;
+    /**
+     * Generate the Node.js script for version computation
+     */
+    private generateVersionComputeScript;
+}

package/lib/versioning/setup.js

@@ -0,0 +1,165 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningSetup = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Sets up versioning tasks and integration for a project
+ */
+class VersioningSetup {
+    constructor(project, config) {
+        this.project = project;
+        this.config = config;
+    }
+    /**
+     * Set up all versioning-related tasks and configurations
+     */
+    setup() {
+        // Create version computation task
+        this.createVersionComputeTask();
+        // Create version print task
+        this.createVersionPrintTask();
+        // Add version computation to build process
+        this.integrateWithBuildProcess();
+        // Add version file to gitignore
+        this.project.gitignore.exclude('~version.json');
+    }
+    /**
+     * Create the version:compute task
+     */
+    createVersionComputeTask() {
+        this.project.addTask('version:compute', {
+            description: 'Compute version information from git',
+            steps: [
+                { exec: 'echo "Computing version information..."' },
+                {
+                    exec: this.generateVersionComputeScript(),
+                },
+            ],
+        });
+    }
+    /**
+     * Create the version:print task
+     */
+    createVersionPrintTask() {
+        this.project.addTask('version:print', {
+            description: 'Print version information',
+            steps: [
+                { exec: 'cat ~version.json' },
+            ],
+        });
+    }
+    /**
+     * Integrate version computation with the build process
+     */
+    integrateWithBuildProcess() {
+        const compileTask = this.project.tasks.tryFind('compile');
+        const computeTask = this.project.tasks.tryFind('version:compute');
+        const printTask = this.project.tasks.tryFind('version:print');
+        if (compileTask && computeTask && printTask) {
+            compileTask.prependSpawn(printTask);
+            compileTask.prependSpawn(computeTask);
+        }
+    }
+    /**
+     * Generate the Node.js script for version computation
+     */
+    generateVersionComputeScript() {
+        const strategyJson = JSON.stringify(this.config.strategy).replace(/"/g, '\\"');
+        return `node -e "
+const fs = require('fs');
+const cp = require('child_process');
+
+// Import versioning modules
+const { VersionComputer, VersioningStrategy } = require('projen-pipelines');
+
+try {
+  // Gather git information
+  const commitHash = cp.execSync('git rev-parse HEAD', {encoding: 'utf8'}).trim();
+  const commitHashShort = commitHash.substring(0, 8);
+  const commitCount = parseInt(cp.execSync('git rev-list --count HEAD', {encoding: 'utf8'}).trim());
+  const branch = cp.execSync('git rev-parse --abbrev-ref HEAD', {encoding: 'utf8'}).trim();
+  
+  let tag = '';
+  let commitsSinceTag = 0;
+  try { 
+    tag = cp.execSync('git describe --tags --exact-match --all', {encoding: 'utf8'}).trim();
+  } catch {
+    try {
+      const describeOutput = cp.execSync('git describe --tags --long --all', {encoding: 'utf8'}).trim();
+      const match = describeOutput.match(/^(.+)-(\\\\d+)-g[0-9a-f]+$/);
+      if (match) {
+        tag = match[1];
+        commitsSinceTag = parseInt(match[2]);
+      }
+    } catch {}
+  }
+  
+  let packageVersion = '0.0.0';
+  try {
+    packageVersion = JSON.parse(fs.readFileSync('package.json', 'utf8')).version;
+  } catch {}
+  
+  // Create computation context
+  const context = {
+    gitInfo: {
+      commitHash,
+      commitHashShort,
+      branch,
+      tag,
+      commitsSinceTag,
+      commitCount,
+      packageVersion
+    },
+    environment: process.env.STAGE || process.env.ENVIRONMENT || 'unknown',
+    deployedBy: process.env.GITHUB_ACTOR || process.env.GITLAB_USER_LOGIN || process.env.USER || 'unknown',
+    buildNumber: process.env.BUILD_NUMBER || process.env.GITHUB_RUN_NUMBER,
+    repository: process.env.GITHUB_REPOSITORY || process.env.CI_PROJECT_PATH,
+    pipelineVersion: process.env.PIPELINE_VERSION
+  };
+  
+  // Create strategy from configuration
+  const strategyConfig = ${strategyJson};
+  const strategy = new VersioningStrategy(strategyConfig.format, strategyConfig.components);
+  
+  // Compute version
+  const computer = new VersionComputer(strategy);
+  computer.computeVersionInfo(context).then(versionInfo => {
+    fs.writeFileSync('~version.json', versionInfo.toJson());
+    console.log('Version computed:', versionInfo.version, '(commit:', versionInfo.commitHashShort + ')');
+  }).catch(error => {
+    console.error('Error computing version:', error.message);
+    const fallback = {
+      version: '0.0.0',
+      commitHash: 'unknown',
+      commitHashShort: 'unknown',
+      branch: 'unknown',
+      commitCount: 0,
+      packageVersion: '0.0.0',
+      deployedAt: new Date().toISOString(),
+      deployedBy: 'unknown',
+      environment: 'unknown'
+    };
+    fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));
+  });
+} catch (e) {
+  console.error('Error in version computation:', e.message);
+  const fallback = {
+    version: '0.0.0',
+    commitHash: 'unknown',
+    commitHashShort: 'unknown',
+    branch: 'unknown',
+    commitCount: 0,
+    packageVersion: '0.0.0',
+    deployedAt: new Date().toISOString(),
+    deployedBy: 'unknown',
+    environment: 'unknown'
+  };
+  fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));
+}"`;
+    }
+}
+exports.VersioningSetup = VersioningSetup;
+_a = JSII_RTTI_SYMBOL_1;
+VersioningSetup[_a] = { fqn: "projen-pipelines.VersioningSetup", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setup.js","sourceRoot":"","sources":["../../src/versioning/setup.ts"],"names":[],"mappings":";;;;;AAGA;;GAEG;AACH,MAAa,eAAe;IAE1B,YAA6B,OAAgB,EAAmB,MAAwB;QAA3D,YAAO,GAAP,OAAO,CAAS;QAAmB,WAAM,GAAN,MAAM,CAAkB;IACxF,CAAC;IAED;;OAEG;IACI,KAAK;QACV,kCAAkC;QAClC,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEhC,4BAA4B;QAC5B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,2CAA2C;QAC3C,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAEjC,gCAAgC;QAChC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE;YACtC,WAAW,EAAE,sCAAsC;YACnD,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,yCAAyC,EAAE;gBACnD;oBACE,IAAI,EAAE,IAAI,CAAC,4BAA4B,EAAE;iBAC1C;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE;YACpC,WAAW,EAAE,2BAA2B;YACxC,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,mBAAmB,EAAE;aAC9B;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC1D,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAClE,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QAE9D,IAAI,WAAW,IAAI,WAAW,IAAI,SAAS,EAAE,CAAC;YAC5C,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YACpC,WAAW,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,4BAA4B;QAClC,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAE/E,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAqDgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCpC,CAAC;IACF,CAAC;;AAhKH,0CAiKC","sourcesContent":["import { Project } from 'projen';\nimport { VersioningConfig } from './types';\n\n/**\n * Sets up versioning tasks and integration for a project\n */\nexport class VersioningSetup {\n\n  constructor(private readonly project: Project, private readonly config: VersioningConfig) {\n  }\n\n  /**\n   * Set up all versioning-related tasks and configurations\n   */\n  public setup(): void {\n    // Create version computation task\n    this.createVersionComputeTask();\n\n    // Create version print task\n    this.createVersionPrintTask();\n\n    // Add version computation to build process\n    this.integrateWithBuildProcess();\n\n    // Add version file to gitignore\n    this.project.gitignore.exclude('~version.json');\n  }\n\n  /**\n   * Create the version:compute task\n   */\n  private createVersionComputeTask(): void {\n    this.project.addTask('version:compute', {\n      description: 'Compute version information from git',\n      steps: [\n        { exec: 'echo \"Computing version information...\"' },\n        {\n          exec: this.generateVersionComputeScript(),\n        },\n      ],\n    });\n  }\n\n  /**\n   * Create the version:print task\n   */\n  private createVersionPrintTask(): void {\n    this.project.addTask('version:print', {\n      description: 'Print version information',\n      steps: [\n        { exec: 'cat ~version.json' },\n      ],\n    });\n  }\n\n  /**\n   * Integrate version computation with the build process\n   */\n  private integrateWithBuildProcess(): void {\n    const compileTask = this.project.tasks.tryFind('compile');\n    const computeTask = this.project.tasks.tryFind('version:compute');\n    const printTask = this.project.tasks.tryFind('version:print');\n\n    if (compileTask && computeTask && printTask) {\n      compileTask.prependSpawn(printTask);\n      compileTask.prependSpawn(computeTask);\n    }\n  }\n\n  /**\n   * Generate the Node.js script for version computation\n   */\n  private generateVersionComputeScript(): string {\n    const strategyJson = JSON.stringify(this.config.strategy).replace(/\"/g, '\\\\\"');\n\n    return `node -e \"\nconst fs = require('fs');\nconst cp = require('child_process');\n\n// Import versioning modules\nconst { VersionComputer, VersioningStrategy } = require('projen-pipelines');\n\ntry {\n  // Gather git information\n  const commitHash = cp.execSync('git rev-parse HEAD', {encoding: 'utf8'}).trim();\n  const commitHashShort = commitHash.substring(0, 8);\n  const commitCount = parseInt(cp.execSync('git rev-list --count HEAD', {encoding: 'utf8'}).trim());\n  const branch = cp.execSync('git rev-parse --abbrev-ref HEAD', {encoding: 'utf8'}).trim();\n  \n  let tag = '';\n  let commitsSinceTag = 0;\n  try { \n    tag = cp.execSync('git describe --tags --exact-match --all', {encoding: 'utf8'}).trim();\n  } catch {\n    try {\n      const describeOutput = cp.execSync('git describe --tags --long --all', {encoding: 'utf8'}).trim();\n      const match = describeOutput.match(/^(.+)-(\\\\\\\\d+)-g[0-9a-f]+$/);\n      if (match) {\n        tag = match[1];\n        commitsSinceTag = parseInt(match[2]);\n      }\n    } catch {}\n  }\n  \n  let packageVersion = '0.0.0';\n  try {\n    packageVersion = JSON.parse(fs.readFileSync('package.json', 'utf8')).version;\n  } catch {}\n  \n  // Create computation context\n  const context = {\n    gitInfo: {\n      commitHash,\n      commitHashShort,\n      branch,\n      tag,\n      commitsSinceTag,\n      commitCount,\n      packageVersion\n    },\n    environment: process.env.STAGE || process.env.ENVIRONMENT || 'unknown',\n    deployedBy: process.env.GITHUB_ACTOR || process.env.GITLAB_USER_LOGIN || process.env.USER || 'unknown',\n    buildNumber: process.env.BUILD_NUMBER || process.env.GITHUB_RUN_NUMBER,\n    repository: process.env.GITHUB_REPOSITORY || process.env.CI_PROJECT_PATH,\n    pipelineVersion: process.env.PIPELINE_VERSION\n  };\n  \n  // Create strategy from configuration\n  const strategyConfig = ${strategyJson};\n  const strategy = new VersioningStrategy(strategyConfig.format, strategyConfig.components);\n  \n  // Compute version\n  const computer = new VersionComputer(strategy);\n  computer.computeVersionInfo(context).then(versionInfo => {\n    fs.writeFileSync('~version.json', versionInfo.toJson());\n    console.log('Version computed:', versionInfo.version, '(commit:', versionInfo.commitHashShort + ')');\n  }).catch(error => {\n    console.error('Error computing version:', error.message);\n    const fallback = {\n      version: '0.0.0',\n      commitHash: 'unknown',\n      commitHashShort: 'unknown',\n      branch: 'unknown',\n      commitCount: 0,\n      packageVersion: '0.0.0',\n      deployedAt: new Date().toISOString(),\n      deployedBy: 'unknown',\n      environment: 'unknown'\n    };\n    fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));\n  });\n} catch (e) {\n  console.error('Error in version computation:', e.message);\n  const fallback = {\n    version: '0.0.0',\n    commitHash: 'unknown',\n    commitHashShort: 'unknown',\n    branch: 'unknown',\n    commitCount: 0,\n    packageVersion: '0.0.0',\n    deployedAt: new Date().toISOString(),\n    deployedBy: 'unknown',\n    environment: 'unknown'\n  };\n  fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));\n}\"`;\n  }\n}\n"]}

package/lib/versioning/strategy.d.ts

@@ -0,0 +1,21 @@
+import { GitTagConfig, PackageJsonConfig, CommitCountConfig, IVersioningStrategy, VersioningStrategyComponents, BuildNumberConfig } from './types';
+/**
+ * Composite versioning strategy that combines multiple strategies
+ */
+export declare class VersioningStrategy implements IVersioningStrategy {
+    readonly format: string;
+    readonly components: VersioningStrategyComponents;
+    /**
+     * Create a composite strategy with custom format and components
+     */
+    static create(format: string, components: VersioningStrategyComponents): VersioningStrategy;
+    /**
+     * Create a build number based strategy
+     */
+    static buildNumber(config?: BuildNumberConfig): VersioningStrategy;
+    static gitTag(config?: GitTagConfig): VersioningStrategy;
+    static packageJson(config?: PackageJsonConfig): VersioningStrategy;
+    static commitCount(config?: CommitCountConfig): VersioningStrategy;
+    static commitHash(): VersioningStrategy;
+    private constructor();
+}

package/lib/versioning/strategy.js

@@ -0,0 +1,51 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningStrategy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Composite versioning strategy that combines multiple strategies
+ */
+class VersioningStrategy {
+    /**
+     * Create a composite strategy with custom format and components
+     */
+    static create(format, components) {
+        return new VersioningStrategy(format, components);
+    }
+    /**
+     * Create a build number based strategy
+     */
+    static buildNumber(config) {
+        const prefix = config?.prefix ?? 'build';
+        return new VersioningStrategy(`${prefix}-{commit-count}-{commit-hash:8}`, {
+            commitCount: config?.commitCount ?? { countFrom: 'all', padding: 5 },
+        });
+    }
+    static gitTag(config) {
+        return new VersioningStrategy('{git-tag}', {
+            gitTag: config ?? { stripPrefix: 'v' },
+            commitCount: { countFrom: 'all' },
+        });
+    }
+    static packageJson(config) {
+        return new VersioningStrategy('{package-version}', { packageJson: config ?? {} });
+    }
+    static commitCount(config) {
+        return new VersioningStrategy('{commit-count}', {
+            commitCount: config ?? { countFrom: 'all' },
+        });
+    }
+    static commitHash() {
+        return new VersioningStrategy('{commit-hash}', {});
+    }
+    constructor(format, components) {
+        this.format = format;
+        this.components = components;
+        //
+    }
+}
+exports.VersioningStrategy = VersioningStrategy;
+_a = JSII_RTTI_SYMBOL_1;
+VersioningStrategy[_a] = { fqn: "projen-pipelines.VersioningStrategy", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/versioning/types.d.ts

@@ -0,0 +1,183 @@
+export type StageOverrides = {
+    [stage: string]: VersioningConfig;
+};
+export interface VersioningConfig {
+    /**
+     * Enable versioning feature
+     * @default true
+     */
+    readonly enabled: boolean;
+    /**
+     * Primary versioning strategy
+     */
+    readonly strategy: IVersioningStrategy;
+    /**
+     * Output configuration
+     */
+    readonly outputs: VersioningOutputConfig;
+    /**
+     * Stage-specific overrides
+     */
+    readonly stageOverrides?: StageOverrides;
+}
+export interface VersioningStrategyComponents {
+    readonly gitTag?: GitTagConfig;
+    readonly packageJson?: PackageJsonConfig;
+    readonly commitCount?: CommitCountConfig;
+}
+export interface IVersioningStrategy {
+    /**
+     * Version format template
+     * Variables: {git-tag}, {package-version}, {commit-count}, {commit-hash},
+     *            {commit-hash:8}, {branch}, {build-number}
+     */
+    readonly format: string;
+    /**
+     * Components to include
+     */
+    readonly components: VersioningStrategyComponents;
+}
+export interface GitTagConfig {
+    /**
+     * Only use annotated tags
+     */
+    readonly annotatedOnly?: boolean;
+    /**
+     * Tag pattern to match
+     */
+    readonly pattern?: string;
+    /**
+     * Strip prefix from tag
+     */
+    readonly stripPrefix?: string;
+    /**
+     * Include commits since tag
+     */
+    readonly includeSinceTag?: boolean;
+}
+export interface PackageJsonConfig {
+    /**
+     * Path to package.json
+     */
+    readonly path?: string;
+    /**
+     * Include pre-release version
+     */
+    readonly includePrerelease?: boolean;
+    /**
+     * Append commit info
+     */
+    readonly appendCommitInfo?: boolean;
+}
+export interface CommitCountConfig {
+    /**
+     * Count from: 'all' | 'branch' | 'since-tag'
+     */
+    readonly countFrom?: 'all' | 'branch' | 'since-tag';
+    /**
+     * Include branch name
+     */
+    readonly includeBranch?: boolean;
+    /**
+     * Reset on major version
+     */
+    readonly resetOnMajor?: boolean;
+    /**
+     * Padding for count
+     */
+    readonly padding?: number;
+}
+export interface VersioningOutputConfig {
+    /**
+     * Output to CloudFormation stack outputs
+     * @default true
+     */
+    readonly cloudFormation: CloudFormationOutputConfig;
+    /**
+     * Output to SSM Parameter Store
+     * @default false
+     */
+    readonly parameterStore: ParameterStoreConfig;
+}
+export interface CloudFormationOutputConfig {
+    readonly enabled: boolean;
+    readonly exportName?: string;
+}
+export interface ParameterStoreConfig {
+    readonly enabled: boolean;
+    readonly parameterName?: string;
+    readonly description?: string;
+    readonly allowOverwrite?: boolean;
+    readonly splitParameters?: boolean;
+    readonly hierarchical?: boolean;
+}
+export interface BuildNumberConfig {
+    readonly prefix?: string;
+    readonly commitCount?: CommitCountConfig;
+}
+export interface GitInfoInput {
+    readonly commitHash: string;
+    readonly branch: string;
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    readonly commitCount: number;
+}
+export interface DeploymentInfoInput {
+    readonly environment: string;
+    readonly deployedBy?: string;
+    readonly buildNumber?: string;
+}
+export interface StandardConfigOptions {
+    readonly parameterStore?: boolean | string;
+    readonly format?: 'plain' | 'structured';
+}
+export interface CloudFormationOnlyOptions {
+    readonly format?: 'plain' | 'structured';
+    readonly stackOutputName?: string;
+    readonly exportName?: string;
+}
+export interface HierarchicalParametersOptions {
+    readonly includeCloudFormation?: boolean;
+    readonly format?: 'plain' | 'structured';
+}
+export interface StandardOutputOptions {
+    readonly parameterName?: string;
+    readonly format?: 'plain' | 'structured';
+}
+export interface IVersionInfo {
+    /**
+     * Primary version string
+     */
+    readonly version: string;
+    /**
+     * Git information (ALWAYS included)
+     */
+    readonly commitHash: string;
+    readonly commitHashShort: string;
+    readonly branch: string;
+    /**
+     * Optional git tag information
+     */
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    /**
+     * Commit count information
+     */
+    readonly commitCount: number;
+    /**
+     * Package.json information (if applicable)
+     */
+    readonly packageVersion?: string;
+    /**
+     * Deployment metadata
+     */
+    readonly deployedAt: string;
+    readonly deployedBy: string;
+    readonly buildNumber?: string;
+    readonly environment: string;
+    /**
+     * Additional metadata
+     */
+    readonly repository?: string;
+    readonly pipelineVersion?: string;
+}

package/lib/versioning/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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