@weave-js/core 0.10.0 → 0.12.0

package/lib/build-runtime.js

@@ -1,70 +0,0 @@
-/**
- * @typedef {import('./types.js').BrokerOptions} BrokerOptions
- * @typedef {import('./types.js').Runtime} Runtime
- * @typedef {import('./types.js').Broker} Broker
-*/
-
-const { initLogger } = require('./runtime/init-logger')
-const { initMiddlewareHandler } = require('./runtime/init-middleware-manager')
-const { initRegistry } = require('./runtime/init-registry')
-const { initContextFactory } = require('./runtime/init-context-factory')
-const { initEventbus } = require('./runtime/init-eventbus')
-const { initValidator } = require('./runtime/init-validator')
-const { initTransport } = require('./runtime/init-transport')
-const { initCache } = require('./runtime/init-cache')
-const { initActionInvoker } = require('./runtime/init-action-invoker')
-const { initServiceManager } = require('./runtime/init-service-manager')
-const { initMetrics } = require('./runtime/init-metrics')
-const { initTracer } = require('./runtime/init-tracing')
-const { initUUIDFactory } = require('./runtime/init-uuid-factory')
-const { version } = require('../package.json')
-const { errorHandler, fatalErrorHandler } = require('./error-handler')
-const EventEmitter = require('eventemitter2')
-const { uuid } = require('@weave-js/utils')
-
-/**
- * Build runtime object
- * @param {BrokerOptions} options Broker options
- * @return {Runtime} Runtime
-*/
-exports.buildRuntime = (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/base.js

@@ -1,142 +0,0 @@
-/*
- * Author: Kevin Ries (kevin@fachw3rk.de)
- * -----
- * Copyright 2021 Fachwerk
- */
-const crypto = require('crypto')
-const { isObject } = require('@weave-js/utils')
-const Constants = require('../metrics/constants')
-
-function getCacheKeyByObject (val) {
-  if (Array.isArray(val)) {
-    return val.map(object => getCacheKeyByObject(object)).join('/')
-  } else if (isObject(val)) {
-    return Object.keys(val).map(key => {
-      return [key, getCacheKeyByObject(val[key])].join('/')
-    }).join('/')
-  } else if (val !== null) {
-    return val.toString()
-  } else {
-    return 'null'
-  }
-}
-
-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 })
-}
-
-exports.createCacheBase = (runtime, options) => {
-  const cache = {
-    runtime,
-    options,
-    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()
-    },
-    getCachingHash (actionName, params, meta, keys) {
-      if (params || meta) {
-        const prefix = `${actionName}:`
-
-        if (keys) {
-          if (keys.length === 1) {
-            const value = params[keys[0]]
-            const key = getCacheKeyByObject(value)
-            return prefix + (isObject(value) ? key : value)
-          }
-
-          if (keys.length > 0) {
-            const res = keys.reduce((pre, property, i) => {
-              const value = params[property]
-              let hash
-              if (isObject(value)) {
-                const key = getCacheKeyByObject(value)
-                hash = generateHash(key)
-              } else {
-                hash = value
-              }
-
-              return pre + (i > 0 ? '|' : '') + hash
-            }, prefix)
-            return res
-          }
-        } else {
-          return prefix + generateHash(getCacheKeyByObject(params))
-        }
-      }
-
-      return actionName
-    }
-  }
-
-  cache.middleware = () => {
-    return {
-      localAction: (handler, action) => {
-        const cacheOptions = Object.assign({ enabled: true }, isObject(action.cache) ? action.cache : { enabled: !!action.cache })
-        if (cacheOptions.enabled) {
-          return function cacheMiddleware (context, serviceInjections) {
-            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)
-            }
-
-            return cache.get(cacheHashKey).then((content) => {
-              if (content !== null) {
-                context.isCachedResult = true
-                return content
-              }
-
-              return handler(context, serviceInjections).then((result) => {
-                cache.set(cacheHashKey, result, action.cache.ttl)
-                return result
-              })
-            })
-          }
-        }
-        return handler
-      }
-    }
-  }
-
-  return cache
-}

