@weave-js/core 0.11.1 → 0.13.0

package/lib/runtime/initServiceManager.js

@@ -1,53 +1,51 @@
-const { createServiceFromSchema } = require('../registry/service/service.js')
-const { WeaveError } = require('../errors')
-const { debounce } = require('@weave-js/utils')
-const fs = require('fs')
+const { createServiceFromSchema } = require('../registry/service/service.js');
+const { WeaveError } = require('../errors');
 
 exports.initServiceManager = (runtime) => {
-  const { options, log, eventBus, transport, state, registry, handleError } = runtime
+  const { options, log, eventBus, transport, state, registry, handleError } = runtime;
 
   // Internal service list
-  const serviceList = []
+  const serviceList = [];
 
   const serviceChanged = (isLocalService = false) => {
     // Send local notification.
-    eventBus.broadcastLocal('$services.changed', { isLocalService })
+    eventBus.broadcastLocal('$services.changed', { isLocalService });
 
     // If the service is a local service - send current node information to other nodes
     if (state.isStarted && isLocalService && transport) {
-      transport.sendNodeInfo()
+      transport.sendNodeInfo();
     }
-  }
-
-  const destroyService = (service) => Promise.resolve()
-    .then(() => service.stop())
-    .then(() => log.info(`Service "${service.name}" was stopped.`))
-    .then(() => {
-      registry.deregisterService(service.name, service.version)
-      log.info(`Service "${service.name}" was deregistered.`)
-      // Remove service from service store.
-      serviceList.splice(serviceList.indexOf(service), 1)
-      // Fire services changed event
-      serviceChanged(true)
-      return Promise.resolve()
-    })
-    .catch(error => log.error(error, `Unable to stop service "${service.name}"`))
+  };
+
+  // const destroyService = (service) => Promise.resolve()
+  //   .then(() => service.stop())
+  //   .then(() => log.info(`Service "${service.name}" was stopped.`))
+  //   .then(() => {
+  //     registry.deregisterService(service.name, service.version)
+  //     log.info(`Service "${service.name}" was deregistered.`)
+  //     // Remove service from service store.
+  //     serviceList.splice(serviceList.indexOf(service), 1)
+  //     // Fire services changed event
+  //     serviceChanged(true)
+  //     return Promise.resolve()
+  //   })
+  //   .catch(error => log.error(error, `Unable to stop service "${service.name}"`))
 
   // `onServiceFileChanged` only triggered by the file watcher
