hono 0.0.3 → 0.0.7

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!!'))
 
@@ -15,11 +16,22 @@ app.fire()
 - Fast - the router is implemented with Trie-Tree structure.
 - Tiny - use only standard API.
 - Portable - zero dependencies.
-- Optimized for Cloudflare Workers.
+- 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)
+sunder x 307,438 ops/sec ±4.77% (73 runs sampled)
+Fastest is hono
+✨  Done in 37.03s.
+```
 
 ## Install
 
-```sh
+```
 $ yarn add hono
 ```
 
@@ -29,21 +41,42 @@ or
 $ 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
-app.get('/', () => 'GET /')
-app.post('/', () => 'POST /')
-app.get('/wild/*/card', () => 'GET /wild/*/card')
+// 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', (req) => {
-  const name = req.params('name')
+app.get('/user/:name', (c) => {
+  const name = c.req.params('name')
   ...
 })
 ```
@@ -51,9 +84,9 @@ app.get('/user/:name', (req) => {
 ### Regexp
 
 ```js
-app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (req) => {
-  const date = req.params('date')
-  const title = req.params('title')
+app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
+  const date = c.req.params('date')
+  const title = c.req.params('title')
   ...
 ```
 
@@ -62,15 +95,78 @@ app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (req) => {
 ```js
 app
   .route('/api/book')
-  .get(() => 'GET /api/book')
-  .post(() => 'POST /api/book')
-  .put(() => 'PUT /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
 
-- goblin <https://github.com/bmf-san/goblin>
+- 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,10 +1,10 @@
 {
   "name": "hono",
-  "version": "0.0.3",
-  "description": "Minimal web framework for Cloudflare Workers",
+  "version": "0.0.7",
+  "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",
@@ -16,9 +16,5 @@
   "devDependencies": {
     "jest": "^27.4.5",
     "node-fetch": "^2.6.6"
-  },
-  "dependencies": {
-    "global": "^4.4.0",
-    "wrangler": "^0.0.0-beta.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.d.ts

@@ -0,0 +1,42 @@
+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
+}
+
+export class Middleware {}

package/src/hono.js

@@ -1,4 +1,12 @@
+'use strict'
+
 const Node = require('./node')
+const compose = require('./compose')
+const methods = require('./methods')
+const defaultFilter = require('./middleware/defaultFilter')
+const Middleware = require('./middleware')
+
+const METHOD_NAME_OF_ALL = 'ALL'
 
 class Router {
   constructor() {
@@ -6,98 +14,129 @@ class Router {
     this.tempPath = '/'
   }
 
-  route(path) {
-    this.tempPath = path
-    return WrappedRouter(this)
+  add(method, path, ...handlers) {
+    this.node.insert(method, path, handlers)
+  }
+
+  match(method, path) {
+    return this.node.search(method, path)
   }
+}
+
+const getPathFromURL = (url) => {
+  // XXX
+  const match = url.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/)
+  return match[5]
+}
+
+class Hono {
+  constructor() {
+    this.router = new Router()
+    this.middlewareRouters = []
 
-  addRoute(method, path, handler) {
-    this.node.insert(method, path, handler)
-    return WrappedRouter(this)
+    for (const method of methods) {
+      this[method] = (...args) => {
+        return this.addRoute(method, ...args)
+      }
+    }
   }
 
-  matchRoute(method, path) {
-    method = method.toLowerCase()
-    const res = this.node.search(method, path)
-    return res
+  all(...args) {
+    this.addRoute('ALL', ...args)
   }
 
-  handle(event) {
-    const result = this.dispatch(event.request)
-    const response = this.filter(result)
-    return event.respondWith(response)
+  getRouter() {
+    return this.router
   }
 
-  filter(result) {
-    if (result instanceof Response) {
-      return result
-    }
-    if (typeof result === 'object') {
-      return new Response(JSON.stringify(result), {
-        status: 200,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      })
+  addRoute(method, ...args) {
+    method = method.toUpperCase()
+    if (args.length === 1) {
+      this.router.add(method, this.router.tempPath, ...args)
+    } else {
+      this.router.add(method, ...args)
     }
-    if (typeof result === 'string') {
-      return new Response(result, {
-        status: 200,
-        headers: {
-          'Content-Type': 'text/plain',
-        },
-      })
+    return this
+  }
+
+  route(path) {
+    this.router.tempPath = path
+    return this
+  }
+
+  use(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
+  async createContext(req, res) {
+    return {
+      req: req,
+      res: res,
+      newResponse: (params) => {
+        return new Response(params)
+      },
     }
-    return this.notFound()
   }
 
-  dispatch(request) {
-    const url = new URL(request.url)
-    const path = url.pathname
-    const method = request.method
-    const res = this.matchRoute(method, path)
+  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(METHOD_NAME_OF_ALL, path)
+      if (mwResult) {
+        middleware.push(...mwResult.handler)
+      }
+    }
 
-    if (!res) {
-      return this.notFound()
+    let wrappedHandler = async (context, next) => {
+      context.res = handler(context)
+      next()
     }
 
-    const handler = res.handler
-    return handler(request)
+    middleware.push(wrappedHandler)
+    const composed = compose(middleware)
+    const c = await this.createContext(request, response)
+
+    composed(c)
+
+    return c.res
   }
 
-  notFound() {
-    return new Response('Not Found', {
-      status: 404,
-      headers: {
-        'content-type': 'text/plain',
-      },
-    })
+  async handleEvent(event) {
+    return this.dispatch(event.request, {}) // XXX
   }
 
   fire() {
     addEventListener('fetch', (event) => {
-      this.handle(event)
+      event.respondWith(this.handleEvent(event))
     })
   }
-}
 
-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.tempPath, ...args)
-        }
-        return target.addRoute(prop, ...args)
-      }
-    },
+  notFound() {
+    return new Response('Not Found', { status: 404 })
+  }
 }
 
-const WrappedRouter = (router = new Router()) => {
-  return new Proxy(router, proxyHandler)
-}
+// Default Export
+module.exports = Hono
+exports = module.exports
 
-module.exports = WrappedRouter
+// Named Export
+exports.Hono = Hono
+exports.Middleware = Middleware

package/src/hono.test.js

@@ -1,9 +1,9 @@
-const Hono = require('./hono')
 const fetch = require('node-fetch')
+const { Hono } = require('./hono')
 
-const app = Hono()
+describe('GET Request', () => {
+  const app = new Hono()
 
-describe('GET match', () => {
   app.get('/hello', () => {
     return new fetch.Response('hello', {
       status: 200,
@@ -14,16 +14,102 @@ describe('GET match', () => {
       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 = new 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 = new Hono()
+
+  const logger = async (c, next) => {
+    console.log(`${c.req.method} : ${c.req.url}`)
+    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()
+    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/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/middleware.js

@@ -0,0 +1,3 @@
+class Middleware {}
+
+module.exports = Middleware

package/src/node.js

@@ -1,127 +1,97 @@
-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]
-      }
-    }
-    if (!curNode.method[method]) {
-      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
   }
+  this.middlewares = []
+}
 
-  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
-    const params = {}
+Node.prototype.search = function (method, path) {
+  let curNode = this
 
-    if (path === '/') {
-      const root = this.children['/']
-      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 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()
       }
     }
 
-    let handler = curNode.method[methodNameOfAll] || curNode.method[method]
+    if (isWildcard) {
+      break
+    }
 
-    if (handler) {
-      const res = new Result({ handler: handler, params: params })
-      return res
-    } else {
-      return this.noRoute()
+    if (isParamMatch === false) {
+      return noRoute()
     }
   }
 
-  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,17 +1,35 @@
 const Node = require('./node')
-const node = new Node()
 
-describe('Util Methods', () => {
-  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 /', () => {
+    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')
@@ -38,6 +56,7 @@ describe('Basic Usage', () => {
 })
 
 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')
@@ -50,35 +69,41 @@ 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')
   })
 })
 
 describe('Regexp', () => {
-  node.insert(
-    'get',
-    '/regex-abc/:id{[0-9]+}/comment/:comment_id{[a-z]+}',
-    '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()
@@ -97,7 +122,8 @@ describe('Regexp', () => {
 })
 
 describe('All', () => {
-  node.insert('all', '/all-methods', 'all methods')
+  const node = new Node()
+  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,76 +1,88 @@
-const Router = require('./hono')
-let router = Router()
+const { Hono } = require('./hono')
 
 describe('Basic Usage', () => {
-  it('get, post hello', () => {
+  const router = new Hono()
+
+  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).toBe('get hello')
+    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).toBe('post hello')
+    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', () => {
-  it('Named Param', () => {
+  let router = new Hono()
+
+  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).toBe('get entry')
+    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).toBe('get wildcard')
+    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).toBe('get post')
+    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', () => {
-  it('Return rooter object', () => {
+  let router = new Hono()
+
+  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).toBe('delete hello')
+    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).toBe('get book')
-    res = router.matchRoute('POST', '/api/book')
+    expect(res.handler[0]).toBe('get book')
+
+    res = await router.matchRoute('POST', '/api/book')
     expect(res).not.toBeNull()
-    expect(res.handler).toBe('post book')
-    res = router.matchRoute('PUT', '/api/book')
+    expect(res.handler[0]).toBe('post book')
+
+    res = await router.matchRoute('PUT', '/api/book')
     expect(res).not.toBeNull()
-    expect(res.handler).toBe('put book')
-    res = router.matchRoute('DELETE', '/api/book')
+    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 } = 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,7 +0,0 @@
-const Hono = require('../../src/hono')
-const app = Hono()
-
-app.get('/', () => 'Hono!!')
-app.get('/hello', () => 'This is /hello')
-
-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": "sandbox",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
-  "license": "ISC"
-}

package/example/basic/wrangler.toml

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

package/hono.mini.js

@@ -1 +0,0 @@
-const Router=require("./router");class Route{constructor(t,e){this.method=t;this.handler=e}}class App{constructor(){this.router=new Router}addRoute(t,e,n){this.router.add(e,new Route(t,n))}handle(t){const e=this.dispatch(t.request);return t.respondWith(e)}dispatch(t){const e=new URL(t.url);const n=e.pathname;const r=this.router.match(n);if(!r){return this.notFound()}const o=t.method.toLowerCase();const s=r[0];if(s.method==o){const i=s.handler;return i(t)}return this.notFound()}notFound(){return new Response("Not Found",{status:404,headers:{"content-type":"text/plain"}})}fire(){addEventListener("fetch",t=>{this.handle(t)})}}const proxyHandler={get:(e,n)=>(...t)=>{if(e.constructor.prototype.hasOwnProperty(n)){return e[n](t[0])}else{e.addRoute(n,t[0],t[1]);return}}};const app=new App;function Hono(){return new Proxy(app,proxyHandler)}module.exports=Hono;class Router{constructor(){this.node=new Node({label:"/"})}add(t,e){this.node.insert(t,e)}match(t){return this.node.search(t)}}class Node{constructor({label:t,stuff:e,children:n}={}){this.label=t||"";this.stuff=e||{};this.children=n||[]}insert(t,e){let n=this;if(t=="/"){n.label=t;n.stuff=e}const r=this.splitPath(t);for(const o of r){let t=n.children[o];if(t){n=t}else{n.children[o]=new Node({label:o,stuff:e,children:[]});n=n.children[o]}}}splitPath(t){const e=[];for(const n of t.split("/")){if(n){e.push(n)}}return e}getPattern(t){const e=t.match(/^\:.+?\{(.+)\}$/);if(e){return"("+e[1]+")"}return"(.+)"}getParamName(t){const e=t.match(/^\:([^\{\}]+)/);if(e){return e[1]}}noRoute(){return null}search(t){let e=this;const n={};for(const r of this.splitPath(t)){const o=e.children[r];if(o){e=o;continue}if(Object.keys(e.children).length==0){if(e.label!=r){return this.noRoute()}break}let t=false;for(const s in e.children){if(s=="*"){e=e.children[s];t=true;break}if(s.match(/^:/)){const i=this.getPattern(s);const c=r.match(new RegExp(i));if(c){const h=this.getParamName(s);n[h]=c[0];e=e.children[s];t=true;break}return this.noRoute()}}if(t==false){return this.noRoute()}}return[e.stuff,n]}}module.exports=Router;

package/src/node.root.test.js

@@ -1,17 +0,0 @@
-const Node = require('./node')
-
-describe('Basic Usage', () => {
-  const node = new Node()
-  node.insert('get', '/', 'get root')
-  it('get /', () => {
-    expect(node.search('get', '/')).not.toBeNull()
-  })
-})
-
-describe('Basic Usage', () => {
-  const node = new Node()
-  node.insert('get', '/hello', 'get hello')
-  it('get /', () => {
-    expect(node.search('get', '/')).toBeNull()
-  })
-})