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

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

@@ -0,0 +1,122 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    const transports = (params.transports || 'websocket,http').split(',').map(t => t.trim());
+
+    if (!transports.includes('http')) {
+        return null;
+    }
+
+    return (
+        <File name="http.ts">
+            {`import { Transport, TransportConfig, RequestOptions, MessageEnvelope } from '../types';
+import { TransportError, ConnectionError, TimeoutError } from '../errors';
+
+export class HttpTransport implements Transport {
+    private config: TransportConfig;
+    private baseUrl: string;
+
+    constructor(config: TransportConfig) {
+        this.config = config;
+        this.baseUrl = config.url;
+    }
+
+    async connect(): Promise<void> {
+        // HTTP doesn't require explicit connection
+        return Promise.resolve();
+    }
+
+    async disconnect(): Promise<void> {
+        // HTTP doesn't require explicit disconnection
+        return Promise.resolve();
+    }
+
+    async send(channel: string, envelope: MessageEnvelope, options?: RequestOptions): Promise<any> {
+        const url = \`\${this.baseUrl}/\${channel}\`;
+        const timeout = options?.timeout || 30000;
+
+        // 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
+        };
+
+        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
+                },
+                body: JSON.stringify(messageEnvelope),
+                signal: controller.signal
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                // 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}\`);
+                    }
+                } catch {
+                    // Fall back to HTTP status error
+                    throw new TransportError(\`HTTP request failed: \${response.status} \${response.statusText}\`);
+                }
+            }
+
+            // Parse response as envelope
+            const responseEnvelope: MessageEnvelope = await response.json();
+
+            // Check for envelope-level errors
+            if (responseEnvelope.error) {
+                throw new TransportError(\`\${responseEnvelope.error.code}: \${responseEnvelope.error.message}\`);
+            }
+
+            return responseEnvelope.payload;
+        } catch (error: any) {
+            clearTimeout(timeoutId);
+
+            if (error.name === 'AbortError') {
+                throw new TimeoutError(\`Request timeout after \${timeout}ms\`);
+            }
+
+            // Re-throw TransportError as-is
+            if (error instanceof TransportError) {
+                throw error;
+            }
+
+            throw new TransportError(\`HTTP request failed: \${error.message}\`);
+        }
+    }
+
+    subscribe(channel: string, callback: (envelope: MessageEnvelope) => void): () => void {
+        // HTTP transport doesn't support real-time subscriptions
+        // This is a placeholder implementation that logs a warning
+        console.warn(\`HTTP transport does not support subscriptions. Channel '\${channel}' subscription ignored.\`);
+        console.warn('Consider using WebSocket transport for real-time message subscriptions.');
+
+        // Return a no-op unsubscribe function
+        return () => {
+            // No-op for HTTP transport
+        };
+    }
+
+    unsubscribe(channel: string, callback?: (envelope: MessageEnvelope) => void): void {
+        // HTTP transport doesn't support subscriptions, so nothing to unsubscribe
+        console.warn(\`HTTP transport does not support subscriptions. Channel '\${channel}' unsubscribe ignored.\`);
+    }
+}`}
+        </File>
+    );
+}

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

