@pipeline-builder/api-server 3.4.129 → 3.4.131

package/lib/http/sse-ticket-store.js

@@ -0,0 +1,160 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createLogger, createEnvRedisClient } from '@pipeline-builder/api-core';
+const logger = createLogger('sse-ticket-store');
+/**
+ * In-memory ticket store — the default. Correct for a single replica only;
+ * mirrors the behavior the SSEManager previously implemented inline.
+ */
+export function createMemoryTicketStore() {
+    const tickets = new Map();
+    const owners = new Map();
+    return {
+        async put(ticketId, record, ttlMs) {
+            tickets.set(ticketId, { ...record, expiresAt: Date.now() + ttlMs });
+        },
+        async consume(ticketId) {
+            const t = tickets.get(ticketId);
+            tickets.delete(ticketId); // single-use — remove whether or not valid
+            if (!t || Date.now() > t.expiresAt)
+                return null;
+            return { orgId: t.orgId, requestId: t.requestId };
+        },
+        async countForOrg(orgId) {
+            const now = Date.now();
+            let n = 0;
+            for (const t of tickets.values())
+                if (t.orgId === orgId && t.expiresAt > now)
+                    n++;
+            return n;
+        },
+        async total() {
+            const now = Date.now();
+            let n = 0;
+            for (const t of tickets.values())
+                if (t.expiresAt > now)
+                    n++;
+            return n;
+        },
+        async bindStreamOwner(requestId, orgId, ttlMs) {
+            owners.set(requestId, { orgId, expiresAt: Date.now() + ttlMs });
+        },
+        async getStreamOwner(requestId) {
+            const o = owners.get(requestId);
+            if (!o)
+                return null;
+            if (Date.now() > o.expiresAt) {
+                owners.delete(requestId);
+                return null;
+            }
+            return o.orgId;
+        },
+        async sweep() {
+            const now = Date.now();
+            for (const [id, t] of tickets)
+                if (now > t.expiresAt)
+                    tickets.delete(id);
+            for (const [id, o] of owners)
+                if (now > o.expiresAt)
+                    owners.delete(id);
+        },
+    };
+}
+const TICKET_PREFIX = 'sse:tkt:';
+const ORG_ZSET_PREFIX = 'sse:tkt:org:';
+const ALL_ZSET = 'sse:tkt:all';
+const OWNER_PREFIX = 'sse:owner:';
+/**
+ * Redis-backed ticket store — required for multi-pod correctness. Tickets are
+ * per-key with native TTL; cap counters are ZSETs scored by expiry (pruned on
+ * read). Stream ownership is a per-subject key with its own TTL. All reads are
+ * fail-safe (null / 0) so a Redis blip never wedges the stream.
+ */
+export function createRedisTicketStore(redis) {
+    const tkey = (id) => `${TICKET_PREFIX}${id}`;
+    const orgKey = (orgId) => `${ORG_ZSET_PREFIX}${orgId}`;
+    const ownerKey = (requestId) => `${OWNER_PREFIX}${requestId}`;
+    const ttlSec = (ttlMs) => Math.max(1, Math.ceil(ttlMs / 1000));
+    return {
+        async put(ticketId, record, ttlMs) {
+            const expiresAt = Date.now() + ttlMs;
+            const sec = ttlSec(ttlMs);
+            try {
+                await redis.set(tkey(ticketId), JSON.stringify(record), 'EX', sec);
+                // Track for the caps. Score = expiry so pruning is a range delete.
+                await redis.zadd(orgKey(record.orgId), expiresAt, ticketId);
+                await redis.zadd(ALL_ZSET, expiresAt, ticketId);
+                // Bound the per-org ZSET's own lifetime so an idle org's key can't leak.
+                await redis.expire(orgKey(record.orgId), sec);
+            }
+            catch (err) {
+                logger.warn('SSE ticket put failed', { error: err instanceof Error ? err.message : String(err) });
+            }
+        },
+        async consume(ticketId) {
+            try {
+                const raw = await redis.get(tkey(ticketId));
+                // Single-use: delete regardless. A concurrent double-redeem: at most one
+                // saw a non-null value before the delete; the ZREM cleans the counters.
+                await redis.del(tkey(ticketId));
+                if (!raw)
+                    return null;
+                const rec = JSON.parse(raw);
+                await redis.zrem(orgKey(rec.orgId), ticketId);
+                await redis.zrem(ALL_ZSET, ticketId);
+                return rec;
+            }
+            catch (err) {
+                logger.warn('SSE ticket consume failed', { error: err instanceof Error ? err.message : String(err) });
+                return null;
+            }
+        },
+        async countForOrg(orgId) {
+            try {
+                await redis.zremrangebyscore(orgKey(orgId), 0, Date.now());
+                return await redis.zcard(orgKey(orgId));
+            }
+            catch {
+                return 0;
+            }
+        },
+        async total() {
+            try {
+                await redis.zremrangebyscore(ALL_ZSET, 0, Date.now());
+                return await redis.zcard(ALL_ZSET);
+            }
+            catch {
+                return 0;
+            }
+        },
+        async bindStreamOwner(requestId, orgId, ttlMs) {
+            try {
+                await redis.set(ownerKey(requestId), orgId, 'EX', ttlSec(ttlMs));
+            }
+            catch (err) {
+                logger.warn('SSE stream-owner bind failed', { error: err instanceof Error ? err.message : String(err) });
+            }
+        },
+        async getStreamOwner(requestId) {
+            try {
+                return await redis.get(ownerKey(requestId));
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+/**
+ * Build a Redis-backed ticket store from the shared env Redis (same wiring as
+ * the rate-limiter / audit-spool). Returns null when Redis isn't configured so
+ * the caller keeps the in-memory default. Never throws.
+ */
+export function createEnvRedisTicketStore() {
+    const client = createEnvRedisClient('sse-ticket');
+    if (!client)
+        return null;
+    logger.info('Redis SSE ticket store initialized');
+    return createRedisTicketStore(client);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-store.js","sourceRoot":"","sources":["../../src/http/sse-ticket-store.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger, createEnvRedisClient } from '@pipeline-builder/api-core';\n\nconst logger = createLogger('sse-ticket-store');\n\n/** A minted ticket's bound identity: owning org + normalized stream subject. */\nexport interface SSETicketRecord {\n  orgId: string;\n  /** Normalized (dashes stripped, lowercased) stream subject id. */\n  requestId: string;\n}\n\n/**\n * Pluggable backend for SSE log-stream tickets AND stream-ownership.\n *\n * Two concerns share one store because both must be consistent across pods:\n * - **Tickets** — short-lived, single-use, bound to (org, subject). The default\n *   in-memory store is correct only single-replica; the Redis store makes the\n *   mint (one pod) / redeem (another pod) exchange work behind a load balancer.\n * - **Stream ownership** — which org OWNS a given stream subject. The stream\n *   producer (platform, a different service) records this so ticket minting can\n *   assert the caller's org owns the subject, closing the cross-tenant attach\n *   gap where any org could mint a ticket for a guessed requestId.\n *\n * All methods are async (Redis is async) and best-effort on the failure side per\n * their doc — a store outage must degrade gracefully, never crash the stream.\n */\nexport interface SSETicketStore {\n  /** Persist a single-use ticket bound to `record`, expiring after `ttlMs`. */\n  put(ticketId: string, record: SSETicketRecord, ttlMs: number): Promise<void>;\n  /** Atomically fetch-and-delete a ticket (single-use). Null if absent/expired. */\n  consume(ticketId: string): Promise<SSETicketRecord | null>;\n  /** Count of live (unexpired) tickets held for an org (per-org cap). */\n  countForOrg(orgId: string): Promise<number>;\n  /** Count of all live tickets across the store (capacity cap). */\n  total(): Promise<number>;\n  /** Record the org that OWNS a stream subject (producer-side), TTL `ttlMs`. */\n  bindStreamOwner(requestId: string, orgId: string, ttlMs: number): Promise<void>;\n  /** The owning org of a stream subject, or null when none is bound. */\n  getStreamOwner(requestId: string): Promise<string | null>;\n  /** Optional hygiene sweep of expired entries (Redis TTL makes this a no-op). */\n  sweep?(): Promise<void>;\n}\n\ninterface StoredTicket extends SSETicketRecord {\n  expiresAt: number;\n}\n\ninterface StoredOwner {\n  orgId: string;\n  expiresAt: number;\n}\n\n/**\n * In-memory ticket store — the default. Correct for a single replica only;\n * mirrors the behavior the SSEManager previously implemented inline.\n */\nexport function createMemoryTicketStore(): SSETicketStore {\n  const tickets = new Map<string, StoredTicket>();\n  const owners = new Map<string, StoredOwner>();\n\n  return {\n    async put(ticketId, record, ttlMs) {\n      tickets.set(ticketId, { ...record, expiresAt: Date.now() + ttlMs });\n    },\n    async consume(ticketId) {\n      const t = tickets.get(ticketId);\n      tickets.delete(ticketId); // single-use — remove whether or not valid\n      if (!t || Date.now() > t.expiresAt) return null;\n      return { orgId: t.orgId, requestId: t.requestId };\n    },\n    async countForOrg(orgId) {\n      const now = Date.now();\n      let n = 0;\n      for (const t of tickets.values()) if (t.orgId === orgId && t.expiresAt > now) n++;\n      return n;\n    },\n    async total() {\n      const now = Date.now();\n      let n = 0;\n      for (const t of tickets.values()) if (t.expiresAt > now) n++;\n      return n;\n    },\n    async bindStreamOwner(requestId, orgId, ttlMs) {\n      owners.set(requestId, { orgId, expiresAt: Date.now() + ttlMs });\n    },\n    async getStreamOwner(requestId) {\n      const o = owners.get(requestId);\n      if (!o) return null;\n      if (Date.now() > o.expiresAt) { owners.delete(requestId); return null; }\n      return o.orgId;\n    },\n    async sweep() {\n      const now = Date.now();\n      for (const [id, t] of tickets) if (now > t.expiresAt) tickets.delete(id);\n      for (const [id, o] of owners) if (now > o.expiresAt) owners.delete(id);\n    },\n  };\n}\n\n/**\n * Minimal ioredis surface the Redis ticket store needs. `set` takes the variadic\n * option tail (`EX <s>`); `zadd`/`zremrangebyscore`/`zcard` back the cap counters.\n */\nexport interface RedisTicketClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: (string | number)[]): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  zadd(key: string, score: number, member: string): Promise<number>;\n  zrem(key: string, ...members: string[]): Promise<number>;\n  zcard(key: string): Promise<number>;\n  zremrangebyscore(key: string, min: number | string, max: number | string): Promise<number>;\n  expire(key: string, seconds: number): Promise<number>;\n}\n\nconst TICKET_PREFIX = 'sse:tkt:';\nconst ORG_ZSET_PREFIX = 'sse:tkt:org:';\nconst ALL_ZSET = 'sse:tkt:all';\nconst OWNER_PREFIX = 'sse:owner:';\n\n/**\n * Redis-backed ticket store — required for multi-pod correctness. Tickets are\n * per-key with native TTL; cap counters are ZSETs scored by expiry (pruned on\n * read). Stream ownership is a per-subject key with its own TTL. All reads are\n * fail-safe (null / 0) so a Redis blip never wedges the stream.\n */\nexport function createRedisTicketStore(redis: RedisTicketClient): SSETicketStore {\n  const tkey = (id: string): string => `${TICKET_PREFIX}${id}`;\n  const orgKey = (orgId: string): string => `${ORG_ZSET_PREFIX}${orgId}`;\n  const ownerKey = (requestId: string): string => `${OWNER_PREFIX}${requestId}`;\n  const ttlSec = (ttlMs: number): number => Math.max(1, Math.ceil(ttlMs / 1000));\n\n  return {\n    async put(ticketId, record, ttlMs) {\n      const expiresAt = Date.now() + ttlMs;\n      const sec = ttlSec(ttlMs);\n      try {\n        await redis.set(tkey(ticketId), JSON.stringify(record), 'EX', sec);\n        // Track for the caps. Score = expiry so pruning is a range delete.\n        await redis.zadd(orgKey(record.orgId), expiresAt, ticketId);\n        await redis.zadd(ALL_ZSET, expiresAt, ticketId);\n        // Bound the per-org ZSET's own lifetime so an idle org's key can't leak.\n        await redis.expire(orgKey(record.orgId), sec);\n      } catch (err) {\n        logger.warn('SSE ticket put failed', { error: err instanceof Error ? err.message : String(err) });\n      }\n    },\n    async consume(ticketId) {\n      try {\n        const raw = await redis.get(tkey(ticketId));\n        // Single-use: delete regardless. A concurrent double-redeem: at most one\n        // saw a non-null value before the delete; the ZREM cleans the counters.\n        await redis.del(tkey(ticketId));\n        if (!raw) return null;\n        const rec = JSON.parse(raw) as SSETicketRecord;\n        await redis.zrem(orgKey(rec.orgId), ticketId);\n        await redis.zrem(ALL_ZSET, ticketId);\n        return rec;\n      } catch (err) {\n        logger.warn('SSE ticket consume failed', { error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n    async countForOrg(orgId) {\n      try {\n        await redis.zremrangebyscore(orgKey(orgId), 0, Date.now());\n        return await redis.zcard(orgKey(orgId));\n      } catch { return 0; }\n    },\n    async total() {\n      try {\n        await redis.zremrangebyscore(ALL_ZSET, 0, Date.now());\n        return await redis.zcard(ALL_ZSET);\n      } catch { return 0; }\n    },\n    async bindStreamOwner(requestId, orgId, ttlMs) {\n      try {\n        await redis.set(ownerKey(requestId), orgId, 'EX', ttlSec(ttlMs));\n      } catch (err) {\n        logger.warn('SSE stream-owner bind failed', { error: err instanceof Error ? err.message : String(err) });\n      }\n    },\n    async getStreamOwner(requestId) {\n      try {\n        return await redis.get(ownerKey(requestId));\n      } catch { return null; }\n    },\n  };\n}\n\n/**\n * Build a Redis-backed ticket store from the shared env Redis (same wiring as\n * the rate-limiter / audit-spool). Returns null when Redis isn't configured so\n * the caller keeps the in-memory default. Never throws.\n */\nexport function createEnvRedisTicketStore(): SSETicketStore | null {\n  const client = createEnvRedisClient<RedisTicketClient>('sse-ticket');\n  if (!client) return null;\n  logger.info('Redis SSE ticket store initialized');\n  return createRedisTicketStore(client);\n}\n"]}

package/package.json

@@ -44,9 +44,9 @@
     "rate-limit-redis": "6.0.0",
     "swagger-ui-express": "5.0.1",
     "uuid": "14.0.1",
-    "@pipeline-builder/pipeline-core": "3.4.123",
-    "@pipeline-builder/api-core": "3.4.105",
-    "@pipeline-builder/pipeline-data": "3.4.109"
+    "@pipeline-builder/api-core": "3.4.106",
+    "@pipeline-builder/pipeline-core": "3.4.125",
+    "@pipeline-builder/pipeline-data": "3.4.111"
   },
   "keywords": [
     "ci-cd",
@@ -102,7 +102,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.129",
+  "version": "3.4.131",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },