@weave-js/core 0.11.0 → 0.11.1

package/lib/broker/defaultOptions.js

@@ -10,6 +10,7 @@
 
 /** @module weave */
 const os = require('os')
+const { createInMemoryCache } = require('../cache/adapters/inMemory.js')
 const { loadBalancingStrategy } = require('../constants')
 
 /**
@@ -28,7 +29,7 @@ exports.getDefaultOptions = () => {
     },
     cache: {
       enabled: false,
-      adapter: 'memory',
+      adapter: createInMemoryCache(),
       ttl: 3000,
       lock: {
         enabled: false

package/lib/broker/index.js

@@ -257,7 +257,7 @@ exports.createBrokerInstance = (runtime) => {
         // handle arrays
         const pongs = {}
 
-        const nodes = registry.getNodeList({})
+        const nodes = registry.nodeCollection.list({})
           .filter(node => !node.isLocal)
           .map(node => node.id)
 

package/lib/cache/adapters/base.js

@@ -0,0 +1,143 @@
+/*
+ * 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 })
+}
+
+const createCacheBase = (name, runtime, adapterOptions, options) => {
+  if (!isString(name)) {
+    throw new WeaveError('Name must 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
+    }
+  }
+
+  Object.defineProperty(cache, 'adapterOptions', {
+    value: adapterOptions,
+    writable: false
+  })
+
+  return cache
+}
+
+module.exports = { createCacheBase }

package/lib/cache/adapters/inMemory.js

@@ -0,0 +1,154 @@
+/*
+ * Author: Kevin Ries (kevin@fachw3rk.de)
+ * -----
+ * Copyright 2021 Fachwerk
+ */
+
+const { match, defaultsDeep } = require('@weave-js/utils')
+const { createCacheBase } = require('./base')
+const { createLock } = require('../lock')
+const Constants = require('../../metrics/constants')
+
+const defaultAdapterOptions = {
+  ttlCheckInterval: 3000
+}
+
+/**
+ * @typedef {Object} InMemoryAdapterOptions
+ * @property {number=} ttlCheckInterval TTL check interval
+*/
+
+/**
+ * Create an in-memory cache adapter.
+ * @param {InMemoryAdapterOptions} adapterOptions Adapter options
+ * @returns {any} CacheFactory
+*/
+const createInMemoryCache = (adapterOptions = {}) => (runtime, options = {}) => {
+  adapterOptions = defaultsDeep(adapterOptions, defaultAdapterOptions)
+  const base = createCacheBase('In-Memory', runtime, adapterOptions, options)
+  const storage = new Map()
+
+  const lock = createLock()
+
+  const ttlTimerHandle = setInterval(() => {
+    checkTtl()
+  }, adapterOptions.ttlCheckInterval)
+
+  ttlTimerHandle.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,
+    {
+      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 is not set in action cache settings, use options ttl
+        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)
+        })
+      },
+      tryAcquireLock (key, ttl) {
+        if (lock.isLocked(key)) {
+          return Promise.reject(new Error('Locked'))
+        }
+
+        return lock.acquire(key, ttl).then(() => {
+          return () => lock.release(key)
+        })
+      },
+      async stop () {
+        clearInterval(ttlTimerHandle)
+      }
+    })
+  return cache
+}
+
+module.exports = { createInMemoryCache }

package/lib/cache/{inMemory.js → adapters/inMemoryLru.js}

@@ -6,13 +6,13 @@
 
 const { match } = require('@weave-js/utils')
 const { createCacheBase } = require('./base')
-const { createLock } = require('./lock')
-const Constants = require('../metrics/constants')
+const { createLock } = require('../lock')
+const Constants = require('../../metrics/constants')
 
-const makeInMemoryCache = (runtime, options = {}) => {
-  const base = createCacheBase(runtime, options)
+const createInMemoryLruCache = (adapterOptions) => (runtime, options = {}) => {
+  const name = 'In-Memory'
+  const base = createCacheBase(name, runtime, options)
   const storage = new Map()
-  const name = 'Memory'
 
   const lock = createLock()
 
@@ -121,7 +121,7 @@ const makeInMemoryCache = (runtime, options = {}) => {
           return () => lock.release(key)
         })
       },
