@pipeline-builder/pipeline-core 0.0.1

package/lib/pipeline/source-builder.js

@@ -0,0 +1,164 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createLogger } from '@pipeline-builder/api-core';
+import { SecretValue } from 'aws-cdk-lib';
+import { Repository } from 'aws-cdk-lib/aws-codecommit';
+import { CodeCommitTrigger, GitHubTrigger, S3Trigger } from 'aws-cdk-lib/aws-codepipeline-actions';
+import { Bucket } from 'aws-cdk-lib/aws-s3';
+import { CodePipelineSource } from 'aws-cdk-lib/pipelines';
+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;
+/** A `secretsmanager:<secret-name>` shorthand reference. */
+const SECRETS_MANAGER_REF_PREFIX = 'secretsmanager:';
+/**
+ * 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. The actual
+ * EventBridge rule creation is implemented in `PipelineBuilder` (the
+ * `ScheduleRule` `events.Rule` targeting the pipeline), not at the source level.
+ *
+ * @example
+ * ```typescript
+ * const sourceBuilder = new SourceBuilder(this, config);
+ * const source = sourceBuilder.create(uniqueId);
+ * ```
+ */
+export 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 = Bucket.fromBucketName(this.scope, id.generate('source:bucket'), options.bucketName);
+        const trigger = options.trigger === TriggerType.AUTO ? S3Trigger.EVENTS : S3Trigger.NONE;
+        return CodePipelineSource.s3(bucket, options.objectKey, { trigger });
+    }
+    /**
+     * Creates a GitHub source for the pipeline
+     */
+    createGitHubSource() {
+        const options = this.config.getGitHubOptions();
+        return CodePipelineSource.gitHub(options.repo, options.branch, {
+            trigger: options.trigger === TriggerType.AUTO ? GitHubTrigger.POLL : GitHubTrigger.NONE,
+            authentication: this.resolveGitHubAuthentication(options),
+        });
+    }
+    /**
+     * Resolve the GitHub authentication token into a {@link SecretValue} without
+     * leaking the token value into the synthesized template.
+     *
+     * - `undefined` token → no authentication (CDK default).
+     * - A `SecretValue` → passed through (already a reference, never plaintext).
+     * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via
+     *   `SecretValue.secretsManager`, so only the reference lands in the template.
+     * - A genuine raw plaintext token → rejected by default (it would be baked as
+     *   plaintext into CloudFormation/CDK context). Only when
+     *   `allowPlainTextToken` is explicitly set is it embedded via
+     *   `SecretValue.unsafePlainText`, and a loud warning is emitted.
+     */
+    resolveGitHubAuthentication(options) {
+        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)) {
+            return SecretValue.secretsManager(token);
+        }
+        if (token.toLowerCase().startsWith(SECRETS_MANAGER_REF_PREFIX)) {
+            return SecretValue.secretsManager(token.slice(SECRETS_MANAGER_REF_PREFIX.length));
+        }
+        // Genuine raw plaintext token — this is the exposure. Reject by default and
+        // point the caller at a secret reference or a CodeStar connection.
+        if (!options.allowPlainTextToken) {
+            throw new Error('GitHub source `token` is a raw plaintext value, which would be baked into the ' +
+                'synthesized CloudFormation template (and CDK context / stack state). Provide a ' +
+                'Secrets Manager reference instead — an `arn:aws:secretsmanager:...` ARN, a ' +
+                '`secretsmanager:<secret-name>` string, or a `SecretValue.secretsManager(...)` — or ' +
+                'prefer a CodeStar connection (`type: "codestar"`). To intentionally embed the token ' +
+                'in plaintext, set `allowPlainTextToken: true`.');
+        }
+        log.warn('GitHub source `token` is being embedded as PLAINTEXT in the synthesized CloudFormation ' +
+            'template because `allowPlainTextToken` is set. Anyone with template, CDK context, or ' +
+            'stack state access can read this token. Use a Secrets Manager reference or a CodeStar ' +
+            'connection instead.');
+        return SecretValue.unsafePlainText(token);
+    }
+    /**
+     * Creates a CodeStar connection source for the pipeline
+     */
+    createCodeStarSource() {
+        const options = this.config.getCodeStarOptions();
+        return CodePipelineSource.connection(options.repo, options.branch, {
+            connectionArn: unwrapSecret(options.connectionArn),
+            triggerOnPush: options.trigger === TriggerType.AUTO,
+            codeBuildCloneOutput: options.codeBuildCloneOutput,
+        });
+    }
+    /**
+     * Creates a CodeCommit source for the pipeline
+     */
+    createCodeCommitSource(id) {
+        const options = this.config.getCodeCommitOptions();
+        const repository = Repository.fromRepositoryName(this.scope, id.generate('source:repo'), options.repositoryName);
+        return CodePipelineSource.codeCommit(repository, options.branch ?? 'main', {
+            trigger: options.trigger === TriggerType.AUTO ? CodeCommitTrigger.EVENTS : CodeCommitTrigger.NONE,
+        });
+    }
+}
+//# 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

@@ -0,0 +1,221 @@
+import type { SecretValue } from 'aws-cdk-lib';
+import type { TriggerType } from '../core/pipeline-types.js';
+/**
+ * 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 authentication token.
+     *
+     * Prefer a Secrets Manager reference so the token value never lands in the
+     * synthesized CloudFormation template / CDK context. Accepted forms:
+     *   - a `SecretValue` (e.g. `SecretValue.secretsManager(...)`),
+     *   - a Secrets Manager ARN string (`arn:aws:secretsmanager:...`),
+     *   - a `secretsmanager:<secret-name>` shorthand string.
+     *
+     * A genuine raw plaintext token (e.g. a `ghp_...` PAT) is rejected by default,
+     * because baking it in would expose it to anyone with template/state access —
+     * set {@link allowPlainTextToken} to intentionally embed it.
+     *
+     * If not provided, uses default GitHub authentication. Consider a CodeStar
+     * connection (`type: 'codestar'`) as the modern, credential-free path.
+     */
+    readonly token?: SecretValue | string;
+    /**
+     * Opt-in escape hatch to embed a raw plaintext {@link token} directly in the
+     * synthesized template. Insecure — the token becomes readable by anyone with
+     * template, CDK context, or stack state access. Leave unset (default) to force
+     * a Secrets Manager reference instead.
+     * @default false
+     */
+    readonly allowPlainTextToken?: boolean;
+    /**
+     * 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;
+}
+/**
+ * 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

@@ -0,0 +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\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.d.ts

@@ -0,0 +1,78 @@
+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.js';
+import type { StageOptions } from './step-types.js';
+import type { ArtifactManager } from '../core/artifact-manager.js';
+import { UniqueId } from '../core/id-generator.js';
+import type { MetaDataType } from '../core/pipeline-types.js';
+/**
+ * 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;
+    /**
+     * Pipeline-level scope used to resolve `{{ pipeline.* }}` template tokens
+     * inside plugin specs. Required — passed through to `createCodeBuildStep`
+     * on every step.
+     */
+    readonly pipelineScope: Record<string, unknown>;
+}
+/**
+ * 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?;
+    private readonly pipelineScope;
+    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;
+}