@asyncapi/converter 1.4.21 → 1.5.0

package/README.md

@@ -1,6 +1,6 @@
 # AsyncAPI Converter
 
-Convert [AsyncAPI](https://asyncapi.com) documents older to newer versions.
+Convert [AsyncAPI](https://asyncapi.com) documents older to newer versions and you can also convert OpenAPI documents to AsyncAPI documents.
 
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
 [![All Contributors](https://img.shields.io/badge/all_contributors-8-orange.svg?style=flat-square)](#contributors-)
@@ -17,6 +17,7 @@ Convert [AsyncAPI](https://asyncapi.com) documents older to newer versions.
   * [In TS](#in-ts)
 - [Conversion 2.x.x to 3.x.x](#conversion-2xx-to-3xx)
 - [Known missing features](#known-missing-features)
+- [OpenAPI 3.0 to AsyncAPI 3.0 Conversion](#openapi-30-to-asyncapi-30-conversion)
 - [Development](#development)
 - [Contribution](#contribution)
 - [Contributors ✨](#contributors-%E2%9C%A8)
@@ -194,6 +195,49 @@ Conversion to version `3.x.x` from `2.x.x` has several assumptions that should b
         examples: ["test"]
   ```
 
+### OpenAPI 3.0 to AsyncAPI 3.0 Conversion
+
+The converter now supports transformation from OpenAPI 3.0 to AsyncAPI 3.0. This feature enables easy transition of existing OpenAPI 3.0 documents to AsyncAPI 3.0.
+
+To use this new conversion feature:
+
+```js
+const fs = require('fs');
+const { convert } = require('@asyncapi/converter')
+
+try {
+  const openapi = fs.readFileSync('openapi.yml', 'utf-8')
+  const asyncapi = convert(openapi, '3.0.0', { from: 'openapi' });
+  console.log(asyncapi);
+} catch (e) {
+  console.error(e);
+}
+```
+
+When converting from OpenAPI to AsyncAPI you can now specify the perspective of the conversion using the `perspective` option. This allows you to choose whether the conversion should be from an application or client point of view
+
+```js
+const { convert } = require('@asyncapi/converter')
+
+try {
+  const asyncapi2 = fs.readFileSync('asyncapi2.yml', 'utf-8')
+  const asyncapi3 = convert(asyncapi2, '3.0.0', { openAPIToAsyncAPI: { perspective: 'client' } });
+  console.log(asyncapi3);
+} catch (e) {
+  console.error(e);
+}
+```
+
+The perspective option can be set to either 'server' (default) or 'client'. 
+
+- With `server` perspective: `action` becomes `receive`
+
+- With `client` perspective: `action` becomes `send`
+
+#### Limitations
+
+- External to internal references: The converter does not support scenarios where an external schema file references internal components of the OpenAPI document. In such cases, manual adjustment of the converted document may be necessary.
+
 ## Development
 
 1. Setup project by installing dependencies `npm install`

package/lib/convert.d.ts

@@ -1,3 +1,5 @@
-import type { AsyncAPIDocument, ConvertVersion, ConvertOptions } from './interfaces';
-export declare function convert(asyncapi: string, version?: ConvertVersion, options?: ConvertOptions): string;
-export declare function convert(asyncapi: AsyncAPIDocument, version?: ConvertVersion, options?: ConvertOptions): AsyncAPIDocument;
+import type { AsyncAPIDocument, AsyncAPIConvertVersion, OpenAPIConvertVersion, ConvertOptions, OpenAPIDocument, OpenAPIToAsyncAPIOptions } from './interfaces';
+export declare function convert(input: string, version: AsyncAPIConvertVersion, options?: ConvertOptions): string;
+export declare function convert(input: AsyncAPIDocument, version: AsyncAPIConvertVersion, options?: ConvertOptions): AsyncAPIDocument;
+export declare function convertOpenAPI(input: string, version: OpenAPIConvertVersion, options?: OpenAPIToAsyncAPIOptions): string;
+export declare function convertOpenAPI(input: OpenAPIDocument, version: OpenAPIConvertVersion, options?: OpenAPIToAsyncAPIOptions): AsyncAPIDocument;

package/lib/convert.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convert = void 0;
+exports.convertOpenAPI = 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 openapi_1 = require("./openapi");
 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(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 asyncAPIconverters = Object.assign(Object.assign(Object.assign({}, first_version_1.converters), second_version_1.converters), third_version_1.converters);
+const conversionVersions = Object.keys(asyncAPIconverters);
+function convert(input, version, options = {}) {
+    const { format, document } = (0, utils_1.serializeInput)(input);
+    if ('openapi' in document) {
+        throw new Error('Cannot convert OpenAPI document. Use convertOpenAPI function instead.');
+    }
     const asyncapiVersion = document.asyncapi;
     let fromVersion = conversionVersions.indexOf(asyncapiVersion);
     const toVersion = conversionVersions.indexOf(version);
@@ -30,7 +34,7 @@ function convert(asyncapi, version = '2.6.0', options = {}) {
     let converted = document;
     for (let i = fromVersion; i <= toVersion; i++) {
         const v = conversionVersions[i];
-        converted = converters[v](converted, options);
+        converted = asyncAPIconverters[v](converted, options);
     }
     if (format === 'yaml') {
         return (0, js_yaml_1.dump)(converted, { skipInvalid: true });
@@ -38,3 +42,18 @@ function convert(asyncapi, version = '2.6.0', options = {}) {
     return converted;
 }
 exports.convert = convert;
+function convertOpenAPI(input, version, options = {}) {
+    const { format, document } = (0, utils_1.serializeInput)(input);
+    const openApiVersion = document.openapi;
+    const converterVersion = openApiVersion;
+    const openapiToAsyncapiConverter = openapi_1.converters[converterVersion];
+    if (!openapiToAsyncapiConverter) {
+        throw new Error(`We are not able to convert OpenAPI ${converterVersion} to AsyncAPI, please raise a feature request.`);
+    }
+    const convertedAsyncAPI = openapiToAsyncapiConverter(document, options);
+    if (format === "yaml") {
+        return (0, js_yaml_1.dump)(convertedAsyncAPI, { skipInvalid: true });
+    }
+    return convertedAsyncAPI;
+}
+exports.convertOpenAPI = convertOpenAPI;

package/lib/index.d.ts

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

package/lib/interfaces.d.ts

@@ -4,7 +4,11 @@
 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' | '3.0.0';
+export declare type OpenAPIDocument = {
+    openapi: string;
+} & Record<string, any>;
+export declare type AsyncAPIConvertVersion = '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 OpenAPIConvertVersion = '3.0.0';
 export declare type ConvertV2ToV3Options = {
     idGenerator?: (data: {
         asyncapi: AsyncAPIDocument;
@@ -19,10 +23,15 @@ export declare type ConvertV2ToV3Options = {
     convertServerComponents?: boolean;
     convertChannelComponents?: boolean;
 };
+export declare type OpenAPIToAsyncAPIOptions = {
+    perspective?: 'client' | 'server';
+};
 export declare type ConvertOptions = {
     v2tov3?: ConvertV2ToV3Options;
+    openAPIToAsyncAPI?: OpenAPIToAsyncAPIOptions;
 };
 /**
  * PRIVATE TYPES
  */
 export declare type ConvertFunction = (asyncapi: AsyncAPIDocument, options: ConvertOptions) => AsyncAPIDocument;
+export declare type ConvertOpenAPIFunction = (openapi: OpenAPIDocument, options: OpenAPIToAsyncAPIOptions) => AsyncAPIDocument;

package/lib/openapi.d.ts

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

package/lib/openapi.js

@@ -0,0 +1,527 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.converters = void 0;
+const utils_1 = require("./utils");
+exports.converters = {
+    '3.0.0': from_openapi_to_asyncapi,
+};
+/**
+ * Converts an OpenAPI document to an AsyncAPI document.
+ * @param {OpenAPIDocument} openapi - The OpenAPI document to convert.
+ * @param {ConvertOptions} options - Conversion options.
+ * @returns {AsyncAPIDocument} The converted AsyncAPI document.
+ */
+function from_openapi_to_asyncapi(openapi, options = {}) {
+    const perspective = options.perspective || 'server';
+    const asyncapi = {
+        asyncapi: '3.0.0',
+        info: convertInfoObject(openapi.info, openapi),
+        servers: openapi.servers ? convertServerObjects(openapi.servers, openapi) : undefined,
+        channels: {},
+        operations: {},
+        components: convertComponents(openapi)
+    };
+    const { channels, operations } = convertPaths(openapi.paths, perspective);
+    asyncapi.channels = channels;
+    asyncapi.operations = operations;
+    (0, utils_1.removeEmptyObjects)(asyncapi);
+    return (0, utils_1.sortObjectKeys)(asyncapi, ['asyncapi', 'info', 'defaultContentType', 'servers', 'channels', 'operations', 'components']);
+}
+/**
+ * Converts openAPI info objects to asyncAPI info objects.
+ * @param info - The openAPI info object to convert.
+ * @param openapi - The complete openAPI document.
+ * @returns openAPI info object
+ */
+function convertInfoObject(info, openapi) {
+    return (0, utils_1.sortObjectKeys)(Object.assign(Object.assign({}, info), { tags: [openapi.tags], externalDocs: openapi.externalDocs }), [
+        "title",
+        "version",
+        "description",
+        "termsOfService",
+        "contact",
+        "license",
+        "tags",
+        "externalDocs",
+    ]);
+}
+/**
+ * Converts OpenAPI server objects to AsyncAPI server objects.
+ * @param {ServerObject[]} servers - The OpenAPI server objects to convert.
+ * @param {OpenAPIDocument} openapi - The complete OpenAPI document.
+ * @returns {AsyncAPIDocument['servers']} The converted AsyncAPI server objects.
+ */
+function convertServerObjects(servers, openapi) {
+    const newServers = {};
+    const security = openapi.security;
+    servers.forEach((server) => {
+        const serverName = generateServerName(server.url);
+        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;
+        }
+        if (protocol !== undefined && server.protocol === undefined) {
+            server.protocol = protocol;
+        }
+        delete server.url;
+        if (security) {
+            server.security = security.map((securityRequirement) => {
+                // pass through the security requirement, conversion will happen in components
+                return securityRequirement;
+            });
+            delete openapi.security;
+        }
+        newServers[serverName] = (0, utils_1.sortObjectKeys)(server, ['host', 'pathname', 'protocol', 'protocolVersion', 'title', 'summary', 'description', 'variables', 'security', 'tags', 'externalDocs', 'bindings']);
+    });
+    return newServers;
+}
+/**
+ * Generates a server name based on the server URL.
+ * @param {string} url - The server URL.
+ * @returns {string} The generated server name.
+ */
+function generateServerName(url) {
+    const { host, pathname } = resolveServerUrl(url);
+    const baseName = host.split('.').slice(-2).join('.');
+    const pathSegment = pathname ? pathname.split('/')[1] : '';
+    return `${baseName}${pathSegment ? `_${pathSegment}` : ''}`.replace(/[^a-zA-Z0-9_]/g, '_');
+}
+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 };
+}
+/**
+ * Converts OpenAPI paths to AsyncAPI channels and operations.
+ * @param {Record<string, any>} paths - The OpenAPI paths object.
+ * @param {'client' | 'server'} perspective - The perspective of the conversion (client or server).
+ * @returns {{ channels: AsyncAPIDocument['channels'], operations: AsyncAPIDocument['operations'] }}
+ */
+function convertPaths(paths, perspective) {
+    var _a;
+    const channels = {};
+    const operations = {};
+    if (paths) {
+        for (const [path, pathItemOrRef] of Object.entries(paths)) {
+            if (!(0, utils_1.isPlainObject)(pathItemOrRef))
+                continue;
+            const pathItem = (0, utils_1.isRefObject)(pathItemOrRef) ? pathItemOrRef : pathItemOrRef;
+            const channelName = path.replace(/^\//, '').replace(/\//g, '_') || 'root';
+            channels[channelName] = {
+                address: path,
+                messages: {},
+                parameters: convertPathParameters(path, pathItem.parameters)
+            };
+            for (const [method, operation] of Object.entries(pathItem)) {
+                if (['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'trace'].includes(method) && (0, utils_1.isPlainObject)(operation)) {
+                    const operationObject = operation;
+                    const operationId = operationObject.operationId || `${method}${channelName}`;
+                    // Create operation
+                    operations[operationId] = {
+                        action: perspective === 'client' ? 'send' : 'receive',
+                        channel: (0, utils_1.createRefObject)('channels', channelName),
+                        summary: operationObject.summary,
+                        description: operationObject.description,
+                        tags: (_a = operationObject.tags) === null || _a === void 0 ? void 0 : _a.map((tag) => ({ name: tag })),
+                        bindings: {
+                            http: {
+                                method: method.toUpperCase(),
+                            }
+                        },
+                        messages: []
+                    };
+                    // Convert request body to message
+                    if (operationObject.requestBody) {
+                        const requestMessages = convertRequestBodyToMessages(operationObject.requestBody, operationId, method);
+                        Object.assign(channels[channelName].messages, requestMessages);
+                        operations[operationId].messages.push(...Object.keys(requestMessages).map(msgName => (0, utils_1.createRefObject)('channels', channelName, 'messages', msgName)));
+                    }
+                    // Convert responses to messages
+                    if (operationObject.responses) {
+                        const responseMessages = convertResponsesToMessages(operationObject.responses, operationId, method);
+                        Object.assign(channels[channelName].messages, responseMessages);
+                        operations[operationId].reply = {
+                            channel: (0, utils_1.createRefObject)('channels', channelName),
+                            messages: Object.keys(responseMessages).map(msgName => (0, utils_1.createRefObject)('channels', channelName, 'messages', msgName))
+                        };
+                    }
+                    // Add reply section if there are responses
+                    if (operationObject.responses && Object.keys(operationObject.responses).length > 0) {
+                        operations[operationId].reply = {
+                            channel: (0, utils_1.createRefObject)('channels', channelName),
+                            messages: Object.entries(operationObject.responses).map(([statusCode, response]) => (0, utils_1.createRefObject)('channels', channelName, 'messages', `${operationId}Response${statusCode}`))
+                        };
+                    }
+                    // Convert parameters
+                    if (operationObject.parameters) {
+                        const params = convertOperationParameters(operationObject.parameters);
+                        if (Object.keys(params).length > 0) {
+                            channels[channelName].parameters = Object.assign(Object.assign({}, channels[channelName].parameters), params);
+                        }
+                    }
+                }
+            }
+            (0, utils_1.removeEmptyObjects)(channels[channelName]);
+        }
+    }
+    return { channels, operations };
+}
+/**
+ * Converts OpenAPI path parameters to AsyncAPI channel parameters.
+ * @param {any[]} parameters - The OpenAPI path parameters.
+ * @returns {Record<string, any>} The converted AsyncAPI channel parameters.
+ */
+function convertPathParameters(path, parameters = []) {
+    var _a;
+    const convertedParams = {};
+    const paramNames = ((_a = path.match(/\{([^}]+)\}/g)) === null || _a === void 0 ? void 0 : _a.map(param => param.slice(1, -1))) || [];
+    paramNames.forEach(paramName => {
+        const param = parameters.find(p => p.name === paramName && p.in === 'path');
+        if (param) {
+            convertedParams[paramName] = convertParameter(param);
+        }
+        else {
+            // If the parameter is not defined in the OpenAPI spec, create a default one
+            convertedParams[paramName] = {
+                description: `Path parameter ${paramName}`,
+            };
+        }
+    });
+    return convertedParams;
+}
+/**
+ * Converts OpenAPI operatiion parameters to AsyncAPI operation parameters.
+ * @param {any[]} parameters - The OpenAPI operation parameters.
+ * @returns {Record<string, any>} The converted AsyncAPI operation parameters.
+ */
+function convertOperationParameters(parameters) {
+    const convertedParams = {};
+    parameters.forEach(param => {
+        if (!(0, utils_1.isRefObject)(param) && param.in === 'query') {
+            convertedParams[param.name] = convertParameter(param);
+        }
+    });
+    return convertedParams;
+}
+/**
+ * Converts an OpenAPI Parameter Object to an AsyncAPI Parameter Object.
+ * @param {ParameterObject} param - The OpenAPI Parameter Object.
+ * @returns {any} The converted AsyncAPI Parameter Object.
+ */
+function convertParameter(param) {
+    const convertedParam = {
+        description: param.description,
+    };
+    if (param.required) {
+        convertedParam.required = param.required;
+    }
+    if (param.schema && !(0, utils_1.isRefObject)(param.schema)) {
+        if (param.schema.enum) {
+            convertedParam.enum = param.schema.enum;
+        }
+        if (param.schema.default !== undefined) {
+            convertedParam.default = param.schema.default;
+        }
+    }
+    if (param.examples) {
+        convertedParam.examples = Object.values(param.examples).map((example) => (0, utils_1.isRefObject)(example) ? example : example.value);
+    }
+    // the location based on the parameter's 'in' property
+    switch (param.in) {
+        case 'query':
+        case 'header':
+        case 'cookie':
+            convertedParam.location = `$message.header#/${param.name}`;
+            break;
+        case 'path':
+            // Path parameters are part of the channel address
+            break;
+        default:
+            // If 'in' is not recognized, default to payload
+            convertedParam.location = `$message.payload#/${param.name}`;
+    }
+    return convertedParam;
+}
+function convertRequestBodyToMessages(requestBody, operationId, method) {
+    const messages = {};
+    if ((0, utils_1.isPlainObject)(requestBody.content)) {
+        Object.entries(requestBody.content).forEach(([contentType, mediaType]) => {
+            const messageName = `${operationId}Request`;
+            messages[messageName] = {
+                name: messageName,
+                title: `${method.toUpperCase()} request`,
+                contentType: contentType,
+                payload: convertSchema(mediaType.schema),
+                summary: requestBody.description,
+            };
+        });
+    }
+    return messages;
+}
+/**
+ * Converts OpenAPI Response Objects to AsyncAPI Message Objects.
+ * @param {ResponsesObject} responses - The OpenAPI Response Objects to convert.
+ * @param {string} operationId - The ID of the operation these responses belong to.
+ * @param {string} method - The HTTP method of the operation.
+ * @returns {Record<string, any>} A record of converted AsyncAPI Message Objects.
+ */
+function convertResponsesToMessages(responses, operationId, method) {
+    const messages = {};
+    Object.entries(responses).forEach(([statusCode, response]) => {
+        if ((0, utils_1.isPlainObject)(response.content)) {
+            Object.entries(response.content).forEach(([contentType, mediaType]) => {
+                const messageName = `${operationId}Response${statusCode}`;
+                messages[messageName] = {
+                    name: messageName,
+                    title: `${method.toUpperCase()} response ${statusCode}`,
+                    contentType: contentType,
+                    payload: convertSchema(mediaType.schema),
+                    summary: response.description,
+                    headers: response.headers ? convertHeadersToSchema(response.headers) : undefined,
+                };
+            });
+        }
+        else {
+            const messageName = `${operationId}Response${statusCode}`;
+            messages[messageName] = {
+                name: messageName,
+                title: `${method.toUpperCase()} response ${statusCode}`,
+                summary: response.description,
+            };
+        }
+    });
+    return messages;
+}
+/**
+ * Converts OpenAPI Components Object to AsyncAPI Components Object.
+ * @param {OpenAPIDocument} openapi - The complete OpenAPI document.
+ * @returns {AsyncAPIDocument['components']} The converted AsyncAPI Components Object.
+ */
+function convertComponents(openapi) {
+    const asyncComponents = {};
+    if (openapi.components) {
+        if (openapi.components.schemas) {
+            asyncComponents.schemas = convertSchemas(openapi.components.schemas);
+        }
+        if (openapi.components.securitySchemes) {
+            asyncComponents.securitySchemes = convertSecuritySchemes(openapi.components.securitySchemes);
+        }
+        if (openapi.components.parameters) {
+            asyncComponents.parameters = {};
+            for (const [name, param] of Object.entries(openapi.components.parameters)) {
+                if (!(0, utils_1.isRefObject)(param)) {
+                    asyncComponents.parameters[name] = convertParameter(param);
+                }
+                else {
+                    asyncComponents.parameters[name] = param;
+                }
+            }
+        }
+        if (openapi.components.responses) {
+            asyncComponents.messages = convertComponentResponsesToMessages(openapi.components.responses);
+        }
+        if (openapi.components.requestBodies) {
+            asyncComponents.messageTraits = convertRequestBodiesToMessageTraits(openapi.components.requestBodies);
+        }
+        if (openapi.components.headers) {
+            asyncComponents.messageTraits = Object.assign(Object.assign({}, (asyncComponents.messageTraits || {})), convertHeadersToMessageTraits(openapi.components.headers));
+        }
+        if (openapi.components.examples) {
+            asyncComponents.examples = openapi.components.examples;
+        }
+    }
+    return (0, utils_1.removeEmptyObjects)(asyncComponents);
+}
+/**
+ * converts openAPI schema object to multiformat/schema object
+ * @param schema openAPI schema object
+ * @returns multiformat/schema object
+ */
+function convertSchema(schema) {
+    if ((0, utils_1.isRefObject)(schema)) {
+        // Check if it's an external reference
+        if (schema.$ref.startsWith('./') || schema.$ref.startsWith('http')) {
+            // Convert external references to multi-format schema objects
+            return {
+                schemaFormat: 'application/vnd.oai.openapi;version=3.0.0',
+                schema: schema
+            };
+        }
+        return schema;
+    }
+    return {
+        schemaFormat: 'application/vnd.oai.openapi;version=3.0.0',
+        schema: schema
+    };
+}
+/**
+ * Converts OpenAPI Schema Objects to AsyncAPI Schema Objects.
+ * @param {Record<string, any>} schemas - The OpenAPI Schema Objects to convert.
+ * @returns {Record<string, any>} The converted AsyncAPI Schema Objects.
+ */
+function convertSchemas(schemas) {
+    const convertedSchemas = {};
+    for (const [name, schema] of Object.entries(schemas)) {
+        convertedSchemas[name] = convertSchema(schema);
+    }
+    return convertedSchemas;
+}
+/**
+ * Converts a single OpenAPI Security Scheme Object to an AsyncAPI Security Scheme Object.
+ * @param {Record<string, any>} scheme - The OpenAPI Security Scheme Object to convert.
+ * @returns {Record<string, any>} The converted AsyncAPI Security Scheme Object.
+ */
+function convertSecuritySchemes(securitySchemes) {
+    const convertedSchemes = {};
+    for (const [name, scheme] of Object.entries(securitySchemes)) {
+        convertedSchemes[name] = convertSecurityScheme(scheme);
+    }
+    return convertedSchemes;
+}
+/**
+ * Converts a single OpenAPI Security Scheme Object to an AsyncAPI Security Scheme Object.
+ * @param {any} scheme - The OpenAPI Security Scheme Object to convert.
+ * @returns {Record<string, any>} The converted AsyncAPI Security Scheme Object.
+ */
+function convertSecurityScheme(scheme) {
+    const convertedScheme = {
+        type: scheme.type,
+        description: scheme.description
+    };
+    if (scheme.type === 'oauth2' && scheme.flows) {
+        const newFlows = JSON.parse(JSON.stringify(scheme.flows));
+        function convertScopesToAvailableScopes(obj) {
+            for (const key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    if (key === 'scopes') {
+                        obj['availableScopes'] = obj[key];
+                        delete obj[key];
+                    }
+                    else if (typeof obj[key] === 'object') {
+                        convertScopesToAvailableScopes(obj[key]);
+                    }
+                }
+            }
+        }
+        convertScopesToAvailableScopes(newFlows);
+        convertedScheme.flows = newFlows;
+        if (scheme.scopes) {
+            convertedScheme.scopes = Object.keys(scheme.scopes);
+        }
+    }
+    else if (scheme.type === 'http') {
+        convertedScheme.scheme = scheme.scheme;
+        if (scheme.scheme === 'bearer') {
+            convertedScheme.bearerFormat = scheme.bearerFormat;
+        }
+    }
+    else if (scheme.type === 'apiKey') {
+        convertedScheme.in = scheme.in;
+        convertedScheme.name = scheme.name;
+    }
+    return convertedScheme;
+}
+/**
+ * Converts OpenAPI Response Objects from the components section to AsyncAPI Message Objects.
+ * @param {Record<string, any>} responses - The OpenAPI Response Objects to convert.
+ * @returns {Record<string, any>} A record of converted AsyncAPI Message Objects.
+ */
+function convertComponentResponsesToMessages(responses) {
+    const messages = {};
+    for (const [name, response] of Object.entries(responses)) {
+        if ((0, utils_1.isPlainObject)(response.content)) {
+            Object.entries(response.content).forEach(([contentType, mediaType]) => {
+                messages[name] = {
+                    name: name,
+                    contentType: contentType,
+                    payload: convertSchema(mediaType.schema),
+                    summary: response.description,
+                    headers: response.headers ? convertHeadersToSchema(response.headers) : undefined,
+                };
+            });
+        }
+        else {
+            messages[name] = {
+                name: name,
+                summary: response.description,
+            };
+        }
+    }
+    return messages;
+}
+/**
+ * Converts OpenAPI Request Body Objects from the components section to AsyncAPI Message Trait Objects.
+ * @param {Record<string, any>} requestBodies - The OpenAPI Request Body Objects to convert.
+ * @returns {Record<string, any>} A record of converted AsyncAPI Message Trait Objects.
+ */
+function convertRequestBodiesToMessageTraits(requestBodies) {
+    const messageTraits = {};
+    for (const [name, requestBodyOrRef] of Object.entries(requestBodies)) {
+        if (!(0, utils_1.isRefObject)(requestBodyOrRef) && requestBodyOrRef.content) {
+            const contentType = Object.keys(requestBodyOrRef.content)[0];
+            messageTraits[name] = {
+                name: name,
+                contentType: contentType,
+                description: requestBodyOrRef.description,
+            };
+            if (requestBodyOrRef.content[contentType].schema &&
+                requestBodyOrRef.content[contentType].schema.properties &&
+                requestBodyOrRef.content[contentType].schema.properties.headers) {
+                messageTraits[name].headers = requestBodyOrRef.content[contentType].schema.properties.headers;
+            }
+        }
+    }
+    return messageTraits;
+}
+/**
+ * Converts OpenAPI Header Objects from the components section to AsyncAPI Message Trait Objects.
+ * @param {Record<string, any>} headers - The OpenAPI Header Objects to convert.
+ * @returns {Record<string, any>} A record of converted AsyncAPI Message Trait Objects.
+ */
+function convertHeadersToMessageTraits(headers) {
+    const messageTraits = {};
+    for (const [name, header] of Object.entries(headers)) {
+        messageTraits[`Header${name}`] = {
+            headers: {
+                type: 'object',
+                properties: {
+                    [name]: header.schema,
+                },
+                required: [name],
+            },
+        };
+    }
+    return messageTraits;
+}
+/**
+ * Converts OpenAPI Header Objects to an AsyncAPI Schema Object representing the headers.
+ * @param {Record<string, any>} headers - The OpenAPI Header Objects to convert.
+ * @returns {SchemaObject} An AsyncAPI Schema Object representing the headers.
+ */
+function convertHeadersToSchema(headers) {
+    const properties = {};
+    for (const [name, headerOrRef] of Object.entries(headers)) {
+        if (!(0, utils_1.isRefObject)(headerOrRef)) {
+            properties[name] = headerOrRef.schema || {};
+        }
+    }
+    return {
+        type: 'object',
+        properties,
+    };
+}

package/lib/utils.d.ts

@@ -1,7 +1,7 @@
-import type { AsyncAPIDocument } from "./interfaces";
-export declare function serializeInput(document: string | AsyncAPIDocument): {
+import type { AsyncAPIDocument, OpenAPIDocument } from "./interfaces";
+export declare function serializeInput(document: string | AsyncAPIDocument | OpenAPIDocument): {
     format: 'json' | 'yaml';
-    document: AsyncAPIDocument;
+    document: AsyncAPIDocument | OpenAPIDocument;
 } | never;
 export declare function objectToSchema(obj: Record<string, unknown>): {
     type: string;
@@ -20,3 +20,4 @@ export declare function isRemoteRef(value: any): 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;
+export declare function removeEmptyObjects(obj: Record<string, any>): Record<string, any>;

package/lib/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortObjectKeys = exports.getValueByPath = exports.getValueByRef = exports.isRemoteRef = exports.isRefObject = exports.createRefPath = exports.createRefObject = exports.isPlainObject = exports.dotsToSlashes = exports.objectToSchema = exports.serializeInput = void 0;
+exports.removeEmptyObjects = exports.sortObjectKeys = exports.getValueByPath = exports.getValueByRef = exports.isRemoteRef = 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;
@@ -13,10 +13,18 @@ function serializeInput(document) {
         }
         const maybeJSON = JSON.parse(document);
         if (typeof maybeJSON === 'object') {
-            return {
-                format: 'json',
-                document: maybeJSON,
-            };
+            if ('openapi' in maybeJSON) {
+                return {
+                    format: 'json',
+                    document: maybeJSON,
+                };
+            }
+            else {
+                return {
+                    format: 'json',
+                    document: maybeJSON,
+                };
+            }
         }
         triedConvertToYaml = true; // NOSONAR
         // if `maybeJSON` is object, then we have 100% sure that we operate on JSON, 
@@ -128,3 +136,18 @@ function untilde(str) {
         return sub;
     });
 }
+function removeEmptyObjects(obj) {
+    Object.keys(obj).forEach(key => {
+        if (obj[key] && typeof obj[key] === 'object') {
+            removeEmptyObjects(obj[key]);
+            if (Object.keys(obj[key]).length === 0) {
+                delete obj[key];
+            }
+        }
+        else if (obj[key] === undefined) {
+            delete obj[key];
+        }
+    });
+    return obj;
+}
+exports.removeEmptyObjects = removeEmptyObjects;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@asyncapi/converter",
-	"version": "1.4.21",
+	"version": "1.5.0",
 	"description": "Convert AsyncAPI documents from older to newer versions.",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
@@ -38,7 +38,7 @@
 	"author": "Fran Mendez <fmvilas@gmail.com> (fmvilas.com)",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@asyncapi/parser": "^3.0.16",
+		"@asyncapi/parser": "^3.1.0",
 		"js-yaml": "^3.14.1"
 	},
 	"devDependencies": {