@ioka-technologies/asyncapi-rust-client-template 0.0.20 → 0.0.22

package/dist/common/index.js

@@ -0,0 +1,2004 @@
+/******/ // The require scope
+/******/ var __webpack_require__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+var __webpack_exports__ = {};
+
+;// ../common/src/string-utils.js
+/**
+ * String conversion utilities for AsyncAPI template generation
+ *
+ * This module provides consistent string conversion functions used across
+ * multiple AsyncAPI templates to ensure naming conventions are standardized.
+ */
+
+/**
+ * Converts a string to a valid Rust identifier
+ * Handles special characters, keywords, and ensures valid Rust naming conventions
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} Valid Rust identifier
+ */
+function toRustIdentifier(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';
+  }
+  const rustKeywords = ['as', 'break', 'const', 'continue', 'crate', 'else', 'enum', 'extern', 'false', 'fn', 'for', 'if', 'impl', 'in', 'let', 'loop', 'match', 'mod', 'move', 'mut', 'pub', 'ref', 'return', 'self', 'Self', 'static', 'struct', 'super', 'trait', 'true', 'type', 'unsafe', 'use', 'where', 'while', 'async', 'await', 'dyn'];
+  if (rustKeywords.includes(identifier)) {
+    identifier = identifier + '_';
+  }
+  return identifier;
+}
+
+/**
+ * Converts a string to PascalCase Rust type name
+ * Handles camelCase, snake_case, and kebab-case inputs
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} PascalCase Rust type name
+ */
+function toRustTypeName(str) {
+  if (!str) return 'Unknown';
+
+  // Ensure str is a string
+  const strValue = String(str);
+  const identifier = toRustIdentifier(strValue);
+
+  // Handle camelCase and PascalCase inputs by splitting on capital letters too
+  const parts = identifier.replace(/([a-z])([A-Z])/g, '$1_$2') // Insert underscore before capital letters
+  .split(/[_\s-]+/) // Split on underscores, spaces, and hyphens
+  .filter(part => part.length > 0);
+  return parts.map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Converts a string to snake_case Rust field name
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} snake_case Rust field name
+ */
+function toRustFieldName(str) {
+  if (!str) return 'unknown';
+  const identifier = toRustIdentifier(str);
+  return identifier.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '').replace(/_+/g, '_');
+}
+
+/**
+ * Converts a string to Rust enum variant name (PascalCase)
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} PascalCase enum variant name
+ */
+function toRustEnumVariant(str) {
+  if (!str) return 'Unknown';
+  return str.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Converts a string to Rust enum variant with serde rename for lowercase serialization
+ *
+ * @param {string} str - Input string to convert
+ * @returns {object} Object with rustName (PascalCase) and serializedName (lowercase)
+ */
+function toRustEnumVariantWithSerde(str) {
+  if (!str) return {
+    rustName: 'Unknown',
+    serializedName: 'unknown'
+  };
+  const rustName = str.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+  const serializedName = str.toLowerCase();
+  return {
+    rustName,
+    serializedName
+  };
+}
+
+/**
+ * Converts a string to kebab-case
+ * Useful for package names and file names
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} kebab-case string
+ */
+function toKebabCase(str) {
+  if (!str) return '';
+  return str.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+
+/**
+ * Converts a string to PascalCase
+ * Useful for class names and type names
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} PascalCase string
+ */
+function toPascalCase(str) {
+  if (!str) return '';
+  return str.replace(/[^a-zA-Z0-9]/g, ' ').split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Converts a string to snake_case
+ * Useful for Rust identifiers and file names
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} snake_case string
+ */
+function toSnakeCase(str) {
+  if (!str) return '';
+  return str.toLowerCase().replace(/[^a-z0-9]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
+}
+
+/**
+ * Converts a string to camelCase
+ * Useful for JavaScript/TypeScript identifiers
+ *
+ * @param {string} str - Input string to convert
+ * @returns {string} camelCase string
+ */
+function toCamelCase(str) {
+  if (!str) return '';
+  const pascalCase = toPascalCase(str);
+  return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+}
+;// ../common/src/message-utils.js
+/**
+ * Message processing utilities for AsyncAPI template generation
+ *
+ * This module provides functions for extracting and processing message information
+ * from AsyncAPI specifications, handling various AsyncAPI versions and formats.
+ */
+
+
+
+/**
+ * Gets the message type name from a message object
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string|null} Message type name or null if not found
+ */
+function getMessageTypeName(message) {
+  if (!message) return null;
+  try {
+    // Try AsyncAPI 3.x format first - check _meta and _json properties
+    if (message._meta && message._meta.id) {
+      return message._meta.id;
+    }
+    if (message._json && message._json['x-parser-message-name']) {
+      return message._json['x-parser-message-name'];
+    }
+    if (message._json && message._json['x-parser-unique-object-id']) {
+      return message._json['x-parser-unique-object-id'];
+    }
+
+    // Try different ways to get the message name
+    if (message.name && typeof message.name === 'function') {
+      return message.name();
+    }
+    if (message.name && typeof message.name === 'string') {
+      return message.name;
+    }
+    if (message.title && typeof message.title === 'function') {
+      return message.title();
+    }
+    if (message.title && typeof message.title === 'string') {
+      return message.title;
+    }
+
+    // Try to extract from $ref
+    if (message.$ref) {
+      return message.$ref.split('/').pop();
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Gets the proper Rust type name from a message
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} Rust type name
+ */
+function getMessageRustTypeName(message) {
+  const messageName = getMessageTypeName(message);
+  return messageName ? toRustTypeName(messageName) : 'UnknownMessage';
+}
+
+/**
+ * Gets the payload component schema Rust type name from a message
+ * This extracts the actual payload type (component schema) rather than the message wrapper
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} Rust type name for the payload component schema
+ */
+function getPayloadRustTypeName(message) {
+  if (!message) return 'UnknownPayload';
+  try {
+    // First priority: For inline message schemas, get the message name itself
+    // This handles cases where the message is defined inline in channels
+    const messageName = getMessageTypeName(message);
+    if (messageName) {
+      // Check if this is a component message reference (has payload.$ref)
+      let payload = null;
+      if (message.payload && typeof message.payload === 'function') {
+        payload = message.payload();
+      } else if (message.payload) {
+        payload = message.payload;
+      }
+
+      // Check the message's _json for payload information
+      const messageJson = message._json || message;
+      if (!payload && messageJson.payload) {
+        payload = messageJson.payload;
+      }
+
+      // If payload has a $ref, this is a component message - extract the schema name
+      if (payload && payload.$ref) {
+        const refParts = payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return toRustTypeName(schemaName);
+      }
+
+      // For inline message schemas, use the message name directly as the payload type
+      // This is the correct approach for messages defined inline in channels
+      return toRustTypeName(messageName);
+    }
+
+    // Second priority: Try to get the payload schema reference from the message
+    let payload = null;
+
+    // Try different ways to access the payload
+    if (message.payload && typeof message.payload === 'function') {
+      payload = message.payload();
+    } else if (message.payload) {
+      payload = message.payload;
+    }
+    if (payload) {
+      // Check for $ref in the payload (direct reference to component schema)
+      if (payload.$ref) {
+        const refParts = payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return toRustTypeName(schemaName);
+      }
+
+      // Check for resolved $ref using x-parser-schema-id
+      if (payload['x-parser-schema-id']) {
+        return toRustTypeName(payload['x-parser-schema-id']);
+      }
+
+      // Check for x-parser-schema-id in _json
+      if (payload._json && payload._json['x-parser-schema-id']) {
+        return toRustTypeName(payload._json['x-parser-schema-id']);
+      }
+
+      // Check for title or name in the payload schema
+      if (payload.title) {
+        const title = typeof payload.title === 'function' ? payload.title() : payload.title;
+        if (title) return toRustTypeName(title);
+      }
+      if (payload.name) {
+        const name = typeof payload.name === 'function' ? payload.name() : payload.name;
+        if (name) return toRustTypeName(name);
+      }
+    }
+
+    // Check the message's _json for payload information
+    const messageJson = message._json || message;
+    if (messageJson.payload) {
+      if (messageJson.payload.$ref) {
+        const refParts = messageJson.payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return toRustTypeName(schemaName);
+      }
+      if (messageJson.payload['x-parser-schema-id']) {
+        return toRustTypeName(messageJson.payload['x-parser-schema-id']);
+      }
+      if (messageJson.payload.title) {
+        return toRustTypeName(messageJson.payload.title);
+      }
+    }
+
+    // Final fallback: try to extract from message title or name directly
+    if (message.title && typeof message.title === 'function') {
+      const title = message.title();
+      if (title && typeof title === 'string') {
+        return toRustTypeName(title);
+      }
+    } else if (message.title && typeof message.title === 'string') {
+      return toRustTypeName(message.title);
+    }
+    if (message.name && typeof message.name === 'function') {
+      const name = message.name();
+      if (name && typeof name === 'string') {
+        return toRustTypeName(name);
+      }
+    } else if (message.name && typeof message.name === 'string') {
+      return toRustTypeName(message.name);
+    }
+
+    // Check message._json for title/name
+    if (messageJson.title && typeof messageJson.title === 'string') {
+      return toRustTypeName(messageJson.title);
+    }
+    if (messageJson.name && typeof messageJson.name === 'string') {
+      return toRustTypeName(messageJson.name);
+    }
+    return 'UnknownPayload';
+  } catch (e) {
+    console.warn('Error extracting payload type name:', e.message);
+    return 'UnknownPayload';
+  }
+}
+
+/**
+ * Gets the TypeScript type name from a message for TypeScript templates
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} TypeScript type name
+ */
+function getMessageTypeScriptTypeName(message) {
+  const messageName = getMessageTypeName(message);
+  if (!messageName) return 'UnknownMessage';
+
+  // Convert to PascalCase for TypeScript interfaces
+  return messageName.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+}
+
+/**
+ * Gets the payload TypeScript type name from a message
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} TypeScript type name for the payload
+ */
+function getPayloadTypeScriptTypeName(message) {
+  if (!message) return 'unknown';
+  try {
+    // Similar logic to getPayloadRustTypeName but for TypeScript naming
+    const messageName = getMessageTypeName(message);
+    if (messageName) {
+      let payload = null;
+      if (message.payload && typeof message.payload === 'function') {
+        payload = message.payload();
+      } else if (message.payload) {
+        payload = message.payload;
+      }
+      const messageJson = message._json || message;
+      if (!payload && messageJson.payload) {
+        payload = messageJson.payload;
+      }
+      if (payload && payload.$ref) {
+        const refParts = payload.$ref.split('/');
+        const schemaName = refParts[refParts.length - 1];
+        return schemaName.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+      }
+      return messageName.split(/[-_\s]+/).map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+    }
+    return 'unknown';
+  } catch (e) {
+    console.warn('Error extracting TypeScript payload type name:', e.message);
+    return 'unknown';
+  }
+}
+
+/**
+ * Checks if a message has a payload schema defined
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {boolean} True if message has a payload schema
+ */
+function messageHasPayload(message) {
+  if (!message) return false;
+  try {
+    // Check for payload function
+    if (message.payload && typeof message.payload === 'function') {
+      const payload = message.payload();
+      return payload !== null && payload !== undefined;
+    }
+
+    // Check for payload property
+    if (message.payload) {
+      return true;
+    }
+
+    // Check _json for payload
+    const messageJson = message._json || message;
+    return !!messageJson.payload;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Gets the content type of a message
+ *
+ * @param {object} message - AsyncAPI message object
+ * @returns {string} Content type (e.g., 'application/json')
+ */
+function getMessageContentType(message) {
+  if (!message) return 'application/json';
+  try {
+    // Check for contentType function
+    if (message.contentType && typeof message.contentType === 'function') {
+      return message.contentType() || 'application/json';
+    }
+
+    // Check for contentType property
+    if (message.contentType) {
+      return message.contentType;
+    }
+
+    // Check _json for contentType
+    const messageJson = message._json || message;
+    if (messageJson.contentType) {
+      return messageJson.contentType;
+    }
+    return 'application/json';
+  } catch (e) {
+    return 'application/json';
+  }
+}
+;// ../common/src/channel-utils.js
+/**
+ * Channel processing utilities for AsyncAPI template generation
+ *
+ * This module provides functions for handling channels, parameters, and
+ * dynamic channel address resolution across different AsyncAPI templates.
+ */
+
+
+
+/**
+ * Gets the NATS subject from a channel address
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {string} NATS subject
+ */
+function getNatsSubject(channel) {
+  try {
+    if (channel.address && typeof channel.address === 'function') {
+      return channel.address();
+    } else if (channel.address) {
+      return channel.address;
+    } else if (channel.id && typeof channel.id === 'function') {
+      return channel.id();
+    } else if (channel.id) {
+      return channel.id;
+    }
+    return 'unknown.subject';
+  } catch (e) {
+    return 'unknown.subject';
+  }
+}
+
+/**
+ * Gets the channel address from a channel object
+ * This is a more generic version of getNatsSubject that works for any protocol
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {string} Channel address
+ */
+function getChannelAddress(channel) {
+  try {
+    if (channel.address && typeof channel.address === 'function') {
+      return channel.address();
+    } else if (channel.address) {
+      return channel.address;
+    } else if (channel.id && typeof channel.id === 'function') {
+      return channel.id();
+    } else if (channel.id) {
+      return channel.id;
+    }
+    return 'unknown.address';
+  } catch (e) {
+    return 'unknown.address';
+  }
+}
+
+/**
+ * Checks if a channel address contains variables (dynamic channel)
+ *
+ * @param {string} address - Channel address
+ * @returns {boolean} True if the address contains variables
+ */
+function isDynamicChannel(address) {
+  if (!address || typeof address !== 'string') return false;
+  return /\{[^}]+\}/.test(address);
+}
+
+/**
+ * Extracts variable names from a channel address
+ *
+ * @param {string} address - Channel address with variables
+ * @returns {Array<string>} Array of variable names
+ */
+function extractChannelVariables(address) {
+  if (!address || typeof address !== 'string') return [];
+  const matches = address.match(/\{([^}]+)\}/g);
+  if (!matches) return [];
+  return matches.map(match => match.slice(1, -1)); // Remove { and }
+}
+
+/**
+ * Extracts channel parameters from a dynamic channel address
+ *
+ * @param {string} channelAddress - Channel address like "device.{device_id}" or "user.{user_id}.notifications"
+ * @returns {Array} Array of parameter objects with name and rustName
+ */
+function extractChannelParameters(channelAddress) {
+  if (!channelAddress) return [];
+  const parameterRegex = /\{([^}]+)\}/g;
+  const parameters = [];
+  let match;
+  while ((match = parameterRegex.exec(channelAddress)) !== null) {
+    const paramName = match[1];
+    parameters.push({
+      name: paramName,
+      rustName: toRustFieldName(paramName),
+      placeholder: match[0] // The full {param_name} string
+    });
+  }
+  return parameters;
+}
+
+/**
+ * Gets channel parameters from a channel object
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {Array<object>} Array of parameter objects with name and description
+ */
+function getChannelParameters(channel) {
+  try {
+    const parameters = [];
+
+    // Try to get parameters from the channel
+    let channelParams = null;
+    if (channel.parameters && typeof channel.parameters === 'function') {
+      channelParams = channel.parameters();
+    } else if (channel.parameters) {
+      channelParams = channel.parameters;
+    } else if (channel._json && channel._json.parameters) {
+      channelParams = channel._json.parameters;
+    }
+    if (channelParams) {
+      // Handle different parameter formats
+      if (typeof channelParams === 'object') {
+        for (const [paramName, paramDef] of Object.entries(channelParams)) {
+          // Skip internal AsyncAPI parser properties
+          if (paramName.startsWith('_') || paramName === 'collections' || paramName === 'meta') {
+            continue;
+          }
+          let description = 'Channel parameter';
+          if (paramDef && typeof paramDef === 'object') {
+            if (typeof paramDef.description === 'string') {
+              description = paramDef.description;
+            } else if (typeof paramDef.description === 'function') {
+              try {
+                description = paramDef.description();
+              } catch (e) {
+                description = 'Channel parameter';
+              }
+            } else if (paramDef._json && paramDef._json.description) {
+              description = paramDef._json.description;
+            }
+          } else if (typeof paramDef === 'string') {
+            description = paramDef;
+          }
+          parameters.push({
+            name: paramName,
+            description: description,
+            rustName: toRustFieldName(paramName),
+            rustType: 'String' // For now, assume all parameters are strings
+          });
+        }
+      }
+    }
+    return parameters;
+  } catch (e) {
+    console.warn('Error extracting channel parameters:', e.message);
+    return [];
+  }
+}
+
+/**
+ * Resolves a dynamic channel address with provided variable values
+ *
+ * @param {string} address - Channel address template with variables
+ * @param {object} variables - Object mapping variable names to values
+ * @returns {string} Resolved channel address
+ */
+function resolveChannelAddress(address, variables) {
+  if (!address || typeof address !== 'string') return address;
+  if (!variables || typeof variables !== 'object') return address;
+  let resolved = address;
+  for (const [varName, varValue] of Object.entries(variables)) {
+    const placeholder = `{${varName}}`;
+    resolved = resolved.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), varValue);
+  }
+  return resolved;
+}
+
+/**
+ * Checks if a channel has dynamic parameters
+ *
+ * @param {object} channel - AsyncAPI channel object
+ * @returns {boolean} True if the channel has parameters
+ */
+function channelHasParameters(channel) {
+  const address = getChannelAddress(channel);
+  return isDynamicChannel(address);
+}
+
+/**
+ * Generates Rust function parameters for dynamic channel parameters
+ *
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {string} Rust function parameter string
+ */
+function generateChannelParameterArgs(channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return '';
+  }
+  return channelParameters.map(param => `${param.rustName}: String`).join(', ') + ', ';
+}
+
+/**
+ * Generates Rust format string and arguments for dynamic channel resolution
+ *
+ * @param {string} channelAddress - Original channel address with parameters
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {object} Object with formatString and formatArgs
+ */
+function generateChannelFormatting(channelAddress, channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return {
+      formatString: `"${channelAddress}".to_string()`,
+      formatArgs: ''
+    };
+  }
+
+  // Replace parameter placeholders with format placeholders
+  let formatString = channelAddress;
+  const formatArgs = [];
+  for (const param of channelParameters) {
+    formatString = formatString.replace(param.placeholder, '{}');
+    formatArgs.push(param.rustName);
+  }
+  return {
+    formatString: `format!("${formatString}", ${formatArgs.join(', ')})`,
+    formatArgs: formatArgs.join(', ')
+  };
+}
+
+/**
+ * Generates TypeScript function parameters for dynamic channel parameters
+ *
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {string} TypeScript function parameter string
+ */
+function generateTypeScriptChannelParameterArgs(channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return '';
+  }
+  return channelParameters.map(param => `${param.name}: string`).join(', ') + ', ';
+}
+
+/**
+ * Generates TypeScript template literal for dynamic channel resolution
+ *
+ * @param {string} channelAddress - Original channel address with parameters
+ * @param {Array} channelParameters - Array of channel parameter objects
+ * @returns {string} TypeScript template literal string
+ */
+function generateTypeScriptChannelFormatting(channelAddress, channelParameters) {
+  if (!channelParameters || channelParameters.length === 0) {
+    return `'${channelAddress}'`;
+  }
+
+  // Replace parameter placeholders with template literal placeholders
+  let templateString = channelAddress;
+  for (const param of channelParameters) {
+    templateString = templateString.replace(param.placeholder, `\${${param.name}}`);
+  }
+  return `\`${templateString}\``;
+}
+
+/**
+ * Extracts server name from a $ref string
+ *
+ * @param {string} serverRef - Server reference like "#/servers/mqtt-server"
+ * @returns {string|null} Server name or null if invalid
+ */
+function extractServerNameFromRef(serverRef) {
+  if (!serverRef || typeof serverRef !== 'string') return null;
+
+  // Handle $ref format: "#/servers/server-name"
+  const refMatch = serverRef.match(/^#\/servers\/(.+)$/);
+  if (refMatch) {
+    return refMatch[1];
+  }
+  return null;
+}
+
+/**
+ * Analyzes channel server restrictions from AsyncAPI specification
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {Array} Array of channel server mapping objects
+ */
+function analyzeChannelServerMappings(asyncapi) {
+  const mappings = [];
+  try {
+    const channels = asyncapi.channels();
+    if (!channels) return mappings;
+    for (const channel of channels) {
+      const channelName = channel.id();
+      let allowedServers = null; // null means available on all servers
+
+      // Try to get servers from the channel object
+      let channelServers = null;
+
+      // Method 1: Try channel.servers() function
+      if (channel.servers && typeof channel.servers === 'function') {
+        try {
+          channelServers = channel.servers();
+        } catch (e) {
+          // Ignore errors and try other methods
+        }
+      }
+
+      // Method 2: Try channel._json.servers (raw JSON data)
+      if (!channelServers && channel._json && channel._json.servers) {
+        channelServers = channel._json.servers;
+      }
+
+      // Method 3: Try direct property access
+      if (!channelServers && channel.servers && Array.isArray(channel.servers)) {
+        channelServers = channel.servers;
+      }
+      if (channelServers && Array.isArray(channelServers) && channelServers.length > 0) {
+        // Extract server names from $ref strings
+        allowedServers = [];
+        for (const serverRef of channelServers) {
+          let serverName = null;
+
+          // Handle different ways the server reference might be provided
+          if (typeof serverRef === 'string') {
+            serverName = extractServerNameFromRef(serverRef);
+          } else if (serverRef && serverRef.$ref) {
+            serverName = extractServerNameFromRef(serverRef.$ref);
+          } else if (serverRef && typeof serverRef.id === 'function') {
+            serverName = serverRef.id();
+          } else if (serverRef && typeof serverRef.id === 'string') {
+            serverName = serverRef.id;
+          }
+          if (serverName) {
+            allowedServers.push(serverName);
+          }
+        }
+
+        // If no valid server names were extracted, treat as available on all servers
+        if (allowedServers.length === 0) {
+          allowedServers = null;
+        }
+      }
+      mappings.push({
+        channelName: channelName,
+        allowedServers: allowedServers,
+        rustChannelName: toRustIdentifier(channelName),
+        description: channel.description && channel.description() || ''
+      });
+    }
+  } catch (e) {
+    console.warn('Error analyzing channel server mappings:', e.message);
+  }
+  return mappings;
+}
+
+/**
+ * Checks if a channel is allowed on a specific server
+ *
+ * @param {string} channelName - Name of the channel
+ * @param {string} serverName - Name of the server
+ * @param {Array} channelMappings - Array of channel server mappings
+ * @returns {boolean} True if channel is allowed on the server
+ */
+function isChannelAllowedOnServer(channelName, serverName, channelMappings) {
+  const mapping = channelMappings.find(m => m.channelName === channelName);
+  if (!mapping) {
+    // If no mapping found, assume channel is allowed on all servers
+    return true;
+  }
+
+  // If allowedServers is null, channel is available on all servers
+  if (mapping.allowedServers === null) {
+    return true;
+  }
+
+  // Check if server is in the allowed list
+  return mapping.allowedServers.includes(serverName);
+}
+;// ../common/src/security-utils.js
+/**
+ * Security analysis utilities for AsyncAPI template generation
+ *
+ * This module provides functions for analyzing security requirements and
+ * authentication schemes across different AsyncAPI templates.
+ */
+
+/**
+ * Analyzes operation security requirements from AsyncAPI specification
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {object} Security analysis result
+ */
+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
+ */
+function operationHasSecurity(operation) {
+  const analysis = analyzeOperationSecurity(operation);
+  return analysis.hasSecurityRequirements;
+}
+
+/**
+ * Alias for operationHasSecurity for TypeScript templates
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation requires authentication
+ */
+function operationRequiresAuth(operation) {
+  return operationHasSecurity(operation);
+}
+
+/**
+ * Checks if the AsyncAPI specification has security schemes defined
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @param {boolean} enableAuth - Whether auth feature is enabled (optional, defaults to true)
+ * @returns {boolean} True if security schemes are present and auth is enabled
+ */
+function hasSecuritySchemes(asyncapi, enableAuth = true) {
+  if (!enableAuth) return false;
+  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.)
+ */
+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';
+  }
+}
+
+/**
+ * Gets the security scheme name from a security scheme object
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @returns {string} Security scheme name
+ */
+function getSecuritySchemeName(securityScheme) {
+  try {
+    if (securityScheme.name && typeof securityScheme.name === 'function') {
+      return securityScheme.name();
+    }
+    if (securityScheme.name) {
+      return securityScheme.name;
+    }
+    if (securityScheme._json && securityScheme._json.name) {
+      return securityScheme._json.name;
+    }
+    return 'unknown';
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Gets the security scheme location (header, query, cookie) for API key schemes
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @returns {string} Security scheme location ('header', 'query', 'cookie')
+ */
+function getSecuritySchemeLocation(securityScheme) {
+  try {
+    if (securityScheme.in && typeof securityScheme.in === 'function') {
+      return securityScheme.in();
+    }
+    if (securityScheme.in) {
+      return securityScheme.in;
+    }
+    if (securityScheme._json && securityScheme._json.in) {
+      return securityScheme._json.in;
+    }
+    return 'header'; // Default to header
+  } catch (e) {
+    return 'header';
+  }
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Gets all security schemes from the AsyncAPI specification
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Map of security scheme names to their definitions
+ */
+function getAllSecuritySchemes(asyncapi) {
+  try {
+    const components = asyncapi.components();
+    if (!components) return {};
+    const securitySchemes = components.securitySchemes();
+    if (!securitySchemes) return {};
+
+    // Convert to plain object if it's a collection
+    if (typeof securitySchemes === 'object' && securitySchemes.all) {
+      const schemes = {};
+      const schemeArray = securitySchemes.all();
+      schemeArray.forEach(scheme => {
+        const name = scheme.id ? scheme.id() : 'unknown';
+        schemes[name] = scheme;
+      });
+      return schemes;
+    }
+    return securitySchemes;
+  } catch (e) {
+    console.warn('Error extracting security schemes:', e.message);
+    return {};
+  }
+}
+
+/**
+ * Checks if a security scheme is of a specific type
+ *
+ * @param {object} securityScheme - AsyncAPI security scheme object
+ * @param {string} expectedType - Expected security scheme type
+ * @returns {boolean} True if the scheme matches the expected type
+ */
+function isSecuritySchemeType(securityScheme, expectedType) {
+  const actualType = getSecuritySchemeType(securityScheme);
+  return actualType.toLowerCase() === expectedType.toLowerCase();
+}
+
+/**
+ * Gets the default port for a given protocol
+ *
+ * @param {string} protocol - Protocol name
+ * @returns {number} Default port number
+ */
+function getDefaultPort(protocol) {
+  switch (protocol === null || protocol === void 0 ? void 0 : protocol.toLowerCase()) {
+    case 'http':
+      return 80;
+    case 'https':
+      return 443;
+    case 'ws':
+    case 'websocket':
+      return 80;
+    case 'wss':
+    case 'websockets':
+      return 443;
+    case 'mqtt':
+      return 1883;
+    case 'mqtts':
+      return 8883;
+    case 'amqp':
+      return 5672;
+    case 'amqps':
+      return 5671;
+    case 'kafka':
+      return 9092;
+    case 'nats':
+      return 4222;
+    default:
+      return 8080;
+  }
+}
+
+/**
+ * Validates that all server references in channels exist in the servers section
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Validation result with errors if any
+ */
+function validateChannelServerReferences(asyncapi) {
+  const result = {
+    valid: true,
+    errors: []
+  };
+  try {
+    // Try multiple ways to get servers
+    let servers = null;
+    let serverNames = [];
+
+    // Method 1: Try asyncapi.servers() function
+    if (asyncapi.servers && typeof asyncapi.servers === 'function') {
+      try {
+        servers = asyncapi.servers();
+        if (servers) {
+          // Check if this is a collection object (has iterator methods)
+          if (typeof servers[Symbol.iterator] === 'function') {
+            // It's iterable - iterate through the servers
+            serverNames = [];
+            for (const server of servers) {
+              const serverName = server.id && typeof server.id === 'function' ? server.id() : server.id;
+              if (serverName) {
+                serverNames.push(serverName);
+              }
+            }
+          } else {
+            // It's a plain object - use Object.keys
+            serverNames = Object.keys(servers);
+          }
+        }
+      } catch (e) {
+        // Ignore and try other methods
+      }
+    }
+
+    // Method 2: Try asyncapi._json.servers (raw JSON data)
+    if (serverNames.length === 0 && asyncapi._json && asyncapi._json.servers) {
+      servers = asyncapi._json.servers;
+      serverNames = Object.keys(servers);
+    }
+
+    // Method 3: Try direct property access
+    if (serverNames.length === 0 && asyncapi.servers && typeof asyncapi.servers === 'object') {
+      servers = asyncapi.servers;
+      serverNames = Object.keys(servers);
+    }
+
+    // Method 4: Try json() method if available
+    if (serverNames.length === 0 && asyncapi.json && typeof asyncapi.json === 'function') {
+      try {
+        const jsonDoc = asyncapi.json();
+        if (jsonDoc && jsonDoc.servers) {
+          servers = jsonDoc.servers;
+          serverNames = Object.keys(servers);
+        }
+      } catch (e) {
+        // Ignore and try other methods
+      }
+    }
+
+    // Note: We'll skip channel validation here to avoid circular dependency
+    // This function can be enhanced later if needed
+    console.warn('Channel server validation skipped to avoid circular dependency');
+  } catch (e) {
+    result.valid = false;
+    result.errors.push({
+      message: `Error validating channel server references: ${e.message}`
+    });
+  }
+  return result;
+}
+;// ../common/src/template-utils.js
+/**
+ * Template parameter utilities for AsyncAPI template generation
+ *
+ * This module provides functions for handling template parameters and
+ * common template operations across different AsyncAPI templates.
+ */
+
+
+
+/**
+ * Checks if a parameter contains unresolved template variables
+ *
+ * @param {string} value - Parameter value to check
+ * @returns {boolean} True if the value contains template variables
+ */
+function isTemplateVariable(value) {
+  return typeof value === 'string' && value.includes('{{') && value.includes('}}');
+}
+
+/**
+ * Extracts information from AsyncAPI specification with fallbacks
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {object} Object with title, version, and description
+ */
+function extractAsyncApiInfo(asyncapi) {
+  let title, version, description;
+  try {
+    const info = asyncapi.info();
+    title = info.title();
+    version = info.version();
+    description = info.description();
+  } catch (error) {
+    title = 'UnknownAPI';
+    version = '1.0.0';
+    description = 'Generated AsyncAPI client';
+  }
+  return {
+    title,
+    version,
+    description
+  };
+}
+
+/**
+ * Resolves template parameters with fallbacks based on AsyncAPI info
+ *
+ * @param {object} params - Template parameters
+ * @param {object} asyncApiInfo - AsyncAPI info object from extractAsyncApiInfo
+ * @returns {object} Resolved parameters
+ */
+function resolveTemplateParameters(params, asyncApiInfo) {
+  const {
+    title,
+    version
+  } = asyncApiInfo;
+
+  // Resolve parameters, falling back to extracted values if parameters contain template variables
+  const clientName = params.clientName && !isTemplateVariable(params.clientName) ? params.clientName : `${toPascalCase(title)}Client`;
+  const packageName = params.packageName && !isTemplateVariable(params.packageName) ? params.packageName : `${toKebabCase(title)}-client`;
+  const packageVersion = params.packageVersion && !isTemplateVariable(params.packageVersion) ? params.packageVersion : version;
+  const license = params.license && !isTemplateVariable(params.license) ? params.license : 'Apache-2.0';
+  const author = params.author && !isTemplateVariable(params.author) ? params.author : 'AsyncAPI Generator';
+  return {
+    clientName,
+    packageName,
+    packageVersion,
+    license,
+    author
+  };
+}
+
+/**
+ * Generates package.json content for Node.js templates
+ *
+ * @param {object} resolvedParams - Resolved template parameters
+ * @param {object} asyncApiInfo - AsyncAPI info object
+ * @param {object} options - Additional options for package.json generation
+ * @returns {object} Package.json object
+ */
+function generatePackageJson(resolvedParams, asyncApiInfo, options = {}) {
+  const {
+    title,
+    description
+  } = asyncApiInfo;
+  const {
+    packageName,
+    packageVersion,
+    license,
+    author
+  } = resolvedParams;
+  const basePackage = {
+    name: packageName,
+    version: packageVersion,
+    description: `${description || title} - AsyncAPI Client`,
+    author: author,
+    license: license,
+    keywords: ['asyncapi', 'client', title.toLowerCase().replace(/[^a-z0-9]/g, '-'), ...(options.additionalKeywords || [])]
+  };
+
+  // Merge with additional options
+  return {
+    ...basePackage,
+    ...options.additionalFields
+  };
+}
+
+/**
+ * Generates README.md content for templates
+ *
+ * @param {object} resolvedParams - Resolved template parameters
+ * @param {object} asyncApiInfo - AsyncAPI info object
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @param {object} options - Additional options for README generation
+ * @returns {string} README.md content
+ */
+function generateReadmeContent(resolvedParams, asyncApiInfo, asyncapi, options = {}) {
+  const {
+    title,
+    description
+  } = asyncApiInfo;
+  const {
+    packageName,
+    packageVersion,
+    license
+  } = resolvedParams;
+  const sections = {
+    title: `# ${title}`,
+    description: description || 'Generated AsyncAPI client',
+    overview: options.overview || 'This client provides type-safe access to your AsyncAPI service.',
+    installation: options.installation || `\`\`\`bash\nnpm install ${packageName}\n\`\`\``,
+    usage: options.usage || '// Usage examples will be added here',
+    metadata: `## Generated from AsyncAPI
+
+- **AsyncAPI Version**: ${asyncapi.version()}
+- **Generated**: ${new Date().toISOString()}
+- **Title**: ${title}
+- **Version**: ${packageVersion}`,
+    license: `## License
+
+${license}`
+  };
+
+  // Allow overriding sections
+  const finalSections = {
+    ...sections,
+    ...options.sections
+  };
+  return Object.values(finalSections).join('\n\n');
+}
+
+/**
+ * Validates template parameters
+ *
+ * @param {object} params - Template parameters to validate
+ * @param {Array<string>} requiredParams - List of required parameter names
+ * @returns {object} Validation result with errors if any
+ */
+function validateTemplateParameters(params, requiredParams = []) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+
+  // Check required parameters
+  for (const paramName of requiredParams) {
+    if (!params[paramName] || isTemplateVariable(params[paramName])) {
+      result.valid = false;
+      result.errors.push(`Required parameter '${paramName}' is missing or contains unresolved template variables`);
+    }
+  }
+
+  // Check for common issues
+  if (params.packageName && !/^[a-z0-9-]+$/.test(params.packageName)) {
+    result.warnings.push('Package name should only contain lowercase letters, numbers, and hyphens');
+  }
+  if (params.packageVersion && !/^\d+\.\d+\.\d+/.test(params.packageVersion)) {
+    result.warnings.push('Package version should follow semantic versioning (e.g., 1.0.0)');
+  }
+  return result;
+}
+
+/**
+ * Generates TypeScript configuration for TypeScript templates
+ *
+ * @param {object} options - TypeScript configuration options
+ * @returns {object} TypeScript configuration object
+ */
+function generateTypeScriptConfig(options = {}) {
+  const defaultConfig = {
+    compilerOptions: {
+      target: 'ES2020',
+      module: 'ES2020',
+      lib: ['ES2020', 'DOM'],
+      outDir: './dist',
+      rootDir: './src',
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      declaration: true,
+      declarationMap: true,
+      sourceMap: true,
+      moduleResolution: 'node',
+      allowSyntheticDefaultImports: true,
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true,
+      resolveJsonModule: true,
+      typeRoots: ['node_modules/@types']
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'dist', '**/*.test.ts', '**/*.spec.ts']
+  };
+
+  // Merge with custom options
+  return {
+    ...defaultConfig,
+    compilerOptions: {
+      ...defaultConfig.compilerOptions,
+      ...options.compilerOptions
+    },
+    include: options.include || defaultConfig.include,
+    exclude: options.exclude || defaultConfig.exclude
+  };
+}
+
+/**
+ * Generates ESLint configuration for JavaScript/TypeScript templates
+ *
+ * @param {object} options - ESLint configuration options
+ * @returns {object} ESLint configuration object
+ */
+function generateEslintConfig(options = {}) {
+  const isTypeScript = options.typescript || false;
+  const baseConfig = {
+    env: {
+      node: true,
+      es2021: true
+    },
+    extends: ['eslint:recommended'],
+    parserOptions: {
+      ecmaVersion: 12,
+      sourceType: 'module'
+    },
+    rules: {
+      'indent': ['error', 4],
+      'linebreak-style': ['error', 'unix'],
+      'quotes': ['error', 'single'],
+      'semi': ['error', 'always']
+    }
+  };
+  if (isTypeScript) {
+    baseConfig.extends.push('@typescript-eslint/recommended');
+    baseConfig.parser = '@typescript-eslint/parser';
+    baseConfig.plugins = ['@typescript-eslint'];
+  }
+
+  // Merge with custom options
+  return {
+    ...baseConfig,
+    ...options.additionalConfig
+  };
+}
+
+/**
+ * Formats a date for use in generated files
+ *
+ * @param {Date} date - Date to format (defaults to current date)
+ * @returns {string} Formatted date string
+ */
+function formatGenerationDate(date = new Date()) {
+  return date.toISOString();
+}
+
+/**
+ * Generates a comment header for generated files
+ *
+ * @param {object} options - Header options
+ * @returns {string} Comment header
+ */
+function generateFileHeader(options = {}) {
+  const {
+    title = 'Generated AsyncAPI File',
+    description = 'This file was automatically generated from an AsyncAPI specification.',
+    generator = 'AsyncAPI Generator',
+    date = new Date(),
+    warning = 'Do not modify this file directly.'
+  } = options;
+  return `/**
+ * ${title}
+ *
+ * ${description}
+ *
+ * Generated by: ${generator}
+ * Generated on: ${formatGenerationDate(date)}
+ *
+ * WARNING: ${warning}
+ */`;
+}
+;// ../common/src/operation-utils.js
+/**
+ * Operation processing utilities for AsyncAPI template generation
+ *
+ * This module provides functions for extracting and processing operation information
+ * from AsyncAPI specifications, handling different operation types and patterns.
+ */
+
+
+
+/**
+ * Gets the operation name from an operation object
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string|null} Operation name or null if not found
+ */
+function getOperationName(operation) {
+  if (!operation) return null;
+  try {
+    // Try AsyncAPI 3.x format first - check _meta and _json properties
+    if (operation._meta && operation._meta.id) {
+      return operation._meta.id;
+    }
+    if (operation._json && operation._json['x-parser-operation-id']) {
+      return operation._json['x-parser-operation-id'];
+    }
+
+    // Try different ways to get the operation name
+    if (operation.id && typeof operation.id === 'function') {
+      return operation.id();
+    }
+    if (operation.id && typeof operation.id === 'string') {
+      return operation.id;
+    }
+    if (operation.operationId && typeof operation.operationId === 'function') {
+      return operation.operationId();
+    }
+    if (operation.operationId && typeof operation.operationId === 'string') {
+      return operation.operationId;
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Gets the operation action (send/receive/publish/subscribe)
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Operation action
+ */
+function getOperationAction(operation) {
+  if (!operation) return 'unknown';
+  try {
+    if (operation.action && typeof operation.action === 'function') {
+      return operation.action();
+    }
+    if (operation.action && typeof operation.action === 'string') {
+      return operation.action;
+    }
+    if (operation._json && operation._json.action) {
+      return operation._json.action;
+    }
+
+    // Fallback based on operation type
+    if (operation.isSend && typeof operation.isSend === 'function' && operation.isSend()) {
+      return 'send';
+    }
+    if (operation.isReceive && typeof operation.isReceive === 'function' && operation.isReceive()) {
+      return 'receive';
+    }
+    return 'unknown';
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Gets the channel associated with an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {object|null} Channel object or null if not found
+ */
+function getOperationChannel(operation) {
+  if (!operation) return null;
+  try {
+    if (operation.channel && typeof operation.channel === 'function') {
+      return operation.channel();
+    }
+    if (operation.channel && typeof operation.channel === 'object') {
+      return operation.channel;
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Gets the messages associated with an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {Array} Array of message objects
+ */
+function getOperationMessages(operation) {
+  if (!operation) return [];
+  try {
+    const messages = [];
+
+    // Try to get messages from the operation
+    if (operation.messages && typeof operation.messages === 'function') {
+      const operationMessages = operation.messages();
+      if (operationMessages && Array.isArray(operationMessages)) {
+        messages.push(...operationMessages);
+      } else if (operationMessages && typeof operationMessages === 'object') {
+        // Handle collection object
+        if (operationMessages.all && typeof operationMessages.all === 'function') {
+          messages.push(...operationMessages.all());
+        } else {
+          messages.push(...Object.values(operationMessages));
+        }
+      }
+    } else if (operation.messages && Array.isArray(operation.messages)) {
+      messages.push(...operation.messages);
+    }
+
+    // Try to get message from _json
+    if (messages.length === 0 && operation._json && operation._json.message) {
+      if (Array.isArray(operation._json.message)) {
+        messages.push(...operation._json.message);
+      } else {
+        messages.push(operation._json.message);
+      }
+    }
+    return messages;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Checks if an operation is a send operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation is a send operation
+ */
+function isOperationSend(operation) {
+  const action = getOperationAction(operation);
+  return action === 'send' || action === 'publish';
+}
+
+/**
+ * Checks if an operation is a receive operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation is a receive operation
+ */
+function isOperationReceive(operation) {
+  const action = getOperationAction(operation);
+  return action === 'receive' || action === 'subscribe';
+}
+
+/**
+ * Gets the Rust function name for an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Rust function name
+ */
+function getOperationRustFunctionName(operation) {
+  const operationName = getOperationName(operation);
+  if (!operationName) return 'unknown_operation';
+  return toRustIdentifier(operationName);
+}
+
+/**
+ * Gets the TypeScript method name for an operation
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} TypeScript method name
+ */
+function getOperationTypeScriptMethodName(operation) {
+  const operationName = getOperationName(operation);
+  if (!operationName) return 'unknownOperation';
+
+  // Convert to camelCase for TypeScript
+  return operationName.split(/[-_\s]+/).map((part, index) => {
+    if (index === 0) {
+      return part.toLowerCase();
+    }
+    return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+  }).join('');
+}
+
+/**
+ * Gets the operation description
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Operation description
+ */
+function getOperationDescription(operation) {
+  if (!operation) return '';
+  try {
+    if (operation.description && typeof operation.description === 'function') {
+      return operation.description() || '';
+    }
+    if (operation.description && typeof operation.description === 'string') {
+      return operation.description;
+    }
+    if (operation._json && operation._json.description) {
+      return operation._json.description;
+    }
+    return '';
+  } catch (e) {
+    return '';
+  }
+}
+
+/**
+ * Gets the operation summary
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {string} Operation summary
+ */
+function getOperationSummary(operation) {
+  if (!operation) return '';
+  try {
+    if (operation.summary && typeof operation.summary === 'function') {
+      return operation.summary() || '';
+    }
+    if (operation.summary && typeof operation.summary === 'string') {
+      return operation.summary;
+    }
+    if (operation._json && operation._json.summary) {
+      return operation._json.summary;
+    }
+    return '';
+  } catch (e) {
+    return '';
+  }
+}
+
+/**
+ * Extracts all operations from an AsyncAPI specification
+ *
+ * @param {object} asyncapi - AsyncAPI specification object
+ * @returns {Array} Array of operation objects with metadata
+ */
+function extractAllOperations(asyncapi) {
+  const operations = [];
+  try {
+    const asyncApiOperations = asyncapi.operations && asyncapi.operations();
+    if (asyncApiOperations) {
+      // Handle AsyncAPI parser collection - use .all() method to get array
+      const operationArray = asyncApiOperations.all ? asyncApiOperations.all() : Object.values(asyncApiOperations);
+      operationArray.forEach(operation => {
+        const operationName = getOperationName(operation);
+        if (operationName) {
+          const channel = getOperationChannel(operation);
+          const messages = getOperationMessages(operation);
+          operations.push({
+            name: operationName,
+            operation: operation,
+            action: getOperationAction(operation),
+            channel: channel,
+            messages: messages,
+            description: getOperationDescription(operation),
+            summary: getOperationSummary(operation),
+            rustFunctionName: getOperationRustFunctionName(operation),
+            typeScriptMethodName: getOperationTypeScriptMethodName(operation),
+            isSend: isOperationSend(operation),
+            isReceive: isOperationReceive(operation)
+          });
+        }
+      });
+    }
+  } catch (e) {
+    console.warn('Error extracting operations:', e.message);
+  }
+  return operations;
+}
+
+/**
+ * Groups operations by their action type
+ *
+ * @param {Array} operations - Array of operation objects
+ * @returns {object} Object with send and receive operation arrays
+ */
+function groupOperationsByAction(operations) {
+  const grouped = {
+    send: [],
+    receive: [],
+    publish: [],
+    subscribe: [],
+    unknown: []
+  };
+  operations.forEach(operation => {
+    const action = operation.action || 'unknown';
+    if (grouped[action]) {
+      grouped[action].push(operation);
+    } else {
+      grouped.unknown.push(operation);
+    }
+  });
+  return grouped;
+}
+
+/**
+ * Gets the operation trait information
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {Array} Array of trait objects
+ */
+function getOperationTraits(operation) {
+  if (!operation) return [];
+  try {
+    const traits = [];
+    if (operation.traits && typeof operation.traits === 'function') {
+      const operationTraits = operation.traits();
+      if (operationTraits && Array.isArray(operationTraits)) {
+        traits.push(...operationTraits);
+      }
+    } else if (operation.traits && Array.isArray(operation.traits)) {
+      traits.push(...operation.traits);
+    }
+
+    // Try to get traits from _json
+    if (traits.length === 0 && operation._json && operation._json.traits) {
+      if (Array.isArray(operation._json.traits)) {
+        traits.push(...operation._json.traits);
+      }
+    }
+    return traits;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Checks if an operation has any traits defined
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {boolean} True if operation has traits
+ */
+function operationHasTraits(operation) {
+  const traits = getOperationTraits(operation);
+  return traits.length > 0;
+}
+
+/**
+ * Gets the operation tags
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @returns {Array} Array of tag objects
+ */
+function getOperationTags(operation) {
+  if (!operation) return [];
+  try {
+    const tags = [];
+    if (operation.tags && typeof operation.tags === 'function') {
+      const operationTags = operation.tags();
+      if (operationTags && Array.isArray(operationTags)) {
+        tags.push(...operationTags);
+      }
+    } else if (operation.tags && Array.isArray(operation.tags)) {
+      tags.push(...operation.tags);
+    }
+
+    // Try to get tags from _json
+    if (tags.length === 0 && operation._json && operation._json.tags) {
+      if (Array.isArray(operation._json.tags)) {
+        tags.push(...operation._json.tags);
+      }
+    }
+    return tags;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Generates operation handler name for server templates
+ *
+ * @param {object} operation - AsyncAPI operation object
+ * @param {string} suffix - Optional suffix to add to handler name
+ * @returns {string} Handler function name
+ */
+function generateOperationHandlerName(operation, suffix = 'Handler') {
+  const operationName = getOperationName(operation);
+  if (!operationName) return `unknown${suffix}`;
+  const pascalCaseName = toPascalCase(operationName);
+  return `${pascalCaseName}${suffix}`;
+}
+;// ../common/src/index.js
+/**
+ * AsyncAPI Common Template Utilities
+ *
+ * This package provides shared utilities for AsyncAPI template generation,
+ * reducing code duplication across multiple templates.
+ */
+
+// String utilities
+
+
+// Message utilities
+
+
+// Channel utilities
+
+
+// Security utilities
+
+
+// Template utilities
+
+
+// Operation utilities
+
+
+// Re-export all utilities
+
+
+// Version information
+const VERSION = '1.0.0';
+
+// Convenience function to get all utilities in one object
+function getAllUtilities() {
+  return {
+    string: {
+      toRustIdentifier: toRustIdentifier,
+      toRustTypeName: toRustTypeName,
+      toRustFieldName: toRustFieldName,
+      toRustEnumVariant: toRustEnumVariant,
+      toRustEnumVariantWithSerde: toRustEnumVariantWithSerde,
+      toKebabCase: toKebabCase,
+      toPascalCase: toPascalCase,
+      toSnakeCase: toSnakeCase,
+      toCamelCase: toCamelCase
+    },
+    message: {
+      getMessageTypeName: getMessageTypeName,
+      getMessageRustTypeName: getMessageRustTypeName,
+      getPayloadRustTypeName: getPayloadRustTypeName,
+      getMessageTypeScriptTypeName: getMessageTypeScriptTypeName,
+      getPayloadTypeScriptTypeName: getPayloadTypeScriptTypeName,
+      messageHasPayload: messageHasPayload,
+      getMessageContentType: getMessageContentType
+    },
+    channel: {
+      getNatsSubject: getNatsSubject,
+      getChannelAddress: getChannelAddress,
+      isDynamicChannel: isDynamicChannel,
+      extractChannelVariables: extractChannelVariables,
+      extractChannelParameters: extractChannelParameters,
+      getChannelParameters: getChannelParameters,
+      resolveChannelAddress: resolveChannelAddress,
+      channelHasParameters: channelHasParameters,
+      generateChannelParameterArgs: generateChannelParameterArgs,
+      generateChannelFormatting: generateChannelFormatting,
+      generateTypeScriptChannelParameterArgs: generateTypeScriptChannelParameterArgs,
+      generateTypeScriptChannelFormatting: generateTypeScriptChannelFormatting,
+      extractServerNameFromRef: extractServerNameFromRef,
+      analyzeChannelServerMappings: analyzeChannelServerMappings,
+      isChannelAllowedOnServer: isChannelAllowedOnServer
+    },
+    security: {
+      analyzeOperationSecurity: analyzeOperationSecurity,
+      operationHasSecurity: operationHasSecurity,
+      operationRequiresAuth: operationRequiresAuth,
+      hasSecuritySchemes: hasSecuritySchemes,
+      getSecuritySchemeType: getSecuritySchemeType,
+      getSecuritySchemeName: getSecuritySchemeName,
+      getSecuritySchemeLocation: getSecuritySchemeLocation,
+      extractOperationSecurityMap: extractOperationSecurityMap,
+      getAllSecuritySchemes: getAllSecuritySchemes,
+      isSecuritySchemeType: isSecuritySchemeType,
+      getDefaultPort: getDefaultPort,
+      validateChannelServerReferences: validateChannelServerReferences
+    },
+    template: {
+      isTemplateVariable: isTemplateVariable,
+      extractAsyncApiInfo: extractAsyncApiInfo,
+      resolveTemplateParameters: resolveTemplateParameters,
+      generatePackageJson: generatePackageJson,
+      generateReadmeContent: generateReadmeContent,
+      validateTemplateParameters: validateTemplateParameters,
+      generateTypeScriptConfig: generateTypeScriptConfig,
+      generateEslintConfig: generateEslintConfig,
+      formatGenerationDate: formatGenerationDate,
+      generateFileHeader: generateFileHeader
+    },
+    operation: {
+      getOperationName: getOperationName,
+      getOperationAction: getOperationAction,
+      getOperationChannel: getOperationChannel,
+      getOperationMessages: getOperationMessages,
+      isOperationSend: isOperationSend,
+      isOperationReceive: isOperationReceive,
+      getOperationRustFunctionName: getOperationRustFunctionName,
+      getOperationTypeScriptMethodName: getOperationTypeScriptMethodName,
+      getOperationDescription: getOperationDescription,
+      getOperationSummary: getOperationSummary,
+      extractAllOperations: extractAllOperations,
+      groupOperationsByAction: groupOperationsByAction,
+      getOperationTraits: getOperationTraits,
+      operationHasTraits: operationHasTraits,
+      getOperationTags: getOperationTags,
+      generateOperationHandlerName: generateOperationHandlerName
+    }
+  };
+}
+export { VERSION, analyzeChannelServerMappings, analyzeOperationSecurity, channelHasParameters, extractAllOperations, extractAsyncApiInfo, extractChannelParameters, extractChannelVariables, extractOperationSecurityMap, extractServerNameFromRef, formatGenerationDate, generateChannelFormatting, generateChannelParameterArgs, generateEslintConfig, generateFileHeader, generateOperationHandlerName, generatePackageJson, generateReadmeContent, generateTypeScriptChannelFormatting, generateTypeScriptChannelParameterArgs, generateTypeScriptConfig, getAllSecuritySchemes, getAllUtilities, getChannelAddress, getChannelParameters, getDefaultPort, getMessageContentType, getMessageRustTypeName, getMessageTypeName, getMessageTypeScriptTypeName, getNatsSubject, getOperationAction, getOperationChannel, getOperationDescription, getOperationMessages, getOperationName, getOperationRustFunctionName, getOperationSummary, getOperationTags, getOperationTraits, getOperationTypeScriptMethodName, getPayloadRustTypeName, getPayloadTypeScriptTypeName, getSecuritySchemeLocation, getSecuritySchemeName, getSecuritySchemeType, groupOperationsByAction, hasSecuritySchemes, isChannelAllowedOnServer, isDynamicChannel, isOperationReceive, isOperationSend, isSecuritySchemeType, isTemplateVariable, messageHasPayload, operationHasSecurity, operationHasTraits, operationRequiresAuth, resolveChannelAddress, resolveTemplateParameters, toCamelCase, toKebabCase, toPascalCase, toRustEnumVariant, toRustEnumVariantWithSerde, toRustFieldName, toRustIdentifier, toRustTypeName, toSnakeCase, validateChannelServerReferences, validateTemplateParameters };