@weave-js/core 0.11.1 → 0.12.0

package/lib/cache/adapters/base.js

@@ -1,63 +1,34 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * 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'
-  }
-}
+const crypto = require('crypto');
+const { isObject, isString } = require('@weave-js/utils');
+const Constants = require('../../metrics/constants');
+const { WeaveError } = require('../../errors');
+const { getCacheKeyByObject } = require('../getCacheKeyByObject');
+const { getPropertyFromDataOrMetadata } = require('../getPropertyFromDataOrMetadata');
 
 function generateHash (key) {
   return crypto
     .createHash('sha1')
     .update(key)
-    .digest('base64')
+    .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 })
+  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.')
+    throw new WeaveError('Name must be a string.');
   }
 
   const cache = {
@@ -70,74 +41,79 @@ const createCacheBase = (name, runtime, adapterOptions, options) => {
     init () {
       // register metrics
       if (runtime.metrics) {
-        this.metrics = runtime.metrics
-        registerCacheMetrics(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.'))
+      runtime.handleError(new Error('Method not implemented.'));
     },
     get (/* hashKey */) {
       /* istanbul ignore next */
-      runtime.handleError(new Error('Method not implemented.'))
+      runtime.handleError(new Error('Method not implemented.'));
     },
     remove () {
       /* istanbul ignore next */
-      runtime.handleError(new Error('Method not implemented.'))
+      runtime.handleError(new Error('Method not implemented.'));
     },
     clear () {
       /* istanbul ignore next */
-      runtime.handleError(new Error('Method not implemented.'))
+      runtime.handleError(new Error('Method not implemented.'));
     },
     stop () {
       /* istanbul ignore next */
-      return Promise.resolve()
+      return Promise.resolve();
     },
+    /**
+     * Generates a caching key for action data/metadata.
+     * @param {string} actionName Namme of the action
+     * @param {any} data  Data
+     * @param {object=} metadata Metadata
+     * @param {Array<string>=} keys Key array
+     * @returns {string} Result key string
+     */
     getCachingKey (actionName, data, metadata, keys) {
       if (data || metadata) {
-        const prefix = actionName + ':'
+        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)
+            const cacheKeyData = getPropertyFromDataOrMetadata(data, metadata, keys[0]);
+            const key = getCacheKeyByObject(cacheKeyData);
+            const value = prefix + (isObject(cacheKeyData) ? key : cacheKeyData);
+            return prefix + generateHash(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
-              }
+            const valueString = keys.reduce((pre, property, index) => {
+              let value = getPropertyFromDataOrMetadata(data, metadata, property);
+              value = getCacheKeyByObject(value);
+
+              return pre + (index > 0 ? '|' : '') + value;
+            }, prefix);
 
-              return pre + (index > 0 ? '|' : '') + hash
-            }, prefix)
-            return res
+            return prefix + generateHash(valueString);
           }
         } else {
-          return prefix + generateHash(getCacheKeyByObject(data))
+          const value = getCacheKeyByObject(data);
+          return prefix + generateHash(value);
         }
       }
 
-      return actionName
+      return actionName;
     }
-  }
+  };
 
   Object.defineProperty(cache, 'adapterOptions', {
     value: adapterOptions,
     writable: false
-  })
+  });
 
-  return cache
-}
+  return cache;
+};
 
-module.exports = { createCacheBase }
+module.exports = { createCacheBase };

package/lib/cache/adapters/inMemory.js

@@ -1,17 +1,17 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { match, defaultsDeep } = require('@weave-js/utils')
-const { createCacheBase } = require('./base')
-const { createLock } = require('../lock')
-const Constants = require('../../metrics/constants')
+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
@@ -24,131 +24,131 @@ const defaultAdapterOptions = {
  * @returns {any} CacheFactory
 */
 const createInMemoryCache = (adapterOptions = {}) => (runtime, options = {}) => {
-  adapterOptions = defaultsDeep(adapterOptions, defaultAdapterOptions)
-  const base = createCacheBase('In-Memory', runtime, adapterOptions, options)
-  const storage = new Map()
+  adapterOptions = defaultsDeep(adapterOptions, defaultAdapterOptions);
+  const base = createCacheBase('In-Memory', runtime, adapterOptions, options);
+  const storage = new Map();
 
-  const lock = createLock()
+  const lock = createLock();
 
   const ttlTimerHandle = setInterval(() => {
-    checkTtl()
-  }, adapterOptions.ttlCheckInterval)
+    checkTtl();
+  }, adapterOptions.ttlCheckInterval);
 
