@weave-js/core 0.11.1 → 0.13.0

package/lib/transport/messageTypes.js

@@ -1,23 +1,23 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
-exports.MESSAGE_UNKNOWN = 'unknown'
-exports.MESSAGE_DISCOVERY = 'discovery'
-exports.MESSAGE_INFO = 'info'
-exports.MESSAGE_REQUEST = 'request'
-exports.MESSAGE_RESPONSE = 'response'
-exports.MESSAGE_PING = 'ping'
-exports.MESSAGE_PONG = 'pong'
-exports.MESSAGE_DISCONNECT = 'disconnect'
-exports.MESSAGE_HEARTBEAT = 'heartbeat'
-exports.MESSAGE_EVENT = 'event'
-exports.MESSAGE_GOSSIP_HELLO = 'gossip_hello'
-exports.MESSAGE_GOSSIP_RESPONSE = 'gossip_response'
-exports.MESSAGE_GOSSIP_REQUEST = 'gossip_request'
-exports.MESSAGE_EVENT_ACK = 'event_ack'
-exports.MESSAGE_RESPONSE_STREAM_BACKPRESSURE = 'response_stream_backpressure'
-exports.MESSAGE_RESPONSE_STREAM_RESUME = 'response_stream_resume'
-exports.MESSAGE_REQUEST_STREAM_BACKPRESSURE = 'request_stream_backpressure'
-exports.MESSAGE_REQUEST_STREAM_RESUME = 'request_stream_resume'
+exports.MESSAGE_UNKNOWN = 'unknown';
+exports.MESSAGE_DISCOVERY = 'discovery';
+exports.MESSAGE_INFO = 'info';
+exports.MESSAGE_REQUEST = 'request';
+exports.MESSAGE_RESPONSE = 'response';
+exports.MESSAGE_PING = 'ping';
+exports.MESSAGE_PONG = 'pong';
+exports.MESSAGE_DISCONNECT = 'disconnect';
+exports.MESSAGE_HEARTBEAT = 'heartbeat';
+exports.MESSAGE_EVENT = 'event';
+exports.MESSAGE_GOSSIP_HELLO = 'gossip_hello';
+exports.MESSAGE_GOSSIP_RESPONSE = 'gossip_response';
+exports.MESSAGE_GOSSIP_REQUEST = 'gossip_request';
+exports.MESSAGE_EVENT_ACK = 'event_ack';
+exports.MESSAGE_RESPONSE_STREAM_BACKPRESSURE = 'response_stream_backpressure';
+exports.MESSAGE_RESPONSE_STREAM_RESUME = 'response_stream_resume';
+exports.MESSAGE_REQUEST_STREAM_BACKPRESSURE = 'request_stream_backpressure';
+exports.MESSAGE_REQUEST_STREAM_RESUME = 'request_stream_resume';

package/lib/types.js

@@ -1,5 +1,5 @@
 // eslint-disable-next-line no-unused-vars
