@weave-js/core 0.9.2 → 0.11.0

package/lib/buildRuntime.js

@@ -0,0 +1,70 @@
+/**
+ * @typedef {import('./types.js').BrokerOptions} BrokerOptions
+ * @typedef {import('./types.js').Runtime} Runtime
+ * @typedef {import('./types.js').Broker} Broker
+*/
+
+const { initLogger } = require('./runtime/initLogger')
+const { initMiddlewareHandler } = require('./runtime/initMiddlewareManager')
+const { initRegistry } = require('./runtime/initRegistry')
+const { initContextFactory } = require('./runtime/initContextFactory')
+const { initEventbus } = require('./runtime/initEventbus')
+const { initValidator } = require('./runtime/initValidator')
+const { initTransport } = require('./runtime/initTransport')
+const { initCache } = require('./runtime/initCache')
+const { initActionInvoker } = require('./runtime/initActionInvoker')
+const { initServiceManager } = require('./runtime/initServiceManager')
+const { initMetrics } = require('./runtime/initMetrics')
+const { initTracer } = require('./runtime/initTracing')
+const { initUUIDFactory } = require('./runtime/initUuidFactory')
+const { errorHandler, fatalErrorHandler } = require('./errorHandler')
+const { uuid } = require('@weave-js/utils')
+const { version } = require('../package.json')
+const EventEmitter = require('eventemitter2')
+
+/**
+ * Build runtime object
+ * @param {BrokerOptions} options Broker options
+ * @return {Runtime} Runtime
+*/
+exports.initRuntime = (options) => {
+  /**
+   * Event bus
+   * @returns {EventEmitter} Service object.
+  */
+  const bus = new EventEmitter({
+    wildcard: true,
+    maxListeners: 1000
+  })
+
+  // Create base runtime object
+  const runtime = {
+    nodeId: options.nodeId,
+    version,
+    options,
+    bus,
+    state: {
+      instanceId: uuid(),
+      isStarted: false
+    },
+    handleError: (error) => errorHandler(runtime, error),
+    fatalError: (message, error, killProcess) => fatalErrorHandler(runtime, message, error, killProcess)
+  }
+
+  // Init modules
+  initLogger(runtime)
+  initUUIDFactory(runtime)
+  initMiddlewareHandler(runtime)
+  initRegistry(runtime)
+  initContextFactory(runtime)
+  initEventbus(runtime)
+  initValidator(runtime)
+  initTransport(runtime)
+  initCache(runtime)
+  initActionInvoker(runtime)
+  initServiceManager(runtime)
+  initMetrics(runtime)
+  initTracer(runtime)
+
+  return runtime
+}

package/lib/cache/base.js

@@ -1,10 +1,11 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 const crypto = require('crypto')
 const { isObject } = require('@weave-js/utils')
