@weave-js/core 0.10.0 → 0.12.0

package/lib/registry/registry.js

@@ -1,6 +1,6 @@
 // @ts-check
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
@@ -18,18 +18,18 @@
  * @typedef {import('../types.js').ServiceChangedDelegate} ServiceChangedDelegate
 */
 
-const { safeCopy } = require('@weave-js/utils')
+const { safeCopy } = require('@weave-js/utils');
 
 // own packages
-const { createNodeCollection } = require('./collections/node-collection')
-const { createServiceCollection } = require('./collections/service-collection')
-const { createActionCollection } = require('./collections/action-collection')
-const { createEventCollection } = require('./collections/event-collection')
-const { createActionEndpoint } = require('./action-endpoint')
-const { createNode } = require('./node')
-const { WeaveServiceNotFoundError, WeaveServiceNotAvailableError } = require('../errors')
+const { createNodeCollection } = require('./collections/nodeCollection');
+const { createServiceCollection } = require('./collections/serviceCollection');
+const { createActionCollection } = require('./collections/actionCollection');
+const { createEventCollection } = require('./collections/eventCollection');
+const { createActionEndpoint } = require('./actionEndpoint');
+const { createNode } = require('./node');
+const { WeaveServiceNotFoundError, WeaveServiceNotAvailableError } = require('../errors');
 
