@pipeline-builder/api-server 3.4.83 → 3.4.85

package/lib/api/app-factory.js

@@ -13,6 +13,7 @@ import { v7 as uuid } from 'uuid';
 import { etagMiddleware } from './etag-middleware.js';
 import { idempotencyMiddleware } from './idempotency-middleware.js';
 import { metricsMiddleware, metricsHandler, incCounter } from './metrics.js';
+import { readinessGuard } from './readiness.js';
 import { SSEManager } from '../http/sse-connection-manager.js';
 // Wire api-core's counter shim to the real prom-client registry. This is
 // a no-op until incCounter is called for the first time (lazy registration
@@ -128,6 +129,13 @@ export function createApp(options = {}) {
         serviceName: process.env.SERVICE_NAME || 'api',
         checkDependencies,
     }));
+    // Readiness guard — 503s business traffic while the service is NotReady
+    // (datastore still connecting at startup, or dropped). Mounted right after
+    // the health router and before everything else so a NotReady request is
+    // rejected cheaply, before rate-limit / idempotency / business handlers ever
+    // touch a disconnected datastore. It allowlists the infra endpoints
+    // (/metrics, /warmup, /docs, /logs) registered below, plus /health + /ready.
+    app.use(readinessGuard());
     // Warm-up endpoint — pre-opens connection pools so the first real request
     // doesn't pay cold-start latency. Always pings Postgres; services using
     // Mongo / Redis / SQS pass `warmupHooks` so those are warmed in parallel.
