@weave-js/core 0.11.0 → 0.12.1

package/lib/middlewares/error-handler/index.js

@@ -1,35 +1,67 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { WeaveError } = require('../../errors')
+const { WeaveError } = require('../../errors');
 
 module.exports = (runtime) => {
   const wrapErrorHandlerMiddleware = function (handler) {
     return function errorHandlerMiddleware (context, serviceInjections) {
       return handler(context, serviceInjections)
-        .catch(error => {
+        .catch((error) => {
           if (!(error instanceof Error)) {
-            error = new WeaveError(error, 500)
+            error = new WeaveError(error, 500);
           }
 
           if (runtime.nodeId !== context.nodeId) {
-            runtime.transport.removePendingRequestsById(context.id)
+            runtime.transport.removePendingRequestsById(context.id);
           }
 
-          runtime.log.debug(`The action ${context.action.name} is rejected`, { requestId: context.id }, error)
-          return runtime.handleError(error)
+          Object.defineProperty(error, 'context', {
+            value: context,
+            writable: true,
+            enumerable: false
+          });
+
+          runtime.log.debug(`The action "${context.action.name}" was rejected`, { requestId: context.requestId }, error);
+          return runtime.handleError(error);
+        });
+    };
+  };
+
+  const wrapEventErrorHandlerMiddleware = function (handler) {
+    return function errorHandlerMiddleware (context, serviceInjections) {
+      return handler(context, serviceInjections)
+        .catch((error) => {
+          if (!(error instanceof Error)) {
+            error = new WeaveError(error, 500);
+          }
+
+          if (runtime.nodeId !== context.nodeId) {
+            runtime.transport.removePendingRequestsById(context.id);
+          }
+
+          Object.defineProperty(error, 'context', {
+            value: context,
+            writable: true,
+            enumerable: false
+          });
+
+          runtime.log.debug(`The event "${context.eventName}" was rejected`, { requestId: context.requestId }, error);
+          return runtime.handleError(error);
         })
-        // .catch(error => {
-        //   runtime.log.error(error)
-        // })
-    }
-  }
+        .catch((error) => {
+          // we just log the error because we don't want to crash the event loop
+          runtime.log.error(error);
+        });
+    };
+  };
 
   return {
     localAction: wrapErrorHandlerMiddleware,
-    remoteAction: wrapErrorHandlerMiddleware
-  }
-}
+    remoteAction: wrapErrorHandlerMiddleware,
+    localEvent: wrapEventErrorHandlerMiddleware
+  };
+};

package/lib/middlewares/index.js

@@ -1,5 +1,5 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
@@ -16,4 +16,4 @@ module.exports = {
   Timeout: require('./timeout'),
   ContextTracker: require('./context-tracker'),
   Validator: require('./validator')
-}
+};

package/lib/middlewares/metrics/getMiddlewareWrapper.js

@@ -1,27 +1,27 @@
-const { Constants } = require('../../metrics')
+const { Constants } = require('../../metrics');
 
 module.exports.getMiddlewareWrapper = (runtime) => function (type, action, handler) {
-  const serviceName = action.service ? action.service.fullyQualifiedName : null
-  const actionName = action.name
+  const serviceName = action.service ? action.service.fullyQualifiedName : null;
+  const actionName = action.name;
 
   return function metricMiddleware (context, serviceInjections) {
-    const callerNodeId = context.callerNodeId
+    const callerNodeId = context.callerNodeId;
 
-    runtime.metrics.increment(Constants.REQUESTS_TOTAL, { type, serviceName, actionName, callerNodeId })
-    runtime.metrics.increment(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId })
-    const requestEnd = runtime.metrics.timer(Constants.REQUESTS_TIME, { type, serviceName, actionName, callerNodeId })
+    runtime.metrics.increment(Constants.REQUESTS_TOTAL, { type, serviceName, actionName, callerNodeId });
+    runtime.metrics.increment(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId });
+    const requestEnd = runtime.metrics.timer(Constants.REQUESTS_TIME, { type, serviceName, actionName, callerNodeId });
 
     return handler(context, serviceInjections)
       .then(result => {
-        requestEnd()
-        runtime.metrics.decrement(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId })
-        return result
+        requestEnd();
+        runtime.metrics.decrement(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId });
+        return result;
       })
       .catch(error => {
-        requestEnd()
-        runtime.metrics.decrement(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId })
-        runtime.metrics.increment(Constants.REQUESTS_ERRORS_TOTAL)
-        runtime.handleError(error)
-      })
-  }
-}
+        requestEnd();
+        runtime.metrics.decrement(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId });
+        runtime.metrics.increment(Constants.REQUESTS_ERRORS_TOTAL);
+        runtime.handleError(error);
+      });
+  };
+};

