@weave-js/core 0.11.1 → 0.13.0

package/lib/registry/collections/eventCollection.js

@@ -1,7 +1,7 @@
 // @ts-check
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
@@ -14,20 +14,20 @@
  * @typedef {import('../../types.js').EndpointCollection} EndpointCollection
 */
 
-const { omit, match } = require('@weave-js/utils')
-const { createEndpointList } = require('./endpointCollection')
+const { omit, match } = require('@weave-js/utils');
+const { createEndpointList } = require('./endpointCollection');
 
-const broadcastEvents = ['broadcast', 'localBroadcast']
+const broadcastEvents = ['broadcast', 'localBroadcast'];
 /**
  * Create event collection
  * @param {Registry} registry Registy reference
  * @return {EventCollection} Event collection
  */
 exports.createEventCollection = (registry) => {
-  const eventCollection = Object.create(null)
-  const { runtime } = registry
-  const events = [] // todo: refactor to js Map
-  const getAllEventsByEventName = (eventName) => events.filter(list => match(eventName, list.name))
+  const eventCollection = Object.create(null);
+  const { runtime } = registry;
+  const events = []; // todo: refactor to js Map
+  const getAllEventsByEventName = (eventName) => events.filter(list => match(eventName, list.name));
 
   /**
    * Add node to collection
@@ -37,80 +37,80 @@ exports.createEventCollection = (registry) => {
    * @return {EndpointCollection} Endpoint collection
   */
   eventCollection.add = (node, service, event) => {
-    const groupName = event.group || service.name
-    let endpointList = eventCollection.get(event.name, groupName)
+    const groupName = event.group || service.name;
+    let endpointList = eventCollection.get(event.name, groupName);
     if (!endpointList) {
-      endpointList = createEndpointList(runtime, event.name, groupName)
-      events.push(endpointList)
+      endpointList = createEndpointList(runtime, event.name, groupName);
+      events.push(endpointList);
     }
-    return endpointList.add(node, service, event)
-  }
+    return endpointList.add(node, service, event);
+  };
 
   eventCollection.get = (eventName, groupName) => {
-    return events.find(endpointList => endpointList.name === eventName && endpointList.groupName === groupName)
-  }
+    return events.find(endpointList => endpointList.name === eventName && endpointList.groupName === groupName);
+  };
 
   eventCollection.remove = (node, eventName) => {
     events.map((list) => {
       if (list.name === eventName) {
-        list.removeByNodeId(node.id)
+        list.removeByNodeId(node.id);
       }
-    })
-  }
+    });
+  };
 
   eventCollection.removeByService = (service) => {
     events.map((list) => {
-      list.removeByService(service)
-    })
-  }
+      list.removeByService(service);
+    });
+  };
 
   eventCollection.getBalancedEndpoints = (eventName, groups) => {
-    const result = []
+    const result = [];
     getAllEventsByEventName(eventName)
       .forEach((endpointList) => {
         if (groups == null || groups.length === 0 || groups.indexOf(endpointList.groupName) !== -1) {
-          const endpoint = endpointList.getNextAvailableEndpoint()
+          const endpoint = endpointList.getNextAvailableEndpoint();
           if (endpoint && endpoint.isAvailable()) {
-            result.push([endpoint, endpointList.groupName])
+            result.push([endpoint, endpointList.groupName]);
           }
         }
-      })
-    return result
-  }
+      });
+    return result;
+  };
 
   eventCollection.getAllEndpoints = (eventName) => {
     return getAllEventsByEventName(eventName)
       .map(list => list.endpoints)
       .map(endpoints => endpoints.filter(endpoint => endpoint.isAvailable()))
-      .reduce((prev, curr) => prev.concat(curr))
-  }
+      .reduce((prev, curr) => prev.concat(curr));
+  };
 
   eventCollection.getAllEndpointsUniqueNodes = (eventName, groups) => {
     let endpoints = getAllEventsByEventName(eventName)
       .filter(endpointList => (groups == null || groups.length === 0 || groups.includes(endpointList.groupName)))
-      .map(endpointList => endpointList.endpoints)
+      .map(endpointList => endpointList.endpoints);
 
     if (endpoints.length > 0) {
-      endpoints = endpoints.reduce((prev, curr) => prev.concat(curr))
+      endpoints = endpoints.reduce((prev, curr) => prev.concat(curr));
     }
 
-    const unique = {}
-    const distinct = []
+    const unique = {};
+    const distinct = [];
 
     for (const i in endpoints) {
       if (typeof (unique[endpoints[i].node.id]) === 'undefined') {
-        distinct.push(endpoints[i])
+        distinct.push(endpoints[i]);
       }
-      unique[endpoints[i].node.id] = endpoints[i].node.id
+      unique[endpoints[i].node.id] = endpoints[i].node.id;
     }
 
-    return distinct
-  }
+    return distinct;
+  };
 
   eventCollection.emitLocal = (context) => {
-    const promises = []
-    const groups = context.eventGroups
-    const isBroadcast = broadcastEvents.includes(context.eventType)
+    const promises = [];
+    const groups = context.eventGroups;
+    const isBroadcast = broadcastEvents.includes(context.eventType);
 
     getAllEventsByEventName(context.eventName)
       .filter(endpointList => (groups == null || groups.length === 0 || groups.includes(endpointList.groupName)))
@@ -118,30 +118,30 @@ exports.createEventCollection = (registry) => {
         if (isBroadcast) {
           list.endpoints.map(endpoint => {
             if (endpoint.isLocal && endpoint.action.handler) {
-              promises.push(endpoint.action.handler(context))
+              promises.push(endpoint.action.handler(context));
             }
-          })
+          });
         } else {
-          const endpoint = list.getNextLocalEndpoint()
+          const endpoint = list.getNextLocalEndpoint();
           if (endpoint && endpoint.isLocal && endpoint.action.handler) {
-            promises.push(endpoint.action.handler(context))
+            promises.push(endpoint.action.handler(context));
           }
         }
