feat: initial structure+first approach

.eslintignore

@@ -0,0 +1,4 @@
+node_modules
+test/temp
+output
+__transpiled

.eslintrc

@@ -0,0 +1,109 @@
+env:
+  node: true
+  es6: true
+  mocha: true
+
+plugins:
+  - sonarjs
+  - mocha
+  - security
+
+extends:
+  - plugin:sonarjs/recommended
+  - plugin:mocha/recommended
+  - plugin:security/recommended
+
+parserOptions:
+  ecmaVersion: 2018
+
+rules:
+  # Ignore Rules
+  strict: 0
+  no-underscore-dangle: 0
+  no-mixed-requires: 0
+  no-process-exit: 0
+  no-warning-comments: 0
+  curly: 0
+  no-multi-spaces: 0
+  no-alert: 0
+  consistent-return: 0
+  consistent-this: [0, self]
+  func-style: 0
+  max-nested-callbacks: 0
+  camelcase: 0
+
+  # Warnings
+  no-debugger: 1
+  no-empty: 1
+  no-invalid-regexp: 1
+  no-unused-expressions: 1
+  no-native-reassign: 1
+  no-fallthrough: 1
+  sonarjs/cognitive-complexity: 1
+
+  # Errors
+  eqeqeq: 2
+  no-undef: 2
+  no-dupe-keys: 2
+  no-empty-character-class: 2
+  no-self-compare: 2
+  valid-typeof: 2
+  no-unused-vars: [2, { "args": "none" }]
+  handle-callback-err: 2
+  no-shadow-restricted-names: 2
+  no-new-require: 2
+  no-mixed-spaces-and-tabs: 2
+  block-scoped-var: 2
+  no-else-return: 2
+  no-throw-literal: 2
+  no-void: 2
+  radix: 2
+  wrap-iife: [2, outside]
+  no-shadow: 0
+  no-use-before-define: [2, nofunc]
+  no-path-concat: 2
+  valid-jsdoc: [0, {requireReturn: false, requireParamDescription: false, requireReturnDescription: false}]
+
+  # stylistic errors
+  no-spaced-func: 2
+  semi-spacing: 2
+  quotes: [2, 'single']
+  key-spacing: [2, { beforeColon: false, afterColon: true }]
+  indent: [2, 2]
+  no-lonely-if: 2
+  no-floating-decimal: 2
+  brace-style: [2, 1tbs, { allowSingleLine: true }]
+  comma-style: [2, last]
+  no-multiple-empty-lines: [2, {max: 1}]
+  no-nested-ternary: 2
+  operator-assignment: [2, always]
+  padded-blocks: [2, never]
+  quote-props: [2, as-needed]
+  keyword-spacing: [2, {'before': true, 'after': true, 'overrides': {}}]
+  space-before-blocks: [2, always]
+  array-bracket-spacing: [2, never]
+  computed-property-spacing: [2, never]
+  space-in-parens: [2, never]
+  space-unary-ops: [2, {words: true, nonwords: false}]
+  wrap-regex: 2
+  linebreak-style: 0
+  semi: [2, always]
+  arrow-spacing: [2, {before: true, after: true}]
+  no-class-assign: 2
+  no-const-assign: 2
+  no-dupe-class-members: 2
+  no-this-before-super: 2
+  no-var: 2
+  object-shorthand: [2, always]
+  prefer-arrow-callback: 2
+  prefer-const: 2
+  prefer-spread: 2
+  prefer-template: 2
+
+overrides:
+  - files: "test/**"
+    rules:
+      prefer-arrow-callback: 0
+      sonarjs/no-duplicate-string: 0
+      security/detect-object-injection: 0
+      security/detect-non-literal-fs-filename: 0

.gitignore

@@ -0,0 +1,7 @@
+/node_modules/
+dist
+local
+.vscode
+.idea
+coverage
+*.DS_Store

lib/appRelationsDiscovery.js

@@ -0,0 +1,65 @@
+const {validate} = require('./utils');
+
+const supportedSyntax = ['default','mermaid'];
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
+async function getRelations(asyncApiDocs,requestedSyntax = 'default') {
+  if (typeof asyncApiDocs !== 'object') throw new Error('You must pass an array of AsyncApiDocuments on which you wish to discover the relations between');
+  if (!supportedSyntax.includes(requestedSyntax)) return;
+
+  const parsedAsyncApiDocs = await validate(asyncApiDocs);
+  const metrics = new Map();
+
+  parsedAsyncApiDocs.forEach(doc => {
+    if (doc.hasServers()) {
+      const servers = doc.servers();
+
+      for (const [, credentials] of Object.entries(servers)) {
+        const slug = `${credentials.url()},${credentials.protocol()}`;
+        let relation;
+        if (metrics.has(slug)) {
+          relation = metrics.get(slug);
+        } else {
+          relation = new Map();
+        }
+        // metrics
+        // ServerMap(n-servers) => {
+        //   <Url+protocol> => ChannelMap(n-channels) => {
+        //      <channelName> => { sub: [] , pub: [] }
+        //    },
+        //    ....
+        // }
+        if (doc.hasChannels()) {
+          doc.channelNames().forEach((channelName) => {
+            let application;
+            if (relation.has(channelName)) {
+              application = relation.get(channelName);
+            } else {
+              application = {
+                sub: [],
+                pub: [],
+              };
+            }
+
+            const channel = doc.channel(channelName);
+            const title = doc.info().title();
+
+            if (channel.hasPublish()) {
+              application.pub.push(title);
+            }
+            if (channel.hasSubscribe()) {
+              application.sub.push(title);
+            }
+
+            relation.set(channelName, application);
+          });
+        }
+        metrics.set(slug,relation);
+      };
+    }
+  });
+  if (requestedSyntax === 'default')
+    return metrics;
+};
+
+module.exports = {getRelations};

lib/index.js

@@ -0,0 +1,3 @@
+const appRelationsDiscovery = require('./appRelationsDiscovery');
+
+module.exports = appRelationsDiscovery;

lib/utils.js

@@ -0,0 +1,21 @@
+const parser = require('@asyncapi/parser');
+
+function validate(asyncApiDocs) {
+  return new Promise((resolve,reject) => {
+    const parsedDocs = [];
+    const Promises = [];
+    asyncApiDocs.forEach(document => {
+      Promises.push(new Promise((resolve, reject) => {
+        parser.parse(document.json())
+          .then(parsedDoc => parsedDocs.push(parsedDoc))
+          .then(() => resolve())
+          .catch(err => reject(err));
+      }));
+    });
+    Promise.all(Promises)
+      .then(() => resolve(parsedDocs))
+      .catch(err => reject(err));
+  });
+}
+
+module.exports = { validate };