refactor: migrate to typescript

Author: chimurai

.npmrc

@@ -0,0 +1 @@
+package-lock=false

.prettierignore

@@ -0,0 +1 @@
+dist

.prettierrc

@@ -1,5 +1,5 @@
 {
   "tabWidth": 2,
-  "semi": false,
+  "semi": true,
   "singleQuote": true
 }

README.md

@@ -15,13 +15,16 @@ Powered by the popular Nodejitsu [`http-proxy`](https://github.com/nodejitsu/nod
 Proxy `/api` requests to `http://www.example.org`
 
 ```javascript
-var express = require('express')
-var proxy = require('http-proxy-middleware')
+var express = require('express');
+var proxy = require('http-proxy-middleware');
 
-var app = express()
+var app = express();
 
-app.use('/api', proxy({ target: 'http://www.example.org', changeOrigin: true }))
-app.listen(3000)
+app.use(
+  '/api',
+  proxy({ target: 'http://www.example.org', changeOrigin: true })
+);
+app.listen(3000);
 
 // http://localhost:3000/api/foo/bar -> http://www.example.org/api/foo/bar
 ```
@@ -68,9 +71,9 @@ Proxy middleware configuration.
 #### proxy([context,] config)
 
 ```javascript
-var proxy = require('http-proxy-middleware')
+var proxy = require('http-proxy-middleware');
 
-var apiProxy = proxy('/api', { target: 'http://www.example.org' })
+var apiProxy = proxy('/api', { target: 'http://www.example.org' });
 //                   \____/   \_____________________________/
 //                     |                    |
 //                   context             options
@@ -88,7 +91,7 @@ var apiProxy = proxy('/api', { target: 'http://www.example.org' })
 
 ```javascript
 // shorthand syntax for the example above:
-var apiProxy = proxy('http://www.example.org/api')
+var apiProxy = proxy('http://www.example.org/api');
 ```
 
 More about the [shorthand configuration](#shorthand).
@@ -99,8 +102,8 @@ An example with `express` server.
 
 ```javascript
 // include dependencies
-var express = require('express')
-var proxy = require('http-proxy-middleware')
+var express = require('express');
+var proxy = require('http-proxy-middleware');
 
 // proxy middleware options
 var options = {
@@ -116,15 +119,15 @@ var options = {
     // override target 'http://www.example.org' to 'http://localhost:8000'
     'dev.localhost:3000': 'http://localhost:8000'
   }
-}
+};
 
 // create the proxy (without context)
-var exampleProxy = proxy(options)
+var exampleProxy = proxy(options);
 
 // mount `exampleProxy` in web server
-var app = express()
-app.use('/api', exampleProxy)
-app.listen(3000)
+var app = express();
+app.use('/api', exampleProxy);
+app.listen(3000);
 ```
 
 ## Context matching
@@ -172,10 +175,10 @@ Providing an alternative way to decide which requests should be proxied; In case
    * @return {Boolean}
    */
   var filter = function(pathname, req) {
-    return pathname.match('^/api') && req.method === 'GET'
-  }
+    return pathname.match('^/api') && req.method === 'GET';
+  };
 
-  var apiProxy = proxy(filter, { target: 'http://www.example.org' })
+  var apiProxy = proxy(filter, { target: 'http://www.example.org' });
   ```
 
 ## Options
@@ -224,23 +227,23 @@ Providing an alternative way to decide which requests should be proxied; In case
   // simple replace
   function logProvider(provider) {
     // replace the default console log provider.
-    return require('winston')
+    return require('winston');
   }
   ```
 
   ```javascript
   // verbose replacement
   function logProvider(provider) {
-    var logger = new (require('winston')).Logger()
+    var logger = new (require('winston')).Logger();
 
     var myCustomProvider = {
       log: logger.log,
       debug: logger.debug,
       info: logger.info,
       warn: logger.warn,
       error: logger.error
-    }
-    return myCustomProvider
+    };
+    return myCustomProvider;
   }
   ```
 
@@ -257,19 +260,19 @@ Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#li
   function onError(err, req, res) {
     res.writeHead(500, {
       'Content-Type': 'text/plain'
-    })
+    });
     res.end(
       'Something went wrong. And we are reporting a custom error message.'
-    )
+    );
   }
   ```
 
 - **option.onProxyRes**: function, subscribe to http-proxy's `proxyRes` event.
 
   ```javascript
   function onProxyRes(proxyRes, req, res) {
-    proxyRes.headers['x-added'] = 'foobar' // add new header to response
-    delete proxyRes.headers['x-removed'] // remove header from response
+    proxyRes.headers['x-added'] = 'foobar'; // add new header to response
+    delete proxyRes.headers['x-removed']; // remove header from response
   }
   ```
 
