@ioka-technologies/asyncapi-ts-client-template 0.0.7 → 0.0.10

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

@@ -0,0 +1,60 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="types.ts">
+            {`/**
+ * Retry configuration interface
+ */
+export interface RetryConfig {
+    enabled: boolean;
+    maxAttempts: number;
+    baseDelay: number;        // Initial delay in ms
+    maxDelay: number;         // Maximum delay in ms
+    backoffMultiplier: number; // Exponential backoff multiplier
+    jitter: boolean;          // Add randomization to prevent thundering herd
+    retryableStatusCodes: number[]; // Which HTTP status codes to retry
+    retryableErrors: string[];      // Which error types to retry
+}
+
+/**
+ * Preset retry configurations
+ */
+export type RetryPreset = 'aggressive' | 'balanced' | 'conservative' | 'none';
+
+/**
+ * Retry event callbacks for monitoring
+ */
+export interface RetryEventCallbacks {
+    /** Called before each retry attempt */
+    onRetry?: (attempt: number, error: Error, delay: number) => void;
+
+    /** Called when all retry attempts are exhausted */
+    onRetryExhausted?: (operation: string, finalError: Error) => void;
+}
+
+/**
+ * Retry-related error types
+ */
+export class RetryError extends Error {
+    constructor(
+        message: string,
+        public attempts: number,
+        public lastError: Error
+    ) {
+        super(message);
+        this.name = 'RetryError';
+    }
+}
+
+export class MaxRetriesExceededError extends RetryError {
+    constructor(attempts: number, lastError: Error) {
+        super(\`Maximum retry attempts (\${attempts}) exceeded\`, attempts, lastError);
+        this.name = 'MaxRetriesExceededError';
+    }
+}
+`}
+        </File>
+    );
+};

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

