@pipeline-builder/api-core 3.1.0

package/lib/services/admin-audit.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAdminAction = logAdminAction;
+exports.getAuditQueue = getAuditQueue;
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)('admin-audit');
+const auditQueue = [];
+let flushTimer = null;
+function logAdminAction(entry) {
+    logger.info('Admin action', entry);
+    auditQueue.push(entry);
+    if (!flushTimer) {
+        flushTimer = setTimeout(flushAuditQueue, 5000);
+    }
+}
+async function flushAuditQueue() {
+    flushTimer = null;
+    const batch = auditQueue.splice(0, auditQueue.length);
+    if (batch.length === 0)
+        return;
+    // Batch will be persisted when a DB writer is registered
+    for (const entry of batch) {
+        logger.debug('Audit entry queued', { action: entry.action, target: entry.targetType });
+    }
+}
+function getAuditQueue() {
+    return [...auditQueue];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRtaW4tYXVkaXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvYWRtaW4tYXVkaXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7O0FBcUJ0Qyx3Q0FNQztBQVlELHNDQUVDO0FBdkNELDRDQUErQztBQUUvQyxNQUFNLE1BQU0sR0FBRyxJQUFBLHFCQUFZLEVBQUMsYUFBYSxDQUFDLENBQUM7QUFjM0MsTUFBTSxVQUFVLEdBQWlCLEVBQUUsQ0FBQztBQUNwQyxJQUFJLFVBQVUsR0FBeUMsSUFBSSxDQUFDO0FBRTVELFNBQWdCLGNBQWMsQ0FBQyxLQUFpQjtJQUM5QyxNQUFNLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNuQyxVQUFVLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3ZCLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUNoQixVQUFVLEdBQUcsVUFBVSxDQUFDLGVBQWUsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNqRCxDQUFDO0FBQ0gsQ0FBQztBQUVELEtBQUssVUFBVSxlQUFlO0lBQzVCLFVBQVUsR0FBRyxJQUFJLENBQUM7SUFDbEIsTUFBTSxLQUFLLEdBQUcsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3RELElBQUksS0FBSyxDQUFDLE1BQU0sS0FBSyxDQUFDO1FBQUUsT0FBTztJQUMvQix5REFBeUQ7SUFDekQsS0FBSyxNQUFNLEtBQUssSUFBSSxLQUFLLEVBQUUsQ0FBQztRQUMxQixNQUFNLENBQUMsS0FBSyxDQUFDLG9CQUFvQixFQUFFLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQ3pGLENBQUM7QUFDSCxDQUFDO0FBRUQsU0FBZ0IsYUFBYTtJQUMzQixPQUFPLENBQUMsR0FBRyxVQUFVLENBQUMsQ0FBQztBQUN6QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmltcG9ydCB7IGNyZWF0ZUxvZ2dlciB9IGZyb20gJy4uL3V0aWxzL2xvZ2dlcic7XG5cbmNvbnN0IGxvZ2dlciA9IGNyZWF0ZUxvZ2dlcignYWRtaW4tYXVkaXQnKTtcblxuZXhwb3J0IGludGVyZmFjZSBBdWRpdEVudHJ5IHtcbiAgdXNlcklkOiBzdHJpbmc7XG4gIHVzZXJFbWFpbD86IHN0cmluZztcbiAgb3JnSWQ/OiBzdHJpbmc7XG4gIGFjdGlvbjogc3RyaW5nO1xuICB0YXJnZXRUeXBlOiBzdHJpbmc7XG4gIHRhcmdldElkPzogc3RyaW5nO1xuICB0YXJnZXROYW1lPzogc3RyaW5nO1xuICBkZXRhaWw/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgaXBBZGRyZXNzPzogc3RyaW5nO1xufVxuXG5jb25zdCBhdWRpdFF1ZXVlOiBBdWRpdEVudHJ5W10gPSBbXTtcbmxldCBmbHVzaFRpbWVyOiBSZXR1cm5UeXBlPHR5cGVvZiBzZXRUaW1lb3V0PiB8IG51bGwgPSBudWxsO1xuXG5leHBvcnQgZnVuY3Rpb24gbG9nQWRtaW5BY3Rpb24oZW50cnk6IEF1ZGl0RW50cnkpOiB2b2lkIHtcbiAgbG9nZ2VyLmluZm8oJ0FkbWluIGFjdGlvbicsIGVudHJ5KTtcbiAgYXVkaXRRdWV1ZS5wdXNoKGVudHJ5KTtcbiAgaWYgKCFmbHVzaFRpbWVyKSB7XG4gICAgZmx1c2hUaW1lciA9IHNldFRpbWVvdXQoZmx1c2hBdWRpdFF1ZXVlLCA1MDAwKTtcbiAgfVxufVxuXG5hc3luYyBmdW5jdGlvbiBmbHVzaEF1ZGl0UXVldWUoKTogUHJvbWlzZTx2b2lkPiB7XG4gIGZsdXNoVGltZXIgPSBudWxsO1xuICBjb25zdCBiYXRjaCA9IGF1ZGl0UXVldWUuc3BsaWNlKDAsIGF1ZGl0UXVldWUubGVuZ3RoKTtcbiAgaWYgKGJhdGNoLmxlbmd0aCA9PT0gMCkgcmV0dXJuO1xuICAvLyBCYXRjaCB3aWxsIGJlIHBlcnNpc3RlZCB3aGVuIGEgREIgd3JpdGVyIGlzIHJlZ2lzdGVyZWRcbiAgZm9yIChjb25zdCBlbnRyeSBvZiBiYXRjaCkge1xuICAgIGxvZ2dlci5kZWJ1ZygnQXVkaXQgZW50cnkgcXVldWVkJywgeyBhY3Rpb246IGVudHJ5LmFjdGlvbiwgdGFyZ2V0OiBlbnRyeS50YXJnZXRUeXBlIH0pO1xuICB9XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRBdWRpdFF1ZXVlKCk6IEF1ZGl0RW50cnlbXSB7XG4gIHJldHVybiBbLi4uYXVkaXRRdWV1ZV07XG59XG4iXX0=

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

@@ -0,0 +1,108 @@
+/**
+ * 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;
+    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.
+     */
+    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.
+     *
+     * @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,212 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheService = void 0;
+exports.createCacheService = createCacheService;
+/**
+ * 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:*');
+ * ```
+ */
+class CacheService {
+    memory = 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.
+     */
+    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;
+            }
+            this.metrics.hits++;
+            return 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 — evict oldest if at capacity
+            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
+            const regex = new RegExp('^' + fp.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.
+     *
+     * @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 value = await factory();
+        await this.set(key, value, ttlSeconds);
+        return value;
+    }
+    /**
+     * 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;
+    }
+}
+exports.CacheService = CacheService;
+/**
+ * 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
+ */
+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): LRU-style Map cache, no external dependencies\n * - Redis: When a Redis client is provided, uses Redis for cross-process caching\n *\n * Design:\n * - All operations are fail-safe: cache misses/errors return null, never throw\n * - JSON serialization for Redis; direct reference for in-memory\n * - Key namespace prefixing to avoid collisions between services\n */\n\n\n/**\n * Cache entry with value and expiration time.\n */\ninterface CacheEntry<T> {\n  value: T;\n  expiresAt: number; // Unix timestamp in ms\n}\n\n/**\n * Minimal Redis-like client interface (subset of ioredis).\n * Services pass their own Redis client instance.\n */\nexport interface RedisCacheClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  keys(pattern: string): Promise<string[]>;\n  /** SCAN-based iteration (preferred over KEYS for production). */\n  scanStream?(options: { match: string; count?: number }): NodeJS.ReadableStream;\n}\n\nexport interface CacheConfig {\n  /** Key prefix for namespace isolation (e.g., 'plugin:', 'compliance:') */\n  prefix: string;\n  /** Default TTL in seconds */\n  defaultTtlSeconds: number;\n  /** Max entries for in-memory cache (default 1000) */\n  maxEntries?: number;\n  /** Optional Redis client — uses in-memory cache if not provided */\n  redis?: RedisCacheClient;\n}\n\n/**\n * Cache service with get/set/del operations and automatic TTL expiry.\n *\n * @example\n * ```typescript\n * const cache = new CacheService({ prefix: 'plugin:', defaultTtlSeconds: 300 });\n *\n * // Set with default TTL\n * await cache.set('org123:list', plugins);\n *\n * // Get (returns null on miss)\n * const cached = await cache.get<Plugin[]>('org123:list');\n *\n * // Invalidate\n * await cache.del('org123:list');\n *\n * // Invalidate by pattern\n * await cache.invalidatePattern('org123:*');\n * ```\n */\nexport class CacheService {\n  private memory = new Map<string, CacheEntry<unknown>>();\n  private readonly prefix: string;\n  private readonly defaultTtlMs: number;\n  private readonly maxEntries: number;\n  private readonly redis?: RedisCacheClient;\n\n  /** Cache metrics — tracks hits, misses, and invalidations. */\n  readonly metrics = { hits: 0, misses: 0, sets: 0, invalidations: 0 };\n\n  constructor(config: CacheConfig) {\n    this.prefix = config.prefix;\n    this.defaultTtlMs = config.defaultTtlSeconds * 1000;\n    this.maxEntries = config.maxEntries ?? 1000;\n    this.redis = config.redis;\n  }\n\n  private fullKey(key: string): string {\n    return `${this.prefix}${key}`;\n  }\n\n  /**\n   * Get a cached value. Returns null on miss or error.\n   */\n  async get<T>(key: string): Promise<T | null> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        const raw = await this.redis.get(fk);\n        if (!raw) { this.metrics.misses++; return null; }\n        this.metrics.hits++;\n        return JSON.parse(raw) as T;\n      }\n\n      // In-memory\n      const entry = this.memory.get(fk);\n      if (!entry) { this.metrics.misses++; return null; }\n      if (Date.now() > entry.expiresAt) {\n        this.memory.delete(fk);\n        this.metrics.misses++;\n        return null;\n      }\n      this.metrics.hits++;\n      return entry.value as T;\n    } catch {\n      this.metrics.misses++;\n      return null;\n    }\n  }\n\n  /**\n   * Set a cached value with optional TTL override.\n   *\n   * @param key - Cache key (prefix is added automatically)\n   * @param value - Value to cache (must be JSON-serializable for Redis)\n   * @param ttlSeconds - TTL override (uses default if not provided)\n   */\n  async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {\n    const fk = this.fullKey(key);\n    const ttl = ttlSeconds ?? this.defaultTtlMs / 1000;\n\n    try {\n      this.metrics.sets++;\n      if (this.redis) {\n        await this.redis.set(fk, JSON.stringify(value), 'EX', ttl);\n        return;\n      }\n\n      // In-memory — evict oldest if at capacity\n      if (this.memory.size >= this.maxEntries) {\n        const firstKey = this.memory.keys().next().value;\n        if (firstKey) this.memory.delete(firstKey);\n      }\n\n      this.memory.set(fk, {\n        value,\n        expiresAt: Date.now() + ttl * 1000,\n      });\n    } catch {\n      // Cache set failure is non-fatal\n    }\n  }\n\n  /**\n   * Delete a cached value.\n   */\n  async del(key: string): Promise<void> {\n    const fk = this.fullKey(key);\n\n    try {\n      if (this.redis) {\n        await this.redis.del(fk);\n        return;\n      }\n      this.memory.delete(fk);\n    } catch {\n      // Cache delete failure is non-fatal\n    }\n  }\n\n  /**\n   * Invalidate all keys matching a pattern (e.g., 'org123:*').\n   * Uses SCAN for Redis (non-blocking) with KEYS fallback, or regex for in-memory.\n   */\n  async invalidatePattern(pattern: string): Promise<number> {\n    const fp = this.fullKey(pattern);\n\n    try {\n      if (this.redis) {\n        const keys = this.redis.scanStream\n          ? await this.scanKeys(fp)\n          : await this.redis.keys(fp);\n        if (keys.length > 0) {\n          await this.redis.del(...keys);\n          this.metrics.invalidations += keys.length;\n        }\n        return keys.length;\n      }\n\n      // In-memory — match glob-style pattern\n      const regex = new RegExp('^' + fp.replace(/\\*/g, '.*') + '$');\n      let deleted = 0;\n      for (const key of this.memory.keys()) {\n        if (regex.test(key)) {\n          this.memory.delete(key);\n          deleted++;\n        }\n      }\n      this.metrics.invalidations += deleted;\n      return deleted;\n    } catch {\n      return 0;\n    }\n  }\n\n  /** Collect keys via Redis SCAN (non-blocking alternative to KEYS). */\n  private scanKeys(pattern: string): Promise<string[]> {\n    return new Promise((resolve, reject) => {\n      const stream = this.redis!.scanStream!({ match: pattern, count: 100 });\n      const keys: string[] = [];\n      stream.on('data', (batch: string[]) => keys.push(...batch));\n      stream.once('end', () => resolve(keys));\n      stream.once('error', reject);\n    });\n  }\n\n  /**\n   * Get or compute: returns cached value if available, otherwise calls the\n   * factory function, caches the result, and returns it.\n   *\n   * @param key - Cache key\n   * @param factory - Async function to compute the value on cache miss\n   * @param ttlSeconds - Optional TTL override\n   * @returns The cached or computed value\n   */\n  async getOrSet<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T> {\n    const cached = await this.get<T>(key);\n    if (cached !== null) return cached;\n\n    const value = await factory();\n    await this.set(key, value, ttlSeconds);\n    return value;\n  }\n\n  /**\n   * Clear all entries (useful for testing).\n   */\n  async clear(): Promise<void> {\n    if (this.redis) {\n      await this.invalidatePattern('*');\n    } else {\n      this.memory.clear();\n    }\n  }\n\n  /** Current in-memory cache size (for diagnostics). */\n  get size(): number {\n    return this.memory.size;\n  }\n}\n\n/**\n * Create a cache service instance.\n *\n * @param prefix - Namespace prefix (e.g., 'compliance:', 'plugin:')\n * @param defaultTtlSeconds - Default TTL in seconds (default 300 = 5 min)\n * @param redis - Optional Redis client for cross-process caching\n */\nexport function createCacheService(\n  prefix: string,\n  defaultTtlSeconds = 300,\n  redis?: RedisCacheClient,\n): CacheService {\n  return new CacheService({ prefix, defaultTtlSeconds, redis });\n}\n"]}

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

@@ -0,0 +1,46 @@
+import { ServiceConfig } from '../types/common';
+/**
+ * Result of a compliance validation check.
+ */
+export interface ComplianceCheckResult {
+    passed: boolean;
+    violations: ComplianceViolation[];
+    warnings: ComplianceViolation[];
+    blocked: boolean;
+    rulesEvaluated: number;
+    rulesSkipped: number;
+    exemptionsApplied: string[];
+}
+export interface ComplianceViolation {
+    ruleId: string;
+    ruleName: string;
+    policyId?: string | null;
+    field: string;
+    operator: string;
+    expectedValue: unknown;
+    actualValue: unknown;
+    severity: string;
+    message: string;
+}
+/**
+ * Compliance service client interface.
+ * Uses fail-closed design: errors propagate to block the operation.
+ */
+export interface ComplianceClient {
+    /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */
+    validatePlugin(orgId: string, attributes: Record<string, unknown>, authHeader: string, entityId?: string, entityName?: string, action?: string): Promise<ComplianceCheckResult>;
+    /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */
+    validatePipeline(orgId: string, attributes: Record<string, unknown>, authHeader: string, entityId?: string, entityName?: string, action?: string): Promise<ComplianceCheckResult>;
+    /** Pre-flight check for plugin (no audit, no notification). */
+    dryRunPlugin(orgId: string, attributes: Record<string, unknown>, authHeader: string): Promise<ComplianceCheckResult>;
+    /** Pre-flight check for pipeline (no audit, no notification). */
+    dryRunPipeline(orgId: string, attributes: Record<string, unknown>, authHeader: string): Promise<ComplianceCheckResult>;
+}
+/**
+ * Create a compliance client.
+ *
+ * IMPORTANT: This client is fail-closed — if the compliance service is
+ * unreachable or returns an error, the error propagates and the calling
+ * operation (plugin upload, pipeline create) is rejected.
+ */
+export declare function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient;

package/lib/services/compliance-client.js

@@ -0,0 +1,102 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComplianceClient = createComplianceClient;
+const http_client_1 = require("./http-client");
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)('compliance-client');
+/**
+ * When true, compliance checks are bypassed if the service is unavailable
+ * (fail-open). Default is fail-closed (errors propagate and block the operation).
+ */
+const COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';
+/**
+ * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the
+ * compliance service is unreachable.
+ */
+function bypassResult(context) {
+    logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);
+    return {
+        passed: true,
+        blocked: false,
+        violations: [],
+        warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],
+        rulesEvaluated: 0,
+        rulesSkipped: 0,
+        exemptionsApplied: [],
+    };
+}
+/**
+ * Build common request headers for compliance calls.
+ */
+function buildHeaders(orgId, authHeader) {
+    const headers = {
+        'x-org-id': orgId,
+        'x-internal-service': 'true',
+    };
+    if (authHeader)
+        headers.Authorization = authHeader;
+    return headers;
+}
+/**
+ * Create a compliance client.
+ *
+ * IMPORTANT: This client is fail-closed — if the compliance service is
+ * unreachable or returns an error, the error propagates and the calling
+ * operation (plugin upload, pipeline create) is rejected.
+ */
+function createComplianceClient(config) {
+    const serviceConfig = {
+        host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',
+        port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),
+    };
+    const client = new http_client_1.InternalHttpClient(serviceConfig);
+    return {
+        async validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {
+            try {
+                const response = await client.post('/compliance/validate/plugin', { attributes, entityId, entityName, action: action ?? 'upload' }, { headers: buildHeaders(orgId, authHeader) });
+                return response.body.data;
+            }
+            catch (error) {
+                if (COMPLIANCE_BYPASS)
+                    return bypassResult({ orgId, entityType: 'plugin', entityId, entityName });
+                throw error;
+            }
+        },
+        async validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {
+            try {
+                const response = await client.post('/compliance/validate/pipeline', { attributes, entityId, entityName, action: action ?? 'create' }, { headers: buildHeaders(orgId, authHeader) });
+                return response.body.data;
+            }
+            catch (error) {
+                if (COMPLIANCE_BYPASS)
+                    return bypassResult({ orgId, entityType: 'pipeline', entityId, entityName });
+                throw error;
+            }
+        },
+        async dryRunPlugin(orgId, attributes, authHeader) {
+            try {
+                const response = await client.post('/compliance/validate/plugin/dry-run', { attributes }, { headers: buildHeaders(orgId, authHeader) });
+                return response.body.data;
+            }
+            catch (error) {
+                if (COMPLIANCE_BYPASS)
+                    return bypassResult({ orgId, entityType: 'plugin', dryRun: true });
+                throw error;
+            }
+        },
+        async dryRunPipeline(orgId, attributes, authHeader) {
+            try {
+                const response = await client.post('/compliance/validate/pipeline/dry-run', { attributes }, { headers: buildHeaders(orgId, authHeader) });
+                return response.body.data;
+            }
+            catch (error) {
+                if (COMPLIANCE_BYPASS)
+                    return bypassResult({ orgId, entityType: 'pipeline', dryRun: true });
+                throw error;
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-client.js","sourceRoot":"","sources":["../../src/services/compliance-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { InternalHttpClient } from './http-client';\nimport { ServiceConfig } from '../types/common';\nimport { createLogger } from '../utils/logger';\n\nconst logger = createLogger('compliance-client');\n\n/**\n * When true, compliance checks are bypassed if the service is unavailable\n * (fail-open). Default is fail-closed (errors propagate and block the operation).\n */\nconst COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';\n\n/**\n * Result of a compliance validation check.\n */\nexport interface ComplianceCheckResult {\n  passed: boolean;\n  violations: ComplianceViolation[];\n  warnings: ComplianceViolation[];\n  blocked: boolean;\n  rulesEvaluated: number;\n  rulesSkipped: number;\n  exemptionsApplied: string[];\n}\n\nexport interface ComplianceViolation {\n  ruleId: string;\n  ruleName: string;\n  policyId?: string | null;\n  field: string;\n  operator: string;\n  expectedValue: unknown;\n  actualValue: unknown;\n  severity: string;\n  message: string;\n}\n\n/**\n * Compliance service client interface.\n * Uses fail-closed design: errors propagate to block the operation.\n */\nexport interface ComplianceClient {\n  /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */\n  validatePlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */\n  validatePipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for plugin (no audit, no notification). */\n  dryRunPlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for pipeline (no audit, no notification). */\n  dryRunPipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n}\n\n/**\n * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the\n * compliance service is unreachable.\n */\nfunction bypassResult(context: Record<string, unknown>): ComplianceCheckResult {\n  logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);\n  return {\n    passed: true,\n    blocked: false,\n    violations: [],\n    warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],\n    rulesEvaluated: 0,\n    rulesSkipped: 0,\n    exemptionsApplied: [],\n  };\n}\n\n/**\n * Build common request headers for compliance calls.\n */\nfunction buildHeaders(orgId: string, authHeader: string): Record<string, string> {\n  const headers: Record<string, string> = {\n    'x-org-id': orgId,\n    'x-internal-service': 'true',\n  };\n  if (authHeader) headers.Authorization = authHeader;\n  return headers;\n}\n\n/**\n * Create a compliance client.\n *\n * IMPORTANT: This client is fail-closed — if the compliance service is\n * unreachable or returns an error, the error propagates and the calling\n * operation (plugin upload, pipeline create) is rejected.\n */\nexport function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient {\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  return {\n    async validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult }>(\n          '/compliance/validate/plugin',\n          { attributes, entityId, entityName, action: action ?? 'upload' },\n          { headers: buildHeaders(orgId, authHeader) },\n        );\n        return response.body.data;\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'plugin', entityId, entityName });\n        throw error;\n      }\n    },\n\n    async validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult }>(\n          '/compliance/validate/pipeline',\n          { attributes, entityId, entityName, action: action ?? 'create' },\n          { headers: buildHeaders(orgId, authHeader) },\n        );\n        return response.body.data;\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'pipeline', entityId, entityName });\n        throw error;\n      }\n    },\n\n    async dryRunPlugin(orgId, attributes, authHeader) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult }>(\n          '/compliance/validate/plugin/dry-run',\n          { attributes },\n          { headers: buildHeaders(orgId, authHeader) },\n        );\n        return response.body.data;\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'plugin', dryRun: true });\n        throw error;\n      }\n    },\n\n    async dryRunPipeline(orgId, attributes, authHeader) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult }>(\n          '/compliance/validate/pipeline/dry-run',\n          { attributes },\n          { headers: buildHeaders(orgId, authHeader) },\n        );\n        return response.body.data;\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'pipeline', dryRun: true });\n        throw error;\n      }\n    },\n  };\n}\n"]}

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

@@ -0,0 +1,11 @@
+import { type ServiceConfig } from '../types/common';
+/**
+ * Registers an entity event subscriber that forwards events to the compliance service.
+ *
+ * Call this at service startup (in index.ts) to enable automatic compliance
+ * notification on entity mutations. Events are fire-and-forget — failures
+ * are logged but never block the original request.
+ *
+ * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)
+ */
+export declare function registerComplianceEventSubscriber(config?: Partial<ServiceConfig>): void;

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

@@ -0,0 +1,60 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerComplianceEventSubscriber = registerComplianceEventSubscriber;
+const compliance_queue_1 = require("./compliance-queue");
+const entity_events_1 = require("./entity-events");
+const http_client_1 = require("./http-client");
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)('compliance-events');
+/**
+ * Registers an entity event subscriber that forwards events to the compliance service.
+ *
+ * Call this at service startup (in index.ts) to enable automatic compliance
+ * notification on entity mutations. Events are fire-and-forget — failures
+ * are logged but never block the original request.
+ *
+ * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)
+ */
+function registerComplianceEventSubscriber(config) {
+    const serviceConfig = {
+        host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',
+        port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),
+    };
+    const client = new http_client_1.InternalHttpClient(serviceConfig);
+    const subscriber = {
+        async onEntityEvent(event) {
+            try {
+                await client.post('/compliance/events/entity', event, {
+                    headers: { 'x-internal-service': 'true' },
+                });
+            }
+            catch (err) {
+                // Fire-and-forget: log and swallow. Compliance notification is non-fatal.
+                logger.warn('Failed to notify compliance service of entity event', {
+                    target: event.target,
+                    eventType: event.eventType,
+                    entityId: event.entityId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            // Also enqueue for async re-validation (catches rule changes after creation)
+            void (0, compliance_queue_1.enqueueComplianceEvent)({
+                eventType: 'validate',
+                target: event.target,
+                entityId: event.entityId,
+                orgId: event.orgId,
+                userId: event.userId,
+                attributes: event.attributes,
+                timestamp: event.timestamp.toISOString(),
+            });
+        },
+    };
+    entity_events_1.entityEvents.subscribe(subscriber);
+    logger.info('Compliance event subscriber registered', {
+        host: serviceConfig.host,
+        port: serviceConfig.port,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,11 @@
+export interface ComplianceEvent {
+    eventType: 'validate' | 'scan' | 'notify';
+    target: 'plugin' | 'pipeline';
+    entityId: string;
+    orgId: string;
+    userId: string;
+    attributes: Record<string, unknown>;
+    timestamp: string;
+}
+export declare function registerComplianceQueueBackend(fn: (event: ComplianceEvent) => Promise<void>): void;
+export declare function enqueueComplianceEvent(event: ComplianceEvent): Promise<void>;