@weave-js/core 0.11.1 → 0.12.0

package/lib/middlewares/action-hooks/index.js

@@ -1,65 +1,65 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
 function callHook (hook, service, context, result) {
   if (typeof hook === 'function') {
-    return hook.call(service, context, result)
+    return hook.call(service, context, result);
   } else if (Array.isArray(hook)) {
     return hook.reduce(
       (promise, fn) => promise.then(res => fn.call(service, context, res)),
-      Promise.resolve(result))
+      Promise.resolve(result));
   }
 }
 
 function callErrorHook (hook, service, context, error) {
   if (typeof hook === 'function') {
-    return hook.call(service, context, error)
+    return hook.call(service, context, error);
   } else if (Array.isArray(hook)) {
     return hook.reduce(
       (promise, fn) => promise.catch(err => fn.call(service, context, err)),
-      Promise.reject(error))
+      Promise.reject(error));
   }
 }
 
 function sanitizeHooks (hooks, service) {
   if (typeof hooks === 'string') {
-    hooks = hooks.split(' ')
+    hooks = hooks.split(' ');
   }
 
   if (Array.isArray(hooks)) {
     return hooks.map((hook) => {
       // resolve the method name
       if (typeof hook === 'string') {
-        return (service && typeof service[hook] === 'function') ? service[hook] : null
+        return (service && typeof service[hook] === 'function') ? service[hook] : null;
       }
-      return hook
-    })
+      return hook;
+    });
   }
