@weave-js/core 0.11.1 → 0.12.0

package/lib/tracing/span.js

@@ -1,4 +1,4 @@
-const hrTime = require('./time')
+const hrTime = require('./time');
 
 exports.createSpan = (tracer, name, options) => {
   const span = Object.assign({}, {
@@ -10,54 +10,54 @@ exports.createSpan = (tracer, name, options) => {
     sampled: options.sampled || tracer.shouldSample(),
     service: options.service,
     tags: {}
-  })
+  });
 
   if (options.service) {
     span.service = {
       name: options.service.name,
       version: options.service.version,
       fullyQualifiedName: options.service.fullyQualifiedName
-    }
+    };
   }
 
   span.addTags = (tags) => {
-    Object.assign(span.tags, tags)
-    return span
-  }
+    Object.assign(span.tags, tags);
+    return span;
+  };
 
   span.start = (time) => {
-    span.startTime = time || hrTime()
-    tracer.invokeCollectorMethod('startedSpan', [span])
-    return span
-  }
+    span.startTime = time || hrTime();
+    tracer.invokeCollectorMethod('startedSpan', [span]);
+    return span;
+  };
 
   span.startChildSpan = (name, options) => {
     const parentOptions = {
       parentId: options.parentId,
       sampled: options.sampled
-    }
-    return tracer.startSpan(name, Object.assign(parentOptions, options))
-  }
+    };
+    return tracer.startSpan(name, Object.assign(parentOptions, options));
+  };
 
   span.finish = (time) => {
-    span.finishTime = time || hrTime()
-    span.duration = span.finishTime - span.startTime
-    tracer.log.debug('Span finished')
-    tracer.invokeCollectorMethod('finishedSpan', [span])
+    span.finishTime = time || hrTime();
+    span.duration = span.finishTime - span.startTime;
+    tracer.log.debug('Span finished');
+    tracer.invokeCollectorMethod('finishedSpan', [span]);
 
-    return span
-  }
+    return span;
+  };
 
-  span.isActive = () => span.finishTime !== null
+  span.isActive = () => span.finishTime !== null;
 
   span.setError = (error) => {
-    span.error = error
-    return span
-  }
+    span.error = error;
+    return span;
+  };
 
   if (options.tags) {
-    span.addTags(options.tags)
+    span.addTags(options.tags);
   }
 
-  return span
-}
+  return span;
+};

package/lib/tracing/time.js

@@ -1,16 +1,16 @@
-const loadTime = getNanoSeconds()
-const nodeLoadTime = loadTime - process.uptime() * 1e9
+const loadTime = getNanoSeconds();
+const nodeLoadTime = loadTime - process.uptime() * 1e9;
 
 function getNanoSeconds () {
-  const time = process.hrtime()
-  return time[0] * 1e9 + time[1]
+  const time = process.hrtime();
+  return time[0] * 1e9 + time[1];
 }
 
 function now () {
-  return (getNanoSeconds() - nodeLoadTime) / 1e6
+  return (getNanoSeconds() - nodeLoadTime) / 1e6;
 }
 
-const loadNs = now()
-const loadMs = Date.now()
+const loadNs = now();
+const loadMs = Date.now();
 
-module.exports = () => loadMs + now() - loadNs
+module.exports = () => loadMs + now() - loadNs;

package/lib/transport/InboundTransformStream.js

@@ -1,75 +1,75 @@
-const { Transform } = require('stream')
+const { Transform } = require('stream');
 
 const pushWithBackpressure = (stream, chunks, encoding, callback = null, $index = 0) => {
   if (!(stream instanceof Transform)) {
-    throw new TypeError('Argument "stream" must be an instance of Duplex')
+    throw new TypeError('Argument "stream" must be an instance of Duplex');
   }
 
-  chunks = [].concat(chunks).filter(x => x !== undefined)
+  chunks = [].concat(chunks).filter(x => x !== undefined);
 
   if (typeof encoding === 'function') {
-    callback = encoding
-    encoding = undefined
+    callback = encoding;
+    encoding = undefined;
   }
 
   if ($index >= chunks.length) {
     if (typeof callback === 'function') {
-      callback()
+      callback();
     }
-    return stream
+    return stream;
   } else if (!stream.push(chunks[$index], ...([encoding].filter(Boolean)))) {
     stream.emit('backpressure', {
       sender: stream.sender,
       requestId: stream.requestId
-    })
+    });
 
     const pipedStreams = [].concat(
       (stream._readableState || {}).pipes || stream
-    ).filter(Boolean)
+    ).filter(Boolean);
 
