@pipeline-builder/pipeline-core 3.1.0

package/lib/config/server-config.js

@@ -0,0 +1,180 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadServerConfig = loadServerConfig;
+exports.loadAuthConfig = loadAuthConfig;
+exports.loadRateLimitConfig = loadRateLimitConfig;
+exports.validateServerConfig = validateServerConfig;
+exports.validateAuthConfig = validateAuthConfig;
+const api_core_1 = require("@pipeline-builder/api-core");
+const app_config_1 = require("./app-config");
+const log = (0, api_core_1.createLogger)('ServerConfig');
+/**
+ * Load server configuration from environment variables.
+ *
+ * Environment variables:
+ * - `PORT` — HTTP listen port (default: `3000`)
+ * - `CORS_ORIGIN` — Comma-separated allowed origins (default: `PLATFORM_BASE_URL`)
+ * - `CORS_CREDENTIALS` — Allow credentials; set to `'false'` to disable (default: `true`)
+ * - `TRUST_PROXY` — Express trust proxy hops (default: `1`)
+ * - `PLATFORM_BASE_URL` — Frontend URL used as CORS fallback (default: `'https://localhost:8443'`)
+ *
+ * @returns Server configuration with port, CORS, trust proxy, and platform URL
+ */
+function loadServerConfig() {
+    return {
+        port: parseInt(process.env.PORT || '3000', 10),
+        cors: {
+            credentials: process.env.CORS_CREDENTIALS !== 'false',
+            origin: process.env.CORS_ORIGIN
+                ? process.env.CORS_ORIGIN.split(',').map(o => o.trim())
+                : [process.env.PLATFORM_BASE_URL || app_config_1.CoreConstants.DEFAULT_PLATFORM_URL],
+        },
+        trustProxy: parseInt(process.env.TRUST_PROXY || '1', 10),
+        platformUrl: process.env.PLATFORM_BASE_URL || app_config_1.CoreConstants.DEFAULT_PLATFORM_URL,
+        httpClient: {
+            timeout: parseInt(process.env.HTTP_CLIENT_TIMEOUT || '5000', 10),
+            maxRetries: parseInt(process.env.HTTP_CLIENT_MAX_RETRIES || '2', 10),
+            retryDelayMs: parseInt(process.env.HTTP_CLIENT_RETRY_DELAY_MS || '200', 10),
+        },
+        sse: {
+            maxClientsPerRequest: parseInt(process.env.SSE_MAX_CLIENTS_PER_REQUEST || '10', 10),
+            clientTimeoutMs: parseInt(process.env.SSE_CLIENT_TIMEOUT_MS || '1800000', 10),
+            cleanupIntervalMs: parseInt(process.env.SSE_CLEANUP_INTERVAL_MS || '300000', 10),
+        },
+        services: {
+            pluginHost: process.env.PLUGIN_SERVICE_HOST || 'plugin',
+            pluginPort: parseInt(process.env.PLUGIN_SERVICE_PORT || '3000', 10),
+            pipelineHost: process.env.PIPELINE_SERVICE_HOST || 'pipeline',
+            pipelinePort: parseInt(process.env.PIPELINE_SERVICE_PORT || '3000', 10),
+            messageHost: process.env.MESSAGE_SERVICE_HOST || 'message',
+            messagePort: parseInt(process.env.MESSAGE_SERVICE_PORT || '3000', 10),
+            complianceHost: process.env.COMPLIANCE_SERVICE_HOST || 'compliance',
+            compliancePort: parseInt(process.env.COMPLIANCE_SERVICE_PORT || '3000', 10),
+            billingHost: process.env.BILLING_SERVICE_HOST || 'billing',
+            billingPort: parseInt(process.env.BILLING_SERVICE_PORT || '3000', 10),
+            billingTimeout: parseInt(process.env.BILLING_SERVICE_TIMEOUT || '5000', 10),
+        },
+    };
+}
+/**
+ * Load authentication configuration from environment variables.
+ *
+ * Environment variables:
+ * - `JWT_SECRET` — **Required.** Secret key for signing JWTs
+ * - `REFRESH_TOKEN_SECRET` — **Required.** Secret key for signing refresh tokens
+ * - `JWT_EXPIRES_IN` — JWT lifetime in seconds (default: `7200` = 2 hours)
+ * - `JWT_ALGORITHM` — JWT signing algorithm (default: `'HS256'`)
+ * - `JWT_SALT_ROUNDS` — bcrypt salt rounds for password hashing (default: `12`)
+ * - `REFRESH_TOKEN_EXPIRES_IN` — Refresh token lifetime in seconds (default: `2592000` = 30 days)
+ *
+ * @returns Authentication configuration with safe defaults (empty strings when env vars are unset).
+ * Call {@link validateAuthConfig} at server startup to enforce required secrets.
+ */
+function loadAuthConfig() {
+    return {
+        jwt: {
+            secret: process.env.JWT_SECRET ?? '',
+            expiresIn: parseInt(process.env.JWT_EXPIRES_IN || '7200', 10),
+            algorithm: (process.env.JWT_ALGORITHM || 'HS256'),
+            saltRounds: parseInt(process.env.JWT_SALT_ROUNDS || '12', 10),
+        },
+        refreshToken: {
+            secret: process.env.REFRESH_TOKEN_SECRET || '',
+            expiresIn: parseInt(process.env.REFRESH_TOKEN_EXPIRES_IN || '2592000', 10),
+        },
+    };
+}
+/**
+ * Load rate limiting configuration from environment variables.
+ *
+ * Environment variables:
+ * - `LIMITER_MAX` — Max requests per window (default: `100`)
+ * - `LIMITER_WINDOWMS` — Rate limit window in ms (default: `900000` = 15 minutes)
+ *
+ * @returns Rate limit configuration
+ */
+function loadRateLimitConfig() {
+    return {
+        max: parseInt(process.env.LIMITER_MAX || '100', 10),
+        windowMs: parseInt(process.env.LIMITER_WINDOWMS || '900000', 10),
+        legacyHeaders: false,
+        standardHeaders: true,
+    };
+}
+/**
+ * Validate server configuration and log warnings for insecure settings.
+ *
+ * @param config - Server configuration to validate
+ */
+function validateServerConfig(config) {
+    const warnings = [];
+    // Check CORS configuration
+    const origin = config.cors.origin;
+    const isWildcard = origin === '*' || (Array.isArray(origin) && origin.includes('*'));
+    if (isWildcard) {
+        warnings.push('CORS origin set to wildcard (*) - consider restricting to specific domains');
+    }
+    if (isWildcard && config.cors.credentials) {
+        // Browsers reject this combination, but it indicates a misconfiguration
+        throw new Error('SECURITY ERROR: CORS_ORIGIN=* with CORS_CREDENTIALS=true is an invalid and insecure configuration. ' +
+            'Set CORS_ORIGIN to specific domains or disable CORS_CREDENTIALS.');
+    }
+    // Check platform URL uses HTTPS
+    if (config.platformUrl.startsWith('http://') &&
+        !config.platformUrl.includes('localhost')) {
+        warnings.push('Platform URL uses HTTP instead of HTTPS - insecure for production');
+    }
+    // Display warnings
+    if (warnings.length > 0) {
+        log.warn('Server configuration warnings:');
+        warnings.forEach(warning => log.warn(`  - ${warning}`));
+    }
+}
+const INSECURE_PATTERNS = ['secret', 'password', 'changeme', 'default', '123456', 'admin'];
+function isInsecureSecret(secret) {
+    const lower = secret.toLowerCase();
+    return INSECURE_PATTERNS.some(s => lower === s || (lower.length < 64 && lower.includes(s)));
+}
+/**
+ * Validate authentication configuration (JWT secrets, algorithms, expiration).
+ * Call this at server startup, not during CDK synthesis.
+ *
+ * @param config - Auth configuration to validate
+ * @throws {Error} If secrets are insecure, too short (<32 chars), or use disallowed algorithms
+ */
+function validateAuthConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Validate both secrets with the same checks
+    for (const [label, secret] of [['JWT', config.jwt.secret], ['Refresh token', config.refreshToken.secret]]) {
+        if (secret.length < 32) {
+            errors.push(`${label} secret should be at least 32 characters long`);
+        }
+        if (isInsecureSecret(secret)) {
+            errors.push(`${label} secret appears to be insecure or default value`);
+        }
+    }
+    // Check JWT expiration times
+    if (config.jwt.expiresIn > 86400) {
+        errors.push('JWT expiration must not exceed 24 hours (86400 seconds)');
+    }
+    else if (config.jwt.expiresIn > 7200) {
+        warnings.push('JWT expiration time is greater than 2 hours - shorter expiration recommended');
+    }
+    // Check algorithm
+    if (!app_config_1.CoreConstants.ALLOWED_JWT_ALGORITHMS.includes(config.jwt.algorithm)) {
+        errors.push(`JWT algorithm ${config.jwt.algorithm} is not in the allowed list`);
+    }
+    // Display warnings
+    if (warnings.length > 0) {
+        log.warn('Auth configuration warnings:');
+        warnings.forEach(warning => log.warn(`  - ${warning}`));
+    }
+    // Throw errors
+    if (errors.length > 0) {
+        throw new Error(`Auth configuration validation failed:\n${errors.map(e => `  - ${e}`).join('\n')}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-config.js","sourceRoot":"","sources":["../../src/config/server-config.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 type { Algorithm } from 'jsonwebtoken';\nimport { CoreConstants } from './app-config';\nimport type { ServerConfig, AuthConfig, RateLimitConfig } from './config-types';\n\nconst log = createLogger('ServerConfig');\n\n/**\n * Load server configuration from environment variables.\n *\n * Environment variables:\n * - `PORT` — HTTP listen port (default: `3000`)\n * - `CORS_ORIGIN` — Comma-separated allowed origins (default: `PLATFORM_BASE_URL`)\n * - `CORS_CREDENTIALS` — Allow credentials; set to `'false'` to disable (default: `true`)\n * - `TRUST_PROXY` — Express trust proxy hops (default: `1`)\n * - `PLATFORM_BASE_URL` — Frontend URL used as CORS fallback (default: `'https://localhost:8443'`)\n *\n * @returns Server configuration with port, CORS, trust proxy, and platform URL\n */\nexport function loadServerConfig(): ServerConfig {\n  return {\n    port: parseInt(process.env.PORT || '3000', 10),\n    cors: {\n      credentials: process.env.CORS_CREDENTIALS !== 'false',\n      origin: process.env.CORS_ORIGIN\n        ? process.env.CORS_ORIGIN.split(',').map(o => o.trim())\n        : [process.env.PLATFORM_BASE_URL || CoreConstants.DEFAULT_PLATFORM_URL],\n    },\n    trustProxy: parseInt(process.env.TRUST_PROXY || '1', 10),\n    platformUrl: process.env.PLATFORM_BASE_URL || CoreConstants.DEFAULT_PLATFORM_URL,\n\n    httpClient: {\n      timeout: parseInt(process.env.HTTP_CLIENT_TIMEOUT || '5000', 10),\n      maxRetries: parseInt(process.env.HTTP_CLIENT_MAX_RETRIES || '2', 10),\n      retryDelayMs: parseInt(process.env.HTTP_CLIENT_RETRY_DELAY_MS || '200', 10),\n    },\n\n    sse: {\n      maxClientsPerRequest: parseInt(process.env.SSE_MAX_CLIENTS_PER_REQUEST || '10', 10),\n      clientTimeoutMs: parseInt(process.env.SSE_CLIENT_TIMEOUT_MS || '1800000', 10),\n      cleanupIntervalMs: parseInt(process.env.SSE_CLEANUP_INTERVAL_MS || '300000', 10),\n    },\n\n    services: {\n      pluginHost: process.env.PLUGIN_SERVICE_HOST || 'plugin',\n      pluginPort: parseInt(process.env.PLUGIN_SERVICE_PORT || '3000', 10),\n      pipelineHost: process.env.PIPELINE_SERVICE_HOST || 'pipeline',\n      pipelinePort: parseInt(process.env.PIPELINE_SERVICE_PORT || '3000', 10),\n      messageHost: process.env.MESSAGE_SERVICE_HOST || 'message',\n      messagePort: parseInt(process.env.MESSAGE_SERVICE_PORT || '3000', 10),\n      complianceHost: process.env.COMPLIANCE_SERVICE_HOST || 'compliance',\n      compliancePort: parseInt(process.env.COMPLIANCE_SERVICE_PORT || '3000', 10),\n      billingHost: process.env.BILLING_SERVICE_HOST || 'billing',\n      billingPort: parseInt(process.env.BILLING_SERVICE_PORT || '3000', 10),\n      billingTimeout: parseInt(process.env.BILLING_SERVICE_TIMEOUT || '5000', 10),\n    },\n  };\n}\n\n/**\n * Load authentication configuration from environment variables.\n *\n * Environment variables:\n * - `JWT_SECRET` — **Required.** Secret key for signing JWTs\n * - `REFRESH_TOKEN_SECRET` — **Required.** Secret key for signing refresh tokens\n * - `JWT_EXPIRES_IN` — JWT lifetime in seconds (default: `7200` = 2 hours)\n * - `JWT_ALGORITHM` — JWT signing algorithm (default: `'HS256'`)\n * - `JWT_SALT_ROUNDS` — bcrypt salt rounds for password hashing (default: `12`)\n * - `REFRESH_TOKEN_EXPIRES_IN` — Refresh token lifetime in seconds (default: `2592000` = 30 days)\n *\n * @returns Authentication configuration with safe defaults (empty strings when env vars are unset).\n * Call {@link validateAuthConfig} at server startup to enforce required secrets.\n */\nexport function loadAuthConfig(): AuthConfig {\n  return {\n    jwt: {\n      secret: process.env.JWT_SECRET ?? '',\n      expiresIn: parseInt(process.env.JWT_EXPIRES_IN || '7200', 10),\n      algorithm: (process.env.JWT_ALGORITHM || 'HS256') as Algorithm,\n      saltRounds: parseInt(process.env.JWT_SALT_ROUNDS || '12', 10),\n    },\n    refreshToken: {\n      secret: process.env.REFRESH_TOKEN_SECRET || '',\n      expiresIn: parseInt(process.env.REFRESH_TOKEN_EXPIRES_IN || '2592000', 10),\n    },\n  };\n}\n\n/**\n * Load rate limiting configuration from environment variables.\n *\n * Environment variables:\n * - `LIMITER_MAX` — Max requests per window (default: `100`)\n * - `LIMITER_WINDOWMS` — Rate limit window in ms (default: `900000` = 15 minutes)\n *\n * @returns Rate limit configuration\n */\nexport function loadRateLimitConfig(): RateLimitConfig {\n  return {\n    max: parseInt(process.env.LIMITER_MAX || '100', 10),\n    windowMs: parseInt(process.env.LIMITER_WINDOWMS || '900000', 10),\n    legacyHeaders: false,\n    standardHeaders: true,\n  };\n}\n\n/**\n * Validate server configuration and log warnings for insecure settings.\n *\n * @param config - Server configuration to validate\n */\nexport function validateServerConfig(config: ServerConfig): void {\n  const warnings: string[] = [];\n\n  // Check CORS configuration\n  const origin = config.cors.origin;\n  const isWildcard = origin === '*' || (Array.isArray(origin) && origin.includes('*'));\n  if (isWildcard) {\n    warnings.push('CORS origin set to wildcard (*) - consider restricting to specific domains');\n  }\n  if (isWildcard && config.cors.credentials) {\n    // Browsers reject this combination, but it indicates a misconfiguration\n    throw new Error(\n      'SECURITY ERROR: CORS_ORIGIN=* with CORS_CREDENTIALS=true is an invalid and insecure configuration. ' +\n      'Set CORS_ORIGIN to specific domains or disable CORS_CREDENTIALS.',\n    );\n  }\n\n  // Check platform URL uses HTTPS\n  if (config.platformUrl.startsWith('http://') &&\n    !config.platformUrl.includes('localhost')) {\n    warnings.push('Platform URL uses HTTP instead of HTTPS - insecure for production');\n  }\n\n  // Display warnings\n  if (warnings.length > 0) {\n    log.warn('Server configuration warnings:');\n    warnings.forEach(warning => log.warn(`  - ${warning}`));\n  }\n}\n\nconst INSECURE_PATTERNS = ['secret', 'password', 'changeme', 'default', '123456', 'admin'];\n\nfunction isInsecureSecret(secret: string): boolean {\n  const lower = secret.toLowerCase();\n  return INSECURE_PATTERNS.some(s => lower === s || (lower.length < 64 && lower.includes(s)));\n}\n\n/**\n * Validate authentication configuration (JWT secrets, algorithms, expiration).\n * Call this at server startup, not during CDK synthesis.\n *\n * @param config - Auth configuration to validate\n * @throws {Error} If secrets are insecure, too short (<32 chars), or use disallowed algorithms\n */\nexport function validateAuthConfig(config: AuthConfig): void {\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  // Validate both secrets with the same checks\n  for (const [label, secret] of [['JWT', config.jwt.secret], ['Refresh token', config.refreshToken.secret]] as const) {\n    if (secret.length < 32) {\n      errors.push(`${label} secret should be at least 32 characters long`);\n    }\n    if (isInsecureSecret(secret)) {\n      errors.push(`${label} secret appears to be insecure or default value`);\n    }\n  }\n\n  // Check JWT expiration times\n  if (config.jwt.expiresIn > 86400) {\n    errors.push('JWT expiration must not exceed 24 hours (86400 seconds)');\n  } else if (config.jwt.expiresIn > 7200) {\n    warnings.push('JWT expiration time is greater than 2 hours - shorter expiration recommended');\n  }\n\n  // Check algorithm\n  if (!CoreConstants.ALLOWED_JWT_ALGORITHMS.includes(config.jwt.algorithm)) {\n    errors.push(`JWT algorithm ${config.jwt.algorithm} is not in the allowed list`);\n  }\n\n  // Display warnings\n  if (warnings.length > 0) {\n    log.warn('Auth configuration warnings:');\n    warnings.forEach(warning => log.warn(`  - ${warning}`));\n  }\n\n  // Throw errors\n  if (errors.length > 0) {\n    throw new Error(\n      `Auth configuration validation failed:\\n${errors.map(e => `  - ${e}`).join('\\n')}`,\n    );\n  }\n}\n"]}

package/lib/core/artifact-manager.d.ts

@@ -0,0 +1,62 @@
+import { CodeBuildStep, FileSet, ShellStep } from 'aws-cdk-lib/pipelines';
+export interface ArtifactKey {
+    readonly stageName: string;
+    readonly stageAlias: string;
+    readonly pluginName: string;
+    readonly pluginAlias: string;
+    readonly outputDirectory: string;
+}
+/**
+ * Manages build step artifacts with hierarchical key-based lookup.
+ * Keys follow the pattern: stageName:stageAlias:pluginName:pluginAlias:outputDirectory
+ *
+ * @example
+ * ```typescript
+ * // Synth step: "no-stage:no-stage-alias:cdk-synth:cdk-synth-alias:cdk.out"
+ * // Build step: "build:build-alias:nodejs-build:nodejs-build-alias:dist"
+ * ```
+ */
+export declare class ArtifactManager {
+    private readonly artifacts;
+    /**
+     * Generate a key string from artifact parameters
+     */
+    private generateKey;
+    /**
+     * Register a build step artifact
+     * @param key - The hierarchical key identifying this artifact (includes output directory)
+     * @param step - The CodeBuildStep or ShellStep to store
+     */
+    add(key: ArtifactKey, step: CodeBuildStep | ShellStep): void;
+    /**
+     * Get a build step by its artifact key
+     * @param key - The hierarchical key identifying the artifact
+     * @returns The stored step, or undefined if not found
+     */
+    get(key: ArtifactKey): CodeBuildStep | ShellStep | undefined;
+    /**
+     * Get the primary output FileSet from a registered step.
+     * @param key - The artifact key identifying the step
+     * @returns The primary output FileSet
+     * @throws Error if the step is not found or has no primary output
+     */
+    getOutput(key: ArtifactKey): FileSet;
+    /**
+     * Register an additional output directory on a stored step and return its FileSet.
+     * Calls CDK's addOutputDirectory() to create a named output beyond the primary.
+     * @param key - The artifact key identifying the step
+     * @param directory - The additional output directory path to register
+     * @returns The FileSet for the additional output directory
+     * @throws Error if the step is not found
+     */
+    addOutput(key: ArtifactKey, directory: string): FileSet;
+    /**
+     * Get a step by key or throw with a helpful error listing available artifacts.
+     */
+    private require;
+    /**
+     * List all artifact keys
+     * @returns Array of all stored artifact key strings
+     */
+    list(): string[];
+}

package/lib/core/artifact-manager.js

@@ -0,0 +1,86 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactManager = void 0;
+/**
+ * Manages build step artifacts with hierarchical key-based lookup.
+ * Keys follow the pattern: stageName:stageAlias:pluginName:pluginAlias:outputDirectory
+ *
+ * @example
+ * ```typescript
+ * // Synth step: "no-stage:no-stage-alias:cdk-synth:cdk-synth-alias:cdk.out"
+ * // Build step: "build:build-alias:nodejs-build:nodejs-build-alias:dist"
+ * ```
+ */
+class ArtifactManager {
+    artifacts = new Map();
+    /**
+     * Generate a key string from artifact parameters
+     */
+    generateKey(key) {
+        return `${key.stageName}:${key.stageAlias}:${key.pluginName}:${key.pluginAlias}:${key.outputDirectory}`;
+    }
+    /**
+     * Register a build step artifact
+     * @param key - The hierarchical key identifying this artifact (includes output directory)
+     * @param step - The CodeBuildStep or ShellStep to store
+     */
+    add(key, step) {
+        this.artifacts.set(this.generateKey(key), step);
+    }
+    /**
+     * Get a build step by its artifact key
+     * @param key - The hierarchical key identifying the artifact
+     * @returns The stored step, or undefined if not found
+     */
+    get(key) {
+        return this.artifacts.get(this.generateKey(key));
+    }
+    /**
+     * Get the primary output FileSet from a registered step.
+     * @param key - The artifact key identifying the step
+     * @returns The primary output FileSet
+     * @throws Error if the step is not found or has no primary output
+     */
+    getOutput(key) {
+        const step = this.require(key);
+        const output = step.primaryOutput;
+        if (!output) {
+            throw new Error(`Step '${key.pluginName}' has no primary output`);
+        }
+        return output;
+    }
+    /**
+     * Register an additional output directory on a stored step and return its FileSet.
+     * Calls CDK's addOutputDirectory() to create a named output beyond the primary.
+     * @param key - The artifact key identifying the step
+     * @param directory - The additional output directory path to register
+     * @returns The FileSet for the additional output directory
+     * @throws Error if the step is not found
+     */
+    addOutput(key, directory) {
+        return this.require(key).addOutputDirectory(directory);
+    }
+    /**
+     * Get a step by key or throw with a helpful error listing available artifacts.
+     */
+    require(key) {
+        const step = this.get(key);
+        if (!step) {
+            const registered = this.list();
+            const available = registered.length > 0 ? ` Available: [${registered.join(', ')}]` : ' No artifacts registered.';
+            throw new Error(`No artifact registered for "${this.generateKey(key)}".${available}`);
+        }
+        return step;
+    }
+    /**
+     * List all artifact keys
+     * @returns Array of all stored artifact key strings
+     */
+    list() {
+        return Array.from(this.artifacts.keys());
+    }
+}
+exports.ArtifactManager = ArtifactManager;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/id-generator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Generates unique CDK construct IDs by appending auto-incrementing counters to labels.
+ * Labels that already end with a numeric counter (e.g., 'cdk:pipeline:1') are returned as-is.
+ *
+ * @example
+ * ```typescript
+ * const id = new UniqueId();
+ *
+ * id.generate('plugin:lookup');   // "plugin:lookup:1"
+ * id.generate('cdk:synth');       // "cdk:synth:1"
+ * id.generate('plugin:lookup');   // "plugin:lookup:2"
+ * id.generate('cdk:pipeline:1'); // "cdk:pipeline:1" (already has counter)
+ * ```
+ */
+export declare class UniqueId {
+    private readonly _counters;
+    /**
+     * Returns a unique construct ID for the given label.
+     * If the label already ends with a numeric counter, it is returned as-is.
+     * Otherwise, an auto-incrementing counter is appended.
+     *
+     * @param label - Colon-separated namespace (e.g., 'plugin:lookup')
+     * @returns The label with counter appended, or unchanged if it already has one
+     */
+    generate(label: string): string;
+}

package/lib/core/id-generator.js

@@ -0,0 +1,44 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueId = void 0;
+/**
+ * Generates unique CDK construct IDs by appending auto-incrementing counters to labels.
+ * Labels that already end with a numeric counter (e.g., 'cdk:pipeline:1') are returned as-is.
+ *
+ * @example
+ * ```typescript
+ * const id = new UniqueId();
+ *
+ * id.generate('plugin:lookup');   // "plugin:lookup:1"
+ * id.generate('cdk:synth');       // "cdk:synth:1"
+ * id.generate('plugin:lookup');   // "plugin:lookup:2"
+ * id.generate('cdk:pipeline:1'); // "cdk:pipeline:1" (already has counter)
+ * ```
+ */
+class UniqueId {
+    _counters = new Map();
+    /**
+     * Returns a unique construct ID for the given label.
+     * If the label already ends with a numeric counter, it is returned as-is.
+     * Otherwise, an auto-incrementing counter is appended.
+     *
+     * @param label - Colon-separated namespace (e.g., 'plugin:lookup')
+     * @returns The label with counter appended, or unchanged if it already has one
+     */
+    generate(label) {
+        if (!label || typeof label !== 'string') {
+            throw new Error('Label must be a non-empty string');
+        }
+        // If label already ends with a numeric counter, return as-is
+        if (/:\d+$/.test(label)) {
+            return label;
+        }
+        const count = (this._counters.get(label) ?? 0) + 1;
+        this._counters.set(label, count);
+        return `${label}:${count}`;
+    }
+}
+exports.UniqueId = UniqueId;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/metadata-builder.d.ts

@@ -0,0 +1,13 @@
+import type { BuildEnvironment } from 'aws-cdk-lib/aws-codebuild';
+import type { CodeBuildStepProps, CodePipelineProps, ShellStepProps } from 'aws-cdk-lib/pipelines';
+import type { MetaDataType } from './pipeline-types';
+/** Extract CDK construct config from metadata for a given namespace. */
+export declare function buildConfigFromMetadata(metadata: MetaDataType, namespace: string): Record<string, unknown>;
+/** Extract CodePipeline config from metadata. */
+export declare function metadataForCodePipeline(metadata: MetaDataType): Partial<CodePipelineProps>;
+/** Extract CodeBuildStep config from metadata. */
+export declare function metadataForCodeBuildStep(metadata: MetaDataType): Partial<CodeBuildStepProps>;
+/** Extract ShellStep config from metadata. */
+export declare function metadataForShellStep(metadata: MetaDataType): Partial<ShellStepProps>;
+/** Extract BuildEnvironment config from metadata. */
+export declare function metadataForBuildEnvironment(metadata: MetaDataType): Partial<BuildEnvironment>;

package/lib/core/metadata-builder.js

@@ -0,0 +1,81 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfigFromMetadata = buildConfigFromMetadata;
+exports.metadataForCodePipeline = metadataForCodePipeline;
+exports.metadataForCodeBuildStep = metadataForCodeBuildStep;
+exports.metadataForShellStep = metadataForShellStep;
+exports.metadataForBuildEnvironment = metadataForBuildEnvironment;
+const pipeline_types_1 = require("./pipeline-types");
+/**
+ * Type-safe namespace constants for metadata configuration.
+ */
+const NAMESPACE = {
+    SHELL_STEP: 'pipelines:shellstep',
+    CODE_BUILD_STEP: 'pipelines:codebuildstep',
+    BUILD_ENVIRONMENT: 'codebuild:buildenvironment',
+    CODE_PIPELINE: 'pipelines:codepipeline',
+};
+const NAMESPACE_KEY_MAP = {
+    [NAMESPACE.SHELL_STEP]: {
+        booleanKeys: [],
+        passthroughKeys: ['additionalInputs', 'commands', 'env', 'envFromCfnOutputs', 'input', 'installCommands', 'primaryOutputDirectory'],
+    },
+    [NAMESPACE.CODE_BUILD_STEP]: {
+        booleanKeys: [],
+        passthroughKeys: ['actionRole', 'additionalInputs', 'buildEnvironment', 'cache', 'commands', 'env', 'envFromCfnOutputs', 'fileSystemLocations', 'input', 'installCommands', 'logging', 'partialBuildSpec', 'primaryOutputDirectory', 'projectName', 'role', 'rolePolicyStatements', 'timeout'],
+    },
+    [NAMESPACE.BUILD_ENVIRONMENT]: {
+        booleanKeys: ['privileged'],
+        passthroughKeys: ['buildImage', 'certificate', 'computeType', 'dockerServer', 'environmentVariables', 'fleet'],
+    },
+    [NAMESPACE.CODE_PIPELINE]: {
+        booleanKeys: ['crossAccountKeys', 'dockerEnabledForSelfMutation', 'dockerEnabledForSynth', 'enableKeyRotation', 'publishAssetsInParallel', 'reuseCrossRegionSupportStacks', 'selfMutation', 'useChangeSets', 'usePipelineRoleForActions'],
+        passthroughKeys: ['artifactBucket', 'assetPublishingCodeBuildDefaults', 'cdkAssetsCliVersion', 'cliVersion', 'codeBuildDefaults', 'codePipeline', 'crossRegionReplicationBuckets', 'dockerCredentials', 'pipelineName', 'pipelineType', 'role', 'selfMutationCodeBuildDefaults', 'synth', 'synthCodeBuildDefaults'],
+    },
+};
+const EMPTY_KEY_CONFIG = { booleanKeys: [], passthroughKeys: [] };
+function getCustomKey(prefix, key) {
+    return `${pipeline_types_1.CDK_METADATA_PREFIX}${prefix}:${key}`.toLowerCase();
+}
+function isTrue(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string')
+        return value.toLowerCase() === 'true';
+    return false;
+}
+/** Extract CDK construct config from metadata for a given namespace. */
+function buildConfigFromMetadata(metadata, namespace) {
+    const { booleanKeys, passthroughKeys } = NAMESPACE_KEY_MAP[namespace] ?? EMPTY_KEY_CONFIG;
+    const result = {};
+    for (const key of booleanKeys) {
+        const raw = metadata[getCustomKey(namespace, key)];
+        if (raw !== undefined)
+            result[key] = isTrue(raw);
+    }
+    for (const key of passthroughKeys) {
+        const raw = metadata[getCustomKey(namespace, key)];
+        if (raw !== undefined)
+            result[key] = raw;
+    }
+    return result;
+}
+/** Extract CodePipeline config from metadata. */
+function metadataForCodePipeline(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.CODE_PIPELINE);
+}
+/** Extract CodeBuildStep config from metadata. */
+function metadataForCodeBuildStep(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.CODE_BUILD_STEP);
+}
+/** Extract ShellStep config from metadata. */
+function metadataForShellStep(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.SHELL_STEP);
+}
+/** Extract BuildEnvironment config from metadata. */
+function metadataForBuildEnvironment(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.BUILD_ENVIRONMENT);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata-builder.js","sourceRoot":"","sources":["../../src/core/metadata-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BuildEnvironment } from 'aws-cdk-lib/aws-codebuild';\nimport type { CodeBuildStepProps, CodePipelineProps, ShellStepProps } from 'aws-cdk-lib/pipelines';\nimport { CDK_METADATA_PREFIX } from './pipeline-types';\nimport type { MetaDataType } from './pipeline-types';\n\n/**\n * Type-safe namespace constants for metadata configuration.\n */\nconst NAMESPACE = {\n  SHELL_STEP: 'pipelines:shellstep',\n  CODE_BUILD_STEP: 'pipelines:codebuildstep',\n  BUILD_ENVIRONMENT: 'codebuild:buildenvironment',\n  CODE_PIPELINE: 'pipelines:codepipeline',\n} as const;\ntype Namespace = (typeof NAMESPACE)[keyof typeof NAMESPACE];\n\ninterface NamespaceKeyConfig {\n  booleanKeys: readonly string[];\n  passthroughKeys: readonly string[];\n}\n\nconst NAMESPACE_KEY_MAP: Record<Namespace, NamespaceKeyConfig> = {\n  [NAMESPACE.SHELL_STEP]: {\n    booleanKeys: [],\n    passthroughKeys: ['additionalInputs', 'commands', 'env', 'envFromCfnOutputs', 'input', 'installCommands', 'primaryOutputDirectory'],\n  },\n  [NAMESPACE.CODE_BUILD_STEP]: {\n    booleanKeys: [],\n    passthroughKeys: ['actionRole', 'additionalInputs', 'buildEnvironment', 'cache', 'commands', 'env', 'envFromCfnOutputs', 'fileSystemLocations', 'input', 'installCommands', 'logging', 'partialBuildSpec', 'primaryOutputDirectory', 'projectName', 'role', 'rolePolicyStatements', 'timeout'],\n  },\n  [NAMESPACE.BUILD_ENVIRONMENT]: {\n    booleanKeys: ['privileged'],\n    passthroughKeys: ['buildImage', 'certificate', 'computeType', 'dockerServer', 'environmentVariables', 'fleet'],\n  },\n  [NAMESPACE.CODE_PIPELINE]: {\n    booleanKeys: ['crossAccountKeys', 'dockerEnabledForSelfMutation', 'dockerEnabledForSynth', 'enableKeyRotation', 'publishAssetsInParallel', 'reuseCrossRegionSupportStacks', 'selfMutation', 'useChangeSets', 'usePipelineRoleForActions'],\n    passthroughKeys: ['artifactBucket', 'assetPublishingCodeBuildDefaults', 'cdkAssetsCliVersion', 'cliVersion', 'codeBuildDefaults', 'codePipeline', 'crossRegionReplicationBuckets', 'dockerCredentials', 'pipelineName', 'pipelineType', 'role', 'selfMutationCodeBuildDefaults', 'synth', 'synthCodeBuildDefaults'],\n  },\n};\n\nconst EMPTY_KEY_CONFIG: NamespaceKeyConfig = { booleanKeys: [], passthroughKeys: [] };\n\nfunction getCustomKey(prefix: string, key: string): string {\n  return `${CDK_METADATA_PREFIX}${prefix}:${key}`.toLowerCase();\n}\n\nfunction isTrue(value: unknown): boolean {\n  if (typeof value === 'boolean') return value;\n  if (typeof value === 'string') return value.toLowerCase() === 'true';\n  return false;\n}\n\n/** Extract CDK construct config from metadata for a given namespace. */\nexport function buildConfigFromMetadata(\n  metadata: MetaDataType,\n  namespace: string,\n): Record<string, unknown> {\n  const { booleanKeys, passthroughKeys } =\n    NAMESPACE_KEY_MAP[namespace as Namespace] ?? EMPTY_KEY_CONFIG;\n\n  const result: Record<string, unknown> = {};\n\n  for (const key of booleanKeys) {\n    const raw = metadata[getCustomKey(namespace, key)];\n    if (raw !== undefined) result[key] = isTrue(raw);\n  }\n\n  for (const key of passthroughKeys) {\n    const raw = metadata[getCustomKey(namespace, key)];\n    if (raw !== undefined) result[key] = raw;\n  }\n\n  return result;\n}\n\n/** Extract CodePipeline config from metadata. */\nexport function metadataForCodePipeline(metadata: MetaDataType): Partial<CodePipelineProps> {\n  return buildConfigFromMetadata(metadata, NAMESPACE.CODE_PIPELINE) as Partial<CodePipelineProps>;\n}\n\n/** Extract CodeBuildStep config from metadata. */\nexport function metadataForCodeBuildStep(metadata: MetaDataType): Partial<CodeBuildStepProps> {\n  return buildConfigFromMetadata(metadata, NAMESPACE.CODE_BUILD_STEP) as Partial<CodeBuildStepProps>;\n}\n\n/** Extract ShellStep config from metadata. */\nexport function metadataForShellStep(metadata: MetaDataType): Partial<ShellStepProps> {\n  return buildConfigFromMetadata(metadata, NAMESPACE.SHELL_STEP) as Partial<ShellStepProps>;\n}\n\n/** Extract BuildEnvironment config from metadata. */\nexport function metadataForBuildEnvironment(metadata: MetaDataType): Partial<BuildEnvironment> {\n  return buildConfigFromMetadata(metadata, NAMESPACE.BUILD_ENVIRONMENT) as Partial<BuildEnvironment>;\n}\n"]}