Implement a faster REST router

lib/rest-adapter.js

@@ -28,6 +28,7 @@ var async = require('async');
 var HttpInvocation = require('./http-invocation');
 var ContextBase = require('./context-base');
 var HttpContext = require('./http-context');
+var RestRouter = require('./rest-router');
 
 var json = bodyParser.json;
 var urlencoded = bodyParser.urlencoded;
@@ -263,6 +264,10 @@ RestAdapter.prototype.createHandler = function() {
 
   var handleUnknownPaths = this._shouldHandleUnknownPaths();
 
+  // Mount rest-router
+  var fastRouter = new RestRouter();
+  root.use(fastRouter);
+
   classes.forEach(function(restClass) {
     var router = express.Router();
     var className = restClass.sharedClass.name;
@@ -277,6 +282,8 @@ RestAdapter.prototype.createHandler = function() {
         var sharedMethod = restMethod.sharedMethod;
         debug('    method %s', sharedMethod.stringName);
         restMethod.routes.forEach(function(route) {
+          // add fullPath for Trie insertion
+          route.fullPath = joinPaths(restClass.getPath(), route.path);
           methods.push({ route: route, method: sharedMethod });
         });
       });
@@ -285,7 +292,7 @@ RestAdapter.prototype.createHandler = function() {
     methods.sort(sortRoutes);
 
     methods.forEach(function(m) {
-      adapter._registerMethodRouteHandlers(router, m.method, m.route);
+      adapter._registerMethodRouteHandlers(router, m.method, m.route, fastRouter);
     });
 
     if (handleUnknownPaths) {
@@ -414,7 +421,8 @@ RestAdapter.errorHandler = function(options) {
 
 RestAdapter.prototype._registerMethodRouteHandlers = function(router,
                                                               sharedMethod,
-                                                              route) {
+                                                              route,
+                                                              fastRouter) {
   var handler = sharedMethod.isStatic ?
     this._createStaticMethodHandler(sharedMethod) :
     this._createPrototypeMethodHandler(sharedMethod);
@@ -425,6 +433,11 @@ RestAdapter.prototype._registerMethodRouteHandlers = function(router,
     // Express 4.x only supports delete
     verb = 'delete';
   }
+
+  // if (fastRouter.canRegister(route, handler)) {
+  handler.methodName = sharedMethod.name;
+  fastRouter[verb](route, handler);
+  // }
   router[verb](route.path, handler);
 };
 

lib/rest-router.js

@@ -0,0 +1,59 @@
+
+var url = require('url');
+var http = require('http');
+var Trie = require('./trie');
+
+var HTTP_METHODS = require('methods');
+
+var RestRouter = module.exports = function(options) {
+  var opts = options || {};
+  var router = function(req, res, next) {
+    router.handle(req, res, next);
+  };
+
+  router.__proto__ = RestRouter;
+  router._trie = new Trie();
+  router.options = opts;
+
+  return router;
+};
+
+// express style API for registering route handlers: ex. route[method](path, handler)
+// add verb:handler for path to trie DS
+HTTP_METHODS.concat('all').forEach(function(method) {
+  RestRouter[method] = function(route, handler) {
+    route.fullPath = normalizePath(route.fullPath, this.opts);
+    var trie = this._trie;
+    trie = trie.add(route, handler);
+    return this;
+  };
+});
+
+// handle request, match path and if found, invoke handler method
+RestRouter.handle = function(req, res, next) {
+  var trie = this._trie;
+  var verb = req.method.toLowerCase();
+  var path = normalizePath(req.url, this.options);
+  var methods = trie.find(path);
+
+  if (methods && verb in methods) {
+    methods[verb](req, res, next);
+  } else {
+    next();
+  }
+};
+
+// For now: exclude paths with parameters like :id
+// and handler functions with err obj i.e. (err, req, res, next)
+
+// RestRouter.canRegister = function(route, handler) {
+//   return !(route.path.includes(':') && handler.length < 4);
+// };
+
+function normalizePath(path, options) {
+  path = url.parse(path).pathname;
+  if (!options || !(options.caseSensitive)) {
+    path = path.toLowerCase();
+  }
+  return path;
+}

lib/trie.js

@@ -0,0 +1,70 @@
+
+module.exports = Trie;
+
+function Trie() {
+  this.methods = {};
+}
+
+// insert new nodes to Trie
+Trie.prototype.add = function(route, handler) {
+  var node = this;
+  var parts = getPathParts(route.fullPath);
+  var segment;
+
+  if (!parts.length) {
+    addVerbHandler(node, route, handler);
+    return this;
+  }
+  for (var i = 0; i < parts.length; i++) {
+    segment = parts[i];
+    if (!(segment in node)) {
+      node[segment] = new Trie();
+      node.param = (segment[0] === ':');
+    }
+    if (i + 1 === parts.length) {
+      addVerbHandler(node[segment], route, handler);
+    }
+    node = node[segment];
+  }
+
+  return this;
+};
+
+// Look for matching path and return methods for a match
+Trie.prototype.find = function(path) {
+  var node = this;
+  var parts = getPathParts(path);
+  var segment;
+
+  for (var i = 0; i < parts.length; i++) {
+    segment = parts[i];
+    if (!(segment in node) && !node.param) return false;
+    if (node.param) {
+      segment = Object.keys(node).find(function(key) {
+        if (key[0] === ':') return key;
+      });
+      return node[segment].methods;
+    }
+    if (i + 1 === parts.length) return node[segment].methods;
+    node = node[segment];
+  }
+};
+
+function getPathParts(path) {
+  return path.trim().split('/').filter(Boolean);
+}
+
+function addVerbHandler(node, route, handler) {
+  node.methods = node.methods || {};
+  var verb = route.verb;
+  if (node.methods[verb]) {
+    console.warn(
+      'WARN: A handler was already registered for %s /api%s : Ignoring the new handler %s',
+      route.verb.toUpperCase(),
+      route.fullPath || '/[unknown]',
+      handler.methodName || '<unknown>'
+      );
+    return;
+  }
+  node.methods[verb] = handler;
+}

package.json

@@ -27,6 +27,7 @@
     "jayson": "^1.2.0",
     "js2xmlparser": "^0.1.9",
     "loopback-phase": "^1.3.0",
+    "methods": "^1.1.2",
     "mux-demux": "^3.7.9",
     "qs": "^2.4.2",
     "request": "^2.55.0",

test/rest-router.test.js

@@ -0,0 +1,93 @@
+var assert = require('assert');
+var expect = require('chai').expect;
+var RestRouter = require('../lib/rest-router.js');
+var Trie = require('../lib/trie.js');
+var express = require('express');
+var supertest = require('supertest');
+var http = require('http');
+
+describe('RestRouter', function() {
+  // Test init
+  it('initializes with Trie datastructure', function(done) {
+    var router = new RestRouter();
+    expect(router).to.have.property('_trie');
+    expect(router._trie).to.be.instanceOf(Trie);
+    done();
+  });
+
+  // test handle
+  it('handles a request', function(done) {
+    var app = express();
+    var router = new RestRouter();
+    var route = { fullPath: '/example', verb: 'get' };
+    var resBody = 'Hello Wold!';
+    // this doesn't make sense to me that I have to call router.get(...)
+    // as well as have route.verb = get
+    // it doesn't work without it
+    router.get(route, function(req, res) {
+      res.end(resBody);
+    });
+    app.use(router);
+    console.log(router._trie);
+    supertest(app)
+      .get(route.fullPath)
+      .expect(200)
+      .expect(resBody)
+      .end(function(err, res) {
+        if (err) return done(err);
+        done();
+      });
+  });
+
+  // test handle param
+  it('handles a request with a parameter', function(done) {
+    var app = express();
+    var router = new RestRouter();
+    var route = { fullPath: '/example/:id', verb: 'get' };
+    var id = '1';
+    // this doesn't make sense to me that I have to call router.get(...)
+    // as well as have route.verb = get
+    // it doesn't work without it
+    router.get(route, function(req, res, next) {
+      console.log('hit');
+      res.end(id);
+    });
+    app.use(router);
+    console.log(router._trie);
+    supertest(app)
+      .get(route.fullPath.replace(':id', id))
+      .expect(200)
+      .expect(id)
+      .end(function(err, res) {
+        console.log(res.body);
+        if (err) return done(err);
+        done();
+      });
+  });
+
+  // test handle param with method after
+  // it('handles a request for a instance method', function() {
+  //   var app = express();
+  //   var router = new RestRouter();
+  //   var route = { fullPath: '/example/:id/properties', verb: 'get' };
+  //   var id = '1';
+  //   // this doesn't make sense to me that I have to call router.get(...)
+  //   // as well as have route.verb = get
+  //   // it doesn't work without it
+  //   router.get(route, function(req, res, next) {
+  //     // List the properties of a mock object
+  //     res.end(req.fullPath);
+  //   });
+  //   app.use(router);
+  //   console.log(router._trie);
+  //   supertest(app)
+  //     .get(route.fullPath.replace(':id', id))
+  //     .expect(200)
+  //     .expect(id)
+  //     .end(function(err, res) {
+  //       console.log(res.body);
+  //       if (err) return done(err);
+  //       done();
+  //     });
+  // });
+});

test/trie.test.js

@@ -0,0 +1,76 @@
+
+var assert = require('assert');
+var expect = require('chai').expect;
+var Trie = require('../lib/trie');
+
+describe('Trie', function() {
+  var trie, route;
+
+  describe('trie.add()', function() {
+    beforeEach(function() {
+      trie = new Trie();
+      route = { fullPath: '', verb: '' };
+    });
+
+    it('has empty root node with only methods key', function() {
+      expect(trie).to.have.keys('methods');
+    });
+
+    it('registers hanlder for path: / to root node', function() {
+      trie.add(setRoute(route, '/', 'get'), 'rootHanlder()');
+      expect(trie.methods).to.have.keys('get');//{ 'get': 'rootHandler()' });
+    });
+
+    it('create a node for a path with single part, no verb-handler', function() {
+      trie.add(setRoute(route, '/Planets'));
+      expect(trie).to.have.property('Planets');
+      expect(trie.Planets).to.have.property('methods');
+    });
+
+    it('registers handler for path: /Planets', function() {
+      trie.add(setRoute(route, '/Planets', 'get'), 'handler()');
+      expect(trie).to.have.deep.property('Planets.methods.get', 'handler()');
+    });
+
+    it('registers handler for path: /Planets/count', function() {
+      trie.add(setRoute(route, '/Planets/count', 'get'), 'count()');
+      expect(trie).to.have.deep.property('Planets.count.methods.get', 'count()');
+    });
+
+    it('registers different HTTP verb handlers for the same path ', function() {
+      trie.add(setRoute(route, '/Planets', 'get'), 'getHandler()');
+      expect(trie).to.have.deep.property('Planets.methods.get', 'getHandler()');
+      trie.add(setRoute(route, '/Planets', 'post'), 'postHandler()');
+      expect(trie).to.have.deep.property('Planets.methods.post', 'postHandler()');
+      trie.add(setRoute(route, '/Planets', 'delete'), 'deleteHandler()');
+      expect(trie).to.have.deep.property('Planets.methods.delete', 'deleteHandler()');
+    });
+
+    it('While registering more than one handler for one verb+path,' +
+      ' preserves the handler which was registered first', function() {
+      trie.add(setRoute(route, '/Planets', 'get'), 'getHandler()');
+      expect(trie).to.have.deep.property('Planets.methods.get', 'getHandler()');
+      trie.add(setRoute(route, '/Planets', 'get'), 'anotherGetHandler()');
+
+      expect(trie).to.have.deep.property('Planets.methods.get')
+          .to.not.equal('anotherGetHandler()');
+    });
+  });
+
+  describe('trie.find()', function() {
+    it('should return handler for matching path', function() {
+      expect(trie).to.have.property('Planets');
+      trie.add(setRoute(route, '/Planets/count', 'get'), 'getCount()');
+      trie.add(setRoute(route, '/Planets/count', 'post'), 'postCount()');
+      var handlers = trie.find('/Planets/count');
+      expect(handlers.get).to.be.equal('getCount()');
+      expect(handlers.post).to.be.equal('postCount()');
+    });
+  });
+});
+
+function setRoute(route, fullPath, verb) {
+  route.fullPath = fullPath,
+  route.verb = verb;
+  return route;
+}