hono 0.0.1 → 0.0.5

package/README.md

@@ -1,4 +1,172 @@
-## hono
+# Hono
+
+Hono [炎] - Tiny web framework for Cloudflare Workers and others.
+
+```js
+const Hono = require('Hono')
+const app = Hono()
+
+app.get('/', () => new Response('Hono!!'))
+
+app.fire()
+```
+
+## Feature
+
+- Fast - the router is implemented with Trie-Tree structure.
+- Tiny - use only standard API.
+- Portable - zero dependencies.
+- Flexible - you can make your own middlewares.
+- Optimized - for Cloudflare Workers and Fastly Compute@Edge.
+
+## Benchmark
+
+```
+hono x 813,001 ops/sec ±2.96% (75 runs sampled)
+itty-router x 160,415 ops/sec ±3.31% (85 runs sampled)
+sundar x 307,438 ops/sec ±4.77% (73 runs sampled)
+Fastest is hono
+✨  Done in 37.03s.
+```
+
+## Install
+
+```
+$ yarn add hono
+```
+
+or
+
+```sh
+$ npm install hono
+```
+
+## Methods
+
+- app.**HTTP_METHOD**(path, callback)
+- app.**all**(path, callback)
+- app.**route**(path)
+- app.**use**(path, middleware)
+
+## Routing
+
+### Basic
+
+`app.HTTP_METHOD`
+
+```js
+// HTTP Methods
+app.get('/', () => new Response('GET /'))
+app.post('/', () => new Response('POST /'))
+
+// Wildcard
+app.get('/wild/*/card', () => {
+  return new Response('GET /wild/*/card')
+})
+```
+
+`app.all`
+
+```js
+// Any HTTP methods
+app.all('/hello', () => new Response('ALL Method /hello'))
+```
+
+### Named Parameter
+
+```js
+app.get('/user/:name', (c) => {
+  const name = c.req.params('name')
+  ...
+})
+```
+
+### Regexp
+
+```js
+app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
+  const date = c.req.params('date')
+  const title = c.req.params('title')
+  ...
+```
+
+### Chained Route
+
+```js
+app
+  .route('/api/book')
+    .get(() => {...})
+    .post(() => {...})
+    .put(() => {...})
+```
+
+## Middleware
+
+```js
+const logger = (c, next) => {
+  console.log(`[${c.req.method}] ${c.req.url}`)
+  next()
+}
+
+const addHeader = (c, next) => {
+  next()
+  c.res.headers.add('x-message', 'This is middleware!')
+}
+
+app = app.use('*', logger)
+app = app.use('/message/*', addHeader)
+
+app.get('/message/hello', () => 'Hello Middleware!')
+```
+
+## Context
+
+### req
+
+```js
+app.get('/hello', (c) => {
+  const userAgent = c.req.headers('User-Agent')
+  ...
+})
+```
+
+### res
+
+```js
+app.use('/', (c, next) => {
+  next()
+  c.res.headers.append('X-Debug', 'Debug message')
+})
+```
+
+## Request
+
+### query
+
+```js
+app.get('/search', (c) => {
+  const query = c.req.query('q')
+  ...
+})
+```
+
+### params
+
+```js
+app.get('/entry/:id', (c) => {
+  const id = c.req.params('id')
+  ...
+})
+```
+
+## Related projects
+
+- koa <https://github.com/koajs/koa>
+- express <https://github.com/expressjs/express>
+- oak <https://github.com/oakserver/oak>
+- itty-router <https://github.com/kwhitley/itty-router>
+- Sunder <https://github.com/SunderJS/sunder>
+- goblin <https://github.com/bmf-san/goblin>
 
 ## Author
 

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "hono",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "Minimal web framework for Cloudflare Workers",
   "main": "src/hono.js",
   "scripts": {
-    "test": "jest --verbose"
+    "test": "jest"
   },
   "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yusukebe/hono.git"
+  },
+  "homepage": "https://github.com/yusukebe/hono",
   "devDependencies": {
     "jest": "^27.4.5",
     "node-fetch": "^2.6.6"
   }
-}
+}

package/src/compose.js