@@ -229,4 +237,4 @@ export function createApp(options = {}) {
     app.get('/logs/:requestId', sseManager.middleware());
     return { app, sseManager };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-factory.js","sourceRoot":"","sources":["../../src/api/app-factory.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,mBAAmB,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEnK,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,WAAW,MAAM,aAAa,CAAC;AACtC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,OAAO,EAAE,EAAgE,MAAM,SAAS,CAAC;AAChG,OAAO,SAAS,EAAE,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,SAAS,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAE/D,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,mEAAmE;AACnE,iBAAiB,CAAC,UAAU,CAAC,CAAC;AAoD9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,SAAS,CAAC,UAA4B,EAAE;IACtD,MAAM,EACJ,UAAU,GAAG,IAAI,EACjB,YAAY,GAAG,IAAI,EACnB,eAAe,GAAG,IAAI,EACtB,cAAc,GAAG,IAAI,EACrB,SAAS,GAAG,KAAK,EACjB,gBAAgB,GAAG,IAAI,EACvB,eAAe,GAAG,KAAK,EACvB,UAAU,GAAG,IAAI,UAAU,EAAE,EAC7B,iBAAiB,EACjB,aAAa,GAAG,IAAI,EACpB,cAAc,EACd,iBAAiB,GAAG,IAAI,EACxB,WAAW,GAAG,EAAE,GACjB,GAAG,OAAO,CAAC;IAEZ,uFAAuF;IACvF,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAC;IACrG,CAAC;IAED,6EAA6E;IAC7E,yEAAyE;IACzE,0EAA0E;IAC1E,2EAA2E;IAC3E,kEAAkE;IAClE,4EAA4E;IAE5E,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1C,MAAM,GAAG,GAAG,OAAO,EAAE,CAAC;IAEtB,uBAAuB;IACvB,EAAE;IACF,yEAAyE;IACzE,2EAA2E;IAC3E,yEAAyE;IACzE,0EAA0E;IAC1E,sDAAsD;IACtD,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAC;IAC3D,MAAM,eAAe,GAAG,aAAa,IAAI,CAAC,YAAY,CAAC;IACvD,IAAI,YAAY,EAAE,CAAC;QACjB,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;YACb,qBAAqB,EAAE;gBACrB,UAAU,EAAE;oBACV,UAAU,EAAE,CAAC,QAAQ,CAAC;oBACtB,SAAS,EAAE,eAAe;wBACxB,CAAC,CAAC,CAAC,QAAQ,EAAE,iBAAiB,EAAE,eAAe,CAAC;wBAChD,CAAC,CAAC,CAAC,QAAQ,CAAC;oBACd,QAAQ,EAAE,CAAC,QAAQ,EAAE,iBAAiB,CAAC;oBACvC,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC;oBACpC,UAAU,EAAE,CAAC,QAAQ,CAAC;oBACtB,OAAO,EAAE,CAAC,QAAQ,CAAC;oBACnB,SAAS,EAAE,CAAC,QAAQ,CAAC;oBACrB,cAAc,EAAE,CAAC,QAAQ,CAAC;oBAC1B,OAAO,EAAE,CAAC,QAAQ,CAAC;oBACnB,UAAU,EAAE,CAAC,QAAQ,CAAC;iBACvB;aACF;SACF,CAAC,CAAC,CAAC;IACN,CAAC;IAED,IAAI,UAAU,EAAE,CAAC;QACf,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,yDAAyD;IACzD,IAAI,iBAAiB,EAAE,CAAC;QACtB,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC;YAClB,MAAM,EAAE,CAAC,GAAY,EAAE,GAAa,EAAE,EAAE;gBACtC,6BAA6B;gBAC7B,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,mBAAmB;oBAAE,OAAO,KAAK,CAAC;gBAC7D,OAAO,WAAW,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACtC,CAAC;YACD,SAAS,EAAE,aAAa,CAAC,2BAA2B;SACrD,CAAC,CAAC,CAAC;IACN,CAAC;IAED,+DAA+D;IAC/D,GAAG,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC;IAE1B,eAAe;IACf,IAAI,cAAc,EAAE,CAAC;QACnB,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED,IAAI,gBAAgB,EAAE,CAAC;QACrB,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC;IAED,6EAA6E;IAC7E,GAAG,CAAC,GAAG,CAAC,aAAa,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IAEhD,yEAAyE;IACzE,GAAG,CAAC,GAAG,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAE,EAAE;QAC1D,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACxC,MAAM,SAAS,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC;QAChE,GAAG,CAAC,SAAS,GAAG,SAAS,CAAC;QAC1B,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;QACzC,IAAI,EAAE,CAAC;IACT,CAAC,CAAC,CAAC;IAEH,uEAAuE;IACvE,GAAG,CAAC,GAAG,CAAC,kBAAkB,CAAC;QACzB,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,KAAK;QAC9C,iBAAiB;KAClB,CAAC,CAAC,CAAC;IAEJ,0EAA0E;IAC1E,wEAAwE;IACxE,0EAA0E;IAC1E,GAAG,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,EAAE,IAAa,EAAE,GAAa,EAAE,EAAE;QACxD,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,GAAG,CAAC;gBAChB,aAAa,EAAE,CAAC,cAAc,EAAE;gBAChC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC;aACrC,CAAC,CAAC;YACH,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;QACrE,CAAC;QAAC,MAAM,CAAC;YACP,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,eAAe,CAAC,CAAC;QACvC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,oEAAoE;IACpE,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,cAAc,EAAE,CAAC,CAAC;IAEtC,+DAA+D;IAC/D,IAAI,aAAa,EAAE,CAAC;QAClB,MAAM,IAAI,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAC;QACjD,GAAG,CAAC,GAAG,CAAC,oBAAoB,EAAE,CAAC,IAAa,EAAE,GAAa,EAAE,EAAE;YAC7D,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC,CAAC,CAAC;QACH,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE;YACtD,eAAe,EAAE,cAAc,EAAE,KAAK,IAAI,2BAA2B;SACtE,CAAC,CAAC,CAAC;IACN,CAAC;IAED,yFAAyF;IACzF,IAAI,eAAe,EAAE,CAAC;QACpB,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAEhD,MAAM,gBAAgB,GAAoC;YACxD,GAAG,EAAE,eAAe,CAAC,GAAG;YACxB,QAAQ,EAAE,eAAe,CAAC,QAAQ;YAClC,eAAe,EAAE,IAAI;YACrB,aAAa,EAAE,KAAK;YACpB,8EAA8E;YAC9E,IAAI,EAAE,CAAC,GAAY,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAK,MAAM;YACpE,mEAAmE;YACnE,wEAAwE;YACxE,iEAAiE;YACjE,8CAA8C;YAC9C,YAAY,EAAE,CAAC,GAAY,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,cAAc,CAAC,GAAG,CAAC,EAAE,IAAI,MAAM,EAAE,EAAE,CAAC;YACrF,OAAO,EAAE,CAAC,IAAa,EAAE,GAAa,EAAE,EAAE;gBACxC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,4CAA4C,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC;YACnG,CAAC;SACF,CAAC;QAEF,mEAAmE;QACnE,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,IAAI,CAAC;gBACH,sEAAsE;gBACtE,gEAAgE;gBAChE,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC/C,iEAAiE;gBACjE,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;gBACnD,iEAAiE;gBACjE,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;gBACjC,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAChD,gBAAgB,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC;oBACtC,WAAW,EAAE,CAAC,GAAG,IAAc,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;iBAC9D,CAAC,CAAC;YACL,CAAC;YAAC,MAAM,CAAC;gBACP,YAAY,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,kEAAkE,CAAC,CAAC;YACtG,CAAC;QACH,CAAC;QAED,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACvC,CAAC;IAED,4FAA4F;IAC5F,MAAM,SAAS,GAAG,aAAa,CAAC,kBAAkB,CAAC;IACnD,GAAG,CAAC,GAAG,CAAC,CAAC,IAAa,EAAE,GAAa,EAAE,IAAkB,EAAE,EAAE;QAC3D,GAAG,CAAC,UAAU,CAAC,SAAS,EAAE,GAAG,EAAE;YAC7B,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;gBACrB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,iBAAiB,CAAC,CAAC;YACzC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,EAAE,CAAC;IACT,CAAC,CAAC,CAAC;IAEH,2BAA2B;IAC3B,MAAM,cAAc,GAAG,YAAY,CAAC,kBAAkB,CAAC,CAAC;IACxD,GAAG,CAAC,GAAG,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAE,EAAE;QAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,GAAG,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;YACpC,cAAc,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,UAAU,IAAI,QAAQ,IAAI,EAAE;gBACtF,MAAM,EAAE,GAAG,CAAC,MAAM;gBAClB,IAAI,EAAE,GAAG,CAAC,WAAW;gBACrB,UAAU,EAAE,GAAG,CAAC,UAAU;gBAC1B,UAAU,EAAE,QAAQ;gBACpB,SAAS,EAAE,GAAG,CAAC,SAAS;aACzB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,EAAE,CAAC;IACT,CAAC,CAAC,CAAC;IAEH,qEAAqE;IACrE,GAAG,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC,CAAC;IAE7B,iDAAiD;IACjD,GAAG,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAEjC,oBAAoB;IACpB,GAAG,CAAC,GAAG,CAAC,kBAAkB,EAAE,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC;IAErD,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC;AAC7B,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'node:module';\nimport { sendSuccess, sendError, generateOpenApiSpec, ErrorCode, createLogger, getOrgId, createHealthRouter, setCounterEmitter } from '@pipeline-builder/api-core';\nimport type { OpenApiSpecOptions } from '@pipeline-builder/api-core';\nimport { Config, CoreConstants, getConnection } from '@pipeline-builder/pipeline-core';\nimport compression from 'compression';\nimport cors from 'cors';\nimport express, { type Express, type NextFunction, type Request, type Response } from 'express';\nimport rateLimit, { ipKeyGenerator } from 'express-rate-limit';\nimport helmet from 'helmet';\nimport swaggerUi from 'swagger-ui-express';\nimport { v7 as uuid } from 'uuid';\nimport { etagMiddleware } from './etag-middleware.js';\nimport { idempotencyMiddleware } from './idempotency-middleware.js';\nimport { metricsMiddleware, metricsHandler, incCounter } from './metrics.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\n// Wire api-core's counter shim to the real prom-client registry. This is\n// a no-op until incCounter is called for the first time (lazy registration\n// in metrics.ts), and lets api-core helpers like the quota client record\n// `quota_fail_open_total` without taking a hard dep on api-server.\nsetCounterEmitter(incCounter);\n\n/**\n * Options for creating an Express application\n */\nexport interface CreateAppOptions {\n  /** Enable CORS (default: true) */\n  enableCors?: boolean;\n  /** Enable Helmet security headers (default: true) */\n  enableHelmet?: boolean;\n  /** Enable rate limiting (default: true) */\n  enableRateLimit?: boolean;\n  /** Redis URL for shared rate-limit state (e.g. 'redis://host:6379'). In-memory when omitted. */\n  redisUrl?: string;\n  /** Enable JSON body parsing (default: true) */\n  enableJsonBody?: boolean;\n  /** JSON body size limit (default: '1mb') */\n  jsonLimit?: string;\n  /** Enable URL-encoded body parsing (default: true) */\n  enableUrlEncoded?: boolean;\n  /** URL-encoded body size limit (default: '1mb') */\n  urlEncodedLimit?: string;\n  /** Custom SSE manager instance */\n  sseManager?: SSEManager;\n  /** Health check dependency checker — if provided, /health reports dependency status */\n  checkDependencies?: () => Promise<Record<string, 'connected' | 'disconnected' | 'unknown'>>;\n  /** Enable OpenAPI spec at /docs/openapi.json and Swagger UI at /docs (default: true) */\n  enableOpenApi?: boolean;\n  /** OpenAPI spec customization options */\n  openApiOptions?: OpenApiSpecOptions;\n  /** Enable gzip/deflate response compression (default: true) */\n  enableCompression?: boolean;\n  /**\n   * Extra warmup callbacks invoked by `GET /warmup` in addition to the\n   * default Postgres ping. Use for services that depend on Mongo, Redis,\n   * SQS, etc. — pre-warming opens connection pools before real traffic\n   * arrives. Each callback should resolve when its dependency is ready;\n   * any rejection causes /warmup to return 503.\n   */\n  warmupHooks?: Array<() => Promise<void>>;\n}\n\n/**\n * Result of creating an Express application\n */\nexport interface CreateAppResult {\n  /** Configured Express application */\n  app: Express;\n  /** SSE manager instance */\n  sseManager: SSEManager;\n}\n\n/**\n * Create and configure an Express application with common middleware\n *\n * Sets up:\n * - CORS with configured origins\n * - Helmet security headers\n * - Rate limiting\n * - JSON and URL-encoded body parsing\n * - Trust proxy settings\n * - Health check endpoint (/health)\n * - Metrics endpoint (/metrics)\n * - SSE logs endpoint (/logs/:requestId)\n *\n * @param options - Configuration options\n * @returns Configured Express app and SSE manager\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, async (req, res) => {\n *   // Your route handler\n * });\n *\n * startServer(app, { name: 'My Service' });\n * ```\n */\nexport function createApp(options: CreateAppOptions = {}): CreateAppResult {\n  const {\n    enableCors = true,\n    enableHelmet = true,\n    enableRateLimit = true,\n    enableJsonBody = true,\n    jsonLimit = '1mb',\n    enableUrlEncoded = true,\n    urlEncodedLimit = '1mb',\n    sseManager = new SSEManager(),\n    checkDependencies,\n    enableOpenApi = true,\n    openApiOptions,\n    enableCompression = true,\n    warmupHooks = [],\n  } = options;\n\n  // Fail fast if JWT_SECRET is not configured — prevents silent auth failures at runtime\n  if (!process.env.JWT_SECRET) {\n    throw new Error('JWT_SECRET environment variable is required. Set it before starting the server.');\n  }\n\n  // OpenTelemetry is NOT initialized here: by the time createApp runs, express\n  // and http have already been required, so the auto-instrumentation hooks\n  // would have nothing to patch (no inbound span → no trace id). Tracing is\n  // started by the `otel-bootstrap.js` preload instead (node -r … — see each\n  // service's Dockerfile CMD / start script), which runs before any\n  // instrumented module loads. `currentTraceId()` then reads the active span.\n\n  const serverConfig = Config.get('server');\n  const app = express();\n\n  // Security middleware.\n  //\n  // Swagger UI needs unsafe-inline + unsafe-eval for its bundled scripts —\n  // but we only relax CSP that far when (a) OpenAPI is enabled AND (b) we're\n  // not in production. In prod, Swagger should be served behind a separate\n  // host or auth-gated route; the main app keeps the strict CSP so a Stored\n  // XSS in any handler can't `eval()` arbitrary script.\n  const isProduction = process.env.NODE_ENV === 'production';\n  const allowSwaggerCsp = enableOpenApi && !isProduction;\n  if (enableHelmet) {\n    app.use(helmet({\n      contentSecurityPolicy: {\n        directives: {\n          defaultSrc: [\"'self'\"],\n          scriptSrc: allowSwaggerCsp\n            ? [\"'self'\", \"'unsafe-inline'\", \"'unsafe-eval'\"]\n            : [\"'self'\"],\n          styleSrc: [\"'self'\", \"'unsafe-inline'\"],\n          imgSrc: [\"'self'\", 'data:', 'blob:'],\n          connectSrc: [\"'self'\"],\n          fontSrc: [\"'self'\"],\n          objectSrc: [\"'none'\"],\n          frameAncestors: [\"'none'\"],\n          baseUri: [\"'self'\"],\n          formAction: [\"'self'\"],\n        },\n      },\n    }));\n  }\n\n  if (enableCors) {\n    app.use(cors(serverConfig.cors));\n  }\n\n  // Response compression (gzip/deflate) — skip SSE streams\n  if (enableCompression) {\n    app.use(compression({\n      filter: (req: Request, res: Response) => {\n        // Don't compress SSE streams\n        if (req.headers.accept === 'text/event-stream') return false;\n        return compression.filter(req, res);\n      },\n      threshold: CoreConstants.COMPRESSION_THRESHOLD_BYTES,\n    }));\n  }\n\n  // ETag support for conditional GET requests (304 Not Modified)\n  app.use(etagMiddleware());\n\n  // Body parsing\n  if (enableJsonBody) {\n    app.use(express.json({ limit: jsonLimit }));\n  }\n\n  if (enableUrlEncoded) {\n    app.use(express.urlencoded({ extended: true, limit: urlEncodedLimit }));\n  }\n\n  // Trust proxy (must be set before rate limiter so req.ip resolves correctly)\n  app.set('trust proxy', serverConfig.trustProxy);\n\n  // Request ID — prefer existing header from nginx, otherwise generate one\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const hdr = req.headers['x-request-id'];\n    const requestId = (Array.isArray(hdr) ? hdr[0] : hdr) || uuid();\n    req.requestId = requestId;\n    res.setHeader('X-Request-Id', requestId);\n    next();\n  });\n\n  // Health check registered before rate limiter so it is never throttled\n  app.use(createHealthRouter({\n    serviceName: process.env.SERVICE_NAME || 'api',\n    checkDependencies,\n  }));\n\n  // Warm-up endpoint — pre-opens connection pools so the first real request\n  // doesn't pay cold-start latency. Always pings Postgres; services using\n  // Mongo / Redis / SQS pass `warmupHooks` so those are warmed in parallel.\n  app.get('/warmup', async (_req: Request, res: Response) => {\n    try {\n      await Promise.all([\n        getConnection().testConnection(),\n        ...warmupHooks.map((hook) => hook()),\n      ]);\n      sendSuccess(res, 200, { warmed: true, hooks: warmupHooks.length });\n    } catch {\n      sendError(res, 503, 'Warmup failed');\n    }\n  });\n\n  // Prometheus metrics endpoint — always registered (never throttled)\n  app.get('/metrics', metricsHandler());\n\n  // OpenAPI spec and Swagger UI (registered before rate limiter)\n  if (enableOpenApi) {\n    const spec = generateOpenApiSpec(openApiOptions);\n    app.get('/docs/openapi.json', (_req: Request, res: Response) => {\n      res.json(spec);\n    });\n    app.use('/docs', swaggerUi.serve, swaggerUi.setup(spec, {\n      customSiteTitle: openApiOptions?.title ?? 'Pipeline Builder API Docs',\n    }));\n  }\n\n  // Rate limiting — uses Redis when redisUrl is provided for shared state across instances\n  if (enableRateLimit) {\n    const rateLimitConfig = Config.get('rateLimit');\n\n    const rateLimitOptions: Parameters<typeof rateLimit>[0] = {\n      max: rateLimitConfig.max,\n      windowMs: rateLimitConfig.windowMs,\n      standardHeaders: true,\n      legacyHeaders: false,\n      // Skip rate limiting for internal service calls (init scripts, inter-service)\n      skip: (req: Request) => req.headers['x-internal-service'] === 'true',\n      // Per-org key: use orgId from JWT when available, fall back to IP.\n      // ipKeyGenerator normalizes IPv6 to a /64 prefix so a single user can't\n      // rotate low-bits to escape the bucket; express-rate-limit 8.x's\n      // validator also refuses to start without it.\n      keyGenerator: (req: Request) => getOrgId(req) || ipKeyGenerator(req.ip || 'anon', 64),\n      handler: (_req: Request, res: Response) => {\n        sendError(res, 429, 'Too many requests, please try again later.', ErrorCode.RATE_LIMIT_EXCEEDED);\n      },\n    };\n\n    // Use Redis store when available for shared state across instances\n    if (options.redisUrl) {\n      try {\n        // ESM has no global `require`; createRequire loads the optional redis\n        // deps synchronously here (only when a redisUrl is configured).\n        const require = createRequire(import.meta.url);\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const { RedisStore } = require('rate-limit-redis');\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const Redis = require('ioredis');\n        const redisClient = new Redis(options.redisUrl);\n        rateLimitOptions.store = new RedisStore({\n          sendCommand: (...args: string[]) => redisClient.call(...args),\n        });\n      } catch {\n        createLogger('rate-limit').warn('Redis store unavailable, falling back to in-memory rate limiting');\n      }\n    }\n\n    app.use(rateLimit(rateLimitOptions));\n  }\n\n  // Express request timeout — uses CoreConstants to share the same default as Lambda handlers\n  const timeoutMs = CoreConstants.HANDLER_TIMEOUT_MS;\n  app.use((_req: Request, res: Response, next: NextFunction) => {\n    res.setTimeout(timeoutMs, () => {\n      if (!res.headersSent) {\n        sendError(res, 503, 'Request timeout');\n      }\n    });\n    next();\n  });\n\n  // Request duration logging\n  const durationLogger = createLogger('request-duration');\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const start = Date.now();\n    res.on('finish', () => {\n      const duration = Date.now() - start;\n      durationLogger.info(`${req.method} ${req.originalUrl} ${res.statusCode} ${duration}ms`, {\n        method: req.method,\n        path: req.originalUrl,\n        statusCode: res.statusCode,\n        durationMs: duration,\n        requestId: req.requestId,\n      });\n    });\n    next();\n  });\n\n  // Prometheus metrics middleware — records request duration and count\n  app.use(metricsMiddleware());\n\n  // Idempotency key support for mutation endpoints\n  app.use(idempotencyMiddleware());\n\n  // SSE logs endpoint\n  app.get('/logs/:requestId', sseManager.middleware());\n\n  return { app, sseManager };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-factory.js","sourceRoot":"","sources":["../../src/api/app-factory.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'node:module';\nimport { sendSuccess, sendError, generateOpenApiSpec, ErrorCode, createLogger, getOrgId, createHealthRouter, setCounterEmitter } from '@pipeline-builder/api-core';\nimport type { OpenApiSpecOptions } from '@pipeline-builder/api-core';\nimport { Config, CoreConstants, getConnection } from '@pipeline-builder/pipeline-core';\nimport compression from 'compression';\nimport cors from 'cors';\nimport express, { type Express, type NextFunction, type Request, type Response } from 'express';\nimport rateLimit, { ipKeyGenerator } from 'express-rate-limit';\nimport helmet from 'helmet';\nimport swaggerUi from 'swagger-ui-express';\nimport { v7 as uuid } from 'uuid';\nimport { etagMiddleware } from './etag-middleware.js';\nimport { idempotencyMiddleware } from './idempotency-middleware.js';\nimport { metricsMiddleware, metricsHandler, incCounter } from './metrics.js';\nimport { readinessGuard } from './readiness.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\n// Wire api-core's counter shim to the real prom-client registry. This is\n// a no-op until incCounter is called for the first time (lazy registration\n// in metrics.ts), and lets api-core helpers like the quota client record\n// `quota_fail_open_total` without taking a hard dep on api-server.\nsetCounterEmitter(incCounter);\n\n/**\n * Options for creating an Express application\n */\nexport interface CreateAppOptions {\n  /** Enable CORS (default: true) */\n  enableCors?: boolean;\n  /** Enable Helmet security headers (default: true) */\n  enableHelmet?: boolean;\n  /** Enable rate limiting (default: true) */\n  enableRateLimit?: boolean;\n  /** Redis URL for shared rate-limit state (e.g. 'redis://host:6379'). In-memory when omitted. */\n  redisUrl?: string;\n  /** Enable JSON body parsing (default: true) */\n  enableJsonBody?: boolean;\n  /** JSON body size limit (default: '1mb') */\n  jsonLimit?: string;\n  /** Enable URL-encoded body parsing (default: true) */\n  enableUrlEncoded?: boolean;\n  /** URL-encoded body size limit (default: '1mb') */\n  urlEncodedLimit?: string;\n  /** Custom SSE manager instance */\n  sseManager?: SSEManager;\n  /** Health check dependency checker — if provided, /health reports dependency status */\n  checkDependencies?: () => Promise<Record<string, 'connected' | 'disconnected' | 'unknown'>>;\n  /** Enable OpenAPI spec at /docs/openapi.json and Swagger UI at /docs (default: true) */\n  enableOpenApi?: boolean;\n  /** OpenAPI spec customization options */\n  openApiOptions?: OpenApiSpecOptions;\n  /** Enable gzip/deflate response compression (default: true) */\n  enableCompression?: boolean;\n  /**\n   * Extra warmup callbacks invoked by `GET /warmup` in addition to the\n   * default Postgres ping. Use for services that depend on Mongo, Redis,\n   * SQS, etc. — pre-warming opens connection pools before real traffic\n   * arrives. Each callback should resolve when its dependency is ready;\n   * any rejection causes /warmup to return 503.\n   */\n  warmupHooks?: Array<() => Promise<void>>;\n}\n\n/**\n * Result of creating an Express application\n */\nexport interface CreateAppResult {\n  /** Configured Express application */\n  app: Express;\n  /** SSE manager instance */\n  sseManager: SSEManager;\n}\n\n/**\n * Create and configure an Express application with common middleware\n *\n * Sets up:\n * - CORS with configured origins\n * - Helmet security headers\n * - Rate limiting\n * - JSON and URL-encoded body parsing\n * - Trust proxy settings\n * - Health check endpoint (/health)\n * - Metrics endpoint (/metrics)\n * - SSE logs endpoint (/logs/:requestId)\n *\n * @param options - Configuration options\n * @returns Configured Express app and SSE manager\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, async (req, res) => {\n *   // Your route handler\n * });\n *\n * startServer(app, { name: 'My Service' });\n * ```\n */\nexport function createApp(options: CreateAppOptions = {}): CreateAppResult {\n  const {\n    enableCors = true,\n    enableHelmet = true,\n    enableRateLimit = true,\n    enableJsonBody = true,\n    jsonLimit = '1mb',\n    enableUrlEncoded = true,\n    urlEncodedLimit = '1mb',\n    sseManager = new SSEManager(),\n    checkDependencies,\n    enableOpenApi = true,\n    openApiOptions,\n    enableCompression = true,\n    warmupHooks = [],\n  } = options;\n\n  // Fail fast if JWT_SECRET is not configured — prevents silent auth failures at runtime\n  if (!process.env.JWT_SECRET) {\n    throw new Error('JWT_SECRET environment variable is required. Set it before starting the server.');\n  }\n\n  // OpenTelemetry is NOT initialized here: by the time createApp runs, express\n  // and http have already been required, so the auto-instrumentation hooks\n  // would have nothing to patch (no inbound span → no trace id). Tracing is\n  // started by the `otel-bootstrap.js` preload instead (node -r … — see each\n  // service's Dockerfile CMD / start script), which runs before any\n  // instrumented module loads. `currentTraceId()` then reads the active span.\n\n  const serverConfig = Config.get('server');\n  const app = express();\n\n  // Security middleware.\n  //\n  // Swagger UI needs unsafe-inline + unsafe-eval for its bundled scripts —\n  // but we only relax CSP that far when (a) OpenAPI is enabled AND (b) we're\n  // not in production. In prod, Swagger should be served behind a separate\n  // host or auth-gated route; the main app keeps the strict CSP so a Stored\n  // XSS in any handler can't `eval()` arbitrary script.\n  const isProduction = process.env.NODE_ENV === 'production';\n  const allowSwaggerCsp = enableOpenApi && !isProduction;\n  if (enableHelmet) {\n    app.use(helmet({\n      contentSecurityPolicy: {\n        directives: {\n          defaultSrc: [\"'self'\"],\n          scriptSrc: allowSwaggerCsp\n            ? [\"'self'\", \"'unsafe-inline'\", \"'unsafe-eval'\"]\n            : [\"'self'\"],\n          styleSrc: [\"'self'\", \"'unsafe-inline'\"],\n          imgSrc: [\"'self'\", 'data:', 'blob:'],\n          connectSrc: [\"'self'\"],\n          fontSrc: [\"'self'\"],\n          objectSrc: [\"'none'\"],\n          frameAncestors: [\"'none'\"],\n          baseUri: [\"'self'\"],\n          formAction: [\"'self'\"],\n        },\n      },\n    }));\n  }\n\n  if (enableCors) {\n    app.use(cors(serverConfig.cors));\n  }\n\n  // Response compression (gzip/deflate) — skip SSE streams\n  if (enableCompression) {\n    app.use(compression({\n      filter: (req: Request, res: Response) => {\n        // Don't compress SSE streams\n        if (req.headers.accept === 'text/event-stream') return false;\n        return compression.filter(req, res);\n      },\n      threshold: CoreConstants.COMPRESSION_THRESHOLD_BYTES,\n    }));\n  }\n\n  // ETag support for conditional GET requests (304 Not Modified)\n  app.use(etagMiddleware());\n\n  // Body parsing\n  if (enableJsonBody) {\n    app.use(express.json({ limit: jsonLimit }));\n  }\n\n  if (enableUrlEncoded) {\n    app.use(express.urlencoded({ extended: true, limit: urlEncodedLimit }));\n  }\n\n  // Trust proxy (must be set before rate limiter so req.ip resolves correctly)\n  app.set('trust proxy', serverConfig.trustProxy);\n\n  // Request ID — prefer existing header from nginx, otherwise generate one\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const hdr = req.headers['x-request-id'];\n    const requestId = (Array.isArray(hdr) ? hdr[0] : hdr) || uuid();\n    req.requestId = requestId;\n    res.setHeader('X-Request-Id', requestId);\n    next();\n  });\n\n  // Health check registered before rate limiter so it is never throttled\n  app.use(createHealthRouter({\n    serviceName: process.env.SERVICE_NAME || 'api',\n    checkDependencies,\n  }));\n\n  // Readiness guard — 503s business traffic while the service is NotReady\n  // (datastore still connecting at startup, or dropped). Mounted right after\n  // the health router and before everything else so a NotReady request is\n  // rejected cheaply, before rate-limit / idempotency / business handlers ever\n  // touch a disconnected datastore. It allowlists the infra endpoints\n  // (/metrics, /warmup, /docs, /logs) registered below, plus /health + /ready.\n  app.use(readinessGuard());\n\n  // Warm-up endpoint — pre-opens connection pools so the first real request\n  // doesn't pay cold-start latency. Always pings Postgres; services using\n  // Mongo / Redis / SQS pass `warmupHooks` so those are warmed in parallel.\n  app.get('/warmup', async (_req: Request, res: Response) => {\n    try {\n      await Promise.all([\n        getConnection().testConnection(),\n        ...warmupHooks.map((hook) => hook()),\n      ]);\n      sendSuccess(res, 200, { warmed: true, hooks: warmupHooks.length });\n    } catch {\n      sendError(res, 503, 'Warmup failed');\n    }\n  });\n\n  // Prometheus metrics endpoint — always registered (never throttled)\n  app.get('/metrics', metricsHandler());\n\n  // OpenAPI spec and Swagger UI (registered before rate limiter)\n  if (enableOpenApi) {\n    const spec = generateOpenApiSpec(openApiOptions);\n    app.get('/docs/openapi.json', (_req: Request, res: Response) => {\n      res.json(spec);\n    });\n    app.use('/docs', swaggerUi.serve, swaggerUi.setup(spec, {\n      customSiteTitle: openApiOptions?.title ?? 'Pipeline Builder API Docs',\n    }));\n  }\n\n  // Rate limiting — uses Redis when redisUrl is provided for shared state across instances\n  if (enableRateLimit) {\n    const rateLimitConfig = Config.get('rateLimit');\n\n    const rateLimitOptions: Parameters<typeof rateLimit>[0] = {\n      max: rateLimitConfig.max,\n      windowMs: rateLimitConfig.windowMs,\n      standardHeaders: true,\n      legacyHeaders: false,\n      // Skip rate limiting for internal service calls (init scripts, inter-service)\n      skip: (req: Request) => req.headers['x-internal-service'] === 'true',\n      // Per-org key: use orgId from JWT when available, fall back to IP.\n      // ipKeyGenerator normalizes IPv6 to a /64 prefix so a single user can't\n      // rotate low-bits to escape the bucket; express-rate-limit 8.x's\n      // validator also refuses to start without it.\n      keyGenerator: (req: Request) => getOrgId(req) || ipKeyGenerator(req.ip || 'anon', 64),\n      handler: (_req: Request, res: Response) => {\n        sendError(res, 429, 'Too many requests, please try again later.', ErrorCode.RATE_LIMIT_EXCEEDED);\n      },\n    };\n\n    // Use Redis store when available for shared state across instances\n    if (options.redisUrl) {\n      try {\n        // ESM has no global `require`; createRequire loads the optional redis\n        // deps synchronously here (only when a redisUrl is configured).\n        const require = createRequire(import.meta.url);\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const { RedisStore } = require('rate-limit-redis');\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const Redis = require('ioredis');\n        const redisClient = new Redis(options.redisUrl);\n        rateLimitOptions.store = new RedisStore({\n          sendCommand: (...args: string[]) => redisClient.call(...args),\n        });\n      } catch {\n        createLogger('rate-limit').warn('Redis store unavailable, falling back to in-memory rate limiting');\n      }\n    }\n\n    app.use(rateLimit(rateLimitOptions));\n  }\n\n  // Express request timeout — uses CoreConstants to share the same default as Lambda handlers\n  const timeoutMs = CoreConstants.HANDLER_TIMEOUT_MS;\n  app.use((_req: Request, res: Response, next: NextFunction) => {\n    res.setTimeout(timeoutMs, () => {\n      if (!res.headersSent) {\n        sendError(res, 503, 'Request timeout');\n      }\n    });\n    next();\n  });\n\n  // Request duration logging\n  const durationLogger = createLogger('request-duration');\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const start = Date.now();\n    res.on('finish', () => {\n      const duration = Date.now() - start;\n      durationLogger.info(`${req.method} ${req.originalUrl} ${res.statusCode} ${duration}ms`, {\n        method: req.method,\n        path: req.originalUrl,\n        statusCode: res.statusCode,\n        durationMs: duration,\n        requestId: req.requestId,\n      });\n    });\n    next();\n  });\n\n  // Prometheus metrics middleware — records request duration and count\n  app.use(metricsMiddleware());\n\n  // Idempotency key support for mutation endpoints\n  app.use(idempotencyMiddleware());\n\n  // SSE logs endpoint\n  app.get('/logs/:requestId', sseManager.middleware());\n\n  return { app, sseManager };\n}\n"]}

package/lib/api/health-checks.d.ts

@@ -2,12 +2,46 @@ type HealthStatus = 'connected' | 'disconnected' | 'unknown';
 type HealthResult = Record<string, HealthStatus>;
 /**
  * Postgres health probe: returns `{ postgres: 'connected' }` when the pool's
- * connection test succeeds, `{ postgres: 'disconnected' }` on any error
- * (so `/health` correctly reports 503). Use as the `checkDependencies`
- * option of `createApp()` for any service backed by the shared pipeline-data
- * Drizzle connection.
+ * connection test succeeds, `{ postgres: 'disconnected' }` on any error or
+ * timeout (so `/ready` correctly reports 503). Use as (part of) the
+ * `checkDependencies` option of `createApp()` for any service backed by the
+ * shared pipeline-data Drizzle connection.
  */
-export declare function postgresHealthCheck(): Promise<HealthResult>;
+export declare function postgresHealthCheck(timeoutMs?: number): Promise<HealthResult>;
+/** Minimal shape of an ioredis client needed for a health PING. */
+interface RedisLike {
+    ping(): Promise<string>;
+}
+/**
+ * Source of a redis client: either the client itself, or a (sync/async) getter.
+ * The getter form supports BullMQ's `queue.client` (a `Promise<RedisClient>`)
+ * so a service can probe the exact connection its queue uses without opening
+ * a second one.
+ */
+type RedisClientSource = RedisLike | (() => RedisLike | Promise<RedisLike>);
+/**
+ * Redis health probe factory: pass the service's EXISTING ioredis connection
+ * (or a getter for it — e.g. `() => queue.client`) and get back a
+ * `checkDependencies` callback that `PING`s it. Mirrors `mongoHealthCheck` —
+ * it probes the real connection rather than opening a throwaway one per call.
+ * The PING is time-boxed so a down redis (whose offline queue would otherwise
+ * buffer the command) reports `disconnected` quickly instead of hanging.
+ */
+export declare function redisHealthCheck(source: RedisClientSource, timeoutMs?: number): () => Promise<HealthResult>;
+/**
+ * Combine several dependency probes into one `checkDependencies` callback that
+ * runs them IN PARALLEL and merges their results. A slow/failed probe can't
+ * delay the others or time out the whole `/ready` response.
+ *
+ * CONTRACT: each probe must CATCH internally and RETURN its `{ name: status }`
+ * (as the built-in postgres/redis/mongo probes do). A probe that THROWS is
+ * merged as `{}` — its dependency then vanishes from the map and `/ready`
+ * reports 200 with the dep simply absent (a silent false-healthy), rather than
+ * surfacing it as `disconnected`. The `.catch(() => ({}))` below only exists so
+ * one misbehaving probe can't take down the others, NOT as a substitute for a
+ * probe returning its own disconnected status.
+ */
+export declare function combineHealthChecks(...checks: Array<() => Promise<HealthResult>>): () => Promise<HealthResult>;
 /**
  * Minimal shape expected of a mongoose connection for the health probe.
  * Accepts `mongoose.connection` directly without requiring mongoose as a

package/lib/api/health-checks.js

@@ -1,22 +1,74 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { getConnection } from '@pipeline-builder/pipeline-core';
+/**
+ * Reject if `promise` hasn't settled within `ms`. A health/readiness probe
+ * must never hang the `/ready` response — a down datastore (or a BullMQ
+ * ioredis client with `maxRetriesPerRequest: null` + an offline queue) can
+ * leave a `ping()`/query pending indefinitely, so every probe is time-boxed.
+ */
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        timer.unref?.();
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (err) => { clearTimeout(timer); reject(err); });
+    });
+}
 /**
  * Postgres health probe: returns `{ postgres: 'connected' }` when the pool's
- * connection test succeeds, `{ postgres: 'disconnected' }` on any error
- * (so `/health` correctly reports 503). Use as the `checkDependencies`
- * option of `createApp()` for any service backed by the shared pipeline-data
- * Drizzle connection.
+ * connection test succeeds, `{ postgres: 'disconnected' }` on any error or
+ * timeout (so `/ready` correctly reports 503). Use as (part of) the
+ * `checkDependencies` option of `createApp()` for any service backed by the
+ * shared pipeline-data Drizzle connection.
  */
