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

package/template/src/client.ts.js

@@ -0,0 +1,377 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+function generateClient(asyncapi, clientName) {
+    // Method name sanitization function
+    function sanitizeMethodName(operationId) {
+        if (!operationId) return 'unknownOperation';
+
+        // Convert to camelCase and remove invalid characters
+        let sanitized = operationId
+            // Replace dots, hyphens, underscores, spaces, and forward slashes with camelCase
+            .replace(/[.\-_\s\/]+(.)/g, (_, char) => char.toUpperCase())
+            // Remove any remaining invalid characters
+            .replace(/[^a-zA-Z0-9]/g, '')
+            // Ensure it starts with a lowercase letter if it starts with a number
+            .replace(/^[^a-zA-Z]/, 'operation')
+            // Ensure first character is lowercase
+            .replace(/^[A-Z]/, char => char.toLowerCase());
+
+        // Handle JavaScript reserved words
+        const JS_RESERVED_WORDS = [
+            'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default',
+            'delete', 'do', 'else', 'export', 'extends', 'finally', 'for', 'function',
+            'if', 'import', 'in', 'instanceof', 'new', 'return', 'super', 'switch',
+            'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield',
+            'let', 'static', 'enum', 'implements', 'package', 'protected', 'interface',
+            'private', 'public', 'async', 'await'
+        ];
+
+        if (JS_RESERVED_WORDS.includes(sanitized)) {
+            sanitized = 'operation' + sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
+        }
+
+        // Handle conflicts with existing class methods
+        const CLASS_METHOD_NAMES = ['connect', 'disconnect', 'unsubscribe', 'constructor'];
+        if (CLASS_METHOD_NAMES.includes(sanitized)) {
+            sanitized = sanitized + 'Operation';
+        }
+
+        return sanitized;
+    }
+
+    let content = `import { TransportFactory } from './runtime/transports/factory';
+import { Transport, TransportConfig, RequestOptions, MessageEnvelope } from './runtime/types';
+import * as Models from './models';
+
+export class ${clientName} {
+    private transport: Transport;
+    private config: TransportConfig;
+
+    constructor(config: TransportConfig) {
+        this.config = config;
+        this.transport = TransportFactory.create(config);
+    }
+
+    async connect(): Promise<void> {
+        await this.transport.connect();
+    }
+
+    async disconnect(): Promise<void> {
+        await this.transport.disconnect();
+    }
+
+    /**
+     * Unsubscribe from a specific channel
+     * @param channel Channel to unsubscribe from
+     * @param callback Optional specific callback to remove
+     */
+    unsubscribe(channel: string, callback?: (payload: any) => void): void {
+        this.transport.unsubscribe(channel, callback);
+    }
+
+    // Generated operation methods
+`;
+
+    // Generate methods for each operation (AsyncAPI v3.0.0)
+    if (asyncapi.operations) {
+        const operations = asyncapi.operations();
+        if (operations) {
+            // Handle AsyncAPI parser collection - use .all() method to get array
+            const operationArray = operations.all ? operations.all() : Object.values(operations);
+            operationArray.forEach((operation) => {
+                // Get operation ID from the operation object
+                let operationId = null;
+                if (operation._meta && operation._meta.id) {
+                    operationId = operation._meta.id;
+                } else if (operation.id && typeof operation.id === 'function') {
+                    operationId = operation.id();
+                } else if (operation.id) {
+                    operationId = operation.id;
+                }
+
+                if (!operationId) {
+                    return;
+                }
+                try {
+                    // Get the channel reference
+                    let channelRef = null;
+                    let channelAddress = null;
+
+                    // Get channel information from embedded channel data (AsyncAPI v3.x approach)
+                    const embeddedChannel = operation._json && operation._json.channel;
+
+                    if (embeddedChannel) {
+                        // Get the channel unique object ID
+                        const embeddedChannelId = embeddedChannel['x-parser-unique-object-id'];
+
+                        if (embeddedChannelId) {
+                            // Find the channel by its ID
+                            const channels = asyncapi.channels();
+
+                            // Look for the channel with matching ID
+                            for (const [channelKey, channel] of Object.entries(channels || {})) {
+                                if (channel.id && channel.id() === embeddedChannelId) {
+                                    if (channel.address && typeof channel.address === 'function') {
+                                        channelAddress = channel.address();
+                                    } else if (channel.address) {
+                                        channelAddress = channel.address;
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    // Fallback: try to get channel from $ref (AsyncAPI v2.x approach)
+                    if (!channelAddress && operation._json && operation._json.channel && operation._json.channel.$ref) {
+                        channelRef = operation._json.channel.$ref;
+
+                        const channelName = channelRef.split('/').pop();
+
+                        const channels = asyncapi.channels();
+                        if (channels && channels[channelName]) {
+                            const channel = channels[channelName];
+                            if (channel.address && typeof channel.address === 'function') {
+                                channelAddress = channel.address();
+                            } else if (channel.address) {
+                                channelAddress = channel.address;
+                            }
+                        }
+                    }
+
+                    // Get the action (send/receive)
+                    let action = 'send';
+                    if (operation.action && typeof operation.action === 'function') {
+                        action = operation.action();
+                    } else if (operation.action) {
+                        action = operation.action;
+                    }
+
+                    // Get message types for this operation
+                    let messageTypes = [];
+                    try {
+                        if (operation.messages && typeof operation.messages === 'function') {
+                            const messages = operation.messages();
+                            if (messages && typeof messages.all === 'function') {
+                                // Handle AsyncAPI parser collection
+                                const messageArray = messages.all();
+                                messageTypes = messageArray.map(msg => {
+                                    // Try to get message name from various sources
+                                    if (msg.name && typeof msg.name === 'function') {
+                                        return msg.name();
+                                    } else if (msg.name) {
+                                        return msg.name;
+                                    } else if (msg._json && msg._json.name) {
+                                        return msg._json.name;
+                                    } else if (msg.$ref) {
+                                        return msg.$ref.split('/').pop();
+                                    }
+                                    return null;
+                                }).filter(Boolean);
+                            } else if (Array.isArray(messages)) {
+                                messageTypes = messages.map(msg => {
+                                    // Try to get message name from various sources
+                                    if (msg.name && typeof msg.name === 'function') {
+                                        return msg.name();
+                                    } else if (msg.name) {
+                                        return msg.name;
+                                    } else if (msg._json && msg._json.name) {
+                                        return msg._json.name;
+                                    } else if (msg.$ref) {
+                                        return msg.$ref.split('/').pop();
+                                    }
+                                    return null;
+                                }).filter(Boolean);
+                            }
+                        } else if (operation.messages && Array.isArray(operation.messages)) {
+                            messageTypes = operation.messages.map(msg => {
+                                // Try to get message name from various sources
+                                if (msg.name && typeof msg.name === 'function') {
+                                    return msg.name();
+                                } else if (msg.name) {
+                                    return msg.name;
+                                } else if (msg._json && msg._json.name) {
+                                    return msg._json.name;
+                                } else if (msg.$ref) {
+                                    return msg.$ref.split('/').pop();
+                                }
+                                return null;
+                            }).filter(Boolean);
+                        }
+
+                        // Fallback: try to get from operation._json.messages
+                        if (messageTypes.length === 0 && operation._json && operation._json.messages) {
+                            messageTypes = operation._json.messages.map(msg => {
+                                if (msg.name) {
+                                    return msg.name;
+                                } else if (msg['x-parser-unique-object-id']) {
+                                    return msg['x-parser-unique-object-id'];
+                                }
+                                return null;
+                            }).filter(Boolean);
+                        }
+                    } catch (msgError) {
+                        // If we can't get messages, try to infer from channel
+                    }
+
+                    if (channelAddress) {
+                        if (action === 'send') {
+                            // Check if this is a request/response pattern
+                            let hasReply = false;
+                            let replyMessageTypes = [];
+
+                            // Try multiple ways to access reply information
+                            try {
+                                // Method 1: Check operation.reply() function
+                                if (operation.reply && typeof operation.reply === 'function') {
+                                    const reply = operation.reply();
+                                    if (reply) {
+                                        hasReply = true;
+
+                                        // Get reply messages
+                                        if (reply.messages && typeof reply.messages === 'function') {
+                                            const replyMessages = reply.messages();
+                                            if (replyMessages && typeof replyMessages.all === 'function') {
+                                                const messageArray = replyMessages.all();
+                                                replyMessageTypes = messageArray.map(msg => {
+                                                    if (msg.name && typeof msg.name === 'function') {
+                                                        return msg.name();
+                                                    } else if (msg.name) {
+                                                        return msg.name;
+                                                    } else if (msg._json && msg._json.name) {
+                                                        return msg._json.name;
+                                                    } else if (msg.$ref) {
+                                                        return msg.$ref.split('/').pop();
+                                                    }
+                                                    return null;
+                                                }).filter(Boolean);
+                                            }
+                                        }
+                                    }
+                                }
+
+                                // Method 2: Check operation._json.reply
+                                if (!hasReply && operation._json && operation._json.reply) {
+                                    hasReply = true;
+                                    const reply = operation._json.reply;
+
+                                    if (reply.messages) {
+                                        replyMessageTypes = reply.messages.map(msg => {
+                                            if (msg.$ref) {
+                                                return msg.$ref.split('/').pop();
+                                            }
+                                            return null;
+                                        }).filter(Boolean);
+                                    }
+                                }
+
+                            } catch (replyError) {
+                                // Could not get reply messages for operation
+                            }
+
+                            // Sanitize the method name
+                            const methodName = sanitizeMethodName(operationId);
+
+                            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';
+
+                                content += `
+    /**
+     * ${methodName} - Request/Response operation
+     * Original operation: ${operationId}
+     * Channel: ${channelAddress}
+     * @param payload Request payload
+     * @param options Request options
+     * @returns Promise that resolves with the response
+     */
+    async ${methodName}(payload: ${requestPayloadType}, options?: RequestOptions): Promise<${responseType}> {
+        const envelope: MessageEnvelope = {
+            operation: '${operationId}',
+            payload,
+            channel: '${channelAddress}'
+        };
+        return this.transport.send('${channelAddress}', envelope, options);
+    }
+`;
+                            } else {
+                                // Regular send operation (fire and forget)
+                                const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
+                                content += `
+    /**
+     * ${methodName} - Send operation (fire and forget)
+     * Original operation: ${operationId}
+     * Channel: ${channelAddress}
+     */
+    async ${methodName}(payload: ${payloadType}, options?: RequestOptions): Promise<void> {
+        const envelope: MessageEnvelope = {
+            operation: '${operationId}',
+            payload,
+            channel: '${channelAddress}'
+        };
+        await this.transport.send('${channelAddress}', envelope, options);
+    }
+`;
+                            }
+                        } else if (action === 'receive') {
+                            // Sanitize the method name
+                            const methodName = sanitizeMethodName(operationId);
+
+                            // Generate receive method (event listener setup)
+                            const payloadType = messageTypes.length > 0 ? `Models.${messageTypes[0]}Payload` : 'any';
+                            content += `
+    /**
+     * ${methodName} - Receive operation
+     * Original operation: ${operationId}
+     * Channel: ${channelAddress}
+     * @param callback Function to call when a message is received
+     * @returns Unsubscribe function to stop listening for messages
+     */
+    ${methodName}(callback: (payload: ${payloadType}) => void): () => void {
+        return this.transport.subscribe('${channelAddress}', (envelope: MessageEnvelope) => {
+            // Filter by operation to ensure we only handle messages for this specific operation
+            if (envelope.operation === '${operationId}') {
+                callback(envelope.payload);
+            }
+        });
+    }
+`;
+                        }
+                    }
+                } catch (error) {
+                    // Skip operations that can't be processed
+                }
+            });
+        }
+    }
+
+    content += `
+}
+
+export default ${clientName};
+`;
+
+    return content;
+}
+
+module.exports = function ({ asyncapi, params }) {
+    const title = asyncapi.info().title();
+
+    // Always use the processed title, ignore params.clientName if it contains template variables
+    let clientName = `${title.replace(/[^a-zA-Z0-9]/g, '')}Client`;
+
+    // Only use params.clientName if it doesn't contain template variables
+    if (params.clientName && !params.clientName.includes('{{')) {
+        clientName = params.clientName;
+    }
+
+    const generatedContent = generateClient(asyncapi, clientName);
+
+    return (
+        <File name="client.ts">
+            {generatedContent}
+        </File>
+    );
+}

package/template/src/index.ts.js

@@ -0,0 +1,13 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="index.ts">
+            {`export * from './client';
+export * from './models';
+export * from './runtime/types';
+export * from './runtime/errors';`}
+        </File>
+    );
+}

package/template/src/models.ts.js

@@ -0,0 +1,229 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+function generateModels(asyncapi) {
+    let content = `// Generated TypeScript models from AsyncAPI specification\n\n`;
+
+    // Helper functions for TypeScript identifier generation
+    function toTypeScriptIdentifier(str) {
+        if (!str) return 'unknown';
+        let identifier = str
+            .replace(/[^a-zA-Z0-9_]/g, '_')
+            .replace(/^[0-9]/, '_$&')
+            .replace(/_+/g, '_')
+            .replace(/^_+|_+$/g, '');
+        if (/^[0-9]/.test(identifier)) {
+            identifier = 'Item' + identifier;
+        }
+        if (!identifier) {
+            identifier = 'unknown';
+        }
+        return identifier;
+    }
+
+    function toTypeScriptTypeName(str) {
+        if (!str) return 'Unknown';
+        // Handle camelCase and PascalCase properly
+        const identifier = str
+            .replace(/[^a-zA-Z0-9]/g, '_')
+            .replace(/^[0-9]/, '_$&')
+            .replace(/_+/g, '_')
+            .replace(/^_+|_+$/g, '');
+
+        // Split on underscores and camelCase boundaries
+        const parts = identifier.split(/[_\s]+|(?=[A-Z])/);
+
+        return parts
+            .filter(part => part.length > 0)
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
+    }
+
+    // Extract message schemas and build channel mapping
+    const components = asyncapi.components();
+    const messageSchemas = [];
+    const messageToChannels = new Map();
+    const generatedTypes = new Set();
+
+    // First, build channel to message mapping
+    if (asyncapi.channels) {
+        const channels = asyncapi.channels();
+        if (channels) {
+            Object.entries(channels).forEach(([channelName, channel]) => {
+                try {
+                    // Handle AsyncAPI 3.x format
+                    if (channel.messages) {
+                        const messages = channel.messages();
+                        if (messages) {
+                            Object.entries(messages).forEach(([msgKey, message]) => {
+                                if (message) {
+                                    let messageName = null;
+                                    if (message.$ref) {
+                                        messageName = message.$ref.split('/').pop();
+                                    } else if (message.name) {
+                                        messageName = typeof message.name === 'function' ? message.name() : message.name;
+                                    }
+
+                                    if (messageName) {
+                                        if (!messageToChannels.has(messageName)) {
+                                            messageToChannels.set(messageName, []);
+                                        }
+                                        messageToChannels.get(messageName).push(channelName);
+                                    }
+                                }
+                            });
+                        }
+                    }
+                } catch (e) {
+                    // Ignore channel processing errors
+                }
+            });
+        }
+    }
+
+    // Extract messages from components
+    if (components && components.messages) {
+        const messages = components.messages();
+        if (messages) {
+            Object.entries(messages).forEach(([name, message]) => {
+                // Skip internal AsyncAPI parser objects
+                if (name === 'collections' || name === '_meta' || name.startsWith('_')) {
+                    return;
+                }
+                let payload = null;
+                let description = null;
+                let title = null;
+                let messageName = name;
+
+                try {
+                    if (message.payload && typeof message.payload === 'function') {
+                        const payloadSchema = message.payload();
+                        payload = payloadSchema && payloadSchema.json ? payloadSchema.json() : payloadSchema;
+                    }
+                    description = message.description && typeof message.description === 'function' ? message.description() : message.description;
+                    title = message.title && typeof message.title === 'function' ? message.title() : message.title;
+
+                    // Try to get the actual message name
+                    if (message.name && typeof message.name === 'function') {
+                        messageName = message.name();
+                    } else if (message.name) {
+                        messageName = message.name;
+                    }
+                } catch (e) {
+                    // Ignore payload extraction errors
+                }
+
+                const channels = messageToChannels.get(messageName) || messageToChannels.get(name) || [];
+                messageSchemas.push({
+                    name: messageName,
+                    typeName: toTypeScriptTypeName(messageName),
+                    payload,
+                    description: description || title,
+                    channels
+                });
+            });
+        }
+    }
+
+    // Helper function to convert JSON schema to TypeScript type
+    function jsonSchemaToTypeScriptType(schema) {
+        if (!schema) return 'any';
+
+        // Handle $ref
+        if (schema.$ref) {
+            const refName = schema.$ref.split('/').pop();
+            return toTypeScriptTypeName(refName);
+        }
+
+        if (!schema.type) {
+            // If no type specified, check for properties (object) or items (array)
+            if (schema.properties) {
+                schema.type = 'object';
+            } else if (schema.items) {
+                schema.type = 'array';
+            } else {
+                return 'any';
+            }
+        }
+
+        switch (schema.type) {
+            case 'string':
+                if (schema.enum && schema.enum.length > 0) {
+                    return schema.enum.map(val => `'${val}'`).join(' | ');
+                }
+                return 'string';
+            case 'integer':
+            case 'number':
+                return 'number';
+            case 'boolean':
+                return 'boolean';
+            case 'array': {
+                const itemType = jsonSchemaToTypeScriptType(schema.items);
+                return `${itemType}[]`;
+            }
+            case 'object':
+                return 'Record<string, any>';
+            default:
+                return 'any';
+        }
+    }
+
+    // Generate message interfaces
+    function generateMessageInterface(schema, messageName) {
+        if (!schema || !schema.properties) {
+            return '  [key: string]: any;';
+        }
+
+        const fields = Object.entries(schema.properties).map(([fieldName, fieldSchema]) => {
+            const tsType = jsonSchemaToTypeScriptType(fieldSchema);
+            const optional = !schema.required || !schema.required.includes(fieldName);
+            const optionalMarker = optional ? '?' : '';
+
+            let fieldDoc = '';
+            if (fieldSchema.description) {
+                fieldDoc = `  /** ${fieldSchema.description} */\n`;
+            }
+
+            return `${fieldDoc}  ${fieldName}${optionalMarker}: ${tsType};`;
+        }).join('\n');
+
+        return fields;
+    }
+
+    // Generate interfaces for each message
+    messageSchemas.forEach(schema => {
+        const doc = schema.description ? `/** ${schema.description} */\n` : `/** ${schema.name} message payload */\n`;
+
+        content += `${doc}export interface ${schema.typeName}Payload {\n`;
+        content += generateMessageInterface(schema.payload, schema.typeName);
+        content += `\n}\n\n`;
+    });
+
+    // Generate a union type for all message payloads
+    if (messageSchemas.length > 0) {
+        const payloadTypes = messageSchemas.map(schema => `${schema.typeName}Payload`).join(' | ');
+        content += `/** Union type for all message payloads */\n`;
+        content += `export type MessagePayload = ${payloadTypes};\n\n`;
+
+        // Generate message type constants
+        content += `/** Message type constants */\n`;
+        content += `export const MessageTypes = {\n`;
+        messageSchemas.forEach(schema => {
+            content += `  ${schema.typeName.toUpperCase()}: '${schema.name}',\n`;
+        });
+        content += `} as const;\n\n`;
+
+        content += `/** Message type union */\n`;
+        content += `export type MessageType = typeof MessageTypes[keyof typeof MessageTypes];\n\n`;
+    }
+
+    return content;
+}
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="models.ts">
+            {generateModels(asyncapi)}
+        </File>
+    );
+}

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

