@pipeline-builder/api-server 3.1.0

package/lib/api/server.js

@@ -0,0 +1,144 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+exports.runServer = runServer;
+const api_core_1 = require("@pipeline-builder/api-core");
+const pipeline_core_1 = require("@pipeline-builder/pipeline-core");
+const tracing_1 = require("./tracing");
+const logger = (0, api_core_1.createLogger)('Server');
+/**
+ * Start an Express server with graceful shutdown handling
+ *
+ * Features:
+ * - Automatic database connection testing
+ * - Graceful shutdown on SIGINT/SIGTERM
+ * - SSE connection cleanup
+ * - Configurable shutdown timeout
+ *
+ * @param app - Express application
+ * @param options - Server options
+ * @returns Server instance and control functions
+ *
+ * @example
+ * ```typescript
+ * const { app, sseManager } = createApp();
+ *
+ * app.post('/api/resource', requireAuth, handler);
+ *
+ * await startServer(app, {
+ *   name: 'My Microservice',
+ *   sseManager,
+ *   onStart: (port) => console.log(`Listening on ${port}`),
+ * });
+ * ```
+ */
+async function startServer(app, options = {}) {
+    const serverConfig = pipeline_core_1.Config.get('server');
+    const { name = 'Microservice', sseManager, shutdownTimeoutMs = 15000, onStart, onShutdown, onBeforeStart, testDatabase, closeDatabase, } = options;
+    const port = options.port ?? serverConfig.port;
+    // Validate auth configuration at server startup (not during CDK synthesis)
+    pipeline_core_1.Config.validateAuth();
+    logger.info(`Starting ${name}...`);
+    // Pre-start hook (e.g., initialize external connections)
+    if (onBeforeStart) {
+        await onBeforeStart();
+    }
+    // Test database connection
+    if (testDatabase !== false) {
+        const dbHealthy = testDatabase
+            ? await testDatabase()
+            : await (0, pipeline_core_1.getConnection)().testConnection();
+        if (!dbHealthy) {
+            throw new Error('Database connection failed');
+        }
+        logger.info('Database connection established');
+    }
+    // Start server
+    const server = app.listen(port, () => {
+        logger.info(`${name} listening on port: ${port}`);
+        logger.info(`Platform URL: ${serverConfig.platformUrl}`);
+        onStart?.(port);
+    });
+    // Shutdown handler (guarded against concurrent signals)
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        if (signal) {
+            logger.info(`${signal} received, shutting down gracefully...`);
+        }
+        // Custom shutdown callback
+        if (onShutdown) {
+            try {
+                await onShutdown();
+            }
+            catch (error) {
+                logger.error('Error in onShutdown callback', { error });
+            }
+        }
+        // Close SSE connections
+        if (sseManager) {
+            sseManager.shutdown();
+            logger.info('SSE connections closed');
+        }
+        // Close HTTP server
+        server.close(async () => {
+            logger.info('HTTP server closed');
+            // Shutdown OpenTelemetry tracing
+            await (0, tracing_1.shutdownTracing)().catch(err => logger.error('Error shutting down tracing', { error: err }));
+            // Close database connection
+            if (closeDatabase !== false) {
+                try {
+                    if (closeDatabase) {
+                        await closeDatabase();
+                    }
+                    else {
+                        await (0, pipeline_core_1.closeConnection)();
+                    }
+                    logger.info('Database connection closed');
+                }
+                catch (error) {
+                    logger.error('Error closing database', { error });
+                }
+            }
+            process.exit(0);
+        });
+        // Force shutdown after timeout
+        setTimeout(() => {
+            logger.error('Forced shutdown after timeout');
+            process.exit(1);
+        }, shutdownTimeoutMs).unref();
+    };
+    // Register signal handlers
+    process.once('SIGINT', () => void shutdown('SIGINT'));
+    process.once('SIGTERM', () => void shutdown('SIGTERM'));
+    return {
+        server,
+        port,
+        shutdown: () => shutdown(),
+    };
+}
+/**
+ * Simple server start wrapper with error handling
+ *
+ * @param app - Express application
+ * @param options - Server options
+ *
+ * @example
+ * ```typescript
+ * const { app, sseManager } = createApp();
+ * app.post('/api/resource', handler);
+ *
+ * void runServer(app, { name: 'My Service', sseManager });
+ * ```
+ */
+function runServer(app, options = {}) {
+    startServer(app, options).catch((error) => {
+        logger.error('Failed to start server', { error });
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { Config, getConnection, closeConnection } from '@pipeline-builder/pipeline-core';\nimport { Express } from 'express';\nimport { shutdownTracing } from './tracing';\nimport { SSEManager } from '../http/sse-connection-manager';\n\nconst logger = createLogger('Server');\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n\n  logger.info(`Starting ${name}...`);\n\n  // Pre-start hook (e.g., initialize external connections)\n  if (onBeforeStart) {\n    await onBeforeStart();\n  }\n\n  // Test database connection\n  if (testDatabase !== false) {\n    const dbHealthy = testDatabase\n      ? await testDatabase()\n      : await getConnection().testConnection();\n\n    if (!dbHealthy) {\n      throw new Error('Database connection failed');\n    }\n\n    logger.info('Database connection established');\n  }\n\n  // Start server\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n\n    // Force shutdown after timeout\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  startServer(app, options).catch((error) => {\n    logger.error('Failed to start server', { error });\n    process.exit(1);\n  });\n}\n"]}

package/lib/api/tracing.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Initialize OpenTelemetry tracing with OTLP HTTP exporter.
+ * Configured via `Config.get('observability').tracing`.
+ *
+ * @example
+ * ```typescript
+ * import { initTracing } from '@pipeline-builder/api-server';
+ * initTracing('pipeline-service');
+ * ```
+ */
+export declare function initTracing(serviceName: string): void;
+/**
+ * Shutdown the OpenTelemetry SDK gracefully.
+ */
+export declare function shutdownTracing(): Promise<void>;

package/lib/api/tracing.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTracing = initTracing;
+exports.shutdownTracing = shutdownTracing;
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const api_core_1 = require("@pipeline-builder/api-core");
+const pipeline_core_1 = require("@pipeline-builder/pipeline-core");
+const logger = (0, api_core_1.createLogger)('Tracing');
+let sdk = null;
+/**
+ * Initialize OpenTelemetry tracing with OTLP HTTP exporter.
+ * Configured via `Config.get('observability').tracing`.
+ *
+ * @example
+ * ```typescript
+ * import { initTracing } from '@pipeline-builder/api-server';
+ * initTracing('pipeline-service');
+ * ```
+ */
+function initTracing(serviceName) {
+    const { tracing } = pipeline_core_1.Config.getAny('observability');
+    if (!tracing.enabled) {
+        logger.debug('OpenTelemetry tracing disabled (set OTEL_TRACING_ENABLED=true to enable)');
+        return;
+    }
+    if (sdk) {
+        logger.debug('OpenTelemetry already initialized');
+        return;
+    }
+    const exporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+        url: tracing.endpoint,
+    });
+    sdk = new sdk_node_1.NodeSDK({
+        resource: (0, resources_1.resourceFromAttributes)({ 'service.name': serviceName }),
+        traceExporter: exporter,
+    });
+    sdk.start();
+    logger.info(`OpenTelemetry tracing initialized for ${serviceName}`);
+}
+/**
+ * Shutdown the OpenTelemetry SDK gracefully.
+ */
+async function shutdownTracing() {
+    if (sdk) {
+        await sdk.shutdown();
+        sdk = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sse-connection-manager';
+export * from './ws-manager';

package/lib/http/index.js

@@ -0,0 +1,21 @@
+"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 });
+__exportStar(require("./sse-connection-manager"), exports);
+__exportStar(require("./ws-manager"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaHR0cC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0NBQStDO0FBQy9DLHNDQUFzQzs7Ozs7Ozs7Ozs7Ozs7OztBQUV0QywyREFBeUM7QUFDekMsK0NBQTZCIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vc3NlLWNvbm5lY3Rpb24tbWFuYWdlcic7XG5leHBvcnQgKiBmcm9tICcuL3dzLW1hbmFnZXInO1xuIl19

package/lib/http/sse-connection-manager.d.ts

@@ -0,0 +1,145 @@
+import { Response } from 'express';
+/**
+ * Event types for SSE logging
+ */
+export type SSEEventType = 'INFO' | 'WARN' | 'ERROR' | 'COMPLETED' | 'ROLLBACK' | 'MESSAGE';
+/**
+ * SSE payload structure
+ */
+export interface SSEPayload {
+    ts: string;
+    type: SSEEventType;
+    message: string;
+    data?: unknown;
+}
+/**
+ * SSE client with connection tracking
+ */
+export interface SSEClient {
+    id: string;
+    res: Response;
+    connectedAt: number;
+    timeout: NodeJS.Timeout;
+    /** Number of consecutive backpressure events (write returned false). */
+    backpressureCount: number;
+}
+/**
+ * SSE Manager configuration options
+ */
+export interface SSEManagerOptions {
+    /** Maximum clients allowed per request ID (default: 10) */
+    maxClientsPerRequest?: number;
+    /** Client timeout in milliseconds (default: 30 minutes) */
+    clientTimeoutMs?: number;
+    /** Interval for cleanup checks in milliseconds (default: 5 minutes) */
+    cleanupIntervalMs?: number;
+}
+/**
+ * SSE Manager statistics
+ */
+export interface SSEManagerStats {
+    totalRequests: number;
+    totalClients: number;
+    oldestConnectionMs: number | null;
+}
+/**
+ * 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...');
+ * ```
+ */
+export declare class SSEManager {
+    private clients;
+    private readonly maxClientsPerRequest;
+    private readonly clientTimeoutMs;
+    private cleanupInterval;
+    constructor(options?: SSEManagerOptions);
+    /**
+     * 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: string, res: Response): boolean;
+    /**
+     * Removes a client from the manager
+     */
+    private removeClient;
+    /**
+     * 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: string, type: SSEEventType, message: string, data?: unknown): number;
+    /**
+     * 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: SSEEventType, message: string, data?: unknown): number;
+    /**
+     * Close all clients for a specific request
+     *
+     * @param requestId - Request ID to close
+     * @param finalMessage - Optional final message to send before closing
+     */
+    closeRequest(requestId: string, finalMessage?: string): void;
+    /**
+     * Get statistics about current connections
+     */
+    getStats(): SSEManagerStats;
+    /**
+     * Check if a request has any connected clients
+     */
+    hasClients(requestId: string): boolean;
+    /**
+     * Get the number of clients for a specific request
+     */
+    getClientCount(requestId: string): number;
+    /**
+     * Middleware to initialize SSE connection
+     *
+     * @example
+     * ```typescript
+     * app.get('/logs/:requestId', sseManager.middleware());
+     * ```
+     */
+    middleware(): (req: {
+        params: {
+            requestId: string;
+        };
+    }, res: Response) => void;
+    /**
+     * Start periodic cleanup of stale connections
+     */
+    private startCleanupInterval;
+    /**
+     * Clean up stale connections using single-pass partition.
+     * O(R × C) instead of O(R × C²), and avoids mutation-during-iteration.
+     */
+    private cleanup;
+    /**
+     * Shutdown the SSE manager and close all connections
+     */
+    shutdown(): void;
+}