@pipeline-builder/pipeline-core 0.0.1

package/lib/pipeline/stage-builder.js

@@ -0,0 +1,129 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+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 { merge, resolveFailureBehavior } from '../core/metadata-helpers.js';
+import { createCodeBuildStep } from '../core/pipeline-helpers.js';
+/**
+ * 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 class StageBuilder {
+    scope;
+    pluginLookup;
+    uniqueId;
+    globalMetadata;
+    defaultComputeType;
+    artifactManager;
+    orgId;
+    pipelineScope;
+    constructor(props) {
+        this.scope = props.scope;
+        this.pluginLookup = props.pluginLookup;
+        this.uniqueId = props.uniqueId;
+        this.globalMetadata = props.globalMetadata;
+        this.defaultComputeType = props.defaultComputeType;
+        this.artifactManager = props.artifactManager;
+        this.orgId = props.orgId;
+        this.pipelineScope = props.pipelineScope;
+    }
+    /**
+     * Resolves a stage's plugin-based step configs into CodeBuild steps
+     * and adds them as a wave to the pipeline.
+     */
+    addStage(pipeline, stage) {
+        const stageAlias = stage.alias ?? `${stage.stageName}-alias`;
+        const preSteps = stage.steps
+            .filter(s => (s.position ?? 'pre') === 'pre')
+            .map(s => this.resolveStep(s, stage.stageName, stageAlias));
+        const postSteps = stage.steps
+            .filter(s => s.position === 'post')
+            .map(s => this.resolveStep(s, stage.stageName, stageAlias));
+        pipeline.addWave(stageAlias, {
+            ...(preSteps.length > 0 && { pre: preSteps }),
+            ...(postSteps.length > 0 && { post: postSteps }),
+        });
+    }
+    resolveStep(stepConfig, stageName, stageAlias) {
+        const plugin = this.pluginLookup.plugin(stepConfig.plugin);
+        // Per-step plugin config lives on the plugin reference (`plugin.metadata` —
+        // e.g. JAVA_VERSION/KOTLIN_VERSION/computetype overrides). pluginLookup.plugin()
+        // returns the resolved CATALOG plugin and drops the reference metadata in the
+        // pre-resolved path, so merge it here too — otherwise per-step overrides are
+        // silently ignored and the build falls back to plugin defaults.
+        // Order (last wins): global < plugin-ref metadata < step-level metadata.
+        const stepMetadata = merge(this.globalMetadata, stepConfig.plugin.metadata ?? {}, stepConfig.metadata ?? {});
+        const pluginAlias = stepConfig.plugin.alias ?? stepConfig.plugin.name;
+        if (stepConfig.inputArtifact && !this.artifactManager) {
+            throw new Error(`Step "${pluginAlias}" requires inputArtifact but no artifactManager is configured.`);
+        }
+        if (stepConfig.additionalInputArtifacts?.length && !this.artifactManager) {
+            throw new Error(`Step "${pluginAlias}" requires additionalInputArtifacts but no artifactManager is configured.`);
+        }
+        const input = stepConfig.inputArtifact && this.artifactManager
+            ? this.artifactManager.getOutput(stepConfig.inputArtifact)
+            : undefined;
+        const additionalInputs = stepConfig.additionalInputArtifacts?.length && this.artifactManager
+            ? Object.fromEntries(stepConfig.additionalInputArtifacts.map(({ artifact, directory }) => [
+                directory || artifact.outputDirectory,
+                this.artifactManager.getOutput(artifact),
+            ]))
+            : undefined;
+        return createCodeBuildStep({
+            id: this.uniqueId.generate(`stage:${stageAlias}:${pluginAlias}`),
+            uniqueId: this.uniqueId,
+            plugin,
+            metadata: stepMetadata,
+            network: stepConfig.network,
+            scope: this.scope,
+            defaultComputeType: this.defaultComputeType,
+            input,
+            additionalInputs,
+            artifactManager: this.artifactManager,
+            stageName,
+            stageAlias,
+            pluginAlias,
+            preInstallCommands: stepConfig.preInstallCommands,
+            postInstallCommands: stepConfig.postInstallCommands,
+            preCommands: stepConfig.preCommands,
+            postCommands: stepConfig.postCommands,
+            env: stepConfig.env,
+            timeout: stepConfig.timeout ?? plugin.timeout ?? undefined,
+            // A scan/security-category plugin can never be downgraded from 'fail' — see resolveFailureBehavior.
+            failureBehavior: resolveFailureBehavior(plugin.category, stepConfig.failureBehavior ?? plugin.failureBehavior),
+            orgId: this.orgId,
+            pipelineScope: this.pipelineScope,
+        });
+    }
+    /**
+     * Resolves and adds multiple stages as waves to the pipeline, in order.
+     */
+    addStages(pipeline, stages) {
+        for (const stage of stages) {
+            this.addStage(pipeline, stage);
+        }
+    }
+}
+//# 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 { 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"]}

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

@@ -0,0 +1,222 @@
+import type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';
+import type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';
+import type { IFileSetProducer } from 'aws-cdk-lib/pipelines';
+import type { Construct } from 'constructs';
+import type { SourceType } from './source-types.js';
+import type { ArtifactKey, ArtifactManager } from '../core/artifact-manager.js';
+import type { UniqueId } from '../core/id-generator.js';
+import type { NetworkConfig } from '../core/network-types.js';
+import type { MetaDataType } from '../core/pipeline-types.js';
+/**
+ * Options for selecting and configuring a plugin
+ */
+export interface PluginOptions {
+    /**
+     * Name of the plugin to use
+     * Must match a registered plugin in the database
+     */
+    readonly name: string;
+    /**
+     * Optional alias for the plugin instance
+     * Useful when using the same plugin multiple times with different configurations
+     */
+    readonly alias?: string;
+    /**
+     * Optional filter criteria for plugin selection
+     * Can be used to select specific plugin versions or variants
+     */
+    readonly filter?: PluginFilter;
+    /**
+     * Additional metadata to merge with plugin's default metadata
+     * This metadata will be available to the plugin during execution
+     */
+    readonly metadata?: MetaDataType;
+}
+/**
+ * Synthesis step configuration combining source and plugin.
+ * Extends StepCustomization to support injecting custom commands and env vars
+ * into the synth CodeBuild step (same hooks available as stage steps).
+ */
+export interface SynthOptions extends StepCustomization {
+    /**
+     * Source configuration (S3, GitHub, or CodeStar)
+     */
+    readonly source: SourceType;
+    /**
+     * Plugin to use for synthesis
+     */
+    readonly plugin: PluginOptions;
+    /**
+     * Additional metadata for the synthesis step
+     * This will be merged with global metadata and plugin metadata
+     */
+    readonly metadata?: MetaDataType;
+    /**
+     * Step-level network configuration applied only to the synth CodeBuild step.
+     * Overrides the pipeline-level `defaults.network` when both are provided.
+     */
+    readonly network?: NetworkConfig;
+}
+/**
+ * Per-step customization options for commands and environment variables.
+ * Custom commands are injected before/after the plugin's commands.
+ * Custom env vars are merged on top of the plugin's defaults.
+ */
+export interface StepCustomization {
+    /** Commands to run before the plugin's install commands */
+    readonly preInstallCommands?: string[];
+    /** Commands to run after the plugin's install commands */
+    readonly postInstallCommands?: string[];
+    /** Commands to run before the plugin's build commands */
+    readonly preCommands?: string[];
+    /** Commands to run after the plugin's build commands */
+    readonly postCommands?: string[];
+    /** Custom environment variables merged on top of the plugin's env */
+    readonly env?: Record<string, string>;
+}
+/**
+ * An additional input artifact with an optional mount directory.
+ * When directory is omitted, defaults to the artifact's outputDirectory.
+ */
+export interface AdditionalInputArtifactConfig {
+    /** Artifact key identifying the source step's output */
+    readonly artifact: ArtifactKey;
+    /** Directory to mount the input at. Defaults to artifact.outputDirectory when omitted. */
+    readonly directory?: string;
+}
+/**
+ * Configuration for a single step within a pipeline stage.
+ * Uses PluginOptions for name-based plugin selection (resolved at build time).
+ */
+export interface StageStepOptions extends StepCustomization {
+    /** Plugin to use for this step */
+    readonly plugin: PluginOptions;
+    /** Step-level metadata merged with stage and global metadata */
+    readonly metadata?: MetaDataType;
+    /** Optional network configuration for this step's CodeBuild action */
+    readonly network?: NetworkConfig;
+    /**
+     * CodeBuild timeout in minutes.
+     * @default 60 (AWS CodeBuild default)
+     */
+    readonly timeout?: number;
+    /**
+     * Position of this step within the pipeline wave.
+     * - 'pre': Runs before the stage deployment (default)
+     * - 'post': Runs after the stage deployment
+     * @default 'pre'
+     */
+    readonly position?: 'pre' | 'post';
+    /** Artifact key for this step's primary input (resolved via ArtifactManager) */
+    readonly inputArtifact?: ArtifactKey;
+    /** Additional input artifacts for this step. Each entry specifies an artifact and an optional mount directory. */
+    readonly additionalInputArtifacts?: AdditionalInputArtifactConfig[];
+    /** Override the plugin's failure behavior for this step. */
+    readonly failureBehavior?: 'fail' | 'warn' | 'ignore';
+}
+/**
+ * A pipeline stage containing one or more build steps.
+ * Each stage maps to a CDK Pipeline wave, with steps executing within the wave.
+ */
+export interface StageOptions {
+    /** Display name for this stage */
+    readonly stageName: string;
+    /** Optional alias used for wave/construct ID generation. Defaults to stageName. */
+    readonly alias?: string;
+    /** Build steps to execute within this stage */
+    readonly steps: StageStepOptions[];
+    /**
+     * Deploy environment this stage targets (e.g. `production`, `staging`).
+     * Declaring it marks the stage as a **deploy** for DORA metrics: pipeline-core
+     * lists every such stage in the `pb.deploys` tag as `<stageName>:<environment>`
+     * so the events Lambda can attribute deployments per environment. Omit it and
+     * the stage is not treated as a deploy.
+     */
+    readonly environment?: string;
+}
+/**
+ * Options for creating a CodeBuild step in the pipeline
+ */
+export interface CodeBuildStepOptions extends StepCustomization {
+    /**
+     * Unique identifier for this CodeBuild step
+     * Should be descriptive and unique within the pipeline
+     * @example 'my-org-my-project-synth'
+     */
+    readonly id: string;
+    /**
+     * UniqueId instance for generating unique construct IDs
+     * Used for network resource lookups (VPC, subnets, security groups)
+     */
+    readonly uniqueId: UniqueId;
+    /**
+     * Plugin configuration from the database
+     * Contains all the plugin's spec data and runtime information
+     */
+    readonly plugin: Plugin;
+    /**
+     * CDK scope used to create constructs (VPC/subnet/security-group lookups).
+     */
+    readonly scope: Construct;
+    /**
+     * Input source for this step
+     * Typically the output from a previous step or the pipeline source
+     */
+    readonly input?: IFileSetProducer;
+    /**
+     * Additional metadata to merge with plugin metadata
+     * Will override conflicting keys from plugin metadata
+     */
+    readonly metadata?: MetaDataType;
+    /**
+     * Optional network configuration for the CodeBuild step.
+     * When provided, resolves VPC, subnet selection, and security groups
+     * so the build runs inside the specified network.
+     */
+    readonly network?: NetworkConfig;
+    /**
+     * Fallback CodeBuild compute type when the plugin doesn't specify one.
+     * @default ComputeType.SMALL
+     */
+    readonly defaultComputeType?: CdkComputeType;
+    /**
+     * CodeBuild timeout in minutes.
+     * @default 60 (AWS CodeBuild default)
+     */
+    readonly timeout?: number;
+    /** Additional inputs mapped by directory path (resolved FileSets) */
+    readonly additionalInputs?: Record<string, IFileSetProducer>;
+    /**
+     * Optional artifact manager for tracking build outputs
+     * When provided and primaryOutputDirectory is set, the step will be registered
+     */
+    readonly artifactManager?: ArtifactManager;
+    /**
+     * Stage name for artifact key generation
+     */
+    readonly stageName?: string;
+    /**
+     * Stage alias for artifact key generation
+     */
+    readonly stageAlias?: string;
+    /**
+     * Plugin alias for artifact key generation
+     */
+    readonly pluginAlias?: string;
+    /**
+     * Failure behavior for this step's build commands.
+     * Applied at shell level: 'fail' = default, 'warn' = log + continue, 'ignore' = || true.
+     */
+    readonly failureBehavior?: 'fail' | 'warn' | 'ignore';
+    /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */
+    readonly orgId?: string;
+    /**
+     * Pipeline-level config used as the `pipeline.*` scope when resolving
+     * template tokens inside plugin specs. Required — every `{{ pipeline.* }}`
+     * reference in a plugin spec is evaluated against this object at synth time.
+     *
+     * Callers constructing a step directly must provide the pipeline identity
+     * + metadata + vars so template resolution is never silently skipped.
+     */
+    readonly pipelineScope: Record<string, unknown>;
+}

