refactor: avoid using lodash where possible (#459)

TrySound · chimurai · web-flow · commit 5eb8d6968da0 · 2021-03-27T14:40:53.000+01:00
* refactor: avoid using lodash where possible

Using lodash methods does not add value where native methods and
operators can be used. In this diff I avoided lodash where possible.

* fix: trigger rebuild

Co-authored-by: chimurai &lt;655241+chimurai@users.noreply.github.com&gt;
diff --git a/src/config-factory.ts b/src/config-factory.ts
@@ -16,7 +16,7 @@ export function createConfig(context, opts?) {
   // app.use('/api', proxy({target:'http://localhost:9000'}));
   if (isContextless(context, opts)) {
     config.context = '/';
-    config.options = _.assign(config.options, context);
+    config.options = Object.assign(config.options, context);
 
     // app.use('/api', proxy('http://localhost:9000'));
     // app.use(proxy('http://localhost:9000/api'));
@@ -25,15 +25,15 @@ export function createConfig(context, opts?) {
     const target = [oUrl.protocol, '//', oUrl.host].join('');
 
     config.context = oUrl.pathname || '/';
-    config.options = _.assign(config.options, { target }, opts);
+    config.options = Object.assign(config.options, { 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);
+    config.options = Object.assign(config.options, opts);
   }
 
   configureLogger(config.options);
@@ -57,7 +57,7 @@ export function createConfig(context, opts?) {
  * @return {Boolean}         [description]
  */
 function isStringShortHand(context: Filter) {
-  if (_.isString(context)) {
+  if (typeof context === 'string') {
     return !!url.parse(context).host;
   }
 }
@@ -74,7 +74,7 @@ function isStringShortHand(context: Filter) {
  * @return {Boolean}         [description]
  */
 function isContextless(context: Filter, opts: Options) {
-  return _.isPlainObject(context) && _.isEmpty(opts);
+  return _.isPlainObject(context) && (opts == null || Object.keys(opts).length === 0);
 }
 
 function configureLogger(options: Options) {
diff --git a/src/context-matcher.ts b/src/context-matcher.ts
@@ -1,5 +1,4 @@
 import * as isGlob from 'is-glob';
-import * as _ from 'lodash';
 import * as micromatch from 'micromatch';
 import * as url from 'url';
 import { ERRORS } from './errors';
@@ -28,7 +27,7 @@ export function match(context, uri, req) {
   }
 
   // custom matching
-  if (_.isFunction(context)) {
+  if (typeof context === 'function') {
     const pathname = getUrlPathName(uri);
     return context(pathname, req);
   }
@@ -85,7 +84,7 @@ function getUrlPathName(uri) {
 }
 
 function isStringPath(context) {
-  return _.isString(context) && !isGlob(context);
+  return typeof context === 'string' && !isGlob(context);
 }
 
 function isGlobPath(context) {
diff --git a/src/handlers.ts b/src/handlers.ts
@@ -22,20 +22,20 @@ export function getHandlers(options) {
     // loop through options and try to find these handlers
     // and add them to the handlers object for subscription in init().
     const eventName = _.camelCase('on ' + event);
-    const fnHandler = _.get(options, eventName);
+    const fnHandler = options ? options[eventName] : null;
 
-    if (_.isFunction(fnHandler)) {
+    if (typeof fnHandler === 'function') {
       handlers[event] = fnHandler;
     }
   }
 
   // add default error handler in absence of error handler
-  if (!_.isFunction(handlers.error)) {
+  if (typeof handlers.error !== 'function') {
     handlers.error = defaultErrorHandler;
   }
 
   // add default close handler in absence of close handler
-  if (!_.isFunction(handlers.close)) {
+  if (typeof handlers.close !== 'function') {
     handlers.close = logClose;
   }
 
diff --git a/src/http-proxy-middleware.ts b/src/http-proxy-middleware.ts
@@ -1,6 +1,5 @@
 import * as express from 'express';
 import * as httpProxy from 'http-proxy';
-import * as _ from 'lodash';
 import { createConfig } from './config-factory';
 import * as contextMatcher from './context-matcher';
 import * as handlers from './handlers';
@@ -110,7 +109,7 @@ export class HttpProxyMiddleware {
 
     // store uri before it gets rewritten for logging
     const originalPath = req.url;
-    const newProxyOptions = _.assign({}, this.proxyOptions);
+    const newProxyOptions = Object.assign({}, this.proxyOptions);
 
     // Apply in order:
     // 1. option.router
diff --git a/src/logger.ts b/src/logger.ts
@@ -1,4 +1,3 @@
-import * as _ from 'lodash';
 import * as util from 'util';
 
 let loggerInstance;
@@ -82,7 +81,7 @@ class Logger {
   public isValidProvider(fnProvider) {
     const result = true;
 
-    if (fnProvider && !_.isFunction(fnProvider)) {
+    if (fnProvider && typeof fnProvider !== 'function') {
       throw new Error('[HPM] Log provider config error. Expecting a function.');
     }
 
@@ -118,9 +117,8 @@ class Logger {
 
   // make sure logged messages and its data are return interpolated
   // make it possible for additional log data, such date/time or custom prefix.
-  private _interpolate() {
-    const fn = _.spread(util.format);
-    const result = fn(_.slice(arguments));
+  private _interpolate(format, ...args) {
+    const result = util.format(format, ...args);
 
     return result;
   }
diff --git a/src/path-rewriter.ts b/src/path-rewriter.ts
@@ -16,7 +16,7 @@ export function createPathRewriter(rewriteConfig) {
     return;
   }
 
-  if (_.isFunction(rewriteConfig)) {
+  if (typeof rewriteConfig === 'function') {
     const customRewriteFn = rewriteConfig;
     return customRewriteFn;
   } else {
@@ -27,26 +27,26 @@ export function createPathRewriter(rewriteConfig) {
   function rewritePath(path) {
     let result = path;
 
-    _.forEach(rulesCache, (rule) => {
+    for (const rule of rulesCache) {
       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;
+        break;
       }
-    });
+    }
 
     return result;
   }
 }
 
 function isValidRewriteConfig(rewriteConfig) {
-  if (_.isFunction(rewriteConfig)) {
+  if (typeof rewriteConfig === 'function') {
     return true;
-  } else if (!_.isEmpty(rewriteConfig) && _.isPlainObject(rewriteConfig)) {
+  } else if (_.isPlainObject(rewriteConfig) && Object.keys(rewriteConfig).length !== 0) {
     return true;
   } else if (
-    _.isUndefined(rewriteConfig) ||
-    _.isNull(rewriteConfig) ||
+    rewriteConfig === undefined ||
+    rewriteConfig === null ||
     _.isEqual(rewriteConfig, {})
   ) {
     return false;
@@ -59,13 +59,13 @@ function parsePathRewriteRules(rewriteConfig) {
   const rules = [];
 
   if (_.isPlainObject(rewriteConfig)) {
-    _.forIn(rewriteConfig, (value, key) => {
+    for (const [key] of Object.entries(rewriteConfig)) {
       rules.push({
         regex: new RegExp(key),
         value: rewriteConfig[key],
       });
       logger.info('[HPM] Proxy rewrite rule created: "%s" ~> "%s"', key, rewriteConfig[key]);
-    });
+    }
   }
 
   return rules;
diff --git a/src/router.ts b/src/router.ts
@@ -8,7 +8,7 @@ export async function getTarget(req, config) {
 
   if (_.isPlainObject(router)) {
     newTarget = getTargetFromProxyTable(req, router);
-  } else if (_.isFunction(router)) {
+  } else if (typeof router === 'function') {
     newTarget = await router(req);
   }
 
@@ -22,23 +22,23 @@ function getTargetFromProxyTable(req, table) {
 
   const hostAndPath = host + path;
 
-  _.forIn(table, (value, key) => {
+  for (const [key] of Object.entries(table)) {
     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;
+        break;
       }
     } else {
       if (key === host) {
         // match 'localhost:3000'
         result = table[key];
         logger.debug('[HPM] Router table match: "%s"', host);
-        return false;
+        break;
       }
     }
-  });
+  }
 
   return result;
 }
diff --git a/test/unit/path-rewriter.spec.ts b/test/unit/path-rewriter.spec.ts
@@ -114,7 +114,7 @@ describe('Path rewriting', () => {
         return changed;
       };
 
-      expect(rewriter(rewriteFn)).resolves.toBe('/123/456');
+      return expect(rewriter(rewriteFn)).resolves.toBe('/123/456');
     });
 
     it('is async and should return alternative path', () => {
@@ -126,7 +126,7 @@ describe('Path rewriting', () => {
         return changed;
       };
 
-      expect(rewriter(rewriteFn)).resolves.toBe('/foo/bar');
+      return expect(rewriter(rewriteFn)).resolves.toBe('/foo/bar');
     });
 
     it('is async and should return replaced path', () => {
@@ -138,7 +138,7 @@ describe('Path rewriting', () => {
         return changed;
       };
 
-      expect(rewriter(rewriteFn)).resolves.toBe('/123/789');
+      return expect(rewriter(rewriteFn)).resolves.toBe('/123/789');
     });
   });
 
diff --git a/test/unit/router.spec.ts b/test/unit/router.spec.ts
@@ -40,7 +40,7 @@ describe('router unit test', () => {
         expect(request.url).toBe('/');
       });
       it('should return new target', () => {
-        expect(result).resolves.toBe('http://foobar.com:666');
+        return expect(result).resolves.toBe('http://foobar.com:666');
       });
     });
   });
@@ -66,7 +66,7 @@ describe('router unit test', () => {
         expect(request.url).toBe('/');
       });
       it('should return new target', () => {
-        expect(result).resolves.toBe('http://foobar.com:666');
+        return expect(result).resolves.toBe('http://foobar.com:666');
       });
     });
   });
@@ -90,71 +90,71 @@ describe('router unit test', () => {
     describe('without router config', () => {
       it('should return the normal target when router not present in config', () => {
         result = getTarget(fakeReq, config);
-        expect(result).resolves.toBeUndefined();
+        return expect(result).resolves.toBeUndefined();
       });
     });
 
     describe('with just the host in router config', () => {
       it('should target http://localhost:6001 when for router:"alpha.localhost"', () => {
         fakeReq.headers.host = 'alpha.localhost';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6001');
+        return expect(result).resolves.toBe('http://localhost:6001');
       });
 
       it('should target http://localhost:6002 when for router:"beta.localhost"', () => {
         fakeReq.headers.host = 'beta.localhost';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6002');
+        return expect(result).resolves.toBe('http://localhost:6002');
       });
     });
 
     describe('with host and host + path config', () => {
       it('should target http://localhost:6004 without path', () => {
         fakeReq.headers.host = 'gamma.localhost';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6004');
+        return expect(result).resolves.toBe('http://localhost:6004');
       });
 
       it('should target http://localhost:6003 exact path match', () => {
         fakeReq.headers.host = 'gamma.localhost';
         fakeReq.url = '/api';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6003');
+        return expect(result).resolves.toBe('http://localhost:6003');
       });
 
       it('should target http://localhost:6004 when contains path', () => {
         fakeReq.headers.host = 'gamma.localhost';
         fakeReq.url = '/api/books/123';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6003');
+        return expect(result).resolves.toBe('http://localhost:6003');
       });
     });
 
     describe('with just the path', () => {
       it('should target http://localhost:6005 with just a path as router config', () => {
         fakeReq.url = '/rest';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6005');
+        return expect(result).resolves.toBe('http://localhost:6005');
       });
 
       it('should target http://localhost:6005 with just a path as router config', () => {
         fakeReq.url = '/rest/deep/path';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6005');
+        return expect(result).resolves.toBe('http://localhost:6005');
       });
 
       it('should target http://localhost:6000 path in not present in router config', () => {
         fakeReq.url = '/unknow-path';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBeUndefined();
+        return expect(result).resolves.toBeUndefined();
       });
     });
 
     describe('matching order of router config', () => {
       it('should return first matching target when similar paths are configured', () => {
         fakeReq.url = '/some/specific/path';
         result = getTarget(fakeReq, proxyOptionWithRouter);
-        expect(result).resolves.toBe('http://localhost:6006');
+        return expect(result).resolves.toBe('http://localhost:6006');
       });
     });
   });

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`import * as isGlob from 'is-glob';`
`2`		`-import * as _ from 'lodash';`
`3`	`2`	`import * as micromatch from 'micromatch';`
`4`	`3`	`import * as url from 'url';`
`5`	`4`	`import { ERRORS } from './errors';`
`@@ -28,7 +27,7 @@ export function match(context, uri, req) {`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`// custom matching`
`31`		`- if (_.isFunction(context)) {`
	`30`	`+ if (typeof context === 'function') {`
`32`	`31`	`const pathname = getUrlPathName(uri);`
`33`	`32`	`return context(pathname, req);`
`34`	`33`	`}`
`@@ -85,7 +84,7 @@ function getUrlPathName(uri) {`
`85`	`84`	`}`
`86`	`85`
`87`	`86`	`function isStringPath(context) {`
`88`		`- return _.isString(context) && !isGlob(context);`
	`87`	`+ return typeof context === 'string' && !isGlob(context);`
`89`	`88`	`}`
`90`	`89`
`91`	`90`	`function isGlobPath(context) {`
Original file line number	Diff line number	Diff line change
`@@ -22,20 +22,20 @@ export function getHandlers(options) {`
`22`	`22`	`// loop through options and try to find these handlers`
`23`	`23`	`// and add them to the handlers object for subscription in init().`
`24`	`24`	`const eventName = _.camelCase('on ' + event);`
`25`		`- const fnHandler = _.get(options, eventName);`
	`25`	`+ const fnHandler = options ? options[eventName] : null;`
`26`	`26`
`27`		`- if (_.isFunction(fnHandler)) {`
	`27`	`+ if (typeof fnHandler === 'function') {`
`28`	`28`	`handlers[event] = fnHandler;`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`// add default error handler in absence of error handler`
`33`		`- if (!_.isFunction(handlers.error)) {`
	`33`	`+ if (typeof handlers.error !== 'function') {`
`34`	`34`	`handlers.error = defaultErrorHandler;`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`// add default close handler in absence of close handler`
`38`		`- if (!_.isFunction(handlers.close)) {`
	`38`	`+ if (typeof handlers.close !== 'function') {`
`39`	`39`	`handlers.close = logClose;`
`40`	`40`	`}`
`41`	`41`