@weave-js/core 0.10.0 → 0.12.0

package/.eslintrc.js

@@ -1 +1 @@
-module.exports = require('../../../.eslintrc.js')
+module.exports = require('../../../.eslintrc.js');

package/jest.config.js

@@ -9,4 +9,4 @@ module.exports = {
   roots: [
     './test'
   ]
-}
+};

package/lib/ExtendableError.js

@@ -0,0 +1,33 @@
+class ExtendableError extends Error {
+  constructor (message = '') {
+    super(message);
+
+    Object.defineProperty(this, 'name', {
+      configurable: true,
+      enumerable: false,
+      value: this.constructor.name,
+      writable: true
+    });
+
+    Object.defineProperty(this, 'message', {
+      configurable: true,
+      enumerable: false,
+      value: message,
+      writable: true
+    });
+
+    if (Object.prototype.hasOwnProperty.call(Error, 'captureStackTrace')) {
+      Error.captureStackTrace(this, this.constructor);
+      return;
+    }
+
+    Object.defineProperty(this, 'stack', {
+      configurable: true,
+      enumerable: false,
+      value: new Error(message).stack,
+      writable: true
+    });
+  }
+}
+
+module.exports = { ExtendableError };

package/lib/broker/context.js

@@ -1,18 +1,19 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
- */
-'use strict'
+*/
+'use strict';
 
 /**
  * @typedef {import('../types').Context} Context
  * @typedef {import('../types').Runtime} Runtime
  * @typedef {import('../types').ContextPromise} ContextPromise
+ * @typedef {import('../types').Endpoint} Endpoint
 */
 
-const { uuid, isFunction, isStream, isStreamObjectMode } = require('@weave-js/utils')
-const { WeaveMaxCallLevelError, WeaveError } = require('../errors')
+const { uuid, isFunction, isStream, isStreamObjectMode } = require('@weave-js/utils');
+const { WeaveMaxCallLevelError, WeaveError } = require('../errors');
 
 /**
  * Create a new context object
@@ -42,60 +43,69 @@ exports.createContext = (runtime) => {
     duration: 0,
     stopTime: 0,
     setData (newParams) {
-      this.data = newParams || {}
+      this.data = newParams || {};
     },
     setStream (stream) {
       if (isStream(stream)) {
         if (isStreamObjectMode(context.options.stream)) {
-          this.meta.$isObjectModeStream = true
+          this.meta.$isObjectModeStream = true;
         }
-        this.stream = stream
+        this.stream = stream;
       } else {
-        throw new WeaveError('No valid stream.')
+        throw new WeaveError('No valid stream.');
       }
     },
     setEndpoint (endpoint) {
-      this.nodeId = endpoint.node.id
-      this.endpoint = endpoint
-      this.action = endpoint.action
-      this.service = endpoint.action.service
+      this.nodeId = endpoint.node.id;
+      this.endpoint = endpoint;
+      this.action = endpoint.action;
+      this.service = endpoint.action.service;
     },
     emit (eventName, payload, options = {}) {
-      options.parentContext = this
-      return runtime.eventBus.emit(eventName, payload, options)
+      options.parentContext = this;
+      return runtime.eventBus.emit(eventName, payload, options);
     },
     broadcast (eventName, payload, options = {}) {
-      options.parentContext = this
-      return runtime.eventBus.broadcast(eventName, payload, options)
+      options.parentContext = this;
+      return runtime.eventBus.broadcast(eventName, payload, options);
     },
     call (actionName, params, options = {}) {
-      options.parentContext = this
+      options.parentContext = this;
       if (runtime.options.registry.maxCallLevel > 0 && this.level >= runtime.options.registry.maxCallLevel) {
-        return Promise.reject(new WeaveMaxCallLevelError({ nodeId: runtime.nodeId, maxCallLevel: runtime.options.registry.maxCallLevel }))
+        return Promise.reject(new WeaveMaxCallLevelError({ nodeId: runtime.nodeId, maxCallLevel: runtime.options.registry.maxCallLevel }));
       }
 
       /** @type {ContextPromise} */