-    let listenerCalled = false
+    let listenerCalled = false;
 
     const drainListener = () => {
       stream.emit('resume_backpressure', {
         sender: stream.sender,
         requestId: stream.requestId
-      })
+      });
 
       if (listenerCalled) {
-        return
+        return;
       }
 
-      listenerCalled = true
+      listenerCalled = true;
 
       for (const stream of pipedStreams) {
-        stream.removeListener('drain', drainListener)
+        stream.removeListener('drain', drainListener);
       }
 
-      pushWithBackpressure(stream, chunks, encoding, callback, $index + 1)
-    }
+      pushWithBackpressure(stream, chunks, encoding, callback, $index + 1);
+    };
 
     for (const stream of pipedStreams) {
-      stream.once('drain', drainListener)
+      stream.once('drain', drainListener);
     }
 
-    return stream
+    return stream;
   }
-  return pushWithBackpressure(stream, chunks, encoding, callback, $index + 1)
-}
+  return pushWithBackpressure(stream, chunks, encoding, callback, $index + 1);
+};
 class InboundTransformStream extends Transform {
   constructor (sender, requestId, options) {
-    super(options)
-    this.sender = sender
-    this.requestId = requestId
+    super(options);
+    this.sender = sender;
+    this.requestId = requestId;
   }
 
   _transform (chunk, encoding, callback) {
-    pushWithBackpressure(this, chunk, encoding, callback)
+    pushWithBackpressure(this, chunk, encoding, callback);
   }
 
   _flush (callback) {
-    return callback()
+    return callback();
   }
 }
 
-module.exports = { InboundTransformStream }
+module.exports = { InboundTransformStream };

package/lib/transport/adapters/adapteBase.js

