@weave-js/core 0.12.1 → 0.13.0

package/lib/ExtendableError.js

@@ -1,6 +1,6 @@
 class ExtendableError extends Error {
-  constructor (message = '') {
-    super(message);
+  constructor (message = '', options) {
+    super(message, options);
 
     Object.defineProperty(this, 'name', {
       configurable: true,

package/lib/errors.js

@@ -4,25 +4,34 @@
  * Copyright 2021 Fachwerk
  */
 
+const { defaultsDeep } = require('@weave-js/utils');
 const { ExtendableError } = require('./ExtendableError');
 
 class WeaveError extends ExtendableError {
-  constructor (message, code, type, data) {
-    super(message);
+  constructor (message, options) { // code, type, data
+    options = defaultsDeep(
+      options,
+      {
+        code: 'WEAVE_ERROR',
+        retryable: false
+      }
+    );
+
+    super(message, options);
     this.name = this.constructor.name;
-    this.code = code || 500;
-    this.type = type;
-    this.data = data;
+    this.code = options.code || 'WEAVE_ERROR';
+    this.data = options.data;
     this.retryable = false;
+
+    if (options.statusCode) {
+      this.statusCode = options.statusCode;
+    }
   }
 }
 
 class WeaveRetryableError extends WeaveError {
-  constructor (message, code, type, data) {
-    super(message);
-    this.code = code || 500;
-    this.type = type;
-    this.data = data;
+  constructor (message, options = { code: 'WEAVE_RETRYABLE_ERROR', retryable: true }) {
+    super(message, options);
     this.retryable = true;
   }
 }
@@ -39,11 +48,11 @@ class WeaveServiceNotFoundError extends WeaveRetryableError {
       message = 'Service not found.';
     }
 
-    super(message, 404, 'WEAVE_SERVICE_NOT_FOUND_ERROR', data);
+    super(message, { code: 'WEAVE_SERVICE_NOT_FOUND_ERROR', data });
   }
 }
 
-class WeaveServiceNotAvailableError extends WeaveRetryableError {
+class WeaveServiceNotAvailableError extends WeaveRetryableError { // 503
   constructor (data = {}) {
     let message;
     if (data.nodeId) {
@@ -54,67 +63,69 @@ class WeaveServiceNotAvailableError extends WeaveRetryableError {
       message = 'Service not available.';
     }
 
-    super(message, 503, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data);
+    super(message, { code: 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data });
   }
 }
 
-class WeaveRequestTimeoutError extends WeaveRetryableError {
+class WeaveRequestTimeoutError extends WeaveRetryableError { // 504
   constructor (actionName, nodeId, timeout) {
-    const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`;
-    super(message, 504, 'WEAVE_REQUEST_TIMEOUT_ERROR', {
+    const data = {
       actionName,
       nodeId,
       timeout
-    });
-    this.retryable = true;
+    };
+
+    const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`;
+    super(message, { code: 'WEAVE_REQUEST_TIMEOUT_ERROR', data });
   }
 }
 
-class WeaveParameterValidationError extends WeaveError {
+class WeaveParameterValidationError extends WeaveError { // 422
   constructor (message, data) {
-    super(message, 422, 'WEAVE_PARAMETER_VALIDATION_ERROR', data);
+    super(message, { code: 'WEAVE_PARAMETER_VALIDATION_ERROR', data });
   }
 }
 
 class WeaveBrokerOptionsError extends WeaveError {
   constructor (message, data) {
-    super(message, 500, 'WEAVE_BROKER_OPTIONS_ERROR', data);
+    super(
+      message,
+      { code: 'WEAVE_BROKER_OPTIONS_ERROR', data }
+    );
   }
 }
 
-class WeaveQueueSizeExceededError extends WeaveError {
+class WeaveQueueSizeExceededError extends WeaveError { // 429
   constructor (data) {
-    super('Queue size limit was exceeded. Request rejected.', 429, 'WEAVE_QUEUE_SIZE_EXCEEDED_ERROR', data);
+    super(
+      'Queue size limit was exceeded. Request rejected.',
+      { code: 'WEAVE_QUEUE_SIZE_EXCEEDED_ERROR', data }
+    );
   }
 }
 
 class WeaveMaxCallLevelError extends WeaveError {
   constructor (data) {
-    super(`Request level has reached the limit (${data.maxCallLevel}) on node "${data.nodeId}".`, 500, 'WEAVE_MAX_CALL_LEVEL_ERROR', data);
+    super(
+      `Request level has reached the limit ${data.maxCallLevel} on node "${data.nodeId}".`,
+      { code: 'WEAVE_MAX_CALL_LEVEL_ERROR', data }
+    );
   }
 }
 
 class WeaveGracefulStopTimeoutError extends WeaveError {
   constructor (service) {
-    super(`Unable to stop service "${service.name}"`, 500, 'GRACEFUL_STOP_TIMEOUT', {
+    const data = {
       name: service.name,
       version: service.version
-    });
-  }
-}
-
-const restoreError = error => {
-  const ErrorClass = module.exports[error.name];
+    };
 
-  if (ErrorClass) {
-    switch (error.name) {
-    case 'WeaveError':
-      return new ErrorClass(error.message, error.code, error.type, error.data);
-            // case 'WeaveParameterValidationError':
-            //     return new ErrorClass(error.message, error.data)
-    }
+    super(
+      `Unable to stop service "${service.name}"`,
+      { code: 'WEAVE_GRACEFUL_STOP_TIMEOUT', data }
+    );
   }
-};
+}
 
 module.exports = {
   WeaveBrokerOptionsError,
@@ -126,6 +137,5 @@ module.exports = {
   WeaveRetryableError,
   WeaveServiceNotAvailableError,
   WeaveServiceNotFoundError,
-  WeaveGracefulStopTimeoutError,
-  restoreError
+  WeaveGracefulStopTimeoutError
 };

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

@@ -12,7 +12,7 @@ module.exports = (runtime) => {
       return handler(context, serviceInjections)
         .catch((error) => {
           if (!(error instanceof Error)) {
-            error = new WeaveError(error, 500);
+            error = new WeaveError(error);
           }
 
           if (runtime.nodeId !== context.nodeId) {
@@ -36,7 +36,7 @@ module.exports = (runtime) => {
       return handler(context, serviceInjections)
         .catch((error) => {
           if (!(error instanceof Error)) {
-            error = new WeaveError(error, 500);
+            error = new WeaveError(error.message, { cause: error });
           }
 
           if (runtime.nodeId !== context.nodeId) {

package/lib/runtime/initServiceManager.js

@@ -93,7 +93,12 @@ exports.initServiceManager = (runtime) => {
             }
 
             if (timeout && (Date.now() - startTimestamp) > timeout) {
-              return reject(new WeaveError('The waiting of the services is interrupted due to a timeout.', 500, 'WAIT_FOR_SERVICE', { services: serviceNames }));
+              return reject(new WeaveError('The waiting of the services is interrupted due to a timeout.', {
+                code: 'WAIT_FOR_SERVICE',
+                data: {
+                  services: serviceNames
+                }
+              }));
             }
 
             options.waitForServiceInterval = setTimeout(serviceCheck, interval);

package/lib/transport/errorPayloadFactory.js

@@ -6,7 +6,6 @@ const errorPayloadFactory =
         message: error.message,
         nodeId: error.nodeId || runtime.nodeId,
         code: error.code,
-        type: error.type,
         stack: error.stack,
         data: error.data
       };

package/lib/transport/messageHandlers.js

@@ -5,10 +5,11 @@
  */
 
 const { InboundTransformStream } = require('./InboundTransformStream');
-const { WeaveError, restoreError } = require('../errors');
+const { WeaveError } = require('../errors');
 const { createContext } = require('../broker/context');
 const { createMessage } = require('./createMessage');
 const MessageTypes = require('./messageTypes');
+const { restoreError } = require('../utils/restoreError');
 
 /**
  * @typedef {import('../types').Transport} Transport
@@ -291,23 +292,10 @@ module.exports = (runtime, transport) => {
 
     // Response is an error
     if (!payload.success) {
-      let error = restoreError(payload.error);
-
-      if (!error) {
-        error = new Error(payload.error.message);
-        error.name = payload.error.name;
-        error.code = payload.error.code;
-        error.type = payload.error.type;
-        error.data = payload.error.data;
-      }
+      const error = restoreError(payload.error);
 
-      error.retryable = payload.error.retryable;
       error.nodeId = error.nodeId || payload.sender;
 
-      if (payload.error.stack) {
-        error.stack = payload.error.stack;
-      }
-
       request.reject(error);
     }
 
@@ -398,6 +386,7 @@ module.exports = (runtime, transport) => {
   const onHeartbeat = (payload) => {
     transport.log.verbose(`Heartbeat from ${payload.sender}`);
     const node = registry.nodeCollection.get(payload.sender);
+
     // if node is unknown then request a node info message.
     if (node) {
       if (!node.isAvailable) {
@@ -510,7 +499,11 @@ module.exports = (runtime, transport) => {
 
       return true;
     } catch (error) {
-      transport.log.error(error, data);
+      transport.log.error(error, type, data);
+
+      runtime.eventBus.broadcastLocal('$transport.error', {
+        error
+      });
     }
     return false;
   };

package/lib/utils/restoreError.js

@@ -1,12 +1,64 @@
 const errors = require('../errors');
 
-exports.restoreError = (error) => {
-  const ErrorClass = errors[error.name];
+const restoreError = (errorPayload) => {
+  const ErrorClass = errors[errorPayload.name];
+  let error;
 
   if (ErrorClass) {
-    switch (error.name) {
+    switch (errorPayload.name) {
     case 'WeaveError':
-      return new ErrorClass(error.message, error.code, error.type, error.data);
+    case 'WeaveRetryableError': {
+      const { message, ...options } = errorPayload;
+      error = new ErrorClass(message, options);
+      break;
+    }
+
+    case 'WeaveParameterValidationError':
+    case 'WeaveBrokerOptionsError': {
+      const { message, data } = errorPayload;
+      error = new ErrorClass(message, data);
+      break;
+    }
+    case 'WeaveServiceNotFoundError':
+    case 'WeaveServiceNotAvailableError':
+    case 'WeaveQueueSizeExceededError':
+    case 'WeaveMaxCallLevelError': {
+      const { data } = errorPayload;
+      error = new ErrorClass(data);
+      break;
+    }
+    case 'WeaveRequestTimeoutError': {
+      const { data } = errorPayload;
+      error = new ErrorClass(data.actionName, data.nodeId, data.timeout);
+      break;
+    }
+    case 'WeaveGracefulStopTimeoutError': {
+      const { data } = errorPayload;
+      error = new ErrorClass(data.service);
+      break;
+    }
+    }
+  } else {
+    error = new Error(errorPayload.message);
+
+    error.name = errorPayload.name;
+
+    error.nodeId = errorPayload.nodeId;
+
+    if (errorPayload.code) {
+      error.code = errorPayload.code;
+    }
+
+    if (errorPayload.data) {
+      error.data = errorPayload.data;
     }
   }
+
+  if (errorPayload.stack) {
+    error.stack = errorPayload.stack;
+  }
+
+  return error;
 };
+
+module.exports = { restoreError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-js/core",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "The core package of weave",
   "keywords": [
     "Weave",
@@ -40,8 +40,8 @@
   "license": "MIT",
   "dependencies": {
     "@weave-js/errors": "^0.9.1",
-    "@weave-js/utils": "^0.11.1",
-    "@weave-js/validator": "^0.12.0",
+    "@weave-js/utils": "^0.12.0",
+    "@weave-js/validator": "^0.13.0",
     "eventemitter2": "^6.4.5",
     "glob": "^7.2.0"
   },
@@ -49,5 +49,5 @@
     "lib": "lib",
     "test": "test"
   },
-  "gitHead": "3f9662a98caa08d32ba5a181cc5871318aaece23"
+  "gitHead": "6772c8bfb00be1da32c17cff621a8abcd98a08fc"
 }