hono 0.0.6 → 0.0.10

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+yusuke@kamawada.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

package/README.md

@@ -3,14 +3,16 @@
 Hono [炎] - Tiny web framework for Cloudflare Workers and others.
 
 ```js
-const Hono = require('Hono')
-const app = Hono()
+const { Hono } = require('hono')
+const app = new Hono()
 
 app.get('/', () => new Response('Hono!!'))
 
 app.fire()
 ```
 
+![carbon](https://user-images.githubusercontent.com/10682/147877725-bce9bd46-953d-4d70-9c2b-3eae47ad4df9.png)
+
 ## Feature
 
 - Fast - the router is implemented with Trie-Tree structure.
@@ -100,32 +102,86 @@ app
     .put(() => {...})
 ```
 
+## Async
+
+```js
+app.get('/fetch-url', async () => {
+  const response = await fetch('https://example.com/')
+  return new Response(`Status is ${response.status}`)
+})
+```
+
 ## Middleware
 
+### Builtin Middleware
+
 ```js
-const logger = (c, next) => {
+const { Hono, Middleware } = require('hono')
+
+...
+
+app.use('*', Middleware.poweredBy)
+
+```
+
+### Custom Middleware
+
+```js
+const logger = async (c, next) => {
   console.log(`[${c.req.method}] ${c.req.url}`)
-  next()
+  await next()
 }
 
-const addHeader = (c, next) => {
-  next()
-  c.res.headers.add('x-message', 'This is middleware!')
+const addHeader = async (c, next) => {
+  await next()
+  await 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!')
 ```
 
+### Custom 404 Response
+
+```js
+const customNotFound = async (c, next) => {
+  await next()
+  if (c.res.status === 404) {
+    c.res = new Response('Custom 404 Not Found', { status: 404 })
+  }
+}
+
+app.use('*', customNotFound)
+```
+
+### Complex Pattern
+
+```js
+// Log response time
+app.use('*', async (c, next) => {
+  await next()
+  const responseTime = await c.res.headers.get('X-Response-Time')
+  console.log(`X-Response-Time: ${responseTime}`)
+})
+
+// Add X-Response-Time header
+app.use('*', async (c, next) => {
+  const start = Date.now()
+  await next()
+  const ms = Date.now() - start
+  await c.res.headers.append('X-Response-Time', `${ms}ms`)
+})
+```
+
 ## Context
 
 ### req
 
 ```js
 app.get('/hello', (c) => {
-  const userAgent = c.req.headers('User-Agent')
+  const userAgent = c.req.headers.get('User-Agent')
   ...
 })
 ```
@@ -159,6 +215,69 @@ app.get('/entry/:id', (c) => {
 })
 ```
 
+## Hono in 1 minute
+
+Create your first Cloudflare Workers with Hono from scratch.
+
+### Demo
+
+![Demo](https://user-images.githubusercontent.com/10682/147877447-ff5907cd-49be-4976-b3b4-5df2ac6dfda4.gif)
+
+### 1. Install Wrangler
+
+Install Cloudflare Command Line "[Wrangler](https://github.com/cloudflare/wrangler)"
+
+```sh
+$ npm i @cloudflare/wrangler -g
+```
+
+### 2. `npm init`
+
+Make npm skeleton directory.
+
+```sh
+$ mkdir hono-example
+$ ch hono-example
+$ npm init -y
+```
+
+### 3. `wrangler init`
+
+Init as a wrangler project.
+
+```sh
+$ wrangler init
+```
+
+### 4. `npm install hono`
+
+Install `hono` from npm repository.
+
+```
+$ npm i hono
+```
+
+### 5. Write your app
+
+Only 4 line!!
+
+```js
+const { Hono } = require('hono')
+const app = new Hono()
+
+app.get('/', () => new Response('Hello! Hono!'))
+
+app.fire()
+```
+
+### 6. Run!
+
+Run the development server locally.
+
+```sh
+$ wrangler dev
+```
+
 ## Related projects
 
 - koa <https://github.com/koajs/koa>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono",
-  "version": "0.0.6",
-  "description": "Minimal web framework for Cloudflare Workers",
+  "version": "0.0.10",
+  "description": "Minimal web framework for Cloudflare Workers and Fastly Compute@Edge",
   "main": "src/hono.js",
   "scripts": {
     "test": "jest"
@@ -13,6 +13,18 @@
     "url": "https://github.com/yusukebe/hono.git"
   },
   "homepage": "https://github.com/yusukebe/hono",
+  "keywords": [
+    "web",
+    "app",
+    "http",
+    "application",
+    "framework",
+    "router",
+    "cloudflare",
+    "workers",
+    "fastly",
+    "compute@edge"
+  ],
   "devDependencies": {
     "jest": "^27.4.5",
     "node-fetch": "^2.6.6"

package/src/compose.js

@@ -4,8 +4,7 @@ const compose = (middleware) => {
     let index = -1
     return dispatch(0)
     function dispatch(i) {
-      if (i <= index)
-        return Promise.reject(new Error('next() called multiple times'))
+      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
       index = i
       let fn = middleware[i]
       if (i === middleware.length) fn = next

package/src/compose.test.js

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

package/src/hono.d.ts

@@ -0,0 +1,67 @@
+type Result = {
+  handler: any
+  params: {}
+}
+
+declare class Node {
+  method: string
+  handler: any
+  children: Node[]
+  middlewares: any[]
+
+  insert(method: string, path: string, handler: any): Node
+  search(method: string, path: string): Result
+}
+
+declare class Context {
+  req: Request
+  res: Response
+  newResponse(params: {}): Response
+}
+
+type Handler = (c: Context, next: () => void) => Response | void
+
+declare class Router {
+  tempPath: string
+  node: Node
+
+  add(method: string, path: string, handler: Handler): Node
+  match(method: string, path: string): Node
+}
+
+export class Hono {
+  router: Router
+  middlewareRouters: Router[]
+
+  use(path: string, middleware: Handler): void
+
+  route(path: string): Hono
+  fire(): void
+
+  all(path: string, handler: Handler): Hono
+  get(path: string, handler: Handler): Hono
+  post(path: string, handler: Handler): Hono
+  put(path: string, handler: Handler): Hono
+  head(path: string, handler: Handler): Hono
+  delete(path: string, handler: Handler): Hono
+
+  notFound(): Response
+
+  getRouter(): Router
+  addRoute(method: string, args: any[]): Hono
+  matchRoute(method: string, path: string): Promise<Node>
+  createContext(req: Request, res: Response): Promise<Context>
+  dispatch(req: Request, res: Response): Promise<Response>
+  handleEvent(event: FetchEvent): Promise<Response>
+}
+
+export class Middleware {
+  static defaultFilter: Handler
+  // Add builtin middlewares
+  static poweredBy: Handler
+}
+
+interface FetchEvent extends Event {
+  request: Request
+  respondWith(response: Promise<Response> | Response): Promise<Response>
+}

package/src/hono.js

@@ -1,8 +1,10 @@
 'use strict'
 
 const Node = require('./node')
+const Middleware = require('./middleware')
 const compose = require('./compose')
-const defaultFilter = require('./middleware/defaultFilter')
+const methods = require('./methods')
+const { getPathFromURL } = require('./util')
 
 const METHOD_NAME_OF_ALL = 'ALL'
 
@@ -21,29 +23,20 @@ class Router {
   }
 }
 
-const getPathFromURL = (url) => {
-  // XXX
-  const match = url.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/)
-  return match[5]
-}
-
-const proxyHandler = {
-  get:
-    (target, prop) =>
-    (...args) => {
-      if (target.constructor.prototype.hasOwnProperty(prop)) {
-        return target[prop](...args)
-      } else {
-        return target.addRoute(prop, ...args)
-      }
-    },
-}
-
 class Hono {
   constructor() {
     this.router = new Router()
-    this.middlewareRouter = new Router()
     this.middlewareRouters = []
+
+    for (const method of methods) {
+      this[method] = (...args) => {
+        return this.addRoute(method, ...args)
+      }
+    }
+  }
+
+  all(...args) {
+    this.addRoute('ALL', ...args)
   }
 
   getRouter() {
@@ -57,15 +50,19 @@ class Hono {
     } else {
       this.router.add(method, ...args)
     }
-    return WrappedApp(this)
+    return this
   }
 
   route(path) {
     this.router.tempPath = path
-    return WrappedApp(this)
+    return this
   }
 
   use(path, middleware) {
+    if (middleware.constructor.name !== 'AsyncFunction') {
+      throw new TypeError('middleware must be a async function!')
+    }
+
     const router = new Router()
     router.add(METHOD_NAME_OF_ALL, path, middleware)
     this.middlewareRouters.push(router)
@@ -90,13 +87,12 @@ class Hono {
     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
+    let handler = result ? result.handler[0] : this.notFound // XXX
 
-    const middleware = [defaultFilter] // add defaultFilter later
+    const middleware = []
 
     for (const mr of this.middlewareRouters) {
       const mwResult = mr.match(METHOD_NAME_OF_ALL, path)
@@ -106,15 +102,17 @@ class Hono {
     }
 
     let wrappedHandler = async (context, next) => {
-      context.res = handler(context)
-      next()
+      context.res = await handler(context)
+      await next()
     }
 
+    middleware.push(Middleware.defaultFilter)
     middleware.push(wrappedHandler)
+
     const composed = compose(middleware)
     const c = await this.createContext(request, response)
 
-    composed(c)
+    await composed(c)
 
     return c.res
   }
@@ -134,8 +132,10 @@ class Hono {
   }
 }
 
-const WrappedApp = (hono = new Hono()) => {
-  return new Proxy(hono, 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,31 +61,32 @@ describe('params and query', () => {
 })
 
 describe('Middleware', () => {
-  const app = Hono()
+  const app = new Hono()
 
   const logger = async (c, next) => {
     console.log(`${c.req.method} : ${c.req.url}`)
-    next()
+    await next()
   }
 
   const rootHeader = async (c, next) => {
-    next()
+    await next()
     await c.res.headers.append('x-custom', 'root')
   }
 
   const customHeader = async (c, next) => {
-    next()
+    await 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')
+    await next()
+    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')
   })
@@ -112,3 +114,45 @@ describe('Middleware', () => {
     expect(await res.headers.get('x-message-2')).toBe('custom-header-2')
   })
 })
+
+describe('Custom 404', () => {
+  const app = new Hono()
+
+  const customNotFound = async (c, next) => {
+    await next()
+    if (c.res.status === 404) {
+      c.res = new fetch.Response('Custom 404 Not Found', { status: 404 })
+    }
+  }
+
+  app.notFound = () => {
+    return new fetch.Response('Default 404 Nout Found', { status: 404 })
+  }
+
+  app.use('*', customNotFound)
+  app.get('/hello', () => {
+    return new fetch.Response('hello')
+  })
+  it('Custom 404 Not Found', async () => {
+    let req = new fetch.Request('https://example.com/hello')
+    let res = await app.dispatch(req)
+    expect(res.status).toBe(200)
+    req = new fetch.Request('https://example.com/foo')
+    res = await app.dispatch(req)
+    expect(res.status).toBe(404)
+    expect(await res.text()).toBe('Custom 404 Not Found')
+  })
+})
+
+describe('Error Handling', () => {
+  const app = new Hono()
+
+  it('Middleware must be async function', () => {
+    expect(() => {
+      app.use('*', {})
+    }).toThrow(TypeError)
+    expect(() => {
+      app.use('*', () => '')
+    }).toThrow(TypeError)
+  })
+})

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

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

package/src/middleware/poweredBy.js

@@ -0,0 +1,6 @@
+const poweredBy = async (c, next) => {
+  await 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,9 @@
+const defaultFilter = require('./middleware/defaultFilter')
+const poweredBy = require('./middleware/poweredBy')
+
+function Middleware() {}
+
+Middleware.defaultFilter = defaultFilter
+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/router.test.js

@@ -1,7 +1,7 @@
-const App = require('./hono')
+const { Hono } = require('./hono')
 
 describe('Basic Usage', () => {
-  const router = App()
+  const router = new Hono()
 
   it('get, post hello', async () => {
     router.get('/hello', 'get hello')
@@ -24,7 +24,7 @@ describe('Basic Usage', () => {
 })
 
 describe('Complex', () => {
-  let router = App()
+  let router = new Hono()
 
   it('Named Param', async () => {
     router.get('/entry/:id', 'get entry')
@@ -56,7 +56,7 @@ describe('Complex', () => {
 })
 
 describe('Chained Route', () => {
-  let router = App()
+  let router = new Hono()
 
   it('Return rooter object', async () => {
     router = router.patch('/hello', 'patch hello')

package/src/util.js

@@ -20,7 +20,14 @@ const getPattern = (label) => {
   }
 }
 
+const getPathFromURL = (url) => {
+  // XXX
+  const match = url.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/)
+  return match[5]
+}
+
 module.exports = {
   splitPath,
   getPattern,
+  getPathFromURL,
 }

package/src/util.test.js

@@ -1,4 +1,4 @@
-const { splitPath, getPattern } = require('./util')
+const { splitPath, getPattern, getPathFromURL } = require('./util')
 
 describe('Utility methods', () => {
   it('splitPath', () => {
@@ -26,4 +26,19 @@ describe('Utility methods', () => {
     expect(res[0]).toBe('id')
     expect(res[1]).toBe('([0-9]+)')
   })
+
+  it('getPathFromURL', () => {
+    let path = getPathFromURL('https://example.com/')
+    expect(path).toBe('/')
+    path = getPathFromURL('https://example.com/hello')
+    expect(path).toBe('/hello')
+    path = getPathFromURL('https://example.com/hello/hey')
+    expect(path).toBe('/hello/hey')
+    path = getPathFromURL('https://example.com/hello?name=foo')
+    expect(path).toBe('/hello')
+    path = getPathFromURL('https://example.com/hello/hey?name=foo&name=bar')
+    expect(path).toBe('/hello/hey')
+    path = getPathFromURL('https://example.com/hello/hey#fragment')
+    expect(path).toBe('/hello/hey')
+  })
 })