-  return hooks
+  return hooks;
 }
 
 const makeActionHookMiddleware = function (handler, action) {
-  const name = action.shortName
-  const hooks = (action.service && action.service.schema) ? action.service.schema.hooks : null
+  const name = action.shortName;
+  const hooks = (action.service && action.service.schema) ? action.service.schema.hooks : null;
 
   if (hooks || action.hooks) {
     // Wildcard hooks
-    const beforeWildcardHook = hooks && hooks.before ? sanitizeHooks(hooks.before['*'], action.service) : null
-    const afterWildcardHook = hooks && hooks.after ? sanitizeHooks(hooks.after['*'], action.service) : null
-    const errorWildcardHook = hooks && hooks.error ? sanitizeHooks(hooks.error['*'], action.service) : null
+    const beforeWildcardHook = hooks && hooks.before ? sanitizeHooks(hooks.before['*'], action.service) : null;
+    const afterWildcardHook = hooks && hooks.after ? sanitizeHooks(hooks.after['*'], action.service) : null;
+    const errorWildcardHook = hooks && hooks.error ? sanitizeHooks(hooks.error['*'], action.service) : null;
 
     // Action name-related hooks
-    const beforeHook = hooks && hooks.before ? sanitizeHooks(hooks.before[name], action.service) : null
-    const afterHook = hooks && hooks.after ? sanitizeHooks(hooks.after[name], action.service) : null
-    const errorHook = hooks && hooks.error ? sanitizeHooks(hooks.error[name], action.service) : null
+    const beforeHook = hooks && hooks.before ? sanitizeHooks(hooks.before[name], action.service) : null;
+    const afterHook = hooks && hooks.after ? sanitizeHooks(hooks.after[name], action.service) : null;
+    const errorHook = hooks && hooks.error ? sanitizeHooks(hooks.error[name], action.service) : null;
 
     // Hooks in action definition
-    const actionBeforeHook = action.hooks && action.hooks.before ? sanitizeHooks(action.hooks.before, action.service) : null
-    const actionAfterHook = action.hooks && action.hooks.after ? sanitizeHooks(action.hooks.after, action.service) : null
-    const actionErrorHook = action.hooks && action.hooks.error ? sanitizeHooks(action.hooks.error, action.service) : null
+    const actionBeforeHook = action.hooks && action.hooks.before ? sanitizeHooks(action.hooks.before, action.service) : null;
+    const actionAfterHook = action.hooks && action.hooks.after ? sanitizeHooks(action.hooks.after, action.service) : null;
+    const actionErrorHook = action.hooks && action.hooks.error ? sanitizeHooks(action.hooks.error, action.service) : null;
 
     if (
       beforeWildcardHook ||
@@ -73,66 +73,66 @@ const makeActionHookMiddleware = function (handler, action) {
       actionErrorHook
     ) {
       return function actionHookMiddleware (context, serviceInjections) {
-        let promise = Promise.resolve()
+        let promise = Promise.resolve();
 
         // before all hook
         if (beforeWildcardHook) {
-          promise = promise.then(() => callHook(beforeWildcardHook, action.service, context))
+          promise = promise.then(() => callHook(beforeWildcardHook, action.service, context));
         }
 
         // Before hook
         if (beforeHook) {
-          promise = promise.then(() => callHook(beforeHook, action.service, context))
+          promise = promise.then(() => callHook(beforeHook, action.service, context));
         }
 
         // Before hook
         if (actionBeforeHook) {
-          promise = promise.then(() => callHook(actionBeforeHook, action.service, context))
+          promise = promise.then(() => callHook(actionBeforeHook, action.service, context));
         }
 
         // Call action handler
-        promise = promise.then(() => handler(context, serviceInjections))
+        promise = promise.then(() => handler(context, serviceInjections));
 
         // After hook in action definition
         if (actionAfterHook) {
-          promise = promise.then(result => callHook(actionAfterHook, action.service, context, result))
+          promise = promise.then(result => callHook(actionAfterHook, action.service, context, result));
         }
 
         // After hook
         if (afterHook) {
-          promise = promise.then(result => callHook(afterHook, action.service, context, result))
+          promise = promise.then(result => callHook(afterHook, action.service, context, result));
         }
 
         // After wildcard hook
         if (afterWildcardHook) {
-          promise = promise.then(result => callHook(afterWildcardHook, action.service, context, result))
+          promise = promise.then(result => callHook(afterWildcardHook, action.service, context, result));
         }
 
         // Error hooks
         // Error hook in action definition
         if (actionErrorHook) {
-          promise = promise.catch(error => callErrorHook(actionErrorHook, action.service, context, error))
+          promise = promise.catch(error => callErrorHook(actionErrorHook, action.service, context, error));
         }
 
         // Error hook
         if (errorHook) {
-          promise = promise.catch(error => callErrorHook(errorHook, action.service, context, error))
+          promise = promise.catch(error => callErrorHook(errorHook, action.service, context, error));
         }
 
         // Error wildcard hook
         if (errorWildcardHook) {
-          promise = promise.catch(error => callErrorHook(errorWildcardHook, action.service, context, error))
+          promise = promise.catch(error => callErrorHook(errorWildcardHook, action.service, context, error));
         }
 
-        return promise
-      }
+        return promise;
+      };
     }
   }
-  return handler
-}
+  return handler;
+};
 
 module.exports = () => {
   return {
     localAction: makeActionHookMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/bulkhead/index.js

@@ -1,10 +1,10 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
-const { Constants } = require('../../metrics')
-const { WeaveQueueSizeExceededError } = require('../../errors')
+const { Constants } = require('../../metrics');
+const { WeaveQueueSizeExceededError } = require('../../errors');
 
 /**
  * @typedef {import('../../types').Runtime} Runtime
@@ -18,47 +18,47 @@ const { WeaveQueueSizeExceededError } = require('../../errors')
  */
 module.exports = (runtime) => {
   const wrapBulkheadMiddleware = function (handler, action) {
-    const bulkheadOptions = runtime.options.bulkhead
+    const bulkheadOptions = runtime.options.bulkhead;
 
     if (bulkheadOptions.enabled) {
-      const queue = []
-      let currentlyInFlight = 0
+      const queue = [];
+      let currentlyInFlight = 0;
 
       const callNext = () => {
-        if (queue.length === 0) return
-        if (currentlyInFlight >= bulkheadOptions.concurrentCalls) return
+        if (queue.length === 0) return;
+        if (currentlyInFlight >= bulkheadOptions.concurrentCalls) return;
 
-        const item = queue.shift()
+        const item = queue.shift();
 
-        currentlyInFlight++
+        currentlyInFlight++;
         handler(item.context)
           .then(result => {
-            currentlyInFlight--
-            item.resolve(result)
-            callNext()
+            currentlyInFlight--;
+            item.resolve(result);
+            callNext();
           })
           .catch(error => {
-            currentlyInFlight--
-            callNext()
-            return item.reject(error)
-          })
-      }
+            currentlyInFlight--;
+            callNext();
+            return item.reject(error);
+          });
+      };
 
       return function bulkheadMiddlware (context, serviceInjections) {
         // Execute action immediately
         if (currentlyInFlight < bulkheadOptions.concurrentCalls) {
-          currentlyInFlight++
+          currentlyInFlight++;
           return handler(context, serviceInjections)
             .then(result => {
-              currentlyInFlight--
-              callNext()
-              return result
+              currentlyInFlight--;
+              callNext();
+              return result;
             })
             .catch(error => {
-              currentlyInFlight--
-              callNext()
-              return Promise.reject(error)
-            })
+              currentlyInFlight--;
+              callNext();
+              return Promise.reject(error);
+            });
         }
 
         // Reject the action if the max queue size is reached.
@@ -67,23 +67,23 @@ module.exports = (runtime) => {
             action: action.name,
             limit: bulkheadOptions.maxQueueSize,
             size: queue.length
-          }))
+          }));
         }
 
         // Queue the request