-const noop = () => {}
+const noop = () => {};
 
 /**
  * Registry factory
@@ -37,7 +37,7 @@ const noop = () => {}
  * @returns {Registry} Registry
 */
 exports.createRegistry = (runtime) => {
-  const { middlewareHandler } = runtime
+  const { middlewareHandler } = runtime;
 
   /**
    * @type {Registry}
@@ -47,277 +47,267 @@ exports.createRegistry = (runtime) => {
     log: runtime.createLogger('REGISTRY'),
     /**
    * Initialize the registry
-   * @param {Broker} runtime Broker instance
-   * @param {MiddlewareHandler} middlewareHandler Middleware handler
-   * @param {ServiceChangedDelegate} serviceChanged Service changed delegate
+   * @param {Runtime} runtime Runtime
    * @returns {void}
    */
     init (runtime) {
-      /**
-       * @type {Broker}
-      */
-
-      /**
-       * @type {MiddlewareHandler}
-      */
-
-      /**
-       * @type {ServiceChangedDelegate}
-      */
-
       // init collections
-      this.nodeCollection = createNodeCollection(this)
-      this.serviceCollection = createServiceCollection(this)
-      this.actionCollection = createActionCollection(this)
-      this.eventCollection = createEventCollection(this)
+      this.nodeCollection = createNodeCollection(this);
+      this.serviceCollection = createServiceCollection(this);
+      this.actionCollection = createActionCollection(this);
+      this.eventCollection = createEventCollection(this);
 
       // register an event handler for "$broker.started".
       runtime.bus.on('$broker.started', () => {
         if (this.nodeCollection.localNode) {
-          this.generateLocalNodeInfo(true)
+          this.generateLocalNodeInfo(true);
         }
-      })
+      });
     },
     onRegisterLocalAction: noop,
     onRegisterRemoteAction: noop,
     checkActionVisibility (action, node) {
-      if (typeof action.visibility === 'undefined' || action.visibility === 'public') {
-        return true
+      if (
+        typeof action.visibility === 'undefined' ||
+        action.visibility === 'public' ||
+        action.visibility === 'published'
+      ) {
+        return true;
       }
 
+      // Only callable from local services.
       if (action.visibility === 'protected' && node.isLocal) {
-        return true
+        return true;
       }
 
-      return false
+      return false;
     },
     registerLocalService (serviceSpecification) {
       if (!this.serviceCollection.has(serviceSpecification.name, serviceSpecification.version, runtime.nodeId)) {
-        const service = this.serviceCollection.add(this.nodeCollection.localNode, serviceSpecification.name, serviceSpecification.version, serviceSpecification.settings)
+        const service = this.serviceCollection.add(this.nodeCollection.localNode, serviceSpecification.name, serviceSpecification.version, serviceSpecification.settings);
 
         if (serviceSpecification.actions) {
-          this.registerActions(this.nodeCollection.localNode, service, serviceSpecification.actions)
+          this.registerActions(this.nodeCollection.localNode, service, serviceSpecification.actions);
         }
 
         if (serviceSpecification.events) {
-          this.registerEvents(this.nodeCollection.localNode, service, serviceSpecification.events)
+          this.registerEvents(this.nodeCollection.localNode, service, serviceSpecification.events);
         }
 
-        this.nodeCollection.localNode.services.push(service)
+        this.nodeCollection.localNode.services.push(service);
 
-        this.generateLocalNodeInfo(runtime.state.isStarted)
+        this.generateLocalNodeInfo(runtime.state.isStarted);
 
         if (serviceSpecification.version) {
-          this.log.info(`Service '${service.name}' (v${serviceSpecification.version}) registered.`)
+          this.log.info(`Service '${service.name}' (v${serviceSpecification.version}) registered.`);
         } else {
-          this.log.info(`Service '${service.name}' registered.`)
+          this.log.info(`Service '${service.name}' registered.`);
         }
 
-        runtime.services.serviceChanged(true)
+        runtime.services.serviceChanged(true);
       }
     },
     registerRemoteServices (node, services) {
       services.forEach((service) => {
         // todo: handle events
-        let oldActions
-        let oldEvents
-        let svc = this.serviceCollection.get(node.id, service.name, service.version)
+        let oldActions;
+        let oldEvents;
+        let svc = this.serviceCollection.get(node.id, service.name, service.version);
 
         if (!svc) {
-          svc = this.serviceCollection.add(node, service.name, service.version, service.settings)
+          svc = this.serviceCollection.add(node, service.name, service.version, service.settings);
         } else {
           // Update existing service with new actions
-          oldActions = Object.assign({}, svc.actions)
-          oldEvents = Object.assign({}, svc.events)
-          svc.update(service)
+          oldActions = Object.assign({}, svc.actions);
+          oldEvents = Object.assign({}, svc.events);
+          svc.update(service);
         }
 
         if (service.actions) {
-          this.registerActions(node, svc, service.actions)
+          this.registerActions(node, svc, service.actions);
         }
 
         if (service.events) {
-          this.registerEvents(node, svc, service.events)
+          this.registerEvents(node, svc, service.events);
         }
 
         if (oldActions) {
-          // this.deregisterAction()
           Object.keys(oldActions).forEach(actionName => {
             if (!service.actions[actionName]) {
-              this.actionCollection.remove(actionName, node)
+              this.actionCollection.remove(actionName, node);
             }
-          })
+          });
         }
 
         if (oldEvents) {
           Object.keys(oldEvents).forEach(eventName => {
             if (!service.actions[eventName]) {
-              this.eventCollection.remove(eventName, node)
+              this.eventCollection.remove(eventName, node);
             }
-          })
+          });
         }
-      })
+      });
 
       // remove old services
-      const oldServices = Array.from(this.serviceCollection.services)
-      oldServices.forEach((service) => {
-        if (service.node.id !== node.id) return
+      const oldServices = Array.from(this.serviceCollection.services);
+      oldServices.forEach((oldService) => {
+        if (oldService.node.id !== node.id) {
+          return;
+        }
 
-        let isExisting = false
+        let isExisting = false;
 
+        // check if the old service exists in the new services.
         services.forEach((svc) => {
-          if (service.equals(svc.name, svc.version)) {
-            isExisting = true
+          if (oldService.equals(svc.name, svc.version)) {
+            isExisting = true;
           }
-        })
+        });
 
         if (!isExisting) {
-          this.deregisterService(service.name, service.version, node.id)
+          this.deregisterService(oldService.name, oldService.version, node.id);
         }
-      })
+      });
 