-  const onServiceFileChanged = async (service) => {
-    const filename = service.filename
+  // const onServiceFileChanged = async (service) => {
+  //   const filename = service.filename;
 
-    // Clear the require cache
-    Object.keys(require.cache).forEach(key => {
-      if (key === filename) {
-        delete require.cache[key]
-      }
-    })
+  //   // Clear the require cache
+  //   Object.keys(require.cache).forEach(key => {
+  //     if (key === filename) {
+  //       delete require.cache[key];
+  //     }
+  //   });
 
-    // Service has changed - 1. destroy the service, then reload it
-    await destroyService(service)
-    await runtime.broker.loadService(filename)
-  }
+  //   // Service has changed - 1. destroy the service, then reload it
+  //   await destroyService(service);
+  //   await runtime.broker.loadService(filename);
+  // };
 
   Object.defineProperty(runtime, 'services', {
     value: {
@@ -55,17 +53,17 @@ exports.initServiceManager = (runtime) => {
       serviceChanged,
       createService (schema) {
         try {
-          const newService = createServiceFromSchema(runtime, schema)
+          const newService = createServiceFromSchema(runtime, schema);
 
-          // if the broker is already startet, we need to start the service.
+          // if the broker is already started, we need to start the service.
           if (runtime.state.isStarted) {
-            newService.start().catch(error => log.error(`Unable to start service ${newService.name}: ${error}`))
+            newService.start().catch(error => log.error(`Unable to start service ${newService.name}: ${error}`));
           }
 
-          return newService
+          return newService;
         } catch (error) {
-          log.error(error)
-          handleError(error)
+          log.error(error);
+          handleError(error);
         }
       },
       /**
@@ -77,52 +75,76 @@ exports.initServiceManager = (runtime) => {
       */
       waitForServices (serviceNames, timeout, interval = 500) {
         if (!Array.isArray(serviceNames)) {
-          serviceNames = [serviceNames]
+          serviceNames = [serviceNames];
         }
 
-        const startTimestamp = Date.now()
+        const startTimestamp = Date.now();
         return new Promise((resolve, reject) => {
           // todo: add timout for service waiter
-          log.warn(`Waiting for services '${serviceNames.join(',')}'`)
+          log.warn(`Waiting for services '${serviceNames.join(',')}'`);
 
           const serviceCheck = () => {
-            const count = serviceNames.filter(serviceName => registry.hasService(serviceName))
+            const count = serviceNames.filter(serviceName => registry.hasService(serviceName));
 
-            log.warn(`${count.length} services of ${serviceNames.length} available. Waiting...`)
+            log.warn(`${count.length} services of ${serviceNames.length} available. Waiting...`);
 
             if (count.length === serviceNames.length) {
-              return resolve()
+              return resolve();
             }
 
             if (timeout && (Date.now() - startTimestamp) > timeout) {
-              return reject(new WeaveError('The waiting of the services is interrupted due to a timeout.', 500, 'WAIT_FOR_SERVICE', { services: serviceNames }))
+              return reject(new WeaveError('The waiting of the services is interrupted due to a timeout.', {
+                code: 'WAIT_FOR_SERVICE',
+                data: {
+                  services: serviceNames
+                }
+              }));
             }
 
-            options.waitForServiceInterval = setTimeout(serviceCheck, interval)
-          }
+            options.waitForServiceInterval = setTimeout(serviceCheck, interval);
+          };
 
-          serviceCheck()
-        })
+          serviceCheck();
+        });
       },
+      /**
+       * Destroy a service
+       * @param {Service} service Service
+       * @returns {Promise<any>} result
+       */
+      async destroyService (service) {
+        try {
+          // Stop the service
+          await service.stop();
+          log.info(`Service "${service.name}" was stopped.`);
+
+          // Deregister the service and remove it from the service list
+          registry.deregisterService(service.name, service.version);
+          serviceList.splice(serviceList.indexOf(service), 1);
+          log.info(`Service "${service.name}" was deregistered.`);
+          serviceChanged(true);
+        } catch (error) {
+          log.error(error, `Unable to stop service "${service.name}"`);
+        }
+      }
       /**
        * Watch a Service object for changes.
        * @param {Service} service Service object
        * @return {void}
       */
-      watchService: (service) => {
-        if (service.filename && onServiceFileChanged) {
-          // Create debounced service changed reference
-          const debouncedOnServiceChange = debounce(onServiceFileChanged, 500)
-
-          // Watch file changes
-          const watcher = fs.watch(service.filename, (eventType, filename) => {
-            log.info(`The Service ${service.name} has been changed. (${eventType}, ${filename})`)
-            watcher.close()
-            debouncedOnServiceChange(service)
-          })
-        }
-      },
-      destroyService
+      // watchService: (service) => {
+      //   if (service.filename && onServiceFileChanged) {
+      //     // Create debounced service changed reference
+      //     const debouncedOnServiceChange = debounce(onServiceFileChanged, 500);
+
+      //     // Watch file changes
+      //     const watcher = fs.watch(service.filename, (eventType, filename) => {
+      //       log.info(`The Service ${service.name} has been changed. (${eventType}, ${filename})`);
+      //       watcher.close();
+      //       debouncedOnServiceChange(service);
+      //     });
+      //   }
+      // }
     }
-  })
-}
+  });
+};

package/lib/runtime/initTracing.js