package/lib/cache/index.js

@@ -1,48 +0,0 @@
-/*
- * Author: Kevin Ries (kevin@fachw3rk.de)
- * -----
- * Copyright 2021 Fachwerk
- */
-
-const { isString, isFunction } = require('@weave-js/utils')
-const { WeaveBrokerOptionsError } = require('../errors')
-
-const adapters = {
-  Memory: require('./memory')
-}
-
-exports.adapters = adapters
-
-exports.createCacheBase = require('./base').createCacheBase
-
-exports.resolve = (cacheOptions) => {
-  const getByName = name => {
-    if (!name) {
-      return null
-    }
-
-    const n = Object.keys(adapters).find(n => n.toLowerCase() === name.toLowerCase())
-    if (n) {
-      return adapters[n]
-    }
-  }
-
-  let cacheFactory
-
-  if (cacheOptions === true) {
-    cacheFactory = this.adapters.Memory
-  } else if (isString(cacheOptions)) {
-    const cache = getByName(cacheOptions)
-
-    if (cache) {
-      cacheFactory = cache
-    } else {
-      throw new WeaveBrokerOptionsError(`Unknown cache type "${cacheOptions}"`)
-    }
-  } else if (isFunction(cacheOptions)) {
-    cacheFactory = cacheOptions
-  }
-  if (cacheFactory) {
-    return cacheFactory
-  }
-}

package/lib/cache/memory.js

@@ -1,121 +0,0 @@
-/*
- * Author: Kevin Ries (kevin@fachw3rk.de)
- * -----
- * Copyright 2021 Fachwerk
- */
-
-const { match } = require('@weave-js/utils')
-const { createCacheBase } = require('./base')
-const Constants = require('../metrics/constants')
-
-const makeMemoryCache = (runtime, options = {}) => {
-  const base = createCacheBase(runtime, options)
-  const storage = new Map()
-  const name = 'Memory'
-
-  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.verbose('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,
-    get (cacheKey) {
-      base.log.debug(`Get ${cacheKey}`)
-
-      if (this.metrics) {
-        this.metrics.increment(Constants.CACHE_GET_TOTAL)
-      }
-
-      const item = storage.get(cacheKey)
-
-      if (item) {
-        cache.log.debug(`Found ${cacheKey}`)
-
-        if (this.metrics) {
-          this.metrics.increment(Constants.CACHE_FOUND_TOTAL)
-        }
-
-        // if (options.ttl) {
-        //   item.expire = Date.now()//  + options_.ttl
-        // }
-
-        if (item.expire && item.expire < Date.now()) {
-          cache.log.debug(`Delete ${cacheKey}`)
-          storage.delete(cacheKey)
-          if (this.metrics) {
-            this.metrics.increment(Constants.CACHE_EXPIRED_TOTAL)
-          }
-          return Promise.resolve(null)
-        }
-
-        return Promise.resolve(item.data)
-      }
-      return Promise.resolve(null)
-    },
-    set (hashKey, data, ttl) {
-      if (this.metrics) {
-        this.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 (this.metrics) {
-        this.metrics.increment(Constants.CACHE_DELETED_TOTAL)
-      }
-      storage.delete(hashKey)
-      base.log.debug(`Delete ${hashKey}`)
-
-      return Promise.resolve()
-    },
-    clear (pattern = '**') {
-      if (this.metrics) {
-        this.metrics.increment(Constants.CACHE_DELETED_TOTAL)
-      }
-      storage.forEach((_, key) => {
-        if (match(key, pattern)) {
-          base.log.debug(`Delete ${key}`)
-          this.remove(key)
-        }
-      })
-      return Promise.resolve()
-    },
-    stop () {
-      clearInterval(timer)
-    }
-  })
-
-  return cache
-}
-
-module.exports = makeMemoryCache