package/lib/middlewares/metrics/index.js

@@ -1,57 +1,57 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
-const { Constants } = require('../../metrics')
-const { getMiddlewareWrapper } = require('./getMiddlewareWrapper')
+const { Constants } = require('../../metrics');
+const { getMiddlewareWrapper } = require('./getMiddlewareWrapper');
 
 module.exports = (runtime) => {
-  const wrapMetricMiddleware = getMiddlewareWrapper(runtime)
+  const wrapMetricMiddleware = getMiddlewareWrapper(runtime);
 
   return {
     created () {
       // Request metrics
-      runtime.metrics.register({ type: 'counter', name: Constants.REQUESTS_TOTAL, description: 'Number of total requests.' })
-      runtime.metrics.register({ type: 'gauge', name: Constants.REQUESTS_IN_FLIGHT, description: 'Number of running requests.' })
-      runtime.metrics.register({ type: 'counter', name: Constants.REQUESTS_ERRORS_TOTAL, description: 'Number of failed requests.' })
-      runtime.metrics.register({ type: 'gauge', name: Constants.REQUESTS_TIME, description: 'Request times in milliseconds' })
+      runtime.metrics.register({ type: 'counter', name: Constants.REQUESTS_TOTAL, description: 'Number of total requests.' });
+      runtime.metrics.register({ type: 'gauge', name: Constants.REQUESTS_IN_FLIGHT, description: 'Number of running requests.' });
+      runtime.metrics.register({ type: 'counter', name: Constants.REQUESTS_ERRORS_TOTAL, description: 'Number of failed requests.' });
+      runtime.metrics.register({ type: 'gauge', name: Constants.REQUESTS_TIME, description: 'Request times in milliseconds' });
 
       // Event metrics
-      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_EMITS, description: 'Number of total emitted events.' })
-      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_BROADCASTS, description: 'Number of total broadcasted events.' })
-      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_BROADCASTS_LOCAL, description: 'Number of total local broadcasted events.' })
-      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_RECEIVED, description: 'Number of total received events.' })
+      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_EMITS, description: 'Number of total emitted events.' });
+      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_BROADCASTS, description: 'Number of total broadcasted events.' });
+      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_BROADCASTS_LOCAL, description: 'Number of total local broadcasted events.' });
+      runtime.metrics.register({ type: 'counter', name: Constants.EVENT_TOTAL_RECEIVED, description: 'Number of total received events.' });
 
       // Transport metrics
-      runtime.metrics.register({ type: 'gauge', name: Constants.TRANSPORT_IN_FLIGHT_STREAMS, description: 'Number of in flight streams.' })
-      runtime.metrics.register({ type: 'counter', name: Constants.TRANSPORTER_PACKETS_SENT, description: 'Number of in flight streams.' })
-      runtime.metrics.register({ type: 'counter', name: Constants.TRANSPORTER_PACKETS_RECEIVED, description: 'Number of in flight streams.' })
-      runtime.metrics.register({ type: 'gauge', name: Constants.TRANSPORT_IN_FLIGHT_STREAMS, description: 'Number of in flight streams.' })
+      runtime.metrics.register({ type: 'gauge', name: Constants.TRANSPORT_IN_FLIGHT_STREAMS, description: 'Number of in flight streams.' });
+      runtime.metrics.register({ type: 'counter', name: Constants.TRANSPORTER_PACKETS_SENT, description: 'Number of in flight streams.' });
+      runtime.metrics.register({ type: 'counter', name: Constants.TRANSPORTER_PACKETS_RECEIVED, description: 'Number of in flight streams.' });
+      runtime.metrics.register({ type: 'gauge', name: Constants.TRANSPORT_IN_FLIGHT_STREAMS, description: 'Number of in flight streams.' });
     },
     localAction (next, action) {
-      return wrapMetricMiddleware('local', action, next)
+      return wrapMetricMiddleware('local', action, next);
     },
     remoteAction (next, action) {
-      return wrapMetricMiddleware('remote', action, next)
+      return wrapMetricMiddleware('remote', action, next);
     },
     emit (next) {
       return (event, payload) => {
-        runtime.metrics.increment(Constants.EVENT_TOTAL_EMITS)
-        return next(event, payload)
-      }
+        runtime.metrics.increment(Constants.EVENT_TOTAL_EMITS);
+        return next(event, payload);
+      };
     },
     broadcast (next) {
       return (event, payload) => {
-        runtime.metrics.increment(Constants.EVENT_TOTAL_BROADCASTS)
-        return next(event, payload)
-      }
+        runtime.metrics.increment(Constants.EVENT_TOTAL_BROADCASTS);
+        return next(event, payload);
+      };
     },
     broadcastLocal (next) {
       return (event, payload) => {
-        runtime.metrics.increment(Constants.EVENT_TOTAL_BROADCASTS_LOCAL)
-        return next(event, payload)
-      }
+        runtime.metrics.increment(Constants.EVENT_TOTAL_BROADCASTS_LOCAL);
+        return next(event, payload);
+      };
     }