-export async function postgresHealthCheck() {
+export async function postgresHealthCheck(timeoutMs = 3000) {
     try {
-        await getConnection().testConnection();
+        await withTimeout(getConnection().testConnection(), timeoutMs, 'postgres testConnection');
         return { postgres: 'connected' };
     }
     catch {
         return { postgres: 'disconnected' };
     }
 }
+/**
+ * Redis health probe factory: pass the service's EXISTING ioredis connection
+ * (or a getter for it — e.g. `() => queue.client`) and get back a
+ * `checkDependencies` callback that `PING`s it. Mirrors `mongoHealthCheck` —
+ * it probes the real connection rather than opening a throwaway one per call.
+ * The PING is time-boxed so a down redis (whose offline queue would otherwise
+ * buffer the command) reports `disconnected` quickly instead of hanging.
+ */
+export function redisHealthCheck(source, timeoutMs = 2000) {
+    return async () => {
+        try {
+            const client = typeof source === 'function' ? await source() : source;
+            await withTimeout(client.ping(), timeoutMs, 'redis ping');
+            return { redis: 'connected' };
+        }
+        catch {
+            return { redis: 'disconnected' };
+        }
+    };
+}
+/**
+ * Combine several dependency probes into one `checkDependencies` callback that
+ * runs them IN PARALLEL and merges their results. A slow/failed probe can't
+ * delay the others or time out the whole `/ready` response.
+ *
+ * CONTRACT: each probe must CATCH internally and RETURN its `{ name: status }`
+ * (as the built-in postgres/redis/mongo probes do). A probe that THROWS is
+ * merged as `{}` — its dependency then vanishes from the map and `/ready`
+ * reports 200 with the dep simply absent (a silent false-healthy), rather than
+ * surfacing it as `disconnected`. The `.catch(() => ({}))` below only exists so
+ * one misbehaving probe can't take down the others, NOT as a substitute for a
+ * probe returning its own disconnected status.
+ */
+export function combineHealthChecks(...checks) {
+    return async () => {
+        const results = await Promise.all(checks.map((check) => check().catch(() => ({}))));
+        return Object.assign({}, ...results);
+    };
+}
 /**
  * MongoDB health probe factory: pass `mongoose.connection` and get back a
  * `checkDependencies` callback that reports based on mongoose's readyState.
@@ -32,4 +84,4 @@ export function mongoHealthCheck(connection) {
                 : 'disconnected',
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health-checks.js","sourceRoot":"","sources":["../../src/api/health-checks.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAKhE;;;;;GAKG;AACH,SAAS,WAAW,CAAI,OAAmB,EAAE,EAAU,EAAE,KAAa;IACpE,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,GAAG,KAAK,oBAAoB,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1F,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,CAAC,IAAI,CACV,CAAC,KAAK,EAAE,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EACnD,CAAC,GAAG,EAAE,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAC/C,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,SAAS,GAAG,IAAI;IACxD,IAAI,CAAC;QACH,MAAM,WAAW,CAAC,aAAa,EAAE,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,yBAAyB,CAAC,CAAC;QAC1F,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC;IACtC,CAAC;AACH,CAAC;AAeD;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAyB,EAAE,SAAS,GAAG,IAAI;IAC1E,OAAO,KAAK,IAAI,EAAE;QAChB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;YACtE,MAAM,WAAW,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;YAC1D,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;QAChC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC;QACnC,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAG,MAA0C;IAE7C,OAAO,KAAK,IAAI,EAAE;QAChB,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAmB,CAAA,CAAC,CAAC,CAAC,CAAC;QACpG,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,OAAO,CAAiB,CAAC;IACvD,CAAC,CAAC;AACJ,CAAC;AAWD;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAAkC;IACjE,OAAO,KAAK,IAAI,EAAE,CAAC,CAAC;QAClB,OAAO,EAAE,UAAU,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW;YAChD,CAAC,CAAC,UAAU,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,iCAAiC;gBACzE,CAAC,CAAC,cAAc;KACrB,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getConnection } from '@pipeline-builder/pipeline-core';\n\ntype HealthStatus = 'connected' | 'disconnected' | 'unknown';\ntype HealthResult = Record<string, HealthStatus>;\n\n/**\n * Reject if `promise` hasn't settled within `ms`. A health/readiness probe\n * must never hang the `/ready` response — a down datastore (or a BullMQ\n * ioredis client with `maxRetriesPerRequest: null` + an offline queue) can\n * leave a `ping()`/query pending indefinitely, so every probe is time-boxed.\n */\nfunction withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);\n    timer.unref?.();\n    promise.then(\n      (value) => { clearTimeout(timer); resolve(value); },\n      (err) => { clearTimeout(timer); reject(err); },\n    );\n  });\n}\n\n/**\n * Postgres health probe: returns `{ postgres: 'connected' }` when the pool's\n * connection test succeeds, `{ postgres: 'disconnected' }` on any error or\n * timeout (so `/ready` correctly reports 503). Use as (part of) the\n * `checkDependencies` option of `createApp()` for any service backed by the\n * shared pipeline-data Drizzle connection.\n */\nexport async function postgresHealthCheck(timeoutMs = 3000): Promise<HealthResult> {\n  try {\n    await withTimeout(getConnection().testConnection(), timeoutMs, 'postgres testConnection');\n    return { postgres: 'connected' };\n  } catch {\n    return { postgres: 'disconnected' };\n  }\n}\n\n/** Minimal shape of an ioredis client needed for a health PING. */\ninterface RedisLike {\n  ping(): Promise<string>;\n}\n\n/**\n * Source of a redis client: either the client itself, or a (sync/async) getter.\n * The getter form supports BullMQ's `queue.client` (a `Promise<RedisClient>`)\n * so a service can probe the exact connection its queue uses without opening\n * a second one.\n */\ntype RedisClientSource = RedisLike | (() => RedisLike | Promise<RedisLike>);\n\n/**\n * Redis health probe factory: pass the service's EXISTING ioredis connection\n * (or a getter for it — e.g. `() => queue.client`) and get back a\n * `checkDependencies` callback that `PING`s it. Mirrors `mongoHealthCheck` —\n * it probes the real connection rather than opening a throwaway one per call.\n * The PING is time-boxed so a down redis (whose offline queue would otherwise\n * buffer the command) reports `disconnected` quickly instead of hanging.\n */\nexport function redisHealthCheck(source: RedisClientSource, timeoutMs = 2000): () => Promise<HealthResult> {\n  return async () => {\n    try {\n      const client = typeof source === 'function' ? await source() : source;\n      await withTimeout(client.ping(), timeoutMs, 'redis ping');\n      return { redis: 'connected' };\n    } catch {\n      return { redis: 'disconnected' };\n    }\n  };\n}\n\n/**\n * Combine several dependency probes into one `checkDependencies` callback that\n * runs them IN PARALLEL and merges their results. A slow/failed probe can't\n * delay the others or time out the whole `/ready` response.\n *\n * CONTRACT: each probe must CATCH internally and RETURN its `{ name: status }`\n * (as the built-in postgres/redis/mongo probes do). A probe that THROWS is\n * merged as `{}` — its dependency then vanishes from the map and `/ready`\n * reports 200 with the dep simply absent (a silent false-healthy), rather than\n * surfacing it as `disconnected`. The `.catch(() => ({}))` below only exists so\n * one misbehaving probe can't take down the others, NOT as a substitute for a\n * probe returning its own disconnected status.\n */\nexport function combineHealthChecks(\n  ...checks: Array<() => Promise<HealthResult>>\n): () => Promise<HealthResult> {\n  return async () => {\n    const results = await Promise.all(checks.map((check) => check().catch(() => ({} as HealthResult))));\n    return Object.assign({}, ...results) as HealthResult;\n  };\n}\n\n/**\n * Minimal shape expected of a mongoose connection for the health probe.\n * Accepts `mongoose.connection` directly without requiring mongoose as a\n * dependency of api-server.\n */\ninterface MongooseConnectionLike {\n  readyState: number;\n}\n\n/**\n * MongoDB health probe factory: pass `mongoose.connection` and get back a\n * `checkDependencies` callback that reports based on mongoose's readyState.\n *\n * Mapping (per mongoose docs): 1=connected, 2=connecting, 3=disconnecting,\n * any other value (0=disconnected, 99=uninitialized) is treated as\n * 'disconnected' so `/health` returns 503.\n */\nexport function mongoHealthCheck(connection: MongooseConnectionLike): () => Promise<HealthResult> {\n  return async () => ({\n    mongodb: connection.readyState === 1 ? 'connected'\n      : connection.readyState === 2 ? 'unknown' // connecting; treat as transient\n        : 'disconnected',\n  });\n}\n"]}

package/lib/api/index.d.ts

@@ -13,5 +13,6 @@ export * from './idempotency-middleware.js';
 export * from './tracing.js';
 export * from './metrics.js';
 export * from './server.js';
+export * from './readiness.js';
 export * from './route-wrapper.js';
 export * from './request-types.js';

package/lib/api/index.js

@@ -23,8 +23,10 @@ export * from './tracing.js';
 export * from './metrics.js';
 // Server utilities
 export * from './server.js';
+// Readiness state + guard middleware
+export * from './readiness.js';
 // Route wrapper
 export * from './route-wrapper.js';
 // Request/Response types
 export * from './request-types.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/mongo-connect.d.ts

@@ -15,17 +15,5 @@ interface MongooseLike {
         serverSelectionTimeoutMS: number;
     }): Promise<unknown>;
 }
-/**
- * Connect to MongoDB with sensible production-ready pool defaults and
- * standard event-handler wiring (error / disconnected / reconnected).
- *
- * Pool sizing is read from env (`MONGO_MAX_POOL`, `MONGO_MIN_POOL`,
- * `MONGO_SERVER_SELECTION_MS`). Without these the driver default of
- * `maxPoolSize=100` lets a burst exhaust Mongo's connection ceiling
- * across replicas. Defaults: 20 max / 2 min / 5s server selection.
- *
- * Pass the service's own mongoose instance — api-server doesn't bundle
- * mongoose itself.
- */
 export declare function connectMongo(mongoose: MongooseLike, uri: string): Promise<void>;
 export {};

package/lib/api/mongo-connect.js

@@ -14,21 +14,28 @@ const logger = createLogger('mongo-connect');
  * Pass the service's own mongoose instance — api-server doesn't bundle
  * mongoose itself.
  */
+let handlersWired = false;
 export async function connectMongo(mongoose, uri) {
     mongoose.set('strictQuery', true);
-    mongoose.connection.on('error', (err) => {
-        logger.error('MongoDB connection error', { error: err?.message });
-    });
-    mongoose.connection.on('disconnected', () => {
-        logger.warn('MongoDB disconnected');
-    });
-    mongoose.connection.on('reconnected', () => {
-        logger.info('MongoDB reconnected');
-    });
+    // Wire the connection event handlers exactly once. The startup supervisor
+    // may call connectMongo repeatedly (retrying until Mongo is reachable);
+    // re-registering on every attempt would leak listeners.
+    if (!handlersWired) {
+        handlersWired = true;
+        mongoose.connection.on('error', (err) => {
+            logger.error('MongoDB connection error', { error: err?.message });
+        });
+        mongoose.connection.on('disconnected', () => {
+            logger.warn('MongoDB disconnected');
+        });
+        mongoose.connection.on('reconnected', () => {
+            logger.info('MongoDB reconnected');
+        });
+    }
     const maxPoolSize = parseInt(process.env.MONGO_MAX_POOL || '20', 10);
     const minPoolSize = parseInt(process.env.MONGO_MIN_POOL || '2', 10);
     const serverSelectionTimeoutMS = parseInt(process.env.MONGO_SERVER_SELECTION_MS || '5000', 10);
     await mongoose.connect(uri, { maxPoolSize, minPoolSize, serverSelectionTimeoutMS });
     logger.info('MongoDB connection established', { maxPoolSize, minPoolSize, serverSelectionTimeoutMS });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/readiness.d.ts

@@ -0,0 +1,29 @@
+import type { RequestHandler } from 'express';
+/** True once dependencies have connected (and remain connected). */
+export declare function isReady(): boolean;
+/** Set by the startup supervisor (and tests). */
+export declare function setReady(ready: boolean): void;
+/**
+ * Default infra endpoints that must stay reachable while NotReady, so
+ * orchestrators can probe liveness/readiness, scrape metrics, warm pools,
+ * serve docs, and relay SSE logs during startup or a dependency outage. This
+ * matches what `createApp` mounts. A service whose own routes COLLIDE with one
+ * of these prefixes (e.g. platform serves a tenant log API at `/logs`) must
+ * pass a narrower list to `readinessGuard()` so its business routes stay gated.
+ */
+export declare const DEFAULT_READINESS_BYPASS: string[];
+/**
+ * Readiness guard — while the service is NotReady (dependencies not yet
+ * connected, or dropped), reject business requests with 503 + Retry-After
+ * instead of letting them hit a disconnected datastore and 500.
+ *
+ * This is the portable, app-level readiness mechanism that works on every
+ * deploy target — including Docker Compose (single replica, no orchestrator
+ * traffic-draining) and Fargate (ECS exposes only one per-service health
+ * signal, which is also a kill trigger). k8s readiness probes layer on top.
+ *
+ * @param bypassPaths Infra prefixes that always pass through even while
+ *   NotReady. Defaults to {@link DEFAULT_READINESS_BYPASS}; pass a custom list
+ *   when a business route would otherwise collide with a default prefix.
+ */
+export declare function readinessGuard(bypassPaths?: readonly string[]): RequestHandler;

package/lib/api/readiness.js

@@ -0,0 +1,65 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { sendError } from '@pipeline-builder/api-core';
+/**
+ * Service readiness state.
+ *
+ * Flipped by startServer's dependency supervisor: set false the instant we
+ * start listening, true once the backing store(s) connect, and back to false
+ * if they later drop. Read by the readiness-guard middleware (and tests).
+ *
+ * Module-level singleton: each service runs as its own process with exactly
+ * one server, so a single flag is sufficient and avoids threading state
+ * through createApp + startServer.
+ *
+ * Defaults to `true` so an app built with createApp but NOT started via
+ * startServer — every route unit test, which drives the app directly with
+ * supertest — is never blocked by the guard. startServer flips it to false
+ * synchronously before it opens the port, so the production path is gated.
+ */
+let serviceReady = true;
+/** True once dependencies have connected (and remain connected). */
+export function isReady() {
+    return serviceReady;
+}
+/** Set by the startup supervisor (and tests). */
+export function setReady(ready) {
+    serviceReady = ready;
+}
+/**
+ * Default infra endpoints that must stay reachable while NotReady, so
+ * orchestrators can probe liveness/readiness, scrape metrics, warm pools,
+ * serve docs, and relay SSE logs during startup or a dependency outage. This
+ * matches what `createApp` mounts. A service whose own routes COLLIDE with one
+ * of these prefixes (e.g. platform serves a tenant log API at `/logs`) must
+ * pass a narrower list to `readinessGuard()` so its business routes stay gated.
+ */
+export const DEFAULT_READINESS_BYPASS = ['/health', '/ready', '/metrics', '/warmup', '/docs', '/logs'];
+function isBypassed(path, bypass) {
+    return bypass.some((p) => path === p || path.startsWith(`${p}/`));
+}
+/**
+ * Readiness guard — while the service is NotReady (dependencies not yet
+ * connected, or dropped), reject business requests with 503 + Retry-After
+ * instead of letting them hit a disconnected datastore and 500.
+ *
+ * This is the portable, app-level readiness mechanism that works on every
+ * deploy target — including Docker Compose (single replica, no orchestrator
+ * traffic-draining) and Fargate (ECS exposes only one per-service health
+ * signal, which is also a kill trigger). k8s readiness probes layer on top.
+ *
+ * @param bypassPaths Infra prefixes that always pass through even while
+ *   NotReady. Defaults to {@link DEFAULT_READINESS_BYPASS}; pass a custom list
+ *   when a business route would otherwise collide with a default prefix.
+ */
+export function readinessGuard(bypassPaths = DEFAULT_READINESS_BYPASS) {
+    return (req, res, next) => {
+        if (serviceReady || isBypassed(req.path, bypassPaths)) {
+            next();
+            return;
+        }
+        res.setHeader('Retry-After', '5');
+        sendError(res, 503, 'Service not ready — dependencies are still connecting');
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/server.js

@@ -1,11 +1,85 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { Server } from 'http';
-import { createLogger, installCrashHandlers } from '@pipeline-builder/api-core';
+import { createLogger, errorMessage, installCrashHandlers } from '@pipeline-builder/api-core';
 import { Config, getConnection, closeConnection } from '@pipeline-builder/pipeline-core';
 import { shutdownTracing } from './tracing.js';
+import { setReady, isReady } from './readiness.js';
 import { SSEManager } from '../http/sse-connection-manager.js';
 const logger = createLogger('server');
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Dependency-supervisor cadence. Initial connect retries with capped backoff;
+// once connected, re-checks at a steady interval so a later outage flips the
+// service NotReady (draining traffic) and a recovery flips it back — without
+// ever exiting / restarting the process.
+const READY_RETRY_BASE_MS = 1000;
+const READY_RETRY_MAX_MS = 10000;
+const READY_MONITOR_INTERVAL_MS = parseInt(process.env.READINESS_MONITOR_INTERVAL_MS || '15000', 10);
+/**
+ * Establish and continuously monitor the service's datastore dependency,
+ * flipping readiness state instead of crash-looping.
+ *
+ * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped
+ *   backoff until it succeeds — a cold datastore must never exit the process.
+ * - Monitor phase: poll `testDatabase` for the life of the process; flip
+ *   ready/NotReady on transitions. While NotReady the readiness guard 503s
+ *   business traffic and orchestrator readiness probes drain the instance.
+ *
+ * Runs in the background (the HTTP server is already listening). Stops when
+ * `aborted()` returns true (graceful shutdown), so it never keeps a closing
+ * process alive.
+ */
+async function superviseDependencies(name, onBeforeStart, testDatabase, aborted) {
+    if (onBeforeStart) {
+        let delay = READY_RETRY_BASE_MS;
+        while (!aborted()) {
+            try {
+                await onBeforeStart();
+                break;
+            }
+            catch (error) {
+                logger.warn(`${name}: dependency init failed, retrying in ${delay}ms`, { error: errorMessage(error) });
+                await sleep(delay);
+                delay = Math.min(delay * 2, READY_RETRY_MAX_MS);
+            }
+        }
+    }
+    // No datastore to gate on → ready as soon as we are listening.
+    if (testDatabase === false) {
+        setReady(true);
+        logger.info(`${name} ready (no datastore dependency)`);
+        return;
+    }
+    const probe = testDatabase ?? (() => getConnection().testConnection());
+    let waitDelay = READY_RETRY_BASE_MS;
+    while (!aborted()) {
+        let ok = false;
+        try {
+            ok = await probe();
+        }
+        catch {
+            ok = false;
+        }
+        if (ok && !isReady()) {
+            setReady(true);
+            waitDelay = READY_RETRY_BASE_MS;
+            logger.info(`${name} ready — dependencies connected`);
+        }
+        else if (!ok && isReady()) {
+            setReady(false);
+            logger.warn(`${name} degraded — dependency check failing (now NotReady)`);
+        }
+        // Steady cadence once ready; faster backoff while waiting so we flip to
+        // ready promptly when the datastore comes up.
+        if (isReady()) {
+            await sleep(READY_MONITOR_INTERVAL_MS);
+        }
+        else {
+            await sleep(waitDelay);
+            waitDelay = Math.min(waitDelay * 2, READY_RETRY_MAX_MS);
+        }
+    }
+}
 /**
  * Start an Express server with graceful shutdown handling
  *
@@ -39,21 +113,16 @@ export async function startServer(app, options = {}) {
     // Validate auth configuration at server startup (not during CDK synthesis)
     Config.validateAuth();
     logger.info(`Starting ${name}...`);
-    // Pre-start hook (e.g., initialize external connections)
-    if (onBeforeStart) {
-        await onBeforeStart();
-    }
-    // Test database connection
-    if (testDatabase !== false) {
-        const dbHealthy = testDatabase
-            ? await testDatabase()
-            : await getConnection().testConnection();
-        if (!dbHealthy) {
-            throw new Error('Database connection failed');
-        }
-        logger.info('Database connection established');
-    }
-    // Start server
+    // Mark NotReady synchronously, BEFORE the port opens, so no request slips
+    // through the readiness guard before the supervisor has run. The supervisor
+    // flips it true once dependencies connect.
+    setReady(false);
+    // Listen FIRST. Previously the process tested the DB and `process.exit(1)`'d
+    // on failure (to be restarted), so during a cold-DB stampede services
+    // crash-looped and never even opened their port. Now we open the port
+    // immediately — /health (liveness), /ready (readiness) and the readiness
+    // guard all respond at once — and establish + monitor the datastore in the
+    // background, reporting NotReady until it connects instead of exiting.
     const server = app.listen(port, () => {
         logger.info(`${name} listening on port: ${port}`);
         logger.info(`Platform URL: ${serverConfig.platformUrl}`);
@@ -61,6 +130,16 @@ export async function startServer(app, options = {}) {
     });
     // Shutdown handler (guarded against concurrent signals)
     let shuttingDown = false;
+    // Background dependency supervisor — established + monitored after listen,
+    // stopped on shutdown so it never keeps a closing process alive. Guard the
+    // floating promise: every expected failure is handled inside, so a rejection
+    // here means a programming error — log it and leave the service NotReady
+    // rather than letting it become an unhandledRejection that crash-exits the
+    // process (which would defeat the whole "never exit on dependency trouble"
+    // goal).
+    superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {
+        logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });
+    });
     const shutdown = async (signal) => {
         if (shuttingDown)
             return;
@@ -139,9 +218,11 @@ export function runServer(app, options = {}) {
     // process exits for the orchestrator to restart. No-op under NODE_ENV=test.
     installCrashHandlers(logger);
     startServer(app, options).catch((error) => {
-        // Log the message + stack explicitly: an Error in winston metadata serializes
-        // to `{}` (message/stack are non-enumerable), which hid the real cause (e.g.
-        // "Database connection failed") behind an empty `{error:{}}`.
+        // startServer now listens-first and supervises the DB in the background, so
+        // it only rejects on a genuinely fatal SETUP error (invalid auth config, a
+        // failed onStart, the port already in use). Log message + stack explicitly:
+        // an Error in winston metadata serializes to `{}` (message/stack are
+        // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.
         logger.error('Failed to start server', {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : undefined,
@@ -149,4 +230,4 @@ export function runServer(app, options = {}) {
         process.exit(1);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { createLogger, installCrashHandlers } from '@pipeline-builder/api-core';\nimport { Config, getConnection, closeConnection } from '@pipeline-builder/pipeline-core';\nimport type { Express } from 'express';\nimport { shutdownTracing } from './tracing.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n\n  logger.info(`Starting ${name}...`);\n\n  // Pre-start hook (e.g., initialize external connections)\n  if (onBeforeStart) {\n    await onBeforeStart();\n  }\n\n  // Test database connection\n  if (testDatabase !== false) {\n    const dbHealthy = testDatabase\n      ? await testDatabase()\n      : await getConnection().testConnection();\n\n    if (!dbHealthy) {\n      throw new Error('Database connection failed');\n    }\n\n    logger.info('Database connection established');\n  }\n\n  // Start server\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n\n    // Force shutdown after timeout\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // Log the message + stack explicitly: an Error in winston metadata serializes\n    // to `{}` (message/stack are non-enumerable), which hid the real cause (e.g.\n    // \"Database connection failed\") behind an empty `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: error instanceof Error ? error.message : String(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { createLogger, errorMessage, installCrashHandlers } from '@pipeline-builder/api-core';\nimport { Config, getConnection, closeConnection } from '@pipeline-builder/pipeline-core';\nimport type { Express } from 'express';\nimport { shutdownTracing } from './tracing.js';\nimport { setReady, isReady } from './readiness.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n// Dependency-supervisor cadence. Initial connect retries with capped backoff;\n// once connected, re-checks at a steady interval so a later outage flips the\n// service NotReady (draining traffic) and a recovery flips it back — without\n// ever exiting / restarting the process.\nconst READY_RETRY_BASE_MS = 1000;\nconst READY_RETRY_MAX_MS = 10000;\nconst READY_MONITOR_INTERVAL_MS = parseInt(process.env.READINESS_MONITOR_INTERVAL_MS || '15000', 10);\n\n/**\n * Establish and continuously monitor the service's datastore dependency,\n * flipping readiness state instead of crash-looping.\n *\n * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped\n *   backoff until it succeeds — a cold datastore must never exit the process.\n * - Monitor phase: poll `testDatabase` for the life of the process; flip\n *   ready/NotReady on transitions. While NotReady the readiness guard 503s\n *   business traffic and orchestrator readiness probes drain the instance.\n *\n * Runs in the background (the HTTP server is already listening). Stops when\n * `aborted()` returns true (graceful shutdown), so it never keeps a closing\n * process alive.\n */\nasync function superviseDependencies(\n  name: string,\n  onBeforeStart: (() => Promise<void>) | undefined,\n  testDatabase: (() => Promise<boolean>) | false | undefined,\n  aborted: () => boolean,\n): Promise<void> {\n  if (onBeforeStart) {\n    let delay = READY_RETRY_BASE_MS;\n    while (!aborted()) {\n      try {\n        await onBeforeStart();\n        break;\n      } catch (error) {\n        logger.warn(`${name}: dependency init failed, retrying in ${delay}ms`, { error: errorMessage(error) });\n        await sleep(delay);\n        delay = Math.min(delay * 2, READY_RETRY_MAX_MS);\n      }\n    }\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    setReady(true);\n    logger.info(`${name} ready (no datastore dependency)`);\n    return;\n  }\n\n  const probe = testDatabase ?? (() => getConnection().testConnection());\n  let waitDelay = READY_RETRY_BASE_MS;\n  while (!aborted()) {\n    let ok = false;\n    try {\n      ok = await probe();\n    } catch {\n      ok = false;\n    }\n\n    if (ok && !isReady()) {\n      setReady(true);\n      waitDelay = READY_RETRY_BASE_MS;\n      logger.info(`${name} ready — dependencies connected`);\n    } else if (!ok && isReady()) {\n      setReady(false);\n      logger.warn(`${name} degraded — dependency check failing (now NotReady)`);\n    }\n\n    // Steady cadence once ready; faster backoff while waiting so we flip to\n    // ready promptly when the datastore comes up.\n    if (isReady()) {\n      await sleep(READY_MONITOR_INTERVAL_MS);\n    } else {\n      await sleep(waitDelay);\n      waitDelay = Math.min(waitDelay * 2, READY_RETRY_MAX_MS);\n    }\n  }\n}\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n\n  logger.info(`Starting ${name}...`);\n\n  // Mark NotReady synchronously, BEFORE the port opens, so no request slips\n  // through the readiness guard before the supervisor has run. The supervisor\n  // flips it true once dependencies connect.\n  setReady(false);\n\n  // Listen FIRST. Previously the process tested the DB and `process.exit(1)`'d\n  // on failure (to be restarted), so during a cold-DB stampede services\n  // crash-looped and never even opened their port. Now we open the port\n  // immediately — /health (liveness), /ready (readiness) and the readiness\n  // guard all respond at once — and establish + monitor the datastore in the\n  // background, reporting NotReady until it connects instead of exiting.\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n\n  // Background dependency supervisor — established + monitored after listen,\n  // stopped on shutdown so it never keeps a closing process alive. Guard the\n  // floating promise: every expected failure is handled inside, so a rejection\n  // here means a programming error — log it and leave the service NotReady\n  // rather than letting it become an unhandledRejection that crash-exits the\n  // process (which would defeat the whole \"never exit on dependency trouble\"\n  // goal).\n  superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {\n    logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });\n  });\n\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n\n    // Force shutdown after timeout\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // startServer now listens-first and supervises the DB in the background, so\n    // it only rejects on a genuinely fatal SETUP error (invalid auth config, a\n    // failed onStart, the port already in use). Log message + stack explicitly:\n    // an Error in winston metadata serializes to `{}` (message/stack are\n    // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: error instanceof Error ? error.message : String(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}

package/package.json

@@ -43,8 +43,8 @@
     "rate-limit-redis": "5.0.0",
     "swagger-ui-express": "5.0.1",
     "uuid": "14.0.0",
-    "@pipeline-builder/api-core": "3.4.71",
-    "@pipeline-builder/pipeline-core": "3.4.79"
+    "@pipeline-builder/api-core": "3.4.72",
+    "@pipeline-builder/pipeline-core": "3.4.80"
   },
   "keywords": [
     "aws",
@@ -88,7 +88,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.83",
+  "version": "3.4.85",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },