hono 0.0.4 → 0.0.5

package/README.md

@@ -3,6 +3,7 @@
 Hono [炎] - Tiny web framework for Cloudflare Workers and others.
 
 ```js
+const Hono = require('Hono')
 const app = Hono()
 
 app.get('/', () => new Response('Hono!!'))
@@ -16,7 +17,17 @@ app.fire()
 - Tiny - use only standard API.
 - Portable - zero dependencies.
 - Flexible - you can make your own middlewares.
-- Optimized - for Cloudflare Workers.
+- 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
 
@@ -50,7 +61,7 @@ app.post('/', () => new Response('POST /'))
 
 // Wildcard
 app.get('/wild/*/card', () => {
-  return new Reponse('GET /wild/*/card')
+  return new Response('GET /wild/*/card')
 })
 ```
 
@@ -58,7 +69,7 @@ app.get('/wild/*/card', () => {
 
 ```js
 // Any HTTP methods
-app.all('/hello', () => 'ALL Method /hello')
+app.all('/hello', () => new Response('ALL Method /hello'))
 ```
 
 ### Named Parameter
@@ -152,6 +163,7 @@ app.get('/entry/:id', (c) => {
 
 - 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>

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "hono",
-  "version": "0.0.4",
+  "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",
@@ -17,4 +17,4 @@
     "jest": "^27.4.5",
     "node-fetch": "^2.6.6"
   }
-}
+}

package/src/hono.js

@@ -2,7 +2,7 @@
 
 const Node = require('./node')
 const compose = require('./compose')
-const filter = require('./middleware/filter')
+const defaultFilter = require('./middleware/defaultFilter')
 
 class Router {
   constructor() {
@@ -15,91 +15,107 @@ class Router {
   }
 
   match(method, path) {
-    method = method.toLowerCase()
     return this.node.search(method, path)
   }
 }
 
-const proxyHandler = {
-  get:
-    (target, prop) =>
-    (...args) => {
-      if (target.constructor.prototype.hasOwnProperty(prop)) {
-        return target[prop](...args)
-      } else {
-        if (args.length == 1) {
-          return target.addRoute(prop, target.router.tempPath, ...args)
-        }
-        return target.addRoute(prop, ...args)
-      }
-    },
+const getPathFromURL = (url) => {
+  // XXX
+  const match = url.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/)
+  return match[5]
 }
 
-class App {
+class Hono {
   constructor() {
     this.router = new Router()
     this.middlewareRouter = new Router()
-    this.middleware = []
+    this.middlewareRouters = []
   }
 
-  addRoute(method, path, ...args) {
-    this.router.add(method, path, ...args)
-    return WrappedApp(this)
+  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)
   }
 
-  matchRoute(method, path) {
-    return this.router.match(method, path)
+  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
+  }
+
+  getRouter() {
+    return this.router
   }
 
   route(path) {
     this.router.tempPath = path
-    return WrappedApp(this)
+    return this
   }
 
   use(path, middleware) {
-    middleware = [middleware]
-    const result = this.middlewareRouter.match('all', path)
-    if (result) {
-      middleware.push(...result.handler)
-    }
-    this.middlewareRouter.add('all', 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
   }
 
   // XXX
-  createContext(req, res) {
-    return { req: req, res: res }
+  async createContext(req, res) {
+    return {
+      req: req,
+      res: res,
+      newResponse: (params) => {
+        return new Response(params)
+      },
+    }
   }
 
   async dispatch(request, response) {
-    const url = new URL(request.url)
-    const [method, path] = [request.method, url.pathname]
+    const [method, path] = [request.method, getPathFromURL(request.url)]
 
-    const result = this.matchRoute(method, path)
+    const result = await this.matchRoute(method, path)
     if (!result) return this.notFound()
 
     request.params = (key) => result.params[key]
 
-    const middleware = [filter]
-    const mwResult = this.middlewareRouter.match('all', path)
-    if (mwResult) {
-      middleware.push(...mwResult.handler)
-    }
+    let handler = result.handler[0] // XXX
+
+    const middleware = [defaultFilter] // add defaultFilter later
 
-    let handler
-    for (const resultHandler of result.handler) {
-      if (resultHandler) {
-        handler = resultHandler
+    for (const mr of this.middlewareRouters) {
+      const mwResult = mr.match('all', path)
+      if (mwResult) {
+        middleware.push(...mwResult.handler)
       }
     }
 
-    let wrappedHandler = (context, next) => {
+    let wrappedHandler = async (context, next) => {
       context.res = handler(context)
       next()
     }
 
     middleware.push(wrappedHandler)
     const composed = compose(middleware)
-    const c = this.createContext(request, response)
+    const c = await this.createContext(request, response)
 
     composed(c)
 
@@ -107,7 +123,7 @@ class App {
   }
 
   async handleEvent(event) {
-    return await this.dispatch(event.request, new Response())
+    return this.dispatch(event.request, {}) // XXX
   }
 
   fire() {
@@ -121,8 +137,8 @@ class App {
   }
 }
 
-const WrappedApp = (router = new App()) => {
-  return new Proxy(router, proxyHandler)
+const CreateApp = () => {
+  return new Hono()
 }
 
-module.exports = WrappedApp
+module.exports = CreateApp

package/src/middleware/{filter.js → defaultFilter.js}

@@ -1,19 +1,19 @@
-const filter = (c, next) => {
-  const url = new URL(c.req.url)
+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 Response(c.res, {
+    c.res = new Reponse(c.res, {
       status: 200,
       headers: {
-        'Content-Type': 'text/plain',
+        'Conten-Type': 'text/plain',
       },
     })
   }
 }
 
-module.exports = filter
+module.exports = defaultFilter

package/src/node.js

@@ -1,131 +1,91 @@
-const methodNameOfAll = 'all'
+'use strict'
 
-class Result {
-  constructor({ handler, params } = {}) {
-    this.handler = handler || []
-    this.params = params || {}
-  }
-}
+const { splitPath, getPattern } = require('./util')
 
-class Node {
-  constructor({ method, label, handler, children } = {}) {
-    this.label = label || ''
-    this.children = children || []
-    this.method = {}
-    if (method && handler) {
-      this.method[method] = handler
-    }
-  }
+const METHOD_NAME_OF_ALL = 'all'
 
-  insert(method, path, handler) {
-    let curNode = this
-    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,
-          handler: handler,
-        })
-        curNode = curNode.children[p]
-      }
-    }
-    curNode.method[method] = handler
-  }
+const createResult = (handler, params) => {
+  return { handler: handler, params: params }
+}
 
-  splitPath(path) {
-    let ps = ['/']
-    for (const p of path.split('/')) {
-      if (p) {
-        ps.push(p)
-      }
-    }
-    return ps
-  }
+const noRoute = () => {
+  return null
+}
 
-  getPattern(label) {
-    // :id{[0-9]+}  → [0-9]+$
-    // :id          → (.+)
-    const match = label.match(/^\:.+?\{(.+)\}$/)
-    if (match) {
-      return '(' + match[1] + ')'
-    }
-    return '(.+)'
+function Node(method, handler, children) {
+  this.children = children || {}
+  this.method = {}
+  if (method && handler) {
+    this.method[method] = handler
   }
+}
 
-  getParamName(label) {
-    const match = label.match(/^\:([^\{\}]+)/)
-    if (match) {
-      return match[1]
+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
+}
 
-  search(method, path) {
-    let curNode = this
-    let [handler, params] = [, {}]
+Node.prototype.search = function (method, path) {
+  let curNode = this
 
-    if (path === '/') {
-      const root = this.children['/']
-      if (!root) return this.noRoute()
-      // app.get('*', () => 'All')
-      const rootAsterisk = root.children['*']
-      if (rootAsterisk) {
-        handler =
-          rootAsterisk.method[method] || rootAsterisk.method[methodNameOfAll]
-      } else if (!root.method[method]) {
-        return this.noRoute()
-      }
-    }
+  const params = {}
+  const parts = splitPath(path)
 
-    for (const p of this.splitPath(path)) {
-      let nextNode = curNode.children[p]
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i]
+    const nextNode = curNode.children[p]
+    if (nextNode) {
+      curNode = nextNode
+      continue
+    }
 
-      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
       }
-
-      let isParamMatch = false
-      for (const key in curNode.children) {
-        if (key === '*') {
-          // Wildcard
+      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
         }
-        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 noRoute()
       }
     }
 
-    handler =
-      handler || curNode.method[methodNameOfAll] || curNode.method[method]
-
-    if (!handler) {
-      return this.noRoute()
+    if (isParamMatch === false) {
+      return noRoute()
     }
-    const res = new Result({ handler: handler, params: params })
-    return res
   }
 
-  noRoute() {
-    return null
+  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

@@ -1,26 +1,17 @@
 const Node = require('./node')
 
-describe('Util Methods', () => {
-  const node = new Node()
-  it('node.splitPath', () => {
-    let ps = node.splitPath('/')
-    expect(ps[0]).toBe('/')
-    ps = node.splitPath('/hello')
-    expect(ps[0]).toBe('/')
-    expect(ps[1]).toBe('hello')
-  })
-})
-
 describe('Root Node', () => {
   const node = new Node()
   node.insert('get', '/', 'get root')
   it('get /', () => {
-    expect(node.search('get', '/')).not.toBeNull()
+    let res = node.search('get', '/')
+    expect(res).not.toBeNull()
+    expect(res.handler).toBe('get root')
     expect(node.search('get', '/hello')).toBeNull()
   })
 })
 
-describe('Root Node', () => {
+describe('Root Node id not defined', () => {
   const node = new Node()
   node.insert('get', '/hello', 'get hello')
   it('get /', () => {
@@ -28,7 +19,7 @@ describe('Root Node', () => {
   })
 })
 
-describe('All', () => {
+describe('All with *', () => {
   const node = new Node()
   node.insert('get', '*', 'get all')
   it('get /', () => {
@@ -78,25 +69,33 @@ describe('Name path', () => {
 
   it('get /entry/456/comment', () => {
     node.insert('get', '/entry/:id', 'get entry')
-    res = node.search('get', '/entry/456/comment')
+    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')
-    res = node.search('get', '/entry/789/comment/123')
+    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')
-    res = node.search('get', '/wildcard-abc/xxxxxx/wildcard-efg')
+    let res = node.search('get', '/wildcard-abc/xxxxxx/wildcard-efg')
     expect(res).not.toBeNull()
     expect(res.handler).toBe('wildcard')
   })
@@ -104,11 +103,7 @@ describe('Wildcard', () => {
 
 describe('Regexp', () => {
   const node = new Node()
-  node.insert(
-    'get',
-    '/regex-abc/:id{[0-9]+}/comment/:comment_id{[a-z]+}',
-    'regexp'
-  )
+  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()

package/src/router.test.js

@@ -1,24 +1,24 @@
 const App = require('./hono')
 
 describe('Basic Usage', () => {
-  let router = App()
+  const router = App()
 
-  it('get, post hello', () => {
+  it('get, post hello', async () => {
     router.get('/hello', 'get hello')
     router.post('/hello', 'post hello')
 
-    let res = router.matchRoute('GET', '/hello')
+    let res = await router.matchRoute('GET', '/hello')
     expect(res).not.toBeNull()
     expect(res.handler[0]).toBe('get hello')
 
-    res = router.matchRoute('POST', '/hello')
+    res = await router.matchRoute('POST', '/hello')
     expect(res).not.toBeNull()
     expect(res.handler[0]).toBe('post hello')
 
-    res = router.matchRoute('PUT', '/hello')
+    res = await router.matchRoute('PUT', '/hello')
     expect(res).toBeNull()
 
-    res = router.matchRoute('GET', '/')
+    res = await router.matchRoute('GET', '/')
     expect(res).toBeNull()
   })
 })
@@ -26,31 +26,31 @@ describe('Basic Usage', () => {
 describe('Complex', () => {
   let router = App()
 
-  it('Named Param', () => {
+  it('Named Param', async () => {
     router.get('/entry/:id', 'get entry')
-    res = router.matchRoute('GET', '/entry/123')
+    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('Wildcard', () => {
+  it('Wildcard', async () => {
     router.get('/wild/*/card', 'get wildcard')
-    res = router.matchRoute('GET', '/wild/xxx/card')
+    res = await router.matchRoute('GET', '/wild/xxx/card')
     expect(res).not.toBeNull()
     expect(res.handler[0]).toBe('get wildcard')
   })
 
-  it('Regexp', () => {
+  it('Regexp', async () => {
     router.get('/post/:date{[0-9]+}/:title{[a-z]+}', 'get post')
-    res = router.matchRoute('GET', '/post/20210101/hello')
+    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 = router.matchRoute('GET', '/post/onetwothree')
+    res = await router.matchRoute('GET', '/post/onetwothree')
     expect(res).toBeNull()
-    res = router.matchRoute('GET', '/post/123/123')
+    res = await router.matchRoute('GET', '/post/123/123')
     expect(res).toBeNull()
   })
 })
@@ -58,27 +58,31 @@ describe('Complex', () => {
 describe('Chained Route', () => {
   let router = App()
 
-  it('Return rooter object', () => {
+  it('Return rooter object', async () => {
     router = router.patch('/hello', 'patch hello')
     expect(router).not.toBeNull()
     router = router.delete('/hello', 'delete hello')
-    res = router.matchRoute('DELETE', '/hello')
+    res = await router.matchRoute('DELETE', '/hello')
     expect(res).not.toBeNull()
     expect(res.handler[0]).toBe('delete hello')
   })
 
-  it('Chain with route method', () => {
+  it('Chain with route method', async () => {
     router.route('/api/book').get('get book').post('post book').put('put book')
-    res = router.matchRoute('GET', '/api/book')
+
+    res = await router.matchRoute('GET', '/api/book')
     expect(res).not.toBeNull()
     expect(res.handler[0]).toBe('get book')
-    res = router.matchRoute('POST', '/api/book')
+
+    res = await router.matchRoute('POST', '/api/book')
     expect(res).not.toBeNull()
     expect(res.handler[0]).toBe('post book')
-    res = router.matchRoute('PUT', '/api/book')
+
+    res = await router.matchRoute('PUT', '/api/book')
     expect(res).not.toBeNull()
     expect(res.handler[0]).toBe('put book')
-    res = router.matchRoute('DELETE', '/api/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/example/basic/index.js

@@ -1,28 +0,0 @@
-const Hono = require('../../src/hono')
-const app = Hono()
-
-// Middleware
-const logger = (c, next) => {
-  console.log(`[${c.req.method}] ${c.req.url}`)
-  next()
-}
-const addHeader = (c, next) => {
-  next()
-  c.res.headers.append('X-message', 'This is addHeader middleware!')
-}
-
-// Mount middleware
-app.use('*', logger)
-app.use('/hello', addHeader)
-
-// Routing
-app.get('/', () => new Response('Hono!!'))
-app.get('/hello', () => new Response('This is /hello'))
-
-app.get('/entry/:id', (c) => {
-  const id = c.req.params('id')
-  return new Response(`Your ID is ${id}`)
-})
-
-// addEventListener
-app.fire()

package/example/basic/package-lock.json

@@ -1,13 +0,0 @@
-{
-  "name": "sandbox",
-  "version": "1.0.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "sandbox",
-      "version": "1.0.0",
-      "license": "ISC"
-    }
-  }
-}

package/example/basic/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "hono-example-basic",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
-  "license": "MIT"
-}

package/example/basic/wrangler.toml

@@ -1,8 +0,0 @@
-name = "hono-example-basic"
-type = "webpack"
-route = ''
-zone_id = ''
-usage_model = ''
-compatibility_flags = []
-workers_dev = true
-compatibility_date = "2021-12-15"