@ioka-technologies/asyncapi-ts-client-template 0.0.21 → 0.0.23

package/package.json

@@ -1,14 +1,17 @@
 {
     "name": "@ioka-technologies/asyncapi-ts-client-template",
-    "version": "0.0.21",
+    "version": "0.0.23",
     "description": "TypeScript AsyncAPI client generator template compatible with rust-asyncapi patterns",
     "main": "template/index.js",
     "scripts": {
+        "build": "webpack --config ../webpack.config.js --env template=ts-client",
+        "build:dev": "webpack --config ../webpack.config.js --env template=ts-client --mode development",
+        "prepublishOnly": "npm run build",
         "test": "npm run test:generate",
-        "test:generate": "asyncapi generate fromTemplate examples/auth-retry/asyncapi.yaml . -o test-output-auth-retry --force-write && 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",
-        "test:simple": "asyncapi generate fromTemplate ../examples/simple/asyncapi.yaml . -o test-output-simple --force-write",
-        "clean": "rm -rf test-output-*"
+        "test:generate": "asyncapi generate fromTemplate examples/auth-retry/asyncapi.yaml ./ -o test-output-auth-retry --force-write && 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",
+        "test:simple": "asyncapi generate fromTemplate ../examples/simple/asyncapi.yaml ./ -o test-output-simple --force-write",
+        "clean": "rm -rf test-output-* dist"
     },
     "keywords": [
         "asyncapi",
@@ -22,6 +25,9 @@
     ],
     "author": "AsyncAPI TypeScript Generator",
     "license": "Apache-2.0",
+    "dependencies": {
+        "@asyncapi/generator-react-sdk": "^1.0.20"
+    },
     "devDependencies": {
         "@asyncapi/cli": "^1.18.0"
     },
@@ -86,6 +92,7 @@
     },
     "files": [
         "template/**/*",
+        "dist/common/**/*",
         "examples/**/*",
         "README.md",
         "USAGE.md",

package/template/helpers/security.js

@@ -1,78 +1,13 @@
 /**
  * Security analysis helper functions for TypeScript client template
- * Adapted from rust-server template helpers
+ * Most common security utilities have been moved to the shared @common package.
  */
 
-/**
- * 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;
-    }
-}
+import {
+    analyzeOperationSecurity,
+    operationHasSecurity,
+    hasSecuritySchemes
+} from "../dist/common/index.js";
 
 /**
  * Get security scheme type from AsyncAPI security scheme definition
@@ -80,7 +15,7 @@ export function hasSecuritySchemes(asyncapi) {
  * @param {object} securityScheme - AsyncAPI security scheme object
  * @returns {string} Security scheme type ('jwt', 'basic', 'apikey', etc.)
  */
-export function getSecuritySchemeType(securityScheme) {
+function getSecuritySchemeType(securityScheme) {
     try {
         if (securityScheme.type && typeof securityScheme.type === 'function') {
             return securityScheme.type();
@@ -103,7 +38,7 @@ export function getSecuritySchemeType(securityScheme) {
  * @param {object} asyncapi - AsyncAPI specification object
  * @returns {object} Map of operation names to their security requirements
  */
-export function extractOperationSecurityMap(asyncapi) {
+function extractOperationSecurityMap(asyncapi) {
     const securityMap = {};
 
     try {
@@ -135,3 +70,15 @@ export function extractOperationSecurityMap(asyncapi) {
 
     return securityMap;
 }
+
+// Export all functions
+export {
+    // Re-export common security utilities for backward compatibility
+    analyzeOperationSecurity,
+    operationHasSecurity as operationRequiresAuth,
+    hasSecuritySchemes,
+
+    // TypeScript client specific functions
+    getSecuritySchemeType,
+    extractOperationSecurityMap
+};

package/template/helpers/security.js.dev

@@ -0,0 +1,84 @@
+/**
+ * Security analysis helper functions for TypeScript client template
+ * Most common security utilities have been moved to the shared @common package.
+ */
+
+import {
+    analyzeOperationSecurity,
+    operationHasSecurity,
+    hasSecuritySchemes
+} from '../../../common/src/index.js';
+
+/**
+ * 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.)
+ */
+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
+ */
+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;
+}
+
+// Export all functions
+export {
+    // Re-export common security utilities for backward compatibility
+    analyzeOperationSecurity,
+    operationHasSecurity as operationRequiresAuth,
+    hasSecuritySchemes,
+
+    // TypeScript client specific functions
+    getSecuritySchemeType,
+    extractOperationSecurityMap
+};

package/template/index.js

@@ -1,7 +1,7 @@
-const { File } = require('@asyncapi/generator-react-sdk');
-const React = require('react');
+import { File } from '@asyncapi/generator-react-sdk';
+import React from 'react';
 
-module.exports = function ({ asyncapi, params }) {
+export default function ({ asyncapi, params }) {
     // Extract info from AsyncAPI spec
     let title, version, description;
     try {
@@ -272,4 +272,4 @@ ${params.license || 'Apache-2.0'}
 `
         )
     ];
-};
+}

package/template/src/client.ts.js

@@ -806,7 +806,7 @@ export default ${clientName};
     return content;
 }
 
-module.exports = function ({ asyncapi, params }) {
+export default function ({ asyncapi, params }) {
     const title = asyncapi.info().title();
 
     // Always use the processed title, ignore params.clientName if it contains template variables
@@ -824,4 +824,4 @@ module.exports = function ({ asyncapi, params }) {
             {generatedContent}
         </File>
     );
-};
+}

package/template/src/index.ts.js

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

package/template/src/models.ts.js

@@ -1,378 +1,21 @@
 /* eslint-disable no-unused-vars */
 import { File } from '@asyncapi/generator-react-sdk';
+import { generateTypeScriptModels } from '../../../common/src/index.js';
 
-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 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) {
-        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, fieldName = '') {
-        if (!schema) return 'any';
-
-        // Handle $ref - resolve from schema registry
-        if (schema.$ref) {
-            const refName = schema.$ref.split('/').pop();
-            // 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) {
-            // 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': {
-                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';
-        }
-    }
-
-    // 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, fieldName);
-            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 component schemas first (so they can be referenced by messages)
-    componentSchemas.forEach(schema => {
-        const doc = schema.description ? `/** ${schema.description} */\n` : `/** ${schema.name} */\n`;
-
-        // Check if this is a standalone enum schema
-        if (schema.schema.type === 'string' && schema.schema.enum && Array.isArray(schema.schema.enum)) {
-            // Generate union type for enum
-            const enumValues = schema.schema.enum.map(val => `'${val}'`).join(' | ');
-            content += `${doc}export type ${schema.typeName} = ${enumValues};\n\n`;
-        } else {
-            // Generate interface for object schema
-            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);
+export default function ({ asyncapi, params }) {
+    // Generate models using the common helper
+    const models = generateTypeScriptModels(asyncapi, {
+        includeMessageTypes: true // TypeScript client includes message type constants
     });
 
-    // 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 ${interfaceName} {\n`;
-        content += generateMessageInterface(schema.payload, schema.typeName);
-        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 += `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)}
+            {`// Generated TypeScript models from AsyncAPI specification
+
+${models.generateComponentSchemas()}
+${models.generateMessageSchemas()}
+${models.generateMessageTypes()}
+`}
         </File>
     );
-};
+}