-      tryLock (key, ttl) {
+      tryAcquireLock (key, ttl) {
         if (lock.isLocked(key)) {
           return Promise.reject(new Error('Locked'))
         }
@@ -137,4 +137,4 @@ const makeInMemoryCache = (runtime, options = {}) => {
   return cache
 }
 
-module.exports = makeInMemoryCache
+module.exports = { createInMemoryLruCache }

package/lib/cache/adapters/index.js

@@ -0,0 +1,46 @@
+/*
+ * Author: Kevin Ries (kevin@fachw3rk.de)
+ * -----
+ * Copyright 2021 Fachwerk
+ */
+
+module.exports = {
+  ...require('./base'),
+  ...require('./inMemory'),
+  ...require('./inMemoryLru')
+}
+
+// exports.resolve = (cacheOptions) => {
+//   const getByName = name => {
+//     if (!name) {
+//       return null
+//     }
+
+//     const n = Object
+//       .keys(adapters)
+//       .find(n => n.toLowerCase() === name.toLowerCase())
+
+//     if (n) {
+//       return adapters[n]
+//     }
+//   }
+
+//   let cacheFactory
+
+//   if (cacheOptions === true) {
+//     cacheFactory = this.adapters.Memory
+//   } else if (isString(cacheOptions)) {
+//     const cache = getByName(cacheOptions)
+
+//     if (cache) {
+//       cacheFactory = cache()
+//     } else {
+//       throw new WeaveBrokerOptionsError(`Unknown cache type "${cacheOptions}"`)
+//     }
+//   } else if (isFunction(cacheOptions)) {
+//     cacheFactory = cacheOptions
+//   }
+//   if (cacheFactory) {
+//     return cacheFactory
+//   }
+// }

package/lib/cache/base.js

@@ -4,8 +4,26 @@
  * Copyright 2021 Fachwerk
  */
 const crypto = require('crypto')
-const { isObject } = require('@weave-js/utils')
+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)) {
@@ -37,8 +55,13 @@ function registerCacheMetrics (metrics) {
   metrics.register({ type: 'counter', name: Constants.CACHE_CLEANED_TOTAL })
 }
 
-exports.createCacheBase = (runtime, options) => {
+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({
@@ -72,20 +95,22 @@ exports.createCacheBase = (runtime, options) => {
       /* istanbul ignore next */
       return Promise.resolve()
     },
-    getCachingHash (actionName, params, meta, keys) {
-      if (params || meta) {
-        const prefix = `${actionName}:`
+    getCachingKey (actionName, data, metadata, keys) {
+      if (data || metadata) {
+        const prefix = actionName + ':'
 
         if (keys) {
+          // fast path for single keys
           if (keys.length === 1) {
-            const value = params[keys[0]]
+            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, i) => {
-              const value = params[property]
+            const res = keys.reduce((pre, property, index) => {
+              const value = getPropertyFromDataOrMetadata(data, metadata, property)
               let hash
               if (isObject(value)) {
                 const key = getCacheKeyByObject(value)
@@ -94,12 +119,12 @@ exports.createCacheBase = (runtime, options) => {
                 hash = value
               }
 
-              return pre + (i > 0 ? '|' : '') + hash
+              return pre + (index > 0 ? '|' : '') + hash
             }, prefix)
             return res
           }
         } else {
-          return prefix + generateHash(getCacheKeyByObject(params))
+          return prefix + generateHash(getCacheKeyByObject(data))
         }
       }
 
@@ -107,41 +132,5 @@ exports.createCacheBase = (runtime, options) => {
     }
   }
 
-  // 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
-
-  //           if (context.meta.$noCache === true) {
-  //             return handler(context, serviceInjections)
-  //           }
-
-  //           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/index.js

@@ -45,17 +45,16 @@ exports.Errors = require('./errors')
 
 exports.Constants = require('./constants')
 
-// Transport
-exports.TransportAdapters = require('./transport/adapters')
-
 // Caching
-exports.Cache = require('./cache')
+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')
 
 // Helper
 exports.defineBrokerOptions = require('./helper/defineBrokerOptions')

package/lib/middlewares/cache/index.js

@@ -1,36 +1,62 @@
-const { isObject } = require('@weave-js/utils')
+const { isString, isFunction } = require('@weave-js/utils')
 
 module.exports = (runtime) => {
   return {
     localAction: (handler, action) => {
-      const cacheOptions = Object.assign(
-        isObject(action.cache) ? action.cache : { enabled: !!action.cache },
-        runtime.options.cache
-      )
-      if (cacheOptions.enabled) {
+      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) {
-          const cache = runtime.cache
-          const cacheHashKey = cache.getCachingHash(action.name, context.data, context.meta, action.cache.keys)
+          // 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 cacheProm
+            let cachePromise
             if (cacheOptions.lock.staleTime && cache.getWithTTl) {
 
             } else {
-              cacheProm = runtime.cache.get(cacheHashKey)
+              cachePromise = runtime.cache.get(cacheHashKey)
             }
 
-            return cacheProm.then((cachedResult) => {
+            return cachePromise.then((cachedResult) => {
               if (cachedResult !== null) {
                 // Found a cached value. Skip calling handler and return our value
                 context.isCachedResult = true

package/lib/registry/registry.js

@@ -147,19 +147,22 @@ exports.createRegistry = (runtime) => {
 
       // remove old services
       const oldServices = Array.from(this.serviceCollection.services)
-      oldServices.forEach((service) => {
-        if (service.node.id !== node.id) return
+      oldServices.forEach((oldService) => {
+        if (oldService.node.id !== node.id) {
+          return
+        }
 
         let isExisting = false
 
+        // check if the old service exists in the new services.
         services.forEach((svc) => {
-          if (service.equals(svc.name, svc.version)) {
+          if (oldService.equals(svc.name, svc.version)) {
             isExisting = true
           }
         })
 
         if (!isExisting) {
-          this.deregisterService(service.name, service.version, node.id)
+          this.deregisterService(oldService.name, oldService.version, node.id)
         }
       })
 
@@ -186,9 +189,9 @@ exports.createRegistry = (runtime) => {
         }
 
         if (node.isLocal) {
-          action.handler = middlewareHandler.wrapHandler('localAction', action.handler, action)// this.onRegisterLocalAction(action)
+          action.handler = middlewareHandler.wrapHandler('localAction', action.handler, action)
         } else {
-          action.handler = middlewareHandler.wrapHandler('remoteAction', runtime.transport.sendRequest.bind(runtime.transport), action)// this.onRegisterRemoteAction(action)
+          action.handler = middlewareHandler.wrapHandler('remoteAction', runtime.transport.sendRequest.bind(runtime.transport), action)
         }
 
         this.actionCollection.add(node, service, action)
@@ -196,13 +199,10 @@ exports.createRegistry = (runtime) => {
         service.addAction(action)
       })
     },
-    getActionList (options) {
-      return this.actionCollection.list(options)
-    },
     deregisterService (name, version, nodeId) {
       this.serviceCollection.remove(nodeId || runtime.nodeId, name, version)
 
-      // It must be a local service
+      // It must be a local service if there is no node ID.
       if (!nodeId) {
         const serviceToRemove = this.nodeCollection.localNode.services.find(service => service.name === name)
         this.nodeCollection.localNode.services.splice(this.nodeCollection.localNode.services.indexOf(serviceToRemove), 1)
@@ -386,12 +386,6 @@ exports.createRegistry = (runtime) => {
       this.nodeCollection.remove(nodeId)
       runtime.eventBus.broadcastLocal('$node.removed', { nodeId })
       this.log.warn(`Node "${nodeId}" removed.`)
-    },
-    getNodeList (options) {
-      return this.nodeCollection.list(options)
-    },
-    getServiceList (options) {
-      return this.serviceCollection.list(options)
     }
   }
 

package/lib/runtime/initCache.js

@@ -1,10 +1,19 @@
-const Cache = require('../cache')
+const { isFunction } = require('@weave-js/utils')
+const { WeaveError } = require('../errors')
 
 exports.initCache = (runtime) => {
   if (runtime.options.cache && runtime.options.cache.enabled) {
-    const createCache = Cache.resolve(runtime.options.cache.adapter)
+    if (!isFunction(runtime.options.cache.adapter)) {
+      throw new WeaveError('Invalid cache adapter.')
+    }
+
+    // Init cache adapter
+    const cache = runtime.options.cache.adapter(runtime, runtime.options.cache)
+
+    runtime.log.info(`Cache: ${cache.name}`)
+
     Object.defineProperty(runtime, 'cache', {
-      value: createCache(runtime, runtime.options.cache)
+      value: cache
     })
   }
 }

package/lib/types.js

@@ -22,7 +22,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
 /**
  * @callback CallActionFunctionDef - Action function definition
  * @param {string} actionName - Name of the action
- * @param {object} data - Payload
+ * @param {object} [data] - Payload
  * @param {ActionOptions} [options] - Action options
  * @return {Promise<any>} Promise - Result
  */
@@ -127,7 +127,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {function(string, any, any=):Promise<any>} emit - Emit
  * @property {function(string, any, any=):Promise<any>} broadcast broadcast
  * @property {function(string, any, any=):Promise<any>} broadcastLocal broadcastLocal
- * @property {function(string):Promise<any>} waitForServices waitForServices
+ * @property {function(Array<string>|string):Promise<any>} waitForServices waitForServices
  * @property {function(string, number=):Promise<PingResult>} ping ping
  * @property {function(Error):void} handleError handleError
  * @property {function():void} fatalError fatalError
@@ -169,7 +169,13 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {Boolean} enabled - Enable tracing middleware. (default = false)
  * @property {Number} samplingRate - Rate of traced actions. (default = 1.0)
  * @property {Array<String|Object>} collectors - Array of tracing collectors.
- * @property {TracingErrorOptions} errors - Settings for tracing errors.
+ * @property {TracingErrorOptions} [errors] - Settings for tracing errors.
+*/
+
+/**
+ * Configuration object for weave service broker.
+ * @typedef {Object} CacheLockOptions
+ * @property {Boolean} [enabled=false] Enable cache lock. (default = false)
 */
 
 /**
@@ -178,6 +184,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {Boolean} enabled Enable cache middleware. (default = false)
  * @property {String | Object} adapter - Cache adapter. (default = memory (In Memory))
  * @property {number} [ttl=3000] - Cache item TTL.
+ * @property {CacheLockOptions} [lock] Cache lock options.
 */
 
 /**
@@ -328,7 +335,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {number} stopTime stopTime
  * @property {any} [metrics] metrics
  * @property {function(any):void} setData - Set data object.
- * @property {function(string, any, ActionOptions):ContextPromise} call - Call a service action
+ * @property {CallActionFunctionDef} call - Call a service action
  * @property {function(string, object):Promise<any>} emit emit
  * @property {Stream} [stream] - Stream
  * @property {function(string, any):Promise<any>} broadcast Broadcast an event to all listener.
@@ -350,7 +357,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {Promise<any>} get get
  * @property {Promise<any>} remove remove
  * @property {Promise<any>} clear clear
- * @property {string} getCachingHash getCachingHash
+ * @property {string} getCachingKey getCachingKey
  * @property {function():Middleware} createMiddleware createMiddleware
  * @property {function():Promise<any>} stop stop
 */
@@ -482,7 +489,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {function(string):Endpoint} getLocalActionEndpoint getLocalActionEndpoint
  * @property {function():NodeInfo} getNodeInfo getNodeInfo
  * @property {function():NodeInfo} getLocalNodeInfo getLocalNodeInfo
- * @property {function():NodeInfo} generateLocalNodeInfo generateLocalNodeInfo
+ * @property {function(Boolean=):NodeInfo} generateLocalNodeInfo generateLocalNodeInfo
  * @property {*} processNodeInfo processNodeInfo
  * @property {function(string, boolean):void} nodeDisconnected nodeDisconnected
  * @property {function(string):void} removeNode removeNode
@@ -507,6 +514,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {function():number} count count
  * @property {function(string):Endpoint} getByNodeId getByNodeId
  * @property {function(string):void} removeByNodeId removeByNodeId
+ * @property {function(string):Endpoint} endpointByNodeId Get endpoint by node ID.
  * @property {function():void} removeByService removeByService
 */
 
@@ -522,6 +530,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {number} lastHeartbeatTime lastHeartbeatTime
  * @property {number} offlineTime offlineTime
  * @property {boolean} isAvailable isAvailable
+ * @property {boolean} wasDisconnectedUnexpectedly Node was disconnected unexpectedly
  * @property {Array<ServiceItem>} services services
  * @property {number} sequence sequence
  * @property {Array<string>} [events] events
@@ -561,7 +570,8 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
 
 /**
  * @typedef {object} NodeCollectionListFilterOptions
- * @property {boolean} [withServices=true] Output all services on an node.
+ * @property {boolean} [availableOnly=false] Git only available nodes.
+ * @property {boolean} [withServices=false] Output all services on an node.
 */
 
 /**
@@ -575,14 +585,14 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {boolean} has has
  * @property {function(string):Node} get get
  * @property {function(string):boolean} remove remove
- * @property {function(NodeCollectionListFilterOptions):Array<Node>} list list
+ * @property {function(NodeCollectionListFilterOptions=):Array<Node>} list list
  * @property {void} disconnected disconnected
  * @property {Array<Node>} toArray toArray
 */
 
 /**
  * @typedef {Object} ServiceActionCollectionListFilterParams
- * @property {boolean} [onlyLocals] Shows only local service actions
+ * @property {boolean} [localOnly] Shows only local service actions
  * @property {boolean} [skipInternals] Shows only local service actions
  * @property {boolean} [withEndpoints] Shows only local service actions
  */
@@ -617,6 +627,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
 /**
  * @typedef {Object} ServiceCollectionListFilterParams
  * @property {boolean} [localOnly=false] Show only local services.
+ * @property {boolean} [availableOnly=false] Show only available services.
  * @property {boolean} [withActions=false] Include actions in result.
  * @property {boolean} [withEvents=false] Include events in result.
  * @property {boolean} [withNodeService=false] Include node service.
@@ -630,8 +641,8 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2')
  * @property {function(Node,string, number, any):ServiceItem} add Add a new service to service collection.
  * @property {*} get get
  * @property {function(string, number, string):boolean} has has
- * @property {function(string, string, number):void} remove remove
- * @property {function(string):void} removeAllByNodeId removeAllByNodeId
+ * @property {function(string, string, number=):void} remove Remove endpoint by node ID, service name and version*.
+ * @property {function(string):void} removeAllByNodeId Remove all endpoints by node ID.
  * @property {*} registerAction registerAction
  * @property {function(string):EndpointCollection} tryFindActionsByActionName tryFindActionsByActionName
  * @property {function():Array<any>} getActionsList getActionsList

package/lib/utils/index.js

@@ -1,5 +1,5 @@
 
 exports = {
   ...require('./options'),
-  ...require('./restore-error')
+  ...require('./restoreError')
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-js/core",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "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.0",
-    "@weave-js/validator": "^0.11.0",
+    "@weave-js/utils": "^0.10.1",
+    "@weave-js/validator": "^0.11.1",
     "eventemitter2": "^6.4.5",
     "glob": "^7.2.0"
   },
@@ -49,5 +49,5 @@
     "lib": "lib",
     "test": "test"
   },
-  "gitHead": "84fd5e4af3af96e8c004bcfba40bb3cb35f23fa7"
+  "gitHead": "bc467dd08fe0626c40e7eb19b344c102386baf15"
 }

package/lib/cache/index.js

@@ -1,48 +0,0 @@
-/*
- * Author: Kevin Ries (kevin@fachw3rk.de)
- * -----
- * Copyright 2021 Fachwerk
- */
-
-const { isString, isFunction } = require('@weave-js/utils')
-const { WeaveBrokerOptionsError } = require('../errors')
-
-const adapters = {
-  Memory: require('./inMemory')
-}
-
-exports.adapters = adapters
-
-exports.createCacheBase = require('./base').createCacheBase
-
-exports.resolve = (cacheOptions) => {
-  const getByName = name => {
-    if (!name) {
-      return null
-    }
-
-    const n = Object.keys(adapters).find(n => n.toLowerCase() === name.toLowerCase())
-    if (n) {
-      return adapters[n]
-    }
-  }
-
-  let cacheFactory
-
-  if (cacheOptions === true) {
-    cacheFactory = this.adapters.Memory
-  } else if (isString(cacheOptions)) {
-    const cache = getByName(cacheOptions)
-
-    if (cache) {
-      cacheFactory = cache
-    } else {
-      throw new WeaveBrokerOptionsError(`Unknown cache type "${cacheOptions}"`)
-    }
-  } else if (isFunction(cacheOptions)) {
-    cacheFactory = cacheOptions
-  }
-  if (cacheFactory) {
-    return cacheFactory
-  }
-}