@ioka-technologies/asyncapi-ts-client-template 0.0.8 → 0.0.11

package/template/src/runtime/auth/headers.ts.js

@@ -0,0 +1,95 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="headers.ts">
+            {`import { AuthCredentials, AuthError } from './types';
+
+/**
+ * Generate authentication headers based on credentials
+ */
+export function generateAuthHeaders(auth: AuthCredentials): Record<string, string> {
+    const headers: Record<string, string> = {};
+
+    if (auth.jwt) {
+        headers['Authorization'] = \`Bearer \${auth.jwt}\`;
+    } else if (auth.basic) {
+        const credentials = btoa(\`\${auth.basic.username}:\${auth.basic.password}\`);
+        headers['Authorization'] = \`Basic \${credentials}\`;
+    } else if (auth.apikey) {
+        if (auth.apikey.location === 'header') {
+            headers[auth.apikey.name] = auth.apikey.key;
+        }
+        // Query parameters are handled in the transport layer
+    }
+
+    return headers;
+}
+
+/**
+ * Generate query parameters for API key authentication
+ */
+export function generateAuthQueryParams(auth: AuthCredentials): Record<string, string> {
+    const params: Record<string, string> = {};
+
+    if (auth.apikey && auth.apikey.location === 'query') {
+        params[auth.apikey.name] = auth.apikey.key;
+    }
+
+    return params;
+}
+
+/**
+ * Validate auth credentials
+ */
+export function validateAuthCredentials(auth: AuthCredentials): void {
+    if (auth.jwt) {
+        if (typeof auth.jwt !== 'string' || auth.jwt.trim() === '') {
+            throw new AuthError('JWT token must be a non-empty string', 'jwt');
+        }
+    }
+
+    if (auth.basic) {
+        if (!auth.basic.username || !auth.basic.password) {
+            throw new AuthError('Basic auth requires both username and password', 'basic');
+        }
+        if (typeof auth.basic.username !== 'string' || typeof auth.basic.password !== 'string') {
+            throw new AuthError('Basic auth username and password must be strings', 'basic');
+        }
+    }
+
+    if (auth.apikey) {
+        if (!auth.apikey.key || !auth.apikey.name) {
+            throw new AuthError('API key auth requires both key and name', 'apikey');
+        }
+        if (typeof auth.apikey.key !== 'string' || typeof auth.apikey.name !== 'string') {
+            throw new AuthError('API key and name must be strings', 'apikey');
+        }
+        if (!['header', 'query'].includes(auth.apikey.location)) {
+            throw new AuthError('API key location must be either "header" or "query"', 'apikey');
+        }
+    }
+}
+
+/**
+ * Check if auth credentials are provided
+ */
+export function hasAuthCredentials(auth?: AuthCredentials): boolean {
+    if (!auth) return false;
+    return !!(auth.jwt || auth.basic || auth.apikey);
+}
+
+/**
+ * Get auth type from credentials
+ */
+export function getAuthType(auth: AuthCredentials): string | null {
+    if (auth.jwt) return 'jwt';
+    if (auth.basic) return 'basic';
+    if (auth.apikey) return 'apikey';
+    return null;
+}
+`}
+        </File>
+    );
+};

package/template/src/runtime/auth/index.ts.js

@@ -0,0 +1,15 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="index.ts">
+            {`// Auth types and interfaces
+export * from './types';
+
+// Auth header utilities
+export * from './headers';
+`}
+        </File>
+    );
+};

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