-  ttlTimerHandle.unref()
+  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()
-  })
+    base.log.debug('Transport adapter connected. Cache will be cleared.');
+    cache.clear();
+  });
 
   const checkTtl = () => {
-    const now = Date.now()
+    const now = Date.now();
 
     storage.forEach((item, hashKey) => {
       if (item.expire && item.expire < now) {
-        cache.log.debug(`Delete ${hashKey}`)
-        storage.delete(hashKey)
+        cache.log.debug(`Delete ${hashKey}`);
+        storage.delete(hashKey);
       }
-    })
-  }
+    });
+  };
 
   const cache = Object.assign(
     {},
     base,
     {
       init () {
-        base.init()
-        cache.isConnected = true
+        base.init();
+        cache.isConnected = true;
       },
       get (cacheKey) {
-        base.log.debug(`Get ${cacheKey}`)
+        base.log.debug(`Get ${cacheKey}`);
 
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_GET_TOTAL)
+          base.metrics.increment(Constants.CACHE_GET_TOTAL);
         }
 
-        const item = storage.get(cacheKey)
+        const item = storage.get(cacheKey);
 
         if (item) {
-          cache.log.debug(`Found ${cacheKey}`)
+          cache.log.debug(`Found ${cacheKey}`);
 
           if (base.metrics) {
-            base.metrics.increment(Constants.CACHE_FOUND_TOTAL)
+            base.metrics.increment(Constants.CACHE_FOUND_TOTAL);
           }
 
           if (item.expire && item.expire < Date.now()) {
-            cache.log.debug(`Delete ${cacheKey}`)
-            storage.delete(cacheKey)
+            cache.log.debug(`Delete ${cacheKey}`);
+            storage.delete(cacheKey);
             if (base.metrics) {
-              base.metrics.increment(Constants.CACHE_EXPIRED_TOTAL)
+              base.metrics.increment(Constants.CACHE_EXPIRED_TOTAL);
             }
-            return Promise.resolve(null)
+            return Promise.resolve(null);
           }
 
-          return Promise.resolve(item.data)
+          return Promise.resolve(item.data);
         }
-        return Promise.resolve(null)
+        return Promise.resolve(null);
       },
       set (hashKey, data, ttl) {
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_SET_TOTAL)
+          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
+          ttl = options.ttl;
         }
 
         storage.set(hashKey, {
           data,
           expire: ttl ? Date.now() + ttl : null
-        })
+        });
 
-        base.log.debug(`Set ${hashKey}`)
+        base.log.debug(`Set ${hashKey}`);
 
-        return Promise.resolve(data)
+        return Promise.resolve(data);
       },
       remove (hashKey) {
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL);
         }
-        storage.delete(hashKey)
-        base.log.debug(`Delete ${hashKey}`)
+        storage.delete(hashKey);
+        base.log.debug(`Delete cached object with key ${hashKey}`);
 
-        return Promise.resolve()
+        return Promise.resolve();
       },
       clear (pattern = '**') {
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL);
         }
+
         storage.forEach((_, key) => {
           if (match(key, pattern)) {
-            base.log.debug(`Delete ${key}`)
-            this.remove(key)
+            this.remove(key);
           }
-        })
-        return Promise.resolve()
+        });
+        return Promise.resolve();
       },
       lock (key, ttl) {
         return lock.acquire(key, ttl).then(() => {
-          return () => lock.release(key)
-        })
+          return () => lock.release(key);
+        });
       },
       tryAcquireLock (key, ttl) {
         if (lock.isLocked(key)) {
-          return Promise.reject(new Error('Locked'))
+          return Promise.reject(new Error('Locked'));
         }
 
         return lock.acquire(key, ttl).then(() => {
-          return () => lock.release(key)
-        })
+          return () => lock.release(key);
+        });
       },
       async stop () {
-        clearInterval(ttlTimerHandle)
+        clearInterval(ttlTimerHandle);
       }
-    })
-  return cache
-}
+    });
+  return cache;
+};
 
-module.exports = { createInMemoryCache }
+module.exports = { createInMemoryCache };

package/lib/cache/adapters/inMemoryLru.js

@@ -1,43 +1,43 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { match } = require('@weave-js/utils')
-const { createCacheBase } = require('./base')
-const { createLock } = require('../lock')
-const Constants = require('../../metrics/constants')
+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 name = 'In-Memory';
+  const base = createCacheBase(name, runtime, options);
+  const storage = new Map();
 
-  const lock = createLock()
+  const lock = createLock();
 
   const timer = setInterval(() => {
-    checkTtl()
-  }, 3000)
+    checkTtl();
+  }, 3000);
 