@@ -1,11 +1,11 @@
-const { resolveCollector } = require('../tracing/collectors')
-const { createSpan } = require('../tracing/span')
+const { resolveCollector } = require('../tracing/collectors');
+const { createSpan } = require('../tracing/span');
 
 exports.initTracer = (runtime) => {
-  const options = runtime.options.tracing
-  const log = runtime.createLogger('TRACER')
-  let collectors = []
-  let samplingCounter = 0
+  const options = runtime.options.tracing;
+  const log = runtime.createLogger('TRACER');
+  let collectors = [];
+  let samplingCounter = 0;
 
   Object.defineProperty(runtime, 'tracer', {
     value: {
@@ -14,52 +14,52 @@ exports.initTracer = (runtime) => {
       log,
       async stop () {
         if (collectors.length > 0) {
-          return await Promise.all(collectors.map(collector => collector.stop()))
+          return await Promise.all(collectors.map(collector => collector.stop()));
         }
       },
       shouldSample (span) {
         // check span priority
         if (options.samplingRate === 0) {
-          return false
+          return false;
         }
 
         if (options.samplingRate === 1) {
-          return true
+          return true;
         }
 
         if (++samplingCounter * this.options.samplingRate >= 1) {
-          samplingCounter = 0
-          return true
+          samplingCounter = 0;
+          return true;
         }
 
-        return false
+        return false;
       },
       invokeCollectorMethod (method, args) {
-        collectors.map(collector => collector[method].apply(collector, args))
+        collectors.map(collector => collector[method].apply(collector, args));
       },
       startSpan (name, options) {
         const span = createSpan(this, name, Object.assign({
           type: 'custom'
-        }, options))
+        }, options));
 
-        span.start()
+        span.start();
 
-        return span
+        return span;
       }
     }
-  })
+  });
 
   // Init collectors
   if (options.enabled) {
-    log.info('Tracer initialized.')
+    log.info('Tracer initialized.');
 
     if (options.collectors) {
       collectors = options.collectors
         .map(entry => {
-          const initCollector = resolveCollector(runtime, entry, this)
-          initCollector.init(runtime)
-          return initCollector
-        })
+          const initCollector = resolveCollector(runtime, entry, this);
+          initCollector.init(runtime);
+          return initCollector;
+        });
     }
   }
-}
+};

package/lib/runtime/initTransport.js

@@ -2,16 +2,16 @@
  * @typedef {import('../types').TransportAdapter} TransportAdapter
 **/
 
-const { createTransport } = require('../transport/createTransport')
-const TransportAdapters = require('../transport/adapters')
+const { createTransport } = require('../transport/createTransport');
+const TransportAdapters = require('../transport/adapters');
 
 exports.initTransport = (runtime) => {
   if (runtime.options.transport.adapter) {
     /** @type {TransportAdapter} */
-    const adapter = TransportAdapters.resolve(runtime, runtime.options.transport)
+    const adapter = TransportAdapters.resolve(runtime, runtime.options.transport);
 
     Object.defineProperty(runtime, 'transport', {
       value: createTransport(runtime, adapter)
-    })
+    });
   }
-}
+};

package/lib/runtime/initUuidFactory.js

@@ -2,7 +2,7 @@
  * @typedef {import('../types.js').Runtime} Runtime
 */
 
-const { isFunction, uuid } = require('@weave-js/utils')
+const { isFunction, uuid } = require('@weave-js/utils');
 
 /**
  * Init uuid Generator and attach it to our runtime object.
@@ -10,7 +10,7 @@ const { isFunction, uuid } = require('@weave-js/utils')
  * @returns {void}
 */
 exports.initUUIDFactory = (runtime) => {
-  const { options } = runtime
+  const { options } = runtime;
 
-  runtime.generateUUID = (options.uuidFactory && isFunction(options.uuidFactory)) ? () => options.uuidFactory(runtime) : uuid
-}
+  runtime.generateUUID = (options.uuidFactory && isFunction(options.uuidFactory)) ? () => options.uuidFactory(runtime) : uuid;
+};