-  }
-}
+  };
+};

package/lib/middlewares/retry/index.js

@@ -1,15 +1,15 @@
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { delay } = require('@weave-js/utils')
+const { delay } = require('@weave-js/utils');
 
 const wrapRetryMiddleware = function (handler, action) {
-  const self = this
-  const options = Object.assign({}, self.options.retryPolicy, action.retryPolicy || {})
+  const self = this;
+  const options = Object.assign({}, self.options.retryPolicy, action.retryPolicy || {});
 
   // middleware is enabled
   if (options.enabled) {
@@ -17,28 +17,28 @@ const wrapRetryMiddleware = function (handler, action) {
     return function retryMiddleware (context, serviceInjections) {
       // if the context has no repeat count, set it to zero.
       if (context.retryCount === undefined) {
-        context.retryCount = 0
+        context.retryCount = 0;
       }
 
-      const attempts = typeof context.options.retries === 'number' ? context.options.retries : options.retries
+      const attempts = typeof context.options.retries === 'number' ? context.options.retries : options.retries;
 
       return handler(context, serviceInjections)
         .catch(error => {
           if (context.retryCount++ < attempts && error.retryable === true) {
-            self.log.warn(`Retry to recall action '${context.action.name}' after ${options.delay}.`)
+            self.log.warn(`Retry to recall action '${context.action.name}' after ${options.delay}.`);
             return delay(options.delay)
-              .then(() => self.call(context.action.name, context.data, { context }))
+              .then(() => self.call(context.action.name, context.data, { context }));
           }
-          return Promise.reject(error)
-        })
-    }
+          return Promise.reject(error);
+        });
+    };
   }
