@asyncapi/converter 0.7.2 → 0.10.0

package/README.md

@@ -34,22 +34,48 @@ id: 'urn:com.asynapi.streetlights'
 ...
 ```
 
-Save the result in a file:
+Save the result in a file by stream:
 
 ```sh
 asyncapi-converter streetlights.yml > streetlights2.yml
 ```
 
-### As a package
+Save the result in a file by `-o, --output` flag:
+
+```sh
+asyncapi-converter streetlights.yml -o streetlights2.yml
+```
+
+### In JS
 
 ```js
+const fs = require('fs');
 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'
-  }))
+    id: 'urn:com.asyncapi.streetlights'
+  }));
+} catch (e) {
+  console.error(e);
+}
+```
+
+### In TS
+
+```ts
+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 asyncapi = fs.readFileSync('streetlights.yml', 'utf-8')
+  console.log(convert(asyncapi, toVersion, options));
 } catch (e) {
   console.error(e)
 }

package/cli.js

@@ -10,6 +10,16 @@ const red = text => `\x1b[31m${text}\x1b[0m`;
 
 let asyncapiFile;
 let version;
+let output;
+
+const parseArguments = (asyncAPIPath, v) => {
+  asyncapiFile = path.resolve(asyncAPIPath);
+  version = v;
+}
+
+const parseOutput = (filePath) => {
+  output = path.resolve(filePath);
+}
 
 const showErrorAndExit = err => {
   console.error(red('Something went wrong:'));
@@ -20,11 +30,9 @@ const showErrorAndExit = err => {
 program
   .version(packageInfo.version)
   .arguments('<document> [version]')
-  .action((asyncAPIPath, v) => {
-    asyncapiFile = path.resolve(asyncAPIPath);
-    version = v;
-  })
+  .action(parseArguments)
   .option('--id <id>', 'application id (defaults to a generated one)')
+  .option('-o, --output <outputFile>', 'file where to put the converted AsyncAPI document', parseOutput)
   .parse(process.argv);
 
 if (!asyncapiFile) {
@@ -46,7 +54,11 @@ try {
     converted = JSON.stringify(converted, undefined, 2);
   }
 
-  console.log(converted);
+  if (output) {
+    fs.writeFileSync(output, converted, 'utf-8');
+  } else {
+    console.log(converted);
+  }
 } catch (e) {
   showErrorAndExit(e);
 }

package/lib/convert.d.ts

@@ -0,0 +1,3 @@
+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;

package/lib/convert.js

@@ -0,0 +1,193 @@
+"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 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,
+};
+const conversionVersions = Object.keys(conversions);
+function convert(asyncapi, version, options = {}) {
+    const { format, document } = (0, utils_1.serializeInput)(asyncapi);
+    const asyncapiVersion = document.asyncapi;
+    let fromVersion = conversionVersions.indexOf(asyncapiVersion);
+    const toVersion = conversionVersions.indexOf(version);
+    if (fromVersion === -1 || toVersion === -1) {
+        throw new Error(`Cannot convert from ${asyncapiVersion} to ${version}.`);
+    }
+    if (fromVersion > toVersion) {
+        throw new Error(`Cannot downgrade from ${asyncapiVersion} to ${version}.`);
+    }
+    if (fromVersion === toVersion) {
+        throw new Error(`Cannot convert to the same version.`);
+    }
+    // add 1 to `fromVersion` because we convert from previous to next
+    fromVersion++;
+    let converted = document;
+    for (let i = fromVersion; i <= toVersion; i++) {
+        converted = conversions[conversionVersions[i]](converted, options);
+    }
+    if (format === 'yaml') {
+        return (0, js_yaml_1.dump)(converted, { skipInvalid: true });
+    }
+    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, options) {
+    asyncapi.asyncapi = '2.0.0-rc1';
+    asyncapi.id = options.id || `urn:${asyncapi.info.title.toLowerCase().split(' ').join('.')}`;
+    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, options) {
+    asyncapi.asyncapi = '2.0.0-rc2';
+    asyncapi.id = asyncapi.id || options.id;
+    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;
+        });
+    }
+    if (!options.id)
+        delete asyncapi.id;
+    return asyncapi;
+}
+function from__2_0_0_rc2__to__2_0_0(asyncapi, options) {
+    asyncapi.asyncapi = '2.0.0';
+    if (!options.id)
+        delete asyncapi.id;
+    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;
+}

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,215 +1,5 @@
-const yaml = require('js-yaml');
-const _ = require('lodash');
-const {
-  serialize,
-  dotsToSlashes,
-  eventToChannel,
-  streamToChannel,
-  convertMessage,
-} = require('./helpers');
-
-const lib = module.exports;
-
-/**
- * Value for key (version) represents the function which converts specification from previous version to the given as key.
- */
-const conversions = {
-  '1.0.0': undefined,
-  '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,
-}
-const conversionVersions = Object.keys(conversions);
-
-lib.convert = (asyncapi, version, options = {}) => {
-  const { isYAML, parsed } = serialize(asyncapi);
-  if (parsed === undefined) return '';
-
-  let fromVersion = conversionVersions.indexOf(parsed.asyncapi);
-  const toVersion = conversionVersions.indexOf(version);
-
-  if (fromVersion === -1 || toVersion === -1) {
-    console.error(`Cannot convert from ${parsed.asyncapi} to ${version}.`);
-    return;
-  }
-  if (fromVersion > toVersion) {
-    console.error(`Cannot downgrade from ${parsed.asyncapi} to ${version}.`);
-    return;
-  }
-  if (fromVersion === toVersion) {
-    console.error(`Cannot convert to the same version.`);
-    return;
-  }
-
-  // add 1 to `fromVersion` because we convert from previous to next
-  fromVersion++;
-  let converted = parsed;
-  for (let i = fromVersion; i <= toVersion; i++) {
-    const fn = conversions[conversionVersions[i]];
-    converted = fn(converted, options);
-  }
-
-  if (isYAML) {
-    converted = yaml.safeDump(converted, { skipInvalid: true });
-  }
-  return converted;
-};
-
-function from__1_0_0__to__1_1_0(asyncapi) {
-  return asyncapi;
-}
-
-function from__1_1_0__to__1_2_0(asyncapi) {
-  return asyncapi;
-}
-
-function from__1_2_0__to__2_0_0_rc1(asyncapi1, options) { // NOSONAR
-  const result = asyncapi1;
-
-  result.asyncapi = '2.0.0-rc1';
-  result.id = options.id || `urn:${asyncapi1.info.title.toLowerCase().split(' ').join('.')}`;
-
-  if (asyncapi1.servers) {
-    const security = asyncapi1.security;
-    result.servers = asyncapi1.servers.map(server => {
-      const { scheme, schemeVersion, ...rest } = server;
-
-      const out = {
-        ...rest,
-        ...{
-          protocol: scheme,
-        }
-      };
-
-      if (schemeVersion) out.protocolVersion = schemeVersion;
-
-      if (security) {
-        out.security = security;
-      }
-
-      return out;
-    });
-  }
-
-  if (asyncapi1.topics) {
-    const baseTopic = asyncapi1.baseTopic ? `${asyncapi1.baseTopic}.` : "";
-    result.channels = _.mapKeys(result.topics, (__, topicName) => dotsToSlashes(`${baseTopic}${topicName}`));
-    _.map(result.channels, ch => {
-      if (ch.publish) {
-        ch.publish = { message: ch.publish };
-      }
-      if (ch.subscribe) {
-        ch.subscribe = { message: ch.subscribe };
-      }
-    });
-  } else if (asyncapi1.stream) {
-    result.channels = {
-      '/': streamToChannel(asyncapi1.stream),
-    };
-  } else if (asyncapi1.events) {
-    result.channels = {
-      '/': eventToChannel(asyncapi1.events),
-    };
-  }
-
-  delete result.topics;
-  delete result.stream;
-  delete result.events;
-  delete result.baseTopic;
-  delete result.security;
-
-  return result;
-}
-
-function from__2_0_0_rc1__to__2_0_0_rc2(asyncapi2rc1, options) { // NOSONAR
-  const result = asyncapi2rc1;
-
-  result.asyncapi = '2.0.0-rc2';
-  result.id = result.id || options.id;
-
-  if (asyncapi2rc1.servers) {
-    const serverMap = {};
-    asyncapi2rc1.servers.forEach((server, index) => {
-      if (server.baseChannel) delete server.baseChannel;
-      const name = index === 0 ? 'default' : `server${index}`;
-      serverMap[name] = server;
-    });
-    result.servers = serverMap;
-  }
-
-  if (result.channels) {
-    _.each(result.channels, (channel, channelName) => {
-      if (channel.parameters) {
-        const parametersMap = {};
-        const paramNames = channelName.match(/\{([^\}]{1,100})\}/g).map(p => p.substr(1, p.length - 2));
-        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 (result.components && result.components.parameters) {
-    _.each(result.components.parameters, (parameter) => {
-      if (parameter.name) delete parameter.name;
-    });
-  }
-
-  if (!options.id) delete result.id;
-  return result;
-}
-
-function from__2_0_0_rc2__to__2_0_0(asyncapi2rc2, options) {
-  const result = asyncapi2rc2;
-  if (!options.id) delete result.id;
-  result.asyncapi = '2.0.0';
-  return result;
-}
-
-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;
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convert = void 0;
+var convert_1 = require("./convert");
+Object.defineProperty(exports, "convert", { enumerable: true, get: function () { return convert_1.convert; } });

package/lib/interfaces.d.ts

@@ -0,0 +1,7 @@
+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';
+export interface ConvertOptions {
+    id?: string;
+}

package/lib/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.d.ts

@@ -0,0 +1,21 @@
+import type { AsyncAPIDocument } from "./interfaces";
+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: {
+        [x: string]: unknown;
+    };
+};
+export declare function dotsToSlashes(topic: string): string;
+export declare function convertMessage(message: any): void;

package/lib/utils.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertMessage = exports.dotsToSlashes = exports.objectToSchema = exports.streamToChannel = exports.eventToChannel = exports.serializeInput = void 0;
+const js_yaml_1 = require("js-yaml");
+function serializeInput(document) {
+    let triedConvertToYaml = false;
+    try {
+        if (typeof document === 'object') {
+            return {
+                format: 'json',
+                document: JSON.parse(JSON.stringify(document)), // copy object
+            };
+        }
+        const maybeJSON = JSON.parse(document);
+        if (typeof maybeJSON === 'object') {
+            return {
+                format: 'json',
+                document: maybeJSON,
+            };
+        }
+        triedConvertToYaml = true; // NOSONAR
+        // if `maybeJSON` is object, then we have 100% sure that we operate on JSON, 
+        // but if it's `string` then we have option that it can be YAML but it doesn't have to be
+        return {
+            format: 'yaml',
+            document: (0, js_yaml_1.load)(document),
+        };
+    }
+    catch (e) {
+        try {
+            if (triedConvertToYaml) {
+                throw e;
+            }
+            // try to parse (again) YAML, because the text itself may not have a JSON representation and cannot be represented as a JSON object/string
+            return {
+                format: 'yaml',
+                document: (0, js_yaml_1.load)(document),
+            };
+        }
+        catch (err) {
+            throw new Error('AsyncAPI document must be a valid JSON or YAML 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) };
+}
+exports.objectToSchema = objectToSchema;
+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);
+            }
+        });
+    }
+    else {
+        if (message.protocolInfo) {
+            message.bindings = message.protocolInfo;
+            delete message.protocolInfo;
+        }
+        if (message.headers) {
+            message.headers = objectToSchema(message.headers);
+        }
+    }
+}
+exports.convertMessage = convertMessage;