Reusable Components API

1const language = "java";
2const framework = "quarkus";
3const methodName = "terminateConnection";
4const methodParams = ["String reason"];
5const preExecutionCode = "// About to terminate connection";
6const postExecutionCode = "// Connection terminated";
7const indent = 2;
8
9function renderCloseConnection() {
10  return (
11    <CloseConnection 
12       language={language}
13       framework={framework}
14       methodName={methodName}
15       methodParams={methodParams}
16       preExecutionCode={preExecutionCode} 
17       postExecutionCode={postExecutionCode} 
18       indent={indent} 
19     />
20  );
21}
22
23renderCloseConnection();

1const language = "python";
2const title = "HoppscotchEchoWebSocketClient";
3
4function renderConnect() {
5  return(
6   <Connect 
7       language={language} 
8       title={title} 
9   />
10  )
11}
12
13renderConnect();

1const language = "java";
2const framework = "quarkus";
3const role = "client";
4const additionalDependencies = ["import java.util.concurrent.CompletableFuture;", "import java.time.Duration;"];
5
6function renderDependencyProvider() {
7  return (
8    <DependencyProvider 
9       language={language} 
10       framework={framework} 
11       role={role} 
12       additionalDependencies={additionalDependencies} 
13    />
14  )
15}
16renderDependencyProvider();

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { FileHeaderInfo } from "@asyncapi/generator-components";
4
5async function renderFileHeader() {
6  const parser = new Parser();
7  const asyncapi_websocket_query = path.resolve(__dirname, "../../../helpers/test/__fixtures__/asyncapi-websocket-query.yml");
8  const language = "javascript";
9  
10  // Parse the AsyncAPI document 
11  const parseResult = await fromFile(parser, asyncapi_websocket_query).parse();
12  const parsedAsyncAPIDocument = parseResult.document;
13  
14  return (
15    <FileHeaderInfo 
16      info={parsedAsyncAPIDocument.info()} 
17      server={parsedAsyncAPIDocument.servers().get("withPathname")} 
18      language={language} 
19    />
20  )
21}
22
23renderFileHeader().catch(console.error);

1const language = "javascript";
2const methodName = "handleMessage";
3const methodParams = ["message","cb"];
4const preExecutionCode = "// Pass the incoming message to all registered message handlers.";
5const postExecutionCode = "// Passed the incoming message to all registered message handlers.";
6const customMethodConfig = {
7  javascript: {
8    methodDocs: "// Method to handle message with callback",
9    methodLogic: "if (cb) cb(message);"
10  }
11};
12
13function renderHandleMessage() {
14  return (
15    <HandleMessage 
16       language={language} 
17       methodName={methodName} 
18       methodParams={methodParams} 
19       preExecutionCode={preExecutionCode} 
20       postExecutionCode={postExecutionCode} 
21       customMethodConfig={customMethodConfig} 
22    />
23  )
24}
25
26renderHandleMessage();

1const language = "java";
2const methodName = "registerHandler";
3const methodParams = ["Handler handler"];
4const methodDocs = "// Process the input data.";
5const methodLogic = "// TODO: implement";
6const preExecutionCode = "// Before handler registration";
7const postExecutionCode = "// After handler registration";
8const customMethodConfig={ openingTag: "{", closingTag: "}", indentSize: 6 };
9const methodConfig = {"java" : {"quarkus": {methodDocs : methodDocs, methodLogic: methodLogic }}};
10const framework = "quarkus";
11
12function renderMethodGenerator() {
13  return (
14    <MethodGenerator 
15       language={language}
16       methodName={methodName} 
17       methodParams={methodParams} 
18       methodDocs={methodDocs} 
19       methodLogic={methodLogic} 
20       preExecutionCode={preExecutionCode} 
21       postExecutionCode={postExecutionCode} 
22       customMethodConfig={customMethodConfig} 
23       methodConfig={methodConfig} 
24       framework={framework} 
25    />
26  )
27}
28
29renderMethodGenerator();

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { Models } from "@asyncapi/generator-components";
4
5async function renderModel() {
6   const parser = new Parser();
7   const asyncapi_v3_path = path.resolve(__dirname, "../__fixtures__/asyncapi-v3.yml");
8
9    // Parse the AsyncAPI document
10   const parseResult = await fromFile(parser, asyncapi_v3_path).parse();
11   const parsedAsyncAPIDocument = parseResult.document;
12   
13   const language = "java";
14   
15   return (
16     <Models 
17        asyncapi={parsedAsyncAPIDocument} 
18        language={language}
19     />
20   )
21}
22
23renderModel().catch(console.error);