-      })
+      });
 
-    return Promise.all(promises)
-  }
+    return Promise.all(promises);
+  };
 
   eventCollection.list = ({ onlyLocals = false, skipInternals = false, withEndpoints = false } = {}) => {
-    const result = []
+    const result = [];
 
     events.forEach(list => {
       if (skipInternals && /^\$node/.test(list.name)) {
-        return
+        return;
       }
 
       if (onlyLocals && !list.hasLocal()) {
-        return
+        return;
       }
 
       const item = {
@@ -150,12 +150,12 @@ exports.createEventCollection = (registry) => {
         groupName: list.groupName,
         hasLocal: list.hasLocal(),
         count: list.count()
-      }
+      };
 
       if (item.count > 0) {
-        const endpoint = list.endpoints[0]
+        const endpoint = list.endpoints[0];
         if (endpoint) {
-          item.event = omit(endpoint.action, ['handler', 'service'])
+          item.event = omit(endpoint.action, ['handler', 'service']);
         }
       }
 
@@ -164,13 +164,13 @@ exports.createEventCollection = (registry) => {
           return {
             nodeId: endpoint.node.id,
             state: endpoint.state
-          }
-        })
+          };
+        });
       }
-      result.push(item)
-    })
-    return result
-  }
+      result.push(item);
+    });
+    return result;
+  };
 
-  return eventCollection
-}
+  return eventCollection;
+};

package/lib/registry/collections/nodeCollection.js

@@ -1,7 +1,7 @@
 // @ts-check
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
@@ -11,88 +11,88 @@
  * @typedef {import('../../types.js').NodeCollection} NodeCollection
 */
 
-const { getIpList, omit } = require('@weave-js/utils')
-const { createNode } = require('../node')
+const { getIpList, omit } = require('@weave-js/utils');
+const { createNode } = require('../node');
 /**
  * Create node collection
  * @param {Registry} registry Registry reference
  * @return {NodeCollection} Node collection
  */
 exports.createNodeCollection = (registry) => {
-  const nodeCollection = Object.create(null)
-  const { runtime } = registry
-  const nodes = new Map()
+  const nodeCollection = Object.create(null);
+  const { runtime } = registry;
+  const nodes = new Map();
 
-  nodeCollection.localNode = null
+  nodeCollection.localNode = null;
 
   nodeCollection.createNode = (nodeId) => {
-    return createNode(nodeId)
-  }
+    return createNode(nodeId);
+  };
 
   nodeCollection.add = (id, node) => {
-    nodes.set(id, node)
-  }
+    nodes.set(id, node);
+  };
 
   nodeCollection.has = (id) => {
-    return nodes.has(id)
-  }
+    return nodes.has(id);
+  };
 
   nodeCollection.get = (id) => {
-    return nodes.get(id)
-  }
+    return nodes.get(id);
+  };
 
   nodeCollection.remove = (id) => {
-    return nodes.delete(id)
-  }
+    return nodes.delete(id);
+  };
 
   nodeCollection.list = ({ withServices = true } = {}) => {
-    const result = []
+    const result = [];
     nodes.forEach(node => {
       if (withServices) {
-        result.push(omit(node, ['info']))
+        result.push(omit(node, ['info']));
       } else {
-        result.push(omit(node, ['info', 'services']))
+        result.push(omit(node, ['info', 'services']));
       }
-    })
-    return result
-  }
+    });
+    return result;
+  };
 
   nodeCollection.disconnected = (nodeId, isUnexpected) => {
-    const node = nodes.get(nodeId)
+    const node = nodes.get(nodeId);
     if (node && node.isAvailable) {
-      registry.deregisterServiceByNodeId(node.id)
-      node.disconnected(isUnexpected)
-      runtime.eventBus.broadcastLocal('$node.disconnected', nodeId, isUnexpected)
-      registry.log.warn(`Node '${node.id}'${isUnexpected ? ' unexpectedly' : ''} disconnected.`)
+      registry.deregisterServiceByNodeId(node.id);
+      node.disconnected(isUnexpected);
+      runtime.eventBus.broadcastLocal('$node.disconnected', nodeId, isUnexpected);
+      registry.log.warn(`Node '${node.id}'${isUnexpected ? ' unexpectedly' : ''} disconnected.`);
     }
-  }
+  };
 
   nodeCollection.toArray = () => {
-    const result = []
-    nodes.forEach(node => result.push(node))
-    return result
-  }
+    const result = [];
+    nodes.forEach(node => result.push(node));
+    return result;
+  };
 
   // get Local node information and add it to the collection by
   const addLocalNode = () => {
-    const node = createNode(runtime.options.nodeId)
+    const node = createNode(runtime.options.nodeId);
 
-    node.isLocal = true
-    node.IPList = getIpList()
+    node.isLocal = true;
+    node.IPList = getIpList();
     node.client = {
       type: 'nodejs',
       version: runtime.version,
       langVersion: process.version
-    }
+    };
 
