@weave-js/core 0.10.0 → 0.12.0

package/lib/runtime/{init-eventbus.js → initEventbus.js}

@@ -1,5 +1,5 @@
 exports.initEventbus = (runtime) => {
-  const { options: brokerOptions, bus, registry, contextFactory } = runtime
+  const { options: brokerOptions, bus, registry, contextFactory } = runtime;
 
   /**
    * Emit a event on all services (grouped and load balanced).
@@ -10,59 +10,60 @@ exports.initEventbus = (runtime) => {
   */
   const emit = (eventName, payload, options) => {
     if (Array.isArray(options)) {
-      options = { groups: options }
+      options = { groups: options };
     } else if (options == null) {
-      options = {}
+      options = {};
     }
 
-    const promises = []
-    // todo: create an event context object
-    const context = contextFactory.create(null, payload, options)
-
-    context.eventType = 'emit'
-    context.eventName = eventName
-    context.eventGroups = options.groups
-
-    // Emit system events
+    // Emit local events
     if (/^\$/.test(eventName)) {
-      bus.emit(eventName, payload)
+      bus.emit(eventName, payload);
     }
 
-    const endpoints = registry.eventCollection.getBalancedEndpoints(eventName, options.groups)
-    const groupedEndpoints = {}
+    // todo: create an event context object
+    const context = contextFactory.create(null, payload, options);
+
+    context.eventType = 'emit';
+    context.eventName = eventName;
+    context.eventGroups = options.groups;
+
+    const endpoints = registry.eventCollection.getBalancedEndpoints(eventName, options.groups);
+    const groupedEndpoints = {};
+    const promises = [];
 
     endpoints.map(([endpoint, groupName]) => {
       if (endpoint) {
         if (endpoint.node.id === brokerOptions.nodeId) {
           // Local event. Call handler
-          promises.push(endpoint.action.handler(context))
+          context.setEndpoint(endpoint);
+          promises.push(endpoint.action.handler(context));
         } else {
-          const e = groupedEndpoints[endpoint.node.id]
+          const e = groupedEndpoints[endpoint.node.id];
           if (e) {
-            e.groups.push(groupName)
+            e.groups.push(groupName);
           } else {
             groupedEndpoints[endpoint.node.id] = {
               endpoint,
               groups: [groupName]
-            }
+            };
           }
         }
       }
-    })
+    });
 
-    // send remote events
+    // Send remote events
     if (runtime.transport) {
       Object.values(groupedEndpoints)
         .forEach(groupedEndpoint => {
-          const newContext = context.copy()
-          newContext.setEndpoint(groupedEndpoint.endpoint)
-          newContext.eventGroups = groupedEndpoint.groups
-          promises.push(runtime.transport.sendEvent(newContext))
-        })
+          const newContext = context.copy();
+          newContext.setEndpoint(groupedEndpoint.endpoint);
+          newContext.eventGroups = groupedEndpoint.groups;
+          promises.push(runtime.transport.sendEvent(newContext));
+        });
     }
 
-    return Promise.all(promises)
-  }
+    return Promise.all(promises);
+  };
 
   /**
   * Send a broadcasted event to all local services.
@@ -74,22 +75,22 @@ exports.initEventbus = (runtime) => {
   const broadcastLocal = (eventName, payload, options) => {
     // If the given group is no array - wrap it.
     if (Array.isArray(options)) {
-      options = { groups: options }
+      options = { groups: options };
     } else if (options == null) {
-      options = {}
+      options = {};
     }
 
-    const context = contextFactory.create(null, payload, options)
-    context.eventType = 'broadcastLocal'
-    context.eventName = eventName
+    const context = contextFactory.create(null, payload, options);
+    context.eventType = 'broadcastLocal';
+    context.eventName = eventName;
 
     // Emit the event on the internal event bus
     if (/^\$/.test(eventName)) {
-      bus.emit(eventName, payload)
+      bus.emit(eventName, payload);
     }
 
-    return registry.eventCollection.emitLocal(context)
-  }
+    return registry.eventCollection.emitLocal(context);
+  };
 
   /**
   * Send a broadcasted event to all services.
@@ -100,38 +101,38 @@ exports.initEventbus = (runtime) => {
   */
   const broadcast = (eventName, payload, options) => {
     if (Array.isArray(options)) {
-      options = { groups: options }
+      options = { groups: options };
     } else if (options == null) {
-      options = {}
+      options = {};
     }
 
-    const promises = []
+    const promises = [];
 
     if (runtime.transport) {
       // create context
       // todo: create an event context object
-      const context = contextFactory.create(null, payload, options)
-      context.eventType = 'broadcast'
-      context.eventName = eventName
-      context.eventGroups = options.groups
+      const context = contextFactory.create(null, payload, options);
+      context.eventType = 'broadcast';
+      context.eventName = eventName;
+      context.eventGroups = options.groups;
 
       // Avoid to broadcast internal events.
       if (!/^\$/.test(eventName)) {
-        const endpoints = registry.eventCollection.getAllEndpointsUniqueNodes(eventName, options.groups)
+        const endpoints = registry.eventCollection.getAllEndpointsUniqueNodes(eventName, options.groups);
 
         endpoints.map(endpoint => {
           if (endpoint.node.id !== brokerOptions.nodeId) {
-            const newContext = context.copy()
-            newContext.setEndpoint(endpoint)
-            promises.push(runtime.transport.sendEvent(newContext))
+            const newContext = context.copy();
+            newContext.setEndpoint(endpoint);
+            promises.push(runtime.transport.sendEvent(newContext));
           }
-        })
+        });
       }
     }
 
