@weave-js/core 0.11.1 → 0.13.0

package/lib/registry/service/parseEvent.js

@@ -1,45 +1,45 @@
-const { isFunction, clone, wrapHandler, isObject, promisify } = require('@weave-js/utils')
-const { WeaveError } = require('../../errors')
+const { isFunction, clone, wrapHandler, isObject, promisify } = require('@weave-js/utils');
+const { WeaveError } = require('../../errors');
 
 module.exports.parseEvent = (runtime, service, eventDefinition, name) => {
-  let event
+  let event;
 
   // if the handler is a method (short form), we wrap the method in our handler object.
   if (isFunction(eventDefinition)) {
-    event = wrapHandler(eventDefinition)
+    event = wrapHandler(eventDefinition);
   } else if (isObject(eventDefinition)) {
-    event = clone(eventDefinition)
+    event = clone(eventDefinition);
   } else {
-    runtime.handleError(new WeaveError(`Invalid event definition "${name}" on service "${service.name}".`))
+    runtime.handleError(new WeaveError(`Invalid event definition "${name}" on service "${service.name}".`));
   }
 
   // Event handler has to be a function
   if (!isFunction(event.handler) && !Array.isArray(event.handler)) {
-    runtime.handleError(new WeaveError(`Missing event handler for "${name}" on service "${service.name}".`))
+    runtime.handleError(new WeaveError(`Missing event handler for "${name}" on service "${service.name}".`));
   }
 
-  event.service = service
+  event.service = service;
 
-  let handler
+  let handler;
   if (isFunction(event.handler)) {
-    handler = promisify(event.handler.bind(service))
+    handler = promisify(event.handler.bind(service));
   } else if (Array.isArray(event.handler)) {
     handler = event.handler.map(h => {
-      return promisify(h.bind(service))
-    })
+      return promisify(h.bind(service));
+    });
   }
 
   if (!event.name) {
-    event.name = name
+    event.name = name;
   }
 
   if (isFunction(handler)) {
-    event.handler = (context) => handler(context)
+    event.handler = (context) => handler(context);
   } else if (Array.isArray(handler)) {
-    event.handler = (context) => Promise.all(handler.map(h => h(context)))
+    event.handler = (context) => Promise.all(handler.map(h => h(context)));
   }
 
-  event.service = service
+  event.service = service;
 
-  return event
-}
+  return event;
+};

package/lib/registry/service/reduceMixins.js

@@ -1,23 +1,23 @@
-const { mergeSchemas } = require('../../utils/options')
-const { wrapInArray } = require('@weave-js/utils')
+const { mergeSchemas } = require('../../utils/options');
+const { wrapInArray } = require('@weave-js/utils');
 
 const reduceMixins = (service, schema) => {
-  const mixins = wrapInArray(schema.mixins)
+  const mixins = wrapInArray(schema.mixins);
   if (mixins.length > 0) {
     const mixedSchema = Array
       .from(mixins)
       .reverse()
       .reduce((s, mixin) => {
         if (mixin.mixins) {
-          mixin = reduceMixins(service, mixin)
+          mixin = reduceMixins(service, mixin);
         }
 
-        return s ? mergeSchemas(s, mixin) : mixin
-      }, null)
-    return mergeSchemas(mixedSchema, schema)
+        return s ? mergeSchemas(s, mixin) : mixin;
+      }, null);
+    return mergeSchemas(mixedSchema, schema);
   }
 
-  return schema
-}
+  return schema;
+};
 
-exports.reduceMixins = reduceMixins
+exports.reduceMixins = reduceMixins;

package/lib/registry/service/service.js

@@ -4,12 +4,12 @@
  * @typedef {import("../../types").Service} Service
 */
 
-const { isFunction, clone, isObject, promisify } = require('@weave-js/utils')
-const { WeaveError } = require('../../errors')
-const { parseAction } = require('./parseAction')
-const { parseEvent } = require('./parseEvent')
-const { reduceMixins } = require('./reduceMixins')
-const { createEventEndpoint } = require('../eventEndpoint')
+const { isFunction, clone, isObject, promisify } = require('@weave-js/utils');
+const { WeaveError } = require('../../errors');
+const { parseAction } = require('./parseAction');
+const { parseEvent } = require('./parseEvent');
+const { reduceMixins } = require('./reduceMixins');
+const { createEventEndpoint } = require('../eventEndpoint');
 /**
  * Service factory
  * @param {Runtime} runtime Broker instance
@@ -19,69 +19,69 @@ const { createEventEndpoint } = require('../eventEndpoint')
 exports.createServiceFromSchema = (runtime, schema) => {
   // Check if a schema is given
   if (!schema) {
-    runtime.handleError(new WeaveError('Schema is missing!'))
+    runtime.handleError(new WeaveError('Schema is missing!'));
   }
 
   /**
    * @type {Service}
   */
