@pipeline-builder/pipeline-core 3.1.1

package/lib/pipeline/source-builder.d.ts

@@ -0,0 +1,47 @@
+import { CodePipelineSource } from 'aws-cdk-lib/pipelines';
+import { Construct } from 'constructs';
+import type { PipelineConfiguration } from './pipeline-configuration';
+import { UniqueId } from '../core/id-generator';
+/**
+ * Creates the appropriate CodePipelineSource based on the pipeline configuration.
+ *
+ * Supports S3, GitHub, CodeStar connection, and CodeCommit sources.
+ *
+ * **Note on SCHEDULE triggers:** Scheduled pipelines require an EventBridge rule
+ * that starts the pipeline on a cron schedule. The source trigger is set to NONE
+ * (no polling/webhook). The EventBridge rule must be created separately as a
+ * pipeline-level construct, not at the source level. The `schedule` field on
+ * source options captures the cron expression for API/frontend use, but the
+ * actual EventBridge rule creation is not yet implemented in this builder.
+ *
+ * @example
+ * ```typescript
+ * const sourceBuilder = new SourceBuilder(this, config);
+ * const source = sourceBuilder.create(uniqueId);
+ * ```
+ */
+export declare class SourceBuilder {
+    private readonly scope;
+    private readonly config;
+    constructor(scope: Construct, config: PipelineConfiguration);
+    /**
+     * Creates the appropriate CodePipelineSource based on source type
+     */
+    create(id: UniqueId): CodePipelineSource;
+    /**
+     * Creates an S3 source for the pipeline
+     */
+    private createS3Source;
+    /**
+     * Creates a GitHub source for the pipeline
+     */
+    private createGitHubSource;
+    /**
+     * Creates a CodeStar connection source for the pipeline
+     */
+    private createCodeStarSource;
+    /**
+     * Creates a CodeCommit source for the pipeline
+     */
+    private createCodeCommitSource;
+}

package/lib/pipeline/source-builder.js