+const Constants = require('../metrics/constants')
 
 function getCacheKeyByObject (val) {
   if (Array.isArray(val)) {
@@ -28,20 +29,26 @@ function generateHash (key) {
 }
 
 function registerCacheMetrics (metrics) {
-  // todo: register metric stores
+  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 = (runtime, options) => {
   const cache = {
+    isConnected: false,
+    runtime,
     options: Object.assign({
       ttl: null
     }, options),
     init () {
-      this.runtime = runtime
-      this.metrics = runtime.metrics
-
-      if (this.runtime) {
-        registerCacheMetrics(this.metrics)
+      // register metrics
+      if (runtime.metrics) {
+        this.metrics = runtime.metrics
+        registerCacheMetrics(runtime.metrics)
       }
     },
     log: runtime.createLogger('CACHER'),
@@ -100,32 +107,41 @@ exports.createCacheBase = (runtime, options) => {
     }
   }
 
-  cache.middleware = () => {
-    return {
-      localAction: (handler, action) => {
-        const cacheOptions = Object.assign({ enabled: true }, isObject(action.cache) ? action.cache : { enabled: !!action.cache })
-        if (cacheOptions.enabled) {
-          return function cacheMiddleware (context) {
-            const cacheHashKey = cache.getCachingHash(action.name, context.data, context.meta, action.cache.keys)
-            context.isCachedResult = false
+  // cache.middleware = (runtime) => {
+  //   return {
+  //     localAction: (handler, action) => {
+  //       const cacheOptions = Object.assign({ enabled: true }, isObject(action.cache) ? action.cache : { enabled: !!action.cache })
+  //       if (cacheOptions.enabled) {
+  //         return function cacheMiddleware (context, serviceInjections) {
+  //           const cacheHashKey = runtime.cache.getCachingHash(action.name, context.data, context.meta, action.cache.keys)
+  //           context.isCachedResult = false
 
-            return cache.get(cacheHashKey).then((content) => {
-              if (content !== null) {
-                context.isCachedResult = true
-                return content
-              }
+  //           if (context.meta.$noCache === true) {
+  //             return handler(context, serviceInjections)
+  //           }
 
-              return handler(context).then((result) => {
-                cache.set(cacheHashKey, result, action.cache.ttl)
-                return result
-              })
-            })
-          }
-        }
-        return handler
-      }
-    }
-  }
+  //           if (runtime.cache.isConnected === false) {
+  //             runtime.cache.log('Cache adapter is not connected yet. Call handler...')
+  //             return handler(context, serviceInjections)
+  //           }
+
+  //           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
+  //     }
+  //   }
+  // }
 
   return cache
 }

package/lib/cache/inMemory.js

@@ -0,0 +1,140 @@
+/*
+ * Author: Kevin Ries (kevin@fachw3rk.de)
+ * -----
+ * Copyright 2021 Fachwerk
+ */
+
+const { match } = require('@weave-js/utils')
+const { createCacheBase } = require('./base')
+const { createLock } = require('./lock')
+const Constants = require('../metrics/constants')
+
+const makeInMemoryCache = (runtime, options = {}) => {
+  const base = createCacheBase(runtime, options)
+  const storage = new Map()
+  const name = 'Memory'
+
+  const lock = createLock()
+
+  const timer = setInterval(() => {
+    checkTtl()
+  }, 3000)
+
+  timer.unref()
+
+  // if a new broker gets connected, we need to clear the cache
+  runtime.bus.on('$transport.connected', () => {
+    base.log.debug('Transport adapter connected. Cache will be cleared.')
+    cache.clear()
+  })
+
+  const checkTtl = () => {
+    const now = Date.now()
+
+    storage.forEach((item, hashKey) => {
+      if (item.expire && item.expire < now) {
+        cache.log.debug(`Delete ${hashKey}`)
+        storage.delete(hashKey)
+      }
+    })
+  }
+
+  const cache = Object.assign(
+    {},
+    base,
+    {
+      name,
+      init () {
+        base.init()
+        cache.isConnected = true
+      },
+      get (cacheKey) {
+        base.log.debug(`Get ${cacheKey}`)
+
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_GET_TOTAL)
+        }
+
+        const item = storage.get(cacheKey)
+
+        if (item) {
+          cache.log.debug(`Found ${cacheKey}`)
+
+          if (base.metrics) {
+            base.metrics.increment(Constants.CACHE_FOUND_TOTAL)
+          }
+
+          if (item.expire && item.expire < Date.now()) {
+            cache.log.debug(`Delete ${cacheKey}`)
+            storage.delete(cacheKey)
+            if (base.metrics) {
+              base.metrics.increment(Constants.CACHE_EXPIRED_TOTAL)
+            }
+            return Promise.resolve(null)
+          }
+
+          return Promise.resolve(item.data)
+        }
+        return Promise.resolve(null)
+      },
+      set (hashKey, data, ttl) {
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_SET_TOTAL)
+        }
+
+        if (ttl == null) {
+          ttl = options.ttl
+        }
+
+        storage.set(hashKey, {
+          data,
+          expire: ttl ? Date.now() + ttl : null
+        })
+
+        base.log.debug(`Set ${hashKey}`)
+
+        return Promise.resolve(data)
+      },
+      remove (hashKey) {
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+        }
+        storage.delete(hashKey)
+        base.log.debug(`Delete ${hashKey}`)
+
+        return Promise.resolve()
+      },
+      clear (pattern = '**') {
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+        }
+        storage.forEach((_, key) => {
+          if (match(key, pattern)) {
+            base.log.debug(`Delete ${key}`)
+            this.remove(key)
+          }
+        })
+        return Promise.resolve()
+      },
+      lock (key, ttl) {
+        return lock.acquire(key, ttl).then(() => {
+          return () => lock.release(key)
+        })
+      },
+      tryLock (key, ttl) {
+        if (lock.isLocked(key)) {
+          return Promise.reject(new Error('Locked'))
+        }
+
+        return lock.acquire(key, ttl).then(() => {
+          return () => lock.release(key)
+        })
+      },
+      stop () {
+        clearInterval(timer)
+      }
+    })
+  return cache
+}
+
+module.exports = makeInMemoryCache

package/lib/cache/index.js

@@ -1,14 +1,14 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 const { isString, isFunction } = require('@weave-js/utils')
 const { WeaveBrokerOptionsError } = require('../errors')
 
 const adapters = {
-  Memory: require('./memory')
+  Memory: require('./inMemory')
 }
 
 exports.adapters = adapters

package/lib/cache/lock.js