-const { EventEmitter2: EventEmitter } = require('eventemitter2')
+const { EventEmitter2: EventEmitter } = require('eventemitter2');
 
 /**
  * @typedef {import('stream').Stream} Stream
@@ -268,7 +268,6 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {RetryPolicyOptions} [retryPolicy] - Retry policy
  * @property {ValidatorOptions} [validatorOptions] Validator options.
  * @property {boolean} [validateActionParams] validateActionParams.
- * @property {boolean} [watchServices] watchServices.
  * @property {number} [waitForServiceInterval] waitForServiceInterval.
  * @property {function():string} [beforeRegisterMiddlewares] beforeRegisterMiddlewares.
  * @property {function(Runtime):string} [uuidFactory] uuidFactory.
@@ -592,9 +591,9 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
 
 /**
  * @typedef {Object} ServiceActionCollectionListFilterParams
- * @property {boolean} [localOnly] Shows only local service actions
- * @property {boolean} [skipInternals] Shows only local service actions
- * @property {boolean} [withEndpoints] Shows only local service actions
+ * @property {boolean} [onlyLocals=false] Shows only local service actions
+ * @property {boolean} [skipInternals=false] Shows only local service actions
+ * @property {boolean} [withEndpoints=false] Shows only local service actions
  */
 
 /**
@@ -663,7 +662,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {function(Action):void} addAction addAction
  * @property {function(Event):void} addEvent addEvent
  * @property {function(string, number, string=): boolean} equals equals
- * @property {function(any)} update update
+ * @property {function(any):void} update update
 */
 
 /**
@@ -757,13 +756,27 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @typedef Middleware
  * @property {() => any} [created] created
  * @property {function(Broker):void} [started] started
- * @property {function(any, ServiceAction): any} [localAction] localAction
- * @property {(handler: any, action: ServiceAction) => any} [remoteAction] remoteAction
- * @property {function(any, ServiceAction): any} [localEvent] localEvent
- * @property {(next: Function) => MiddlewareEventDelegate} [emit] emit
- * @property {(next: Function) => MiddlewareEventDelegate} [broadcast] broadcast
- * @property {(next: Function) => MiddlewareEventDelegate} [broadcastLocal] broadcastLocal
- * @property {() => any} [brokerStopped] brokerStopped
+ * @property {function(Broker):void} [stopping] stopped
+ * @property {function(Broker):void} [createService] stopped
+ * @property {function(Broker):void} [loadService] stopped
+ * @property {function(Broker):void} [loadServices] stopped
+ * @property {function(Broker):void} [stopping] stopped
+ * @property {function(Broker):void} [ping] stopped
+ * @property {function(Broker):void} [call] stopped
+ * @property {function(Broker):void} [multiCall] stopped
+ * @property {function(Broker):void} [emit] stopped
+ * @property {function(Broker):void} [broadcast] stopped
+ * @property {function(Broker):void} [broadcastLocal] stopped
+ * @property {function(Broker):void} [serviceCreating] stopped
+ * @property {function(Broker):void} [serviceCreated] stopped
+ * @property {function(Broker):void} [serviceStopping] stopped
+ * @property {function(Broker):void} [serviceStopped] stopped
+ * @property {function(Broker):void} [localAction] stopped
+ * @property {function(Broker):void} [localEvent] stopped
+ * @property {function(Broker):void} [remoteAction] stopped
+ * @property {function(Broker):void} [remoteEvent] stopped
+ * @property {function(Broker):void} [transportSend] stopped
+ * @property {function(Broker):void} [transportMessageHandler] stopped
 */
 
 // Validator
@@ -779,7 +792,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * Tracer instance
  * @typedef Tracer
  * @property {void} init init
- * @property {Promise<any>} stop stop
+ * @property {function():Promise<any>} stop stop
  * @property {boolean} shouldSample shouldSample
  * @property {function():void} invokeCollectorMethod invokeCollectorMethod
  * @property {function(string, object):Span} startSpan startSpan
@@ -834,4 +847,4 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @param {object} data - Payload
  */
 
-module.exports = {}
+module.exports = {};

package/lib/utils/index.js

@@ -2,4 +2,4 @@
 exports = {
   ...require('./options'),
   ...require('./restoreError')
-}
+};

package/lib/utils/options.js

@@ -6,111 +6,111 @@ const {
   flatten,
   wrapHandler,
   wrapInArray
-} = require('@weave-js/utils')
+} = require('@weave-js/utils');
 
 function mergeSettings (source, targetSchema) {
-  return defaultsDeep(source, targetSchema)
+  return defaultsDeep(source, targetSchema);
 }
 
 function mergeMeta (source, targetSchema) {
-  return defaultsDeep(source, targetSchema)
+  return defaultsDeep(source, targetSchema);
 }
 
 function mergeUniqueArrays (source, targetSchema) {
-  return compact(flatten([targetSchema, source]))
+  return compact(flatten([targetSchema, source]));
 }
 
 function mergeActions (source, targetSchema) {
   Object.keys(source).map(key => {
     // prevent action merge
     if (source[key] === false && targetSchema[key]) {
-      delete targetSchema[key]
-      return
+      delete targetSchema[key];
+      return;
     }
 
-    const sourceAction = wrapHandler(source[key])
-    const targetSchemaAction = wrapHandler(targetSchema[key])
+    const sourceAction = wrapHandler(source[key]);
+    const targetSchemaAction = wrapHandler(targetSchema[key]);
 
-    targetSchema[key] = deepMerge(sourceAction, targetSchemaAction)
-  })
+    targetSchema[key] = deepMerge(sourceAction, targetSchemaAction);
+  });
 
