@pipeline-builder/pipeline-core 0.0.1

package/lib/config/app-config.js

@@ -0,0 +1,197 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MAX_PAGE_LIMIT as SHARED_MAX_PAGE_LIMIT, DEFAULT_PAGE_LIMIT as SHARED_DEFAULT_PAGE_LIMIT } from '@pipeline-builder/api-core';
+import { loadBillingConfig } from './billing-config.js';
+import * as HandlerConstants from './handler-constants.js';
+import { loadRegistryConfig, loadRedisConfig, loadPluginBuildConfig, loadDockerConfig, loadDatabaseConfig, loadObservabilityConfig, loadComplianceConfig, loadAWSConfig, } from './infrastructure-config.js';
+import { loadServerConfig, loadAuthConfig, loadRateLimitConfig, validateServerConfig, validateAuthConfig, } from './server-config.js';
+/**
+ * Core constants — configurable via environment variables with sensible defaults.
+ */
+export class CoreConstants {
+    static NAME_PATTERN = /^[a-z0-9-]+$/;
+    // Supported JWT algorithms
+    static ALLOWED_JWT_ALGORITHMS = ['HS256', 'RS256', 'ES256'];
+    // Custom Resource Handler configuration (must be less than Lambda timeout of 30s to allow response handling).
+    // Sourced from the dependency-free `handler-constants.ts` leaf — the Lambda handler imports that module
+    // directly (not this one) so its esbuild bundle never pulls in aws-cdk-lib via infrastructure-config.
+    static HANDLER_TIMEOUT_MS = HandlerConstants.HANDLER_TIMEOUT_MS;
+    /** Default platform URL fallback when PLATFORM_BASE_URL is not set. */
+    static DEFAULT_PLATFORM_URL = HandlerConstants.DEFAULT_PLATFORM_URL;
+    static HANDLER_DEFAULT_BASE_URL = HandlerConstants.HANDLER_DEFAULT_BASE_URL;
+    static HANDLER_MAX_RETRIES = HandlerConstants.HANDLER_MAX_RETRIES;
+    static HANDLER_RETRY_DELAY_MS = HandlerConstants.HANDLER_RETRY_DELAY_MS;
+    // Plugin build queue configuration.
+    // NOTE: maxAttempts / backoffDelayMs / workerTimeoutMs are NOT duplicated here —
+    // `loadPluginBuildConfig` (infrastructure-config.ts) is their single source of
+    // truth, read via `Config.get('pluginBuild')`.
+    static PLUGIN_BUILD_QUEUE_NAME = process.env.PLUGIN_BUILD_QUEUE_NAME || 'plugin-build';
+    static PLUGIN_BUILD_COMPLETED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_COMPLETED_RETENTION_SECS || '3600', 10); // 1 hr
+    static PLUGIN_BUILD_FAILED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_FAILED_RETENTION_SECS || '86400', 10); // 24 hr
+    // Pagination and limits — single source in api-core (validation/common-schemas)
+    // so the validation layer, this config, and pipeline-data's CrudService never drift.
+    static MAX_PAGE_LIMIT = SHARED_MAX_PAGE_LIMIT;
+    static DEFAULT_PAGE_LIMIT = SHARED_DEFAULT_PAGE_LIMIT;
+    static MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);
+    static PLUGIN_MAX_UPLOAD_MB = parseInt(process.env.PLUGIN_MAX_UPLOAD_MB || '4096', 10);
+    static PIPELINE_NAME_MAX_LENGTH = parseInt(process.env.PIPELINE_NAME_MAX_LENGTH || '100', 10);
+    static DEFAULT_PLUGIN_VERSION = process.env.DEFAULT_PLUGIN_VERSION || '1.0.0';
+    // SSE stream timeout for AI generation endpoints
+    static SSE_STREAM_TIMEOUT_MS = parseInt(process.env.SSE_STREAM_TIMEOUT_MS || '300000', 10); // 5 min
+    // Git provider API base URLs (configurable for enterprise instances)
+    static GITHUB_API_BASE_URL = process.env.GITHUB_API_BASE_URL || 'https://api.github.com';
+    static BITBUCKET_API_BASE_URL = process.env.BITBUCKET_API_BASE_URL || 'https://api.bitbucket.org/2.0';
+    // Bulk operations and event ingestion
+    static MAX_BULK_ITEMS = parseInt(process.env.MAX_BULK_ITEMS || '100', 10);
+    static MAX_EVENTS_PER_BATCH = parseInt(process.env.MAX_EVENTS_PER_BATCH || '100', 10);
+    static DEFAULT_REPORT_RANGE_DAYS = parseInt(process.env.DEFAULT_REPORT_RANGE_DAYS || '30', 10);
+    // Secrets Manager path prefix for org-scoped secrets
+    static SECRETS_PATH_PREFIX = process.env.SECRETS_PATH_PREFIX || 'pipeline-builder';
+    /** Build a Secrets Manager path: {prefix}/{orgId}/{name} */
+    static secretPath(orgId, name) {
+        return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/${name}`;
+    }
+    // Database connection
+    static DB_MAX_RETRIES = parseInt(process.env.DB_MAX_RETRIES || '3', 10);
+    static DB_RETRY_DELAY_MS = parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10); // 1s
+    static DB_TRANSACTION_TIMEOUT_MS = parseInt(process.env.DB_TRANSACTION_TIMEOUT_MS || '30000', 10); // 30s
+    static DB_CLOSE_TIMEOUT_MS = parseInt(process.env.DB_CLOSE_TIMEOUT_MS || '5000', 10); // 5s
+    // Response compression
+    static COMPRESSION_THRESHOLD_BYTES = parseInt(process.env.COMPRESSION_THRESHOLD_BYTES || '1024', 10);
+    // Idempotency
+    static IDEMPOTENCY_TTL_MS = parseInt(process.env.IDEMPOTENCY_TTL_MS || '300000', 10); // 5 min
+    static IDEMPOTENCY_MAX_STORE_SIZE = parseInt(process.env.IDEMPOTENCY_MAX_STORE_SIZE || '10000', 10);
+    static IDEMPOTENCY_CLEANUP_INTERVAL_MS = parseInt(process.env.IDEMPOTENCY_CLEANUP_INTERVAL_MS || '60000', 10); // 1 min
+    // Cache
+    static CACHE_CLEANUP_INTERVAL_MS = parseInt(process.env.CACHE_CLEANUP_INTERVAL_MS || '30000', 10); // 30s
+    // Server-side cache TTLs (seconds)
+    static CACHE_TTL_ENTITY = parseInt(process.env.CACHE_TTL_ENTITY || '60', 10); // plugin/pipeline findById
+    static CACHE_TTL_MESSAGE = parseInt(process.env.CACHE_TTL_MESSAGE || '300', 10); // announcements/conversations (5 min)
+    static CACHE_TTL_REPORT_INVENTORY = parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10); // plugin summary/distribution (5 min)
+    static CACHE_TTL_REPORT_TIMESERIES = parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10); // execution/build metrics (2 min)
+    static CACHE_TTL_COMPLIANCE_RULES = parseInt(process.env.CACHE_TTL_COMPLIANCE_RULES || '60', 10); // active compliance rules
+    static CACHE_TTL_BILLING_PLANS = parseInt(process.env.CACHE_TTL_BILLING_PLANS || '14400', 10); // billing plans (4 hours)
+    // SSE backpressure
+    static SSE_BACKPRESSURE_THRESHOLD = parseInt(process.env.SSE_BACKPRESSURE_THRESHOLD || '10', 10);
+    // HTTP Cache-Control headers
+    static CACHE_CONTROL_LIST = process.env.CACHE_CONTROL_LIST || 'private, max-age=30, stale-while-revalidate=60';
+    static CACHE_CONTROL_DETAIL = process.env.CACHE_CONTROL_DETAIL || 'private, max-age=60, stale-while-revalidate=120';
+}
+/**
+ * Per-section loader map — each section is loaded lazily on first access.
+ * This avoids loading all config sections (and their required env vars)
+ * when only one section is needed (e.g. CDK synthesis only needs 'aws').
+ */
+const sectionLoaders = {
+    server: loadServerConfig,
+    auth: loadAuthConfig,
+    database: loadDatabaseConfig,
+    registry: loadRegistryConfig,
+    redis: loadRedisConfig,
+    pluginBuild: loadPluginBuildConfig,
+    dockerConfig: loadDockerConfig,
+    observability: loadObservabilityConfig,
+    compliance: loadComplianceConfig,
+    aws: loadAWSConfig,
+    rateLimit: loadRateLimitConfig,
+    billing: loadBillingConfig,
+};
+/** Per-section validators — only run for sections that have validation logic. */
+const sectionValidators = {
+    server: validateServerConfig,
+};
+/**
+ * Configuration facade with lazy per-section loading.
+ *
+ * Each section is loaded and validated independently on first access,
+ * so requesting `Config.get('aws')` does not trigger loading of
+ * server, auth, or billing config (and their env var requirements).
+ *
+ * Usage: `Config.get('server')`, `Config.get('auth')`, etc.
+ */
+export class Config {
+    static cache = new Map();
+    /**
+     * Get a specific configuration section (loaded lazily on first access).
+     */
+    static get(section) {
+        if (!this.cache.has(section)) {
+            const loader = sectionLoaders[section];
+            const value = loader();
+            const validator = sectionValidators[section];
+            if (validator)
+                validator(value);
+            this.cache.set(section, value);
+        }
+        return this.cache.get(section);
+    }
+    /**
+     * Merge a partial override into a config section, taking precedence over the
+     * env-loaded values for all subsequent `Config.get(section)` calls.
+     *
+     * Used at CDK synth start to inject platform-sourced infrastructure config
+     * (e.g. the registry pull host derived from the platform's public URL) so the
+     * synth does not silently depend on the operator's local `process.env`.
+     * `undefined` fields in `partial` are ignored so they never clobber a loaded
+     * value. Loads (and validates) the section first so the override merges onto
+     * the real defaults.
+     */
+    static override(section, partial) {
+        const current = this.get(section);
+        const defined = Object.fromEntries(Object.entries(partial).filter(([, v]) => v !== undefined));
+        this.cache.set(section, { ...current, ...defined });
+    }
+    /**
+     * Like {@link override}, but scoped: snapshots the current cache state for
+     * `section` and returns a restore function that reverts it. Use around a
+     * single unit of work (e.g. one CDK PipelineBuilder's synth) so a per-builder
+     * override does NOT leak into the process-wide cache and bleed into sibling
+     * builders in a multi-pipeline CDK app. Calling the returned function restores
+     * the exact prior state — the previously cached value, or an unloaded section
+     * if it had not been cached yet (so the next `get()` re-loads from env).
+     */
+    static overrideScoped(section, partial) {
+        const hadCached = this.cache.has(section);
+        const previous = hadCached ? this.cache.get(section) : undefined;
+        this.override(section, partial);
+        return () => {
+            if (hadCached)
+                this.cache.set(section, previous);
+            else
+                this.cache.delete(section);
+        };
+    }
+    /**
+     * Clear all cached config sections so the next `Config.get()` re-reads them
+     * from the current `process.env` (re-running each section's loader + validator).
+     *
+     * Use when env has been mutated in-process and the cache is now stale — e.g. a
+     * long-running CLI that reconfigures between operations. CDK synth runs in a
+     * fresh subprocess that already reads env on first access, so it does not need
+     * this. Note: this also drops any values set via {@link override}.
+     */
+    static reload() {
+        this.cache.clear();
+    }
+    /**
+     * @internal Reset configuration (for testing only). Alias for {@link reload}.
+     */
+    static _resetForTesting() {
+        this.reload();
+    }
+    /**
+     * Validate auth configuration (JWT secrets, algorithms, expiration).
+     * Call this at server startup, not during CDK synthesis.
+     */
+    static validateAuth() {
+        validateAuthConfig(this.get('auth'));
+    }
+    /**
+     * Untyped config access — use when the published package types don't include a new section yet.
+     * Avoids the `(Config as unknown as ...).get(...)` cast pattern in consumers.
+     */
+    static getAny(section) {
+        return this.get(section);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-config.js","sourceRoot":"","sources":["../../src/config/app-config.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { MAX_PAGE_LIMIT as SHARED_MAX_PAGE_LIMIT, DEFAULT_PAGE_LIMIT as SHARED_DEFAULT_PAGE_LIMIT } from '@pipeline-builder/api-core';\nimport type { Algorithm } from 'jsonwebtoken';\nimport { loadBillingConfig } from './billing-config.js';\nimport type { AppConfig } from './config-types.js';\nimport * as HandlerConstants from './handler-constants.js';\nimport {\n  loadRegistryConfig,\n  loadRedisConfig,\n  loadPluginBuildConfig,\n  loadDockerConfig,\n  loadDatabaseConfig,\n  loadObservabilityConfig,\n  loadComplianceConfig,\n  loadAWSConfig,\n} from './infrastructure-config.js';\nimport {\n  loadServerConfig,\n  loadAuthConfig,\n  loadRateLimitConfig,\n  validateServerConfig,\n  validateAuthConfig,\n} from './server-config.js';\n\n/**\n * Core constants — configurable via environment variables with sensible defaults.\n */\nexport class CoreConstants {\n  static readonly NAME_PATTERN = /^[a-z0-9-]+$/;\n\n  // Supported JWT algorithms\n  static readonly ALLOWED_JWT_ALGORITHMS: Algorithm[] = ['HS256', 'RS256', 'ES256'];\n\n  // Custom Resource Handler configuration (must be less than Lambda timeout of 30s to allow response handling).\n  // Sourced from the dependency-free `handler-constants.ts` leaf — the Lambda handler imports that module\n  // directly (not this one) so its esbuild bundle never pulls in aws-cdk-lib via infrastructure-config.\n  static readonly HANDLER_TIMEOUT_MS = HandlerConstants.HANDLER_TIMEOUT_MS;\n  /** Default platform URL fallback when PLATFORM_BASE_URL is not set. */\n  static readonly DEFAULT_PLATFORM_URL = HandlerConstants.DEFAULT_PLATFORM_URL;\n\n  static readonly HANDLER_DEFAULT_BASE_URL = HandlerConstants.HANDLER_DEFAULT_BASE_URL;\n  static readonly HANDLER_MAX_RETRIES = HandlerConstants.HANDLER_MAX_RETRIES;\n  static readonly HANDLER_RETRY_DELAY_MS = HandlerConstants.HANDLER_RETRY_DELAY_MS;\n\n  // Plugin build queue configuration.\n  // NOTE: maxAttempts / backoffDelayMs / workerTimeoutMs are NOT duplicated here —\n  // `loadPluginBuildConfig` (infrastructure-config.ts) is their single source of\n  // truth, read via `Config.get('pluginBuild')`.\n  static readonly PLUGIN_BUILD_QUEUE_NAME = process.env.PLUGIN_BUILD_QUEUE_NAME || 'plugin-build';\n  static readonly PLUGIN_BUILD_COMPLETED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_COMPLETED_RETENTION_SECS || '3600', 10); // 1 hr\n  static readonly PLUGIN_BUILD_FAILED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_FAILED_RETENTION_SECS || '86400', 10); // 24 hr\n\n  // Pagination and limits — single source in api-core (validation/common-schemas)\n  // so the validation layer, this config, and pipeline-data's CrudService never drift.\n  static readonly MAX_PAGE_LIMIT = SHARED_MAX_PAGE_LIMIT;\n  static readonly DEFAULT_PAGE_LIMIT = SHARED_DEFAULT_PAGE_LIMIT;\n  static readonly MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);\n  static readonly PLUGIN_MAX_UPLOAD_MB = parseInt(process.env.PLUGIN_MAX_UPLOAD_MB || '4096', 10);\n  static readonly PIPELINE_NAME_MAX_LENGTH = parseInt(process.env.PIPELINE_NAME_MAX_LENGTH || '100', 10);\n  static readonly DEFAULT_PLUGIN_VERSION = process.env.DEFAULT_PLUGIN_VERSION || '1.0.0';\n\n  // SSE stream timeout for AI generation endpoints\n  static readonly SSE_STREAM_TIMEOUT_MS = parseInt(process.env.SSE_STREAM_TIMEOUT_MS || '300000', 10); // 5 min\n\n  // Git provider API base URLs (configurable for enterprise instances)\n  static readonly GITHUB_API_BASE_URL = process.env.GITHUB_API_BASE_URL || 'https://api.github.com';\n  static readonly BITBUCKET_API_BASE_URL = process.env.BITBUCKET_API_BASE_URL || 'https://api.bitbucket.org/2.0';\n\n  // Bulk operations and event ingestion\n  static readonly MAX_BULK_ITEMS = parseInt(process.env.MAX_BULK_ITEMS || '100', 10);\n  static readonly MAX_EVENTS_PER_BATCH = parseInt(process.env.MAX_EVENTS_PER_BATCH || '100', 10);\n  static readonly DEFAULT_REPORT_RANGE_DAYS = parseInt(process.env.DEFAULT_REPORT_RANGE_DAYS || '30', 10);\n\n  // Secrets Manager path prefix for org-scoped secrets\n  static readonly SECRETS_PATH_PREFIX = process.env.SECRETS_PATH_PREFIX || 'pipeline-builder';\n\n  /** Build a Secrets Manager path: {prefix}/{orgId}/{name} */\n  static secretPath(orgId: string, name: string): string {\n    return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/${name}`;\n  }\n\n  // Database connection\n  static readonly DB_MAX_RETRIES = parseInt(process.env.DB_MAX_RETRIES || '3', 10);\n  static readonly DB_RETRY_DELAY_MS = parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10); // 1s\n  static readonly DB_TRANSACTION_TIMEOUT_MS = parseInt(process.env.DB_TRANSACTION_TIMEOUT_MS || '30000', 10); // 30s\n  static readonly DB_CLOSE_TIMEOUT_MS = parseInt(process.env.DB_CLOSE_TIMEOUT_MS || '5000', 10); // 5s\n\n  // Response compression\n  static readonly COMPRESSION_THRESHOLD_BYTES = parseInt(process.env.COMPRESSION_THRESHOLD_BYTES || '1024', 10);\n\n  // Idempotency\n  static readonly IDEMPOTENCY_TTL_MS = parseInt(process.env.IDEMPOTENCY_TTL_MS || '300000', 10); // 5 min\n  static readonly IDEMPOTENCY_MAX_STORE_SIZE = parseInt(process.env.IDEMPOTENCY_MAX_STORE_SIZE || '10000', 10);\n  static readonly IDEMPOTENCY_CLEANUP_INTERVAL_MS = parseInt(process.env.IDEMPOTENCY_CLEANUP_INTERVAL_MS || '60000', 10); // 1 min\n\n  // Cache\n  static readonly CACHE_CLEANUP_INTERVAL_MS = parseInt(process.env.CACHE_CLEANUP_INTERVAL_MS || '30000', 10); // 30s\n\n  // Server-side cache TTLs (seconds)\n  static readonly CACHE_TTL_ENTITY = parseInt(process.env.CACHE_TTL_ENTITY || '60', 10); // plugin/pipeline findById\n  static readonly CACHE_TTL_MESSAGE = parseInt(process.env.CACHE_TTL_MESSAGE || '300', 10); // announcements/conversations (5 min)\n  static readonly CACHE_TTL_REPORT_INVENTORY = parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10); // plugin summary/distribution (5 min)\n  static readonly CACHE_TTL_REPORT_TIMESERIES = parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10); // execution/build metrics (2 min)\n  static readonly CACHE_TTL_COMPLIANCE_RULES = parseInt(process.env.CACHE_TTL_COMPLIANCE_RULES || '60', 10); // active compliance rules\n  static readonly CACHE_TTL_BILLING_PLANS = parseInt(process.env.CACHE_TTL_BILLING_PLANS || '14400', 10); // billing plans (4 hours)\n\n  // SSE backpressure\n  static readonly SSE_BACKPRESSURE_THRESHOLD = parseInt(process.env.SSE_BACKPRESSURE_THRESHOLD || '10', 10);\n\n  // HTTP Cache-Control headers\n  static readonly CACHE_CONTROL_LIST = process.env.CACHE_CONTROL_LIST || 'private, max-age=30, stale-while-revalidate=60';\n  static readonly CACHE_CONTROL_DETAIL = process.env.CACHE_CONTROL_DETAIL || 'private, max-age=60, stale-while-revalidate=120';\n}\n\n/**\n * Per-section loader map — each section is loaded lazily on first access.\n * This avoids loading all config sections (and their required env vars)\n * when only one section is needed (e.g. CDK synthesis only needs 'aws').\n */\nconst sectionLoaders: { [K in keyof AppConfig]: () => AppConfig[K] } = {\n  server: loadServerConfig,\n  auth: loadAuthConfig,\n  database: loadDatabaseConfig,\n  registry: loadRegistryConfig,\n  redis: loadRedisConfig,\n  pluginBuild: loadPluginBuildConfig,\n  dockerConfig: loadDockerConfig,\n  observability: loadObservabilityConfig,\n  compliance: loadComplianceConfig,\n  aws: loadAWSConfig,\n  rateLimit: loadRateLimitConfig,\n  billing: loadBillingConfig,\n};\n\n/** Per-section validators — only run for sections that have validation logic. */\nconst sectionValidators: Partial<{ [K in keyof AppConfig]: (config: AppConfig[K]) => void }> = {\n  server: validateServerConfig,\n};\n\n/**\n * Configuration facade with lazy per-section loading.\n *\n * Each section is loaded and validated independently on first access,\n * so requesting `Config.get('aws')` does not trigger loading of\n * server, auth, or billing config (and their env var requirements).\n *\n * Usage: `Config.get('server')`, `Config.get('auth')`, etc.\n */\nexport class Config {\n  private static cache = new Map<keyof AppConfig, unknown>();\n\n  /**\n   * Get a specific configuration section (loaded lazily on first access).\n   */\n  static get<K extends keyof AppConfig>(section: K): AppConfig[K] {\n    if (!this.cache.has(section)) {\n      const loader = sectionLoaders[section];\n      const value = loader();\n      const validator = sectionValidators[section];\n      if (validator) (validator as (v: AppConfig[K]) => void)(value);\n      this.cache.set(section, value);\n    }\n    return this.cache.get(section) as AppConfig[K];\n  }\n\n  /**\n   * Merge a partial override into a config section, taking precedence over the\n   * env-loaded values for all subsequent `Config.get(section)` calls.\n   *\n   * Used at CDK synth start to inject platform-sourced infrastructure config\n   * (e.g. the registry pull host derived from the platform's public URL) so the\n   * synth does not silently depend on the operator's local `process.env`.\n   * `undefined` fields in `partial` are ignored so they never clobber a loaded\n   * value. Loads (and validates) the section first so the override merges onto\n   * the real defaults.\n   */\n  static override<K extends keyof AppConfig>(section: K, partial: Partial<AppConfig[K]>): void {\n    const current = this.get(section);\n    const defined = Object.fromEntries(\n      Object.entries(partial).filter(([, v]) => v !== undefined),\n    ) as Partial<AppConfig[K]>;\n    this.cache.set(section, { ...current, ...defined });\n  }\n\n  /**\n   * Like {@link override}, but scoped: snapshots the current cache state for\n   * `section` and returns a restore function that reverts it. Use around a\n   * single unit of work (e.g. one CDK PipelineBuilder's synth) so a per-builder\n   * override does NOT leak into the process-wide cache and bleed into sibling\n   * builders in a multi-pipeline CDK app. Calling the returned function restores\n   * the exact prior state — the previously cached value, or an unloaded section\n   * if it had not been cached yet (so the next `get()` re-loads from env).\n   */\n  static overrideScoped<K extends keyof AppConfig>(\n    section: K,\n    partial: Partial<AppConfig[K]>,\n  ): () => void {\n    const hadCached = this.cache.has(section);\n    const previous = hadCached ? this.cache.get(section) : undefined;\n    this.override(section, partial);\n    return () => {\n      if (hadCached) this.cache.set(section, previous);\n      else this.cache.delete(section);\n    };\n  }\n\n  /**\n   * Clear all cached config sections so the next `Config.get()` re-reads them\n   * from the current `process.env` (re-running each section's loader + validator).\n   *\n   * Use when env has been mutated in-process and the cache is now stale — e.g. a\n   * long-running CLI that reconfigures between operations. CDK synth runs in a\n   * fresh subprocess that already reads env on first access, so it does not need\n   * this. Note: this also drops any values set via {@link override}.\n   */\n  static reload(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * @internal Reset configuration (for testing only). Alias for {@link reload}.\n   */\n  static _resetForTesting(): void {\n    this.reload();\n  }\n\n  /**\n   * Validate auth configuration (JWT secrets, algorithms, expiration).\n   * Call this at server startup, not during CDK synthesis.\n   */\n  static validateAuth(): void {\n    validateAuthConfig(this.get('auth'));\n  }\n\n  /**\n   * Untyped config access — use when the published package types don't include a new section yet.\n   * Avoids the `(Config as unknown as ...).get(...)` cast pattern in consumers.\n   */\n  static getAny(section: string): unknown {\n    return this.get(section as keyof AppConfig);\n  }\n}\n"]}