@@ -1,10 +1,10 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const EventEmitter = require('events').EventEmitter
+const EventEmitter = require('events').EventEmitter;
 
 /**
  * @typedef {Object} AdapterBase
@@ -22,7 +22,7 @@ const EventEmitter = require('events').EventEmitter
  * @returns {AdapterBase} Adapter base object
 */
 const createTransportBase = () => {
-  let prefix = 'weave'
+  let prefix = 'weave';
 
   return {
     name: null,
@@ -32,23 +32,23 @@ const createTransportBase = () => {
     interruptCounter: 0,
     repeatAttemptCounter: 0,
     init (broker, transport, messageHandler) {
-      this.broker = broker
-      this.transport = transport
-      this.log = transport.log
-      this.messageHandler = messageHandler
+      this.broker = broker;
+      this.transport = transport;
+      this.log = transport.log;
+      this.messageHandler = messageHandler;
 
       if (broker.options.namespace) {
-        prefix = `${prefix}-${broker.options.namespace}`
+        prefix = `${prefix}-${broker.options.namespace}`;
       }
 
       if (this.afterInit) {
-        this.afterInit()
+        this.afterInit();
       }
 
-      return Promise.resolve()
+      return Promise.resolve();
     },
     subscribe () {
-      return Promise.resolve()
+      return Promise.resolve();
     },
     /**
      *
@@ -59,49 +59,49 @@ const createTransportBase = () => {
      * @returns {void}
     */
     connected (connectionEventParams = {}) {
-      this.bus.emit('$adapter.connected', connectionEventParams)
+      this.bus.emit('$adapter.connected', connectionEventParams);
     },
     disconnected () {
-      this.bus.emit('$adapter.disconnected')
+      this.bus.emit('$adapter.disconnected');
     },
     getTopic (cmd, nodeId) {
-      const topic = prefix + '.' + cmd + (nodeId ? '.' + nodeId : '')
-      return topic
+      const topic = prefix + '.' + cmd + (nodeId ? '.' + nodeId : '');
+      return topic;
     },
     preSend (packet) {
-      return this.send(packet)
+      return this.send(packet);
     },
     send (/* message*/) {
-      this.broker.handleError(new Error('Method "send" not implemented.'))
+      this.broker.handleError(new Error('Method "send" not implemented.'));
     },
     incomingMessage (messageType, message) {
-      const data = this.deserialize(message)
-      this.updateStatisticReceived(message.length)
-      this.bus.emit('$adapter.message', messageType, data)
+      const data = this.deserialize(message);
+      this.updateStatisticReceived(message.length);
+      this.bus.emit('$adapter.message', messageType, data);
     },
     serialize (packet) {
       try {
         // Add the sender to each outgoing message
-        packet.payload.sender = this.broker.nodeId
-        return Buffer.from(JSON.stringify(packet))
+        packet.payload.sender = this.broker.nodeId;
+        return Buffer.from(JSON.stringify(packet));
       } catch (error) {
-        this.broker.handleError(error)
+        this.broker.handleError(error);
       }
     },
     deserialize (packet) {
       try {
-        return JSON.parse(packet)
+        return JSON.parse(packet);
       } catch (error) {
-        this.broker.handleError(error)
+        this.broker.handleError(error);
       }
     },
     updateStatisticReceived (length) {
-      this.transport.statistics.received.packages += length
+      this.transport.statistics.received.packages += length;
     },
     updateStatisticSent (length) {
-      this.transport.statistics.sent.packages += length
+      this.transport.statistics.sent.packages += length;
     }
-  }
-}
+  };
+};
 
-module.exports = createTransportBase
+module.exports = createTransportBase;

package/lib/transport/adapters/adapters.js

@@ -1,9 +1,9 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2019 Fachwerk
  */
 
-exports.BaseAdapter = require('./adapteBase')
-exports.Dummy = require('./dummy')
-exports.TCP = require('./tcp')
+exports.BaseAdapter = require('./adapteBase');
+exports.Dummy = require('./dummy');
+exports.TCP = require('./tcp');

package/lib/transport/adapters/dummy/index.js

@@ -1,42 +1,42 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const TransportBase = require('../adapteBase')
-const EventEmitter = require('eventemitter2').EventEmitter2
+const TransportBase = require('../adapteBase');
+const EventEmitter = require('eventemitter2').EventEmitter2;
 
 // create a global eventbus to pass messages between weave service brokers.
 global.bus = new EventEmitter({
   wildcard: true,
   maxListeners: 100
-})
+});
 
 const DummyTransportAdapter = (adapterOptions) => {
-  const messageBus = global.bus
+  const messageBus = global.bus;
 
   return Object.assign(TransportBase(adapterOptions), {
     name: 'Dummy',
     connect () {
-      this.bus.emit('$adapter.connected', false)
-      this.log.info('Dummy transport client connected.')
-      return Promise.resolve()
+      this.bus.emit('$adapter.connected', false);
+      this.log.info('Dummy transport client connected.');
+      return Promise.resolve();
     },
     close () {
-      return Promise.resolve()
+      return Promise.resolve();
     },
     send (message) {
-      const data = this.serialize(message)
-      const topic = this.getTopic(message.type, message.targetNodeId)
-      messageBus.emit(topic, data)
-      return Promise.resolve()
+      const data = this.serialize(message);
+      const topic = this.getTopic(message.type, message.targetNodeId);
+      messageBus.emit(topic, data);
+      return Promise.resolve();
     },
     subscribe (type, nodeId) {
-      const topic = this.getTopic(type, nodeId)
-      messageBus.on(topic, message => this.incomingMessage(type, message))
+      const topic = this.getTopic(type, nodeId);
+      messageBus.on(topic, message => this.incomingMessage(type, message));
     }
-  })
-}
+  });
+};
 
