@weave-js/core 0.9.4 → 0.11.1

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/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/adapters/inMemoryLru.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 createInMemoryLruCache = (adapterOptions) => (runtime, options = {}) => {
+  const name = 'In-Memory'
+  const base = createCacheBase(name, runtime, options)
+  const storage = new Map()
+
+  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)
+        })
+      },
+      tryAcquireLock (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 = { 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

@@ -1,10 +1,29 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * 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)) {
@@ -28,20 +47,31 @@ 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) => {
+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 () {
-      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'),
@@ -65,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)
@@ -87,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))
         }
       }
 
@@ -100,32 +132,5 @@ 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
-
-            return cache.get(cacheHashKey).then((content) => {
-              if (content !== null) {
-                context.isCachedResult = true
-                return content
-              }
-
-              return handler(context).then((result) => {
-                cache.set(cacheHashKey, result, action.cache.ttl)
-                return result
-              })
-            })
-          }
-        }
-        return handler
-      }
-    }
-  }
-
   return cache
 }