-      const p = runtime.actionInvoker.call(actionName, params, options)
+      const p = runtime.actionInvoker.call(actionName, params, options);
 
       return p.then(result => {
         if (p.context) {
-          this.meta = Object.assign(this.meta, p.context.meta)
+          this.meta = Object.assign(this.meta, p.context.meta);
         }
-        return result
-      })
+        return result;
+      });
     },
     startSpan (name, options) {
+      options = Object.assign({
+        id: this.id,
+        traceId: this.requestId,
+        parentId: this.parentId,
+        type: 'action',
+        service: this.service,
+        sampled: this.tracing
+      }, options);
+
       if (this.span) {
-        this.span = this.span.startChildSpan(name, options)
+        this.span = this.span.startChildSpan(name, options);
       } else {
-        this.span = runtime.tracer.startSpan(name, options)
+        this.span = runtime.tracer.startSpan(name, options);
       }
-      return this.span
+      return this.span;
     },
     finishSpan () {
       if (this.span) {
-        this.span.finish()
-        return this.span
+        this.span.finish();
+        return this.span;
       }
     },
     /**
@@ -103,38 +113,40 @@ exports.createContext = (runtime) => {
      * @returns {Context} New copied context
     */
     copy () {
-      const contextCopy = exports.createContext(runtime)
+      const contextCopy = exports.createContext(runtime);
 
-      contextCopy.nodeId = this.nodeId
-      contextCopy.options = this.options
-      contextCopy.data = this.data
-      contextCopy.meta = this.meta
-      contextCopy.parentContext = this.parentContext
-      contextCopy.callerNodeId = this.callerNodeId
-      contextCopy.level = this.level
-      contextCopy.eventName = this.eventName
-      contextCopy.eventType = this.eventType
-      contextCopy.eventGroups = this.eventGroups
+      contextCopy.nodeId = this.nodeId;
+      contextCopy.options = this.options;
+      contextCopy.data = this.data;
+      contextCopy.meta = this.meta;
+      contextCopy.parentContext = this.parentContext;
+      contextCopy.callerNodeId = this.callerNodeId;
+      contextCopy.requestId = this.requestId;
+      contextCopy.tracing = this.tracing;
+      contextCopy.level = this.level;
+      contextCopy.eventName = this.eventName;
+      contextCopy.eventType = this.eventType;
+      contextCopy.eventGroups = this.eventGroups;
 
-      return contextCopy
+      return contextCopy;
     }
-  }
+  };
 
   // Generate context Id
   if (!context.id) {
     // Use UUID factory from broker options
     if (runtime.options.uuidFactory && isFunction(runtime.options.uuidFactory)) {
-      context.id = runtime.options.uuidFactory.call(context, runtime)
+      context.id = runtime.options.uuidFactory.call(context, runtime);
     } else {
-      context.id = uuid()
+      context.id = uuid();
     }
 
     // Pass existing request ID
     if (!context.requestId) {
-      context.requestId = context.id
+      context.requestId = context.id;
     }
   }
 
-  return context
-}
+  return context;
+};
 

package/lib/broker/{default-options.js → defaultOptions.js}

@@ -3,14 +3,15 @@
 */
 
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
 
 /** @module weave */
-const os = require('os')
-const { loadBalancingStrategy } = require('../constants')
+const os = require('os');
+const { createInMemoryCache } = require('../cache/adapters/inMemory.js');
+const { loadBalancingStrategy } = require('../constants');
 
 /**
  * Returns the default options
@@ -28,8 +29,11 @@ exports.getDefaultOptions = () => {
     },
     cache: {
       enabled: false,
-      adapter: 'memory',
-      ttl: 3000
+      adapter: createInMemoryCache(),
+      ttl: 3000,
+      lock: {
+        enabled: false
+      }
     },
     circuitBreaker: {
       enabled: false,
@@ -49,7 +53,10 @@ exports.getDefaultOptions = () => {
       heartbeatTimeout: 10 * 1000,
       offlineNodeCheckInterval: 30 * 1000,
       maxOfflineTime: 1000 * 60 * 10,
-      maxChunkSize: 256 * 1024
+      maxChunkSize: 256 * 1024,
+      streams: {
+        handleBackpressure: true
+      }
     },
     errorHandler: null,
     loadInternalMiddlewares: true,
@@ -58,9 +65,9 @@ exports.getDefaultOptions = () => {
       collectCommonMetrics: true,
       collectInterval: 5000,
       adapters: [],
-      defaultBuckets: [1, 5, 10, 20, 25, 30, 50, 100, 250, 500, 1000, 2500, 5000, 10000]
+      defaultBuckets: [1, 5, 10, 20, 25, 30, 40, 50, 100, 250, 500, 1000, 2500, 5000, 10000]
     },
-    middlewares: null,
+    middlewares: [],
     logger: {
       enabled: true,
       level: 'info',
@@ -72,7 +79,19 @@ exports.getDefaultOptions = () => {
     tracing: {
       enabled: false,
       samplingRate: 1.0,
-      collectors: []
+      collectors: [],
+      actions: {
+        data: false,
+        tags: {}
+      },
+      events: {
+        data: false,
+        tags: {}
+      },
+      errors: {
+        fields: ['name', 'message', 'code', 'type', 'data'],
+        stackTrace: false
+      }
     },
     namespace: '',
     registry: {
@@ -91,7 +110,6 @@ exports.getDefaultOptions = () => {
     validatorOptions: {
       strict: true,
       strictMode: 'remove' // 'error'
-    },
-    watchServices: false
-  }
-}
+    }
+  };
+};