-  const service = Object.create(null)
+  const service = Object.create(null);
 
   // Set reference to the runtime.
-  service.runtime = runtime
+  service.runtime = runtime;
 
   // Set reference to the broker instance.
-  service.broker = runtime.broker
+  service.broker = runtime.broker;
 
-  // Apply all mixins (including childs)
+  // Apply all mixins (including children)
   if (schema.mixins) {
-    schema = reduceMixins(service, schema)
+    schema = reduceMixins(service, schema);
   }
 
-  // Call "afterSchemasMerged" service lifecylce hook(s)
+  // Call "afterSchemasMerged" service lifecycle hook(s)
   if (schema.afterSchemasMerged) {
     if (isFunction(schema.afterSchemasMerged)) {
-      schema.afterSchemasMerged.call(service, schema)
+      schema.afterSchemasMerged.call(service, schema);
     } else if (Array.isArray(schema.afterSchemasMerged)) {
-      Promise.all(schema.afterSchemasMerged.map(afterSchemasMerged => afterSchemasMerged.call(service, schema)))
+      Promise.all(schema.afterSchemasMerged.map(afterSchemasMerged => afterSchemasMerged.call(service, schema)));
     }
   }
 
   // Call "serviceCreating" middleware hook
-  runtime.middlewareHandler.callHandlersSync('serviceCreating', [service, schema])
+  runtime.middlewareHandler.callHandlersSync('serviceCreating', [service, schema]);
 
   // validate name
   if (!schema.name) {
-    runtime.handleError(new WeaveError('Service name is missing!'))
+    runtime.handleError(new WeaveError('Service name is missing!'));
   }
 
   // Set name
-  service.name = schema.name
+  service.name = schema.name;
 
   // Set service version
-  service.version = schema.version
+  service.version = schema.version;
 
   // Create a full qualified name, including version if set.
-  service.fullyQualifiedName = service.version ? `${service.name}.${service.version}` : service.name
+  service.fullyQualifiedName = service.version ? `${service.name}.${service.version}` : service.name;
 
   // Set a reference to the base schema
-  service.schema = schema
+  service.schema = schema;
 
   // Set the service settings
-  service.settings = schema.settings || {}
+  service.settings = schema.settings || {};
 
   // Set the service meta data
-  service.meta = schema.meta || {}
+  service.meta = schema.meta || {};
 
   // Create a separate protocol instance for the service.
   service.log = runtime.createLogger(`${service.name}-service`, {
     svc: service.name,
     version: service.version
-  })
+  });
 
   // Action object