@@ -12,14 +12,22 @@ module.exports = function ({ asyncapi, params }) {
         <File name="http.ts">
             {`import { Transport, TransportConfig, RequestOptions, MessageEnvelope } from '../types';
 import { TransportError, ConnectionError, TimeoutError } from '../errors';
+import { generateAuthHeaders, generateAuthQueryParams, hasAuthCredentials, AuthError, UnauthorizedError, AuthCredentials } from '../auth';
+import { createRetryManager, getRetryConfig } from '../retry';
 
 export class HttpTransport implements Transport {
     private config: TransportConfig;
     private baseUrl: string;
+    private retryManager: any;
 
     constructor(config: TransportConfig) {
         this.config = config;
         this.baseUrl = config.url;
+
+        // Initialize retry manager if retry config is provided
+        if (config.retry) {
+            this.retryManager = createRetryManager(config.retry, config.retryCallbacks);
+        }
     }
 
     async connect(): Promise<void> {
@@ -33,46 +41,114 @@ export class HttpTransport implements Transport {
     }
 
     async send(channel: string, envelope: MessageEnvelope, options?: RequestOptions): Promise<any> {
-        const url = \`\${this.baseUrl}/\${channel}\`;
-        const timeout = options?.timeout || 30000;
+        // Determine retry configuration (options override config)
+        const retryConfig = options?.retry ? getRetryConfig(options.retry) :
+                           this.config.retry ? getRetryConfig(this.config.retry) : null;
+
+        const retryManager = retryConfig ? createRetryManager(retryConfig, this.config.retryCallbacks) : null;
+
+        const sendOperation = async () => {
+            return this.performHttpRequest(channel, envelope, options);
+        };
+
+        // Execute with retry if configured
+        if (retryManager) {
+            return retryManager.executeWithRetry(sendOperation, \`\${envelope.operation} on \${channel}\`);
+        } else {
+            return sendOperation();
+        }
+    }
+
+    private async performHttpRequest(channel: string, envelope: MessageEnvelope, options?: RequestOptions): Promise<any> {
+        let url = \`\${this.baseUrl}/\${channel}\`;
+        const timeout = options?.timeout || this.config.timeout || 30000;
+
+        // Generate auth headers if credentials are available
+        const authHeaders = this.config.auth ? generateAuthHeaders(this.config.auth) : {};
 
         // Prepare the complete envelope for HTTP transport
         const messageEnvelope: MessageEnvelope = {
             ...envelope,
             channel: envelope.channel || channel,
             timestamp: envelope.timestamp || new Date().toISOString(),
-            id: options?.correlationId || envelope.id
+            id: options?.correlationId || envelope.id || this.generateCorrelationId(),
+            headers: {
+                ...envelope.headers,
+                ...authHeaders
+            }
+        };
+
+        // Prepare headers
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json',
+            'X-Operation': envelope.operation,
+            'X-Correlation-ID': messageEnvelope.id || '',
+            ...this.config.headers
         };
 
+        // Add auth headers if auth is configured
+        if (this.config.auth && hasAuthCredentials(this.config.auth)) {
+            try {
+                const authHeaders = generateAuthHeaders(this.config.auth);
+                Object.assign(headers, authHeaders);
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new AuthError(\`Failed to generate auth headers: \${errorMessage}\`);
+            }
+        }
+
+        // Add auth query parameters if needed
+        if (this.config.auth?.apikey?.location === 'query') {
+            const authParams = generateAuthQueryParams(this.config.auth);
+            const urlObj = new URL(url);
+            Object.entries(authParams).forEach(([key, value]) => {
+                urlObj.searchParams.set(key, value);
+            });
+            url = urlObj.toString();
+        }
+
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeout);
 
         try {
             const response = await fetch(url, {
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'X-Operation': envelope.operation,
-                    'X-Correlation-ID': messageEnvelope.id || '',
-                    ...this.config.headers
-                },
+                headers,
                 body: JSON.stringify(messageEnvelope),
                 signal: controller.signal
             });
 
             clearTimeout(timeoutId);
 
+            // Handle auth errors specifically
+            if (response.status === 401) {
+                // Call auth error callback if available
+                if (this.config.authCallbacks?.onAuthError) {
+                    const shouldRetry = await this.config.authCallbacks.onAuthError();
+                    if (shouldRetry) {
+                        // Retry the request with potentially updated auth
+                        return this.performHttpRequest(channel, envelope, options);
+                    }
+                }
+                throw new UnauthorizedError('Authentication failed');
+            }
+
             if (!response.ok) {
+                // Create error with status for retry logic
+                const error = new TransportError(\`HTTP request failed: \${response.status} \${response.statusText}\`);
+                (error as any).status = response.status;
+
                 // Try to parse error response as envelope
                 try {
                     const errorEnvelope: MessageEnvelope = await response.json();
                     if (errorEnvelope.error) {
-                        throw new TransportError(\`\${errorEnvelope.error.code}: \${errorEnvelope.error.message}\`);
+                        error.message = \`\${errorEnvelope.error.code}: \${errorEnvelope.error.message}\`;
                     }
                 } catch {
-                    // Fall back to HTTP status error
-                    throw new TransportError(\`HTTP request failed: \${response.status} \${response.statusText}\`);
+                    // Use the default error message
                 }
+
+                throw error;
             }
 
             // Parse response as envelope
@@ -88,15 +164,34 @@ export class HttpTransport implements Transport {
             clearTimeout(timeoutId);
 
             if (error.name === 'AbortError') {
-                throw new TimeoutError(\`Request timeout after \${timeout}ms\`);
+                const timeoutError = new TimeoutError(\`Request timeout after \${timeout}ms\`);
+                (timeoutError as any).code = 'TIMEOUT';
+                throw timeoutError;
             }
 
-            // Re-throw TransportError as-is
-            if (error instanceof TransportError) {
+            // Add error codes for retry logic
+            if (error instanceof TransportError || error instanceof AuthError) {
                 throw error;
             }
 
-            throw new TransportError(\`HTTP request failed: \${error.message}\`);
+            // Network errors
+            const networkError = new TransportError(\`HTTP request failed: \${error.message}\`);
+            (networkError as any).code = 'NETWORK_ERROR';
+            throw networkError;
+        }
+    }
+
+    private generateCorrelationId(): string {
+        return \`http-\${Date.now()}-\${Math.random().toString(36).substr(2, 9)}\`;
+    }
+
+    /**
+     * Update authentication configuration
+     * @param auth New authentication configuration
+     */
+    updateAuth(auth: AuthCredentials): void {
+        if (this.config) {
+            this.config.auth = auth;
         }
     }
 
@@ -119,4 +214,4 @@ export class HttpTransport implements Transport {
 }`}
         </File>
     );