1const language = "java";
2const framework = "quarkus";
3const title = "HoppscotchEchoWebSocketClient";
4
5function renderOnClose() {
6 return (
7   <OnClose 
8      language={language} 
9      framework={framework} 
10      title={title}  
11   />
12 )
13}
14
15renderOnClose();

1const language = "javascript";
2
3function renderOnError() {
4  return (
5    <OnError language={language} />
6  )
7}
8
9renderOnError();

1const language = "javascript";
2
3function renderOnMessage() {
4  return (
5    <OnMessage language={language} />
6  )
7}
8
9renderOnMessage();

1const language = "java";
2const framework = "quarkus";
3const title = "HoppscotchEchoWebSocketClient";
4
5function renderOnOpen() {
6  return (
7    <OnOpen 
8       language={language} 
9       framework={framework} 
10       title={title} 
11    />
12  )
13}
14
15renderOnOpen();

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { getQueryParams } from "@asyncapi/generator-helpers";
4import { QueryParamsVariables } from "@asyncapi/generator-components";
5
6async function renderQueryParamsVariable(){
7   const parser = new Parser();
8   const asyncapi_v3_path = path.resolve(__dirname, "../__fixtures__/asyncapi-v3.yml");
9   
10   // Parse the AsyncAPI document
11   const parseResult = await fromFile(parser, asyncapi_v3_path).parse();
12   const parsedAsyncAPIDocument = parseResult.document;
13   
14   const channels = parsedAsyncAPIDocument.channels();
15   const queryParamsObject = getQueryParams(channels);
16   const queryParamsArray = queryParamsObject ? Array.from(queryParamsObject.entries()) : [];
17   
18   const language = "java";
19   const framework = "quarkus";
20   
21   return (
22     <QueryParamsVariables 
23         language={language} 
24         framework={framework}   
25         queryParams={queryParamsArray} 
26     />
27   )
28}
29
30renderQueryParamsVariable().catch(console.error);

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { AvailableOperations } from "@asyncapi/generator-components";
4
5async function renderAvailableOperations(){
6  const parser = new Parser();
7  const asyncapi_websocket_query = path.resolve(__dirname, '../../../helpers/test/__fixtures__/asyncapi-websocket-query.yml');
8
9  //parse the AsyncAPI document
10  const parseResult = await fromFile(parser, asyncapi_websocket_query).parse();
11  const parsedAsyncAPIDocument = parseResult.document;
12
13  return (
14   <AvailableOperations operations={parsedAsyncAPIDocument.operations().all()} />
15  )    
16}
17
18renderAvailableOperations().catch(console.error);

1const language = "javascript";
2
3function renderCoreMethods() {
4  return (
5    <CoreMethods language={language} />
6  )
7}
8
9renderCoreMethods();

