hono 0.0.4 → 0.0.8

package/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: ci
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [16.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn install --frozen-lockfile
+    - run: npm test

package/README.md

@@ -3,7 +3,8 @@
 Hono [炎] - Tiny web framework for Cloudflare Workers and others.
 
 ```js
-const app = Hono()
+const { Hono } = require('hono')
+const app = new 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)
+sunder 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
@@ -91,6 +102,19 @@ app
 
 ## Middleware
 
+### Builtin Middleware
+
+```js
+const { Hono, Middleware } = require('hono')
+
+...
+
+app.use('*', Middleware.poweredBy)
+
+```
+
+### Custom Middleware
+
 ```js
 const logger = (c, next) => {
   console.log(`[${c.req.method}] ${c.req.url}`)
@@ -102,8 +126,8 @@ const addHeader = (c, next) => {
   c.res.headers.add('x-message', 'This is middleware!')
 }
 
-app = app.use('*', logger)
-app = app.use('/message/*', addHeader)
+app.use('*', logger)
+app.use('/message/*', addHeader)
 
 app.get('/message/hello', () => 'Hello Middleware!')
 ```
@@ -152,6 +176,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",
-  "description": "Minimal web framework for Cloudflare Workers",
+  "version": "0.0.8",
+  "description": "Minimal web framework for Cloudflare Workers and Fastly Compute@Edge",
   "main": "src/hono.js",
   "scripts": {
-    "test": "jest --verbose"
+    "test": "jest"
   },
   "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
   "license": "MIT",

package/src/hono.d.ts

@@ -0,0 +1,47 @@
+declare class FetchEvent {}
+declare class Request {}
+declare class Response {}
+declare class Context {}
+
+declare class Node {}
+
+declare class Router {
+  tempPath: string
+  node: Node
+
+  add(method: string, path: string, handlers: any[]): Node
+  match(method: string, path: string): Node
+}
+
+export class Hono {
+  router: Router
+  middlewareRouters: Router[]
+
+  getRouter(): Router
+  addRoute(method: string, args: any[]): Hono
+  matchRoute(method: string, path: string): Node
+  createContext(req: Request, res: Response): Context
+  dispatch(req: Request, res: Response): Response
+  handleEvent(event: FetchEvent): Response
+  fire(): void
+
+  notFound(): Response
+
+  route(path: string): Hono
+
+  use(path: string, middleware: any): void
+
+  all(path: string, handler: any): Hono
+  get(path: string, handler: any): Hono
+  post(path: string, handler: any): Hono
+  put(path: string, handler: any): Hono
+  head(path: string, handler: any): Hono
+  delete(path: string, handler: any): Hono
+}
+
+// XXX
+declare interface BuiltinMiddleware {}
+
+export class Middleware {
+  static poweredBy: BuiltinMiddleware
+}

package/src/hono.js

@@ -2,7 +2,11 @@
 
 const Node = require('./node')
 const compose = require('./compose')
-const filter = require('./middleware/filter')
+const methods = require('./methods')
+const defaultFilter = require('./middleware/defaultFilter')
+const Middleware = require('./middleware')
+
+const METHOD_NAME_OF_ALL = 'ALL'
 
 class Router {
   constructor() {
@@ -15,91 +19,99 @@ 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 = []
+
+    for (const method of methods) {
+      this[method] = (...args) => {
+        return this.addRoute(method, ...args)
+      }
+    }
   }
 
-  addRoute(method, path, ...args) {
-    this.router.add(method, path, ...args)
-    return WrappedApp(this)
+  all(...args) {
+    this.addRoute('ALL', ...args)
   }
 
-  matchRoute(method, path) {
-    return this.router.match(method, path)
+  getRouter() {
+    return this.router
+  }
+
+  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
   }
 
   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(METHOD_NAME_OF_ALL, path, middleware)
+    this.middlewareRouters.push(router)
+  }
+
+  async matchRoute(method, path) {
+    return this.router.match(method, path)
   }
 
   // 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
 
-    let handler
-    for (const resultHandler of result.handler) {
-      if (resultHandler) {
-        handler = resultHandler
+    const middleware = [defaultFilter] // add defaultFilter later
+
+    for (const mr of this.middlewareRouters) {
+      const mwResult = mr.match(METHOD_NAME_OF_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 +119,7 @@ class App {
   }
 
   async handleEvent(event) {
-    return await this.dispatch(event.request, new Response())
+    return this.dispatch(event.request, {}) // XXX
   }
 
   fire() {
@@ -121,8 +133,10 @@ class App {
   }
 }
 
-const WrappedApp = (router = new App()) => {
-  return new Proxy(router, proxyHandler)
-}
+// Default Export
+module.exports = Hono
+exports = module.exports
 
-module.exports = WrappedApp
+// Named Export
+exports.Hono = Hono
+exports.Middleware = Middleware

package/src/hono.test.js

@@ -1,8 +1,9 @@
-const Hono = require('./hono')
 const fetch = require('node-fetch')
+const { Hono } = require('./hono')
 
 describe('GET Request', () => {
-  const app = Hono()
+  const app = new Hono()
+
   app.get('/hello', () => {
     return new fetch.Response('hello', {
       status: 200,
@@ -29,7 +30,7 @@ describe('GET Request', () => {
 })
 
 describe('params and query', () => {
-  const app = Hono()
+  const app = new Hono()
 
   app.get('/entry/:id', async (c) => {
     const id = await c.req.params('id')
@@ -60,29 +61,55 @@ describe('params and query', () => {
 })
 
 describe('Middleware', () => {
-  const app = Hono()
+  const app = new Hono()
 
-  const logger = (c, next) => {
+  const logger = async (c, next) => {
     console.log(`${c.req.method} : ${c.req.url}`)
     next()
   }
 
-  const customHeader = (c, next) => {
+  const rootHeader = async (c, next) => {
+    next()
+    await c.res.headers.append('x-custom', 'root')
+  }
+
+  const customHeader = async (c, next) => {
+    next()
+    await c.res.headers.append('x-message', 'custom-header')
+  }
+  const customHeader2 = async (c, next) => {
     next()
-    c.res.headers.append('x-message', 'custom-header')
+    await c.res.headers.append('x-message-2', 'custom-header-2')
   }
 
   app.use('*', logger)
+  app.use('*', rootHeader)
   app.use('/hello', customHeader)
+  app.use('/hello/*', customHeader2)
   app.get('/hello', () => {
     return new fetch.Response('hello')
   })
+  app.get('/hello/:message', (c) => {
+    const message = c.req.params('message')
+    return new fetch.Response(`${message}`)
+  })
 
   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-custom')).toBe('root')
     expect(await res.headers.get('x-message')).toBe('custom-header')
+    expect(await res.headers.get('x-message-2')).toBe('custom-header-2')
+  })
+
+  it('logging and custom header with named params', async () => {
+    let req = new fetch.Request('https://example.com/hello/message')
+    let res = await app.dispatch(req)
+    expect(res.status).toBe(200)
+    expect(await res.text()).toBe('message')
+    expect(await res.headers.get('x-custom')).toBe('root')
+    expect(await res.headers.get('x-message-2')).toBe('custom-header-2')
   })
 })

package/src/methods.js

@@ -0,0 +1,30 @@
+const methods = [
+  'get',
+  'post',
+  'put',
+  'head',
+  'delete',
+  'options',
+  'trace',
+  'copy',
+  'lock',
+  'mkcol',
+  'move',
+  'patch',
+  'purge',
+  'propfind',
+  'proppatch',
+  'unlock',
+  'report',
+  'mkactivity',
+  'checkout',
+  'merge',
+  'm-search',
+  'notify',
+  'subscribe',
+  'unsubscribe',
+  'search',
+  'connect',
+]
+
+module.exports = methods

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/middleware/poweredBy.js

@@ -0,0 +1,6 @@
+const poweredBy = async (c, next) => {
+  next()
+  await c.res.headers.append('X-Powered-By', 'Hono')
+}
+
+module.exports = poweredBy

package/src/middleware/poweredBy.test.js

@@ -0,0 +1,17 @@
+const fetch = require('node-fetch')
+const { Hono, Middleware } = require('../hono')
+
+describe('Powered by Middleware', () => {
+  const app = new Hono()
+
+  app.use('*', Middleware.poweredBy)
+  app.get('/', () => new fetch.Response('root'))
+
+  it('Response headers include X-Powered-By', async () => {
+    let req = new fetch.Request('https://example.com/')
+    let res = await app.dispatch(req, new fetch.Response())
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(200)
+    expect(res.headers.get('X-Powered-By')).toBe('Hono')
+  })
+})

package/src/middleware.js

@@ -0,0 +1,7 @@
+const poweredBy = require('./middleware/poweredBy')
+
+function Middleware() {}
+
+Middleware.poweredBy = poweredBy
+
+module.exports = Middleware

package/src/middleware.test.js

@@ -0,0 +1,17 @@
+const fetch = require('node-fetch')
+const { Hono, Middleware } = require('./hono')
+
+describe('Builtin Middleware', () => {
+  const app = new Hono()
+
+  app.use('*', Middleware.poweredBy)
+  app.get('/', () => new fetch.Response('root'))
+
+  it('Builtin Powered By Middleware', async () => {
+    let req = new fetch.Request('https://example.com/')
+    let res = await app.dispatch(req, new fetch.Response())
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(200)
+    expect(res.headers.get('X-Powered-By')).toBe('Hono')
+  })
+})

package/src/node.js

@@ -1,131 +1,97 @@
-const methodNameOfAll = 'all'
+'use strict'
 
-class Result {
-  constructor({ handler, params } = {}) {
-    this.handler = handler || []
-    this.params = params || {}
-  }
+const { splitPath, getPattern } = require('./util')
+
+const METHOD_NAME_OF_ALL = 'ALL'
+
+const createResult = (handler, params) => {
+  return { handler: handler, params: params }
 }
 
-class Node {
-  constructor({ method, label, handler, children } = {}) {
-    this.label = label || ''
-    this.children = children || []
-    this.method = {}
-    if (method && handler) {
-      this.method[method] = handler
-    }
-  }
+const noRoute = () => {
+  return null
+}
 
-  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
+function Node(method, handler, children) {
+  this.children = children || {}
+  this.method = {}
+  if (method && handler) {
+    this.method[method] = handler
   }
+  this.middlewares = []
+}
 
-  splitPath(path) {
-    let ps = ['/']
-    for (const p of path.split('/')) {
-      if (p) {
-        ps.push(p)
-      }
+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
     }
-    return ps
+    curNode.children[p] = new Node(method, handler)
+    curNode = curNode.children[p]
   }
+  curNode.method[method] = handler
+  return curNode
+}
 
-  getPattern(label) {
-    // :id{[0-9]+}  → [0-9]+$
-    // :id          → (.+)
-    const match = label.match(/^\:.+?\{(.+)\}$/)
-    if (match) {
-      return '(' + match[1] + ')'
-    }
-    return '(.+)'
-  }
+Node.prototype.search = function (method, path) {
+  let curNode = this
 
-  getParamName(label) {
-    const match = label.match(/^\:([^\{\}]+)/)
-    if (match) {
-      return match[1]
-    }
-  }
+  const params = {}
+  const parts = splitPath(path)
 
-  search(method, path) {
-    let curNode = this
-    let [handler, params] = [, {}]
-
-    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()
-      }
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i]
+    const nextNode = curNode.children[p]
+    if (nextNode) {
+      curNode = nextNode
+      continue
     }
 
-    for (const p of this.splitPath(path)) {
-      let nextNode = curNode.children[p]
-
-      if (nextNode) {
-        curNode = nextNode
-        continue
+    let isWildcard = false
+    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['*']
+        isWildcard = 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 (isWildcard) {
+      break
+    }
 
-    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()
@@ -128,7 +123,7 @@ describe('Regexp', () => {
 
 describe('All', () => {
   const node = new Node()
-  node.insert('all', '/all-methods', 'all methods')
+  node.insert('ALL', '/all-methods', 'all methods') // ALL
   it('/all-methods', () => {
     res = node.search('get', '/all-methods')
     expect(res).not.toBeNull()

package/src/router.test.js

@@ -1,84 +1,88 @@
-const App = require('./hono')
+const { Hono } = require('./hono')
 
 describe('Basic Usage', () => {
-  let router = App()
+  const router = new Hono()
 
-  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()
   })
 })
 
 describe('Complex', () => {
-  let router = App()
+  let router = new Hono()
 
-  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()
   })
 })
 
 describe('Chained Route', () => {
-  let router = App()
+  let router = new Hono()
 
-  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 } = 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"