@@ -0,0 +1,111 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceBuilder = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_codecommit_1 = require("aws-cdk-lib/aws-codecommit");
+const aws_codepipeline_actions_1 = require("aws-cdk-lib/aws-codepipeline-actions");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const pipelines_1 = require("aws-cdk-lib/pipelines");
+const pipeline_helpers_1 = require("../core/pipeline-helpers");
+const pipeline_types_1 = require("../core/pipeline-types");
+/**
+ * Creates the appropriate CodePipelineSource based on the pipeline configuration.
+ *
+ * Supports S3, GitHub, CodeStar connection, and CodeCommit sources.
+ *
+ * **Note on SCHEDULE triggers:** Scheduled pipelines require an EventBridge rule
+ * that starts the pipeline on a cron schedule. The source trigger is set to NONE
+ * (no polling/webhook). The EventBridge rule must be created separately as a
+ * pipeline-level construct, not at the source level. The `schedule` field on
+ * source options captures the cron expression for API/frontend use, but the
+ * actual EventBridge rule creation is not yet implemented in this builder.
+ *
+ * @example
+ * ```typescript
+ * const sourceBuilder = new SourceBuilder(this, config);
+ * const source = sourceBuilder.create(uniqueId);
+ * ```
+ */
+class SourceBuilder {
+    scope;
+    config;
+    constructor(scope, config) {
+        this.scope = scope;
+        this.config = config;
+    }
+    /**
+     * Creates the appropriate CodePipelineSource based on source type
+     */
+    create(id) {
+        switch (this.config.source.type) {
+            case 's3':
+                return this.createS3Source(id);
+            case 'github':
+                return this.createGitHubSource();
+            case 'codestar':
+                return this.createCodeStarSource();
+            case 'codecommit':
+                return this.createCodeCommitSource(id);
+            default: {
+                const _exhaustive = this.config.source;
+                throw new Error(`Unsupported source type: ${_exhaustive.type}`);
+            }
+        }
+    }
+    /**
+     * Creates an S3 source for the pipeline
+     */
+    createS3Source(id) {
+        const options = this.config.getS3Options();
+        const bucket = aws_s3_1.Bucket.fromBucketName(this.scope, id.generate('source:bucket'), options.bucketName);
+        let trigger;
+        switch (options.trigger) {
+            case pipeline_types_1.TriggerType.AUTO:
+                trigger = aws_codepipeline_actions_1.S3Trigger.EVENTS;
+                break;
+            case pipeline_types_1.TriggerType.SCHEDULE:
+                trigger = aws_codepipeline_actions_1.S3Trigger.NONE;
+                break;
+            default: trigger = aws_codepipeline_actions_1.S3Trigger.NONE;
+        }
+        return pipelines_1.CodePipelineSource.s3(bucket, options.objectKey, { trigger });
+    }
+    /**
+     * Creates a GitHub source for the pipeline
+     */
+    createGitHubSource() {
+        const options = this.config.getGitHubOptions();
+        const authentication = options.token
+            ? (typeof options.token === 'string' ? aws_cdk_lib_1.SecretValue.unsafePlainText(options.token) : options.token)
+            : undefined;
+        return pipelines_1.CodePipelineSource.gitHub(options.repo, options.branch, {
+            trigger: options.trigger === pipeline_types_1.TriggerType.AUTO ? aws_codepipeline_actions_1.GitHubTrigger.POLL : aws_codepipeline_actions_1.GitHubTrigger.NONE,
+            authentication,
+        });
+    }
+    /**
+     * Creates a CodeStar connection source for the pipeline
+     */
+    createCodeStarSource() {
+        const options = this.config.getCodeStarOptions();
+        return pipelines_1.CodePipelineSource.connection(options.repo, options.branch, {
+            connectionArn: (0, pipeline_helpers_1.unwrapSecret)(options.connectionArn),
+            triggerOnPush: options.trigger === pipeline_types_1.TriggerType.AUTO,
+            codeBuildCloneOutput: options.codeBuildCloneOutput,
+        });
+    }
+    /**
+     * Creates a CodeCommit source for the pipeline
+     */
+    createCodeCommitSource(id) {
+        const options = this.config.getCodeCommitOptions();
+        const repository = aws_codecommit_1.Repository.fromRepositoryName(this.scope, id.generate('source:repo'), options.repositoryName);
+        return pipelines_1.CodePipelineSource.codeCommit(repository, options.branch ?? 'main', {
+            trigger: options.trigger === pipeline_types_1.TriggerType.AUTO ? aws_codepipeline_actions_1.CodeCommitTrigger.EVENTS : aws_codepipeline_actions_1.CodeCommitTrigger.NONE,
+        });
+    }
+}
+exports.SourceBuilder = SourceBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-builder.js","sourceRoot":"","sources":["../../src/pipeline/source-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { SecretValue } from 'aws-cdk-lib';\nimport { Repository } from 'aws-cdk-lib/aws-codecommit';\nimport { CodeCommitTrigger, GitHubTrigger, S3Trigger } from 'aws-cdk-lib/aws-codepipeline-actions';\nimport { Bucket } from 'aws-cdk-lib/aws-s3';\nimport { CodePipelineSource } from 'aws-cdk-lib/pipelines';\nimport { Construct } from 'constructs';\nimport type { PipelineConfiguration } from './pipeline-configuration';\nimport { UniqueId } from '../core/id-generator';\nimport { unwrapSecret } from '../core/pipeline-helpers';\nimport { TriggerType, type SourceType } from '../core/pipeline-types';\n\n/**\n * Creates the appropriate CodePipelineSource based on the pipeline configuration.\n *\n * Supports S3, GitHub, CodeStar connection, and CodeCommit sources.\n *\n * **Note on SCHEDULE triggers:** Scheduled pipelines require an EventBridge rule\n * that starts the pipeline on a cron schedule. The source trigger is set to NONE\n * (no polling/webhook). The EventBridge rule must be created separately as a\n * pipeline-level construct, not at the source level. The `schedule` field on\n * source options captures the cron expression for API/frontend use, but the\n * actual EventBridge rule creation is not yet implemented in this builder.\n *\n * @example\n * ```typescript\n * const sourceBuilder = new SourceBuilder(this, config);\n * const source = sourceBuilder.create(uniqueId);\n * ```\n */\nexport class SourceBuilder {\n  constructor(\n    private readonly scope: Construct,\n    private readonly config: PipelineConfiguration,\n  ) {}\n\n  /**\n   * Creates the appropriate CodePipelineSource based on source type\n   */\n  create(id: UniqueId): CodePipelineSource {\n    switch (this.config.source.type) {\n      case 's3':\n        return this.createS3Source(id);\n      case 'github':\n        return this.createGitHubSource();\n      case 'codestar':\n        return this.createCodeStarSource();\n      case 'codecommit':\n        return this.createCodeCommitSource(id);\n      default: {\n        const _exhaustive: never = this.config.source;\n        throw new Error(`Unsupported source type: ${(_exhaustive as SourceType).type}`);\n      }\n    }\n  }\n\n  /**\n   * Creates an S3 source for the pipeline\n   */\n  private createS3Source(id: UniqueId): CodePipelineSource {\n    const options = this.config.getS3Options();\n\n    const bucket = Bucket.fromBucketName(\n      this.scope,\n      id.generate('source:bucket'),\n      options.bucketName,\n    );\n\n    let trigger: S3Trigger;\n    switch (options.trigger) {\n      case TriggerType.AUTO: trigger = S3Trigger.EVENTS; break;\n      case TriggerType.SCHEDULE: trigger = S3Trigger.NONE; break;\n      default: trigger = S3Trigger.NONE;\n    }\n\n    return CodePipelineSource.s3(bucket, options.objectKey, { trigger });\n  }\n\n  /**\n   * Creates a GitHub source for the pipeline\n   */\n  private createGitHubSource(): CodePipelineSource {\n    const options = this.config.getGitHubOptions();\n\n    const authentication = options.token\n      ? (typeof options.token === 'string' ? SecretValue.unsafePlainText(options.token) : options.token)\n      : undefined;\n\n    return CodePipelineSource.gitHub(options.repo, options.branch, {\n      trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,\n      authentication,\n    });\n  }\n\n  /**\n   * Creates a CodeStar connection source for the pipeline\n   */\n  private createCodeStarSource(): CodePipelineSource {\n    const options = this.config.getCodeStarOptions();\n\n    return CodePipelineSource.connection(options.repo, options.branch, {\n      connectionArn: unwrapSecret(options.connectionArn),\n      triggerOnPush: options.trigger === TriggerType.AUTO,\n      codeBuildCloneOutput: options.codeBuildCloneOutput,\n    });\n  }\n\n  /**\n   * Creates a CodeCommit source for the pipeline\n   */\n  private createCodeCommitSource(id: UniqueId): CodePipelineSource {\n    const options = this.config.getCodeCommitOptions();\n\n    const repository = Repository.fromRepositoryName(\n      this.scope,\n      id.generate('source:repo'),\n      options.repositoryName,\n    );\n\n    return CodePipelineSource.codeCommit(repository, options.branch ?? 'main', {\n      trigger: options.trigger === TriggerType.AUTO ? CodeCommitTrigger.EVENTS : CodeCommitTrigger.NONE,\n    });\n  }\n}\n"]}