@@ -278,7 +281,7 @@ Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#li
   ```javascript
   function onProxyReq(proxyReq, req, res) {
     // add custom header to request
-    proxyReq.setHeader('x-added', 'foobar')
+    proxyReq.setHeader('x-added', 'foobar');
     // or log the req
   }
   ```
@@ -288,7 +291,7 @@ Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#li
   ```javascript
   function onProxyReqWs(proxyReq, req, socket, options, head) {
     // add custom header
-    proxyReq.setHeader('X-Special-Proxy-Header', 'foobar')
+    proxyReq.setHeader('X-Special-Proxy-Header', 'foobar');
   }
   ```
 
@@ -297,15 +300,15 @@ Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#li
   ```javascript
   function onOpen(proxySocket) {
     // listen for messages coming FROM the target here
-    proxySocket.on('data', hybiParseAndLogMessage)
+    proxySocket.on('data', hybiParseAndLogMessage);
   }
   ```
 
 - **option.onClose**: function, subscribe to http-proxy's `close` event.
   ```javascript
   function onClose(res, socket, head) {
     // view disconnected websocket connections
-    console.log('Client disconnected')
+    console.log('Client disconnected');
   }
   ```
 
@@ -383,13 +386,13 @@ The following options are provided by the underlying [http-proxy](https://github
 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.
 
 ```javascript
-proxy('http://www.example.org:8000/api')
+proxy('http://www.example.org:8000/api');
 // proxy('/api', {target: 'http://www.example.org:8000'});
 
-proxy('http://www.example.org:8000/api/books/*/**.json')
+proxy('http://www.example.org:8000/api/books/*/**.json');
 // proxy('/api/books/*/**.json', {target: 'http://www.example.org:8000'});
 
-proxy('http://www.example.org:8000/api', { changeOrigin: true })
+proxy('http://www.example.org:8000/api', { changeOrigin: true });
 // proxy('/api', {target: 'http://www.example.org:8000', changeOrigin: true});
 ```
 
@@ -399,7 +402,10 @@ If you want to use the server's `app.use` `path` parameter to match requests;
 Create and mount the proxy without the http-proxy-middleware `context` parameter:
 
 ```javascript
-app.use('/api', proxy({ target: 'http://www.example.org', changeOrigin: true }))
+app.use(
+  '/api',
+  proxy({ target: 'http://www.example.org', changeOrigin: true })
+);
 ```
 
 `app.use` documentation:
@@ -411,27 +417,27 @@ app.use('/api', proxy({ target: 'http://www.example.org', changeOrigin: true }))
 
 ```javascript
 // verbose api
-proxy('/', { target: 'http://echo.websocket.org', ws: true })
+proxy('/', { target: 'http://echo.websocket.org', ws: true });
 
 // shorthand
-proxy('http://echo.websocket.org', { ws: true })
+proxy('http://echo.websocket.org', { ws: true });
 
 // shorter shorthand
-proxy('ws://echo.websocket.org')
+proxy('ws://echo.websocket.org');
 ```
 
 ### External WebSocket upgrade
 
 In the previous WebSocket examples, http-proxy-middleware relies on a initial http request in order to listen to the http `upgrade` event. If you need to proxy WebSockets without the initial http request, you can subscribe to the server's http `upgrade` event manually.
 
 ```javascript
-var wsProxy = proxy('ws://echo.websocket.org', { changeOrigin: true })
+var wsProxy = proxy('ws://echo.websocket.org', { changeOrigin: true });
 
-var app = express()
-app.use(wsProxy)
+var app = express();
+app.use(wsProxy);
 
-var server = app.listen(3000)
-server.on('upgrade', wsProxy.upgrade) // <-- subscribe to http 'upgrade'
+var server = app.listen(3000);
+server.on('upgrade', wsProxy.upgrade); // <-- subscribe to http 'upgrade'
 ```
 
 ## Working examples

dist/config-factory.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const url = require("url");
+const errors_1 = require("./errors");
+const logger_1 = require("./logger");
+var logger = logger_1.getInstance();
+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_1.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;
+}
+exports.createConfig = createConfig;
+/**
+ * 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);
+    }
+}