-      runtime.services.serviceChanged(false)
+      runtime.services.serviceChanged(false);
     },
     registerEvents (node, service, events) {
       Object.keys(events).forEach((key) => {
-        const event = events[key]
+        const event = events[key];
 
         if (node.isLocal) {
-          event.handler = middlewareHandler.wrapHandler('localEvent', event.handler, event) // this.onRegisterLocalEvent(event)
+          event.handler = middlewareHandler.wrapHandler('localEvent', event.handler, event); // this.onRegisterLocalEvent(event)
         }
 
-        this.eventCollection.add(node, service, event)
-        service.addEvent(event)
-      })
+        this.eventCollection.add(node, service, event);
+        service.addEvent(event);
+      });
     },
     registerActions (node, service, actions) {
       Object.keys(actions).forEach((key) => {
-        const action = actions[key]
+        const action = actions[key];
 
         if (!this.checkActionVisibility(action, node)) {
-          return
+          return;
         }
 
         if (node.isLocal) {
-          action.handler = middlewareHandler.wrapHandler('localAction', action.handler, action)// this.onRegisterLocalAction(action)
+          action.handler = middlewareHandler.wrapHandler('localAction', action.handler, action);
         } else {
-          action.handler = middlewareHandler.wrapHandler('remoteAction', runtime.transport.request.bind(runtime.transport), action)// this.onRegisterRemoteAction(action)
+          action.handler = middlewareHandler.wrapHandler('remoteAction', runtime.transport.sendRequest.bind(runtime.transport), action);
         }
 
-        this.actionCollection.add(node, service, action)
+        this.actionCollection.add(node, service, action);
 
-        service.addAction(action)
-      })
-    },
-    getActionList (options) {
-      return this.actionCollection.list(options)
+        service.addAction(action);
+      });
     },
     deregisterService (name, version, nodeId) {
-      this.serviceCollection.remove(nodeId || runtime.nodeId, name, version)
+      this.serviceCollection.remove(nodeId || runtime.nodeId, name, version);
 
-      // It must be a local service
+      // It must be a local service if there is no node ID.
       if (!nodeId) {
-        const serviceToRemove = this.nodeCollection.localNode.services.find(service => service.name === name)
-        this.nodeCollection.localNode.services.splice(this.nodeCollection.localNode.services.indexOf(serviceToRemove), 1)
+        const serviceToRemove = this.nodeCollection.localNode.services.find(service => service.name === name);
+        this.nodeCollection.localNode.services.splice(this.nodeCollection.localNode.services.indexOf(serviceToRemove), 1);
       }
 
       if (!nodeId || nodeId === runtime.nodeId) {
-        this.generateLocalNodeInfo(true)
+        this.generateLocalNodeInfo(true);
       }
     },
     deregisterServiceByNodeId (nodeId) {
-      return this.serviceCollection.removeAllByNodeId(nodeId)
+      return this.serviceCollection.removeAllByNodeId(nodeId);
     },
     hasService (serviceName, version, nodeId) {
-      return this.serviceCollection.has(serviceName, version, nodeId)
+      return this.serviceCollection.has(serviceName, version, nodeId);
     },
     getNextAvailableActionEndpoint (actionName, opts = {}) {
       // Handle direct endpoint call.
       if (typeof actionName !== 'string') {
-        return actionName
+        return actionName;
       } else {
         // check if the action call is intended for a specific remote node
         if (opts.nodeId) {
-          const endpoint = this.getActionEndpointByNodeId(actionName, opts.nodeId)
+          const endpoint = this.getActionEndpointByNodeId(actionName, opts.nodeId);
 
           // no endpoint for this action & node ID found
           if (!endpoint) {
-            this.log.warn(`Service "${actionName}" is not registered on node ${opts.nodeId}.`)
-            return new WeaveServiceNotFoundError({ actionName, nodeId: opts.nodeId })
+            this.log.warn(`Service "${actionName}" is not registered on node ${opts.nodeId}.`);
+            return new WeaveServiceNotFoundError({ actionName, nodeId: opts.nodeId });
           }
 
-          return endpoint
+          return endpoint;
         } else {
-          const endpointList = this.getActionEndpoints(actionName)
+          const endpointList = this.getActionEndpoints(actionName);
 
           if (!endpointList) {
-            this.log.warn(`Service "${actionName}" is not registered.`)
-            return new WeaveServiceNotFoundError({ actionName })
+            this.log.warn(`Service "${actionName}" is not registered.`);
+            return new WeaveServiceNotFoundError({ actionName });
           }
 
-          const endpoint = endpointList.getNextAvailableEndpoint()
+          const endpoint = endpointList.getNextAvailableEndpoint();
 
           if (!endpoint) {
-            this.log.warn(`Service "${actionName}" is not available.`)
-            return new WeaveServiceNotAvailableError({ actionName })
+            this.log.warn(`Service "${actionName}" is not available.`);
+            return new WeaveServiceNotAvailableError({ actionName });
           }
 
-          return endpoint
+          return endpoint;
         }
       }
     },
     getActionEndpointByNodeId (actionName, nodeId) {
-      const endpointList = this.getActionEndpoints(actionName)
+      const endpointList = this.getActionEndpoints(actionName);
       if (endpointList) {
-        return endpointList.getByNodeId(nodeId)
+        return endpointList.getByNodeId(nodeId);
       }
-      return null
+      return null;
     },
     getActionEndpoints (actionName) {
-      return this.actionCollection.get(actionName)
+      return this.actionCollection.get(actionName);
     },
     createPrivateActionEndpoint (action) {
-      return createActionEndpoint(runtime, this.nodeCollection.localNode, action.service, action)
+      return createActionEndpoint(runtime, this.nodeCollection.localNode, action.service, action);
     },
     getLocalActionEndpoint (actionName) {
-      const endpointList = this.getActionEndpoints(actionName)
+      const endpointList = this.getActionEndpoints(actionName);
 
       if (!endpointList) {
-        this.log.warn(`Service "${actionName}" is not registered localy.`)
-        runtime.handleError(new WeaveServiceNotFoundError({ actionName }))
+        this.log.warn(`Service "${actionName}" is not registered localy.`);
+        runtime.handleError(new WeaveServiceNotFoundError({ actionName }));
       }
 
-      const endpoint = endpointList.getNextLocalEndpoint()
+      const endpoint = endpointList.getNextLocalEndpoint();
 
       if (!endpoint) {
-        this.log.warn(`Service "${actionName}" is not available localy.`)
-        runtime.handleError(new WeaveServiceNotAvailableError({ actionName }))
+        this.log.warn(`Service "${actionName}" is not available localy.`);
+        runtime.handleError(new WeaveServiceNotAvailableError({ actionName }));
       }
 
-      return endpoint
+      return endpoint;
     },
     getNodeInfo (nodeId) {
-      const node = this.nodeCollection.get(nodeId)
+      const node = this.nodeCollection.get(nodeId);
 
       if (!node) {
-        return null
+        return null;
       }
 
-      return node.info
+      return node.info;
     },
     getLocalNodeInfo (forceGenerateInfo) {
       if (forceGenerateInfo || !this.nodeCollection.localNode.info) {
-        return this.generateLocalNodeInfo()
+        return this.generateLocalNodeInfo();
       }
 
-      return this.nodeCollection.localNode.info
+      return this.nodeCollection.localNode.info;
     },
     generateLocalNodeInfo (incrementSequence = false) {
-      const { client, IPList, sequence } = this.nodeCollection.localNode
-      const nodeInfo = { client, IPList, sequence }
+      const { client, IPList, sequence } = this.nodeCollection.localNode;
+      const nodeInfo = { client, IPList, sequence };
 
       if (incrementSequence) {
-        this.nodeCollection.localNode.sequence++
+        this.nodeCollection.localNode.sequence++;
       }
 
       if (runtime.state.isStarted) {
@@ -327,86 +317,80 @@ exports.createRegistry = (runtime) => {
           withEvents: true,
           withNodeService: runtime.options.registry.publishNodeService,
           withSettings: true
-        })
+        });
       } else {
-        nodeInfo.services = []
+        nodeInfo.services = [];
       }
 