package/lib/pipeline/source-types.d.ts

@@ -0,0 +1,191 @@
+import type { SecretValue } from 'aws-cdk-lib';
+import type { TriggerType } from '../core/pipeline-types';
+/**
+ * S3 source configuration for CodePipeline
+ *
+ * @example
+ * ```typescript
+ * const source: S3SourceConfig = {
+ *   type: 's3',
+ *   options: {
+ *     bucketName: 'my-source-bucket',
+ *     objectKey: 'source.zip',
+ *     trigger: TriggerType.AUTO
+ *   }
+ * };
+ * ```
+ */
+export interface S3SourceConfig {
+    readonly type: 's3';
+    readonly options: S3Options;
+}
+/**
+ * GitHub source configuration for CodePipeline
+ *
+ * @example
+ * ```typescript
+ * const source: GitHubSourceConfig = {
+ *   type: 'github',
+ *   options: {
+ *     repo: 'owner/repository',
+ *     branch: 'main',
+ *     trigger: TriggerType.AUTO
+ *   }
+ * };
+ * ```
+ */
+export interface GitHubSourceConfig {
+    readonly type: 'github';
+    readonly options: GitHubOptions;
+}
+/**
+ * CodeStar connection source configuration for CodePipeline
+ *
+ * @example
+ * ```typescript
+ * const source: CodeStarSourceConfig = {
+ *   type: 'codestar',
+ *   options: {
+ *     repo: 'owner/repository',
+ *     branch: 'main',
+ *     connectionArn: 'arn:aws:codestar-connections:...',
+ *     trigger: TriggerType.AUTO
+ *   }
+ * };
+ * ```
+ */
+export interface CodeStarSourceConfig {
+    readonly type: 'codestar';
+    readonly options: CodeStarOptions;
+}
+/**
+ * Configuration options for S3 pipeline source
+ */
+export interface S3Options {
+    /**
+     * Name of the S3 bucket containing the source code
+     * @example 'my-pipeline-source-bucket'
+     */
+    readonly bucketName: string;
+    /**
+     * Object key (path) to the source archive within the bucket
+     * @default 'source.zip'
+     */
+    readonly objectKey?: string;
+    /**
+     * Pipeline trigger behavior
+     * @default TriggerType.NONE
+     */
+    readonly trigger?: TriggerType;
+    /**
+     * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).
+     * Only used when trigger is SCHEDULE.
+     */
+    readonly schedule?: string;
+}
+/**
+ * Configuration options for GitHub pipeline source
+ */
+export interface GitHubOptions {
+    /**
+     * GitHub repository in the format "owner/repo"
+     * @example 'myorg/myrepo'
+     */
+    readonly repo: string;
+    /**
+     * Branch to track
+     * @default 'main'
+     */
+    readonly branch?: string;
+    /**
+     * GitHub personal access token or SecretValue
+     * If not provided, uses default GitHub authentication
+     */
+    readonly token?: SecretValue | string;
+    /**
+     * Pipeline trigger behavior
+     * @default TriggerType.NONE
+     */
+    readonly trigger?: TriggerType;
+    /**
+     * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).
+     * Only used when trigger is SCHEDULE.
+     */
+    readonly schedule?: string;
+}
+/**
+ * Configuration options for CodeStar connection pipeline source
+ */
+export interface CodeStarOptions {
+    /**
+     * Repository identifier in the format "owner/repo"
+     * @example 'myorg/myrepo'
+     */
+    readonly repo: string;
+    /**
+     * Branch to track
+     * @default 'main'
+     */
+    readonly branch?: string;
+    /**
+     * ARN of the CodeStar connection to use
+     * Can be a string ARN or SecretValue
+     * @example 'arn:aws:codestar-connections:us-east-1:123456789012:connection/abc123'
+     */
+    readonly connectionArn: SecretValue | string;
+    /**
+     * Pipeline trigger behavior
+     * @default TriggerType.NONE
+     */
+    readonly trigger?: TriggerType;
+    /**
+     * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).
+     * Only used when trigger is SCHEDULE.
+     */
+    readonly schedule?: string;
+    /**
+     * Whether to enable full clone capability in CodeBuild
+     * When true, CodeBuild can perform git operations on the full repository
+     * @default false
+     */
+    readonly codeBuildCloneOutput?: boolean;
+}
+/**
+ * CodeCommit source configuration for CodePipeline
+ *
+ * @example
+ * ```typescript
+ * const source: CodeCommitSourceConfig = {
+ *   type: 'codecommit',
+ *   options: {
+ *     repositoryName: 'my-repo',
+ *     branch: 'main',
+ *     trigger: TriggerType.AUTO
+ *   }
+ * };
+ * ```
+ */
+export interface CodeCommitSourceConfig {
+    readonly type: 'codecommit';
+    readonly options: CodeCommitOptions;
+}
+/**
+ * Configuration options for CodeCommit pipeline source
+ */
+export interface CodeCommitOptions {
+    /**
+     * Name of the CodeCommit repository
+     * @example 'my-repo'
+     */
+    readonly repositoryName: string;
+    /**
+     * Branch to track
+     * @default 'main'
+     */
+    readonly branch?: string;
+    /**
+     * Pipeline trigger behavior
+     * @default TriggerType.NONE
+     */
+    readonly trigger?: TriggerType;
+}