-  service.actions = {}
-  service.events = {}
+  service.actions = {};
+  service.events = {};
 
   // Create the service registry item
   const serviceSpecification = {
@@ -92,89 +92,89 @@ exports.createServiceFromSchema = (runtime, schema) => {
     version: service.version,
     actions: {},
     events: {}
-  }
+  };
 
   // Bind service methods to context
   if (isObject(schema.methods)) {
     Object.keys(schema.methods).map(name => {
-      const method = schema.methods[name]
+      const method = schema.methods[name];
 
       // Reserved property names
       if (['log', 'actions', 'meta', 'events', 'settings', 'methods', 'dependencies', 'version', 'dependencies', 'broker', 'runtime', 'afterSchemasMerged', 'created', 'started', 'stopped'].includes(name)) {
-        runtime.handleError(new WeaveError(`Invalid method name ${name} in service ${service.name}.`))
+        runtime.handleError(new WeaveError(`Invalid method name ${name} in service ${service.name}.`));
       }
 
-      service[name] = method.bind(service)
-    })
+      service[name] = method.bind(service);
+    });
   }
 
   // Bind and register service actions
   if (isObject(schema.actions)) {
     Object.keys(schema.actions).map(name => {
-      const actionDefinition = schema.actions[name]
+      const actionDefinition = schema.actions[name];
 
       // skip actions that are set to false
-      if (actionDefinition === false) return
+      if (actionDefinition === false) return;
 
-      const innerAction = parseAction(runtime, service, clone(actionDefinition), name)
-      serviceSpecification.actions[innerAction.name] = innerAction
+      const innerAction = parseAction(runtime, service, clone(actionDefinition), name);
+      serviceSpecification.actions[innerAction.name] = innerAction;
 
-      const wrappedAction = runtime.middlewareHandler.wrapHandler('localAction', innerAction.handler, innerAction)
+      const wrappedAction = runtime.middlewareHandler.wrapHandler('localAction', innerAction.handler, innerAction);
 
       // Make the action accessable via this.actions["actionName"]
       service.actions[name] = (data, options) => {
-        let context
+        let context;
         // reuse context
         if (options && options.context) {
-          context = options.context
+          context = options.context;
         } else {
-          const endpoint = runtime.registry.createPrivateActionEndpoint(innerAction)
+          const endpoint = runtime.registry.createPrivateActionEndpoint(innerAction);
           // create a new context
-          context = runtime.contextFactory.create(endpoint, data, options || {})
+          context = runtime.contextFactory.create(endpoint, data, options || {});
         }
 
-        return wrappedAction(context, { service, runtime, errors: {}})
-      }
-    })
+        return wrappedAction(context, { service, runtime, errors: {}});
+      };
+    });
   }
 
   // Bind and register service events
   if (isObject(schema.events)) {
     Object.keys(schema.events).map(name => {
-      const eventDefinition = schema.events[name]
-      const innerEvent = parseEvent(runtime, service, clone(eventDefinition), name)
+      const eventDefinition = schema.events[name];
+      const innerEvent = parseEvent(runtime, service, clone(eventDefinition), name);
 
-      serviceSpecification.events[name] = innerEvent
+      serviceSpecification.events[name] = innerEvent;
 
       // wrap event
-      const wrappedEvent = runtime.middlewareHandler.wrapHandler('localEvent', innerEvent.handler, innerEvent)
+      const wrappedEvent = runtime.middlewareHandler.wrapHandler('localEvent', innerEvent.handler, innerEvent);
 
       // Add local event handler
       service.events[name] = (data, options) => {
-        let context
+        let context;
         if (options && options.context) {
-          context = options.context
+          context = options.context;
         } else {
           // create a local endpoint for the event
-          const endpoint = createEventEndpoint(runtime, runtime.registry.nodeCollection.localNode, innerEvent.service, innerEvent)
+          const endpoint = createEventEndpoint(runtime, runtime.registry.nodeCollection.localNode, innerEvent.service, innerEvent);
 
           // create a new context
-          context = runtime.contextFactory.create(endpoint, data, options || {})
+          context = runtime.contextFactory.create(endpoint, data, options || {});
         }
 
-        return wrappedEvent(context)
-      }
-    })
+        return wrappedEvent(context);
+      };
+    });
   }
 
-  // Call "created" service lifecylce hook(s)
+  // Call "created" service lifecycle hook(s)
   if (schema.created) {
     if (isFunction(schema.created)) {
-      schema.created.call(service)
+      schema.created.call(service);
     }
 
     if (Array.isArray(schema.created)) {
-      Promise.all(schema.created.map(createdHook => createdHook.call(service)))
+      Promise.all(schema.created.map(createdHook => createdHook.call(service)));
     }
   }
 
@@ -189,49 +189,49 @@ exports.createServiceFromSchema = (runtime, schema) => {
       .then(() => runtime.middlewareHandler.callHandlersAsync('serviceStarting', [service]))
       .then(() => {
         if (schema.dependencies) {
-          return runtime.services.waitForServices(schema.dependencies, service.settings.$dependencyTimeout || 0)
+          return runtime.services.waitForServices(schema.dependencies, service.settings.$dependencyTimeout || 0);
         }
       }).then(() => {
         if (isFunction(schema.started)) {
-          return promisify(schema.started.bind(service))()
+          return promisify(schema.started.bind(service))();
         }
 
         if (Array.isArray(schema.started)) {
           return schema.started
             .map(hook => promisify(hook.bind(service)))
-            .reduce((p, hook) => p.then(hook), Promise.resolve())
+            .reduce((p, hook) => p.then(hook), Promise.resolve());
         }
       })
       .then(() => runtime.registry.registerLocalService(serviceSpecification))
-      .then(() => runtime.middlewareHandler.callHandlersAsync('serviceStarted', [service]))
-  }
+      .then(() => runtime.middlewareHandler.callHandlersAsync('serviceStarted', [service]));
+  };
 
   // stop method for service
   service.stop = () => {
-    service.log.info(`Stopping service "${service.fullyQualifiedName}"...`)
+    service.log.info(`Stopping service "${service.fullyQualifiedName}"...`);
     return Promise.resolve()
       .then(() => {
-        return runtime.middlewareHandler.callHandlersAsync('serviceStopping', [service])
+        return runtime.middlewareHandler.callHandlersAsync('serviceStopping', [service]);
       })
       .then(() => {
         if (isFunction(schema.stopped)) {
-          return promisify(schema.stopped.bind(service))()
+          return promisify(schema.stopped.bind(service))();
         }
 
         if (Array.isArray(schema.stopped)) {
           return schema.stopped
             .map(hook => promisify(hook.bind(service)))
-            .reduce((p, hook) => p.then(hook), Promise.resolve())
+            .reduce((p, hook) => p.then(hook), Promise.resolve());
         }
       })
       .then(() => runtime.middlewareHandler.callHandlersAsync('serviceStopped', [service], { reverse: true }))
-      .then(() => service.log.info(`Service "${service.name}" stopped`))
-  }
+      .then(() => service.log.info(`Service "${service.name}" stopped`));
+  };
 
