@pipeline-builder/pipeline-core 0.0.1

package/lib/core/artifact-manager.js

@@ -0,0 +1,83 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CodeBuildStep, FileSet, ShellStep } from 'aws-cdk-lib/pipelines';
+/**
+ * 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 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());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+/**
+ * Generates unique CDK construct IDs by appending auto-incrementing counters
+ * to labels, with an optional stack-identity hash inserted after the first
+ * namespace segment to prevent collisions across pipelines/orgs.
+ *
+ * Why the hash matters:
+ *   AWS resources with explicit names (CloudWatch log groups, IAM roles)
+ *   collide if two CDK stacks generate the same name. When org A's
+ *   spring-boot pipeline and org B's spring-boot pipeline both deploy a
+ *   `plugin-lookup-1` log group, the second deploy fails with
+ *   "Resource already exists". The hash makes each (project, org) pair
+ *   produce a unique stable name without changing the rest of the label.
+ *
+ * Format with org+project:
+ *   generate('plugin:lookup')   → 'plugin:{hash}:lookup:1'
+ *   generate('log:group')       → 'log:{hash}:group:1'
+ *   generate('plugin:lookup')   → 'plugin:{hash}:lookup:2'   (counter inc)
+ *   generate('cdk:pipeline:1')  → 'cdk:pipeline:1'           (already counted)
+ *
+ * @example
+ * ```typescript
+ * const id = new UniqueId({ organization: 'AcmeCorp', project: 'spring-boot' });
+ * id.generate('plugin:lookup');   // "plugin:a1b2c3d4:lookup:1"
+ * id.generate('log:group');       // "log:a1b2c3d4:group:1"
+ * id.generate('plugin:lookup');   // "plugin:a1b2c3d4:lookup:2"
+ * ```
+ */
+export interface UniqueIdOptions {
+    /** Organization name — combined with project to form the stack-identity hash. */
+    readonly organization: string;
+    /** Project name — combined with organization to form the stack-identity hash. */
+    readonly project: string;
+}
+export declare class UniqueId {
+    private readonly _counters;
+    private readonly _stackId;
+    constructor(opts: UniqueIdOptions);
+    /**
+     * 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; if a stack-identity
+     * hash was provided at construction, it's inserted after the first segment.
+     *
+     * @param label - Colon-separated namespace (e.g., 'plugin:lookup')
+     * @returns The label with hash + counter inserted
+     */
+    generate(label: string): string;
+    /** The stack-identity hash derived from organization + project. */
+    get stackId(): string;
+}

package/lib/core/id-generator.js

