@pipeline-builder/api-server 3.4.130 → 3.4.132

package/lib/api/route-wrapper.js

@@ -40,7 +40,11 @@ export function withRoute(handler, options = {}) {
     const { requireOrgId = true } = options;
     return async (req, res) => {
         const ctx = getContext(req);
-        const orgId = ctx.identity.orgId?.toLowerCase() || '';
+        // `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.
+        const orgId = ctx.identity.orgId || '';
         const userId = ctx.identity.userId || '';
         if (requireOrgId && !orgId) {
             return sendBadRequest(res, 'Organization ID is required');
@@ -77,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":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,YAAY,GACb,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,MAAM,MAAM,GAAG,YAAY,CAAC,eAAe,CAAC,CAAC;AAE7C;;;;;GAKG;AACH,SAAS,eAAe,CAAC,KAAc;IACrC,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,CAAC;QACxE,OAAO,GAAG,KAAK,CAAC,IAAI,IAAI,mBAAmB,yBAAyB,CAAC;IACvE,CAAC;IACD,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC;AA8BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,SAAS,CACvB,OAA4C,EAC5C,OAAO,GAAqB,EAAE;IAE9B,MAAM,EAAE,YAAY,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;IAExC,OAAO,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;QAC3C,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;QAC5B,MAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;QACtD,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC;QAEzC,IAAI,YAAY,IAAI,CAAC,KAAK,EAAE,CAAC;YAC3B,OAAO,cAAc,CAAC,GAAG,EAAE,6BAA6B,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAClD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,sDAAsD;YACtD,IAAI,GAAG,CAAC,WAAW,EAAE,CAAC;gBACpB,MAAM,CAAC,KAAK,CAAC,yCAAyC,EAAE;oBACtD,SAAS,EAAE,GAAG,CAAC,SAAS;oBACxB,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC;iBAC9B,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;YAED,IAAI,KAAK,YAAY,QAAQ,EAAE,CAAC;gBAC9B,MAAM,MAAM,GAAG,KAAK,CAAC,UAAU,IAAI,GAAG,IAAI,KAAK,CAAC,UAAU,GAAG,GAAG;oBAC9D,CAAC,CAAC,KAAK,CAAC,UAAU;oBAClB,CAAC,CAAC,GAAG,CAAC;gBACR,OAAO,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YAC3D,CAAC;YAED,6EAA6E;YAC7E,8EAA8E;YAC9E,+EAA+E;YAC/E,8EAA8E;YAC9E,MAAM,EAAE,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;YACjC,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,EAAE;gBACjC,SAAS,EAAE,GAAG,CAAC,SAAS;gBACxB,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC;gBAC7B,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1C,CAAC,CAAC;YACH,OAAO,iBAAiB,CAAC,GAAG,EAAE,uBAAuB,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;QACvF,CAAC;IACH,CAAC,CAAC;AACJ,CAAC","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    const orgId = ctx.identity.orgId?.toLowerCase() || '';\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 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"]}

package/lib/api/tenant-context.js

@@ -7,6 +7,9 @@ import { getContext } from './get-context.js';
  *  the active-org parent (org → team hierarchy) so downstream side-effects can
  *  reach it without a request. */
 const identityScope = (req) => ({
+    // `identity.orgId` is already normalized (trimmed + lowercased) once at
+    // resolution in api-core's `getIdentity`, so the GUC set here matches the
+    // app-layer WHERE clauses exactly — no ad-hoc re-normalization needed.
     orgId: getContext(req).identity.orgId,
     isSuperAdmin: isSystemAdmin(req),
     parentOrgId: req.user?.parentOrganizationId,
@@ -40,4 +43,4 @@ export function withTenantContext(resolve = identityScope) {
         runWithTenantContext(scope, () => next());
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVuYW50LWNvbnRleHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBpL3RlbmFudC1jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQzNELE9BQU8sRUFBRSxvQkFBb0IsRUFBc0IsTUFBTSxpQ0FBaUMsQ0FBQztBQUUzRixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFZOUM7O2tDQUVrQztBQUNsQyxNQUFNLGFBQWEsR0FBd0IsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDbkQsS0FBSyxFQUFFLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSztJQUNyQyxZQUFZLEVBQUUsYUFBYSxDQUFDLEdBQUcsQ0FBQztJQUNoQyxXQUFXLEVBQUUsR0FBRyxDQUFDLElBQUksRUFBRSxvQkFBb0I7Q0FDNUMsQ0FBQyxDQUFDO0FBRUg7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBQ0gsTUFBTSxVQUFVLGlCQUFpQixDQUFDLE9BQU8sR0FBd0IsYUFBYTtJQUM1RSxPQUFPLENBQUMsR0FBWSxFQUFFLElBQWMsRUFBRSxJQUFrQixFQUFRLEVBQUU7UUFDaEUsSUFBSSxLQUFvQixDQUFDO1FBQ3pCLElBQUksQ0FBQztZQUNILEtBQUssR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDdkIsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDVixPQUFPO1FBQ1QsQ0FBQztRQUNELG9CQUFvQixDQUFDLEtBQUssRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQzVDLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHsgaXNTeXN0ZW1BZG1pbiB9IGZyb20gJ0BwaXBlbGluZS1idWlsZGVyL2FwaS1jb3JlJztcbmltcG9ydCB7IHJ1bldpdGhUZW5hbnRDb250ZXh0LCB0eXBlIFRlbmFudENvbnRleHQgfSBmcm9tICdAcGlwZWxpbmUtYnVpbGRlci9waXBlbGluZS1kYXRhJztcbmltcG9ydCB0eXBlIHsgUmVxdWVzdCwgUmVzcG9uc2UsIE5leHRGdW5jdGlvbiB9IGZyb20gJ2V4cHJlc3MnO1xuaW1wb3J0IHsgZ2V0Q29udGV4dCB9IGZyb20gJy4vZ2V0LWNvbnRleHQuanMnO1xuXG4vKipcbiAqIFJlc29sdmVzIHRoZSBSTFMgdGVuYW50IHNjb3BlIGZvciBhIHJlcXVlc3QuIFRoZSBkZWZhdWx0IHJlYWRzIHRoZSBDQUxMRVInc1xuICogYXV0aGVudGljYXRlZCBpZGVudGl0eSBvcmcgKGBjdHguaWRlbnRpdHkub3JnSWRgLCB2YWxpZGF0ZWQgYnkgcmVxdWlyZU9yZ0lkKSDigJQgTk9UXG4gKiBgZ2V0T3JnSWQocmVxKWAsIHdoaWNoIHByZWZlcnMgcm91dGUgcGFyYW1zICh0aGUgcXVlcmllZCBzY29wZSksIHRoZSB3cm9uZyB0ZW5hbnQgZm9yXG4gKiBSTFMuIFNlcnZpY2VzIHdpdGggYSBkaWZmZXJlbnQgcmVxdWVzdCBib3VuZGFyeSBzdXBwbHkgdGhlaXIgb3duIHJlc29sdmVyIChlLmcuIHBsYXRmb3JtXG4gKiBzZXRzIHRoZSBzY29wZSBwcmUtYXV0aCBmcm9tIGFuIHVudmVyaWZpZWQgSldUIHBlZWsgc28gdW5hdXRoZW50aWNhdGVkIGVuZHBvaW50cyBzdGlsbFxuICogZ2V0IGEgc2FuZSBkZWZhdWx0KS5cbiAqL1xuZXhwb3J0IHR5cGUgVGVuYW50U2NvcGVSZXNvbHZlciA9IChyZXE6IFJlcXVlc3QpID0+IFRlbmFudENvbnRleHQ7XG5cbi8qKiBEZWZhdWx0IHJlc29sdmVyOiB0aGUgYXV0aGVudGljYXRlZCBpZGVudGl0eSdzIG9yZyArIHN1cGVyLWFkbWluIGZsYWcsIHBsdXNcbiAqICB0aGUgYWN0aXZlLW9yZyBwYXJlbnQgKG9yZyDihpIgdGVhbSBoaWVyYXJjaHkpIHNvIGRvd25zdHJlYW0gc2lkZS1lZmZlY3RzIGNhblxuICogIHJlYWNoIGl0IHdpdGhvdXQgYSByZXF1ZXN0LiAqL1xuY29uc3QgaWRlbnRpdHlTY29wZTogVGVuYW50U2NvcGVSZXNvbHZlciA9IChyZXEpID0+ICh7XG4gIG9yZ0lkOiBnZXRDb250ZXh0KHJlcSkuaWRlbnRpdHkub3JnSWQsXG4gIGlzU3VwZXJBZG1pbjogaXNTeXN0ZW1BZG1pbihyZXEpLFxuICBwYXJlbnRPcmdJZDogcmVxLnVzZXI/LnBhcmVudE9yZ2FuaXphdGlvbklkLFxufSk7XG5cbi8qKlxuICogRXN0YWJsaXNoIHRoZSByZXF1ZXN0J3Mgcm93LWxldmVsLXNlY3VyaXR5IHRlbmFudCBzY29wZS5cbiAqXG4gKiBSdW5zIHRoZSByZXN0IG9mIHRoZSByZXF1ZXN0IGluc2lkZSBgcnVuV2l0aFRlbmFudENvbnRleHQoeyBvcmdJZCwgaXNTdXBlckFkbWluIH0pYCAoYW5cbiAqIEFzeW5jTG9jYWxTdG9yYWdlIHNjb3BlKSBzbyBldmVyeSBgd2l0aFRlbmFudFR4YCBxdWVyeSBkb3duc3RyZWFtIGNhbiBgU0VUIExPQ0FMYCB0aGVcbiAqIFBvc3RncmVzIEdVQ3MgdGhhdCBSTFMgcG9saWNpZXMgcmVhZC4gV2l0aG91dCB0aGlzLCByZWFkcyBhZ2FpbnN0IEZPUkNFLVJMUyB0YWJsZXMgKGUuZy5cbiAqIGBwbHVnaW5zYCwgYHBpcGVsaW5lc2ApIHJ1biB3aXRoIGVtcHR5IEdVQ3MgYW5kIHNpbGVudGx5IHJldHVybiBubyByb3dzIOKAlCB0aGUgXCJzZXQgb25jZVxuICogYXQgdGhlIHJlcXVlc3QgYm91bmRhcnlcIiBib29rZW5kIHRoZSBSTFMgZW5mb3JjZW1lbnQgcGxhbiBjYWxscyBmb3IuXG4gKlxuICogRGVmYXVsdCBwbGFjZW1lbnQgaXMgQUZURVIgYHJlcXVpcmVBdXRoYCArIGByZXF1aXJlT3JnSWRgICh0aGUgcm91dGUgZmFjdG9yaWVzIGRvIHRoaXMpO1xuICogcGFzcyBhIGN1c3RvbSBgcmVzb2x2ZWAgZm9yIGEgZGlmZmVyZW50IGJvdW5kYXJ5LiBBIHRocm93biByZXNvbHZlciBtZWFucyB0ZW5hbnQgaWRlbnRpdHlcbiAqIGNvdWxkIE5PVCBiZSBlc3RhYmxpc2hlZCAoYSB3aXJpbmcgYnVnIOKAlCB0aGlzIHJ1bnMgYWZ0ZXIgYXV0aCkg4oCUIHdlIGhhcmQtRkFJTCB0aGUgcmVxdWVzdFxuICogKDUwMCB2aWEgbmV4dChlcnIpKSByYXRoZXIgdGhhbiBwcm9jZWVkLiBQcm9jZWVkaW5nIHdvdWxkIHJ1biBxdWVyaWVzIHdpdGggZW1wdHkgUkxTIEdVQ3M7XG4gKiB1bmRlciBGT1JDRSBSTFMgdGhhdCBoaWRlcyByb3dzLCBidXQgd2hpbGUgUkxTIGlzIGluIG93bmVyLWJ5cGFzcyBtb2RlIHRoZSBhcHAtbGF5ZXIgV0hFUkVcbiAqIGNsYXVzZSBpcyB0aGUgb25seSB0ZW5hbnQgZ2F0ZSwgc28gYSBzY29wZWxlc3MgcmVxdWVzdCBtdXN0IG5vdCBzaWxlbnRseSBjb250aW51ZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHdpdGhUZW5hbnRDb250ZXh0KHJlc29sdmU6IFRlbmFudFNjb3BlUmVzb2x2ZXIgPSBpZGVudGl0eVNjb3BlKSB7XG4gIHJldHVybiAocmVxOiBSZXF1ZXN0LCBfcmVzOiBSZXNwb25zZSwgbmV4dDogTmV4dEZ1bmN0aW9uKTogdm9pZCA9PiB7XG4gICAgbGV0IHNjb3BlOiBUZW5hbnRDb250ZXh0O1xuICAgIHRyeSB7XG4gICAgICBzY29wZSA9IHJlc29sdmUocmVxKTtcbiAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgIG5leHQoZXJyKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgcnVuV2l0aFRlbmFudENvbnRleHQoc2NvcGUsICgpID0+IG5leHQoKSk7XG4gIH07XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/http/index.d.ts

@@ -1 +1,2 @@
 export * from './sse-connection-manager.js';
+export * from './sse-ticket-store.js';

package/lib/http/index.js

@@ -1,4 +1,5 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export * from './sse-connection-manager.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaHR0cC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9zc2UtY29ubmVjdGlvbi1tYW5hZ2VyLmpzJztcbiJdfQ==
+export * from './sse-ticket-store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaHR0cC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL3NzZS1jb25uZWN0aW9uLW1hbmFnZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zc2UtdGlja2V0LXN0b3JlLmpzJztcbiJdfQ==

package/lib/http/sse-connection-manager.d.ts

@@ -1,4 +1,5 @@
 import type { Response } from 'express';
+import { type SSETicketStore } from './sse-ticket-store.js';
 /**
  * Event types for SSE logging
  */
@@ -68,6 +69,19 @@ export interface SSEManagerOptions {
     maxTicketsPerOrg?: number;
     /** Ticket TTL in ms (default: `SSE_TICKET_TTL_MS` from api-core). */
     ticketTtlMs?: number;
+    /**
+     * Ticket + stream-ownership backend. Defaults to an in-memory store (correct
+     * single-replica only). Inject `createEnvRedisTicketStore()` (or a bespoke
+     * `SSETicketStore`) so ticket mint/redeem AND stream ownership work across
+     * horizontally-scaled pods and — critically — so the platform stream producer
+     * (a different service) can bind ownership that this service reads.
+     */
+    ticketStore?: SSETicketStore;
+    /**
+     * TTL for a stream-ownership binding (default: `SSE_STREAM_OWNER_TTL_MS` env or
+     * 1h). Long enough to outlive a build; the producer re-binds as needed.
+     */
+    streamOwnerTtlMs?: number;
 }
 /**
  * A build-log stream subject id: either a dashed UUID (api-server's `uuid()`)
@@ -84,7 +98,7 @@ export type CreateTicketResult = {
     ticket: string;
 } | {
     ok: false;
-    reason: 'org-limit' | 'capacity';
+    reason: 'org-limit' | 'capacity' | 'forbidden';
 };
 /**
  * SSE Manager statistics
@@ -118,16 +132,17 @@ export declare class SSEManager {
      *  map mirrors `clients[].orgId` counts at all times. Orgs reach zero are
      *  deleted to keep the map bounded. */
     private orgClientCounts;
-    /** Single-use SSE tickets, keyed by opaque ticket id. Bounded by
-     *  `maxTotalTickets` / `maxTicketsPerOrg`; swept on the cleanup interval and
-     *  validated (expiry) at consume time. */
-    private tickets;
+    /** Ticket + stream-ownership backend (in-memory default; Redis for multi-pod).
+     *  Bounded by `maxTotalTickets` / `maxTicketsPerOrg`, enforced in createTicket;
+     *  expiry is validated at consume time and swept on the cleanup interval. */
+    private readonly ticketStore;
     private readonly maxClientsPerRequest;
     private readonly maxTotalClients;
     private readonly maxClientsPerOrg;
     private readonly maxTotalTickets;
     private readonly maxTicketsPerOrg;
     private readonly ticketTtlMs;
+    private readonly streamOwnerTtlMs;
     private readonly clientTimeoutMs;
     private cleanupInterval;
     constructor(options?: SSEManagerOptions);
@@ -142,8 +157,28 @@ export declare class SSEManager {
      * expected to have already format-validated against {@link SSE_REQUEST_ID_RE}.
      */
     private static normalizeRequestId;
-    /** Count of live (unexpired) tickets currently held for an org. */
-    private countLiveTicketsForOrg;
+    /**
+     * Canonical form of an orgId for ownership equality checks: trimmed and
+     * lowercased. The stream PRODUCER (bindStreamOwner) and the ticket-minting
+     * CONSUMER (createTicket) run in different services, so a casing / whitespace
+     * drift between how each renders the same org would otherwise make the owner
+     * comparison in {@link createTicket} false-`forbidden` the real owner.
+     * Normalizing both sides — mirroring {@link normalizeRequestId} — closes that.
+     */
+    private static normalizeOrgId;
+    /**
+     * Record the org that OWNS a stream subject. The stream PRODUCER calls this
+     * when it creates a build-log stream so that ticket minting can assert the
+     * caller's org owns the subject (see {@link createTicket}). Backed by the
+     * injected ticket store, so when a Redis store is wired the platform producer
+     * (a different service sharing the same Redis) can bind ownership that this
+     * service reads — closing the cross-tenant attach gap where any org could mint
+     * a ticket for a guessed requestId.
+     *
+     * @param requestId - The stream subject (format-validated by the caller).
+     * @param orgId - The owning org (normalized internally via normalizeOrgId).
+     */
+    bindStreamOwner(requestId: string, orgId: string): Promise<void>;
     /**
      * Mint a short-lived, single-use SSE ticket bound to `orgId` AND a specific
      * stream subject (`requestId`). Clients POST to obtain one (JWT-authenticated)
@@ -152,16 +187,23 @@ export declare class SSEManager {
      * ticket can then only be consumed to open that one subject's stream — see
      * {@link consumeTicket} — which is what enforces per-subject authorization.
      *
+     * ORG-OWNERSHIP: if a stream owner has been bound for this subject (via
+     * {@link bindStreamOwner}) and it is a DIFFERENT org, minting is refused
+     * (`reason: 'forbidden'`) — an org cannot mint a ticket for another org's
+     * stream even if it guesses the requestId. When no owner is bound (producer
+     * wiring not yet present), minting falls back to binding the ticket to the
+     * caller's own org, preserving current behavior.
+     *
      * Bounded by `maxTotalTickets` (process-wide) and `maxTicketsPerOrg`
      * (per-tenant). Mirrors the message-service notifications ticket store.
      *
-     * @param orgId - Owning org (already normalized by the caller).
+     * @param orgId - Owning org (normalized internally via normalizeOrgId).
      * @param requestId - The build-log stream subject this ticket authorizes.
      *   The caller must have format-validated it (see {@link SSE_REQUEST_ID_RE}).
      * @returns `{ ok: true, ticket }` on success, or `{ ok: false, reason }`
-     *   where reason is `'org-limit'` (per-org cap) or `'capacity'` (total cap).
+     *   where reason is `'org-limit'`, `'capacity'`, or `'forbidden'`.
      */
-    createTicket(orgId: string, requestId: string): CreateTicketResult;
+    createTicket(orgId: string, requestId: string): Promise<CreateTicketResult>;
     /**
      * Validate and CONSUME a ticket for a specific stream subject. Single-use:
      * the ticket is deleted whether or not it turns out to be valid, so a replay
@@ -180,9 +222,9 @@ export declare class SSEManager {
      * @param requestId - The stream subject from the URL path (`:requestId`),
      *   already format-validated by the caller.
      */
-    consumeTicket(ticketId: string, requestId: string): {
+    consumeTicket(ticketId: string, requestId: string): Promise<{
         orgId: string;
-    } | null;
+    } | null>;
     /**
      * Adds a client to the SSE manager
      *
@@ -260,7 +302,7 @@ export declare class SSEManager {
         query?: {
             ticket?: unknown;
         };
-    }, res: Response) => void;
+    }, res: Response) => Promise<void>;
     /**
      * Start periodic cleanup of stale connections
      */