@pipeline-builder/api-server 3.1.0

package/lib/http/sse-connection-manager.js

@@ -0,0 +1,329 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEManager = void 0;
+const api_core_1 = require("@pipeline-builder/api-core");
+const pipeline_core_1 = require("@pipeline-builder/pipeline-core");
+const uuid_1 = require("uuid");
+const logger = (0, api_core_1.createLogger)('SSEManager');
+/**
+ * SSE helper class with memory leak protection
+ *
+ * Features:
+ * - Client limits per request ID
+ * - Automatic timeout for idle connections
+ * - Periodic cleanup of stale connections
+ * - Connection statistics
+ *
+ * @example
+ * ```typescript
+ * const sseManager = new SSEManager({ maxClientsPerRequest: 5 });
+ * app.get('/logs/:requestId', sseManager.middleware());
+ *
+ * // Send events
+ * sseManager.send('request-123', 'INFO', 'Processing...');
+ * ```
+ */
+class SSEManager {
+    clients = new Map();
+    maxClientsPerRequest;
+    clientTimeoutMs;
+    cleanupInterval = null;
+    constructor(options = {}) {
+        this.maxClientsPerRequest = options.maxClientsPerRequest ?? parseInt(process.env.SSE_MAX_CLIENTS_PER_REQUEST || '10', 10);
+        this.clientTimeoutMs = options.clientTimeoutMs ?? parseInt(process.env.SSE_CLIENT_TIMEOUT_MS || '1800000', 10); // 30 minutes
+        const cleanupIntervalMs = options.cleanupIntervalMs ?? parseInt(process.env.SSE_CLEANUP_INTERVAL_MS || '300000', 10); // 5 minutes
+        this.startCleanupInterval(cleanupIntervalMs);
+    }
+    /**
+     * Adds a client to the SSE manager
+     *
+     * @param requestId - Unique request ID
+     * @param res - Express Response object
+     * @returns true if client was added, false if rejected (limit reached)
+     */
+    addClient(requestId, res) {
+        const existing = this.clients.get(requestId) || [];
+        // Check client limit
+        if (existing.length >= this.maxClientsPerRequest) {
+            logger.warn(`Client limit reached for request ${requestId} (max: ${this.maxClientsPerRequest})`);
+            return false;
+        }
+        // Create timeout for this client
+        const clientId = (0, uuid_1.v7)();
+        const timeout = setTimeout(() => {
+            logger.debug(`Client ${clientId} timed out for request ${requestId}`);
+            this.removeClient(requestId, clientId);
+            try {
+                res.end();
+            }
+            catch (err) {
+                logger.debug('Response already closed on timeout', { requestId, clientId, error: err instanceof Error ? err.message : String(err) });
+            }
+        }, this.clientTimeoutMs);
+        const client = {
+            id: clientId,
+            res,
+            connectedAt: Date.now(),
+            timeout,
+            backpressureCount: 0,
+        };
+        // Handle disconnection
+        res.on('close', () => {
+            clearTimeout(timeout);
+            this.removeClient(requestId, clientId);
+        });
+        res.on('error', (err) => {
+            logger.error(`SSE client error for request ${requestId}:`, err);
+            clearTimeout(timeout);
+            this.removeClient(requestId, clientId);
+        });
+        existing.push(client);
+        this.clients.set(requestId, existing);
+        logger.debug(`Client ${clientId} connected for request ${requestId} (total: ${existing.length})`);
+        return true;
+    }
+    /**
+     * Removes a client from the manager
+     */
+    removeClient(requestId, clientId) {
+        const clients = this.clients.get(requestId);
+        if (!clients)
+            return;
+        const remaining = clients.filter(c => {
+            if (c.id === clientId) {
+                clearTimeout(c.timeout);
+                return false;
+            }
+            return true;
+        });
+        if (remaining.length === 0) {
+            this.clients.delete(requestId);
+            logger.debug(`All clients disconnected for request ${requestId}`);
+        }
+        else {
+            this.clients.set(requestId, remaining);
+        }
+    }
+    /**
+     * Sends a message to all SSE clients for a requestId
+     *
+     * @param requestId - Request ID
+     * @param type - Event type
+     * @param message - Message string
+     * @param data - Optional additional data
+     * @returns Number of clients the message was sent to
+     */
+    send(requestId, type, message, data) {
+        const payload = {
+            ts: new Date().toISOString(),
+            type,
+            message,
+            data,
+        };
+        const clients = [...(this.clients.get(requestId) || [])];
+        let sentCount = 0;
+        const serialized = `data: ${JSON.stringify(payload)}\n\n`;
+        for (const client of clients) {
+            try {
+                // Backpressure: skip clients whose write buffer is full
+                if (client.res.writableEnded) {
+                    this.removeClient(requestId, client.id);
+                    continue;
+                }
+                const canWrite = client.res.write(serialized);
+                if (!canWrite) {
+                    client.backpressureCount++;
+                    // Disconnect clients that consistently can't keep up (10 consecutive backpressure events)
+                    if (client.backpressureCount >= pipeline_core_1.CoreConstants.SSE_BACKPRESSURE_THRESHOLD) {
+                        logger.warn(`Disconnecting slow client ${client.id} for request ${requestId} (${client.backpressureCount} backpressure events)`);
+                        this.removeClient(requestId, client.id);
+                        try {
+                            client.res.end();
+                        }
+                        catch { /* already closed */ }
+                        continue;
+                    }
+                }
+                else {
+                    client.backpressureCount = 0; // Reset on successful write
+                }
+                sentCount++;
+            }
+            catch (error) {
+                logger.error(`Failed to send to client ${client.id}:`, error);
+                this.removeClient(requestId, client.id);
+            }
+        }
+        return sentCount;
+    }
+    /**
+     * Broadcast a message to all connected clients across all requests
+     *
+     * @param type - Event type
+     * @param message - Message string
+     * @param data - Optional additional data
+     * @returns Total number of clients the message was sent to
+     */
+    broadcast(type, message, data) {
+        let totalSent = 0;
+        for (const requestId of this.clients.keys()) {
+            totalSent += this.send(requestId, type, message, data);
+        }
+        return totalSent;
+    }
+    /**
+     * Close all clients for a specific request
+     *
+     * @param requestId - Request ID to close
+     * @param finalMessage - Optional final message to send before closing
+     */
+    closeRequest(requestId, finalMessage) {
+        const clients = this.clients.get(requestId);
+        if (!clients)
+            return;
+        if (finalMessage) {
+            this.send(requestId, 'COMPLETED', finalMessage);
+        }
+        for (const client of clients) {
+            clearTimeout(client.timeout);
+            try {
+                client.res.end();
+            }
+            catch (err) {
+                logger.debug('Response already closed on request close', { requestId, clientId: client.id, error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+        this.clients.delete(requestId);
+        logger.debug(`Closed all clients for request ${requestId}`);
+    }
+    /**
+     * Get statistics about current connections
+     */
+    getStats() {
+        let totalClients = 0;
+        let oldestConnection = null;
+        const now = Date.now();
+        for (const clients of this.clients.values()) {
+            totalClients += clients.length;
+            for (const client of clients) {
+                const age = now - client.connectedAt;
+                if (oldestConnection === null || age > oldestConnection) {
+                    oldestConnection = age;
+                }
+            }
+        }
+        return {
+            totalRequests: this.clients.size,
+            totalClients,
+            oldestConnectionMs: oldestConnection,
+        };
+    }
+    /**
+     * Check if a request has any connected clients
+     */
+    hasClients(requestId) {
+        const clients = this.clients.get(requestId);
+        return clients !== undefined && clients.length > 0;
+    }
+    /**
+     * Get the number of clients for a specific request
+     */
+    getClientCount(requestId) {
+        return this.clients.get(requestId)?.length ?? 0;
+    }
+    /**
+     * Middleware to initialize SSE connection
+     *
+     * @example
+     * ```typescript
+     * app.get('/logs/:requestId', sseManager.middleware());
+     * ```
+     */
+    middleware() {
+        const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        return (req, res) => {
+            const { requestId } = req.params;
+            if (!UUID_RE.test(requestId)) {
+                res.status(400).end('Invalid requestId format');
+                return;
+            }
+            // Check client limit BEFORE flushing headers, so we can still send 429
+            const existing = this.clients.get(requestId) || [];
+            if (existing.length >= this.maxClientsPerRequest) {
+                logger.warn(`Client limit reached for request ${requestId} (max: ${this.maxClientsPerRequest})`);
+                res.status(429).end('Too many connections for this request');
+                return;
+            }
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            res.setHeader('X-Accel-Buffering', 'no'); // Disable nginx buffering
+            res.flushHeaders();
+            this.addClient(requestId, res);
+        };
+    }
+    /**
+     * Start periodic cleanup of stale connections
+     */
+    startCleanupInterval(intervalMs) {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, intervalMs);
+        // Don't prevent process exit
+        this.cleanupInterval.unref();
+    }
+    /**
+     * Clean up stale connections using single-pass partition.
+     * O(R × C) instead of O(R × C²), and avoids mutation-during-iteration.
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [requestId, clients] of this.clients.entries()) {
+            const stale = [];
+            const active = [];
+            for (const client of clients) {
+                if (now - client.connectedAt > this.clientTimeoutMs) {
+                    stale.push(client);
+                }
+                else {
+                    active.push(client);
+                }
+            }
+            for (const client of stale) {
+                clearTimeout(client.timeout);
+                try {
+                    client.res.end();
+                }
+                catch { /* already closed */ }
+                cleaned++;
+            }
+            if (active.length === 0) {
+                this.clients.delete(requestId);
+            }
+            else if (stale.length > 0) {
+                this.clients.set(requestId, active);
+            }
+        }
+        if (cleaned > 0) {
+            logger.info(`Cleaned up ${cleaned} stale SSE connections`);
+        }
+    }
+    /**
+     * Shutdown the SSE manager and close all connections
+     */
+    shutdown() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        for (const requestId of [...this.clients.keys()]) {
+            this.closeRequest(requestId, 'Server shutting down');
+        }
+        logger.info('SSE Manager shut down');
+    }
+}
+exports.SSEManager = SSEManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-connection-manager.js","sourceRoot":"","sources":["../../src/http/sse-connection-manager.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport { Response } from 'express';\nimport { v7 as uuid } from 'uuid';\n\nconst logger = createLogger('SSEManager');\n\n/**\n * Event types for SSE logging\n */\nexport type SSEEventType = 'INFO' | 'WARN' | 'ERROR' | 'COMPLETED' | 'ROLLBACK' | 'MESSAGE';\n\n/**\n * SSE payload structure\n */\nexport interface SSEPayload {\n  ts: string;\n  type: SSEEventType;\n  message: string;\n  data?: unknown;\n}\n\n/**\n * SSE client with connection tracking\n */\nexport interface SSEClient {\n  id: string;\n  res: Response;\n  connectedAt: number;\n  timeout: NodeJS.Timeout;\n  /** Number of consecutive backpressure events (write returned false). */\n  backpressureCount: number;\n}\n\n/**\n * SSE Manager configuration options\n */\nexport interface SSEManagerOptions {\n  /** Maximum clients allowed per request ID (default: 10) */\n  maxClientsPerRequest?: number;\n  /** Client timeout in milliseconds (default: 30 minutes) */\n  clientTimeoutMs?: number;\n  /** Interval for cleanup checks in milliseconds (default: 5 minutes) */\n  cleanupIntervalMs?: number;\n}\n\n/**\n * SSE Manager statistics\n */\nexport interface SSEManagerStats {\n  totalRequests: number;\n  totalClients: number;\n  oldestConnectionMs: number | null;\n}\n\n/**\n * SSE helper class with memory leak protection\n *\n * Features:\n * - Client limits per request ID\n * - Automatic timeout for idle connections\n * - Periodic cleanup of stale connections\n * - Connection statistics\n *\n * @example\n * ```typescript\n * const sseManager = new SSEManager({ maxClientsPerRequest: 5 });\n * app.get('/logs/:requestId', sseManager.middleware());\n *\n * // Send events\n * sseManager.send('request-123', 'INFO', 'Processing...');\n * ```\n */\nexport class SSEManager {\n  private clients = new Map<string, SSEClient[]>();\n  private readonly maxClientsPerRequest: number;\n  private readonly clientTimeoutMs: number;\n  private cleanupInterval: NodeJS.Timeout | null = null;\n\n  constructor(options: SSEManagerOptions = {}) {\n    this.maxClientsPerRequest = options.maxClientsPerRequest ?? parseInt(process.env.SSE_MAX_CLIENTS_PER_REQUEST || '10', 10);\n    this.clientTimeoutMs = options.clientTimeoutMs ?? parseInt(process.env.SSE_CLIENT_TIMEOUT_MS || '1800000', 10); // 30 minutes\n\n    const cleanupIntervalMs = options.cleanupIntervalMs ?? parseInt(process.env.SSE_CLEANUP_INTERVAL_MS || '300000', 10); // 5 minutes\n    this.startCleanupInterval(cleanupIntervalMs);\n  }\n\n  /**\n   * Adds a client to the SSE manager\n   *\n   * @param requestId - Unique request ID\n   * @param res - Express Response object\n   * @returns true if client was added, false if rejected (limit reached)\n   */\n  addClient(requestId: string, res: Response): boolean {\n    const existing = this.clients.get(requestId) || [];\n\n    // Check client limit\n    if (existing.length >= this.maxClientsPerRequest) {\n      logger.warn(`Client limit reached for request ${requestId} (max: ${this.maxClientsPerRequest})`);\n      return false;\n    }\n\n    // Create timeout for this client\n    const clientId = uuid();\n    const timeout = setTimeout(() => {\n      logger.debug(`Client ${clientId} timed out for request ${requestId}`);\n      this.removeClient(requestId, clientId);\n      try {\n        res.end();\n      } catch (err) {\n        logger.debug('Response already closed on timeout', { requestId, clientId, error: err instanceof Error ? err.message : String(err) });\n      }\n    }, this.clientTimeoutMs);\n\n    const client: SSEClient = {\n      id: clientId,\n      res,\n      connectedAt: Date.now(),\n      timeout,\n      backpressureCount: 0,\n    };\n\n    // Handle disconnection\n    res.on('close', () => {\n      clearTimeout(timeout);\n      this.removeClient(requestId, clientId);\n    });\n\n    res.on('error', (err) => {\n      logger.error(`SSE client error for request ${requestId}:`, err);\n      clearTimeout(timeout);\n      this.removeClient(requestId, clientId);\n    });\n\n    existing.push(client);\n    this.clients.set(requestId, existing);\n\n    logger.debug(`Client ${clientId} connected for request ${requestId} (total: ${existing.length})`);\n    return true;\n  }\n\n  /**\n   * Removes a client from the manager\n   */\n  private removeClient(requestId: string, clientId: string): void {\n    const clients = this.clients.get(requestId);\n    if (!clients) return;\n\n    const remaining = clients.filter(c => {\n      if (c.id === clientId) {\n        clearTimeout(c.timeout);\n        return false;\n      }\n      return true;\n    });\n\n    if (remaining.length === 0) {\n      this.clients.delete(requestId);\n      logger.debug(`All clients disconnected for request ${requestId}`);\n    } else {\n      this.clients.set(requestId, remaining);\n    }\n  }\n\n  /**\n   * Sends a message to all SSE clients for a requestId\n   *\n   * @param requestId - Request ID\n   * @param type - Event type\n   * @param message - Message string\n   * @param data - Optional additional data\n   * @returns Number of clients the message was sent to\n   */\n  send(requestId: string, type: SSEEventType, message: string, data?: unknown): number {\n    const payload: SSEPayload = {\n      ts: new Date().toISOString(),\n      type,\n      message,\n      data,\n    };\n\n    const clients = [...(this.clients.get(requestId) || [])];\n    let sentCount = 0;\n    const serialized = `data: ${JSON.stringify(payload)}\\n\\n`;\n\n    for (const client of clients) {\n      try {\n        // Backpressure: skip clients whose write buffer is full\n        if (client.res.writableEnded) {\n          this.removeClient(requestId, client.id);\n          continue;\n        }\n        const canWrite = client.res.write(serialized);\n        if (!canWrite) {\n          client.backpressureCount++;\n          // Disconnect clients that consistently can't keep up (10 consecutive backpressure events)\n          if (client.backpressureCount >= CoreConstants.SSE_BACKPRESSURE_THRESHOLD) {\n            logger.warn(`Disconnecting slow client ${client.id} for request ${requestId} (${client.backpressureCount} backpressure events)`);\n            this.removeClient(requestId, client.id);\n            try { client.res.end(); } catch { /* already closed */ }\n            continue;\n          }\n        } else {\n          client.backpressureCount = 0; // Reset on successful write\n        }\n        sentCount++;\n      } catch (error) {\n        logger.error(`Failed to send to client ${client.id}:`, error);\n        this.removeClient(requestId, client.id);\n      }\n    }\n\n    return sentCount;\n  }\n\n  /**\n   * Broadcast a message to all connected clients across all requests\n   *\n   * @param type - Event type\n   * @param message - Message string\n   * @param data - Optional additional data\n   * @returns Total number of clients the message was sent to\n   */\n  broadcast(type: SSEEventType, message: string, data?: unknown): number {\n    let totalSent = 0;\n    for (const requestId of this.clients.keys()) {\n      totalSent += this.send(requestId, type, message, data);\n    }\n    return totalSent;\n  }\n\n  /**\n   * Close all clients for a specific request\n   *\n   * @param requestId - Request ID to close\n   * @param finalMessage - Optional final message to send before closing\n   */\n  closeRequest(requestId: string, finalMessage?: string): void {\n    const clients = this.clients.get(requestId);\n    if (!clients) return;\n\n    if (finalMessage) {\n      this.send(requestId, 'COMPLETED', finalMessage);\n    }\n\n    for (const client of clients) {\n      clearTimeout(client.timeout);\n      try {\n        client.res.end();\n      } catch (err) {\n        logger.debug('Response already closed on request close', { requestId, clientId: client.id, error: err instanceof Error ? err.message : String(err) });\n      }\n    }\n\n    this.clients.delete(requestId);\n    logger.debug(`Closed all clients for request ${requestId}`);\n  }\n\n  /**\n   * Get statistics about current connections\n   */\n  getStats(): SSEManagerStats {\n    let totalClients = 0;\n    let oldestConnection: number | null = null;\n    const now = Date.now();\n\n    for (const clients of this.clients.values()) {\n      totalClients += clients.length;\n      for (const client of clients) {\n        const age = now - client.connectedAt;\n        if (oldestConnection === null || age > oldestConnection) {\n          oldestConnection = age;\n        }\n      }\n    }\n\n    return {\n      totalRequests: this.clients.size,\n      totalClients,\n      oldestConnectionMs: oldestConnection,\n    };\n  }\n\n  /**\n   * Check if a request has any connected clients\n   */\n  hasClients(requestId: string): boolean {\n    const clients = this.clients.get(requestId);\n    return clients !== undefined && clients.length > 0;\n  }\n\n  /**\n   * Get the number of clients for a specific request\n   */\n  getClientCount(requestId: string): number {\n    return this.clients.get(requestId)?.length ?? 0;\n  }\n\n  /**\n   * Middleware to initialize SSE connection\n   *\n   * @example\n   * ```typescript\n   * app.get('/logs/:requestId', sseManager.middleware());\n   * ```\n   */\n  middleware() {\n    const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n    return (req: { params: { requestId: string } }, res: Response) => {\n      const { requestId } = req.params;\n\n      if (!UUID_RE.test(requestId)) {\n        res.status(400).end('Invalid requestId format');\n        return;\n      }\n\n      // Check client limit BEFORE flushing headers, so we can still send 429\n      const existing = this.clients.get(requestId) || [];\n      if (existing.length >= this.maxClientsPerRequest) {\n        logger.warn(`Client limit reached for request ${requestId} (max: ${this.maxClientsPerRequest})`);\n        res.status(429).end('Too many connections for this request');\n        return;\n      }\n\n      res.setHeader('Content-Type', 'text/event-stream');\n      res.setHeader('Cache-Control', 'no-cache');\n      res.setHeader('Connection', 'keep-alive');\n      res.setHeader('X-Accel-Buffering', 'no'); // Disable nginx buffering\n      res.flushHeaders();\n\n      this.addClient(requestId, res);\n    };\n  }\n\n  /**\n   * Start periodic cleanup of stale connections\n   */\n  private startCleanupInterval(intervalMs: number): void {\n    this.cleanupInterval = setInterval(() => {\n      this.cleanup();\n    }, intervalMs);\n\n    // Don't prevent process exit\n    this.cleanupInterval.unref();\n  }\n\n  /**\n   * Clean up stale connections using single-pass partition.\n   * O(R × C) instead of O(R × C²), and avoids mutation-during-iteration.\n   */\n  private cleanup(): void {\n    const now = Date.now();\n    let cleaned = 0;\n\n    for (const [requestId, clients] of this.clients.entries()) {\n      const stale: SSEClient[] = [];\n      const active: SSEClient[] = [];\n\n      for (const client of clients) {\n        if (now - client.connectedAt > this.clientTimeoutMs) {\n          stale.push(client);\n        } else {\n          active.push(client);\n        }\n      }\n\n      for (const client of stale) {\n        clearTimeout(client.timeout);\n        try { client.res.end(); } catch { /* already closed */ }\n        cleaned++;\n      }\n\n      if (active.length === 0) {\n        this.clients.delete(requestId);\n      } else if (stale.length > 0) {\n        this.clients.set(requestId, active);\n      }\n    }\n\n    if (cleaned > 0) {\n      logger.info(`Cleaned up ${cleaned} stale SSE connections`);\n    }\n  }\n\n  /**\n   * Shutdown the SSE manager and close all connections\n   */\n  shutdown(): void {\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n      this.cleanupInterval = null;\n    }\n\n    for (const requestId of [...this.clients.keys()]) {\n      this.closeRequest(requestId, 'Server shutting down');\n    }\n\n    logger.info('SSE Manager shut down');\n  }\n}\n"]}

package/lib/http/ws-manager.d.ts

@@ -0,0 +1,37 @@
+export interface WSClient {
+    id: string;
+    orgId: string;
+    send(data: string): void;
+    close(): void;
+}
+type MessageHandler = (client: WSClient, message: Record<string, unknown>) => void;
+/**
+ * WebSocket connection manager.
+ * Manages authenticated WebSocket connections per org.
+ * Works alongside SSE for backward compatibility.
+ *
+ * Requires a WebSocket library (ws) to be wired in at server startup.
+ * This module provides the management layer only.
+ */
+export declare class WSManager {
+    private clients;
+    private handlers;
+    private maxClientsPerOrg;
+    constructor(options?: {
+        maxClientsPerOrg?: number;
+    });
+    addClient(client: WSClient): boolean;
+    removeClient(client: WSClient): void;
+    onMessage(type: string, handler: MessageHandler): void;
+    handleMessage(client: WSClient, raw: string): void;
+    sendToOrg(orgId: string, type: string, data: unknown): number;
+    broadcast(type: string, data: unknown): number;
+    getStats(): {
+        orgs: number;
+        clients: number;
+    };
+}
+export declare function createWSManager(options?: {
+    maxClientsPerOrg?: number;
+}): WSManager;
+export {};

package/lib/http/ws-manager.js

@@ -0,0 +1,105 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSManager = void 0;
+exports.createWSManager = createWSManager;
+const api_core_1 = require("@pipeline-builder/api-core");
+const logger = (0, api_core_1.createLogger)('ws-manager');
+/**
+ * WebSocket connection manager.
+ * Manages authenticated WebSocket connections per org.
+ * Works alongside SSE for backward compatibility.
+ *
+ * Requires a WebSocket library (ws) to be wired in at server startup.
+ * This module provides the management layer only.
+ */
+class WSManager {
+    clients = new Map();
+    handlers = new Map();
+    maxClientsPerOrg;
+    constructor(options = {}) {
+        this.maxClientsPerOrg = options.maxClientsPerOrg ?? 50;
+    }
+    addClient(client) {
+        if (!this.clients.has(client.orgId)) {
+            this.clients.set(client.orgId, new Set());
+        }
+        const orgClients = this.clients.get(client.orgId);
+        if (orgClients.size >= this.maxClientsPerOrg) {
+            logger.warn('Max WebSocket clients reached for org', { orgId: client.orgId });
+            return false;
+        }
+        orgClients.add(client);
+        logger.debug('WebSocket client connected', { orgId: client.orgId, clientId: client.id, total: orgClients.size });
+        return true;
+    }
+    removeClient(client) {
+        const orgClients = this.clients.get(client.orgId);
+        if (orgClients) {
+            orgClients.delete(client);
+            if (orgClients.size === 0)
+                this.clients.delete(client.orgId);
+        }
+    }
+    onMessage(type, handler) {
+        this.handlers.set(type, handler);
+    }
+    handleMessage(client, raw) {
+        try {
+            const msg = JSON.parse(raw);
+            if (!msg.type)
+                return;
+            const handler = this.handlers.get(msg.type);
+            if (handler)
+                handler(client, msg);
+        }
+        catch {
+            logger.debug('Invalid WebSocket message', { clientId: client.id });
+        }
+    }
+    sendToOrg(orgId, type, data) {
+        const orgClients = this.clients.get(orgId);
+        if (!orgClients)
+            return 0;
+        const payload = JSON.stringify({ type, data, ts: new Date().toISOString() });
+        let sent = 0;
+        for (const client of orgClients) {
+            try {
+                client.send(payload);
+                sent++;
+            }
+            catch {
+                this.removeClient(client);
+            }
+        }
+        return sent;
+    }
+    broadcast(type, data) {
+        const payload = JSON.stringify({ type, data, ts: new Date().toISOString() });
+        let sent = 0;
+        for (const [, orgClients] of this.clients) {
+            for (const client of orgClients) {
+                try {
+                    client.send(payload);
+                    sent++;
+                }
+                catch {
+                    this.removeClient(client);
+                }
+            }
+        }
+        return sent;
+    }
+    getStats() {
+        let clients = 0;
+        for (const [, orgClients] of this.clients)
+            clients += orgClients.size;
+        return { orgs: this.clients.size, clients };
+    }
+}
+exports.WSManager = WSManager;
+function createWSManager(options) {
+    return new WSManager(options);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ws-manager.js","sourceRoot":"","sources":["../../src/http/ws-manager.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\n\nconst logger = createLogger('ws-manager');\n\nexport interface WSClient {\n  id: string;\n  orgId: string;\n  send(data: string): void;\n  close(): void;\n}\n\ntype MessageHandler = (client: WSClient, message: Record<string, unknown>) => void;\n\n/**\n * WebSocket connection manager.\n * Manages authenticated WebSocket connections per org.\n * Works alongside SSE for backward compatibility.\n *\n * Requires a WebSocket library (ws) to be wired in at server startup.\n * This module provides the management layer only.\n */\nexport class WSManager {\n  private clients = new Map<string, Set<WSClient>>();\n  private handlers = new Map<string, MessageHandler>();\n  private maxClientsPerOrg: number;\n\n  constructor(options: { maxClientsPerOrg?: number } = {}) {\n    this.maxClientsPerOrg = options.maxClientsPerOrg ?? 50;\n  }\n\n  addClient(client: WSClient): boolean {\n    if (!this.clients.has(client.orgId)) {\n      this.clients.set(client.orgId, new Set());\n    }\n    const orgClients = this.clients.get(client.orgId)!;\n    if (orgClients.size >= this.maxClientsPerOrg) {\n      logger.warn('Max WebSocket clients reached for org', { orgId: client.orgId });\n      return false;\n    }\n    orgClients.add(client);\n    logger.debug('WebSocket client connected', { orgId: client.orgId, clientId: client.id, total: orgClients.size });\n    return true;\n  }\n\n  removeClient(client: WSClient): void {\n    const orgClients = this.clients.get(client.orgId);\n    if (orgClients) {\n      orgClients.delete(client);\n      if (orgClients.size === 0) this.clients.delete(client.orgId);\n    }\n  }\n\n  onMessage(type: string, handler: MessageHandler): void {\n    this.handlers.set(type, handler);\n  }\n\n  handleMessage(client: WSClient, raw: string): void {\n    try {\n      const msg = JSON.parse(raw) as { type?: string; [key: string]: unknown };\n      if (!msg.type) return;\n      const handler = this.handlers.get(msg.type);\n      if (handler) handler(client, msg);\n    } catch {\n      logger.debug('Invalid WebSocket message', { clientId: client.id });\n    }\n  }\n\n  sendToOrg(orgId: string, type: string, data: unknown): number {\n    const orgClients = this.clients.get(orgId);\n    if (!orgClients) return 0;\n    const payload = JSON.stringify({ type, data, ts: new Date().toISOString() });\n    let sent = 0;\n    for (const client of orgClients) {\n      try { client.send(payload); sent++; } catch { this.removeClient(client); }\n    }\n    return sent;\n  }\n\n  broadcast(type: string, data: unknown): number {\n    const payload = JSON.stringify({ type, data, ts: new Date().toISOString() });\n    let sent = 0;\n    for (const [, orgClients] of this.clients) {\n      for (const client of orgClients) {\n        try { client.send(payload); sent++; } catch { this.removeClient(client); }\n      }\n    }\n    return sent;\n  }\n\n  getStats(): { orgs: number; clients: number } {\n    let clients = 0;\n    for (const [, orgClients] of this.clients) clients += orgClients.size;\n    return { orgs: this.clients.size, clients };\n  }\n}\n\nexport function createWSManager(options?: { maxClientsPerOrg?: number }): WSManager {\n  return new WSManager(options);\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module @pipeline-builder/api-server
+ *
+ * Express server infrastructure and request lifecycle utilities.
+ *
+ * **App Factory**
+ * - createApp — creates a configured Express app with CORS, Helmet, rate limiting
+ * - runServer, startServer — server lifecycle with graceful shutdown
+ *
+ * **Middleware**
+ * - attachRequestContext / createRequestContext — attaches identity + logging to each request
+ * - requireOrgId — validates organization ID is present on the request
+ * - checkQuota — quota enforcement middleware
+ * - etagMiddleware — ETag-based conditional response support
+ * - idempotencyMiddleware — idempotent request handling
+ * - middlewareFactory — composable middleware builder
+ *
+ * **Route Helpers**
+ * - withRoute — wraps async route handlers with context extraction, orgId validation, and error handling
+ * - getContext — retrieves RequestContext from the Express request
+ * - RouteContext, RequestContext — route and request context types
+ *
+ * **SSE**
+ * - SSEManager — Server-Sent Events connection manager
+ *
+ * **Observability**
+ * - Tracing and metrics collection utilities
+ */
+export * from './api';
+export * from './http';

package/lib/index.js

@@ -0,0 +1,51 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @module @pipeline-builder/api-server
+ *
+ * Express server infrastructure and request lifecycle utilities.
+ *
+ * **App Factory**
+ * - createApp — creates a configured Express app with CORS, Helmet, rate limiting
+ * - runServer, startServer — server lifecycle with graceful shutdown
+ *
+ * **Middleware**
+ * - attachRequestContext / createRequestContext — attaches identity + logging to each request
+ * - requireOrgId — validates organization ID is present on the request
+ * - checkQuota — quota enforcement middleware
+ * - etagMiddleware — ETag-based conditional response support
+ * - idempotencyMiddleware — idempotent request handling
+ * - middlewareFactory — composable middleware builder
+ *
+ * **Route Helpers**
+ * - withRoute — wraps async route handlers with context extraction, orgId validation, and error handling
+ * - getContext — retrieves RequestContext from the Express request
+ * - RouteContext, RequestContext — route and request context types
+ *
+ * **SSE**
+ * - SSEManager — Server-Sent Events connection manager
+ *
+ * **Observability**
+ * - Tracing and metrics collection utilities
+ */
+// API Infrastructure
+__exportStar(require("./api"), exports);
+// HTTP Utilities
+__exportStar(require("./http"), exports);
+//# sourceMappingURL=data:application/json;base64,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