@@ -0,0 +1,50 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createHash } from 'crypto';
+export class UniqueId {
+    _counters = new Map();
+    _stackId;
+    constructor(opts) {
+        // 8 hex chars = 32 bits = 1 in 4 billion collision odds across pipelines.
+        // Lowercased for case-insensitive stability ("AcmeCorp" === "acmecorp").
+        this._stackId = createHash('sha256')
+            .update(`${opts.project}:${opts.organization}`.toLowerCase())
+            .digest('hex')
+            .slice(0, 8);
+    }
+    /**
+     * 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; if a stack-identity
+     * hash was provided at construction, it's inserted after the first segment.
+     *
+     * @param label - Colon-separated namespace (e.g., 'plugin:lookup')
+     * @returns The label with hash + counter inserted
+     */
+    generate(label) {
+        if (!label || typeof label !== 'string') {
+            throw new Error('Label must be a non-empty string');
+        }
+        // Already counted (e.g., 'cdk:pipeline:1') — pass through.
+        if (/:\d+$/.test(label)) {
+            return label;
+        }
+        const count = (this._counters.get(label) ?? 0) + 1;
+        this._counters.set(label, count);
+        // Insert the stack hash after the first namespace segment so the leading
+        // category (`plugin`, `log`, `resource`, etc.) stays human-readable.
+        const idx = label.indexOf(':');
+        if (idx === -1) {
+            // Single-segment label — put the hash before the counter.
+            return `${label}:${this._stackId}:${count}`;
+        }
+        const head = label.slice(0, idx);
+        const tail = label.slice(idx + 1);
+        return `${head}:${this._stackId}:${tail}:${count}`;
+    }
+    /** The stack-identity hash derived from organization + project. */
+    get stackId() {
+        return this._stackId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,48 @@
+import type { BuildEnvironment } from 'aws-cdk-lib/aws-codebuild';
+import type { CodeBuildStepProps, CodePipelineProps, ShellStepProps } from 'aws-cdk-lib/pipelines';
+import type { NetworkConfig } from './network-types.js';
+import type { MetaDataType } from './pipeline-types.js';
+import type { RoleConfig } from './role-types.js';
+import type { SecurityGroupConfig } from './security-group-types.js';
+/** 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>;
+/** Coerce a metadata value to a positive integer; undefined if absent/invalid. */
+export declare function asInt(v: unknown): number | undefined;
+/**
+ * Build a NetworkConfig from `ec2:network` metadata keys. The variant comes
+ * from NETWORK_TYPE, or is inferred (subnetIds -> subnetIds, tags -> vpcLookup,
+ * vpcId -> vpcId). Returns undefined when no usable network metadata is present.
+ */
+export declare function networkConfigFromMetadata(metadata: MetaDataType): NetworkConfig | undefined;
+/**
+ * Build a RoleConfig from `iam:role` metadata keys (roleArn / roleName /
+ * codeBuildDefault). The 4 keys can't express the full `oidc` option set, so an
+ * `oidc` type from metadata is ignored. Returns undefined when no keys are set.
+ */
+export declare function roleConfigFromMetadata(metadata: MetaDataType): RoleConfig | undefined;
+/**
+ * Build a SecurityGroupConfig from `ec2:securitygroup` metadata keys
+ * (securityGroupIds / securityGroupLookup). Returns undefined when no keys set.
+ */
+export declare function securityGroupConfigFromMetadata(metadata: MetaDataType): SecurityGroupConfig | undefined;
+/** A CodePipeline V2 pipeline-level variable parsed from `operations.variables`. */
+export interface PipelineVariableSpec {
+    name: string;
+    defaultValue?: string;
+    description?: string;
+}
+/**
+ * Parse `operations.variables` metadata into CodePipeline V2 variable specs.
+ * Accepts a JSON array (`[{"name":"ENV","default":"prod","description":"..."}]`)
+ * or a compact comma-separated `name=default` list (`ENV=prod,REGION=us-east-1`).
+ * Entries without a usable name are skipped; returns [] when nothing valid.
+ */
+export declare function parsePipelineVariables(value: unknown): PipelineVariableSpec[];

package/lib/core/metadata-builder.js

@@ -0,0 +1,278 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CDK_METADATA_PREFIX, MetadataKeys } from './pipeline-types.js';
+/**
+ * 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 `${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. */
+export 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. */
+export function metadataForCodePipeline(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.CODE_PIPELINE);
+}
+/** Extract CodeBuildStep config from metadata. */
+export function metadataForCodeBuildStep(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.CODE_BUILD_STEP);
+}
+/** Extract ShellStep config from metadata. */
+export function metadataForShellStep(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.SHELL_STEP);
+}
+/** Extract BuildEnvironment config from metadata. */
+export function metadataForBuildEnvironment(metadata) {
+    return buildConfigFromMetadata(metadata, NAMESPACE.BUILD_ENVIRONMENT);
+}
+// ---------------------------------------------------------------------------
+// Typed-config extractors: ec2:network / iam:role / ec2:securitygroup metadata
+// -> the discriminated-union config objects the builder already consumes
+// (NetworkConfig / RoleConfig / SecurityGroupConfig). Unlike the namespaces
+// above (which map 1:1 to CDK construct props), these feed resolveNetwork /
+// resolveRole / resolveSecurityGroup. Each returns undefined when its keys are
+// absent, so callers fall through with `prop ?? metadata ?? env` precedence.
+// ---------------------------------------------------------------------------
+function asStr(v) {
+    return typeof v === 'string' && v.trim() !== '' ? v : undefined;
+}
+/** Accept a JSON array or a comma-separated string -> string[] (undefined if empty). */
+function asList(v) {
+    const items = Array.isArray(v)
+        ? v.map(String).map(s => s.trim()).filter(Boolean)
+        : typeof v === 'string' && v.trim() !== ''
+            ? v.split(',').map(s => s.trim()).filter(Boolean)
+            : [];
+    return items.length > 0 ? items : undefined;
+}
+/** Accept a JSON object or a JSON string -> Record<string,string> (undefined if empty). */
+function asTags(v) {
+    let obj = v;
+    if (typeof v === 'string' && v.trim() !== '') {
+        try {
+            obj = JSON.parse(v);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        const entries = Object.entries(obj).map(([k, val]) => [k, String(val)]);
+        return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+    }
+    return undefined;
+}
+/** undefined when the key is absent; otherwise a coerced boolean. */
+function asBool(v) {
+    return v === undefined ? undefined : isTrue(v);
+}
+/** Coerce a metadata value to a positive integer; undefined if absent/invalid. */
+export function asInt(v) {
+    if (v === undefined || v === null || v === '')
+        return undefined;
+    const n = typeof v === 'number' ? v : Number(String(v).trim());
+    return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+/**
+ * Build a NetworkConfig from `ec2:network` metadata keys. The variant comes
+ * from NETWORK_TYPE, or is inferred (subnetIds -> subnetIds, tags -> vpcLookup,
+ * vpcId -> vpcId). Returns undefined when no usable network metadata is present.
+ */
+export function networkConfigFromMetadata(metadata) {
+    const type = asStr(metadata[MetadataKeys.NETWORK_TYPE]);
+    const vpcId = asStr(metadata[MetadataKeys.NETWORK_VPC_ID]);
+    const subnetIds = asList(metadata[MetadataKeys.NETWORK_SUBNET_IDS]);
+    const subnetType = asStr(metadata[MetadataKeys.NETWORK_SUBNET_TYPE]);
+    const availabilityZones = asList(metadata[MetadataKeys.NETWORK_AVAILABILITY_ZONES]);
+    const subnetGroupName = asStr(metadata[MetadataKeys.NETWORK_SUBNET_GROUP_NAME]);
+    const securityGroupIds = asList(metadata[MetadataKeys.NETWORK_SECURITY_GROUP_IDS]);
+    const tags = asTags(metadata[MetadataKeys.NETWORK_TAGS]);
+    const vpcName = asStr(metadata[MetadataKeys.NETWORK_VPC_NAME]);
+    const region = asStr(metadata[MetadataKeys.NETWORK_REGION]);
+    const variant = type ?? (subnetIds ? 'subnetIds' : tags ? 'vpcLookup' : vpcId ? 'vpcId' : undefined);
+    switch (variant) {
+        case 'subnetIds':
+            if (!vpcId || !subnetIds)
+                return undefined;
+            return { type: 'subnetIds', options: { vpcId, subnetIds, ...(securityGroupIds && { securityGroupIds }) } };
+        case 'vpcId':
+            if (!vpcId)
+                return undefined;
+            return {
+                type: 'vpcId',
+                options: {
+                    vpcId,
+                    ...(subnetType && { subnetType }),
+                    ...(availabilityZones && { availabilityZones }),
+                    ...(subnetGroupName && { subnetGroupName }),
+                    ...(securityGroupIds && { securityGroupIds }),
+                },
+            };
+        case 'vpcLookup':
+            if (!tags)
+                return undefined;
+            return {
+                type: 'vpcLookup',
+                options: {
+                    tags,
+                    ...(subnetType && { subnetType }),
+                    ...(availabilityZones && { availabilityZones }),
+                    ...(subnetGroupName && { subnetGroupName }),
+                    ...(securityGroupIds && { securityGroupIds }),
+                    ...(vpcName && { vpcName }),
+                    ...(region && { region }),
+                },
+            };
+        default:
+            return undefined;
+    }
+}
+/**
+ * Build a RoleConfig from `iam:role` metadata keys (roleArn / roleName /
+ * codeBuildDefault). The 4 keys can't express the full `oidc` option set, so an
+ * `oidc` type from metadata is ignored. Returns undefined when no keys are set.
+ */
+export function roleConfigFromMetadata(metadata) {
+    const type = asStr(metadata[MetadataKeys.ROLE_TYPE]);
+    const roleArn = asStr(metadata[MetadataKeys.ROLE_ARN]);
+    const roleName = asStr(metadata[MetadataKeys.ROLE_NAME]);
+    const mutable = asBool(metadata[MetadataKeys.ROLE_MUTABLE]);
+    const variant = type ?? (roleArn ? 'roleArn' : roleName ? 'roleName' : undefined);
+    switch (variant) {
+        case 'roleArn':
+            if (!roleArn)
+                return undefined;
+            return { type: 'roleArn', options: { roleArn, ...(mutable !== undefined && { mutable }) } };
+        case 'roleName':
+            if (!roleName)
+                return undefined;
+            return { type: 'roleName', options: { roleName, ...(mutable !== undefined && { mutable }) } };
+        case 'codeBuildDefault':
+            return { type: 'codeBuildDefault', options: { ...(roleName && { roleName }) } };
+        default:
+            return undefined;
+    }
+}
+/**
+ * Build a SecurityGroupConfig from `ec2:securitygroup` metadata keys
+ * (securityGroupIds / securityGroupLookup). Returns undefined when no keys set.
+ */
+export function securityGroupConfigFromMetadata(metadata) {
+    const type = asStr(metadata[MetadataKeys.SECURITY_GROUP_TYPE]);
+    const ids = asList(metadata[MetadataKeys.SECURITY_GROUP_IDS]);
+    const mutable = asBool(metadata[MetadataKeys.SECURITY_GROUP_MUTABLE]);
+    const name = asStr(metadata[MetadataKeys.SECURITY_GROUP_NAME]);
+    const vpcId = asStr(metadata[MetadataKeys.SECURITY_GROUP_VPC_ID]);
+    const variant = type ?? (ids ? 'securityGroupIds' : name ? 'securityGroupLookup' : undefined);
+    switch (variant) {
+        case 'securityGroupIds':
+            if (!ids)
+                return undefined;
+            return { type: 'securityGroupIds', options: { securityGroupIds: ids, ...(mutable !== undefined && { mutable }) } };
+        case 'securityGroupLookup':
+            if (!name || !vpcId)
+                return undefined;
+            return { type: 'securityGroupLookup', options: { securityGroupName: name, vpcId } };
+        default:
+            return undefined;
+    }
+}
+/**
+ * Parse `operations.variables` metadata into CodePipeline V2 variable specs.
+ * Accepts a JSON array (`[{"name":"ENV","default":"prod","description":"..."}]`)
+ * or a compact comma-separated `name=default` list (`ENV=prod,REGION=us-east-1`).
+ * Entries without a usable name are skipped; returns [] when nothing valid.
+ */
+export function parsePipelineVariables(value) {
+    if (value === undefined || value === null || value === '')
+        return [];
+    // Already an array (JSON-typed metadata) or a JSON-encoded string.
+    let parsed = value;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                parsed = value;
+            }
+        }
+    }
+    if (Array.isArray(parsed)) {
+        const specs = [];
+        for (const entry of parsed) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const e = entry;
+            const name = asStr(e.name);
+            if (!name)
+                continue;
+            const defaultValue = asStr(e.default) ?? asStr(e.defaultValue);
+            const description = asStr(e.description);
+            specs.push({ name, ...(defaultValue !== undefined && { defaultValue }), ...(description !== undefined && { description }) });
+        }
+        return specs;
+    }
+    // Compact `name=default` comma list.
+    if (typeof parsed === 'string') {
+        const specs = [];
+        for (const pair of parsed.split(',')) {
+            const idx = pair.indexOf('=');
+            const name = (idx === -1 ? pair : pair.slice(0, idx)).trim();
+            if (!name)
+                continue;
+            const defaultValue = idx === -1 ? undefined : pair.slice(idx + 1).trim();
+            specs.push({ name, ...(defaultValue ? { defaultValue } : {}) });
+        }
+        return specs;
+    }
+    return [];
+}
+//# 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 type { NetworkConfig, SubnetTypeName } from './network-types.js';\nimport { CDK_METADATA_PREFIX, MetadataKeys } from './pipeline-types.js';\nimport type { MetaDataType } from './pipeline-types.js';\nimport type { RoleConfig } from './role-types.js';\nimport type { SecurityGroupConfig } from './security-group-types.js';\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\n// ---------------------------------------------------------------------------\n// Typed-config extractors: ec2:network / iam:role / ec2:securitygroup metadata\n// -> the discriminated-union config objects the builder already consumes\n// (NetworkConfig / RoleConfig / SecurityGroupConfig). Unlike the namespaces\n// above (which map 1:1 to CDK construct props), these feed resolveNetwork /\n// resolveRole / resolveSecurityGroup. Each returns undefined when its keys are\n// absent, so callers fall through with `prop ?? metadata ?? env` precedence.\n// ---------------------------------------------------------------------------\n\nfunction asStr(v: unknown): string | undefined {\n  return typeof v === 'string' && v.trim() !== '' ? v : undefined;\n}\n\n/** Accept a JSON array or a comma-separated string -> string[] (undefined if empty). */\nfunction asList(v: unknown): string[] | undefined {\n  const items = Array.isArray(v)\n    ? v.map(String).map(s => s.trim()).filter(Boolean)\n    : typeof v === 'string' && v.trim() !== ''\n      ? v.split(',').map(s => s.trim()).filter(Boolean)\n      : [];\n  return items.length > 0 ? items : undefined;\n}\n\n/** Accept a JSON object or a JSON string -> Record<string,string> (undefined if empty). */\nfunction asTags(v: unknown): Record<string, string> | undefined {\n  let obj: unknown = v;\n  if (typeof v === 'string' && v.trim() !== '') {\n    try { obj = JSON.parse(v); } catch { return undefined; }\n  }\n  if (obj && typeof obj === 'object' && !Array.isArray(obj)) {\n    const entries = Object.entries(obj as Record<string, unknown>).map(([k, val]) => [k, String(val)] as const);\n    return entries.length > 0 ? Object.fromEntries(entries) : undefined;\n  }\n  return undefined;\n}\n\n/** undefined when the key is absent; otherwise a coerced boolean. */\nfunction asBool(v: unknown): boolean | undefined {\n  return v === undefined ? undefined : isTrue(v);\n}\n\n/** Coerce a metadata value to a positive integer; undefined if absent/invalid. */\nexport function asInt(v: unknown): number | undefined {\n  if (v === undefined || v === null || v === '') return undefined;\n  const n = typeof v === 'number' ? v : Number(String(v).trim());\n  return Number.isInteger(n) && n > 0 ? n : undefined;\n}\n\n/**\n * Build a NetworkConfig from `ec2:network` metadata keys. The variant comes\n * from NETWORK_TYPE, or is inferred (subnetIds -> subnetIds, tags -> vpcLookup,\n * vpcId -> vpcId). Returns undefined when no usable network metadata is present.\n */\nexport function networkConfigFromMetadata(metadata: MetaDataType): NetworkConfig | undefined {\n  const type = asStr(metadata[MetadataKeys.NETWORK_TYPE]);\n  const vpcId = asStr(metadata[MetadataKeys.NETWORK_VPC_ID]);\n  const subnetIds = asList(metadata[MetadataKeys.NETWORK_SUBNET_IDS]);\n  const subnetType = asStr(metadata[MetadataKeys.NETWORK_SUBNET_TYPE]) as SubnetTypeName | undefined;\n  const availabilityZones = asList(metadata[MetadataKeys.NETWORK_AVAILABILITY_ZONES]);\n  const subnetGroupName = asStr(metadata[MetadataKeys.NETWORK_SUBNET_GROUP_NAME]);\n  const securityGroupIds = asList(metadata[MetadataKeys.NETWORK_SECURITY_GROUP_IDS]);\n  const tags = asTags(metadata[MetadataKeys.NETWORK_TAGS]);\n  const vpcName = asStr(metadata[MetadataKeys.NETWORK_VPC_NAME]);\n  const region = asStr(metadata[MetadataKeys.NETWORK_REGION]);\n\n  const variant = type ?? (subnetIds ? 'subnetIds' : tags ? 'vpcLookup' : vpcId ? 'vpcId' : undefined);\n\n  switch (variant) {\n    case 'subnetIds':\n      if (!vpcId || !subnetIds) return undefined;\n      return { type: 'subnetIds', options: { vpcId, subnetIds, ...(securityGroupIds && { securityGroupIds }) } };\n    case 'vpcId':\n      if (!vpcId) return undefined;\n      return {\n        type: 'vpcId',\n        options: {\n          vpcId,\n          ...(subnetType && { subnetType }),\n          ...(availabilityZones && { availabilityZones }),\n          ...(subnetGroupName && { subnetGroupName }),\n          ...(securityGroupIds && { securityGroupIds }),\n        },\n      };\n    case 'vpcLookup':\n      if (!tags) return undefined;\n      return {\n        type: 'vpcLookup',\n        options: {\n          tags,\n          ...(subnetType && { subnetType }),\n          ...(availabilityZones && { availabilityZones }),\n          ...(subnetGroupName && { subnetGroupName }),\n          ...(securityGroupIds && { securityGroupIds }),\n          ...(vpcName && { vpcName }),\n          ...(region && { region }),\n        },\n      };\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Build a RoleConfig from `iam:role` metadata keys (roleArn / roleName /\n * codeBuildDefault). The 4 keys can't express the full `oidc` option set, so an\n * `oidc` type from metadata is ignored. Returns undefined when no keys are set.\n */\nexport function roleConfigFromMetadata(metadata: MetaDataType): RoleConfig | undefined {\n  const type = asStr(metadata[MetadataKeys.ROLE_TYPE]);\n  const roleArn = asStr(metadata[MetadataKeys.ROLE_ARN]);\n  const roleName = asStr(metadata[MetadataKeys.ROLE_NAME]);\n  const mutable = asBool(metadata[MetadataKeys.ROLE_MUTABLE]);\n\n  const variant = type ?? (roleArn ? 'roleArn' : roleName ? 'roleName' : undefined);\n\n  switch (variant) {\n    case 'roleArn':\n      if (!roleArn) return undefined;\n      return { type: 'roleArn', options: { roleArn, ...(mutable !== undefined && { mutable }) } };\n    case 'roleName':\n      if (!roleName) return undefined;\n      return { type: 'roleName', options: { roleName, ...(mutable !== undefined && { mutable }) } };\n    case 'codeBuildDefault':\n      return { type: 'codeBuildDefault', options: { ...(roleName && { roleName }) } };\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Build a SecurityGroupConfig from `ec2:securitygroup` metadata keys\n * (securityGroupIds / securityGroupLookup). Returns undefined when no keys set.\n */\nexport function securityGroupConfigFromMetadata(metadata: MetaDataType): SecurityGroupConfig | undefined {\n  const type = asStr(metadata[MetadataKeys.SECURITY_GROUP_TYPE]);\n  const ids = asList(metadata[MetadataKeys.SECURITY_GROUP_IDS]);\n  const mutable = asBool(metadata[MetadataKeys.SECURITY_GROUP_MUTABLE]);\n  const name = asStr(metadata[MetadataKeys.SECURITY_GROUP_NAME]);\n  const vpcId = asStr(metadata[MetadataKeys.SECURITY_GROUP_VPC_ID]);\n\n  const variant = type ?? (ids ? 'securityGroupIds' : name ? 'securityGroupLookup' : undefined);\n\n  switch (variant) {\n    case 'securityGroupIds':\n      if (!ids) return undefined;\n      return { type: 'securityGroupIds', options: { securityGroupIds: ids, ...(mutable !== undefined && { mutable }) } };\n    case 'securityGroupLookup':\n      if (!name || !vpcId) return undefined;\n      return { type: 'securityGroupLookup', options: { securityGroupName: name, vpcId } };\n    default:\n      return undefined;\n  }\n}\n\n/** A CodePipeline V2 pipeline-level variable parsed from `operations.variables`. */\nexport interface PipelineVariableSpec {\n  name: string;\n  defaultValue?: string;\n  description?: string;\n}\n\n/**\n * Parse `operations.variables` metadata into CodePipeline V2 variable specs.\n * Accepts a JSON array (`[{\"name\":\"ENV\",\"default\":\"prod\",\"description\":\"...\"}]`)\n * or a compact comma-separated `name=default` list (`ENV=prod,REGION=us-east-1`).\n * Entries without a usable name are skipped; returns [] when nothing valid.\n */\nexport function parsePipelineVariables(value: unknown): PipelineVariableSpec[] {\n  if (value === undefined || value === null || value === '') return [];\n\n  // Already an array (JSON-typed metadata) or a JSON-encoded string.\n  let parsed: unknown = value;\n  if (typeof value === 'string') {\n    const trimmed = value.trim();\n    if (trimmed.startsWith('[') || trimmed.startsWith('{')) {\n      try { parsed = JSON.parse(trimmed); } catch { parsed = value; }\n    }\n  }\n\n  if (Array.isArray(parsed)) {\n    const specs: PipelineVariableSpec[] = [];\n    for (const entry of parsed) {\n      if (!entry || typeof entry !== 'object') continue;\n      const e = entry as Record<string, unknown>;\n      const name = asStr(e.name);\n      if (!name) continue;\n      const defaultValue = asStr(e.default) ?? asStr(e.defaultValue);\n      const description = asStr(e.description);\n      specs.push({ name, ...(defaultValue !== undefined && { defaultValue }), ...(description !== undefined && { description }) });\n    }\n    return specs;\n  }\n\n  // Compact `name=default` comma list.\n  if (typeof parsed === 'string') {\n    const specs: PipelineVariableSpec[] = [];\n    for (const pair of parsed.split(',')) {\n      const idx = pair.indexOf('=');\n      const name = (idx === -1 ? pair : pair.slice(0, idx)).trim();\n      if (!name) continue;\n      const defaultValue = idx === -1 ? undefined : pair.slice(idx + 1).trim();\n      specs.push({ name, ...(defaultValue ? { defaultValue } : {}) });\n    }\n    return specs;\n  }\n\n  return [];\n}\n"]}

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