-    node.sequence = 1
-    nodeCollection.add(node.id, node)
-    nodeCollection.localNode = node
+    node.sequence = 1;
+    nodeCollection.add(node.id, node);
+    nodeCollection.localNode = node;
 
-    return node
-  }
+    return node;
+  };
 
-  addLocalNode()
+  addLocalNode();
 
-  return nodeCollection
-}
+  return nodeCollection;
+};

package/lib/registry/collections/serviceCollection.js

@@ -1,7 +1,7 @@
 // @ts-check
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
@@ -12,8 +12,8 @@
 */
 
 // const { createEndpointCollection } = require('./endpoint-collection')
-const { omit, remove } = require('@weave-js/utils')
-const { createServiceItem } = require('../serviceItem')
+const { omit, remove } = require('@weave-js/utils');
+const { createServiceItem } = require('../serviceItem');
 
 /**
  * Service collection factory
@@ -22,10 +22,10 @@ const { createServiceItem } = require('../serviceItem')
 */
 exports.createServiceCollection = (registry) => {
   /** @type {ServiceCollection} */
-  const serviceCollection = Object.create(null)
-  const { runtime } = registry
-  const services = serviceCollection.services = []
-  const actions = new Map()
+  const serviceCollection = Object.create(null);
+  const { runtime } = registry;
+  const services = serviceCollection.services = [];
+  const actions = new Map();
   // const options = broker.options
 
   // const findServiceByNode = (nodeId, name) => {
@@ -33,65 +33,71 @@ exports.createServiceCollection = (registry) => {
   // }
 
   serviceCollection.add = (node, name, version, settings) => {
-    const item = createServiceItem(node, name, version, settings, node.id === runtime.nodeId)
-    services.push(item)
-    return item
-  }
+    const item = createServiceItem(node, name, version, settings, node.id === runtime.nodeId);
+    services.push(item);
+    return item;
+  };
 
-  serviceCollection.get = (nodeId, name, version) => services.find(svc => svc.equals(name, version, nodeId))
+  serviceCollection.get = (nodeId, name, version) => services.find(svc => svc.equals(name, version, nodeId));
 
   serviceCollection.has = (name, version, nodeId) => {
-    return !!services.find(svc => svc.equals(name, version, nodeId))
-  }
+    return !!services.find(svc => svc.equals(name, version, nodeId));
+  };
 
   serviceCollection.remove = (nodeId, name, version) => {
-    const service = serviceCollection.get(nodeId, name, version)
+    const service = serviceCollection.get(nodeId, name, version);
 
     if (service) {
-      registry.actionCollection.removeByService(service)
-      registry.eventCollection.removeByService(service)
-      remove(services, svc => svc === service)
+      registry.actionCollection.removeByService(service);
+      registry.eventCollection.removeByService(service);
+      remove(services, svc => svc === service);
     }
-  }
+  };
 
   serviceCollection.removeAllByNodeId = (nodeId) => {
     remove(services, service => {
       if (service.node.id === nodeId) {
-        registry.actionCollection.removeByService(service)
-        registry.eventCollection.removeByService(service)
-        return true
+        registry.actionCollection.removeByService(service);
+        registry.eventCollection.removeByService(service);
+        return true;
       }
-      return false
-    })
-  }
+      return false;
+    });
+  };
 