package/lib/pipeline/source-types.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pipeline/stage-builder.d.ts

@@ -0,0 +1,71 @@
+import type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';
+import { CodePipeline } from 'aws-cdk-lib/pipelines';
+import { Construct } from 'constructs';
+import { PluginLookup } from './plugin-lookup';
+import type { StageOptions } from './step-types';
+import type { ArtifactManager } from '../core/artifact-manager';
+import { UniqueId } from '../core/id-generator';
+import type { MetaDataType } from '../core/pipeline-types';
+/**
+ * Configuration properties for the StageBuilder
+ */
+export interface StageBuilderProps {
+    /** CDK construct scope for creating child constructs */
+    readonly scope: Construct;
+    /** Plugin lookup service for resolving plugin references to CDK constructs */
+    readonly pluginLookup: PluginLookup;
+    /** Unique ID generator for creating deterministic construct IDs */
+    readonly uniqueId: UniqueId;
+    /** Global metadata inherited by all stage steps */
+    readonly globalMetadata: MetaDataType;
+    /** Default CodeBuild compute type for steps that don't specify one */
+    readonly defaultComputeType?: CdkComputeType;
+    /** Artifact manager for resolving input artifact keys to FileSets */
+    readonly artifactManager?: ArtifactManager;
+    /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */
+    readonly orgId?: string;
+}
+/**
+ * Builds and adds pipeline stages (waves) to a CodePipeline.
+ *
+ * Each stage is resolved from high-level configuration (plugin names)
+ * into CDK CodeBuild steps via PluginLookup, then added as a wave.
+ *
+ * @example
+ * ```typescript
+ * const stageBuilder = new StageBuilder({
+ *   scope: this,
+ *   pluginLookup,
+ *   uniqueId,
+ *   globalMetadata: mergedMetadata,
+ * });
+ * stageBuilder.addStage(pipeline, {
+ *   stageName: 'Integration Tests',
+ *   alias: 'integration',
+ *   steps: [
+ *     { plugin: { name: 'jest-integration' } },
+ *     { plugin: { name: 'e2e-tests', alias: 'cypress' } },
+ *   ],
+ * });
+ * ```
+ */
+export declare class StageBuilder {
+    private readonly scope;
+    private readonly pluginLookup;
+    private readonly uniqueId;
+    private readonly globalMetadata;
+    private readonly defaultComputeType?;
+    private readonly artifactManager?;
+    private readonly orgId?;
+    constructor(props: StageBuilderProps);
+    /**
+     * Resolves a stage's plugin-based step configs into CodeBuild steps
+     * and adds them as a wave to the pipeline.
+     */
+    addStage(pipeline: CodePipeline, stage: StageOptions): void;
+    private resolveStep;
+    /**
+     * Resolves and adds multiple stages as waves to the pipeline, in order.
+     */
+    addStages(pipeline: CodePipeline, stages: StageOptions[]): void;
+}