@@ -0,0 +1,74 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="types.ts">
+            {`/**
+ * Authentication credentials for different auth types
+ */
+export interface AuthCredentials {
+    /** JWT Bearer token */
+    jwt?: string;
+
+    /** Basic authentication credentials */
+    basic?: {
+        username: string;
+        password: string;
+    };
+
+    /** API Key authentication */
+    apikey?: {
+        key: string;
+        location: 'header' | 'query';
+        name: string;
+    };
+}
+
+/**
+ * Auth-related error types
+ */
+export class AuthError extends Error {
+    constructor(message: string, public authType?: string) {
+        super(message);
+        this.name = 'AuthError';
+    }
+}
+
+export class TokenExpiredError extends AuthError {
+    constructor(message: string = 'Token has expired') {
+        super(message, 'jwt');
+        this.name = 'TokenExpiredError';
+    }
+}
+
+export class UnauthorizedError extends AuthError {
+    constructor(message: string = 'Unauthorized access') {
+        super(message);
+        this.name = 'UnauthorizedError';
+    }
+}
+
+/**
+ * Auth event callbacks for monitoring and token refresh
+ */
+export interface AuthEventCallbacks {
+    /** Called when a 401 Unauthorized response is received */
+    onAuthError?: () => Promise<boolean>;
+
+    /** Called when token needs to be refreshed */
+    onTokenRefresh?: (oldToken: string) => Promise<string>;
+}
+
+/**
+ * Security requirement analysis result
+ */
+export interface SecurityRequirement {
+    hasSecurityRequirements: boolean;
+    securitySchemes: any[];
+    requiresAuthentication: boolean;
+}
+`}
+        </File>
+    );
+};

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

@@ -0,0 +1,18 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="index.ts">
+            {`// Retry types and interfaces
+export * from './types';
+
+// Retry presets
+export * from './presets';
+
+// Retry manager
+export * from './manager';
+`}
+        </File>
+    );
+};

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

@@ -0,0 +1,150 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="manager.ts">
+            {`import { RetryConfig, RetryEventCallbacks, MaxRetriesExceededError } from './types';
+import { getRetryConfig } from './presets';
+
+/**
+ * Retry manager for handling exponential backoff and retry logic
+ */
+export class RetryManager {
+    private config: RetryConfig;
+    private callbacks?: RetryEventCallbacks;
+
+    constructor(config: RetryConfig, callbacks?: RetryEventCallbacks) {
+        this.config = config;
+        this.callbacks = callbacks;
+    }
+
+    /**
+     * Execute an operation with retry logic
+     */
+    async executeWithRetry<T>(
+        operation: () => Promise<T>,
+        operationName: string
+    ): Promise<T> {
+        if (!this.config.enabled) {
+            return operation();
+        }
+
+        let lastError: Error;
+
+        for (let attempt = 1; attempt <= this.config.maxAttempts; attempt++) {
+            try {
+                return await operation();
+            } catch (error) {
+                lastError = error as Error;
+
+                // Check if error is retryable
+                if (!this.isRetryable(error) || attempt === this.config.maxAttempts) {
+                    if (attempt === this.config.maxAttempts && this.callbacks?.onRetryExhausted) {
+                        this.callbacks.onRetryExhausted(operationName, lastError);
+                    }
+                    throw error;
+                }
+
+                // Calculate delay with exponential backoff and jitter
+                const delay = this.calculateDelay(attempt);
+
+                // Call retry callback
+                if (this.callbacks?.onRetry) {
+                    this.callbacks.onRetry(attempt, lastError, delay);
+                }
+
+                // Wait before retrying
+                await this.sleep(delay);
+            }
+        }
+
+        // This should never be reached, but TypeScript requires it
+        throw new MaxRetriesExceededError(this.config.maxAttempts, lastError!);
+    }
+
+    /**
+     * Check if an error is retryable based on configuration
+     */
+    private isRetryable(error: any): boolean {
+        // Check HTTP status codes
+        if (error.status && this.config.retryableStatusCodes.includes(error.status)) {
+            return true;
+        }
+
+        // Check error codes
+        if (error.code && this.config.retryableErrors.includes(error.code)) {
+            return true;
+        }
+
+        // Check error names
+        if (error.name && this.config.retryableErrors.includes(error.name)) {
+            return true;
+        }
+
+        // Check error messages for common network errors
+        if (error.message) {
+            const message = error.message.toLowerCase();
+            for (const retryableError of this.config.retryableErrors) {
+                if (message.includes(retryableError.toLowerCase())) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Calculate delay with exponential backoff and optional jitter
+     */
+    private calculateDelay(attempt: number): number {
+        let delay = this.config.baseDelay * Math.pow(this.config.backoffMultiplier, attempt - 1);
+
+        // Apply maximum delay cap
+        delay = Math.min(delay, this.config.maxDelay);
+
+        // Add jitter to prevent thundering herd
+        if (this.config.jitter) {
+            delay = delay * (0.5 + Math.random() * 0.5);
+        }
+
+        return Math.floor(delay);
+    }
+
+    /**
+     * Sleep for specified milliseconds
+     */
+    private sleep(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /**
+     * Get current retry configuration
+     */
+    getConfig(): RetryConfig {
+        return { ...this.config };
+    }
+
+    /**
+     * Update retry configuration
+     */
+    updateConfig(config: Partial<RetryConfig>): void {
+        this.config = { ...this.config, ...config };
+    }
+}
+
+/**
+ * Create a retry manager from config or preset
+ */
+export function createRetryManager(
+    config: RetryConfig | string,
+    callbacks?: RetryEventCallbacks
+): RetryManager {
+    const retryConfig = getRetryConfig(config as any);
+    return new RetryManager(retryConfig, callbacks);
+}
+`}
+        </File>
+    );
+};

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