-  serviceCollection.tryFindActionsByActionName = (actionName) => actions.get(actionName)
+  serviceCollection.tryFindActionsByActionName = (actionName) => actions.get(actionName);
 
   serviceCollection.getActionsList = () => {
-    const result = []
+    const result = [];
     actions.forEach((action, key) => {
       const item = {
         name: key,
         count: action.count(),
         hasLocal: action.hasLocal()
-      }
-      result.push(item)
-    })
-    return result
-  }
-
-  serviceCollection.list = ({ localOnly = false, withActions = false, withEvents = false, withNodeService = false, withSettings = false }) => {
-    const result = []
+      };
+      result.push(item);
+    });
+    return result;
+  };
+
+  serviceCollection.list = ({
+    localOnly = false,
+    withActions = false,
+    withEvents = false,
+    withNodeService = false,
+    withSettings = false
+  } = {}) => {
+    const result = [];
     services.forEach((service) => {
       if (/^\$node/.test(service.name) && !withNodeService) {
-        return
+        return;
       }
       if (service.settings && service.settings.$private) {
-        return
+        return;
       }
 
       if (localOnly && !service.isLocal) {
-        return
+        return;
       }
 
       const item = {
@@ -99,39 +105,39 @@ exports.createServiceCollection = (registry) => {
         nodeId: service.node.id,
         version: service.version,
         isAvailable: service.node.isAvailable
-      }
+      };
 
       if (withSettings) {
-        item.settings = service.settings
+        item.settings = service.settings;
       }
 
       if (withActions) {
-        item.actions = {}
+        item.actions = {};
         Object.values(service.actions)
           .forEach(action => {
-            item.actions[action.name] = omit(action, ['handler', 'service'])
-          })
+            item.actions[action.name] = omit(action, ['handler', 'service']);
+          });
       }
 
       if (withEvents) {
-        item.events = {}
+        item.events = {};
         Object.values(service.events)
           .forEach(event => {
-            item.events[event.name] = omit(event, ['service', 'handler'])
-          })
+            item.events[event.name] = omit(event, ['service', 'handler']);
+          });
       }
 
-      result.push(item)
-    })
-    return result
-  }
+      result.push(item);
+    });
+    return result;
+  };
 
   serviceCollection.findEndpointByNodeId = (actionName, nodeId) => {
-    const endpointListItem = serviceCollection.tryFindActionsByActionName(actionName)
+    const endpointListItem = serviceCollection.tryFindActionsByActionName(actionName);
     if (endpointListItem) {
-      return endpointListItem.endpointByNodeId(nodeId)
+      return endpointListItem.endpointByNodeId(nodeId);
     }
-  }
+  };
 
-  return serviceCollection
-}
+  return serviceCollection;
+};

package/lib/registry/eventEndpoint.js

@@ -1,26 +1,26 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
 exports.createEventEndpoint = (broker, node, service, event) => {
-  const eventEndpoint = Object.create(null)
+  const eventEndpoint = Object.create(null);
 
-  eventEndpoint.node = node
-  eventEndpoint.service = service
-  eventEndpoint.action = event
-  eventEndpoint.isLocal = eventEndpoint.node.id === broker.nodeId
-  eventEndpoint.state = true
-  eventEndpoint.name = `${node.id}:${event.name}`
+  eventEndpoint.node = node;
+  eventEndpoint.service = service;
+  eventEndpoint.action = event;
+  eventEndpoint.isLocal = eventEndpoint.node.id === broker.nodeId;
+  eventEndpoint.state = true;
+  eventEndpoint.name = `${node.id}:${event.name}`;
 
   eventEndpoint.updateEvent = (newEvent) => {
-    eventEndpoint.action = newEvent
-  }
+    eventEndpoint.action = newEvent;
+  };
 
   eventEndpoint.isAvailable = () => {
-    return eventEndpoint.state
-  }
+    return eventEndpoint.state;
+  };
 
-  return eventEndpoint
-}
+  return eventEndpoint;
+};

package/lib/registry/load-balancer/base.js

@@ -1,7 +1,7 @@
 module.exports = (broker, registry) => {
   return {
     next (/* endpointList,context*/) {
-      broker.handleError(new Error('Method not implemented!'))
+      broker.handleError(new Error('Method not implemented!'));
     }
-  }
-}
+  };
+};

package/lib/registry/load-balancer/index.js

@@ -1,22 +1,22 @@
 const Strategies = {
   Random: require('./random'),
   RoundRobin: require('./round-robin')
-}
+};
 const getByName = name => {
   if (!name) {
-    return null
+    return null;
   }
 
-  const n = Object.keys(Strategies).find(n => n.toLowerCase() === name.toLowerCase())
+  const n = Object.keys(Strategies).find(n => n.toLowerCase() === name.toLowerCase());
   if (n) {
-    return this.Cache[n]
+    return this.Cache[n];
   }
-}
+};
 
 module.exports = {
   resolve (option) {
     if (typeof option === 'string') {
-      return getByName(option)
+      return getByName(option);
     }
   }
-}
+};