feat: enable v3 support

components/Asyncapi.js

@@ -0,0 +1,25 @@
+import { Info } from './Info';
+import { Servers } from './Servers';
+import { Operations } from './Operations';
+import { FrontMatter } from './FrontMatter';
+import { TableOfContents } from './TableOfContents';
+
+// eslint-disable-next-line no-unused-vars
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+
+/**
+ * @param {{asyncapi: AsyncAPIDocumentInterface, params: any}} param0 
+ */
+export function Asyncapi({ asyncapi, params }) {
+  return (
+    <>
+      {params.frontMatter && <FrontMatter asyncapi={asyncapi} params={params} />}
+      <Info asyncapi={asyncapi} params={params} />
+      {params.toc !== 'false' && <TableOfContents asyncapi={asyncapi} />}
+
+      <Servers asyncapi={asyncapi} />
+      <Operations asyncapi={asyncapi} />
+    </>
+  );
+}
+

components/Operations.js

@@ -1,52 +1,61 @@
 import { Text } from '@asyncapi/generator-react-sdk';
-
 import { Bindings } from './Bindings';
 import { Extensions } from './Extensions';
 import { Message } from './Message';
 import { Schema } from './Schema';
 import { Security } from './Security';
 import { Tags } from './Tags';
 import { Header, ListItem, Link } from './common';
-
 import { SchemaHelpers } from '../helpers/schema';
 import { FormatHelpers } from '../helpers/format';
 
