@asyncapi/generator 1.9.18 → 1.10.0

package/.releaserc

@@ -0,0 +1,22 @@
+---
+branches:
+- master
+# by default release workflow reacts on push not only to master. 
+#This is why out of the box sematic release is configured for all these branches
+- name: next-spec
+  prerelease: true
+- name: next-major
+  prerelease: true
+- name: next-major-spec
+  prerelease: true
+- name: beta
+  prerelease: true
+- name: alpha
+  prerelease: true
+plugins:
+- - "@semantic-release/commit-analyzer"
+  - preset: conventionalcommits
+- - "@semantic-release/release-notes-generator"
+  - preset: conventionalcommits
+- "@semantic-release/npm"
+- "@semantic-release/github"

package/CODEOWNERS

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

package/README.md

@@ -10,12 +10,6 @@
 
 - [Overview](#overview)
 - [List of official generator templates](#list-of-official-generator-templates)
-- [Requirements](#requirements)
-- [Using from the command-line interface (CLI)](#using-from-the-command-line-interface-cli)
-  * [CLI installation](#cli-installation)
-  * [CLI usage](#cli-usage)
-- [Generator version vs Template version](#generator-version-vs-template-version)
-- [How to create a template](#how-to-create-a-template)
 - [Contributing](#contributing)
 - [Contributors ✨](#contributors-%E2%9C%A8)
 
@@ -23,9 +17,7 @@
 
 ## Overview
 
-Generator is a tool that you can use to generate whatever you want basing on the AsyncAPI specification file as an input.
-
-To specify what exactly must be generated you create so called **template**. To create your own template, go to section that explains [How to create a template](#how-to-create-a-template).
+Generator is a tool that you can use to generate whatever you want basing on the AsyncAPI specification file as an input. For more information [read the docs](https://www.asyncapi.com/docs/tools/generator).
 
 There is a large number of templates that are ready to use and are officially supported by the AsyncAPI Initiative.
 
@@ -47,39 +39,13 @@ Template Name | Description | Source code
 `@asyncapi/ts-nats-template` | Generates TypeScript NATS client | [click here](https://github.com/asyncapi/ts-nats-template/)
 `@asyncapi/go-watermill-template` | Generates Go client using Watermill | [click here](https://github.com/asyncapi/go-watermill-template)
 `@asyncapi/dotnet-nats-template` | Generates .NET C# client using NATS | [click here](https://github.com/asyncapi/dotnet-nats-template)
+`@asyncapi/php-template` | Generates PHP client using RabbitMQ | [click here](https://github.com/asyncapi/php-template)
+`@asyncapi/dotnet-rabbitmq-template` | Generates .NET C# client using RabbitMQ | [click here](https://github.com/asyncapi/dotnet-rabbitmq-template)
 
 <!-- TEMPLATES-LIST:END -->
 
 You can find above templates and the ones provided by the community in **[this list](https://github.com/search?q=topic%3Aasyncapi+topic%3Agenerator+topic%3Atemplate)**
 
-## Requirements
-
-* Node.js v12.16 and higher
-* npm v6.13.7 and higher
-
-Install both packages using [official installer](https://nodejs.org/en/download/). After installation make sure both packages have proper version by running `node -v` and `npm -v`. To upgrade invalid npm version run `npm install npm@latest -g`
-
-> The generator is tested at the moment against Node 14 and NPM 6. Using newer versions is enabled but we don't guarantee they work well. Please provide feedback via issues.
-
-## Using from the command-line interface (CLI)
-
-### CLI installation
-Learn to install the AsyncAPI CLI from the [installation guide](docs/installation-guide.md).
-
-### CLI usage 
-
-Learn more about different ways of using the CLI from the [usage document](docs/usage.md).
-
-## Generator version vs Template version
-
-Learn more about versioning from the [versioning document](docs/versioning.md).
-
-## How to create a template
-
-To create your own template, for example code generator for some specific language and technology, learn from the following resources:
-- Read the [documentation](docs/README.md)
-- Use [Template for Generator Templates](https://github.com/asyncapi/template-for-generator-templates) that showcases Generator features
-
 ## Contributing
 
 Read [CONTRIBUTING](CONTRIBUTING.md) guide.

package/cli.js

@@ -4,6 +4,7 @@ const path = require('path');
 const os = require('os');
 const program = require('commander');
 const xfs = require('fs.extra');
+const { DiagnosticSeverity } = require('@asyncapi/parser/cjs');
 const packageInfo = require('./package.json');
 const Generator = require('./lib/generator');
 const Watcher = require('./lib/watcher');
@@ -64,8 +65,10 @@ const mapBaseUrlParser = v => {
 const showError = err => {
   console.error(red('Something went wrong:'));
   console.error(red(err.stack || err.message));
-  if (err.errors) console.error(red(JSON.stringify(err.errors)));
-  if (err.validationErrors) console.error(red(JSON.stringify(err.validationErrors, null, 4)));
+  if (err.diagnostics) {
+    const errorDiagnostics = err.diagnostics.filter(diagnostic => diagnostic.severity === DiagnosticSeverity.Error);
+    console.error(red(`Errors:\n${JSON.stringify(errorDiagnostics, undefined, 2)}`));
+  }
 };
 const showErrorAndExit = err => {
   showError(err);
@@ -127,7 +130,7 @@ xfs.mkdirp(program.output, async err => {
       console.warn(`WARNING: ${template} is a remote template. Changes may be lost on subsequent installations.`);
     }
 
-    watcher.watch(watcherHandler, (paths) => {
+    await watcher.watch(watcherHandler, (paths) => {
       showErrorAndExit({ message: `[WATCHER] Could not find the file path ${paths}, are you sure it still exists? If it has been deleted or moved please rerun the generator.` });
     });
   }

package/docs/README.md

@@ -1,18 +1,3 @@
-Table of Contents
+## Documentation
 
-- [Introduction](index.md)
-- [Installation Guide](installation-guide.md)
-- [Usage](usage.md)
-- [AsyncAPI document](asyncapi-document.md)
-- [Template](template.md)
-- [Parser](parser.md)
-- [Generator version vs template version](versioning.md)
-- [Template Development](template-development.md)
-- [Configuration File](configuration-file.md)
-- [Template context](template-context.md)
-- [React render engine](react-render-engine.md)
-- [Nunjucks render engine](nunjucks-render-engine.md)
-- [Hooks](hooks.md)
-- [File templates](file-templates.md)
-- [TypeScript support](typescript-support.md)
-- [Special file names](special-file-names.md)
+Read the docs on https://www.asyncapi.com/docs/tools/generator. You can still read the docs from here, but some of the links may be broken.

package/docs/configuration-file.md

@@ -8,6 +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.
 |`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.
@@ -27,6 +28,7 @@ The `generator` property from `package.json` file must contain a JSON object tha
 "generator":
 {
   "renderer": "react",
+  "apiVersion": "v1",
   "supportedProtocols": ["amqp", "mqtt"],
   "parameters": {
     "server": {

package/docs/hooks.md

@@ -14,11 +14,11 @@ The following types of hooks are currently supported:
 
 The generator parses:
 - All the files in the `.hooks` directory inside the template.
-- All modules listed in the template configuration and triggers only hooks that names were added to the config. You can use the official AsyncAPI [hooks library](https://github.com/asyncapi/generator-hooks). To learn how to add hooks to configuration [read more about the configuration file](#configuration-file).
+- All modules listed in the template configuration and triggers only hooks that names were added to the config. You can use the official AsyncAPI [hooks library](https://github.com/asyncapi/generator-hooks). To learn how to add hooks to configuration [read more about the configuration file](https://www.asyncapi.com/docs/tools/generator/configuration-file).
 
 ### Examples
 
-> Some of the examples have names of hook functions provided and some not. Keep in mind that hook functions kept in template in default location do not require a name. Name is required only if you keep hooks in non default location or in a separate library, because such hooks need to be explicitly configured in the configuration file. For more details on hooks configuration [read more about the configuration file](#configuration-file).
+> Some of the examples have names of hook functions provided and some not. Keep in mind that hook functions kept in template in default location do not require a name. Name is required only if you keep hooks in non default location or in a separate library, because such hooks need to be explicitly configured in the configuration file. For more details on hooks configuration [read more about the configuration file](https://www.asyncapi.com/docs/tools/generator/configuration-file).
 
 Most basic modules with hooks look like this:
 ```js
@@ -78,4 +78,4 @@ module.exports = {
 		return currentFilename.replace('-', '_')
 	};
 };
-```
+```

package/lib/generator.js

@@ -2,18 +2,15 @@ const path = require('path');
 const fs = require('fs');
 const xfs = require('fs.extra');
 const minimatch = require('minimatch');
-const parser = require('@asyncapi/parser');
-const { configureReact, renderReact, saveRenderedReactContent } = require('./renderer/react');
-const { configureNunjucks, renderNunjucks } = require('./renderer/nunjucks');
-const { parse, AsyncAPIDocument } = parser;
-const ramlDtParser = require('@asyncapi/raml-dt-schema-parser');
-const openapiSchemaParser = require('@asyncapi/openapi-schema-parser');
-const avroSchemaParser = require('@asyncapi/avro-schema-parser');
 const jmespath = require('jmespath');
 const filenamify = require('filenamify');
 const git = require('simple-git');
 const log = require('loglevel');
 const Arborist = require('@npmcli/arborist');
+const { isAsyncAPIDocument } = require('@asyncapi/parser/cjs/document');
+
+const { configureReact, renderReact, saveRenderedReactContent } = require('./renderer/react');
+const { configureNunjucks, renderNunjucks } = require('./renderer/nunjucks');
 const { validateTemplateConfig } = require('./templateConfigValidator');
 const {
   convertMapToObject,
@@ -30,8 +27,9 @@ const {
   registerSourceMap,
   registerTypeScript,
   getTemplateDetails,
-  getMapBaseUrlToFolderResolver
+  convertCollectionToObject,
 } = require('./utils');
+const { parse, usesNewAPI, getProperApiDocument } = require('./parser');
 const { registerFilters } = require('./filtersRegistry');
 const { registerHooks } = require('./hooksRegistry');
 
@@ -57,9 +55,6 @@ const shouldIgnoreDir = dirPath =>
   dirPath === '.git'
   || dirPath.startsWith(`.git${path.sep}`);
 
-parser.registerSchemaParser(openapiSchemaParser);
-parser.registerSchemaParser(ramlDtParser);
-parser.registerSchemaParser(avroSchemaParser);
 registerSourceMap();
 registerTypeScript();
 
@@ -164,10 +159,9 @@ class Generator {
    * @return {Promise}
    */
   async generate(asyncapiDocument) {
-    if (!(asyncapiDocument instanceof AsyncAPIDocument)) throw new Error('Parameter "asyncapiDocument" must be an AsyncAPIDocument object.');
+    if (!isAsyncAPIDocument(asyncapiDocument)) throw new Error('Parameter "asyncapiDocument" must be an AsyncAPIDocument object.');
 
     this.asyncapi = asyncapiDocument;
-
     if (this.output === 'fs') {
       xfs.mkdirpSync(this.targetDir);
       if (!this.forceWrite) await this.verifyTargetDir(this.targetDir);
@@ -185,6 +179,9 @@ class Generator {
     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);
+
     if (!isReactTemplate(this.templateConfig)) {
       await registerFilters(this.nunjucks, this.templateConfig, this.templateDir, FILTERS_DIRNAME);
     }
@@ -252,18 +249,23 @@ class Generator {
    * }
    *
    * @param  {String} asyncapiString AsyncAPI string to use as source.
-   * @param  {Object} [parserOptions={}] AsyncAPI parser options. Check out {@link https://www.github.com/asyncapi/parser-js|@asyncapi/parser} for more information.
+   * @param  {Object} [parseOptions={}] AsyncAPI Parser parse options. Check out {@link https://www.github.com/asyncapi/parser-js|@asyncapi/parser} for more information.
    * @return {Promise}
    */
-  async generateFromString(asyncapiString, parserOptions = {}) {
+  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 asyncapi = await parse(asyncapiString, parserOptions);
-    return this.generate(asyncapi);
+    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;
+    }
+    return this.generate(document);
   }
 
   /**
@@ -290,12 +292,7 @@ class Generator {
    */
   async generateFromURL(asyncapiURL) {
     const doc = await fetchSpec(asyncapiURL);
-    const parserOptions = {};
-    if (this.mapBaseUrlToFolder.url) {
-      parserOptions.resolve = {resolver: getMapBaseUrlToFolderResolver(this.mapBaseUrlToFolder)};
-    }
-
-    return this.generateFromString(doc, parserOptions);
+    return this.generateFromString(doc, { path: asyncapiURL });
   }
 
   /**
@@ -322,12 +319,7 @@ class Generator {
    */
   async generateFromFile(asyncapiFile) {
     const doc = await readFile(asyncapiFile, { encoding: 'utf8' });
-    const parserOptions = { path: asyncapiFile };
-    if (this.mapBaseUrlToFolder.url) {
-      parserOptions.resolve = {resolver: getMapBaseUrlToFolderResolver(this.mapBaseUrlToFolder)};
-    }
-
-    return this.generateFromString(doc, parserOptions);
+    return this.generateFromString(doc, { path: asyncapiFile });
   }
 
   /**
@@ -425,18 +417,30 @@ class Generator {
   getAllParameters(asyncapiDocument) {
     const parameters = new Map();
 
-    if (asyncapiDocument.hasChannels()) {
-      asyncapiDocument.channelNames().forEach(channelName => {
-        const channel = asyncapiDocument.channel(channelName);
-        for (const [key, value] of Object.entries(channel.parameters())) {
-          parameters.set(key, value);
-        }
+    if (usesNewAPI(this.templateConfig)) {
+      asyncapiDocument.channels().all().forEach(channel => {
+        channel.parameters().all().forEach(parameter => {
+          parameters.set(parameter.id(), parameter);
+        });
       });
-    }
 
-    if (asyncapiDocument.hasComponents()) {
-      for (const [key, value] of Object.entries(asyncapiDocument.components().parameters())) {
-        parameters.set(key, value);
+      asyncapiDocument.components().channelParameters().all().forEach(parameter => {
+        parameters.set(parameter.id(), parameter);
+      });
+    } else {
+      if (asyncapiDocument.hasChannels()) {
+        asyncapiDocument.channelNames().forEach(channelName => {
+          const channel = asyncapiDocument.channel(channelName);
+          for (const [key, value] of Object.entries(channel.parameters())) {
+            parameters.set(key, value);
+          }
+        });
+      }
+  
+      if (asyncapiDocument.hasComponents()) {
+        for (const [key, value] of Object.entries(asyncapiDocument.components().parameters())) {
+          parameters.set(key, value);
+        }
       }
     }
 
@@ -451,9 +455,6 @@ class Generator {
    * @return {Promise}
    */
   generateDirectoryStructure(asyncapiDocument) {
-    const objectMap = {};
-    asyncapiDocument.allSchemas().forEach((schema, schemaId) => { if (schema.type() === 'object') objectMap[schemaId] = schema; });
-
     return new Promise((resolve, reject) => {
       xfs.mkdirpSync(this.targetDir);
 
@@ -463,7 +464,7 @@ class Generator {
 
       walker.on('file', async (root, stats, next) => {
         try {
-          await this.filesGenerationHandler(asyncapiDocument, objectMap, root, stats, next);
+          await this.filesGenerationHandler(asyncapiDocument, root, stats, next);
         } catch (e) {
           reject(e);
         }
@@ -514,16 +515,31 @@ class Generator {
    * @param  {String} stats Information about the file.
    * @param  {Function} next Callback function
    */
-  async filesGenerationHandler(asyncapiDocument, objectMap, root, stats, next) {
-    const fileNamesForSeparation = {
-      channel: asyncapiDocument.channels(),
-      message: convertMapToObject(asyncapiDocument.allMessages()),
-      securityScheme: asyncapiDocument.components() ? asyncapiDocument.components().securitySchemes() : {},
-      schema: asyncapiDocument.components() ? asyncapiDocument.components().schemas() : {},
-      objectSchema: objectMap,
-      parameter: convertMapToObject(this.getAllParameters(asyncapiDocument)),
-      everySchema: convertMapToObject(asyncapiDocument.allSchemas()),
-    };
+  async filesGenerationHandler(asyncapiDocument, root, stats, next) {
+    let fileNamesForSeparation = {};
+    if (usesNewAPI(this.templateConfig)) {
+      fileNamesForSeparation = {
+        channel: convertCollectionToObject(asyncapiDocument.channels().all(), 'address'),
+        message: convertCollectionToObject(asyncapiDocument.messages().all(), 'id'),
+        securityScheme: convertCollectionToObject(asyncapiDocument.components().securitySchemes().all(), 'id'),
+        schema: convertCollectionToObject(asyncapiDocument.components().schemas().all(), 'id'),
+        objectSchema: convertCollectionToObject(asyncapiDocument.schemas().all().filter(schema => schema.type() === 'object'), 'id'),
+        parameter: convertMapToObject(this.getAllParameters(asyncapiDocument)),
+        everySchema: convertCollectionToObject(asyncapiDocument.schemas().all(), 'id'),
+      };
+    } else {
+      const objectSchema = {};
+      asyncapiDocument.allSchemas().forEach((schema, schemaId) => { if (schema.type() === 'object') objectSchema[schemaId] = schema; });
+      fileNamesForSeparation = {
+        channel: asyncapiDocument.channels(),
+        message: convertMapToObject(asyncapiDocument.allMessages()),
+        securityScheme: asyncapiDocument.components() ? asyncapiDocument.components().securitySchemes() : {},
+        schema: asyncapiDocument.components() ? asyncapiDocument.components().schemas() : {},
+        objectSchema,
+        parameter: convertMapToObject(this.getAllParameters(asyncapiDocument)),
+        everySchema: convertMapToObject(asyncapiDocument.allSchemas()),
+      };
+    }
 
     // Check if the filename dictates it should be separated
     let wasSeparated = false;
@@ -663,7 +679,6 @@ class Generator {
     }
 
     if (this.isNonRenderableFile(relativeSourceFile)) return await copyFile(sourceFile, targetFile);
-
     await this.renderAndWriteToFile(asyncapiDocument, sourceFile, targetFile);
   }
 

package/lib/parser.js

@@ -0,0 +1,123 @@
+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 parser = module.exports;
+
+const defaultParser = new Parser({
+  schemaParsers: [
+    OpenAPISchemaParser(),
+    AvroSchemaParser(),
+    RamlDTSchemaParser(),
+  ],
+});
+
+parser.parse = (asyncapi, oldOptions, generator) => {
+  const options = convertOldOptionsToNew(oldOptions, generator);
+  return defaultParser.parse(asyncapi, options);
+};
+
+parser.usesNewAPI = (templateConfig = {}) => {
+  return templateConfig.apiVersion === 'v1';
+};
+
+parser.getProperApiDocument = (asyncapiDocument, templateConfig) => {
+  return parser.usesNewAPI(templateConfig) ? asyncapiDocument : convertToOldAPI(asyncapiDocument);
+};
+
+// 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.
+function convertOldOptionsToNew(oldOptions, generator) {
+  if (!oldOptions) return;
+  const newOptions = {};
+
+  if (typeof oldOptions.path === 'string') {
+    newOptions.source = oldOptions.path;
+  }
+  if (typeof oldOptions.applyTraits === 'boolean') {
+    newOptions.applyTraits = oldOptions.applyTraits;
+  }
+
+  const resolvers = [];
+  if (generator && generator.mapBaseUrlToFolder && generator.mapBaseUrlToFolder.url) {
+    resolvers.push(...getMapBaseUrlToFolderResolvers(generator.mapBaseUrlToFolder));
+  }
+  if (oldOptions.resolve) {
+    resolvers.push(...convertOldResolvers(oldOptions.resolve));
+  }
+
+  if (resolvers.length) {
+    newOptions.__unstable = {};
+    newOptions.__unstable.resolver = {
+      resolvers,
+    };
+  }
+
+  return newOptions;
+}
+
+/**
+ * Creates a custom resolver that maps urlToFolder.url to urlToFolder.folder
+ * Building your custom resolver is explained here: https://apitools.dev/json-schema-ref-parser/docs/plugins/resolvers.html
+ *
+ * @private
+ * @param  {object} urlToFolder to resolve url e.g. https://schema.example.com/crm/ to a folder e.g. ./test/docs/.
+ * @return {{read(*, *, *): Promise<unknown>, canRead(*): boolean, order: number}}
+ */
+function getMapBaseUrlToFolderResolvers({ url: baseUrl, folder: baseDir }) {
+  const resolver = {
+    order: 1,
+    canRead: true,
+    read(uri) {
+      return new Promise(((resolve, reject) => {
+        const path = uri.toString();
+        const localpath = path.replace(baseUrl, baseDir);
+        try {
+          fs.readFile(localpath, (err, data) => {
+            if (err) {
+              reject(`Error opening file "${localpath}"`);
+            } else {
+              resolve(data.toString());
+            }
+          });
+        } catch (err) {
+          reject(`Error opening file "${localpath}"`);
+        }
+      }));
+    }
+  };
+
+  return [
+    { schema: 'http', ...resolver, },
+    { schema: 'https', ...resolver, },
+  ];
+};
+
+function convertOldResolvers(resolvers = {}) { // NOSONAR
+  if (Object.keys(resolvers).length === 0) return [];
+
+  return Object.entries(resolvers).map(([protocol, resolver]) => {
+    return {
+      schema: protocol,
+      order: resolver.order || 1,
+      canRead: (uri) => canReadFn(uri, resolver.canRead),
+      read: (uri) => {
+        return resolver.read({ url: uri.valueOf(), extension: uri.suffix() });
+      }
+    };
+  });
+}
+
+function canReadFn(uri, canRead) {
+  const value = uri.valueOf();
+  if (typeof canRead === 'boolean') return canRead;
+  if (typeof canRead === 'string') return canRead === value;
+  if (Array.isArray(canRead)) return canRead.includes(value);
+  if (canRead instanceof RegExp) return canRead.test(value);
+  if (typeof canRead === 'function') {
+    return canRead({ url: value, extension: uri.suffix() });
+  }
+  return false;
+}

package/lib/templateConfigValidator.js

@@ -5,6 +5,11 @@ const levenshtein = require('levenshtein-edit-distance');
 
 const ajv = new Ajv({ allErrors: true });
 
+// See https://github.com/asyncapi/parser-api
+const supportedParserAPIMajorVersions = [
+  'v1',
+];
+
 /**
    * Validates the template configuration.
    *
@@ -14,20 +19,19 @@ const ajv = new Ajv({ allErrors: true });
    * @return {Boolean}
    */
 module.exports.validateTemplateConfig = (templateConfig, templateParams, asyncapiDocument) => {
-  const { parameters, supportedProtocols, conditionalFiles, generator } = templateConfig;
-  
+  const { parameters, supportedProtocols, conditionalFiles, generator, apiVersion } = templateConfig;
+
   validateConditionalFiles(conditionalFiles);
-  isTemplateCompatible(generator);
+  isTemplateCompatible(generator, apiVersion);
   isRequiredParamProvided(parameters, templateParams);
   isProvidedTemplateRendererSupported(templateConfig);
   if (asyncapiDocument) {
-    const server = asyncapiDocument.server(templateParams.server);
+    const server = asyncapiDocument.servers().get(templateParams.server);
     isServerProvidedInDocument(server, templateParams.server);
     isServerProtocolSupported(server, supportedProtocols, templateParams.server);
   }
 
   isProvidedParameterSupported(parameters, templateParams);
-
   return true;
 };
 
@@ -35,24 +39,29 @@ module.exports.validateTemplateConfig = (templateConfig, templateParams, asyncap
  * Checks if template is compatible with the version of the generator that is used
  * @private
  * @param {String} generator Information about supported generator version that is part of the template configuration
+ * @param {String} generator Information about supported Parser-API version that is part of the template configuration
  */
-function isTemplateCompatible(generator) {
+function isTemplateCompatible(generator, apiVersion) {
   const generatorVersion = getGeneratorVersion();
   if (typeof generator === 'string' && !semver.satisfies(generatorVersion, generator, {includePrerelease: true})) {
     throw new Error(`This template is not compatible with the current version of the generator (${generatorVersion}). This template is compatible with the following version range: ${generator}.`);
-  }  
+  }
+
+  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()}`);
+  }
 }
 
 /**
  * Checks if parameters described in template configuration as required are passed to the generator
  * @private
  * @param {Object} configParams Parameters specified in template configuration
- * @param {Object} templateParams All parameters provided to generator 
+ * @param {Object} templateParams All parameters provided to generator
  */
 function isRequiredParamProvided(configParams, templateParams) {
   const missingParams = Object.keys(configParams || {})
     .filter(key => configParams[key].required && !templateParams[key]);
-    
+
   if (missingParams.length) {
     throw new Error(`This template requires the following missing params: ${missingParams}.`);
   }
@@ -75,29 +84,29 @@ function getParamSuggestion(wrongParam, configParams) {
  * Checks if parameters provided to generator is supported by the template
  * @private
  * @param {Object} configParams Parameters specified in template configuration
- * @param {Object} templateParams All parameters provided to generator 
+ * @param {Object} templateParams All parameters provided to generator
  */
 function isProvidedParameterSupported(configParams, templateParams) {
   const wrongParams = Object.keys(templateParams || {}).filter(key => !configParams || !configParams[key]);
-  
+
   if (!wrongParams.length) return;
   if (!configParams) throw new Error('This template doesn\'t have any params.');
 
   let suggestionsString = '';
-  
-  wrongParams.forEach(wp => { 
+
+  wrongParams.forEach(wp => {
     suggestionsString += `\nDid you mean "${getParamSuggestion(wp,configParams)}" instead of "${wp}"?`;
   });
 
   throw new Error(`This template doesn't have the following params: ${wrongParams}.${suggestionsString}`);
 }
-  
+
 /**
  * Checks if given AsyncAPI document has servers with protocol that is supported by the template
  * @private
  * @param {Object} server Server object from AsyncAPI file
  * @param {String[]} supportedProtocols Supported protocols specified in template configuration
- * @param {String} paramsServerName Name of the server specified as a param for the generator 
+ * @param {String} paramsServerName Name of the server specified as a param for the generator
  */
 function isServerProtocolSupported(server, supportedProtocols, paramsServerName) {
   if (server && Array.isArray(supportedProtocols) && !supportedProtocols.includes(server.protocol())) {
@@ -107,7 +116,7 @@ function isServerProtocolSupported(server, supportedProtocols, paramsServerName)
 
 /**
  * Checks if the the provided renderer are supported (no renderer are also supported, defaults to nunjucks)
- * 
+ *
  * @param  {Object} templateConfig Template configuration.
  */
 function isProvidedTemplateRendererSupported(templateConfig) {
@@ -115,7 +124,7 @@ function isProvidedTemplateRendererSupported(templateConfig) {
   if (supportedRenderers.includes(templateConfig.renderer)) {
     return;
   }
-  
+
   throw new Error(`We do not support '${templateConfig.renderer}' as a renderer for a template. Only 'react' or 'nunjucks' are supported.`);
 }
 
@@ -137,7 +146,7 @@ function isServerProvidedInDocument(server, paramsServerName) {
 function validateConditionalFiles(conditionalFiles) {
   if (typeof conditionalFiles === 'object') {
     const fileNames = Object.keys(conditionalFiles);
-    
+
     fileNames.forEach(fileName => {
       const def = conditionalFiles[fileName];
       if (typeof def.subject !== 'string') throw new Error(`Invalid conditional file subject for ${fileName}: ${def.subject}.`);
@@ -145,4 +154,4 @@ function validateConditionalFiles(conditionalFiles) {
       conditionalFiles[fileName].validate = ajv.compile(conditionalFiles[fileName].validation);
     });
   }
-}
+}

package/lib/utils.js

@@ -7,6 +7,7 @@ const resolvePkg = require('resolve-pkg');
 const resolveFrom = require('resolve-from');
 const globalDirs = require('global-dirs');
 const log = require('loglevel');
+
 const packageJson = require('../package.json');
 
 const logMessage = require('./logMessages.js');
@@ -223,39 +224,11 @@ utils.getTemplateDetails = (name, PACKAGE_JSON_FILENAME) => {
   return installedPkg;
 };
 
-/**
- * Creates a custom resolver that maps urlToFolder.url to urlToFolder.folder
- * Building your custom resolver is explained here: https://apitools.dev/json-schema-ref-parser/docs/plugins/resolvers.html
- *
- * @private
- * @param  {object} urlToFolder to resolve url e.g. https://schema.example.com/crm/ to a folder e.g. ./test/docs/.
- * @return {{read(*, *, *): Promise<unknown>, canRead(*): boolean, order: number}}
- */
-utils.getMapBaseUrlToFolderResolver = (urlToFolder) => {
-  return {
-    order: 1,
-    canRead (file) {
-      return true;
-    },
-    read(file, callback, $refs) {
-      const baseUrl = urlToFolder.url;
-      const baseDir = urlToFolder.folder;
-
-      return new Promise(((resolve, reject) => {
-        let localpath = file.url;
-        localpath = localpath.replace(baseUrl,baseDir);
-        try {
-          fs.readFile(localpath, (err, data) => {
-            if (err) {
-              reject(`Error opening file "${localpath}"`);
-            } else {
-              resolve(data);
-            }
-          });
-        } catch (err) {
-          reject(`Error opening file "${localpath}"`);
-        }
-      }));
-    }
-  };
+utils.convertCollectionToObject = (array, idFunction) => {
+  const tempObject = {};
+  for (const value of array) {
+    const id = value[idFunction]();
+    tempObject[id] = value;
+  }
+  return tempObject;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asyncapi/generator",
-  "version": "1.9.18",
+  "version": "1.10.0",
   "description": "The AsyncAPI generator. It can generate documentation, code, anything!",
   "main": "./lib/generator.js",
   "bin": {
@@ -47,11 +47,11 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/asyncapi/generator",
   "dependencies": {
-    "@asyncapi/avro-schema-parser": "^1.1.0",
+    "@asyncapi/avro-schema-parser": "^3.0.0",
     "@asyncapi/generator-react-sdk": "^0.2.23",
-    "@asyncapi/openapi-schema-parser": "^2.0.3",
-    "@asyncapi/parser": "^1.18.0",
-    "@asyncapi/raml-dt-schema-parser": "^2.0.1",
+    "@asyncapi/openapi-schema-parser": "^3.0.0",
+    "@asyncapi/parser": "^2.0.0",
+    "@asyncapi/raml-dt-schema-parser": "^4.0.0",
     "@npmcli/arborist": "^2.2.4",
     "ajv": "^6.10.2",
     "chokidar": "^3.4.0",