index.js

/**
 * HydraExpress Module
 * @description A module that binds Hydra and ExpressJS. This simplifies building API enabled microservices.
 * @author Carlos Justiniano
 */
'use strict';

const debug = require('debug')('hydra-express');
const listEndpoints = require('./routes-helper');
const Promise = require('bluebird');
Promise.config({
  // Enables all warnings except forgotten return statements.
  warnings: {
    wForgottenReturn: false
  }
});

Promise.series = (iterable, action) => {
  return Promise.mapSeries(
    iterable.map(action),
    (value, index, _length) => value || iterable[index].name || null
  );
};

const hydra = require('@gameleap/hydra');
const Utils = hydra.getUtilsHelper();
const ServerResponse = hydra.getServerResponseHelper();
let serverResponse = new ServerResponse();

const bodyParser = require('body-parser');
const express = require('express');
const helmet = require('helmet');
const http = require('http');
const moment = require('moment');
const path = require('path');
const responseTime = require('response-time');

let app = express();

let defaultLogger = () => {
  let dump = (level, obj) => {
    console.log(level.toUpperCase());
    console.dir(obj, {
      colors: true,
      depth: null
    });
  };
  return {
    fatal: (obj) => dump('FATAL', obj),
    error: (obj) => dump('ERROR', obj),
    debug: (obj) => dump('DEBUG', obj),
    info: (obj) => dump('INFO', obj)
  };
};

/**
 * @name HydraExpress
 * @summary HydraExpress class
 */
class HydraExpress {
  /**
   * @name constructor
   * @return {undefined}
   */
  constructor() {
    this.config = null;
    this.server = null;
    this.testMode = false;
    this.appLogger = defaultLogger();
    this.registeredPlugins = [];
    this._getExpressRoutes = this._getExpressRoutes.bind(this);
  }

  /**
   * @name use
   * @summary Adds plugins to Hydra
   * @param {...object} plugins - plugins to register
   * @return {object} - Promise which will resolve when all plugins are registered
   */
  use(...plugins) {
    return Promise.series(plugins, (plugin) => this._registerPlugin(plugin));
  }

  /**
   * @name _registerPlugin
   * @summary Registers a plugin with Hydra
   * @param {object} plugin - HydraPlugin to use
   * @return {object} Promise or value
   */
  _registerPlugin(plugin) {
    this.registeredPlugins.push(plugin);
    return plugin.setHydraExpress(this);
  }

  /**
   * @name validateConfig
   * @summary Validates a configuration object to ensure all required fields are present
   * @private
   * @param {object} config - config object
   * @return {array} array - of missing fields or empty array
   */
  validateConfig(config) {
    let missingFields = [];
    let requiredMembers = {
      'hydra': {
        'serviceName': '',
        'serviceDescription': ''
      },
      'registerRoutesCallback': ''
    };

    Object.keys(requiredMembers).forEach((key) => {
      let type = typeof requiredMembers[key];
      if (type === 'string') {
        if (config[key] === undefined) {
          missingFields.push(key);
        }
      } else if (type === 'object') {
        if (config[key] === undefined) {
          missingFields.push(key);
        } else {
          Object.keys(requiredMembers[key]).forEach((key2) => {
            if (config[key][key2] === undefined) {
              missingFields.push(`${key}.${key2}`);
            }
          });
        }
      }
    });

    return missingFields;
  }

  /**
   * @name _init
   * @summary Initialize HydraExpress using a configuration object.
   * @private
   * @throws Throws an Error() if config is found to be invalid
   * @param {object} config - configuration as described in the projects readme
   * @return {object} Promise - promise resolving to hydraexpress ready or failure
   */
  _init(config) {
    return new Promise((resolve, reject) => {
      if (!config.hydra) {
        reject(new Error('Config missing hydra block'));
        return;
      }

      if (!config.hydra.redis) {
        reject(new Error('Config missing redis block'));
        return;
      }

      config.hydra.serviceIP = config.hydra.serviceIP || '';
      config.hydra.servicePort = config.hydra.servicePort || 0;
      config.hydra.serviceType = config.hydra.serviceType || '';

      let missingFields = this.validateConfig(config);
      if (missingFields.length) {
        reject(new Error(`Config missing fields: ${missingFields.join(' ')}`));
      } else if (!config.registerRoutesCallback) {
        reject(new Error('Config missing registerRoutesCallback parameter'));
      } else {
        config.hydra.serviceVersion = config.version;
        this.config = config;
        this.config.environment = this.config.environment || 'development';
        this.registerRoutesCallback = config.registerRoutesCallback;
        this.registerMiddlewareCallback = config.registerMiddlewareCallback;
        /**
         * Start the log event Listener as soon as possible in order to
         * receive redis initialization errors.
         *
         * @param {string} entry - log entry
         */
        hydra.on('log', (entry) => {
          if (entry.msg) {
            if (entry.msg.indexOf('Unavailable hydra-router instances') > -1) {
              // surpress this message since use of hydra-router is optional
              return;
            }
            entry.message = entry.msg;
          }
          this.log(entry.type, entry.message);
        });

        return this.start(resolve, reject);
      }
    });
  }