-        return new Promise((resolve, reject) => queue.push({ resolve, reject, context }))
-      }
+        return new Promise((resolve, reject) => queue.push({ resolve, reject, context }));
+      };
     }
-    return handler
-  }
+    return handler;
+  };
 
   return {
     created () {
       if (runtime.options.metrics.enabled) {
         // todo: add bulkhead metrics
-        runtime.metrics.register({ type: 'gauge', name: Constants.BULKHEAD_REQUESTS_IN_FLIGHT, description: 'Number of in flight requests.' })
+        runtime.metrics.register({ type: 'gauge', name: Constants.BULKHEAD_REQUESTS_IN_FLIGHT, description: 'Number of in flight requests.' });
       }
     },
     localAction: wrapBulkheadMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/cache/index.js

@@ -1,29 +1,29 @@
-const { isString, isFunction } = require('@weave-js/utils')
+const { isString, isFunction } = require('@weave-js/utils');
 
 module.exports = (runtime) => {
   return {
     localAction: (handler, action) => {
-      const cacheOptions = runtime.options.cache
+      const cacheOptions = runtime.options.cache;
       const cacheActionOptions = {
         enabled: !!action.cache
-      }
+      };
 
       if (isString(action.cache)) {
-        cacheActionOptions.keys = action.cache.split(' ')
+        cacheActionOptions.keys = action.cache.split(' ');
       } else if (action.cache && Array.isArray(action.cache.keys)) {
-        cacheActionOptions.keys = action.cache.keys
+        cacheActionOptions.keys = action.cache.keys;
       }
 
       if (cacheActionOptions.enabled) {
-        const cache = runtime.cache
-        const isEnabledFunction = isFunction(action.cache.condition)
+        const cache = runtime.cache;
+        const isEnabledFunction = isFunction(action.cache.condition);
 
         return function cacheMiddleware (context, serviceInjections) {
           // handle enabled function
           if (isEnabledFunction) {
             if (!action.cache.enabled.call(null, context)) {
               // Enabled function returns "false". Cache is disabled.
-              return handler(context, serviceInjections)
+              return handler(context, serviceInjections);
             }
           }
 
@@ -33,74 +33,74 @@ module.exports = (runtime) => {
             context.data,
             context.meta,
             cacheActionOptions.keys
-          )
+          );
 
-          context.isCachedResult = false
+          context.isCachedResult = false;
 
           // Disable caching by meta property.
           if (context.meta.$noCache === true) {
-            return handler(context, serviceInjections)
+            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)
+            cache.log('Cache adapter is not connected yet. Call handler...');
+            return handler(context, serviceInjections);
           }
 
           if (cacheOptions.lock.enabled) {
-            let cachePromise
+            let cachePromise;
             if (cacheOptions.lock.staleTime && cache.getWithTTl) {
 
             } else {
-              cachePromise = runtime.cache.get(cacheHashKey)
+              cachePromise = runtime.cache.get(cacheHashKey);
             }
 
             return cachePromise.then((cachedResult) => {
               if (cachedResult !== null) {
                 // Found a cached value. Skip calling handler and return our value
-                context.isCachedResult = true
-                return cachedResult
+                context.isCachedResult = true;
+                return cachedResult;
               }
 
               return cache.lock(cacheHashKey).then((release) => {
                 return cache.get(cacheHashKey).then(cachedResult => {
                   if (cachedResult !== null) {
                     // Found a cached value. Skip calling handler and return our value
-                    context.isCachedResult = true
+                    context.isCachedResult = true;
                     return release().then(() => {
-                      return cachedResult
-                    })
+                      return cachedResult;
+                    });
                   }
 
                   return handler(context).then((result) => {
                     // Cache the value
                     cache.set(cacheHashKey, result, action.cache.ttl).then(() => {
                       // release the lock
-                      release()
-                    })
-                    return result
-                  })
-                })
-              })
-            })
+                      release();
+                    });
+                    return result;
+                  });
+                });
+              });
+            });
           }
 
           // Not using cache lock
           return runtime.cache.get(cacheHashKey).then((cachedResult) => {
             if (cachedResult !== null) {
-              context.isCachedResult = true
-              return cachedResult
+              context.isCachedResult = true;
+              return cachedResult;
             }
 
             return handler(context, serviceInjections).then((result) => {
-              runtime.cache.set(cacheHashKey, result, action.cache.ttl)
-              return result
-            })
-          })
-        }
+              runtime.cache.set(cacheHashKey, result, action.cache.ttl);
+              return result;
+            });
+          });
+        };
       }
