@weave-js/core 0.9.4 → 0.11.1

package/lib/middlewares/cache/index.js

@@ -0,0 +1,106 @@
+const { isString, isFunction } = require('@weave-js/utils')
+
+module.exports = (runtime) => {
+  return {
+    localAction: (handler, action) => {
+      const cacheOptions = runtime.options.cache
+      const cacheActionOptions = {
+        enabled: !!action.cache
+      }
+
+      if (isString(action.cache)) {
+        cacheActionOptions.keys = action.cache.split(' ')
+      } else if (action.cache && Array.isArray(action.cache.keys)) {
+        cacheActionOptions.keys = action.cache.keys
+      }
+
+      if (cacheActionOptions.enabled) {
+        const cache = runtime.cache
+        const isEnabledFunction = isFunction(action.cache.condition)
+
+        return function cacheMiddleware (context, serviceInjections) {
+          // handle enabled function
+          if (isEnabledFunction) {
+            if (!action.cache.enabled.call(null, context)) {
+              // Enabled function returns "false". Cache is disabled.
+              return handler(context, serviceInjections)
+            }
+          }
+
+          // Generate cache hash
+          const cacheHashKey = cache.getCachingKey(
+            action.name,
+            context.data,
+            context.meta,
+            cacheActionOptions.keys
+          )
+
+          context.isCachedResult = false
+
+          // Disable caching by meta property.
+          if (context.meta.$noCache === true) {
+            return handler(context, serviceInjections)
+          }
+
+          // The cache adapter is not connected yet. In this case, we call the handler regular
+          if (cache.isConnected === false) {
+            cache.log('Cache adapter is not connected yet. Call handler...')
+            return handler(context, serviceInjections)
+          }
+
+          if (cacheOptions.lock.enabled) {
+            let cachePromise
+            if (cacheOptions.lock.staleTime && cache.getWithTTl) {
+
+            } else {
+              cachePromise = runtime.cache.get(cacheHashKey)
+            }
+
+            return cachePromise.then((cachedResult) => {
+              if (cachedResult !== null) {
+                // Found a cached value. Skip calling handler and return our value
+                context.isCachedResult = true
+                return cachedResult
+              }
+
+              return cache.lock(cacheHashKey).then((release) => {
+                return cache.get(cacheHashKey).then(cachedResult => {
+                  if (cachedResult !== null) {
+                    // Found a cached value. Skip calling handler and return our value
+                    context.isCachedResult = true
+                    return release().then(() => {
+                      return cachedResult
+                    })
+                  }
+
+                  return handler(context).then((result) => {
+                    // Cache the value
+                    cache.set(cacheHashKey, result, action.cache.ttl).then(() => {
+                      // release the lock
+                      release()
+                    })
+                    return result
+                  })
+                })
+              })
+            })
+          }
+
+          // Not using cache lock
+          return runtime.cache.get(cacheHashKey).then((cachedResult) => {
+            if (cachedResult !== null) {
+              context.isCachedResult = true
+              return cachedResult
+            }
+
+            return handler(context, serviceInjections).then((result) => {
+              runtime.cache.set(cacheHashKey, result, action.cache.ttl)
+              return result
+            })
+          })
+        }
+      }
+      return handler
+    }
+  }
+}

package/lib/middlewares/circuit-breaker/index.js

