@weave-js/core 0.10.0 → 0.12.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/adapters/base.js

@@ -0,0 +1,119 @@
+/*
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
+ * -----
+ * Copyright 2021 Fachwerk
+ */
+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');
+}
+
+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();
+    },
+    /**
+     * 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 + '.';
+
+        if (keys) {
+          // fast path for single keys
+          if (keys.length === 1) {
+            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 valueString = keys.reduce((pre, property, index) => {
+              let value = getPropertyFromDataOrMetadata(data, metadata, property);
+              value = getCacheKeyByObject(value);
+
+              return pre + (index > 0 ? '|' : '') + value;
+            }, prefix);
+
+            return prefix + generateHash(valueString);
+          }
+        } else {
+          const value = getCacheKeyByObject(data);
+          return prefix + generateHash(value);
+        }
+      }
+
+      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.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 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 cached object with key ${hashKey}`);
+
+        return Promise.resolve();
+      },
+      clear (pattern = '**') {
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL);
+        }
+
+        storage.forEach((_, key) => {
+          if (match(key, pattern)) {
+            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.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 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,10 @@
+/*
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
+ * -----
+ * Copyright 2021 Fachwerk
+ */
+
+module.exports = {
+  ...require('./base'),
+  ...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 };

package/lib/cache/getPropertyFromDataOrMetadata.js

@@ -0,0 +1,20 @@
+const { dotGet } = require('@weave-js/utils');
+
+/**
+ * Get property from data or metadata object.
+ * @param {any} data data object
+ * @param {object} metadata metadata object
+ * @param {string} key key
+ * @returns {any} Result
+ */
+const 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);
+};
+
+module.exports = { getPropertyFromDataOrMetadata };

package/lib/cache/lock.js

@@ -1,14 +1,37 @@
-exports.ttlcreateLock = () => {
-  const locked = new Map()
-  return {
-    acquire (key, ttl) {
-      const lock = locked.get(key)
-      if (!lock) {
-        lock.set(key, [])
+const createLock = () => {
+  const locked = new Map();
+
+  function acquire (key, ttl) {
+    const lockedItems = locked.get(key);
+    if (!lockedItems) {
+      locked.set(key, []);
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve) => lockedItems.push(resolve));
+    }
+  }
+
+  function isLocked (key) {
+    return !!locked.has(key);
+  }
+
+  function release (key) {
+    const lockedItems = locked.get(key);
+    if (lockedItems) {
+      if (lockedItems.length > 0) {
+        lockedItems.shift()();
+      } else {
+        locked.delete(key);
       }
-    },
-    isLocked (key) {
-      return !!locked.has(key)
     }
+    return Promise.resolve();
   }
-}
+
+  return Object.freeze({
+    acquire,
+    isLocked,
+    release
+  });
+};
+
+module.exports = { createLock };

package/lib/constants.js

@@ -1,15 +1,22 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-exports.PROTOCOL_VERSION = 1
+exports.PROTOCOL_VERSION = 1;
 
 exports.loadBalancingStrategy = {
   ROUND_ROBIN: 'round_robin',
   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',
@@ -18,8 +25,4 @@ exports.level = {
   warn: 'warn',
   error: 'error',
   fatal: 'fatal'
-}
-
-exports.SYNC_MIDDLEWARE_HOOKS = {
-  STARTING: 'starting'
-}
+};

package/lib/{error-handler.js → errorHandler.js}

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