-  timer.unref()
+  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()
-  })
+    base.log.debug('Transport adapter connected. Cache will be cleared.');
+    cache.clear();
+  });
 
   const checkTtl = () => {
-    const now = Date.now()
+    const now = Date.now();
 
     storage.forEach((item, hashKey) => {
       if (item.expire && item.expire < now) {
-        cache.log.debug(`Delete ${hashKey}`)
-        storage.delete(hashKey)
+        cache.log.debug(`Delete ${hashKey}`);
+        storage.delete(hashKey);
       }
-    })
-  }
+    });
+  };
 
   const cache = Object.assign(
     {},
@@ -45,96 +45,96 @@ const createInMemoryLruCache = (adapterOptions) => (runtime, options = {}) => {
     {
       name,
       init () {
-        base.init()
-        cache.isConnected = true
+        base.init();
+        cache.isConnected = true;
       },
       get (cacheKey) {
-        base.log.debug(`Get ${cacheKey}`)
+        base.log.debug(`Get ${cacheKey}`);
 
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_GET_TOTAL)
+          base.metrics.increment(Constants.CACHE_GET_TOTAL);
         }
 
-        const item = storage.get(cacheKey)
+        const item = storage.get(cacheKey);
 
         if (item) {
-          cache.log.debug(`Found ${cacheKey}`)
+          cache.log.debug(`Found ${cacheKey}`);
 
           if (base.metrics) {
-            base.metrics.increment(Constants.CACHE_FOUND_TOTAL)
+            base.metrics.increment(Constants.CACHE_FOUND_TOTAL);
           }
 
           if (item.expire && item.expire < Date.now()) {
-            cache.log.debug(`Delete ${cacheKey}`)
-            storage.delete(cacheKey)
+            cache.log.debug(`Delete ${cacheKey}`);
+            storage.delete(cacheKey);
             if (base.metrics) {
-              base.metrics.increment(Constants.CACHE_EXPIRED_TOTAL)
+              base.metrics.increment(Constants.CACHE_EXPIRED_TOTAL);
             }
-            return Promise.resolve(null)
+            return Promise.resolve(null);
           }
 
-          return Promise.resolve(item.data)
+          return Promise.resolve(item.data);
         }
-        return Promise.resolve(null)
+        return Promise.resolve(null);
       },
       set (hashKey, data, ttl) {
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_SET_TOTAL)
+          base.metrics.increment(Constants.CACHE_SET_TOTAL);
         }
 
         if (ttl == null) {
-          ttl = options.ttl
+          ttl = options.ttl;
         }
 
         storage.set(hashKey, {
           data,
           expire: ttl ? Date.now() + ttl : null
-        })
+        });
 
-        base.log.debug(`Set ${hashKey}`)
+        base.log.debug(`Set ${hashKey}`);
 
-        return Promise.resolve(data)
+        return Promise.resolve(data);
       },
       remove (hashKey) {
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL);
         }
-        storage.delete(hashKey)
-        base.log.debug(`Delete ${hashKey}`)
+        storage.delete(hashKey);
+        base.log.debug(`Delete ${hashKey}`);
 
-        return Promise.resolve()
+        return Promise.resolve();
       },
       clear (pattern = '**') {
         if (base.metrics) {
-          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL);
         }
         storage.forEach((_, key) => {
           if (match(key, pattern)) {
-            base.log.debug(`Delete ${key}`)
-            this.remove(key)
+            base.log.debug(`Delete ${key}`);
+            this.remove(key);
           }
-        })
-        return Promise.resolve()
+        });
+        return Promise.resolve();
       },
       lock (key, ttl) {
         return lock.acquire(key, ttl).then(() => {
-          return () => lock.release(key)
-        })
+          return () => lock.release(key);
+        });
       },
       tryAcquireLock (key, ttl) {
         if (lock.isLocked(key)) {
-          return Promise.reject(new Error('Locked'))
+          return Promise.reject(new Error('Locked'));
         }
 
         return lock.acquire(key, ttl).then(() => {
-          return () => lock.release(key)
-        })
+          return () => lock.release(key);
+        });
       },
       stop () {
-        clearInterval(timer)
+        clearInterval(timer);
       }
-    })
-  return cache
-}
+    });
+  return cache;
+};
 
-module.exports = { createInMemoryLruCache }
+module.exports = { createInMemoryLruCache };

package/lib/cache/adapters/index.js

@@ -1,46 +1,10 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * 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
-//   }
-// }
+  ...require('./inMemory')
+};

package/lib/cache/getCacheKeyByObject.js

@@ -0,0 +1,31 @@
+const { isObject, isString } = require('@weave-js/utils');
+
+/**
+ * Get property from data or metadata object.
+ * @param {any} value Value
+ * @returns {string} Cache key
+*/
+const getCacheKeyByObject = (value) => {
+  if (Array.isArray(value)) {
+    return '[' + value.map(object => getCacheKeyByObject(object)).join(',') + ']';
+  } else if (isObject(value)) {
+    // Handle date objects
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+
+    return '{' + Object.keys(value)
+      .map((key) => {
+        return [key, getCacheKeyByObject(value[key])].join(':');
+      })
+      .join(',') + '}';
+  } else if (isString(value)) {
+    return value;
+  } else if (typeof value === 'boolean' || typeof value === 'number') {
+    return value.toString();
+  } else {
+    return 'null';
+  }
+};
+
+module.exports = { getCacheKeyByObject };