-  return handler
-}
+  return handler;
+};
 
 module.exports = () => {
   return {
     localAction: wrapRetryMiddleware,
     remoteAction: wrapRetryMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/timeout/index.js

@@ -1,44 +1,44 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { promiseTimeout } = require('@weave-js/utils')
-const { WeaveRequestTimeoutError } = require('../../errors')
+const { promiseTimeout } = require('@weave-js/utils');
+const { WeaveRequestTimeoutError } = require('../../errors');
 
 const wrapTimeoutMiddleware = function (handler) {
-  const self = this
-  const registryOptions = self.options.registry || {}
+  const self = this;
+  const registryOptions = self.options.registry || {};
 
   return function timeoutMiddleware (context, serviceInjections) {
     if (typeof context.options.timeout === 'undefined' || registryOptions.requestTimeout) {
-      context.options.timeout = registryOptions.requestTimeout || 0
+      context.options.timeout = registryOptions.requestTimeout || 0;
     }
 
     if (context.options.timeout > 0 && !context.startHighResolutionTime) {
-      context.startHighResolutionTime = process.hrtime()
+      context.startHighResolutionTime = process.hrtime();
     }
 
-    let promise = handler(context, serviceInjections)
+    let promise = handler(context, serviceInjections);
 
     if (context.options.timeout > 0) {
       promise = promiseTimeout(context.options.timeout, promise, new WeaveRequestTimeoutError(context.action.name, context.nodeId, context.options.timeout))
         .catch(error => {
           if (error instanceof WeaveRequestTimeoutError) {
-            self.log.warn(`Request '${context.action.name}' timed out.`)
+            self.log.warn(`Request '${context.action.name}' timed out.`);
           }
 
-          return Promise.reject(error)
-        })
+          return Promise.reject(error);
+        });
     }
-    return promise
-  }
-}
+    return promise;
+  };
+};
 
 module.exports = () => {
   return {
     localAction: wrapTimeoutMiddleware,
     remoteAction: wrapTimeoutMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/tracing/index.js

@@ -1,25 +1,25 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { isPlainObject } = require('@weave-js/utils')
-const { buildActionTags, buildEventTags } = require('./tags')
+const { isPlainObject } = require('@weave-js/utils');
+const { buildActionTags, buildEventTags } = require('./tags');
 
 const wrapTracingLocalActionMiddleware = function (handler) {
-  const broker = this
-  const tracingOptions = broker.options.tracing || {}
+  const broker = this;
+  const tracingOptions = broker.options.tracing || {};
 
   if (tracingOptions.enabled) {
     return function metricsLocalMiddleware (context, serviceInjections) {
-      const tags = buildActionTags(context, tracingOptions)
+      const tags = buildActionTags(context, tracingOptions);
 
       if (tracingOptions) {
-        tags.data = context.data !== null && isPlainObject(context.data) ? Object.assign({}, context.data) : context.data
+        tags.data = context.data !== null && isPlainObject(context.data) ? Object.assign({}, context.data) : context.data;
       }
 
-      const spanName = `action "${context.action.name}"`
+      const spanName = `action "${context.action.name}"`;
 
       const span = context.startSpan(spanName, {
         id: context.id,
@@ -29,43 +29,43 @@ const wrapTracingLocalActionMiddleware = function (handler) {
         service: context.service,
         tags,
         sampled: context.tracing
-      })
+      });
 
-      context.span = span
+      context.span = span;
 
       return handler(context, serviceInjections)
         .then(result => {
           const tags = {
             isCachedResult: context.isCachedResult
-          }
+          };
 
           if (tracingOptions) {
-            tags.response = result !== null && isPlainObject(result) ? Object.assign({}, result) : result
+            tags.response = result !== null && isPlainObject(result) ? Object.assign({}, result) : result;
           }
 
-          span.addTags(tags)
-          span.finish()
-          return result
+          span.addTags(tags);
+          span.finish();
+          return result;
         })
         .catch(error => {
           span
             .setError(error)
-            .finish()
-          return Promise.reject(error)
-        })
-    }
+            .finish();
+          return Promise.reject(error);
+        });
+    };
   }
-  return handler
-}
+  return handler;
+};
 
 const wrapTracingLocalEventMiddleware = function (handler, event) {
-  const broker = this
-  const service = event.service
-  const tracingOptions = broker.options.tracing || {}
+  const broker = this;
+  const service = event.service;
+  const tracingOptions = broker.options.tracing || {};
 
   if (tracingOptions.enabled) {
     return function metricsLocalMiddleware (context) {
-      const tags = buildEventTags(context)
+      const tags = buildEventTags(context);
 
       const span = context.startSpan(`event "${context.eventName}"`, {
         id: context.id,
@@ -75,29 +75,29 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
         service,
         tags,
         sampled: context.tracing
-      })
+      });
 
-      context.span = span
+      context.span = span;
 
       return handler(context)
         .then(result => {
-          span.finish()
-          return result
+          span.finish();
+          return result;
         })
         .catch(error => {
           span
             .setError(error)
-            .finish()
-          return Promise.reject(error)
-        })
-    }
+            .finish();
+          return Promise.reject(error);
+        });
+    };
   }
-  return handler
-}
+  return handler;
+};
 
 module.exports = () => {
   return {
     localAction: wrapTracingLocalActionMiddleware,
     localEvent: wrapTracingLocalEventMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/tracing/tags.js

@@ -17,10 +17,10 @@ module.exports.buildActionTags = (context, brokerTracingOptions, actionTracingOp
     isRemoteCall: !!context.callerNodeId,
     nodeId: context.nodeId,
     requestId: context.requestId
-  }
+  };
 
-  return tags
-}
+  return tags;
+};
 
 /**
  * Build span tags object
@@ -37,7 +37,7 @@ module.exports.buildEventTags = (context, brokerTracingOptions, actionTracingOpt
     isRemoteCall: !!context.callerNodeId,
     nodeId: context.nodeId,
     requestId: context.requestId
-  }
+  };
 
-  return tags
-}
+  return tags;
+};

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