@@ -1,14 +1,31 @@
-exports.ttlcreateLock = () => {
+const createLock = () => {
   const locked = new Map()
+
   return {
     acquire (key, ttl) {
-      const lock = locked.get(key)
-      if (!lock) {
-        lock.set(key, [])
+      const lockedItems = locked.get(key)
+      if (!lockedItems) {
+        locked.set(key, [])
+        return Promise.resolve()
+      } 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)
+        }
+      }
+      return Promise.resolve()
     }
   }
 }
+
+module.exports = { createLock }

package/lib/constants.js

@@ -1,7 +1,7 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 exports.PROTOCOL_VERSION = 1
@@ -11,6 +11,13 @@ exports.loadBalancingStrategy = {
   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',
   debug: 'debug',
@@ -19,7 +26,3 @@ exports.level = {
   error: 'error',
   fatal: 'fatal'
 }
-
-exports.SYNC_MIDDLEWARE_HOOKS = {
-  STARTING: 'starting'
-}

package/lib/errorHandler.js

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

package/lib/errors.js

@@ -1,10 +1,12 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
-class WeaveError extends Error {
+const { ExtendableError } = require('./ExtendableError')
+
+class WeaveError extends ExtendableError {
   constructor (message, code, type, data) {
     super(message)
     this.name = this.constructor.name
@@ -15,7 +17,7 @@ class WeaveError extends Error {
   }
 }
 
-class WeaveRetrieableError extends WeaveError {
+class WeaveRetryableError extends WeaveError {
   constructor (message, code, type, data) {
     super(message)
     this.code = code || 500
@@ -25,7 +27,7 @@ class WeaveRetrieableError extends WeaveError {
   }
 }
 
-class WeaveServiceNotFoundError extends WeaveRetrieableError {
+class WeaveServiceNotFoundError extends WeaveRetryableError {
   constructor (data = {}) {
     let message
 
@@ -33,31 +35,36 @@ class WeaveServiceNotFoundError extends WeaveRetrieableError {
       message = `Service "${data.actionName}" not found on node "${data.nodeId}".`
     } else if (data.actionName) {
       message = `Service "${data.actionName}" not found.`
+    } else {
+      message = 'Service not found.'
     }
 
     super(message, 404, 'WEAVE_SERVICE_NOT_FOUND_ERROR', data)
   }
 }
 
-class WeaveServiceNotAvailableError extends WeaveRetrieableError {
+class WeaveServiceNotAvailableError extends WeaveRetryableError {
   constructor (data = {}) {
     let message
     if (data.nodeId) {
       message = `Service "${data.actionName}" not available on node "${data.nodeId}".`
-    } else {
+    } else if (data.actionName) {
       message = `Service "${data.actionName}" not available.`
+    } else {
+      message = 'Service not available.'
     }
 
-    super(message, 405, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data)
+    super(message, 503, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data)
   }
 }
 
-class WeaveRequestTimeoutError extends WeaveRetrieableError {
+class WeaveRequestTimeoutError extends WeaveRetryableError {
   constructor (actionName, nodeId, timeout) {
     const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`
     super(message, 504, 'WEAVE_REQUEST_TIMEOUT_ERROR', {
       actionName,
-      nodeId
+      nodeId,
+      timeout
     })
     this.retryable = true
   }
@@ -116,7 +123,7 @@ module.exports = {
   WeaveParameterValidationError,
   WeaveQueueSizeExceededError,
   WeaveRequestTimeoutError,
-  WeaveRetrieableError,
+  WeaveRetryableError,
   WeaveServiceNotAvailableError,
   WeaveServiceNotFoundError,
   WeaveGracefulStopTimeoutError,

package/lib/helper/{define-action.js → defineAction.js}

@@ -1,3 +1,5 @@
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').ServiceActionDefinition} ServiceActionDefinition
 */
@@ -6,7 +8,7 @@
  * Create and register a new service action.
  * @param {ServiceActionDefinition} actionDefinition - Schema of the the action
  * @returns {ServiceActionDefinition} Action definition
- */
+*/
 module.exports = function (actionDefinition) {
   return actionDefinition
 }

package/lib/helper/{define-broker-options.js → defineBrokerOptions.js}

@@ -1,3 +1,5 @@
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').BrokerOptions} BrokerOptions
  */

package/lib/helper/{define-service.js → defineService.js}

@@ -1,3 +1,6 @@
+
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').ServiceSchema} ServiceSchema
 */
@@ -6,7 +9,7 @@
  * Create and register a new service
  * @param {ServiceSchema} serviceSchema - Schema of the Service
  * @returns {ServiceSchema} Service schema
- */
+*/
 module.exports = function (serviceSchema) {
   return serviceSchema
 }

package/lib/index.js

@@ -4,93 +4,15 @@
  * @typedef {import('./types.js').Broker} Broker
 */
 
-const EventEmitter = require('eventemitter2')
-const { getDefaultOptions } = require('./broker/default-options')
-const { defaultsDeep, uuid, isFunction } = require('@weave-js/utils')
-const { initLogger } = require('./runtime/init-logger')
-const { initMiddlewareHandler } = require('./runtime/init-middleware-manager')
-const { initRegistry } = require('./runtime/init-registry')
-const { initContextFactory } = require('./runtime/init-context-factory')
-const { initEventbus } = require('./runtime/init-eventbus')
-const { initValidator } = require('./runtime/init-validator')
-const { initTransport } = require('./runtime/init-transport')
-const { initCache } = require('./runtime/init-cache')
-const { initActionInvoker } = require('./runtime/init-action-invoker')
-const { initServiceManager } = require('./runtime/init-service-manager')
-const { initMetrics } = require('./runtime/init-metrics')
-const { initTracer } = require('./runtime/init-tracing')
-const { initUUIDFactory } = require('./runtime/init-uuid-factory')
+const { getDefaultOptions } = require('./broker/defaultOptions')
+const { defaultsDeep } = require('@weave-js/utils')
+const { initRuntime } = require('./buildRuntime')
 const { createBrokerInstance } = require('./broker')
-const { version } = require('../package.json')
-
-exports.defaultOptions = require('./broker/default-options')
-
-const errorHandler = ({ options }, error) => {
-  if (options.errorHandler) {
-    return options.errorHandler.call(null, error)
-  }
-  throw error
-}
-
-const fatalErrorHandler = (runtime, message, error, killProcess = true) => {
-  const { options, log } = runtime
-  if (options.logger.enabled) {
-    log.fatal(error, message)
-  } else {
-    console.error(message, error)
-  }
-
-  if (killProcess) {
-    process.exit(1)
-  }
-}
 
 /**
- * Build runtime object
- * @param {BrokerOptions} options Broker options
- * @return {Runtime} Runtime
+ * @type {BrokerOptions} options Broker options
 */
-const buildRuntime = (options) => {
-  /**
-   * Event bus
-   * @returns {EventEmitter} Service object.
-  */
-  const bus = new EventEmitter({
-    wildcard: true,
-    maxListeners: 1000
-  })
-
-  // Create base runtime object
-  const runtime = {
-    nodeId: options.nodeId,
-    version,
-    options,
-    bus,
-    state: {
-      instanceId: uuid(),
-      isStarted: false
-    },
-    handleError: (error) => errorHandler(runtime, error),
-    fatalError: (message, error, killProcess) => fatalErrorHandler(runtime, message, error, killProcess)
-  }
-
-  // Init modules
-  initLogger(runtime)
-  initUUIDFactory(runtime)
-  initMiddlewareHandler(runtime)
-  initRegistry(runtime)
-  initContextFactory(runtime)
-  initEventbus(runtime)
-  initValidator(runtime)
-  initTransport(runtime)
-  initCache(runtime)
-  initActionInvoker(runtime)
-  initServiceManager(runtime)
-  initMetrics(runtime)
-  initTracer(runtime)
-
-  return runtime
-}
+exports.defaultOptions = getDefaultOptions()
 
 /**
  * Build runtime object
@@ -105,13 +27,12 @@ exports.createBroker = (options) => {
   options = defaultsDeep(options, defaultOptions)
 
   // Init runtime
-  const runtime = buildRuntime(options)
+  const runtime = initRuntime(options)
 
   // Create broker instance
   return createBrokerInstance(runtime)
 }
 
-// eslint-disable-next-line valid-jsdoc
 /**
  * @deprecated since version 0.9.0
  * @param {import('./types.js').BrokerOptions} options Broker options.
@@ -123,15 +44,20 @@ exports.Weave = exports.createBroker
 exports.Errors = require('./errors')
 
 exports.Constants = require('./constants')
+
 // Transport
 exports.TransportAdapters = require('./transport/adapters')
 
 // Caching
 exports.Cache = require('./cache')
-exports.createBaseTracingCollector = require('./tracing/collectors/base')
+
+/**
+ * @deprecated since version 0.10.0
+*/
+exports.createBaseTracingCollector = require('./tracing/collectors/base').createBaseTracingCollector
 exports.TracingAdapters = require('./tracing/collectors')
 
 // Helper
-exports.defineBrokerOptions = require('./helper/define-broker-options')
-exports.defineService = require('./helper/define-service')
-exports.defineAction = require('./helper/define-action')
+exports.defineBrokerOptions = require('./helper/defineBrokerOptions')
+exports.defineService = require('./helper/defineService')
+exports.defineAction = require('./helper/defineAction')