@@ -0,0 +1,329 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    const transports = (params.transports || 'websocket,http').split(',').map(t => t.trim());
+
+    if (!transports.includes('websocket')) {
+        return null;
+    }
+
+    return (
+        <File name="websocket.ts">
+            {`import { v4 as uuidv4 } from 'uuid';
+import { Transport, TransportConfig, RequestOptions, ResponseHandler, MessageEnvelope, EnvelopeCallback } from '../types';
+import { TransportError, ConnectionError, TimeoutError } from '../errors';
+
+// Environment-aware WebSocket implementation
+const getWebSocketImpl = (): typeof WebSocket => {
+    if (typeof window !== 'undefined' && window.WebSocket) {
+        // Browser environment - use native WebSocket
+        return window.WebSocket;
+    } else if (typeof global !== 'undefined') {
+        // Node.js environment - try to require ws
+        try {
+            return require('ws');
+        } catch (error) {
+            throw new Error('WebSocket implementation not available. In Node.js, please install the "ws" package: npm install ws');
+        }
+    } else {
+        throw new Error('WebSocket implementation not available in this environment');
+    }
+};
+
+// Type definition that works for both browser and Node.js WebSocket
+type WebSocketLike = {
+    readonly readyState: number;
+    readonly OPEN: number;
+    send(data: string): void;
+    close(): void;
+    addEventListener?(type: string, listener: (event: any) => void): void;
+    removeEventListener?(type: string, listener: (event: any) => void): void;
+    on?(event: string, listener: (...args: any[]) => void): void;
+    off?(event: string, listener: (...args: any[]) => void): void;
+};
+
+export class WebSocketTransport implements Transport {
+    private ws: WebSocketLike | null = null;
+    private WebSocketImpl: typeof WebSocket;
+    private config: TransportConfig;
+    private responseHandlers: Map<string, ResponseHandler> = new Map();
+    private subscriptions: Map<string, Set<EnvelopeCallback>> = new Map();
+    private operationSubscriptions: Map<string, Set<(payload: any) => void>> = new Map();
+    private reconnectAttempts = 0;
+    private maxReconnectAttempts = 5;
+    private reconnectDelay = 1000;
+
+    constructor(config: TransportConfig) {
+        this.config = config;
+        this.WebSocketImpl = getWebSocketImpl();
+    }
+
+    async connect(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new this.WebSocketImpl(this.config.url) as WebSocketLike;
+
+                // Handle both browser and Node.js WebSocket APIs
+                if (typeof window !== 'undefined' && this.ws.addEventListener) {
+                    // Browser WebSocket API
+                    this.ws.addEventListener('open', () => {
+                        this.reconnectAttempts = 0;
+                        resolve();
+                    });
+
+                    this.ws.addEventListener('message', (event: MessageEvent) => {
+                        this.handleMessage(event.data);
+                    });
+
+                    this.ws.addEventListener('close', () => {
+                        this.handleDisconnect();
+                    });
+
+                    this.ws.addEventListener('error', (event: Event) => {
+                        reject(new ConnectionError(\`WebSocket connection failed: \${event.type}\`));
+                    });
+                } else if (this.ws.on) {
+                    // Node.js ws library API
+                    this.ws.on('open', () => {
+                        this.reconnectAttempts = 0;
+                        resolve();
+                    });
+
+                    this.ws.on('message', (data: any) => {
+                        this.handleMessage(data.toString());
+                    });
+
+                    this.ws.on('close', () => {
+                        this.handleDisconnect();
+                    });
+
+                    this.ws.on('error', (error: any) => {
+                        reject(new ConnectionError(\`WebSocket connection failed: \${error.message}\`));
+                    });
+                } else {
+                    reject(new ConnectionError('WebSocket implementation does not support required event handling'));
+                }
+            } catch (error: any) {
+                reject(new ConnectionError(\`Failed to create WebSocket: \${error.message}\`));
+            }
+        });
+    }
+
+    async disconnect(): Promise<void> {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+
+    async send(channel: string, envelope: MessageEnvelope, options?: RequestOptions): Promise<any> {
+        if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
+            throw new TransportError('WebSocket is not connected');
+        }
+
+        // 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()
+        };
+
+        return new Promise((resolve, reject) => {
+            const timeout = options?.timeout || 30000;
+            const timeoutId = setTimeout(() => {
+                this.responseHandlers.delete(requestId);
+                reject(new TimeoutError(\`Request timeout after \${timeout}ms\`));
+            }, timeout);
+
+            this.responseHandlers.set(requestId, {
+                resolve: (data) => {
+                    clearTimeout(timeoutId);
+                    resolve(data);
+                },
+                reject: (error) => {
+                    clearTimeout(timeoutId);
+                    reject(error);
+                }
+            });
+
+            this.ws!.send(JSON.stringify(messageEnvelope));
+        });
+    }
+
+    subscribe(channel: string, callback: (envelope: MessageEnvelope) => void): () => void {
+        if (!this.subscriptions.has(channel)) {
+            this.subscriptions.set(channel, new Set());
+        }
+
+        this.subscriptions.get(channel)!.add(callback);
+
+        // Send subscription message to server using envelope format
+        if (this.ws && this.ws.readyState === this.ws.OPEN) {
+            const subscribeEnvelope: MessageEnvelope = {
+                operation: 'subscribe',
+                channel,
+                payload: { channel },
+                timestamp: new Date().toISOString()
+            };
+            this.ws.send(JSON.stringify(subscribeEnvelope));
+        }
+
+        // Return unsubscribe function
+        return () => {
+            this.unsubscribe(channel, callback);
+        };
+    }
+
+    unsubscribe(channel: string, callback?: (envelope: MessageEnvelope) => void): void {
+        const channelSubscriptions = this.subscriptions.get(channel);
+        if (!channelSubscriptions) {
+            return;
+        }
+
+        if (callback) {
+            channelSubscriptions.delete(callback);
+            if (channelSubscriptions.size === 0) {
+                this.subscriptions.delete(channel);
+                this.sendUnsubscribeMessage(channel);
+            }
+        } else {
+            // Unsubscribe all callbacks for this channel
+            this.subscriptions.delete(channel);
+            this.sendUnsubscribeMessage(channel);
+        }
+    }
+
+    /**
+     * Subscribe to a specific operation on a channel
+     * This provides operation-based filtering on the client side
+     */
+    subscribeToOperation(channel: string, operation: string, callback: (payload: any) => void): () => void {
+        const operationKey = \`\${channel}:\${operation}\`;
+
+        if (!this.operationSubscriptions.has(operationKey)) {
+            this.operationSubscriptions.set(operationKey, new Set());
+        }
+
+        this.operationSubscriptions.get(operationKey)!.add(callback);
+
+        // Subscribe to the channel if not already subscribed
+        if (!this.subscriptions.has(channel)) {
+            this.subscribe(channel, (envelope: MessageEnvelope) => {
+                this.handleOperationMessage(envelope);
+            });
+        }
+
+        // Return unsubscribe function
+        return () => {
+            const opCallbacks = this.operationSubscriptions.get(operationKey);
+            if (opCallbacks) {
+                opCallbacks.delete(callback);
+                if (opCallbacks.size === 0) {
+                    this.operationSubscriptions.delete(operationKey);
+                }
+            }
+        };
+    }
+
+    private handleOperationMessage(envelope: MessageEnvelope): void {
+        if (!envelope.operation || !envelope.channel) {
+            return;
+        }
+
+        const operationKey = \`\${envelope.channel}:\${envelope.operation}\`;
+        const operationCallbacks = this.operationSubscriptions.get(operationKey);
+
+        if (operationCallbacks) {
+            operationCallbacks.forEach(callback => {
+                try {
+                    callback(envelope.payload);
+                } catch (error) {
+                    console.error(\`Error in operation callback for \${envelope.operation}:\`, error);
+                }
+            });
+        }
+    }
+
+    private sendUnsubscribeMessage(channel: string): void {
+        if (this.ws && this.ws.readyState === this.ws.OPEN) {
+            const unsubscribeMessage = {
+                type: 'unsubscribe',
+                channel,
+                timestamp: new Date().toISOString()
+            };
+            this.ws.send(JSON.stringify(unsubscribeMessage));
+        }
+    }
+
+    private handleMessage(data: string): void {
+        try {
+            const envelope: MessageEnvelope = JSON.parse(data);
+
+            // Handle response messages (with ID for request/response correlation)
+            if (envelope.id) {
+                const handler = this.responseHandlers.get(envelope.id);
+                if (handler) {
+                    this.responseHandlers.delete(envelope.id);
+                    if (envelope.error) {
+                        handler.reject(new TransportError(\`\${envelope.error.code}: \${envelope.error.message}\`));
+                    } else {
+                        handler.resolve(envelope.payload);
+                    }
+                }
+                return;
+            }
+
+            // Handle subscription messages (broadcast messages without correlation ID)
+            if (envelope.channel) {
+                const channelSubscriptions = this.subscriptions.get(envelope.channel);
+                if (channelSubscriptions) {
+                    channelSubscriptions.forEach(callback => {
+                        try {
+                            callback(envelope);
+                        } catch (error) {
+                            console.error(\`Error in subscription callback for channel \${envelope.channel}:\`, error);
+                        }
+                    });
+                }
+
+                // Also handle operation-based subscriptions
+                this.handleOperationMessage(envelope);
+            }
+        } catch (error) {
+            console.error('Failed to parse WebSocket message:', error);
+        }
+    }
+
+    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
+                });
+            }, this.reconnectDelay * this.reconnectAttempts);
+        }
+    }
+
+    private resubscribeAll(): void {
+        if (this.ws && this.ws.readyState === this.ws.OPEN) {
+            for (const channel of this.subscriptions.keys()) {
+                const subscribeMessage = {
+                    type: 'subscribe',
+                    channel,
+                    timestamp: new Date().toISOString()
+                };
+                this.ws.send(JSON.stringify(subscribeMessage));
+            }
+        }
+    }
+}`}
+        </File>
+    );
+}

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