+// eslint-disable-next-line no-unused-vars
+import { AsyncAPIDocumentInterface, OperationInterface, ChannelInterface } from '@asyncapi/parser';
+
+function isV3({asyncapi}) {
+  return asyncapi.version().split('.')[0] === '3';
+}
+
+/**
+ * @param {{asyncapi: AsyncAPIDocumentInterface}} param0 
+ */
 export function Operations({ asyncapi }) {
   const channels = asyncapi.channels();
   if (channels.isEmpty()) {
     return null;
   }
 
   const operationsList = [];
-  channels.all().map(channel => {
+  for (const channel of channels.all()) {
     const channelName = channel.address();
-    channel.operations().all().forEach(operation => {
-      if (operation.action() === 'publish') {
-        operationsList.push(
-          <Operation
-            key={`pub-${channelName}`}
-            type='publish'
-            asyncapi={asyncapi}
-            operation={operation}
-            channelName={channelName}
-            channel={channel}
-          />
-        );
-      }
-      if (operation.action() === 'subscribe') {
-        operationsList.push(
-          <Operation
-            key={`sub-${channelName}`}
-            type='subscribe'
-            asyncapi={asyncapi}
-            operation={operation}
-            channelName={channelName}
-            channel={channel}
-          />
-        );
+    const operations = channel.operations().all();
+    operations.map(operation => {
+      let type;
+      if (operation.isSend()) {
+        if (operation.reply() !== undefined) {
+          type = 'request';
+        } else {
+          type = 'send';
+        }
+      } else if (operation.isReceive()) {
+        if (operation.reply() !== undefined) {
+          type = 'reply';
+        } else {
+          type = 'receive';
+        }
       }
+      operationsList.push(
+        <Operation
+          key={`${operation.action()}-${channelName}`}
+          type={type}
+          asyncapi={asyncapi}
+          operation={operation}
+          channelName={channelName}
+          channel={channel}
+        />
+      );
     });
-  });
+  }
 
   return (
     <>
@@ -57,8 +66,35 @@ export function Operations({ asyncapi }) {
     </>
   );
 }
-
-function Operation({ type, asyncapi, operation, channelName, channel }) { // NOSONAR
+function getRenderedTypeForOperation({asyncapi, type}) {
+  const isv3 = isV3({asyncapi});
+  if (isv3) {
+    switch (type) {
+    case 'request':
+      return 'REQUEST';
+    case 'send':
+      return 'SEND';
+    case 'reply':
+      return 'REPLY';
+    case 'receive':
+      return 'RECEIVE';
+    }
+  }
+  // For v2, we render the application view still
+  // Meaning the when you use publish operation it means other publish to your application because your application is subscribing to it.
+  switch (type) {
+  case 'send': // This is the publish operation
+    return 'SUB';
+  case 'receive': // This is the subscribe operation
+    return 'PUB';
+  }
+  // This case should never happen, if it does this function needs to be changed
+  return 'UNKNOWN';
+}
+/**
+ * @param {{asyncapi: AsyncAPIDocumentInterface, type: string, operation: OperationInterface, channelName: string, channel: ChannelInterface}} param0 
+ */
+function Operation({ asyncapi, type, operation, channelName, channel }) { // NOSONAR
   if (!operation || !channel) {
     return null;
   }
@@ -68,7 +104,8 @@ function Operation({ type, asyncapi, operation, channelName, channel }) { // NOS
   const applyToAllServers = asyncapi.servers().all().length === channel.servers().all().length;
   const servers = applyToAllServers ? [] : channel.servers().all();
   const security = operation.security();
-  const renderedType = type === 'publish' ? 'PUB' : 'SUB';
+  const renderedType = getRenderedTypeForOperation({asyncapi, type});
+
   const showInfoList = operationId || (servers && servers.length);
 
   return (
@@ -79,7 +116,7 @@ function Operation({ type, asyncapi, operation, channelName, channel }) { // NOS
 
       {operation.summary() && (
         <Text newLines={2}>
-          *{operation.summary()}*
+          *{operation.summary().trim()}*
         </Text>
       )}
 
@@ -138,11 +175,16 @@ function Operation({ type, asyncapi, operation, channelName, channel }) { // NOS
       <Extensions name="Channel extensions" item={channel} />
       <Extensions name="Operation extensions" item={operation} />
 
-      <OperationMessages operation={operation} />
+      <OperationMessages operation={operation} asyncapi={asyncapi} type={type} />
+
+      <OperationReply operation={operation} />
     </Text>
   );
 }
 
+/**
+ * @param {{channel: ChannelInterface}} param0 
+ */
 function OperationParameters({ channel }) {
   const parameters = SchemaHelpers.parametersToSchema(channel.parameters().all());
   if (!parameters) {
@@ -156,18 +198,36 @@ function OperationParameters({ channel }) {
     </Text>
   );
 }
-
-function OperationMessages({ operation }) {
+function getOperationMessageText({asyncapi, type}) {
+  let messagesText = 'Accepts **one of** the following messages:';
+  if (isV3({asyncapi})) {
+    if (type === 'send') {
+      messagesText = 'Sending **one of** the following messages:';
+    } else if (type === 'request') {
+      messagesText = 'Request contains **one of** the following messages:';
+    } else if (type === 'receive') {
+      messagesText = 'Receive **one of** the following messages:';
+    } else if (type === 'reply') {
+      messagesText = 'Request contains **one of** the following messages:';
+    }
+  }
+  return messagesText;
+}
+/**
+ * @param {{operation: OperationInterface, asyncapi: AsyncAPIDocumentInterface, type: string}} param0 
+ */
+function OperationMessages({ asyncapi, operation, type }) {
   const messages = operation.messages().all();
   if (messages.length === 0) {
     return null;
   }
+  const messageText = getOperationMessageText({asyncapi, type});
 
   return (
     <>
       {messages.length > 1 && (
         <Text newLines={2}>
-          Accepts **one of** the following messages:
+          {messageText}
         </Text>
       )}
       {messages.map((msg, idx) => (
@@ -176,3 +236,81 @@ function OperationMessages({ operation }) {
     </>
   );
 }
+
+/**
+ * @param {{operation: OperationInterface}} param0 
+ */
+function OperationReply({ operation, type }) {
+  const reply = operation.reply();
+  if (reply === undefined) {
+    return null;
+  }
+  const explicitChannel = reply.channel();
+
+  let typeText;
+  if (operation.isSend()) {
+    typeText = 'Request';
+  } else if (operation.isReceive()) {
+    typeText = 'Response';
+  }
+
+  let messagesText;
+  if (type === 'request') {
+    messagesText = 'Receive **one of** the following messages as a response to the request:';
+  } else if (type === 'reply') {
+    messagesText = 'Replying with **one of** the following messages:';
+  }
+
+  return (
+    <Text>
+      <Header type={4}>
+        {`${typeText} information`}
+      </Header>
+
+      {explicitChannel && <ListItem>{type} should be done to channel: `{explicitChannel.address()}`</ListItem>}
+
+      <OperationReplyAddress name="Operation reply address" reply={reply} />
+
+      <>
+        {reply.messages().length > 1 && (
+          <Text newLines={2}>
+            {messagesText}
+          </Text>
+        )}
+        {reply.messages().length > 1 && reply.messages().map((msg, idx) => (
+          <Message message={msg} key={`message-${idx}`} />
+        ))}
+      </>
+      <Extensions name="Operation reply extensions" item={reply} />
+    </Text>
+  );
+}
+
+/**
+ * @param {{reply: OperationReplyInterface}} param0 
+ */
+function OperationReplyAddress({ reply }) {
+  const address = reply.address();
+  if (address === undefined) {
+    return null;
+  }
+  const location = address.location();
+
+  return (
+    <Text>
+      <Header type={4}>
+        {'Operation reply address information'}
+      </Header>
+
+      {address.hasDescription() && (
+        <Text newLines={2}>
+          {address.description()}
+        </Text>
+      )}
+
+      <ListItem>Operation reply address location: `{location}`</ListItem>
+
+      <Extensions name="Operation reply address extensions" item={address} />
+    </Text>
+  );
+}

components/Schema.js

@@ -6,6 +6,12 @@ import { SchemaHelpers } from '../helpers/schema';
 
 const headers = ['Name', 'Type', 'Description', 'Value', 'Constraints', 'Notes'];
 
+// eslint-disable-next-line no-unused-vars
+import { SchemaInterface } from '@asyncapi/parser';
+
+/**
+ * @param {{schema: SchemaInterface, schemaName: string, hideTitle: boolean}} param0 
+ */
 export function Schema({ schema, schemaName, hideTitle = false }) {
   return (
     <Text>

helpers/schema.js

@@ -194,6 +194,11 @@ export class SchemaHelpers {
     return JSON.stringify(value);
   }
 
+  /**
+   * 
+   * @param {import('@asyncapi/parser').ChannelParametersInterface} parameters 
+   * @returns 
+   */
   static parametersToSchema(parameters) {
     if (parameters.length === 0) {
       return;
@@ -204,7 +209,7 @@ export class SchemaHelpers {
       properties: parameters.reduce(
         (obj, parameter) => {
           const parameterName = parameter.id();
-          obj[String(parameterName)] = Object.assign({}, parameter.schema().json());
+          obj[String(parameterName)] = Object.assign({}, parameter.schema() === undefined ? {type: 'string'} : parameter.schema().json());
           obj[String(parameterName)].description =
             parameter.description() || obj[String(parameterName)].description;
           obj[String(parameterName)][this.extParameterLocation] = parameter.location();