http-proxy-middleware 0.19.2 → 0.20.0

package/dist/http-proxy-middleware.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const httpProxy = require("http-proxy");
+const _ = require("lodash");
+const config_factory_1 = require("./config-factory");
+const contextMatcher = require("./context-matcher");
+const handlers = require("./handlers");
+const logger_1 = require("./logger");
+const PathRewriter = require("./path-rewriter");
+const Router = require("./router");
+class HttpProxyMiddleware {
+    constructor(context, opts) {
+        this.logger = logger_1.getInstance();
+        this.wsInternalSubscribed = false;
+        // https://github.com/Microsoft/TypeScript/wiki/'this'-in-TypeScript#red-flags-for-this
+        this.middleware = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            if (this.shouldProxy(this.config.context, req)) {
+                const activeProxyOptions = this.prepareProxyRequest(req);
+                this.proxy.web(req, res, activeProxyOptions);
+            }
+            else {
+                next();
+            }
+            if (this.proxyOptions.ws === true) {
+                // use initial request to access the server object to subscribe to http upgrade event
+                this.catchUpgradeRequest(req.connection.server);
+            }
+        });
+        this.catchUpgradeRequest = server => {
+            if (!this.wsInternalSubscribed) {
+                server.on('upgrade', this.handleUpgrade);
+                // prevent duplicate upgrade handling;
+                // in case external upgrade is also configured
+                this.wsInternalSubscribed = true;
+            }
+        };
+        this.handleUpgrade = (req, socket, head) => {
+            if (this.shouldProxy(this.config.context, req)) {
+                const activeProxyOptions = this.prepareProxyRequest(req);
+                this.proxy.ws(req, socket, head, activeProxyOptions);
+                this.logger.info('[HPM] Upgrading to WebSocket');
+            }
+        };
+        /**
+         * Determine whether request should be proxied.
+         *
+         * @private
+         * @param  {String} context [description]
+         * @param  {Object} req     [description]
+         * @return {Boolean}
+         */
+        this.shouldProxy = (context, req) => {
+            const 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
+         */
+        this.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
+            const originalPath = req.url;
+            const newProxyOptions = _.assign({}, this.proxyOptions);
+            // Apply in order:
+            // 1. option.router
+            // 2. option.pathRewrite
+            this.applyRouter(req, newProxyOptions);
+            this.applyPathRewrite(req, this.pathRewriter);
+            // debug logging for both http(s) and websockets
+            if (this.proxyOptions.logLevel === 'debug') {
+                const arrow = logger_1.getArrow(originalPath, req.url, this.proxyOptions.target, newProxyOptions.target);
+                this.logger.debug('[HPM] %s %s %s %s', req.method, originalPath, arrow, newProxyOptions.target);
+            }
+            return newProxyOptions;
+        };
+        // Modify option.target when router present.
+        this.applyRouter = (req, options) => {
+            let newTarget;
+            if (options.router) {
+                newTarget = Router.getTarget(req, options);
+                if (newTarget) {
+                    this.logger.debug('[HPM] Router new target: %s -> "%s"', options.target, newTarget);
+                    options.target = newTarget;
+                }
+            }
+        };
+        // rewrite path
+        this.applyPathRewrite = (req, pathRewriter) => {
+            if (pathRewriter) {
+                const path = pathRewriter(req.url, req);
+                if (typeof path === 'string') {
+                    req.url = path;
+                }
+                else {
+                    this.logger.info('[HPM] pathRewrite: No rewritten path found. (%s)', req.url);
+                }
+            }
+        };
+        this.logError = (err, req, res) => {
+            const hostname = (req.headers && req.headers.host) || (req.hostname || req.host); // (websocket) || (node0.10 || node 4/5)
+            const target = this.proxyOptions.target.host || this.proxyOptions.target;
+            const errorMessage = '[HPM] Error occurred while trying to proxy request %s from %s to %s (%s) (%s)';
+            const errReference = 'https://nodejs.org/api/errors.html#errors_common_system_errors'; // link to Node Common Systems Errors page
+            this.logger.error(errorMessage, req.url, hostname, target, err.code || err, errReference);
+        };
+        this.config = config_factory_1.createConfig(context, opts);
+        this.proxyOptions = this.config.options;
+        // create proxy
+        this.proxy = httpProxy.createProxyServer({});
+        this.logger.info(`[HPM] Proxy created: ${this.config.context}  -> ${this.proxyOptions.target}`);
+        this.pathRewriter = PathRewriter.createPathRewriter(this.proxyOptions.pathRewrite); // returns undefined when "pathRewrite" is not provided
+        // attach handler to http-proxy events
+        handlers.init(this.proxy, this.proxyOptions);
+        // log errors for debug purpose
+        this.proxy.on('error', this.logError);
+        // https://github.com/chimurai/http-proxy-middleware/issues/19
+        // expose function to upgrade externally
+        this.middleware.upgrade = (req, socket, head) => {
+            if (!this.wsInternalSubscribed) {
+                this.handleUpgrade(req, socket, head);
+            }
+        };
+    }
+}
+exports.HttpProxyMiddleware = HttpProxyMiddleware;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+const http_proxy_middleware_1 = require("./http-proxy-middleware");
+function proxy(context, opts) {
+    const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(context, opts);
+    return middleware;
+}
+module.exports = proxy;