package/lib/runtime/initValidator.js

@@ -1,5 +1,5 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
@@ -8,7 +8,7 @@
  * @typedef {import('../types.js').Runtime} Runtime
 */
 
-const ObjectValidator = require('@weave-js/validator')
+const ObjectValidator = require('@weave-js/validator');
 
 /**
  * Init validator and attach it to our runtime object.
@@ -16,11 +16,11 @@ const ObjectValidator = require('@weave-js/validator')
  * @returns {void}
 */
 exports.initValidator = (runtime) => {
-  const validator = ObjectValidator()
+  const validator = ObjectValidator();
 
   Object.defineProperty(runtime, 'validator', {
     value: {
       ...validator
     }
-  })
-}
+  });
+};

package/lib/tracing/collectors/base.js

@@ -1,52 +1,52 @@
-const { isObject, pick } = require('@weave-js/utils')
+const { isObject, pick } = require('@weave-js/utils');
 
 exports.createBaseTracingCollector = (runtime) => {
-  const baseTracingCollector = Object.create(null)
+  const baseTracingCollector = Object.create(null);
 
-  baseTracingCollector.options = runtime.tracer.options
+  baseTracingCollector.options = runtime.tracer.options;
 
   baseTracingCollector.init = (runtime) => {
-    baseTracingCollector.runtime = runtime
-    baseTracingCollector.tracer = runtime.tracer
-  }
+    baseTracingCollector.runtime = runtime;
+    baseTracingCollector.tracer = runtime.tracer;
+  };
 
   baseTracingCollector.startedSpan = () => {
     // throw new WeaveError('not implemented.')
-  }
+  };
 
   baseTracingCollector.finishedSpan = () => {
     // throw new WeaveError('not implemented.')
-  }
+  };
 
   baseTracingCollector.stop = () => {
     // throw new WeaveError('not implemented.')
-  }
+  };
 
   baseTracingCollector.flattenTags = (obj, convertToString = false, path = '') => {
     if (!obj) {
-      return null
+      return null;
     }
 
     return Object.keys(obj).reduce((res, k) => {
-      const o = obj[k]
-      const pp = (path ? path + '.' : '') + k
+      const o = obj[k];
+      const pp = (path ? path + '.' : '') + k;
 
       if (isObject(o)) {
-        Object.assign(res, baseTracingCollector.flattenTags(o, convertToString, pp))
+        Object.assign(res, baseTracingCollector.flattenTags(o, convertToString, pp));
       } else if (o !== undefined) {
-        res[pp] = convertToString ? String(o) : o
+        res[pp] = convertToString ? String(o) : o;
       }
 
-      return res
-    }, {})
-  }
+      return res;
+    }, {});
+  };
 
   baseTracingCollector.getErrorFields = (err, fields) => {
     if (!err) {
-      return null
+      return null;
     }
-    return pick(err, fields)
-  }
+    return pick(err, fields);
+  };
 
-  return baseTracingCollector
-}
+  return baseTracingCollector;
+};

package/lib/tracing/collectors/event.js