@@ -0,0 +1,22 @@
+// Based on the code in the MIT licensed `koa-compose` package.
+const compose = (middleware) => {
+  return function (context, next) {
+    let index = -1
+    return dispatch(0)
+    function dispatch(i) {
+      if (i <= index)
+        return Promise.reject(new Error('next() called multiple times'))
+      index = i
+      let fn = middleware[i]
+      if (i === middleware.length) fn = next
+      if (!fn) return Promise.resolve()
+      try {
+        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)))
+      } catch (err) {
+        return Promise.reject(err)
+      }
+    }
+  }
+}
+
+module.exports = compose

package/src/compose.test.js

@@ -0,0 +1,42 @@
+const compose = require('./compose')
+
+describe('compose middleware', () => {
+  const middleware = []
+
+  const a = (c, next) => {
+    c.req['log'] = 'log'
+    next()
+  }
+  middleware.push(a)
+
+  const b = (c, next) => {
+    next()
+    c.res['header'] = `${c.res.header}-custom-header`
+  }
+  middleware.push(b)
+
+  const handler = (c, next) => {
+    c.req['log'] = `${c.req.log} message`
+    next()
+    c.res = { message: 'new response' }
+  }
+  middleware.push(handler)
+
+  const request = {}
+  const response = {}
+
+  it('Request', () => {
+    const c = { req: request, res: response }
+    const composed = compose(middleware)
+    composed(c)
+    expect(c.req['log']).not.toBeNull()
+    expect(c.req['log']).toBe('log message')
+  })
+  it('Response', () => {
+    const c = { req: request, res: response }
+    const composed = compose(middleware)
+    composed(c)
+    expect(c.res['header']).not.toBeNull()
+    expect(c.res['message']).toBe('new response')
+  })
+})

package/src/hono.js

@@ -1,77 +1,144 @@
-const Router = require('./router')
+'use strict'
 
