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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ioka-technologies/asyncapi-ts-client-template",
-    "version": "0.0.36",
+    "version": "0.0.41",
     "description": "TypeScript AsyncAPI client generator template compatible with rust-asyncapi patterns",
     "main": "template/index.js",
     "scripts": {
@@ -24,6 +24,10 @@
         "rust-asyncapi"
     ],
     "author": "AsyncAPI TypeScript Generator",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Ioka-Technologies/asyncapi-template"
+    },
     "license": "Apache-2.0",
     "dependencies": {
         "@asyncapi/generator-react-sdk": "^1.0.20"

package/template/src/client.ts.js

@@ -142,14 +142,23 @@ import * as Models from './models';
 export class ${clientName} {
     private transport: Transport;
     private config: TransportConfig;
+    private connectPromise: Promise<void> | null = null;
 
     constructor(config: TransportConfig) {
         this.config = config;
         this.transport = TransportFactory.create(config);
     }
 
-    async connect(): Promise<void> {
-        await this.transport.connect();
+    connect(): Promise<void> {
+        if (this.transport.isConnected()) {
+            return Promise.resolve();
+        }
+        if (!this.connectPromise) {
+            this.connectPromise = this.transport.connect().finally(() => {
+                this.connectPromise = null;
+            });
+        }
+        return this.connectPromise;
     }
 
     async disconnect(): Promise<void> {

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

@@ -60,6 +60,10 @@ export class WebSocketTransport implements Transport {
     private _isConnected = false;
     private reconnectAttempts = 0;
     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)
@@ -104,37 +108,73 @@ export class WebSocketTransport implements Transport {
         return () => { this.disconnectedListeners.delete(callback); };
     }
 
-    async connect(): Promise<void> {
+    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;
-                        this.config.connectionCallbacks?.onConnected?.();
+                        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) => {
+                    socket.addEventListener('error', (event: Event) => {
+                        if (!isCurrent()) return;
                         if (!this._isConnected) {
                             // Error during initial connection
-                            reject(new ConnectionError(\`WebSocket connection failed: \${event.type}\`));
+                            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);
@@ -143,27 +183,43 @@ export class WebSocketTransport implements Transport {
                             );
                         }
                     });
-                } 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;
-                        this.config.connectionCallbacks?.onConnected?.();
+                        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) => {
+                    socket.on('error', (error: any) => {
+                        if (!isCurrent()) return;
                         if (!this._isConnected) {
                             // Error during initial connection
-                            reject(new ConnectionError(\`WebSocket connection failed: \${error.message}\`));
+                            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);
@@ -173,10 +229,10 @@ export class WebSocketTransport implements Transport {
                         }
                     });
                 } 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}\`));
             }
         });
     }
@@ -191,12 +247,19 @@ export class WebSocketTransport implements Transport {
             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');
 
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
+        const socket = this.ws;
+        this.ws = null;
+        if (socket) {
+            socket.close();
         }
     }
 
@@ -443,10 +506,7 @@ export class WebSocketTransport implements Transport {
         this.rejectPendingRequests('WebSocket connection lost');
 
         // Don't reconnect if this was intentional
-        if (this.intentionalDisconnect) {
-            this.intentionalDisconnect = false;
-            return;
-        }
+        if (this.intentionalDisconnect) return;
 
         // Notify listeners of unexpected disconnect
         const reason = 'WebSocket connection lost unexpectedly';
@@ -464,6 +524,9 @@ export class WebSocketTransport implements Transport {
     }
 
     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) {
@@ -479,22 +542,13 @@ export class WebSocketTransport implements Transport {
         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();
 
-                // 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); }
-                });
-
-                // Re-subscribe to all channels
-                this.resubscribeAll();
             } catch (error) {
-                console.error('WebSocket reconnection attempt failed:', error);
                 // Try again
                 this.attemptReconnect();
             }