-      return handler
+      return handler;
     }
-  }
-}
+  };
+};

package/lib/middlewares/circuit-breaker/index.js

@@ -1,5 +1,5 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
@@ -8,32 +8,32 @@ const {
   CIRCUIT_HALF_OPENED,
   CIRCUIT_HALF_OPEN_WAITING,
   CIRCUIT_OPENED
-} = require('../../constants').circuitBreakerStates
+} = require('../../constants').circuitBreakerStates;
 
 module.exports = (runtime) => {
-  const storage = new Map()
-  let log = null
-  let circuitBreakerTimer = null
+  const storage = new Map();
+  let log = null;
+  let circuitBreakerTimer = null;
 
   function createWindowTimer (windowTime) {
-    circuitBreakerTimer = setInterval(() => clearEndpointStore(), windowTime)
-    circuitBreakerTimer.unref()
+    circuitBreakerTimer = setInterval(() => clearEndpointStore(), windowTime);
+    circuitBreakerTimer.unref();
   }
 
   function clearEndpointStore () {
     storage.forEach((item) => {
       if (item.callCounter === 0) {
-        storage.delete(item.name)
-        return
+        storage.delete(item.name);
+        return;
       }
 
-      item.callCounter = 0
-      item.failureCouter = 0
-    })
+      item.callCounter = 0;
+      item.failureCouter = 0;
+    });
   }
 
   function getEndpointState (endpoint, options) {
-    let item = storage.get(endpoint.name)
+    let item = storage.get(endpoint.name);
     if (!item) {
       item = {
         endpoint,
@@ -42,127 +42,127 @@ module.exports = (runtime) => {
         failureCouter: 0,
         state: CIRCUIT_CLOSED,
         circuitBreakerTimer: null
-      }
-      storage.set(endpoint.name, item)
+      };
+      storage.set(endpoint.name, item);
     }
 
-    return item
+    return item;
   }
 
   function onSuccess (item, options) {
-    item.callCounter++
+    item.callCounter++;
 
     if (item.state === CIRCUIT_HALF_OPENED) {
-      closeCircuitBreaker(item)
+      closeCircuitBreaker(item);
     } else {
-      checkThreshold(item, options)
+      checkThreshold(item, options);
     }
   }
 
   function onFailure (item, options) {
-    item.callCounter++
-    item.failureCouter++
+    item.callCounter++;
+    item.failureCouter++;
 
-    checkThreshold(item, options)
+    checkThreshold(item, options);
   }
 
   function checkThreshold (item, options) {
     if (item.failureCouter >= options.maxFailures) {
-      openCircuitBreaker(item)
+      openCircuitBreaker(item);
     }
   }
 
   function openCircuitBreaker (item) {
-    item.state = CIRCUIT_OPENED
-    item.endpoint.state = false
-    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout)
-    item.circuitBreakerTimer.unref()
-    log.debug(`Circuit breaker has been opened for endpoint '${item.endpoint.name}'`)
+    item.state = CIRCUIT_OPENED;
+    item.endpoint.state = false;
+    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout);
+    item.circuitBreakerTimer.unref();
+    log.debug(`Circuit breaker has been opened for endpoint '${item.endpoint.name}'`);
   }
 
   function halfOpenCircuitBreaker (item) {
-    item.state = CIRCUIT_HALF_OPENED
-    item.endpoint.state = true
+    item.state = CIRCUIT_HALF_OPENED;
+    item.endpoint.state = true;
 
-    log.debug(`Circuit breaker has been half opened for endpoint '${item.endpoint.name}'`)
+    log.debug(`Circuit breaker has been half opened for endpoint '${item.endpoint.name}'`);
 
     if (item.circuitBreakerTimer) {
-      clearTimeout(item.circuitBreakerTimer)
-      item.circuitBreakerTimer = null
+      clearTimeout(item.circuitBreakerTimer);
+      item.circuitBreakerTimer = null;
     }
   }
 
   function handleHalfOpen (item) {
-    item.state = CIRCUIT_HALF_OPEN_WAITING
-    item.endpoint.state = false
-    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout)
-    item.circuitBreakerTimer.unref()
+    item.state = CIRCUIT_HALF_OPEN_WAITING;
+    item.endpoint.state = false;
+    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout);
+    item.circuitBreakerTimer.unref();
   }
 
   function closeCircuitBreaker (item) {
-    item.failureCouter = 0
-    item.callCounter = 0
-    item.state = CIRCUIT_CLOSED
-    item.endpoint.state = true
+    item.failureCouter = 0;
+    item.callCounter = 0;
+    item.state = CIRCUIT_CLOSED;
+    item.endpoint.state = true;
 
     if (item.circuitBreakerTimer) {
-      clearTimeout(item.circuitBreakerTimer)
-      item.circuitBreakerTimer = null
+      clearTimeout(item.circuitBreakerTimer);
+      item.circuitBreakerTimer = null;
     }
 
-    log.debug(`Circuit breaker has been closed for endpoint '${item.endpoint.name}'`)
+    log.debug(`Circuit breaker has been closed for endpoint '${item.endpoint.name}'`);
   }
 
   function wrapCircuitBreakerMiddleware (handler, action) {
-    const options = Object.assign({}, runtime.options.circuitBreaker, action.circuitBreaker || {})
+    const options = Object.assign({}, runtime.options.circuitBreaker, action.circuitBreaker || {});
 
     if (options.enabled) {
       return function curcuitBreakerMiddleware (context, serviceInjections) {
-        const endpoint = context.endpoint
-        const item = getEndpointState(endpoint, options)
+        const endpoint = context.endpoint;
+        const item = getEndpointState(endpoint, options);
 
         // handle half open states
         if (item.state === CIRCUIT_HALF_OPENED) {
-          handleHalfOpen(item, context)
+          handleHalfOpen(item, context);
         }
 
         return handler(context, serviceInjections)
           .then(result => {
-            const item = getEndpointState(endpoint, options)
-            onSuccess(item, options)
+            const item = getEndpointState(endpoint, options);
+            onSuccess(item, options);
 
-            return result
+            return result;
           })
           .catch(error => {
             if (item && (!error.nodeId || error.nodeId === context.nodeId)) {
-              onFailure(item, options)
+              onFailure(item, options);
             }
 
-            return Promise.reject(error)
-          })
-      }
+            return Promise.reject(error);
+          });
+      };
     }
-    return handler
+    return handler;
   }
 
   return {
     created () {
-      log = runtime.createLogger('circuit-breaker')
+      log = runtime.createLogger('circuit-breaker');
 
       if (runtime.options.metrics.enabled) {
         // todo: add circuit breaker metrics
       }
     },
     started () {
-      const { enabled, windowTime } = this.options.circuitBreaker
+      const { enabled, windowTime } = this.options.circuitBreaker;
       if (enabled) {
-        createWindowTimer(windowTime)
+        createWindowTimer(windowTime);
       }
     },
     localAction: wrapCircuitBreakerMiddleware,
     remoteAction: wrapCircuitBreakerMiddleware,
     brokerStopped () {
-      clearInterval(circuitBreakerTimer)
+      clearInterval(circuitBreakerTimer);
     }
-  }
-}
+  };
+};