-class Route {
-  constructor(method, handler) {
-    this.method = method;
-    this.handler = handler;
+const Node = require('./node')
+const compose = require('./compose')
+const defaultFilter = require('./middleware/defaultFilter')
+
+class Router {
+  constructor() {
+    this.node = new Node()
+    this.tempPath = '/'
+  }
+
+  add(method, path, ...handlers) {
+    this.node.insert(method, path, handlers)
+  }
+
+  match(method, path) {
+    return this.node.search(method, path)
   }
 }
 
-class App {
+const getPathFromURL = (url) => {
+  // XXX
+  const match = url.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/)
+  return match[5]
+}
+
+class Hono {
   constructor() {
-    this.router = new Router();
+    this.router = new Router()
+    this.middlewareRouter = new Router()
+    this.middlewareRouters = []
   }
 
-  addRoute(method, path, handler) {
-    this.router.add(path, new Route(method, handler))
+  get(...args) {
+    return this.addRoute('GET', ...args)
+  }
+  post(...args) {
+    return this.addRoute('POST', ...args)
+  }
+  put(...args) {
+    return this.addRoute('PUT', ...args)
+  }
+  delete(...args) {
+    return this.addRoute('DELETE', ...args)
+  }
+  patch(...args) {
+    return this.addRoute('PATCH', ...args)
   }
 
-  handle(event) {
-    const response = this.dispatch(event.request)
-    return event.respondWith(response)
+  addRoute(method, ...args) {
+    method = method.toUpperCase()
+    if (args.length === 1) {
+      this.router.add(method, this.router.tempPath, ...args)
+    } else {
+      this.router.add(method, ...args)
+    }
+    return this
   }
 
-  dispatch(request) {
-    const url = new URL(request.url)
-    const path = url.pathname
-    const match = this.router.match(path)
+  getRouter() {
+    return this.router
+  }
 
-    if (!match) {
-      return this.notFound()
-    }
+  route(path) {
+    this.router.tempPath = path
+    return this
+  }
+
+  use(path, middleware) {
+    const router = new Router()
+    router.add('all', path, middleware)
+    this.middlewareRouters.push(router)
+  }
+
+  async matchRoute(method, path) {
+    const res = this.router.match(method, path)
+    return res
+  }
 
-    const method = request.method.toLowerCase()
-    const route = match[0]
-    if (route.method == method) {
-      const handler = route.handler
-      return handler(request)
+  // XXX
+  async createContext(req, res) {
+    return {
+      req: req,
+      res: res,
+      newResponse: (params) => {
+        return new Response(params)
+      },
     }
-    return this.notFound()
   }
 
-  notFound() {
-    return new Response('Not Found', {
-      status: 404,
-      headers: {
-        'content-type': 'text/plain'
+  async dispatch(request, response) {
+    const [method, path] = [request.method, getPathFromURL(request.url)]
+
+    const result = await this.matchRoute(method, path)
+    if (!result) return this.notFound()
+
+    request.params = (key) => result.params[key]
+
+    let handler = result.handler[0] // XXX
+
+    const middleware = [defaultFilter] // add defaultFilter later
+
+    for (const mr of this.middlewareRouters) {
+      const mwResult = mr.match('all', path)
+      if (mwResult) {
+        middleware.push(...mwResult.handler)
       }
-    })
+    }
+
+    let wrappedHandler = async (context, next) => {
+      context.res = handler(context)
+      next()
+    }
+
+    middleware.push(wrappedHandler)
+    const composed = compose(middleware)
+    const c = await this.createContext(request, response)
+
+    composed(c)
+
+    return c.res
+  }
+
+  async handleEvent(event) {
+    return this.dispatch(event.request, {}) // XXX
   }
 
   fire() {
-    addEventListener("fetch", (event) => {
-      this.handle(event)
+    addEventListener('fetch', (event) => {
+      event.respondWith(this.handleEvent(event))
     })
   }
-}
 
-const proxyHandler = {
-  get: (target, prop) => (...args) => {
-    if (target.constructor.prototype.hasOwnProperty(prop)) {
-      return target[prop](args[0])
-    } else {
-      target.addRoute(prop, args[0], args[1])
-      return
-    }
+  notFound() {
+    return new Response('Not Found', { status: 404 })
   }
 }
 
-const app = new App()
-
-function Hono() {
-  return new Proxy(
-    app, proxyHandler
-  )
+const CreateApp = () => {
+  return new Hono()
 }
 
-module.exports = Hono
+module.exports = CreateApp

package/src/hono.test.js

@@ -1,29 +1,88 @@
 const Hono = require('./hono')
 const fetch = require('node-fetch')
 
-const app = new Hono()
-
-describe('GET match', () => {
+describe('GET Request', () => {
+  const app = Hono()
   app.get('/hello', () => {
     return new fetch.Response('hello', {
-      status: 200
+      status: 200,
     })
   })
   app.notFound = () => {
     return new fetch.Response('not found', {
-      status: 404
+      status: 404,
     })
   }
-  it('GET /hello is ok', () => {
+  it('GET /hello is ok', async () => {
     let req = new fetch.Request('https://example.com/hello')
-    let res = app.dispatch(req)
+    let res = await app.dispatch(req, new fetch.Response())
     expect(res).not.toBeNull()
     expect(res.status).toBe(200)
+    expect(await res.text()).toBe('hello')
   })
-  it('GET / is not found', () => {
+  it('GET / is not found', async () => {
     let req = new fetch.Request('https://example.com/')
-    let res = app.dispatch(req)
+    let res = await app.dispatch(req, new fetch.Response())
     expect(res).not.toBeNull()
     expect(res.status).toBe(404)
   })
 })
+
+describe('params and query', () => {
+  const app = Hono()
+
+  app.get('/entry/:id', async (c) => {
+    const id = await c.req.params('id')
+    return new fetch.Response(`id is ${id}`, {
+      status: 200,
+    })
+  })
+
+  app.get('/search', async (c) => {
+    const name = await c.req.query('name')
+    return new fetch.Response(`name is ${name}`, {
+      status: 200,
+    })
+  })
+
+  it('params of /entry/:id is found', async () => {
+    let req = new fetch.Request('https://example.com/entry/123')
+    let res = await app.dispatch(req)
+    expect(res.status).toBe(200)
+    expect(await res.text()).toBe('id is 123')
+  })
+  it('query of /search?name=sam is found', async () => {
+    let req = new fetch.Request('https://example.com/search?name=sam')
+    let res = await app.dispatch(req)
+    expect(res.status).toBe(200)
+    expect(await res.text()).toBe('name is sam')
+  })
+})
+
+describe('Middleware', () => {
+  const app = Hono()
+
+  const logger = (c, next) => {
+    console.log(`${c.req.method} : ${c.req.url}`)
+    next()
+  }
+
+  const customHeader = (c, next) => {
+    next()
+    c.res.headers.append('x-message', 'custom-header')
+  }
+
+  app.use('*', logger)
+  app.use('/hello', customHeader)
+  app.get('/hello', () => {
+    return new fetch.Response('hello')
+  })
+
+  it('logging and custom header', async () => {
+    let req = new fetch.Request('https://example.com/hello')
+    let res = await app.dispatch(req)
+    expect(res.status).toBe(200)
+    expect(await res.text()).toBe('hello')
+    expect(await res.headers.get('x-message')).toBe('custom-header')
+  })
+})

package/src/middleware/defaultFilter.js

@@ -0,0 +1,19 @@
+const defaultFilter = (c, next) => {
+  c.req.query = (key) => {
+    const url = new URL(c.req.url)
+    return url.searchParams.get(key)
+  }
+
+  next()
+
+  if (typeof c.res === 'string') {
+    c.res = new Reponse(c.res, {
+      status: 200,
+      headers: {
+        'Conten-Type': 'text/plain',
+      },
+    })
+  }
+}
+
+module.exports = defaultFilter

package/src/node.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const { splitPath, getPattern } = require('./util')
+
+const METHOD_NAME_OF_ALL = 'all'
+
+const createResult = (handler, params) => {
+  return { handler: handler, params: params }
+}
+
+const noRoute = () => {
+  return null
+}
+
+function Node(method, handler, children) {
+  this.children = children || {}
+  this.method = {}
+  if (method && handler) {
+    this.method[method] = handler
+  }
+}
+
+Node.prototype.insert = function (method, path, handler) {
+  let curNode = this
+  const parts = splitPath(path)
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i]
+    if (Object.keys(curNode.children).includes(p)) {
+      curNode = curNode.children[p]
+      continue
+    }
+    curNode.children[p] = new Node(method, handler)
+    curNode = curNode.children[p]
+  }
+  curNode.method[method] = handler
+  return curNode
+}
+
+Node.prototype.search = function (method, path) {
+  let curNode = this
+
+  const params = {}
+  const parts = splitPath(path)
+
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i]
+    const nextNode = curNode.children[p]
+    if (nextNode) {
+      curNode = nextNode
+      continue
+    }
+
+    let isParamMatch = false
+    const keys = Object.keys(curNode.children)
+    for (let j = 0; j < keys.length; j++) {
+      const key = keys[j]
+      // Wildcard
+      if (key === '*') {
+        curNode = curNode.children['*']
+        isParamMatch = true
+        break
+      }
+      const pattern = getPattern(key)
+      if (pattern) {
+        const match = p.match(new RegExp(pattern[1]))
+        if (match) {
+          const k = pattern[0]
+          params[k] = match[1]
+          curNode = curNode.children[key]
+          isParamMatch = true
+          break
+        }
+        return noRoute()
+      }
+    }
+
+    if (isParamMatch === false) {
+      return noRoute()
+    }
+  }
+
+  const handler = curNode.method[METHOD_NAME_OF_ALL] || curNode.method[method]
+
+  if (!handler) {
+    return noRoute()
+  }
+
+  return createResult(handler, params)
+}
+
+module.exports = Node

package/src/node.test.js

@@ -0,0 +1,135 @@
+const Node = require('./node')
+
+describe('Root Node', () => {
+  const node = new Node()
+  node.insert('get', '/', 'get root')
+  it('get /', () => {
+    let res = node.search('get', '/')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('get root')
+    expect(node.search('get', '/hello')).toBeNull()
+  })
+})
+
+describe('Root Node id not defined', () => {
+  const node = new Node()
+  node.insert('get', '/hello', 'get hello')
+  it('get /', () => {
+    expect(node.search('get', '/')).toBeNull()
+  })
+})
+
+describe('All with *', () => {
+  const node = new Node()
+  node.insert('get', '*', 'get all')
+  it('get /', () => {
+    expect(node.search('get', '/')).not.toBeNull()
+    expect(node.search('get', '/hello')).not.toBeNull()
+  })
+})
+
+describe('Basic Usage', () => {
+  const node = new Node()
+  node.insert('get', '/hello', 'get hello')
+  node.insert('post', '/hello', 'post hello')
+  node.insert('get', '/hello/foo', 'get hello foo')
+
+  it('get, post /hello', () => {
+    expect(node.search('get', '/')).toBeNull()
+    expect(node.search('post', '/')).toBeNull()
+
+    expect(node.search('get', '/hello').handler).toBe('get hello')
+    expect(node.search('post', '/hello').handler).toBe('post hello')
+    expect(node.search('put', '/hello')).toBeNull()
+  })
+  it('get /nothing', () => {
+    expect(node.search('get', '/nothing')).toBeNull()
+  })
+  it('/hello/foo, /hello/bar', () => {
+    expect(node.search('get', '/hello/foo').handler).toBe('get hello foo')
+    expect(node.search('post', '/hello/foo')).toBeNull()
+    expect(node.search('get', '/hello/bar')).toBeNull()
+  })
+  it('/hello/foo/bar', () => {
+    expect(node.search('get', '/hello/foo/bar')).toBeNull()
+  })
+})
+
+describe('Name path', () => {
+  const node = new Node()
+  it('get /entry/123', () => {
+    node.insert('get', '/entry/:id', 'get entry')
+    let res = node.search('get', '/entry/123')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('get entry')
+    expect(res.params).not.toBeNull()
+    expect(res.params['id']).toBe('123')
+    expect(res.params['id']).not.toBe('1234')
+  })
+
+  it('get /entry/456/comment', () => {
+    node.insert('get', '/entry/:id', 'get entry')
+    let res = node.search('get', '/entry/456/comment')
+    expect(res).toBeNull()
+  })
+
+  it('get /entry/789/comment/123', () => {
+    node.insert('get', '/entry/:id/comment/:comment_id', 'get comment')
+    let res = node.search('get', '/entry/789/comment/123')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('get comment')
+    expect(res.params['id']).toBe('789')
+    expect(res.params['comment_id']).toBe('123')
+  })
+
+  it('get /map/:location/events', () => {
+    node.insert('get', '/map/:location/events', 'get events')
+    let res = node.search('get', '/map/yokohama/events')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('get events')
+    expect(res.params['location']).toBe('yokohama')
+  })
+})
+
+describe('Wildcard', () => {
+  const node = new Node()
+  it('/wildcard-abc/xxxxxx/wildcard-efg', () => {
+    node.insert('get', '/wildcard-abc/*/wildcard-efg', 'wildcard')
+    let res = node.search('get', '/wildcard-abc/xxxxxx/wildcard-efg')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('wildcard')
+  })
+})
+
+describe('Regexp', () => {
+  const node = new Node()
+  node.insert('get', '/regex-abc/:id{[0-9]+}/comment/:comment_id{[a-z]+}', 'regexp')
+  it('/regexp-abc/123/comment/abc', () => {
+    res = node.search('get', '/regex-abc/123/comment/abc')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('regexp')
+    expect(res.params['id']).toBe('123')
+    expect(res.params['comment_id']).toBe('abc')
+  })
+  it('/regexp-abc/abc', () => {
+    res = node.search('get', '/regex-abc/abc')
+    expect(res).toBeNull()
+  })
+  it('/regexp-abc/123/comment/123', () => {
+    res = node.search('get', '/regex-abc/123/comment/123')
+    expect(res).toBeNull()
+  })
+})
+
+describe('All', () => {
+  const node = new Node()
+  node.insert('all', '/all-methods', 'all methods')
+  it('/all-methods', () => {
+    res = node.search('get', '/all-methods')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('all methods')
+    res = node.search('put', '/all-methods')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('all methods')
+  })
+})

package/src/router.test.js

@@ -1,66 +1,88 @@
-const Router = require('./router')
-
-let router = new Router()
-
-describe('root match', () => {
-  it('/ match', () => {
-    router.add('/', 'root')
-    let match = router.match('/')
-    expect(match).not.toBeNull()
-    expect(match[0]).toBe('root')
-    match = router.match('/foo')
-    expect(match).toBeNull()
-  })
+const App = require('./hono')
+
+describe('Basic Usage', () => {
+  const router = App()
+
+  it('get, post hello', async () => {
+    router.get('/hello', 'get hello')
+    router.post('/hello', 'post hello')
+
+    let res = await router.matchRoute('GET', '/hello')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('get hello')
 
-  it('/hello match', () => {
-    router.add('/hello', 'hello')
-    match = router.match('/foo')
-    expect(match).toBeNull()
-    match = router.match('/hello')
-    expect(match[0]).toBe('hello')
+    res = await router.matchRoute('POST', '/hello')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('post hello')
+
+    res = await router.matchRoute('PUT', '/hello')
+    expect(res).toBeNull()
+
+    res = await router.matchRoute('GET', '/')
+    expect(res).toBeNull()
   })
 })
 
-describe('path match', () => {
-  router.add('/entry/:id', 'entry-id')
-  router.add('/entry/:id/:comment', 'entry-id-comment')
-  router.add('/year/:year{[0-9]{4}}/:month{[0-9]{2}}', 'date-regex')
+describe('Complex', () => {
+  let router = App()
 
-  it('entry id match', () => {
-    const match = router.match('/entry/123')
-    expect(match[0]).toBe('entry-id')
-    expect(match[1]['id']).toBe('123')
+  it('Named Param', async () => {
+    router.get('/entry/:id', 'get entry')
+    res = await router.matchRoute('GET', '/entry/123')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('get entry')
+    expect(res.params['id']).toBe('123')
   })
 
-  it('entry id and comment match', () => {
-    const match = router.match('/entry/123/45678')
-    expect(match[0]).toBe('entry-id-comment')
-    expect(match[1]['id']).toBe('123')
-    expect(match[1]['comment']).toBe('45678')
+  it('Wildcard', async () => {
+    router.get('/wild/*/card', 'get wildcard')
+    res = await router.matchRoute('GET', '/wild/xxx/card')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('get wildcard')
   })
 
-  it('date-regex', () => {
-    const match = router.match('/year/2021/12')
-    expect(match[0]).toBe('date-regex')
-    expect(match[1]['year']).toBe('2021')
-    expect(match[1]['month']).toBe('12')
+  it('Regexp', async () => {
+    router.get('/post/:date{[0-9]+}/:title{[a-z]+}', 'get post')
+    res = await router.matchRoute('GET', '/post/20210101/hello')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('get post')
+    expect(res.params['date']).toBe('20210101')
+    expect(res.params['title']).toBe('hello')
+    res = await router.matchRoute('GET', '/post/onetwothree')
+    expect(res).toBeNull()
+    res = await router.matchRoute('GET', '/post/123/123')
+    expect(res).toBeNull()
   })
+})
 
-  it('not match', () => {
-    let match = router.match('/foo')
-    expect(match).toBeNull()
-    match = router.match('/year/abc')
-    expect(match).toBeNull()
+describe('Chained Route', () => {
+  let router = App()
+
+  it('Return rooter object', async () => {
+    router = router.patch('/hello', 'patch hello')
+    expect(router).not.toBeNull()
+    router = router.delete('/hello', 'delete hello')
+    res = await router.matchRoute('DELETE', '/hello')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('delete hello')
   })
-})
 
-describe('wildcard', () => {
-  it('match', () => {
-    router = new Router()
-    router.add('/abc/*/def')
-    let match = router.match('/abc/xxx/def')
-    expect(match).not.toBeNull()
-    match = router.match('/abc/xxx/abc')
-    expect(match).toBeNull()
+  it('Chain with route method', async () => {
+    router.route('/api/book').get('get book').post('post book').put('put book')
+
+    res = await router.matchRoute('GET', '/api/book')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('get book')
+
+    res = await router.matchRoute('POST', '/api/book')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('post book')
+
+    res = await router.matchRoute('PUT', '/api/book')
+    expect(res).not.toBeNull()
+    expect(res.handler[0]).toBe('put book')
+
+    res = await router.matchRoute('DELETE', '/api/book')
+    expect(res).toBeNull()
   })
 })

package/src/util.js

@@ -0,0 +1,26 @@
+const splitPath = (path) => {
+  path = path.split(/\//) // faster than path.split('/')
+  if (path[0] === '') {
+    path.shift()
+  }
+  return path
+}
+
+const getPattern = (label) => {
+  // :id{[0-9]+}  => ([0-9]+)
+  // :id          => (.+)
+  //const name = ''
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/)
+  if (match) {
+    if (match[2]) {
+      return [match[1], '(' + match[2] + ')']
+    } else {
+      return [match[1], '(.+)']
+    }
+  }
+}
+
+module.exports = {
+  splitPath,
+  getPattern,
+}

package/src/util.test.js

@@ -0,0 +1,29 @@
+const { splitPath, getPattern, getParamName } = require('./util')
+
+describe('Utility methods', () => {
+  it('splitPath', () => {
+    let ps = splitPath('/')
+    expect(ps[0]).toBe('')
+    ps = splitPath('/hello')
+    expect(ps[0]).toBe('hello')
+    ps = splitPath('*')
+    expect(ps[0]).toBe('*')
+    ps = splitPath('/wildcard-abc/*/wildcard-efg')
+    expect(ps[0]).toBe('wildcard-abc')
+    expect(ps[1]).toBe('*')
+    expect(ps[2]).toBe('wildcard-efg')
+    ps = splitPath('/map/:location/events')
+    expect(ps[0]).toBe('map')
+    expect(ps[1]).toBe(':location')
+    expect(ps[2]).toBe('events')
+  })
+
+  it('getPattern', () => {
+    let res = getPattern(':id')
+    expect(res[0]).toBe('id')
+    expect(res[1]).toBe('(.+)')
+    res = getPattern(':id{[0-9]+}')
+    expect(res[0]).toBe('id')
+    expect(res[1]).toBe('([0-9]+)')
+  })
+})

package/src/router.js

@@ -1,116 +0,0 @@
-// Ref: https://github.com/bmf-san/goblin
-
-class Router {
-  constructor() {
-    this.node = new Node({ label: "/" })
-  }
-  add(path, stuff) {
-    this.node.insert(path, stuff);
-  }
-  match(path) {
-    return this.node.search(path);
-  }
-}
-
-class Node {
-  constructor({ label, stuff, children } = {}) {
-    this.label = label || "";
-    this.stuff = stuff || {};
-    this.children = children || [];
-  }
-
-  insert(path, stuff) {
-    let curNode = this
-    if (path == '/') {
-      curNode.label = path
-      curNode.stuff = stuff
-    }
-    const ps = this.splitPath(path)
-    for (const p of ps) {
-      let nextNode = curNode.children[p]
-      if (nextNode) {
-        curNode = nextNode
-      } else {
-        curNode.children[p] = new Node({ label: p, stuff: stuff, children: [] })
-        curNode = curNode.children[p]
-      }
-    }
-  }
-
-  splitPath(path) {
-    const ps = []
-    for (const p of path.split('/')) {
-      if (p) {
-        ps.push(p)
-      }
-    }
-    return ps
-  }
-
-  getPattern(label) {
-    // :id{[0-9]+}  → [0-9]+$
-    // :id          → (.+)
-    const match = label.match(/^\:.+?\{(.+)\}$/)
-    if (match) {
-      return '(' + match[1] + ')'
-    }
-    return '(.+)'
-  }
-
-  getParamName(label) {
-    const match = label.match(/^\:([^\{\}]+)/)
-    if (match) {
-      return match[1]
-    }
-  }
-
-  noRoute() {
-    return null
-  }
-
-  search(path) {
-
-    let curNode = this
-    const params = {}
-
-    for (const p of this.splitPath(path)) {
-      const nextNode = curNode.children[p]
-      if (nextNode) {
-        curNode = nextNode
-        continue
-      }
-      if (Object.keys(curNode.children).length == 0) {
-        if (curNode.label != p) {
-          return this.noRoute()
-        }
-        break
-      }
-      let isParamMatch = false
-      for (const key in curNode.children) {
-        if (key == "*") { // Wildcard
-          curNode = curNode.children[key]
-          isParamMatch = true
-          break
-        }
-        if (key.match(/^:/)) {
-          const pattern = this.getPattern(key)
-          const match = p.match(new RegExp(pattern))
-          if (match) {
-            const k = this.getParamName(key)
-            params[k] = match[0]
-            curNode = curNode.children[key]
-            isParamMatch = true
-            break
-          }
-          return this.noRoute()
-        }
-      }
-      if (isParamMatch == false) {
-        return this.noRoute()
-      }
-    }
-    return [curNode.stuff, params]
-  }
-}
-
-module.exports = Router