@pipeline-builder/api-core 0.0.1

package/lib/services/audit-spool.js

@@ -0,0 +1,172 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('audit-spool');
+const DEFAULT_SPOOL_KEY = 'audit:spool';
+const DEFAULT_MAX_DEPTH = 10_000;
+/** Guard so a pathological in-progress list can't spin `recover`/`take` forever. */
+const MAX_MOVE_ITERATIONS = 100_000;
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function safeParse(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && parsed.event && parsed.serviceName ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Redis-LIST-backed spool. Durable across process restarts (unlike an in-memory
+ * or per-pod-disk buffer), shared by all replicas of a service, and bounded via
+ * a trim-to-tail on overflow (drops the OLDEST, emitting `audit_spool_dropped_total`).
+ */
+export function createRedisAuditSpool(redis, opts = {}) {
+    const key = opts.key ?? DEFAULT_SPOOL_KEY;
+    // The in-progress "processing" list — a taken batch lives here until it is
+    // acked (delivered) or requeued (still failing). It is a security log's
+    // durability net: a crash between take and ack/requeue leaves the batch here,
+    // and `recover` reclaims it on restart instead of silently losing it.
+    const inProgressKey = `${key}:inflight`;
+    const maxDepth = Math.max(1, opts.maxDepth ?? DEFAULT_MAX_DEPTH);
+    // The EXACT serialized string each returned entry was parsed from, so `ack` /
+    // `requeue` can LREM the precise value off the in-progress list. Keyed by the
+    // returned object identity (the drain consumer passes the SAME objects back),
+    // so it needs no stable re-serialization. WeakMap → entries GC naturally.
+    const rawByEntry = new WeakMap();
+    const rawOf = (entry) => rawByEntry.get(entry) ?? JSON.stringify(entry);
+    return {
+        async enqueue(entry) {
+            try {
+                const len = await redis.rpush(key, JSON.stringify(entry));
+                emitCounter('audit_spool_enqueued_total', { service: entry.serviceName });
+                if (len > maxDepth) {
+                    // Keep only the newest `maxDepth`; drop the overflow at the head.
+                    const dropped = len - maxDepth;
+                    await redis.ltrim(key, dropped, -1);
+                    emitCounter('audit_spool_dropped_total', { service: entry.serviceName }, dropped);
+                    logger.warn('Audit spool overflow — dropped oldest buffered events', { dropped, maxDepth });
+                }
+            }
+            catch (err) {
+                logger.warn('Audit spool enqueue failed (event lost)', { error: errMsg(err) });
+            }
+        },
+        async take(max) {
+            try {
+                const out = [];
+                const limit = Math.max(1, max);
+                for (let i = 0; i < limit; i++) {
+                    // Atomically MOVE head→in-progress-tail so the entry is never in limbo:
+                    // it is on exactly one list at all times, recoverable after a crash.
+                    const raw = await redis.lmove(key, inProgressKey, 'LEFT', 'RIGHT');
+                    if (raw === null || raw === undefined)
+                        break;
+                    const parsed = safeParse(raw);
+                    if (parsed) {
+                        rawByEntry.set(parsed, raw);
+                        out.push(parsed);
+                    }
+                    else {
+                        // Corrupt payload — drop it off the in-progress list so it can't wedge
+                        // the drain, and account for it.
+                        await redis.lrem(inProgressKey, 1, raw);
+                        emitCounter('audit_spool_dropped_total', { service: 'unknown' });
+                    }
+                }
+                return out;
+            }
+            catch (err) {
+                logger.warn('Audit spool take failed', { error: errMsg(err) });
+                return [];
+            }
+        },
+        async ack(entries) {
+            if (entries.length === 0)
+                return;
+            try {
+                for (const entry of entries) {
+                    await redis.lrem(inProgressKey, 1, rawOf(entry));
+                    rawByEntry.delete(entry);
+                }
+            }
+            catch (err) {
+                logger.warn('Audit spool ack failed (may re-deliver on recover)', { error: errMsg(err) });
+            }
+        },
+        async requeue(entries) {
+            if (entries.length === 0)
+                return;
+            try {
+                // Put failed re-deliveries back at the HEAD so they're retried first and
+                // rough emission order is preserved across the outage — and clear them
+                // from the in-progress list so `recover` doesn't double them. Iterate in
+                // reverse so lpush restores the batch's original order at the head.
+                //
+                // ORDERING INVARIANT (at-least-once): lpush to the main list FIRST, THEN
+                // lrem from in-progress. A crash between the two leaves the entry on BOTH
+                // lists → harmless double-delivery (deduped downstream by idempotency
+                // reuse), never a LOSS. The reverse order (lrem then lpush) would drop the
+                // event outright on a crash in the gap, which a security log must not do.
+                for (let i = entries.length - 1; i >= 0; i--) {
+                    const raw = rawOf(entries[i]);
+                    await redis.lpush(key, raw);
+                    await redis.lrem(inProgressKey, 1, raw);
+                    rawByEntry.delete(entries[i]);
+                }
+            }
+            catch (err) {
+                logger.warn('Audit spool requeue failed (events lost)', { error: errMsg(err) });
+            }
+        },
+        async recover() {
+            try {
+                let reclaimed = 0;
+                for (let i = 0; i < MAX_MOVE_ITERATIONS; i++) {
+                    // Move in-progress-tail → main-head: an older stranded entry (nearer the
+                    // in-progress head) ends up ahead of a newer one, preserving order.
+                    const raw = await redis.lmove(inProgressKey, key, 'RIGHT', 'LEFT');
+                    if (raw === null || raw === undefined)
+                        break;
+                    reclaimed++;
+                }
+                if (reclaimed > 0) {
+                    emitCounter('audit_spool_recovered_total', {}, reclaimed);
+                    logger.warn('Audit spool recovered stranded in-progress events', { reclaimed });
+                }
+                return reclaimed;
+            }
+            catch (err) {
+                logger.warn('Audit spool recover failed', { error: errMsg(err) });
+                return 0;
+            }
+        },
+        async depth() {
+            try {
+                return await redis.llen(key);
+            }
+            catch {
+                return 0;
+            }
+        },
+    };
+}
+/**
+ * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_HOST`
+ * env via the shared `createEnvRedisClient`. Returns `null` when Redis is not
+ * configured or the client can't be constructed — the caller then runs without a
+ * spool (pre-spool best-effort behavior), never crashing. The shared helper loads
+ * ioredis via `createRequire`, so this stays importable where Redis isn't present.
+ */
+export function createEnvRedisAuditSpool(opts = {}) {
+    const inst = createEnvRedisClient('audit-spool');
+    if (!inst)
+        return null;
+    logger.info('Redis audit spool initialized');
+    return createRedisAuditSpool(inst, opts);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit-spool.js","sourceRoot":"","sources":["../../src/services/audit-spool.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport type { RemoteAuditEvent } from './remote-audit-client.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('audit-spool');\n\n/** A buffered emission: the event plus which service must re-deliver it. */\nexport interface AuditSpoolEntry {\n  event: RemoteAuditEvent;\n  serviceName: string;\n}\n\n/**\n * Durable buffer for audit events that failed LIVE delivery to the platform\n * (retries exhausted during a sustained outage). Without this, the audit trail —\n * a security log — is silently lost the moment the platform is down for longer\n * than the client's small retry budget.\n *\n * Contract:\n * - BOUNDED. A security log must degrade to \"dropped the oldest, loudly\" (a\n *   metric) rather than grow without limit and OOM the emitter.\n * - FAIL-SAFE. Every method swallows its own errors — a broken/unreachable spool\n *   must never break or block the audit emission path (which is itself\n *   fire-and-forget). A spool problem degrades to the pre-spool behavior.\n * - Ordering is best-effort. Re-delivered events chain at re-delivery time\n *   (that's when the platform inserts them), so each event also carries an\n *   `occurredAt` stamped at emission for reviewers — see RemoteAuditEvent.\n */\nexport interface AuditSpool {\n  /** Buffer an event that failed live delivery. */\n  enqueue(entry: AuditSpoolEntry): Promise<void>;\n  /**\n   * Atomically MOVE up to `max` buffered entries onto an in-progress list and\n   * return them. Because the entries are moved (not popped-and-dropped), a crash\n   * mid-drain leaves them recoverable on the in-progress list — see `recover`.\n   * Each taken entry MUST be resolved with exactly one of `ack` (delivered) or\n   * `requeue` (still failing), or it lingers on the in-progress list until the\n   * next `recover`.\n   */\n  take(max: number): Promise<AuditSpoolEntry[]>;\n  /** Acknowledge successfully re-delivered entries — removes them from the\n   *  in-progress list so they are not recovered again. */\n  ack(entries: AuditSpoolEntry[]): Promise<void>;\n  /** Return entries whose re-delivery failed to the HEAD of the buffer (retried\n   *  first) and clear them from the in-progress list. Best-effort. */\n  requeue(entries: AuditSpoolEntry[]): Promise<void>;\n  /** Reclaim any entries stranded on the in-progress list by a prior crash,\n   *  moving them back to the head of the main buffer. Call once at startup.\n   *  Returns the number reclaimed. */\n  recover(): Promise<number>;\n  /** Approximate current depth (for metrics / drain decisions). */\n  depth(): Promise<number>;\n}\n\n/** Minimal Redis LIST surface the spool needs (a subset of ioredis). */\ninterface RedisListClient {\n  rpush(key: string, ...values: string[]): Promise<number>;\n  lpush(key: string, ...values: string[]): Promise<number>;\n  lpop(key: string, count: number): Promise<string[] | null>;\n  ltrim(key: string, start: number, stop: number): Promise<unknown>;\n  llen(key: string): Promise<number>;\n  /** Atomically pop from one list end and push to another (Redis ≥ 6.2). */\n  lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT'): Promise<string | null>;\n  /** Remove `count` occurrences of `value` from a list. */\n  lrem(key: string, count: number, value: string): Promise<number>;\n}\n\nconst DEFAULT_SPOOL_KEY = 'audit:spool';\nconst DEFAULT_MAX_DEPTH = 10_000;\n/** Guard so a pathological in-progress list can't spin `recover`/`take` forever. */\nconst MAX_MOVE_ITERATIONS = 100_000;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction safeParse(raw: string): AuditSpoolEntry | null {\n  try {\n    const parsed = JSON.parse(raw) as AuditSpoolEntry;\n    return parsed && parsed.event && parsed.serviceName ? parsed : null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Redis-LIST-backed spool. Durable across process restarts (unlike an in-memory\n * or per-pod-disk buffer), shared by all replicas of a service, and bounded via\n * a trim-to-tail on overflow (drops the OLDEST, emitting `audit_spool_dropped_total`).\n */\nexport function createRedisAuditSpool(\n  redis: RedisListClient,\n  opts: { maxDepth?: number; key?: string } = {},\n): AuditSpool {\n  const key = opts.key ?? DEFAULT_SPOOL_KEY;\n  // The in-progress \"processing\" list — a taken batch lives here until it is\n  // acked (delivered) or requeued (still failing). It is a security log's\n  // durability net: a crash between take and ack/requeue leaves the batch here,\n  // and `recover` reclaims it on restart instead of silently losing it.\n  const inProgressKey = `${key}:inflight`;\n  const maxDepth = Math.max(1, opts.maxDepth ?? DEFAULT_MAX_DEPTH);\n\n  // The EXACT serialized string each returned entry was parsed from, so `ack` /\n  // `requeue` can LREM the precise value off the in-progress list. Keyed by the\n  // returned object identity (the drain consumer passes the SAME objects back),\n  // so it needs no stable re-serialization. WeakMap → entries GC naturally.\n  const rawByEntry = new WeakMap<AuditSpoolEntry, string>();\n  const rawOf = (entry: AuditSpoolEntry): string => rawByEntry.get(entry) ?? JSON.stringify(entry);\n\n  return {\n    async enqueue(entry) {\n      try {\n        const len = await redis.rpush(key, JSON.stringify(entry));\n        emitCounter('audit_spool_enqueued_total', { service: entry.serviceName });\n        if (len > maxDepth) {\n          // Keep only the newest `maxDepth`; drop the overflow at the head.\n          const dropped = len - maxDepth;\n          await redis.ltrim(key, dropped, -1);\n          emitCounter('audit_spool_dropped_total', { service: entry.serviceName }, dropped);\n          logger.warn('Audit spool overflow — dropped oldest buffered events', { dropped, maxDepth });\n        }\n      } catch (err) {\n        logger.warn('Audit spool enqueue failed (event lost)', { error: errMsg(err) });\n      }\n    },\n\n    async take(max) {\n      try {\n        const out: AuditSpoolEntry[] = [];\n        const limit = Math.max(1, max);\n        for (let i = 0; i < limit; i++) {\n          // Atomically MOVE head→in-progress-tail so the entry is never in limbo:\n          // it is on exactly one list at all times, recoverable after a crash.\n          const raw = await redis.lmove(key, inProgressKey, 'LEFT', 'RIGHT');\n          if (raw === null || raw === undefined) break;\n          const parsed = safeParse(raw);\n          if (parsed) {\n            rawByEntry.set(parsed, raw);\n            out.push(parsed);\n          } else {\n            // Corrupt payload — drop it off the in-progress list so it can't wedge\n            // the drain, and account for it.\n            await redis.lrem(inProgressKey, 1, raw);\n            emitCounter('audit_spool_dropped_total', { service: 'unknown' });\n          }\n        }\n        return out;\n      } catch (err) {\n        logger.warn('Audit spool take failed', { error: errMsg(err) });\n        return [];\n      }\n    },\n\n    async ack(entries) {\n      if (entries.length === 0) return;\n      try {\n        for (const entry of entries) {\n          await redis.lrem(inProgressKey, 1, rawOf(entry));\n          rawByEntry.delete(entry);\n        }\n      } catch (err) {\n        logger.warn('Audit spool ack failed (may re-deliver on recover)', { error: errMsg(err) });\n      }\n    },\n\n    async requeue(entries) {\n      if (entries.length === 0) return;\n      try {\n        // Put failed re-deliveries back at the HEAD so they're retried first and\n        // rough emission order is preserved across the outage — and clear them\n        // from the in-progress list so `recover` doesn't double them. Iterate in\n        // reverse so lpush restores the batch's original order at the head.\n        //\n        // ORDERING INVARIANT (at-least-once): lpush to the main list FIRST, THEN\n        // lrem from in-progress. A crash between the two leaves the entry on BOTH\n        // lists → harmless double-delivery (deduped downstream by idempotency\n        // reuse), never a LOSS. The reverse order (lrem then lpush) would drop the\n        // event outright on a crash in the gap, which a security log must not do.\n        for (let i = entries.length - 1; i >= 0; i--) {\n          const raw = rawOf(entries[i]);\n          await redis.lpush(key, raw);\n          await redis.lrem(inProgressKey, 1, raw);\n          rawByEntry.delete(entries[i]);\n        }\n      } catch (err) {\n        logger.warn('Audit spool requeue failed (events lost)', { error: errMsg(err) });\n      }\n    },\n\n    async recover() {\n      try {\n        let reclaimed = 0;\n        for (let i = 0; i < MAX_MOVE_ITERATIONS; i++) {\n          // Move in-progress-tail → main-head: an older stranded entry (nearer the\n          // in-progress head) ends up ahead of a newer one, preserving order.\n          const raw = await redis.lmove(inProgressKey, key, 'RIGHT', 'LEFT');\n          if (raw === null || raw === undefined) break;\n          reclaimed++;\n        }\n        if (reclaimed > 0) {\n          emitCounter('audit_spool_recovered_total', {}, reclaimed);\n          logger.warn('Audit spool recovered stranded in-progress events', { reclaimed });\n        }\n        return reclaimed;\n      } catch (err) {\n        logger.warn('Audit spool recover failed', { error: errMsg(err) });\n        return 0;\n      }\n    },\n\n    async depth() {\n      try {\n        return await redis.llen(key);\n      } catch {\n        return 0;\n      }\n    },\n  };\n}\n\n/**\n * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_HOST`\n * env via the shared `createEnvRedisClient`. Returns `null` when Redis is not\n * configured or the client can't be constructed — the caller then runs without a\n * spool (pre-spool best-effort behavior), never crashing. The shared helper loads\n * ioredis via `createRequire`, so this stays importable where Redis isn't present.\n */\nexport function createEnvRedisAuditSpool(opts: { maxDepth?: number; key?: string } = {}): AuditSpool | null {\n  const inst = createEnvRedisClient<RedisListClient>('audit-spool');\n  if (!inst) return null;\n  logger.info('Redis audit spool initialized');\n  return createRedisAuditSpool(inst, opts);\n}\n"]}