-module.exports = DummyTransportAdapter
+module.exports = DummyTransportAdapter;

package/lib/transport/adapters/fromURI.js

@@ -1,35 +1,35 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2019 Fachwerk
  */
-const { parse } = require('url')
-const getAdapterByName = require('./getAdapterByName')
+const { parse } = require('url');
+const getAdapterByName = require('./getAdapterByName');
 
 function fromURI (uri) {
   if (typeof uri !== 'string') {
-    throw new Error('URI needs to be a string.')
+    throw new Error('URI needs to be a string.');
   }
 
-  const urlObject = parse(uri)
+  const urlObject = parse(uri);
 
   if (!urlObject.protocol) {
-    throw new Error('Protocol is missing.')
+    throw new Error('Protocol is missing.');
   }
 
-  const name = urlObject.protocol.slice(0, -1).toLowerCase()
+  const name = urlObject.protocol.slice(0, -1).toLowerCase();
 
-  const AdapterFactory = getAdapterByName(name)
+  const AdapterFactory = getAdapterByName(name);
 
   if (!AdapterFactory) {
-    throw new Error('No adapter found.')
+    throw new Error('No adapter found.');
   }
 
-  let config = null
+  let config = null;
   if (AdapterFactory.uriToConfig) {
-    config = AdapterFactory.uriToConfig(urlObject)
+    config = AdapterFactory.uriToConfig(urlObject);
   }
-  return AdapterFactory(config)
+  return AdapterFactory(config);
 }
 
-module.exports = fromURI
+module.exports = fromURI;

package/lib/transport/adapters/getAdapterByName.js

@@ -1,11 +1,11 @@
-const adapters = require('./adapters')
+const adapters = require('./adapters');
 
 module.exports = name => {
   if (!name) {
-    return
+    return;
   }
-  const foundAdapterName = Object.keys(adapters).find(adapter => adapter.toLowerCase() === name.toLowerCase())
+  const foundAdapterName = Object.keys(adapters).find(adapter => adapter.toLowerCase() === name.toLowerCase());
   if (foundAdapterName) {
-    return adapters[foundAdapterName]
+    return adapters[foundAdapterName];
   }
-}
+};

package/lib/transport/adapters/index.js

@@ -1,29 +1,29 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { WeaveBrokerOptionsError } = require('../../errors')
-const fromURI = require('./fromURI')
-const getAdapterByName = require('./getAdapterByName')
-const adapters = require('./adapters')
+const { WeaveBrokerOptionsError } = require('../../errors');
+const fromURI = require('./fromURI');
+const getAdapterByName = require('./getAdapterByName');
+const adapters = require('./adapters');
 
 const resolve = (broker, options) => {
   if (typeof options === 'object') {
     if (typeof options.adapter === 'string') {
-      const Adapter = getAdapterByName(options.adapter)
+      const Adapter = getAdapterByName(options.adapter);
 
       if (Adapter) {
-        return Adapter(options.options)
+        return Adapter(options.options);
       } else {
-        broker.handleError(new WeaveBrokerOptionsError(`Invalid transport settings: ${options.adapter}`))
+        broker.handleError(new WeaveBrokerOptionsError(`Invalid transport settings: ${options.adapter}`));
       }
     }
-    return options.adapter
+    return options.adapter;
   }
 
-  return null
-}
+  return null;
+};
 
-module.exports = Object.assign({ resolve, fromURI }, adapters)
+module.exports = Object.assign({ resolve, fromURI }, adapters);

package/lib/transport/adapters/tcp/discovery/codec.js

@@ -1,10 +1,10 @@
 module.exports = function createCodec (options) {
   return {
     encode (object) {
-      return Buffer.from(JSON.stringify(object))
+      return Buffer.from(JSON.stringify(object));
     },
     decode (buffer) {
-      return JSON.parse(buffer.toString())
+      return JSON.parse(buffer.toString());
     }
-  }
-}
+  };
+};