-  return targetSchema
+  return targetSchema;
 }
 
 // Merge events
 function mergeEvents (source, targetSchema) {
   Object.keys(source).map(key => {
-    const sourceEvent = wrapHandler(source[key])
-    const targetEvent = wrapHandler(targetSchema[key])
+    const sourceEvent = wrapHandler(source[key]);
+    const targetEvent = wrapHandler(targetSchema[key]);
 
-    let handler = compact(flatten([sourceEvent ? sourceEvent.handler : null, targetEvent ? targetEvent.handler : null]))
+    let handler = compact(flatten([sourceEvent ? sourceEvent.handler : null, targetEvent ? targetEvent.handler : null]));
     if (handler.length === 1) {
-      handler = handler[0]
+      handler = handler[0];
     }
 
-    targetSchema[key] = deepMerge(sourceEvent, targetEvent)
-    targetSchema[key].handler = handler
-  })
-  return targetSchema
+    targetSchema[key] = deepMerge(sourceEvent, targetEvent);
+    targetSchema[key].handler = handler;
+  });
+  return targetSchema;
 }
 
 function mergeMethods (source, targetSchema) {
-  return Object.assign(source, targetSchema)
+  return Object.assign(source, targetSchema);
 }
 
 function mergeActionHooks (source, target) {
   Object.keys(source).map(hookName => {
     if (!target[hookName]) {
-      target[hookName] = {}
+      target[hookName] = {};
     }
 
     Object.keys(source[hookName]).map(actionName => {
-      const sourceHookAction = wrapInArray(source[hookName][actionName])
-      const targetHookAction = wrapInArray(target[hookName][actionName])
-      target[hookName][actionName] = compact(flatten([sourceHookAction, targetHookAction]))
-    })
-  })
+      const sourceHookAction = wrapInArray(source[hookName][actionName]);
+      const targetHookAction = wrapInArray(target[hookName][actionName]);
+      target[hookName][actionName] = compact(flatten([sourceHookAction, targetHookAction]));
+    });
+  });
 
-  return target
+  return target;
 }
 
 function mergeLifecicleHooks (source, targetSchema) {
-  return compact(flatten([targetSchema, source]))
+  return compact(flatten([targetSchema, source]));
 }
 
 function mergeSchemas (mixin, targetSchema) {
-  const mixinSchema = clone(mixin)
-  const resultSchema = clone(targetSchema)
+  const mixinSchema = clone(mixin);
+  const resultSchema = clone(targetSchema);
 
   Object.keys(resultSchema).forEach(key => {
     if (['name', 'version'].includes(key)) {
       // override value
-      mixinSchema[key] = resultSchema[key]
+      mixinSchema[key] = resultSchema[key];
     } else if (key === 'dependencies') {
-      mixinSchema[key] = mergeUniqueArrays(resultSchema[key], mixinSchema[key])
+      mixinSchema[key] = mergeUniqueArrays(resultSchema[key], mixinSchema[key]);
     } else if (key === 'mixins') {
-      mixinSchema[key] = mergeUniqueArrays(resultSchema[key], mixinSchema[key] || {})
+      mixinSchema[key] = mergeUniqueArrays(resultSchema[key], mixinSchema[key] || {});
     } else if (key === 'settings') {
-      mixinSchema[key] = mergeSettings(resultSchema[key], mixinSchema[key])
+      mixinSchema[key] = mergeSettings(resultSchema[key], mixinSchema[key]);
     } else if (key === 'meta') {
-      mixinSchema[key] = mergeMeta(resultSchema[key], mixinSchema[key])
+      mixinSchema[key] = mergeMeta(resultSchema[key], mixinSchema[key]);
     } else if (key === 'actions') {
-      mixinSchema[key] = mergeActions(resultSchema[key], mixinSchema[key] || {})
+      mixinSchema[key] = mergeActions(resultSchema[key], mixinSchema[key] || {});
     } else if (key === 'hooks') {
-      mixinSchema[key] = mergeActionHooks(resultSchema[key], mixinSchema[key] || {})
+      mixinSchema[key] = mergeActionHooks(resultSchema[key], mixinSchema[key] || {});
     } else if (key === 'events') {
-      mixinSchema[key] = mergeEvents(resultSchema[key], mixinSchema[key] || {})
+      mixinSchema[key] = mergeEvents(resultSchema[key], mixinSchema[key] || {});
     } else if (key === 'methods') {
-      mixinSchema[key] = mergeMethods(resultSchema[key], mixinSchema[key] || {})
+      mixinSchema[key] = mergeMethods(resultSchema[key], mixinSchema[key] || {});
     } else if (['afterSchemasMerged', 'created', 'started', 'stopped'].includes(key)) {
-      mixinSchema[key] = mergeLifecicleHooks(resultSchema[key], mixinSchema[key])
+      mixinSchema[key] = mergeLifecicleHooks(resultSchema[key], mixinSchema[key]);
     } else {
       // default action for properties
-      mixinSchema[key] = resultSchema[key]
+      mixinSchema[key] = resultSchema[key];
     }
-  })
+  });
 