-      this.nodeCollection.localNode.info = safeCopy(nodeInfo)
-      return this.nodeCollection.localNode.info
+      this.nodeCollection.localNode.info = safeCopy(nodeInfo);
+      return this.nodeCollection.localNode.info;
     },
     processNodeInfo (payload) {
       /**
        * @type {string}
       */
-      const nodeId = payload.sender
+      const nodeId = payload.sender;
 
       /**
        * @type {Node}
       */
-      let node = this.nodeCollection.get(nodeId)
+      let node = this.nodeCollection.get(nodeId);
 
       /**
        * @type {boolean}
       */
-      let isNew = false
+      let isNew = false;
 
       /**
        * @type {boolean}
       */
-      let isReconnected = false
+      let isReconnected = false;
 
       // There is no node with the specified ID. It must therefore be a new node.
       if (!node) {
-        isNew = true
-        node = createNode(nodeId)
-        this.nodeCollection.add(nodeId, node)
+        isNew = true;
+        node = createNode(nodeId);
+        this.nodeCollection.add(nodeId, node);
       } else if (!node.isAvailable) {
         // Node exists, but is marked as unavailable. It must therefore be a reconnected node.
-        isReconnected = true
-        node.isAvailable = true
-        node.lastHeartbeatTime = Date.now()
+        isReconnected = true;
+        node.isAvailable = true;
+        node.lastHeartbeatTime = Date.now();
       }
 
       // todo: Handle multiple nodes with the same ID.
-      const updateNesesary = node.update(payload, isReconnected)
+      const updateNecessary = node.update(payload, isReconnected);
 
-      if (updateNesesary && node.services) {
-        this.registerRemoteServices(node, node.services)
+      if (updateNecessary && node.services) {
+        this.registerRemoteServices(node, node.services);
       }
 
       if (isNew) {
-        runtime.eventBus.broadcastLocal('$node.connected', { node, isReconnected })
-        this.log.info(`Node "${node.id}" connected!`)
+        runtime.eventBus.broadcastLocal('$node.connected', { node, isReconnected });
+        this.log.info(`Node "${node.id}" connected!`);
       } else if (isReconnected) {
-        runtime.eventBus.broadcastLocal('$node.connected', { node, isReconnected })
-        this.log.info(`Node "${node.id}" reconnected!`)
+        runtime.eventBus.broadcastLocal('$node.connected', { node, isReconnected });
+        this.log.info(`Node "${node.id}" reconnected!`);
       } else {
-        runtime.eventBus.broadcastLocal('$node.updated', { node, isReconnected })
-        this.log.info(`Node "${node.id}" updated!`)
+        runtime.eventBus.broadcastLocal('$node.updated', { node, isReconnected });
+        this.log.info(`Node "${node.id}" updated!`);
       }
     },
     nodeDisconnected (nodeId, isUnexpected) {
-      const node = this.nodeCollection.get(nodeId)
+      const node = this.nodeCollection.get(nodeId);
       if (node && node.isAvailable) {
-        this.deregisterServiceByNodeId(node.id)
-        node.disconnected(isUnexpected)
-        runtime.eventBus.broadcastLocal('$node.disconnected', { nodeId, isUnexpected })
-        this.log.warn(`Nodes "${node.id}"${isUnexpected ? ' unexpectedly' : ''} disconnected.`)
+        this.deregisterServiceByNodeId(node.id);
+        node.disconnected(isUnexpected);
+        runtime.eventBus.broadcastLocal('$node.disconnected', { nodeId, isUnexpected });
+        this.log.warn(`Nodes "${node.id}"${isUnexpected ? ' unexpectedly' : ''} disconnected.`);
       }
     },
     removeNode (nodeId) {
-      this.nodeCollection.remove(nodeId)
-      runtime.eventBus.broadcastLocal('$node.removed', { nodeId })
-      this.log.warn(`Node "${nodeId}" removed.`)
-    },
-    getNodeList (options) {
-      return this.nodeCollection.list(options)
-    },
-    getServiceList (options) {
-      return this.serviceCollection.list(options)
+      this.nodeCollection.remove(nodeId);
+      runtime.eventBus.broadcastLocal('$node.removed', { nodeId });
+      this.log.warn(`Node "${nodeId}" removed.`);
     }
-  }
+  };
 