-}
+};

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

@@ -13,6 +13,8 @@ module.exports = function ({ asyncapi, params }) {
             {`import { v4 as uuidv4 } from 'uuid';
 import { Transport, TransportConfig, RequestOptions, ResponseHandler, MessageEnvelope, EnvelopeCallback } from '../types';
 import { TransportError, ConnectionError, TimeoutError } from '../errors';
+import { generateAuthHeaders, generateAuthQueryParams, hasAuthCredentials, AuthError, UnauthorizedError, AuthCredentials } from '../auth';
+import { createRetryManager, getRetryConfig } from '../retry';
 
 // Environment-aware WebSocket implementation
 const getWebSocketImpl = (): typeof WebSocket => {
@@ -122,13 +124,20 @@ export class WebSocketTransport implements Transport {
             throw new TransportError('WebSocket is not connected');
         }
 
+        // Generate auth headers if credentials are available
+        const authHeaders = this.config.auth ? generateAuthHeaders(this.config.auth) : {};
+
         // Ensure envelope has required fields
         const requestId = options?.correlationId || envelope.id || uuidv4();
         const messageEnvelope: MessageEnvelope = {
             ...envelope,
             id: requestId,
             channel: envelope.channel || channel,
-            timestamp: envelope.timestamp || new Date().toISOString()
+            timestamp: envelope.timestamp || new Date().toISOString(),
+            headers: {
+                ...envelope.headers,
+                ...authHeaders
+            }
         };
 
         return new Promise((resolve, reject) => {
@@ -162,11 +171,15 @@ export class WebSocketTransport implements Transport {
 
         // Send subscription message to server using envelope format
         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) : {};
+
             const subscribeEnvelope: MessageEnvelope = {
                 operation: 'subscribe',
                 channel,
                 payload: { channel },
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString(),
+                headers: authHeaders
             };
             this.ws.send(JSON.stringify(subscribeEnvelope));
         }
@@ -323,7 +336,19 @@ export class WebSocketTransport implements Transport {
             }
         }
     }
+
+    /**
+     * Update authentication configuration
+     * @param auth New authentication configuration
+     */
+    updateAuth(auth: AuthCredentials): void {
+        if (this.config) {
+            this.config.auth = auth;
+        }
+        // Note: For WebSocket, auth is typically handled during connection
+        // If you need to update auth for an active connection, you may need to reconnect
+    }
 }`}
         </File>
     );
-}
+};

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

@@ -4,7 +4,10 @@ import { File } from '@asyncapi/generator-react-sdk';
 module.exports = function ({ asyncapi, params }) {
     return (
         <File name="types.ts">
-            {`/**
+            {`import { AuthCredentials, AuthEventCallbacks } from './auth';
+import { RetryConfig, RetryPreset, RetryEventCallbacks } from './retry';
+
+/**
  * Standard message envelope for all AsyncAPI communications
  */
 export interface MessageEnvelope {
@@ -13,6 +16,7 @@ export interface MessageEnvelope {
     channel?: string;           // Optional channel context
     payload: any;               // Message payload
     timestamp?: string;         // Optional ISO 8601 timestamp
+    headers?: Record<string, string>; // Transport-level headers (auth, routing, etc.)
     error?: {                   // Error information
         code: string;
         message: string;
@@ -38,6 +42,10 @@ export interface TransportConfig {
     url: string;
     headers?: Record<string, string>;
     timeout?: number;
+    auth?: AuthCredentials;                    // Authentication credentials
+    retry?: RetryConfig | RetryPreset;         // Retry configuration
+    authCallbacks?: AuthEventCallbacks;        // Auth event callbacks
+    retryCallbacks?: RetryEventCallbacks;      // Retry event callbacks
 }
 
 /**
@@ -45,7 +53,8 @@ export interface TransportConfig {
  */
 export interface RequestOptions {
     timeout?: number;
-    correlationId?: string;     // Override correlation ID
+    correlationId?: string;                    // Override correlation ID
+    retry?: RetryConfig | RetryPreset;         // Override retry config for this request
 }
 
 /**
@@ -72,4 +81,4 @@ export type UnsubscribeFunction = () => void;
 export type EnvelopeCallback = (envelope: MessageEnvelope) => void;`}
         </File>
     );
-}
+};