@pipeline-builder/pipeline-core 3.4.135 → 3.4.137

package/lib/pipeline/pipeline-configuration.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { CoreConstants } from '../config/app-config.js';
-import { merge, replaceNonAlphanumeric } from '../core/pipeline-helpers.js';
+import { merge, replaceNonAlphanumeric } from '../core/metadata-helpers.js';
 import { TriggerType } from '../core/pipeline-types.js';
 /**
  * Validated and processed pipeline configuration (business logic layer).
@@ -31,6 +31,8 @@ export class PipelineConfiguration {
     defaults;
     synthCustomization;
     stages;
+    /** Pipeline-level template variables, exposed to `{{ pipeline.vars.* }}`. */
+    vars;
     constructor(props) {
         this.validateProps(props);
         // Sanitize project and organization names
@@ -59,6 +61,26 @@ export class PipelineConfiguration {
             env: props.synth.env,
         };
         this.stages = props.stages;
+        this.vars = props.vars ?? {};
+    }
+    /**
+     * Template scope exposed as `pipeline.*` to pipeline configs, plugin specs, and
+     * the source builder. Built once here so every consumer — the synth step, each
+     * stage step, and the source token — resolves `{{ pipeline.* }}` against the
+     * identical snapshot (no drift between call sites).
+     */
+    getPipelineScope() {
+        return {
+            pipeline: {
+                projectName: this.project,
+                project: this.project,
+                orgId: this.organization,
+                organization: this.organization,
+                pipelineName: this.pipelineName,
+                metadata: this.metadata.merged,
+                vars: this.vars,
+            },
+        };
     }
     /**
      * Validates BuilderProps to ensure all required fields are present.
@@ -189,4 +211,4 @@ export class PipelineConfiguration {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-configuration.js","sourceRoot":"","sources":["../../src/pipeline/pipeline-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BuilderProps } from './pipeline-builder.js';\nimport type { CodeCommitOptions, CodeStarOptions, GitHubOptions, S3Options } from './source-types.js';\nimport type { PluginOptions, StageOptions, StepCustomization } from './step-types.js';\nimport { CoreConstants } from '../config/app-config.js';\nimport type { CodeBuildDefaults, NetworkConfig } from '../core/network-types.js';\nimport { merge, replaceNonAlphanumeric } from '../core/pipeline-helpers.js';\nimport type { MetaDataType, SourceType } from '../core/pipeline-types.js';\nimport { TriggerType } from '../core/pipeline-types.js';\n\n/**\n * Validated and processed pipeline configuration (business logic layer).\n * This class handles all non-CDK logic: validation, sanitization, and metadata merging.\n * It can be tested independently without CDK dependencies.\n *\n * ## Metadata merge chain (last wins)\n *\n * 1. `BuilderProps.global` — base metadata inherited by all steps\n * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata\n * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata\n * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)\n * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls\n *\n * Steps 1–3 are merged here into `this.metadata.merged`.\n * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.\n * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.\n */\nexport class PipelineConfiguration {\n  public readonly project: string;\n  public readonly organization: string;\n  public readonly pipelineName: string;\n  public readonly metadata: {\n    readonly global: MetaDataType;\n    readonly synth: MetaDataType;\n    readonly merged: MetaDataType;\n  };\n  public readonly source: SourceType;\n  public readonly plugin: PluginOptions;\n  public readonly network: NetworkConfig | undefined;\n  public readonly defaults: CodeBuildDefaults | undefined;\n  public readonly synthCustomization: StepCustomization;\n  public readonly stages: StageOptions[] | undefined;\n\n  constructor(props: BuilderProps) {\n    this.validateProps(props);\n\n    // Sanitize project and organization names\n    this.project = replaceNonAlphanumeric(props.project, '_').toLowerCase();\n    this.organization = replaceNonAlphanumeric(props.organization, '_').toLowerCase();\n\n    // Calculate pipeline name\n    this.pipelineName = props.pipelineName ?? `${this.organization}-${this.project}-pipeline`;\n\n    // Metadata merging: global → defaults → synth-specific\n    const global = { ...(props.global ?? {}) };\n    const withDefaults = merge(global, props.defaults?.metadata ?? {});\n    this.metadata = {\n      global,\n      synth: props.synth.metadata ?? {},\n      merged: merge(withDefaults, props.synth.metadata ?? {}),\n    };\n\n    // Expose synth/builder properties directly\n    this.source = props.synth.source;\n    this.plugin = props.synth.plugin;\n    this.network = props.synth.network;\n    this.defaults = props.defaults;\n    this.synthCustomization = {\n      preInstallCommands: props.synth.preInstallCommands,\n      postInstallCommands: props.synth.postInstallCommands,\n      preCommands: props.synth.preCommands,\n      postCommands: props.synth.postCommands,\n      env: props.synth.env,\n    };\n    this.stages = props.stages;\n  }\n\n  /**\n   * Validates BuilderProps to ensure all required fields are present.\n   * Throws an error with detailed messages if validation fails.\n   */\n  private validateProps(props: BuilderProps): void {\n    const errors: string[] = [];\n\n    if (!props.project) {\n      errors.push('BuilderProps.project is required');\n    }\n\n    if (!props.organization) {\n      errors.push('BuilderProps.organization is required');\n    }\n\n    if (!props.synth?.source) {\n      errors.push('BuilderProps.synth.source is required');\n    }\n\n    if (!props.synth?.plugin) {\n      errors.push('BuilderProps.synth.plugin is required');\n    } else if (!props.synth.plugin.name?.trim()) {\n      errors.push('BuilderProps.synth.plugin.name must be a non-empty string');\n    }\n\n    // Validate repo format for GitHub and CodeStar sources (both use \"owner/repo\")\n    const sourceType = props.synth?.source?.type;\n    if (sourceType === 'github' || sourceType === 'codestar') {\n      const repo = props.synth?.source?.options?.repo;\n      if (repo && !repo.includes('/')) {\n        errors.push(`Invalid ${sourceType} repository format: \"${repo}\". Expected format: \"owner/repo\"`);\n      }\n    }\n\n    // Validate pipeline name length (AWS max 100 characters)\n    const MAX_PIPELINE_NAME_LENGTH = CoreConstants.PIPELINE_NAME_MAX_LENGTH;\n    const pipelineName = props.pipelineName\n      ?? `${replaceNonAlphanumeric(props.organization ?? '', '_').toLowerCase()}-${replaceNonAlphanumeric(props.project ?? '', '_').toLowerCase()}-pipeline`;\n    if (pipelineName.length > MAX_PIPELINE_NAME_LENGTH) {\n      errors.push(`Pipeline name \"${pipelineName}\" exceeds AWS maximum of ${MAX_PIPELINE_NAME_LENGTH} characters (${pipelineName.length})`);\n    }\n\n    // Validate stages\n    if (props.stages) {\n      const stageNames = new Set<string>();\n      for (const stage of props.stages) {\n        if (!stage.stageName?.trim()) {\n          errors.push('Each stage must have a non-empty stageName');\n        } else if (stageNames.has(stage.stageName)) {\n          errors.push(`Duplicate stage name: \"${stage.stageName}\"`);\n        } else {\n          stageNames.add(stage.stageName);\n        }\n        if (!stage.steps?.length) {\n          errors.push(`Stage \"${stage.stageName ?? '(unnamed)'}\" must have at least one step`);\n        }\n      }\n    }\n\n    if (errors.length > 0) {\n      throw new Error(\n        'Pipeline configuration validation failed:\\n' +\n        errors.map(e => `  - ${e}`).join('\\n'),\n      );\n    }\n  }\n\n  /**\n   * Extracts S3 source options with defaults applied.\n   *\n   * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `s3`\n   */\n  getS3Options(): Required<Pick<S3Options, 'bucketName' | 'objectKey' | 'trigger'>> & Omit<S3Options, 'bucketName' | 'objectKey' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 's3') {\n      throw new Error('Source type is not S3');\n    }\n\n    return {\n      ...source.options,\n      objectKey: source.options.objectKey ?? 'source.zip',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts GitHub source options with defaults applied.\n   *\n   * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `github`\n   */\n  getGitHubOptions(): Required<Pick<GitHubOptions, 'repo' | 'branch' | 'trigger'>> & Omit<GitHubOptions, 'repo' | 'branch' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 'github') {\n      throw new Error('Source type is not GitHub');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts CodeStar source options with defaults applied.\n   *\n   * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`\n   * @throws {Error} If the configured source type is not `codestar`\n   */\n  getCodeStarOptions(): Required<Pick<CodeStarOptions, 'repo' | 'branch' | 'trigger' | 'codeBuildCloneOutput' | 'connectionArn'>> {\n    const source = this.source;\n    if (source.type !== 'codestar') {\n      throw new Error('Source type is not CodeStar');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n      codeBuildCloneOutput: source.options.codeBuildCloneOutput ?? false,\n    };\n  }\n\n  /**\n   * Extracts CodeCommit source options with defaults applied.\n   *\n   * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `codecommit`\n   */\n  getCodeCommitOptions(): Required<Pick<CodeCommitOptions, 'repositoryName' | 'branch' | 'trigger'>> {\n    const source = this.source;\n    if (source.type !== 'codecommit') {\n      throw new Error('Source type is not CodeCommit');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-configuration.js","sourceRoot":"","sources":["../../src/pipeline/pipeline-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BuilderProps } from './pipeline-builder.js';\nimport type { CodeCommitOptions, CodeStarOptions, GitHubOptions, S3Options, SourceType } from './source-types.js';\nimport type { PluginOptions, StageOptions, StepCustomization } from './step-types.js';\nimport { CoreConstants } from '../config/app-config.js';\nimport { merge, replaceNonAlphanumeric } from '../core/metadata-helpers.js';\nimport type { CodeBuildDefaults, NetworkConfig } from '../core/network-types.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\nimport { TriggerType } from '../core/pipeline-types.js';\n\n/**\n * Validated and processed pipeline configuration (business logic layer).\n * This class handles all non-CDK logic: validation, sanitization, and metadata merging.\n * It can be tested independently without CDK dependencies.\n *\n * ## Metadata merge chain (last wins)\n *\n * 1. `BuilderProps.global` — base metadata inherited by all steps\n * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata\n * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata\n * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)\n * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls\n *\n * Steps 1–3 are merged here into `this.metadata.merged`.\n * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.\n * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.\n */\nexport class PipelineConfiguration {\n  public readonly project: string;\n  public readonly organization: string;\n  public readonly pipelineName: string;\n  public readonly metadata: {\n    readonly global: MetaDataType;\n    readonly synth: MetaDataType;\n    readonly merged: MetaDataType;\n  };\n  public readonly source: SourceType;\n  public readonly plugin: PluginOptions;\n  public readonly network: NetworkConfig | undefined;\n  public readonly defaults: CodeBuildDefaults | undefined;\n  public readonly synthCustomization: StepCustomization;\n  public readonly stages: StageOptions[] | undefined;\n  /** Pipeline-level template variables, exposed to `{{ pipeline.vars.* }}`. */\n  public readonly vars: Record<string, unknown>;\n\n  constructor(props: BuilderProps) {\n    this.validateProps(props);\n\n    // Sanitize project and organization names\n    this.project = replaceNonAlphanumeric(props.project, '_').toLowerCase();\n    this.organization = replaceNonAlphanumeric(props.organization, '_').toLowerCase();\n\n    // Calculate pipeline name\n    this.pipelineName = props.pipelineName ?? `${this.organization}-${this.project}-pipeline`;\n\n    // Metadata merging: global → defaults → synth-specific\n    const global = { ...(props.global ?? {}) };\n    const withDefaults = merge(global, props.defaults?.metadata ?? {});\n    this.metadata = {\n      global,\n      synth: props.synth.metadata ?? {},\n      merged: merge(withDefaults, props.synth.metadata ?? {}),\n    };\n\n    // Expose synth/builder properties directly\n    this.source = props.synth.source;\n    this.plugin = props.synth.plugin;\n    this.network = props.synth.network;\n    this.defaults = props.defaults;\n    this.synthCustomization = {\n      preInstallCommands: props.synth.preInstallCommands,\n      postInstallCommands: props.synth.postInstallCommands,\n      preCommands: props.synth.preCommands,\n      postCommands: props.synth.postCommands,\n      env: props.synth.env,\n    };\n    this.stages = props.stages;\n    this.vars = props.vars ?? {};\n  }\n\n  /**\n   * Template scope exposed as `pipeline.*` to pipeline configs, plugin specs, and\n   * the source builder. Built once here so every consumer — the synth step, each\n   * stage step, and the source token — resolves `{{ pipeline.* }}` against the\n   * identical snapshot (no drift between call sites).\n   */\n  getPipelineScope(): Record<string, unknown> {\n    return {\n      pipeline: {\n        projectName: this.project,\n        project: this.project,\n        orgId: this.organization,\n        organization: this.organization,\n        pipelineName: this.pipelineName,\n        metadata: this.metadata.merged,\n        vars: this.vars,\n      },\n    };\n  }\n\n  /**\n   * Validates BuilderProps to ensure all required fields are present.\n   * Throws an error with detailed messages if validation fails.\n   */\n  private validateProps(props: BuilderProps): void {\n    const errors: string[] = [];\n\n    if (!props.project) {\n      errors.push('BuilderProps.project is required');\n    }\n\n    if (!props.organization) {\n      errors.push('BuilderProps.organization is required');\n    }\n\n    if (!props.synth?.source) {\n      errors.push('BuilderProps.synth.source is required');\n    }\n\n    if (!props.synth?.plugin) {\n      errors.push('BuilderProps.synth.plugin is required');\n    } else if (!props.synth.plugin.name?.trim()) {\n      errors.push('BuilderProps.synth.plugin.name must be a non-empty string');\n    }\n\n    // Validate repo format for GitHub and CodeStar sources (both use \"owner/repo\")\n    const sourceType = props.synth?.source?.type;\n    if (sourceType === 'github' || sourceType === 'codestar') {\n      const repo = props.synth?.source?.options?.repo;\n      if (repo && !repo.includes('/')) {\n        errors.push(`Invalid ${sourceType} repository format: \"${repo}\". Expected format: \"owner/repo\"`);\n      }\n    }\n\n    // Validate pipeline name length (AWS max 100 characters)\n    const MAX_PIPELINE_NAME_LENGTH = CoreConstants.PIPELINE_NAME_MAX_LENGTH;\n    const pipelineName = props.pipelineName\n      ?? `${replaceNonAlphanumeric(props.organization ?? '', '_').toLowerCase()}-${replaceNonAlphanumeric(props.project ?? '', '_').toLowerCase()}-pipeline`;\n    if (pipelineName.length > MAX_PIPELINE_NAME_LENGTH) {\n      errors.push(`Pipeline name \"${pipelineName}\" exceeds AWS maximum of ${MAX_PIPELINE_NAME_LENGTH} characters (${pipelineName.length})`);\n    }\n\n    // Validate stages\n    if (props.stages) {\n      const stageNames = new Set<string>();\n      for (const stage of props.stages) {\n        if (!stage.stageName?.trim()) {\n          errors.push('Each stage must have a non-empty stageName');\n        } else if (stageNames.has(stage.stageName)) {\n          errors.push(`Duplicate stage name: \"${stage.stageName}\"`);\n        } else {\n          stageNames.add(stage.stageName);\n        }\n        if (!stage.steps?.length) {\n          errors.push(`Stage \"${stage.stageName ?? '(unnamed)'}\" must have at least one step`);\n        }\n      }\n    }\n\n    if (errors.length > 0) {\n      throw new Error(\n        'Pipeline configuration validation failed:\\n' +\n        errors.map(e => `  - ${e}`).join('\\n'),\n      );\n    }\n  }\n\n  /**\n   * Extracts S3 source options with defaults applied.\n   *\n   * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `s3`\n   */\n  getS3Options(): Required<Pick<S3Options, 'bucketName' | 'objectKey' | 'trigger'>> & Omit<S3Options, 'bucketName' | 'objectKey' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 's3') {\n      throw new Error('Source type is not S3');\n    }\n\n    return {\n      ...source.options,\n      objectKey: source.options.objectKey ?? 'source.zip',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts GitHub source options with defaults applied.\n   *\n   * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `github`\n   */\n  getGitHubOptions(): Required<Pick<GitHubOptions, 'repo' | 'branch' | 'trigger'>> & Omit<GitHubOptions, 'repo' | 'branch' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 'github') {\n      throw new Error('Source type is not GitHub');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts CodeStar source options with defaults applied.\n   *\n   * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`\n   * @throws {Error} If the configured source type is not `codestar`\n   */\n  getCodeStarOptions(): Required<Pick<CodeStarOptions, 'repo' | 'branch' | 'trigger' | 'codeBuildCloneOutput' | 'connectionArn'>> {\n    const source = this.source;\n    if (source.type !== 'codestar') {\n      throw new Error('Source type is not CodeStar');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n      codeBuildCloneOutput: source.options.codeBuildCloneOutput ?? false,\n    };\n  }\n\n  /**\n   * Extracts CodeCommit source options with defaults applied.\n   *\n   * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `codecommit`\n   */\n  getCodeCommitOptions(): Required<Pick<CodeCommitOptions, 'repositoryName' | 'branch' | 'trigger'>> {\n    const source = this.source;\n    if (source.type !== 'codecommit') {\n      throw new Error('Source type is not CodeCommit');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n}\n"]}

package/lib/pipeline/plugin-spec.d.ts

@@ -0,0 +1,138 @@
+/**
+ * The `PluginSpec` domain type — the shape of a plugin's declared contract as
+ * stored in the database and exchanged over the API.
+ *
+ * Kept in its own module, apart from the synth-time authoring types in
+ * `step-types.ts`, because those reference CDK types (`Construct`,
+ * `IFileSetProducer`, CodeBuild's `ComputeType`) while this one is pure data.
+ * API services consume `PluginSpec`; only the CDK entry point consumes the rest.
+ */
+import type { ComputeType, PluginType } from '../core/pipeline-types.js';
+/**
+ * Plugin spec defining plugin behavior and requirements.
+ * This is typically loaded from a plugin spec file (plugin-spec.yaml).
+ */
+export interface PluginSpec {
+    /**
+     * Unique identifier for the plugin
+     * @example 'nodejs-build'
+     */
+    readonly name: string;
+    /**
+     * Human-readable description of what the plugin does
+     * @example 'Builds and tests Node.js applications'
+     */
+    readonly description?: string;
+    /**
+     * Keywords for plugin discovery and categorization
+     * @example ['nodejs', 'typescript', 'build', 'test']
+     */
+    readonly keywords?: string[];
+    /**
+     * Plugin category for AI-assisted selection and organization.
+     * One of: language, security, quality, testing, deploy, artifact,
+     *         infrastructure, monitoring, notification, ai
+     */
+    readonly category?: string;
+    /**
+     * Semantic version of the plugin
+     * @example '1.0.0'
+     */
+    readonly version?: string;
+    /**
+     * Type of pipeline step this plugin creates
+     * @default PluginType.CODE_BUILD_STEP
+     */
+    readonly pluginType?: PluginType;
+    /**
+     * CodeBuild compute resource size to use
+     * @default ComputeType.SMALL
+     */
+    readonly computeType?: ComputeType;
+    /**
+     * Maximum execution time in minutes.
+     * Used as fallback when the pipeline step doesn't set timeout.
+     * @default 60 (AWS CodeBuild default)
+     */
+    readonly timeout?: number;
+    /**
+     * What happens when this step fails.
+     * - 'fail': Stop the pipeline (default)
+     * - 'warn': Log a warning and continue
+     * - 'ignore': Silently continue
+     * @default 'fail'
+     */
+    readonly failureBehavior?: 'fail' | 'warn' | 'ignore';
+    /**
+     * Secret requirements for this plugin.
+     * Declares named secrets the plugin expects at build time.
+     */
+    readonly secrets?: Array<{
+        name: string;
+        required: boolean;
+        description?: string;
+    }>;
+    /**
+     * Directory containing the primary build output artifacts
+     * @example 'dist'
+     */
+    readonly primaryOutputDirectory?: string;
+    /**
+     * Additional metadata that can be accessed during plugin execution
+     * Keys should use the format 'aws:cdk:{namespace}:{key}' (all lowercase)
+     */
+    readonly metadata?: Record<string, string | number | boolean>;
+    /**
+     * Path to Dockerfile or Dockerfile content
+     * Used to build the container environment for this plugin
+     */
+    readonly dockerfile?: string;
+    /**
+     * Commands to run during the install phase
+     * Typically used for installing dependencies
+     * @example ['npm ci', 'npm run build']
+     */
+    readonly installCommands?: string[];
+    /**
+     * Commands to run during the build/execution phase
+     * These are the main commands that perform the plugin's work
+     * @example ['npm test', 'npm run deploy']
+     */
+    readonly commands?: string[];
+    /**
+     * Environment variables to set in the build environment
+     * @example { API_URL: 'https://api.example.com', LOG_LEVEL: 'info' }
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * Docker build arguments passed via --build-arg at image build time.
+     * Used to parameterize Dockerfile ARG values when building the plugin image.
+     * @example { PYTHON_VERSION: '3.12', NODE_ENV: 'production' }
+     */
+    readonly buildArgs?: Record<string, string>;
+    /**
+     * Pipeline metadata keys the plugin references via `{{ pipeline.metadata.X }}`.
+     * Declared as a contract — pipelines using this plugin must supply all
+     * listed keys unless the template uses `| default: '...'`.
+     * @example ['env', 'namespace', 'clusterName']
+     */
+    readonly requiredMetadata?: string[];
+    /**
+     * Pipeline vars keys the plugin references via `{{ pipeline.vars.X }}`.
+     * @example ['branch', 'slackChannel']
+     */
+    readonly requiredVars?: string[];
+    /**
+     * Optional type declarations for the metadata keys listed in `requiredMetadata`.
+     * Used at upload time to verify that coercion filters (`| number`, `| bool`,
+     * `| json`) match the declared type — e.g. `{{ pipeline.metadata.count | number }}`
+     * requires `count: 'number'` here, otherwise the plugin is rejected.
+     * Keys not declared default to `'string'`.
+     * @example { count: 'number', enabled: 'bool' }
+     */
+    readonly metadataTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
+    /**
+     * Optional type declarations for vars keys (same semantics as `metadataTypes`).
+     */
+    readonly varsTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
+}

package/lib/pipeline/plugin-spec.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pipeline/source-builder.js

@@ -10,6 +10,8 @@ import { Construct } from 'constructs';
 import { UniqueId } from '../core/id-generator.js';
 import { unwrapSecret } from '../core/pipeline-helpers.js';
 import { TriggerType } from '../core/pipeline-types.js';
+import { resolveTemplates } from '../template/index.js';
+import { hasTemplate } from '../template/tokenizer.js';
 const log = createLogger('source-builder');
 /** A Secrets Manager ARN (`arn:aws:secretsmanager:...`, incl. partition variants). */
 const SECRETS_MANAGER_ARN = /^arn:aws[a-z-]*:secretsmanager:/i;
@@ -93,12 +95,26 @@ export class SourceBuilder {
      *   `SecretValue.unsafePlainText`, and a loud warning is emitted.
      */
     resolveGitHubAuthentication(options) {
-        const token = options.token;
+        let token = options.token;
         if (token === undefined)
             return undefined;
         // A SecretValue is already a reference (e.g. Secrets Manager) — never plaintext.
         if (typeof token !== 'string')
             return token;
+        // Synth-time templating: resolve `{{ pipeline.* }}` in the token against the
+        // pipeline scope (e.g. `secretsmanager:pipeline-builder/{{ pipeline.vars.orgId }}/
+        // github-token`) so the secret reference can be parameterized by pipeline vars —
+        // the only source field that is templatable. No-op when the token carries no
+        // template (a plain ARN, `secretsmanager:` ref, or plaintext resolves to itself).
+        if (hasTemplate(token)) {
+            const holder = { token };
+            const { errors } = resolveTemplates(holder, this.config.getPipelineScope(), (f) => f === 'token', 'pipeline');
+            if (errors.length > 0) {
+                const e = errors[0];
+                throw new Error(`GitHub source token template resolution failed at '${e.field ?? 'token'}': ${e.message}`);
+            }
+            token = holder.token;
+        }
         // A string that names a Secrets Manager secret is resolved to a reference so
         // only the pointer — not the token — is written to the template / CDK context.
         if (SECRETS_MANAGER_ARN.test(token)) {
@@ -145,4 +161,4 @@ export class 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 { createLogger } from '@pipeline-builder/api-core';\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.js';\nimport type { GitHubOptions } from './source-types.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { unwrapSecret } from '../core/pipeline-helpers.js';\nimport { TriggerType, type SourceType } from '../core/pipeline-types.js';\n\nconst log = createLogger('source-builder');\n\n/** A Secrets Manager ARN (`arn:aws:secretsmanager:...`, incl. partition variants). */\nconst SECRETS_MANAGER_ARN = /^arn:aws[a-z-]*:secretsmanager:/i;\n/** A `secretsmanager:<secret-name>` shorthand reference. */\nconst SECRETS_MANAGER_REF_PREFIX = 'secretsmanager:';\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. The actual\n * EventBridge rule creation is implemented in `PipelineBuilder` (the\n * `ScheduleRule` `events.Rule` targeting the pipeline), not at the source level.\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    const trigger =\n      options.trigger === TriggerType.AUTO ? S3Trigger.EVENTS : S3Trigger.NONE;\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    return CodePipelineSource.gitHub(options.repo, options.branch, {\n      trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,\n      authentication: this.resolveGitHubAuthentication(options),\n    });\n  }\n\n  /**\n   * Resolve the GitHub authentication token into a {@link SecretValue} without\n   * leaking the token value into the synthesized template.\n   *\n   * - `undefined` token → no authentication (CDK default).\n   * - A `SecretValue` → passed through (already a reference, never plaintext).\n   * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via\n   *   `SecretValue.secretsManager`, so only the reference lands in the template.\n   * - A genuine raw plaintext token → rejected by default (it would be baked as\n   *   plaintext into CloudFormation/CDK context). Only when\n   *   `allowPlainTextToken` is explicitly set is it embedded via\n   *   `SecretValue.unsafePlainText`, and a loud warning is emitted.\n   */\n  private resolveGitHubAuthentication(options: GitHubOptions): SecretValue | undefined {\n    const token = options.token;\n    if (token === undefined) return undefined;\n\n    // A SecretValue is already a reference (e.g. Secrets Manager) — never plaintext.\n    if (typeof token !== 'string') return token;\n\n    // A string that names a Secrets Manager secret is resolved to a reference so\n    // only the pointer — not the token — is written to the template / CDK context.\n    if (SECRETS_MANAGER_ARN.test(token)) {\n      return SecretValue.secretsManager(token);\n    }\n    if (token.toLowerCase().startsWith(SECRETS_MANAGER_REF_PREFIX)) {\n      return SecretValue.secretsManager(token.slice(SECRETS_MANAGER_REF_PREFIX.length));\n    }\n\n    // Genuine raw plaintext token — this is the exposure. Reject by default and\n    // point the caller at a secret reference or a CodeStar connection.\n    if (!options.allowPlainTextToken) {\n      throw new Error(\n        'GitHub source `token` is a raw plaintext value, which would be baked into the ' +\n        'synthesized CloudFormation template (and CDK context / stack state). Provide a ' +\n        'Secrets Manager reference instead — an `arn:aws:secretsmanager:...` ARN, a ' +\n        '`secretsmanager:<secret-name>` string, or a `SecretValue.secretsManager(...)` — or ' +\n        'prefer a CodeStar connection (`type: \"codestar\"`). To intentionally embed the token ' +\n        'in plaintext, set `allowPlainTextToken: true`.',\n      );\n    }\n\n    log.warn(\n      'GitHub source `token` is being embedded as PLAINTEXT in the synthesized CloudFormation ' +\n      'template because `allowPlainTextToken` is set. Anyone with template, CDK context, or ' +\n      'stack state access can read this token. Use a Secrets Manager reference or a CodeStar ' +\n      'connection instead.',\n    );\n    return SecretValue.unsafePlainText(token);\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"]}
+//# 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 { createLogger } from '@pipeline-builder/api-core';\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.js';\nimport type { GitHubOptions, SourceType } from './source-types.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { unwrapSecret } from '../core/pipeline-helpers.js';\nimport { TriggerType } from '../core/pipeline-types.js';\nimport { resolveTemplates } from '../template/index.js';\nimport { hasTemplate } from '../template/tokenizer.js';\n\nconst log = createLogger('source-builder');\n\n/** A Secrets Manager ARN (`arn:aws:secretsmanager:...`, incl. partition variants). */\nconst SECRETS_MANAGER_ARN = /^arn:aws[a-z-]*:secretsmanager:/i;\n/** A `secretsmanager:<secret-name>` shorthand reference. */\nconst SECRETS_MANAGER_REF_PREFIX = 'secretsmanager:';\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. The actual\n * EventBridge rule creation is implemented in `PipelineBuilder` (the\n * `ScheduleRule` `events.Rule` targeting the pipeline), not at the source level.\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    const trigger =\n      options.trigger === TriggerType.AUTO ? S3Trigger.EVENTS : S3Trigger.NONE;\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    return CodePipelineSource.gitHub(options.repo, options.branch, {\n      trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,\n      authentication: this.resolveGitHubAuthentication(options),\n    });\n  }\n\n  /**\n   * Resolve the GitHub authentication token into a {@link SecretValue} without\n   * leaking the token value into the synthesized template.\n   *\n   * - `undefined` token → no authentication (CDK default).\n   * - A `SecretValue` → passed through (already a reference, never plaintext).\n   * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via\n   *   `SecretValue.secretsManager`, so only the reference lands in the template.\n   * - A genuine raw plaintext token → rejected by default (it would be baked as\n   *   plaintext into CloudFormation/CDK context). Only when\n   *   `allowPlainTextToken` is explicitly set is it embedded via\n   *   `SecretValue.unsafePlainText`, and a loud warning is emitted.\n   */\n  private resolveGitHubAuthentication(options: GitHubOptions): SecretValue | undefined {\n    let token = options.token;\n    if (token === undefined) return undefined;\n\n    // A SecretValue is already a reference (e.g. Secrets Manager) — never plaintext.\n    if (typeof token !== 'string') return token;\n\n    // Synth-time templating: resolve `{{ pipeline.* }}` in the token against the\n    // pipeline scope (e.g. `secretsmanager:pipeline-builder/{{ pipeline.vars.orgId }}/\n    // github-token`) so the secret reference can be parameterized by pipeline vars —\n    // the only source field that is templatable. No-op when the token carries no\n    // template (a plain ARN, `secretsmanager:` ref, or plaintext resolves to itself).\n    if (hasTemplate(token)) {\n      const holder = { token };\n      const { errors } = resolveTemplates(holder, this.config.getPipelineScope(), (f) => f === 'token', 'pipeline');\n      if (errors.length > 0) {\n        const e = errors[0]!;\n        throw new Error(`GitHub source token template resolution failed at '${e.field ?? 'token'}': ${e.message}`);\n      }\n      token = holder.token;\n    }\n\n    // A string that names a Secrets Manager secret is resolved to a reference so\n    // only the pointer — not the token — is written to the template / CDK context.\n    if (SECRETS_MANAGER_ARN.test(token)) {\n      return SecretValue.secretsManager(token);\n    }\n    if (token.toLowerCase().startsWith(SECRETS_MANAGER_REF_PREFIX)) {\n      return SecretValue.secretsManager(token.slice(SECRETS_MANAGER_REF_PREFIX.length));\n    }\n\n    // Genuine raw plaintext token — this is the exposure. Reject by default and\n    // point the caller at a secret reference or a CodeStar connection.\n    if (!options.allowPlainTextToken) {\n      throw new Error(\n        'GitHub source `token` is a raw plaintext value, which would be baked into the ' +\n        'synthesized CloudFormation template (and CDK context / stack state). Provide a ' +\n        'Secrets Manager reference instead — an `arn:aws:secretsmanager:...` ARN, a ' +\n        '`secretsmanager:<secret-name>` string, or a `SecretValue.secretsManager(...)` — or ' +\n        'prefer a CodeStar connection (`type: \"codestar\"`). To intentionally embed the token ' +\n        'in plaintext, set `allowPlainTextToken: true`.',\n      );\n    }\n\n    log.warn(\n      'GitHub source `token` is being embedded as PLAINTEXT in the synthesized CloudFormation ' +\n      'template because `allowPlainTextToken` is set. Anyone with template, CDK context, or ' +\n      'stack state access can read this token. Use a Secrets Manager reference or a CodeStar ' +\n      'connection instead.',\n    );\n    return SecretValue.unsafePlainText(token);\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

@@ -209,3 +209,13 @@ export interface CodeCommitOptions {
      */
     readonly trigger?: TriggerType;
 }
+/**
+ * Union type of all supported pipeline source types
+ *
+ * Supported sources:
+ * - S3SourceConfig: Source code from S3 bucket
+ * - GitHubSourceConfig: Source code from GitHub repository
+ * - CodeStarSourceConfig: Source code via CodeStar connection (GitHub, Bitbucket, GitLab)
+ * - CodeCommitSourceConfig: Source code from AWS CodeCommit repository
+ */
+export type SourceType = S3SourceConfig | GitHubSourceConfig | CodeStarSourceConfig | CodeCommitSourceConfig;

package/lib/pipeline/source-types.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-types.js","sourceRoot":"","sources":["../../src/pipeline/source-types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { SecretValue } from 'aws-cdk-lib';\nimport type { TriggerType } from '../core/pipeline-types.js';\n\n/**\n * S3 source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: S3SourceConfig = {\n *   type: 's3',\n *   options: {\n *     bucketName: 'my-source-bucket',\n *     objectKey: 'source.zip',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface S3SourceConfig {\n  readonly type: 's3';\n  readonly options: S3Options;\n}\n\n/**\n * GitHub source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: GitHubSourceConfig = {\n *   type: 'github',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface GitHubSourceConfig {\n  readonly type: 'github';\n  readonly options: GitHubOptions;\n}\n\n/**\n * CodeStar connection source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeStarSourceConfig = {\n *   type: 'codestar',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     connectionArn: 'arn:aws:codestar-connections:...',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeStarSourceConfig {\n  readonly type: 'codestar';\n  readonly options: CodeStarOptions;\n}\n\n/**\n * Configuration options for S3 pipeline source\n */\nexport interface S3Options {\n  /**\n   * Name of the S3 bucket containing the source code\n   * @example 'my-pipeline-source-bucket'\n   */\n  readonly bucketName: string;\n\n  /**\n   * Object key (path) to the source archive within the bucket\n   * @default 'source.zip'\n   */\n  readonly objectKey?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for GitHub pipeline source\n */\nexport interface GitHubOptions {\n  /**\n   * GitHub repository in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * GitHub authentication token.\n   *\n   * Prefer a Secrets Manager reference so the token value never lands in the\n   * synthesized CloudFormation template / CDK context. Accepted forms:\n   *   - a `SecretValue` (e.g. `SecretValue.secretsManager(...)`),\n   *   - a Secrets Manager ARN string (`arn:aws:secretsmanager:...`),\n   *   - a `secretsmanager:<secret-name>` shorthand string.\n   *\n   * A genuine raw plaintext token (e.g. a `ghp_...` PAT) is rejected by default,\n   * because baking it in would expose it to anyone with template/state access —\n   * set {@link allowPlainTextToken} to intentionally embed it.\n   *\n   * If not provided, uses default GitHub authentication. Consider a CodeStar\n   * connection (`type: 'codestar'`) as the modern, credential-free path.\n   */\n  readonly token?: SecretValue | string;\n\n  /**\n   * Opt-in escape hatch to embed a raw plaintext {@link token} directly in the\n   * synthesized template. Insecure — the token becomes readable by anyone with\n   * template, CDK context, or stack state access. Leave unset (default) to force\n   * a Secrets Manager reference instead.\n   * @default false\n   */\n  readonly allowPlainTextToken?: boolean;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for CodeStar connection pipeline source\n */\nexport interface CodeStarOptions {\n  /**\n   * Repository identifier in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * ARN of the CodeStar connection to use\n   * Can be a string ARN or SecretValue\n   * @example 'arn:aws:codestar-connections:us-east-1:123456789012:connection/abc123'\n   */\n  readonly connectionArn: SecretValue | string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n\n  /**\n   * Whether to enable full clone capability in CodeBuild\n   * When true, CodeBuild can perform git operations on the full repository\n   * @default false\n   */\n  readonly codeBuildCloneOutput?: boolean;\n}\n\n/**\n * CodeCommit source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeCommitSourceConfig = {\n *   type: 'codecommit',\n *   options: {\n *     repositoryName: 'my-repo',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeCommitSourceConfig {\n  readonly type: 'codecommit';\n  readonly options: CodeCommitOptions;\n}\n\n/**\n * Configuration options for CodeCommit pipeline source\n */\nexport interface CodeCommitOptions {\n  /**\n   * Name of the CodeCommit repository\n   * @example 'my-repo'\n   */\n  readonly repositoryName: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-types.js","sourceRoot":"","sources":["../../src/pipeline/source-types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { SecretValue } from 'aws-cdk-lib';\nimport type { TriggerType } from '../core/pipeline-types.js';\n\n/**\n * S3 source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: S3SourceConfig = {\n *   type: 's3',\n *   options: {\n *     bucketName: 'my-source-bucket',\n *     objectKey: 'source.zip',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface S3SourceConfig {\n  readonly type: 's3';\n  readonly options: S3Options;\n}\n\n/**\n * GitHub source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: GitHubSourceConfig = {\n *   type: 'github',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface GitHubSourceConfig {\n  readonly type: 'github';\n  readonly options: GitHubOptions;\n}\n\n/**\n * CodeStar connection source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeStarSourceConfig = {\n *   type: 'codestar',\n *   options: {\n *     repo: 'owner/repository',\n *     branch: 'main',\n *     connectionArn: 'arn:aws:codestar-connections:...',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeStarSourceConfig {\n  readonly type: 'codestar';\n  readonly options: CodeStarOptions;\n}\n\n/**\n * Configuration options for S3 pipeline source\n */\nexport interface S3Options {\n  /**\n   * Name of the S3 bucket containing the source code\n   * @example 'my-pipeline-source-bucket'\n   */\n  readonly bucketName: string;\n\n  /**\n   * Object key (path) to the source archive within the bucket\n   * @default 'source.zip'\n   */\n  readonly objectKey?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for GitHub pipeline source\n */\nexport interface GitHubOptions {\n  /**\n   * GitHub repository in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * GitHub authentication token.\n   *\n   * Prefer a Secrets Manager reference so the token value never lands in the\n   * synthesized CloudFormation template / CDK context. Accepted forms:\n   *   - a `SecretValue` (e.g. `SecretValue.secretsManager(...)`),\n   *   - a Secrets Manager ARN string (`arn:aws:secretsmanager:...`),\n   *   - a `secretsmanager:<secret-name>` shorthand string.\n   *\n   * A genuine raw plaintext token (e.g. a `ghp_...` PAT) is rejected by default,\n   * because baking it in would expose it to anyone with template/state access —\n   * set {@link allowPlainTextToken} to intentionally embed it.\n   *\n   * If not provided, uses default GitHub authentication. Consider a CodeStar\n   * connection (`type: 'codestar'`) as the modern, credential-free path.\n   */\n  readonly token?: SecretValue | string;\n\n  /**\n   * Opt-in escape hatch to embed a raw plaintext {@link token} directly in the\n   * synthesized template. Insecure — the token becomes readable by anyone with\n   * template, CDK context, or stack state access. Leave unset (default) to force\n   * a Secrets Manager reference instead.\n   * @default false\n   */\n  readonly allowPlainTextToken?: boolean;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n}\n\n/**\n * Configuration options for CodeStar connection pipeline source\n */\nexport interface CodeStarOptions {\n  /**\n   * Repository identifier in the format \"owner/repo\"\n   * @example 'myorg/myrepo'\n   */\n  readonly repo: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * ARN of the CodeStar connection to use\n   * Can be a string ARN or SecretValue\n   * @example 'arn:aws:codestar-connections:us-east-1:123456789012:connection/abc123'\n   */\n  readonly connectionArn: SecretValue | string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n\n  /**\n   * Cron expression for scheduled trigger (e.g., 'cron(0 0 * * ? *)' for daily).\n   * Only used when trigger is SCHEDULE.\n   */\n  readonly schedule?: string;\n\n  /**\n   * Whether to enable full clone capability in CodeBuild\n   * When true, CodeBuild can perform git operations on the full repository\n   * @default false\n   */\n  readonly codeBuildCloneOutput?: boolean;\n}\n\n/**\n * CodeCommit source configuration for CodePipeline\n *\n * @example\n * ```typescript\n * const source: CodeCommitSourceConfig = {\n *   type: 'codecommit',\n *   options: {\n *     repositoryName: 'my-repo',\n *     branch: 'main',\n *     trigger: TriggerType.AUTO\n *   }\n * };\n * ```\n */\nexport interface CodeCommitSourceConfig {\n  readonly type: 'codecommit';\n  readonly options: CodeCommitOptions;\n}\n\n/**\n * Configuration options for CodeCommit pipeline source\n */\nexport interface CodeCommitOptions {\n  /**\n   * Name of the CodeCommit repository\n   * @example 'my-repo'\n   */\n  readonly repositoryName: string;\n\n  /**\n   * Branch to track\n   * @default 'main'\n   */\n  readonly branch?: string;\n\n  /**\n   * Pipeline trigger behavior\n   * @default TriggerType.NONE\n   */\n  readonly trigger?: TriggerType;\n}\n\n/**\n * Union type of all supported pipeline source types\n *\n * Supported sources:\n * - S3SourceConfig: Source code from S3 bucket\n * - GitHubSourceConfig: Source code from GitHub repository\n * - CodeStarSourceConfig: Source code via CodeStar connection (GitHub, Bitbucket, GitLab)\n * - CodeCommitSourceConfig: Source code from AWS CodeCommit repository\n */\nexport type SourceType = S3SourceConfig | GitHubSourceConfig | CodeStarSourceConfig | CodeCommitSourceConfig;\n"]}

package/lib/pipeline/stage-builder.js

@@ -4,7 +4,8 @@ import { CodePipeline } from 'aws-cdk-lib/pipelines';
 import { Construct } from 'constructs';
 import { PluginLookup } from './plugin-lookup.js';
 import { UniqueId } from '../core/id-generator.js';
-import { createCodeBuildStep, merge, resolveFailureBehavior } from '../core/pipeline-helpers.js';
+import { merge, resolveFailureBehavior } from '../core/metadata-helpers.js';
+import { createCodeBuildStep } from '../core/pipeline-helpers.js';
 /**
  * Builds and adds pipeline stages (waves) to a CodePipeline.
  *
@@ -125,4 +126,4 @@ export class 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.js';\nimport type { StageOptions } from './step-types.js';\nimport type { ArtifactManager } from '../core/artifact-manager.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { createCodeBuildStep, merge, resolveFailureBehavior } from '../core/pipeline-helpers.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\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   * Pipeline-level scope used to resolve `{{ pipeline.* }}` template tokens\n   * inside plugin specs. Required — passed through to `createCodeBuildStep`\n   * on every step.\n   */\n  readonly pipelineScope: Record<string, unknown>;\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  private readonly pipelineScope: Record<string, unknown>;\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    this.pipelineScope = props.pipelineScope;\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    // Per-step plugin config lives on the plugin reference (`plugin.metadata` —\n    // e.g. JAVA_VERSION/KOTLIN_VERSION/computetype overrides). pluginLookup.plugin()\n    // returns the resolved CATALOG plugin and drops the reference metadata in the\n    // pre-resolved path, so merge it here too — otherwise per-step overrides are\n    // silently ignored and the build falls back to plugin defaults.\n    // Order (last wins): global < plugin-ref metadata < step-level metadata.\n    const stepMetadata = merge(this.globalMetadata, stepConfig.plugin.metadata ?? {}, 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      // A scan/security-category plugin can never be downgraded from 'fail' — see resolveFailureBehavior.\n      failureBehavior: resolveFailureBehavior(plugin.category, stepConfig.failureBehavior ?? plugin.failureBehavior),\n      orgId: this.orgId,\n      pipelineScope: this.pipelineScope,\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stage-builder.js","sourceRoot":"","sources":["../../src/pipeline/stage-builder.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAoClE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,OAAO,YAAY;IACN,KAAK,CAAY;IACjB,YAAY,CAAe;IAC3B,QAAQ,CAAW;IACnB,cAAc,CAAe;IAC7B,kBAAkB,CAAkB;IACpC,eAAe,CAAmB;IAClC,KAAK,CAAU;IACf,aAAa,CAA0B;IAExD,YAAY,KAAwB;QAClC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QACvC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;QAC3C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC;QACnD,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;QAC7C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,QAAsB,EAAE,KAAmB;QAClD,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,SAAS,QAAQ,CAAC;QAE7D,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK;aACzB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC;aAC5C,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;QAC9D,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK;aAC1B,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,CAAC;aAClC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;QAE9D,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE;YAC3B,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;YAC7C,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;SACjD,CAAC,CAAC;IACL,CAAC;IAEO,WAAW,CAAC,UAAyC,EAAE,SAAiB,EAAE,UAAkB;QAClG,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAC3D,4EAA4E;QAC5E,iFAAiF;QACjF,8EAA8E;QAC9E,6EAA6E;QAC7E,gEAAgE;QAChE,yEAAyE;QACzE,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,EAAE,UAAU,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;QAC7G,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC;QAEtE,IAAI,UAAU,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CACb,SAAS,WAAW,gEAAgE,CACrF,CAAC;QACJ,CAAC;QACD,IAAI,UAAU,CAAC,wBAAwB,EAAE,MAAM,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CACb,SAAS,WAAW,2EAA2E,CAChG,CAAC;QACJ,CAAC;QAED,MAAM,KAAK,GAAG,UAAU,CAAC,aAAa,IAAI,IAAI,CAAC,eAAe;YAC5D,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,UAAU,CAAC,aAAa,CAAC;YAC1D,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,gBAAgB,GAAG,UAAU,CAAC,wBAAwB,EAAE,MAAM,IAAI,IAAI,CAAC,eAAe;YAC1F,CAAC,CAAC,MAAM,CAAC,WAAW,CAClB,UAAU,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;gBACnE,SAAS,IAAI,QAAQ,CAAC,eAAe;gBACrC,IAAI,CAAC,eAAgB,CAAC,SAAS,CAAC,QAAQ,CAAC;aAC1C,CAAC,CACH;YACD,CAAC,CAAC,SAAS,CAAC;QAEd,OAAO,mBAAmB,CAAC;YACzB,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,UAAU,IAAI,WAAW,EAAE,CAAC;YAChE,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,MAAM;YACN,QAAQ,EAAE,YAAY;YACtB,OAAO,EAAE,UAAU,CAAC,OAAO;YAC3B,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,KAAK;YACL,gBAAgB;YAChB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,SAAS;YACT,UAAU;YACV,WAAW;YACX,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;YACjD,mBAAmB,EAAE,UAAU,CAAC,mBAAmB;YACnD,WAAW,EAAE,UAAU,CAAC,WAAW;YACnC,YAAY,EAAE,UAAU,CAAC,YAAY;YACrC,GAAG,EAAE,UAAU,CAAC,GAAG;YACnB,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,IAAI,SAAS;YAC1D,oGAAoG;YACpG,eAAe,EAAE,sBAAsB,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,eAAe,IAAI,MAAM,CAAC,eAAe,CAAC;YAC9G,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,QAAsB,EAAE,MAAsB;QACtD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;CACF","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.js';\nimport type { StageOptions } from './step-types.js';\nimport type { ArtifactManager } from '../core/artifact-manager.js';\nimport { UniqueId } from '../core/id-generator.js';\nimport { merge, resolveFailureBehavior } from '../core/metadata-helpers.js';\nimport { createCodeBuildStep } from '../core/pipeline-helpers.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\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   * Pipeline-level scope used to resolve `{{ pipeline.* }}` template tokens\n   * inside plugin specs. Required — passed through to `createCodeBuildStep`\n   * on every step.\n   */\n  readonly pipelineScope: Record<string, unknown>;\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  private readonly pipelineScope: Record<string, unknown>;\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    this.pipelineScope = props.pipelineScope;\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    // Per-step plugin config lives on the plugin reference (`plugin.metadata` —\n    // e.g. JAVA_VERSION/KOTLIN_VERSION/computetype overrides). pluginLookup.plugin()\n    // returns the resolved CATALOG plugin and drops the reference metadata in the\n    // pre-resolved path, so merge it here too — otherwise per-step overrides are\n    // silently ignored and the build falls back to plugin defaults.\n    // Order (last wins): global < plugin-ref metadata < step-level metadata.\n    const stepMetadata = merge(this.globalMetadata, stepConfig.plugin.metadata ?? {}, 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      // A scan/security-category plugin can never be downgraded from 'fail' — see resolveFailureBehavior.\n      failureBehavior: resolveFailureBehavior(plugin.category, stepConfig.failureBehavior ?? plugin.failureBehavior),\n      orgId: this.orgId,\n      pipelineScope: this.pipelineScope,\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"]}