@asyncapi/generator 1.11.0 → 1.13.0

package/.sonarcloud.properties

@@ -1,2 +1,2 @@
 #we need to explicitly exclude them as some are commit to the repo
-sonar.exclusions=test/test-project/node_modules/@asyncapi/html-template/**/*
+sonar.exclusions=test/**/*

package/CODEOWNERS

@@ -9,4 +9,4 @@
 * @derberg @magicmatatjahu @jonaslagoni @asyncapi-bot-eve
 
 # All .md files
-*.md @Florence-Njeri @pratik2315 @asyncapi-bot-eve
+*.md @Florence-Njeri @derberg @asyncapi-bot-eve

package/docs/configuration-file.md

@@ -8,7 +8,7 @@ The `generator` property from `package.json` file must contain a JSON object tha
 |Name|Type|Description|
 |---|---|---|
 |`renderer`| String | Its value can be either `react` or `nunjucks` (default).
-|`apiVersion`| String | Determines which **major** version of the [Parser-API](https://github.com/asyncapi/parser-api) the template uses. For example, `v1` for `v1.x.x`. If not specified, the Generator assumes the template is not compatible with the Parser-API so it will use the [Parser-JS v1 API](https://github.com/asyncapi/parser-js/tree/v1.18.1#api-documentation). If the template uses a version of the Parser-API that is not supported by the Generator, the Generator will throw an error.
+|`apiVersion`| String | Determines which **major** version of the [Parser-API](https://github.com/asyncapi/parser-api) the template uses. For example, `v2` for `v2.x.x`. If not specified, the Generator assumes the template is not compatible with the Parser-API so it will use the [Parser-JS v1 API](https://github.com/asyncapi/parser-js/tree/v1.18.1#api-documentation). For templates that need to support AsyncAPI specification v3 make sure to use `v2` [Parser-API](https://github.com/asyncapi/parser-api). If the template uses a version of the Parser-API that is not supported by the Generator, the Generator will throw an error.
 |`supportedProtocols`| [String] | A list with all the protocols this template supports.
 |`parameters`| Object[String, Object] | An object with all the parameters that can be passed when generating the template. When using the command line, it's done by indicating `--param name=value` or `-p name=value`.
 |`parameters[param].description`| String | A user-friendly description about the parameter.
@@ -28,7 +28,7 @@ The `generator` property from `package.json` file must contain a JSON object tha
 "generator":
 {
   "renderer": "react",
-  "apiVersion": "v1",
+  "apiVersion": "v2",
   "supportedProtocols": ["amqp", "mqtt"],
   "parameters": {
     "server": {

package/lib/generator.js

@@ -155,13 +155,19 @@ class Generator {
    *   console.error(e);
    * }
    *
-   * @param  {AsyncAPIDocument} asyncapiDocument AsyncAPIDocument object to use as source.
+   * @param  {AsyncAPIDocument | string} asyncapiDocument AsyncAPIDocument object to use as source.
+   * @param  {Object} [parseOptions={}] AsyncAPI Parser parse options. Check out {@link https://www.github.com/asyncapi/parser-js|@asyncapi/parser} for more information. Remember to use the right options to the right parser depending on the template you are using.
    * @return {Promise}
    */
-  async generate(asyncapiDocument) {
-    if (!isAsyncAPIDocument(asyncapiDocument)) throw new Error('Parameter "asyncapiDocument" must be an AsyncAPIDocument object.');
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async generate(asyncapiDocument, parseOptions = {}) {
+    const isAlreadyParsedDocument = isAsyncAPIDocument(asyncapiDocument);
+    const isParsableCompatible = asyncapiDocument && typeof asyncapiDocument === 'string';
+    if (!isAlreadyParsedDocument && !isParsableCompatible) {
+      throw new Error('Parameter "asyncapiDocument" must be a non-empty string or an already parsed AsyncAPI document.');
+    }
+    this.asyncapi = this.originalAsyncAPI = asyncapiDocument;
 
-    this.asyncapi = asyncapiDocument;
     if (this.output === 'fs') {
       xfs.mkdirpSync(this.targetDir);
       if (!this.forceWrite) await this.verifyTargetDir(this.targetDir);
@@ -176,11 +182,11 @@ class Generator {
     this.templateName = templatePkgName;
     this.templateContentDir = path.resolve(this.templateDir, TEMPLATE_CONTENT_DIRNAME);
     await this.loadTemplateConfig();
-    validateTemplateConfig(this.templateConfig, this.templateParams, asyncapiDocument);
-    await this.configureTemplate();
 
-    // use new or old document API based on `templateConfig.apiVersion` value
-    this.asyncapi = asyncapiDocument = getProperApiDocument(asyncapiDocument, this.templateConfig);
+    await this.parseInput(this.asyncapi, parseOptions);
+
+    validateTemplateConfig(this.templateConfig, this.templateParams, this.asyncapi);
+    await this.configureTemplate();
 
     if (!isReactTemplate(this.templateConfig)) {
       await registerFilters(this.nunjucks, this.templateConfig, this.templateDir, FILTERS_DIRNAME);
@@ -192,17 +198,38 @@ class Generator {
       const entrypointPath = path.resolve(this.templateContentDir, this.entrypoint);
       if (!(await exists(entrypointPath))) throw new Error(`Template entrypoint "${entrypointPath}" couldn't be found.`);
       if (this.output === 'fs') {
-        await this.generateFile(asyncapiDocument, path.basename(entrypointPath), path.dirname(entrypointPath));
+        await this.generateFile(this.asyncapi, path.basename(entrypointPath), path.dirname(entrypointPath));
         await this.launchHook('generate:after');
       } else if (this.output === 'string') {
-        return this.renderFile(asyncapiDocument, entrypointPath);
+        return this.renderFile(this.asyncapi, entrypointPath);
       }
     } else {
-      await this.generateDirectoryStructure(asyncapiDocument);
+      await this.generateDirectoryStructure(this.asyncapi);
       await this.launchHook('generate:after');
     }
   }
 
+  /**
+   * Parse the generator input based on the template `templateConfig.apiVersion` value.
+   */
+  async parseInput(asyncapiDocument, parseOptions = {}) {
+    const isAlreadyParsedDocument = isAsyncAPIDocument(asyncapiDocument);
+    // use the expected document API based on `templateConfig.apiVersion` value
+    if (isAlreadyParsedDocument) {
+      this.asyncapi = getProperApiDocument(asyncapiDocument, this.templateConfig);
+    } else {
+      /** @type {AsyncAPIDocument} Parsed AsyncAPI schema. See {@link https://github.com/asyncapi/parser-js/blob/master/API.md#module_@asyncapi/parser+AsyncAPIDocument|AsyncAPIDocument} for details on object structure. */
+      const { document, diagnostics } = await parse(asyncapiDocument, parseOptions, this);
+      if (!document) {
+        const err = new Error('Input is not a correct AsyncAPI document so it cannot be processed.');
+        err.diagnostics = diagnostics;
+        throw err;
+      } else {
+        this.asyncapi = document;
+      }
+    }
+  }
+
   /**
    * Configure the templates based the desired renderer.
    */
@@ -250,22 +277,15 @@ class Generator {
    *
    * @param  {String} asyncapiString AsyncAPI string to use as source.
    * @param  {Object} [parseOptions={}] AsyncAPI Parser parse options. Check out {@link https://www.github.com/asyncapi/parser-js|@asyncapi/parser} for more information.
+   * @deprecated Use the `generate` function instead. Just change the function name and it works out of the box.
    * @return {Promise}
    */
   async generateFromString(asyncapiString, parseOptions = {}) {
-    if (!asyncapiString || typeof asyncapiString !== 'string') throw new Error('Parameter "asyncapiString" must be a non-empty string.');
-
-    /** @type {String} AsyncAPI string to use as a source. */
-    this.originalAsyncAPI = asyncapiString;
-
-    /** @type {AsyncAPIDocument} Parsed AsyncAPI schema. See {@link https://github.com/asyncapi/parser-js/blob/master/API.md#module_@asyncapi/parser+AsyncAPIDocument|AsyncAPIDocument} for details on object structure. */
-    const { document, diagnostics } = await parse(asyncapiString, parseOptions, this);
-    if (!document) {
-      const err = new Error('Input is not a corrent AsyncAPI document so it cannot be processed.');
-      err.diagnostics = diagnostics;
-      throw err;
+    const isParsableCompatible = asyncapiString && typeof asyncapiString === 'string';
+    if (!isParsableCompatible) {
+      throw new Error('Parameter "asyncapiString" must be a non-empty string.');
     }
-    return this.generate(document);
+    return this.generate(asyncapiString, parseOptions);
   }
 
   /**
@@ -292,7 +312,7 @@ class Generator {
    */
   async generateFromURL(asyncapiURL) {
     const doc = await fetchSpec(asyncapiURL);
-    return this.generateFromString(doc, { path: asyncapiURL });
+    return this.generate(doc, { path: asyncapiURL });
   }
 
   /**
@@ -319,7 +339,7 @@ class Generator {
    */
   async generateFromFile(asyncapiFile) {
     const doc = await readFile(asyncapiFile, { encoding: 'utf8' });
-    return this.generateFromString(doc, { path: asyncapiFile });
+    return this.generate(doc, { path: asyncapiFile });
   }
 
   /**
@@ -416,7 +436,6 @@ class Generator {
    */
   getAllParameters(asyncapiDocument) {
     const parameters = new Map();
-
     if (usesNewAPI(this.templateConfig)) {
       asyncapiDocument.channels().all().forEach(channel => {
         channel.parameters().all().forEach(parameter => {
@@ -436,7 +455,7 @@ class Generator {
           }
         });
       }
-  
+
       if (asyncapiDocument.hasComponents()) {
         for (const [key, value] of Object.entries(asyncapiDocument.components().parameters())) {
           parameters.set(key, value);

package/lib/parser.js

@@ -1,33 +1,52 @@
 const fs = require('fs');
-
-const { Parser, convertToOldAPI } = require('@asyncapi/parser/cjs');
-const { OpenAPISchemaParser } = require('@asyncapi/openapi-schema-parser');
-const { AvroSchemaParser } = require('@asyncapi/avro-schema-parser');
-const { RamlDTSchemaParser } = require('@asyncapi/raml-dt-schema-parser');
-const { ProtoBuffSchemaParser } = require('@asyncapi/protobuf-schema-parser');
+const { convertToOldAPI } = require('@asyncapi/parser');
+const { ConvertDocumentParserAPIVersion, NewParser } = require('@smoya/multi-parser');
 
 const parser = module.exports;
 
-const defaultParser = new Parser({
-  schemaParsers: [
-    OpenAPISchemaParser(),
-    AvroSchemaParser(),
-    RamlDTSchemaParser(),
-    ProtoBuffSchemaParser(),
-  ],
-});
+/**
+ * Convert the template defined value `apiVersion: 'v1'` to only contain the numeric value `1`.
+ */
+parser.sanitizeTemplateApiVersion = (apiVersion) => {
+  if (apiVersion && apiVersion.length > 1) {
+    return apiVersion.substring(1);
+  }
+  return apiVersion;
+};
 
-parser.parse = (asyncapi, oldOptions, generator) => {
+parser.parse = async (asyncapi, oldOptions, generator) => {
+  let apiVersion = this.sanitizeTemplateApiVersion(generator.templateConfig.apiVersion);
+  // Defaulting to apiVersion v1 to convert it to the Parser-API v1 afterwards.
+  if (!this.usesNewAPI(generator.templateConfig)) {
+    apiVersion = '1';
+  }
   const options = convertOldOptionsToNew(oldOptions, generator);
-  return defaultParser.parse(asyncapi, options);
+  const parser = NewParser(apiVersion, {parserOptions: options, includeSchemaParsers: true});
+  const { document, diagnostics } = await parser.parse(asyncapi, options);
+  if (!document) {
+    return {document, diagnostics};
+  }
+  const correctDocument = this.getProperApiDocument(document, generator.templateConfig);
+  return {document: correctDocument, diagnostics};
 };
 
+/**
+ * If the template expect one of the Parser-API versions, it must be above 0
+ */
 parser.usesNewAPI = (templateConfig = {}) => {
-  return templateConfig.apiVersion === 'v1';
+  return Number(this.sanitizeTemplateApiVersion(templateConfig.apiVersion)) > 0;
 };
 
-parser.getProperApiDocument = (asyncapiDocument, templateConfig) => {
-  return parser.usesNewAPI(templateConfig) ? asyncapiDocument : convertToOldAPI(asyncapiDocument);
+/**
+ * Based on the current parsed AsyncAPI document, convert it to expected API version from the template.
+ */
+parser.getProperApiDocument = (asyncapiDocument, templateConfig = {}) => {
+  const apiVersion = this.sanitizeTemplateApiVersion(templateConfig.apiVersion);
+  if (apiVersion === undefined) {
+    // Convert to old API from JS Parser v1
+    return convertToOldAPI(asyncapiDocument);
+  }
+  return ConvertDocumentParserAPIVersion(asyncapiDocument, apiVersion);
 };
 
 // The new options for the v2 Parser are different from those for the v1 version, but in order not to release Generator v2, we are converting the old options of Parser to the new ones.

package/lib/templateConfigValidator.js

@@ -2,22 +2,26 @@ const semver = require('semver');
 const Ajv = require('ajv');
 const { getGeneratorVersion } = require('./utils');
 const levenshtein = require('levenshtein-edit-distance');
+// eslint-disable-next-line no-unused-vars
+const {AsyncAPIDocumentInterface, AsyncAPIDocument} = require('@asyncapi/parser');
+const { usesNewAPI } = require('./parser');
 
 const ajv = new Ajv({ allErrors: true });
 
 // See https://github.com/asyncapi/parser-api
 const supportedParserAPIMajorVersions = [
   'v1',
+  'v2'
 ];
 
 /**
-   * Validates the template configuration.
-   *
-   * @param  {Object} templateConfig Template configuration.
-   * @param  {Object} templateParams Params specified when running generator.
-   * @param  {AsyncAPIDocument} asyncapiDocument AsyncAPIDocument object to use as source.
-   * @return {Boolean}
-   */
+ * Validates the template configuration.
+ *
+ * @param  {Object} templateConfig Template configuration.
+ * @param  {Object} templateParams Params specified when running generator.
+ * @param  {AsyncAPIDocumentInterface | AsyncAPIDocument} asyncapiDocument AsyncAPIDocument object to use as source.
+ * @return {Boolean}
+ */
 module.exports.validateTemplateConfig = (templateConfig, templateParams, asyncapiDocument) => {
   const { parameters, supportedProtocols, conditionalFiles, generator, apiVersion } = templateConfig;
 
@@ -25,10 +29,15 @@ module.exports.validateTemplateConfig = (templateConfig, templateParams, asyncap
   isTemplateCompatible(generator, apiVersion);
   isRequiredParamProvided(parameters, templateParams);
   isProvidedTemplateRendererSupported(templateConfig);
-  if (asyncapiDocument) {
-    const server = asyncapiDocument.servers().get(templateParams.server);
-    isServerProvidedInDocument(server, templateParams.server);
+  if (asyncapiDocument && templateParams.server) {
+    let server;
+    if (usesNewAPI(templateConfig)) {
+      server = asyncapiDocument.servers().get(templateParams.server);
+    } else {
+      server = asyncapiDocument.servers()[templateParams.server];
+    }
     isServerProtocolSupported(server, supportedProtocols, templateParams.server);
+    isServerProvidedInDocument(server, templateParams.server);
   }
 
   isProvidedParameterSupported(parameters, templateParams);
@@ -48,7 +57,7 @@ function isTemplateCompatible(generator, apiVersion) {
   }
 
   if (typeof apiVersion === 'string' && !supportedParserAPIMajorVersions.includes(apiVersion)) {
-    throw new Error(`The version specified in apiVersion is not supported by this Generator version. Supported versions are: ${supportedParserAPIMajorVersions.toString()}`);
+    throw new Error(`The version specified in apiVersion is not supported by this Generator version. Supported versions are: ${supportedParserAPIMajorVersions.join(', ')}`);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asyncapi/generator",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "The AsyncAPI generator. It can generate documentation, code, anything!",
   "main": "./lib/generator.js",
   "bin": {
@@ -48,13 +48,10 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/asyncapi/generator",
   "dependencies": {
-    "@asyncapi/avro-schema-parser": "^3.0.3",
-    "@asyncapi/generator-react-sdk": "^1.0.0",
-    "@asyncapi/openapi-schema-parser": "^3.0.4",
-    "@asyncapi/parser": "^2.1.0",
-    "@asyncapi/protobuf-schema-parser": "3.0.0",
-    "@asyncapi/raml-dt-schema-parser": "^4.0.4",
+    "@asyncapi/generator-react-sdk": "^0.2.23",
+    "@asyncapi/parser": "2.1.0",
     "@npmcli/arborist": "^2.2.4",
+    "@smoya/multi-parser": "3.0.0",
     "ajv": "^8.12.0",
     "chokidar": "^3.4.0",
     "commander": "^6.1.0",