@pipeline-builder/pipeline-core 3.1.0

package/lib/handlers/plugin-lookup-handler.js

@@ -0,0 +1,313 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+exports._resetCredentialsCache = _resetCredentialsCache;
+const client_secrets_manager_1 = require("@aws-sdk/client-secrets-manager");
+const axios_1 = __importStar(require("axios"));
+const app_config_1 = require("../config/app-config");
+/**
+ * Structured logger for Lambda (outputs JSON to CloudWatch).
+ * Debug messages only emitted when LOG_LEVEL=debug.
+ */
+function logEntry(level, tag, message, data) {
+    const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });
+    switch (level) {
+        case 'ERROR':
+            console.error(line);
+            break;
+        case 'DEBUG':
+            if (process.env.LOG_LEVEL === 'debug')
+                console.debug(line);
+            break;
+        default: console.log(line);
+    }
+}
+const lambdaLog = {
+    info: (tag, message, data) => logEntry('INFO', tag, message, data),
+    error: (tag, message, data) => logEntry('ERROR', tag, message, data),
+    debug: (tag, message, data) => logEntry('DEBUG', tag, message, data),
+};
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
+const RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */
+const PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;
+if (!PLATFORM_SECRET_NAME) {
+    throw new Error('PLATFORM_SECRET_NAME environment variable is required');
+}
+/** Cached token to avoid repeated Secrets Manager calls within a single invocation. */
+let cachedToken = null;
+/** @internal Reset cached token (for testing only). */
+function _resetCredentialsCache() { cachedToken = null; }
+/**
+ * Fetch JWT token from AWS Secrets Manager.
+ * Caches the result for the lifetime of the Lambda execution context.
+ *
+ * The secret name is set via PLATFORM_SECRET_NAME env var (e.g. `{prefix}/{orgId}/platform`)
+ * Create it with: `pipeline-manager store-token`
+ */
+async function getToken() {
+    if (cachedToken)
+        return cachedToken;
+    lambdaLog.info('AUTH', `Fetching token from Secrets Manager: ${PLATFORM_SECRET_NAME}`);
+    const client = new client_secrets_manager_1.SecretsManagerClient({});
+    const response = await client.send(new client_secrets_manager_1.GetSecretValueCommand({ SecretId: PLATFORM_SECRET_NAME }));
+    if (!response.SecretString) {
+        throw new Error(`Secret "${PLATFORM_SECRET_NAME}" is empty`);
+    }
+    const parsed = JSON.parse(response.SecretString);
+    if (!parsed.accessToken) {
+        throw new Error(`Secret "${PLATFORM_SECRET_NAME}" missing accessToken — run "pipeline-manager store-token" to generate`);
+    }
+    cachedToken = parsed.accessToken;
+    lambdaLog.info('AUTH', 'Token retrieved from Secrets Manager');
+    return cachedToken;
+}
+/**
+ * Creates a pre-configured Axios instance for API requests.
+ *
+ * @param baseURL - Base URL of the target API
+ * @param token - JWT token for authorization
+ * @returns Configured Axios instance
+ */
+function create(baseURL, token) {
+    return axios_1.default.create({
+        baseURL,
+        timeout: app_config_1.CoreConstants.HANDLER_TIMEOUT_MS,
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+    });
+}
+/**
+ * Fetches plugin configuration from the external API with retry logic.
+ * Retries on transient failures (429, 502, 503, 504, network errors)
+ * with exponential backoff.
+ *
+ * @param api - Configured Axios instance
+ * @param pluginFilter - Filter criteria for the plugin lookup
+ * @returns The plugin data returned by the API
+ * @throws Error on persistent failure, timeout or invalid response
+ */
+async function fetch(api, pluginFilter) {
+    lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });
+    let lastError;
+    for (let attempt = 0; attempt <= app_config_1.CoreConstants.HANDLER_MAX_RETRIES; attempt++) {
+        if (attempt > 0) {
+            const delay = app_config_1.CoreConstants.HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+            lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${app_config_1.CoreConstants.HANDLER_MAX_RETRIES + 1} after ${delay}ms`);
+            await sleep(delay);
+        }
+        try {
+            const { data, status } = await api.post('/api/plugins/lookup', {
+                filter: pluginFilter,
+            });
+            if (!data) {
+                throw new Error('Empty response data from API');
+            }
+            lambdaLog.info('FETCH', 'Plugin fetched successfully', {
+                status,
+                plugin: data.name,
+                version: data.version,
+                id: data.id,
+            });
+            return data;
+        }
+        catch (error) {
+            if (error instanceof axios_1.AxiosError) {
+                if (error.code === 'ECONNABORTED') {
+                    lambdaLog.error('FETCH', `Plugin lookup timed out after ${app_config_1.CoreConstants.HANDLER_TIMEOUT_MS}ms`);
+                    throw new Error(`Plugin lookup timed out after ${app_config_1.CoreConstants.HANDLER_TIMEOUT_MS}ms`);
+                }
+                const retryable = error.response
+                    ? RETRYABLE_STATUSES.has(error.response.status)
+                    : RETRYABLE_CODES.has(error.code ?? '');
+                const msg = error.response
+                    ? `API error ${error.response.status}: ${error.response.statusText}`
+                    : error.code || error.message;
+                if (retryable && attempt < app_config_1.CoreConstants.HANDLER_MAX_RETRIES) {
+                    lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });
+                    lastError = new Error(`Failed to fetch plugin: ${msg}`);
+                    continue;
+                }
+                lambdaLog.error('FETCH', msg, { responseData: error.response?.data });
+                throw new Error(`Failed to fetch plugin: ${msg}`);
+            }
+            throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');
+        }
+    }
+    throw lastError ?? new Error('Failed to fetch plugin after retries');
+}
+/**
+ * Validates the plugin filter object
+ *
+ * @param pluginFilter - Filter to validate
+ * @returns true if valid
+ * @throws Error if invalid
+ */
+function validatePluginFilter(pluginFilter) {
+    if (!pluginFilter || typeof pluginFilter !== 'object') {
+        throw new Error('Missing or invalid pluginFilter');
+    }
+    const filter = pluginFilter;
+    if (!filter.name && !filter.id && !filter.version && !filter.orgId) {
+        throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');
+    }
+    return true;
+}
+/**
+ * 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 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
+ *   }
+ * }
+ * ```
+ */
+const handler = async (event) => {
+    lambdaLog.info('START', `${event.RequestType} request received`, {
+        logicalResourceId: event.LogicalResourceId,
+        requestId: event.RequestId,
+        stackId: event.StackId,
+    });
+    const baseResponse = {
+        StackId: event.StackId,
+        RequestId: event.RequestId,
+        LogicalResourceId: event.LogicalResourceId,
+        PhysicalResourceId: event.LogicalResourceId,
+    };
+    try {
+        // Handle Delete - always succeed (no-op)
+        if (event.RequestType === 'Delete') {
+            lambdaLog.info('DELETE', 'No-op - returning SUCCESS');
+            return {
+                ...baseResponse,
+                Status: 'SUCCESS',
+                Reason: 'Delete completed (no-op)',
+            };
+        }
+        // Extract and validate properties
+        const pluginFilter = event.ResourceProperties.pluginFilter;
+        const baseURL = event.ResourceProperties.baseURL || app_config_1.CoreConstants.HANDLER_DEFAULT_BASE_URL;
+        if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {
+            throw new Error(`Invalid baseURL: "${baseURL}" — must start with http:// or https://`);
+        }
+        lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });
+        validatePluginFilter(pluginFilter);
+        // Get token from Secrets Manager and create API client
+        const token = await getToken();
+        const api = create(baseURL, token);
+        // Fetch plugin
+        lambdaLog.info('FETCH', 'Initiating plugin lookup...');
+        const plugin = await fetch(api, pluginFilter);
+        lambdaLog.info('FETCH', 'Plugin retrieved successfully', {
+            name: plugin.name,
+            version: plugin.version,
+            id: plugin.id,
+        });
+        // Strip large fields to stay within CloudFormation's 4096-byte Data limit.
+        // CDK constructs only need the fields used by createCodeBuildStep().
+        const slim = {
+            id: plugin.id,
+            name: plugin.name,
+            version: plugin.version,
+            pluginType: plugin.pluginType,
+            computeType: plugin.computeType,
+            commands: plugin.commands,
+            installCommands: plugin.installCommands,
+            env: plugin.env,
+            metadata: plugin.metadata,
+            primaryOutputDirectory: plugin.primaryOutputDirectory,
+            secrets: plugin.secrets,
+            failureBehavior: plugin.failureBehavior,
+            timeout: plugin.timeout,
+            imageTag: plugin.imageTag,
+        };
+        const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');
+        lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });
+        return {
+            ...baseResponse,
+            Status: 'SUCCESS',
+            Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,
+            Data: {
+                ResultValue: encoded,
+            },
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : 'Unexpected error occurred';
+        lambdaLog.error('ERROR', 'Handler failed', {
+            reason,
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        return {
+            ...baseResponse,
+            Status: 'FAILED',
+            Reason: reason,
+        };
+    }
+    finally {
+        lambdaLog.info('END', 'Custom resource execution completed');
+    }
+};
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-handler.js","sourceRoot":"","sources":["../../src/handlers/plugin-lookup-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';\nimport { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from 'aws-lambda';\nimport axios, { AxiosInstance, AxiosError } from 'axios';\nimport { CoreConstants } from '../config/app-config';\n\n/**\n * Structured logger for Lambda (outputs JSON to CloudWatch).\n * Debug messages only emitted when LOG_LEVEL=debug.\n */\nfunction logEntry(level: string, tag: string, message: string, data?: unknown) {\n  const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });\n  switch (level) {\n    case 'ERROR': console.error(line); break;\n    case 'DEBUG': if (process.env.LOG_LEVEL === 'debug') console.debug(line); break;\n    default: console.log(line);\n  }\n}\n\nconst lambdaLog = {\n  info: (tag: string, message: string, data?: unknown) => logEntry('INFO', tag, message, data),\n  error: (tag: string, message: string, data?: unknown) => logEntry('ERROR', tag, message, data),\n  debug: (tag: string, message: string, data?: unknown) => logEntry('DEBUG', tag, message, data),\n};\n\nconst RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);\nconst RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */\nconst PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;\nif (!PLATFORM_SECRET_NAME) {\n  throw new Error('PLATFORM_SECRET_NAME environment variable is required');\n}\n\n/** Cached token to avoid repeated Secrets Manager calls within a single invocation. */\nlet cachedToken: string | null = null;\n\n/** @internal Reset cached token (for testing only). */\nexport function _resetCredentialsCache(): void { cachedToken = null; }\n\n/**\n * Fetch JWT token from AWS Secrets Manager.\n * Caches the result for the lifetime of the Lambda execution context.\n *\n * The secret name is set via PLATFORM_SECRET_NAME env var (e.g. `{prefix}/{orgId}/platform`)\n * Create it with: `pipeline-manager store-token`\n */\nasync function getToken(): Promise<string> {\n  if (cachedToken) return cachedToken;\n\n  lambdaLog.info('AUTH', `Fetching token from Secrets Manager: ${PLATFORM_SECRET_NAME}`);\n\n  const client = new SecretsManagerClient({});\n  const response = await client.send(new GetSecretValueCommand({ SecretId: PLATFORM_SECRET_NAME }));\n\n  if (!response.SecretString) {\n    throw new Error(`Secret \"${PLATFORM_SECRET_NAME}\" is empty`);\n  }\n\n  const parsed = JSON.parse(response.SecretString) as Record<string, string>;\n  if (!parsed.accessToken) {\n    throw new Error(`Secret \"${PLATFORM_SECRET_NAME}\" missing accessToken — run \"pipeline-manager store-token\" to generate`);\n  }\n\n  cachedToken = parsed.accessToken;\n  lambdaLog.info('AUTH', 'Token retrieved from Secrets Manager');\n  return cachedToken;\n}\n\n/**\n * Creates a pre-configured Axios instance for API requests.\n *\n * @param baseURL - Base URL of the target API\n * @param token - JWT token for authorization\n * @returns Configured Axios instance\n */\nfunction create(baseURL: string, token: string): AxiosInstance {\n  return axios.create({\n    baseURL,\n    timeout: CoreConstants.HANDLER_TIMEOUT_MS,\n    headers: {\n      'Content-Type': 'application/json',\n      'Authorization': `Bearer ${token}`,\n    },\n  });\n}\n\n/**\n * Fetches plugin configuration from the external API with retry logic.\n * Retries on transient failures (429, 502, 503, 504, network errors)\n * with exponential backoff.\n *\n * @param api - Configured Axios instance\n * @param pluginFilter - Filter criteria for the plugin lookup\n * @returns The plugin data returned by the API\n * @throws Error on persistent failure, timeout or invalid response\n */\nasync function fetch(api: AxiosInstance, pluginFilter: PluginFilter): Promise<Plugin> {\n  lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });\n\n  let lastError: Error | undefined;\n\n  for (let attempt = 0; attempt <= CoreConstants.HANDLER_MAX_RETRIES; attempt++) {\n    if (attempt > 0) {\n      const delay = CoreConstants.HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);\n      lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${CoreConstants.HANDLER_MAX_RETRIES + 1} after ${delay}ms`);\n      await sleep(delay);\n    }\n\n    try {\n      const { data, status } = await api.post<Plugin>('/api/plugins/lookup', {\n        filter: pluginFilter,\n      });\n\n      if (!data) {\n        throw new Error('Empty response data from API');\n      }\n\n      lambdaLog.info('FETCH', 'Plugin fetched successfully', {\n        status,\n        plugin: data.name,\n        version: data.version,\n        id: data.id,\n      });\n\n      return data;\n    } catch (error) {\n      if (error instanceof AxiosError) {\n        if (error.code === 'ECONNABORTED') {\n          lambdaLog.error('FETCH', `Plugin lookup timed out after ${CoreConstants.HANDLER_TIMEOUT_MS}ms`);\n          throw new Error(`Plugin lookup timed out after ${CoreConstants.HANDLER_TIMEOUT_MS}ms`);\n        }\n\n        const retryable = error.response\n          ? RETRYABLE_STATUSES.has(error.response.status)\n          : RETRYABLE_CODES.has(error.code ?? '');\n\n        const msg = error.response\n          ? `API error ${error.response.status}: ${error.response.statusText}`\n          : error.code || error.message;\n\n        if (retryable && attempt < CoreConstants.HANDLER_MAX_RETRIES) {\n          lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });\n          lastError = new Error(`Failed to fetch plugin: ${msg}`);\n          continue;\n        }\n\n        lambdaLog.error('FETCH', msg, { responseData: error.response?.data });\n        throw new Error(`Failed to fetch plugin: ${msg}`);\n      }\n\n      throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');\n    }\n  }\n\n  throw lastError ?? new Error('Failed to fetch plugin after retries');\n}\n\n/**\n * Validates the plugin filter object\n *\n * @param pluginFilter - Filter to validate\n * @returns true if valid\n * @throws Error if invalid\n */\nfunction validatePluginFilter(pluginFilter: unknown): pluginFilter is PluginFilter {\n  if (!pluginFilter || typeof pluginFilter !== 'object') {\n    throw new Error('Missing or invalid pluginFilter');\n  }\n\n  const filter = pluginFilter as Record<string, unknown>;\n  if (!filter.name && !filter.id && !filter.version && !filter.orgId) {\n    throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');\n  }\n\n  return true;\n}\n\n/**\n * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.\n *\n * Authenticates using JWT token from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).\n * Create the secret with: `pipeline-manager store-token`\n *\n * Request Types:\n * - Create/Update: fetches and returns plugin configuration from API\n * - Delete: no-op (always succeeds)\n *\n * Response:\n * - Success: Returns base64-encoded plugin JSON in Data.ResultValue\n * - Failure: Returns error message in Reason\n *\n * @param event - CloudFormation custom resource event\n * @returns CloudFormation response\n *\n * @example\n * Custom Resource Properties:\n * ```json\n * {\n *   \"baseURL\": \"https://api.example.com\",\n *   \"pluginFilter\": {\n *     \"name\": \"nodejs-build\",\n *     \"version\": \"1.0.0\",\n *     \"isActive\": true\n *   }\n * }\n * ```\n */\nexport const handler = async (\n  event: CloudFormationCustomResourceEvent,\n): Promise<CloudFormationCustomResourceResponse> => {\n  lambdaLog.info('START', `${event.RequestType} request received`, {\n    logicalResourceId: event.LogicalResourceId,\n    requestId: event.RequestId,\n    stackId: event.StackId,\n  });\n\n  const baseResponse: Partial<CloudFormationCustomResourceResponse> = {\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    PhysicalResourceId: event.LogicalResourceId,\n  };\n\n  try {\n    // Handle Delete - always succeed (no-op)\n    if (event.RequestType === 'Delete') {\n      lambdaLog.info('DELETE', 'No-op - returning SUCCESS');\n      return {\n        ...baseResponse,\n        Status: 'SUCCESS',\n        Reason: 'Delete completed (no-op)',\n      } as CloudFormationCustomResourceResponse;\n    }\n\n    // Extract and validate properties\n    const pluginFilter = event.ResourceProperties.pluginFilter;\n    const baseURL = event.ResourceProperties.baseURL || CoreConstants.HANDLER_DEFAULT_BASE_URL;\n\n    if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {\n      throw new Error(`Invalid baseURL: \"${baseURL}\" — must start with http:// or https://`);\n    }\n\n    lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });\n\n    validatePluginFilter(pluginFilter);\n\n    // Get token from Secrets Manager and create API client\n    const token = await getToken();\n    const api = create(baseURL, token);\n\n    // Fetch plugin\n    lambdaLog.info('FETCH', 'Initiating plugin lookup...');\n    const plugin = await fetch(api, pluginFilter);\n    lambdaLog.info('FETCH', 'Plugin retrieved successfully', {\n      name: plugin.name,\n      version: plugin.version,\n      id: plugin.id,\n    });\n\n    // Strip large fields to stay within CloudFormation's 4096-byte Data limit.\n    // CDK constructs only need the fields used by createCodeBuildStep().\n    const slim = {\n      id: plugin.id,\n      name: plugin.name,\n      version: plugin.version,\n      pluginType: plugin.pluginType,\n      computeType: plugin.computeType,\n      commands: plugin.commands,\n      installCommands: plugin.installCommands,\n      env: plugin.env,\n      metadata: plugin.metadata,\n      primaryOutputDirectory: plugin.primaryOutputDirectory,\n      secrets: plugin.secrets,\n      failureBehavior: plugin.failureBehavior,\n      timeout: plugin.timeout,\n      imageTag: plugin.imageTag,\n    };\n\n    const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');\n    lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });\n\n    return {\n      ...baseResponse,\n      Status: 'SUCCESS',\n      Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,\n      Data: {\n        ResultValue: encoded,\n      },\n    } as CloudFormationCustomResourceResponse;\n  } catch (error) {\n    const reason = error instanceof Error ? error.message : 'Unexpected error occurred';\n    lambdaLog.error('ERROR', 'Handler failed', {\n      reason,\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n\n    return {\n      ...baseResponse,\n      Status: 'FAILED',\n      Reason: reason,\n    } as CloudFormationCustomResourceResponse;\n  } finally {\n    lambdaLog.info('END', 'Custom resource execution completed');\n  }\n};\n"]}

package/lib/handlers/pnpm-lock.yaml

@@ -0,0 +1,12 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies: {}
+
+packages: {}

package/lib/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module @pipeline-builder/pipeline-core
+ *
+ * Application configuration, pipeline domain types, and CDK constructs.
+ *
+ * **Config**
+ * - Config — application configuration singleton (environment-driven)
+ * - ConfigTypes — typed configuration interfaces
+ *
+ * **Types**
+ * - PipelineType, ComputeType, AccessModifier, PluginType — pipeline domain enums
+ * - NetworkTypes, RoleTypes, SecurityGroupTypes — infrastructure type definitions
+ * - SourceTypes, StepTypes — pipeline source and step configuration types
+ * - IdGenerator — deterministic ID generation
+ *
+ * **CDK Constructs**
+ * - PipelineBuilder — top-level CDK pipeline construct
+ * - StageBuilder — pipeline stage composition
+ * - PipelineConfiguration — pipeline config resolution
+ * - PluginLookup — plugin resolution for pipeline steps
+ * - ArtifactManager — build artifact management
+ *
+ * **Helpers**
+ * - replaceNonAlphanumeric, extractMetadataEnv — string and metadata utilities
+ * - buildConfigFromMetadata, metadataForCodePipeline, etc. — metadata builders
+ *
+ * **Re-exports from api-core**
+ * - ErrorCode, createLogger
+ *
+ * **Re-exports from pipeline-data**
+ * - db, schema, getConnection, closeConnection — database access
+ * - CrudService, BaseEntity — CRUD service infrastructure
+ * - All query condition builders and filter types
+ * - Compliance domain types (RuleSeverity, RuleTarget, etc.)
+ * - drizzleRows, drizzleCount — type helpers
+ */
+export * from './config/app-config';
+export * from './config/config-types';
+export * from './core/pipeline-types';
+export * from './core/network-types';
+export * from './core/role-types';
+export * from './core/security-group-types';
+export * from './core/id-generator';
+export { replaceNonAlphanumeric, extractMetadataEnv } from './core/pipeline-helpers';
+export { buildConfigFromMetadata, metadataForCodePipeline, metadataForCodeBuildStep, metadataForShellStep, metadataForBuildEnvironment, } from './core/metadata-builder';
+export * from './core/artifact-manager';
+export { ErrorCode, createLogger, } from '@pipeline-builder/api-core';
+export { db, getConnection, closeConnection, schema, buildPluginConditions, buildPipelineConditions, buildMessageConditions, validateMessageFilter, buildCompliancePolicyConditions, buildComplianceRuleConditions, buildComplianceExemptionConditions, buildComplianceAuditConditions, buildComplianceScanConditions, buildPublishedRuleCatalogConditions, buildComplianceRuleSubscriptionConditions, type PluginFilter, type PipelineFilter, type MessageFilter, type CompliancePolicyFilter, type ComplianceRuleFilter, type ComplianceExemptionFilter, type ComplianceAuditFilter, type ComplianceScanFilter, type ComplianceRuleSubscriptionFilter, type PluginSecret, type RuleSeverity, type RuleTarget, type RuleOperator, type RuleConditionMode, type RuleScope, type RuleCondition, type ComplianceRoleType, CrudService, type BaseEntity, drizzleRows, drizzleCount, } from '@pipeline-builder/pipeline-data';
+export * from './pipeline/source-types';
+export * from './pipeline/step-types';
+export * from './pipeline/stage-builder';
+export * from './pipeline/pipeline-builder';
+export * from './pipeline/plugin-lookup';
+export { PipelineConfiguration } from './pipeline/pipeline-configuration';

package/lib/index.js

@@ -0,0 +1,112 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineConfiguration = exports.drizzleCount = exports.drizzleRows = exports.CrudService = exports.buildComplianceRuleSubscriptionConditions = exports.buildPublishedRuleCatalogConditions = exports.buildComplianceScanConditions = exports.buildComplianceAuditConditions = exports.buildComplianceExemptionConditions = exports.buildComplianceRuleConditions = exports.buildCompliancePolicyConditions = exports.validateMessageFilter = exports.buildMessageConditions = exports.buildPipelineConditions = exports.buildPluginConditions = exports.schema = exports.closeConnection = exports.getConnection = exports.db = exports.createLogger = exports.ErrorCode = exports.metadataForBuildEnvironment = exports.metadataForShellStep = exports.metadataForCodeBuildStep = exports.metadataForCodePipeline = exports.buildConfigFromMetadata = exports.extractMetadataEnv = exports.replaceNonAlphanumeric = void 0;
+/**
+ * @module @pipeline-builder/pipeline-core
+ *
+ * Application configuration, pipeline domain types, and CDK constructs.
+ *
+ * **Config**
+ * - Config — application configuration singleton (environment-driven)
+ * - ConfigTypes — typed configuration interfaces
+ *
+ * **Types**
+ * - PipelineType, ComputeType, AccessModifier, PluginType — pipeline domain enums
+ * - NetworkTypes, RoleTypes, SecurityGroupTypes — infrastructure type definitions
+ * - SourceTypes, StepTypes — pipeline source and step configuration types
+ * - IdGenerator — deterministic ID generation
+ *
+ * **CDK Constructs**
+ * - PipelineBuilder — top-level CDK pipeline construct
+ * - StageBuilder — pipeline stage composition
+ * - PipelineConfiguration — pipeline config resolution
+ * - PluginLookup — plugin resolution for pipeline steps
+ * - ArtifactManager — build artifact management
+ *
+ * **Helpers**
+ * - replaceNonAlphanumeric, extractMetadataEnv — string and metadata utilities
+ * - buildConfigFromMetadata, metadataForCodePipeline, etc. — metadata builders
+ *
+ * **Re-exports from api-core**
+ * - ErrorCode, createLogger
+ *
+ * **Re-exports from pipeline-data**
+ * - db, schema, getConnection, closeConnection — database access
+ * - CrudService, BaseEntity — CRUD service infrastructure
+ * - All query condition builders and filter types
+ * - Compliance domain types (RuleSeverity, RuleTarget, etc.)
+ * - drizzleRows, drizzleCount — type helpers
+ */
+// Configuration
+__exportStar(require("./config/app-config"), exports);
+__exportStar(require("./config/config-types"), exports);
+// Core types (public surface)
+__exportStar(require("./core/pipeline-types"), exports);
+__exportStar(require("./core/network-types"), exports);
+__exportStar(require("./core/role-types"), exports);
+__exportStar(require("./core/security-group-types"), exports);
+__exportStar(require("./core/id-generator"), exports);
+var pipeline_helpers_1 = require("./core/pipeline-helpers");
+Object.defineProperty(exports, "replaceNonAlphanumeric", { enumerable: true, get: function () { return pipeline_helpers_1.replaceNonAlphanumeric; } });
+Object.defineProperty(exports, "extractMetadataEnv", { enumerable: true, get: function () { return pipeline_helpers_1.extractMetadataEnv; } });
+var metadata_builder_1 = require("./core/metadata-builder");
+Object.defineProperty(exports, "buildConfigFromMetadata", { enumerable: true, get: function () { return metadata_builder_1.buildConfigFromMetadata; } });
+Object.defineProperty(exports, "metadataForCodePipeline", { enumerable: true, get: function () { return metadata_builder_1.metadataForCodePipeline; } });
+Object.defineProperty(exports, "metadataForCodeBuildStep", { enumerable: true, get: function () { return metadata_builder_1.metadataForCodeBuildStep; } });
+Object.defineProperty(exports, "metadataForShellStep", { enumerable: true, get: function () { return metadata_builder_1.metadataForShellStep; } });
+Object.defineProperty(exports, "metadataForBuildEnvironment", { enumerable: true, get: function () { return metadata_builder_1.metadataForBuildEnvironment; } });
+__exportStar(require("./core/artifact-manager"), exports);
+// Re-export from api-core (only items consumed by external packages)
+var api_core_1 = require("@pipeline-builder/api-core");
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return api_core_1.ErrorCode; } });
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return api_core_1.createLogger; } });
+// Re-export database layer from pipeline-data (only items consumed externally)
+var pipeline_data_1 = require("@pipeline-builder/pipeline-data");
+// Database connection
+Object.defineProperty(exports, "db", { enumerable: true, get: function () { return pipeline_data_1.db; } });
+Object.defineProperty(exports, "getConnection", { enumerable: true, get: function () { return pipeline_data_1.getConnection; } });
+Object.defineProperty(exports, "closeConnection", { enumerable: true, get: function () { return pipeline_data_1.closeConnection; } });
+// Schema & tables
+Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return pipeline_data_1.schema; } });
+// Query builders
+Object.defineProperty(exports, "buildPluginConditions", { enumerable: true, get: function () { return pipeline_data_1.buildPluginConditions; } });
+Object.defineProperty(exports, "buildPipelineConditions", { enumerable: true, get: function () { return pipeline_data_1.buildPipelineConditions; } });
+Object.defineProperty(exports, "buildMessageConditions", { enumerable: true, get: function () { return pipeline_data_1.buildMessageConditions; } });
+Object.defineProperty(exports, "validateMessageFilter", { enumerable: true, get: function () { return pipeline_data_1.validateMessageFilter; } });
+Object.defineProperty(exports, "buildCompliancePolicyConditions", { enumerable: true, get: function () { return pipeline_data_1.buildCompliancePolicyConditions; } });
+Object.defineProperty(exports, "buildComplianceRuleConditions", { enumerable: true, get: function () { return pipeline_data_1.buildComplianceRuleConditions; } });
+Object.defineProperty(exports, "buildComplianceExemptionConditions", { enumerable: true, get: function () { return pipeline_data_1.buildComplianceExemptionConditions; } });
+Object.defineProperty(exports, "buildComplianceAuditConditions", { enumerable: true, get: function () { return pipeline_data_1.buildComplianceAuditConditions; } });
+Object.defineProperty(exports, "buildComplianceScanConditions", { enumerable: true, get: function () { return pipeline_data_1.buildComplianceScanConditions; } });
+Object.defineProperty(exports, "buildPublishedRuleCatalogConditions", { enumerable: true, get: function () { return pipeline_data_1.buildPublishedRuleCatalogConditions; } });
+Object.defineProperty(exports, "buildComplianceRuleSubscriptionConditions", { enumerable: true, get: function () { return pipeline_data_1.buildComplianceRuleSubscriptionConditions; } });
+// CRUD service
+Object.defineProperty(exports, "CrudService", { enumerable: true, get: function () { return pipeline_data_1.CrudService; } });
+// Drizzle type helpers
+Object.defineProperty(exports, "drizzleRows", { enumerable: true, get: function () { return pipeline_data_1.drizzleRows; } });
+Object.defineProperty(exports, "drizzleCount", { enumerable: true, get: function () { return pipeline_data_1.drizzleCount; } });
+// Pipeline (CDK constructs)
+__exportStar(require("./pipeline/source-types"), exports);
+__exportStar(require("./pipeline/step-types"), exports);
+__exportStar(require("./pipeline/stage-builder"), exports);
+__exportStar(require("./pipeline/pipeline-builder"), exports);
+__exportStar(require("./pipeline/plugin-lookup"), exports);
+var pipeline_configuration_1 = require("./pipeline/pipeline-configuration");
+Object.defineProperty(exports, "PipelineConfiguration", { enumerable: true, get: function () { return pipeline_configuration_1.PipelineConfiguration; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,82 @@
+import { CodePipeline } from 'aws-cdk-lib/pipelines';
+import { Construct } from 'constructs';
+import { PipelineConfiguration } from './pipeline-configuration';
+import type { StageOptions, SynthOptions } from './step-types';
+import type { CodeBuildDefaults } from '../core/network-types';
+import type { MetaDataType } from '../core/pipeline-types';
+import type { RoleConfig } from '../core/role-types';
+/**
+ * Configuration properties for the PipelineBuilder construct
+ */
+export interface BuilderProps {
+    /** Project identifier (will be sanitized to lowercase alphanumeric with underscores) */
+    readonly project: string;
+    /** Organization identifier (will be sanitized to lowercase alphanumeric with underscores) */
+    readonly organization: string;
+    /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */
+    readonly orgId?: string;
+    /** Pipeline database record ID — injected as PIPELINE_ID env var for autonomous synth */
+    readonly pipelineId?: string;
+    /** Optional custom pipeline name. Defaults to: {organization}-{project}-pipeline */
+    readonly pipelineName?: string;
+    /** Global metadata inherited by all pipeline steps */
+    readonly global?: MetaDataType;
+    /**
+     * Pipeline-level CodeBuild defaults applied to all CodeBuild actions
+     * (synth, self-mutation, asset publishing) via `codeBuildDefaults`.
+     */
+    readonly defaults?: CodeBuildDefaults;
+    /**
+     * Optional IAM role for the CodePipeline.
+     * When provided, resolves to a CDK IRole and is passed to the CodePipeline construct.
+     * When omitted, CDK auto-creates a role with the correct codepipeline.amazonaws.com principal.
+     */
+    readonly role?: RoleConfig;
+    /** Synthesis configuration including source and plugin details */
+    readonly synth: SynthOptions;
+    /**
+     * Optional pipeline stages, each containing one or more CodeBuild steps.
+     * Stages are added as waves to the CodePipeline after the synth step.
+     */
+    readonly stages?: StageOptions[];
+    /** Optional cron/rate expression for scheduled pipeline execution. */
+    readonly schedule?: string;
+    /** Custom tags applied to all pipeline resources. */
+    readonly tags?: Record<string, string>;
+}
+/**
+ * CDK construct that creates and configures a CodePipeline for continuous deployment.
+ *
+ * Features:
+ * - Multi-source support (S3, GitHub, CodeStar)
+ * - Plugin-based build steps
+ * - Metadata-driven configuration
+ * - Automatic tagging
+ * - Automatic sanitization of project and organization names
+ *
+ * @example
+ * ```typescript
+ * new PipelineBuilder(this, 'MyPipeline', {
+ *   project: 'my-app',
+ *   organization: 'my-org',
+ *   synth: {
+ *     source: {
+ *       type: 'github',
+ *       options: { repo: 'owner/repo', branch: 'main' }
+ *     },
+ *     plugin: { name: 'synth' }
+ *   }
+ * });
+ * ```
+ */
+export declare class PipelineBuilder extends Construct {
+    readonly pipeline: CodePipeline;
+    readonly config: PipelineConfiguration;
+    constructor(scope: Construct, id: string, props: BuilderProps);
+    /**
+     * Resolves CodeBuildDefaults into the shape expected by CDK's codeBuildDefaults.
+     * Combines network config, security groups, and pipeline-level environment variables
+     * (PIPELINE_ID, EXECUTION_ID, PLATFORM_BASE_URL) available to all CodeBuild actions.
+     */
+    private resolveDefaults;
+}