@pipeline-builder/api-server 4.1.14 → 4.1.16

package/lib/api/mongo-connect.js

@@ -1,6 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { createLogger } from '@pipeline-builder/api-core';
+import { createLogger, envInt } from '@pipeline-builder/api-core';
 const logger = createLogger('mongo-connect');
 /**
  * Connect to MongoDB with sensible production-ready pool defaults and
@@ -32,10 +32,10 @@ export async function connectMongo(mongoose, uri) {
             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);
+    const maxPoolSize = envInt('MONGO_MAX_POOL', 20, { min: 1 });
+    const minPoolSize = envInt('MONGO_MIN_POOL', 2, { min: 0 });
+    const serverSelectionTimeoutMS = envInt('MONGO_SERVER_SELECTION_MS', 5000, { min: 1 });
     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/quota-reservation.d.ts

@@ -0,0 +1,52 @@
+import { type QuotaReserveResult, type QuotaService, type QuotaType } from '@pipeline-builder/api-core';
+import type { Response } from 'express';
+/** The reserved quota slot, handed to the guarded body. */
+export interface QuotaSlot {
+    /** Minted service token the reservation used — reuse it for the body's own S2S calls. */
+    readonly serviceAuth: string;
+    readonly reservation: QuotaReserveResult;
+    /**
+     * The reserved resource has been consumed (e.g. the AI provider started
+     * responding). From here on a failure KEEPS the slot — the cost was incurred.
+     */
+    markConsumed(): void;
+    /** Give the slot back now. Idempotent: refunds at most once. */
+    refund(): void;
+}
+export interface QuotaReservationOptions {
+    quotaService: QuotaService;
+    orgId: string;
+    type: QuotaType;
+    /** Signer of the quota service token. Defaults to this process (`SERVICE_NAME`). */
+    serviceName?: string;
+    logWarn: (message: string, data?: unknown) => void;
+    /** When set, a denied reservation is answered on it (429, or 503 when unconfirmable). */
+    res?: Response;
+}
+export type QuotaReservationOutcome<T> = {
+    status: 'denied';
+    reservation: QuotaReserveResult;
+} | {
+    status: 'done';
+    value: T;
+}
+/** Only with an `onError` handler: the body threw and the handler answered. */
+ | {
+    status: 'failed';
+    error: unknown;
+};
+/**
+ * Reserve one quota slot, run `body`, and settle the slot by ONE rule:
+ * keep it once the resource was consumed; refund it if the body fails first.
+ *
+ * - Denied → `{ status: 'denied' }` (answered on `res` when given); `body` never runs.
+ * - `body` resolves → the slot is kept (unless `body` called `slot.refund()`).
+ * - `body` throws → refunded unless consumed — marked via `slot.markConsumed()`
+ *   or signalled by the error itself carrying `providerContacted === true`
+ *   (an AI round-trip that completed but produced nothing usable). The error is
+ *   then passed to `onError`, or rethrown when there is none.
+ *
+ * The reserve and refund authenticate with a minted service token, never the
+ * end-user bearer: the quota increment endpoint rejects user principals.
+ */
+export declare function withQuotaReservation<T>(opts: QuotaReservationOptions, body: (slot: QuotaSlot) => Promise<T>, onError?: (error: unknown) => void | Promise<void>): Promise<QuotaReservationOutcome<T>>;

package/lib/api/quota-reservation.js

@@ -0,0 +1,56 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { decrementQuota, getServiceAuthHeader, reserveQuota, sendQuotaReserveDenied, serviceIdentity, } from '@pipeline-builder/api-core';
+/**
+ * Reserve one quota slot, run `body`, and settle the slot by ONE rule:
+ * keep it once the resource was consumed; refund it if the body fails first.
+ *
+ * - Denied → `{ status: 'denied' }` (answered on `res` when given); `body` never runs.
+ * - `body` resolves → the slot is kept (unless `body` called `slot.refund()`).
+ * - `body` throws → refunded unless consumed — marked via `slot.markConsumed()`
+ *   or signalled by the error itself carrying `providerContacted === true`
+ *   (an AI round-trip that completed but produced nothing usable). The error is
+ *   then passed to `onError`, or rethrown when there is none.
+ *
+ * The reserve and refund authenticate with a minted service token, never the
+ * end-user bearer: the quota increment endpoint rejects user principals.
+ */
+export async function withQuotaReservation(opts, body, onError) {
+    const { quotaService, orgId, type, logWarn } = opts;
+    const serviceAuth = getServiceAuthHeader({ serviceName: opts.serviceName ?? serviceIdentity(), orgId, role: 'member' });
+    // Reserve atomically BEFORE any work: two concurrent requests at the limit
+    // can't both pass.
+    const reservation = await reserveQuota(quotaService, orgId, type, serviceAuth);
+    if (reservation.exceeded) {
+        if (opts.res)
+            sendQuotaReserveDenied(opts.res, type, reservation);
+        return { status: 'denied', reservation };
+    }
+    let consumed = false;
+    let refunded = false;
+    const slot = {
+        serviceAuth,
+        reservation,
+        markConsumed: () => { consumed = true; },
+        refund: () => {
+            if (refunded)
+                return;
+            refunded = true;
+            // The reserved resetAt keeps a period rollover from being double-charged.
+            decrementQuota(quotaService, orgId, type, serviceAuth, logWarn, 1, reservation.quota.resetAt);
+        },
+    };
+    try {
+        return { status: 'done', value: await body(slot) };
+    }
+    catch (error) {
+        const errorSaysConsumed = error?.providerContacted === true;
+        if (!consumed && !errorSaysConsumed)
+            slot.refund();
+        if (!onError)
+            throw error;
+        await onError(error);
+        return { status: 'failed', error };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/rate-limit-by-org.d.ts

@@ -8,6 +8,16 @@ export interface OrgRateLimitOptions {
     windowMs: number;
     /** Optional 429 message override. */
     message?: string;
+    /**
+     * What one bucket is (default `org`):
+     *  - `org`  — the verified org (an org service account gets its own bucket);
+     *  - `user` — the verified caller (`sub`), for per-person caps;
+     *  - `ip`   — the TRUSTED client IP (`req.ip`, resolved by the app's
+     *             `trust proxy` setting — never a raw forwarding header), for
+     *             per-address caps that a user can't reset by switching orgs.
+     * Every mode falls back to the client-IP bucket for an unauthenticated caller.
+     */
+    keyBy?: 'org' | 'user' | 'ip';
 }
 /**
  * Per-ORGANIZATION rate limiter for a specific hot/expensive route, keyed on the

package/lib/api/rate-limit-by-org.js

@@ -21,7 +21,7 @@ import { createSharedRateLimitStore } from './rate-limit-store.js';
  *     withRoute(handler));
  */
 export function rateLimitByOrg(opts) {
-    const { name, max, windowMs, message } = opts;
+    const { name, max, windowMs, message, keyBy = 'org' } = opts;
     const options = {
         max,
         windowMs,
@@ -39,10 +39,15 @@ export function rateLimitByOrg(opts) {
         // bucket when unauthenticated so pre-auth traffic is still bounded.
         // Namespaced (`sa:`/`org:`/`ip:`) so no two id spaces can collide.
         keyGenerator: (req) => {
+            const ip = `ip:${ipKeyGenerator(req.ip || 'anon', 64)}`;
+            if (keyBy === 'ip')
+                return ip;
+            if (keyBy === 'user')
+                return req.user?.sub ? `user:${req.user.sub}` : ip;
             if (req.user?.principalType === 'service_account' && req.user.sub)
                 return `sa:${req.user.sub}`;
             const orgId = req.user?.organizationId;
-            return orgId ? `org:${orgId.toLowerCase()}` : `ip:${ipKeyGenerator(req.ip || 'anon', 64)}`;
+            return orgId ? `org:${orgId.toLowerCase()}` : ip;
         },
         handler: (_req, res) => {
             sendError(res, 429, message ?? `Too many ${name} requests, please slow down.`, ErrorCode.RATE_LIMIT_EXCEEDED);
@@ -55,4 +60,4 @@ export function rateLimitByOrg(opts) {
     options.store = createSharedRateLimitStore(`${process.env.SERVICE_NAME || 'api'}:${name}`);
     return rateLimit(options);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rate-limit-by-org.js","sourceRoot":"","sources":["../../src/api/rate-limit-by-org.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAE1F,OAAO,SAAS,EAAE,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAwBnE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,cAAc,CAAC,IAAyB;IACtD,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;IAE7D,MAAM,OAAO,GAAoC;QAC/C,GAAG;QACH,QAAQ;QACR,eAAe,EAAE,IAAI;QACrB,aAAa,EAAE,KAAK;QACpB,2EAA2E;QAC3E,IAAI,EAAE,CAAC,GAAY,EAAE,EAAE,CAAC,sBAAsB,CAAC,GAAG,CAAC;QACnD,2EAA2E;QAC3E,gBAAgB,EAAE,IAAI;QACtB,sEAAsE;QACtE,4EAA4E;QAC5E,0EAA0E;QAC1E,yEAAyE;QACzE,4EAA4E;QAC5E,oEAAoE;QACpE,mEAAmE;QACnE,YAAY,EAAE,CAAC,GAAY,EAAU,EAAE;YACrC,MAAM,EAAE,GAAG,MAAM,cAAc,CAAC,GAAG,CAAC,EAAE,IAAI,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;YACxD,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAO,EAAE,CAAC;YAC9B,IAAI,KAAK,KAAK,MAAM;gBAAE,OAAO,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACzE,IAAI,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,iBAAiB,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG;gBAAE,OAAO,MAAM,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YAC/F,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,cAAc,CAAC;YACvC,OAAO,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACnD,CAAC;QACD,OAAO,EAAE,CAAC,IAAa,EAAE,GAAa,EAAQ,EAAE;YAC9C,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,IAAI,YAAY,IAAI,8BAA8B,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC;QAChH,CAAC;KACF,CAAC;IAEF,+EAA+E;IAC/E,iFAAiF;IACjF,2EAA2E;IAC3E,mBAAmB;IACnB,OAAO,CAAC,KAAK,GAAG,0BAA0B,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC,CAAC;IAE3F,OAAO,SAAS,CAAC,OAAO,CAAC,CAAC;AAC5B,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sendError, ErrorCode, verifyServicePrincipal } from '@pipeline-builder/api-core';\nimport type { Request, Response } from 'express';\nimport rateLimit, { ipKeyGenerator } from 'express-rate-limit';\nimport { createSharedRateLimitStore } from './rate-limit-store.js';\n\n/** Config for a {@link rateLimitByOrg} limiter. */\nexport interface OrgRateLimitOptions {\n  /** Unique name — namespaces the Redis bucket + labels logs. */\n  name: string;\n  /** Max requests per window per org (or per client IP when unauthenticated). */\n  max: number;\n  /** Window length in ms. */\n  windowMs: number;\n  /** Optional 429 message override. */\n  message?: string;\n  /**\n   * What one bucket is (default `org`):\n   *  - `org`  — the verified org (an org service account gets its own bucket);\n   *  - `user` — the verified caller (`sub`), for per-person caps;\n   *  - `ip`   — the TRUSTED client IP (`req.ip`, resolved by the app's\n   *             `trust proxy` setting — never a raw forwarding header), for\n   *             per-address caps that a user can't reset by switching orgs.\n   * Every mode falls back to the client-IP bucket for an unauthenticated caller.\n   */\n  keyBy?: 'org' | 'user' | 'ip';\n}\n\n/**\n * Per-ORGANIZATION rate limiter for a specific hot/expensive route, keyed on the\n * VERIFIED auth org — the complement to the coarse global per-IP limiter in\n * `createApp` (which a whole org behind one NAT shares, and a distributed\n * attacker spreads across IP buckets to evade).\n *\n * MUST be mounted AFTER `requireAuth` so `req.user.organizationId` is populated;\n * an unauthenticated caller falls back to a client-IP bucket (never a spoofable\n * header) so it stays bounded. Verified internal service principals are exempt\n * (they carry a signed service JWT). Uses the shared env Redis store\n * (cross-replica, namespaced by `name`) when configured, else in-memory.\n *\n * @example\n *   router.post('/', ...createAuthenticatedWithOrgRoute(), requirePermission('messages:write'),\n *     rateLimitByOrg({ name: 'message-send', max: 60, windowMs: 60_000 }),\n *     withRoute(handler));\n */\nexport function rateLimitByOrg(opts: OrgRateLimitOptions) {\n  const { name, max, windowMs, message, keyBy = 'org' } = opts;\n\n  const options: Parameters<typeof rateLimit>[0] = {\n    max,\n    windowMs,\n    standardHeaders: true,\n    legacyHeaders: false,\n    // Exempt cryptographically-verified internal service callers (signed JWT).\n    skip: (req: Request) => verifyServicePrincipal(req),\n    // Redis store failure degrades to \"not limited\", never a 500 on the route.\n    passOnStoreError: true,\n    // Bucket by VERIFIED identity (set by requireAuth), NOT the spoofable\n    // `x-org-id` header. An ORG SERVICE ACCOUNT gets its OWN bucket rather than\n    // its org's: automation is exactly the traffic shape that would otherwise\n    // drain the window its org's people share, and the plan requires machine\n    // rate limits to be keyed per account. Falls back to a normalized client-IP\n    // bucket when unauthenticated so pre-auth traffic is still bounded.\n    // Namespaced (`sa:`/`org:`/`ip:`) so no two id spaces can collide.\n    keyGenerator: (req: Request): string => {\n      const ip = `ip:${ipKeyGenerator(req.ip || 'anon', 64)}`;\n      if (keyBy === 'ip') return ip;\n      if (keyBy === 'user') return req.user?.sub ? `user:${req.user.sub}` : ip;\n      if (req.user?.principalType === 'service_account' && req.user.sub) return `sa:${req.user.sub}`;\n      const orgId = req.user?.organizationId;\n      return orgId ? `org:${orgId.toLowerCase()}` : ip;\n    },\n    handler: (_req: Request, res: Response): void => {\n      sendError(res, 429, message ?? `Too many ${name} requests, please slow down.`, ErrorCode.RATE_LIMIT_EXCEEDED);\n    },\n  };\n\n  // Shared cross-replica store (one process-wide Redis connection) when Redis is\n  // configured, else per-process memory. Namespaced by service AND limiter name so\n  // distinct limiters — or same-named limiters in different services — never\n  // share a counter.\n  options.store = createSharedRateLimitStore(`${process.env.SERVICE_NAME || 'api'}:${name}`);\n\n  return rateLimit(options);\n}\n"]}

package/lib/api/require-org-id.d.ts

@@ -1,6 +1,6 @@
 import type { Request, Response, NextFunction } from 'express';
 /**
- * Create middleware that validates the request has an orgId in the identity headers.
+ * Create middleware that validates the request has a resolved tenant org (`ctx.identity.orgId`).
  *
  * @returns Express middleware
  *

package/lib/api/require-org-id.js

@@ -3,7 +3,7 @@
 import { ErrorCode, sendError } from '@pipeline-builder/api-core';
 import { getContext } from './get-context.js';
 /**
- * Create middleware that validates the request has an orgId in the identity headers.
+ * Create middleware that validates the request has a resolved tenant org (`ctx.identity.orgId`).
  *
  * @returns Express middleware
  *
@@ -18,11 +18,11 @@ export function requireOrgId() {
     return (req, res, next) => {
         const ctx = getContext(req);
         if (!ctx.identity.orgId) {
-            ctx.log('ERROR', 'Organization ID is missing from request headers');
-            sendError(res, 400, 'Organization ID is required. Please provide x-org-id header.', ErrorCode.VALIDATION_ERROR);
+            ctx.log('ERROR', 'Organization ID is missing from the request identity');
+            sendError(res, 400, 'Organization ID is required: the caller has no active organization.', ErrorCode.VALIDATION_ERROR);
             return;
         }
         next();
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/route-wrapper.js

@@ -41,9 +41,7 @@ export function withRoute(handler, options = {}) {
     return async (req, res) => {
         const ctx = getContext(req);
         // `identity.orgId` is already normalized (trimmed + lowercased) once at
-        // resolution in api-core's `getIdentity`, so the previously-duplicated
-        // `.toLowerCase()` here is redundant — kept normalization at the single
-        // source of truth instead. This value now matches the RLS GUC exactly.
+        // resolution in api-core's `getIdentity`, so it matches the RLS GUC exactly.
         const orgId = ctx.identity.orgId || '';
         const userId = ctx.identity.userId || '';
         if (requireOrgId && !orgId) {
@@ -65,7 +63,9 @@ export function withRoute(handler, options = {}) {
                 const status = error.statusCode >= 400 && error.statusCode < 600
                     ? error.statusCode
                     : 500;
-                return sendError(res, status, error.message, error.code);
+                return error.details === undefined
+                    ? sendError(res, status, error.message, error.code)
+                    : sendError(res, status, error.message, error.code, error.details);
             }
             // Unhandled error → 500. NEVER echo the raw message to the client: DB driver
             // errors carry the SQL + bound params, and CrudService deliberately lets them
@@ -81,4 +81,4 @@ export function withRoute(handler, options = {}) {
         }
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-wrapper.js","sourceRoot":"","sources":["../../src/api/route-wrapper.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  AppError,\n  errorMessage,\n  extractDbError,\n  sendError,\n  sendBadRequest,\n  sendInternalError,\n  createLogger,\n} from '@pipeline-builder/api-core';\nimport type { Request, Response, RequestHandler } from 'express';\nimport { getContext } from './get-context.js';\nimport type { RequestContext } from './request-types.js';\n\nconst logger = createLogger('route-wrapper');\n\n/**\n * A log-safe rendering of an unknown error. drizzle-orm's `DrizzleQueryError`\n * embeds the failed SQL statement AND the bound parameter values (real data) in\n * its `.message` (`Failed query: <sql>\\nparams: <values>`). Never put that in a\n * response or a log line — collapse it to the error name. Other errors are safe.\n */\nfunction safeErrorForLog(error: unknown): string {\n  if (error instanceof Error && error.message.startsWith('Failed query:')) {\n    return `${error.name || 'DrizzleQueryError'}: database query failed`;\n  }\n  return errorMessage(error);\n}\n\n/**\n * Context object passed to every route handler wrapped with `withRoute()`.\n */\nexport interface RouteContext {\n  /** Original Express request */\n  req: Request;\n  /** Original Express response */\n  res: Response;\n  /** Request context with identity and logging */\n  ctx: RequestContext;\n  /** Lowercased organization ID (guaranteed non-empty when requireOrgId is true) */\n  orgId: string;\n  /** User ID from JWT (defaults to empty string) */\n  userId: string;\n}\n\n/**\n * Options for `withRoute()`.\n */\nexport interface WithRouteOptions {\n  /**\n   * Whether to require orgId on the request.\n   * When true (default), returns 400 if orgId is missing.\n   * Set to false for routes that don't need org context.\n   */\n  requireOrgId?: boolean;\n}\n\n/**\n * Wrap an async route handler with standard boilerplate.\n *\n * Extracts context, orgId, userId from the request, validates orgId,\n * and catches errors. Typed `AppError` subclasses are automatically\n * mapped to the correct HTTP response.\n *\n * @param handler - Async function receiving a RouteContext\n * @param options - Configuration options\n * @returns Express RequestHandler\n *\n * @example\n * ```typescript\n * router.get('/:id', withRoute(async ({ req, res, ctx, orgId }) => {\n *   const id = getParam(req.params, 'id');\n *   const result = await pipelineService.findById(id, orgId);\n *   if (!result) throw new NotFoundError('Pipeline not found');\n *   return sendSuccess(res, 200, { pipeline: result });\n * }));\n * ```\n */\nexport function withRoute(\n  handler: (rc: RouteContext) => Promise<void>,\n  options: WithRouteOptions = {},\n): RequestHandler {\n  const { requireOrgId = true } = options;\n\n  return async (req: Request, res: Response) => {\n    const ctx = getContext(req);\n    // `identity.orgId` is already normalized (trimmed + lowercased) once at\n    // resolution in api-core's `getIdentity`, so the previously-duplicated\n    // `.toLowerCase()` here is redundant — kept normalization at the single\n    // source of truth instead. This value now matches the RLS GUC exactly.\n    const orgId = ctx.identity.orgId || '';\n    const userId = ctx.identity.userId || '';\n\n    if (requireOrgId && !orgId) {\n      return sendBadRequest(res, 'Organization ID is required');\n    }\n\n    try {\n      await handler({ req, res, ctx, orgId, userId });\n    } catch (error) {\n      // Don't send another response if one was already sent\n      if (res.headersSent) {\n        logger.error('Route handler error after response sent', {\n          requestId: ctx.requestId,\n          error: safeErrorForLog(error),\n        });\n        return;\n      }\n\n      if (error instanceof AppError) {\n        const status = error.statusCode >= 400 && error.statusCode < 600\n          ? error.statusCode\n          : 500;\n        return sendError(res, status, error.message, error.code);\n      }\n\n      // Unhandled error → 500. NEVER echo the raw message to the client: DB driver\n      // errors carry the SQL + bound params, and CrudService deliberately lets them\n      // propagate here. Send a generic message + requestId (to correlate with logs),\n      // and log only sanitized DB metadata (code/constraint/table — no SQL/params).\n      const db = extractDbError(error);\n      ctx.log('ERROR', 'Request failed', {\n        requestId: ctx.requestId,\n        error: safeErrorForLog(error),\n        ...(Object.keys(db).length ? { db } : {}),\n      });\n      return sendInternalError(res, 'Internal server error', { requestId: ctx.requestId });\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-wrapper.js","sourceRoot":"","sources":["../../src/api/route-wrapper.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  AppError,\n  errorMessage,\n  extractDbError,\n  sendError,\n  sendBadRequest,\n  sendInternalError,\n  createLogger,\n} from '@pipeline-builder/api-core';\nimport type { Request, Response, RequestHandler } from 'express';\nimport { getContext } from './get-context.js';\nimport type { RequestContext } from './request-types.js';\n\nconst logger = createLogger('route-wrapper');\n\n/**\n * A log-safe rendering of an unknown error. drizzle-orm's `DrizzleQueryError`\n * embeds the failed SQL statement AND the bound parameter values (real data) in\n * its `.message` (`Failed query: <sql>\\nparams: <values>`). Never put that in a\n * response or a log line — collapse it to the error name. Other errors are safe.\n */\nfunction safeErrorForLog(error: unknown): string {\n  if (error instanceof Error && error.message.startsWith('Failed query:')) {\n    return `${error.name || 'DrizzleQueryError'}: database query failed`;\n  }\n  return errorMessage(error);\n}\n\n/**\n * Context object passed to every route handler wrapped with `withRoute()`.\n */\nexport interface RouteContext {\n  /** Original Express request */\n  req: Request;\n  /** Original Express response */\n  res: Response;\n  /** Request context with identity and logging */\n  ctx: RequestContext;\n  /** Lowercased organization ID (guaranteed non-empty when requireOrgId is true) */\n  orgId: string;\n  /** User ID from JWT (defaults to empty string) */\n  userId: string;\n}\n\n/**\n * Options for `withRoute()`.\n */\nexport interface WithRouteOptions {\n  /**\n   * Whether to require orgId on the request.\n   * When true (default), returns 400 if orgId is missing.\n   * Set to false for routes that don't need org context.\n   */\n  requireOrgId?: boolean;\n}\n\n/**\n * Wrap an async route handler with standard boilerplate.\n *\n * Extracts context, orgId, userId from the request, validates orgId,\n * and catches errors. Typed `AppError` subclasses are automatically\n * mapped to the correct HTTP response.\n *\n * @param handler - Async function receiving a RouteContext\n * @param options - Configuration options\n * @returns Express RequestHandler\n *\n * @example\n * ```typescript\n * router.get('/:id', withRoute(async ({ req, res, ctx, orgId }) => {\n *   const id = getParam(req.params, 'id');\n *   const result = await pipelineService.findById(id, orgId);\n *   if (!result) throw new NotFoundError('Pipeline not found');\n *   return sendSuccess(res, 200, { pipeline: result });\n * }));\n * ```\n */\nexport function withRoute(\n  handler: (rc: RouteContext) => Promise<void>,\n  options: WithRouteOptions = {},\n): RequestHandler {\n  const { requireOrgId = true } = options;\n\n  return async (req: Request, res: Response) => {\n    const ctx = getContext(req);\n    // `identity.orgId` is already normalized (trimmed + lowercased) once at\n    // resolution in api-core's `getIdentity`, so it matches the RLS GUC exactly.\n    const orgId = ctx.identity.orgId || '';\n    const userId = ctx.identity.userId || '';\n\n    if (requireOrgId && !orgId) {\n      return sendBadRequest(res, 'Organization ID is required');\n    }\n\n    try {\n      await handler({ req, res, ctx, orgId, userId });\n    } catch (error) {\n      // Don't send another response if one was already sent\n      if (res.headersSent) {\n        logger.error('Route handler error after response sent', {\n          requestId: ctx.requestId,\n          error: safeErrorForLog(error),\n        });\n        return;\n      }\n\n      if (error instanceof AppError) {\n        const status = error.statusCode >= 400 && error.statusCode < 600\n          ? error.statusCode\n          : 500;\n        return error.details === undefined\n          ? sendError(res, status, error.message, error.code)\n          : sendError(res, status, error.message, error.code, error.details);\n      }\n\n      // Unhandled error → 500. NEVER echo the raw message to the client: DB driver\n      // errors carry the SQL + bound params, and CrudService deliberately lets them\n      // propagate here. Send a generic message + requestId (to correlate with logs),\n      // and log only sanitized DB metadata (code/constraint/table — no SQL/params).\n      const db = extractDbError(error);\n      ctx.log('ERROR', 'Request failed', {\n        requestId: ctx.requestId,\n        error: safeErrorForLog(error),\n        ...(Object.keys(db).length ? { db } : {}),\n      });\n      return sendInternalError(res, 'Internal server error', { requestId: ctx.requestId });\n    }\n  };\n}\n"]}

package/lib/api/server.js

@@ -1,21 +1,20 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { Server } from 'http';
-import { buildRouteTable, createLogger, errorMessage, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable } from '@pipeline-builder/api-core';
+import { buildRouteTable, createLogger, errorMessage, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable, sleep, envInt } from '@pipeline-builder/api-core';
 import { Config } from '@pipeline-builder/pipeline-core';
 import { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';
 import { setReady, isReady } from './readiness.js';
 import { shutdownTracing } from './tracing.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);
+const READY_MONITOR_INTERVAL_MS = envInt('READINESS_MONITOR_INTERVAL_MS', 15_000, { min: 1 });
 /**
  * Establish and continuously monitor the service's datastore dependency,
  * flipping readiness state instead of crash-looping.
@@ -41,6 +40,8 @@ async function superviseDependencies(name, onBeforeStart, testDatabase, aborted)
     }
     // No datastore to gate on → ready as soon as we are listening.
     if (testDatabase === false) {
+        if (aborted())
+            return; // shutdown began while we were initializing
         setReady(true);
         logger.info(`${name} ready (no datastore dependency)`);
         return;
@@ -55,6 +56,10 @@ async function superviseDependencies(name, onBeforeStart, testDatabase, aborted)
         catch {
             ok = false;
         }
+        // A probe that was in flight when shutdown began must not flip the
+        // draining instance back to ready.
+        if (aborted())
+            break;
         if (ok && !isReady()) {
             setReady(true);
             waitDelay = READY_RETRY_BASE_MS;
@@ -108,7 +113,7 @@ export async function startServer(app, options = {}) {
     // Validate auth configuration at server startup (not during CDK synthesis)
     Config.validateAuth();
     // Fail fast if this service has no internal signing key of its own, or no
-    // public bundle to verify its peers with (#14). Without them it would mint
+    // public bundle to verify its peers with. Without them it would mint
     // tokens on an EPHEMERAL in-process key that no peer accepts, and reject every
     // peer's token — i.e. silently lose all service-to-service traffic. Checked
     // HERE rather than in `createApp` because it is a property of the running
@@ -155,9 +160,21 @@ export async function startServer(app, options = {}) {
         if (shuttingDown)
             return;
         shuttingDown = true;
+        // Drain FIRST: report NotReady before anything else, so the load balancer /
+        // readiness probe stops sending new work while the rest of shutdown runs.
+        // (Previously readiness stayed green through onShutdown, which could take
+        // seconds — new requests kept arriving at a process tearing itself down.)
+        setReady(false);
         if (signal) {
             logger.info(`${signal} received, shutting down gracefully...`);
         }
+        // Arm the force-exit BEFORE awaiting anything: a hung onShutdown (a stuck
+        // queue close, a Redis quit that never answers) would otherwise block forever
+        // with the timer never started, so the pod would ignore SIGTERM until SIGKILL.
+        setTimeout(() => {
+            logger.error('Forced shutdown after timeout');
+            process.exit(1);
+        }, shutdownTimeoutMs).unref();
         // Custom shutdown callback
         if (onShutdown) {
             try {
@@ -194,11 +211,6 @@ export async function startServer(app, options = {}) {
             }
             process.exit(0);
         });
-        // Force shutdown after timeout
-        setTimeout(() => {
-            logger.error('Forced shutdown after timeout');
-            process.exit(1);
-        }, shutdownTimeoutMs).unref();
     };
     // Register signal handlers
     process.once('SIGINT', () => void shutdown('SIGINT'));
@@ -246,4 +258,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 { buildRouteTable, createLogger, errorMessage, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';\nimport type { Express } from 'express';\nimport { setReady, isReady } from './readiness.js';\nimport { shutdownTracing } from './tracing.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    await retryForever(onBeforeStart, {\n      baseMs: READY_RETRY_BASE_MS,\n      maxMs: READY_RETRY_MAX_MS,\n      onAttemptFailed: (error, delayMs) => logger.warn(\n        `${name}: dependency init failed, retrying in ${delayMs}ms`,\n        { error: errorMessage(error) },\n      ),\n      shouldContinue: () => !aborted(),\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 = nextBackoffMs(waitDelay, 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  // Fail fast if this service has no internal signing key of its own, or no\n  // public bundle to verify its peers with (#14). Without them it would mint\n  // tokens on an EPHEMERAL in-process key that no peer accepts, and reject every\n  // peer's token — i.e. silently lose all service-to-service traffic. Checked\n  // HERE rather than in `createApp` because it is a property of the running\n  // deployment, not of the app object: route-table builders and test suites\n  // assemble an app without ever signing anything.\n  for (const envVar of ['SERVICE_SIGNING_KEY_FILE', 'SERVICE_KEY_BUNDLE_FILE'] as const) {\n    if (!process.env[envVar]) {\n      throw new Error(`${envVar} environment variable is required (generate with deploy/bin/service-signing-keys.sh). Set it before starting the server.`);\n    }\n  }\n  // Fail fast on an unusable Redis configuration (throws RedisConfigError) — a\n  // Redis client is created lazily on first use, so without this a bad config\n  // would surface as request-time errors instead of a failed start.\n  resolveRedisConnection();\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  // Route table of the fully assembled app (see api-core's route-table.ts): the\n  // same introspection the per-service coverage test asserts on, logged once at\n  // boot so an ungated or unaudited write route is visible in the running\n  // service, not only in CI.\n  logger.info('Route table built', summarizeRouteTable(buildRouteTable(app)));\n\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: errorMessage(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 { buildRouteTable, createLogger, errorMessage, installCrashHandlers, nextBackoffMs, resolveRedisConnection, retryForever, summarizeRouteTable, sleep, envInt } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';\nimport type { Express } from 'express';\nimport { setReady, isReady } from './readiness.js';\nimport { shutdownTracing } from './tracing.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\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 = envInt('READINESS_MONITOR_INTERVAL_MS', 15_000, { min: 1 });\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    await retryForever(onBeforeStart, {\n      baseMs: READY_RETRY_BASE_MS,\n      maxMs: READY_RETRY_MAX_MS,\n      onAttemptFailed: (error, delayMs) => logger.warn(\n        `${name}: dependency init failed, retrying in ${delayMs}ms`,\n        { error: errorMessage(error) },\n      ),\n      shouldContinue: () => !aborted(),\n    });\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    if (aborted()) return; // shutdown began while we were initializing\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    // A probe that was in flight when shutdown began must not flip the\n    // draining instance back to ready.\n    if (aborted()) break;\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 = nextBackoffMs(waitDelay, 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  // Fail fast if this service has no internal signing key of its own, or no\n  // public bundle to verify its peers with. Without them it would mint\n  // tokens on an EPHEMERAL in-process key that no peer accepts, and reject every\n  // peer's token — i.e. silently lose all service-to-service traffic. Checked\n  // HERE rather than in `createApp` because it is a property of the running\n  // deployment, not of the app object: route-table builders and test suites\n  // assemble an app without ever signing anything.\n  for (const envVar of ['SERVICE_SIGNING_KEY_FILE', 'SERVICE_KEY_BUNDLE_FILE'] as const) {\n    if (!process.env[envVar]) {\n      throw new Error(`${envVar} environment variable is required (generate with deploy/bin/service-signing-keys.sh). Set it before starting the server.`);\n    }\n  }\n  // Fail fast on an unusable Redis configuration (throws RedisConfigError) — a\n  // Redis client is created lazily on first use, so without this a bad config\n  // would surface as request-time errors instead of a failed start.\n  resolveRedisConnection();\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    // Drain FIRST: report NotReady before anything else, so the load balancer /\n    // readiness probe stops sending new work while the rest of shutdown runs.\n    // (Previously readiness stayed green through onShutdown, which could take\n    // seconds — new requests kept arriving at a process tearing itself down.)\n    setReady(false);\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Arm the force-exit BEFORE awaiting anything: a hung onShutdown (a stuck\n    // queue close, a Redis quit that never answers) would otherwise block forever\n    // with the timer never started, so the pod would ignore SIGTERM until SIGKILL.\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\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\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  // Route table of the fully assembled app (see api-core's route-table.ts): the\n  // same introspection the per-service coverage test asserts on, logged once at\n  // boot so an ungated or unaudited write route is visible in the running\n  // service, not only in CI.\n  logger.info('Route table built', summarizeRouteTable(buildRouteTable(app)));\n\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: errorMessage(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}

package/lib/api/tenant-context.d.ts

@@ -2,9 +2,8 @@ import { type TenantContext } from '@pipeline-builder/pipeline-data';
 import type { Request, Response, NextFunction } from 'express';
 /**
  * Resolves the RLS tenant scope for a request. The default reads the CALLER's
- * authenticated identity org (`ctx.identity.orgId`, validated by requireOrgId) — NOT
- * `getOrgId(req)`, which prefers route params (the queried scope), the wrong tenant for
- * RLS. Services with a different request boundary supply their own resolver (e.g. platform
+ * authenticated identity org (`ctx.identity.orgId`, validated by requireOrgId) — never a
+ * route param, which names the QUERIED scope, the wrong tenant for RLS. Services with a different request boundary supply their own resolver (e.g. platform
  * sets the scope pre-auth from an unverified JWT peek so unauthenticated endpoints still
  * get a sane default).
  */
@@ -21,8 +20,8 @@ export type TenantScopeResolver = (req: Request) => TenantContext;
  * Default placement is AFTER `requireAuth` + `requireOrgId` (the route factories do this);
  * pass a custom `resolve` for a different boundary. A thrown resolver means tenant identity
  * could NOT be established (a wiring bug — this runs after auth) — we hard-FAIL the request
- * (500 via next(err)) rather than proceed. Proceeding would run queries with empty RLS GUCs;
- * under FORCE RLS that hides rows, but while RLS is in owner-bypass mode the app-layer WHERE
- * clause is the only tenant gate, so a scopeless request must not silently continue.
+ * (500 via next(err)) rather than proceed. Proceeding would run queries with empty RLS GUCs,
+ * which under FORCE RLS hide every row and refuse writes — a wiring bug surfacing as a
+ * silently empty result instead of an error.
  */
 export declare function withTenantContext(resolve?: TenantScopeResolver): (req: Request, _res: Response, next: NextFunction) => void;