@pipeline-builder/api-core 3.4.81 → 3.4.83

package/lib/middleware/auth.d.ts

@@ -40,6 +40,12 @@ export declare function isSystemOrgId(orgId?: string, orgName?: string): boolean
  * sample data; it just no longer confers privilege.
  */
 export declare function isSystemAdmin(req: Request): boolean;
+/**
+ * Whether the request's token carries a specific capability `scope` (e.g.
+ * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine
+ * identity — a normal interactive user token has no `scope` and returns false.
+ */
+export declare function hasScope(req: Request, scope: string): boolean;
 /** Requires system admin (admin role + system organization). */
 export declare function requireSystemAdmin(req: Request, res: Response, next: NextFunction): void;
 /**

package/lib/middleware/auth.js

@@ -133,6 +133,14 @@ export function isSystemOrgId(orgId, orgName) {
 export function isSystemAdmin(req) {
     return req.user?.isSuperAdmin === true;
 }
+/**
+ * Whether the request's token carries a specific capability `scope` (e.g.
+ * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine
+ * identity — a normal interactive user token has no `scope` and returns false.
+ */
+export function hasScope(req, scope) {
+    return req.user?.scope === scope;
+}
 /** Requires system admin (admin role + system organization). */
 export function requireSystemAdmin(req, res, next) {
     if (!isSystemAdmin(req)) {
@@ -229,4 +237,4 @@ export function getServiceAuthHeader(opts) {
 export function isServicePrincipal(req) {
     return req.user?.sub?.startsWith('service:') ?? false;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { JwtPayload } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n\n/** Cached JWT secret with periodic refresh from env var. */\nlet _jwtSecret: string | undefined;\nlet _jwtSecretRefreshedAt = 0;\nconst JWT_SECRET_REFRESH_INTERVAL_MS = 300_000; // 5 minutes\n\nfunction getJwtSecret(): string {\n  const now = Date.now();\n  if (!_jwtSecret || now - _jwtSecretRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    const secret = process.env.JWT_SECRET;\n    if (!secret) {\n      logger.error('JWT_SECRET environment variable is not set');\n      throw new Error('JWT_SECRET environment variable is required');\n    }\n    if (_jwtSecret && _jwtSecret !== secret) {\n      logger.info('JWT secret rotated');\n    }\n    _jwtSecret = secret;\n    _jwtSecretRefreshedAt = now;\n  }\n  return _jwtSecret;\n}\n\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  return (req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  };\n}\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  try {\n    // Pass through optional issuer/audience verification when env-configured.\n    // Without these, a JWT signed by any system that happens to share the\n    // same JWT_SECRET would be accepted — defence-in-depth for shared-secret\n    // misconfigurations across services / environments.\n    // Pin the accepted algorithm to the configured HMAC alg (default HS256).\n    // Without an allow-list, `jwt.verify` accepts any algorithm the key can\n    // verify — the classic alg-confusion vector (and a hard guard against\n    // `alg:none`). Env-driven so it stays in lockstep with how tokens are\n    // signed (see signServiceToken + platform's config.auth.jwt.algorithm).\n    const verifyOptions: jwt.VerifyOptions = { algorithms: [(process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm] };\n    const expectedIssuer = process.env.JWT_ISSUER;\n    const expectedAudience = process.env.JWT_AUDIENCE;\n    if (expectedIssuer) verifyOptions.issuer = expectedIssuer;\n    if (expectedAudience) verifyOptions.audience = expectedAudience;\n    const decoded = jwt.verify(parts[1], getJwtSecret(), verifyOptions) as JwtPayload;\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    req.user = { ...decoded };\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    if (error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n/**\n * Requires admin role. Use after requireAuth.\n * Permits users whose per-org role is 'admin' or 'owner'.\n */\nexport function requireAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n\n  if (req.user.role !== 'admin' && req.user.role !== 'owner') {\n    return sendError(res, HttpStatus.FORBIDDEN, 'Admin access required', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n\n  next();\n}\n\n/** Organization ID/name that identifies the system (super-admin) tenant. */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || 'system').toLowerCase();\n\n/**\n * Check if an orgId or orgName matches the system org.\n * Use this instead of comparing directly against SYSTEM_ORG_ID,\n * because the JWT orgId is a database ID (e.g. MongoDB ObjectId)\n * while SYSTEM_ORG_ID is the well-known name \"system\".\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_ID;\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/** Requires system admin (admin role + system organization). */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  };\n}\n\n/**\n * Resolve the effective access modifier for an entity being created/updated.\n * 'public' is permitted for any admin or owner role (system admins create\n * catalog-wide public entities; org admins create org-wide public entities).\n * Everyone else (member role, no role) gets 'private'.\n */\nexport function resolveAccessModifier(req: Request, requested: string | undefined): 'public' | 'private' {\n  if (requested === 'public' && (req.user?.role === 'admin' || req.user?.role === 'owner')) {\n    return 'public';\n  }\n  return 'private';\n}\n\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived JWT signed with the shared\n// JWT_SECRET, identifying the calling service via `sub: 'service:<name>'`.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireAdmin` rely on the org/role embedded in the token.\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org ID, or 'system' for system-wide ops. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries (required — no implicit default). **Pass the LOWEST\n   * role the call actually needs** (`'member'` for read / data-plane calls) so a\n   * leaked service token can't perform admin actions in the target org.\n   * `isAdmin` is derived from this (admin|owner → true).\n   */\n  role: 'owner' | 'admin' | 'member';\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n * Scope it with `opts.role` — least privilege keeps a leaked token low-value.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: JwtPayload = {\n    sub: `service:${opts.serviceName}`,\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n  };\n  // Match the optional issuer/audience that requireAuth verifies, when\n  // configured. Without these, a service token signed here would fail\n  // requireAuth in a deployment that has set JWT_ISSUER/JWT_AUDIENCE.\n  const signOptions: jwt.SignOptions = {\n    expiresIn: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    // Sign with the same configured alg requireAuth pins on verify, so service\n    // tokens stay valid under a non-default JWT_ALGORITHM.\n    algorithm: (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm,\n  };\n  if (process.env.JWT_ISSUER) signOptions.issuer = process.env.JWT_ISSUER;\n  if (process.env.JWT_AUDIENCE) signOptions.audience = process.env.JWT_AUDIENCE;\n  return jwt.sign(payload, getJwtSecret(), signOptions);\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user.sub` was issued by `signServiceToken` (i.e. starts with `service:`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.sub?.startsWith('service:') ?? false;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { JwtPayload } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n\n/** Cached JWT secret with periodic refresh from env var. */\nlet _jwtSecret: string | undefined;\nlet _jwtSecretRefreshedAt = 0;\nconst JWT_SECRET_REFRESH_INTERVAL_MS = 300_000; // 5 minutes\n\nfunction getJwtSecret(): string {\n  const now = Date.now();\n  if (!_jwtSecret || now - _jwtSecretRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    const secret = process.env.JWT_SECRET;\n    if (!secret) {\n      logger.error('JWT_SECRET environment variable is not set');\n      throw new Error('JWT_SECRET environment variable is required');\n    }\n    if (_jwtSecret && _jwtSecret !== secret) {\n      logger.info('JWT secret rotated');\n    }\n    _jwtSecret = secret;\n    _jwtSecretRefreshedAt = now;\n  }\n  return _jwtSecret;\n}\n\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  return (req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  };\n}\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  try {\n    // Pass through optional issuer/audience verification when env-configured.\n    // Without these, a JWT signed by any system that happens to share the\n    // same JWT_SECRET would be accepted — defence-in-depth for shared-secret\n    // misconfigurations across services / environments.\n    // Pin the accepted algorithm to the configured HMAC alg (default HS256).\n    // Without an allow-list, `jwt.verify` accepts any algorithm the key can\n    // verify — the classic alg-confusion vector (and a hard guard against\n    // `alg:none`). Env-driven so it stays in lockstep with how tokens are\n    // signed (see signServiceToken + platform's config.auth.jwt.algorithm).\n    const verifyOptions: jwt.VerifyOptions = { algorithms: [(process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm] };\n    const expectedIssuer = process.env.JWT_ISSUER;\n    const expectedAudience = process.env.JWT_AUDIENCE;\n    if (expectedIssuer) verifyOptions.issuer = expectedIssuer;\n    if (expectedAudience) verifyOptions.audience = expectedAudience;\n    const decoded = jwt.verify(parts[1], getJwtSecret(), verifyOptions) as JwtPayload;\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    req.user = { ...decoded };\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    if (error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n/**\n * Requires admin role. Use after requireAuth.\n * Permits users whose per-org role is 'admin' or 'owner'.\n */\nexport function requireAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n\n  if (req.user.role !== 'admin' && req.user.role !== 'owner') {\n    return sendError(res, HttpStatus.FORBIDDEN, 'Admin access required', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n\n  next();\n}\n\n/** Organization ID/name that identifies the system (super-admin) tenant. */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || 'system').toLowerCase();\n\n/**\n * Check if an orgId or orgName matches the system org.\n * Use this instead of comparing directly against SYSTEM_ORG_ID,\n * because the JWT orgId is a database ID (e.g. MongoDB ObjectId)\n * while SYSTEM_ORG_ID is the well-known name \"system\".\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_ID;\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires system admin (admin role + system organization). */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  };\n}\n\n/**\n * Resolve the effective access modifier for an entity being created/updated.\n * 'public' is permitted for any admin or owner role (system admins create\n * catalog-wide public entities; org admins create org-wide public entities).\n * Everyone else (member role, no role) gets 'private'.\n */\nexport function resolveAccessModifier(req: Request, requested: string | undefined): 'public' | 'private' {\n  if (requested === 'public' && (req.user?.role === 'admin' || req.user?.role === 'owner')) {\n    return 'public';\n  }\n  return 'private';\n}\n\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived JWT signed with the shared\n// JWT_SECRET, identifying the calling service via `sub: 'service:<name>'`.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireAdmin` rely on the org/role embedded in the token.\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org ID, or 'system' for system-wide ops. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries (required — no implicit default). **Pass the LOWEST\n   * role the call actually needs** (`'member'` for read / data-plane calls) so a\n   * leaked service token can't perform admin actions in the target org.\n   * `isAdmin` is derived from this (admin|owner → true).\n   */\n  role: 'owner' | 'admin' | 'member';\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n * Scope it with `opts.role` — least privilege keeps a leaked token low-value.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: JwtPayload = {\n    sub: `service:${opts.serviceName}`,\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n  };\n  // Match the optional issuer/audience that requireAuth verifies, when\n  // configured. Without these, a service token signed here would fail\n  // requireAuth in a deployment that has set JWT_ISSUER/JWT_AUDIENCE.\n  const signOptions: jwt.SignOptions = {\n    expiresIn: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    // Sign with the same configured alg requireAuth pins on verify, so service\n    // tokens stay valid under a non-default JWT_ALGORITHM.\n    algorithm: (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm,\n  };\n  if (process.env.JWT_ISSUER) signOptions.issuer = process.env.JWT_ISSUER;\n  if (process.env.JWT_AUDIENCE) signOptions.audience = process.env.JWT_AUDIENCE;\n  return jwt.sign(payload, getJwtSecret(), signOptions);\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user.sub` was issued by `signServiceToken` (i.e. starts with `service:`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.sub?.startsWith('service:') ?? false;\n}\n"]}

package/lib/middleware/mongo-sanitize.d.ts

@@ -12,8 +12,10 @@ import type { NextFunction, Request, Response } from 'express';
  * Apply BEFORE any Mongo query handler (typically right after
  * `express.json()`). Postgres-backed services don't need it.
  *
- * Modifies in place. On Express 5+ where `req.query` is a read-only getter,
- * this still works because we mutate the underlying object's keys, not the
- * reference.
+ * `req.body` and `req.params` are plain writable objects, so they're sanitized
+ * in place. On Express 5 `req.query` is a GETTER that re-parses the URL and
+ * returns a fresh object on every access — mutating it is a no-op — so we
+ * sanitize a snapshot and pin it onto the request instance with
+ * `Object.defineProperty`, shadowing the getter for all downstream reads.
  */
 export declare function mongoSanitize(): (req: Request, _res: Response, next: NextFunction) => void;

package/lib/middleware/mongo-sanitize.js

@@ -13,18 +13,30 @@
  * Apply BEFORE any Mongo query handler (typically right after
  * `express.json()`). Postgres-backed services don't need it.
  *
- * Modifies in place. On Express 5+ where `req.query` is a read-only getter,
- * this still works because we mutate the underlying object's keys, not the
- * reference.
+ * `req.body` and `req.params` are plain writable objects, so they're sanitized
+ * in place. On Express 5 `req.query` is a GETTER that re-parses the URL and
+ * returns a fresh object on every access — mutating it is a no-op — so we
+ * sanitize a snapshot and pin it onto the request instance with
+ * `Object.defineProperty`, shadowing the getter for all downstream reads.
  */
 export function mongoSanitize() {
     return (req, _res, next) => {
         if (req.body && typeof req.body === 'object')
             sanitizeObject(req.body);
-        if (req.query && typeof req.query === 'object')
-            sanitizeObject(req.query);
         if (req.params && typeof req.params === 'object')
             sanitizeObject(req.params);
+        if (req.query && typeof req.query === 'object') {
+            const q = req.query;
+            sanitizeObject(q);
+            // Pin the sanitized snapshot so the Express 5 getter can't re-parse a
+            // fresh (unsanitized) object on the next access.
+            try {
+                Object.defineProperty(req, 'query', { value: q, writable: true, configurable: true, enumerable: true });
+            }
+            catch {
+                // Express 4 (writable data prop) — the in-place sanitize above sufficed.
+            }
+        }
         next();
     };
 }
@@ -55,4 +67,4 @@ function sanitizeObject(obj, depth = 0) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/cache-service.js

@@ -135,8 +135,11 @@ export class CacheService {
                 }
                 return keys.length;
             }
-            // In-memory — match glob-style pattern
-            const regex = new RegExp('^' + fp.replace(/\*/g, '.*') + '$');
+            // In-memory — match glob-style pattern. Escape regex metacharacters first
+            // so a literal `.`/`(`/`[` in a key prefix (e.g. `org:v1.2:*`) can't
+            // over-match or throw (a throw here is swallowed → nothing invalidated →
+            // stale reads); only `*` is treated as a wildcard.
+            const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*') + '$');
             let deleted = 0;
             for (const key of this.memory.keys()) {
                 if (regex.test(key)) {
@@ -204,4 +207,4 @@ export class CacheService {
 export function createCacheService(prefix, defaultTtlSeconds = 300, redis) {
     return new CacheService({ prefix, defaultTtlSeconds, redis });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-service.js","sourceRoot":"","sources":["../../src/services/cache-service.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAgDtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,YAAY;IACf,MAAM,GAAG,IAAI,GAAG,EAA+B,CAAC;IACvC,MAAM,CAAS;IACf,YAAY,CAAS;IACrB,UAAU,CAAS;IACnB,KAAK,CAAoB;IAE1C,8DAA8D;IACrD,OAAO,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC;IAErE,YAAY,MAAmB;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,iBAAiB,GAAG,IAAI,CAAC;QACpD,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC;QAC5C,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5B,CAAC;IAEO,OAAO,CAAC,GAAW;QACzB,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAI,GAAW;QACtB,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAE7B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACrC,IAAI,CAAC,GAAG,EAAE,CAAC;oBAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;oBAAC,OAAO,IAAI,CAAC;gBAAC,CAAC;gBACjD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;gBACpB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAM,CAAC;YAC9B,CAAC;YAED,YAAY;YACZ,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAClC,IAAI,CAAC,KAAK,EAAE,CAAC;gBAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBAAC,OAAO,IAAI,CAAC;YAAC,CAAC;YACnD,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;gBACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBACvB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBACtB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC,KAAU,CAAC;QAC1B,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,GAAG,CAAI,GAAW,EAAE,KAAQ,EAAE,UAAmB;QACrD,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,GAAG,GAAG,UAAU,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAEnD,IAAI,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACpB,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;gBAC3D,OAAO;YACT,CAAC;YAED,0CAA0C;YAC1C,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;gBACjD,IAAI,QAAQ;oBAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAC7C,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE;gBAClB,KAAK;gBACL,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;aACnC,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,iCAAiC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAE7B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACzB,OAAO;YACT,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACzB,CAAC;QAAC,MAAM,CAAC;YACP,oCAAoC;QACtC,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,iBAAiB,CAAC,OAAe;QACrC,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAEjC,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU;oBAChC,CAAC,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACzB,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC9B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACpB,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;oBAC9B,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC;gBAC5C,CAAC;gBACD,OAAO,IAAI,CAAC,MAAM,CAAC;YACrB,CAAC;YAED,uCAAuC;YACvC,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;YAC9D,IAAI,OAAO,GAAG,CAAC,CAAC;YAChB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;gBACrC,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;oBACpB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oBACxB,OAAO,EAAE,CAAC;gBACZ,CAAC;YACH,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,OAAO,CAAC;YACtC,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAED,sEAAsE;IAC9D,QAAQ,CAAC,OAAe;QAC9B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAM,CAAC,UAAW,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;YACvE,MAAM,IAAI,GAAa,EAAE,CAAC;YAC1B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAe,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;YAC5D,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,QAAQ,CAAI,GAAW,EAAE,OAAyB,EAAE,UAAmB;QAC3E,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAI,GAAG,CAAC,CAAC;QACtC,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,MAAM,CAAC;QAEnC,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC;QAC9B,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;QACvC,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IAED,sDAAsD;IACtD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,iBAAiB,GAAG,GAAG,EACvB,KAAwB;IAExB,OAAO,IAAI,YAAY,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,CAAC;AAChE,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lightweight caching service with TTL support.\n *\n * Two implementations:\n * - In-memory (default): LRU-style Map cache, no external dependencies\n * - Redis: When a Redis client is provided, uses Redis for cross-process caching\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - JSON serialization for Redis; direct reference for in-memory\n * - Key namespace prefixing to avoid collisions between services\n */\n\n\n/**\n * Cache entry with value and expiration time.\n */\ninterface CacheEntry<T> {\n  value: T;\n  expiresAt: number; // Unix timestamp in ms\n}\n\n/**\n * Minimal Redis-like client interface (subset of ioredis).\n * Services pass their own Redis client instance.\n */\nexport interface RedisCacheClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  keys(pattern: string): Promise<string[]>;\n  /** SCAN-based iteration (preferred over KEYS for production). */\n  scanStream?(options: { match: string; count?: number }): NodeJS.ReadableStream;\n}\n\nexport interface CacheConfig {\n  /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */\n  prefix: string;\n  /** Default TTL in seconds */\n  defaultTtlSeconds: number;\n  /** Max entries for in-memory cache (default 1000) */\n  maxEntries?: number;\n  /** Optional Redis client — uses in-memory cache if not provided */\n  redis?: RedisCacheClient;\n}\n\n/**\n * Cache service with get/set/del operations and automatic TTL expiry.\n *\n * @example\n * ```typescript\n * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });\n *\n * // Set with default TTL\n * await cache.set('org123:list', plugins);\n *\n * // Get (returns null on miss)\n * const cached = await cache.get<Plugin[]>('org123:list');\n *\n * // Invalidate\n * await cache.del('org123:list');\n *\n * // Invalidate by pattern\n * await cache.invalidatePattern('org123:*');\n * ```\n */\nexport class CacheService {\n  private memory = new Map<string, CacheEntry<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly redis?: RedisCacheClient;\n\n  /** Cache metrics — tracks hits, misses, and invalidations. */\n  readonly metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };\n\n  constructor(config: CacheConfig) {\n    this.prefix = config.prefix;\n    this.defaultTtlMs = config.defaultTtlSeconds * 1000;\n    this.maxEntries = config.maxEntries ?? 1000;\n    this.redis = config.redis;\n  }\n\n  private fullKey(key: string): string {\n    return `${this.prefix}${key}`;\n  }\n\n  /**\n   * Get a cached value. Returns null on miss or error.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        const raw = await this.redis.get(fk);\n        if (!raw) { this.metrics.misses++; return null; }\n        this.metrics.hits++;\n        return JSON.parse(raw) as T;\n      }\n\n      // In-memory\n      const entry = this.memory.get(fk);\n      if (!entry) { this.metrics.misses++; return null; }\n      if (Date.now() > entry.expiresAt) {\n        this.memory.delete(fk);\n        this.metrics.misses++;\n        return null;\n      }\n      this.metrics.hits++;\n      return entry.value as T;\n    } catch {\n      this.metrics.misses++;\n      return null;\n    }\n  }\n\n  /**\n   * Set a cached value with optional TTL override.\n   *\n   * @param key - Cache key (prefix is added automatically)\n   * @param value - Value to cache (must be JSON-serializable for Redis)\n   * @param ttlSeconds - TTL override (uses default if not provided)\n   */\n  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const fk = this.fullKey(key);\n    const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;\n\n    try {\n      this.metrics.sets++;\n      if (this.redis) {\n        await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);\n        return;\n      }\n\n      // In-memory — evict oldest if at capacity\n      if (this.memory.size >= this.maxEntries) {\n        const firstKey = this.memory.keys().next().value;\n        if (firstKey) this.memory.delete(firstKey);\n      }\n\n      this.memory.set(fk, {\n        value,\n        expiresAt: Date.now() + ttl * 1000,\n      });\n    } catch {\n      // Cache set failure is non-fatal\n    }\n  }\n\n  /**\n   * Delete a cached value.\n   */\n  async del(key: string): Promise<void> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        await this.redis.del(fk);\n        return;\n      }\n      this.memory.delete(fk);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    const fp = this.fullKey(pattern);\n\n    try {\n      if (this.redis) {\n        const keys = this.redis.scanStream\n          ? await this.scanKeys(fp)\n          : await this.redis.keys(fp);\n        if (keys.length > 0) {\n          await this.redis.del(...keys);\n          this.metrics.invalidations += keys.length;\n        }\n        return keys.length;\n      }\n\n      // In-memory — match glob-style pattern\n      const regex = new RegExp('^' + fp.replace(/\\*/g, '.*') + '$');\n      let deleted = 0;\n      for (const key of this.memory.keys()) {\n        if (regex.test(key)) {\n          this.memory.delete(key);\n          deleted++;\n        }\n      }\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\n    }\n  }\n\n  /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */\n  private scanKeys(pattern: string): Promise<string[]> {\n    return new Promise((resolve, reject) => {\n      const stream = this.redis!.scanStream!({ match: pattern, count: 100 });\n      const keys: string[] = [];\n      stream.on('data', (batch: string[]) => keys.push(...batch));\n      stream.once('end', () => resolve(keys));\n      stream.once('error', reject);\n    });\n  }\n\n  /**\n   * Get or compute: returns cached value if available, otherwise calls the\n   * factory function, caches the result, and returns it.\n   *\n   * @param key - Cache key\n   * @param factory - Async function to compute the value on cache miss\n   * @param ttlSeconds - Optional TTL override\n   * @returns The cached or computed value\n   */\n  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T> {\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    const value = await factory();\n    await this.set(key, value, ttlSeconds);\n    return value;\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    if (this.redis) {\n      await this.invalidatePattern('*');\n    } else {\n      this.memory.clear();\n    }\n  }\n\n  /** Current in-memory cache size (for diagnostics). */\n  get size(): number {\n    return this.memory.size;\n  }\n}\n\n/**\n * Create a cache service instance.\n *\n * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')\n * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)\n * @param redis - Optional Redis client for cross-process caching\n */\nexport function createCacheService(\n  prefix: string,\n  defaultTtlSeconds = 300,\n  redis?: RedisCacheClient,\n): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds, redis });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-service.js","sourceRoot":"","sources":["../../src/services/cache-service.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lightweight caching service with TTL support.\n *\n * Two implementations:\n * - In-memory (default): LRU-style Map cache, no external dependencies\n * - Redis: When a Redis client is provided, uses Redis for cross-process caching\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - JSON serialization for Redis; direct reference for in-memory\n * - Key namespace prefixing to avoid collisions between services\n */\n\n\n/**\n * Cache entry with value and expiration time.\n */\ninterface CacheEntry<T> {\n  value: T;\n  expiresAt: number; // Unix timestamp in ms\n}\n\n/**\n * Minimal Redis-like client interface (subset of ioredis).\n * Services pass their own Redis client instance.\n */\nexport interface RedisCacheClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  keys(pattern: string): Promise<string[]>;\n  /** SCAN-based iteration (preferred over KEYS for production). */\n  scanStream?(options: { match: string; count?: number }): NodeJS.ReadableStream;\n}\n\nexport interface CacheConfig {\n  /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */\n  prefix: string;\n  /** Default TTL in seconds */\n  defaultTtlSeconds: number;\n  /** Max entries for in-memory cache (default 1000) */\n  maxEntries?: number;\n  /** Optional Redis client — uses in-memory cache if not provided */\n  redis?: RedisCacheClient;\n}\n\n/**\n * Cache service with get/set/del operations and automatic TTL expiry.\n *\n * @example\n * ```typescript\n * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });\n *\n * // Set with default TTL\n * await cache.set('org123:list', plugins);\n *\n * // Get (returns null on miss)\n * const cached = await cache.get<Plugin[]>('org123:list');\n *\n * // Invalidate\n * await cache.del('org123:list');\n *\n * // Invalidate by pattern\n * await cache.invalidatePattern('org123:*');\n * ```\n */\nexport class CacheService {\n  private memory = new Map<string, CacheEntry<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly redis?: RedisCacheClient;\n\n  /** Cache metrics — tracks hits, misses, and invalidations. */\n  readonly metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };\n\n  constructor(config: CacheConfig) {\n    this.prefix = config.prefix;\n    this.defaultTtlMs = config.defaultTtlSeconds * 1000;\n    this.maxEntries = config.maxEntries ?? 1000;\n    this.redis = config.redis;\n  }\n\n  private fullKey(key: string): string {\n    return `${this.prefix}${key}`;\n  }\n\n  /**\n   * Get a cached value. Returns null on miss or error.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        const raw = await this.redis.get(fk);\n        if (!raw) { this.metrics.misses++; return null; }\n        this.metrics.hits++;\n        return JSON.parse(raw) as T;\n      }\n\n      // In-memory\n      const entry = this.memory.get(fk);\n      if (!entry) { this.metrics.misses++; return null; }\n      if (Date.now() > entry.expiresAt) {\n        this.memory.delete(fk);\n        this.metrics.misses++;\n        return null;\n      }\n      this.metrics.hits++;\n      return entry.value as T;\n    } catch {\n      this.metrics.misses++;\n      return null;\n    }\n  }\n\n  /**\n   * Set a cached value with optional TTL override.\n   *\n   * @param key - Cache key (prefix is added automatically)\n   * @param value - Value to cache (must be JSON-serializable for Redis)\n   * @param ttlSeconds - TTL override (uses default if not provided)\n   */\n  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const fk = this.fullKey(key);\n    const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;\n\n    try {\n      this.metrics.sets++;\n      if (this.redis) {\n        await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);\n        return;\n      }\n\n      // In-memory — evict oldest if at capacity\n      if (this.memory.size >= this.maxEntries) {\n        const firstKey = this.memory.keys().next().value;\n        if (firstKey) this.memory.delete(firstKey);\n      }\n\n      this.memory.set(fk, {\n        value,\n        expiresAt: Date.now() + ttl * 1000,\n      });\n    } catch {\n      // Cache set failure is non-fatal\n    }\n  }\n\n  /**\n   * Delete a cached value.\n   */\n  async del(key: string): Promise<void> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        await this.redis.del(fk);\n        return;\n      }\n      this.memory.delete(fk);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    const fp = this.fullKey(pattern);\n\n    try {\n      if (this.redis) {\n        const keys = this.redis.scanStream\n          ? await this.scanKeys(fp)\n          : await this.redis.keys(fp);\n        if (keys.length > 0) {\n          await this.redis.del(...keys);\n          this.metrics.invalidations += keys.length;\n        }\n        return keys.length;\n      }\n\n      // In-memory — match glob-style pattern. Escape regex metacharacters first\n      // so a literal `.`/`(`/`[` in a key prefix (e.g. `org:v1.2:*`) can't\n      // over-match or throw (a throw here is swallowed → nothing invalidated →\n      // stale reads); only `*` is treated as a wildcard.\n      const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\\\\\*/g, '.*') + '$');\n      let deleted = 0;\n      for (const key of this.memory.keys()) {\n        if (regex.test(key)) {\n          this.memory.delete(key);\n          deleted++;\n        }\n      }\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\n    }\n  }\n\n  /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */\n  private scanKeys(pattern: string): Promise<string[]> {\n    return new Promise((resolve, reject) => {\n      const stream = this.redis!.scanStream!({ match: pattern, count: 100 });\n      const keys: string[] = [];\n      stream.on('data', (batch: string[]) => keys.push(...batch));\n      stream.once('end', () => resolve(keys));\n      stream.once('error', reject);\n    });\n  }\n\n  /**\n   * Get or compute: returns cached value if available, otherwise calls the\n   * factory function, caches the result, and returns it.\n   *\n   * @param key - Cache key\n   * @param factory - Async function to compute the value on cache miss\n   * @param ttlSeconds - Optional TTL override\n   * @returns The cached or computed value\n   */\n  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T> {\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    const value = await factory();\n    await this.set(key, value, ttlSeconds);\n    return value;\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    if (this.redis) {\n      await this.invalidatePattern('*');\n    } else {\n      this.memory.clear();\n    }\n  }\n\n  /** Current in-memory cache size (for diagnostics). */\n  get size(): number {\n    return this.memory.size;\n  }\n}\n\n/**\n * Create a cache service instance.\n *\n * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')\n * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)\n * @param redis - Optional Redis client for cross-process caching\n */\nexport function createCacheService(\n  prefix: string,\n  defaultTtlSeconds = 300,\n  redis?: RedisCacheClient,\n): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds, redis });\n}\n"]}

package/lib/services/compliance-event-subscriber.js

@@ -54,6 +54,7 @@ export function registerComplianceEventSubscriber(config, serviceName = 'entity-
                 target: event.target,
                 entityId: event.entityId,
                 orgId: event.orgId,
+                parentOrgId: event.parentOrgId,
                 userId: event.userId,
                 attributes: event.attributes,
                 timestamp: event.timestamp.toISOString(),
@@ -66,4 +67,4 @@ export function registerComplianceEventSubscriber(config, serviceName = 'entity-
         port: serviceConfig.port,
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxpYW5jZS1ldmVudC1zdWJzY3JpYmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcnZpY2VzL2NvbXBsaWFuY2UtZXZlbnQtc3Vic2NyaWJlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQy9ELE9BQU8sRUFBRSxZQUFZLEVBQWdELE1BQU0sb0JBQW9CLENBQUM7QUFDaEcsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdEQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDN0QsT0FBTyxFQUFzQixNQUFNLG9CQUFvQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVsRCxNQUFNLE1BQU0sR0FBRyxZQUFZLENBQUMsbUJBQW1CLENBQUMsQ0FBQztBQUVqRDs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsTUFBTSxVQUFVLGlDQUFpQyxDQUMvQyxNQUErQixFQUMvQixjQUFzQixlQUFlO0lBRXJDLE1BQU0sYUFBYSxHQUFrQjtRQUNuQyxJQUFJLEVBQUUsTUFBTSxFQUFFLElBQUksSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLHVCQUF1QixJQUFJLFlBQVk7UUFDekUsSUFBSSxFQUFFLE1BQU0sRUFBRSxJQUFJLElBQUksUUFBUSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsdUJBQXVCLElBQUksTUFBTSxFQUFFLEVBQUUsQ0FBQztLQUNsRixDQUFDO0lBRUYsTUFBTSxNQUFNLEdBQUcsSUFBSSxrQkFBa0IsQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUVyRCxNQUFNLFVBQVUsR0FBMEI7UUFDeEMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxLQUFrQjtZQUNwQyxJQUFJLENBQUM7Z0JBQ0gsZ0VBQWdFO2dCQUNoRSxrRUFBa0U7Z0JBQ2xFLG9EQUFvRDtnQkFDcEQsZ0VBQWdFO2dCQUNoRSxzREFBc0Q7Z0JBQ3RELE1BQU0sTUFBTSxDQUFDLElBQUksQ0FBQywyQkFBMkIsRUFBRSxLQUFLLEVBQUU7b0JBQ3BELE9BQU8sRUFBRSxFQUFFLGFBQWEsRUFBRSxvQkFBb0IsQ0FBQyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsS0FBSyxDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUMsRUFBRTtpQkFDdEcsQ0FBQyxDQUFDO1lBQ0wsQ0FBQztZQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7Z0JBQ2IsMEVBQTBFO2dCQUMxRSxNQUFNLENBQUMsSUFBSSxDQUFDLHFEQUFxRCxFQUFFO29CQUNqRSxNQUFNLEVBQUUsS0FBSyxDQUFDLE1BQU07b0JBQ3BCLFNBQVMsRUFBRSxLQUFLLENBQUMsU0FBUztvQkFDMUIsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRO29CQUN4QixLQUFLLEVBQUUsR0FBRyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQztpQkFDeEQsQ0FBQyxDQUFDO1lBQ0wsQ0FBQztZQUVELDZFQUE2RTtZQUM3RSxLQUFLLHNCQUFzQixDQUFDO2dCQUMxQixTQUFTLEVBQUUsVUFBVTtnQkFDckIsTUFBTSxFQUFFLEtBQUssQ0FBQyxNQUErQjtnQkFDN0MsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRO2dCQUN4QixLQUFLLEVBQUUsS0FBSyxDQUFDLEtBQUs7Z0JBQ2xCLE1BQU0sRUFBRSxLQUFLLENBQUMsTUFBTTtnQkFDcEIsVUFBVSxFQUFFLEtBQUssQ0FBQyxVQUFVO2dCQUM1QixTQUFTLEVBQUUsS0FBSyxDQUFDLFNBQVMsQ0FBQyxXQUFXLEVBQUU7YUFDekMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztLQUNGLENBQUM7SUFFRixZQUFZLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQ25DLE1BQU0sQ0FBQyxJQUFJLENBQUMsd0NBQXdDLEVBQUU7UUFDcEQsSUFBSSxFQUFFLGFBQWEsQ0FBQyxJQUFJO1FBQ3hCLElBQUksRUFBRSxhQUFhLENBQUMsSUFBSTtLQUN6QixDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmltcG9ydCB7IGVucXVldWVDb21wbGlhbmNlRXZlbnQgfSBmcm9tICcuL2NvbXBsaWFuY2UtcXVldWUuanMnO1xuaW1wb3J0IHsgZW50aXR5RXZlbnRzLCB0eXBlIEVudGl0eUV2ZW50LCB0eXBlIEVudGl0eUV2ZW50U3Vic2NyaWJlciB9IGZyb20gJy4vZW50aXR5LWV2ZW50cy5qcyc7XG5pbXBvcnQgeyBJbnRlcm5hbEh0dHBDbGllbnQgfSBmcm9tICcuL2h0dHAtY2xpZW50LmpzJztcbmltcG9ydCB7IGdldFNlcnZpY2VBdXRoSGVhZGVyIH0gZnJvbSAnLi4vbWlkZGxld2FyZS9hdXRoLmpzJztcbmltcG9ydCB7IHR5cGUgU2VydmljZUNvbmZpZyB9IGZyb20gJy4uL3R5cGVzL2NvbW1vbi5qcyc7XG5pbXBvcnQgeyBjcmVhdGVMb2dnZXIgfSBmcm9tICcuLi91dGlscy9sb2dnZXIuanMnO1xuXG5jb25zdCBsb2dnZXIgPSBjcmVhdGVMb2dnZXIoJ2NvbXBsaWFuY2UtZXZlbnRzJyk7XG5cbi8qKlxuICogUmVnaXN0ZXJzIGFuIGVudGl0eSBldmVudCBzdWJzY3JpYmVyIHRoYXQgZm9yd2FyZHMgZXZlbnRzIHRvIHRoZSBjb21wbGlhbmNlIHNlcnZpY2UuXG4gKlxuICogQ2FsbCB0aGlzIGF0IHNlcnZpY2Ugc3RhcnR1cCAoaW4gaW5kZXgudHMpIHRvIGVuYWJsZSBhdXRvbWF0aWMgY29tcGxpYW5jZVxuICogbm90aWZpY2F0aW9uIG9uIGVudGl0eSBtdXRhdGlvbnMuIEV2ZW50cyBhcmUgZmlyZS1hbmQtZm9yZ2V0IOKAlCBmYWlsdXJlc1xuICogYXJlIGxvZ2dlZCBidXQgbmV2ZXIgYmxvY2sgdGhlIG9yaWdpbmFsIHJlcXVlc3QuXG4gKlxuICogQHBhcmFtIGNvbmZpZyAtIE9wdGlvbmFsIHNlcnZpY2UgY29uZmlnIG92ZXJyaWRlIChkZWZhdWx0cyB0byBDT01QTElBTkNFX1NFUlZJQ0VfSE9TVC9QT1JUIGVudiB2YXJzKVxuICogQHBhcmFtIHNlcnZpY2VOYW1lIC0gU2VydmljZSBpZGVudGlmaWVyIGJha2VkIGludG8gdGhlIHNpZ25lZCBKV1QncyBgc3ViYFxuICogICAoZS5nLiAncGlwZWxpbmUnLCAncGx1Z2luJykuIFRoZSBjb21wbGlhbmNlIHJvdXRlIHJlcXVpcmVzIGEgc2VydmljZVxuICogICBwcmluY2lwYWwg4oCUIGEgc3Bvb2ZhYmxlIGB4LWludGVybmFsLXNlcnZpY2U6IHRydWVgIGhlYWRlciBpcyBubyBsb25nZXJcbiAqICAgYWNjZXB0ZWQuIERlZmF1bHRzIHRvIGEgZ2VuZXJpYyAnZW50aXR5LWV2ZW50cycgd2hlbiB1bnNwZWNpZmllZCwgYnV0XG4gKiAgIGNhbGxlcnMgc2hvdWxkIHBhc3MgdGhlaXIgc2VydmljZSBuYW1lIGZvciBhY2N1cmF0ZSBhdWRpdCB0cmFpbHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZWdpc3RlckNvbXBsaWFuY2VFdmVudFN1YnNjcmliZXIoXG4gIGNvbmZpZz86IFBhcnRpYWw8U2VydmljZUNvbmZpZz4sXG4gIHNlcnZpY2VOYW1lOiBzdHJpbmcgPSAnZW50aXR5LWV2ZW50cycsXG4pOiB2b2lkIHtcbiAgY29uc3Qgc2VydmljZUNvbmZpZzogU2VydmljZUNvbmZpZyA9IHtcbiAgICBob3N0OiBjb25maWc/Lmhvc3QgPz8gcHJvY2Vzcy5lbnYuQ09NUExJQU5DRV9TRVJWSUNFX0hPU1QgPz8gJ2NvbXBsaWFuY2UnLFxuICAgIHBvcnQ6IGNvbmZpZz8ucG9ydCA/PyBwYXJzZUludChwcm9jZXNzLmVudi5DT01QTElBTkNFX1NFUlZJQ0VfUE9SVCA/PyAnMzAwMCcsIDEwKSxcbiAgfTtcblxuICBjb25zdCBjbGllbnQgPSBuZXcgSW50ZXJuYWxIdHRwQ2xpZW50KHNlcnZpY2VDb25maWcpO1xuXG4gIGNvbnN0IHN1YnNjcmliZXI6IEVudGl0eUV2ZW50U3Vic2NyaWJlciA9IHtcbiAgICBhc3luYyBvbkVudGl0eUV2ZW50KGV2ZW50OiBFbnRpdHlFdmVudCk6IFByb21pc2U8dm9pZD4ge1xuICAgICAgdHJ5IHtcbiAgICAgICAgLy8gTWludCBhIHBlci1ldmVudCBzZXJ2aWNlIEpXVCBzY29wZWQgdG8gdGhlIGV2ZW50J3Mgb3JnIHNvIHRoZVxuICAgICAgICAvLyBjb21wbGlhbmNlIHJvdXRlJ3MgYHJ1bldpdGhUZW5hbnRDb250ZXh0YCBzZWVzIHRoZSByaWdodCB0ZW5hbnRcbiAgICAgICAgLy8gR1VDLiBUaGUgY29tcGxpYW5jZSBzaWRlIGVuZm9yY2VzIGByZXF1aXJlQXV0aGAgK1xuICAgICAgICAvLyBgcmVxdWlyZVNlcnZpY2VQcmluY2lwYWxgIOKAlCB0aGUgcHJldmlvdXMgYHgtaW50ZXJuYWwtc2VydmljZWBcbiAgICAgICAgLy8gaGVhZGVyIGlzIG5vIGxvbmdlciBzdWZmaWNpZW50IChhbmQgd2FzIHNwb29mYWJsZSkuXG4gICAgICAgIGF3YWl0IGNsaWVudC5wb3N0KCcvY29tcGxpYW5jZS9ldmVudHMvZW50aXR5JywgZXZlbnQsIHtcbiAgICAgICAgICBoZWFkZXJzOiB7IEF1dGhvcml6YXRpb246IGdldFNlcnZpY2VBdXRoSGVhZGVyKHsgc2VydmljZU5hbWUsIG9yZ0lkOiBldmVudC5vcmdJZCwgcm9sZTogJ21lbWJlcicgfSkgfSxcbiAgICAgICAgfSk7XG4gICAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgICAgLy8gRmlyZS1hbmQtZm9yZ2V0OiBsb2cgYW5kIHN3YWxsb3cuIENvbXBsaWFuY2Ugbm90aWZpY2F0aW9uIGlzIG5vbi1mYXRhbC5cbiAgICAgICAgbG9nZ2VyLndhcm4oJ0ZhaWxlZCB0byBub3RpZnkgY29tcGxpYW5jZSBzZXJ2aWNlIG9mIGVudGl0eSBldmVudCcsIHtcbiAgICAgICAgICB0YXJnZXQ6IGV2ZW50LnRhcmdldCxcbiAgICAgICAgICBldmVudFR5cGU6IGV2ZW50LmV2ZW50VHlwZSxcbiAgICAgICAgICBlbnRpdHlJZDogZXZlbnQuZW50aXR5SWQsXG4gICAgICAgICAgZXJyb3I6IGVyciBpbnN0YW5jZW9mIEVycm9yID8gZXJyLm1lc3NhZ2UgOiBTdHJpbmcoZXJyKSxcbiAgICAgICAgfSk7XG4gICAgICB9XG5cbiAgICAgIC8vIEFsc28gZW5xdWV1ZSBmb3IgYXN5bmMgcmUtdmFsaWRhdGlvbiAoY2F0Y2hlcyBydWxlIGNoYW5nZXMgYWZ0ZXIgY3JlYXRpb24pXG4gICAgICB2b2lkIGVucXVldWVDb21wbGlhbmNlRXZlbnQoe1xuICAgICAgICBldmVudFR5cGU6ICd2YWxpZGF0ZScsXG4gICAgICAgIHRhcmdldDogZXZlbnQudGFyZ2V0IGFzICdwbHVnaW4nIHwgJ3BpcGVsaW5lJyxcbiAgICAgICAgZW50aXR5SWQ6IGV2ZW50LmVudGl0eUlkLFxuICAgICAgICBvcmdJZDogZXZlbnQub3JnSWQsXG4gICAgICAgIHVzZXJJZDogZXZlbnQudXNlcklkLFxuICAgICAgICBhdHRyaWJ1dGVzOiBldmVudC5hdHRyaWJ1dGVzLFxuICAgICAgICB0aW1lc3RhbXA6IGV2ZW50LnRpbWVzdGFtcC50b0lTT1N0cmluZygpLFxuICAgICAgfSk7XG4gICAgfSxcbiAgfTtcblxuICBlbnRpdHlFdmVudHMuc3Vic2NyaWJlKHN1YnNjcmliZXIpO1xuICBsb2dnZXIuaW5mbygnQ29tcGxpYW5jZSBldmVudCBzdWJzY3JpYmVyIHJlZ2lzdGVyZWQnLCB7XG4gICAgaG9zdDogc2VydmljZUNvbmZpZy5ob3N0LFxuICAgIHBvcnQ6IHNlcnZpY2VDb25maWcucG9ydCxcbiAgfSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/compliance-queue.d.ts

@@ -3,6 +3,9 @@ export interface ComplianceEvent {
     target: 'plugin' | 'pipeline';
     entityId: string;
     orgId: string;
+    /** Owning org's parent (present only when `orgId` is a team) so the async
+     *  worker evaluates parent `propagateToChildren` rules like the live path. */
+    parentOrgId?: string;
     userId: string;
     attributes: Record<string, unknown>;
     timestamp: string;

package/lib/services/compliance-queue.js

@@ -31,4 +31,4 @@ export async function enqueueComplianceEvent(event) {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/entity-events.d.ts

@@ -9,6 +9,10 @@ export interface EntityEvent {
     entityId: string;
     /** The organization that owns this entity */
     orgId: string;
+    /** Org → team hierarchy: the owning org's parent (present only when `orgId` is
+     *  a team). Lets compliance evaluate parent `propagateToChildren` rules on the
+     *  async event path, matching live validation. */
+    parentOrgId?: string;
     /** The user who performed the mutation */
     userId: string;
     /** When the event occurred */

package/lib/services/entity-events.js

@@ -57,4 +57,4 @@ class EntityEventEmitter {
 }
 /** Singleton entity event emitter — shared across the process */
 export const entityEvents = new EntityEventEmitter();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/leader-lock.d.ts

@@ -6,6 +6,9 @@ export interface LockRedis {
     set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
     get(key: string): Promise<string | null>;
     del(...keys: string[]): Promise<number>;
+    /** Optional Lua eval (ioredis has it). When present, release uses an atomic
+     *  compare-and-delete so a lapsed holder can't free a successor's lock. */
+    eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;
 }
 /**
  * Run `fn` only if this process wins a short-lived distributed lock — the

package/lib/services/leader-lock.js

@@ -1,6 +1,9 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { randomUUID } from 'crypto';
+/** Atomic "delete only if I still own it" — closes the get-then-del race where
+ *  the lock expires and is re-acquired between the two calls. */
+const RELEASE_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end';
 /**
  * Run `fn` only if this process wins a short-lived distributed lock — the
  * across-pods "single runner" guard for periodic jobs (digest flushes, etc.).
@@ -22,10 +25,16 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     }
     finally {
         // Release only if the lock is still ours — if our run overran the TTL and
-        // another holder took over, deleting here would free their lock early.
+        // another holder took over, releasing here would free their lock early.
+        // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without
+        // eval (the small non-atomic window is TTL-bounded).
         try {
-            if ((await redis.get(key)) === token)
+            if (typeof redis.eval === 'function') {
+                await redis.eval(RELEASE_IF_OWNER, 1, key, token);
+            }
+            else if ((await redis.get(key)) === token) {
                 await redis.del(key);
+            }
         }
         catch {
             // Best-effort: the TTL expires the lock regardless.
@@ -33,4 +42,4 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/quota.d.ts

@@ -47,10 +47,10 @@ export interface QuotaService {
     /** Reset quota usage. Returns true on success. */
     reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean>;
     /**
-     * Get the org's quota tier ('developer' | 'pro' | 'unlimited'). Used by
+     * Get the org's quota tier ('developer' | 'pro' | 'team' | 'enterprise'). Used by
      * the plugin-build queue partitioning to route a build to the
      * right per-tier queue. Fail-open returns DEFAULT_TIER ('developer')
-     * a misclassified pro/unlimited org will land in the developer queue
+     * a misclassified pro/team/enterprise org will land in the developer queue
      * and still build, just without the tier-scoped scheduling boost.
      */
     getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;