@weave-js/core 0.10.0 → 0.12.0

package/lib/errors.js

@@ -1,89 +1,96 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-class WeaveError extends Error {
+const { ExtendableError } = require('./ExtendableError');
+
+class WeaveError extends ExtendableError {
   constructor (message, code, type, data) {
-    super(message)
-    this.name = this.constructor.name
-    this.code = code || 500
-    this.type = type
-    this.data = data
-    this.retryable = false
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code || 500;
+    this.type = type;
+    this.data = data;
+    this.retryable = false;
   }
 }
 
-class WeaveRetrieableError extends WeaveError {
+class WeaveRetryableError extends WeaveError {
   constructor (message, code, type, data) {
-    super(message)
-    this.code = code || 500
-    this.type = type
-    this.data = data
-    this.retryable = true
+    super(message);
+    this.code = code || 500;
+    this.type = type;
+    this.data = data;
+    this.retryable = true;
   }
 }
 
-class WeaveServiceNotFoundError extends WeaveRetrieableError {
+class WeaveServiceNotFoundError extends WeaveRetryableError {
   constructor (data = {}) {
-    let message
+    let message;
 
     if (data.actionName && data.nodeId) {
-      message = `Service "${data.actionName}" not found on node "${data.nodeId}".`
+      message = `Service "${data.actionName}" not found on node "${data.nodeId}".`;
     } else if (data.actionName) {
-      message = `Service "${data.actionName}" not found.`
+      message = `Service "${data.actionName}" not found.`;
+    } else {
+      message = 'Service not found.';
     }
 
-    super(message, 404, 'WEAVE_SERVICE_NOT_FOUND_ERROR', data)
+    super(message, 404, 'WEAVE_SERVICE_NOT_FOUND_ERROR', data);
   }
 }
 
-class WeaveServiceNotAvailableError extends WeaveRetrieableError {
+class WeaveServiceNotAvailableError extends WeaveRetryableError {
   constructor (data = {}) {
-    let message
+    let message;
     if (data.nodeId) {
-      message = `Service "${data.actionName}" not available on node "${data.nodeId}".`
+      message = `Service "${data.actionName}" not available on node "${data.nodeId}".`;
+    } else if (data.actionName) {
+      message = `Service "${data.actionName}" not available.`;
     } else {
-      message = `Service "${data.actionName}" not available.`
+      message = 'Service not available.';
     }
 
-    super(message, 405, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data)
+    super(message, 503, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data);
   }
 }
 
-class WeaveRequestTimeoutError extends WeaveRetrieableError {
+class WeaveRequestTimeoutError extends WeaveRetryableError {
   constructor (actionName, nodeId, timeout) {
-    const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`
+    const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`;
     super(message, 504, 'WEAVE_REQUEST_TIMEOUT_ERROR', {
       actionName,
-      nodeId
-    })
-    this.retryable = true
+      nodeId,
+      timeout
+    });
+    this.retryable = true;
   }
 }
 
 class WeaveParameterValidationError extends WeaveError {
   constructor (message, data) {
-    super(message, 422, 'WEAVE_PARAMETER_VALIDATION_ERROR', data)
+    super(message, 422, 'WEAVE_PARAMETER_VALIDATION_ERROR', data);
   }
 }
 
 class WeaveBrokerOptionsError extends WeaveError {
   constructor (message, data) {
-    super(message, 500, 'WEAVE_BROKER_OPTIONS_ERROR', data)
+    super(message, 500, 'WEAVE_BROKER_OPTIONS_ERROR', data);
   }
 }
 
 class WeaveQueueSizeExceededError extends WeaveError {
   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.', 429, '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}".`, 500, 'WEAVE_MAX_CALL_LEVEL_ERROR', data);
   }
 }
 
@@ -92,22 +99,22 @@ class WeaveGracefulStopTimeoutError extends WeaveError {
     super(`Unable to stop service "${service.name}"`, 500, 'GRACEFUL_STOP_TIMEOUT', {
       name: service.name,
       version: service.version
-    })
+    });
   }
 }
 
 const restoreError = error => {
-  const ErrorClass = module.exports[error.name]
+  const ErrorClass = module.exports[error.name];
 
   if (ErrorClass) {
     switch (error.name) {
     case 'WeaveError':
-      return new ErrorClass(error.message, error.code, error.type, error.data)
+      return new ErrorClass(error.message, error.code, error.type, error.data);
             // case 'WeaveParameterValidationError':
             //     return new ErrorClass(error.message, error.data)
     }
   }
-}
+};
 
 module.exports = {
   WeaveBrokerOptionsError,
@@ -116,9 +123,9 @@ module.exports = {
   WeaveParameterValidationError,
   WeaveQueueSizeExceededError,
   WeaveRequestTimeoutError,
-  WeaveRetrieableError,
+  WeaveRetryableError,
   WeaveServiceNotAvailableError,
   WeaveServiceNotFoundError,
   WeaveGracefulStopTimeoutError,
   restoreError
-}
+};

