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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ioka-technologies/asyncapi-ts-client-template",
-    "version": "0.0.35",
+    "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> {
@@ -185,6 +194,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 +505,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 +528,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 +571,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 +740,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 +761,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 +799,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