package/dist/logger.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const util = require("util");
+let loggerInstance;
+const defaultProvider = {
+    // tslint:disable: no-console
+    log: console.log,
+    debug: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+};
+// log level 'weight'
+var LEVELS;
+(function (LEVELS) {
+    LEVELS[LEVELS["debug"] = 10] = "debug";
+    LEVELS[LEVELS["info"] = 20] = "info";
+    LEVELS[LEVELS["warn"] = 30] = "warn";
+    LEVELS[LEVELS["error"] = 50] = "error";
+    LEVELS[LEVELS["silent"] = 80] = "silent";
+})(LEVELS || (LEVELS = {}));
+function getInstance() {
+    if (!loggerInstance) {
+        loggerInstance = new Logger();
+    }
+    return loggerInstance;
+}
+exports.getInstance = getInstance;
+class Logger {
+    constructor() {
+        this.setLevel('info');
+        this.setProvider(() => defaultProvider);
+    }
+    // log will log messages, regardless of logLevels
+    log() {
+        this.provider.log(this._interpolate.apply(null, arguments));
+    }
+    debug() {
+        if (this._showLevel('debug')) {
+            this.provider.debug(this._interpolate.apply(null, arguments));
+        }
+    }
+    info() {
+        if (this._showLevel('info')) {
+            this.provider.info(this._interpolate.apply(null, arguments));
+        }
+    }
+    warn() {
+        if (this._showLevel('warn')) {
+            this.provider.warn(this._interpolate.apply(null, arguments));
+        }
+    }
+    error() {
+        if (this._showLevel('error')) {
+            this.provider.error(this._interpolate.apply(null, arguments));
+        }
+    }
+    setLevel(v) {
+        if (this.isValidLevel(v)) {
+            this.logLevel = v;
+        }
+    }
+    setProvider(fn) {
+        if (fn && this.isValidProvider(fn)) {
+            this.provider = fn(defaultProvider);
+        }
+    }
+    isValidProvider(fnProvider) {
+        const result = true;
+        if (fnProvider && !_.isFunction(fnProvider)) {
+            throw new Error('[HPM] Log provider config error. Expecting a function.');
+        }
+        return result;
+    }
+    isValidLevel(levelName) {
+        const validLevels = Object.keys(LEVELS);
+        const isValid = validLevels.includes(levelName);
+        if (!isValid) {
+            throw new Error('[HPM] Log level error. Invalid logLevel.');
+        }
+        return isValid;
+    }
+    /**
+     * Decide to log or not to log, based on the log levels 'weight'
+     * @param  {String}  showLevel [debug, info, warn, error, silent]
+     * @return {Boolean}
+     */
+    _showLevel(showLevel) {
+        let result = false;
+        const currentLogLevel = LEVELS[this.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.
+    _interpolate() {
+        const fn = _.spread(util.format);
+        const result = fn(_.slice(arguments));
+        return result;
+    }
+}
+/**
+ * -> normal proxy
+ * => router
+ * ~> pathRewrite
+ * ≈> router + pathRewrite
+ *
+ * @param  {String} originalPath
+ * @param  {String} newPath
+ * @param  {String} originalTarget
+ * @param  {String} newTarget
+ * @return {String}
+ */
+function getArrow(originalPath, newPath, originalTarget, newTarget) {
+    const arrow = ['>'];
+    const isNewTarget = originalTarget !== newTarget; // router
+    const isNewPath = originalPath !== newPath; // pathRewrite
+    if (isNewPath && !isNewTarget) {
+        arrow.unshift('~');
+    }
+    else if (!isNewPath && isNewTarget) {
+        arrow.unshift('=');
+    }
+    else if (isNewPath && isNewTarget) {
+        arrow.unshift('≈');
+    }
+    else {
+        arrow.unshift('-');
+    }
+    return arrow.join('');
+}
+exports.getArrow = getArrow;

package/dist/path-rewriter.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const errors_1 = require("./errors");
+const logger_1 = require("./logger");
+const logger = logger_1.getInstance();
+/**
+ * Create rewrite function, to cache parsed rewrite rules.
+ *
+ * @param {Object} rewriteConfig
+ * @return {Function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
+ */
+function createPathRewriter(rewriteConfig) {
+    let rulesCache;
+    if (!isValidRewriteConfig(rewriteConfig)) {
+        return;
+    }
+    if (_.isFunction(rewriteConfig)) {
+        const customRewriteFn = rewriteConfig;
+        return customRewriteFn;
+    }
+    else {
+        rulesCache = parsePathRewriteRules(rewriteConfig);
+        return rewritePath;
+    }
+    function rewritePath(path) {
+        let result = path;
+        _.forEach(rulesCache, 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;
+    }
+}
+exports.createPathRewriter = createPathRewriter;
+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(errors_1.ERRORS.ERR_PATH_REWRITER_CONFIG);
+    }
+}
+function parsePathRewriteRules(rewriteConfig) {
+    const rules = [];
+    if (_.isPlainObject(rewriteConfig)) {
+        _.forIn(rewriteConfig, (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;
+}

package/dist/router.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const logger_1 = require("./logger");
+const logger = logger_1.getInstance();
+function getTarget(req, config) {
+    let newTarget;
+    const router = config.router;
+    if (_.isPlainObject(router)) {
+        newTarget = getTargetFromProxyTable(req, router);
+    }
+    else if (_.isFunction(router)) {
+        newTarget = router(req);
+    }
+    return newTarget;
+}
+exports.getTarget = getTarget;
+function getTargetFromProxyTable(req, table) {
+    let result;
+    const host = req.headers.host;
+    const path = req.url;
+    const hostAndPath = host + path;
+    _.forIn(table, (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;
+            }
+        }
+    });
+    return result;
+}
+function containsPath(v) {
+    return v.indexOf('/') > -1;
+}

package/package.json

@@ -1,19 +1,26 @@
 {
   "name": "http-proxy-middleware",
-  "version": "0.19.2",
+  "version": "0.20.0",
   "description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
-  "main": "index.js",
+  "main": "dist/index.js",
   "files": [
-    "index.js",
-    "lib"
+    "dist"
   ],
   "scripts": {
-    "clean": "rm -rf coverage",
-    "lint": "prettier \"**/*.{js,md}\" --list-different",
-    "lint:fix": "prettier \"**/*.{js,md}\" --write",
-    "test": "mocha --recursive --colors --reporter spec",
-    "cover": "npm run clean && istanbul cover ./node_modules/mocha/bin/_mocha -- --recursive",
-    "coveralls": "istanbul cover ./node_modules/mocha/bin/_mocha --report lcovonly -- --recursive --reporter spec && istanbul-coveralls && npm run clean"
+    "clean": "rm -rf dist && rm -rf coverage",
+    "lint": "yarn lint:prettier && yarn lint:tslint",
+    "lint:prettier": "prettier --check \"**/*.{js,ts,md}\"",
+    "lint:tslint": "yarn tslint -c tslint.json '{lib,test}/**/*.ts'",
+    "lint:fix": "prettier --write \"**/*.{js,ts,md}\"",
+    "build": "tsc",
+    "pretest": "yarn build",
+    "test": "jest --runInBand",
+    "precover": "yarn clean && yarn build",
+    "cover": "jest --runInBand --coverage",
+    "precoveralls": "yarn clean && yarn build",
+    "coveralls": "jest --runInBand --coverage --coverageReporters=text-lcov | coveralls",
+    "postcoveralls": "yarn clean",
+    "prepare": "yarn clean && yarn build"
   },
   "repository": {
     "type": "git",
@@ -41,36 +48,41 @@
   },
   "homepage": "https://github.com/chimurai/http-proxy-middleware",
   "devDependencies": {
-    "@commitlint/cli": "^7.2.1",
-    "@commitlint/config-conventional": "^7.1.2",
-    "browser-sync": "^2.26.3",
-    "chai": "^4.2.0",
+    "@commitlint/cli": "^8.0.0",
+    "@commitlint/config-conventional": "^8.0.0",
+    "@types/express": "^4.17.0",
+    "@types/http-proxy": "^1.17.0",
+    "@types/is-glob": "^4.0.0",
+    "@types/jest": "^24.0.15",
+    "@types/lodash": "^4.14.136",
+    "@types/micromatch": "^3.1.0",
+    "@types/node": "^12.6.2",
+    "browser-sync": "^2.26.7",
     "connect": "^3.6.6",
-    "coveralls": "^3.0.2",
+    "coveralls": "^3.0.5",
     "express": "^4.16.4",
-    "husky": "^1.2.0",
-    "istanbul": "^0.4.5",
-    "istanbul-coveralls": "^1.0.3",
-    "mocha": "^5.2.0",
-    "mocha-lcov-reporter": "1.3.0",
-    "opn": "^5.4.0",
-    "precise-commits": "^1.0.2",
-    "prettier": "^1.15.2",
-    "ws": "^6.1.2"
+    "husky": "^3.0.0",
+    "jest": "^24.5.0",
+    "open": "^6.4.0",
+    "prettier": "^1.18.2",
+    "ts-jest": "^24.0.0",
+    "tslint": "^5.18.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^3.5.3",
+    "ws": "^7.1.0"
   },
   "dependencies": {
-    "http-proxy": "^1.18.1",
-    "is-glob": "^4.0.0",
-    "lodash": "^4.17.11",
-    "micromatch": "^3.1.10"
+    "http-proxy": "^1.17.0",
+    "is-glob": "^4.0.1",
+    "lodash": "^4.17.14",
+    "micromatch": "^4.0.2"
   },
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=8.0.0"
   },
   "husky": {
     "hooks": {
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
-      "pre-commit": "precise-commits"
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
     }
   },
   "commitlint": {

package/index.js

@@ -1,5 +0,0 @@
-var HPM = require('./lib')
-
-module.exports = function(context, opts) {
-  return new HPM(context, opts)
-}

package/lib/config-factory.js

@@ -1,129 +0,0 @@
-var _ = require('lodash')
-var url = require('url')
-var ERRORS = require('./errors')
-var logger = require('./logger').getInstance()
-
-module.exports = {
-  createConfig: createConfig
-}
-
-function createConfig(context, opts) {
-  // 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('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('')
-
-    config.context = oUrl.pathname || '/'
-    config.options = _.assign(config.options, { target: target }, opts)
-
-    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)
-  }
-
-  configureLogger(config.options)
-
-  if (!config.options.target) {
-    throw new Error(ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING)
-  }
-
-  // Legacy option.proxyHost
-  config.options = mapLegacyProxyHostOption(config.options)
-
-  // Legacy option.proxyTable > option.router
-  config.options = mapLegacyProxyTableOption(config.options)
-
-  return config
-}
-
-/**
- * Checks if a String only target/config is provided.
- * This can be just the host or with the optional path.
- *
- * @example
- *      app.use('/api', proxy('http://localhost:9000'));
-        app.use(proxy('http://localhost:9000/api'));
- *
- * @param  {String}  context [description]
- * @return {Boolean}         [description]
- */
-function isStringShortHand(context) {
-  if (_.isString(context)) {
-    return !!url.parse(context).host
-  }
-}
-
-/**
- * Checks if a Object only config is provided, without a context.
- * In this case the all paths will be proxied.
- *
- * @example
- *     app.use('/api', proxy({target:'http://localhost:9000'}));
- *
- * @param  {Object}  context [description]
- * @param  {*}       opts    [description]
- * @return {Boolean}         [description]
- */
-function isContextless(context, 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('*************************************')
-
-    options.headers = options.headers || {}
-    options.headers.host = options.proxyHost
-  }
-
-  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('*************************************')
-
-    options.router = _.clone(options.proxyTable)
-    _.omit(options, 'proxyTable')
-  }
-
-  return options
-}
-
-function configureLogger(options) {
-  if (options.logLevel) {
-    logger.setLevel(options.logLevel)
-  }
-
-  if (options.logProvider) {
-    logger.setProvider(options.logProvider)
-  }
-}