-  return registry
-}
+  return registry;
+};

package/lib/registry/service/parseAction.js

@@ -1,36 +1,36 @@
-const { isFunction, clone, wrapHandler, isObject, promisify } = require('@weave-js/utils')
-const { WeaveError } = require('../../errors')
+const { isFunction, clone, wrapHandler, isObject, promisify } = require('@weave-js/utils');
+const { WeaveError } = require('../../errors');
 
 module.exports.parseAction = (runtime, service, actionDefinition, name) => {
-  let action = actionDefinition
+  let action = actionDefinition;
 
   // if the handler is a method (short form), we wrap the method in our handler object.
   if (isFunction(actionDefinition)) {
-    action = wrapHandler(actionDefinition)
+    action = wrapHandler(actionDefinition);
   } else if (isObject(actionDefinition)) {
-    action = clone(actionDefinition)
+    action = clone(actionDefinition);
   } else {
-    runtime.handleError(new WeaveError(`Invalid action definition in "${name}" on service "${service.name}".`))
+    runtime.handleError(new WeaveError(`Invalid action definition in "${name}" on service "${service.name}".`));
   }
 
-  const handler = action.handler
+  const handler = action.handler;
 
   // Action handler has to be a function
   if (!isFunction(handler)) {
-    runtime.handleError(new WeaveError(`Missing action handler in "${name}" on service "${service.name}".`))
+    runtime.handleError(new WeaveError(`Missing action handler in "${name}" on service "${service.name}".`));
   }
 
-  action.name = service.name + '.' + (action.name || name)
-  action.shortName = name
+  action.name = service.name + '.' + (action.name || name);
+  action.shortName = name;
 
   // if this is a versioned service. The action name is prefixed with the version number.
   if (service.version) {
-    action.name = `v${service.version}.${action.name}`
+    action.name = `v${service.version}.${action.name}`;
   }
 
-  action.service = service
-  action.version = service.version
-  action.handler = promisify(handler.bind(service))
+  action.service = service;
+  action.version = service.version;
+  action.handler = promisify(handler.bind(service));
 
-  return action
-}
+  return action;
+};

