feat: switch model renders (#53)

Co-authored-by: Fran Méndez <fmvilas@gmail.com>

components/channel/OnReceivingData.js

@@ -1,5 +1,5 @@
 
-import { isBinaryPayload, pascalCase, isStringPayload } from '../../utils/index';
+import { isBinaryPayload, isStringPayload, isJsonPayload} from '../../utils/index';
 
 /**
  * Component which ensures the hooks are called after receiving data.
@@ -9,20 +9,29 @@ import { isBinaryPayload, pascalCase, isStringPayload } from '../../utils/index'
  */
 export function OnReceivingData(message, defaultContentType) {
   //Check if we are converting from binary
-  let convertToBinary = '';
+  let convertFromBinary;
   if (isBinaryPayload(message.contentType(), defaultContentType)) {
-    convertToBinary = `
+    convertFromBinary = `
     if(receivedDataHooks.length == 0){
-      receivedData = ${pascalCase(message.uid())}Message.Convert.to${pascalCase(message.uid())}(receivedData.toString());
+      receivedData = JSON.parse(receivedData.toString());
     }`;
   }
 
   //Check if we are converting from string
-  let convertToString = '';
+  let convertFromString;
   if (isStringPayload(message.contentType(), defaultContentType)) {
-    convertToString = `
+    convertFromString = `
     if(receivedDataHooks.length == 0){
-      receivedData = ${pascalCase(message.uid())}Message.Convert.to${pascalCase(message.uid())}(receivedData);
+      receivedData = JSON.parse(receivedData);
+    }`;
+  }
+
+  //Check if we are converting from JSON
+  let convertFromJson;
+  if (isJsonPayload(message.contentType(), defaultContentType)) {
+    convertFromJson = `
+    if(receivedDataHooks.length == 0){
+      receivedData = receivedData;
     }`;
   }
 
@@ -32,8 +41,7 @@ export function OnReceivingData(message, defaultContentType) {
     for(let hook of receivedDataHooks){
       receivedData = hook(receivedData);
     }
-    ${convertToBinary}
-    ${convertToString}
+    ${convertFromBinary || convertFromString || convertFromJson}
   } catch (e) {
     const error = NatsTypescriptTemplateError.errorForCode(ErrorCode.HOOK_ERROR, e);
     throw error;

components/channel/general.js

@@ -1,17 +1,17 @@
 
-import { messageHasNotNullPayload, pascalCase } from '../../utils/index';
+import { messageHasNotNullPayload, getSchemaFileName } from '../../utils/index';
 
 export function General(channel, publishMessage, subscribeMessage, path) {
   // Import the correct messages
   let publishMessageImport = '';
   if (channel.hasPublish() && messageHasNotNullPayload(publishMessage.payload())) {
-    const publishMessageUid = publishMessage.uid();
-    publishMessageImport = `import * as ${pascalCase(publishMessageUid)}Message from '${path}/messages/${pascalCase(publishMessageUid)}'`;
+    const publishMessageUid = getSchemaFileName(publishMessage.payload().uid());
+    publishMessageImport = `import {${publishMessageUid}} from '${path}/schemas/${publishMessageUid}';`;
   }
   let subscribeMessageImport = '';
   if (channel.hasSubscribe() && messageHasNotNullPayload(subscribeMessage.payload())) {
-    const subscribeMessageUid = subscribeMessage.uid();
-    subscribeMessageImport = `import * as ${pascalCase(subscribeMessageUid)}Message from '${path}/messages/${pascalCase(subscribeMessageUid)}'`;
+    const subscribeMessageUid = getSchemaFileName(subscribeMessage.payload().uid());
+    subscribeMessageImport = `import {${subscribeMessageUid}} from '${path}/schemas/${subscribeMessageUid}';`;
   }
 
   return `

components/index/standard.js

@@ -1,4 +1,4 @@
-import { containsBinaryPayload, containsStringPayload, containsJsonPayload, camelCase, pascalCase, messageHasNotNullPayload} from '../../utils/index';
+import { containsBinaryPayload, containsStringPayload, containsJsonPayload, camelCase, pascalCase, messageHasNotNullPayload, getSchemaFileName} from '../../utils/index';
 
 /**
  * Return disconnect function based on the payload
@@ -259,11 +259,11 @@ export function getStandardHeaderCode(asyncapi, pathToRoot, channelPath) {
   }
 
   //Import the messages and re-export them
-  for (const [messageName, message] of asyncapi.allMessages()) {
+  for (const [, message] of asyncapi.allMessages()) {
     if (messageHasNotNullPayload(message.payload())) {
-      const pascalMessageName = pascalCase(messageName);
-      imports.push(`import * as ${pascalMessageName}Message from "${pathToRoot}/messages/${pascalMessageName}";`);
-      exports.push(`export {${pascalMessageName}Message};`);
+      const schemaName = getSchemaFileName(message.payload().uid());
+      imports.push(`import {${schemaName}} from "${pathToRoot}/schemas/${schemaName}";`);
+      exports.push(`export {${schemaName}};`);
     }
   }
   return `

examples/GenerateAndTest.sh

@@ -5,7 +5,7 @@ cd ./publish\ subscribe
 sh ./GenerateAndBuild.sh
 sh ./Test.sh
 
-cd ../../request\ reply
+cd ../request\ reply
 sh ./GenerateAndBuild.sh
 sh ./Test.sh
 

examples/publish subscribe/streetlight/src/messages/AnonymSchema1.ts

@@ -0,0 +1,10 @@
+class anonymSchema1 {
+  private lumen: number;
+
+  constructor(input: anonymSchema1Input) {
+    this.lumen = input.lumen;
+  }
+
+  get lumen(): number { return this.lumen; }
+  set lumen(lumen: number) { this.lumen = lumen; }
+}

examples/request reply/streetlight/package.json

@@ -23,4 +23,4 @@
     "chai": "^4.2.0",
     "mocha": "^8.2.1"
   }
-}
+}

hooks/schema-generation.js

@@ -0,0 +1,38 @@
+/* eslint-disable security/detect-non-literal-fs-filename */
+const {TypeScriptGenerator, FormatHelpers} = require('@asyncapi/generator-model-sdk');
+const fs = require('fs');
+const Path = require('path');
+
+const preset = {
+  interface: {
+    async property({ renderer, model, propertyName, property }) {
+      const signature = renderer.renderTypeSignature(property, { isRequired: model.isRequired(propertyName) });
+      return `${propertyName}${signature};`;
+    }
+  }
+};
+/**
+ * Use AsyncAPI generator model gen library to generate all schemas.
+ */
+module.exports = {
+  'generate:after': async (generator) => {
+    const typescriptGenerator = new TypeScriptGenerator({modelType: 'interface', presets: [preset]});
+    const generatedModels = await typescriptGenerator.generate(generator.asyncapi);
+    const targetDir = Path.join(generator.targetDir, 'src/schemas/');
+    for (const generatedModel of generatedModels) {
+      const fileContent = `
+${generatedModel.model.getImmediateDependencies().map((value) => {return FormatHelpers.toPascalCase(value);}).join('\n')}
+${generatedModel.result}
+      `;
+      await fs.promises.mkdir(`${targetDir}`, { recursive: true }).catch(console.error);
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(
+        Path.join(
+          targetDir,
+          `${FormatHelpers.toPascalCase(generatedModel.modelName)}.ts`
+        ),
+        fileContent
+      );
+    }
+  }
+};