  /**
   * @name _shutdown
   * @summary Shutdown hydra-express safely.
   * @return {object} Promise - promise resolving to hydraexpress ready or failure
   */
  _shutdown() {
    return new Promise((resolve, reject) => {
      if (!this.server) {
        this.log("error", "Server was not up, nothing to shut down.");

        hydra
          .shutdown()
          .then((result) => {
            resolve(result);
          })
          .catch((err) => {
            reject(err);
          });
      } else {
        this.server.close(() => {
          this.log("error", "Server is shutting down.");
          hydra
            .shutdown()
            .then((result) => {
              resolve(result);
            })
            .catch((err) => {
              reject(err);
            });
        });
      }
    });
  }

  /**
   * @name getExpress
   * @summary Retrieve the ExpressJS object
   * @return {object} express - ExpressJS object
   */
  getExpress() {
    return express;
  }

  /**
   * @name getExpressApp
   * @summary Retrieve the ExpressJS app object
   * @return {object} app - express app object
   */
  getExpressApp() {
    return app;
  }

  /**
   * @name getHydra
   * @summary Retrieve the Hydra object
   * @private
   * @return {object} hydra - Hydra object
   */
  getHydra() {
    return hydra;
  }

  /**
   * @name getRuntimeConfig
   * @summary Retrieve loaded configuration object
   * @return {object} config - immutable object
   */
  getRuntimeConfig() {
    return Object.assign({}, this.config);
  }

  /**
   * @name log
   * @summary logs a message
   * @private
   * @param {string} type - type of message: 'info', 'start', 'error'
   * @param {string} message - message to log
   * @return {undefined}
   */
  log(type, message) {
    let msg = (typeof message === 'object') ? Utils.safeJSONStringify(message) : message;
    debug(`${type} ${msg}`);
    let suppressLogEmit = true;
    switch (type) {
      case 'fatal':
        this.appLogger.fatal({
          event: type,
          message: msg
        });
        hydra.sendToHealthLog('fatal', message, suppressLogEmit);
        break;
      case 'error':
        this.appLogger.error({
          event: type,
          message: msg
        });
        hydra.sendToHealthLog('fatal', message, suppressLogEmit);
        break;
      case 'debug':
        this.appLogger.debug({
          event: type,
          message: msg
        });
        break;
      default:
        this.appLogger.info({
          event: type,
          message: msg
        });
        break;
    }
  }

  /**
   * @name start
   * @summary Starts the HydraExpress server
   * @param {function} resolve - promise resolve
   * @param {function} _reject - promise reject
   * @private
   * @return {undefined}
   */
  start(resolve, _reject) {
    let serviceInfo;
    return hydra.init(this.config, this.testMode)
      .then((config) => {
        this.config = config;
        return Promise.series(this.registeredPlugins, (plugin) => plugin.setConfig(config));
      })
      .then(() => hydra.registerService())
      .then((_serviceInfo) => {
        serviceInfo = _serviceInfo;
        this.log('start', `${hydra.getServiceName()} (v.${hydra.getInstanceVersion()}) server listening on port ${this.config.hydra.servicePort}`);
        this.log('info', `Using environment: ${this.config.environment}`);
        this.initService();
        return Promise.series(this.registeredPlugins, (plugin) => plugin.onServiceReady());
      })
      .then(() => Promise.delay(2000))
      .then(() => resolve(serviceInfo))
      .catch((err) => {
        this.log('error', {
          err
        });
        process.emit('cleanup');
      });
  }

