@pipeline-builder/pipeline-core 0.0.1

package/lib/core/role.js

@@ -0,0 +1,117 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Duration, Stack } from 'aws-cdk-lib';
+import { Effect, ManagedPolicy, OpenIdConnectPrincipal, OpenIdConnectProvider, PolicyStatement, Role, ServicePrincipal, } from 'aws-cdk-lib/aws-iam';
+import { Construct } from 'constructs';
+import { UniqueId } from './id-generator.js';
+import { Config } from '../config/app-config.js';
+/**
+ * Resolve a RoleConfig into a CDK IRole.
+ * Uses discriminated union narrowing to delegate to the appropriate CDK lookup.
+ *
+ * @param scope - CDK construct scope
+ * @param id - UniqueId instance for generating unique construct IDs
+ * @param config - Role configuration to resolve
+ * @returns Resolved CDK IRole ready to pass to CodePipeline
+ */
+export function resolveRole(scope, id, config) {
+    switch (config.type) {
+        case 'roleArn':
+            return Role.fromRoleArn(scope, id.generate('role:arn'), config.options.roleArn, {
+                mutable: config.options.mutable,
+            });
+        case 'roleName':
+            return Role.fromRoleName(scope, id.generate('role:name'), config.options.roleName, {
+                mutable: config.options.mutable,
+            });
+        case 'codeBuildDefault':
+            return createCodeBuildDefaultRole(scope, id, config.options);
+        case 'oidc':
+            return createOidcRole(scope, id, config.options);
+        default: {
+            const _exhaustive = config;
+            throw new Error(`Unknown role config type: ${_exhaustive.type}`);
+        }
+    }
+}
+/**
+ * Creates a new IAM role with CodeBuild service principal and CloudWatch Logs permissions.
+ */
+function createCodeBuildDefaultRole(scope, id, options) {
+    const role = new Role(scope, id.generate('role:codebuild'), {
+        assumedBy: new ServicePrincipal('codebuild.amazonaws.com'),
+        ...(options.roleName && { roleName: options.roleName }),
+    });
+    const stack = Stack.of(scope);
+    const logGroupPrefix = Config.get('aws').logging.groupName;
+    // Derive ARN pattern from the configured log group name (strip trailing segment for wildcard)
+    const logGroupPattern = logGroupPrefix.replace(/\/[^/]*$/, '/*');
+    role.addToPolicy(new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: [
+            'logs:CreateLogGroup',
+            'logs:CreateLogStream',
+            'logs:PutLogEvents',
+        ],
+        resources: [
+            `arn:aws:logs:${stack.region}:${stack.account}:log-group:${logGroupPattern}:*`,
+        ],
+    }));
+    return role;
+}
+/**
+ * Creates a new IAM role with an OIDC federated trust principal.
+ *
+ * Supports either referencing an existing OIDC provider by ARN
+ * or creating a new one from issuer URL + client IDs.
+ */
+function createOidcRole(scope, id, options) {
+    if (options.providerArn && options.issuer) {
+        throw new Error('OIDC role config must specify either providerArn or issuer, not both');
+    }
+    let provider;
+    if (options.providerArn) {
+        provider = OpenIdConnectProvider.fromOpenIdConnectProviderArn(scope, id.generate('oidc:provider'), options.providerArn);
+    }
+    else if (options.issuer) {
+        provider = new OpenIdConnectProvider(scope, id.generate('oidc:provider'), {
+            url: options.issuer,
+            clientIds: options.clientIds ?? ['sts.amazonaws.com'],
+            thumbprints: options.thumbprints,
+        });
+    }
+    else {
+        throw new Error('OIDC role config requires either providerArn or issuer');
+    }
+    const principal = new OpenIdConnectPrincipal(provider, {
+        ...(options.conditions && { StringEquals: options.conditions }),
+        ...(options.conditionsLike && { StringLike: options.conditionsLike }),
+    });
+    const role = new Role(scope, id.generate('role:oidc'), {
+        assumedBy: principal,
+        ...(options.roleName && { roleName: options.roleName }),
+        ...(options.description && { description: options.description }),
+        ...(options.maxSessionDuration && {
+            maxSessionDuration: Duration.seconds(options.maxSessionDuration),
+        }),
+        ...(options.permissionsBoundaryArn && {
+            permissionsBoundary: ManagedPolicy.fromManagedPolicyArn(scope, id.generate('oidc:boundary'), options.permissionsBoundaryArn),
+        }),
+    });
+    if (options.managedPolicyArns) {
+        for (const arn of options.managedPolicyArns) {
+            role.addManagedPolicy(ManagedPolicy.fromManagedPolicyArn(scope, id.generate('oidc:policy'), arn));
+        }
+    }
+    if (options.policyStatements) {
+        for (const stmt of options.policyStatements) {
+            role.addToPolicy(new PolicyStatement({
+                effect: stmt.effect === 'Deny' ? Effect.DENY : Effect.ALLOW,
+                actions: stmt.actions,
+                resources: stmt.resources,
+            }));
+        }
+    }
+    return role;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role.js","sourceRoot":"","sources":["../../src/core/role.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Duration, Stack } from 'aws-cdk-lib';\nimport {\n  Effect,\n  type IOpenIdConnectProvider,\n  type IRole,\n  ManagedPolicy,\n  OpenIdConnectPrincipal,\n  OpenIdConnectProvider,\n  PolicyStatement,\n  Role,\n  ServicePrincipal,\n} from 'aws-cdk-lib/aws-iam';\nimport { Construct } from 'constructs';\nimport { UniqueId } from './id-generator.js';\nimport type { CodeBuildDefaultRoleOptions, OidcRoleOptions, RoleConfig } from './role-types.js';\nimport { Config } from '../config/app-config.js';\n\n/**\n * Resolve a RoleConfig into a CDK IRole.\n * Uses discriminated union narrowing to delegate to the appropriate CDK lookup.\n *\n * @param scope - CDK construct scope\n * @param id - UniqueId instance for generating unique construct IDs\n * @param config - Role configuration to resolve\n * @returns Resolved CDK IRole ready to pass to CodePipeline\n */\nexport function resolveRole(\n  scope: Construct,\n  id: UniqueId,\n  config: RoleConfig,\n): IRole {\n  switch (config.type) {\n    case 'roleArn':\n      return Role.fromRoleArn(scope, id.generate('role:arn'), config.options.roleArn, {\n        mutable: config.options.mutable,\n      });\n    case 'roleName':\n      return Role.fromRoleName(scope, id.generate('role:name'), config.options.roleName, {\n        mutable: config.options.mutable,\n      });\n    case 'codeBuildDefault':\n      return createCodeBuildDefaultRole(scope, id, config.options);\n    case 'oidc':\n      return createOidcRole(scope, id, config.options);\n    default: {\n      const _exhaustive: never = config;\n      throw new Error(`Unknown role config type: ${(_exhaustive as RoleConfig).type}`);\n    }\n  }\n}\n\n/**\n * Creates a new IAM role with CodeBuild service principal and CloudWatch Logs permissions.\n */\nfunction createCodeBuildDefaultRole(\n  scope: Construct,\n  id: UniqueId,\n  options: CodeBuildDefaultRoleOptions,\n): IRole {\n  const role = new Role(scope, id.generate('role:codebuild'), {\n    assumedBy: new ServicePrincipal('codebuild.amazonaws.com'),\n    ...(options.roleName && { roleName: options.roleName }),\n  });\n\n  const stack = Stack.of(scope);\n  const logGroupPrefix = Config.get('aws').logging.groupName;\n  // Derive ARN pattern from the configured log group name (strip trailing segment for wildcard)\n  const logGroupPattern = logGroupPrefix.replace(/\\/[^/]*$/, '/*');\n  role.addToPolicy(\n    new PolicyStatement({\n      effect: Effect.ALLOW,\n      actions: [\n        'logs:CreateLogGroup',\n        'logs:CreateLogStream',\n        'logs:PutLogEvents',\n      ],\n      resources: [\n        `arn:aws:logs:${stack.region}:${stack.account}:log-group:${logGroupPattern}:*`,\n      ],\n    }),\n  );\n\n  return role;\n}\n\n/**\n * Creates a new IAM role with an OIDC federated trust principal.\n *\n * Supports either referencing an existing OIDC provider by ARN\n * or creating a new one from issuer URL + client IDs.\n */\nfunction createOidcRole(\n  scope: Construct,\n  id: UniqueId,\n  options: OidcRoleOptions,\n): IRole {\n  if (options.providerArn && options.issuer) {\n    throw new Error('OIDC role config must specify either providerArn or issuer, not both');\n  }\n\n  let provider: IOpenIdConnectProvider;\n\n  if (options.providerArn) {\n    provider = OpenIdConnectProvider.fromOpenIdConnectProviderArn(\n      scope,\n      id.generate('oidc:provider'),\n      options.providerArn,\n    );\n  } else if (options.issuer) {\n    provider = new OpenIdConnectProvider(scope, id.generate('oidc:provider'), {\n      url: options.issuer,\n      clientIds: options.clientIds ?? ['sts.amazonaws.com'],\n      thumbprints: options.thumbprints,\n    });\n  } else {\n    throw new Error('OIDC role config requires either providerArn or issuer');\n  }\n\n  const principal = new OpenIdConnectPrincipal(provider, {\n    ...(options.conditions && { StringEquals: options.conditions }),\n    ...(options.conditionsLike && { StringLike: options.conditionsLike }),\n  });\n\n  const role = new Role(scope, id.generate('role:oidc'), {\n    assumedBy: principal,\n    ...(options.roleName && { roleName: options.roleName }),\n    ...(options.description && { description: options.description }),\n    ...(options.maxSessionDuration && {\n      maxSessionDuration: Duration.seconds(options.maxSessionDuration),\n    }),\n    ...(options.permissionsBoundaryArn && {\n      permissionsBoundary: ManagedPolicy.fromManagedPolicyArn(\n        scope,\n        id.generate('oidc:boundary'),\n        options.permissionsBoundaryArn,\n      ),\n    }),\n  });\n\n  if (options.managedPolicyArns) {\n    for (const arn of options.managedPolicyArns) {\n      role.addManagedPolicy(ManagedPolicy.fromManagedPolicyArn(scope, id.generate('oidc:policy'), arn));\n    }\n  }\n\n  if (options.policyStatements) {\n    for (const stmt of options.policyStatements) {\n      role.addToPolicy(\n        new PolicyStatement({\n          effect: stmt.effect === 'Deny' ? Effect.DENY : Effect.ALLOW,\n          actions: stmt.actions,\n          resources: stmt.resources,\n        }),\n      );\n    }\n  }\n\n  return role;\n}\n"]}

package/lib/core/security-group-types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Security group configuration using explicit security group IDs
+ *
+ * Looks up existing security groups by their IDs via `SecurityGroup.fromSecurityGroupId`.
+ *
+ * @example
+ * ```typescript
+ * const sg: SecurityGroupIdsConfig = {
+ *   type: 'securityGroupIds',
+ *   options: {
+ *     securityGroupIds: ['sg-12345678', 'sg-87654321'],
+ *   }
+ * };
+ * ```
+ */
+export interface SecurityGroupIdsConfig {
+    readonly type: 'securityGroupIds';
+    readonly options: SecurityGroupIdsOptions;
+}
+/**
+ * Security group configuration using name-based lookup
+ *
+ * Looks up an existing security group by name and VPC ID
+ * via `SecurityGroup.fromLookupByName`.
+ *
+ * @example
+ * ```typescript
+ * const sg: SecurityGroupLookupConfig = {
+ *   type: 'securityGroupLookup',
+ *   options: {
+ *     securityGroupName: 'my-codebuild-sg',
+ *     vpcId: 'vpc-0a1b2c3d4e5f6a7b8',
+ *   }
+ * };
+ * ```
+ */
+export interface SecurityGroupLookupConfig {
+    readonly type: 'securityGroupLookup';
+    readonly options: SecurityGroupLookupOptions;
+}
+/**
+ * Configuration options for security group lookup by IDs
+ */
+export interface SecurityGroupIdsOptions {
+    /**
+     * List of security group IDs
+     * @example ['sg-12345678', 'sg-87654321']
+     */
+    readonly securityGroupIds: string[];
+    /**
+     * Whether the imported security groups can be modified by attaching
+     * ingress/egress rules. Set to false to avoid additional API calls
+     * during synthesis.
+     * @default true
+     */
+    readonly mutable?: boolean;
+}
+/**
+ * Configuration options for security group lookup by name
+ */
+export interface SecurityGroupLookupOptions {
+    /**
+     * Name of the security group to look up
+     * @example 'my-codebuild-sg'
+     */
+    readonly securityGroupName: string;
+    /**
+     * VPC ID that contains the security group.
+     * Required for name-based lookup.
+     * @example 'vpc-0a1b2c3d4e5f6a7b8'
+     */
+    readonly vpcId: string;
+}
+/**
+ * Union type of all supported security group configurations.
+ *
+ * Used at the pipeline level (`CodeBuildDefaults.securityGroups`) to specify
+ * security groups for CodeBuild actions.
+ *
+ * Each variant resolves to CDK `ISecurityGroup[]`:
+ * - SecurityGroupIdsConfig: Security groups looked up by IDs
+ * - SecurityGroupLookupConfig: Security group looked up by name + VPC
+ */
+export type SecurityGroupConfig = SecurityGroupIdsConfig | SecurityGroupLookupConfig;

package/lib/core/security-group-types.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/security-group.d.ts

@@ -0,0 +1,14 @@
+import { type ISecurityGroup } from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+import { UniqueId } from './id-generator.js';
+import type { SecurityGroupConfig } from './security-group-types.js';
+/**
+ * Resolve a SecurityGroupConfig into CDK ISecurityGroup[].
+ * Uses discriminated union narrowing to delegate to the appropriate CDK lookup.
+ *
+ * @param scope - CDK construct scope
+ * @param id - UniqueId instance for generating unique construct IDs
+ * @param config - Security group configuration to resolve
+ * @returns Resolved CDK ISecurityGroup array
+ */
+export declare function resolveSecurityGroup(scope: Construct, id: UniqueId, config: SecurityGroupConfig): ISecurityGroup[];

package/lib/core/security-group.js

@@ -0,0 +1,33 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { SecurityGroup, Vpc } from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+import { UniqueId } from './id-generator.js';
+/**
+ * Resolve a SecurityGroupConfig into CDK ISecurityGroup[].
+ * Uses discriminated union narrowing to delegate to the appropriate CDK lookup.
+ *
+ * @param scope - CDK construct scope
+ * @param id - UniqueId instance for generating unique construct IDs
+ * @param config - Security group configuration to resolve
+ * @returns Resolved CDK ISecurityGroup array
+ */
+export function resolveSecurityGroup(scope, id, config) {
+    switch (config.type) {
+        case 'securityGroupIds':
+            return config.options.securityGroupIds.map((sgId) => SecurityGroup.fromSecurityGroupId(scope, id.generate('sg:id'), sgId, { mutable: config.options.mutable }));
+        case 'securityGroupLookup': {
+            const vpc = Vpc.fromLookup(scope, id.generate('sg:vpc'), {
+                vpcId: config.options.vpcId,
+            });
+            return [
+                SecurityGroup.fromLookupByName(scope, id.generate('sg:lookup'), config.options.securityGroupName, vpc),
+            ];
+        }
+        default: {
+            const _exhaustive = config;
+            throw new Error(`Unknown security group config type: ${_exhaustive.type}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/handlers/plugin-lookup-handler.d.ts

@@ -0,0 +1,32 @@
+import type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from 'aws-lambda';
+/**
+ * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.
+ *
+ * Authenticates using JWT token from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).
+ * Create the secret with: `pipeline-manager infra store-token`
+ *
+ * Request Types:
+ * - Create/Update: fetches and returns plugin configuration from API
+ * - Delete: no-op (always succeeds)
+ *
+ * Response:
+ * - Success: Returns base64-encoded plugin JSON in Data.ResultValue
+ * - Failure: Returns error message in Reason
+ *
+ * @param event - CloudFormation custom resource event
+ * @returns CloudFormation response
+ *
+ * @example
+ * Custom Resource Properties:
+ * ```json
+ * {
+ *   "baseURL": "https://api.example.com",
+ *   "pluginFilter": {
+ *     "name": "nodejs-build",
+ *     "version": "1.0.0",
+ *     "isActive": true
+ *   }
+ * }
+ * ```
+ */
+export declare const handler: (event: CloudFormationCustomResourceEvent) => Promise<CloudFormationCustomResourceResponse>;