package/lib/helper/{define-action.js → defineAction.js}

@@ -1,3 +1,5 @@
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').ServiceActionDefinition} ServiceActionDefinition
 */
@@ -6,7 +8,7 @@
  * Create and register a new service action.
  * @param {ServiceActionDefinition} actionDefinition - Schema of the the action
  * @returns {ServiceActionDefinition} Action definition
- */
+*/
 module.exports = function (actionDefinition) {
-  return actionDefinition
-}
+  return actionDefinition;
+};

package/lib/helper/{define-broker-options.js → defineBrokerOptions.js}

@@ -1,3 +1,5 @@
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').BrokerOptions} BrokerOptions
  */
@@ -8,5 +10,5 @@
  * @returns {BrokerOptions} Broker options
 */
 module.exports = function (options) {
-  return options
-}
+  return options;
+};

package/lib/helper/{define-service.js → defineService.js}

@@ -1,3 +1,6 @@
+
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').ServiceSchema} ServiceSchema
 */
@@ -6,7 +9,7 @@
  * Create and register a new service
  * @param {ServiceSchema} serviceSchema - Schema of the Service
  * @returns {ServiceSchema} Service schema
- */
+*/
 module.exports = function (serviceSchema) {
-  return serviceSchema
-}
+  return serviceSchema;
+};

package/lib/index.js

@@ -4,15 +4,15 @@
  * @typedef {import('./types.js').Broker} Broker
 */
 
-const { getDefaultOptions } = require('./broker/default-options')
-const { defaultsDeep } = require('@weave-js/utils')
-const { buildRuntime } = require('./build-runtime')
-const { createBrokerInstance } = require('./broker')
+const { getDefaultOptions } = require('./broker/defaultOptions');
+const { defaultsDeep } = require('@weave-js/utils');
+const { initRuntime } = require('./buildRuntime');
+const { createBrokerInstance } = require('./broker');
 
 /**
  * @type {BrokerOptions} options Broker options
 */
-exports.defaultOptions = require('./broker/default-options')
+exports.defaultOptions = getDefaultOptions();
 
 /**
  * Build runtime object
@@ -21,39 +21,42 @@ exports.defaultOptions = require('./broker/default-options')
 */
 exports.createBroker = (options) => {
   // get default options
-  const defaultOptions = getDefaultOptions()
+  const defaultOptions = getDefaultOptions();
 
   // merge options with default options
-  options = defaultsDeep(options, defaultOptions)
+  options = defaultsDeep(options, defaultOptions);
 
   // Init runtime
-  const runtime = buildRuntime(options)
+  const runtime = initRuntime(options);
 
   // Create broker instance
-  return createBrokerInstance(runtime)
-}
+  return createBrokerInstance(runtime);
+};
 
-// eslint-disable-next-line valid-jsdoc
 /**
  * @deprecated since version 0.9.0
  * @param {import('./types.js').BrokerOptions} options Broker options.
  * @returns {import('./types.js').Broker} Broker instance
 */
-exports.Weave = exports.createBroker
+exports.Weave = exports.createBroker;
 
 // Errors
-exports.Errors = require('./errors')
+exports.Errors = require('./errors');
 
-exports.Constants = require('./constants')
-// Transport
-exports.TransportAdapters = require('./transport/adapters')
+exports.Constants = require('./constants');
 
 // Caching
-exports.Cache = require('./cache')
-exports.createBaseTracingCollector = require('./tracing/collectors/base')
-exports.TracingAdapters = require('./tracing/collectors')
+exports.Cache = require('./cache/adapters');
+
+/**
+ * @deprecated since version 0.10.0
+*/
+exports.createBaseTracingCollector = require('./tracing/collectors/base').createBaseTracingCollector;
+exports.TransportAdapters = require('./transport/adapters');
+exports.TracingAdapters = require('./tracing/collectors');
+exports.CacheAdapters = require('./cache/adapters');
 
 // Helper
-exports.defineBrokerOptions = require('./helper/define-broker-options')
-exports.defineService = require('./helper/define-service')
-exports.defineAction = require('./helper/define-action')
+exports.defineBrokerOptions = require('./helper/defineBrokerOptions');
+exports.defineService = require('./helper/defineService');
+exports.defineAction = require('./helper/defineAction');

package/lib/logger/base.js