package/lib/pipeline/step-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":"step-types.js","sourceRoot":"","sources":["../../src/pipeline/step-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 { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { ComputeType as CdkComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport type { IFileSetProducer } from 'aws-cdk-lib/pipelines';\nimport type { Construct } from 'constructs';\nimport type { SourceType } from './source-types.js';\nimport type { ArtifactKey, ArtifactManager } from '../core/artifact-manager.js';\nimport type { UniqueId } from '../core/id-generator.js';\nimport type { NetworkConfig } from '../core/network-types.js';\nimport type { MetaDataType } from '../core/pipeline-types.js';\n\n/**\n * Options for selecting and configuring a plugin\n */\nexport interface PluginOptions {\n  /**\n   * Name of the plugin to use\n   * Must match a registered plugin in the database\n   */\n  readonly name: string;\n\n  /**\n   * Optional alias for the plugin instance\n   * Useful when using the same plugin multiple times with different configurations\n   */\n  readonly alias?: string;\n\n  /**\n   * Optional filter criteria for plugin selection\n   * Can be used to select specific plugin versions or variants\n   */\n  readonly filter?: PluginFilter;\n\n  /**\n   * Additional metadata to merge with plugin's default metadata\n   * This metadata will be available to the plugin during execution\n   */\n  readonly metadata?: MetaDataType;\n}\n\n/**\n * Synthesis step configuration combining source and plugin.\n * Extends StepCustomization to support injecting custom commands and env vars\n * into the synth CodeBuild step (same hooks available as stage steps).\n */\nexport interface SynthOptions extends StepCustomization {\n  /**\n   * Source configuration (S3, GitHub, or CodeStar)\n   */\n  readonly source: SourceType;\n\n  /**\n   * Plugin to use for synthesis\n   */\n  readonly plugin: PluginOptions;\n\n  /**\n   * Additional metadata for the synthesis step\n   * This will be merged with global metadata and plugin metadata\n   */\n  readonly metadata?: MetaDataType;\n\n  /**\n   * Step-level network configuration applied only to the synth CodeBuild step.\n   * Overrides the pipeline-level `defaults.network` when both are provided.\n   */\n  readonly network?: NetworkConfig;\n}\n\n/**\n * Per-step customization options for commands and environment variables.\n * Custom commands are injected before/after the plugin's commands.\n * Custom env vars are merged on top of the plugin's defaults.\n */\nexport interface StepCustomization {\n  /** Commands to run before the plugin's install commands */\n  readonly preInstallCommands?: string[];\n\n  /** Commands to run after the plugin's install commands */\n  readonly postInstallCommands?: string[];\n\n  /** Commands to run before the plugin's build commands */\n  readonly preCommands?: string[];\n\n  /** Commands to run after the plugin's build commands */\n  readonly postCommands?: string[];\n\n  /** Custom environment variables merged on top of the plugin's env */\n  readonly env?: Record<string, string>;\n}\n\n/**\n * An additional input artifact with an optional mount directory.\n * When directory is omitted, defaults to the artifact's outputDirectory.\n */\nexport interface AdditionalInputArtifactConfig {\n  /** Artifact key identifying the source step's output */\n  readonly artifact: ArtifactKey;\n\n  /** Directory to mount the input at. Defaults to artifact.outputDirectory when omitted. */\n  readonly directory?: string;\n}\n\n/**\n * Configuration for a single step within a pipeline stage.\n * Uses PluginOptions for name-based plugin selection (resolved at build time).\n */\nexport interface StageStepOptions extends StepCustomization {\n  /** Plugin to use for this step */\n  readonly plugin: PluginOptions;\n\n  /** Step-level metadata merged with stage and global metadata */\n  readonly metadata?: MetaDataType;\n\n  /** Optional network configuration for this step's CodeBuild action */\n  readonly network?: NetworkConfig;\n\n  /**\n   * CodeBuild timeout in minutes.\n   * @default 60 (AWS CodeBuild default)\n   */\n  readonly timeout?: number;\n\n  /**\n   * Position of this step within the pipeline wave.\n   * - 'pre': Runs before the stage deployment (default)\n   * - 'post': Runs after the stage deployment\n   * @default 'pre'\n   */\n  readonly position?: 'pre' | 'post';\n\n  /** Artifact key for this step's primary input (resolved via ArtifactManager) */\n  readonly inputArtifact?: ArtifactKey;\n\n  /** Additional input artifacts for this step. Each entry specifies an artifact and an optional mount directory. */\n  readonly additionalInputArtifacts?: AdditionalInputArtifactConfig[];\n\n  /** Override the plugin's failure behavior for this step. */\n  readonly failureBehavior?: 'fail' | 'warn' | 'ignore';\n}\n\n/**\n * A pipeline stage containing one or more build steps.\n * Each stage maps to a CDK Pipeline wave, with steps executing within the wave.\n */\nexport interface StageOptions {\n  /** Display name for this stage */\n  readonly stageName: string;\n\n  /** Optional alias used for wave/construct ID generation. Defaults to stageName. */\n  readonly alias?: string;\n\n  /** Build steps to execute within this stage */\n  readonly steps: StageStepOptions[];\n\n  /**\n   * Deploy environment this stage targets (e.g. `production`, `staging`).\n   * Declaring it marks the stage as a **deploy** for DORA metrics: pipeline-core\n   * lists every such stage in the `pb.deploys` tag as `<stageName>:<environment>`\n   * so the events Lambda can attribute deployments per environment. Omit it and\n   * the stage is not treated as a deploy.\n   */\n  readonly environment?: string;\n}\n\n/**\n * Options for creating a CodeBuild step in the pipeline\n */\nexport interface CodeBuildStepOptions extends StepCustomization {\n  /**\n   * Unique identifier for this CodeBuild step\n   * Should be descriptive and unique within the pipeline\n   * @example 'my-org-my-project-synth'\n   */\n  readonly id: string;\n\n  /**\n   * UniqueId instance for generating unique construct IDs\n   * Used for network resource lookups (VPC, subnets, security groups)\n   */\n  readonly uniqueId: UniqueId;\n\n  /**\n   * Plugin configuration from the database\n   * Contains all the plugin's spec data and runtime information\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * CDK scope used to create constructs (VPC/subnet/security-group lookups).\n   */\n  readonly scope: Construct;\n\n  /**\n   * Input source for this step\n   * Typically the output from a previous step or the pipeline source\n   */\n  readonly input?: IFileSetProducer;\n\n  /**\n   * Additional metadata to merge with plugin metadata\n   * Will override conflicting keys from plugin metadata\n   */\n  readonly metadata?: MetaDataType;\n\n  /**\n   * Optional network configuration for the CodeBuild step.\n   * When provided, resolves VPC, subnet selection, and security groups\n   * so the build runs inside the specified network.\n   */\n  readonly network?: NetworkConfig;\n\n  /**\n   * Fallback CodeBuild compute type when the plugin doesn't specify one.\n   * @default ComputeType.SMALL\n   */\n  readonly defaultComputeType?: CdkComputeType;\n\n  /**\n   * CodeBuild timeout in minutes.\n   * @default 60 (AWS CodeBuild default)\n   */\n  readonly timeout?: number;\n\n  /** Additional inputs mapped by directory path (resolved FileSets) */\n  readonly additionalInputs?: Record<string, IFileSetProducer>;\n\n  /**\n   * Optional artifact manager for tracking build outputs\n   * When provided and primaryOutputDirectory is set, the step will be registered\n   */\n  readonly artifactManager?: ArtifactManager;\n\n  /**\n   * Stage name for artifact key generation\n   */\n  readonly stageName?: string;\n\n  /**\n   * Stage alias for artifact key generation\n   */\n  readonly stageAlias?: string;\n\n  /**\n   * Plugin alias for artifact key generation\n   */\n  readonly pluginAlias?: string;\n\n  /**\n   * Failure behavior for this step's build commands.\n   * Applied at shell level: 'fail' = default, 'warn' = log + continue, 'ignore' = || true.\n   */\n  readonly failureBehavior?: 'fail' | 'warn' | 'ignore';\n\n  /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */\n  readonly orgId?: string;\n\n  /**\n   * Pipeline-level config used as the `pipeline.*` scope when resolving\n   * template tokens inside plugin specs. Required — every `{{ pipeline.* }}`\n   * reference in a plugin spec is evaluated against this object at synth time.\n   *\n   * Callers constructing a step directly must provide the pipeline identity\n   * + metadata + vars so template resolution is never silently skipped.\n   */\n  readonly pipelineScope: Record<string, unknown>;\n}\n"]}

package/lib/template/evaluator.d.ts

@@ -0,0 +1,42 @@
+import { ErrorCode } from '@pipeline-builder/api-core';
+import type { SourcePosition, Token } from './tokenizer.js';
+export type Scope = Record<string, unknown>;
+export interface EvalError {
+    code: ErrorCode;
+    message: string;
+    field?: string;
+    path?: string;
+    pos?: SourcePosition;
+}
+/**
+ * Look up a dot-separated path inside a scope object. Returns `undefined`
+ * if any intermediate segment is missing or not an object.
+ *
+ * Only OWN enumerable-or-not-inherited properties are traversed: a segment is
+ * resolved via `Object.prototype.hasOwnProperty.call` so inherited members of
+ * the prototype chain (`constructor`, `toString`, `valueOf`, `hasOwnProperty`,
+ * the `__proto__` accessor, …) never resolve — they return `undefined` and thus
+ * fall through to the caller's normal unknown-path handling (a `| default:`
+ * fallback or a `TEMPLATE_UNKNOWN_PATH` error). Applied at every level,
+ * including the root segment, this also makes the scope's own top-level keys
+ * the effective root allow-list, so an unknown/prototype root is rejected even
+ * on the synth path that skips `validateTemplates`.
+ */
+export declare function lookupPath(scope: Scope, path: string[]): unknown;
+/**
+ * Resolve a token stream against a scope. Returns the resolved string.
+ * Throws `EvalError` when an unresolved path has no default filter.
+ *
+ * Coercion filters (`| number`, `| bool`, `| json`) only take effect
+ * when the template expression is the entire field — e.g.
+ * `replicas: "{{ vars.count | number }}"` yields `3` (number) while
+ * `replicas: "count={{ vars.count | number }}"` yields `"count=3"`
+ * (string, because the template is embedded in surrounding literals).
+ * Mixed-literal fields always return a string.
+ */
+export declare function resolve(tokens: Token[], scope: Scope, field?: string): string | number | boolean | null | unknown[] | Record<string, unknown>;
+/**
+ * Extract dependency paths from a token stream. Used by the topological
+ * sort pass to order resolution of self-referencing documents.
+ */
+export declare function dependencies(tokens: Token[]): string[];

package/lib/template/evaluator.js

@@ -0,0 +1,164 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { ErrorCode } from '@pipeline-builder/api-core';
+const RESERVED_ROOT_PATHS = new Set(['secrets']);
+/**
+ * Look up a dot-separated path inside a scope object. Returns `undefined`
+ * if any intermediate segment is missing or not an object.
+ *
+ * Only OWN enumerable-or-not-inherited properties are traversed: a segment is
+ * resolved via `Object.prototype.hasOwnProperty.call` so inherited members of
+ * the prototype chain (`constructor`, `toString`, `valueOf`, `hasOwnProperty`,
+ * the `__proto__` accessor, …) never resolve — they return `undefined` and thus
+ * fall through to the caller's normal unknown-path handling (a `| default:`
+ * fallback or a `TEMPLATE_UNKNOWN_PATH` error). Applied at every level,
+ * including the root segment, this also makes the scope's own top-level keys
+ * the effective root allow-list, so an unknown/prototype root is rejected even
+ * on the synth path that skips `validateTemplates`.
+ */
+export function lookupPath(scope, path) {
+    let cur = scope;
+    for (const segment of path) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        if (!Object.prototype.hasOwnProperty.call(cur, segment))
+            return undefined;
+        cur = cur[segment];
+    }
+    return cur;
+}
+/**
+ * Resolve a token stream against a scope. Returns the resolved string.
+ * Throws `EvalError` when an unresolved path has no default filter.
+ *
+ * Coercion filters (`| number`, `| bool`, `| json`) only take effect
+ * when the template expression is the entire field — e.g.
+ * `replicas: "{{ vars.count | number }}"` yields `3` (number) while
+ * `replicas: "count={{ vars.count | number }}"` yields `"count=3"`
+ * (string, because the template is embedded in surrounding literals).
+ * Mixed-literal fields always return a string.
+ */
+export function resolve(tokens, scope, field) {
+    // Whole-field coercion shortcut: only apply coercion when the entire field
+    // is a single expression (no surrounding literal text).
+    if (tokens.length === 1 && tokens[0].kind === 'expr' && tokens[0].coerce) {
+        const tok = tokens[0];
+        const raw = resolveOne(tok, scope, field);
+        return applyCoercion(raw, tok.coerce, tok, field);
+    }
+    const parts = [];
+    for (const tok of tokens) {
+        if (tok.kind === 'literal') {
+            parts.push(tok.value);
+            continue;
+        }
+        const raw = resolveOne(tok, scope, field);
+        parts.push(typeof raw === 'string' ? raw : String(raw));
+    }
+    return parts.join('');
+}
+/** Resolve a single expression token to its string form (no coercion). */
+function resolveOne(tok, scope, field) {
+    const root = tok.path[0];
+    if (RESERVED_ROOT_PATHS.has(root)) {
+        throw makeEvalError({
+            code: ErrorCode.TEMPLATE_SECRETS_RESERVED,
+            message: `'${root}' is a reserved scope — use the plugin's 'secrets:' field instead`,
+            field,
+            path: tok.path.join('.'),
+            pos: tok.pos,
+        });
+    }
+    const value = lookupPath(scope, tok.path);
+    // A missing path OR an empty string falls to the default (intended, tested):
+    // an unset/blank value is treated as "provide a default or fail".
+    if (value == null || value === '') {
+        if (tok.defaultValue !== undefined)
+            return tok.defaultValue;
+        throw makeEvalError({
+            code: ErrorCode.TEMPLATE_UNKNOWN_PATH,
+            message: `Template references unknown path '${tok.path.join('.')}' and no default provided`,
+            field,
+            path: tok.path.join('.'),
+            pos: tok.pos,
+        });
+    }
+    if (typeof value === 'object') {
+        throw makeEvalError({
+            code: ErrorCode.TEMPLATE_TYPE_MISMATCH,
+            message: `Template path '${tok.path.join('.')}' resolved to an object; only strings/numbers/booleans are interpolatable`,
+            field,
+            path: tok.path.join('.'),
+            pos: tok.pos,
+        });
+    }
+    return String(value);
+}
+/** Apply a whole-field coercion filter to a resolved string value. */
+function applyCoercion(raw, kind, tok, field) {
+    switch (kind) {
+        case 'number': {
+            const n = Number(raw);
+            if (!Number.isFinite(n)) {
+                throw makeEvalError({
+                    code: ErrorCode.TEMPLATE_TYPE_MISMATCH,
+                    message: `'${raw}' cannot be coerced to number at path '${tok.path.join('.')}'`,
+                    field,
+                    path: tok.path.join('.'),
+                    pos: tok.pos,
+                });
+            }
+            return n;
+        }
+        case 'bool': {
+            const v = raw.trim().toLowerCase();
+            if (v === 'true' || v === '1' || v === 'yes')
+                return true;
+            if (v === 'false' || v === '0' || v === 'no' || v === '')
+                return false;
+            throw makeEvalError({
+                code: ErrorCode.TEMPLATE_TYPE_MISMATCH,
+                message: `'${raw}' cannot be coerced to bool at path '${tok.path.join('.')}'`,
+                field,
+                path: tok.path.join('.'),
+                pos: tok.pos,
+            });
+        }
+        case 'json': {
+            try {
+                return JSON.parse(raw);
+            }
+            catch (err) {
+                throw makeEvalError({
+                    code: ErrorCode.TEMPLATE_TYPE_MISMATCH,
+                    message: `'${raw}' is not valid JSON at path '${tok.path.join('.')}': ${err.message}`,
+                    field,
+                    path: tok.path.join('.'),
+                    pos: tok.pos,
+                });
+            }
+        }
+    }
+}
+/**
+ * Extract dependency paths from a token stream. Used by the topological
+ * sort pass to order resolution of self-referencing documents.
+ */
+export function dependencies(tokens) {
+    const out = [];
+    for (const tok of tokens) {
+        if (tok.kind === 'expr')
+            out.push(tok.path.join('.'));
+    }
+    return out;
+}
+function makeEvalError(e) {
+    const err = new Error(e.message);
+    err.name = 'TemplateEvalError';
+    err.code = e.code;
+    err.field = e.field;
+    err.path = e.path;
+    err.pos = e.pos;
+    return err;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../src/template/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode } from '@pipeline-builder/api-core';\nimport type { CoerceKind, SourcePosition, Token } from './tokenizer.js';\n\nexport type Scope = Record<string, unknown>;\n\nexport interface EvalError {\n  code: ErrorCode;\n  message: string;\n  field?: string;\n  path?: string;\n  pos?: SourcePosition;\n}\n\nconst RESERVED_ROOT_PATHS = new Set(['secrets']);\n\n/**\n * Look up a dot-separated path inside a scope object. Returns `undefined`\n * if any intermediate segment is missing or not an object.\n *\n * Only OWN enumerable-or-not-inherited properties are traversed: a segment is\n * resolved via `Object.prototype.hasOwnProperty.call` so inherited members of\n * the prototype chain (`constructor`, `toString`, `valueOf`, `hasOwnProperty`,\n * the `__proto__` accessor, …) never resolve — they return `undefined` and thus\n * fall through to the caller's normal unknown-path handling (a `| default:`\n * fallback or a `TEMPLATE_UNKNOWN_PATH` error). Applied at every level,\n * including the root segment, this also makes the scope's own top-level keys\n * the effective root allow-list, so an unknown/prototype root is rejected even\n * on the synth path that skips `validateTemplates`.\n */\nexport function lookupPath(scope: Scope, path: string[]): unknown {\n  let cur: unknown = scope;\n  for (const segment of path) {\n    if (cur == null || typeof cur !== 'object') return undefined;\n    if (!Object.prototype.hasOwnProperty.call(cur, segment)) return undefined;\n    cur = (cur as Record<string, unknown>)[segment];\n  }\n  return cur;\n}\n\n/**\n * Resolve a token stream against a scope. Returns the resolved string.\n * Throws `EvalError` when an unresolved path has no default filter.\n *\n * Coercion filters (`| number`, `| bool`, `| json`) only take effect\n * when the template expression is the entire field — e.g.\n * `replicas: \"{{ vars.count | number }}\"` yields `3` (number) while\n * `replicas: \"count={{ vars.count | number }}\"` yields `\"count=3\"`\n * (string, because the template is embedded in surrounding literals).\n * Mixed-literal fields always return a string.\n */\nexport function resolve(\n  tokens: Token[],\n  scope: Scope,\n  field?: string,\n): string | number | boolean | null | unknown[] | Record<string, unknown> {\n  // Whole-field coercion shortcut: only apply coercion when the entire field\n  // is a single expression (no surrounding literal text).\n  if (tokens.length === 1 && tokens[0]!.kind === 'expr' && tokens[0]!.coerce) {\n    const tok = tokens[0]! as Extract<Token, { kind: 'expr' }>;\n    const raw = resolveOne(tok, scope, field);\n    return applyCoercion(raw, tok.coerce!, tok, field);\n  }\n\n  const parts: string[] = [];\n  for (const tok of tokens) {\n    if (tok.kind === 'literal') {\n      parts.push(tok.value);\n      continue;\n    }\n    const raw = resolveOne(tok, scope, field);\n    parts.push(typeof raw === 'string' ? raw : String(raw));\n  }\n  return parts.join('');\n}\n\n/** Resolve a single expression token to its string form (no coercion). */\nfunction resolveOne(tok: Extract<Token, { kind: 'expr' }>, scope: Scope, field?: string): string {\n  const root = tok.path[0]!;\n  if (RESERVED_ROOT_PATHS.has(root)) {\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_SECRETS_RESERVED,\n      message: `'${root}' is a reserved scope — use the plugin's 'secrets:' field instead`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  const value = lookupPath(scope, tok.path);\n  // A missing path OR an empty string falls to the default (intended, tested):\n  // an unset/blank value is treated as \"provide a default or fail\".\n  if (value == null || value === '') {\n    if (tok.defaultValue !== undefined) return tok.defaultValue;\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_UNKNOWN_PATH,\n      message: `Template references unknown path '${tok.path.join('.')}' and no default provided`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  if (typeof value === 'object') {\n    throw makeEvalError({\n      code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n      message: `Template path '${tok.path.join('.')}' resolved to an object; only strings/numbers/booleans are interpolatable`,\n      field,\n      path: tok.path.join('.'),\n      pos: tok.pos,\n    });\n  }\n  return String(value);\n}\n\n/** Apply a whole-field coercion filter to a resolved string value. */\nfunction applyCoercion(\n  raw: string,\n  kind: CoerceKind,\n  tok: Extract<Token, { kind: 'expr' }>,\n  field?: string,\n): number | boolean | null | string | unknown[] | Record<string, unknown> {\n  switch (kind) {\n    case 'number': {\n      const n = Number(raw);\n      if (!Number.isFinite(n)) {\n        throw makeEvalError({\n          code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n          message: `'${raw}' cannot be coerced to number at path '${tok.path.join('.')}'`,\n          field,\n          path: tok.path.join('.'),\n          pos: tok.pos,\n        });\n      }\n      return n;\n    }\n    case 'bool': {\n      const v = raw.trim().toLowerCase();\n      if (v === 'true' || v === '1' || v === 'yes') return true;\n      if (v === 'false' || v === '0' || v === 'no' || v === '') return false;\n      throw makeEvalError({\n        code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n        message: `'${raw}' cannot be coerced to bool at path '${tok.path.join('.')}'`,\n        field,\n        path: tok.path.join('.'),\n        pos: tok.pos,\n      });\n    }\n    case 'json': {\n      try {\n        return JSON.parse(raw) as string | number | boolean | null | unknown[] | Record<string, unknown>;\n      } catch (err) {\n        throw makeEvalError({\n          code: ErrorCode.TEMPLATE_TYPE_MISMATCH,\n          message: `'${raw}' is not valid JSON at path '${tok.path.join('.')}': ${(err as Error).message}`,\n          field,\n          path: tok.path.join('.'),\n          pos: tok.pos,\n        });\n      }\n    }\n  }\n}\n\n/**\n * Extract dependency paths from a token stream. Used by the topological\n * sort pass to order resolution of self-referencing documents.\n */\nexport function dependencies(tokens: Token[]): string[] {\n  const out: string[] = [];\n  for (const tok of tokens) {\n    if (tok.kind === 'expr') out.push(tok.path.join('.'));\n  }\n  return out;\n}\n\nfunction makeEvalError(e: EvalError): Error & EvalError {\n  const err = new Error(e.message) as Error & EvalError;\n  err.name = 'TemplateEvalError';\n  err.code = e.code;\n  err.field = e.field;\n  err.path = e.path;\n  err.pos = e.pos;\n  return err;\n}\n"]}