-  return mixinSchema
+  return mixinSchema;
 }
 
-module.exports = { mergeSchemas }
+module.exports = { mergeSchemas };

package/lib/utils/restoreError.js

@@ -1,12 +1,64 @@
-const errors = require('../errors')
+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.11.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.10.1",
-    "@weave-js/validator": "^0.11.1",
+    "@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": "bc467dd08fe0626c40e7eb19b344c102386baf15"
+  "gitHead": "6772c8bfb00be1da32c17cff621a8abcd98a08fc"
 }

package/lib/cache/base.js

@@ -1,136 +0,0 @@
-/*
- * Author: Kevin Ries (kevin@fachw3rk.de)
- * -----
- * Copyright 2021 Fachwerk
- */
-const crypto = require('crypto')
-const { isObject, dotGet, isString } = require('@weave-js/utils')
-const Constants = require('../metrics/constants')
-const { WeaveError } = require('../errors')
-
-/**
- * Get property from data or metadata object.
- * @param {any} data data object
- * @param {object} metadata metadata object
- * @param {string} key key
- * @returns {any} Result
- */
-function 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)
-}
-
-function getCacheKeyByObject (val) {
-  if (Array.isArray(val)) {
-    return val.map(object => getCacheKeyByObject(object)).join('/')
-  } else if (isObject(val)) {
-    return Object.keys(val).map(key => {
-      return [key, getCacheKeyByObject(val[key])].join('/')
-    }).join('/')
-  } else if (val !== null) {
-    return val.toString()
-  } else {
-    return 'null'
-  }
-}
-
-function generateHash (key) {
-  return crypto
-    .createHash('sha1')
-    .update(key)
-    .digest('base64')
-}
-
-function registerCacheMetrics (metrics) {
-  metrics.register({ type: 'counter', name: Constants.CACHE_GET_TOTAL })
-  metrics.register({ type: 'counter', name: Constants.CACHE_SET_TOTAL })
-  metrics.register({ type: 'counter', name: Constants.CACHE_FOUND_TOTAL })
-  metrics.register({ type: 'counter', name: Constants.CACHE_EXPIRED_TOTAL })
-  metrics.register({ type: 'counter', name: Constants.CACHE_DELETED_TOTAL })
-  metrics.register({ type: 'counter', name: Constants.CACHE_CLEANED_TOTAL })
-}
-
-exports.createCacheBase = (name, runtime, options) => {
-  if (!isString(name)) {
-    throw new WeaveError('Name needs to be a string.')
-  }
-
-  const cache = {
-    name,
-    isConnected: false,
-    runtime,
-    options: Object.assign({
-      ttl: null
-    }, options),
-    init () {
-      // register metrics
-      if (runtime.metrics) {
-        this.metrics = runtime.metrics
-        registerCacheMetrics(runtime.metrics)
-      }
-    },
-    log: runtime.createLogger('CACHER'),
-    set (/* hashKey, result, ttl */) {
-      /* istanbul ignore next */
-      runtime.handleError(new Error('Method not implemented.'))
-    },
-    get (/* hashKey */) {
-      /* istanbul ignore next */
-      runtime.handleError(new Error('Method not implemented.'))
-    },
-    remove () {
-      /* istanbul ignore next */
-      runtime.handleError(new Error('Method not implemented.'))
-    },
-    clear () {
-      /* istanbul ignore next */
-      runtime.handleError(new Error('Method not implemented.'))
-    },
-    stop () {
-      /* istanbul ignore next */
-      return Promise.resolve()
-    },
-    getCachingKey (actionName, data, metadata, keys) {
-      if (data || metadata) {
-        const prefix = actionName + ':'
-
-        if (keys) {
-          // fast path for single keys
-          if (keys.length === 1) {
-            const value = getPropertyFromDataOrMetadata(data, metadata, keys[0])
-            const key = getCacheKeyByObject(value)
-            return prefix + (isObject(value) ? key : value)
-          }
-
-          // Handle data cache keys
-          if (keys.length > 0) {
-            const res = keys.reduce((pre, property, index) => {
-              const value = getPropertyFromDataOrMetadata(data, metadata, property)
-              let hash
-              if (isObject(value)) {
-                const key = getCacheKeyByObject(value)
-                hash = generateHash(key)
-              } else {
-                hash = value
-              }
-
-              return pre + (index > 0 ? '|' : '') + hash
-            }, prefix)
-            return res
-          }
-        } else {
-          return prefix + generateHash(getCacheKeyByObject(data))
-        }
-      }
-
-      return actionName
-    }
-  }
-
-  return cache
-}