@@ -1,4 +1,4 @@
-const { createBaseTracingCollector } = require('./base')
+const { createBaseTracingCollector } = require('./base');
 
 const mergeDefaultOptions = (options) => {
   return Object.assign({
@@ -7,80 +7,80 @@ const mergeDefaultOptions = (options) => {
     sendStartSpan: false,
     sendFinishedSpan: true,
     broadcast: false
-  }, options)
-}
+  }, options);
+};
 
 module.exports = (options) => (runtime, tracer) => {
-  options = mergeDefaultOptions(options)
+  options = mergeDefaultOptions(options);
 
-  const exporter = createBaseTracingCollector(runtime)
+  const exporter = createBaseTracingCollector(runtime);
 
-  exporter.init(runtime, tracer)
+  exporter.init(runtime, tracer);
 
-  const queue = []
+  const queue = [];
 
-  let timer
+  let timer;
 
   const generateTracingData = () => {
     return Array
       .from(queue)
       .map(span => {
-        const newSpan = Object.assign({}, span)
+        const newSpan = Object.assign({}, span);
 
         if (newSpan.error) {
-          newSpan.error = exporter.getErrorFields(newSpan.error, exporter.options.errors.fields)
+          newSpan.error = exporter.getErrorFields(newSpan.error, exporter.options.errors.fields);
         }
 
-        return newSpan
-      })
-  }
+        return newSpan;
+      });
+  };
 
   const flushQueue = () => {
-    if (queue.length === 0) return
+    if (queue.length === 0) return;
 
-    const data = generateTracingData()
-    queue.length = 0
+    const data = generateTracingData();
+    queue.length = 0;
 
     if (options.broadcast) {
-      exporter.runtime.eventBus.broadcast(options.eventName, data)
+      exporter.runtime.eventBus.broadcast(options.eventName, data);
     } else {
-      exporter.runtime.eventBus.emit(options.eventName, data)
+      exporter.runtime.eventBus.emit(options.eventName, data);
     }
-  }
+  };
 
   if (options.interval > 0) {
-    timer = setInterval(() => flushQueue(), options.interval)
-    timer.unref()
+    timer = setInterval(() => flushQueue(), options.interval);
+    timer.unref();
   }
 
   exporter.init = (runtime) => {
 
-  }
+  };
 
   exporter.startedSpan = (span) => {
     if (options.sendStartSpan) {
-      queue.push(span)
+      queue.push(span);
       if (!timer) {
-        flushQueue()
+        flushQueue();
       }
     }
-  }
+  };
 
   exporter.finishedSpan = (span) => {
     if (options.sendFinishedSpan) {
-      queue.push(span)
+      queue.push(span);
       if (!timer) {
-        flushQueue()
+        flushQueue();
       }
     }
-  }
+  };
 
   exporter.stop = async () => {
     if (timer) {
-      clearInterval(timer)
-      timer = null
+      clearInterval(timer);
+      timer = null;
     }
-  }
+  };
 
-  return exporter
-}
+  return exporter;
+};

package/lib/tracing/collectors/index.js

@@ -1,39 +1,39 @@
-const { isFunction } = require('@weave-js/utils')
+const { isFunction } = require('@weave-js/utils');
 
 const collectors = {
   // Console: require('./console'),
   Event: require('./event'),
   BaseCollector: require('./base')
-}
+};
 
 const getByName = name => {
-  const n = Object.keys(collectors).find(collectorName => collectorName.toLowerCase() === name.toLowerCase())
-  return collectors[n]
-}
+  const n = Object.keys(collectors).find(collectorName => collectorName.toLowerCase() === name.toLowerCase());
+  return collectors[n];
+};
 
 exports.resolveCollector = (runtime, collector) => {
-  let CollectorClass
+  let CollectorClass;
   if (typeof collector === 'string') {
-    CollectorClass = getByName(collector)
+    CollectorClass = getByName(collector);
   }
 
   if (isFunction(collector)) {
-    return collector(runtime)
+    return collector(runtime);
   }
 
   if (typeof collector === 'object') {
-    return collector
+    return collector;
   }
 
   if (!CollectorClass) {
-    runtime.handleError(new Error('Tracer not found'))
+    runtime.handleError(new Error('Tracer not found'));
   }
 
-  return new CollectorClass(collector)
-}
+  return new CollectorClass(collector);
+};
 
-exports.Base = collectors.BaseCollector
+exports.Base = collectors.BaseCollector;
 
-exports.Console = collectors.Console
+exports.Console = collectors.Console;
 
-exports.Event = collectors.Event
+exports.Event = collectors.Event;