hono 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Yusuke Wada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+## hono
+
+## Author
+
+Yusuke Wada <https://github.com/yusukebe>
+
+## License
+
+MIT

package/package.json

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

package/src/hono.js

@@ -0,0 +1,77 @@
+const Router = require('./router')
+
+class Route {
+  constructor(method, handler) {
+    this.method = method;
+    this.handler = handler;
+  }
+}
+
+class App {
+  constructor() {
+    this.router = new Router();
+  }
+
+  addRoute(method, path, handler) {
+    this.router.add(path, new Route(method, handler))
+  }
+
+  handle(event) {
+    const response = this.dispatch(event.request)
+    return event.respondWith(response)
+  }
+
+  dispatch(request) {
+    const url = new URL(request.url)
+    const path = url.pathname
+    const match = this.router.match(path)
+
+    if (!match) {
+      return this.notFound()
+    }
+
+    const method = request.method.toLowerCase()
+    const route = match[0]
+    if (route.method == method) {
+      const handler = route.handler
+      return handler(request)
+    }
+    return this.notFound()
+  }
+
+  notFound() {
+    return new Response('Not Found', {
+      status: 404,
+      headers: {
+        'content-type': 'text/plain'
+      }
+    })
+  }
+
+  fire() {
+    addEventListener("fetch", (event) => {
+      this.handle(event)
+    })
+  }
+}
+
+const proxyHandler = {
+  get: (target, prop) => (...args) => {
+    if (target.constructor.prototype.hasOwnProperty(prop)) {
+      return target[prop](args[0])
+    } else {
+      target.addRoute(prop, args[0], args[1])
+      return
+    }
+  }
+}
+
+const app = new App()
+
+function Hono() {
+  return new Proxy(
+    app, proxyHandler
+  )
+}
+
+module.exports = Hono

package/src/hono.test.js

@@ -0,0 +1,29 @@
+const Hono = require('./hono')
+const fetch = require('node-fetch')
+
+const app = new Hono()
+
+describe('GET match', () => {
+  app.get('/hello', () => {
+    return new fetch.Response('hello', {
+      status: 200
+    })
+  })
+  app.notFound = () => {
+    return new fetch.Response('not found', {
+      status: 404
+    })
+  }
+  it('GET /hello is ok', () => {
+    let req = new fetch.Request('https://example.com/hello')
+    let res = app.dispatch(req)
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(200)
+  })
+  it('GET / is not found', () => {
+    let req = new fetch.Request('https://example.com/')
+    let res = app.dispatch(req)
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(404)
+  })
+})

package/src/router.js

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

package/src/router.test.js

@@ -0,0 +1,66 @@
+const Router = require('./router')
+
+let router = new Router()
+
+describe('root match', () => {
+  it('/ match', () => {
+    router.add('/', 'root')
+    let match = router.match('/')
+    expect(match).not.toBeNull()
+    expect(match[0]).toBe('root')
+    match = router.match('/foo')
+    expect(match).toBeNull()
+  })
+
+  it('/hello match', () => {
+    router.add('/hello', 'hello')
+    match = router.match('/foo')
+    expect(match).toBeNull()
+    match = router.match('/hello')
+    expect(match[0]).toBe('hello')
+  })
+})
+
+describe('path match', () => {
+  router.add('/entry/:id', 'entry-id')
+  router.add('/entry/:id/:comment', 'entry-id-comment')
+  router.add('/year/:year{[0-9]{4}}/:month{[0-9]{2}}', 'date-regex')
+
+  it('entry id match', () => {
+    const match = router.match('/entry/123')
+    expect(match[0]).toBe('entry-id')
+    expect(match[1]['id']).toBe('123')
+  })
+
+  it('entry id and comment match', () => {
+    const match = router.match('/entry/123/45678')
+    expect(match[0]).toBe('entry-id-comment')
+    expect(match[1]['id']).toBe('123')
+    expect(match[1]['comment']).toBe('45678')
+  })
+
+  it('date-regex', () => {
+    const match = router.match('/year/2021/12')
+    expect(match[0]).toBe('date-regex')
+    expect(match[1]['year']).toBe('2021')
+    expect(match[1]['month']).toBe('12')
+  })
+
+  it('not match', () => {
+    let match = router.match('/foo')
+    expect(match).toBeNull()
+    match = router.match('/year/abc')
+    expect(match).toBeNull()
+  })
+})
+
+describe('wildcard', () => {
+  it('match', () => {
+    router = new Router()
+    router.add('/abc/*/def')
+    let match = router.match('/abc/xxx/def')
+    expect(match).not.toBeNull()
+    match = router.match('/abc/xxx/abc')
+    expect(match).toBeNull()
+  })
+})