@asyncapi/converter 1.2.1 → 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)
@@ -91,6 +92,75 @@ try {
 }
 ```
 
+## 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

@@ -4,11 +4,12 @@ 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 converters = Object.assign(Object.assign({}, first_version_1.converters), second_version_1.converters);
+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);

package/lib/interfaces.d.ts

@@ -4,8 +4,24 @@
 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 declare type 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
  */

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@asyncapi/converter",
-	"version": "1.2.1",
+	"version": "1.3.0",
 	"description": "Convert AsyncAPI documents from older to newer versions.",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",