@ioka-technologies/asyncapi-ts-client-template 0.0.35 → 0.0.41

package/template/src/runtime/transports/websocket.ts.js

@@ -11,7 +11,7 @@ export default function ({ asyncapi, params }) {
     return (
         <File name="websocket.ts">
             {`import { v4 as uuidv4 } from 'uuid';
-import { Transport, TransportConfig, RequestOptions, ResponseHandler, MessageEnvelope, EnvelopeCallback } from '../types';
+import { Transport, TransportConfig, RequestOptions, ResponseHandler, MessageEnvelope, EnvelopeCallback, ReconnectConfig } from '../types';
 import { TransportError, ConnectionError, TimeoutError } from '../errors';
 import { generateAuthHeaders, generateAuthQueryParams, hasAuthCredentials, AuthError, UnauthorizedError, AuthCredentials } from '../auth';
 import { createRetryManager, getRetryConfig } from '../retry';
@@ -54,74 +54,212 @@ export class WebSocketTransport implements Transport {
     private subscriptions: Map<string, Set<EnvelopeCallback>> = new Map();
     private operationSubscriptions: Map<string, Set<(payload: any) => void>> = new Map();
     private channelOperations: Map<string, string> = new Map(); // Track operation for each channel
+
+    // Reconnect state
+    private intentionalDisconnect = false;
+    private _isConnected = false;
     private reconnectAttempts = 0;
-    private maxReconnectAttempts = 5;
-    private reconnectDelay = 1000;
+    private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+    private connectPromise: Promise<void> | null = null;
+    private pendingConnectionReject: ((error: Error) => void) | null = null;
+    private connectionGeneration = 0;
+    private hasConnectedSuccessfully = false;
+    private reconnectConfig: Required<ReconnectConfig>;
+
+    // Event listener registries (for application-layer listeners beyond config callbacks)
+    private reconnectedListeners = new Set<() => void>();
+    private disconnectedListeners = new Set<(reason: string) => void>();
 
     constructor(config: TransportConfig) {
         this.config = config;
+        this.reconnectConfig = {
+            enabled: config.reconnect?.enabled ?? true,
+            maxAttempts: config.reconnect?.maxAttempts ?? 0, // 0 = unlimited
+            baseDelay: config.reconnect?.baseDelay ?? 1000,
+            maxDelay: config.reconnect?.maxDelay ?? 30000,
+            backoffMultiplier: config.reconnect?.backoffMultiplier ?? 2,
+            jitter: config.reconnect?.jitter ?? true,
+        };
         // WebSocketImpl will be set during connect()
     }
 
-    async connect(): Promise<void> {
+    /**
+     * Check if the transport is currently connected
+     */
+    isConnected(): boolean {
+        return this._isConnected && this.ws !== null && this.ws.readyState === this.ws.OPEN;
+    }
+
+    /**
+     * Register a callback for when the transport reconnects after a disconnect.
+     * Returns an unsubscribe function.
+     */
+    onReconnected(callback: () => void): () => void {
+        this.reconnectedListeners.add(callback);
+        return () => { this.reconnectedListeners.delete(callback); };
+    }
+
+    /**
+     * Register a callback for when the transport disconnects unexpectedly.
+     * Returns an unsubscribe function.
+     */
+    onDisconnected(callback: (reason: string) => void): () => void {
+        this.disconnectedListeners.add(callback);
+        return () => { this.disconnectedListeners.delete(callback); };
+    }
+
+    connect(): Promise<void> {
+        if (this.isConnected()) return Promise.resolve();
+        if (this.connectPromise) return this.connectPromise;
+        this.intentionalDisconnect = false;
+        this.connectPromise = this.createConnection().finally(() => {
+            this.connectPromise = null;
+            if (!this.isConnected()) this.attemptReconnect();
+        });
+        return this.connectPromise;
+    }
+
+    private async createConnection(): Promise<void> {
         if (!this.WebSocketImpl) {
             this.WebSocketImpl = await getWebSocketImpl();
         }
 
         return new Promise((resolve, reject) => {
+            let settled = false;
+            this.pendingConnectionReject = reject;
+            const generation = ++this.connectionGeneration;
+            const fail = (error: Error): void => {
+                if (!settled) { settled = true; reject(error); }
+                this.pendingConnectionReject = null;
+            };
             try {
-                this.ws = new this.WebSocketImpl(this.config.url) as WebSocketLike;
+                const socket = new this.WebSocketImpl(this.config.url) as WebSocketLike;
+                this.ws = socket;
+                const isCurrent = (): boolean => generation === this.connectionGeneration && this.ws === socket;
 
                 // Handle both browser and Node.js WebSocket APIs
-                if (typeof window !== 'undefined' && this.ws.addEventListener) {
+                if (typeof window !== 'undefined' && socket.addEventListener) {
                     // Browser WebSocket API
-                    this.ws.addEventListener('open', () => {
+                    socket.addEventListener('open', () => {
+                        if (!isCurrent()) return;
+                        settled = true;
+                        this.pendingConnectionReject = null;
+                        const wasReconnect = this.hasConnectedSuccessfully;
+                        this.hasConnectedSuccessfully = true;
                         this.reconnectAttempts = 0;
+                        this._isConnected = true;
+                        if (wasReconnect) {
+                            this.config.connectionCallbacks?.onReconnected?.();
+                            this.reconnectedListeners.forEach(cb => cb());
+                            this.resubscribeAll();
+                        } else {
+                            this.config.connectionCallbacks?.onConnected?.();
+                        }
                         resolve();
                     });
 
-                    this.ws.addEventListener('message', (event: MessageEvent) => {
-                        this.handleMessage(event.data);
+                    socket.addEventListener('message', (event: MessageEvent) => {
+                        if (isCurrent()) this.handleMessage(event.data);
                     });
 
-                    this.ws.addEventListener('close', () => {
+                    socket.addEventListener('close', () => {
+                        if (!isCurrent()) return;
+                        this._isConnected = false;
+                        this.ws = null;
+                        fail(new ConnectionError('WebSocket connection closed'));
                         this.handleDisconnect();
                     });
 
-                    this.ws.addEventListener('error', (event: Event) => {
-                        reject(new ConnectionError(\`WebSocket connection failed: \${event.type}\`));
+                    socket.addEventListener('error', (event: Event) => {
+                        if (!isCurrent()) return;
+                        if (!this._isConnected) {
+                            // Error during initial connection
+                            fail(new ConnectionError(\`WebSocket connection failed: \${event.type}\`));
+                        } else {
+                            // Error on established connection — handleDisconnect will be called by 'close'
+                            console.error('WebSocket error on established connection:', event);
+                            this.config.connectionCallbacks?.onError?.(
+                                new ConnectionError('WebSocket error')
+                            );
+                        }
                     });
-                } else if (this.ws.on) {
+                } else if (socket.on) {
                     // Node.js ws library API
-                    this.ws.on('open', () => {
+                    socket.on('open', () => {
+                        if (!isCurrent()) return;
+                        settled = true;
+                        this.pendingConnectionReject = null;
+                        const wasReconnect = this.hasConnectedSuccessfully;
+                        this.hasConnectedSuccessfully = true;
                         this.reconnectAttempts = 0;
+                        this._isConnected = true;
+                        if (wasReconnect) {
+                            this.config.connectionCallbacks?.onReconnected?.();
+                            this.reconnectedListeners.forEach(cb => cb());
+                            this.resubscribeAll();
+                        } else {
+                            this.config.connectionCallbacks?.onConnected?.();
+                        }
                         resolve();
                     });
 
-                    this.ws.on('message', (data: any) => {
-                        this.handleMessage(data.toString());
+                    socket.on('message', (data: any) => {
+                        if (isCurrent()) this.handleMessage(data.toString());
                     });
 
-                    this.ws.on('close', () => {
+                    socket.on('close', () => {
+                        if (!isCurrent()) return;
+                        this._isConnected = false;
+                        this.ws = null;
+                        fail(new ConnectionError('WebSocket connection closed'));
                         this.handleDisconnect();
                     });
 
-                    this.ws.on('error', (error: any) => {
-                        reject(new ConnectionError(\`WebSocket connection failed: \${error.message}\`));
+                    socket.on('error', (error: any) => {
+                        if (!isCurrent()) return;
+                        if (!this._isConnected) {
+                            // Error during initial connection
+                            fail(new ConnectionError(\`WebSocket connection failed: \${error.message}\`));
+                        } else {
+                            // Error on established connection — handleDisconnect will be called by 'close'
+                            console.error('WebSocket error on established connection:', error);
+                            this.config.connectionCallbacks?.onError?.(
+                                new ConnectionError(\`WebSocket error: \${error.message}\`)
+                            );
+                        }
                     });
                 } else {
-                    reject(new ConnectionError('WebSocket implementation does not support required event handling'));
+                    fail(new ConnectionError('WebSocket implementation does not support required event handling'));
                 }
             } catch (error: any) {
-                reject(new ConnectionError(\`Failed to create WebSocket: \${error.message}\`));
+                fail(new ConnectionError(\`Failed to create WebSocket: \${error.message}\`));
             }
         });
     }
 
     async disconnect(): Promise<void> {
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
+        this.intentionalDisconnect = true;
+        this._isConnected = false;
+
+        // Cancel any pending reconnect timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+
+        this.connectionGeneration++;
+        if (this.pendingConnectionReject) {
+            this.pendingConnectionReject(new ConnectionError('Connection closed intentionally'));
+            this.pendingConnectionReject = null;
+        }
+
+        // Reject all pending requests
+        this.rejectPendingRequests('Connection closed intentionally');
+
+        const socket = this.ws;
+        this.ws = null;
+        if (socket) {
+            socket.close();
         }
     }
 
@@ -203,7 +341,7 @@ export class WebSocketTransport implements Transport {
             const authHeaders = this.config.auth ? generateAuthHeaders(this.config.auth) : {};
 
             const subscribeEnvelope: MessageEnvelope = {
-                operation: operation,  // ✅ Use the actual operation name
+                operation: operation,  // Use the actual operation name
                 channel,
                 payload: { channel, operation },
                 timestamp: new Date().toISOString(),
@@ -244,7 +382,7 @@ export class WebSocketTransport implements Transport {
      * This provides operation-based filtering on the client side
      */
     subscribeToOperation(channel: string, operation: string, callback: (payload: any) => void): () => void {
-        const operationKey = \`\${channel}:\${operation}\`;
+        const operationKey = \`\${channel}::\${operation}\`;
 
         if (!this.operationSubscriptions.has(operationKey)) {
             this.operationSubscriptions.set(operationKey, new Set());
@@ -265,7 +403,9 @@ export class WebSocketTransport implements Transport {
                 // Generate auth headers if credentials are available
                 const authHeaders = this.config.auth ? generateAuthHeaders(this.config.auth) : {};
 
+                const requestId = uuidv4();
                 const subscribeEnvelope: MessageEnvelope = {
+                    id: requestId,
                     operation: operation,
                     channel,
                     payload: { channel, operation },
@@ -293,7 +433,7 @@ export class WebSocketTransport implements Transport {
             return;
         }
 
-        const operationKey = \`\${envelope.channel}:\${envelope.operation}\`;
+        const operationKey = \`\${envelope.channel}::\${envelope.operation}\`;
         const operationCallbacks = this.operationSubscriptions.get(operationKey);
 
         if (operationCallbacks) {
@@ -359,36 +499,130 @@ export class WebSocketTransport implements Transport {
     }
 
     private handleDisconnect(): void {
-        if (this.reconnectAttempts < this.maxReconnectAttempts) {
-            this.reconnectAttempts++;
-            setTimeout(() => {
-                this.connect().then(() => {
-                    // Re-subscribe to all channels after reconnection
-                    this.resubscribeAll();
-                }).catch(() => {
-                    // Failed to reconnect
-                });
-            }, this.reconnectDelay * this.reconnectAttempts);
+        const wasConnected = this._isConnected;
+        this._isConnected = false;
+
+        // Reject all pending request/response handlers immediately
+        this.rejectPendingRequests('WebSocket connection lost');
+
+        // Don't reconnect if this was intentional
+        if (this.intentionalDisconnect) return;
+
+        // Notify listeners of unexpected disconnect
+        const reason = 'WebSocket connection lost unexpectedly';
+        this.config.connectionCallbacks?.onDisconnected?.(reason);
+        this.disconnectedListeners.forEach(cb => {
+            try { cb(reason); } catch (e) { console.error('Error in disconnect listener:', e); }
+        });
+
+        // Start reconnection if enabled
+        if (!this.reconnectConfig.enabled) {
+            return;
+        }
+
+        this.attemptReconnect();
+    }
+
+    private attemptReconnect(): void {
+        if (this.intentionalDisconnect || this.reconnectTimer || this.connectPromise) {
+            return;
+        }
+        // Check if we've exceeded max attempts (0 = unlimited)
+        if (this.reconnectConfig.maxAttempts > 0 &&
+            this.reconnectAttempts >= this.reconnectConfig.maxAttempts) {
+            console.error(\`WebSocket reconnect failed after \${this.reconnectAttempts} attempts\`);
+            this.config.connectionCallbacks?.onReconnectFailed?.(this.reconnectAttempts);
+            return;
         }
+
+        this.reconnectAttempts++;
+        const delay = this.calculateReconnectDelay(this.reconnectAttempts);
+
+        console.log(\`WebSocket reconnecting in \${delay}ms (attempt \${this.reconnectAttempts})\`);
+        this.config.connectionCallbacks?.onReconnecting?.(this.reconnectAttempts, delay);
+
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            try {
+                // Reset the intentional disconnect flag before reconnecting
+                this.intentionalDisconnect = false;
+                await this.connect();
+
+            } catch (error) {
+                // Try again
+                this.attemptReconnect();
+            }
+        }, delay);
+    }
+
+    private calculateReconnectDelay(attempt: number): number {
+        let delay = this.reconnectConfig.baseDelay *
+            Math.pow(this.reconnectConfig.backoffMultiplier, attempt - 1);
+
+        // Cap at max delay
+        delay = Math.min(delay, this.reconnectConfig.maxDelay);
+
+        // Add jitter
+        if (this.reconnectConfig.jitter) {
+            delay = delay * (0.5 + Math.random() * 0.5);
+        }
+
+        return Math.floor(delay);
+    }
+
+    private rejectPendingRequests(reason: string): void {
+        for (const [requestId, handler] of this.responseHandlers) {
+            handler.reject(new ConnectionError(reason));
+        }
+        this.responseHandlers.clear();
     }
 
     private resubscribeAll(): void {
-        if (this.ws && this.ws.readyState === this.ws.OPEN) {
-            // Generate auth headers if credentials are available
-            const authHeaders = this.config.auth ? generateAuthHeaders(this.config.auth) : {};
+        if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
+            return;
+        }
 
-            for (const channel of this.subscriptions.keys()) {
-                const operation = this.channelOperations.get(channel);
-                if (operation) {
-                    const subscribeEnvelope: MessageEnvelope = {
-                        operation: operation,
-                        channel,
-                        payload: { channel, operation },
-                        timestamp: new Date().toISOString(),
-                        headers: authHeaders
-                    };
-                    this.ws.send(JSON.stringify(subscribeEnvelope));
-                }
+        const authHeaders = this.config.auth ? generateAuthHeaders(this.config.auth) : {};
+
+        // Collect all unique channel+operation pairs that need resubscription
+        const subscriptionsToRestore = new Set<string>();
+
+        // From channel-based subscriptions
+        for (const channel of this.subscriptions.keys()) {
+            const operation = this.channelOperations.get(channel);
+            if (operation) {
+                subscriptionsToRestore.add(\`\${channel}::\${operation}\`);
+            }
+        }
+
+        // From operation-based subscriptions (these may have additional operations
+        // on channels already tracked above)
+        for (const operationKey of this.operationSubscriptions.keys()) {
+            // operationKey format is "channel::operation"
+            const separatorIndex = operationKey.indexOf('::');
+            if (separatorIndex !== -1) {
+                subscriptionsToRestore.add(operationKey);
+            }
+        }
+
+        // Send subscribe messages for all unique channel+operation pairs
+        for (const key of subscriptionsToRestore) {
+            const separatorIndex = key.indexOf('::');
+            const channel = key.substring(0, separatorIndex);
+            const operation = key.substring(separatorIndex + 2);
+            try {
+                const subscribeEnvelope: MessageEnvelope = {
+                    id: uuidv4(),
+                    operation: operation,
+                    channel: channel,
+                    payload: { channel, operation },
+                    timestamp: new Date().toISOString(),
+                    headers: authHeaders
+                };
+                this.ws.send(JSON.stringify(subscribeEnvelope));
+                console.log(\`Resubscribed to \${channel} (operation: \${operation})\`);
+            } catch (error) {
+                console.error(\`Failed to resubscribe to \${channel}:\`, error);
             }
         }
     }

package/template/src/runtime/types.ts.js

@@ -23,6 +23,47 @@ export interface MessageEnvelope {
     };
 }
 
+/**
+ * Connection lifecycle event callbacks
+ */
+export interface ConnectionEventCallbacks {
+    /** Called when the WebSocket connection is established (including reconnections) */
+    onConnected?: () => void;
+
+    /** Called when the WebSocket connection is lost unexpectedly */
+    onDisconnected?: (reason: string) => void;
+
+    /** Called when a reconnection attempt starts */
+    onReconnecting?: (attempt: number, delay: number) => void;
+
+    /** Called when reconnection succeeds after a disconnection */
+    onReconnected?: () => void;
+
+    /** Called when all reconnection attempts are exhausted (if a limit is set) */
+    onReconnectFailed?: (attempts: number) => void;
+
+    /** Called on any WebSocket error */
+    onError?: (error: Error) => void;
+}
+
+/**
+ * Configuration for WebSocket reconnection behavior
+ */
+export interface ReconnectConfig {
+    /** Whether to automatically reconnect on disconnect. Default: true */
+    enabled?: boolean;
+    /** Maximum number of reconnect attempts. 0 = unlimited. Default: 0 (unlimited) */
+    maxAttempts?: number;
+    /** Initial delay in ms before first reconnect attempt. Default: 1000 */
+    baseDelay?: number;
+    /** Maximum delay in ms between reconnect attempts. Default: 30000 */
+    maxDelay?: number;
+    /** Backoff multiplier. Default: 2 */
+    backoffMultiplier?: number;
+    /** Add jitter to prevent thundering herd. Default: true */
+    jitter?: boolean;
+}
+
 /**
  * Transport interface for sending and receiving messages
  */
@@ -32,6 +73,15 @@ export interface Transport {
     send(channel: string, envelope: MessageEnvelope, options?: RequestOptions): Promise<any>;
     subscribe(channel: string, operation: string, callback: (envelope: MessageEnvelope) => void): () => void;
     unsubscribe(channel: string, callback?: (envelope: MessageEnvelope) => void): void;
+
+    /** Check if the transport is currently connected */
+    isConnected(): boolean;
+
+    /** Register a callback for when the transport reconnects after a disconnect */
+    onReconnected(callback: () => void): () => void;
+
+    /** Register a callback for when the transport disconnects unexpectedly */
+    onDisconnected(callback: (reason: string) => void): () => void;
 }
 
 /**
@@ -46,6 +96,8 @@ export interface TransportConfig {
     retry?: RetryConfig | RetryPreset;         // Retry configuration
     authCallbacks?: AuthEventCallbacks;        // Auth event callbacks
     retryCallbacks?: RetryEventCallbacks;      // Retry event callbacks
+    reconnect?: ReconnectConfig;               // Reconnection configuration
+    connectionCallbacks?: ConnectionEventCallbacks; // Connection lifecycle callbacks
 }
 
 /**