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

package/examples/auth-retry/login-flow-example.ts

@@ -0,0 +1,375 @@
+/**
+ * Login Flow Example - JWT Token Management
+ *
+ * This example demonstrates how to handle a typical authentication flow:
+ * 1. Start with no authentication (or basic auth for login)
+ * 2. Call userLogin operation
+ * 3. Extract JWT token from response
+ * 4. Update client auth configuration
+ * 5. Make authenticated requests with the JWT
+ */
+
+import React, { useState, useCallback, useEffect } from 'react';
+
+// These would be imported from your generated client
+// import { UserServiceClient } from './generated-client';
+// import { AuthError, UnauthorizedError, AuthCredentials } from './generated-client';
+
+// For this example, we'll use placeholder types and classes
+interface AuthCredentials {
+    jwt?: string;
+    basic?: {
+        username: string;
+        password: string;
+    };
+    apikey?: {
+        key: string;
+        location: 'header' | 'query';
+        name: string;
+    };
+}
+
+class UserServiceClient {
+    constructor(config: any) { }
+    async connect(): Promise<void> { }
+    async disconnect(): Promise<void> { }
+    async userLogin(payload: any): Promise<any> { return {}; }
+    async getUserProfile(payload: any): Promise<any> { return {}; }
+    async updateUserPreferences(payload: any): Promise<void> { }
+    userNotifications(callback: (notification: any) => void): () => void { return () => { }; }
+    updateAuth(auth: AuthCredentials): void { }
+    getAuth(): AuthCredentials | undefined { return {}; }
+}
+
+class AuthError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'AuthError';
+    }
+}
+
+class UnauthorizedError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'UnauthorizedError';
+    }
+}
+
+// Example login response type (this would be generated from your AsyncAPI spec)
+interface LoginResponse {
+    token: string;
+    user: {
+        id: string;
+        email: string;
+        name: string;
+    };
+    expiresAt: string;
+}
+
+// Example user profile type
+interface UserProfile {
+    id: string;
+    email: string;
+    name: string;
+    preferences: {
+        theme: string;
+        notifications: boolean;
+    };
+    lastLoginAt: string;
+}
+
+async function loginFlowExample() {
+    // Step 1: Create client without authentication (for login)
+    const client = new UserServiceClient({
+        type: 'http',
+        url: 'https://api.example.com',
+        retry: 'balanced'
+        // No auth configuration initially
+    });
+
+    await client.connect();
+
+    try {
+        // Step 2: Perform login (this operation doesn't require auth)
+        console.log('Logging in...');
+        const loginResponse: LoginResponse = await client.userLogin({
+            email: 'user@example.com',
+            password: 'mypassword'
+        });
+
+        console.log('Login successful!', loginResponse.user);
+
+        // Step 3: Update client auth configuration with JWT token
+        client.updateAuth({
+            jwt: loginResponse.token
+        });
+
+        console.log('Auth updated with JWT token');
+
+        // Step 4: Now make authenticated requests
+        // The JWT token will be automatically included in all subsequent requests
+        const userProfile: UserProfile = await client.getUserProfile({
+            userId: loginResponse.user.id
+        });
+
+        console.log('User profile retrieved:', userProfile);
+
+        // Step 5: Make other authenticated operations
+        await client.updateUserPreferences({
+            userId: loginResponse.user.id,
+            preferences: {
+                theme: 'dark',
+                notifications: true
+            }
+        });
+
+        console.log('User preferences updated');
+
+    } catch (error) {
+        if (error instanceof UnauthorizedError) {
+            console.error('Authentication failed:', error.message);
+            // Handle login failure - show login form again
+        } else if (error instanceof AuthError) {
+            console.error('Auth configuration error:', error.message);
+        } else {
+            console.error('Unexpected error:', error);
+        }
+    } finally {
+        await client.disconnect();
+    }
+}
+
+/**
+ * Advanced Login Flow with Token Refresh
+ *
+ * This example shows how to handle token refresh scenarios
+ */
+async function advancedLoginFlowExample() {
+    let currentToken: string | null = null;
+    let refreshToken: string | null = null;
+
+    const client = new UserServiceClient({
+        type: 'http',
+        url: 'https://api.example.com',
+        retry: 'balanced',
+        authCallbacks: {
+            onAuthError: async () => {
+                // Handle 401 errors by attempting token refresh
+                console.log('Auth error detected, attempting token refresh...');
+
+                if (refreshToken) {
+                    try {
+                        const refreshResponse = await refreshJwtToken(refreshToken);
+                        currentToken = refreshResponse.token;
+                        refreshToken = refreshResponse.refreshToken;
+
+                        // Update the client's auth configuration
+                        client.updateAuth({
+                            jwt: currentToken || undefined
+                        });
+
+                        console.log('Token refreshed successfully');
+                        return true; // Retry the original request
+                    } catch (refreshError) {
+                        console.error('Token refresh failed:', refreshError);
+                        // Redirect to login page
+                        return false;
+                    }
+                }
+
+                return false; // No refresh token available
+            }
+        }
+    });
+
+    await client.connect();
+
+    try {
+        // Initial login
+        const loginResponse = await client.userLogin({
+            email: 'user@example.com',
+            password: 'mypassword'
+        });
+
+        currentToken = loginResponse.token;
+        refreshToken = loginResponse.refreshToken; // Assuming your API provides refresh tokens
+
+        // Set initial auth
+        client.updateAuth({
+            jwt: currentToken || undefined
+        });
+
+        // Make authenticated requests - token refresh will be handled automatically
+        const userProfile = await client.getUserProfile({
+            userId: loginResponse.user.id
+        });
+
+        console.log('User profile:', userProfile);
+
+    } catch (error) {
+        console.error('Login flow failed:', error);
+    } finally {
+        await client.disconnect();
+    }
+}
+
+/**
+ * WebSocket Login Flow Example
+ *
+ * For WebSocket connections, you typically need to reconnect after updating auth
+ */
+async function websocketLoginFlowExample() {
+    // Step 1: Create WebSocket client without auth
+    const client = new UserServiceClient({
+        type: 'websocket',
+        url: 'wss://api.example.com/ws',
+        retry: 'balanced'
+    });
+
+    await client.connect();
+
+    try {
+        // Step 2: Login via WebSocket
+        const loginResponse: LoginResponse = await client.userLogin({
+            email: 'user@example.com',
+            password: 'mypassword'
+        });
+
+        console.log('Login successful via WebSocket');
+
+        // Step 3: Disconnect and reconnect with auth
+        await client.disconnect();
+
+        client.updateAuth({
+            jwt: loginResponse.token
+        });
+
+        await client.connect(); // Reconnect with auth headers
+
+        // Step 4: Subscribe to authenticated events
+        const unsubscribe = client.userNotifications((notification) => {
+            console.log('Received notification:', notification);
+        });
+
+        // Step 5: Make authenticated requests
+        const userProfile = await client.getUserProfile({
+            userId: loginResponse.user.id
+        });
+
+        console.log('User profile:', userProfile);
+
+        // Clean up
+        setTimeout(() => {
+            unsubscribe();
+            client.disconnect();
+        }, 30000);
+
+    } catch (error) {
+        console.error('WebSocket login flow failed:', error);
+        await client.disconnect();
+    }
+}
+
+/**
+ * React Hook Example for Login Flow
+ */
+function useAuthenticatedClient() {
+    const [client, setClient] = useState(null as UserServiceClient | null);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [user, setUser] = useState(null as any);
+
+    const initializeClient = useCallback(() => {
+        const newClient = new UserServiceClient({
+            type: 'http',
+            url: process.env.REACT_APP_API_URL || 'https://api.example.com',
+            retry: 'balanced',
+            authCallbacks: {
+                onAuthError: async () => {
+                    // Handle auth errors by clearing auth state
+                    setIsAuthenticated(false);
+                    setUser(null);
+                    return false;
+                }
+            }
+        });
+
+        newClient.connect();
+        setClient(newClient);
+        return newClient;
+    }, []);
+
+    const login = useCallback(async (email: string, password: string) => {
+        const currentClient = client || initializeClient();
+
+        try {
+            const loginResponse = await currentClient.userLogin({ email, password });
+
+            // Update auth configuration
+            currentClient.updateAuth({
+                jwt: loginResponse.token
+            });
+
+            setIsAuthenticated(true);
+            setUser(loginResponse.user);
+
+            return loginResponse;
+        } catch (error) {
+            console.error('Login failed:', error);
+            throw error;
+        }
+    }, [client, initializeClient]);
+
+    const logout = useCallback(async () => {
+        if (client) {
+            // Clear auth
+            client.updateAuth({});
+            await client.disconnect();
+        }
+
+        setIsAuthenticated(false);
+        setUser(null);
+        setClient(null);
+    }, [client]);
+
+    useEffect(() => {
+        return () => {
+            if (client) {
+                client.disconnect();
+            }
+        };
+    }, [client]);
+
+    return {
+        client,
+        isAuthenticated,
+        user,
+        login,
+        logout,
+        initializeClient
+    };
+}
+
+// Helper function for token refresh (implement based on your API)
+async function refreshJwtToken(refreshToken: string): Promise<{ token: string; refreshToken: string }> {
+    const response = await fetch('/api/auth/refresh', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ refreshToken })
+    });
+
+    if (!response.ok) {
+        throw new Error('Token refresh failed');
+    }
+
+    return response.json();
+}
+
+// Export examples
+export {
+    loginFlowExample,
+    advancedLoginFlowExample,
+    websocketLoginFlowExample,
+    useAuthenticatedClient
+};

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@ioka-technologies/asyncapi-ts-client-template",
-    "version": "0.0.7",
+    "version": "0.0.10",
     "description": "TypeScript AsyncAPI client generator template compatible with rust-asyncapi patterns",
     "main": "template/index.js",
     "scripts": {
         "test": "npm run test:generate",
-        "test:generate": "asyncapi generate fromTemplate examples/simple/asyncapi.yaml . -o test-output-simple --force-write -p enableAuth=true",
+        "test:generate": "asyncapi generate fromTemplate examples/auth-retry/asyncapi.yaml . -o test-output-auth-retry --force-write -p enableAuth=true && cd test-output-auth-retry && npm install && npm run build",
+        "test:realworld": "asyncapi generate fromTemplate ../examples/realworld/asyncapi.yaml . -o test-output-realworld --force-write -p enableAuth=true",
         "clean": "rm -rf test-output-*"
     },
     "keywords": [

package/template/helpers/security.js

@@ -0,0 +1,137 @@
+/**
+ * Security analysis helper functions for TypeScript client template
+ * Adapted from rust-server template helpers
+ */
+
+/**
+ * Analyzes operation security requirements from AsyncAPI specification
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {object} Security analysis result
+ */
+export function analyzeOperationSecurity(operation) {
+    try {
+        // Check AsyncAPI security field
+        const security = operation.security && operation.security();
+        if (security && Array.isArray(security) && security.length > 0) {
+            return {
+                hasSecurityRequirements: true,
+                securitySchemes: security,
+                requiresAuthentication: true
+            };
+        }
+
+        // Check if operation has security defined in AsyncAPI spec
+        const operationJson = operation._json || operation;
+        if (operationJson.security && Array.isArray(operationJson.security) && operationJson.security.length > 0) {
+            return {
+                hasSecurityRequirements: true,
+                securitySchemes: operationJson.security,
+                requiresAuthentication: true
+            };
+        }
+
+        return {
+            hasSecurityRequirements: false,
+            securitySchemes: [],
+            requiresAuthentication: false
+        };
+    } catch (e) {
+        return {
+            hasSecurityRequirements: false,
+            securitySchemes: [],
+            requiresAuthentication: false
+        };
+    }
+}
+
+/**
+ * Checks if an operation has security requirements
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation has security requirements
+ */
+export function operationRequiresAuth(operation) {
+    const analysis = analyzeOperationSecurity(operation);
+    return analysis.hasSecurityRequirements;
+}
+
+/**
+ * Checks if the AsyncAPI specification has security schemes defined
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {boolean} True if security schemes are present
+ */
+export function hasSecuritySchemes(asyncapi) {
+    try {
+        const components = asyncapi.components();
+        if (!components) return false;
+
+        const securitySchemes = components.securitySchemes();
+        return securitySchemes && Object.keys(securitySchemes).length > 0;
+    } catch (e) {
+        return false;
+    }
+}
+
+/**
+ * Get security scheme type from AsyncAPI security scheme definition
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @returns {string} Security scheme type ('jwt', 'basic', 'apikey', etc.)
+ */
+export function getSecuritySchemeType(securityScheme) {
+    try {
+        if (securityScheme.type && typeof securityScheme.type === 'function') {
+            return securityScheme.type();
+        }
+        if (securityScheme.type) {
+            return securityScheme.type;
+        }
+        if (securityScheme._json && securityScheme._json.type) {
+            return securityScheme._json.type;
+        }
+        return 'unknown';
+    } catch (e) {
+        return 'unknown';
+    }
+}
+
+/**
+ * Extract security requirements for all operations in the AsyncAPI spec
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Map of operation names to their security requirements
+ */
+export function extractOperationSecurityMap(asyncapi) {
+    const securityMap = {};
+
+    try {
+        const operations = asyncapi.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
+                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) {
+                    const securityAnalysis = analyzeOperationSecurity(operation);
+                    securityMap[operationId] = securityAnalysis;
+                }
+            });
+        }
+    } catch (e) {
+        console.warn('Error extracting operation security map:', e.message);
+    }
+
+    return securityMap;
+}

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