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

package/template/index.js

@@ -38,70 +38,67 @@ module.exports = function ({ asyncapi, params }) {
         ? params.packageVersion
         : version;
 
-    const transports = (params.transports || 'websocket,http').split(',').map(t => t.trim());
-
     // Generate all files from the main index.js
     return [
-        React.createElement(File, { name: "package.json" },
+        React.createElement(File, { name: 'package.json' },
             JSON.stringify({
                 name: packageName,
                 version: packageVersion,
                 description: `${description || title} - TypeScript AsyncAPI Client`,
-                main: "dist/index.js",
-                types: "dist/index.d.ts",
+                main: 'dist/index.js',
+                types: 'dist/index.d.ts',
                 scripts: {
-                    build: "tsc",
-                    dev: "tsc --watch",
-                    test: "jest",
-                    lint: "eslint src/**/*.ts",
-                    prepare: "npm run build"
+                    build: 'tsc',
+                    dev: 'tsc --watch',
+                    test: 'jest',
+                    lint: 'eslint src/**/*.ts',
+                    prepare: 'npm run build'
                 },
                 keywords: [
-                    "asyncapi",
-                    "websocket",
-                    "http",
-                    "client",
-                    "typescript",
+                    'asyncapi',
+                    'websocket',
+                    'http',
+                    'client',
+                    'typescript',
                     title.toLowerCase().replace(/[^a-z0-9]/g, '-')
                 ],
-                author: params.author || "AsyncAPI Generator",
-                license: params.license || "Apache-2.0",
+                author: params.author || 'AsyncAPI Generator',
+                license: params.license || 'Apache-2.0',
                 dependencies: {
-                    uuid: "^9.0.0"
+                    uuid: '^9.0.0'
                 },
                 optionalDependencies: {
-                    ws: "^8.14.0"
+                    ws: '^8.14.0'
                 },
                 devDependencies: {
-                    "@types/ws": "^8.5.0",
-                    "@types/uuid": "^9.0.0",
-                    "@types/node": "^20.0.0",
-                    typescript: "^5.0.0",
-                    eslint: "^8.0.0",
-                    "@typescript-eslint/eslint-plugin": "^6.0.0",
-                    "@typescript-eslint/parser": "^6.0.0",
+                    '@types/ws': '^8.5.0',
+                    '@types/uuid': '^9.0.0',
+                    '@types/node': '^20.0.0',
+                    typescript: '^5.0.0',
+                    eslint: '^8.0.0',
+                    '@typescript-eslint/eslint-plugin': '^6.0.0',
+                    '@typescript-eslint/parser': '^6.0.0',
                     ...(params.generateTests && {
-                        jest: "^29.0.0",
-                        "@types/jest": "^29.0.0",
-                        "ts-jest": "^29.0.0"
+                        jest: '^29.0.0',
+                        '@types/jest': '^29.0.0',
+                        'ts-jest': '^29.0.0'
                     })
                 },
                 files: [
-                    "dist/**/*",
-                    "README.md",
-                    "USAGE.md"
+                    'dist/**/*',
+                    'README.md'
                 ]
             }, null, 2)
         ),
 
-        React.createElement(File, { name: "tsconfig.json" },
+        React.createElement(File, { name: 'tsconfig.json' },
             JSON.stringify({
                 compilerOptions: {
-                    target: "ES2020",
-                    module: "ES2020",
-                    lib: ["ES2020", "DOM"],
-                    outDir: "./dist",
-                    rootDir: "./src",
+                    target: 'ES2020',
+                    module: 'ES2020',
+                    lib: ['ES2020', 'DOM'],
+                    outDir: './dist',
+                    rootDir: './src',
                     strict: true,
                     esModuleInterop: true,
                     skipLibCheck: true,
@@ -109,75 +106,61 @@ module.exports = function ({ asyncapi, params }) {
                     declaration: true,
                     declarationMap: true,
                     sourceMap: true,
-                    moduleResolution: "node",
+                    moduleResolution: 'node',
                     allowSyntheticDefaultImports: true,
                     experimentalDecorators: true,
                     emitDecoratorMetadata: true,
                     resolveJsonModule: true,
-                    typeRoots: ["node_modules/@types"]
+                    typeRoots: ['node_modules/@types']
                 },
                 include: [
-                    "src/**/*"
+                    'src/**/*'
                 ],
                 exclude: [
-                    "node_modules",
-                    "dist",
-                    "**/*.test.ts",
-                    "**/*.spec.ts"
+                    'node_modules',
+                    'dist',
+                    '**/*.test.ts',
+                    '**/*.spec.ts'
                 ]
             }, null, 2)
         ),
 
-        React.createElement(File, { name: "README.md" },
+        React.createElement(File, { name: 'README.md' },
             `# ${title}
 
 ${description || 'Generated TypeScript AsyncAPI client'}
 
-## Installation
-
-\`\`\`bash
-npm install ${packageName}
-\`\`\`
-
-## Quick Start
-
-See [USAGE.md](./USAGE.md) for detailed usage instructions.
+## Overview
 
-## Generated from AsyncAPI
+This TypeScript client provides type-safe access to your AsyncAPI service with automatic transport selection and built-in error handling. Generated from your AsyncAPI specification, it offers seamless integration with both WebSocket and HTTP protocols.
 
-This client was generated from an AsyncAPI specification using the TypeScript AsyncAPI Client Generator.
+## Technical Requirements
 
-- AsyncAPI Version: ${asyncapi.version()}
-- Generated: ${new Date().toISOString()}
-`
-        ),
+- Node.js 16+
+- TypeScript 4.5+
 
-        React.createElement(File, { name: "USAGE.md" },
-            `# ${title} - Usage Guide
+## Supported Transports
 
-This document shows how to use the generated TypeScript AsyncAPI client.
+- WebSocket (with auto-reconnection)
+- HTTP (with retry logic)
 
 ## Installation
 
-### Browser Usage
-For browser environments, install the package normally:
-\`\`\`bash
-npm install ${packageName}
-\`\`\`
+### For Node.js Projects
 
-### Node.js Usage
-For Node.js environments, you'll also need the WebSocket library:
 \`\`\`bash
 npm install ${packageName} ws
 \`\`\`
 
-## Environment Compatibility
+### For Browser Projects
+
+\`\`\`bash
+npm install ${packageName}
+\`\`\`
 
-This client automatically detects the environment and uses the appropriate WebSocket implementation:
-- **Browser**: Uses the native \`WebSocket\` API
-- **Node.js**: Uses the \`ws\` library (must be installed separately)
+## Quick Start
 
-## WebSocket Usage
+### WebSocket Client
 
 \`\`\`typescript
 import { ${clientName} } from '${packageName}';
@@ -190,25 +173,16 @@ const client = new ${clientName}({
     }
 });
 
-// Connect to the WebSocket
+// Connect and send messages
 await client.connect();
-
-// Send a message and wait for response
-try {
-    const response = await client.sendMessage({
-        text: 'Hello, World!',
-        userId: '123'
-    });
-    console.log('Response:', response);
-} catch (error) {
-    console.error('Error:', error);
-}
-
-// Disconnect when done
-await client.disconnect();
+const response = await client.sendMessage({
+    text: 'Hello, World!',
+    userId: '123'
+});
+console.log('Response:', response);
 \`\`\`
 
-## HTTP Usage
+### HTTP Client
 
 \`\`\`typescript
 import { ${clientName} } from '${packageName}';
@@ -221,36 +195,24 @@ const client = new ${clientName}({
     }
 });
 
-// Send HTTP request
-try {
-    const response = await client.sendMessage({
-        text: 'Hello, World!',
-        userId: '123'
-    });
-    console.log('Response:', response);
-} catch (error) {
-    console.error('Error:', error);
-}
+const response = await client.sendMessage({
+    text: 'Hello, World!',
+    userId: '123'
+});
 \`\`\`
 
 ## Configuration Options
 
-\`\`\`typescript
-interface TransportConfig {
-    type: 'websocket' | 'http';
-    url: string;
-    headers?: Record<string, string>;
-    timeout?: number;
-}
-\`\`\`
+| Option | Type | Description | Default |
+|--------|------|-------------|---------|
+| \`type\` | \`'websocket' \\| 'http'\` | Transport protocol | Required |
+| \`url\` | \`string\` | Server URL | Required |
+| \`headers\` | \`Record<string, string>\` | Request headers | \`{}\` |
+| \`timeout\` | \`number\` | Request timeout (ms) | \`30000\` |
 
 ## Error Handling
 
-The client throws specific error types:
-
-- \`TransportError\`: General transport errors
-- \`ConnectionError\`: Connection-related errors
-- \`TimeoutError\`: Request timeout errors
+The client provides specific error types for different scenarios:
 
 \`\`\`typescript
 import { TransportError, ConnectionError, TimeoutError } from '${packageName}';
@@ -261,23 +223,52 @@ try {
     if (error instanceof ConnectionError) {
         console.error('Connection failed:', error.message);
     } else if (error instanceof TimeoutError) {
-        console.error('Request timed out:', error.message);
+        console.error('Request timed out');
     } else if (error instanceof TransportError) {
         console.error('Transport error:', error.message);
     }
 }
 \`\`\`
 
-## Troubleshooting
+## Environment Compatibility
+
+- **Browser**: Uses native WebSocket API (no additional dependencies)
+- **Node.js**: Requires \`ws\` package for WebSocket support
+
+## Development
 
-### WebSocket Issues in Node.js
-If you get an error like "WebSocket implementation not available", make sure you have installed the \`ws\` package:
 \`\`\`bash
-npm install ws
+# Build the project
+npm run build
+
+# Watch for changes
+npm run dev
+
+# Run tests
+npm test
+
+# Lint code
+npm run lint
 \`\`\`
 
-### Browser Compatibility
-The client uses the native WebSocket API in browsers, which is supported in all modern browsers. No additional dependencies are required.
+## Generated from AsyncAPI
+
+- **AsyncAPI Version**: ${asyncapi.version()}
+- **Generated**: ${new Date().toISOString()}
+- **Title**: ${title}
+- **Version**: ${packageVersion}
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes and add tests
+4. Run the test suite: \`npm test\`
+5. Submit a pull request
+
+## License
+
+${params.license || 'Apache-2.0'}
 `
         )
     ];

package/template/src/client.ts.js

@@ -1,5 +1,6 @@
 /* eslint-disable no-unused-vars */
 import { File } from '@asyncapi/generator-react-sdk';
+import { operationRequiresAuth, extractOperationSecurityMap } from '../helpers/security.js';
 
 function generateClient(asyncapi, clientName) {
     // Method name sanitization function
@@ -9,7 +10,7 @@ function generateClient(asyncapi, clientName) {
         // 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())
+            .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
@@ -42,6 +43,7 @@ function generateClient(asyncapi, clientName) {
 
     let content = `import { TransportFactory } from './runtime/transports/factory';
 import { Transport, TransportConfig, RequestOptions, MessageEnvelope } from './runtime/types';
+import { AuthCredentials } from './runtime/auth/types';
 import * as Models from './models';
 
 export class ${clientName} {
@@ -70,6 +72,26 @@ export class ${clientName} {
         this.transport.unsubscribe(channel, callback);
     }
 
+    /**
+     * Update authentication configuration
+     * @param auth New authentication configuration
+     */
+    updateAuth(auth: AuthCredentials): void {
+        this.config.auth = auth;
+        // If transport supports auth updates, update it
+        if (this.transport && typeof (this.transport as any).updateAuth === 'function') {
+            (this.transport as any).updateAuth(auth);
+        }
+    }
+
+    /**
+     * Get current authentication configuration
+     * @returns Current auth configuration
+     */
+    getAuth(): AuthCredentials | undefined {
+        return this.config.auth;
+    }
+
     // Generated operation methods
 `;
 
@@ -374,4 +396,4 @@ module.exports = function ({ asyncapi, params }) {
             {generatedContent}
         </File>
     );
-}
+};

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