  /**
   * @name initService
   * @summary Initialize service
   * @private
   * @return {undefined}
   */
  initService() {
    app.use(responseTime());

    /**
     * @description Stamp every request with the process id that handled it.
     * @param {object} req - express request object
     * @param {object} res - express response object
     * @param {function} next - express next handler
     */
    app.use((req, res, next) => {
      res.set('x-process-id', process.pid);
      next();
    });

    /**
     * @description Fatal error handler.
     * @param {function} err - error handler function
     */
    let doOnce = 1;
    process.on('cleanup', () => {
      if (doOnce === 1) {
        doOnce += 1;
        setTimeout(() => {
          this._shutdown()
            .then(() => {
              process.exit(1);
            });
        }, 1000);
      }
    });
    process.on('unhandledRejection', (reason, _p) => {
      this.log('fatal', Utils.safeJSONStringify(reason));
      console.log(reason); // necessary for full stack trace
      process.emit('cleanup');
    });
    process.on('uncaughtException', (err) => {
      let stack = err.stack;
      delete err.__cached_trace__;
      delete err.__previous__;
      delete err.domain;
      this.log('fatal', Utils.safeJSONStringify({
        event: 'error',
        error: err.name,
        stack: stack
      }));
      process.emit('cleanup');
    });
    process.on('SIGTERM', () => {
      this.log('fatal', 'Received SIGTERM');
      process.emit('cleanup');
    });
    process.on('SIGINT', () => {
      this.log('fatal', 'Received SIGINT');
      process.emit('cleanup');
    });

    /**
     * Security.
     */
    const ninetyDaysInMilliseconds = moment.duration(90, 'days').asMilliseconds();
    app.use(helmet());
    app.use(helmet.hidePoweredBy({
      setTo: `${hydra.getServiceName()}/${hydra.getInstanceVersion()}`
    }));
    app.use(helmet.hsts({
      maxAge: ninetyDaysInMilliseconds
    }));

    if (this.config.bodyParser) {
      let bodyParserConfig = Object.assign({
        json: {},
        urlencoded: {
          extended: false
        }
      }, this.config.bodyParser);
      app.use(bodyParser.json(bodyParserConfig.json));
      app.use(bodyParser.urlencoded(bodyParserConfig.urlencoded));
    } else {
      app.use(bodyParser.json());
      app.use(bodyParser.urlencoded({
        extended: false
      }));
    }

    this.registerMiddlewareCallback && this.registerMiddlewareCallback();

    this.config.appPath = path.join('./', 'public');
    app.use('/', express.static(this.config.appPath));

    app.set('port', this.config.servicePort);

    this.server = http.createServer(app);

    /**
     * @param {object} error - error object
     * @description on handler for errors.
     */
    this.server.on('error', (error) => {
      if (error.syscall !== 'listen') {
        throw error;
      }

      let bind = (typeof port === 'string') ? `Pipe ${this.config.hydra.servicePort}` : `Port ${this.config.hydra.servicePort}`;
      switch (error.code) {
        case 'EACCES':
          this.log('error', `${bind} requires elevated privileges`);
          process.exit(1);
          break;
        case 'EADDRINUSE':
          this.log('error', `${bind} is already in use`);
          process.exit(1);
          break;
        default:
          throw error;
      }
    });

    /**
     * On SIGTERM perform graceful shutdown.
     */
    process.on('SIGTERM', () => {
      this.log('error', `Process ${process.pid} recieved SIGTERM - attempting graceful shutdown`);
      this.server.close(() => {
        process.exit(0);
      });
    });

    /**
     * @description listen handler for server.
     */
    this.server.listen(this.config.hydra.servicePort, () => {
      this.registerRoutesCallback && this.registerRoutesCallback();

      app.use('/*', (req, res) => {
        res.sendFile(path.resolve(this.config.appPath + '/index.html'));
      });

      /**
       * Post middleware init. Make sure to do this last.
       */

      /**
       * @param {object} req - express request object
       * @param {object} res - express response object
       * @param {function} next - express next handler
       */
      app.use((req, res, next) => {
        let err = new Error('Not Found');
        err.status = ServerResponse.HTTP_NOT_FOUND;
        next(err);
      });

      /**
       * @param {object} err - express err object
       * @param {object} req - express request object
       * @param {object} res - express response object
       * @param {function} _next - express next handler
       */
      app.use((err, req, res, _next) => {
        let errCode = err.status || ServerResponse.HTTP_SERVER_ERROR;
        if (err.status !== ServerResponse.HTTP_NOT_FOUND) {
          this.appLogger.fatal({
            event: 'error',
            error: err.name,
            stack: err.stack
          });
        }
        res.status(errCode).json({
          code: errCode
        });
      });
    });
  }

  /**
   * @name _registerRoutes
   * @summary Register API routes.
   * @private
   * @param {object} routes - object with key/value pairs of routeBase: express api object
   * @return {undefined}
   */
  _registerRoutes(routesMap) {
    let allRoutesList = [];
    let allRoutesSecurityMap = {};

    Object.keys(routesMap).forEach((routePath) => {
      const {
        routes,
        routesSecurityMap
      } = this._getExpressRoutes(routePath, routesMap[routePath].stack);

      allRoutesList = allRoutesList.concat(routes);
      allRoutesSecurityMap = {
        ...allRoutesSecurityMap,
        ...routesSecurityMap
      };

      app.use(routePath, routesMap[routePath]);
    });

    hydra.registerRoutes(allRoutesList);
    // register router security details
    hydra.registerRoutesSecurityMap(allRoutesSecurityMap);
  }

