@asyncapi/generator 1.9.4 → 1.9.7

package/.releaserc

@@ -0,0 +1,10 @@
+---
+branches:
+- master
+plugins:
+- - "@semantic-release/commit-analyzer"
+  - preset: conventionalcommits
+- - "@semantic-release/release-notes-generator"
+  - preset: conventionalcommits
+- "@semantic-release/npm"
+- "@semantic-release/github"

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to make participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at fmvilas@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

package/CONTRIBUTING.md

@@ -1,38 +1,61 @@
-## Overview
+# Contributing to AsyncAPI
+We love your input! We want to make contributing to this project as easy and transparent as possible.
 
-Contributions are more than welcome. If you want to contribute, please make sure you go through the following steps:
+## Contribution recogniton
 
-1. Pick or create an issue. 
-    - It's always a good idea to leave a message saying that you're going to work on it before you start any actual work.
-    - Consider contacting us on [slack](https://www.asyncapi.com/slack-invite/) to discuss the topic first
-2. Fork the repository and work there.
-3. Open a Pull Request pointing to the `master` branch.
-4. A maintainer will review and, eventually, merge your Pull Request. Please, be patient as most of us are doing this in our spare time.
+We use [All Contributors](https://allcontributors.org/docs/en/specification) specification to handle recognitions. For more details read [this](https://github.com/asyncapi/community/blob/master/recognize-contributors.md) document.
 
-## Code validation
+## Summary of the contribution flow
 
-Before creating a Pull Request you should validate your code with ESLint.
+The following is a summary of the ideal contribution flow. Please, note that Pull Requests can also be rejected by the maintainers when appropriate.
 
 ```
-npm run lint
+    ┌───────────────────────┐
+    │                       │
+    │    Open an issue      │
+    │  (a bug report or a   │
+    │   feature request)    │
+    │                       │
+    └───────────────────────┘
+               ⇩
+    ┌───────────────────────┐
+    │                       │
+    │  Open a Pull Request  │
+    │   (only after issue   │
+    │     is approved)      │
+    │                       │
+    └───────────────────────┘
+               ⇩
+    ┌───────────────────────┐
+    │                       │
+    │   Your changes will   │
+    │     be merged and     │
+    │ published on the next │
+    │        release        │
+    │                       │
+    └───────────────────────┘
 ```
 
-## Developing with Docker
+## Code of Conduct
+AsyncAPI has adopted a Code of Conduct that we expect project participants to adhere to. Please [read the full text](./CODE_OF_CONDUCT.md) so that you can understand what sort of behaviour is expected.
 
-In case you want to quickly build a docker image locally to check if it works then run `npm run docker-build`
+## Our Development Process
+We use Github to host code, to track issues and feature requests, as well as accept pull requests.
 
-In case you don't have a local node environment you can run 
+## Issues
+[Open an issue](https://github.com/asyncapi/asyncapi/issues/new) **only** if you want to report a bug or a feature. Don't open issues for questions or support, instead join our [Slack workspace](https://www.asyncapi.com/slack-invite) and ask there. Don't forget to follow our [Slack Etiquette](https://github.com/asyncapi/community/blob/master/slack-etiquette.md) while interacting with community members! It's more likely you'll get help, and much faster!
 
-```
-docker build -t asyncapi/generator:latest .
-docker run -v `pwd`:`pwd` -w `pwd` -it --rm --entrypoint /bin/sh  asyncapi/generator:latest
-npm install
-./cli.js --help
-```
+## Bug Reports and Feature Requests
+
+Please use our issues templates that provide you with hints on what information we need from you to help you out.
+
+## Pull Requests
+
+**Please, make sure you open an issue before starting with a Pull Request, unless it's a typo or a really obvious error.** Pull requests are the best way to propose changes to the specification. Get familiar with our document that explains [Git workflow](https://github.com/asyncapi/community/blob/master/git-workflow.md) used in our repositories.
 
 ## Conventional commits
 
-This project follows [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/#summary) specification. Releasing to GitHub and NPM is done with the support of [semantic-release](https://semantic-release.gitbook.io/semantic-release/).
+Our repositories follow [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/#summary) specification. Releasing to GitHub and NPM is done with the support of [semantic-release](https://semantic-release.gitbook.io/semantic-release/).
 
 Pull requests should have a title that follows the specification, otherwise, merging is blocked. If you are not familiar with the specification simply ask maintainers to modify. You can also use this cheatsheet if you want:
 
@@ -48,3 +71,9 @@ What about MAJOR release? just add `!` to the prefix, like `fix!: ` or `refactor
 Prefix that follows specification is not enough though. Remember that the title must be clear and descriptive with usage of [imperative mood](https://chris.beams.io/posts/git-commit/#imperative).
 
 Happy contributing :heart:
+
+## License
+When you submit changes, your submissions are understood to be under the same [Apache 2.0 License](https://github.com/asyncapi/asyncapi/blob/master/LICENSE) that covers the project. Feel free to [contact the maintainers](https://www.asyncapi.com/slack-invite) if that's a concern.
+
+## References
+This document was adapted from the open-source contribution guidelines for [Facebook's Draft](https://github.com/facebook/draft-js/blob/master/CONTRIBUTING.md).

package/README.md

@@ -286,9 +286,8 @@ Before using newer versions of the template, always look at the [changelog](http
 ## 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 about [authoring templates](docs/authoring.md)
+- Read the [documentation](docs/README.md)
 - Use [Template for Generator Templates](https://github.com/asyncapi/template-for-generator-templates) that showcases Generator features
-- Check the [list of templates recipes](docs/templates-recipes.md)
 
 ## Contributing
 
@@ -317,6 +316,9 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
     <td align="center"><a href="https://github.com/muenchhausen"><img src="https://avatars.githubusercontent.com/u/1210783?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Derk Muenchhausen</b></sub></a><br /><a href="https://github.com/asyncapi/generator/commits?author=muenchhausen" title="Code">💻</a></td>
     <td align="center"><a href="http://ben.timby.com/"><img src="https://avatars.githubusercontent.com/u/669270?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ben Timby</b></sub></a><br /><a href="https://github.com/asyncapi/generator/commits?author=btimby" title="Code">💻</a></td>
   </tr>
+  <tr>
+    <td align="center"><a href="https://github.com/lkmandy"><img src="https://avatars.githubusercontent.com/u/17765231?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Amanda  Shafack </b></sub></a><br /><a href="https://github.com/asyncapi/generator/commits?author=lkmandy" title="Documentation">📖</a></td>
+  </tr>
 </table>
 
 <!-- markdownlint-restore -->

package/docs/README.md

@@ -0,0 +1,15 @@
+Table of Contents
+
+- [Introduction](index.md)
+- [AsyncAPI Specification File](asyncapi-file.md)
+- [Configuration File](configuration-file.md)
+- [Templates](template.md)
+- [Authoring Templates](authoring-templates.md)
+- [React Render Engine](react-render-engine.md)
+- [Nunjucks Render Engine](nunjucks-render-engine.md)
+- [AsyncAPI Context](asyncapi-context.md)
+- [Parser](parser.md)
+- [Hooks](hooks.md)
+- [File Templates](file-templates.md)
+- [TypeScript Support](typescript-support.md)
+- [Special file names](special-file-names.md)

package/docs/asyncapi-context.md

@@ -0,0 +1,6 @@
+---
+title: "AsyncAPI Context"
+weight: 80
+---
+
+>This document is under construction.

package/docs/asyncapi-file.md

@@ -0,0 +1,6 @@
+---
+title: "AsyncAPI Specification File"
+weight: 20
+---
+
+>This document is under construction.

package/docs/authoring-templates.md

@@ -0,0 +1,17 @@
+---
+title: "Authoring Templates"
+weight: 50
+---
+
+The AsyncAPI generator has been built with extensibility in mind. The package uses a set of default templates to let you generate documentation and code. However, you can create and use your own templates. In this section, you learn how to create your own one.
+
+To work on a template, you need an AsyncAPI specification file that you can use for testing. For this purpose, you can use [this](../test/docs/dummy.yml) dummy file as it's purpose is to cover as many features of AsyncAPI as possible. Do not copy this file to your template but use it directly from this repo like this: `ag https://raw.githubusercontent.com/asyncapi/generator/master/test/docs/dummy.yml ./your-template`
+
+> In case you find some features missing or other possible improvements in the dummy file, suggest changes. The goal is to build a file that all templates can use and check their specification features coverage.
+
+1. A template is a directory in your file system.
+1. The template can have own dependencies. Just create `package.json` for the template. The generator makes sure to trigger the installation of dependencies.
+1. Templates can be configured. Configuration must be stored in the `package.json` file under custom `generator` property. [Read more about the configuration file](#configuration-file).
+1. The template engine can be either [React](#react) (recommended) or [Nunjucks](#nunjucks) (default). This can be controlled with the `renderer` property in the [template configuration](#template-configuration).
+1. Templates may contain `hooks` that are functions invoked during specific moment of the generation. In the template, they must be stored in the `hooks` directory under the template directory. They can also be stored in other modules and external libraries and configured inside the template [Read more about hooks](#hooks).
+1. There are parameters with special meaning. [Read more about special parameters](#special-parameters).

package/docs/configuration-file.md

@@ -0,0 +1,78 @@
+---
+title: "Configuration File"
+weight: 30
+---
+
+The `generator` property from `package.json` file must contain a JSON object that may have the following information:
+
+|Name|Type|Description|
+|---|---|---|
+|`renderer`| String | Its value can be either `react` or `nunjucks` (default).
+|`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.
+|`parameters[param].default`| Any | Default value of the parameter if not specified. Shouldn't be used for mandatory `required=true` parameters.
+|`parameters[param].required`| Boolean | Whether the parameter is required or not.
+|`conditionalFiles`| Object[String, Object] | An object containing all the file paths that should be conditionally rendered. Each key represents a file path and each value must be an object with the keys `subject` and `validation`. The file path should be relative to the `template` directory inside the template.
+|`conditionalFiles[filePath].subject`| String | The `subject` is a [JMESPath](http://jmespath.org/) query to grab the value you want to apply the condition to. It queries an object with the whole AsyncAPI document and, when specified, the given server. The object looks like this: `{ asyncapi: { ... }, server: { ... } }`. If the template supports `server` parameter, you can access server details like for example protocol this way: `server.protocol`. During validation with `conditionalFiles` only the server that template user selected is available in the specification file. For more information about `server` parameter [read about special parameters](#special-parameters).
+|`conditionalFiles[filePath].validation`| Object | The `validation` is a JSON Schema Draft 07 object. This JSON Schema definition will be applied to the JSON value resulting from the `subject` query. If validation doesn't have errors, the condition is met, and therefore the given file will be rendered. Otherwise, the file is ignored. Check [JSON Schema Validation](https://json-schema.org/draft-07/json-schema-validation.html#rfc.section.6) document for a list of all possible validation keywords.
+|`nonRenderableFiles`| [String] | A list of file paths or [globs](https://en.wikipedia.org/wiki/Glob_(programming)) that must be copied "as-is" to the target directory, i.e., without performing any rendering process. This is useful when you want to copy binary files.
+|`generator`| [String] | A string representing the Generator version-range the template is compatible with. This value must follow the [semver](https://nodejs.dev/learn/semantic-versioning-using-npm) syntax. E.g., `>=1.0.0`, `>=1.0.0 <=2.0.0`, `~1.0.0`, `^1.0.0`, `1.0.0`, etc. [Read more about semver](https://docs.npmjs.com/about-semantic-versioning).
+|`filters`| [String] | A list of modules containing functions that can be used as Nunjucks filters. In case of external modules, remember they need to be added as a dependency in `package.json` of your template.
+|`hooks`| Object[String, String] or Object[String, Array[String]] | A list of modules containing hooks, except for the ones you keep locally in your template in default location. For each module you must specify the exact name of the hook that should be used in the template. For a single hook you can specify it as a string, for more you must pass an array of strings. In case of external modules, remember they need to be added as a dependency in `package.json` of your template.
+
+### Example
+
+```json
+"generator":
+{
+  "renderer": "react",
+  "supportedProtocols": ["amqp", "mqtt"],
+  "parameters": {
+    "server": {
+      "description": "The server you want to use in the code.",
+      "required": true
+    },
+    "dummyParameter": {
+      "description": "Example of parameter with default value.",
+      "default": "just a string",
+      "required": false
+    }
+  },
+  "conditionalFiles": {
+    "path/to/file/that/is/relative/to/template/dir/test-amqp.js": {
+      "subject": "server.protocol",
+      "validation": {
+        "const": "amqp"
+      }
+    },
+    "path/to/file/that/is/relative/to/template/dir/support.html": {
+      "subject": "info.contact",
+        "validation": {
+          "required": ["url"]
+        }
+    }
+  },
+  "nonRenderableFiles": [
+    "src/api/middlewares/*.*",
+    "lib/lib/config.js"
+  ],
+  "generator": "<2.0.0",
+  "filters": [
+    "@asyncapi/generator-filters"
+  ],
+  "hooks": {
+    "@asyncapi/generator-hooks": "hookFunctionName"
+  }
+}
+```
+
+## Special parameters
+
+There are some template parameters that have a special meaning:
+
+|Name|Description|
+|---|---|
+|`server`| It is used to let the template know which server from the AsyncAPI specification file you want to use. In some cases, this may be required. For instance, when generating code that connects to a specific server. Use this parameter in case your template relies on users' information about what server from the specification file they want to use during generation. You also need this parameter if you want to use `server.protocol` notation within `conditionalFiles` configuration option. Once you decide to specify this parameter for your template, it is recommended you make it a mandatory parameter otherwise a feature like `conditionalFiles` is not going to work if your users do not use this parameter obligatory.
+
+

package/docs/file-templates.md

@@ -0,0 +1,67 @@
+---
+title: "File templates"
+weight: 110
+---
+
+It is possible to generate files for each specific object in your AsyncAPI documentation. For example, you can specify a filename like `$$channel$$.js` to generate a file for each channel defined in your AsyncAPI. The following file-template names and extra variables in them are available:
+
+   - `$$channel$$`, within the template-file you have access to two variables [`channel`](https://github.com/asyncapi/parser-js/blob/master/API.md#Channel) and [`channelName`](https://github.com/asyncapi/parser-js/blob/master/API.md#AsyncAPIDocument+channels). Where the `channel` contains the current channel being rendered.
+   - `$$message$$`, within the template-file you have access to two variables [`message`](https://github.com/asyncapi/parser-js/blob/master/API.md#Message) and [`messageName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Message+uid). Where `message` contains the current message being rendered.
+   - `$$schema$$`, within the template-file you have access to two variables [`schema`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema) and [`schemaName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema+uid). Where `schema` contains the current schema being rendered. Only schemas from [Components object](https://www.asyncapi.com/docs/specifications/2.0.0/#a-name-componentsobject-a-components-object) are used. 
+   - `$$everySchema$$`, within the template-file you have access to two variables [`schema`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema) and [`schemaName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema+uid). Where `schema` contains the current schema being rendered. Every [Schema object](https://www.asyncapi.com/docs/specifications/2.0.0/#schemaObject) from the entire AsyncAPI file is used.
+   - `$$objectSchema$$`, within the template-file you have access to two variables [`schema`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema) and [`schemaName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema+uid). Where `schema` contains the current schema being rendered. All the [Schema objects](https://www.asyncapi.com/docs/specifications/2.0.0/#schemaObject) with type object is used.
+   - `$$parameter$$`, within the template-file you have access to two variables [`parameter`](https://github.com/asyncapi/parser-js/blob/master/API.md#ChannelParameter) and [`parameterName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Channel+parameters). Where the `parameter` contains the current parameter being rendered.
+   - `$$securityScheme$$`, within the template-file you have access to two variables [`securityScheme`](https://github.com/asyncapi/parser-js/blob/master/API.md#SecurityScheme) and [`securitySchemeName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Components+securitySchemes). Where `securityScheme` contains the current security scheme being rendered.
+
+The file name will be equal to `*Name` variable.
+
+### Example
+
+The file name is `$$schema$$.txt`, the content of this file is:
+```
+Schema name is '{{schemaName}}' and properties are:
+{% for propName, prop in schema.properties() %}
+- {{prop.uid()}}
+{% endfor %}
+```
+
+With following AsyncAPI:
+```
+components:
+  schemas: 
+    peoplePayload:
+      type: object
+      properties:
+        event:
+          $ref: "#/components/schemas/people"
+    people:
+      type: object
+      properties:
+        id:
+          type: integer
+```
+
+The generator creates two files `peoplePayload.txt` and `people.txt` with the following content:
+```
+Schema name is 'peoplePayload' and properties are:
+- people
+```
+
+and
+```
+Schema name is 'people' and properties are:
+- id
+```
+
+### React
+
+The above way of rendering **file templates** works for both `nunjucks` and `react` render engines, but `react` also has another, more generic way to render multiple files. It is enough to return an array of `File` components in the rendering component. See the following example:
+
+```tsx
+export default function({ asyncapi }) {
+  return [
+    <File name={`file1.html`}>Content</File>,
+    <File name={`file2.html`}>Content</File>
+  ]
+}
+```

package/docs/hooks.md

@@ -0,0 +1,81 @@
+---
+title: "Hooks"
+weight: 100
+---
+
+Hooks are functions called by the generator on a specific moment in the generation process. Hooks can be anonymous functions but you can also add function names. These hooks can have arguments provided to them or being expected to return a value.
+The following types of hooks are currently supported:
+
+|Hook type|Description| Return type | Arguments 
+|---|---|---|---|
+| `generate:before` | Called after registration of all filters and before the generator starts processing of the template. | void : Nothing is expected to be returned. | [The generator instance](https://github.com/asyncapi/generator/blob/master/docs/api.md)
+| `generate:after` | Called at the very end of the generation. | void : Nothing is expected to be returned. | [The generator instance](https://github.com/asyncapi/generator/blob/master/docs/api.md)
+| `setFileTemplateName ` | Called right before saving a new file generated by [file template](./file-templates.md). | string : a new filename for the generator to use for the file template. | [The generator instance](https://github.com/asyncapi/generator/blob/master/docs/api.md) and object in the form of `{ "originalFilename" : string }`
+
+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).
+
+### 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).
+
+Most basic modules with hooks look like this:
+```js
+module.exports = {
+  'generate:after': generator => console.log('This runs after generation is complete')
+}
+```
+
+Below you have an example Hook that after generation creates an AsyncAPI file.
+
+```js
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  'generate:after': generator => {
+    const asyncapi = generator.originalAsyncAPI;
+    let extension;
+
+    try {
+      JSON.parse(asyncapi);
+      extension = 'json';
+    } catch (e) {
+      extension = 'yaml';
+    }
+
+    fs.writeFileSync(path.resolve(generator.targetDir, `asyncapi.${extension}`), asyncapi);
+  }
+};
+```
+And here an example Hook that before generation switches `publish` and `subscribe` operations for each channel.
+
+```js
+module.exports = {
+  'generate:before': function switchOperations(generator) {
+    const asyncapi = generator.asyncapi;
+    for (let [key, value] of Object.entries(asyncapi.channels())) {
+      let publish = value._json.publish;
+      value._json.publish = value._json.subscribe;
+      value._json.subscribe = publish;
+      if (!value._json.subscribe) {
+        delete value._json.subscribe;
+      }
+      if (!value._json.publish) {
+        delete value._json.publish;
+      }
+    }
+  };
+};
+```
+
+Example hook for changing the filename of a template file. Replaces all '-' characters with '_'.
+```js
+module.exports = {
+	'setFileTemplateName': (generator, hookArguments) => {
+		const currentFilename = hookArguments.originalFilename ;
+		return currentFilename.replace('-', '_')
+	};
+};
+```

package/docs/index.md

@@ -0,0 +1,6 @@
+---
+title: "Introduction"
+weight: 10
+---
+
+>This document is under construction.

package/docs/nunjucks-render-engine.md

@@ -0,0 +1,78 @@
+---
+title: "Nunjucks Render Engine"
+weight: 70
+---
+
+[Nunjucks](https://mozilla.github.io/nunjucks) is the default render engine, however, we strongly recommend adopting the [React](#react) engine.
+
+### Common assumptions
+
+1. Templates may contain [Nunjucks filters or helper functions](https://mozilla.github.io/nunjucks/templating.html#builtin-filters). [Read more about filters](#filters).
+1. Templates may contain `partials` (reusable chunks). They must be stored in the `.partials` directory under the template directory. [Read more about partials](#partials).
+1. Templates may contain multiple files. Unless stated otherwise, all files will be rendered.
+1. The default variables you have access to in any the template file are the following:
+   - `asyncapi` that is a parsed spec file object. Read the [API](https://github.com/asyncapi/parser-js/blob/master/API.md#AsyncAPIDocument) of the Parser to understand what structure you have access to in this parameter.
+   - `originalAsyncAPI` that is an original spec file before it is parsed. 
+   - `params` that contain the parameters provided when generating.
+
+### Partials
+
+Files from the `.partials` directory do not end up with other generated files in the target directory. In this directory you should keep reusable templates chunks that you can [include](https://mozilla.github.io/nunjucks/templating.html#include) in your templates. You can also put there [macros](https://mozilla.github.io/nunjucks/templating.html#macro) to use them in templates, like in below example:
+
+```html
+{# tags.html #}
+{% macro tags(tagList) %}
+<div class="mt-4">
+  {% for tag in tagList %}
+    <span class="bg-grey-dark font-normal text-sm no-underline text-white rounded lowercase mr-2 px-2 py-1" title="{{tag.description()}}">{{tag.name()}}</span>
+  {% endfor %}
+</div>
+{% endmacro %}
+
+{# operations.html #}
+{% from "./tags.html" import tags %}
+{{ tags(operation.tags()) }}
+```
+
+### Filters
+
+A filter is a helper function that you can create to perform complex tasks. They are JavaScript files that register one or many [Nunjuck filters](https://mozilla.github.io/nunjucks/api.html#custom-filters). The generator parses all the files in the `filters` directory. Functions exported from these files are registered as filters.
+
+You can use the filter function in your template as in the following example:
+
+```js
+const {{ channelName | camelCase }} = '{{ channelName }}';
+```
+
+The generator also supports asynchronous filters. Asynchronous filters receive as the last argument a callback to resume rendering. Asynchronous filters must be annotated with the `async` keyword. Make sure to call the callback with two arguments: `callback(err, res)`. `err` can be `null`. See the following example of how to use asynchronous filters:
+
+```js
+const filter = module.exports;
+
+async function asyncCamelCase(str, callback) {
+  try {
+    const result = // logic for camel casing str
+    callback(null, result);
+  } catch (error) {
+    callback(error);
+  }
+}
+filter.renderAsyncContent = renderAsyncContent;
+
+// using in template
+{{ channelName | asyncCamelCase }}
+```
+
+Unfortunately, if you need to use Promise, filter still must be annotated with the `async` keyword:
+
+```js
+async function asyncCamelCase(str, callback) {
+  return new Promise((resolve, reject) => {
+    // logic with callback
+  });
+}
+```
+
+In case you have more than one template and want to reuse filters, you can put them in a single library. You can configure such a library in the template configuration under `filters` property. You can also use the official AsyncAPI [filters library](https://github.com/asyncapi/generator-filters). To learn how to add such filters to configuration [read more about the configuration file](#configuration-file).
+
+

package/docs/parser.md

@@ -0,0 +1,6 @@
+---
+title: "Parser"
+weight: 90
+---
+
+>This document is under construction.

package/docs/react-render-engine.md

@@ -0,0 +1,80 @@
+---
+title: "React Render Engine"
+weight: 60
+---
+
+[React](https://reactjs.org) is the render engine that we strongly suggest you should use for any new templates. The only reason it is not the default render engine is to stay backward compatible.
+
+* It enables the possibility of [debugging](#debugging-react-template) your template (this is not possible with Nunjucks).
+* It provides better error stack traces.
+* Provides better support for separating code into more manageable chunks/components.
+* The readability of the template is much better compared to Nunjucks syntax.
+* Better tool support for development.
+* Introduces testability of components which is not possible with Nunjucks.
+
+When writing React templates you decide whether to use CommonJS, ES5, or ES6 modules since everything is bundled together before the rendering process takes over. We use our own React renderer which can be found in the [Generator React SDK](https://github.com/asyncapi/generator-react-sdk). 
+There you can find information about how the renderer works or how we transpile your template files.
+
+Your React template always require `@asyncapi/generator-react-sdk` as a dependency. `@asyncapi/generator-react-sdk` is required to access the `File` component which is required as a root component for a file to be rendered. Furthermore it provides some common components to make your development easier, like `Text` or `Indent`.
+
+Let's consider a basic React template as the one below called `MyTemplate.js`:
+
+```js
+import { File, Text } from "@asyncapi/generator-react-sdk";
+
+export default function({ asyncapi, params, originalAsyncAPI }) {
+  return (
+    <File name="asyncapi.md">
+      <Text>Some text that should render as is</Text>
+    </File>
+  );
+}
+```
+
+The exported default function returns a `File` component as a root component which the [Generator](https://github.com/asyncapi/generator) uses to figure out what file should be generated. In our case we overwrite the default functionality of saving the file as `MyTemplate.js` but instead use the filename `asyncapi.md`. It is then specified that we should render `Some text that should render as is\n` within that file. Notice the `\n` character at the end, this is something that is automatically added after the `Text` component. 
+
+For further information about components, props etc. see the [Generator React SDK](https://github.com/asyncapi/generator-react-sdk)
+
+### Common assumptions
+
+1. Generator renders all files located in the `template` directory if they meet the following conditions:
+    - `File` is the root component
+    - The file is not in the list of `nonRenderableFiles` in the template configuration
+1. New lines are automatically added after each `Text` component.
+1. The props you have access to in rendering function is:
+   - `asyncapi` that is a parsed spec file object. Read the [API](https://github.com/asyncapi/parser-js/blob/master/API.md#AsyncAPIDocument) of the Parser to understand what structure you have access to in this parameter.
+   - `originalAsyncAPI` that is an original spec file before it is parsed. 
+   - `params` that contain the parameters provided when generating.
+1. All the file templates are supported where the variables are provided after the default props as listed above. 
+
+### Debugging React template in VSCode
+
+With React, it enables you to debug your templates. For Visual Studio Code, we have created a boilerplate [launch configuration](https://code.visualstudio.com/docs/editor/debugging#_launch-configurations) to enable debug in your template. Add the following launch configuration:
+
+```json
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug template",
+      "timeout": 10000,
+      "sourceMaps": true,
+      "args": [
+        "./asyncapi.yml",
+        "./template",
+        "--output",
+        "./output",
+        "--install",
+        "--force-write"
+      ],
+      "program": "ag"
+    }
+  ]
+}
+```
+
+Now replace `./asyncapi.yml` with your document of choice. Replace `./template` with the path to your React template. You can now debug your template by adding any breakpoints you want and inspect your code.
+
+

package/docs/special-file-names.md

@@ -0,0 +1,11 @@
+---
+title: "Special file names"
+weight: 130
+---
+
+We use NPM behind the scenes to download and install the templates. Since NPM will not fetch files like `.gitignore`, you should name them differently. Luckily, the Generator will take care of renaming them back for you. The following is a table of the special file names:
+
+|Special file name|Output file name|
+|---|---|
+|`{.gitignore}`|`.gitignore`|
+|`{.npmignore}`|`.npmignore`|

package/docs/template.md

@@ -0,0 +1,6 @@
+---
+title: "Template"
+weight: 40
+---
+
+>This document is under construction.

package/docs/typescript-support.md

@@ -0,0 +1,13 @@
+---
+title: "TypeScript Support"
+weight: 120
+---
+
+The AsyncAPI generator has TypeScript support for [hooks](#hooks) and Nunjucks's [filters](#filters). Assumptions:
+
+- Installing the `typescript` package and creating the` tsconfig.json` file isn't necessary.
+- Source code of the hook/filter must have `.ts` extension.
+- Each package related to the typings for TypeScript like `@types/node` must be installed in the template under `dependencies` array. This is because the Generator transpiles the TypeScript code on-the-fly while rendering the template, and cannot use packages under `devDependencies`.
+- Each template should have `@types/node` package installed to enable support for typings for Node.
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asyncapi/generator",
-  "version": "1.9.4",
+  "version": "1.9.7",
   "description": "The AsyncAPI generator. It can generate documentation, code, anything!",
   "main": "./lib/generator.js",
   "bin": {
@@ -19,7 +19,6 @@
     "test:cli": "node cli.js ./test/docs/dummy.yml @asyncapi/html-template -o test/output --force-write --debug && test -e test/output/index.html",
     "test:cleanup": "rimraf \"test/temp\"",
     "docs": "jsdoc2md lib/generator.js > docs/api.md",
-    "release": "semantic-release",
     "docker:build": "docker build -t asyncapi/generator:latest .",
     "lint": "eslint --max-warnings 0 --config .eslintrc .",
     "lint:tpl:validator": "eslint --fix --config .eslintrc .github/templates-list-validator",
@@ -48,15 +47,16 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/asyncapi/generator",
   "dependencies": {
-    "@asyncapi/avro-schema-parser": "^1.0.0",
+    "@asyncapi/avro-schema-parser": "^1.1.0",
     "@asyncapi/generator-react-sdk": "^0.2.23",
     "@asyncapi/openapi-schema-parser": "^2.0.1",
-    "@asyncapi/parser": "^1.15.0",
+    "@asyncapi/parser": "^1.15.1",
     "@asyncapi/raml-dt-schema-parser": "^2.0.1",
     "@npmcli/arborist": "^2.2.4",
     "ajv": "^6.10.2",
     "chokidar": "^3.4.0",
     "commander": "^6.1.0",
+    "conventional-changelog-conventionalcommits": "^5.0.0",
     "filenamify": "^4.1.0",
     "fs.extra": "^1.3.2",
     "global-dirs": "^3.0.0",
@@ -77,12 +77,6 @@
     "typescript": "^4.2.2"
   },
   "devDependencies": {
-    "@semantic-release/commit-analyzer": "^8.0.1",
-    "@semantic-release/github": "^7.0.4",
-    "@semantic-release/npm": "^7.0.6",
-    "@semantic-release/release-notes-generator": "^9.0.1",
-    "all-contributors-cli": "^6.14.2",
-    "conventional-changelog-conventionalcommits": "^4.4.0",
     "eslint": "^6.8.0",
     "eslint-plugin-jest": "^23.8.2",
     "eslint-plugin-sonarjs": "^0.5.0",
@@ -90,28 +84,6 @@
     "jsdoc-to-markdown": "^5.0.0",
     "markdown-toc": "^1.2.0",
     "rimraf": "^3.0.2",
-    "semantic-release": "^17.2.2",
     "unixify": "^1.0.0"
-  },
-  "release": {
-    "branches": [
-      "master"
-    ],
-    "plugins": [
-      [
-        "@semantic-release/commit-analyzer",
-        {
-          "preset": "conventionalcommits"
-        }
-      ],
-      [
-        "@semantic-release/release-notes-generator",
-        {
-          "preset": "conventionalcommits"
-        }
-      ],
-      "@semantic-release/npm",
-      "@semantic-release/github"
-    ]
   }
 }

package/docs/authoring.md

@@ -1,402 +0,0 @@
-# Authoring templates
-
-The AsyncAPI generator has been built with extensibility in mind. The package uses a set of default templates to let you generate documentation and code. However, you can create and use your own templates. In this section, you learn how to create your own one.
-
-To work on a template, you need an AsyncAPI specification file that you can use for testing. For this purpose, you can use [this](../test/docs/dummy.yml) dummy file as it's purpose is to cover as many features of AsyncAPI as possible. Do not copy this file to your template but use it directly from this repo like this: `ag https://raw.githubusercontent.com/asyncapi/generator/master/test/docs/dummy.yml ./your-template`
-
-> In case you find some features missing or other possible improvements in the dummy file, suggest changes. The goal is to build a file that all templates can use and check their specification features coverage.
-
-## Common assumptions
-
-1. A template is a directory in your file system.
-1. The template can have own dependencies. Just create `package.json` for the template. The generator makes sure to trigger the installation of dependencies.
-1. Templates can be configured. Configuration must be stored in the `package.json` file under custom `generator` property. [Read more about the configuration file](#configuration-file).
-1. The template engine can be either [React](#react) (recommended) or [Nunjucks](#nunjucks) (default). This can be controlled with the `renderer` property in the [template configuration](#template-configuration).
-1. Templates may contain `hooks` that are functions invoked during specific moment of the generation. In the template, they must be stored in the `hooks` directory under the template directory. They can also be stored in other modules and external libraries and configured inside the template [Read more about hooks](#hooks).
-1. There are parameters with special meaning. [Read more about special parameters](#special-parameters).
-
-## Special file names
-
-We use NPM behind the scenes to download and install the templates. Since NPM will not fetch files like `.gitignore`, you should name them differently. Luckily, the Generator will take care of renaming them back for you. The following is a table of the special file names:
-
-|Special file name|Output file name|
-|---|---|
-|`{.gitignore}`|`.gitignore`|
-|`{.npmignore}`|`.npmignore`|
-
-## File templates
-
-It is possible to generate files for each specific object in your AsyncAPI documentation. For example, you can specify a filename like `$$channel$$.js` to generate a file for each channel defined in your AsyncAPI. The following file-template names and extra variables in them are available:
-
-   - `$$channel$$`, within the template-file you have access to two variables [`channel`](https://github.com/asyncapi/parser-js/blob/master/API.md#Channel) and [`channelName`](https://github.com/asyncapi/parser-js/blob/master/API.md#AsyncAPIDocument+channels). Where `channel` contains the current channel being rendered.
-   - `$$message$$`, within the template-file you have access to two variables [`message`](https://github.com/asyncapi/parser-js/blob/master/API.md#Message) and [`messageName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Message+uid). Where `message` contains the current message being rendered.
-   - `$$schema$$`, within the template-file you have access to two variables [`schema`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema) and [`schemaName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema+uid). Where `schema` contains the current schema being rendered. Only schemas from [Components object](https://www.asyncapi.com/docs/specifications/2.0.0/#a-name-componentsobject-a-components-object) are used. 
-   - `$$everySchema$$`, within the template-file you have access to two variables [`schema`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema) and [`schemaName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema+uid). Where `schema` contains the current schema being rendered. Every [Schema object](https://www.asyncapi.com/docs/specifications/2.0.0/#schemaObject) from the entire AsyncAPI file is used.
-   - `$$objectSchema$$`, within the template-file you have access to two variables [`schema`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema) and [`schemaName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Schema+uid). Where `schema` contains the current schema being rendered. All the [Schema objects](https://www.asyncapi.com/docs/specifications/2.0.0/#schemaObject) with type object is used.
-   - `$$parameter$$`, within the template-file you have access to two variables [`parameter`](https://github.com/asyncapi/parser-js/blob/master/API.md#ChannelParameter) and [`parameterName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Channel+parameters). Where `parameter` contains the current parameter being rendered.
-   - `$$securityScheme$$`, within the template-file you have access to two variables [`securityScheme`](https://github.com/asyncapi/parser-js/blob/master/API.md#SecurityScheme) and [`securitySchemeName`](https://github.com/asyncapi/parser-js/blob/master/API.md#Components+securitySchemes). Where `securityScheme` contains the current security scheme being rendered.
-
-The file name will be equal to `*Name` variable.
-
-### Example
-
-The file name is `$$schema$$.txt`, the content of this file is:
-```
-Schema name is '{{schemaName}}' and properties are:
-{% for propName, prop in schema.properties() %}
-- {{prop.uid()}}
-{% endfor %}
-```
-
-With following AsyncAPI:
-```
-components:
-  schemas: 
-    peoplePayload:
-      type: object
-      properties:
-        event:
-          $ref: "#/components/schemas/people"
-    people:
-      type: object
-      properties:
-        id:
-          type: integer
-```
-
-The generator creates two files `peoplePayload.txt` and `people.txt` with the following content:
-```
-Schema name is 'peoplePayload' and properties are:
-- people
-```
-
-and
-```
-Schema name is 'people' and properties are:
-- id
-```
-
-### React
-
-The above way of rendering **file templates** works for both `nunjucks` and `react` render engines, but `react` also has another, more generic way to render multiple files. It is enough to return an array of `File` components in the rendering component. See the following example:
-
-```tsx
-export default function({ asyncapi }) {
-  return [
-    <File name={`file1.html`}>Content</File>,
-    <File name={`file2.html`}>Content</File>
-  ]
-}
-```
-
-## Hooks
-
-Hooks are functions called by the generator on a specific moment in the generation process. Hooks can be anonymous functions but you can also add function names. These hooks can have arguments provided to them or being expected to return a value.
-The following types of hooks are currently supported:
-
-|Hook type|Description| Return type | Arguments 
-|---|---|---|---|
-| `generate:before` | Called after registration of all filters and before generator starts processing of the template. | void : Nothing is expected to be returned. | [The generator instance](https://github.com/asyncapi/generator/blob/master/docs/api.md)
-| `generate:after` | Called at the very end of the generation. | void : Nothing is expected to be returned. | [The generator instance](https://github.com/asyncapi/generator/blob/master/docs/api.md)
-| `setFileTemplateName ` | Called right before saving a new file generated by [file template](https://github.com/asyncapi/generator/blob/master/docs/authoring.md#file-templates). | string : a new filename for the generator to use for the file template. | [The generator instance](https://github.com/asyncapi/generator/blob/master/docs/api.md) and object in the form of `{ "originalFilename" : string }`
-
-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).
-
-### Examples
-
-> Some of examples have name 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).
-
-Most basic module with hooks looke like this:
-```js
-module.exports = {
-  'generate:after': generator => console.log('This runs after generation is complete')
-}
-```
-
-Below you have an example Hook that after generation creates an AsyncAPI file.
-
-```js
-const fs = require('fs');
-const path = require('path');
-
-module.exports = {
-  'generate:after': generator => {
-    const asyncapi = generator.originalAsyncAPI;
-    let extension;
-
-    try {
-      JSON.parse(asyncapi);
-      extension = 'json';
-    } catch (e) {
-      extension = 'yaml';
-    }
-
-    fs.writeFileSync(path.resolve(generator.targetDir, `asyncapi.${extension}`), asyncapi);
-  }
-};
-```
-And here an example Hook that before generation switches `publish` and `subscribe` operations for each channel.
-
-```js
-module.exports = {
-  'generate:before': function switchOperations(generator) {
-    const asyncapi = generator.asyncapi;
-    for (let [key, value] of Object.entries(asyncapi.channels())) {
-      let publish = value._json.publish;
-      value._json.publish = value._json.subscribe;
-      value._json.subscribe = publish;
-      if (!value._json.subscribe) {
-        delete value._json.subscribe;
-      }
-      if (!value._json.publish) {
-        delete value._json.publish;
-      }
-    }
-  };
-};
-```
-
-Example hook for changing the filename of a template file. Replaces all '-' characters with '_'.
-```js
-module.exports = {
-	'setFileTemplateName': (generator, hookArguments) => {
-		const currentFilename = hookArguments.originalFilename ;
-		return currentFilename.replace('-', '_')
-	};
-};
-```
-
-## Configuration File
-
-The `generator` property from `package.json` file must contain a JSON object that may have the following information:
-
-|Name|Type|Description|
-|---|---|---|
-|`renderer`| String | Its value can be either `react` or `nunjucks` (default).
-|`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.
-|`parameters[param].default`| Any | Default value of the parameter if not specified. Shouldn't be used for mandatory `required=true` parameters.
-|`parameters[param].required`| Boolean | Whether the parameter is required or not.
-|`conditionalFiles`| Object[String, Object] | An object containing all the file paths that should be conditionally rendered. Each key represents a file path and each value must be an object with the keys `subject` and `validation`. The file path should be relative to the `template` directory inside the template.
-|`conditionalFiles[filePath].subject`| String | The `subject` is a [JMESPath](http://jmespath.org/) query to grab the value you want to apply the condition to. It queries an object with the whole AsyncAPI document and, when specified, the given server. The object looks like this: `{ asyncapi: { ... }, server: { ... } }`. If template supports `server` parameter, you can access server details like for example protocol this way: `server.protocol`. During validation with `conditionalFiles` only the server that template user selected is available in the specification file. For more information about `server` parameter [read about special parameters](#special-parameters).
-|`conditionalFiles[filePath].validation`| Object | The `validation` is a JSON Schema Draft 07 object. This JSON Schema definition will be applied to the JSON value resulting from the `subject` query. If validation doesn't have errors, the condition is met, and therefore the given file will be rendered. Otherwise, the file is ignored. Check [JSON Schema Validation](https://json-schema.org/draft-07/json-schema-validation.html#rfc.section.6) document for a list of all possible validation keywords.
-|`nonRenderableFiles`| [String] | A list of file paths or [globs](https://en.wikipedia.org/wiki/Glob_(programming)) that must be copied "as-is" to the target directory, i.e., without performing any rendering process. This is useful when you want to copy binary files.
-|`generator`| [String] | A string representing the Generator version-range the template is compatible with. This value must follow the [semver](https://nodejs.dev/learn/semantic-versioning-using-npm) syntax. E.g., `>=1.0.0`, `>=1.0.0 <=2.0.0`, `~1.0.0`, `^1.0.0`, `1.0.0`, etc. [Read more about semver](https://docs.npmjs.com/about-semantic-versioning).
-|`filters`| [String] | A list of modules containing functions that can be used as Nunjucks filters. In case of external modules, remember they need to be added as a dependency in `package.json` of your template.
-|`hooks`| Object[String, String] or Object[String, Array[String]] | A list of modules containing hooks, except of the ones you keep locally in your template in default location. For each module you must specify exact name of the hook that should be used in the template. For single hook you can specify it as a string, for more you must pass an array of strings. In case of external modules, remember they need to be added as a dependency in `package.json` of your template.
-
-### Example
-
-```json
-"generator":
-{
-  "renderer": "react",
-  "supportedProtocols": ["amqp", "mqtt"],
-  "parameters": {
-    "server": {
-      "description": "The server you want to use in the code.",
-      "required": true
-    },
-    "dummyParameter": {
-      "description": "Example of parameter with default value.",
-      "default": "just a string",
-      "required": false
-    }
-  },
-  "conditionalFiles": {
-    "path/to/file/that/is/relative/to/template/dir/test-amqp.js": {
-      "subject": "server.protocol",
-      "validation": {
-        "const": "amqp"
-      }
-    },
-    "path/to/file/that/is/relative/to/template/dir/support.html": {
-      "subject": "info.contact",
-        "validation": {
-          "required": ["url"]
-        }
-    }
-  },
-  "nonRenderableFiles": [
-    "src/api/middlewares/*.*",
-    "lib/lib/config.js"
-  ],
-  "generator": "<2.0.0",
-  "filters": [
-    "@asyncapi/generator-filters"
-  ],
-  "hooks": {
-    "@asyncapi/generator-hooks": "hookFunctionName"
-  }
-}
-```
-
-## Special parameters
-
-There are some template parameters that have a special meaning:
-
-|Name|Description|
-|---|---|
-|`server`| It is used to let the template know which server from the AsyncAPI specification file you want to use. In some cases, this may be required. For instance, when generating code that connects to a specific server. Use this parameter in case your template relies on users' information about what server from the specification file they want to use during generation. You also need this parameter if you want to use `server.protocol` notation within `conditionalFiles` configuration option. Once you decide to specify this parameter for your template, it is recommended you make it a mandatory parameter otherwise feature like `conditionalFiles` is not going to work if your users do not use this parameter obligatory.
-
-## React
-
-[React](https://reactjs.org) is the render engine that we strongly suggest you should use for any new templates. The only reason it is not the default render engine is to stay backward compatible.
-
-* It enables the possiblity of [debugging](#debugging-react-template) your template (this is not possible with Nunjucks).
-* It provides better error stack traces.
-* Provides better support for separating code into more manageable chunks/components.
-* The readability of the template is much better compared to Nunjucks syntax.
-* Better tool support for development.
-* Introduces testability of components which is not possible with Nunjucks.
-
-When writing React templates you decide whether to use CommonJS, ES5, or ES6 modules since everything is bundled together before the rendering process takes over. We use our own React renderer which can be found in the [Generator React SDK](https://github.com/asyncapi/generator-react-sdk). 
-There you can find information about how the renderer works or how we transpile your template files.
-
-Your React template always require `@asyncapi/generator-react-sdk` as a dependency. `@asyncapi/generator-react-sdk` is required to access the `File` component which is required as a root component for a file to be rendered. Furthermore it provides some common components to make your development easier, like `Text` or `Indent`.
-
-Let's consider a basic React template as the one below called `MyTemplate.js`:
-
-```js
-import { File, Text } from "@asyncapi/generator-react-sdk";
-
-export default function({ asyncapi, params, originalAsyncAPI }) {
-  return (
-    <File name="asyncapi.md">
-      <Text>Some text that should render as is</Text>
-    </File>
-  );
-}
-```
-
-The exported default function returns a `File` component as a root component which the [Generator](https://github.com/asyncapi/generator) uses to figure out what file should be generated. In our case we overwrite the default functionality of saving the file as `MyTemplate.js` but instead use the filename `asyncapi.md`. It is then specified that we should render `Some text that should render as is\n` within that file. Notice the `\n` character at the end, this is something that is automatically added after the `Text` component. 
-
-For further information about components, props etc. see the [Generator React SDK](https://github.com/asyncapi/generator-react-sdk)
-
-### Common assumptions
-
-1. Generator renders all files located in the `template` directory if they meet the following conditions:
-    - `File` is the root component
-    - The file is not in the list of `nonRenderableFiles` in the template configuration
-1. New lines are automatically added after each `Text` component.
-1. The props you have access to in rendering function is:
-   - `asyncapi` that is a parsed spec file object. Read the [API](https://github.com/asyncapi/parser-js/blob/master/API.md#AsyncAPIDocument) of the Parser to understand to what structure you have access in this parameter.
-   - `originalAsyncAPI` that is an original spec file before it is parsed. 
-   - `params` that contains the parameters provided when generating.
-1. All the file templates are supported where the variables are provided after the default props as listed above. 
-
-### Debugging React template in VSCode
-
-With React, it enables you to debug your templates. For Visual Studio Code, we have created a boilerplate [launch configuration](https://code.visualstudio.com/docs/editor/debugging#_launch-configurations) to enable debug in your template. Add the following launch configuration:
-
-```json
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Debug template",
-      "timeout": 10000,
-      "sourceMaps": true,
-      "args": [
-        "./asyncapi.yml",
-        "./template",
-        "--output",
-        "./output",
-        "--install",
-        "--force-write"
-      ],
-      "program": "ag"
-    }
-  ]
-}
-```
-
-Now replace `./asyncapi.yml` with your document of choice. Replace `./template` with the path to your React template. You can now debug your template by adding any breakpoints you want and inspect your code.
-
-## Nunjucks
-
-[Nunjucks](https://mozilla.github.io/nunjucks) is the default render engine, however, we strongly recommend adopting the [React](#react) engine.
-
-### Common assumptions
-
-1. Templates may contain [Nunjucks filters or helper functions](https://mozilla.github.io/nunjucks/templating.html#builtin-filters). [Read more about filters](#filters).
-1. Templates may contain `partials` (reusable chunks). They must be stored in the `.partials` directory under the template directory. [Read more about partials](#partials).
-1. Templates may contain multiple files. Unless stated otherwise, all files will be rendered.
-1. The default variables you have access to in any the template file are the following:
-   - `asyncapi` that is a parsed spec file object. Read the [API](https://github.com/asyncapi/parser-js/blob/master/API.md#AsyncAPIDocument) of the Parser to understand to what structure you have access in this parameter.
-   - `originalAsyncAPI` that is an original spec file before it is parsed. 
-   - `params` that contains the parameters provided when generating.
-
-### Partials
-
-Files from the `.partials` directory do not end up with other generated files in the target directory. In this directory you should keep reusable templates chunks that you can [include](https://mozilla.github.io/nunjucks/templating.html#include) in your templates. You can also put there [macros](https://mozilla.github.io/nunjucks/templating.html#macro) to use them in templates, like in below example:
-
-```html
-{# tags.html #}
-{% macro tags(tagList) %}
-<div class="mt-4">
-  {% for tag in tagList %}
-    <span class="bg-grey-dark font-normal text-sm no-underline text-white rounded lowercase mr-2 px-2 py-1" title="{{tag.description()}}">{{tag.name()}}</span>
-  {% endfor %}
-</div>
-{% endmacro %}
-
-{# operations.html #}
-{% from "./tags.html" import tags %}
-{{ tags(operation.tags()) }}
-```
-
-### Filters
-
-A filter is a helper function that you can create to perform complex tasks. They are JavaScript files that register one or many [Nunjuck filters](https://mozilla.github.io/nunjucks/api.html#custom-filters). The generator parses all the files in the `filters` directory. Functions exported from these files are registered as filters.
-
-You can use the filter function in your template as in the following example:
-
-```js
-const {{ channelName | camelCase }} = '{{ channelName }}';
-```
-
-The generator also supports asynchronous filters. Asynchronous filters receive as last argument a callback to resume rendering. Asynchronous filters must be annotated with the `async` keyword. Make sure to call the callback with two arguments: `callback(err, res)`. `err` can be `null`. See the following example of how to use asynchronous filters:
-
-```js
-const filter = module.exports;
-
-async function asyncCamelCase(str, callback) {
-  try {
-    const result = // logic for camel casing str
-    callback(null, result);
-  } catch (error) {
-    callback(error);
-  }
-}
-filter.renderAsyncContent = renderAsyncContent;
-
-// using in template
-{{ channelName | asyncCamelCase }}
-```
-
-Unfornatelly, if you need to use Promise, filter still must be annotated with the `async` keyword:
-
-```js
-async function asyncCamelCase(str, callback) {
-  return new Promise((resolve, reject) => {
-    // logic with callback
-  });
-}
-```
-
-In case you have more than one template and want to reuse filters, you can put them in a single library. You can configure such a library in the template configuration under `filters` property. You can also use the official AsyncAPI [filters library](https://github.com/asyncapi/generator-filters). To learn how to add such filters to configuration [read more about the configuration file](#configuration-file).
-
-## TypeScript support 
-
-The AsyncAPI generator has TypeScript support for [hooks](#hooks) and Nunjucks's [filters](#filters). Assumptions:
-
-- Installing the `typescript` package and creating the` tsconfig.json` file isn't necessary.
-- Source code of the hook/filter must have `.ts` extension.
-- Each package related to the typings for TypeScript like `@types/node` must be installed in the template under `dependencies` array. This is because the Generator transpiles the TypeScript code on-the-fly while rendering the template, and cannot use packages under `devDependencies`.
-- Each template should have `@types/node` package installed to enable support for typings for Node.

package/docs/templates-recipes.md

@@ -1,110 +0,0 @@
-# Templates recipes
-
-In this document you can find recipes for templates that you might want to copy and reuse them for your need to speed up template development. Feel free to create a Pull Request with your recipe.
-
-## Prerequisites
-
-You must be familiar with [Nunjucks](https://mozilla.github.io/nunjucks/) templating engine and [how it is supported in the generator](./authoring.md).
-
-## Recipes
-
-- [Using Schema objects to generate types for a given programming language](#using-schema-objects-to-generate-types-for-a-given-programming-language)
-- [Displaying separate lists for different channels operations](#displaying-separate-lists-for-different-channels-operations)
-
-### Using Schema objects to generate types for a given programming language
-
-* Java example where `$$schema$$.java` file looks like this:
-    ```java
-    package com.async.generated;
-
-    public class {{schema.uid()}} {
-        
-    {%- for propertyName, property in schema.properties() %}
-        public {{property.type() | toJavaType}} {{propertyName}};
-    {%- endfor %}
-        public {{schema.uid()}}(
-        {%- set counter = 0 %}
-        {%- for propertyName, property in schema.properties() %}
-            {%- if property.required()%}
-                {%- if counter == schema.properties().length %}
-                    {{ property.type() | toJavaType }} {{ propertyName }}
-                {%- else %}
-                    {{ property.type() | toJavaType }} {{ propertyName }},
-                {%- endif %}
-            {%- set counter = counter +1 %}
-            {%- endif %}
-        {%- endfor %}) {
-        {%- for propertyName, property in schema.properties() %}
-            {%- if property.required()%}
-                this.{{ propertyName }}={{ propertyName }};
-            {%- endif %}
-        {%- endfor %}
-        }
-    }
-    ```
-    The `toJavaType` filter:
-    ```js
-    Nunjucks.addFilter('toJavaType', jsonSchemaType => {
-    switch (jsonSchemaType.toLowerCase()) {
-        case 'string':
-        return 'String';
-        case 'integer':
-        return  'Integer'
-        case 'number':
-        return 'Double';
-        case 'boolean':
-        return 'boolean';
-    }
-    });
-    ```
-* Nodejs example where `$$schema$$.js` file looks like this:
-    ```js
-    export default class {{ schema.name() }} {
-    {%- for propertyName, property in schema.properties() %}
-        {%- if property.required()%}
-    public {{ propertyName }}:{{ property.type() }};
-        {%- else %}
-    public {{ propertyName }}?:{{ property.type() }};
-        {%- endif %}
-    {%- endfor %}
-    constructor(
-        {%- set counter = 0 %}
-        {%- for propertyName, property in schema.properties() %}
-            {%- if property.required()%}
-                {%- if counter == schema.properties().length %}
-                    {{ propertyName }}:{{ property.type() }}
-                {%- else %}
-                    {{ propertyName }}:{{ property.type() }},
-                {%- endif %}
-            {%- set counter = counter +1 %}
-            {%- endif %}
-        {%- endfor %}
-        ) {
-        {%- for propertyName, property in schema.properties() %}
-            {%- if property.required()%}
-                this.{{ propertyName }}={{ propertyName }};
-            {%- endif %}
-        {%- endfor %}
-    }
-    }
-    ```
-
-### Displaying separate lists for different channels operations
-
-* HTML example that renders two separate containers, one with `publish` and second with `subscribe` operations:
-    ```html
-    {% for channelName, channel in asyncapi.channels() %}
-    <div class="responsive-container">
-        {% if channel.hasPublish() %}
-        {{ channelName }}
-        {{ channel | dump }}
-        {% endif %}
-    </div>
-    <div class="responsive-container">
-        {% if channel.hasSubscribe() %}
-        {{ channelName }}
-        {{ channel | dump }}
-        {% endif %}
-    </div>
-    {% endfor %}
-    ```