@weave-js/core 0.11.1 → 0.13.0

package/lib/cache/getPropertyFromDataOrMetadata.js

@@ -0,0 +1,20 @@
+const { dotGet } = require('@weave-js/utils');
+
+/**
+ * Get property from data or metadata object.
+ * @param {any} data data object
+ * @param {object} metadata metadata object
+ * @param {string} key key
+ * @returns {any} Result
+ */
+const getPropertyFromDataOrMetadata = (data, metadata, key) => {
+  // if a key starts with ":", the property is picked from metadata
+  if (key.startsWith(':')) {
+    // remove ':' from key.
+    key = key.replace(':', '');
+    return dotGet(metadata, key);
+  }
+  return dotGet(data, key);
+};
+
+module.exports = { getPropertyFromDataOrMetadata };

package/lib/cache/lock.js

@@ -1,31 +1,37 @@
 const createLock = () => {
-  const locked = new Map()
+  const locked = new Map();
 
-  return {
-    acquire (key, ttl) {
-      const lockedItems = locked.get(key)
-      if (!lockedItems) {
-        locked.set(key, [])
-        return Promise.resolve()
+  function acquire (key, ttl) {
+    const lockedItems = locked.get(key);
+    if (!lockedItems) {
+      locked.set(key, []);
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve) => lockedItems.push(resolve));
+    }
+  }
+
+  function isLocked (key) {
+    return !!locked.has(key);
+  }
+
+  function release (key) {
+    const lockedItems = locked.get(key);
+    if (lockedItems) {
+      if (lockedItems.length > 0) {
+        lockedItems.shift()();
       } else {
-        return new Promise((resolve) => lockedItems.push(resolve))
-      }
-    },
-    isLocked (key) {
-      return !!locked.has(key)
-    },
-    release (key) {
-      const lockedItems = locked.get(key)
-      if (lockedItems) {
-        if (lockedItems.length > 0) {
-          lockedItems.shift()()
-        } else {
-          locked.delete(key)
-        }
+        locked.delete(key);
       }
-      return Promise.resolve()
     }
+    return Promise.resolve();
   }
-}
 
-module.exports = { createLock }
+  return Object.freeze({
+    acquire,
+    isLocked,
+    release
+  });
+};
+
+module.exports = { createLock };

package/lib/constants.js

@@ -1,22 +1,22 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-exports.PROTOCOL_VERSION = 1
+exports.PROTOCOL_VERSION = 1;
 
 exports.loadBalancingStrategy = {
   ROUND_ROBIN: 'round_robin',
   RANDOM: 'random'
-}
+};
 
 exports.circuitBreakerStates = {
   CIRCUIT_CLOSED: 'closed',
   CIRCUIT_HALF_OPENED: 'half_opened',
   CIRCUIT_HALF_OPEN_WAITING: 'half_open_waiting',
   CIRCUIT_OPENED: 'opened'
-}
+};
 
 exports.level = {
   trace: 'trace',
@@ -25,4 +25,4 @@ exports.level = {
   warn: 'warn',
   error: 'error',
   fatal: 'fatal'
-}
+};

package/lib/errorHandler.js

@@ -1,19 +1,19 @@
 exports.errorHandler = ({ options }, error) => {
   if (options.errorHandler) {
-    return options.errorHandler.call(null, error)
+    return options.errorHandler.call(null, error);
   }
-  throw error
-}
+  throw error;
+};
 
 exports.fatalErrorHandler = (runtime, message, error, killProcess = true) => {
-  const { options, log } = runtime
+  const { options, log } = runtime;
   if (options.logger.enabled) {
-    log.fatal(error, message)
+    log.fatal(error, message);
   } else {
-    console.error(message, error)
+    console.error(message, error);
   }
 
   if (killProcess) {
-    process.exit(1)
+    process.exit(1);
   }
-}
+};

package/lib/errors.js

@@ -1,118 +1,129 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { ExtendableError } = require('./ExtendableError')
+const { defaultsDeep } = require('@weave-js/utils');
+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
+  constructor (message, options) { // code, type, data
+    options = defaultsDeep(
+      options,
+      {
+        code: 'WEAVE_ERROR',
+        retryable: false
+      }
+    );
+
+    super(message, options);
+    this.name = this.constructor.name;
+    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
-    this.retryable = true
+  constructor (message, options = { code: 'WEAVE_RETRYABLE_ERROR', retryable: true }) {
+    super(message, options);
+    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, { code: 'WEAVE_SERVICE_NOT_FOUND_ERROR', data });
   }
 }
 
-class WeaveServiceNotAvailableError extends WeaveRetryableError {
+class WeaveServiceNotAvailableError extends WeaveRetryableError { // 503
   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, { 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 }
+    );
   }
 }
 
@@ -126,6 +137,5 @@ module.exports = {
   WeaveRetryableError,
   WeaveServiceNotAvailableError,
   WeaveServiceNotFoundError,
-  WeaveGracefulStopTimeoutError,
-  restoreError
-}
+  WeaveGracefulStopTimeoutError
+};

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,42 +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')
+exports.Constants = require('./constants');
 
 // Caching
-exports.Cache = require('./cache/adapters')
+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')
+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 };