@@ -0,0 +1,75 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="types.ts">
+            {`/**
+ * Standard message envelope for all AsyncAPI communications
+ */
+export interface MessageEnvelope {
+    operation: string;           // AsyncAPI operation ID
+    id?: string;                // Correlation ID for request/response
+    channel?: string;           // Optional channel context
+    payload: any;               // Message payload
+    timestamp?: string;         // Optional ISO 8601 timestamp
+    error?: {                   // Error information
+        code: string;
+        message: string;
+    };
+}
+
+/**
+ * Transport interface for sending and receiving messages
+ */
+export interface Transport {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(channel: string, envelope: MessageEnvelope, options?: RequestOptions): Promise<any>;
+    subscribe(channel: string, callback: (envelope: MessageEnvelope) => void): () => void;
+    unsubscribe(channel: string, callback?: (envelope: MessageEnvelope) => void): void;
+}
+
+/**
+ * Configuration for transport implementations
+ */
+export interface TransportConfig {
+    type: 'websocket' | 'http';
+    url: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+
+/**
+ * Options for individual requests
+ */
+export interface RequestOptions {
+    timeout?: number;
+    correlationId?: string;     // Override correlation ID
+}
+
+/**
+ * Internal response handler for request/response patterns
+ */
+export interface ResponseHandler {
+    resolve: (data: any) => void;
+    reject: (error: Error) => void;
+}
+
+/**
+ * Callback function for message subscriptions
+ */
+export type MessageCallback = (payload: any) => void;
+
+/**
+ * Function to unsubscribe from a channel
+ */
+export type UnsubscribeFunction = () => void;
+
+/**
+ * Envelope callback for transport-level message handling
+ */
+export type EnvelopeCallback = (envelope: MessageEnvelope) => void;`}
+        </File>
+    );
+}