@@ -0,0 +1,29 @@
+/* eslint-disable no-unused-vars */
+import { File } from '@asyncapi/generator-react-sdk';
+
+module.exports = function ({ asyncapi, params }) {
+    return (
+        <File name="errors.ts">
+            {`export class TransportError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'TransportError';
+    }
+}
+
+export class ConnectionError extends TransportError {
+    constructor(message: string) {
+        super(message);
+        this.name = 'ConnectionError';
+    }
+}
+
+export class TimeoutError extends TransportError {
+    constructor(message: string) {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}`}
+        </File>
+    );
+}

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

@@ -0,0 +1,33 @@
+/* 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());
+
+    let imports = `import { Transport, TransportConfig } from '../types';\n`;
+    let cases = '';
+
+    if (transports.includes('websocket')) {
+        imports += `import { WebSocketTransport } from './websocket';\n`;
+        cases += `            case 'websocket': return new WebSocketTransport(config);\n`;
+    }
+
+    if (transports.includes('http')) {
+        imports += `import { HttpTransport } from './http';\n`;
+        cases += `            case 'http': return new HttpTransport(config);\n`;
+    }
+
+    return (
+        <File name="factory.ts">
+            {`${imports}
+export class TransportFactory {
+    static create(config: TransportConfig): Transport {
+        switch (config.type) {
+${cases}            default:
+                throw new Error(\`Unsupported transport type: \${config.type}\`);
+        }
+    }
+}`}
+        </File>
+    );
+}