@weave-js/core 0.11.1 → 0.12.0

package/lib/middlewares/validator/index.js

@@ -1,11 +1,11 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { WeaveParameterValidationError } = require('../../errors')
-const { capitalize } = require('@weave-js/utils')
+const { WeaveParameterValidationError } = require('../../errors');
+const { capitalize } = require('@weave-js/utils');
 
 /**
  * @typedef {import('../../types').Runtime} Runtime
@@ -18,77 +18,77 @@ const { capitalize } = require('@weave-js/utils')
  * @returns {Middleware} - Validator middleware
 */
 module.exports = (runtime) => {
-  const validator = runtime.validator
+  const validator = runtime.validator;
 
   const processErrors = (context, type, results) => {
-    const errors = results.map(data => Object.assign(data, { nodeId: context.nodeId, action: context.action.name }))
-    return Promise.reject(new WeaveParameterValidationError(`${capitalize(type)} parameter validation error`, errors))
-  }
+    const errors = results.map(data => Object.assign(data, { nodeId: context.nodeId, action: context.action.name }));
+    return Promise.reject(new WeaveParameterValidationError(`${capitalize(type)} parameter validation error`, errors));
+  };
 
   return {
     localAction (handler, action) {
       const parameterOptions = Object.assign(
         runtime.options.validatorOptions,
         action.validatorOptions
-      )
+      );
 
       // validate request schema
-      let validateRequestSchema
-      let validateResponseSchema
+      let validateRequestSchema;
+      let validateResponseSchema;
       if (action.params && typeof action.params === 'object') {
-        validateRequestSchema = validator.compile(action.params, parameterOptions)
+        validateRequestSchema = validator.compile(action.params, parameterOptions);
       }
 
       if (action.responseSchema && typeof action.responseSchema === 'object') {
-        validateResponseSchema = validator.compile(action.responseSchema, parameterOptions)
+        validateResponseSchema = validator.compile(action.responseSchema, parameterOptions);
       }
 
       if (!validateRequestSchema && !validateRequestSchema) {
-        return handler
+        return handler;
       }
 
       return (context, serviceInjections) => {
-        const requestSchemaResult = validateRequestSchema ? validateRequestSchema(context.data) : true
+        const requestSchemaResult = validateRequestSchema ? validateRequestSchema(context.data) : true;
 
         if (requestSchemaResult === true) {
           return handler(context, serviceInjections)
             .then((result) => {
               if (validateResponseSchema) {
-                const responseSchemaResult = validateResponseSchema(result)
+                const responseSchemaResult = validateResponseSchema(result);
                 if (responseSchemaResult === true) {
-                  return result
+                  return result;
                 }
-                return processErrors(context, 'response', responseSchemaResult)
+                return processErrors(context, 'response', responseSchemaResult);
               }
-              return result
-            })
+              return result;
+            });
         } else {
           // Enriching the validator errors with some useful information
-          return processErrors(context, 'request', requestSchemaResult)
+          return processErrors(context, 'request', requestSchemaResult);
         }
-      }
+      };
     },
     localEvent (handler, event) {
       if (event.params && typeof event.params === 'object') {
         const parameterOptions = Object.assign(
           runtime.options.validatorOptions,
           event.validatorOptions
-        )
+        );
 
-        const validate = validator.compile(event.params, parameterOptions)
+        const validate = validator.compile(event.params, parameterOptions);
 
         return (context, serviceInjections) => {
-          let result = validate(context.data)
+          let result = validate(context.data);
 
           if (result === true) {
-            return handler(context, serviceInjections)
+            return handler(context, serviceInjections);
           } else {
-            result = result.map(data => Object.assign(data, { nodeId: context.nodeId, event: context.eventName }))
-            return Promise.reject(new WeaveParameterValidationError('Parameter validation error', result))
+            result = result.map(data => Object.assign(data, { nodeId: context.nodeId, event: context.eventName }));
+            return Promise.reject(new WeaveParameterValidationError('Parameter validation error', result));
           }
-        }
+        };
       }
-      return handler
+      return handler;
     }
-  }
-}
+  };
+};

package/lib/registry/actionEndpoint.js

@@ -7,7 +7,7 @@
 */
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
@@ -31,15 +31,15 @@ exports.createActionEndpoint = (runtime, node, service, action) => {
     isLocal: node.id === runtime.nodeId,
     state: true,
     name: `${node.id}:${action.name}`
-  }
+  };
 
   endpoint.updateAction = (newAction) => {
-    endpoint.action = newAction
-  }
+    endpoint.action = newAction;
+  };
 
   endpoint.isAvailable = () => {
-    return endpoint.state === true
-  }
+    return endpoint.state === true;
+  };
 
-  return endpoint
-}
+  return endpoint;
+};

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