package/lib/middlewares/tracing/buildTags.js

@@ -1,17 +0,0 @@
-/**
- * @typedef {import("../../types.js").Context} Context
-*/
-
-/**
- * Build span tags object
- * @param {Context} context - Context
- * @returns {object} Tags
-*/
-module.exports.buildTags = (context) => {
-  return {
-    requestLevel: context.level,
-    action: context.action ? { name: context.action.name, shortName: context.action.shortName } : null,
-    isRemoteCall: !!context.callerNodeId,
-    nodeId: context.nodeId
-  }
-}

package/lib/new-errors.js

@@ -1,25 +0,0 @@
-/*
- * Author: Kevin Ries (kevin@fachw3rk.de)
- * -----
- * Copyright 2021 Fachwerk
- */
-
-const errors = require('@weave-js/errors')
-
-class RetrieableError extends Error {
-  constructor () {
-    super(...arguments)
-    this.retryable = true
-  }
-}
-
-module.exports = errors({
-  WeaveError: { code: 500 },
-  WeaveRetrieableError: { baseClass: RetrieableError },
-  WeaveServiceNotFoundError: {}, // retrieable
-  WeaveServiceNotAvailableError: {},
-  WeaveRequestTimeoutError: {},
-  WeaveParameterValidationError: {},
-  WeaveBrokerOptionsError: {},
-  WeaveQueueSizeExceededError: {}
-})

package/lib/registry/event-endpoint.js

@@ -1,26 +0,0 @@
-/*
- * Author: Kevin Ries (kevin@fachw3rk.de)
- * -----
- * Copyright 2021 Fachwerk
- */
-
-exports.createEventEndpoint = (broker, node, service, event) => {
-  const eventEndpoint = Object.create(null)
-
-  eventEndpoint.node = node
-  eventEndpoint.service = service
-  eventEndpoint.action = event
-  eventEndpoint.isLocal = eventEndpoint.node.id === broker.nodeId
-  eventEndpoint.state = true
-  eventEndpoint.name = `${node.id}:${event.name}`
-
-  eventEndpoint.updateEvent = (newEvent) => {
-    eventEndpoint.action = newEvent
-  }
-
-  eventEndpoint.isAvailable = () => {
-    return eventEndpoint.state
-  }
-
-  return eventEndpoint
-}

package/lib/runtime/init-cache.js

@@ -1,10 +0,0 @@
-const Cache = require('../cache')
-
-exports.initCache = (runtime) => {
-  if (runtime.options.cache && runtime.options.cache.enabled) {
-    const createCache = Cache.resolve(runtime.options.cache.adapter)
-    Object.defineProperty(runtime, 'cache', {
-      value: createCache(runtime, runtime.options.cache)
-    })
-  }
-}

package/lib/runtime/init-service-manager.js

