@weave-js/core 0.10.0 → 0.11.0

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

@@ -8,7 +8,19 @@ function callHook (hook, service, context, result) {
   if (typeof hook === 'function') {
     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))
+    return hook.reduce(
+      (promise, fn) => promise.then(res => fn.call(service, context, res)),
+      Promise.resolve(result))
+  }
+}
+
+function callErrorHook (hook, service, context, error) {
+  if (typeof hook === 'function') {
+    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))
   }
 }
 
@@ -19,6 +31,7 @@ function sanitizeHooks (hooks, service) {
 
   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
       }
@@ -32,15 +45,33 @@ const makeActionHookMiddleware = function (handler, action) {
   const name = action.shortName
   const hooks = (action.service && action.service.schema) ? action.service.schema.hooks : null
 
-  if (hooks) {
-    const beforeWildcardHook = hooks.before ? sanitizeHooks(hooks.before['*'], action.service) : null
-    const afterWildcardHook = hooks.after ? sanitizeHooks(hooks.after['*'], action.service) : null
-    const errorWildcardHook = hooks.error ? sanitizeHooks(hooks.error['*'], action.service) : null
-    const beforeHook = hooks.before ? sanitizeHooks(hooks.before[name], action.service) : null
-    const afterHook = hooks.after ? sanitizeHooks(hooks.after[name], action.service) : null
-    const errorHook = hooks.error ? sanitizeHooks(hooks.error[name], action.service) : 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
+
+    // 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
 
-    if (beforeWildcardHook || afterWildcardHook || errorWildcardHook || beforeHook || afterHook || errorHook) {
+    // 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
+
+    if (
+      beforeWildcardHook ||
+      afterWildcardHook ||
+      errorWildcardHook ||
+      beforeHook ||
+      afterHook ||
+      errorHook ||
+      actionBeforeHook ||
+      actionAfterHook ||
+      actionErrorHook
+    ) {
       return function actionHookMiddleware (context, serviceInjections) {
         let promise = Promise.resolve()
 
@@ -54,9 +85,19 @@ const makeActionHookMiddleware = function (handler, action) {
           promise = promise.then(() => callHook(beforeHook, action.service, context))
         }
 
+        // Before hook
+        if (actionBeforeHook) {
+          promise = promise.then(() => callHook(actionBeforeHook, action.service, context))
+        }
+
         // Call action handler
         promise = promise.then(() => handler(context, serviceInjections))
 
+        // After hook in action definition
+        if (actionAfterHook) {
+          promise = promise.then(result => callHook(actionAfterHook, action.service, context, result))
+        }
+
         // After hook
         if (afterHook) {
           promise = promise.then(result => callHook(afterHook, action.service, context, result))
@@ -67,13 +108,20 @@ const makeActionHookMiddleware = function (handler, action) {
           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))
+        }
+
         // Error hook
         if (errorHook) {
-          promise = promise.catch(error => callHook(errorHook, action.service, context, error))
+          promise = promise.catch(error => callErrorHook(errorHook, action.service, context, error))
         }
+
         // Error wildcard hook
         if (errorWildcardHook) {
-          promise = promise.catch(error => callHook(errorWildcardHook, action.service, context, error))
+          promise = promise.catch(error => callErrorHook(errorWildcardHook, action.service, context, error))
         }
 
         return promise

package/lib/middlewares/bulkhead/index.js

@@ -3,7 +3,7 @@
  * -----
  * Copyright 2021 Fachwerk
  */
-
+const { Constants } = require('../../metrics')
 const { WeaveQueueSizeExceededError } = require('../../errors')
 
 /**
@@ -81,6 +81,7 @@ module.exports = (runtime) => {
     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.' })
       }
     },
     localAction: wrapBulkheadMiddleware

package/lib/middlewares/cache/index.js

@@ -0,0 +1,80 @@
+const { isObject } = 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) {
+        return function cacheMiddleware (context, serviceInjections) {
+          const cache = runtime.cache
+          const cacheHashKey = cache.getCachingHash(action.name, context.data, context.meta, action.cache.keys)
+          context.isCachedResult = false
+
+          if (context.meta.$noCache === true) {
+            return handler(context, serviceInjections)
+          }
+
+          if (cache.isConnected === false) {
+            cache.log('Cache adapter is not connected yet. Call handler...')
+            return handler(context, serviceInjections)
+          }
+
+          if (cacheOptions.lock.enabled) {
+            let cacheProm
+            if (cacheOptions.lock.staleTime && cache.getWithTTl) {
+
+            } else {
+              cacheProm = runtime.cache.get(cacheHashKey)
+            }
+
+            return cacheProm.then((cachedResult) => {
+              if (cachedResult !== null) {
+                // Found a cached value. Skip calling handler and return our value
+                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
+                    return release().then(() => {
+                      return cachedResult
+                    })
+                  }
+
+                  return handler(context).then((result) => {
+                    // Cache the value
+                    cache.set(cacheHashKey, result, action.cache.ttl).then(() => {
+                      // release the lock
+                      release()
+                    })
+                    return result
+                  })
+                })
+              })
+            })
+          }
+
+          // Not using cache lock
+          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
+    }
+  }
+}

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

@@ -3,6 +3,12 @@
  * -----
  * Copyright 2021 Fachwerk
  */
+const {
+  CIRCUIT_CLOSED,
+  CIRCUIT_HALF_OPENED,
+  CIRCUIT_HALF_OPEN_WAITING,
+  CIRCUIT_OPENED
+} = require('../../constants').circuitBreakerStates
 
 module.exports = (runtime) => {
   const storage = new Map()
@@ -15,7 +21,7 @@ module.exports = (runtime) => {
   }
 
   function clearEndpointStore () {
-    storage.forEach(item => {
+    storage.forEach((item) => {
       if (item.callCounter === 0) {
         storage.delete(item.name)
         return
@@ -34,7 +40,7 @@ module.exports = (runtime) => {
         options,
         callCounter: 0,
         failureCouter: 0,
-        state: 'CIRCUIT_BREAKER_CLOSED',
+        state: CIRCUIT_CLOSED,
         circuitBreakerTimer: null
       }
       storage.set(endpoint.name, item)
@@ -43,17 +49,17 @@ module.exports = (runtime) => {
     return item
   }
 
-  function success (item, options) {
+  function onSuccess (item, options) {
     item.callCounter++
 
-    if (item.state === 'CIRCUIT_BREAKER_HALF_OPENED') {
-      closeCircuitBreaker(item, options)
+    if (item.state === CIRCUIT_HALF_OPENED) {
+      closeCircuitBreaker(item)
     } else {
       checkThreshold(item, options)
     }
   }
 
-  function failure (item, error, options) {
+  function onFailure (item, options) {
     item.callCounter++
     item.failureCouter++
 
@@ -67,24 +73,36 @@ module.exports = (runtime) => {
   }
 
   function openCircuitBreaker (item) {
-    item.state = 'CIRCUIT_BREAKER_OPEN'
+    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_BREAKER_HALF_OPEN'
+    item.state = CIRCUIT_HALF_OPENED
     item.endpoint.state = true
 
     log.debug(`Circuit breaker has been half opened for endpoint '${item.endpoint.name}'`)
+
+    if (item.circuitBreakerTimer) {
+      clearTimeout(item.circuitBreakerTimer)
+      item.circuitBreakerTimer = null
+    }
   }
 
-  function closeCircuitBreaker (item, options) {
+  function handleHalfOpen (item) {
+    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_BREAKER_CLOSED'
+    item.state = CIRCUIT_CLOSED
     item.endpoint.state = true
 
     if (item.circuitBreakerTimer) {
@@ -103,15 +121,22 @@ module.exports = (runtime) => {
         const endpoint = context.endpoint
         const item = getEndpointState(endpoint, options)
 
+        // handle half open states
+        if (item.state === CIRCUIT_HALF_OPENED) {
+          handleHalfOpen(item, context)
+        }
+
         return handler(context, serviceInjections)
           .then(result => {
             const item = getEndpointState(endpoint, options)
-            success(item, options)
+            onSuccess(item, options)
 
             return result
           })
           .catch(error => {
-            failure(item, error, options)
+            if (item && (!error.nodeId || error.nodeId === context.nodeId)) {
+              onFailure(item, options)
+            }
 
             return Promise.reject(error)
           })

package/lib/middlewares/index.js

@@ -7,6 +7,7 @@
 module.exports = {
   ActionHooks: require('./action-hooks'),
   Bulkhead: require('./bulkhead'),
+  Cache: require('./cache'),
   CircuitBreaker: require('./circuit-breaker'),
   ErrorHandler: require('./error-handler'),
   Metrics: require('./metrics'),

package/lib/middlewares/metrics/index.js

@@ -33,7 +33,7 @@ module.exports = (runtime) => {
       return wrapMetricMiddleware('local', action, next)
     },
     remoteAction (next, action) {
-      return wrapMetricMiddleware.call('remote', action, next)
+      return wrapMetricMiddleware('remote', action, next)
     },
     emit (next) {
       return (event, payload) => {

package/lib/middlewares/timeout/index.js

@@ -7,7 +7,7 @@
 const { promiseTimeout } = require('@weave-js/utils')
 const { WeaveRequestTimeoutError } = require('../../errors')
 
-const wrapTimeoutMiddleware = function (handler, action) {
+const wrapTimeoutMiddleware = function (handler) {
   const self = this
   const registryOptions = self.options.registry || {}
 
@@ -23,7 +23,7 @@ const wrapTimeoutMiddleware = function (handler, action) {
     let promise = handler(context, serviceInjections)
 
     if (context.options.timeout > 0) {
-      promise = promiseTimeout(context.options.timeout, promise, new WeaveRequestTimeoutError(context.action.name, context.nodeId))
+      promise = promiseTimeout(context.options.timeout, promise, new WeaveRequestTimeoutError(context.action.name, context.nodeId, context.options.timeout))
         .catch(error => {
           if (error instanceof WeaveRequestTimeoutError) {
             self.log.warn(`Request '${context.action.name}' timed out.`)

package/lib/middlewares/tracing/index.js

@@ -4,17 +4,22 @@
  * Copyright 2021 Fachwerk
  */
 
-const { buildTags } = require('./buildTags')
+const { isPlainObject } = require('@weave-js/utils')
+const { buildActionTags, buildEventTags } = require('./tags')
 
 const wrapTracingLocalActionMiddleware = function (handler) {
   const broker = this
-  const options = broker.options.tracing || {}
+  const tracingOptions = broker.options.tracing || {}
 
-  if (options.enabled) {
+  if (tracingOptions.enabled) {
     return function metricsLocalMiddleware (context, serviceInjections) {
-      const tags = buildTags(context)
+      const tags = buildActionTags(context, tracingOptions)
 
-      const spanName = `action '${context.action.name}'`
+      if (tracingOptions) {
+        tags.data = context.data !== null && isPlainObject(context.data) ? Object.assign({}, context.data) : context.data
+      }
+
+      const spanName = `action "${context.action.name}"`
 
       const span = context.startSpan(spanName, {
         id: context.id,
@@ -30,6 +35,15 @@ const wrapTracingLocalActionMiddleware = function (handler) {
 
       return handler(context, serviceInjections)
         .then(result => {
+          const tags = {
+            isCachedResult: context.isCachedResult
+          }
+
+          if (tracingOptions) {
+            tags.response = result !== null && isPlainObject(result) ? Object.assign({}, result) : result
+          }
+
+          span.addTags(tags)
           span.finish()
           return result
         })
@@ -47,13 +61,13 @@ const wrapTracingLocalActionMiddleware = function (handler) {
 const wrapTracingLocalEventMiddleware = function (handler, event) {
   const broker = this
   const service = event.service
-  const options = broker.options.tracing || {}
+  const tracingOptions = broker.options.tracing || {}
 
-  if (options.enabled) {
+  if (tracingOptions.enabled) {
     return function metricsLocalMiddleware (context) {
-      const tags = buildTags(context)
+      const tags = buildEventTags(context)
 
-      const span = context.startSpan(`event '${context.eventName}'`, {
+      const span = context.startSpan(`event "${context.eventName}"`, {
         id: context.id,
         traceId: context.requestId,
         parentId: context.parentId,
@@ -67,7 +81,6 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
 
       return handler(context)
         .then(result => {
-          span.addTags(tags)
           span.finish()
           return result
         })
@@ -82,7 +95,7 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
   return handler
 }
 
-module.exports = (broker) => {
+module.exports = () => {
   return {
     localAction: wrapTracingLocalActionMiddleware,
     localEvent: wrapTracingLocalEventMiddleware

package/lib/middlewares/tracing/tags.js

@@ -0,0 +1,43 @@
+/**
+ * @typedef {import("../../types.js").Context} Context
+ * @typedef {import("../../types.js").TracingOptions} TracingOptions
+*/
+
+/**
+ * Build span tags object
+ * @param {Context} context - Context
+ * @param {TracingOptions} brokerTracingOptions - Tracing options
+ * @param {TracingOptions} actionTracingOptions - Tracing options
+ * @returns {object} Tags
+*/
+module.exports.buildActionTags = (context, brokerTracingOptions, actionTracingOptions) => {
+  const tags = {
+    requestLevel: context.level,
+    action: context.action ? { name: context.action.name, shortName: context.action.shortName } : null,
+    isRemoteCall: !!context.callerNodeId,
+    nodeId: context.nodeId,
+    requestId: context.requestId
+  }
+
+  return tags
+}
+
+/**
+ * Build span tags object
+ * @param {Context} context - Context
+ * @param {TracingOptions} brokerTracingOptions - Tracing options
+ * @param {TracingOptions} actionTracingOptions - Tracing options
+ * @returns {object} Tags
+*/
+module.exports.buildEventTags = (context, brokerTracingOptions, actionTracingOptions) => {
+  const tags = {
+    requestLevel: context.level,
+    event: context.eventName,
+    eventType: context.eventType,
+    isRemoteCall: !!context.callerNodeId,
+    nodeId: context.nodeId,
+    requestId: context.requestId
+  }
+
+  return tags
+}

package/lib/middlewares/validator/index.js

@@ -16,7 +16,7 @@ const { capitalize } = require('@weave-js/utils')
  * Create validator middleware
  * @param {Runtime} runtime - Runtime reference
  * @returns {Middleware} - Validator middleware
- */
+*/
 module.exports = (runtime) => {
   const validator = runtime.validator
 

package/lib/registry/collections/{action-collection.js → actionCollection.js}

@@ -11,7 +11,7 @@
  * @typedef {import('../../types.js').ServiceActionCollection} ServiceActionCollection
 */
 const { omit } = require('@weave-js/utils')
-const { createEndpointList } = require('./endpoint-collection')
+const { createEndpointList } = require('./endpointCollection')
 
 /**
  * Configuration object for weave service broker.

package/lib/registry/collections/{endpoint-collection.js → endpointCollection.js}

@@ -14,14 +14,14 @@
  * @typedef {import('../../types.js').EndpointCollection} EndpointCollection
 */
 
-const { createActionEndpoint } = require('../action-endpoint')
+const { createActionEndpoint } = require('../actionEndpoint')
 const { loadBalancingStrategy } = require('../../constants')
 
 /**
  *
  * @param {Runtime} runtime Runtime instance
  * @param {string} name name
- * @param {string} groupName Group name
+ * @param {string=} groupName Group name
  * @returns {EndpointCollection} EndpointCollection
  */
 exports.createEndpointList = (runtime, name, groupName) => {
@@ -33,7 +33,6 @@ exports.createEndpointList = (runtime, name, groupName) => {
 
   let counter = 0
 
-  endpointList.state = runtime // ????
   endpointList.name = name
   endpointList.groupName = groupName
   endpointList.isInternal = name.startsWith('$')

package/lib/registry/collections/{event-collection.js → eventCollection.js}

@@ -15,7 +15,7 @@
 */
 
 const { omit, match } = require('@weave-js/utils')
-const { createEndpointList } = require('./endpoint-collection')
+const { createEndpointList } = require('./endpointCollection')
 
 const broadcastEvents = ['broadcast', 'localBroadcast']
 /**
@@ -51,7 +51,7 @@ exports.createEventCollection = (registry) => {
   }
 
   eventCollection.remove = (node, eventName) => {
-    events.map(list => {
+    events.map((list) => {
       if (list.name === eventName) {
         list.removeByNodeId(node.id)
       }
@@ -59,7 +59,7 @@ exports.createEventCollection = (registry) => {
   }
 
   eventCollection.removeByService = (service) => {
-    events.map(list => {
+    events.map((list) => {
       list.removeByService(service)
     })
   }
@@ -67,7 +67,7 @@ exports.createEventCollection = (registry) => {
   eventCollection.getBalancedEndpoints = (eventName, groups) => {
     const result = []
     getAllEventsByEventName(eventName)
-      .forEach(endpointList => {
+      .forEach((endpointList) => {
         if (groups == null || groups.length === 0 || groups.indexOf(endpointList.groupName) !== -1) {
           const endpoint = endpointList.getNextAvailableEndpoint()
           if (endpoint && endpoint.isAvailable()) {
@@ -75,10 +75,6 @@ exports.createEventCollection = (registry) => {
           }
         }
       })
-      // .filter(endpointList => (groups == null || groups.length === 0 || groups.includes(endpointList.groupName)))
-      // .map(endpointList => ({ endpoint: endpointList.getNextAvailableEndpoint(), endpointList }))
-      // .filter(({ endpoint }) => endpoint && endpoint.isAvailable())
-      // .map(({ endpoint, endpointList }) => [endpoint, endpointList.groupName])
     return result
   }
 

package/lib/registry/collections/{service-collection.js → serviceCollection.js}

@@ -13,7 +13,7 @@
 
 // const { createEndpointCollection } = require('./endpoint-collection')
 const { omit, remove } = require('@weave-js/utils')
-const { createServiceItem } = require('../service-item')
+const { createServiceItem } = require('../serviceItem')
 
 /**
  * Service collection factory

package/lib/registry/registry.js

@@ -21,11 +21,11 @@
 const { safeCopy } = require('@weave-js/utils')
 
 // own packages
-const { createNodeCollection } = require('./collections/node-collection')
-const { createServiceCollection } = require('./collections/service-collection')
-const { createActionCollection } = require('./collections/action-collection')
-const { createEventCollection } = require('./collections/event-collection')
-const { createActionEndpoint } = require('./action-endpoint')
+const { createNodeCollection } = require('./collections/nodeCollection')
+const { createServiceCollection } = require('./collections/serviceCollection')
+const { createActionCollection } = require('./collections/actionCollection')
+const { createEventCollection } = require('./collections/eventCollection')
+const { createActionEndpoint } = require('./actionEndpoint')
 const { createNode } = require('./node')
 const { WeaveServiceNotFoundError, WeaveServiceNotAvailableError } = require('../errors')
 
@@ -47,24 +47,12 @@ exports.createRegistry = (runtime) => {
     log: runtime.createLogger('REGISTRY'),
     /**
    * Initialize the registry
-   * @param {Broker} runtime Broker instance
+   * @param {Runtime} runtime Runtime
    * @param {MiddlewareHandler} middlewareHandler Middleware handler
    * @param {ServiceChangedDelegate} serviceChanged Service changed delegate
    * @returns {void}
    */
     init (runtime) {
-      /**
-       * @type {Broker}
-      */
-
-      /**
-       * @type {MiddlewareHandler}
-      */
-
-      /**
-       * @type {ServiceChangedDelegate}
-      */
-
       // init collections
       this.nodeCollection = createNodeCollection(this)
       this.serviceCollection = createServiceCollection(this)
@@ -141,7 +129,6 @@ exports.createRegistry = (runtime) => {
         }
 
         if (oldActions) {
-          // this.deregisterAction()
           Object.keys(oldActions).forEach(actionName => {
             if (!service.actions[actionName]) {
               this.actionCollection.remove(actionName, node)
@@ -201,7 +188,7 @@ exports.createRegistry = (runtime) => {
         if (node.isLocal) {
           action.handler = middlewareHandler.wrapHandler('localAction', action.handler, action)// this.onRegisterLocalAction(action)
         } else {
-          action.handler = middlewareHandler.wrapHandler('remoteAction', runtime.transport.request.bind(runtime.transport), action)// this.onRegisterRemoteAction(action)
+          action.handler = middlewareHandler.wrapHandler('remoteAction', runtime.transport.sendRequest.bind(runtime.transport), action)// this.onRegisterRemoteAction(action)
         }
 
         this.actionCollection.add(node, service, action)
@@ -369,9 +356,9 @@ exports.createRegistry = (runtime) => {
       }
 
       // todo: Handle multiple nodes with the same ID.
-      const updateNesesary = node.update(payload, isReconnected)
+      const updateNecessary = node.update(payload, isReconnected)
 
-      if (updateNesesary && node.services) {
+      if (updateNecessary && node.services) {
         this.registerRemoteServices(node, node.services)
       }