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

package/template/src/models.ts.js

@@ -2,7 +2,7 @@
 import { File } from '@asyncapi/generator-react-sdk';
 
 function generateModels(asyncapi) {
-    let content = `// Generated TypeScript models from AsyncAPI specification\n\n`;
+    let content = '// Generated TypeScript models from AsyncAPI specification\n\n';
 
     // Helper functions for TypeScript identifier generation
     function toTypeScriptIdentifier(str) {
@@ -42,8 +42,104 @@ function generateModels(asyncapi) {
     // Extract message schemas and build channel mapping
     const components = asyncapi.components();
     const messageSchemas = [];
+    const componentSchemas = [];
     const messageToChannels = new Map();
     const generatedTypes = new Set();
+    const schemaRegistry = new Map();
+
+    // Build schema registry from components.schemas
+    // Try to access the raw AsyncAPI document
+    let rawDoc = null;
+    try {
+        if (asyncapi.json && typeof asyncapi.json === 'function') {
+            rawDoc = asyncapi.json();
+        } else if (asyncapi._json) {
+            rawDoc = asyncapi._json;
+        }
+    } catch (e) {
+        // Ignore
+    }
+
+    // Extract schemas from raw document if available
+    if (rawDoc && rawDoc.components && rawDoc.components.schemas) {
+        Object.entries(rawDoc.components.schemas).forEach(([name, schema]) => {
+            if (name && typeof name === 'string' && schema && typeof schema === 'object') {
+                schemaRegistry.set(name, schema);
+                componentSchemas.push({
+                    name,
+                    typeName: toTypeScriptTypeName(name),
+                    schema: schema,
+                    description: schema.description
+                });
+            }
+        });
+    }
+
+    // Fallback: try the components.schemas() method
+    if (componentSchemas.length === 0 && components && components.schemas) {
+        try {
+            const schemas = components.schemas();
+            if (schemas) {
+                // Try different ways to access schemas
+                let schemaEntries = [];
+
+                if (schemas instanceof Map) {
+                    schemaEntries = Array.from(schemas.entries());
+                } else if (typeof schemas === 'object') {
+                    schemaEntries = Object.entries(schemas);
+                } else if (schemas.all && typeof schemas.all === 'function') {
+                    // AsyncAPI parser might have an all() method
+                    const allSchemas = schemas.all();
+                    if (Array.isArray(allSchemas)) {
+                        schemaEntries = allSchemas.map(schema => {
+                            const name = schema.uid ? schema.uid() : (schema.id ? schema.id() : null);
+                            return [name, schema];
+                        }).filter(([name]) => name);
+                    }
+                }
+
+                schemaEntries.forEach(([name, schema]) => {
+                    // Skip internal AsyncAPI parser objects and numeric keys
+                    if (!name || name === 'collections' || name === '_meta' || name.startsWith('_') || /^\d+$/.test(name)) {
+                        return;
+                    }
+
+                    let schemaData = null;
+                    let description = null;
+
+                    try {
+                        // Handle different schema object types
+                        if (schema && typeof schema.json === 'function') {
+                            schemaData = schema.json();
+                        } else if (schema && typeof schema === 'object') {
+                            schemaData = schema;
+                        }
+
+                        if (schema && typeof schema.description === 'function') {
+                            description = schema.description();
+                        } else if (schema && schema.description) {
+                            description = schema.description;
+                        }
+                    } catch (e) {
+                        // Ignore schema extraction errors
+                        console.warn(`Failed to extract schema for ${name}:`, e.message);
+                    }
+
+                    if (schemaData && typeof name === 'string' && name.length > 0) {
+                        schemaRegistry.set(name, schemaData);
+                        componentSchemas.push({
+                            name,
+                            typeName: toTypeScriptTypeName(name),
+                            schema: schemaData,
+                            description
+                        });
+                    }
+                });
+            }
+        } catch (e) {
+            console.warn('Failed to extract component schemas:', e.message);
+        }
+    }
 
     // First, build channel to message mapping
     if (asyncapi.channels) {
@@ -126,13 +222,25 @@ function generateModels(asyncapi) {
     }
 
     // Helper function to convert JSON schema to TypeScript type
-    function jsonSchemaToTypeScriptType(schema) {
+    function jsonSchemaToTypeScriptType(schema, fieldName = '') {
         if (!schema) return 'any';
 
-        // Handle $ref
+        // Handle $ref - resolve from schema registry
         if (schema.$ref) {
             const refName = schema.$ref.split('/').pop();
-            return toTypeScriptTypeName(refName);
+            // Always return the type name for $ref, since we generate all component schemas
+            const typeName = toTypeScriptTypeName(refName);
+            return typeName;
+        }
+
+        // Handle resolved $ref - check for x-parser-schema-id which indicates original schema name
+        if (schema['x-parser-schema-id'] && typeof schema['x-parser-schema-id'] === 'string') {
+            const schemaId = schema['x-parser-schema-id'];
+            // Check if this matches a known component schema
+            if (schemaRegistry.has(schemaId)) {
+                const typeName = toTypeScriptTypeName(schemaId);
+                return typeName;
+            }
         }
 
         if (!schema.type) {
@@ -158,10 +266,19 @@ function generateModels(asyncapi) {
             case 'boolean':
                 return 'boolean';
             case 'array': {
-                const itemType = jsonSchemaToTypeScriptType(schema.items);
-                return `${itemType}[]`;
+                if (schema.items) {
+                    const itemType = jsonSchemaToTypeScriptType(schema.items, fieldName);
+                    return `${itemType}[]`;
+                }
+                return 'any[]';
             }
             case 'object':
+                // For objects with properties, we should generate inline types or check if it's a known schema
+                if (schema.properties) {
+                    // This is a complex object - for now return Record<string, any>
+                    // In a more sophisticated implementation, we could generate inline types
+                    return 'Record<string, any>';
+                }
                 return 'Record<string, any>';
             default:
                 return 'any';
@@ -175,7 +292,7 @@ function generateModels(asyncapi) {
         }
 
         const fields = Object.entries(schema.properties).map(([fieldName, fieldSchema]) => {
-            const tsType = jsonSchemaToTypeScriptType(fieldSchema);
+            const tsType = jsonSchemaToTypeScriptType(fieldSchema, fieldName);
             const optional = !schema.required || !schema.required.includes(fieldName);
             const optionalMarker = optional ? '?' : '';
 
@@ -190,31 +307,54 @@ function generateModels(asyncapi) {
         return fields;
     }
 
-    // Generate interfaces for each message
+    // Generate interfaces for component schemas first (so they can be referenced by messages)
+    componentSchemas.forEach(schema => {
+        const doc = schema.description ? `/** ${schema.description} */\n` : `/** ${schema.name} */\n`;
+
+        content += `${doc}export interface ${schema.typeName} {\n`;
+        content += generateMessageInterface(schema.schema, schema.typeName);
+        content += '\n}\n\n';
+
+        // Track generated types to avoid duplicates
+        generatedTypes.add(schema.typeName);
+    });
+
+    // Generate interfaces for each message (only if not already generated as component schema)
     messageSchemas.forEach(schema => {
+        const interfaceName = `${schema.typeName}Payload`;
+
+        // Check if this is a duplicate of a component schema
+        // For message payloads that match component schema names, skip the payload version
+        if (generatedTypes.has(schema.typeName) || generatedTypes.has(interfaceName)) {
+            // Skip generating the payload version if we already have the component schema
+            return;
+        }
+
         const doc = schema.description ? `/** ${schema.description} */\n` : `/** ${schema.name} message payload */\n`;
 
-        content += `${doc}export interface ${schema.typeName}Payload {\n`;
+        content += `${doc}export interface ${interfaceName} {\n`;
         content += generateMessageInterface(schema.payload, schema.typeName);
-        content += `\n}\n\n`;
+        content += '\n}\n\n';
+
+        generatedTypes.add(interfaceName);
     });
 
     // 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 += '/** 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`;
+        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 += '} as const;\n\n';
 
-        content += `/** Message type union */\n`;
-        content += `export type MessageType = typeof MessageTypes[keyof typeof MessageTypes];\n\n`;
+        content += '/** Message type union */\n';
+        content += 'export type MessageType = typeof MessageTypes[keyof typeof MessageTypes];\n\n';
     }
 
     return content;
@@ -226,4 +366,4 @@ module.exports = function ({ asyncapi, params }) {
             {generateModels(asyncapi)}
         </File>
     );
-}
+};

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