1const language = "javascript";
2
3function renderInstallation() {
4  return (
5    <Installation language={language} />
6  )
7}
8
9renderInstallation()

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { MessageExamples } from "@asyncapi/generator-components";
4
5async function renderMessageExamples(){
6  const parser = new Parser();
7  const asyncapi_websocket_query = path.resolve(__dirname, '../../../helpers/test/__fixtures__/asyncapi-websocket-query.yml');
8
9  //parse the AsyncAPI document
10  const parseResult = await fromFile(parser, asyncapi_websocket_query).parse();
11  const parsedAsyncAPIDocument = parseResult.document;
12  const operations = parsedAsyncAPIDocument.operations().all();
13
14  return operations.map((operation) => {
15     return (
16       <MessageExamples operation={operation} />
17     )    
18  });
19}
20
21renderMessageExamples().catch(console.error);

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { OperationHeader } from "@asyncapi/generator-components";
4
5async function renderOperationHeader(){
6  const parser = new Parser();
7  const asyncapi_websocket_query = path.resolve(__dirname, '../../../helpers/test/__fixtures__/asyncapi-websocket-query.yml');
8
9  //parse the AsyncAPI document
10  const parseResult = await fromFile(parser, asyncapi_websocket_query).parse();
11  const parsedAsyncAPIDocument = parseResult.document;
12  const operations = parsedAsyncAPIDocument.operations().all();
13
14  return operations.map((operation) => {
15     return (
16       <OperationHeader operation={operation} />
17     )    
18  });
19}
20
21renderOperationHeader().catch(console.error);

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { getServer, getServerUrl } from '@asyncapi/generator-helpers';
4import { Overview } from "@asyncapi/generator-components";
5
6async function renderOverview(){
7  const parser = new Parser();
8  const asyncapi_websocket_query = path.resolve(__dirname, '../../../helpers/test/__fixtures__/asyncapi-websocket-query.yml');
9
10  //parse the AsyncAPI document
11  const parseResult = await fromFile(parser, asyncapi_websocket_query).parse();
12  const parsedAsyncAPIDocument = parseResult.document;
13
14  const info = parsedAsyncAPIDocument.info();
15  const title = info.title();
16  const server = getServer(parsedAsyncAPIDocument.servers(), 'withoutPathName');
17  const serverUrl = getServerUrl(server);
18
19  return (
20     <Overview 
21       info={info} 
22       title={title} 
23       serverUrl={serverUrl} 
24     />
25  )
26}
27
28renderOverview().catch(console.error);

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { buildParams } from '@asyncapi/generator-helpers';
4import { Readme } from "@asyncapi/generator-components";
5
6async function renderReadme(){
7  const parser = new Parser();
8  const asyncapi_websocket_query = path.resolve(__dirname, '../../../helpers/test/__fixtures__/asyncapi-websocket-query.yml');
9
10  // parse the AsyncAPI document
11  const parseResult = await fromFile(parser, asyncapi_websocket_query).parse();
12  const parsedAsyncAPIDocument = parseResult.document;
13  const language = "javascript";
14  const config = { clientFileName: 'myClient.js' };
15  const params = buildParams('javascript', config, 'echoServer');
16  
17  return (
18    <Readme 
19      asyncapi={parsedAsyncAPIDocument} 
20      params={params} 
21      language={language}
22    />
23  )
24}
25
26renderReadme().catch(console.error);

1const clientName = "MyClient";
2const clientFileName = "myClient.js";
3const language = "javascript";
4
5function renderUsage(){
6  return (
7    <Usage 
8       clientName={clientName} 
9       clientFileName={clientFileName} 
10       language={language}
11    />
12  )
13}
14
15renderUsage();

1const language = "python";
2const methodName = "registerErrorHandler";
3const methodParams = ["self", "handler"];
4const preExecutionCode = "# Pre-register operations";
5const postExecutionCode = "# Post-register operations";
6const customMethodConfig = { returnType: "int", openingTag: "{", closingTag: "}", indentSize: 2};
7
8function renderRegisterErrorHandler() {
9 return (
10   <RegisterErrorHandler 
11      language={language} 
12      methodName={methodName} 
13      methodParams={methodParams} 
14      preExecutionCode={preExecutionCode} 
15      postExecutionCode={postExecutionCode} 
16      customMethodConfig={customMethodConfig}   
17   />
18 )
19}
20
21renderRegisterErrorHandler();

1const language = "python";
2const methodName = "registerMessageHandler";
3const methodParams = ["self", "handler"];
4const preExecutionCode = "# Pre-register operations";
5const postExecutionCode = "# Post-register operations";
6
7function renderRegisterMessageHandler(){
8  return (
9     <RegisterMessageHandler 
10       language={language} 
11       methodName={methodName} 
12       methodParams={methodParams} 
13       preExecutionCode={preExecutionCode} 
14       postExecutionCode={postExecutionCode} 
15     />
16  )
17}
18
19renderRegisterMessageHandler();

1import path from "path";
2import { Parser, fromFile } from "@asyncapi/parser";
3import { SendOperations } from "@asyncapi/generator-components";
4
5async function renderSendOperations(){
6   const parser = new Parser();
7   const asyncapi_v3_path = path.resolve(__dirname, '../__fixtures__/asyncapi-v3.yml');
8   
9   // Parse the AsyncAPI document
10   const parseResult = await fromFile(parser, asyncapi_v3_path).parse();
11   const parsedAsyncAPIDocument = parseResult.document;
12   
13   const language = "javascript";
14   const clientName = "AccountServiceAPI";
15   const sendOperations = parsedAsyncAPIDocument.operations().filterBySend();
16   
17   return (
18      <SendOperations 
19         language={language} 
20         clientName={clientName} 
21         sendOperations={sendOperations} 
22      />
23   )
24}
25
26renderSendOperations().catch(console.error);