Router Improvements - Add support for deep nested routers + Session storage fixes

lib/config.mjs

@@ -4,7 +4,15 @@ import fs from 'fs'
 const ROOT = process.cwd()
 const configPath = path.join(ROOT, 'turbo-serv.json')
 
-const configDefault = {static: {dir: 'public'}}
+const configDefault = { static: { dir: 'public' } }
+const sessionDefault = {
+  store: 'memory',
+  options: {
+    host: '0.0.0.0',
+    port: 0,
+    expire: 120
+  }
+}
 
 let config
 try {
@@ -13,6 +21,7 @@ try {
 } catch (e) {
   console.log('Parser Error in config file')
   config = configDefault
+  config.session = sessionDefault
 }
 
 config.ROOT = ROOT

lib/handlers/session.mjs

@@ -1,22 +1,12 @@
 import uid from 'uid-safe'
 import signature from 'cookie-signature'
-import MemoryStore from '../stores/memory'
-// import RedisStore from '../stores/redis'
-// import MongoStore from '../stores/mongo'
+import { DataBase, dbOptions } from './../../lib/stores/store'
 
-let options = {
-  // host: '127.0.0.2',
-  // port: 5432,
-  // expire: 120, // 2 min
-  // database: RedisStore
-  // database: MongoStore
-}
-let DB = options.database || MemoryStore
-let sessionStoreDB = new DB()
-let sessionStore = sessionStoreDB.init(options)
+let sessionStoreDB = new DataBase()
+let sessionStore = sessionStoreDB.init(dbOptions)
 
 class Session {
-  async init (req, res) {
+  async init(req, res) {
     let data
     const SECRET = 'session'
     if (req.cookies && req.cookies.sess_id) {
@@ -34,33 +24,33 @@ class Session {
     this.sess_id = data.id
     this.data = data
     res.setCookie('sess_id', signature.sign(this.sess_id, SECRET), {
-      maxAge: options.expire || 60 * 60 * 24 * 7 // 1 week
+      maxAge: dbOptions.expire
     })
   }
 
-  async set (key, value) {
+  async set(key, value) {
     let data = sessionStore.get(this.sess_id)
     if (data instanceof Promise) {
       data = await data
     }
     if (!data) {
-      data = {sess_id: this.sess_id}
+      data = { sess_id: this.sess_id }
     }
     data[key] = value
     await sessionStore.set(this.sess_id, data)
   }
 
-  get (key) {
+  get(key) {
     let result = sessionStore.get(this.sess_id)
     return result
   }
 
-  delete () {
+  delete() {
     sessionStore.delete(this.sess_id)
   }
 }
 
-export default async function () {
+export default async function() {
   if (sessionStore instanceof Promise) {
     sessionStore = await sessionStore
   }

lib/router.mjs

@@ -1,20 +1,52 @@
-
 export default class Router {
-  constructor (path = '/') {
-    this.routes = {GET: {}, POST: {}}
+  constructor(path = '/') {
+    this.routes = { GET: {}, POST: {} }
     this.path = path
     this.isRouter = true
+    this.routers = []
   }
 
-  get (path, fn) {
+  get(path, fn) {
     this.routes.GET[path] = fn
   }
 
-  post (path, fn) {
+  post(path, fn) {
     this.routes.POST[path] = fn
   }
 
-  getHandler (method, path) {
-    return this.routes[method][path]
+  addRouter(router) {
+    this.routers.push(router)
+  }
+
+  getHandler(method, path) {
+    const handler = this.routes[method][path]
+    return typeof handler == 'function'
+      ? handler
+      : this.findRouter(method, path, this.routers)
+  }
+
+  findRouter(method, path, routers) {
+    if (!Array.isArray(routers)) routers = [routers]
+    for (const router of routers) {
+      if (path.startsWith(router.path)) {
+        path = path.slice(router.path.length)
+        const deepRouter = this.hasDeepRouter(
+          router,
+          path
+            .slice(1)
+            .split('/')
+            .map(token => `/${token}`)
+            .shift()
+        )
+        return deepRouter
+          ? this.findRouter(method, path, deepRouter)
+          : router.routes[method][path]
+      }
+    }
+  }
+
+  hasDeepRouter(router, pathToken) {
+    const route = router.routers.filter(route => route.path === pathToken)
+    return route ? route[0] : null
   }
 }

lib/server.mjs

@@ -8,55 +8,50 @@ import finalHandler from './handlers/final'
 import Router from './router'
 import sessionHandler from './handlers/session'
 
-const HANDLERS = [
-  staticHandler,
-  cookieParser,
-  sessionHandler,
-  bodyParser
-]
+const HANDLERS = [staticHandler, cookieParser, sessionHandler, bodyParser]
 
 export default class App {
-  constructor () {
-    this.server = turbo.createServer(function (req, res) {
+  constructor() {
+    this.server = turbo.createServer(function(req, res) {
       Object.assign(req, Request)
       Object.assign(res, Response)
       req.res = res
       req._handlers = HANDLERS
       res.req = req
     })
-    this.addRouter(new Router())
+    this.addRoute(new Router())
   }
-
-  addRouter (router) {
+  addRoute(router) {
     if (!this.router) {
       this.router = router
-      HANDLERS.push(function () {
+      HANDLERS.push(function() {
         const handler = router.getHandler(this.method, this.url)
         if (handler) {
           return this.callHandlers(handler)
         }
         return null
-      },
-      finalHandler)
+      }, finalHandler)
     }
   }
 
-  getRouter () {
+  getRouter() {
     return this.router
   }
 
-  listen (port) {
+  listen(port) {
     this.PORT = process.env.PORT || port || 5000
     this.server.listen(this.PORT)
     console.log('Server running on PORT ' + this.PORT)
   }
 
-  close () {
+  close() {
     this.server.close(_ => {
       console.log('Shutting down App!')
       process.exit()
     })
   }
 
-  static get Router () { return Router }
+  static get Router() {
+    return Router
+  }
 }

lib/stores/memory.mjs

@@ -1,15 +1,20 @@
 export default class MemoryStore {
-  init () {
+  init(options) {
     this.store = {}
+    this.expiryTime = options.expire
     return this
   }
-  set (key, value) {
+  set(key, value) {
     this.store[key] = value
+
+    setTimeout(() => {
+      this.delete(key)
+    }, this.expiryTime * 1000)
   }
-  get (key) {
+  get(key) {
     return this.store[key]
   }
-  delete (key) {
+  delete(key) {
     delete this.store[key]
   }
 }

lib/stores/mongo.mjs

@@ -1,30 +1,39 @@
 import mongo from 'mongodb'
 
 export default class mongoStore {
-  async init (options) {
-    let url = options.url || 'mongodb://localhost:27017/'
+  async init(options) {
+    let url = `mongodb://${options.host}:${options.port}/`
     this.client = mongo.MongoClient
     let db = await this.client.connect(url)
-    console.log('mongo db connected...')
+    console.log('Connected to mongo...')
     this.store = db.db('session-data')
+    this.store
+      .collection('sessions')
+      .createIndex({ createdAt: -1 }, { expireAfterSeconds: options.expire })
     return this
   }
 
-  set (hash, value) {
+  set(hash, value) {
     let data = {}
     data['sess_id'] = hash
     data['data'] = value
     let obj = {}
     obj['sess_id'] = hash
-    this.store.collection('sessions').replaceOne(obj, { $set: data }, { upsert: true }, (err, res) => {
-      if (err) {
-        console.log(err)
-      }
-    })
+    obj['createdAt'] = new Date()
+    this.store
+      .collection('sessions')
+      .replaceOne(obj, { $set: data }, { upsert: true }, (err, res) => {
+        if (err) {
+          console.log(err)
+        }
+      })
   }
 
-  async get (key) {
-    let result = await this.store.collection('sessions').find({ sess_id: key }).toArray()
+  async get(key) {
+    let result = await this.store
+      .collection('sessions')
+      .find({ sess_id: key })
+      .toArray()
     if (result.length >= 1) {
       result = result[0]
       if (result) {
@@ -34,7 +43,7 @@ export default class mongoStore {
     return null
   }
 
-  delete (key) {
+  delete(key) {
     this.store.collection('sessions').remove({ sess_id: key })
   }
 }

lib/stores/store.mjs

@@ -0,0 +1,19 @@
+import MemoryStore from './memory'
+import RedisStore from './redis'
+import MongoStore from './mongo'
+
+import config from './../config'
+
+// Available storage types: In-Memory, Redis, Mongo
+
+let storeConfig = {
+  memory: MemoryStore,
+  redis: RedisStore,
+  mongo: MongoStore
+}
+// Set prefered DB by setting dbConfig['mongo' | 'redis' | memory]
+
+const DataBase = storeConfig[config.session.store]
+const dbOptions = config.session.options
+
+export { DataBase, dbOptions }

package.json

@@ -28,8 +28,10 @@
     "cookie-signature": "^1.1.0",
     "formidable": "^1.2.1",
     "mime": "^2.2.0",
+    "mongodb": "^3.0.6",
     "node-fetch": "^2.0.0",
     "querystring": "^0.2.0",
+    "redis": "^2.8.0",
     "turbo-http": "^0.3.0",
     "uid-safe": "^2.1.5"
   },