  /**
   * Recursively collects routes from express routers.
   * Works if a router is mounted as a child to another router.
   * @param {string} rootPath
   * @param {[object]} routerStack
   * @param {array} routes
   * @param {object} routesSecurityMap
   */
  _getExpressRoutes(rootPath, routerStack, routes = [], routesSecurityMap = {}) {
    const endpoints = listEndpoints({stack: routerStack});

    endpoints.forEach(endpoint => {
      endpoint.methods.forEach(method => {
        method = method.toLowerCase();
        let fullRoute = `[${method}]${rootPath}${endpoint.path}`;
        routes.push(fullRoute);
        routesSecurityMap[fullRoute] = endpoint.isSecured;
      });
    });

    return {
      routes,
      routesSecurityMap
    };
  }

  /**
   * @name sendResponse
   * @summary Send a server response to caller.
   * @param {number} httpCode - HTTP response code
   * @param {object} res - Node HTTP response object
   * @param {object} data - An object to send
   * @return {undefined}
   */
  _sendResponse(httpCode, res, data) {
    serverResponse.sendResponse(httpCode, res, data);
  }

}

/* ************************************************************************************************ */
/* ************************************************************************************************ */
/* ************************************************************************************************ */
/* ************************************************************************************************ */
/* ************************************************************************************************ */
/* ************************************************************************************************ */
/* ************************************************************************************************ */
/* ************************************************************************************************ */
/* ************************************************************************************************ */

/**
 * @name IHydraExpress
 * @summary Interface to a HydraExpress class
 */
class IHydraExpress extends HydraExpress {
  /**
   * @name constructor
   * @return {undefined}
   */
  constructor() {
    super();
  }

  /**
   * @name init
   * @summary Initializes the HydraExpress module
   * @param {object} config - application configuration object
   * @param {string} version - version of application
   * @param {function} registerRoutesCallback - callback function to register routes
   * @param {function} registerMiddlewareCallback - callback function to register middleware
   * @return {object} Promise - promise resolving to hydraexpress ready or failure
   */
  init(config, version, registerRoutesCallback, registerMiddlewareCallback) {
    if (typeof config === 'string') {
      const configHelper = hydra.getConfigHelper();
      return configHelper.init(config)
        .then(() => {
          return this.init(configHelper.getObject(), version, registerRoutesCallback, registerMiddlewareCallback);
        })
        .catch((_err) => {
          throw new Error(`Unable to load config from ${config}`);
        });
    }

    let inner = {};
    if (typeof version === 'function') {
      registerMiddlewareCallback = registerRoutesCallback;
      registerRoutesCallback = version;
      // inner.version = config.version || require(`${__dirname}/package.json`).version;
    } else if (version) {
      inner.version = version;
    }

    if (registerRoutesCallback) {
      inner.registerRoutesCallback = registerRoutesCallback;
    }
    if (registerMiddlewareCallback) {
      inner.registerMiddlewareCallback = registerMiddlewareCallback;
    }
    if (config.testMode === true) {
      this.testMode = true;
    }
    return super._init(Object.assign({}, config, inner));
  }

  /**
   * @name shutdown
   * @summary Shutdown hydra-express safely.
   * @return {object} Promise - promise resolving to hydraexpress ready or failure
   */
  shutdown() {
    return super._shutdown();
  }

  /**
   * @name getExpress
   * @summary Retrieve the underlying ExpressJS object
   * @return {object} express - expressjs object
   */
  getExpress() {
    return super.getExpress();
  }

  /**
   * @name getHydra
   * @summary Retrieve the underlying Hydra object
   * @return {object} hydra - hydra object
   */
  getHydra() {
    return super.getHydra();
  }

  /**
   * @name getRuntimeConfig
   * @summary Retrieve loaded configuration object
   * @return {object} config - immutable object
   */
  getRuntimeConfig() {
    return super.getRuntimeConfig();
  }

  /**
   * @name log
   * @summary Logger. Use to log messages
   * @param {string} type - type of message: 'fatal', 'error', 'debug', 'info'
   * @param {string} str - string message to log
   * @return {undefined}
   */
  log(type, str) {
    super.log(type, str);
  }

  /**
   * @name registerRoutes
   * @summary Register API routes.
   * @param {string} routeBaseUrl - route base url, ex: /v1/offers
   * @param {object} api - express api object
   * @return {undefined}
   */
  registerRoutes(routeBaseUrl, api) {
    super._registerRoutes(routeBaseUrl, api);
  }

  /**
   * @name sendResponse
   * @summary Send a server response to caller.
   * @param {number} httpCode - HTTP response code
   * @param {object} res - Node HTTP response object
   * @param {object} data - An object to send
   * @return {undefined}
   */
  sendResponse(httpCode, res, data) {
    super._sendResponse(httpCode, res, data);
  }

}

module.exports = new IHydraExpress;