package/lib/config/aws-config-cdk.d.ts

@@ -0,0 +1,49 @@
+/**
+ * CDK adapters for {@link AWSConfig}.
+ *
+ * `AWSConfig` is deliberately plain data (see its doc comment): env-loaded
+ * numbers and strings, no `aws-cdk-lib` on the import graph. That keeps `Config`
+ * — which every API service reads — free of CDK. These functions are the single
+ * conversion point from that plain data into CDK value objects, and they live
+ * behind the `@pipeline-builder/pipeline-core/cdk` entry point, so only code that
+ * actually synthesizes stacks pays for `aws-cdk-lib`.
+ */
+import { Duration, RemovalPolicy } from 'aws-cdk-lib';
+import { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+import type { AWSConfig } from './config-types.js';
+/**
+ * Resolve a Lambda runtime identifier (e.g. `'nodejs24.x'`) to a CDK `Runtime`.
+ *
+ * @param runtime - runtime identifier from `Config.get('aws').lambda.runtime`
+ * @returns the CDK enum member; falls back to Node.js 24 for unknown values
+ */
+export declare function lambdaRuntime(runtime: AWSConfig['lambda']['runtime']): Runtime;
+/**
+ * Convert a Lambda timeout in seconds to a CDK `Duration`.
+ *
+ * @param seconds - timeout from `Config.get('aws').lambda.timeoutSeconds`
+ */
+export declare function lambdaTimeout(seconds: AWSConfig['lambda']['timeoutSeconds']): Duration;
+/**
+ * Resolve a Lambda architecture name to a CDK `Architecture`.
+ *
+ * @param architecture - value from `Config.get('aws').lambda.architecture`
+ */
+export declare function lambdaArchitecture(architecture: AWSConfig['lambda']['architecture']): Architecture;
+/**
+ * Convert a retention day count to CDK's `RetentionDays`.
+ *
+ * `RetentionDays` members are the day counts themselves, so the cast is exact —
+ * `infrastructure-config.ts` has already validated the value against the same
+ * set of allowed periods.
+ *
+ * @param days - value from `Config.get('aws').logging.retentionDays`
+ */
+export declare function logRetention(days: AWSConfig['logging']['retentionDays']): RetentionDays;
+/**
+ * Resolve a log-group removal policy name to a CDK `RemovalPolicy`.
+ *
+ * @param policy - value from `Config.get('aws').logging.removalPolicy`
+ */
+export declare function logRemovalPolicy(policy: AWSConfig['logging']['removalPolicy']): RemovalPolicy;

package/lib/config/aws-config-cdk.js

@@ -0,0 +1,65 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * CDK adapters for {@link AWSConfig}.
+ *
+ * `AWSConfig` is deliberately plain data (see its doc comment): env-loaded
+ * numbers and strings, no `aws-cdk-lib` on the import graph. That keeps `Config`
+ * — which every API service reads — free of CDK. These functions are the single
+ * conversion point from that plain data into CDK value objects, and they live
+ * behind the `@pipeline-builder/pipeline-core/cdk` entry point, so only code that
+ * actually synthesizes stacks pays for `aws-cdk-lib`.
+ */
+import { Duration, RemovalPolicy } from 'aws-cdk-lib';
+import { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+/** Runtime identifiers this platform supports, mapped to their CDK enum member. */
+const RUNTIMES = {
+    'nodejs24.x': Runtime.NODEJS_24_X,
+};
+/**
+ * Resolve a Lambda runtime identifier (e.g. `'nodejs24.x'`) to a CDK `Runtime`.
+ *
+ * @param runtime - runtime identifier from `Config.get('aws').lambda.runtime`
+ * @returns the CDK enum member; falls back to Node.js 24 for unknown values
+ */
+export function lambdaRuntime(runtime) {
+    return RUNTIMES[runtime] || Runtime.NODEJS_24_X;
+}
+/**
+ * Convert a Lambda timeout in seconds to a CDK `Duration`.
+ *
+ * @param seconds - timeout from `Config.get('aws').lambda.timeoutSeconds`
+ */
+export function lambdaTimeout(seconds) {
+    return Duration.seconds(seconds);
+}
+/**
+ * Resolve a Lambda architecture name to a CDK `Architecture`.
+ *
+ * @param architecture - value from `Config.get('aws').lambda.architecture`
+ */
+export function lambdaArchitecture(architecture) {
+    return architecture === 'x86_64' ? Architecture.X86_64 : Architecture.ARM_64;
+}
+/**
+ * Convert a retention day count to CDK's `RetentionDays`.
+ *
+ * `RetentionDays` members are the day counts themselves, so the cast is exact —
+ * `infrastructure-config.ts` has already validated the value against the same
+ * set of allowed periods.
+ *
+ * @param days - value from `Config.get('aws').logging.retentionDays`
+ */
+export function logRetention(days) {
+    return days;
+}
+/**
+ * Resolve a log-group removal policy name to a CDK `RemovalPolicy`.
+ *
+ * @param policy - value from `Config.get('aws').logging.removalPolicy`
+ */
+export function logRemovalPolicy(policy) {
+    return policy === 'retain' ? RemovalPolicy.RETAIN : RemovalPolicy.DESTROY;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/config/billing-config.d.ts

@@ -0,0 +1,24 @@
+import type { BillingConfig, BundleConfig, ComboDiscountConfig } from './config-types.js';
+/**
+ * Load billing plan configuration from environment variables.
+ */
+export declare function loadBillingConfig(): BillingConfig;
+/**
+ * Config-load guardrail for combos: every `bundleId` must resolve to an ACTIVE
+ * bundle and every `minQuantities` key must be one of the combo's `bundleIds`.
+ * A typo'd member or stray minQuantity key otherwise ships a permanently-inert
+ * combo (missing bundle treated as unit price 0, or a min never satisfiable),
+ * silently never applying. Throws so misconfig fails fast at boot.
+ */
+export declare function assertCombosValid(combos: ComboDiscountConfig[], bundles: BundleConfig[]): void;
+/**
+ * Config-load guardrail for the `requires` prerequisite graph. A `requires` entry
+ * that doesn't resolve to an ACTIVE bundle — or that participates in a cycle —
+ * silently makes the referencing bundle unpurchasable (the addon route rejects
+ * with 400 forever because the prerequisite can never be satisfied). Catch it at
+ * load with a clear error rather than shipping a dead SKU.
+ *
+ *  - Every id in a bundle's `requires` MUST name an active bundle in the catalog.
+ *  - The `requires` graph MUST be acyclic (a → b → a can never be satisfied).
+ */
+export declare function assertBundleRequiresValid(bundles: BundleConfig[]): void;