package/lib/registry/service/parseEvent.js

@@ -1,45 +1,45 @@
-const { isFunction, clone, wrapHandler, isObject, promisify } = require('@weave-js/utils')
-const { WeaveError } = require('../../errors')
+const { isFunction, clone, wrapHandler, isObject, promisify } = require('@weave-js/utils');
+const { WeaveError } = require('../../errors');
 
 module.exports.parseEvent = (runtime, service, eventDefinition, name) => {
-  let event
+  let event;
 
   // if the handler is a method (short form), we wrap the method in our handler object.
   if (isFunction(eventDefinition)) {
-    event = wrapHandler(eventDefinition)
+    event = wrapHandler(eventDefinition);
   } else if (isObject(eventDefinition)) {
-    event = clone(eventDefinition)
+    event = clone(eventDefinition);
   } else {
-    runtime.handleError(new WeaveError(`Invalid event definition "${name}" on service "${service.name}".`))
+    runtime.handleError(new WeaveError(`Invalid event definition "${name}" on service "${service.name}".`));
   }
 
   // Event handler has to be a function
   if (!isFunction(event.handler) && !Array.isArray(event.handler)) {
-    runtime.handleError(new WeaveError(`Missing event handler for "${name}" on service "${service.name}".`))
+    runtime.handleError(new WeaveError(`Missing event handler for "${name}" on service "${service.name}".`));
   }
 
-  event.service = service
+  event.service = service;
 
-  let handler
+  let handler;
   if (isFunction(event.handler)) {
-    handler = promisify(event.handler.bind(service))
+    handler = promisify(event.handler.bind(service));
   } else if (Array.isArray(event.handler)) {
     handler = event.handler.map(h => {
-      return promisify(h.bind(service))
-    })
+      return promisify(h.bind(service));
+    });
   }
 
   if (!event.name) {
-    event.name = name
+    event.name = name;
   }
 
   if (isFunction(handler)) {
-    event.handler = (context) => handler(context)
+    event.handler = (context) => handler(context);
   } else if (Array.isArray(handler)) {
-    event.handler = (context) => Promise.all(handler.map(h => h(context)))
+    event.handler = (context) => Promise.all(handler.map(h => h(context)));
   }
 
-  event.service = service
+  event.service = service;
 
-  return event
-}
+  return event;
+};