@weave-js/core 0.11.0 → 0.12.1

package/lib/registry/collections/actionCollection.js

@@ -1,7 +1,7 @@
 // @ts-check
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
@@ -10,8 +10,8 @@
  * @typedef {import('../../types.js').Registry} Registry
  * @typedef {import('../../types.js').ServiceActionCollection} ServiceActionCollection
 */
-const { omit } = require('@weave-js/utils')
-const { createEndpointList } = require('./endpointCollection')
+const { omit } = require('@weave-js/utils');
+const { createEndpointList } = require('./endpointCollection');
 
 /**
  * Configuration object for weave service broker.
@@ -29,47 +29,51 @@ exports.createActionCollection = (registry) => {
   /**
    * @type {ServiceActionCollection}
   */
-  const actionCollection = Object.create(null)
-  const { runtime } = registry
-  const actions = new Map()
+  const actionCollection = Object.create(null);
+  const { runtime } = registry;
+  const actions = new Map();
 
   actionCollection.add = (node, service, action) => {
-    let endPointList = actions.get(action.name)
+    let endPointList = actions.get(action.name);
     if (!endPointList) {
-      endPointList = createEndpointList(runtime, action.name)
-      actions.set(action.name, endPointList)
+      endPointList = createEndpointList(runtime, action.name);
+      actions.set(action.name, endPointList);
     }
-    return endPointList.add(node, service, action)
-  }
+    return endPointList.add(node, service, action);
+  };
 
   actionCollection.get = (actionName) => {
-    return actions.get(actionName)
-  }
+    return actions.get(actionName);
+  };
 
   actionCollection.removeByService = (service) => {
     actions.forEach(list => {
-      list.removeByService(service)
-    })
-  }
+      list.removeByService(service);
+    });
+  };
 
   actionCollection.remove = (actionName, node) => {
     // todo: switch property order
-    const endpoints = actions.get(actionName)
+    const endpoints = actions.get(actionName);
     if (endpoints) {
-      endpoints.removeByNodeId(node.id)
+      endpoints.removeByNodeId(node.id);
     }
-  }
+  };
 
-  actionCollection.list = ({ onlyLocals = false, skipInternals = false, withEndpoints = false } = {}) => {
-    const result = []
+  actionCollection.list = ({
+    onlyLocals = false,
+    skipInternals = false,
+    withEndpoints = false
+  } = {}) => {
+    const result = [];
 
     actions.forEach(action => {
       if (skipInternals && /^\$node/.test(action.name)) {
-        return
+        return;
       }
 
       if (onlyLocals && !action.hasLocal()) {
-        return
+        return;
       }
 
       // todo: don't create an new object
@@ -78,17 +82,17 @@ exports.createActionCollection = (registry) => {
         hasAvailable: action.hasAvailable(),
         hasLocal: action.hasLocal(),
         count: action.count()
-      }
+      };
 
       if (item.count > 0) {
-        const endpoint = action.endpoints[0]
+        const endpoint = action.endpoints[0];
         if (endpoint) {
-          item.action = omit(endpoint.action, ['handler', 'service'])
+          item.action = omit(endpoint.action, ['handler', 'service']);
         }
       }
 
       if (item.action == null || item.action.protected) {
-        return
+        return;
       }
 
       if (withEndpoints) {
@@ -96,14 +100,14 @@ exports.createActionCollection = (registry) => {
           return {
             nodeId: endpoint.node.id,
             state: endpoint.state
-          }
-        })
+          };
+        });
       }
 
-      result.push(item)
-    })
-    return result
-  }
+      result.push(item);
+    });
+    return result;
+  };
 
-  return actionCollection
-}
+  return actionCollection;
+};

package/lib/registry/collections/endpointCollection.js

@@ -1,7 +1,7 @@
 // @ts-check
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
@@ -14,8 +14,8 @@
  * @typedef {import('../../types.js').EndpointCollection} EndpointCollection
 */
 