package/lib/services/cache-service.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Minimal Redis-like client interface (subset of ioredis).
+ * Services pass their own Redis client instance.
+ */
+export interface RedisCacheClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
+    del(...keys: string[]): Promise<number>;
+    keys(pattern: string): Promise<string[]>;
+    /** SCAN-based iteration (preferred over KEYS for production). */
+    scanStream?(options: {
+        match: string;
+        count?: number;
+    }): NodeJS.ReadableStream;
+}
+export interface CacheConfig {
+    /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */
+    prefix: string;
+    /** Default TTL in seconds */
+    defaultTtlSeconds: number;
+    /** Max entries for in-memory cache (default 1000) */
+    maxEntries?: number;
+    /** Optional Redis client — uses in-memory cache if not provided */
+    redis?: RedisCacheClient;
+}
+/**
+ * Cache service with get/set/del operations and automatic TTL expiry.
+ *
+ * @example
+ * ```typescript
+ * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });
+ *
+ * // Set with default TTL
+ * await cache.set('org123:list', plugins);
+ *
+ * // Get (returns null on miss)
+ * const cached = await cache.get<Plugin[]>('org123:list');
+ *
+ * // Invalidate
+ * await cache.del('org123:list');
+ *
+ * // Invalidate by pattern
+ * await cache.invalidatePattern('org123:*');
+ * ```
+ */
+export declare class CacheService {
+    private memory;
+    /**
+     * In-flight `getOrSet` factory promises, keyed by full cache key. Coalesces
+     * concurrent cold callers onto a single `factory()` invocation (single-flight
+     * / stampede protection); entries are cleared once the promise settles.
+     */
+    private inflight;
+    private readonly prefix;
+    private readonly defaultTtlMs;
+    private readonly maxEntries;
+    private readonly redis?;
+    /** Cache metrics — tracks hits, misses, and invalidations. */
+    readonly metrics: {
+        hits: number;
+        misses: number;
+        sets: number;
+        invalidations: number;
+    };
+    constructor(config: CacheConfig);
+    private fullKey;
+    /**
+     * 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.
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * 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 ttlSeconds - TTL override (uses default if not provided)
+     */
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    /**
+     * Delete a cached value.
+     */
+    del(key: string): Promise<void>;
+    /**
+     * Invalidate all keys matching a pattern (e.g., 'org123:*').
+     * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.
+     */
+    invalidatePattern(pattern: string): Promise<number>;
+    /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */
+    private scanKeys;
+    /**
+     * Get or compute: returns cached value if available, otherwise calls the
+     * factory function, caches the result, and returns it.
+     *
+     * Single-flight / stampede protection: when N callers miss concurrently for
+     * the same key, only ONE `factory()` runs — the rest await its shared promise.
+     * The in-flight entry is cleared once it settles (success or failure), so a
+     * failed factory doesn't poison later calls.
+     *
+     * @param key - Cache key
+     * @param factory - Async function to compute the value on cache miss
+     * @param ttlSeconds - Optional TTL override
+     * @returns The cached or computed value
+     */
+    getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T>;
+    /**
+     * Clear all entries (useful for testing).
+     */
+    clear(): Promise<void>;
+    /** Current in-memory cache size (for diagnostics). */
+    get size(): number;
+}
+/**
+ * Create a cache service instance.
+ *
+ * @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 declare function createCacheService(prefix: string, defaultTtlSeconds?: number, redis?: RedisCacheClient): CacheService;

package/lib/services/cache-service.js

@@ -0,0 +1,276 @@
+// 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).
+ *
+ * Primitives are returned as-is. Prefers the structured-clone algorithm; falls
+ * back to a JSON round-trip on older runtimes or exotic values.
+ */
+function cloneValue(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        return JSON.parse(JSON.stringify(value));
+    }
+}
+/**
+ * Cache service with get/set/del operations and automatic TTL expiry.
+ *
+ * @example
+ * ```typescript
+ * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });
+ *
+ * // Set with default TTL
+ * await cache.set('org123:list', plugins);
+ *
+ * // Get (returns null on miss)
+ * const cached = await cache.get<Plugin[]>('org123:list');
+ *
+ * // Invalidate
+ * await cache.del('org123:list');
+ *
+ * // Invalidate by pattern
+ * await cache.invalidatePattern('org123:*');
+ * ```
+ */
+export class CacheService {
+    memory = new Map();
+    /**
+     * In-flight `getOrSet` factory promises, keyed by full cache key. Coalesces
+     * concurrent cold callers onto a single `factory()` invocation (single-flight
+     * / stampede protection); entries are cleared once the promise settles.
+     */
+    inflight = new Map();
+    prefix;
+    defaultTtlMs;
+    maxEntries;
+    redis;
+    /** 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;
+    }
+    fullKey(key) {
+        return `${this.prefix}${key}`;
+    }
+    /**
+     * 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.
+     */
+    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++;
+                return null;
+            }
+            if (Date.now() > entry.expiresAt) {
+                this.memory.delete(fk);
+                this.metrics.misses++;
+                return null;
+            }
+            // LRU touch: delete + re-insert moves this key to the newest position
+            // (Map preserves insertion order), so `set`'s oldest-first eviction is a
+            // true least-recently-USED eviction rather than first-inserted (FIFO).
+            this.memory.delete(fk);
+            this.memory.set(fk, entry);
+            this.metrics.hits++;
+            // Clone so a caller mutating the result can't corrupt the shared entry.
+            return cloneValue(entry.value);
+        }
+        catch {
+            this.metrics.misses++;
+            return null;
+        }
+    }
+    /**
+     * 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 ttlSeconds - TTL override (uses default if not provided)
+     */
+    async set(key, value, ttlSeconds) {
+        const fk = this.fullKey(key);
+        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
+            // 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.
+            this.memory.delete(fk);
+            if (this.memory.size >= this.maxEntries) {
+                const firstKey = this.memory.keys().next().value;
+                if (firstKey)
+                    this.memory.delete(firstKey);
+            }
+            this.memory.set(fk, {
+                value,
+                expiresAt: Date.now() + ttl * 1000,
+            });
+        }
+        catch {
+            // Cache set failure is non-fatal
+        }
+    }
+    /**
+     * 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);
+        }
+        catch {
+            // Cache delete failure is non-fatal
+        }
+    }
+    /**
+     * Invalidate all keys matching a pattern (e.g., 'org123:*').
+     * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.
+     */
+    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++;
+                }
+            }
+            this.metrics.invalidations += deleted;
+            return deleted;
+        }
+        catch {
+            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.
+     *
+     * Single-flight / stampede protection: when N callers miss concurrently for
+     * the same key, only ONE `factory()` runs — the rest await its shared promise.
+     * The in-flight entry is cleared once it settles (success or failure), so a
+     * failed factory doesn't poison later calls.
+     *
+     * @param key - Cache key
+     * @param factory - Async function to compute the value on cache miss
+     * @param ttlSeconds - Optional TTL override
+     * @returns The cached or computed value
+     */
+    async getOrSet(key, factory, ttlSeconds) {
+        const cached = await this.get(key);
+        if (cached !== null)
+            return cached;
+        const fk = this.fullKey(key);
+        // Coalesce concurrent cold callers onto a single factory() invocation. The
+        // in-flight promise resolves to the RAW value; each awaiter (the primary
+        // caller below AND every coalesced caller here) clones it INDEPENDENTLY.
+        // 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.)
+        const existing = this.inflight.get(fk);
+        if (existing)
+            return cloneValue(await existing);
+        const flight = (async () => {
+            const value = await factory();
+            await this.set(key, value, ttlSeconds);
+            return value;
+        })();
+        this.inflight.set(fk, flight);
+        try {
+            return cloneValue(await flight);
+        }
+        finally {
+            this.inflight.delete(fk);
+        }
+    }
+    /**
+     * Clear all entries (useful for testing).
+     */
+    async clear() {
+        if (this.redis) {
+            await this.invalidatePattern('*');
+        }
+        else {
+            this.memory.clear();
+        }
+    }
+    /** Current in-memory cache size (for diagnostics). */
+    get size() {
+        return this.memory.size;
+    }
+}
+/**
+ * Create a cache service instance.
+ *
+ * @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 });
+}
+//# 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"]}