@@ -1,128 +0,0 @@
-const { createServiceFromSchema } = require('../registry/service/service.js')
-const { WeaveError } = require('../errors')
-const { debounce } = require('@weave-js/utils')
-const fs = require('fs')
-
-exports.initServiceManager = (runtime) => {
-  const { options, log, eventBus, transport, state, registry, handleError } = runtime
-
-  // Internal service list
-  const serviceList = []
-
-  const serviceChanged = (isLocalService = false) => {
-    // Send local notification.
-    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()
-    }
-  }
-
-  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
-
-    // 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)
-  }
-
-  Object.defineProperty(runtime, 'services', {
-    value: {
-      serviceList,
-      serviceChanged,
-      createService (schema) {
-        try {
-          const newService = createServiceFromSchema(runtime, schema)
-
-          // if the broker is already startet, we need to start the service.
-          if (runtime.state.isStarted) {
-            newService.start().catch(error => log.error(`Unable to start service ${newService.name}: ${error}`))
-          }
-
-          return newService
-        } catch (error) {
-          log.error(error)
-          handleError(error)
-        }
-      },
-      /**
-       * Wait for services before continuing startup.
-       * @param {Array.<string>} serviceNames Names of the services
-       * @param {Number} timeout Time in Miliseconds before the broker stops.
-       * @param {Number} interval Time in Miliseconds to check for services.
-       * @returns {Promise} Promise
-      */
-      waitForServices (serviceNames, timeout, interval = 500) {
-        if (!Array.isArray(serviceNames)) {
-          serviceNames = [serviceNames]
-        }
-
-        const startTimestamp = Date.now()
-        return new Promise((resolve, reject) => {
-          // todo: add timout for service waiter
-          log.warn(`Waiting for services '${serviceNames.join(',')}'`)
-
-          const serviceCheck = () => {
-            const count = serviceNames.filter(serviceName => registry.hasService(serviceName))
-
-            log.warn(`${count.length} services of ${serviceNames.length} available. Waiting...`)
-
-            if (count.length === serviceNames.length) {
-              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 }))
-            }
-
-            options.waitForServiceInterval = setTimeout(serviceCheck, interval)
-          }
-
-          serviceCheck()
-        })
-      },
-      /**
-       * 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
-    }
-  })
-}

package/lib/tracing/collectors/console.js

@@ -1,34 +0,0 @@
-/* istanbul ignore file */
-
-const BaseCollector = require('./base')
-
-class ConsoleCollector extends BaseCollector {
-  constructor (options) {
-    super(options)
-
-    this.options = Object.assign({
-      events: {
-        started: '$tracing.trace.span.started',
-        finished: '$tracing.trace.span.finished'
-      },
-      broadcast: false
-    })
-  }
-
-  init (broker, tracer) {
-    super.init(tracer)
-    this.broker = broker
-  }
-
-  startedSpan (span) {
-    // const data = this.generateTracePayload(span)
-    this.broker.emit(this.options.events.started, span)
-  }
-
-  finishedSpan (span) {
-    // const data = this.generateTracePayload(span)
-    this.broker.emit(this.options.events.finished, span)
-  }
-}
-
-module.exports = ConsoleCollector

package/lib/tracing/index.js

@@ -1,3 +0,0 @@
-module.exports = {
-  Tracer: require('./tracer')
-}

package/lib/tracing/tracer.js

@@ -1,64 +0,0 @@
-const { resolveCollector } = require('./collectors')
-const { createSpan } = require('./span')
-
-module.exports = () => {
-  let collectors = []
-  let samplingCounter = 0
-
-  return {
-    init (broker, options) {
-      this.options = options
-      this.broker = broker
-      this.log = broker.createLogger('Tracer')
-      // this.storage = asyncStore()
-      // this.storage.enable()
-
-      if (options.enabled) {
-        this.log.info('Tracer initialized.')
-
-        if (options.collectors) {
-          collectors = options.collectors
-            .map(entry => {
-              const initCollector = resolveCollector(broker, entry, this)
-              // collector.init(this)
-              return initCollector()
-            })
-        }
-      }
-    },
-    async stop () {
-      if (collectors) {
-        return await Promise.all(collectors.map(collector => collector.stop()))
-      }
-    },
-    shouldSample (span) {
-      // check span priority
-      if (this.options.samplingRate === 0) {
-        return false
-      }
-
-      if (this.options.samplingRate === 1) {
-        return true
-      }
-
-      if (++samplingCounter * this.options.samplingRate >= 1) {
-        samplingCounter = 0
-        return true
-      }
-
-      return false
-    },
-    invokeCollectorMethod (method, args) {
-      collectors.map(collector => collector[method].apply(collector, args))
-    },
-    startSpan (name, options) {
-      const span = createSpan(this, name, Object.assign({
-        type: 'custom'
-      }, options))
-
-      span.start()
-
-      return span
-    }
-  }
-}