@@ -1,54 +1,63 @@
-const { isStandardLevel, levelMethods } = require('./levels')
-const { noop, generateLogMethod } = require('./tools')
+const { WeaveError } = require('../errors');
+const { isStandardLevel, levelMethods } = require('./levels');
+const { noop, generateLogMethod } = require('./tools');
 
 exports.initBase = (runtime) => {
   runtime.setLevel = (level) => {
-    const { labels, values } = runtime.levels
+    const { labels, values } = runtime.levels;
+
+    // Handle number values for level
     if (typeof level === 'number') {
-      if (labels[level] === undefined) throw Error('unknown level value' + level)
-      level = labels[level]
+      if (labels[level] === undefined) {
+        throw new WeaveError(`Unknown level value: "${level}"`);
+      }
+      level = labels[level];
+    }
+
+    // Handle unknown log levels
+    if (values[level] === undefined) {
+      throw new WeaveError(`Unknown level: "${level}"`);
     }
 
-    if (values[level] === undefined) throw Error('unknown level ' + level)
-    // const preLevelVal = this[levelValSym]
-    const levelVal = runtime.levelValue = values[level]
-    const useOnlyCustomLevelsVal = runtime.options.useOnlyCustomLevelsSym
-    const hook = runtime.options.hooks.logMethod
+    const levelVal = runtime.levelValue = values[level];
+    const useOnlyCustomLevelsVal = runtime.options.useOnlyCustomLevelsSym;
+    const hook = runtime.options.hooks.logMethod;
 
     for (const key in values) {
       if (levelVal < values[key]) {
-        runtime.logMethods[key] = noop
-        continue
+        runtime.logMethods[key] = noop;
+        continue;
       }
-      runtime.logMethods[key] = isStandardLevel(key, useOnlyCustomLevelsVal) ? levelMethods[key](runtime, hook) : generateLogMethod(runtime, values[key], hook)
+      runtime.logMethods[key] = isStandardLevel(key, useOnlyCustomLevelsVal) ? levelMethods[key](runtime, hook) : generateLogMethod(runtime, values[key], hook);
     }
-  }
+  };
 
-  runtime.write = (originObj, message, number) => {
-    const isErrorObject = originObj instanceof Error
-    const mixin = runtime.mixin
-    const time = Date.now()
-    let object
+  runtime.write = (originObject, message, number) => {
+    const isErrorObject = originObject instanceof Error;
+    const mixin = runtime.mixin;
+    const time = Date.now();
+    let object;
 
-    if (originObj === undefined || originObj === null) {
-      object = mixin ? mixin({}) : {}
+    if (originObject === undefined || originObject === null) {
+      object = mixin ? mixin({}) : {};
     } else {
-      object = Object.assign(mixin ? mixin(originObj) : {}, originObj)
+      object = Object.assign(mixin ? mixin(originObject) : {}, originObject);
 
+      // If the object is an error object, we set the message to the error message.
       if (!message && isErrorObject) {
-        message = originObj.message
+        message = originObject.message;
       }
 
       if (isErrorObject) {
-        object.stack = originObj.stack
+        object.stack = originObject.stack;
         if (!object.type) {
-          object.type = 'Error'
+          object.type = 'Error';
         }
       }
     }
 
-    const logString = runtime.formatter(runtime, object, message, number, time)
+    const logString = runtime.formatter(runtime, object, message, number, time);
 
-    runtime.destination.write(logString)
-  }
-}
+    runtime.destination.write(logString);
+  };
+};

package/lib/logger/format/asHumanReadable.js

@@ -1,8 +1,8 @@
-const { green, magenta, red, yellow, white, gray, cyan } = require('../utils/colorize')
-const os = require('os')
+const { green, magenta, red, yellow, gray, cyan } = require('../utils/colorize');
+const os = require('os');
 
 exports.asHumanReadable = ({ levels, options }, originObj, message, number, time) => {
-  let logResult = ''
+  let logResult = '';
 
   const logLevelColors = {
     fatal: magenta,
@@ -11,31 +11,32 @@ exports.asHumanReadable = ({ levels, options }, originObj, message, number, time
     info: green,
     debug: cyan,
     verbose: gray
-  }
+  };
 
-  const currentLabel = levels.labels[number]
+  const currentLabel = levels.labels[number];
 
+  const color = logLevelColors[currentLabel] || yellow;
   // Log level label
-  logResult += logLevelColors[currentLabel](currentLabel.toUpperCase())
+  logResult += color(currentLabel.toUpperCase());
 
   // date time
-  logResult += ' [' + new Date(time).toISOString() + '] '
+  logResult += ' [' + new Date(time).toISOString() + '] ';
 
   if (options.base.pid && options.base.hostname) {
-    logResult += ` (${options.base.pid} on ${options.base.hostname})`
+    logResult += ` (${options.base.pid} on ${options.base.hostname})`;
   }
 
   if (message) {
-    logResult += ' ' + logLevelColors[currentLabel](message)
+    logResult += ' ' + color(message);
   }
 
   if (Object.keys(originObj).length > 0) {
     // logResult += gray(' Json:')
-    logResult += os.EOL
-    logResult += gray(JSON.stringify(originObj, null, 2))
+    logResult += os.EOL;
+    logResult += gray(JSON.stringify(originObj, null, 2));
   }
 
-  logResult += os.EOL
+  logResult += os.EOL;
 
-  return logResult
-}
+  return logResult;
+};

