@weave-js/core 0.11.0 → 0.12.1

package/lib/errors.js

@@ -1,96 +1,96 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { ExtendableError } = require('./ExtendableError')
+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 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 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.'
+      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 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.`
+      message = `Service "${data.actionName}" not available.`;
     } else {
-      message = 'Service not available.'
+      message = 'Service not available.';
     }
 
-    super(message, 503, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data)
+    super(message, 503, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data);
   }
 }
 
 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,
       timeout
-    })
-    this.retryable = true
+    });
+    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);
   }
 }
 
@@ -99,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,
@@ -128,4 +128,4 @@ module.exports = {
   WeaveServiceNotFoundError,
   WeaveGracefulStopTimeoutError,
   restoreError
-}
+};

package/lib/helper/defineAction.js

@@ -10,5 +10,5 @@
  * @returns {ServiceActionDefinition} Action definition
 */
 module.exports = function (actionDefinition) {
-  return actionDefinition
-}
+  return actionDefinition;
+};

package/lib/helper/defineBrokerOptions.js

@@ -10,5 +10,5 @@
  * @returns {BrokerOptions} Broker options
 */
 module.exports = function (options) {
-  return options
-}
+  return options;
+};

package/lib/helper/defineService.js

@@ -11,5 +11,5 @@
  * @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/defaultOptions')
-const { defaultsDeep } = require('@weave-js/utils')
-const { initRuntime } = require('./buildRuntime')
-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 = getDefaultOptions()
+exports.defaultOptions = getDefaultOptions();
 
 /**
  * Build runtime object
@@ -21,43 +21,42 @@ exports.defaultOptions = getDefaultOptions()
 */
 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 = initRuntime(options)
+  const runtime = initRuntime(options);
 
   // Create broker instance
-  return createBrokerInstance(runtime)
-}
+  return createBrokerInstance(runtime);
+};
 
 /**
  * @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.Cache = require('./cache/adapters');
 
 /**
  * @deprecated since version 0.10.0
 */
-exports.createBaseTracingCollector = require('./tracing/collectors/base').createBaseTracingCollector
-exports.TracingAdapters = require('./tracing/collectors')
+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/defineBrokerOptions')
-exports.defineService = require('./helper/defineService')
-exports.defineAction = require('./helper/defineAction')
+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, 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,32 +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
+  const color = logLevelColors[currentLabel] || yellow;
   // Log level label
-  logResult += color(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 += ' ' + color(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,17 +1,17 @@
 /*
- * 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,
@@ -29,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;
+};

package/lib/logger/levels.js

@@ -1,4 +1,4 @@
-const { generateLogMethod } = require('./tools')
+const { generateLogMethod } = require('./tools');
 
 const levels = {
   verbose: 60,
@@ -7,14 +7,14 @@ const levels = {
   warn: 30,
   error: 20,
   fatal: 10
-}
+};
 
 // wrap log methods
 const levelMethods = {
   fatal: (runtime, hook) => {
-    const logFatal = generateLogMethod(runtime, levels.fatal, hook)
+    const logFatal = generateLogMethod(runtime, levels.fatal, hook);
     return function (...args) {
-      logFatal.call(runtime, ...args)
+      logFatal.call(runtime, ...args);
       // if (typeof stream.flushSync === 'function') {
       //   try {
       //     stream.flushSync()
@@ -22,48 +22,48 @@ const levelMethods = {
       //     // https://github.com/pinojs/pino/pull/740#discussion_r346788313
       //   }
       // }
-    }
+    };
   },
   error: (runtime, hook) => generateLogMethod(runtime, levels.error, hook),
   warn: (runtime, hook) => generateLogMethod(runtime, levels.warn, hook),
   info: (runtime, hook) => generateLogMethod(runtime, levels.info, hook),
   debug: (runtime, hook) => generateLogMethod(runtime, levels.debug, hook),
   verbose: (runtime, hook) => generateLogMethod(runtime, levels.verbose, hook)
-}
+};
 
-exports.levelMethods = levelMethods
+exports.levelMethods = levelMethods;
 
 const numbers = Object.keys(levels).reduce((o, k) => {
-  o[levels[k]] = k
-  return o
-}, {})
+  o[levels[k]] = k;
+  return o;
+}, {});
 
 exports.mappings = (customLevels = null, useOnlyCustomLevels = false) => {
   const customNums = customLevels ? Object.keys(customLevels).reduce((o, k) => {
-    o[customLevels[k]] = k
-    return o
+    o[customLevels[k]] = k;
+    return o;
   }, {})
-    : null
+    : null;
 
   const labels = Object.assign(
     Object.create(Object.prototype, { Infinity: { value: 'silent' }}),
     useOnlyCustomLevels ? null : numbers,
     customNums
-  )
+  );
 
   // Merge log levels with "silent" log level.
   const values = Object.assign(
     Object.create(Object.prototype, { silent: { value: 0 }}),
     useOnlyCustomLevels ? null : levels,
     customLevels
-  )
+  );
 
-  return { labels, values }
-}
+  return { labels, values };
+};
 
 exports.isStandardLevel = (level, useOnlyCustomLevels) => {
   if (useOnlyCustomLevels) {
-    return false
+    return false;
   }
 
   switch (level) {
@@ -73,8 +73,8 @@ exports.isStandardLevel = (level, useOnlyCustomLevels) => {
   case 'info':
   case 'debug':
   case 'verbose':
-    return true
+    return true;
   default:
-    return false
+    return false;
   }
-}
+};