nav tabs on admin dashboard

node_modules/http-proxy-middleware/lib/config-factory.js

@@ -1,54 +1,55 @@
-var _      = require('lodash');
-var url    = require('url');
-var logger = require('./logger').getInstance();
+var _ = require('lodash')
+var url = require('url')
+var ERRORS = require('./errors')
+var logger = require('./logger').getInstance()
 
 module.exports = {
-    createConfig: createConfig
-};
+  createConfig: createConfig
+}
 
 function createConfig(context, opts) {
-    // structure of config object to be returned
-    var config = {
-        context: undefined,
-        options: {}
-    };
+  // structure of config object to be returned
+  var config = {
+    context: undefined,
+    options: {}
+  }
+
+  // app.use('/api', proxy({target:'http://localhost:9000'}));
+  if (isContextless(context, opts)) {
+    config.context = '/'
+    config.options = _.assign(config.options, context)
 
-    // app.use('/api', proxy({target:'http://localhost:9000'}));
-    if (isContextless(context, opts)) {
-        config.context = '/';
-        config.options = _.assign(config.options, context);
-    }
     // app.use('/api', proxy('http://localhost:9000'));
     // app.use(proxy('http://localhost:9000/api'));
-    else if (isStringShortHand(context)) {
-        var oUrl   = url.parse(context);
-        var target = [oUrl.protocol, '//', oUrl.host].join('');
+  } else if (isStringShortHand(context)) {
+    var oUrl = url.parse(context)
+    var target = [oUrl.protocol, '//', oUrl.host].join('')
 
-        config.context = oUrl.pathname || '/';
-        config.options = _.assign(config.options, {target: target}, opts);
+    config.context = oUrl.pathname || '/'
+    config.options = _.assign(config.options, { target: target }, opts)
 
-        if (oUrl.protocol === 'ws:' || oUrl.protocol === 'wss:') {
-            config.options.ws = true;
-        }
+    if (oUrl.protocol === 'ws:' || oUrl.protocol === 'wss:') {
+      config.options.ws = true
+    }
     // app.use('/api', proxy({target:'http://localhost:9000'}));
-    } else {
-        config.context = context;
-        config.options = _.assign(config.options, opts);
-    }
+  } else {
+    config.context = context
+    config.options = _.assign(config.options, opts)
+  }
 
-    configureLogger(config.options);
+  configureLogger(config.options)
 
-    if (!config.options.target) {
-        throw new Error('[HPM] Missing "target" option. Example: {target: "http://www.example.org"}');
-    }
+  if (!config.options.target) {
+    throw new Error(ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING)
+  }
 
-    // Legacy option.proxyHost
-    config.options = mapLegacyProxyHostOption(config.options);
+  // Legacy option.proxyHost
+  config.options = mapLegacyProxyHostOption(config.options)
 
-    // Legacy option.proxyTable > option.router
-    config.options = mapLegacyProxyTableOption(config.options);
+  // Legacy option.proxyTable > option.router
+  config.options = mapLegacyProxyTableOption(config.options)
 
-    return config;
+  return config
 }
 
 /**
@@ -63,9 +64,9 @@ function createConfig(context, opts) {
  * @return {Boolean}         [description]
  */
 function isStringShortHand(context) {
-    if (_.isString(context)) {
-        return (url.parse(context).host) ? true : false;
-    }
+  if (_.isString(context)) {
+    return !!url.parse(context).host
+  }
 }
 
 /**
@@ -80,47 +81,49 @@ function isStringShortHand(context) {
  * @return {Boolean}         [description]
  */
 function isContextless(context, opts) {
-    return (_.isPlainObject(context) && _.isEmpty(opts));
+  return _.isPlainObject(context) && _.isEmpty(opts)
 }
 
 function mapLegacyProxyHostOption(options) {
-    // set options.headers.host when option.proxyHost is provided
-    if (options.proxyHost) {
-        logger.warn('*************************************');
-        logger.warn('[HPM] Deprecated "option.proxyHost"');
-        logger.warn('      Use "option.changeOrigin" or "option.headers.host" instead');
-        logger.warn('      "option.proxyHost" will be removed in future release.');
-        logger.warn('*************************************');
+  // set options.headers.host when option.proxyHost is provided
+  if (options.proxyHost) {
+    logger.warn('*************************************')
+    logger.warn('[HPM] Deprecated "option.proxyHost"')
+    logger.warn(
+      '      Use "option.changeOrigin" or "option.headers.host" instead'
+    )
+    logger.warn('      "option.proxyHost" will be removed in future release.')
+    logger.warn('*************************************')
 
-        options.headers = options.headers || {};
-        options.headers.host = options.proxyHost;
-    }
+    options.headers = options.headers || {}
+    options.headers.host = options.proxyHost
+  }
 
-    return options;
+  return options
 }
 
 // Warn deprecated proxyTable api usage
 function mapLegacyProxyTableOption(options) {
-    if (options.proxyTable) {
-        logger.warn('*************************************');
-        logger.warn('[HPM] Deprecated "option.proxyTable"');
-        logger.warn('      Use "option.router" instead');
-        logger.warn('      "option.proxyTable" will be removed in future release.');
-        logger.warn('*************************************');
+  if (options.proxyTable) {
+    logger.warn('*************************************')
+    logger.warn('[HPM] Deprecated "option.proxyTable"')
+    logger.warn('      Use "option.router" instead')
+    logger.warn('      "option.proxyTable" will be removed in future release.')
+    logger.warn('*************************************')
 
-        options.router = _.clone(options.proxyTable);
-        _.omit(options, 'proxyTable');
-    }
+    options.router = _.clone(options.proxyTable)
+    _.omit(options, 'proxyTable')
+  }
 
-    return options;
+  return options
 }
 
 function configureLogger(options) {
-    if (options.logLevel) {
-        logger.setLevel(options.logLevel);
-    }
+  if (options.logLevel) {
+    logger.setLevel(options.logLevel)
+  }
 
-    if (options.logProvider) {
-        logger.setProvider(options.logProvider);
-    }
+  if (options.logProvider) {
+    logger.setProvider(options.logProvider)
+  }
 }