package/lib/pipeline/stage-builder.js

@@ -0,0 +1,118 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageBuilder = void 0;
+const pipeline_helpers_1 = require("../core/pipeline-helpers");
+/**
+ * Builds and adds pipeline stages (waves) to a CodePipeline.
+ *
+ * Each stage is resolved from high-level configuration (plugin names)
+ * into CDK CodeBuild steps via PluginLookup, then added as a wave.
+ *
+ * @example
+ * ```typescript
+ * const stageBuilder = new StageBuilder({
+ *   scope: this,
+ *   pluginLookup,
+ *   uniqueId,
+ *   globalMetadata: mergedMetadata,
+ * });
+ * stageBuilder.addStage(pipeline, {
+ *   stageName: 'Integration Tests',
+ *   alias: 'integration',
+ *   steps: [
+ *     { plugin: { name: 'jest-integration' } },
+ *     { plugin: { name: 'e2e-tests', alias: 'cypress' } },
+ *   ],
+ * });
+ * ```
+ */
+class StageBuilder {
+    scope;
+    pluginLookup;
+    uniqueId;
+    globalMetadata;
+    defaultComputeType;
+    artifactManager;
+    orgId;
+    constructor(props) {
+        this.scope = props.scope;
+        this.pluginLookup = props.pluginLookup;
+        this.uniqueId = props.uniqueId;
+        this.globalMetadata = props.globalMetadata;
+        this.defaultComputeType = props.defaultComputeType;
+        this.artifactManager = props.artifactManager;
+        this.orgId = props.orgId;
+    }
+    /**
+     * Resolves a stage's plugin-based step configs into CodeBuild steps
+     * and adds them as a wave to the pipeline.
+     */
+    addStage(pipeline, stage) {
+        const stageAlias = stage.alias ?? `${stage.stageName}-alias`;
+        const preSteps = stage.steps
+            .filter(s => (s.position ?? 'pre') === 'pre')
+            .map(s => this.resolveStep(s, stage.stageName, stageAlias));
+        const postSteps = stage.steps
+            .filter(s => s.position === 'post')
+            .map(s => this.resolveStep(s, stage.stageName, stageAlias));
+        pipeline.addWave(stageAlias, {
+            ...(preSteps.length > 0 && { pre: preSteps }),
+            ...(postSteps.length > 0 && { post: postSteps }),
+        });
+    }
+    resolveStep(stepConfig, stageName, stageAlias) {
+        const plugin = this.pluginLookup.plugin(stepConfig.plugin);
+        const stepMetadata = (0, pipeline_helpers_1.merge)(this.globalMetadata, stepConfig.metadata ?? {});
+        const pluginAlias = stepConfig.plugin.alias ?? stepConfig.plugin.name;
+        if (stepConfig.inputArtifact && !this.artifactManager) {
+            throw new Error(`Step "${pluginAlias}" requires inputArtifact but no artifactManager is configured.`);
+        }
+        if (stepConfig.additionalInputArtifacts?.length && !this.artifactManager) {
+            throw new Error(`Step "${pluginAlias}" requires additionalInputArtifacts but no artifactManager is configured.`);
+        }
+        const input = stepConfig.inputArtifact && this.artifactManager
+            ? this.artifactManager.getOutput(stepConfig.inputArtifact)
+            : undefined;
+        const additionalInputs = stepConfig.additionalInputArtifacts?.length && this.artifactManager
+            ? Object.fromEntries(stepConfig.additionalInputArtifacts.map(({ artifact, directory }) => [
+                directory || artifact.outputDirectory,
+                this.artifactManager.getOutput(artifact),
+            ]))
+            : undefined;
+        return (0, pipeline_helpers_1.createCodeBuildStep)({
+            id: this.uniqueId.generate(`stage:${stageAlias}:${pluginAlias}`),
+            uniqueId: this.uniqueId,
+            plugin,
+            metadata: stepMetadata,
+            network: stepConfig.network,
+            scope: this.scope,
+            defaultComputeType: this.defaultComputeType,
+            input,
+            additionalInputs,
+            artifactManager: this.artifactManager,
+            stageName,
+            stageAlias,
+            pluginAlias,
+            preInstallCommands: stepConfig.preInstallCommands,
+            postInstallCommands: stepConfig.postInstallCommands,
+            preCommands: stepConfig.preCommands,
+            postCommands: stepConfig.postCommands,
+            env: stepConfig.env,
+            timeout: stepConfig.timeout ?? plugin.timeout ?? undefined,
+            failureBehavior: (stepConfig.failureBehavior ?? plugin.failureBehavior),
+            orgId: this.orgId,
+        });
+    }
+    /**
+     * Resolves and adds multiple stages as waves to the pipeline, in order.
+     */
+    addStages(pipeline, stages) {
+        for (const stage of stages) {
+            this.addStage(pipeline, stage);
+        }
+    }
+}
+exports.StageBuilder = StageBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stage-builder.js","sourceRoot":"","sources":["../../src/pipeline/stage-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport { CodePipeline } from 'aws-cdk-lib/pipelines';\nimport { Construct } from 'constructs';\nimport { PluginLookup } from './plugin-lookup';\nimport type { StageOptions } from './step-types';\nimport type { ArtifactManager } from '../core/artifact-manager';\nimport { UniqueId } from '../core/id-generator';\nimport { createCodeBuildStep, merge } from '../core/pipeline-helpers';\nimport type { MetaDataType } from '../core/pipeline-types';\n\n/**\n * Configuration properties for the StageBuilder\n */\nexport interface StageBuilderProps {\n  /** CDK construct scope for creating child constructs */\n  readonly scope: Construct;\n\n  /** Plugin lookup service for resolving plugin references to CDK constructs */\n  readonly pluginLookup: PluginLookup;\n\n  /** Unique ID generator for creating deterministic construct IDs */\n  readonly uniqueId: UniqueId;\n\n  /** Global metadata inherited by all stage steps */\n  readonly globalMetadata: MetaDataType;\n\n  /** Default CodeBuild compute type for steps that don't specify one */\n  readonly defaultComputeType?: CdkComputeType;\n\n  /** Artifact manager for resolving input artifact keys to FileSets */\n  readonly artifactManager?: ArtifactManager;\n\n  /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */\n  readonly orgId?: string;\n}\n\n/**\n * Builds and adds pipeline stages (waves) to a CodePipeline.\n *\n * Each stage is resolved from high-level configuration (plugin names)\n * into CDK CodeBuild steps via PluginLookup, then added as a wave.\n *\n * @example\n * ```typescript\n * const stageBuilder = new StageBuilder({\n *   scope: this,\n *   pluginLookup,\n *   uniqueId,\n *   globalMetadata: mergedMetadata,\n * });\n * stageBuilder.addStage(pipeline, {\n *   stageName: 'Integration Tests',\n *   alias: 'integration',\n *   steps: [\n *     { plugin: { name: 'jest-integration' } },\n *     { plugin: { name: 'e2e-tests', alias: 'cypress' } },\n *   ],\n * });\n * ```\n */\nexport class StageBuilder {\n  private readonly scope: Construct;\n  private readonly pluginLookup: PluginLookup;\n  private readonly uniqueId: UniqueId;\n  private readonly globalMetadata: MetaDataType;\n  private readonly defaultComputeType?: CdkComputeType;\n  private readonly artifactManager?: ArtifactManager;\n  private readonly orgId?: string;\n\n  constructor(props: StageBuilderProps) {\n    this.scope = props.scope;\n    this.pluginLookup = props.pluginLookup;\n    this.uniqueId = props.uniqueId;\n    this.globalMetadata = props.globalMetadata;\n    this.defaultComputeType = props.defaultComputeType;\n    this.artifactManager = props.artifactManager;\n    this.orgId = props.orgId;\n  }\n\n  /**\n   * Resolves a stage's plugin-based step configs into CodeBuild steps\n   * and adds them as a wave to the pipeline.\n   */\n  addStage(pipeline: CodePipeline, stage: StageOptions): void {\n    const stageAlias = stage.alias ?? `${stage.stageName}-alias`;\n\n    const preSteps = stage.steps\n      .filter(s => (s.position ?? 'pre') === 'pre')\n      .map(s => this.resolveStep(s, stage.stageName, stageAlias));\n    const postSteps = stage.steps\n      .filter(s => s.position === 'post')\n      .map(s => this.resolveStep(s, stage.stageName, stageAlias));\n\n    pipeline.addWave(stageAlias, {\n      ...(preSteps.length > 0 && { pre: preSteps }),\n      ...(postSteps.length > 0 && { post: postSteps }),\n    });\n  }\n\n  private resolveStep(stepConfig: StageOptions['steps'][number], stageName: string, stageAlias: string) {\n    const plugin = this.pluginLookup.plugin(stepConfig.plugin);\n    const stepMetadata = merge(this.globalMetadata, stepConfig.metadata ?? {});\n    const pluginAlias = stepConfig.plugin.alias ?? stepConfig.plugin.name;\n\n    if (stepConfig.inputArtifact && !this.artifactManager) {\n      throw new Error(\n        `Step \"${pluginAlias}\" requires inputArtifact but no artifactManager is configured.`,\n      );\n    }\n    if (stepConfig.additionalInputArtifacts?.length && !this.artifactManager) {\n      throw new Error(\n        `Step \"${pluginAlias}\" requires additionalInputArtifacts but no artifactManager is configured.`,\n      );\n    }\n\n    const input = stepConfig.inputArtifact && this.artifactManager\n      ? this.artifactManager.getOutput(stepConfig.inputArtifact)\n      : undefined;\n\n    const additionalInputs = stepConfig.additionalInputArtifacts?.length && this.artifactManager\n      ? Object.fromEntries(\n        stepConfig.additionalInputArtifacts.map(({ artifact, directory }) => [\n          directory || artifact.outputDirectory,\n          this.artifactManager!.getOutput(artifact),\n        ]),\n      )\n      : undefined;\n\n    return createCodeBuildStep({\n      id: this.uniqueId.generate(`stage:${stageAlias}:${pluginAlias}`),\n      uniqueId: this.uniqueId,\n      plugin,\n      metadata: stepMetadata,\n      network: stepConfig.network,\n      scope: this.scope,\n      defaultComputeType: this.defaultComputeType,\n      input,\n      additionalInputs,\n      artifactManager: this.artifactManager,\n      stageName,\n      stageAlias,\n      pluginAlias,\n      preInstallCommands: stepConfig.preInstallCommands,\n      postInstallCommands: stepConfig.postInstallCommands,\n      preCommands: stepConfig.preCommands,\n      postCommands: stepConfig.postCommands,\n      env: stepConfig.env,\n      timeout: stepConfig.timeout ?? plugin.timeout ?? undefined,\n      failureBehavior: (stepConfig.failureBehavior ?? plugin.failureBehavior) as 'fail' | 'warn' | 'ignore',\n      orgId: this.orgId,\n    });\n  }\n\n  /**\n   * Resolves and adds multiple stages as waves to the pipeline, in order.\n   */\n  addStages(pipeline: CodePipeline, stages: StageOptions[]): void {\n    for (const stage of stages) {\n      this.addStage(pipeline, stage);\n    }\n  }\n}\n"]}