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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ioka-technologies/asyncapi-ts-client-template",
-    "version": "0.0.35",
+    "version": "0.0.36",
     "description": "TypeScript AsyncAPI client generator template compatible with rust-asyncapi patterns",
     "main": "template/index.js",
     "scripts": {

package/template/src/client.ts.js

@@ -185,6 +185,29 @@ export class ${clientName} {
         return this.config.auth;
     }
 
+    /**
+     * Check if the transport is currently connected
+     */
+    isConnected(): boolean {
+        return this.transport.isConnected();
+    }
+
+    /**
+     * Register a callback for when the transport reconnects after a disconnect.
+     * Returns an unsubscribe function.
+     */
+    onReconnected(callback: () => void): () => void {
+        return this.transport.onReconnected(callback);
+    }
+
+    /**
+     * Register a callback for when the transport disconnects unexpectedly.
+     * Returns an unsubscribe function.
+     */
+    onDisconnected(callback: (reason: string) => void): () => void {
+        return this.transport.onDisconnected(callback);
+    }
+
     // Generated operation methods
 `;
 
@@ -473,8 +496,8 @@ export class ${clientName} {
 
                             if (hasReply) {
                                 // Request/Response pattern - send and wait for response
-                                const requestPayloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
-                                const responseType = replyMessageTypes.length > 0 ? `Models.${replyMessageTypes[0]}Payload` : 'any';
+                                const requestPayloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}` : 'any';
+                                const responseType = replyMessageTypes.length > 0 ? `Models.${replyMessageTypes[0]}` : 'any';
 
                                 content += `
     /**
@@ -496,7 +519,7 @@ export class ${clientName} {
 `;
                             } else {
                                 // Regular send operation (fire and forget)
-                                const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
+                                const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}` : 'any';
                                 content += `
     /**
      * ${methodName} - Send operation (fire and forget)
@@ -539,7 +562,7 @@ export class ${clientName} {
                             const methodName = sanitizeMethodName(operationId);
 
                             // Generate receive method (event listener setup)
-                            const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
+                            const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}` : 'any';
                             content += `
     /**
      * ${methodName} - Receive operation
@@ -708,8 +731,8 @@ export class ${serviceName} {
                                     }
 
                                     if (hasReply) {
-                                        const requestPayloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
-                                        const responseType = replyMessageTypes.length > 0 ? `Models.${replyMessageTypes[0]}Payload` : 'any';
+                                        const requestPayloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}` : 'any';
+                                        const responseType = replyMessageTypes.length > 0 ? `Models.${replyMessageTypes[0]}` : 'any';
 
                                         content += `
     /**
@@ -729,7 +752,7 @@ export class ${serviceName} {
     }
 `;
                                     } else {
-                                        const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
+                                        const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}` : 'any';
                                         content += `
     /**
      * ${methodName} - Send operation (fire and forget)
@@ -767,7 +790,7 @@ export class ${serviceName} {
                                     }
                                 } else if (action === 'receive') {
                                     // Generate receive method (event listener setup) for dynamic channels
-                                    const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
+                                    const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}` : 'any';
                                     content += `
     /**
      * ${methodName} - Receive operation

package/template/src/index.ts.js

@@ -7,7 +7,8 @@ export default function ({ asyncapi, params }) {
             {`export * from './client';
 export * from './models';
 export * from './runtime/types';
-export * from './runtime/errors';`}
+export * from './runtime/errors';
+export { RECONNECT_PRESETS, ReconnectPreset, getReconnectPreset } from './runtime/retry/presets';`}
         </File>
     );
 }

package/template/src/runtime/retry/presets.ts.js

@@ -5,6 +5,7 @@ export default function ({ asyncapi, params }) {
     return (
         <File name="presets.ts">
             {`import { RetryConfig, RetryPreset } from './types';
+import { ReconnectConfig } from '../types';
 
 /**
  * Predefined retry configuration presets
@@ -75,6 +76,57 @@ export function mergeRetryConfig(preset: RetryPreset, overrides: Partial<RetryCo
         ...overrides
     };
 }
+
+/**
+ * Predefined reconnection configuration presets for WebSocket transport
+ */
+export type ReconnectPreset = 'aggressive' | 'balanced' | 'conservative' | 'none';
+
+export const RECONNECT_PRESETS: Record<ReconnectPreset, Required<ReconnectConfig>> = {
+    /** Aggressive reconnection - fast retries, unlimited attempts */
+    aggressive: {
+        enabled: true,
+        maxAttempts: 0,
+        baseDelay: 500,
+        maxDelay: 10000,
+        backoffMultiplier: 1.5,
+        jitter: true,
+    },
+    /** Balanced reconnection - moderate retries, unlimited attempts */
+    balanced: {
+        enabled: true,
+        maxAttempts: 0,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        backoffMultiplier: 2,
+        jitter: true,
+    },
+    /** Conservative reconnection - slow retries, limited attempts */
+    conservative: {
+        enabled: true,
+        maxAttempts: 10,
+        baseDelay: 2000,
+        maxDelay: 60000,
+        backoffMultiplier: 2,
+        jitter: true,
+    },
+    /** No reconnection */
+    none: {
+        enabled: false,
+        maxAttempts: 0,
+        baseDelay: 0,
+        maxDelay: 0,
+        backoffMultiplier: 0,
+        jitter: false,
+    },
+};
+
+/**
+ * Get reconnect configuration from preset name
+ */
+export function getReconnectPreset(preset: ReconnectPreset): Required<ReconnectConfig> {
+    return RECONNECT_PRESETS[preset];
+}
 `}
         </File>
     );

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

@@ -195,6 +195,34 @@ export class HttpTransport implements Transport {
         }
     }
 
+    /**
+     * Check if the transport is currently connected.
+     * HTTP transport is always considered connected.
+     */
+    isConnected(): boolean {
+        return true;
+    }
+
+    /**
+     * Register a callback for when the transport reconnects after a disconnect.
+     * HTTP transport does not have persistent connections, so this is a no-op.
+     * Returns an unsubscribe function.
+     */
+    onReconnected(callback: () => void): () => void {
+        // No-op for HTTP transport
+        return () => {};
+    }
+
+    /**
+     * Register a callback for when the transport disconnects unexpectedly.
+     * HTTP transport does not have persistent connections, so this is a no-op.
+     * Returns an unsubscribe function.
+     */
+    onDisconnected(callback: (reason: string) => void): () => void {
+        // No-op for HTTP transport
+        return () => {};
+    }
+
     subscribe(channel: string, operation: string, callback: (envelope: MessageEnvelope) => void): () => void {
         // HTTP transport doesn't support real-time subscriptions
         // This is a placeholder implementation that logs a warning

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,15 +54,56 @@ 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 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()
     }
 
+    /**
+     * 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); };
+    }
+
     async connect(): Promise<void> {
         if (!this.WebSocketImpl) {
             this.WebSocketImpl = await getWebSocketImpl();
@@ -77,6 +118,8 @@ export class WebSocketTransport implements Transport {
                     // Browser WebSocket API
                     this.ws.addEventListener('open', () => {
                         this.reconnectAttempts = 0;
+                        this._isConnected = true;
+                        this.config.connectionCallbacks?.onConnected?.();
                         resolve();
                     });
 
@@ -89,12 +132,23 @@ export class WebSocketTransport implements Transport {
                     });
 
                     this.ws.addEventListener('error', (event: Event) => {
-                        reject(new ConnectionError(\`WebSocket connection failed: \${event.type}\`));
+                        if (!this._isConnected) {
+                            // Error during initial connection
+                            reject(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) {
                     // Node.js ws library API
                     this.ws.on('open', () => {
                         this.reconnectAttempts = 0;
+                        this._isConnected = true;
+                        this.config.connectionCallbacks?.onConnected?.();
                         resolve();
                     });
 
@@ -107,7 +161,16 @@ export class WebSocketTransport implements Transport {
                     });
 
                     this.ws.on('error', (error: any) => {
-                        reject(new ConnectionError(\`WebSocket connection failed: \${error.message}\`));
+                        if (!this._isConnected) {
+                            // Error during initial connection
+                            reject(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'));
@@ -119,6 +182,18 @@ export class WebSocketTransport implements Transport {
     }
 
     async disconnect(): Promise<void> {
+        this.intentionalDisconnect = true;
+        this._isConnected = false;
+
+        // Cancel any pending reconnect timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+
+        // Reject all pending requests
+        this.rejectPendingRequests('Connection closed intentionally');
+
         if (this.ws) {
             this.ws.close();
             this.ws = null;
@@ -203,7 +278,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 +319,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 +340,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 +370,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 +436,139 @@ 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
+        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) {
+            this.intentionalDisconnect = false;
+            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 {
+        // 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 () => {
+            try {
+                // Reset the intentional disconnect flag before reconnecting
+                this.intentionalDisconnect = false;
+                await this.connect();
+
+                // Reconnection succeeded
+                console.log('WebSocket reconnected successfully');
+                this.config.connectionCallbacks?.onReconnected?.();
+                this.reconnectedListeners.forEach(cb => {
+                    try { cb(); } catch (e) { console.error('Error in reconnect listener:', e); }
                 });
-            }, this.reconnectDelay * this.reconnectAttempts);
+
+                // Re-subscribe to all channels
+                this.resubscribeAll();
+            } catch (error) {
+                console.error('WebSocket reconnection attempt failed:', 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
 }
 
 /**