node_modules/http-proxy-middleware/lib/context-matcher.js

@@ -1,43 +1,43 @@
-var _ = require('lodash');
-var url = require('url');
-var isGlob = require('is-glob');
-var micromatch = require('micromatch');
+var _ = require('lodash')
+var url = require('url')
+var isGlob = require('is-glob')
+var micromatch = require('micromatch')
+var ERRORS = require('./errors')
 
 module.exports = {
-    match: matchContext
-};
+  match: matchContext
+}
 
 function matchContext(context, uri, req) {
+  // single path
+  if (isStringPath(context)) {
+    return matchSingleStringPath(context, uri)
+  }
 
-    // single path
-    if (isStringPath(context)) {
-        return matchSingleStringPath(context, uri);
+  // single glob path
+  if (isGlobPath(context)) {
+    return matchSingleGlobPath(context, uri)
+  }
+
+  // multi path
+  if (Array.isArray(context)) {
+    if (context.every(isStringPath)) {
+      return matchMultiPath(context, uri)
+    }
+    if (context.every(isGlobPath)) {
+      return matchMultiGlobPath(context, uri)
     }
 
-    // single glob path
-    if (isGlobPath(context)) {
-        return matchSingleGlobPath(context, uri);
-    }
+    throw new Error(ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY)
+  }
 
-    // multi path
-    if (Array.isArray(context)) {
-        if (context.every(isStringPath)) {
-            return matchMultiPath(context, uri);
-        }
-        if (context.every(isGlobPath)) {
-            return matchMultiGlobPath(context, uri);
-        }
+  // custom matching
+  if (_.isFunction(context)) {
+    var pathname = getUrlPathName(uri)
+    return context(pathname, req)
+  }
 
-        throw new Error('[HPM] Invalid context. Expecting something like: ["/api", "/ajax"] or ["/api/**", "!**.html"]');
-    }
-
-    // custom matching
-    if (_.isFunction(context)) {
-        var pathname = getUrlPathName(uri);
-        return context(pathname, req);
-    }
-
-    throw new Error('[HPM] Invalid context. Expecting something like: "/api" or ["/api", "/ajax"]');
+  throw new Error(ERRORS.ERR_CONTEXT_MATCHER_GENERIC)
 }
 
 /**
@@ -46,33 +46,33 @@ function matchContext(context, uri, req) {
  * @return {Boolean}
  */
 function matchSingleStringPath(context, uri) {
-    var pathname = getUrlPathName(uri);
-    return pathname.indexOf(context) === 0;
+  var pathname = getUrlPathName(uri)
+  return pathname.indexOf(context) === 0
 }
 
 function matchSingleGlobPath(pattern, uri) {
-    var pathname = getUrlPathName(uri);
-    var matches = micromatch(pathname, pattern);
-    return matches && (matches.length > 0);
+  var pathname = getUrlPathName(uri)
+  var matches = micromatch(pathname, pattern)
+  return matches && matches.length > 0
 }
 
 function matchMultiGlobPath(patternList, uri) {
-    return matchSingleGlobPath(patternList, uri);
+  return matchSingleGlobPath(patternList, uri)
 }
 
 /**
- * @param  {String} context ['/api', '/ajax']
+ * @param  {String} contextList ['/api', '/ajax']
  * @param  {String} uri     'http://example.org/api/b/c/d.html'
  * @return {Boolean}
  */
 function matchMultiPath(contextList, uri) {
-    for (var i = 0; i < contextList.length; i++) {
-        var context = contextList[i];
-        if (matchSingleStringPath(context, uri)) {
-            return true;
-        }
+  for (var i = 0; i < contextList.length; i++) {
+    var context = contextList[i]
+    if (matchSingleStringPath(context, uri)) {
+      return true
     }
-    return false;
+  }
+  return false
 }
 
 /**
@@ -82,13 +82,13 @@ function matchMultiPath(contextList, uri) {
  * @return {String}     RFC 3986 path
  */
 function getUrlPathName(uri) {
-    return uri && url.parse(uri).pathname;
+  return uri && url.parse(uri).pathname
 }
 
 function isStringPath(context) {
-    return _.isString(context) && !isGlob(context);
+  return _.isString(context) && !isGlob(context)
 }
 
 function isGlobPath(context) {
-    return isGlob(context);
+  return isGlob(context)
 }

node_modules/http-proxy-middleware/lib/handlers.js

@@ -1,74 +1,82 @@
-var _      = require('lodash');
-var logger = require('./logger').getInstance();
+var _ = require('lodash')
+var logger = require('./logger').getInstance()
 
 module.exports = {
-    init: init,
-    getHandlers: getProxyEventHandlers
-};
+  init: init,
+  getHandlers: getProxyEventHandlers
+}
 
 function init(proxy, opts) {
-    var handlers = getProxyEventHandlers(opts);
+  var handlers = getProxyEventHandlers(opts)
 
-    _.forIn(handlers, function(handler, eventName) {
-        proxy.on(eventName, handlers[eventName]);
-    });
+  _.forIn(handlers, function(handler, eventName) {
+    proxy.on(eventName, handlers[eventName])
+  })
 
-    logger.debug('[HPM] Subscribed to http-proxy events: ', _.keys(handlers));
+  logger.debug('[HPM] Subscribed to http-proxy events: ', _.keys(handlers))
 }
 
 function getProxyEventHandlers(opts) {
-    // https://github.com/nodejitsu/node-http-proxy#listening-for-proxy-events
-    var proxyEvents = ['error', 'proxyReq', 'proxyReqWs', 'proxyRes', 'open', 'close'];
-    var handlers = {};
+  // https://github.com/nodejitsu/node-http-proxy#listening-for-proxy-events
+  var proxyEvents = [
+    'error',
+    'proxyReq',
+    'proxyReqWs',
+    'proxyRes',
+    'open',
+    'close'
+  ]
+  var handlers = {}
 
-    _.forEach(proxyEvents, function(event) {
-        // all handlers for the http-proxy events are prefixed with 'on'.
-        // loop through options and try to find these handlers
-        // and add them to the handlers object for subscription in init().
-        var eventName = _.camelCase('on ' + event);
-        var fnHandler = _.get(opts, eventName);
+  _.forEach(proxyEvents, function(event) {
+    // all handlers for the http-proxy events are prefixed with 'on'.
+    // loop through options and try to find these handlers
+    // and add them to the handlers object for subscription in init().
+    var eventName = _.camelCase('on ' + event)
+    var fnHandler = _.get(opts, eventName)
 
-        if (_.isFunction(fnHandler)) {
-            handlers[event] = fnHandler;
-        }
-    });
-
-    // add default error handler in absence of error handler
-    if (!_.isFunction(handlers.error)) {
-        handlers.error = defaultErrorHandler;
+    if (_.isFunction(fnHandler)) {
+      handlers[event] = fnHandler
     }
+  })
 
-    // add default close handler in absence of close handler
-    if (!_.isFunction(handlers.close)) {
-        handlers.close = logClose;
-    }
+  // add default error handler in absence of error handler
+  if (!_.isFunction(handlers.error)) {
+    handlers.error = defaultErrorHandler
+  }
 
-    return handlers;
-};
+  // add default close handler in absence of close handler
+  if (!_.isFunction(handlers.close)) {
+    handlers.close = logClose
+  }
+
+  return handlers
+}
 
 function defaultErrorHandler(err, req, res) {
-    var host = (req.headers && req.headers.host);
-    var code = err.code;
+  var host = req.headers && req.headers.host
+  var code = err.code
 
-    if (res.writeHead && !res.headersSent) {
-        if (/HPE_INVALID/.test(code)) {
-            res.writeHead(502);
-        } else {
-            switch(code) {
-                case 'ECONNRESET':
-                case 'ENOTFOUND':
-                case 'ECONNREFUSED':
-                    res.writeHead(504);
-                    break;
-                default: res.writeHead(500);
-            }
-        }
+  if (res.writeHead && !res.headersSent) {
+    if (/HPE_INVALID/.test(code)) {
+      res.writeHead(502)
+    } else {
+      switch (code) {
+        case 'ECONNRESET':
+        case 'ENOTFOUND':
+        case 'ECONNREFUSED':
+          res.writeHead(504)
+          break
+        default:
+          res.writeHead(500)
+      }
     }
+  }
 
-    res.end('Error occured while trying to proxy to: ' + host + req.url);
+  res.end('Error occured while trying to proxy to: ' + host + req.url)
 }
 
 function logClose(req, socket, head) {
-    // view disconnected websocket connections
-    logger.info('[HPM] Client disconnected');
+  // view disconnected websocket connections
+  logger.info('[HPM] Client disconnected')
 }

node_modules/http-proxy-middleware/lib/index.js

@@ -1,147 +1,182 @@
-var _              = require('lodash');
-var httpProxy      = require('http-proxy');
-var configFactory  = require('./config-factory');
-var handlers       = require('./handlers');
-var contextMatcher = require('./context-matcher');
-var PathRewriter   = require('./path-rewriter');
-var Router         = require('./router');
-var logger         = require('./logger').getInstance();
-var getArrow       = require('./logger').getArrow;
+var _ = require('lodash')
+var httpProxy = require('http-proxy')
+var configFactory = require('./config-factory')
+var handlers = require('./handlers')
+var contextMatcher = require('./context-matcher')
+var PathRewriter = require('./path-rewriter')
+var Router = require('./router')
+var logger = require('./logger').getInstance()
+var getArrow = require('./logger').getArrow
 
-module.exports = HttpProxyMiddleware;
+module.exports = HttpProxyMiddleware
 
 function HttpProxyMiddleware(context, opts) {
-    // https://github.com/chimurai/http-proxy-middleware/issues/57
-    var wsUpgradeDebounced  = _.debounce(handleUpgrade);
-    var wsInitialized       = false;
-    var config              = configFactory.createConfig(context, opts);
-    var proxyOptions        = config.options;
+  // https://github.com/chimurai/http-proxy-middleware/issues/57
+  var wsUpgradeDebounced = _.debounce(handleUpgrade)
+  var wsInitialized = false
+  var config = configFactory.createConfig(context, opts)
+  var proxyOptions = config.options
 
-    // create proxy
-    var proxy = httpProxy.createProxyServer({});
-    logger.info('[HPM] Proxy created:', config.context, ' -> ', proxyOptions.target);
+  // create proxy
+  var proxy = httpProxy.createProxyServer({})
+  logger.info(
+    '[HPM] Proxy created:',
+    config.context,
+    ' -> ',
+    proxyOptions.target
+  )
 
-    var pathRewriter = PathRewriter.create(proxyOptions.pathRewrite); // returns undefined when "pathRewrite" is not provided
+  var pathRewriter = PathRewriter.create(proxyOptions.pathRewrite) // returns undefined when "pathRewrite" is not provided
 
-    // attach handler to http-proxy events
-    handlers.init(proxy, proxyOptions);
+  // attach handler to http-proxy events
+  handlers.init(proxy, proxyOptions)
 
-    // log errors for debug purpose
-    proxy.on('error', logError);
+  // log errors for debug purpose
+  proxy.on('error', logError)
 
-    // https://github.com/chimurai/http-proxy-middleware/issues/19
-    // expose function to upgrade externally
-    middleware.upgrade = wsUpgradeDebounced;
+  // https://github.com/chimurai/http-proxy-middleware/issues/19
+  // expose function to upgrade externally
+  middleware.upgrade = wsUpgradeDebounced
 
-    return middleware;
+  return middleware
 
-    function middleware(req, res, next) {
-        if (shouldProxy(config.context, req)) {
-            var activeProxyOptions = prepareProxyRequest(req);
-            proxy.web(req, res, activeProxyOptions);
-        } else {
-            next();
-        }
-
-        if (proxyOptions.ws === true) {
-            // use initial request to access the server object to subscribe to http upgrade event
-            catchUpgradeRequest(req.connection.server);
-        }
+  function middleware(req, res, next) {
+    if (shouldProxy(config.context, req)) {
+      var activeProxyOptions = prepareProxyRequest(req)
+      proxy.web(req, res, activeProxyOptions)
+    } else {
+      next()
     }
 
-    function catchUpgradeRequest(server) {
-        // subscribe once; don't subscribe on every request...
-        // https://github.com/chimurai/http-proxy-middleware/issues/113
-        if (!wsInitialized) {
-            server.on('upgrade', wsUpgradeDebounced);
-            wsInitialized = true;
-        }
+    if (proxyOptions.ws === true) {
+      // use initial request to access the server object to subscribe to http upgrade event
+      catchUpgradeRequest(req.connection.server)
+    }
+  }
+
+  function catchUpgradeRequest(server) {
+    // subscribe once; don't subscribe on every request...
+    // https://github.com/chimurai/http-proxy-middleware/issues/113
+    if (!wsInitialized) {
+      server.on('upgrade', wsUpgradeDebounced)
+      wsInitialized = true
+    }
+  }
+
+  function handleUpgrade(req, socket, head) {
+    // set to initialized when used externally
+    wsInitialized = true
+
+    if (shouldProxy(config.context, req)) {
+      var activeProxyOptions = prepareProxyRequest(req)
+      proxy.ws(req, socket, head, activeProxyOptions)
+      logger.info('[HPM] Upgrading to WebSocket')
+    }
+  }
+
+  /**
+   * Determine whether request should be proxied.
+   *
+   * @private
+   * @param  {String} context [description]
+   * @param  {Object} req     [description]
+   * @return {Boolean}
+   */
+  function shouldProxy(context, req) {
+    var path = req.originalUrl || req.url
+    return contextMatcher.match(context, path, req)
+  }
+
+  /**
+   * Apply option.router and option.pathRewrite
+   * Order matters:
+   *    Router uses original path for routing;
+   *    NOT the modified path, after it has been rewritten by pathRewrite
+   * @param {Object} req
+   * @return {Object} proxy options
+   */
+  function prepareProxyRequest(req) {
+    // https://github.com/chimurai/http-proxy-middleware/issues/17
+    // https://github.com/chimurai/http-proxy-middleware/issues/94
+    req.url = req.originalUrl || req.url
+
+    // store uri before it gets rewritten for logging
+    var originalPath = req.url
+    var newProxyOptions = _.assign({}, proxyOptions)
+
+    // Apply in order:
+    // 1. option.router
+    // 2. option.pathRewrite
+    __applyRouter(req, newProxyOptions)
+    __applyPathRewrite(req, pathRewriter)
+
+    // debug logging for both http(s) and websockets
+    if (proxyOptions.logLevel === 'debug') {
+      var arrow = getArrow(
+        originalPath,
+        req.url,
+        proxyOptions.target,
+        newProxyOptions.target
+      )
+      logger.debug(
+        '[HPM] %s %s %s %s',
+        req.method,
+        originalPath,
+        arrow,
+        newProxyOptions.target
+      )
     }
 
-    function handleUpgrade(req, socket, head) {
-        // set to initialized when used externally
-        wsInitialized = true;
+    return newProxyOptions
+  }
 
-        if (shouldProxy(config.context, req)) {
-            var activeProxyOptions = prepareProxyRequest(req);
-            proxy.ws(req, socket, head, activeProxyOptions);
-            logger.info('[HPM] Upgrading to WebSocket');
-        }
+  // Modify option.target when router present.
+  function __applyRouter(req, options) {
+    var newTarget
+
+    if (options.router) {
+      newTarget = Router.getTarget(req, options)
+
+      if (newTarget) {
+        logger.debug(
+          '[HPM] Router new target: %s -> "%s"',
+          options.target,
+          newTarget
+        )
+        options.target = newTarget
+      }
     }
+  }
 
-    /**
-     * Determine whether request should be proxied.
-     *
-     * @private
-     * @return {Boolean}
-     */
-    function shouldProxy(context, req) {
-        var path = (req.originalUrl || req.url);
-        return contextMatcher.match(context, path, req);
+  // rewrite path
+  function __applyPathRewrite(req, pathRewriter) {
+    if (pathRewriter) {
+      var path = pathRewriter(req.url, req)
+
+      if (typeof path === 'string') {
+        req.url = path
+      } else {
+        logger.info('[HPM] pathRewrite: No rewritten path found. (%s)', req.url)
+      }
     }
+  }
 
-    /**
-     * Apply option.router and option.pathRewrite
-     * Order matters:
-          Router uses original path for routing;
-          NOT the modified path, after it has been rewritten by pathRewrite
-     */
-    function prepareProxyRequest(req) {
-        // https://github.com/chimurai/http-proxy-middleware/issues/17
-        // https://github.com/chimurai/http-proxy-middleware/issues/94
-        req.url = (req.originalUrl || req.url);
+  function logError(err, req, res) {
+    var hostname =
+      (req.headers && req.headers.host) || (req.hostname || req.host) // (websocket) || (node0.10 || node 4/5)
+    var target = proxyOptions.target.host || proxyOptions.target
+    var errorMessage =
+      '[HPM] Error occurred while trying to proxy request %s from %s to %s (%s) (%s)'
+    var errReference =
+      'https://nodejs.org/api/errors.html#errors_common_system_errors' // link to Node Common Systems Errors page
 
-        // store uri before it gets rewritten for logging
-        var originalPath = req.url;
-        var newProxyOptions = _.assign({}, proxyOptions);
-
-        // Apply in order:
-        // 1. option.router
-        // 2. option.pathRewrite
-        __applyRouter(req, newProxyOptions);
-        __applyPathRewrite(req, pathRewriter);
-
-        // debug logging for both http(s) and websockets
-        if (proxyOptions.logLevel === 'debug') {
-            var arrow = getArrow(originalPath, req.url, proxyOptions.target, newProxyOptions.target);
-            logger.debug('[HPM] %s %s %s %s', req.method, originalPath, arrow, newProxyOptions.target);
-        }
-
-        return newProxyOptions;
-    }
-
-    // Modify option.target when router present.
-    function __applyRouter(req, options) {
-        var newTarget;
-
-        if (options.router) {
-            newTarget = Router.getTarget(req, options);
-
-            if (newTarget) {
-                logger.debug('[HPM] Router new target: %s -> "%s"', options.target, newTarget);
-                options.target = newTarget;
-            }
-        }
-    }
-
-    // rewrite path
-    function __applyPathRewrite(req, pathRewriter) {
-        if (pathRewriter) {
-            var path = pathRewriter(req.url, req);
-
-            if (typeof path === 'string') {
-                req.url =  path;
-            } else {
-                logger.info('[HPM] pathRewrite: No rewritten path found. (%s)', req.url);
-            }
-        }
-    }
-
-    function logError(err, req, res) {
-        var hostname = (req.headers && req.headers.host) || (req.hostname || req.host);     // (websocket) || (node0.10 || node 4/5)
-        var target = proxyOptions.target.host || proxyOptions.target;
-        var errReference = 'https://nodejs.org/api/errors.html#errors_common_system_errors'; // link to Node Common Systems Errors page
-
-        logger.error('[HPM] Error occurred while trying to proxy request %s from %s to %s (%s) (%s)', req.url, hostname, target, err.code, errReference);
-    }
-};
+    logger.error(
+      errorMessage,
+      req.url,
+      hostname,
+      target,
+      err.code || err,
+      errReference
+    )
+  }
+}

node_modules/http-proxy-middleware/lib/logger.js

@@ -1,144 +1,144 @@
-var util = require('util');
-var _ = require('lodash');
+var util = require('util')
+var _ = require('lodash')
 
-var loggerInstance;
+var loggerInstance
 
 var defaultProvider = {
-    log: console.log,
-    debug: console.log,    // use .log(); since console does not have .debug()
-    info: console.info,
-    warn: console.warn,
-    error: console.error
-};
+  log: console.log,
+  debug: console.log, // use .log(); since console does not have .debug()
+  info: console.info,
+  warn: console.warn,
+  error: console.error
+}
 
 // log level 'weight'
 var LEVELS = {
-    debug: 10,
-    info: 20,
-    warn: 30,
-    error: 50,
-    silent: 80
-};
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 50,
+  silent: 80
+}
 
 module.exports = {
-    // singleton
-    getInstance: function() {
-        if (!loggerInstance) {
-            loggerInstance = new Logger();
-        }
+  // singleton
+  getInstance: function() {
+    if (!loggerInstance) {
+      loggerInstance = new Logger()
+    }
 
-        return loggerInstance;
-    },
-    getArrow: getArrow
-};
+    return loggerInstance
+  },
+  getArrow: getArrow
+}
 
 function Logger() {
-    var logLevel;
-    var provider;
+  var logLevel
+  var provider
 
-    var api = {
-        log: log,
-        debug: debug,
-        info: info,
-        warn: warn,
-        error: error,
-        setLevel: function(v) {
-            if (isValidLevel(v)) {
-                logLevel = v;
-            }
-        },
-        setProvider: function(fn) {
-            if (fn && isValidProvider(fn)) {
-                provider = fn(defaultProvider);
-            }
-        }
-    };
+  var api = {
+    log: log,
+    debug: debug,
+    info: info,
+    warn: warn,
+    error: error,
+    setLevel: function(v) {
+      if (isValidLevel(v)) {
+        logLevel = v
+      }
+    },
+    setProvider: function(fn) {
+      if (fn && isValidProvider(fn)) {
+        provider = fn(defaultProvider)
+      }
+    }
+  }
 
-    init();
+  init()
 
-    return api;
+  return api
 
-    function init() {
-        api.setLevel('info');
-        api.setProvider(function() {
-            return defaultProvider;
-        });
+  function init() {
+    api.setLevel('info')
+    api.setProvider(function() {
+      return defaultProvider
+    })
+  }
+
+  // log will log messages, regardless of logLevels
+  function log() {
+    provider.log(_interpolate.apply(null, arguments))
+  }
+
+  function debug() {
+    if (_showLevel('debug')) {
+      provider.debug(_interpolate.apply(null, arguments))
+    }
+  }
+
+  function info() {
+    if (_showLevel('info')) {
+      provider.info(_interpolate.apply(null, arguments))
+    }
+  }
+
+  function warn() {
+    if (_showLevel('warn')) {
+      provider.warn(_interpolate.apply(null, arguments))
+    }
+  }
+
+  function error() {
+    if (_showLevel('error')) {
+      provider.error(_interpolate.apply(null, arguments))
+    }
+  }
+
+  /**
+   * Decide to log or not to log, based on the log levels 'weight'
+   * @param  {String}  showLevel [debug, info, warn, error, silent]
+   * @return {Boolean}
+   */
+  function _showLevel(showLevel) {
+    var result = false
+    var currentLogLevel = LEVELS[logLevel]
+
+    if (currentLogLevel && currentLogLevel <= LEVELS[showLevel]) {
+      result = true
     }
 
-    // log will log messages, regardless of logLevels
-    function log() {
-        provider.log(_interpolate.apply(null, arguments));
+    return result
+  }
+
+  // make sure logged messages and its data are return interpolated
+  // make it possible for additional log data, such date/time or custom prefix.
+  function _interpolate() {
+    var fn = _.spread(util.format)
+    var result = fn(_.slice(arguments))
+
+    return result
+  }
+
+  function isValidProvider(fnProvider) {
+    var result = true
+
+    if (fnProvider && !_.isFunction(fnProvider)) {
+      throw new Error('[HPM] Log provider config error. Expecting a function.')
     }
 
-    function debug() {
-        if (_showLevel('debug')) {
-            provider.debug(_interpolate.apply(null, arguments));
-        }
+    return result
+  }
+
+  function isValidLevel(levelName) {
+    var validLevels = _.keys(LEVELS)
+    var isValid = _.includes(validLevels, levelName)
+
+    if (!isValid) {
+      throw new Error('[HPM] Log level error. Invalid logLevel.')
     }
 
-    function info() {
-        if (_showLevel('info')) {
-            provider.info(_interpolate.apply(null, arguments));
-        }
-    }
-
-    function warn() {
-        if (_showLevel('warn')) {
-            provider.warn(_interpolate.apply(null, arguments));
-        }
-    }
-
-    function error() {
-        if (_showLevel('error')) {
-            provider.error(_interpolate.apply(null, arguments));
-        }
-    }
-
-    /**
-     * Decide to log or not to log, based on the log levels 'weight'
-     * @param  {String}  showLevel [debug, info, warn, error, silent]
-     * @return {Boolean}
-     */
-    function _showLevel(showLevel) {
-        var result = false;
-        var currentLogLevel = LEVELS[logLevel];
-
-        if (currentLogLevel && (currentLogLevel <= LEVELS[showLevel])) {
-            result = true;
-        }
-
-        return result;
-    }
-
-    // make sure logged messages and its data are return interpolated
-    // make it possible for additional log data, such date/time or custom prefix.
-    function _interpolate() {
-        var fn = _.spread(util.format);
-        var result = fn(_.slice(arguments));
-
-        return result;
-    }
-
-    function isValidProvider(fnProvider) {
-        var result = true;
-
-        if (fnProvider && !_.isFunction(fnProvider)) {
-            throw new Error('[HPM] Log provider config error. Expecting a function.');
-        }
-
-        return result;
-    }
-
-    function isValidLevel(levelName) {
-        var validLevels = _.keys(LEVELS);
-        var isValid = _.includes(validLevels, levelName);
-
-        if (!isValid) {
-            throw new Error('[HPM] Log level error. Invalid logLevel.');
-        }
-
-        return isValid;
-    }
+    return isValid
+  }
 }
 
 /**
@@ -146,13 +146,27 @@ function Logger() {
  * => router
  * ~> pathRewrite
  * ≈> router + pathRewrite
+ *
+ * @param  {String} originalPath
+ * @param  {String} newPath
+ * @param  {String} originalTarget
+ * @param  {String} newTarget
+ * @return {String}
  */
 function getArrow(originalPath, newPath, originalTarget, newTarget) {
-    var arrow = ['>'];
-    var isNewTarget = (originalTarget !== newTarget); // router
-    var isNewPath = (originalPath !== newPath); // pathRewrite
+  var arrow = ['>']
+  var isNewTarget = originalTarget !== newTarget // router
+  var isNewPath = originalPath !== newPath // pathRewrite
 
-    if (isNewPath && !isNewTarget) {arrow.unshift('~');} else if (!isNewPath && isNewTarget) {arrow.unshift('=');} else if (isNewPath && isNewTarget) {arrow.unshift('≈');} else {arrow.unshift('-');}
+  if (isNewPath && !isNewTarget) {
+    arrow.unshift('~')
+  } else if (!isNewPath && isNewTarget) {
+    arrow.unshift('=')
+  } else if (isNewPath && isNewTarget) {
+    arrow.unshift('≈')
+  } else {
+    arrow.unshift('-')
+  }
 
-    return arrow.join('');
+  return arrow.join('')
 }

node_modules/http-proxy-middleware/lib/path-rewriter.js

@@ -1,72 +1,79 @@
-var _      = require('lodash');
-var logger = require('./logger').getInstance();
+var _ = require('lodash')
+var logger = require('./logger').getInstance()
+var ERRORS = require('./errors')
 
 module.exports = {
-    create: createPathRewriter
-};
+  create: createPathRewriter
+}
 
 /**
  * Create rewrite function, to cache parsed rewrite rules.
  *
- * @returns {function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
+ * @param {Object} rewriteConfig
+ * @return {Function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
  */
 function createPathRewriter(rewriteConfig) {
-    var rulesCache;
+  var rulesCache
 
-    if (!isValidRewriteConfig(rewriteConfig)) {
-        return;
-    }
+  if (!isValidRewriteConfig(rewriteConfig)) {
+    return
+  }
 
-    if (_.isFunction(rewriteConfig)) {
-        var customRewriteFn = rewriteConfig;
-        return customRewriteFn;
-    } else {
-        rulesCache = parsePathRewriteRules(rewriteConfig);
-        return rewritePath;
-    }
+  if (_.isFunction(rewriteConfig)) {
+    var customRewriteFn = rewriteConfig
+    return customRewriteFn
+  } else {
+    rulesCache = parsePathRewriteRules(rewriteConfig)
+    return rewritePath
+  }
 
-    function rewritePath(path) {
-        var result = path;
+  function rewritePath(path) {
+    var result = path
 
-        _.forEach(rulesCache, function(rule) {
-            if (rule.regex.test(path)) {
-                result = result.replace(rule.regex, rule.value);
-                logger.debug('[HPM] Rewriting path from "%s" to "%s"', path, result);
-                return false;
-            }
-        });
+    _.forEach(rulesCache, function(rule) {
+      if (rule.regex.test(path)) {
+        result = result.replace(rule.regex, rule.value)
+        logger.debug('[HPM] Rewriting path from "%s" to "%s"', path, result)
+        return false
+      }
+    })
 
-        return result;
-    }
+    return result
+  }
 }
 
 function isValidRewriteConfig(rewriteConfig) {
-    if (_.isFunction(rewriteConfig)) {
-        return true;
-    } else if (!_.isEmpty(rewriteConfig) && _.isPlainObject(rewriteConfig)) {
-        return true;
-    } else if (_.isUndefined(rewriteConfig) ||
-               _.isNull(rewriteConfig) ||
-               _.isEqual(rewriteConfig, {})) {
-        return false;
-    } else {
-        throw new Error('[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function');
-    }
+  if (_.isFunction(rewriteConfig)) {
+    return true
+  } else if (!_.isEmpty(rewriteConfig) && _.isPlainObject(rewriteConfig)) {
+    return true
+  } else if (
+    _.isUndefined(rewriteConfig) ||
+    _.isNull(rewriteConfig) ||
+    _.isEqual(rewriteConfig, {})
+  ) {
+    return false
+  } else {
+    throw new Error(ERRORS.ERR_PATH_REWRITER_CONFIG)
+  }
 }
 
 function parsePathRewriteRules(rewriteConfig) {
-    var rules = [];
+  var rules = []
 
-    if (_.isPlainObject(rewriteConfig)) {
-        _.forIn(rewriteConfig, function(value, key) {
-            rules.push({
-                regex: new RegExp(key),
-                value: rewriteConfig[key]
-            });
-            logger.info('[HPM] Proxy rewrite rule created: "%s" ~> "%s"', key, rewriteConfig[key]);
-        });
-    }
+  if (_.isPlainObject(rewriteConfig)) {
+    _.forIn(rewriteConfig, function(value, key) {
+      rules.push({
+        regex: new RegExp(key),
+        value: rewriteConfig[key]
+      })
+      logger.info(
+        '[HPM] Proxy rewrite rule created: "%s" ~> "%s"',
+        key,
+        rewriteConfig[key]
+      )
+    })
+  }
 
-    return rules;
+  return rules
 }
-

node_modules/http-proxy-middleware/lib/router.js

@@ -1,53 +1,51 @@
-var _      = require('lodash');
-var logger = require('./logger.js').getInstance();
+var _ = require('lodash')
+var logger = require('./logger.js').getInstance()
 
 module.exports = {
-    getTarget: getTarget
-};
+  getTarget: getTarget
+}
 
 function getTarget(req, config) {
-    var newTarget;
-    var router = config.router;
+  var newTarget
+  var router = config.router
 
-    if (_.isPlainObject(router)) {
-        newTarget = getTargetFromProxyTable(req, router);
-    } else if (_.isFunction(router)) {
-        newTarget = router(req);
-    }
+  if (_.isPlainObject(router)) {
+    newTarget = getTargetFromProxyTable(req, router)
+  } else if (_.isFunction(router)) {
+    newTarget = router(req)
+  }
 
-    return newTarget;
+  return newTarget
 }
 
 function getTargetFromProxyTable(req, table) {
-    var result;
-    var host = req.headers.host;
-    var path = req.url;
+  var result
+  var host = req.headers.host
+  var path = req.url
 
-    var hostAndPath = host + path;
+  var hostAndPath = host + path
 
-    _.forIn(table, function(value, key) {
-        if (containsPath(key)) {
+  _.forIn(table, function(value, key) {
+    if (containsPath(key)) {
+      if (hostAndPath.indexOf(key) > -1) {
+        // match 'localhost:3000/api'
+        result = table[key]
+        logger.debug('[HPM] Router table match: "%s"', key)
+        return false
+      }
+    } else {
+      if (key === host) {
+        // match 'localhost:3000'
+        result = table[key]
+        logger.debug('[HPM] Router table match: "%s"', host)
+        return false
+      }
+    }
+  })
 
-            if (hostAndPath.indexOf(key) > -1) {    // match 'localhost:3000/api'
-                result = table[key];
-                logger.debug('[HPM] Router table match: "%s"', key);
-                return false;
-            }
-        } else {
-
-            if (key === host) {                     // match 'localhost:3000'
-                result = table[key];
-                logger.debug('[HPM] Router table match: "%s"', host);
-                return false;
-            }
-
-        }
-
-    });
-
-    return result;
+  return result
 }
 
 function containsPath(v) {
-    return v.indexOf('/') > -1;
+  return v.indexOf('/') > -1
 }