-  runtime.middlewareHandler.callHandlersSync('serviceCreated', [service, schema])
+  runtime.middlewareHandler.callHandlersSync('serviceCreated', [service, schema]);
 
   // Add service to brokers local map
-  runtime.services.serviceList.push(service)
+  runtime.services.serviceList.push(service);
 
-  return service
-}
+  return service;
+};

package/lib/registry/serviceItem.js

@@ -1,9 +1,9 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
-'use strict'
+'use strict';
 
 /**
  * @typedef {import("../types").ServiceItem} ServiceItem
@@ -23,32 +23,32 @@ exports.createServiceItem = (node, name, version, settings, isLocal) => {
   /**
    * @type {ServiceItem}
   */
-  const serviceItem = Object.create(null)
+  const serviceItem = Object.create(null);
 
-  serviceItem.name = name
-  serviceItem.node = node
-  serviceItem.settings = settings || {}
-  serviceItem.version = version
-  serviceItem.actions = {}
-  serviceItem.events = {}
-  serviceItem.isLocal = isLocal
+  serviceItem.name = name;
+  serviceItem.node = node;
+  serviceItem.settings = settings || {};
+  serviceItem.version = version;
+  serviceItem.actions = {};
+  serviceItem.events = {};
+  serviceItem.isLocal = isLocal;
 
   serviceItem.addAction = (action) => {
-    serviceItem.actions[action.name] = action
-  }
+    serviceItem.actions[action.name] = action;
+  };
 
   serviceItem.addEvent = (event) => {
-    serviceItem.events[event.name] = event
-  }
+    serviceItem.events[event.name] = event;
+  };
 
   serviceItem.equals = (name, version, nodeId) => {
-    return serviceItem.name === name && serviceItem.version === version && (nodeId == null || serviceItem.node.id === nodeId)
-  }
+    return serviceItem.name === name && serviceItem.version === version && (nodeId == null || serviceItem.node.id === nodeId);
+  };
 
   serviceItem.update = (service) => {
-    serviceItem.settings = service.settings
-    serviceItem.version = service.version
-  }
+    serviceItem.settings = service.settings;
+    serviceItem.version = service.version;
+  };
 
-  return serviceItem
-}
+  return serviceItem;
+};

package/lib/runtime/initActionInvoker.js

@@ -1,7 +1,7 @@
-const errors = require('../errors')
+const errors = require('../errors');
 
 exports.initActionInvoker = (runtime) => {
-  const { registry, contextFactory, log, handleError } = runtime
+  const { registry, contextFactory, log, handleError } = runtime;
 
   /**
    * Call a action.
@@ -11,36 +11,36 @@ exports.initActionInvoker = (runtime) => {
    * @returns {Promise} Promise
   */
   const call = (actionName, data, opts = {}) => {
-    const endpoint = registry.getNextAvailableActionEndpoint(actionName, opts)
+    const endpoint = registry.getNextAvailableActionEndpoint(actionName, opts);
 
     if (endpoint instanceof Error) {
       return Promise.reject(endpoint)
-        .catch(error => handleError(error))
+        .catch(error => handleError(error));
     }
 
-    const action = endpoint.action
-    const nodeId = endpoint.node.id
-    let context
+    const action = endpoint.action;
+    const nodeId = endpoint.node.id;
+    let context;
 
     // If a context is passed, we use this
     if (opts.context !== undefined) {
-      context = opts.context
-      context.nodeId = nodeId
+      context = opts.context;
+      context.nodeId = nodeId;
     } else {
-      context = contextFactory.create(endpoint, data, opts)
+      context = contextFactory.create(endpoint, data, opts);
     }
 
     if (endpoint.isLocal) {
-      log.debug({ action: context.action.name, requestId: context.requestId }, 'Call action local.')
+      log.debug({ action: context.action.name, requestId: context.requestId }, 'Call action local.');
     } else {
-      log.debug({ action: context.action.name, nodeId, requestId: context.requestId }, 'Call action on remote node.')
+      log.debug({ action: context.action.name, nodeId, requestId: context.requestId }, 'Call action on remote node.');
     }
 
-    const p = action.handler(context, { service: context.action.service, runtime, errors })
-    p.context = context
+    const p = action.handler(context, { service: context.action.service, runtime, errors });
+    p.context = context;
 
-    return p
-  }
+    return p;
+  };
 
   /**
    * Call multiple actions.
@@ -49,16 +49,16 @@ exports.initActionInvoker = (runtime) => {
   */
   const multiCall = (actions) => {
     if (Array.isArray(actions)) {
-      return Promise.all(actions.map(item => call(item.actionName, item.params, item.options)))
+      return Promise.all(actions.map(item => call(item.actionName, item.params, item.options)));
     } else {
-      return Promise.reject(new errors.WeaveError('Actions need to be an Array'))
+      return Promise.reject(new errors.WeaveError('Actions need to be an Array'));
     }
-  }
+  };
 
   Object.defineProperty(runtime, 'actionInvoker', {
     value: {
       call,
       multiCall
     }
-  })
-}
+  });
+};