-const { createActionEndpoint } = require('../actionEndpoint')
-const { loadBalancingStrategy } = require('../../constants')
+const { createActionEndpoint } = require('../actionEndpoint');
+const { loadBalancingStrategy } = require('../../constants');
 
 /**
  *
@@ -26,133 +26,133 @@ const { loadBalancingStrategy } = require('../../constants')
  */
 exports.createEndpointList = (runtime, name, groupName) => {
   /** @type {EndpointCollection} */
-  const endpointList = Object.create(null)
-  const options = runtime.options
+  const endpointList = Object.create(null);
+  const options = runtime.options;
   /** @type {Array} */
-  const list = endpointList.endpoints = []
+  const list = endpointList.endpoints = [];
 
-  let counter = 0
+  let counter = 0;
 
-  endpointList.name = name
-  endpointList.groupName = groupName
-  endpointList.isInternal = name.startsWith('$')
-  endpointList.localEndpoints = []
+  endpointList.name = name;
+  endpointList.groupName = groupName;
+  endpointList.isInternal = name.startsWith('$');
+  endpointList.localEndpoints = [];
 
   const setLocalEndpoints = () => {
-    endpointList.localEndpoints = list.filter(endpoint => endpoint.isLocal)
-  }
+    endpointList.localEndpoints = list.filter(endpoint => endpoint.isLocal);
+  };
 
   /**
    * Select an Entpoint with the selected Load-Balancing-Strategy
    * @param {*} endpointList List of all available Endpoints
    * @returns {any} Endpoint
-   */
+  */
   const select = (endpointList) => {
-    // round robin
+    // Round robin
     if (options.registry.loadBalancingStrategy === loadBalancingStrategy.ROUND_ROBIN) {
       if (counter >= endpointList.length) {
-        counter = 0
+        counter = 0;
       }
-      const res = endpointList[counter++]
-      return res
+      const res = endpointList[counter++];
+      return res;
     } else {
-      const randomInt = (min, max) => Math.floor(Math.random() * (max - min + 1) + min)
-      return endpointList[randomInt(0, endpointList.length - 1)]
+      const randomInt = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
+      return endpointList[randomInt(0, endpointList.length - 1)];
       // todo: implement random load balancer
     }
-  }
+  };
 
   endpointList.add = (node, service, action) => { // todo: addaction
-    const foundEndpoint = list.find(endpoint => endpoint.node.id === node.id && endpoint.service.name === service.name)
+    const foundEndpoint = list.find(endpoint => endpoint.node.id === node.id && endpoint.service.name === service.name);
 
     if (foundEndpoint) {
-      foundEndpoint.updateAction(action)
-      return false
+      foundEndpoint.updateAction(action);
+      return false;
     }
 
-    const newEndpoint = createActionEndpoint(runtime, node, service, action)
+    const newEndpoint = createActionEndpoint(runtime, node, service, action);
 
-    list.push(newEndpoint)
-    setLocalEndpoints()
-    return true
-  }
+    list.push(newEndpoint);
+    setLocalEndpoints();
+    return true;
+  };
 
-  endpointList.hasAvailable = () => list.find(endpoint => endpoint.isAvailable()) != null
+  endpointList.hasAvailable = () => list.find(endpoint => endpoint.isAvailable()) != null;
 
-  endpointList.hasLocal = () => endpointList.localEndpoints.length > 0
+  endpointList.hasLocal = () => endpointList.localEndpoints.length > 0;
 
   endpointList.getNextAvailableEndpoint = () => {
     if (list.length === 0) {
-      return null
+      return null;
     }
 
     // If there is a local service, get a local endpoint
     if (endpointList.isInternal && endpointList.hasLocal()) {
-      return endpointList.getNextLocalEndpoint()
+      return endpointList.getNextLocalEndpoint();
     }
 
     // If only one endpoint is available return this.
     if (list.length === 1) {
-      const endpoint = list[0]
+      const endpoint = list[0];
       if (endpoint.isAvailable()) {
-        return endpoint
+        return endpoint;
       }
-      return null
+      return null;
     }
 
     if (options.registry.preferLocalActions && endpointList.hasLocal()) {
-      const endpoint = endpointList.getNextLocalEndpoint()
+      const endpoint = endpointList.getNextLocalEndpoint();
       if (endpoint && endpoint.isAvailable()) {
-        return endpoint
+        return endpoint;
       }
     }
 
-    const availableEndpoints = list.filter(endpoint => endpoint.isAvailable())
+    const availableEndpoints = list.filter(endpoint => endpoint.isAvailable());
     if (availableEndpoints.length === 0) {
-      return null
+      return null;
     }
 
-    return select(availableEndpoints)
-  }
+    return select(availableEndpoints);
+  };
 
   endpointList.getNextLocalEndpoint = () => {
     if (endpointList.localEndpoints.length === 0) {
-      return null
+      return null;
     }
 
     if (list.length === 1) {
-      const endpoint = endpointList.localEndpoints[0]
+      const endpoint = endpointList.localEndpoints[0];
       if (endpoint.isAvailable()) {
-        return endpoint
+        return endpoint;
       }
-      return null
+      return null;
     }
 
-    const availableEndpoints = endpointList.localEndpoints.filter(endpoint => endpoint.isAvailable())
+    const availableEndpoints = endpointList.localEndpoints.filter(endpoint => endpoint.isAvailable());
     if (availableEndpoints.length === 0) {
-      return null
+      return null;
     }
 
-    return select(availableEndpoints)
-  }
+    return select(availableEndpoints);
+  };
 
-  endpointList.count = () => list.length
+  endpointList.count = () => list.length;
 
-  endpointList.getByNodeId = (nodeId) => list.find(endpoint => endpoint.node.id === nodeId)
+  endpointList.getByNodeId = (nodeId) => list.find(endpoint => endpoint.node.id === nodeId);
 
   endpointList.removeByNodeId = (nodeId) => {
-    const endpointToRemove = list.find(item => item.node.id === nodeId)
-    list.splice(list.indexOf(endpointToRemove), 1)
-    setLocalEndpoints()
-  }
+    const endpointToRemove = list.find(item => item.node.id === nodeId);
+    list.splice(list.indexOf(endpointToRemove), 1);
+    setLocalEndpoints();
+  };
 
-  endpointList.removeByService = service => {
-    const endpointToRemove = list.find(endpoint => endpoint.service === service)
+  endpointList.removeByService = (service) => {
+    const endpointToRemove = list.find(endpoint => endpoint.service === service);
     if (endpointToRemove) {
-      list.splice(list.indexOf(endpointToRemove), 1)
+      list.splice(list.indexOf(endpointToRemove), 1);
     }
-    setLocalEndpoints()
-  }
+    setLocalEndpoints();
+  };
 
-  return endpointList
-}
+  return endpointList;
+};

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;
+};