feat(pathRewrite): support for custom pathRewrite function. (chimurai#74)

Author: chimurai

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [v0.x.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.x.0)
+- feat(pathRewrite): support for custom pathRewrite function.
+
 ## [v0.14.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.14.0)
 - feat(proxy): support proxy creation without context.
 - fix(connect mounting): use connect's `path` configuration to mount proxy.

README.md

@@ -192,7 +192,7 @@ var server = app.listen(3000);
 
 ## Options
 
-*  **option.pathRewrite**: object, rewrite target's url path. Object-keys will be used as _RegExp_ to match paths.
+*  **option.pathRewrite**: object/function, rewrite target's url path. Object-keys will be used as _RegExp_ to match paths.
     ```javascript
     // rewrite path
     pathRewrite: {"^/old/api" : "/new/api"}
@@ -202,6 +202,9 @@ var server = app.listen(3000);
 
     // add base path
     pathRewrite: {"^/" : "/basepath/"}
+
+    // custom rewriting
+    pathRewrite: function (path) { return path.replace('/api', '/base/api') }
     ```
 
 * **option.proxyTable**: object, re-target `option.target` based on the request header `host` parameter. `host` can be used in conjunction with `path`. Only one instance of the proxy will be used. The order of the configuration matters.

index.js

@@ -77,7 +77,9 @@ var httpProxyMiddleware = function(context, opts) {
         // store uri before it gets rewritten for logging
         var originalPath = req.url;
 
-        // apply apply option.proxyTable & option.pathRewrite
+        // Apply in order:
+        // 1. option.proxyTable
+        // 2. option.pathRewrite
         var alteredProxyOptions = __applyProxyTableOption(req, proxyOptions);
         __applyPathRewrite(req, pathRewriter);
 
@@ -105,7 +107,13 @@ var httpProxyMiddleware = function(context, opts) {
     // rewrite path
     function __applyPathRewrite(req) {
         if (pathRewriter) {
-            req.url = pathRewriter(req.url);
+            var path = pathRewriter(req.url);
+
+            if (path) {
+                req.url =  path;
+            } else {
+                logger.info('[HPM] pathRewrite: No rewritten path found. (%s)', req.url);
+            }
         }
     }
 

lib/path-rewriter.js

@@ -7,21 +7,28 @@ module.exports = {
 
 /**
  * Create rewrite function, to cache parsed rewrite rules.
+ *
+ * @returns {function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
  */
-function createPathRewriter(config) {
+function createPathRewriter(rewriteConfig) {
+    var rulesCache;
 
-    if (config === undefined || config === null) {
+    if (!isValidRewriteConfig(rewriteConfig)) {
         return;
     }
 
-    var rules = parsePathRewriteRules(config);
-
-    return rewritePath;
+    if (_.isFunction(rewriteConfig)) {
+        var customRewriteFn = rewriteConfig;
+        return customRewriteFn;
+    } else {
+        rulesCache = parsePathRewriteRules(rewriteConfig);
+        return rewritePath;
+    }
 
     function rewritePath(path) {
         var result = path;
 
-        _.forEach(rules,function(rule) {
+        _.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);
@@ -33,21 +40,31 @@ function createPathRewriter(config) {
     }
 }
 
-function parsePathRewriteRules(config) {
-    var rules = [];
-
-    if (_.isPlainObject(config) === false) {
-        throw new Error('[HPM] Invalid pathRewrite config. Expecting an object literal with pathRewrite configuration');
+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');
+    }
+}
 
-        _.forIn(config, function(value, key) {
+function parsePathRewriteRules(rewriteConfig) {
+    var rules = [];
+
+    if (_.isPlainObject(rewriteConfig)) {
+        _.forIn(rewriteConfig, function(value, key) {
             rules.push({
                 regex: new RegExp(key),
-                value: config[key]
+                value: rewriteConfig[key]
             });
-            logger.info('[HPM] Proxy rewrite rule created: "%s" ~> "%s"', key, config[key]);
+            logger.info('[HPM] Proxy rewrite rule created: "%s" ~> "%s"', key, rewriteConfig[key]);
         });
-
     }
 
     return rules;

recipes/pathRewrite.md

@@ -7,6 +7,7 @@ Modify request paths before requests are send to the target.
 - [rewrite paths](#rewrite-paths)
 - [remove paths](#remove-paths)
 - [add paths](#add-paths)
+- [custom rewrite function](#custom-rewrite-function)
 
 <!-- /MarkdownTOC -->
 
@@ -67,3 +68,25 @@ var apiProxy = proxy('/api', options);
 
 // `/api/lorum/ipsum` -> `http://localhost:3000/extra/api/lorum/ipsum`
 ```
+
+## custom rewrite function
+
+Implement you own path rewrite logic.
+When rewrite function is not return a path (undefined), the original path will be used.
+
+```javascript
+var proxy = require("http-proxy-middleware");
+
+var rewriteFn = function (path) {
+    return path.replace('/api/foo', '/api/bar');
+}
+
+var options = {
+    target: 'http://localhost:3000',
+    pathRewrite: rewriteFn
+};
+
+var apiProxy = proxy('/api', options);
+
+// `/api/foo/lorum/ipsum` -> `http://localhost:3000/api/bar/lorum/ipsum`
+```

test/path-rewriter.spec.js

@@ -6,7 +6,7 @@ describe('Path rewriting', function() {
     var result;
     var config;
 
-    describe('Configuration and usage', function() {
+    describe('Rewrite rules configuration and usage', function() {
 
         beforeEach(function() {
             config = {
@@ -55,7 +55,7 @@ describe('Path rewriting', function() {
         });
     });
 
-    describe('add base path to requests', function() {
+    describe('Rewrite rule: add base path to requests', function() {
 
         beforeEach(function() {
             config = {
@@ -73,6 +73,39 @@ describe('Path rewriting', function() {
         });
     });
 
+    describe('Rewrite function', function() {
+        var rewriter;
+
+        beforeEach(function() {
+            rewriter = function(fn) {
+                var rewriteFn = pathRewriter.create(fn);
+                var requestPath = '/123/456';
+                return rewriteFn(requestPath);
+            };
+        });
+
+        it('should return unmodified path', function() {
+            var rewriteFn = function(path) {
+                return path;
+            };
+            expect(rewriter(rewriteFn)).to.equal('/123/456');
+        });
+
+        it('should return alternative path', function() {
+            var rewriteFn = function(path) {
+                return '/foo/bar';
+            };
+            expect(rewriter(rewriteFn)).to.equal('/foo/bar');
+        });
+
+        it('should return replaced path', function() {
+            var rewriteFn = function(path) {
+                return path.replace('/456', '/789');
+            };
+            expect(rewriter(rewriteFn)).to.equal('/123/789');
+        });
+    });
+
     describe('Invalid configuration', function() {
         var badFn;
 
@@ -93,7 +126,6 @@ describe('Path rewriting', function() {
         it('should throw when bad config is provided', function() {
             expect(badFn(123)).to.throw(Error);
             expect(badFn('abc')).to.throw(Error);
-            expect(badFn(function() {})).to.throw(Error);
             expect(badFn([])).to.throw(Error);
             expect(badFn([1,2,3])).to.throw(Error);
         });
@@ -102,6 +134,10 @@ describe('Path rewriting', function() {
             expect(badFn({})).to.not.throw(Error);
         });
 
+        it('should not throw when function config is provided', function() {
+            expect(badFn(function() {})).to.not.throw(Error);
+        });
+
     });
 });