-    promises.push(broadcastLocal(eventName, payload, options))
-    return Promise.all(promises)
-  }
+    promises.push(broadcastLocal(eventName, payload, options));
+    return Promise.all(promises);
+  };
 
   Object.defineProperty(runtime, 'eventBus', {
     value: {
@@ -139,5 +140,5 @@ exports.initEventbus = (runtime) => {
       broadcast,
       broadcastLocal
     }
-  })
-}
+  });
+};

package/lib/runtime/{init-logger.js → initLogger.js}

@@ -4,8 +4,8 @@
  * @typedef {import('../types.js').Transport} Transport
 */
 
-const { defaultsDeep } = require('@weave-js/utils')
-const { createLogger: createDefaultLogger } = require('../logger/index')
+const { defaultsDeep } = require('@weave-js/utils');
+const { createLogger: createDefaultLogger } = require('../logger/index');
 
 /**
  * Init logger
@@ -18,11 +18,11 @@ exports.initLogger = (runtime) => {
       nodeId: runtime.options.nodeId,
       moduleName,
       ...additional
-    }
+    };
 
     // custom logger generator function.
     if (typeof runtime.options.logger === 'function') {
-      return runtime.options.logger(bindings, runtime.options.logger.level)
+      return runtime.options.logger(bindings, runtime.options.logger.level);
     }
 
     // merge log options
@@ -30,18 +30,18 @@ exports.initLogger = (runtime) => {
       base: {
         ...bindings
       }
-    }, runtime.options.logger)
+    }, runtime.options.logger);
 
-    return createDefaultLogger(loggerOptions)
-  }
+    return createDefaultLogger(loggerOptions);
+  };
 
-  const createLogger = (moduleName, service) => loggerFactory(runtime, moduleName, service)
+  const createLogger = (moduleName, service) => loggerFactory(runtime, moduleName, service);
 
   // create weave default logger
-  const log = createLogger('WEAVE')
+  const log = createLogger('WEAVE');
 
   Object.assign(runtime, {
     createLogger,
     log
-  })
-}
+  });
+};

package/lib/runtime/{init-metrics.js → initMetrics.js}

@@ -1,6 +1,7 @@
-const { isPlainObject, isFunction } = require('@weave-js/utils')
-const { registerCommonMetrics, updateCommonMetrics } = require('../metrics/common')
-const MetricTypes = require('../metrics/types')
+const { isPlainObject, isFunction } = require('@weave-js/utils');
+const { WeaveError } = require('../errors');
+const { registerCommonMetrics, updateCommonMetrics } = require('../metrics/common');
+const MetricTypes = require('../metrics/types');
 
 /**
  * @typedef {import('../types.js').Runtime} Runtime
@@ -12,15 +13,15 @@ const MetricTypes = require('../metrics/types')
  * @returns {void}
  */
 exports.initMetrics = (runtime) => {
-  const metricOptions = runtime.options.metrics
+  const metricOptions = runtime.options.metrics;
 
   if (metricOptions.enabled) {
-    const storage = new Map()
+    const storage = new Map();
 
-    const log = runtime.createLogger('METRICS')
+    const log = runtime.createLogger('METRICS');
 
     /** @type {NodeJS.Timeout} */
-    let commonUpdateTimer
+    let commonUpdateTimer;
 
     Object.defineProperty(runtime, 'metrics', {
       value: {
@@ -32,101 +33,101 @@ exports.initMetrics = (runtime) => {
           // Load adapters
           if (metricOptions.adapters) {
             if (!Array.isArray(metricOptions.adapters)) {
-              runtime.handleError(new Error('Metic adapter needs to be an Array'))
+              runtime.handleError(new WeaveError('Metic adapter needs to be an Array.'));
             }
 
             this.adapters = metricOptions.adapters.map(adapter => {
-              adapter.init(this)
-              return adapter
-            })
+              adapter.init(this);
+              return adapter;
+            });
           }
         },
         stop () {
           if (commonUpdateTimer) {
-            clearInterval(commonUpdateTimer)
+            clearInterval(commonUpdateTimer);
           }
 
-          return Promise.all(this.adapters.map(adapter => adapter.stop()))
+          return Promise.all(this.adapters.map(adapter => adapter.stop()));
         },
         register (obj) {
           if (!isPlainObject(obj)) {
-            runtime.handleError(new Error('Param needs to be an object.'))
+            runtime.handleError(new WeaveError('Param needs to be an object.'));
           }
 
           if (!obj.type) {
-            runtime.handleError(new Error('Type is missing.'))
+            runtime.handleError(new WeaveError('Type is missing.'));
           }
 
           if (!obj.name) {
-            runtime.handleError(new Error('Name is missing.'))
+            runtime.handleError(new WeaveError('Name is missing.'));
           }
 
-          const createMetricType = MetricTypes.resolve(obj.type)
+          const createMetricType = MetricTypes.resolve(obj.type);
 
           if (!createMetricType) {
-            runtime.handleError(new Error('Unknown metric type.'))
+            runtime.handleError(new WeaveError('Unknown metric type.'));
           }
 
-          const type = createMetricType(this, obj)
+          const type = createMetricType(this, obj);
 
-          this.storage.set(obj.name, type)
+          this.storage.set(obj.name, type);
 
-          return type
+          return type;
         },
         increment (name, labels, value = 1, timestamp) {
           if (!metricOptions.enabled) {
-            return null
+            return null;
           }
 
-          const item = this.storage.get(name)
+          const item = this.storage.get(name);
 
           if (!item) {
-            runtime.handleError(new Error('Item not found.'))
+            runtime.handleError(new WeaveError('Item not found.'));
           }
 
-          item.increment(labels, value, timestamp)
+          item.increment(labels, value, timestamp);
         },
         decrement (name, labels, value = 1, timestamp) {
           if (!metricOptions.enabled) {
-            return null
+            return null;
           }
 
-          const item = this.storage.get(name)
+          const item = this.storage.get(name);
 
           if (!item) {
-            runtime.handleError(new Error('Item not found.'))
+            runtime.handleError(new WeaveError('Item not found.'));
           }
 
-          item.decrement(labels, value, timestamp)
+          item.decrement(labels, value, timestamp);
         },
         set (name, value, labels, timestamp) {
           if (!metricOptions.enabled) {
-            return null
+            return null;
           }
 
-          const item = this.storage.get(name)
+          const item = this.storage.get(name);
 
           if (!isFunction(item.set)) {
-            runtime.handleError(new Error('Invalid metric type'))
+            runtime.handleError(new WeaveError('Invalid metric type'));
           }
 
-          item.set(value, labels, timestamp)
+          item.set(value, labels, timestamp);
         },
         timer (name, labels, timestamp) {
-          let item
+          let item;
           if (name) {
-            item = this.storage.get(name)
+            item = this.storage.get(name);
           }
-          const start = process.hrtime()
+          const start = process.hrtime();
 
           return () => {
-            const delta = process.hrtime(start)
-            const duration = (delta[0] + delta[1] / 1e9) * 1000
+            const delta = process.hrtime(start);
+            const duration = (delta[0] + delta[1] / 1e9) * 1000;
             if (item) {
-              item.set(duration, labels, timestamp)
+              item.set(duration, labels, timestamp);
             }
-            return duration
-          }
+            return duration;
+          };
           // const item = this.storage.get(name)
           // if (item) {
 
@@ -134,30 +135,30 @@ exports.initMetrics = (runtime) => {
           // item.observe(labels, value, timestamp)
         },
         getMetric (name) {
-          const item = this.storage.get(name)
+          const item = this.storage.get(name);
 
           if (!item) {
-            runtime.handleError(new Error('Item not found.'))
+            runtime.handleError(new WeaveError('Item not found.'));
           }
 
-          return item
+          return item;
         },
-        list (options = {}) {
-          const results = []
+        list (/* options = {} */) {
+          const results = [];
 
           this.storage.forEach(metric => {
-            results.push(metric.toObject())
-          })
+            results.push(metric.toObject());
+          });
 
-          return results
+          return results;
         }
       }
-    })
+    });
 
     if (metricOptions.enabled && metricOptions.collectCommonMetrics) {
-      registerCommonMetrics(runtime)
-      commonUpdateTimer = setInterval(() => updateCommonMetrics(runtime), metricOptions.collectInterval)
-      commonUpdateTimer.unref()
+      registerCommonMetrics(runtime);
+      commonUpdateTimer = setInterval(() => updateCommonMetrics(runtime), metricOptions.collectInterval);
+      commonUpdateTimer.unref();
     }
   }
