@pipeline-builder/api-core 4.1.2 → 4.1.4

package/lib/services/cache-service.js

@@ -1,11 +1,35 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Deep-clone a value so the in-memory backend hands back an INDEPENDENT copy on
- * every read — matching the Redis backend, which returns a fresh `JSON.parse`
- * clone each time. Without this the in-memory cache returns the same stored
- * object reference, so a consumer mutating a "cached" object silently corrupts
- * the shared cache (a footgun that only bites under the memory backend).
+ * Lightweight caching service with TTL support.
+ *
+ * Storage is a per-process true-LRU Map (no external dependencies).
+ *
+ * Cross-replica invalidation: every service runs several
+ * replicas (HPA), each with its OWN in-memory cache. An invalidation performed on
+ * one pod (`del` / `invalidatePattern` / `clear`) is broadcast over Redis pub/sub
+ * ({@link CacheInvalidationBus}, wired from the ambient Redis env by default) and
+ * applied by every other pod, so a write on pod A can't leave pod B serving the
+ * stale entry until its TTL lapses. A pod whose subscriber (re)connects flushes
+ * its local cache — it may have missed invalidations while disconnected — and a
+ * `getOrSet` whose factory raced an invalidation does not cache its result.
+ *
+ * Design:
+ * - All operations are fail-safe: cache misses/errors return null, never throw
+ * - Reads deep-clone, so every caller gets an independent copy (mutating a
+ *   result is always safe)
+ * - `getOrSet` is single-flight: concurrent misses share one factory() call
+ * - Key namespace prefixing to avoid collisions between services
+ */
+import { randomUUID } from 'crypto';
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('cache-service');
+/**
+ * Deep-clone a value so the cache hands back an INDEPENDENT copy on every read.
+ * Without this it returns the same stored object reference, so a consumer
+ * mutating a "cached" object silently corrupts the shared cache.
  *
  * Primitives are returned as-is. Prefers the structured-clone algorithm; falls
  * back to a JSON round-trip on older runtimes or exotic values.
@@ -20,6 +44,87 @@ function cloneValue(value) {
         return JSON.parse(JSON.stringify(value));
     }
 }
+const CACHE_INVALIDATION_CHANNEL = 'cache:invalidate';
+/**
+ * Redis pub/sub invalidation bus. PUBLISH on the given client; SUBSCRIBE on a
+ * `duplicate()` (a subscribed ioredis connection can't run other commands).
+ *
+ * The SUBSCRIBE is issued on every `ready` (initial connect AND each reconnect)
+ * rather than once at construction: the env client runs without an offline
+ * queue, so a subscribe issued before the connection is up is rejected and would
+ * never be retried. Each `ready` also triggers `onResync` so every cache flushes
+ * whatever it may have missed while disconnected.
+ */
+export function createRedisCacheInvalidationBus(publisher) {
+    const subscriber = publisher.duplicate();
+    const messageHandlers = [];
+    const resyncHandlers = [];
+    const resync = () => {
+        for (const h of resyncHandlers) {
+            try {
+                h();
+            }
+            catch { /* isolated */ }
+        }
+    };
+    const doSubscribe = () => {
+        void Promise.resolve(subscriber.subscribe(CACHE_INVALIDATION_CHANNEL))
+            .then(() => resync())
+            .catch((err) => {
+            emitCounter('cache_invalidation_subscribe_failed_total', {});
+            logger.warn('Cache invalidation subscribe failed; will retry on next reconnect', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        });
+    };
+    subscriber.on('message', (channel, raw) => {
+        if (channel !== CACHE_INVALIDATION_CHANNEL)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        for (const h of messageHandlers) {
+            try {
+                h(msg);
+            }
+            catch { /* one cache can't break the others */ }
+        }
+    });
+    subscriber.on('ready', doSubscribe);
+    subscriber.on('error', (e) => logger.warn('Cache invalidation subscriber error', { error: e instanceof Error ? e.message : String(e) }));
+    if (subscriber.status === 'ready')
+        doSubscribe();
+    return {
+        publish(msg) {
+            void Promise.resolve()
+                .then(() => publisher.publish(CACHE_INVALIDATION_CHANNEL, JSON.stringify(msg)))
+                .catch((err) => {
+                emitCounter('cache_invalidation_publish_failed_total', { prefix: msg.prefix });
+                logger.warn('Cache invalidation publish failed (other replicas keep the entry until TTL)', {
+                    prefix: msg.prefix, op: msg.op, error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        },
+        subscribe(onMessage, onResync) {
+            messageHandlers.push(onMessage);
+            resyncHandlers.push(onResync);
+        },
+    };
+}
+// undefined = not yet attempted; null = attempted, Redis not configured.
+let envInvalidationBus;
+/** Process-wide invalidation bus from the ambient Redis env (null without Redis). */
+function getEnvCacheInvalidationBus() {
+    if (envInvalidationBus === undefined) {
+        const client = createEnvRedisClient('cache-invalidation');
+        envInvalidationBus = client ? createRedisCacheInvalidationBus(client) : null;
+    }
+    return envInvalidationBus;
+}
 /**
  * Cache service with get/set/del operations and automatic TTL expiry.
  *
@@ -51,14 +156,55 @@ export class CacheService {
     prefix;
     defaultTtlMs;
     maxEntries;
-    redis;
+    bus;
+    instanceId = randomUUID();
+    /**
+     * Bumped on EVERY invalidation (local or remote). `getOrSet` only caches a
+     * factory result if no invalidation happened while the factory ran — otherwise
+     * it could re-cache a value read before the write that invalidated it.
+     */
+    generation = 0;
     /** Cache metrics — tracks hits, misses, and invalidations. */
     metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };
     constructor(config) {
         this.prefix = config.prefix;
         this.defaultTtlMs = config.defaultTtlSeconds * 1000;
         this.maxEntries = config.maxEntries ?? 1000;
-        this.redis = config.redis;
+        this.bus = config.invalidationBus === undefined ? getEnvCacheInvalidationBus() : config.invalidationBus;
+        this.bus?.subscribe((msg) => {
+            if (msg.origin === this.instanceId || msg.prefix !== this.prefix)
+                return;
+            this.applyLocalInvalidation(msg.op, msg.key);
+        }, () => this.applyLocalInvalidation('clear'));
+    }
+    /** Broadcast an invalidation to the other replicas. */
+    broadcast(op, key) {
+        this.bus?.publish({ origin: this.instanceId, prefix: this.prefix, op, ...(key !== undefined && { key }) });
+    }
+    /** Apply an invalidation to THIS process's in-memory entries. Returns the count removed. */
+    applyLocalInvalidation(op, key) {
+        this.generation++;
+        if (op === 'clear') {
+            const n = this.memory.size;
+            this.memory.clear();
+            return n;
+        }
+        if (op === 'del') {
+            return this.memory.delete(this.fullKey(key ?? '')) ? 1 : 0;
+        }
+        // Glob 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 would leave entries stale); only `*` is treated as a wildcard.
+        const fp = this.fullKey(key ?? '');
+        const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*') + '$');
+        let deleted = 0;
+        for (const k of this.memory.keys()) {
+            if (regex.test(k)) {
+                this.memory.delete(k);
+                deleted++;
+            }
+        }
+        return deleted;
     }
     fullKey(key) {
         return `${this.prefix}${key}`;
@@ -67,23 +213,11 @@ export class CacheService {
      * Get a cached value. Returns null on miss or error.
      *
      * The returned value is an INDEPENDENT deep copy — mutating it never affects
-     * the cached entry (the in-memory backend clones on read for parity with
-     * Redis, which returns a fresh JSON clone). Callers may still treat results as
-     * immutable, but doing so is no longer load-bearing for cache integrity.
+     * the cached entry.
      */
     async get(key) {
         const fk = this.fullKey(key);
         try {
-            if (this.redis) {
-                const raw = await this.redis.get(fk);
-                if (!raw) {
-                    this.metrics.misses++;
-                    return null;
-                }
-                this.metrics.hits++;
-                return JSON.parse(raw);
-            }
-            // In-memory
             const entry = this.memory.get(fk);
             if (!entry) {
                 this.metrics.misses++;
@@ -112,7 +246,7 @@ export class CacheService {
      * Set a cached value with optional TTL override.
      *
      * @param key - Cache key (prefix is added automatically)
-     * @param value - Value to cache (must be JSON-serializable for Redis)
+     * @param value - Value to cache
      * @param ttlSeconds - TTL override (uses default if not provided)
      */
     async set(key, value, ttlSeconds) {
@@ -120,11 +254,7 @@ export class CacheService {
         const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;
         try {
             this.metrics.sets++;
-            if (this.redis) {
-                await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);
-                return;
-            }
-            // In-memory — a write counts as a use, so drop any existing entry first
+            // A write counts as a use, so drop any existing entry first
             // and re-insert below as the newest (Map preserves insertion order). This
             // keeps the Map ordered oldest-USED → newest-USED so the eviction below is
             // true LRU, and avoids evicting a victim when merely updating a key.
@@ -147,13 +277,9 @@ export class CacheService {
      * Delete a cached value.
      */
     async del(key) {
-        const fk = this.fullKey(key);
         try {
-            if (this.redis) {
-                await this.redis.del(fk);
-                return;
-            }
-            this.memory.delete(fk);
+            this.applyLocalInvalidation('del', key);
+            this.broadcast('del', key);
         }
         catch {
             // Cache delete failure is non-fatal
@@ -161,33 +287,13 @@ export class CacheService {
     }
     /**
      * Invalidate all keys matching a pattern (e.g., 'org123:*').
-     * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.
+     * Only `*` is a wildcard.
      */
     async invalidatePattern(pattern) {
-        const fp = this.fullKey(pattern);
         try {
-            if (this.redis) {
-                const keys = this.redis.scanStream
-                    ? await this.scanKeys(fp)
-                    : await this.redis.keys(fp);
-                if (keys.length > 0) {
-                    await this.redis.del(...keys);
-                    this.metrics.invalidations += keys.length;
-                }
-                return keys.length;
-            }
-            // 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)) {
-                    this.memory.delete(key);
-                    deleted++;
-                }
-            }
+            // Apply locally, then fan out to the other replicas.
+            const deleted = this.applyLocalInvalidation('pattern', pattern);
+            this.broadcast('pattern', pattern);
             this.metrics.invalidations += deleted;
             return deleted;
         }
@@ -195,16 +301,6 @@ export class CacheService {
             return 0;
         }
     }
-    /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */
-    scanKeys(pattern) {
-        return new Promise((resolve, reject) => {
-            const stream = this.redis.scanStream({ match: pattern, count: 100 });
-            const keys = [];
-            stream.on('data', (batch) => keys.push(...batch));
-            stream.once('end', () => resolve(keys));
-            stream.once('error', reject);
-        });
-    }
     /**
      * Get or compute: returns cached value if available, otherwise calls the
      * factory function, caches the result, and returns it.
@@ -230,13 +326,17 @@ export class CacheService {
         // Cloning inside the flight instead would hand one shared clone to all N
         // coalesced callers, so one caller mutating its "independent" result would
         // corrupt what the others read — the exact footgun get()'s clone-on-read
-        // prevents. (Redis backend is unaffected: set serializes, get JSON.parses.)
+        // prevents.
         const existing = this.inflight.get(fk);
         if (existing)
             return cloneValue(await existing);
+        const generationAtStart = this.generation;
         const flight = (async () => {
             const value = await factory();
-            await this.set(key, value, ttlSeconds);
+            // An invalidation (here or on another replica) landed while the factory
+            // ran: its read may predate that write, so don't cache it.
+            if (this.generation === generationAtStart)
+                await this.set(key, value, ttlSeconds);
             return value;
         })();
         this.inflight.set(fk, flight);
@@ -251,12 +351,8 @@ export class CacheService {
      * Clear all entries (useful for testing).
      */
     async clear() {
-        if (this.redis) {
-            await this.invalidatePattern('*');
-        }
-        else {
-            this.memory.clear();
-        }
+        this.applyLocalInvalidation('clear');
+        this.broadcast('clear');
     }
     /** Current in-memory cache size (for diagnostics). */
     get size() {
@@ -268,9 +364,8 @@ export class CacheService {
  *
  * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')
  * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)
- * @param redis - Optional Redis client for cross-process caching
  */
-export function createCacheService(prefix, defaultTtlSeconds = 300, redis) {
-    return new CacheService({ prefix, defaultTtlSeconds, redis });
+export function createCacheService(prefix, defaultTtlSeconds = 300) {
+    return new CacheService({ prefix, defaultTtlSeconds });
 }
-//# 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): true-LRU 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; the in-memory backend deep-clones on read so\n *   both backends return an independent copy (mutating a result is always safe)\n * - `getOrSet` is single-flight: concurrent misses share one factory() call\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 * Deep-clone a value so the in-memory backend hands back an INDEPENDENT copy on\n * every read — matching the Redis backend, which returns a fresh `JSON.parse`\n * clone each time. Without this the in-memory cache returns the same stored\n * object reference, so a consumer mutating a \"cached\" object silently corrupts\n * the shared cache (a footgun that only bites under the memory backend).\n *\n * Primitives are returned as-is. Prefers the structured-clone algorithm; falls\n * back to a JSON round-trip on older runtimes or exotic values.\n */\nfunction cloneValue<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value;\n  try {\n    return structuredClone(value);\n  } catch {\n    return JSON.parse(JSON.stringify(value)) as T;\n  }\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  /**\n   * In-flight `getOrSet` factory promises, keyed by full cache key. Coalesces\n   * concurrent cold callers onto a single `factory()` invocation (single-flight\n   * / stampede protection); entries are cleared once the promise settles.\n   */\n  private inflight = new Map<string, Promise<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   * The returned value is an INDEPENDENT deep copy — mutating it never affects\n   * the cached entry (the in-memory backend clones on read for parity with\n   * Redis, which returns a fresh JSON clone). Callers may still treat results as\n   * immutable, but doing so is no longer load-bearing for cache integrity.\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      // LRU touch: delete + re-insert moves this key to the newest position\n      // (Map preserves insertion order), so `set`'s oldest-first eviction is a\n      // true least-recently-USED eviction rather than first-inserted (FIFO).\n      this.memory.delete(fk);\n      this.memory.set(fk, entry);\n      this.metrics.hits++;\n      // Clone so a caller mutating the result can't corrupt the shared entry.\n      return cloneValue(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 — a write counts as a use, so drop any existing entry first\n      // and re-insert below as the newest (Map preserves insertion order). This\n      // keeps the Map ordered oldest-USED → newest-USED so the eviction below is\n      // true LRU, and avoids evicting a victim when merely updating a key.\n      this.memory.delete(fk);\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   * Single-flight / stampede protection: when N callers miss concurrently for\n   * the same key, only ONE `factory()` runs — the rest await its shared promise.\n   * The in-flight entry is cleared once it settles (success or failure), so a\n   * failed factory doesn't poison later calls.\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 fk = this.fullKey(key);\n    // Coalesce concurrent cold callers onto a single factory() invocation. The\n    // in-flight promise resolves to the RAW value; each awaiter (the primary\n    // caller below AND every coalesced caller here) clones it INDEPENDENTLY.\n    // Cloning inside the flight instead would hand one shared clone to all N\n    // coalesced callers, so one caller mutating its \"independent\" result would\n    // corrupt what the others read — the exact footgun get()'s clone-on-read\n    // prevents. (Redis backend is unaffected: set serializes, get JSON.parses.)\n    const existing = this.inflight.get(fk) as Promise<T> | undefined;\n    if (existing) return cloneValue(await existing);\n\n    const flight = (async () => {\n      const value = await factory();\n      await this.set(key, value, ttlSeconds);\n      return value;\n    })();\n    this.inflight.set(fk, flight);\n    try {\n      return cloneValue(await flight);\n    } finally {\n      this.inflight.delete(fk);\n    }\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 * Storage is a per-process true-LRU Map (no external dependencies).\n *\n * Cross-replica invalidation: every service runs several\n * replicas (HPA), each with its OWN in-memory cache. An invalidation performed on\n * one pod (`del` / `invalidatePattern` / `clear`) is broadcast over Redis pub/sub\n * ({@link CacheInvalidationBus}, wired from the ambient Redis env by default) and\n * applied by every other pod, so a write on pod A can't leave pod B serving the\n * stale entry until its TTL lapses. A pod whose subscriber (re)connects flushes\n * its local cache — it may have missed invalidations while disconnected — and a\n * `getOrSet` whose factory raced an invalidation does not cache its result.\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - Reads deep-clone, so every caller gets an independent copy (mutating a\n *   result is always safe)\n * - `getOrSet` is single-flight: concurrent misses share one factory() call\n * - Key namespace prefixing to avoid collisions between services\n */\n\nimport { randomUUID } from 'crypto';\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('cache-service');\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 * Deep-clone a value so the cache hands back an INDEPENDENT copy on every read.\n * Without this it returns the same stored object reference, so a consumer\n * mutating a \"cached\" object silently corrupts the shared cache.\n *\n * Primitives are returned as-is. Prefers the structured-clone algorithm; falls\n * back to a JSON round-trip on older runtimes or exotic values.\n */\nfunction cloneValue<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value;\n  try {\n    return structuredClone(value);\n  } catch {\n    return JSON.parse(JSON.stringify(value)) as T;\n  }\n}\n\n/**\n * Minimal Redis key/value client surface (subset of ioredis) shared by the\n * token-revocation publisher/reader and platform's Redis helpers.\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}\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 the cache (default 1000) */\n  maxEntries?: number;\n  /**\n   * Cross-replica invalidation bus. Omit to use the shared env-Redis bus (null\n   * when Redis isn't configured → single-process semantics); pass `null` to\n   * disable explicitly.\n   */\n  invalidationBus?: CacheInvalidationBus | null;\n}\n\n/** One invalidation broadcast to every replica. */\nexport interface CacheInvalidationMessage {\n  /** Id of the CacheService instance that invalidated (it ignores its own echo). */\n  origin: string;\n  /** The cache namespace (`CacheConfig.prefix`) the invalidation applies to. */\n  prefix: string;\n  op: 'del' | 'pattern' | 'clear';\n  /** Un-prefixed key (`del`) or glob pattern (`pattern`). */\n  key?: string;\n}\n\n/** Transport that fans cache invalidations out to every replica. */\nexport interface CacheInvalidationBus {\n  /** Fire-and-forget broadcast. Never throws. */\n  publish(msg: CacheInvalidationMessage): void;\n  /**\n   * Register handlers. `onMessage` receives every broadcast (including this\n   * process's own); `onResync` fires whenever the subscription is (re)established,\n   * i.e. whenever invalidations may have been missed.\n   */\n  subscribe(onMessage: (msg: CacheInvalidationMessage) => void, onResync: () => void): void;\n}\n\n/** Minimal ioredis pub/sub surface the env bus needs. */\nexport interface RedisInvalidationClient {\n  publish(channel: string, message: string): Promise<number>;\n  subscribe(...channels: string[]): Promise<unknown>;\n  on(event: string, cb: (...args: any[]) => void): unknown;\n  duplicate(): RedisInvalidationClient;\n  status?: string;\n}\n\nconst CACHE_INVALIDATION_CHANNEL = 'cache:invalidate';\n\n/**\n * Redis pub/sub invalidation bus. PUBLISH on the given client; SUBSCRIBE on a\n * `duplicate()` (a subscribed ioredis connection can't run other commands).\n *\n * The SUBSCRIBE is issued on every `ready` (initial connect AND each reconnect)\n * rather than once at construction: the env client runs without an offline\n * queue, so a subscribe issued before the connection is up is rejected and would\n * never be retried. Each `ready` also triggers `onResync` so every cache flushes\n * whatever it may have missed while disconnected.\n */\nexport function createRedisCacheInvalidationBus(publisher: RedisInvalidationClient): CacheInvalidationBus {\n  const subscriber = publisher.duplicate();\n  const messageHandlers: Array<(msg: CacheInvalidationMessage) => void> = [];\n  const resyncHandlers: Array<() => void> = [];\n\n  const resync = (): void => {\n    for (const h of resyncHandlers) {\n      try { h(); } catch { /* isolated */ }\n    }\n  };\n  const doSubscribe = (): void => {\n    void Promise.resolve(subscriber.subscribe(CACHE_INVALIDATION_CHANNEL))\n      .then(() => resync())\n      .catch((err: unknown) => {\n        emitCounter('cache_invalidation_subscribe_failed_total', {});\n        logger.warn('Cache invalidation subscribe failed; will retry on next reconnect', {\n          error: err instanceof Error ? err.message : String(err),\n        });\n      });\n  };\n\n  subscriber.on('message', (channel: string, raw: string) => {\n    if (channel !== CACHE_INVALIDATION_CHANNEL) return;\n    let msg: CacheInvalidationMessage;\n    try {\n      msg = JSON.parse(raw) as CacheInvalidationMessage;\n    } catch {\n      return;\n    }\n    for (const h of messageHandlers) {\n      try { h(msg); } catch { /* one cache can't break the others */ }\n    }\n  });\n  subscriber.on('ready', doSubscribe);\n  subscriber.on('error', (e: unknown) =>\n    logger.warn('Cache invalidation subscriber error', { error: e instanceof Error ? e.message : String(e) }));\n  if (subscriber.status === 'ready') doSubscribe();\n\n  return {\n    publish(msg) {\n      void Promise.resolve()\n        .then(() => publisher.publish(CACHE_INVALIDATION_CHANNEL, JSON.stringify(msg)))\n        .catch((err: unknown) => {\n          emitCounter('cache_invalidation_publish_failed_total', { prefix: msg.prefix });\n          logger.warn('Cache invalidation publish failed (other replicas keep the entry until TTL)', {\n            prefix: msg.prefix, op: msg.op, error: err instanceof Error ? err.message : String(err),\n          });\n        });\n    },\n    subscribe(onMessage, onResync) {\n      messageHandlers.push(onMessage);\n      resyncHandlers.push(onResync);\n    },\n  };\n}\n\n// undefined = not yet attempted; null = attempted, Redis not configured.\nlet envInvalidationBus: CacheInvalidationBus | null | undefined;\n\n/** Process-wide invalidation bus from the ambient Redis env (null without Redis). */\nfunction getEnvCacheInvalidationBus(): CacheInvalidationBus | null {\n  if (envInvalidationBus === undefined) {\n    const client = createEnvRedisClient<RedisInvalidationClient>('cache-invalidation');\n    envInvalidationBus = client ? createRedisCacheInvalidationBus(client) : null;\n  }\n  return envInvalidationBus;\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  /**\n   * In-flight `getOrSet` factory promises, keyed by full cache key. Coalesces\n   * concurrent cold callers onto a single `factory()` invocation (single-flight\n   * / stampede protection); entries are cleared once the promise settles.\n   */\n  private inflight = new Map<string, Promise<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly bus: CacheInvalidationBus | null;\n  private readonly instanceId = randomUUID();\n  /**\n   * Bumped on EVERY invalidation (local or remote). `getOrSet` only caches a\n   * factory result if no invalidation happened while the factory ran — otherwise\n   * it could re-cache a value read before the write that invalidated it.\n   */\n  private generation = 0;\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.bus = config.invalidationBus === undefined ? getEnvCacheInvalidationBus() : config.invalidationBus;\n    this.bus?.subscribe(\n      (msg) => {\n        if (msg.origin === this.instanceId || msg.prefix !== this.prefix) return;\n        this.applyLocalInvalidation(msg.op, msg.key);\n      },\n      () => this.applyLocalInvalidation('clear'),\n    );\n  }\n\n  /** Broadcast an invalidation to the other replicas. */\n  private broadcast(op: CacheInvalidationMessage['op'], key?: string): void {\n    this.bus?.publish({ origin: this.instanceId, prefix: this.prefix, op, ...(key !== undefined && { key }) });\n  }\n\n  /** Apply an invalidation to THIS process's in-memory entries. Returns the count removed. */\n  private applyLocalInvalidation(op: CacheInvalidationMessage['op'], key?: string): number {\n    this.generation++;\n    if (op === 'clear') {\n      const n = this.memory.size;\n      this.memory.clear();\n      return n;\n    }\n    if (op === 'del') {\n      return this.memory.delete(this.fullKey(key ?? '')) ? 1 : 0;\n    }\n    // Glob pattern. Escape regex metacharacters first so a literal `.`/`(`/`[`\n    // in a key prefix (e.g. `org:v1.2:*`) can't over-match or throw (a throw\n    // here would leave entries stale); only `*` is treated as a wildcard.\n    const fp = this.fullKey(key ?? '');\n    const regex = new RegExp('^' + fp.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\\\\\*/g, '.*') + '$');\n    let deleted = 0;\n    for (const k of this.memory.keys()) {\n      if (regex.test(k)) {\n        this.memory.delete(k);\n        deleted++;\n      }\n    }\n    return deleted;\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   * The returned value is an INDEPENDENT deep copy — mutating it never affects\n   * the cached entry.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\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      // LRU touch: delete + re-insert moves this key to the newest position\n      // (Map preserves insertion order), so `set`'s oldest-first eviction is a\n      // true least-recently-USED eviction rather than first-inserted (FIFO).\n      this.memory.delete(fk);\n      this.memory.set(fk, entry);\n      this.metrics.hits++;\n      // Clone so a caller mutating the result can't corrupt the shared entry.\n      return cloneValue(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\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      // A write counts as a use, so drop any existing entry first\n      // and re-insert below as the newest (Map preserves insertion order). This\n      // keeps the Map ordered oldest-USED → newest-USED so the eviction below is\n      // true LRU, and avoids evicting a victim when merely updating a key.\n      this.memory.delete(fk);\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    try {\n      this.applyLocalInvalidation('del', key);\n      this.broadcast('del', key);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Only `*` is a wildcard.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    try {\n      // Apply locally, then fan out to the other replicas.\n      const deleted = this.applyLocalInvalidation('pattern', pattern);\n      this.broadcast('pattern', pattern);\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\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   * Single-flight / stampede protection: when N callers miss concurrently for\n   * the same key, only ONE `factory()` runs — the rest await its shared promise.\n   * The in-flight entry is cleared once it settles (success or failure), so a\n   * failed factory doesn't poison later calls.\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 fk = this.fullKey(key);\n    // Coalesce concurrent cold callers onto a single factory() invocation. The\n    // in-flight promise resolves to the RAW value; each awaiter (the primary\n    // caller below AND every coalesced caller here) clones it INDEPENDENTLY.\n    // Cloning inside the flight instead would hand one shared clone to all N\n    // coalesced callers, so one caller mutating its \"independent\" result would\n    // corrupt what the others read — the exact footgun get()'s clone-on-read\n    // prevents.\n    const existing = this.inflight.get(fk) as Promise<T> | undefined;\n    if (existing) return cloneValue(await existing);\n\n    const generationAtStart = this.generation;\n    const flight = (async () => {\n      const value = await factory();\n      // An invalidation (here or on another replica) landed while the factory\n      // ran: its read may predate that write, so don't cache it.\n      if (this.generation === generationAtStart) await this.set(key, value, ttlSeconds);\n      return value;\n    })();\n    this.inflight.set(fk, flight);\n    try {\n      return cloneValue(await flight);\n    } finally {\n      this.inflight.delete(fk);\n    }\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    this.applyLocalInvalidation('clear');\n    this.broadcast('clear');\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 */\nexport function createCacheService(prefix: string, defaultTtlSeconds = 300): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds });\n}\n"]}

package/lib/services/compliance-event-subscriber.d.ts

@@ -8,9 +8,10 @@ import { type ServiceConfig } from '../types/common.js';
  *
  * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)
  * @param serviceName - Service identifier baked into the signed JWT's `sub`
- *   (e.g. 'pipeline', 'plugin'). The compliance route requires a service
- *   principal — a spoofable `x-internal-service: true` header is no longer
- *   accepted. Defaults to a generic 'entity-events' when unspecified, but
- *   callers should pass their service name for accurate audit trails.
+ *   (e.g. 'pipeline', 'plugin'). The compliance route is an INTERNAL route: it
+ *   admits only those two services' own signed tokens, and no user token.
+ *   Defaults to THIS process's identity (`SERVICE_NAME`) — since #14 a service
+ *   holds only its own signing key, so a placeholder name would mint a token no
+ *   peer could verify.
  */
 export declare function registerComplianceEventSubscriber(config?: Partial<ServiceConfig>, serviceName?: string): void;

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { entityEvents } from './entity-events.js';
 import { InternalHttpClient } from './http-client.js';
+import { serviceIdentity } from './service-keys.js';
 import { getServiceAuthHeader } from '../middleware/auth.js';
 import {} from '../types/common.js';
 import { createLogger } from '../utils/logger.js';
@@ -16,12 +17,13 @@ const logger = createLogger('compliance-events');
  *
  * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)
  * @param serviceName - Service identifier baked into the signed JWT's `sub`
- *   (e.g. 'pipeline', 'plugin'). The compliance route requires a service
- *   principal — a spoofable `x-internal-service: true` header is no longer
- *   accepted. Defaults to a generic 'entity-events' when unspecified, but
- *   callers should pass their service name for accurate audit trails.
+ *   (e.g. 'pipeline', 'plugin'). The compliance route is an INTERNAL route: it
+ *   admits only those two services' own signed tokens, and no user token.
+ *   Defaults to THIS process's identity (`SERVICE_NAME`) — since #14 a service
+ *   holds only its own signing key, so a placeholder name would mint a token no
+ *   peer could verify.
  */
-export function registerComplianceEventSubscriber(config, serviceName = 'entity-events') {
+export function registerComplianceEventSubscriber(config, serviceName = serviceIdentity()) {
     const serviceConfig = {
         host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',
         port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),
@@ -69,4 +71,4 @@ export function registerComplianceEventSubscriber(config, serviceName = 'entity-
         port: serviceConfig.port,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-event-subscriber.js","sourceRoot":"","sources":["../../src/services/compliance-event-subscriber.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,YAAY,EAAgD,MAAM,oBAAoB,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAsB,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAEjD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,iCAAiC,CAC/C,MAA+B,EAC/B,WAAW,GAAW,eAAe,EAAE;IAEvC,MAAM,aAAa,GAAkB;QACnC,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,YAAY;QACzE,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,MAAM,EAAE,EAAE,CAAC;KAClF,CAAC;IAEF,MAAM,MAAM,GAAG,IAAI,kBAAkB,CAAC,aAAa,CAAC,CAAC;IAErD,MAAM,UAAU,GAA0B;QACxC,KAAK,CAAC,aAAa,CAAC,KAAkB;YACpC,IAAI,CAAC;gBACH,gEAAgE;gBAChE,kEAAkE;gBAClE,oDAAoD;gBACpD,gEAAgE;gBAChE,sDAAsD;gBACtD,EAAE;gBACF,oEAAoE;gBACpE,6DAA6D;gBAC7D,sEAAsE;gBACtE,uEAAuE;gBACvE,wEAAwE;gBACxE,6DAA6D;gBAC7D,MAAM,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,KAAK,EAAE;oBACpD,OAAO,EAAE;wBACP,eAAe,EAAE,oBAAoB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;wBAC1F,iBAAiB,EAAE,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE;qBAC3G;iBACF,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,sEAAsE;gBACtE,wEAAwE;gBACxE,yDAAyD;gBACzD,WAAW,CAAC,6BAA6B,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;gBAC3F,MAAM,CAAC,IAAI,CAAC,qDAAqD,EAAE;oBACjE,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,SAAS,EAAE,KAAK,CAAC,SAAS;oBAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;oBACxB,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;iBACxD,CAAC,CAAC;YACL,CAAC;QACH,CAAC;KACF,CAAC;IAEF,YAAY,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IACnC,MAAM,CAAC,IAAI,CAAC,wCAAwC,EAAE;QACpD,IAAI,EAAE,aAAa,CAAC,IAAI;QACxB,IAAI,EAAE,aAAa,CAAC,IAAI;KACzB,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { entityEvents, type EntityEvent, type EntityEventSubscriber } from './entity-events.js';\nimport { InternalHttpClient } from './http-client.js';\nimport { serviceIdentity } from './service-keys.js';\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport { type ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('compliance-events');\n\n/**\n * Registers an entity event subscriber that forwards events to the compliance service.\n *\n * Call this at service startup (in index.ts) to enable automatic compliance\n * notification on entity mutations. Events are fire-and-forget — failures\n * are logged but never block the original request.\n *\n * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)\n * @param serviceName - Service identifier baked into the signed JWT's `sub`\n *   (e.g. 'pipeline', 'plugin'). The compliance route is an INTERNAL route: it\n *   admits only those two services' own signed tokens, and no user token.\n *   Defaults to THIS process's identity (`SERVICE_NAME`) — since #14 a service\n *   holds only its own signing key, so a placeholder name would mint a token no\n *   peer could verify.\n */\nexport function registerComplianceEventSubscriber(\n  config?: Partial<ServiceConfig>,\n  serviceName: string = serviceIdentity(),\n): void {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',\n    port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  const subscriber: EntityEventSubscriber = {\n    async onEntityEvent(event: EntityEvent): Promise<void> {\n      try {\n        // Mint a per-event service JWT scoped to the event's org so the\n        // compliance route's `runWithTenantContext` sees the right tenant\n        // GUC. The compliance side enforces `requireAuth` +\n        // `requireServicePrincipal` — the previous `x-internal-service`\n        // header is no longer sufficient (and was spoofable).\n        //\n        // This HTTP notify is the SINGLE delivery channel for post-mutation\n        // re-validation (primary enforcement is the fail-CLOSED live\n        // validate path). A stable per-event `Idempotency-Key` makes the POST\n        // retry-safe in the http-client, so a transient 5xx/timeout is retried\n        // rather than dropped on the first attempt; compliance re-evaluation is\n        // naturally idempotent, so a duplicate delivery is harmless.\n        await client.post('/compliance/events/entity', event, {\n          headers: {\n            'Authorization': getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' }),\n            'Idempotency-Key': `${event.target}:${event.entityId}:${event.eventType}:${event.timestamp.toISOString()}`,\n          },\n        });\n      } catch (err) {\n        // Fire-and-forget: log + a drop metric so sustained loss is alertable\n        // (operators can't act on a warn line alone), then swallow — compliance\n        // notification is non-fatal to the originating mutation.\n        emitCounter('compliance_event_drop_total', { service: serviceName, target: event.target });\n        logger.warn('Failed to notify compliance service of entity event', {\n          target: event.target,\n          eventType: event.eventType,\n          entityId: event.entityId,\n          error: err instanceof Error ? err.message : String(err),\n        });\n      }\n    },\n  };\n\n  entityEvents.subscribe(subscriber);\n  logger.info('Compliance event subscriber registered', {\n    host: serviceConfig.host,\n    port: serviceConfig.port,\n  });\n}\n"]}