package/lib/logger/format/asJson.js

@@ -1,25 +1,25 @@
-const os = require('os')
+const os = require('os');
 
 exports.asJson = (runtime, originObj, message, number, time) => {
   const data = {
     level: number,
     time,
     ...runtime.fixtures
-  }
+  };
 
   if (message !== undefined) {
-    data[runtime.options.messageKey] = message
+    data[runtime.options.messageKey] = message;
   }
 
-  const notHasOwnProperty = originObj.hasOwnProperty === undefined
+  const doesNotHaveOwnProperty = originObj.hasOwnProperty === undefined;
 
-  let value
+  let value;
   for (const key in originObj) {
-    value = originObj[key]
-    if ((notHasOwnProperty || originObj.hasOwnProperty(key)) && value !== undefined) {
-      data[key] = value
+    value = originObj[key];
+    if ((doesNotHaveOwnProperty || originObj.hasOwnProperty(key)) && value !== undefined) {
+      data[key] = value;
     }
   }
 
-  return JSON.stringify(data) + os.EOL
-}
+  return JSON.stringify(data) + os.EOL;
+};

package/lib/logger/format/index.js

@@ -1,4 +1,4 @@
-const { asJson } = require('./asJson')
-const { asHumanReadable } = require('./asHumanReadable')
+const { asJson } = require('./asJson');
+const { asHumanReadable } = require('./asHumanReadable');
 
-module.exports = { asJson, asHumanReadable }
+module.exports = { asJson, asHumanReadable };

package/lib/logger/index.js

@@ -1,24 +1,27 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2019 Fachwerk
  */
 
-const os = require('os')
-const { initBase } = require('./base')
-const { asJson, asHumanReadable } = require('./format')
-const { mappings } = require('./levels')
-const { coreFixtures } = require('./tools')
+const os = require('os');
+const { initBase } = require('./base');
+const { asJson, asHumanReadable } = require('./format');
+const { mappings } = require('./levels');
+const { coreFixtures } = require('./tools');
 
-const { pid } = process
-const hostname = os.hostname()
+const { pid } = process;
+const hostname = os.hostname();
 
 const defaultOptions = {
   enabled: true,
   level: 'info',
   messageKey: 'message',
   customLevels: null,
-  base: { pid, hostname },
+  base: {
+    pid,
+    hostname
+  },
   hooks: {
     logMethod: undefined
   },
@@ -26,50 +29,50 @@ const defaultOptions = {
     messageFormat: false
   },
   destination: process.stdout
-}
+};
 
 exports.createLogger = (options) => {
-  options = Object.assign(defaultOptions, options)
+  options = Object.assign(defaultOptions, options);
 
-  const instance = {}
+  const instance = {};
   const runtime = {
     options,
     logMethods: {},
     destination: options.destination,
     formatter: process.stdout.isTTY ? asHumanReadable : asJson
-  }
+  };
 
   if (options.enabled === false) {
-    options.level = 'silent'
+    options.level = 'silent';
   }
 
   if (options.base !== null) {
     if (options.name === undefined) {
-      runtime.fixtures = coreFixtures(options.base)
+      runtime.fixtures = coreFixtures(options.base);
     } else {
-      runtime.fixtures = coreFixtures(Object.assign({}, options.base, { name: options.name }))
+      runtime.fixtures = coreFixtures(Object.assign({}, options.base, { name: options.name }));
     }
   }
 
   if (options.mixin && typeof options.mixin !== 'function') {
-    throw Error(`Unknown mixin type "${typeof options.mixin}" - expected "function"`)
+    throw Error(`Unknown mixin type "${typeof options.mixin}" - expected "function"`);
   } else if (options.mixin) {
-    runtime.mixin = options.mixin
+    runtime.mixin = options.mixin;
   }
 
-  const levels = mappings(options.customLevels)
+  const levels = mappings(options.customLevels);
 
   // merge levels in logger runtime
-  Object.assign(runtime, { levels })
+  Object.assign(runtime, { levels });
 
-  initBase(runtime)
+  initBase(runtime);
 
-  runtime.setLevel(options.level)
+  runtime.setLevel(options.level);
 
   Object.assign(instance, {
     levels,
     ...runtime.logMethods
-  })
+  });
 
-  return instance
-}
+  return instance;
+};