@@ -0,0 +1,31 @@
+/**
+ * Metadata and string helpers that are FREE of `aws-cdk-lib`.
+ *
+ * Split out of `pipeline-helpers.ts` (which builds CodeBuild steps and therefore
+ * pulls in the CDK) so the main `@pipeline-builder/pipeline-core` entry point can
+ * export them without putting `aws-cdk-lib` on every consumer's import graph.
+ * Anything here that needs a CDK type belongs in `pipeline-helpers.ts` instead.
+ */
+import { type MetaDataType } from './pipeline-types.js';
+/**
+ * Merge multiple metadata objects into one. Later sources override earlier ones.
+ */
+export declare function merge(...sources: Array<Partial<MetaDataType>>): MetaDataType;
+/**
+ * Extract non-namespaced metadata keys as environment variable strings.
+ * Keys starting with 'aws:cdk:' are reserved for CDK construct props
+ * (processed by metadata extraction functions) and are excluded here.
+ *
+ * All values are converted to strings for CodeBuild compatibility.
+ */
+export declare function extractMetadataEnv(metadata: MetaDataType): Record<string, string>;
+/** Resolve the effective failureBehavior: a scan/security-category plugin is pinned
+ *  to 'fail'; otherwise the authored value (default 'fail'). */
+export declare function resolveFailureBehavior(category?: string, authored?: 'fail' | 'warn' | 'ignore'): 'fail' | 'warn' | 'ignore';
+/**
+ * Replaces all characters that are not letters or numbers with the specified value
+ * @param input - The string to process
+ * @param replaceValue - The character(s) to replace non-alphanumeric characters with (default: '_')
+ * @returns The string with non-alphanumeric characters replaced
+ */
+export declare function replaceNonAlphanumeric(input: string, replaceValue?: string): string;