Merge pull request #59 from chimurai/custom-context-matching

feat(context): custom context matcher

Author: chimurai

README.md

@@ -94,6 +94,7 @@ Request URL's [ _path-absolute_ and _query_](https://tools.ietf.org/html/rfc3986
     - `['/api', '/ajax', '/someotherpath']`
 
 * **wildcard path matching**
+    
     For fine-grained control you can use wildcard matching. Glob pattern matching is done by _micromatch_. Visit [micromatch](https://www.npmjs.com/package/micromatch) or [glob](https://www.npmjs.com/package/glob) for more globbing examples.
     - `'**'` matches any path, all requests will be proxied.
     - `'**/*.html'` matches any path which ends with `.html`
@@ -102,6 +103,17 @@ Request URL's [ _path-absolute_ and _query_](https://tools.ietf.org/html/rfc3986
     - `['/api/**', '/ajax/**']` combine multiple patterns
     - `['/api/**', '!**/bad.json']` exclusion
 
+* **custom matching**
+    
+    For full control you can provide a custom filter function to determine which requests should be proxied or not.
+    ```javascript
+    var filter = function (path, req) {
+        return (path.match('^/api') && req.method === 'GET');
+    };
+
+    var apiProxy = proxyMiddleware(filter, {target: 'http://www.example.org'})
+    ```
+
 ## Shorthand
 
 Use the shorthand syntax when verbose configuration is not needed. The `context` and `option.target` will be automatically configured when shorthand is used. Options can still be used if needed.

index.js

@@ -39,7 +39,7 @@ var httpProxyMiddleware = function(context, opts) {
             req.url = req.originalUrl;
         }
 
-        if (contextMatcher.match(config.context, req.url)) {
+        if (contextMatcher.match(config.context, req.url, req)) {
             var activeProxyOptions = prepareProxyRequest(req);
             proxy.web(req, res, activeProxyOptions);
         } else {
@@ -62,7 +62,7 @@ var httpProxyMiddleware = function(context, opts) {
     }
 
     function handleUpgrade(req, socket, head) {
-        if (contextMatcher.match(config.context, req.url)) {
+        if (contextMatcher.match(config.context, req.url, req)) {
             var activeProxyOptions = prepareProxyRequest(req);
             proxy.ws(req, socket, head, activeProxyOptions);
             logger.info('[HPM] Upgrading to WebSocket');

lib/context-matcher.js

@@ -1,3 +1,4 @@
+var _ = require('lodash');
 var url = require('url');
 var isGlob = require('is-glob');
 var micromatch = require('micromatch');
@@ -6,15 +7,18 @@ module.exports = {
     match: matchContext
 };
 
-function matchContext(context, uri) {
+function matchContext(context, uri, req) {
+
     // 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)) {
@@ -27,6 +31,12 @@ function matchContext(context, uri) {
         throw new Error('[HPM] Invalid context. Expecting something like: ["/api", "/ajax"] or ["/api/**", "!**.html"]');
     }
 
+    // custom matching
+    if (_.isFunction(context)) {
+        var path = getUrlPath(uri);
+        return context(path, req);
+    }
+
     throw new Error('[HPM] Invalid context. Expecting something like: "/api" or ["/api", "/ajax"]');
 }
 
@@ -70,7 +80,7 @@ function getUrlPath(uri) {
 }
 
 function isStringPath(context) {
-    return typeof context === 'string' && !isGlob(context);
+    return _.isString(context) && !isGlob(context);
 }
 
 function isGlobPath(context) {

recipes/context.md

@@ -0,0 +1,75 @@
+# Context matching
+
+## Path
+
+This example will create a basic proxy.
+
+Requests with path `/api` will be proxied to `http://localhost:3000`
+
+```javascript
+var proxy = require("http-proxy-middleware");
+
+var apiProxy = proxy('/api', {target: 'http://localhost:3000'});
+
+// `/api/foo/bar` -> `http://localhost:3000/api/foo/bar`
+```
+
+## Multi Path
+
+This example will create a basic proxy 
+
+Requests with path `/api` and `/rest` will be proxied to `http://localhost:3000`
+
+```javascript
+var proxy = require("http-proxy-middleware");
+
+var apiProxy = proxy(['/api', '/rest'], {target: 'http://localhost:3000'});
+
+// `/api/foo/bar` -> `http://localhost:3000/api/foo/bar`
+// `/rest/lorum/ipsum` -> `http://localhost:3000/rest/lorum/ipsum`
+```
+
+## Wildcard
+
+This example will create a proxy with wildcard context matching.
+
+```javascript
+var proxy = require("http-proxy-middleware");
+
+var apiProxy = proxy('/api/**/*.json', {target: 'http://localhost:3000'});
+```
+
+## Multi Wildcard
+
+This example will create a proxy with wildcard context matching.
+
+```javascript
+var proxy = require("http-proxy-middleware");
+
+var apiProxy = proxy(['/api/**', '/ajax/**'], {target: 'http://localhost:3000'});
+```
+
+## Wildcard / Exclusion
+
+This example will create a proxy with wildcard context matching.
+
+```javascript
+var proxy = require("http-proxy-middleware");
+
+var apiProxy = proxy(['/api/**', '!**/bad.json'], {target: 'http://localhost:3000'});
+```
+
+## Custom filtering
+
+This example will create a proxy with custom filtering.
+The request `path` and `req` object are provided to determine which requests should be proxied or not.
+
+```javascript
+var proxy = require("http-proxy-middleware");
+
+var filter = function (path, req) {
+    return (path.match('^/api') && req.method === 'GET');
+};
+
+var apiProxy = proxy(filter, {target: 'http://localhost:3000'});
+```