-}
+};

package/lib/runtime/{init-middleware-manager.js → initMiddlewareManager.js}

@@ -1,71 +1,71 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
 exports.initMiddlewareHandler = (runtime) => {
-  const list = []
+  const list = [];
 
   Object.defineProperty(runtime, 'middlewareHandler', {
     value: {
       count () {
-        return list.length
+        return list.length;
       },
       add (middleware) {
         if (!middleware) {
-          return
+          return;
         }
 
         if (typeof middleware === 'function') {
-          middleware = middleware.call(runtime, runtime)
+          middleware = middleware.call(runtime, runtime);
         }
 
-        list.push(middleware)
+        list.push(middleware);
       },
       wrapMethod (methodName, handler, bindTo = runtime) {
         if (list.length) {
-          const middlewareList = list.filter(middleware => !!middleware[methodName])
+          const middlewareList = list.filter(middleware => !!middleware[methodName]);
           if (middlewareList.length) {
-            handler = middlewareList.reduce((next, middleware) => middleware[methodName].call(runtime, next), handler.bind(bindTo))
+            handler = middlewareList.reduce((next, middleware) => middleware[methodName].call(runtime, next), handler.bind(bindTo));
           }
         }
-        return handler
+        return handler;
       },
       wrapHandler (methodName, handler, definition) {
         if (list.length) {
           handler = list.reduce((handler, middleware) => {
             if (typeof middleware[methodName] === 'function') {
-              return middleware[methodName].call(runtime, handler, definition)
+              return middleware[methodName].call(runtime, handler, definition);
             } else {
-              return handler
+              return handler;
             }
-          }, handler)
+          }, handler);
         }
-        return handler
+        return handler;
       },
       callHandlersAsync (methodName, args, reverse = false) {
-        const middlewareList = reverse ? Array.from(list).reverse() : list
+        const middlewareList = reverse ? Array.from(list).reverse() : list;
         const momentousHandlers = middlewareList
           .filter(middleware => typeof middleware[methodName] === 'function')
-          .map(middleware => middleware[methodName])
+          .map(middleware => middleware[methodName]);
 
         if (momentousHandlers.length) {
-          return momentousHandlers.reduce((p, func) => p.then(() => func.apply(runtime, args)), Promise.resolve())
+          return momentousHandlers.reduce((p, func) => p.then(() => func.apply(runtime, args)), Promise.resolve());
         }
 
-        return Promise.resolve()
+        return Promise.resolve();
       },
       callHandlersSync (methodName, args, reverse = false) {
         if (list.length) {
-          const middlewareList = reverse ? Array.from(list).reverse() : list
+          const middlewareList = reverse ? Array.from(list).reverse() : list;
 
           middlewareList
             .filter(middleware => typeof middleware[methodName] === 'function')
             .map(middleware => middleware[methodName])
-            .forEach(handler => handler.apply(runtime, args))
+            .forEach(handler => handler.apply(runtime, args));
         }
       }
     }
-  })
-}
+  });
+};

package/lib/runtime/{init-registry.js → initRegistry.js}

@@ -1,13 +1,13 @@
 // @ts-check
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
 /**
  * @typedef {import('../types').Runtime} Runtime
 */
-const { createRegistry } = require('../registry/registry.js')
+const { createRegistry } = require('../registry/registry.js');
 
 /**
  * Injects registy in runtime
@@ -15,11 +15,11 @@ const { createRegistry } = require('../registry/registry.js')
  * @returns {void}
 */
 exports.initRegistry = (runtime) => {
-  const registry = createRegistry(runtime)
+  const registry = createRegistry(runtime);
 
-  registry.init(runtime)
+  registry.init(runtime);
 
   Object.defineProperty(runtime, 'registry', {
     value: registry
-  })
-}
+  });
+};