@@ -1,8 +1,14 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
+const {
+  CIRCUIT_CLOSED,
+  CIRCUIT_HALF_OPENED,
+  CIRCUIT_HALF_OPEN_WAITING,
+  CIRCUIT_OPENED
+} = require('../../constants').circuitBreakerStates
 
 module.exports = (runtime) => {
   const storage = new Map()
@@ -15,7 +21,7 @@ module.exports = (runtime) => {
   }
 
   function clearEndpointStore () {
-    storage.forEach(item => {
+    storage.forEach((item) => {
       if (item.callCounter === 0) {
         storage.delete(item.name)
         return
@@ -34,7 +40,7 @@ module.exports = (runtime) => {
         options,
         callCounter: 0,
         failureCouter: 0,
-        state: 'CIRCUIT_BREAKER_CLOSED',
+        state: CIRCUIT_CLOSED,
         circuitBreakerTimer: null
       }
       storage.set(endpoint.name, item)
@@ -43,17 +49,17 @@ module.exports = (runtime) => {
     return item
   }
 
-  function success (item, options) {
+  function onSuccess (item, options) {
     item.callCounter++
 
-    if (item.state === 'CIRCUIT_BREAKER_HALF_OPENED') {
-      closeCircuitBreaker(item, options)
+    if (item.state === CIRCUIT_HALF_OPENED) {
+      closeCircuitBreaker(item)
     } else {
       checkThreshold(item, options)
     }
   }
 
-  function failure (item, error, options) {
+  function onFailure (item, options) {
     item.callCounter++
     item.failureCouter++
 
@@ -67,24 +73,36 @@ module.exports = (runtime) => {
   }
 
   function openCircuitBreaker (item) {
-    item.state = 'CIRCUIT_BREAKER_OPEN'
+    item.state = CIRCUIT_OPENED
     item.endpoint.state = false
     item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout)
-
+    item.circuitBreakerTimer.unref()
     log.debug(`Circuit breaker has been opened for endpoint '${item.endpoint.name}'`)
   }
 
   function halfOpenCircuitBreaker (item) {
-    item.state = 'CIRCUIT_BREAKER_HALF_OPEN'
+    item.state = CIRCUIT_HALF_OPENED
     item.endpoint.state = true
 
     log.debug(`Circuit breaker has been half opened for endpoint '${item.endpoint.name}'`)
+
+    if (item.circuitBreakerTimer) {
+      clearTimeout(item.circuitBreakerTimer)
+      item.circuitBreakerTimer = null
+    }
   }
 
-  function closeCircuitBreaker (item, options) {
+  function handleHalfOpen (item) {
+    item.state = CIRCUIT_HALF_OPEN_WAITING
+    item.endpoint.state = false
+    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout)
+    item.circuitBreakerTimer.unref()
+  }
+
+  function closeCircuitBreaker (item) {
     item.failureCouter = 0
     item.callCounter = 0
-    item.state = 'CIRCUIT_BREAKER_CLOSED'
+    item.state = CIRCUIT_CLOSED
     item.endpoint.state = true
 
     if (item.circuitBreakerTimer) {
@@ -99,19 +117,26 @@ module.exports = (runtime) => {
     const options = Object.assign({}, runtime.options.circuitBreaker, action.circuitBreaker || {})
 
     if (options.enabled) {
-      return function curcuitBreakerMiddleware (context) {
+      return function curcuitBreakerMiddleware (context, serviceInjections) {
         const endpoint = context.endpoint
         const item = getEndpointState(endpoint, options)
 
-        return handler(context)
+        // handle half open states
+        if (item.state === CIRCUIT_HALF_OPENED) {
+          handleHalfOpen(item, context)
+        }
+
+        return handler(context, serviceInjections)
           .then(result => {
             const item = getEndpointState(endpoint, options)
-            success(item, options)
+            onSuccess(item, options)
 
             return result
           })
           .catch(error => {
-            failure(item, error, options)
+            if (item && (!error.nodeId || error.nodeId === context.nodeId)) {
+              onFailure(item, options)
+            }
 
             return Promise.reject(error)
           })

package/lib/middlewares/context-tracker/index.js

@@ -27,16 +27,16 @@ module.exports = (runtime) => {
   }
 
   function wrapContextTrackerMiddleware (actionHandler) {
-    return function ContextTrackerMiddleware (context) {
+    return function ContextTrackerMiddleware (context, serviceInjections) {
       const isTracked = context.options.track === true ? context.options.track : runtime.options.contextTracking.enabled
 
       if (!isTracked) {
-        return actionHandler(context)
+        return actionHandler(context, serviceInjections)
       }
 
       addContext(context)
 
-      return actionHandler(context)
+      return actionHandler(context, serviceInjections)
         .then(result => {
           removeContext(context)
           return result

package/lib/middlewares/error-handler/index.js

@@ -1,15 +1,15 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 const { WeaveError } = require('../../errors')
 
 module.exports = (runtime) => {
   const wrapErrorHandlerMiddleware = function (handler) {
-    return function errorHandlerMiddleware (context) {
-      return handler(context)
+    return function errorHandlerMiddleware (context, serviceInjections) {
+      return handler(context, serviceInjections)
         .catch(error => {
           if (!(error instanceof Error)) {
             error = new WeaveError(error, 500)

package/lib/middlewares/index.js

@@ -1,12 +1,13 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 module.exports = {
   ActionHooks: require('./action-hooks'),
   Bulkhead: require('./bulkhead'),
+  Cache: require('./cache'),
   CircuitBreaker: require('./circuit-breaker'),
   ErrorHandler: require('./error-handler'),
   Metrics: require('./metrics'),

package/lib/middlewares/metrics/getMiddlewareWrapper.js

@@ -4,14 +4,14 @@ module.exports.getMiddlewareWrapper = (runtime) => function (type, action, handl
   const serviceName = action.service ? action.service.fullyQualifiedName : null
   const actionName = action.name
 
-  return function metricMiddleware (context) {
+  return function metricMiddleware (context, serviceInjections) {
     const callerNodeId = context.callerNodeId
 
     runtime.metrics.increment(Constants.REQUESTS_TOTAL, { type, serviceName, actionName, callerNodeId })
     runtime.metrics.increment(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId })
     const requestEnd = runtime.metrics.timer(Constants.REQUESTS_TIME, { type, serviceName, actionName, callerNodeId })
 
-    return handler(context)
+    return handler(context, serviceInjections)
       .then(result => {
         requestEnd()
         runtime.metrics.decrement(Constants.REQUESTS_IN_FLIGHT, { type, serviceName, actionName, callerNodeId })

package/lib/middlewares/metrics/index.js

@@ -1,7 +1,7 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 const { Constants } = require('../../metrics')
 const { getMiddlewareWrapper } = require('./getMiddlewareWrapper')
@@ -33,7 +33,7 @@ module.exports = (runtime) => {
       return wrapMetricMiddleware('local', action, next)
     },
     remoteAction (next, action) {
-      return wrapMetricMiddleware.call('remote', action, next)
+      return wrapMetricMiddleware('remote', action, next)
     },
     emit (next) {
       return (event, payload) => {

package/lib/middlewares/retry/index.js

@@ -2,7 +2,7 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 const { delay } = require('@weave-js/utils')
@@ -14,7 +14,7 @@ const wrapRetryMiddleware = function (handler, action) {
   // middleware is enabled
   if (options.enabled) {
     // Return middlware handler
-    return function retryMiddleware (context) {
+    return function retryMiddleware (context, serviceInjections) {
       // if the context has no repeat count, set it to zero.
       if (context.retryCount === undefined) {
         context.retryCount = 0
@@ -22,14 +22,15 @@ const wrapRetryMiddleware = function (handler, action) {
 
       const attempts = typeof context.options.retries === 'number' ? context.options.retries : options.retries
 
-      return handler(context).catch(error => {
-        if (context.retryCount++ < attempts && error.retryable === true) {
-          self.log.warn(`Retry to recall action '${context.action.name}' after ${options.delay}.`)
-          return delay(options.delay)
-            .then(() => self.call(context.action.name, context.data, { context }))
-        }
-        return Promise.reject(error)
-      })
+      return handler(context, serviceInjections)
+        .catch(error => {
+          if (context.retryCount++ < attempts && error.retryable === true) {
+            self.log.warn(`Retry to recall action '${context.action.name}' after ${options.delay}.`)
+            return delay(options.delay)
+              .then(() => self.call(context.action.name, context.data, { context }))
+          }
+          return Promise.reject(error)
+        })
     }
   }
   return handler

package/lib/middlewares/timeout/index.js

@@ -1,17 +1,17 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 const { promiseTimeout } = require('@weave-js/utils')
 const { WeaveRequestTimeoutError } = require('../../errors')
 
-const wrapTimeoutMiddleware = function (handler, action) {
+const wrapTimeoutMiddleware = function (handler) {
   const self = this
   const registryOptions = self.options.registry || {}
 
-  return function timeoutMiddleware (context) {
+  return function timeoutMiddleware (context, serviceInjections) {
     if (typeof context.options.timeout === 'undefined' || registryOptions.requestTimeout) {
       context.options.timeout = registryOptions.requestTimeout || 0
     }
@@ -20,10 +20,10 @@ const wrapTimeoutMiddleware = function (handler, action) {
       context.startHighResolutionTime = process.hrtime()
     }
 
-    let promise = handler(context)
+    let promise = handler(context, serviceInjections)
 
     if (context.options.timeout > 0) {
-      promise = promiseTimeout(context.options.timeout, promise, new WeaveRequestTimeoutError(context.action.name, context.nodeId))
+      promise = promiseTimeout(context.options.timeout, promise, new WeaveRequestTimeoutError(context.action.name, context.nodeId, context.options.timeout))
         .catch(error => {
           if (error instanceof WeaveRequestTimeoutError) {
             self.log.warn(`Request '${context.action.name}' timed out.`)

package/lib/middlewares/tracing/index.js

@@ -1,20 +1,25 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
-const { buildTags } = require('./buildTags')
+const { isPlainObject } = require('@weave-js/utils')
+const { buildActionTags, buildEventTags } = require('./tags')
 
 const wrapTracingLocalActionMiddleware = function (handler) {
   const broker = this
-  const options = broker.options.tracing || {}
+  const tracingOptions = broker.options.tracing || {}
 
-  if (options.enabled) {
-    return function metricsLocalMiddleware (context) {
-      const tags = buildTags(context)
+  if (tracingOptions.enabled) {
+    return function metricsLocalMiddleware (context, serviceInjections) {
+      const tags = buildActionTags(context, tracingOptions)
+
+      if (tracingOptions) {
+        tags.data = context.data !== null && isPlainObject(context.data) ? Object.assign({}, context.data) : context.data
+      }
 
-      const spanName = `action '${context.action.name}'`
+      const spanName = `action "${context.action.name}"`
 
       const span = context.startSpan(spanName, {
         id: context.id,
@@ -28,8 +33,17 @@ const wrapTracingLocalActionMiddleware = function (handler) {
 
       context.span = span
 
-      return handler(context)
+      return handler(context, serviceInjections)
         .then(result => {
+          const tags = {
+            isCachedResult: context.isCachedResult
+          }
+
+          if (tracingOptions) {
+            tags.response = result !== null && isPlainObject(result) ? Object.assign({}, result) : result
+          }
+
+          span.addTags(tags)
           span.finish()
           return result
         })
@@ -47,13 +61,13 @@ const wrapTracingLocalActionMiddleware = function (handler) {
 const wrapTracingLocalEventMiddleware = function (handler, event) {
   const broker = this
   const service = event.service
-  const options = broker.options.tracing || {}
+  const tracingOptions = broker.options.tracing || {}
 
-  if (options.enabled) {
+  if (tracingOptions.enabled) {
     return function metricsLocalMiddleware (context) {
-      const tags = buildTags(context)
+      const tags = buildEventTags(context)
 
-      const span = context.startSpan(`event '${context.eventName}'`, {
+      const span = context.startSpan(`event "${context.eventName}"`, {
         id: context.id,
         traceId: context.requestId,
         parentId: context.parentId,
@@ -67,7 +81,6 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
 
       return handler(context)
         .then(result => {
-          span.addTags(tags)
           span.finish()
           return result
         })
@@ -82,7 +95,7 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
   return handler
 }
 
-module.exports = (broker) => {
+module.exports = () => {
   return {
     localAction: wrapTracingLocalActionMiddleware,
     localEvent: wrapTracingLocalEventMiddleware

package/lib/middlewares/tracing/tags.js

@@ -0,0 +1,43 @@
+/**
+ * @typedef {import("../../types.js").Context} Context
+ * @typedef {import("../../types.js").TracingOptions} TracingOptions
+*/
+
+/**
+ * Build span tags object
+ * @param {Context} context - Context
+ * @param {TracingOptions} brokerTracingOptions - Tracing options
+ * @param {TracingOptions} actionTracingOptions - Tracing options
+ * @returns {object} Tags
+*/
+module.exports.buildActionTags = (context, brokerTracingOptions, actionTracingOptions) => {
+  const tags = {
+    requestLevel: context.level,
+    action: context.action ? { name: context.action.name, shortName: context.action.shortName } : null,
+    isRemoteCall: !!context.callerNodeId,
+    nodeId: context.nodeId,
+    requestId: context.requestId
+  }
+
+  return tags
+}
+
+/**
+ * Build span tags object
+ * @param {Context} context - Context
+ * @param {TracingOptions} brokerTracingOptions - Tracing options
+ * @param {TracingOptions} actionTracingOptions - Tracing options
+ * @returns {object} Tags
+*/
+module.exports.buildEventTags = (context, brokerTracingOptions, actionTracingOptions) => {
+  const tags = {
+    requestLevel: context.level,
+    event: context.eventName,
+    eventType: context.eventType,
+    isRemoteCall: !!context.callerNodeId,
+    nodeId: context.nodeId,
+    requestId: context.requestId
+  }
+
+  return tags
+}

package/lib/middlewares/validator/index.js

@@ -1,7 +1,7 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 const { WeaveParameterValidationError } = require('../../errors')
@@ -16,7 +16,7 @@ const { capitalize } = require('@weave-js/utils')
  * Create validator middleware
  * @param {Runtime} runtime - Runtime reference
  * @returns {Middleware} - Validator middleware
- */
+*/
 module.exports = (runtime) => {
   const validator = runtime.validator
 
@@ -47,11 +47,11 @@ module.exports = (runtime) => {
         return handler
       }
 
-      return (context) => {
+      return (context, serviceInjections) => {
         const requestSchemaResult = validateRequestSchema ? validateRequestSchema(context.data) : true
 
         if (requestSchemaResult === true) {
-          return handler(context)
+          return handler(context, serviceInjections)
             .then((result) => {
               if (validateResponseSchema) {
                 const responseSchemaResult = validateResponseSchema(result)
@@ -77,11 +77,11 @@ module.exports = (runtime) => {
 
         const validate = validator.compile(event.params, parameterOptions)
 
-        return (context) => {
+        return (context, serviceInjections) => {
           let result = validate(context.data)
 
           if (result === true) {
-            return handler(context)
+            return handler(context, serviceInjections)
           } else {
             result = result.map(data => Object.assign(data, { nodeId: context.nodeId, event: context.eventName }))
             return Promise.reject(new WeaveParameterValidationError('Parameter validation error', result))

package/lib/registry/collections/{action-collection.js → actionCollection.js}

@@ -3,7 +3,7 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
 */
 
 /**
@@ -11,7 +11,7 @@
  * @typedef {import('../../types.js').ServiceActionCollection} ServiceActionCollection
 */
 const { omit } = require('@weave-js/utils')
-const { createEndpointList } = require('./endpoint-collection')
+const { createEndpointList } = require('./endpointCollection')
 
 /**
  * Configuration object for weave service broker.

package/lib/registry/collections/{endpoint-collection.js → endpointCollection.js}

@@ -3,20 +3,36 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
-const { createActionEndpoint } = require('../action-endpoint')
+/**
+ * @typedef {import('../../types.js').Runtime} Runtime
+ * @typedef {import('../../types.js').EventCollection} EventCollection
+ * @typedef {import('../../types.js').Service} Service
+ * @typedef {import('../../types.js').Node} Node
+ * @typedef {import('../../types.js').EndpointCollection} EndpointCollection
+*/
+
+const { createActionEndpoint } = require('../actionEndpoint')
 const { loadBalancingStrategy } = require('../../constants')
 
+/**
+ *
+ * @param {Runtime} runtime Runtime instance
+ * @param {string} name name
+ * @param {string=} groupName Group name
+ * @returns {EndpointCollection} EndpointCollection
+ */
 exports.createEndpointList = (runtime, name, groupName) => {
+  /** @type {EndpointCollection} */
   const endpointList = Object.create(null)
   const options = runtime.options
+  /** @type {Array} */
   const list = endpointList.endpoints = []
 
   let counter = 0
 
-  endpointList.state = runtime // ????
   endpointList.name = name
   endpointList.groupName = groupName
   endpointList.isInternal = name.startsWith('$')