@pipeline-builder/pipeline-core 3.1.1

package/lib/pipeline/pipeline-builder.js

@@ -0,0 +1,292 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineBuilder = void 0;
+const api_core_1 = require("@pipeline-builder/api-core");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cloudwatch = __importStar(require("aws-cdk-lib/aws-cloudwatch"));
+const aws_codepipeline_1 = require("aws-cdk-lib/aws-codepipeline");
+const events = __importStar(require("aws-cdk-lib/aws-events"));
+const targets = __importStar(require("aws-cdk-lib/aws-events-targets"));
+const kms = __importStar(require("aws-cdk-lib/aws-kms"));
+const sns = __importStar(require("aws-cdk-lib/aws-sns"));
+const pipelines_1 = require("aws-cdk-lib/pipelines");
+const constructs_1 = require("constructs");
+const pipeline_configuration_1 = require("./pipeline-configuration");
+const plugin_lookup_1 = require("./plugin-lookup");
+const source_builder_1 = require("./source-builder");
+const stage_builder_1 = require("./stage-builder");
+const app_config_1 = require("../config/app-config");
+const artifact_manager_1 = require("../core/artifact-manager");
+const id_generator_1 = require("../core/id-generator");
+const metadata_builder_1 = require("../core/metadata-builder");
+const network_1 = require("../core/network");
+const pipeline_helpers_1 = require("../core/pipeline-helpers");
+const pipeline_types_1 = require("../core/pipeline-types");
+const role_1 = require("../core/role");
+const security_group_1 = require("../core/security-group");
+const PIPELINE_EVENT_MAP = {
+    FAILED: aws_codepipeline_1.PipelineNotificationEvents.PIPELINE_EXECUTION_FAILED,
+    SUCCEEDED: aws_codepipeline_1.PipelineNotificationEvents.PIPELINE_EXECUTION_SUCCEEDED,
+    STARTED: aws_codepipeline_1.PipelineNotificationEvents.PIPELINE_EXECUTION_STARTED,
+    CANCELED: aws_codepipeline_1.PipelineNotificationEvents.PIPELINE_EXECUTION_CANCELED,
+    SUPERSEDED: aws_codepipeline_1.PipelineNotificationEvents.PIPELINE_EXECUTION_SUPERSEDED,
+};
+function parseNotificationEvents(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === 'string')
+        return value.split(',').map(s => s.trim());
+    return ['FAILED', 'SUCCEEDED'];
+}
+/**
+ * CDK construct that creates and configures a CodePipeline for continuous deployment.
+ *
+ * Features:
+ * - Multi-source support (S3, GitHub, CodeStar)
+ * - Plugin-based build steps
+ * - Metadata-driven configuration
+ * - Automatic tagging
+ * - Automatic sanitization of project and organization names
+ *
+ * @example
+ * ```typescript
+ * new PipelineBuilder(this, 'MyPipeline', {
+ *   project: 'my-app',
+ *   organization: 'my-org',
+ *   synth: {
+ *     source: {
+ *       type: 'github',
+ *       options: { repo: 'owner/repo', branch: 'main' }
+ *     },
+ *     plugin: { name: 'synth' }
+ *   }
+ * });
+ * ```
+ */
+class PipelineBuilder extends constructs_1.Construct {
+    pipeline;
+    config;
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Use PipelineConfiguration for all business logic (validation, sanitization, metadata merging)
+        this.config = new pipeline_configuration_1.PipelineConfiguration(props);
+        const serverConfig = app_config_1.Config.get('server');
+        const awsConfig = app_config_1.Config.get('aws');
+        const uniqueId = new id_generator_1.UniqueId();
+        const pluginLookup = new plugin_lookup_1.PluginLookup(this, uniqueId.generate('plugin:lookup'), {
+            organization: this.config.organization,
+            project: this.config.project,
+            platformUrl: serverConfig.platformUrl,
+            uniqueId,
+            orgId: props.orgId,
+            runtime: awsConfig.lambda.runtime,
+            timeout: awsConfig.lambda.timeout,
+            reservedConcurrentExecutions: awsConfig.lambda.reservedConcurrentExecutions,
+        });
+        // Create source and build step
+        const sourceBuilder = new source_builder_1.SourceBuilder(this, this.config);
+        const source = sourceBuilder.create(uniqueId);
+        // RESOLVED_SYNTH_PLUGIN=true (CodePipeline): resolve plugin via custom resource Lambda
+        // RESOLVED_SYNTH_PLUGIN=false (default/CLI): use fallback with pipeline-manager synth commands
+        const plugin = awsConfig.resolvedSynthPlugin
+            ? pluginLookup.plugin(this.config.plugin)
+            : pluginLookup.fallbackSynth();
+        const defaultComputeType = awsConfig.codeBuild.computeType;
+        const artifactManager = new artifact_manager_1.ArtifactManager();
+        const synthAlias = this.config.plugin.alias ?? this.config.plugin.name;
+        const synth = (0, pipeline_helpers_1.createCodeBuildStep)({
+            ...this.config.synthCustomization,
+            id: uniqueId.generate('cdk:synth'),
+            uniqueId,
+            plugin,
+            input: source,
+            metadata: this.config.metadata.merged,
+            network: this.config.network,
+            scope: this,
+            defaultComputeType,
+            artifactManager,
+            stageName: 'no-stage',
+            stageAlias: 'no-stage-alias',
+            pluginAlias: `${synthAlias}-alias`,
+            orgId: props.orgId,
+        });
+        // Resolve pipeline-level defaults into codeBuildDefaults
+        // Build the per-org platform secret name for CodeBuild env vars
+        const platformSecretName = props.orgId
+            ? app_config_1.CoreConstants.secretPath(props.orgId, 'platform')
+            : undefined;
+        const codeBuildDefaults = this.resolveDefaults(this.config.defaults, uniqueId, props.pipelineId, platformSecretName, serverConfig.platformUrl);
+        // Resolve IAM role if explicitly provided; otherwise let CDK auto-create
+        // the pipeline role with the correct codepipeline.amazonaws.com principal.
+        if (props.role?.type === 'codeBuildDefault') {
+            (0, api_core_1.createLogger)('PipelineBuilder').warn('codeBuildDefault role type uses codebuild.amazonaws.com trust principal — ' +
+                'this is not suitable as the pipeline-level role. Consider using roleArn/roleName ' +
+                'or omitting the role to let CDK auto-create one with codepipeline.amazonaws.com.');
+        }
+        const role = props.role
+            ? (0, role_1.resolveRole)(this, uniqueId, props.role)
+            : undefined;
+        // Create CodePipeline construct
+        this.pipeline = new pipelines_1.CodePipeline(this, uniqueId.generate('pipelines:codepipeline'), {
+            ...(codeBuildDefaults && { codeBuildDefaults }),
+            ...(role && { role }),
+            pipelineType: aws_codepipeline_1.PipelineType.V2,
+            pipelineName: this.config.pipelineName,
+            synth,
+            ...(0, metadata_builder_1.metadataForCodePipeline)(this.config.metadata.merged),
+        });
+        // Add stages as waves via StageBuilder
+        if (props.stages) {
+            const stageBuilder = new stage_builder_1.StageBuilder({
+                scope: this,
+                pluginLookup,
+                uniqueId,
+                globalMetadata: this.config.metadata.merged,
+                defaultComputeType,
+                artifactManager,
+                orgId: props.orgId,
+            });
+            stageBuilder.addStages(this.pipeline, props.stages);
+        }
+        // ── Tags ──
+        aws_cdk_lib_1.Tags.of(this.pipeline).add('project', this.config.project);
+        aws_cdk_lib_1.Tags.of(this.pipeline).add('organization', this.config.organization);
+        if (props.tags) {
+            for (const [key, value] of Object.entries(props.tags)) {
+                aws_cdk_lib_1.Tags.of(this.pipeline).add(key, value);
+            }
+        }
+        // Build the internal pipeline before accessing its properties
+        this.pipeline.buildPipeline();
+        const cdkPipeline = this.pipeline.pipeline;
+        const meta = this.config.metadata.merged;
+        // ── SNS Notifications ──
+        const notificationTopicArn = meta[pipeline_types_1.MetadataKeys.NOTIFICATION_TOPIC_ARN];
+        if (typeof notificationTopicArn === 'string') {
+            const topic = sns.Topic.fromTopicArn(this, 'NotificationTopic', notificationTopicArn);
+            const notificationEvents = parseNotificationEvents(meta[pipeline_types_1.MetadataKeys.NOTIFICATION_EVENTS])
+                .map(e => PIPELINE_EVENT_MAP[e.toUpperCase()])
+                .filter(Boolean);
+            if (notificationEvents.length > 0) {
+                cdkPipeline.notifyOn('PipelineNotification', topic, { events: notificationEvents });
+            }
+        }
+        // ── Scheduled Execution ──
+        if (props.synth.source.options?.trigger === pipeline_types_1.TriggerType.SCHEDULE || props.schedule) {
+            const expr = props.schedule || props.synth.source.options?.schedule || 'rate(1 day)';
+            new events.Rule(this, 'ScheduleRule', {
+                schedule: events.Schedule.expression(expr),
+                targets: [new targets.CodePipeline(cdkPipeline)],
+            });
+        }
+        // ── Execution Event Tracking (forward pipeline state changes to SNS) ──
+        if (meta[pipeline_types_1.MetadataKeys.ENABLE_EXECUTION_EVENTS] && typeof notificationTopicArn === 'string') {
+            new events.Rule(this, 'ExecutionEventRule', {
+                eventPattern: {
+                    source: ['aws.codepipeline'],
+                    detailType: ['CodePipeline Pipeline Execution State Change'],
+                    resources: [cdkPipeline.pipelineArn],
+                },
+                targets: [new targets.SnsTopic(sns.Topic.fromTopicArn(this, 'ExecutionEventTopic', notificationTopicArn))],
+            });
+        }
+        // ── Artifact Encryption (KMS key) ──
+        const kmsKeyArn = this.config.metadata.merged[pipeline_types_1.MetadataKeys.KMS_KEY_ARN];
+        if (typeof kmsKeyArn === 'string') {
+            const key = kms.Key.fromKeyArn(this, 'ArtifactKey', kmsKeyArn);
+            aws_cdk_lib_1.Tags.of(key).add('pipeline', this.config.pipelineName);
+        }
+        // ── Pipeline Metrics & Alarms ──
+        const enableMetrics = this.config.metadata.merged[pipeline_types_1.MetadataKeys.ENABLE_METRICS];
+        if (enableMetrics) {
+            new cloudwatch.Alarm(this, 'PipelineFailureAlarm', {
+                metric: new cloudwatch.Metric({
+                    namespace: 'AWS/CodePipeline',
+                    metricName: 'FailedPipelineExecutionCount',
+                    dimensionsMap: { PipelineName: this.config.pipelineName },
+                    statistic: 'Sum',
+                    period: aws_cdk_lib_1.Duration.minutes(5),
+                }),
+                threshold: 1,
+                evaluationPeriods: 1,
+                alarmDescription: `Pipeline ${this.config.pipelineName} execution failed`,
+                comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+        }
+    }
+    /**
+     * Resolves CodeBuildDefaults into the shape expected by CDK's codeBuildDefaults.
+     * Combines network config, security groups, and pipeline-level environment variables
+     * (PIPELINE_ID, EXECUTION_ID, PLATFORM_BASE_URL) available to all CodeBuild actions.
+     */
+    resolveDefaults(defaults, id, pipelineId, platformSecretName, platformUrl) {
+        const networkProps = defaults?.network
+            ? (0, network_1.resolveNetwork)(this, id, defaults.network)
+            : undefined;
+        const standaloneSecurityGroups = defaults?.securityGroups
+            ? (0, security_group_1.resolveSecurityGroup)(this, id, defaults.securityGroups)
+            : undefined;
+        // Pipeline-level env vars available to all CodeBuild actions
+        // Note: #{codepipeline.*} resolved variables must go through CodeBuildStep.env
+        // (action-level), not buildEnvironment.environmentVariables (project-level).
+        const pipelineEnvVars = {
+            PLATFORM_BASE_URL: { value: platformUrl },
+            ...(pipelineId && { PIPELINE_ID: { value: pipelineId } }),
+            ...(platformSecretName && { PLATFORM_SECRET_NAME: { value: platformSecretName } }),
+            // Enable plugin resolution via custom resource Lambda inside CodePipeline
+            RESOLVED_SYNTH_PLUGIN: { value: 'true' },
+            // Propagate TLS verification setting so all CodeBuild steps can reach
+            // the platform API when using self-signed certificates
+            ...(process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0' && {
+                NODE_TLS_REJECT_UNAUTHORIZED: { value: '0' },
+            }),
+        };
+        const securityGroups = [
+            ...(networkProps?.securityGroups ?? []),
+            ...(standaloneSecurityGroups ?? []),
+        ];
+        return {
+            ...(networkProps && { vpc: networkProps.vpc, subnetSelection: networkProps.subnetSelection }),
+            ...(securityGroups.length > 0 && { securityGroups }),
+            buildEnvironment: { environmentVariables: pipelineEnvVars },
+        };
+    }
+}
+exports.PipelineBuilder = PipelineBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-builder.js","sourceRoot":"","sources":["../../src/pipeline/pipeline-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 { Duration, Tags } from 'aws-cdk-lib';\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport { PipelineNotificationEvents, PipelineType } from 'aws-cdk-lib/aws-codepipeline';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as targets from 'aws-cdk-lib/aws-events-targets';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport * as sns from 'aws-cdk-lib/aws-sns';\nimport { CodePipeline, type CodeBuildOptions } from 'aws-cdk-lib/pipelines';\nimport { Construct } from 'constructs';\nimport { PipelineConfiguration } from './pipeline-configuration';\nimport { PluginLookup } from './plugin-lookup';\nimport { SourceBuilder } from './source-builder';\nimport { StageBuilder } from './stage-builder';\nimport type { StageOptions, SynthOptions } from './step-types';\nimport { Config, CoreConstants } from '../config/app-config';\nimport { ArtifactManager } from '../core/artifact-manager';\nimport { UniqueId } from '../core/id-generator';\nimport { metadataForCodePipeline } from '../core/metadata-builder';\nimport { resolveNetwork } from '../core/network';\nimport type { CodeBuildDefaults } from '../core/network-types';\nimport { createCodeBuildStep } from '../core/pipeline-helpers';\nimport { MetadataKeys, TriggerType } from '../core/pipeline-types';\nimport type { MetaDataType } from '../core/pipeline-types';\nimport { resolveRole } from '../core/role';\nimport type { RoleConfig } from '../core/role-types';\nimport { resolveSecurityGroup } from '../core/security-group';\n\nconst PIPELINE_EVENT_MAP: Record<string, PipelineNotificationEvents> = {\n  FAILED: PipelineNotificationEvents.PIPELINE_EXECUTION_FAILED,\n  SUCCEEDED: PipelineNotificationEvents.PIPELINE_EXECUTION_SUCCEEDED,\n  STARTED: PipelineNotificationEvents.PIPELINE_EXECUTION_STARTED,\n  CANCELED: PipelineNotificationEvents.PIPELINE_EXECUTION_CANCELED,\n  SUPERSEDED: PipelineNotificationEvents.PIPELINE_EXECUTION_SUPERSEDED,\n};\n\nfunction parseNotificationEvents(value: unknown): string[] {\n  if (Array.isArray(value)) return value;\n  if (typeof value === 'string') return value.split(',').map(s => s.trim());\n  return ['FAILED', 'SUCCEEDED'];\n}\n\n/**\n * Configuration properties for the PipelineBuilder construct\n */\nexport interface BuilderProps {\n  /** Project identifier (will be sanitized to lowercase alphanumeric with underscores) */\n  readonly project: string;\n\n  /** Organization identifier (will be sanitized to lowercase alphanumeric with underscores) */\n  readonly organization: string;\n\n  /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */\n  readonly orgId?: string;\n\n  /** Pipeline database record ID — injected as PIPELINE_ID env var for autonomous synth */\n  readonly pipelineId?: string;\n\n  /** Optional custom pipeline name. Defaults to: {organization}-{project}-pipeline */\n  readonly pipelineName?: string;\n\n  /** Global metadata inherited by all pipeline steps */\n  readonly global?: MetaDataType;\n\n  /**\n   * Pipeline-level CodeBuild defaults applied to all CodeBuild actions\n   * (synth, self-mutation, asset publishing) via `codeBuildDefaults`.\n   */\n  readonly defaults?: CodeBuildDefaults;\n\n  /**\n   * Optional IAM role for the CodePipeline.\n   * When provided, resolves to a CDK IRole and is passed to the CodePipeline construct.\n   * When omitted, CDK auto-creates a role with the correct codepipeline.amazonaws.com principal.\n   */\n  readonly role?: RoleConfig;\n\n  /** Synthesis configuration including source and plugin details */\n  readonly synth: SynthOptions;\n\n  /**\n   * Optional pipeline stages, each containing one or more CodeBuild steps.\n   * Stages are added as waves to the CodePipeline after the synth step.\n   */\n  readonly stages?: StageOptions[];\n\n  /** Optional cron/rate expression for scheduled pipeline execution. */\n  readonly schedule?: string;\n\n  /** Custom tags applied to all pipeline resources. */\n  readonly tags?: Record<string, string>;\n}\n\n/**\n * CDK construct that creates and configures a CodePipeline for continuous deployment.\n *\n * Features:\n * - Multi-source support (S3, GitHub, CodeStar)\n * - Plugin-based build steps\n * - Metadata-driven configuration\n * - Automatic tagging\n * - Automatic sanitization of project and organization names\n *\n * @example\n * ```typescript\n * new PipelineBuilder(this, 'MyPipeline', {\n *   project: 'my-app',\n *   organization: 'my-org',\n *   synth: {\n *     source: {\n *       type: 'github',\n *       options: { repo: 'owner/repo', branch: 'main' }\n *     },\n *     plugin: { name: 'synth' }\n *   }\n * });\n * ```\n */\nexport class PipelineBuilder extends Construct {\n  public readonly pipeline: CodePipeline;\n  public readonly config: PipelineConfiguration;\n\n  constructor(scope: Construct, id: string, props: BuilderProps) {\n    super(scope, id);\n\n    // Use PipelineConfiguration for all business logic (validation, sanitization, metadata merging)\n    this.config = new PipelineConfiguration(props);\n\n    const serverConfig = Config.get('server');\n    const awsConfig = Config.get('aws');\n    const uniqueId = new UniqueId();\n    const pluginLookup = new PluginLookup(\n      this,\n      uniqueId.generate('plugin:lookup'),\n      {\n        organization: this.config.organization,\n        project: this.config.project,\n        platformUrl: serverConfig.platformUrl,\n        uniqueId,\n        orgId: props.orgId,\n        runtime: awsConfig.lambda.runtime,\n        timeout: awsConfig.lambda.timeout,\n        reservedConcurrentExecutions: awsConfig.lambda.reservedConcurrentExecutions,\n      },\n    );\n\n    // Create source and build step\n    const sourceBuilder = new SourceBuilder(this, this.config);\n    const source = sourceBuilder.create(uniqueId);\n\n    // RESOLVED_SYNTH_PLUGIN=true (CodePipeline): resolve plugin via custom resource Lambda\n    // RESOLVED_SYNTH_PLUGIN=false (default/CLI): use fallback with pipeline-manager synth commands\n    const plugin = awsConfig.resolvedSynthPlugin\n      ? pluginLookup.plugin(this.config.plugin)\n      : pluginLookup.fallbackSynth();\n    const defaultComputeType = awsConfig.codeBuild.computeType;\n    const artifactManager = new ArtifactManager();\n    const synthAlias = this.config.plugin.alias ?? this.config.plugin.name;\n    const synth = createCodeBuildStep({\n      ...this.config.synthCustomization,\n      id: uniqueId.generate('cdk:synth'),\n      uniqueId,\n      plugin,\n      input: source,\n      metadata: this.config.metadata.merged,\n      network: this.config.network,\n      scope: this,\n      defaultComputeType,\n      artifactManager,\n      stageName: 'no-stage',\n      stageAlias: 'no-stage-alias',\n      pluginAlias: `${synthAlias}-alias`,\n      orgId: props.orgId,\n    });\n\n    // Resolve pipeline-level defaults into codeBuildDefaults\n    // Build the per-org platform secret name for CodeBuild env vars\n    const platformSecretName = props.orgId\n      ? CoreConstants.secretPath(props.orgId, 'platform')\n      : undefined;\n\n    const codeBuildDefaults = this.resolveDefaults(this.config.defaults, uniqueId, props.pipelineId, platformSecretName, serverConfig.platformUrl);\n\n    // Resolve IAM role if explicitly provided; otherwise let CDK auto-create\n    // the pipeline role with the correct codepipeline.amazonaws.com principal.\n    if (props.role?.type === 'codeBuildDefault') {\n      createLogger('PipelineBuilder').warn(\n        'codeBuildDefault role type uses codebuild.amazonaws.com trust principal — ' +\n        'this is not suitable as the pipeline-level role. Consider using roleArn/roleName ' +\n        'or omitting the role to let CDK auto-create one with codepipeline.amazonaws.com.',\n      );\n    }\n    const role = props.role\n      ? resolveRole(this, uniqueId, props.role)\n      : undefined;\n\n    // Create CodePipeline construct\n    this.pipeline = new CodePipeline(this, uniqueId.generate('pipelines:codepipeline'), {\n      ...(codeBuildDefaults && { codeBuildDefaults }),\n      ...(role && { role }),\n      pipelineType: PipelineType.V2,\n      pipelineName: this.config.pipelineName,\n      synth,\n      ...metadataForCodePipeline(this.config.metadata.merged),\n    });\n\n    // Add stages as waves via StageBuilder\n    if (props.stages) {\n      const stageBuilder = new StageBuilder({\n        scope: this,\n        pluginLookup,\n        uniqueId,\n        globalMetadata: this.config.metadata.merged,\n        defaultComputeType,\n        artifactManager,\n        orgId: props.orgId,\n      });\n      stageBuilder.addStages(this.pipeline, props.stages);\n    }\n\n    // ── Tags ──\n    Tags.of(this.pipeline).add('project', this.config.project);\n    Tags.of(this.pipeline).add('organization', this.config.organization);\n    if (props.tags) {\n      for (const [key, value] of Object.entries(props.tags)) {\n        Tags.of(this.pipeline).add(key, value);\n      }\n    }\n\n    // Build the internal pipeline before accessing its properties\n    this.pipeline.buildPipeline();\n    const cdkPipeline = this.pipeline.pipeline;\n    const meta = this.config.metadata.merged;\n\n    // ── SNS Notifications ──\n    const notificationTopicArn = meta[MetadataKeys.NOTIFICATION_TOPIC_ARN];\n    if (typeof notificationTopicArn === 'string') {\n      const topic = sns.Topic.fromTopicArn(this, 'NotificationTopic', notificationTopicArn);\n      const notificationEvents = parseNotificationEvents(meta[MetadataKeys.NOTIFICATION_EVENTS])\n        .map(e => PIPELINE_EVENT_MAP[e.toUpperCase()])\n        .filter(Boolean);\n      if (notificationEvents.length > 0) {\n        cdkPipeline.notifyOn('PipelineNotification', topic, { events: notificationEvents });\n      }\n    }\n\n    // ── Scheduled Execution ──\n    if (props.synth.source.options?.trigger === TriggerType.SCHEDULE || props.schedule) {\n      const expr = props.schedule || (props.synth.source.options as { schedule?: string })?.schedule || 'rate(1 day)';\n      new events.Rule(this, 'ScheduleRule', {\n        schedule: events.Schedule.expression(expr),\n        targets: [new targets.CodePipeline(cdkPipeline)],\n      });\n    }\n\n    // ── Execution Event Tracking (forward pipeline state changes to SNS) ──\n    if (meta[MetadataKeys.ENABLE_EXECUTION_EVENTS] && typeof notificationTopicArn === 'string') {\n      new events.Rule(this, 'ExecutionEventRule', {\n        eventPattern: {\n          source: ['aws.codepipeline'],\n          detailType: ['CodePipeline Pipeline Execution State Change'],\n          resources: [cdkPipeline.pipelineArn],\n        },\n        targets: [new targets.SnsTopic(\n          sns.Topic.fromTopicArn(this, 'ExecutionEventTopic', notificationTopicArn),\n        )],\n      });\n    }\n\n    // ── Artifact Encryption (KMS key) ──\n    const kmsKeyArn = this.config.metadata.merged[MetadataKeys.KMS_KEY_ARN];\n    if (typeof kmsKeyArn === 'string') {\n      const key = kms.Key.fromKeyArn(this, 'ArtifactKey', kmsKeyArn);\n      Tags.of(key).add('pipeline', this.config.pipelineName);\n    }\n\n    // ── Pipeline Metrics & Alarms ──\n    const enableMetrics = this.config.metadata.merged[MetadataKeys.ENABLE_METRICS];\n    if (enableMetrics) {\n      new cloudwatch.Alarm(this, 'PipelineFailureAlarm', {\n        metric: new cloudwatch.Metric({\n          namespace: 'AWS/CodePipeline',\n          metricName: 'FailedPipelineExecutionCount',\n          dimensionsMap: { PipelineName: this.config.pipelineName },\n          statistic: 'Sum',\n          period: Duration.minutes(5),\n        }),\n        threshold: 1,\n        evaluationPeriods: 1,\n        alarmDescription: `Pipeline ${this.config.pipelineName} execution failed`,\n        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n      });\n    }\n  }\n\n  /**\n   * Resolves CodeBuildDefaults into the shape expected by CDK's codeBuildDefaults.\n   * Combines network config, security groups, and pipeline-level environment variables\n   * (PIPELINE_ID, EXECUTION_ID, PLATFORM_BASE_URL) available to all CodeBuild actions.\n   */\n  private resolveDefaults(\n    defaults: CodeBuildDefaults | undefined,\n    id: UniqueId,\n    pipelineId: string | undefined,\n    platformSecretName: string | undefined,\n    platformUrl: string,\n  ): CodeBuildOptions | undefined {\n    const networkProps = defaults?.network\n      ? resolveNetwork(this, id, defaults.network)\n      : undefined;\n\n    const standaloneSecurityGroups = defaults?.securityGroups\n      ? resolveSecurityGroup(this, id, defaults.securityGroups)\n      : undefined;\n\n    // Pipeline-level env vars available to all CodeBuild actions\n    // Note: #{codepipeline.*} resolved variables must go through CodeBuildStep.env\n    // (action-level), not buildEnvironment.environmentVariables (project-level).\n    const pipelineEnvVars: Record<string, { value: string }> = {\n      PLATFORM_BASE_URL: { value: platformUrl },\n      ...(pipelineId && { PIPELINE_ID: { value: pipelineId } }),\n      ...(platformSecretName && { PLATFORM_SECRET_NAME: { value: platformSecretName } }),\n      // Enable plugin resolution via custom resource Lambda inside CodePipeline\n      RESOLVED_SYNTH_PLUGIN: { value: 'true' },\n      // Propagate TLS verification setting so all CodeBuild steps can reach\n      // the platform API when using self-signed certificates\n      ...(process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0' && {\n        NODE_TLS_REJECT_UNAUTHORIZED: { value: '0' },\n      }),\n    };\n\n    const securityGroups = [\n      ...(networkProps?.securityGroups ?? []),\n      ...(standaloneSecurityGroups ?? []),\n    ];\n\n    return {\n      ...(networkProps && { vpc: networkProps.vpc, subnetSelection: networkProps.subnetSelection }),\n      ...(securityGroups.length > 0 && { securityGroups }),\n      buildEnvironment: { environmentVariables: pipelineEnvVars },\n    };\n  }\n}\n"]}

package/lib/pipeline/pipeline-configuration.d.ts

@@ -0,0 +1,72 @@
+import type { BuilderProps } from './pipeline-builder';
+import type { CodeCommitOptions, CodeStarOptions, GitHubOptions, S3Options } from './source-types';
+import type { PluginOptions, StageOptions, StepCustomization } from './step-types';
+import type { CodeBuildDefaults, NetworkConfig } from '../core/network-types';
+import type { MetaDataType, SourceType } from '../core/pipeline-types';
+/**
+ * Validated and processed pipeline configuration (business logic layer).
+ * This class handles all non-CDK logic: validation, sanitization, and metadata merging.
+ * It can be tested independently without CDK dependencies.
+ *
+ * ## Metadata merge chain (last wins)
+ *
+ * 1. `BuilderProps.global` — base metadata inherited by all steps
+ * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata
+ * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata
+ * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)
+ * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls
+ *
+ * Steps 1–3 are merged here into `this.metadata.merged`.
+ * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.
+ * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.
+ */
+export declare class PipelineConfiguration {
+    readonly project: string;
+    readonly organization: string;
+    readonly pipelineName: string;
+    readonly metadata: {
+        readonly global: MetaDataType;
+        readonly synth: MetaDataType;
+        readonly merged: MetaDataType;
+    };
+    readonly source: SourceType;
+    readonly plugin: PluginOptions;
+    readonly network: NetworkConfig | undefined;
+    readonly defaults: CodeBuildDefaults | undefined;
+    readonly synthCustomization: StepCustomization;
+    readonly stages: StageOptions[] | undefined;
+    constructor(props: BuilderProps);
+    /**
+     * Validates BuilderProps to ensure all required fields are present.
+     * Throws an error with detailed messages if validation fails.
+     */
+    private validateProps;
+    /**
+     * Extracts S3 source options with defaults applied.
+     *
+     * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `s3`
+     */
+    getS3Options(): Required<Pick<S3Options, 'bucketName' | 'objectKey' | 'trigger'>> & Omit<S3Options, 'bucketName' | 'objectKey' | 'trigger'>;
+    /**
+     * Extracts GitHub source options with defaults applied.
+     *
+     * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `github`
+     */
+    getGitHubOptions(): Required<Pick<GitHubOptions, 'repo' | 'branch' | 'trigger'>> & Omit<GitHubOptions, 'repo' | 'branch' | 'trigger'>;
+    /**
+     * Extracts CodeStar source options with defaults applied.
+     *
+     * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`
+     * @throws {Error} If the configured source type is not `codestar`
+     */
+    getCodeStarOptions(): Required<Pick<CodeStarOptions, 'repo' | 'branch' | 'trigger' | 'codeBuildCloneOutput' | 'connectionArn'>>;
+    /**
+     * Extracts CodeCommit source options with defaults applied.
+     *
+     * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `codecommit`
+     */
+    getCodeCommitOptions(): Required<Pick<CodeCommitOptions, 'repositoryName' | 'branch' | 'trigger'>>;
+}