@@ -0,0 +1,81 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="presets.ts">
+            {`import { RetryConfig, RetryPreset } from './types';
+
+/**
+ * Predefined retry configuration presets
+ */
+export const RETRY_PRESETS: Record<RetryPreset, RetryConfig> = {
+    none: {
+        enabled: false,
+        maxAttempts: 1,
+        baseDelay: 0,
+        maxDelay: 0,
+        backoffMultiplier: 1,
+        jitter: false,
+        retryableStatusCodes: [],
+        retryableErrors: []
+    },
+
+    conservative: {
+        enabled: true,
+        maxAttempts: 3,
+        baseDelay: 1000,      // 1 second
+        maxDelay: 10000,      // 10 seconds max
+        backoffMultiplier: 2,
+        jitter: true,
+        retryableStatusCodes: [500, 502, 503, 504],
+        retryableErrors: ['NETWORK_ERROR', 'TIMEOUT', 'ECONNRESET', 'ENOTFOUND']
+    },
+
+    balanced: {
+        enabled: true,
+        maxAttempts: 5,
+        baseDelay: 500,       // 500ms
+        maxDelay: 30000,      // 30 seconds max
+        backoffMultiplier: 2,
+        jitter: true,
+        retryableStatusCodes: [429, 500, 502, 503, 504],
+        retryableErrors: ['NETWORK_ERROR', 'TIMEOUT', 'CONNECTION_ERROR', 'ECONNRESET', 'ENOTFOUND', 'ETIMEDOUT']
+    },
+
+    aggressive: {
+        enabled: true,
+        maxAttempts: 10,
+        baseDelay: 100,       // 100ms
+        maxDelay: 60000,      // 1 minute max
+        backoffMultiplier: 1.5,
+        jitter: true,
+        retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+        retryableErrors: ['NETWORK_ERROR', 'TIMEOUT', 'CONNECTION_ERROR', 'DNS_ERROR', 'ECONNRESET', 'ENOTFOUND', 'ETIMEDOUT', 'ECONNREFUSED']
+    }
+};
+
+/**
+ * Get retry configuration from preset or return custom config
+ */
+export function getRetryConfig(config: RetryConfig | RetryPreset): RetryConfig {
+    if (typeof config === 'string') {
+        return RETRY_PRESETS[config];
+    }
+    return config;
+}
+
+/**
+ * Merge custom retry config with preset defaults
+ */
+export function mergeRetryConfig(preset: RetryPreset, overrides: Partial<RetryConfig>): RetryConfig {
+    const baseConfig = RETRY_PRESETS[preset];
+    return {
+        ...baseConfig,
+        ...overrides
+    };
+}
+`}
+        </File>
+    );
+};

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>
     );
-}
+};