package/lib/runtime/initCache.js

@@ -1,19 +1,19 @@
-const { isFunction } = require('@weave-js/utils')
-const { WeaveError } = require('../errors')
+const { isFunction } = require('@weave-js/utils');
+const { WeaveError } = require('../errors');
 
 exports.initCache = (runtime) => {
   if (runtime.options.cache && runtime.options.cache.enabled) {
     if (!isFunction(runtime.options.cache.adapter)) {
-      throw new WeaveError('Invalid cache adapter.')
+      throw new WeaveError('Invalid cache adapter.');
     }
 
     // Init cache adapter
-    const cache = runtime.options.cache.adapter(runtime, runtime.options.cache)
+    const cache = runtime.options.cache.adapter(runtime, runtime.options.cache);
 
-    runtime.log.info(`Cache: ${cache.name}`)
+    runtime.log.info(`Cache: ${cache.name}`);
 
     Object.defineProperty(runtime, 'cache', {
       value: cache
-    })
+    });
   }
-}
+};

package/lib/runtime/initContextFactory.js

@@ -1,11 +1,11 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
-'use strict'
+'use strict';
 
-const { createContext } = require('../broker/context')
+const { createContext } = require('../broker/context');
 
 /**
  * @typedef {import('../types').Runtime} Runtime
@@ -30,54 +30,54 @@ exports.initContextFactory = (runtime) => {
        * @returns {Context} Context
       */
       create (endpoint, data, opts) {
-        const context = createContext(runtime)
+        const context = createContext(runtime);
 
-        opts = opts || {}
-        context.setData(data)
+        opts = opts || {};
+        context.setData(data);
         // context.timeout = opts.timeout || 0
-        context.retryCount = opts.retryCount
-        context.options = opts
+        context.retryCount = opts.retryCount;
+        context.options = opts;
 
         // get external request id from options
         if (opts.requestId) {
-          context.requestId = opts.requestId
+          context.requestId = opts.requestId;
         } else if (opts.parentContext && opts.parentContext.requestId) {
-          context.requestId = opts.parentContext.requestId
+          context.requestId = opts.parentContext.requestId;
         }
 
         // meta data
         if (opts.parentContext && opts.parentContext.meta !== null) {
-          context.meta = Object.assign({}, opts.parentContext.meta, opts.meta)
+          context.meta = Object.assign({}, opts.parentContext.meta, opts.meta);
         } else if (opts.meta) {
-          context.meta = opts.meta
+          context.meta = opts.meta;
         }
 
         // Parent context
         if (opts.parentContext != null) {
-          context.parentId = opts.parentContext.id
-          context.level = opts.parentContext.level + 1
-          context.tracing = opts.parentContext.tracing
-          context.span = opts.parentContext.span
+          context.parentId = opts.parentContext.id;
+          context.level = opts.parentContext.level + 1;
+          context.tracing = opts.parentContext.tracing;
+          context.span = opts.parentContext.span;
         }
 
         // handle local streams
         if (opts.stream) {
-          context.setStream(opts.stream)
+          context.setStream(opts.stream);
         }
 
         // set request ID for metrics
         if (context.metrics || context.nodeId !== runtime.nodeId) {
           if (!context.requestId) {
-            context.requestId = context.id
+            context.requestId = context.id;
           }
         }
 
         if (endpoint) {
-          context.setEndpoint(endpoint)
+          context.setEndpoint(endpoint);
         }
 
-        return context
+        return context;
       }
     }
-  })
-}
+  });
+};