projen-pipelines 0.2.12 → 0.2.13

package/lib/versioning/config.js

@@ -0,0 +1,91 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningConfigUtils = exports.VersioningConfigurations = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const outputs_1 = require("./outputs");
+const strategy_1 = require("./strategy");
+/**
+ * Main versioning configuration class with factory methods
+ */
+class VersioningConfigurations {
+    /**
+     * Standard configuration with commit count strategy
+     */
+    static standard(options) {
+        return {
+            enabled: true,
+            strategy: strategy_1.VersioningStrategy.commitCount(),
+            outputs: outputs_1.VersioningOutputs.standard({
+                parameterName: typeof options?.parameterStore === 'string' ? options.parameterStore : undefined,
+                format: options?.format,
+            }),
+        };
+    }
+    /**
+     * Minimal configuration for testing
+     */
+    static minimal() {
+        return {
+            enabled: true,
+            strategy: strategy_1.VersioningStrategy.commitHash(),
+            outputs: outputs_1.VersioningOutputs.minimal(),
+        };
+    }
+    /**
+     * Create a custom configuration
+     */
+    static custom(config) {
+        return {
+            enabled: config.enabled ?? true,
+            strategy: config.strategy,
+            outputs: config.outputs,
+            stageOverrides: config.stageOverrides,
+        };
+    }
+}
+exports.VersioningConfigurations = VersioningConfigurations;
+_a = JSII_RTTI_SYMBOL_1;
+VersioningConfigurations[_a] = { fqn: "projen-pipelines.VersioningConfigurations", version: "0.2.13" };
+/**
+ * Utility functions for versioning configuration
+ */
+class VersioningConfigUtils {
+    /**
+     * Resolve configuration for a specific stage
+     */
+    static resolveForStage(config, stage) {
+        const stageOverride = config.stageOverrides?.[stage];
+        if (!stageOverride) {
+            return config;
+        }
+        return {
+            ...config,
+            ...stageOverride,
+            outputs: stageOverride.outputs ? { ...config.outputs, ...stageOverride.outputs } : config.outputs,
+        };
+    }
+    /**
+     * Validate configuration
+     */
+    static validate(config) {
+        const errors = [];
+        if (!config.strategy) {
+            errors.push('Strategy is required');
+        }
+        if (!config.outputs) {
+            errors.push('Outputs configuration is required');
+        }
+        return errors;
+    }
+    /**
+     * Get default configuration
+     */
+    static default() {
+        return VersioningConfigurations.standard();
+    }
+}
+exports.VersioningConfigUtils = VersioningConfigUtils;
+_b = JSII_RTTI_SYMBOL_1;
+VersioningConfigUtils[_b] = { fqn: "projen-pipelines.VersioningConfigUtils", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/versioning/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export { VersionInfo, VersionInfoBuilder } from './version-info';
+export { VersioningStrategy, } from './strategy';
+export { OutputConfigBase, CloudFormationOutput, ParameterStoreOutput, OutputFormat, VersioningOutputs, } from './outputs';
+export { GitInfo, ComputationContext, VersionComputationStrategy, CompositeComputation, VersionComputer, } from './computation';
+export { CustomVersioningConfig, VersioningConfigurations, VersioningConfigUtils, } from './config';
+export { VersioningSetup, } from './setup';

package/lib/versioning/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+exports.VersioningSetup = exports.VersioningConfigUtils = exports.VersioningConfigurations = exports.VersionComputer = exports.CompositeComputation = exports.VersionComputationStrategy = exports.VersioningOutputs = exports.OutputFormat = exports.ParameterStoreOutput = exports.CloudFormationOutput = exports.OutputConfigBase = exports.VersioningStrategy = exports.VersionInfoBuilder = exports.VersionInfo = void 0;
+// Types
+__exportStar(require("./types"), exports);
+// Version Information
+var version_info_1 = require("./version-info");
+Object.defineProperty(exports, "VersionInfo", { enumerable: true, get: function () { return version_info_1.VersionInfo; } });
+Object.defineProperty(exports, "VersionInfoBuilder", { enumerable: true, get: function () { return version_info_1.VersionInfoBuilder; } });
+// Strategies
+var strategy_1 = require("./strategy");
+Object.defineProperty(exports, "VersioningStrategy", { enumerable: true, get: function () { return strategy_1.VersioningStrategy; } });
+// Outputs
+var outputs_1 = require("./outputs");
+Object.defineProperty(exports, "OutputConfigBase", { enumerable: true, get: function () { return outputs_1.OutputConfigBase; } });
+Object.defineProperty(exports, "CloudFormationOutput", { enumerable: true, get: function () { return outputs_1.CloudFormationOutput; } });
+Object.defineProperty(exports, "ParameterStoreOutput", { enumerable: true, get: function () { return outputs_1.ParameterStoreOutput; } });
+Object.defineProperty(exports, "OutputFormat", { enumerable: true, get: function () { return outputs_1.OutputFormat; } });
+Object.defineProperty(exports, "VersioningOutputs", { enumerable: true, get: function () { return outputs_1.VersioningOutputs; } });
+// Computation
+var computation_1 = require("./computation");
+Object.defineProperty(exports, "VersionComputationStrategy", { enumerable: true, get: function () { return computation_1.VersionComputationStrategy; } });
+Object.defineProperty(exports, "CompositeComputation", { enumerable: true, get: function () { return computation_1.CompositeComputation; } });
+Object.defineProperty(exports, "VersionComputer", { enumerable: true, get: function () { return computation_1.VersionComputer; } });
+// Configuration
+var config_1 = require("./config");
+Object.defineProperty(exports, "VersioningConfigurations", { enumerable: true, get: function () { return config_1.VersioningConfigurations; } });
+Object.defineProperty(exports, "VersioningConfigUtils", { enumerable: true, get: function () { return config_1.VersioningConfigUtils; } });
+// Setup
+var setup_1 = require("./setup");
+Object.defineProperty(exports, "VersioningSetup", { enumerable: true, get: function () { return setup_1.VersioningSetup; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyc2lvbmluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLFFBQVE7QUFDUiwwQ0FBd0I7QUFFeEIsc0JBQXNCO0FBQ3RCLCtDQUFpRTtBQUF4RCwyR0FBQSxXQUFXLE9BQUE7QUFBRSxrSEFBQSxrQkFBa0IsT0FBQTtBQUV4QyxhQUFhO0FBQ2IsdUNBRW9CO0FBRGxCLDhHQUFBLGtCQUFrQixPQUFBO0FBR3BCLFVBQVU7QUFDVixxQ0FNbUI7QUFMakIsMkdBQUEsZ0JBQWdCLE9BQUE7QUFDaEIsK0dBQUEsb0JBQW9CLE9BQUE7QUFDcEIsK0dBQUEsb0JBQW9CLE9BQUE7QUFDcEIsdUdBQUEsWUFBWSxPQUFBO0FBQ1osNEdBQUEsaUJBQWlCLE9BQUE7QUFHbkIsY0FBYztBQUNkLDZDQU11QjtBQUhyQix5SEFBQSwwQkFBMEIsT0FBQTtBQUMxQixtSEFBQSxvQkFBb0IsT0FBQTtBQUNwQiw4R0FBQSxlQUFlLE9BQUE7QUFHakIsZ0JBQWdCO0FBQ2hCLG1DQUlrQjtBQUZoQixrSEFBQSx3QkFBd0IsT0FBQTtBQUN4QiwrR0FBQSxxQkFBcUIsT0FBQTtBQUd2QixRQUFRO0FBQ1IsaUNBRWlCO0FBRGYsd0dBQUEsZUFBZSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVHlwZXNcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuXG4vLyBWZXJzaW9uIEluZm9ybWF0aW9uXG5leHBvcnQgeyBWZXJzaW9uSW5mbywgVmVyc2lvbkluZm9CdWlsZGVyIH0gZnJvbSAnLi92ZXJzaW9uLWluZm8nO1xuXG4vLyBTdHJhdGVnaWVzXG5leHBvcnQge1xuICBWZXJzaW9uaW5nU3RyYXRlZ3ksXG59IGZyb20gJy4vc3RyYXRlZ3knO1xuXG4vLyBPdXRwdXRzXG5leHBvcnQge1xuICBPdXRwdXRDb25maWdCYXNlLFxuICBDbG91ZEZvcm1hdGlvbk91dHB1dCxcbiAgUGFyYW1ldGVyU3RvcmVPdXRwdXQsXG4gIE91dHB1dEZvcm1hdCxcbiAgVmVyc2lvbmluZ091dHB1dHMsXG59IGZyb20gJy4vb3V0cHV0cyc7XG5cbi8vIENvbXB1dGF0aW9uXG5leHBvcnQge1xuICBHaXRJbmZvLFxuICBDb21wdXRhdGlvbkNvbnRleHQsXG4gIFZlcnNpb25Db21wdXRhdGlvblN0cmF0ZWd5LFxuICBDb21wb3NpdGVDb21wdXRhdGlvbixcbiAgVmVyc2lvbkNvbXB1dGVyLFxufSBmcm9tICcuL2NvbXB1dGF0aW9uJztcblxuLy8gQ29uZmlndXJhdGlvblxuZXhwb3J0IHtcbiAgQ3VzdG9tVmVyc2lvbmluZ0NvbmZpZyxcbiAgVmVyc2lvbmluZ0NvbmZpZ3VyYXRpb25zLFxuICBWZXJzaW9uaW5nQ29uZmlnVXRpbHMsXG59IGZyb20gJy4vY29uZmlnJztcblxuLy8gU2V0dXBcbmV4cG9ydCB7XG4gIFZlcnNpb25pbmdTZXR1cCxcbn0gZnJvbSAnLi9zZXR1cCc7XG4iXX0=

package/lib/versioning/outputs.d.ts

@@ -0,0 +1,87 @@
+import { CloudFormationOutputConfig, ParameterStoreConfig, VersioningOutputConfig, StandardOutputOptions, CloudFormationOnlyOptions, HierarchicalParametersOptions } from './types';
+/**
+ * Base class for output configurations
+ */
+export declare abstract class OutputConfigBase {
+    readonly type: string;
+    protected constructor(type: string);
+    /**
+     * Convert to configuration object
+     */
+    abstract toConfig(): any;
+}
+/**
+ * CloudFormation output configuration
+ */
+export declare class CloudFormationOutput extends OutputConfigBase {
+    private readonly config?;
+    static readonly TYPE = "cloudformation";
+    /**
+     * Enable CloudFormation outputs with default configuration
+     */
+    static enabled(): CloudFormationOutput;
+    /**
+     * Disable CloudFormation outputs
+     */
+    static disabled(): CloudFormationOutput;
+    /**
+     * Configure CloudFormation outputs with custom settings
+     */
+    static withConfig(config: CloudFormationOutputConfig): CloudFormationOutput;
+    private constructor();
+    toConfig(): any;
+}
+/**
+ * SSM Parameter Store output configuration
+ */
+export declare class ParameterStoreOutput extends OutputConfigBase {
+    private readonly config?;
+    static readonly TYPE = "parameterStore";
+    /**
+     * Enable Parameter Store outputs with parameter name
+     */
+    static enabled(parameterName: string): ParameterStoreOutput;
+    /**
+     * Disable Parameter Store outputs
+     */
+    static disabled(): ParameterStoreOutput;
+    /**
+     * Configure Parameter Store outputs with custom settings
+     */
+    static withConfig(config: ParameterStoreConfig): ParameterStoreOutput;
+    /**
+     * Configure Parameter Store with hierarchical parameters
+     */
+    static hierarchical(basePath: string, options?: HierarchicalParametersOptions): ParameterStoreOutput;
+    private constructor();
+    toConfig(): any;
+}
+/**
+ * Output format types
+ */
+export declare class OutputFormat {
+    static readonly PLAIN: "plain";
+    static readonly STRUCTURED: "structured";
+    private constructor();
+}
+/**
+ * Factory class for output configurations
+ */
+export declare class VersioningOutputs {
+    /**
+     * Create output configuration with CloudFormation and SSM Parameter Store
+     */
+    static standard(options?: StandardOutputOptions): VersioningOutputConfig;
+    /**
+     * Create output configuration with only CloudFormation
+     */
+    static cloudFormationOnly(options?: CloudFormationOnlyOptions): VersioningOutputConfig;
+    /**
+     * Create output configuration with hierarchical SSM parameters
+     */
+    static hierarchicalParameters(basePath: string, options?: HierarchicalParametersOptions): VersioningOutputConfig;
+    /**
+     * Create minimal output configuration (CloudFormation only, plain format)
+     */
+    static minimal(): VersioningOutputConfig;
+}

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();
+}