@microfleet/core/src/plugins/router/modules/lifecycle/index.ts

Abstract microservice core

import Bluebird = require('bluebird')
import Errors = require('common-errors')
import _debug = require('debug')
import is = require('is')
import upperFirst = require('lodash/upperFirst')
import Extensions, { LifecycleRequestType } from '../../extensions'

const debug = _debug('mservice:router:module:lifecycle')
export type ActionHandler = (...args: any[]) => any

function moduleLifecycle(
  module: string,
  promiseFactory: ActionHandler,
  extensions: Extensions,
  args: any[],
  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  context?: any
): Bluebird<any> {
  if (!is.string(module)) {
    return Bluebird.reject(new Errors.ArgumentError('module'))
  }

  if (!is.fn(promiseFactory)) {
    return Bluebird.reject(new Errors.ArgumentError('promiseFactory'))
  }

  if (!(extensions instanceof Extensions)) {
    return Bluebird.reject(new Errors.ArgumentError('extensions'))
  }

  if (!is.array(args)) {
    return Bluebird.reject(new Errors.ArgumentError('args'))
  }

  debug('lifecycle for module "%s"', module)

  const upperFirstName = upperFirst(module)
  const preModule = `pre${upperFirstName}` as LifecycleRequestType
  const postModule = `post${upperFirstName}` as LifecycleRequestType
  let result

  if (extensions.has(preModule)) {
    result = Bluebird.resolve([preModule, args, context])
      .bind(extensions)
      .spread(extensions.exec)
  } else {
    result = Bluebird.resolve(args)
  }

  return result
    .bind(context)
    .spread(promiseFactory)
    .reflect()
    .then((inspection) => {
      let resultResponse = null
      let errorResponse = null

      if (inspection.isFulfilled()) {
        resultResponse = inspection.value()
      } else {
        errorResponse = inspection.reason()
      }

      if (!extensions.has(postModule)) {
        if (errorResponse) {
          return Bluebird.reject(errorResponse)
        }

        return resultResponse
      }

      return Bluebird
        .resolve([postModule, [errorResponse, resultResponse, ...args], context])
        .bind(extensions)
        .spread(extensions.exec)
        .spread((error, response) => {
          if (error) {
            return Bluebird.reject(error)
          }

          return response
        })
    })
}

export default moduleLifecycle