@asyncapi/converter 1.2.0 → 1.3.0

package/README.md

@@ -15,6 +15,7 @@ Convert [AsyncAPI](https://asyncapi.com) documents older to newer versions.
   * [From CLI](#from-cli)
   * [In JS](#in-js)
   * [In TS](#in-ts)
+- [Conversion 2.x.x to 3.x.x](#conversion-2xx-to-3xx)
 - [Known missing features](#known-missing-features)
 - [Development](#development)
 - [Contribution](#contribution)
@@ -32,7 +33,7 @@ npm i @asyncapi/converter
 
 ### From CLI
 
-To convert an AsyncAPi document in the console needs the official [AsyncAPI CLI](https://github.com/asyncapi/cli).
+To convert an AsyncAPI document in the console needs the official [AsyncAPI CLI](https://github.com/asyncapi/cli).
 
 If you don't have CLI installed, run this command to install the CLI globally on your system:
 
@@ -51,7 +52,7 @@ channels:
 ...
 ```
 
-Convert to specific version:
+Convert to a specific version:
 
 ```sh
 asyncapi convert streetlights.yml -o streetlights2.yml -t 2.3.0
@@ -70,9 +71,7 @@ const { convert } = require('@asyncapi/converter')
 
 try {
   const asyncapi = fs.readFileSync('streetlights.yml', 'utf-8')
-  console.log(convert(asyncapi, '2.0.0', {
-    id: 'urn:com.asyncapi.streetlights'
-  }));
+  console.log(convert(asyncapi, '2.6.0'));
 } catch (e) {
   console.error(e);
 }
@@ -85,18 +84,83 @@ import { convert } from '@asyncapi/converter';
 import type { ConvertVersion, ConvertOptions } from '@asyncapi/converter';
 
 try {
-  const toVersion: ConvertVersion = '2.0.0';
-  const options: ConvertOptions = {
-    id: 'urn:com.asyncapi.streetlights'
-  };
-
+  const toVersion: ConvertVersion = '2.6.0';
   const asyncapi = fs.readFileSync('streetlights.yml', 'utf-8')
-  console.log(convert(asyncapi, toVersion, options));
+  console.log(convert(asyncapi, toVersion));
 } catch (e) {
   console.error(e)
 }
 ```
 
+## Conversion 2.x.x to 3.x.x
+
+> **NOTE**: This feature is still WIP, and is until the final release of `3.0.0`.
+
+Conversion to version `3.x.x` from `2.x.x` has several assumptions that should be know before converting:
+
+- The input must be valid AsyncAPI document.
+- External references are not resolved and converted, they remain untouched, even if they are incorrect.
+- In version `3.0.0`, the channel identifier is no longer its address, but due to the difficulty of defining a unique identifier, we still treat the address as an identifier. If there is a need to assign an identifier other than an address, an `x-channelId` extension should be defined at the level of the given channel.
+
+  ```yaml
+  # 2.x.x
+  channels:
+    users/signup:
+      x-channelId: 'userSignUp'
+      ...
+    users/logout:
+      ...
+
+  # 3.0.0
+  channels:
+    userSignUp:
+      ...
+    users/logout:
+      ...
+  ```
+
+- The `publish` operation is treated as a `receive` action, and `subscribe` is treated as a `send` action. Conversion by default is embraced from the application perspective. If you want to change this logic, you need to specify `v2tov3.pointOfView` configuration as `client`.
+- If the operation does not have an `operationId` field defined, the unique identifier of the operation will be defined as a combination of the identifier of the channel on which the operation was defined + the type of operation, `publish` or `subscribe`. Identical situation is with messages. However, here the priority is the `messageId` field and then the concatenation `{publish|subscribe}.messages.{optional index of oneOf messages}`.
+
+  ```yaml
+  # 2.x.x
+  channels:
+    users/signup:
+      publish:
+        message:
+          ...
+      subscribe:
+        operationId: 'userSignUpEvent'
+        message:
+          oneOf:
+            - messageId: 'userSignUpEventMessage'
+              ...
+            - ...
+        
+
+  # 3.0.0
+  channels:
+    users/signup:
+      messages:
+        publish.message:
+          ...
+        userSignUpEventMessage:
+          ...
+        userSignUpEvent.message.1:
+          ...
+  operations:
+    users/signup.publish:
+      action: receive
+      ...
+    userSignUpEvent:
+      action: send
+      ...
+  ```
+
+- Security requirements that use scopes are defined in the appropriate places inline, the rest as a reference to the `components.securitySchemes` objects.
+- If servers are defined at the channel level, they are converted as references to the corresponding objects defined in the `servers` field.
+- Channels and servers defined in components are also converted (unless configured otherwise).
+
 ## Known missing features
 
 * When converting from 1.x to 2.x, Streaming APIs (those using `stream` instead of `topics` or `events`) are converted correctly but information about framing type and delimiter is missing until a [protocolInfo](https://github.com/asyncapi/extensions-catalog/issues/1) for that purpose is created.

package/lib/convert.js

@@ -1,37 +1,16 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convert = void 0;
 const js_yaml_1 = require("js-yaml");
+const first_version_1 = require("./first-version");
+const second_version_1 = require("./second-version");
+const third_version_1 = require("./third-version");
 const utils_1 = require("./utils");
 /**
  * Value for key (version) represents the function which converts specification from previous version to the given as key.
  */
-const conversions = {
-    '1.0.0': from__undefined__to__1_0_0,
-    '1.1.0': from__1_0_0__to__1_1_0,
-    '1.2.0': from__1_1_0__to__1_2_0,
-    '2.0.0-rc1': from__1_2_0__to__2_0_0_rc1,
-    '2.0.0-rc2': from__2_0_0_rc1__to__2_0_0_rc2,
-    '2.0.0': from__2_0_0_rc2__to__2_0_0,
-    '2.1.0': from__2_0_0__to__2_1_0,
-    '2.2.0': from__2_1_0__to__2_2_0,
-    '2.3.0': from__2_2_0__to__2_3_0,
-    '2.4.0': from__2_3_0__to__2_4_0,
-    '2.5.0': from__2_4_0__to__2_5_0,
-    '2.6.0': from__2_5_0__to__2_6_0,
-};
-const conversionVersions = Object.keys(conversions);
+const converters = Object.assign(Object.assign(Object.assign({}, first_version_1.converters), second_version_1.converters), third_version_1.converters);
+const conversionVersions = Object.keys(converters);
 function convert(asyncapi, version = '2.6.0', options = {}) {
     const { format, document } = (0, utils_1.serializeInput)(asyncapi);
     const asyncapiVersion = document.asyncapi;
@@ -50,7 +29,8 @@ function convert(asyncapi, version = '2.6.0', options = {}) {
     fromVersion++;
     let converted = document;
     for (let i = fromVersion; i <= toVersion; i++) {
-        converted = conversions[conversionVersions[i]](converted, options);
+        const v = conversionVersions[i];
+        converted = converters[v](converted, options);
     }
     if (format === 'yaml') {
         return (0, js_yaml_1.dump)(converted, { skipInvalid: true });
@@ -58,145 +38,3 @@ function convert(asyncapi, version = '2.6.0', options = {}) {
     return converted;
 }
 exports.convert = convert;
-function from__undefined__to__1_0_0(asyncapi, _) {
-    asyncapi.asyncapi = '1.0.0';
-    return asyncapi;
-}
-function from__1_0_0__to__1_1_0(asyncapi, _) {
-    asyncapi.asyncapi = '1.1.0';
-    return asyncapi;
-}
-function from__1_1_0__to__1_2_0(asyncapi, _) {
-    asyncapi.asyncapi = '1.2.0';
-    return asyncapi;
-}
-function from__1_2_0__to__2_0_0_rc1(asyncapi, _) {
-    asyncapi.asyncapi = '2.0.0-rc1';
-    if (asyncapi.servers) {
-        const security = asyncapi.security;
-        asyncapi.servers = asyncapi.servers.map((server) => {
-            const { scheme, schemeVersion } = server, rest = __rest(server, ["scheme", "schemeVersion"]);
-            const out = Object.assign(Object.assign({}, rest), { protocol: scheme });
-            if (schemeVersion) {
-                out.protocolVersion = schemeVersion;
-            }
-            if (security) {
-                out.security = security;
-            }
-            return out;
-        });
-    }
-    if (asyncapi.topics) {
-        const baseTopic = asyncapi.baseTopic ? `${asyncapi.baseTopic}.` : "";
-        asyncapi.channels = Object.entries(asyncapi.topics).reduce((newChannels, [channelName, channel]) => {
-            if (channel.publish) {
-                channel.publish = { message: channel.publish };
-            }
-            if (channel.subscribe) {
-                channel.subscribe = { message: channel.subscribe };
-            }
-            channelName = (0, utils_1.dotsToSlashes)(`${baseTopic}${channelName}`);
-            newChannels[channelName] = channel;
-            return newChannels;
-        }, {});
-    }
-    else if (asyncapi.stream) {
-        asyncapi.channels = {
-            '/': (0, utils_1.streamToChannel)(asyncapi.stream),
-        };
-    }
-    else if (asyncapi.events) {
-        asyncapi.channels = {
-            '/': (0, utils_1.eventToChannel)(asyncapi.events),
-        };
-    }
-    delete asyncapi.topics;
-    delete asyncapi.stream;
-    delete asyncapi.events;
-    delete asyncapi.baseTopic;
-    delete asyncapi.security;
-    return asyncapi;
-}
-function from__2_0_0_rc1__to__2_0_0_rc2(asyncapi, _) {
-    asyncapi.asyncapi = '2.0.0-rc2';
-    if (asyncapi.servers) {
-        const serverMap = {};
-        asyncapi.servers.forEach((server, index) => {
-            if (server.baseChannel)
-                delete server.baseChannel;
-            const name = index === 0 ? 'default' : `server${index}`;
-            serverMap[name] = server;
-        });
-        asyncapi.servers = serverMap;
-    }
-    if (asyncapi.channels) {
-        Object.entries(asyncapi.channels).forEach(([channelName, channel]) => {
-            if (channel.parameters) {
-                const parametersMap = {};
-                const paramNames = channelName.match(/\{([^\}]{1,100})\}/g).map(p => p.substr(1, p.length - 2)); // NOSONAR
-                channel.parameters.forEach((parameter, index) => {
-                    const name = parameter.name || paramNames[index];
-                    if (parameter.name)
-                        delete parameter.name;
-                    parametersMap[name] = parameter;
-                });
-                channel.parameters = parametersMap;
-            }
-            if (channel.publish && channel.publish.message) {
-                const message = channel.publish.message;
-                (0, utils_1.convertMessage)(message);
-            }
-            if (channel.subscribe && channel.subscribe.message) {
-                const message = channel.subscribe.message;
-                (0, utils_1.convertMessage)(message);
-            }
-            if (channel.protocolInfo) {
-                channel.bindings = channel.protocolInfo;
-                delete channel.protocolInfo;
-            }
-            if (channel.publish && channel.publish.protocolInfo) {
-                channel.publish.bindings = channel.publish.protocolInfo;
-                delete channel.publish.protocolInfo;
-            }
-            if (channel.subscribe && channel.subscribe.protocolInfo) {
-                channel.subscribe.bindings = channel.subscribe.protocolInfo;
-                delete channel.subscribe.protocolInfo;
-            }
-        });
-    }
-    if (asyncapi.components && asyncapi.components.parameters) {
-        Object.values(asyncapi.components.parameters).forEach((parameter) => {
-            if (parameter.name)
-                delete parameter.name;
-        });
-    }
-    return asyncapi;
-}
-function from__2_0_0_rc2__to__2_0_0(asyncapi, _) {
-    asyncapi.asyncapi = '2.0.0';
-    return asyncapi;
-}
-function from__2_0_0__to__2_1_0(asyncapi, _) {
-    asyncapi.asyncapi = '2.1.0';
-    return asyncapi;
-}
-function from__2_1_0__to__2_2_0(asyncapi, _) {
-    asyncapi.asyncapi = '2.2.0';
-    return asyncapi;
-}
-function from__2_2_0__to__2_3_0(asyncapi, _) {
-    asyncapi.asyncapi = '2.3.0';
-    return asyncapi;
-}
-function from__2_3_0__to__2_4_0(asyncapi, _) {
-    asyncapi.asyncapi = '2.4.0';
-    return asyncapi;
-}
-function from__2_4_0__to__2_5_0(asyncapi, _) {
-    asyncapi.asyncapi = '2.5.0';
-    return asyncapi;
-}
-function from__2_5_0__to__2_6_0(asyncapi, _) {
-    asyncapi.asyncapi = '2.6.0';
-    return asyncapi;
-}

package/lib/first-version.d.ts

@@ -0,0 +1,2 @@
+import type { ConvertFunction } from './interfaces';
+export declare const converters: Record<string, ConvertFunction>;

package/lib/first-version.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.converters = void 0;
+exports.converters = {
+    '1.0.0': from__undefined__to__1_0_0,
+    '1.1.0': from__1_0_0__to__1_1_0,
+    '1.2.0': from__1_1_0__to__1_2_0,
+};
+function from__undefined__to__1_0_0(asyncapi, _) {
+    asyncapi.asyncapi = '1.0.0';
+    return asyncapi;
+}
+function from__1_0_0__to__1_1_0(asyncapi, _) {
+    asyncapi.asyncapi = '1.1.0';
+    return asyncapi;
+}
+function from__1_1_0__to__1_2_0(asyncapi, _) {
+    asyncapi.asyncapi = '1.2.0';
+    return asyncapi;
+}

package/lib/index.d.ts

@@ -1,2 +1,2 @@
 export { convert } from './convert';
-export type { ConvertVersion, ConvertOptions } from './interfaces';
+export type { AsyncAPIDocument, ConvertVersion, ConvertOptions } from './interfaces';

package/lib/interfaces.d.ts

@@ -1,6 +1,28 @@
+/**
+ * PUBLIC TYPES
+ */
 export declare type AsyncAPIDocument = {
     asyncapi: string;
 } & Record<string, any>;
-export declare type ConvertVersion = '1.1.0' | '1.2.0' | '2.0.0-rc1' | '2.0.0-rc2' | '2.0.0' | '2.1.0' | '2.2.0' | '2.3.0' | '2.4.0' | '2.5.0' | '2.6.0';
-export interface ConvertOptions {
-}
+export declare type ConvertVersion = '1.1.0' | '1.2.0' | '2.0.0-rc1' | '2.0.0-rc2' | '2.0.0' | '2.1.0' | '2.2.0' | '2.3.0' | '2.4.0' | '2.5.0' | '2.6.0' | '3.0.0';
+export declare type ConvertV2ToV3Options = {
+    idGenerator?: (data: {
+        asyncapi: AsyncAPIDocument;
+        kind: 'channel' | 'operation' | 'message';
+        key: string | number | undefined;
+        path: Array<string | number>;
+        object: any;
+        parentId?: string;
+    }) => string;
+    pointOfView?: 'application' | 'client';
+    useChannelIdExtension?: boolean;
+    convertServerComponents?: boolean;
+    convertChannelComponents?: boolean;
+};
+export declare type ConvertOptions = {
+    v2tov3?: ConvertV2ToV3Options;
+};
+/**
+ * PRIVATE TYPES
+ */
+export declare type ConvertFunction = (asyncapi: AsyncAPIDocument, options: ConvertOptions) => AsyncAPIDocument;

package/lib/second-version.d.ts

@@ -0,0 +1,2 @@
+import type { ConvertFunction } from './interfaces';
+export declare const converters: Record<string, ConvertFunction>;

package/lib/second-version.js

@@ -0,0 +1,217 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.converters = void 0;
+const utils_1 = require("./utils");
+exports.converters = {
+    '2.0.0-rc1': from__1_2_0__to__2_0_0_rc1,
+    '2.0.0-rc2': from__2_0_0_rc1__to__2_0_0_rc2,
+    '2.0.0': from__2_0_0_rc2__to__2_0_0,
+    '2.1.0': from__2_0_0__to__2_1_0,
+    '2.2.0': from__2_1_0__to__2_2_0,
+    '2.3.0': from__2_2_0__to__2_3_0,
+    '2.4.0': from__2_3_0__to__2_4_0,
+    '2.5.0': from__2_4_0__to__2_5_0,
+    '2.6.0': from__2_5_0__to__2_6_0,
+};
+function from__1_2_0__to__2_0_0_rc1(asyncapi, _) {
+    asyncapi.asyncapi = '2.0.0-rc1';
+    if (asyncapi.servers) {
+        const security = asyncapi.security;
+        asyncapi.servers = asyncapi.servers.map((server) => {
+            const { scheme, schemeVersion } = server, rest = __rest(server, ["scheme", "schemeVersion"]);
+            const out = Object.assign(Object.assign({}, rest), { protocol: scheme });
+            if (schemeVersion) {
+                out.protocolVersion = schemeVersion;
+            }
+            if (security) {
+                out.security = security;
+            }
+            return out;
+        });
+    }
+    if (asyncapi.topics) {
+        const baseTopic = asyncapi.baseTopic ? `${asyncapi.baseTopic}.` : "";
+        asyncapi.channels = Object.entries(asyncapi.topics).reduce((newChannels, [channelName, channel]) => {
+            if (channel.publish) {
+                channel.publish = { message: channel.publish };
+            }
+            if (channel.subscribe) {
+                channel.subscribe = { message: channel.subscribe };
+            }
+            channelName = (0, utils_1.dotsToSlashes)(`${baseTopic}${channelName}`);
+            newChannels[channelName] = channel;
+            return newChannels;
+        }, {});
+    }
+    else if (asyncapi.stream) {
+        asyncapi.channels = {
+            '/': streamToChannel(asyncapi.stream),
+        };
+    }
+    else if (asyncapi.events) {
+        asyncapi.channels = {
+            '/': eventToChannel(asyncapi.events),
+        };
+    }
+    delete asyncapi.topics;
+    delete asyncapi.stream;
+    delete asyncapi.events;
+    delete asyncapi.baseTopic;
+    delete asyncapi.security;
+    return asyncapi;
+}
+function from__2_0_0_rc1__to__2_0_0_rc2(asyncapi, _) {
+    asyncapi.asyncapi = '2.0.0-rc2';
+    if (asyncapi.servers) {
+        const serverMap = {};
+        asyncapi.servers.forEach((server, index) => {
+            if (server.baseChannel)
+                delete server.baseChannel;
+            const name = index === 0 ? 'default' : `server${index}`;
+            serverMap[name] = server;
+        });
+        asyncapi.servers = serverMap;
+    }
+    if (asyncapi.channels) {
+        Object.entries(asyncapi.channels).forEach(([channelName, channel]) => {
+            if (channel.parameters) {
+                const parametersMap = {};
+                const paramNames = channelName.match(/\{([^\}]{1,100})\}/g).map(p => p.substr(1, p.length - 2)); // NOSONAR
+                channel.parameters.forEach((parameter, index) => {
+                    const name = parameter.name || paramNames[index];
+                    if (parameter.name)
+                        delete parameter.name;
+                    parametersMap[name] = parameter;
+                });
+                channel.parameters = parametersMap;
+            }
+            if (channel.publish && channel.publish.message) {
+                const message = channel.publish.message;
+                convertMessage(message);
+            }
+            if (channel.subscribe && channel.subscribe.message) {
+                const message = channel.subscribe.message;
+                convertMessage(message);
+            }
+            if (channel.protocolInfo) {
+                channel.bindings = channel.protocolInfo;
+                delete channel.protocolInfo;
+            }
+            if (channel.publish && channel.publish.protocolInfo) {
+                channel.publish.bindings = channel.publish.protocolInfo;
+                delete channel.publish.protocolInfo;
+            }
+            if (channel.subscribe && channel.subscribe.protocolInfo) {
+                channel.subscribe.bindings = channel.subscribe.protocolInfo;
+                delete channel.subscribe.protocolInfo;
+            }
+        });
+    }
+    if (asyncapi.components && asyncapi.components.parameters) {
+        Object.values(asyncapi.components.parameters).forEach((parameter) => {
+            if (parameter.name)
+                delete parameter.name;
+        });
+    }
+    return asyncapi;
+}
+function from__2_0_0_rc2__to__2_0_0(asyncapi, _) {
+    asyncapi.asyncapi = '2.0.0';
+    return asyncapi;
+}
+function from__2_0_0__to__2_1_0(asyncapi, _) {
+    asyncapi.asyncapi = '2.1.0';
+    return asyncapi;
+}
+function from__2_1_0__to__2_2_0(asyncapi, _) {
+    asyncapi.asyncapi = '2.2.0';
+    return asyncapi;
+}
+function from__2_2_0__to__2_3_0(asyncapi, _) {
+    asyncapi.asyncapi = '2.3.0';
+    return asyncapi;
+}
+function from__2_3_0__to__2_4_0(asyncapi, _) {
+    asyncapi.asyncapi = '2.4.0';
+    return asyncapi;
+}
+function from__2_4_0__to__2_5_0(asyncapi, _) {
+    asyncapi.asyncapi = '2.5.0';
+    return asyncapi;
+}
+function from__2_5_0__to__2_6_0(asyncapi, _) {
+    asyncapi.asyncapi = '2.6.0';
+    return asyncapi;
+}
+function eventToChannel(event) {
+    const out = {};
+    if (event.receive) {
+        out.publish = {
+            message: {
+                oneOf: event.receive
+            }
+        };
+    }
+    if (event.send) {
+        out.subscribe = {
+            message: {
+                oneOf: event.send
+            }
+        };
+    }
+    return out;
+}
+function streamToChannel(stream) {
+    const out = {};
+    if (stream.read) {
+        out.publish = {
+            message: {
+                oneOf: stream.read
+            }
+        };
+    }
+    if (stream.write) {
+        out.subscribe = {
+            message: {
+                oneOf: stream.write
+            }
+        };
+    }
+    return out;
+}
+function convertMessage(message) {
+    if (message.oneOf) {
+        message.oneOf.forEach((m) => {
+            if (m.protocolInfo) {
+                m.bindings = m.protocolInfo;
+                delete m.protocolInfo;
+            }
+            if (m.headers) {
+                m.headers = objectToSchema(m.headers);
+            }
+        });
+    }
+    else {
+        if (message.protocolInfo) {
+            message.bindings = message.protocolInfo;
+            delete message.protocolInfo;
+        }
+        if (message.headers) {
+            message.headers = objectToSchema(message.headers);
+        }
+    }
+}
+function objectToSchema(obj) {
+    return { type: 'object', properties: Object.assign({}, obj) };
+}

package/lib/third-version.d.ts

@@ -0,0 +1,2 @@
+import type { ConvertFunction } from './interfaces';
+export declare const converters: Record<string, ConvertFunction>;

package/lib/third-version.js

@@ -0,0 +1,452 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.converters = void 0;
+const utils_1 = require("./utils");
+exports.converters = {
+    '3.0.0': from__2_6_0__to__3_0_0,
+};
+function from__2_6_0__to__3_0_0(asyncapi, options) {
+    var _a;
+    asyncapi.asyncapi = '3.0.0';
+    const v2tov3Options = Object.assign({ pointOfView: 'application', useChannelIdExtension: true, convertServerComponents: true, convertChannelComponents: true }, ((_a = options.v2tov3) !== null && _a !== void 0 ? _a : {}));
+    v2tov3Options.idGenerator = v2tov3Options.idGenerator || idGeneratorFactory(v2tov3Options);
+    const context = {
+        refs: new Map(),
+    };
+    convertInfoObject(asyncapi, context);
+    if ((0, utils_1.isPlainObject)(asyncapi.servers)) {
+        asyncapi.servers = convertServerObjects(asyncapi.servers, asyncapi);
+    }
+    if ((0, utils_1.isPlainObject)(asyncapi.channels)) {
+        asyncapi.channels = convertChannelObjects(asyncapi.channels, asyncapi, v2tov3Options, context);
+    }
+    convertComponents(asyncapi, v2tov3Options, context);
+    replaceDeepRefs(asyncapi, context.refs, '', asyncapi);
+    return (0, utils_1.sortObjectKeys)(asyncapi, ['asyncapi', 'id', 'info', 'defaultContentType', 'servers', 'channels', 'operations', 'components']);
+}
+/**
+ * Moving Tags and ExternalDocs to the Info Object.
+ */
+function convertInfoObject(asyncapi, context) {
+    if (asyncapi.tags) {
+        asyncapi.info.tags = asyncapi.tags;
+        context.refs.set((0, utils_1.createRefPath)('tags'), (0, utils_1.createRefPath)('info', 'tags'));
+        delete asyncapi.tags;
+    }
+    if (asyncapi.externalDocs) {
+        asyncapi.info.externalDocs = asyncapi.externalDocs;
+        context.refs.set((0, utils_1.createRefPath)('externalDocs'), (0, utils_1.createRefPath)('info', 'externalDocs'));
+        delete asyncapi.externalDocs;
+    }
+    asyncapi.info = (0, utils_1.sortObjectKeys)(asyncapi.info, ['title', 'version', 'description', 'termsOfService', 'contact', 'license', 'tags', 'externalDocs']);
+}
+/**
+ * Split `url` field to the `host` and `pathname` (optional) fields.
+ * Unify referencing mechanism in security field.
+ */
+function convertServerObjects(servers, asyncapi) {
+    const newServers = {};
+    Object.entries(servers).forEach(([serverName, server]) => {
+        if ((0, utils_1.isRefObject)(server)) {
+            newServers[serverName] = server;
+            return;
+        }
+        const { host, pathname, protocol } = resolveServerUrl(server.url);
+        server.host = host;
+        if (pathname !== undefined) {
+            server.pathname = pathname;
+        }
+        // Dont overwrite anything
+        if (protocol !== undefined && server.protocol === undefined) {
+            server.protocol = protocol;
+        }
+        delete server.url;
+        if (server.security) {
+            server.security = convertSecurityObject(server.security, asyncapi);
+        }
+        newServers[serverName] = (0, utils_1.sortObjectKeys)(server, ['host', 'pathname', 'protocol', 'protocolVersion', 'title', 'summary', 'description', 'variables', 'security', 'tags', 'externalDocs', 'bindings']);
+    });
+    return newServers;
+}
+/**
+ * Convert operation part of channels into standalone operations
+ */
+function toStandaloneOperation(data) {
+    const { kind, channel, asyncapi, operations, context, inComponents, channelId, channelAddress, options, oldPath } = data;
+    let operation = channel[kind];
+    const operationPath = inComponents ? ['components', 'operations'] : ['operations'];
+    if ((0, utils_1.isPlainObject)(operation)) {
+        const { operationId, operation: newOperation, messages } = convertOperationObject({ asyncapi, kind, channel, channelId, oldChannelId: channelAddress, operation, inComponents }, options, context);
+        if (operation.security) {
+            newOperation.security = convertSecurityObject(operation.security, asyncapi);
+        }
+        operationPath.push(operationId);
+        context.refs.set((0, utils_1.createRefPath)(...oldPath, kind), (0, utils_1.createRefPath)(...operationPath));
+        operations[operationId] = newOperation;
+        delete channel[kind];
+        return messages !== null && messages !== void 0 ? messages : {};
+    }
+    return {};
+}
+/**
+ * Split Channel Objects to the Channel Objects and Operation Objects.
+ */
+function convertChannelObjects(channels, asyncapi, options, context, inComponents = false) {
+    const newChannels = {};
+    Object.entries(channels).forEach(([channelAddress, channel]) => {
+        const oldPath = inComponents ? ['components', 'channels', channelAddress] : ['channels', channelAddress];
+        const channelId = options.idGenerator({ asyncapi, kind: 'channel', key: channelAddress, path: oldPath, object: channel });
+        const newPath = inComponents ? ['components', 'channels', channelId] : ['channels', channelId];
+        context.refs.set((0, utils_1.createRefPath)(...oldPath), (0, utils_1.createRefPath)(...newPath));
+        if ((0, utils_1.isRefObject)(channel)) {
+            newChannels[channelId] = channel;
+            return;
+        }
+        // assign address
+        channel.address = channelAddress;
+        // change the Server names to the Refs
+        const servers = channel.servers;
+        if (Array.isArray(servers)) {
+            channel.servers = servers.map((serverName) => (0, utils_1.createRefObject)('servers', serverName));
+        }
+        const operations = {};
+        // serialize publish and subscribe Operation Objects to standalone object
+        const publishMessages = toStandaloneOperation({ kind: 'publish', channel, asyncapi, operations, context, inComponents, channelId, channelAddress, options, oldPath });
+        const subscribeMessages = toStandaloneOperation({ kind: 'subscribe', channel, asyncapi, operations, context, inComponents, channelId, channelAddress, options, oldPath });
+        if (publishMessages || subscribeMessages) {
+            const allOperationMessages = Object.assign(Object.assign({}, publishMessages), subscribeMessages);
+            channel.messages = convertMessages({
+                messages: allOperationMessages
+            });
+        }
+        setOperationsOnRoot({ operations, inComponents, asyncapi, oldPath });
+        newChannels[channelId] = (0, utils_1.sortObjectKeys)(channel, ['address', 'messages', 'title', 'summary', 'description', 'servers', 'parameters', 'tags', 'externalDocs', 'bindings']);
+    });
+    return newChannels;
+}
+/**
+ * Assign the operations to the root AsyncAPI object.
+ */
+function setOperationsOnRoot(data) {
+    var _a, _b, _c, _d, _e;
+    const { operations, inComponents, asyncapi, oldPath } = data;
+    if (Object.keys(operations)) {
+        if (inComponents) {
+            const components = asyncapi.components = (_a = asyncapi.components) !== null && _a !== void 0 ? _a : {};
+            components.operations = Object.assign(Object.assign({}, (_b = components.operations) !== null && _b !== void 0 ? _b : {}), operations);
+            // if given component is used in the `channels` object then create references for operations in the `operations` object
+            if (channelIsUsed((_c = asyncapi.channels) !== null && _c !== void 0 ? _c : {}, oldPath)) {
+                const referencedOperations = Object.keys(operations).reduce((acc, current) => {
+                    acc[current] = (0, utils_1.createRefObject)('components', 'operations', current);
+                    return acc;
+                }, {});
+                asyncapi.operations = Object.assign(Object.assign({}, (_d = asyncapi.operations) !== null && _d !== void 0 ? _d : {}), referencedOperations);
+            }
+        }
+        else {
+            asyncapi.operations = Object.assign(Object.assign({}, (_e = asyncapi.operations) !== null && _e !== void 0 ? _e : {}), operations);
+        }
+    }
+}
+/**
+ * Points to the connected channel and split messages for channel
+ */
+function convertOperationObject(data, options, context) {
+    const { asyncapi, channelId, oldChannelId, kind, inComponents } = data;
+    const operation = Object.assign({}, data.operation);
+    const oldChannelPath = ['channels', oldChannelId];
+    if (inComponents) {
+        oldChannelPath.unshift('components');
+    }
+    const newChannelPath = ['channels', channelId];
+    if (inComponents) {
+        newChannelPath.unshift('components');
+    }
+    const operationId = options.idGenerator({ asyncapi, kind: 'operation', key: kind, path: oldChannelPath, object: data.operation, parentId: channelId });
+    operation.channel = (0, utils_1.createRefObject)(...newChannelPath);
+    try {
+        delete operation.operationId;
+    }
+    catch (err) { }
+    const isPublish = kind === 'publish';
+    if (options.pointOfView === 'application') {
+        operation.action = isPublish ? 'receive' : 'send';
+    }
+    else {
+        operation.action = isPublish ? 'send' : 'receive';
+    }
+    const message = operation.message;
+    let serializedMessages = {};
+    if (message) {
+        delete operation.message;
+        const oldMessagePath = ['channels', oldChannelId, kind, 'message'];
+        const newMessagePath = ['channels', channelId, 'messages'];
+        if (inComponents) {
+            oldMessagePath.unshift('components');
+            newMessagePath.unshift('components');
+        }
+        serializedMessages = moveMessagesFromOperation(message, newMessagePath, oldMessagePath, asyncapi, options, context, operationId);
+        applyMessageRefsToOperation(serializedMessages, newMessagePath, operation);
+    }
+    const sortedOperation = (0, utils_1.sortObjectKeys)(operation, ['action', 'channel', 'title', 'summary', 'description', 'security', 'tags', 'externalDocs', 'bindings', 'traits']);
+    return { operationId, operation: sortedOperation, messages: serializedMessages };
+}
+/**
+ * Remove all messages under operations and return an object of them.
+ */
+function moveMessagesFromOperation(message, newMessagePath, oldMessagePath, asyncapi, options, context, operationId) {
+    if (Array.isArray(message.oneOf)) {
+        //Message oneOf no longer exists, it's implicit by having multiple entires in the message object.
+        return message.oneOf.reduce((acc, current, index) => {
+            const messagePath = [...oldMessagePath, 'oneOf', index];
+            const messageId = options.idGenerator({ asyncapi, kind: 'message', key: index, path: messagePath, object: current, parentId: operationId });
+            context.refs.set((0, utils_1.createRefPath)(...messagePath), (0, utils_1.createRefPath)(...newMessagePath, messageId));
+            acc[messageId] = current;
+            return acc;
+        }, {});
+    }
+    else {
+        const messageId = options.idGenerator({ asyncapi, kind: 'message', key: 'message', path: oldMessagePath, object: message, parentId: operationId });
+        context.refs.set((0, utils_1.createRefPath)(...oldMessagePath), (0, utils_1.createRefPath)(...newMessagePath, messageId));
+        return { [messageId]: message };
+    }
+}
+/**
+ * Add references of messages to operations.
+ */
+function applyMessageRefsToOperation(serializedMessages, newMessagePath, operation) {
+    if (Object.keys(serializedMessages !== null && serializedMessages !== void 0 ? serializedMessages : {}).length > 0) {
+        const newOperationMessages = [];
+        Object.entries(serializedMessages).forEach(([messageId, messageValue]) => {
+            if ((0, utils_1.isRefObject)(messageValue)) {
+                // shallow copy of JS reference
+                newOperationMessages.push(Object.assign({}, messageValue));
+            }
+            else {
+                const messagePath = [...newMessagePath, messageId];
+                newOperationMessages.push((0, utils_1.createRefObject)(...messagePath));
+            }
+        });
+        operation.messages = newOperationMessages;
+    }
+}
+/**
+ * Convert messages that use custom schema format into schema union.
+ */
+function convertMessages(data) {
+    const messages = Object.assign({}, data.messages);
+    // Convert schema formats to union schemas
+    Object.entries(messages).forEach(([_, message]) => {
+        if (message.schemaFormat !== undefined) {
+            const payloadSchema = message.payload;
+            message.payload = {
+                schemaFormat: message.schemaFormat,
+                schema: payloadSchema
+            };
+            delete message.schemaFormat;
+        }
+    });
+    return messages;
+}
+/**
+ * Convert `channels`, `servers` and `securitySchemes` in components.
+ */
+function convertComponents(asyncapi, options, context) {
+    const components = asyncapi.components;
+    if (!(0, utils_1.isPlainObject)(components)) {
+        return;
+    }
+    if (options.convertServerComponents && (0, utils_1.isPlainObject)(components.servers)) {
+        components.servers = convertServerObjects(components.servers, asyncapi);
+    }
+    if (options.convertChannelComponents && (0, utils_1.isPlainObject)(components.channels)) {
+        components.channels = convertChannelObjects(components.channels, asyncapi, options, context, true);
+    }
+    if ((0, utils_1.isPlainObject)(components.securitySchemes)) {
+        components.securitySchemes = convertSecuritySchemes(components.securitySchemes);
+    }
+    if ((0, utils_1.isPlainObject)(components.messages)) {
+        components.messages = convertMessages({
+            messages: components.messages
+        });
+    }
+}
+/**
+ * Convert `channels`, `servers` and `securitySchemes` in components.
+ */
+function convertSecuritySchemes(securitySchemes) {
+    const newSecuritySchemes = {};
+    Object.entries(securitySchemes).forEach(([name, scheme]) => {
+        newSecuritySchemes[name] = convertSecuritySchemeObject(scheme);
+    });
+    return newSecuritySchemes;
+}
+/**
+ * Unify referencing mechanism in security field
+ */
+function convertSecurityObject(security, asyncapi) {
+    const newSecurity = [];
+    security.forEach(securityItem => {
+        Object.entries(securityItem).forEach(([securityName, scopes]) => {
+            // without scopes - use ref
+            if (!scopes.length) {
+                newSecurity.push((0, utils_1.createRefObject)('components', 'securitySchemes', securityName));
+                return;
+            }
+            // create new security scheme in the components/securitySchemes with appropriate scopes
+            const securityScheme = (0, utils_1.getValueByPath)(asyncapi, ['components', 'securitySchemes', securityName]);
+            // handle logic only on `oauth2` and `openIdConnect` security mechanism
+            if (securityScheme.type === 'oauth2' || securityScheme.type === 'openIdConnect') {
+                const newSecurityScheme = convertSecuritySchemeObject(securityScheme);
+                newSecurity.push(Object.assign(Object.assign({}, newSecurityScheme), { scopes: [...scopes] }));
+            }
+        });
+    });
+    return newSecurity;
+}
+const flowKinds = ['implicit', 'password', 'clientCredentials', 'authorizationCode'];
+/**
+ * Convert security scheme object to new from v3 version (flow.[x].scopes -> flow.[x].availableScopes).
+ */
+function convertSecuritySchemeObject(original) {
+    const securityScheme = JSON.parse(JSON.stringify(original));
+    if (securityScheme.flows) {
+        flowKinds.forEach(flow => {
+            const flowScheme = securityScheme.flows[flow];
+            if (flowScheme === null || flowScheme === void 0 ? void 0 : flowScheme.scopes) {
+                flowScheme.availableScopes = flowScheme.scopes;
+                delete flowScheme.scopes;
+            }
+        });
+    }
+    return securityScheme;
+}
+/**
+ * Split `url` to the `host` and `pathname` (optional) fields.
+ *
+ * This function takes care of https://github.com/asyncapi/spec/pull/888
+ */
+function resolveServerUrl(url) {
+    let [maybeProtocol, maybeHost] = url.split('://');
+    if (!maybeHost) {
+        maybeHost = maybeProtocol;
+    }
+    const [host, ...pathnames] = maybeHost.split('/');
+    if (pathnames.length) {
+        return { host, pathname: `/${pathnames.join('/')}`, protocol: maybeProtocol };
+    }
+    return { host, pathname: undefined, protocol: maybeProtocol };
+}
+/**
+ * Check if given channel (based on path) is used in the `channels` object.
+ */
+function channelIsUsed(channels, path) {
+    for (const channel of Object.values(channels)) {
+        if ((0, utils_1.isRefObject)(channel) && (0, utils_1.createRefPath)(...path) === channel.$ref) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Replace all deep local references with the new beginning of ref (when object is moved to another place).
+ */
+function replaceDeepRefs(value, refs, key, parent) {
+    if (key === '$ref' && typeof value === 'string') {
+        const newRef = replaceRef(value, refs);
+        if (typeof newRef === 'string') {
+            parent[key] = newRef;
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        return value.forEach((item, idx) => replaceDeepRefs(item, refs, idx, value));
+    }
+    if (value && typeof value === 'object') {
+        for (const objKey in value) {
+            replaceDeepRefs(value[objKey], refs, objKey, value);
+        }
+    }
+}
+function replaceRef(ref, refs) {
+    const allowed = [];
+    refs.forEach((_, key) => {
+        // few refs can be allowed
+        if (ref.startsWith(key)) {
+            allowed.push(key);
+        }
+    });
+    // find the longest one
+    allowed.sort((a, b) => a.length - b.length);
+    const from = allowed.pop();
+    if (!from) {
+        return;
+    }
+    const toReplace = refs.get(from);
+    if (toReplace) {
+        return ref.replace(from, toReplace);
+    }
+}
+/**
+ * Default function to generate ids for objects.
+ */
+function idGeneratorFactory(options) {
+    const useChannelIdExtension = options.useChannelIdExtension;
+    return (data) => {
+        const { asyncapi, kind, object, key, parentId } = data;
+        switch (kind) {
+            case 'channel':
+                return generateIdForChannel(object, key, useChannelIdExtension);
+            case 'operation':
+                {
+                    const oldOperationId = object.operationId;
+                    const operationId = oldOperationId || (parentId ? `${parentId}.${key}` : kind);
+                    return operationId;
+                }
+                ;
+            case 'message':
+                return generateIdForMessage(object, asyncapi, parentId, key);
+            default: return '';
+        }
+    };
+}
+function generateIdForChannel(object, key, useChannelIdExtension) {
+    if ((0, utils_1.isRefObject)(object)) {
+        const id = key;
+        return id;
+    }
+    const channel = object;
+    let channelId;
+    if (useChannelIdExtension) {
+        channelId = channel['x-channelId'] || key;
+    }
+    else {
+        channelId = key;
+    }
+    return channelId;
+}
+function generateIdForMessage(object, asyncapi, parentId, key) {
+    if ((0, utils_1.isRefObject)(object)) {
+        const possibleMessage = (0, utils_1.getValueByRef)(asyncapi, object.$ref);
+        if (possibleMessage === null || possibleMessage === void 0 ? void 0 : possibleMessage.messageId) {
+            const messageId = possibleMessage.messageId;
+            return messageId;
+        }
+    }
+    const messageId = object.messageId;
+    if (messageId) {
+        return messageId;
+    }
+    let operationKind;
+    const splitParentId = parentId.split('.');
+    if (splitParentId.length === 1) {
+        operationKind = parentId;
+    }
+    else {
+        operationKind = splitParentId.pop();
+    }
+    if (typeof key === 'number') {
+        return `${operationKind}.message.${key}`;
+    }
+    return `${operationKind}.message`;
+}

package/lib/utils.d.ts

@@ -3,14 +3,6 @@ export declare function serializeInput(document: string | AsyncAPIDocument): {
     format: 'json' | 'yaml';
     document: AsyncAPIDocument;
 } | never;
-export declare function eventToChannel(event: any): {
-    publish: any;
-    subscribe: any;
-};
-export declare function streamToChannel(stream: any): {
-    publish: any;
-    subscribe: any;
-};
 export declare function objectToSchema(obj: Record<string, unknown>): {
     type: string;
     properties: {
@@ -18,4 +10,12 @@ export declare function objectToSchema(obj: Record<string, unknown>): {
     };
 };
 export declare function dotsToSlashes(topic: string): string;
-export declare function convertMessage(message: any): void;
+export declare function isPlainObject(value: unknown): boolean;
+export declare function createRefObject(...paths: Array<string | number>): {
+    $ref: string;
+};
+export declare function createRefPath(...paths: Array<string | number>): string;
+export declare function isRefObject(value: unknown): boolean;
+export declare function getValueByRef(root: any, ref: string): any;
+export declare function getValueByPath(value: any, path: string[]): any;
+export declare function sortObjectKeys(obj: any, keys: string[]): any;

package/lib/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertMessage = exports.dotsToSlashes = exports.objectToSchema = exports.streamToChannel = exports.eventToChannel = exports.serializeInput = void 0;
+exports.sortObjectKeys = exports.getValueByPath = exports.getValueByRef = exports.isRefObject = exports.createRefPath = exports.createRefObject = exports.isPlainObject = exports.dotsToSlashes = exports.objectToSchema = exports.serializeInput = void 0;
 const js_yaml_1 = require("js-yaml");
 function serializeInput(document) {
     let triedConvertToYaml = false;
@@ -43,44 +43,6 @@ function serializeInput(document) {
     }
 }
 exports.serializeInput = serializeInput;
-function eventToChannel(event) {
-    const out = {};
-    if (event.receive) {
-        out.publish = {
-            message: {
-                oneOf: event.receive
-            }
-        };
-    }
-    if (event.send) {
-        out.subscribe = {
-            message: {
-                oneOf: event.send
-            }
-        };
-    }
-    return out;
-}
-exports.eventToChannel = eventToChannel;
-function streamToChannel(stream) {
-    const out = {};
-    if (stream.read) {
-        out.publish = {
-            message: {
-                oneOf: stream.read
-            }
-        };
-    }
-    if (stream.write) {
-        out.subscribe = {
-            message: {
-                oneOf: stream.write
-            }
-        };
-    }
-    return out;
-}
-exports.streamToChannel = streamToChannel;
 function objectToSchema(obj) {
     return { type: 'object', properties: Object.assign({}, obj) };
 }
@@ -89,26 +51,76 @@ function dotsToSlashes(topic) {
     return topic.replace(/\./g, '/');
 }
 exports.dotsToSlashes = dotsToSlashes;
-function convertMessage(message) {
-    if (message.oneOf) {
-        message.oneOf.forEach((m) => {
-            if (m.protocolInfo) {
-                m.bindings = m.protocolInfo;
-                delete m.protocolInfo;
-            }
-            if (m.headers) {
-                m.headers = objectToSchema(m.headers);
-            }
-        });
+function isPlainObject(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+exports.isPlainObject = isPlainObject;
+function createRefObject(...paths) {
+    return {
+        $ref: createRefPath(...paths),
+    };
+}
+exports.createRefObject = createRefObject;
+function createRefPath(...paths) {
+    return `#/${paths.map(String).map(tilde).join('/')}`;
+}
+exports.createRefPath = createRefPath;
+function isRefObject(value) {
+    return Boolean(value && '$ref' in value);
+}
+exports.isRefObject = isRefObject;
+function getValueByRef(root, ref) {
+    if (!ref.startsWith('#')) {
+        return;
+    }
+    // remove `#/` at start, split string by `/` and untilde (change ~1 to / etc)
+    const path = ref.substring(2).split('/').map(untilde);
+    return getValueByPath(root, path);
+}
+exports.getValueByRef = getValueByRef;
+function getValueByPath(value, path) {
+    let index = 0;
+    const length = path.length;
+    while (value != null && index < length) {
+        value = value[path[index++]];
     }
-    else {
-        if (message.protocolInfo) {
-            message.bindings = message.protocolInfo;
-            delete message.protocolInfo;
+    return index == length ? value : undefined;
+}
+exports.getValueByPath = getValueByPath;
+function sortObjectKeys(obj, keys) {
+    const newObject = {};
+    // add sorted keys
+    keys.forEach(key => {
+        if (key in obj) {
+            newObject[key] = obj[key];
         }
-        if (message.headers) {
-            message.headers = objectToSchema(message.headers);
+    });
+    // add rest of keys
+    Object.keys(obj).forEach(key => {
+        if (!keys.includes(key)) {
+            newObject[key] = obj[key];
         }
-    }
+    });
+    return newObject;
+}
+exports.sortObjectKeys = sortObjectKeys;
+function tilde(str) {
+    return str.replace(/[~/]{1}/g, (sub) => {
+        switch (sub) {
+            case '/': return '~1';
+            case '~': return '~0';
+        }
+        return sub;
+    });
+}
+function untilde(str) {
+    if (!str.includes('~'))
+        return str;
+    return str.replace(/~[01]/g, (sub) => {
+        switch (sub) {
+            case '~1': return '/';
+            case '~0': return '~';
+        }
+        return sub;
+    });
 }
-exports.convertMessage = convertMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@asyncapi/converter",
-	"version": "1.2.0",
+	"version": "1.3.0",
 	"description": "Convert AsyncAPI documents from older to newer versions.",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
@@ -8,7 +8,6 @@
 		"build": "tsc",
 		"test": "cross-env CI=true NODE_ENV=test jest --coverage",
 		"lint": "echo 'no linter configured yet'",
-		"release": "semantic-release",
 		"generate:assets": "npm run generate:readme:toc",
 		"generate:readme:toc": "markdown-toc -i README.md",
 		"bump:version": "npm --no-git-tag-version --allow-same-version version $VERSION",
@@ -39,44 +38,19 @@
 	"author": "Fran Mendez <fmvilas@gmail.com> (fmvilas.com)",
 	"license": "Apache-2.0",
 	"dependencies": {
+		"@asyncapi/parser": "^2.0.0-next-major.11",
 		"js-yaml": "^3.14.1"
 	},
 	"devDependencies": {
 		"@jest/types": "^27.5.1",
-		"@semantic-release/commit-analyzer": "^9.0.2",
-		"@semantic-release/github": "^8.0.2",
-		"@semantic-release/npm": "^8.0.3",
-		"@semantic-release/release-notes-generator": "^10.0.3",
 		"@types/jest": "^27.4.1",
 		"@types/js-yaml": "^4.0.5",
-		"conventional-changelog-conventionalcommits": "^4.6.3",
+		"conventional-changelog-conventionalcommits": "^5.0.0",
 		"cross-env": "^7.0.3",
 		"jest": "^27.5.1",
-		"semantic-release": "^19.0.3",
+		"markdown-toc": "^1.2.0",
 		"ts-jest": "^27.1.3",
 		"ts-node": "^10.7.0",
-		"typescript": "^4.6.2",
-		"markdown-toc": "^1.2.0"
-	},
-	"release": {
-		"branches": [
-			"master"
-		],
-		"plugins": [
-			[
-				"@semantic-release/commit-analyzer",
-				{
-					"preset": "conventionalcommits"
-				}
-			],
-			[
-				"@semantic-release/release-notes-generator",
-				{
-					"preset": "conventionalcommits"
-				}
-			],
-			"@semantic-release/npm",
-			"@semantic-release/github"
-		]
+		"typescript": "^4.6.2"
 	}
 }