0http-bun 0.0.2 → 1.0.0

package/README.md

@@ -8,7 +8,9 @@ Experimental, bun-based HTTP framework inspired by [0http](https://0http.21no.de
 ```js
 const http = require('0http-bun')
 
-const { router } = http({})
+const { router } = http({
+  port: 3000
+})
 router.use((req, next) => {
   req.ctx = {
     engine: 'bun'
@@ -28,10 +30,7 @@ router.delete('/:id', async (req) => {
   })
 })
 
-module.exports = {
-  port: 3000,
-  fetch: (request) => router.lookup(request)
-}
+export default router
 ```
 # Benchmarks
 ## 0http-bun (bun v0.2.2)

package/demos/basic.js

@@ -21,7 +21,4 @@ router.delete('/:id', async (req) => {
   })
 })
 
-module.exports = {
-  port: 3000,
-  fetch: (request) => router.lookup(request)
-}
+export default router

package/demos/minimal.js

@@ -7,7 +7,4 @@ router.get('/hi', async (req) => {
   return new Response('Hello World!')
 })
 
-module.exports = {
-  port: 3000,
-  fetch: (request) => router.lookup(request)
-}
+export default router

package/index.js

@@ -1,5 +1,6 @@
 module.exports = (config = {}) => {
-  const router = config.router || require('./lib/router/sequential')(config)
+  // Sequential is default and only router implementation for now
+  const router = require('./lib/router/sequential')(config)
 
   return {
     router

package/lib/next.js

@@ -1,4 +1,4 @@
-module.exports = function next (middlewares, req, index, routers = {}, defaultRoute, errorHandler) {
+module.exports = function next (middlewares, req, index, defaultRoute, errorHandler) {
   const middleware = middlewares[index]
   if (!middleware) {
     return defaultRoute(req)
@@ -8,27 +8,12 @@ module.exports = function next (middlewares, req, index, routers = {}, defaultRo
     if (err) {
       return errorHandler(err, req)
     } else {
-      return next(middlewares, req, index + 1, routers, defaultRoute, errorHandler)
+      return next(middlewares, req, index + 1, defaultRoute, errorHandler)
     }
   }
 
   try {
-    if (middleware.id) {
-      // nested routes support
-      const pattern = routers[middleware.id]
-      if (pattern) {
-        req.preRouterPath = req.path
-
-        req.path = req.path.replace(pattern, '')
-        if (!req.path.startsWith('/')) {
-          req.path = '/' + req.path
-        }
-      }
-
-      return middleware.lookup(req, step)
-    } else {
-      return middleware(req, step)
-    }
+    return middleware(req, step)
   } catch (err) {
     return errorHandler(err, req)
   }

package/lib/router/sequential.js

@@ -2,12 +2,10 @@
 
 const Trouter = require('trouter')
 const next = require('./../next')
-const LRU = require('lru-cache')
-const { parse } = require('regexparam')
 
 module.exports = (config = {}) => {
-  if (config.defaultRoute === undefined) {
-    config.defaultRoute = (req) => {
+  if (!config.defaultRoute) {
+    config.defaultRoute = () => {
       const res = new Response(null, {
         status: 404
       })
@@ -15,8 +13,8 @@ module.exports = (config = {}) => {
       return res
     }
   }
-  if (config.errorHandler === undefined) {
-    config.errorHandler = (err, req) => {
+  if (!config.errorHandler) {
+    config.errorHandler = (err) => {
       const res = new Response(err.message, {
         status: 500
       })
@@ -24,18 +22,9 @@ module.exports = (config = {}) => {
       return res
     }
   }
-  if (config.cacheSize === undefined) {
-    config.cacheSize = 1000
-  }
-  if (config.id === undefined) {
-    config.id = (Date.now().toString(36) + Math.random().toString(36).substring(2, 5)).toUpperCase()
-  }
 
-  const routers = {}
-  const isCacheEnabled = config.cacheSize > 0
-  const cache = isCacheEnabled ? new LRU({ max: config.cacheSize }) : null
   const router = new Trouter()
-  router.id = config.id
+  router.port = config.port || 3000
 
   const _use = router.use
 
@@ -46,53 +35,25 @@ module.exports = (config = {}) => {
     }
     _use.call(router, prefix, middlewares)
 
-    if (middlewares[0].id) {
-      // caching router -> pattern relation for urls pattern replacement
-      const { pattern } = parse(prefix, true)
-      routers[middlewares[0].id] = pattern
-    }
-
     return this
   }
 
-  router.lookup = (req, step) => {
+  router.fetch = (req) => {
     const url = new URL(req.url)
+
     req.path = url.pathname || '/'
     req.query = url.queryparams
     req.search = url.search
     req.hostname = url.hostname
 
-    let match
-    if (isCacheEnabled) {
-      const reqCacheKey = req.method + req.path
-      match = cache.get(reqCacheKey)
-      if (!match) {
-        match = router.find(req.method, req.path)
-        cache.set(reqCacheKey, match)
-      }
-    } else {
-      match = router.find(req.method, req.path)
-    }
-
-    if (match.handlers.length !== 0) {
-      const middlewares = [...match.handlers]
-      if (step !== undefined) {
-        // router is being used as a nested router
-        middlewares.push((req, next) => {
-          req.path = req.preRouterPath
-
-          delete req.preRouterPath
-
-          return step()
-        })
-      }
-
+    const match = router.find(req.method, req.path)
+    if (match.handlers.length > 0) {
       if (!req.params) {
         req.params = {}
       }
       Object.assign(req.params, match.params)
 
-      return next(middlewares, req, 0, routers, config.defaultRoute, config.errorHandler)
+      return next(match.handlers, req, 0, config.defaultRoute, config.errorHandler)
     } else {
       return config.defaultRoute(req)
     }

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "0http-bun",
-  "version": "0.0.2",
-  "description": "0http alternative for Bun",
+  "version": "1.0.0",
+  "description": "0http for Bun",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "lint": "bun x standard",
+    "format": "bun x standard --fix"
   },
   "dependencies": {
-    "lru-cache": "^7.10.1",
-    "regexparam": "^2.0.0",
-    "trouter": "^3.2.0"
+    "trouter": "^3.2.1"
   },
   "repository": {
     "type": "git",

package/test/config.test.js

@@ -0,0 +1,44 @@
+/* global describe, it, expect, beforeAll */
+
+const http = require('../index')
+const { router } = http({
+  port: 3000,
+  defaultRoute: (req) => {
+    const res = new Response('Not Found!', {
+      status: 404
+    })
+
+    return res
+  },
+  errorHandler: (err) => {
+    const res = new Response('Error: ' + err.message, {
+      status: 500
+    })
+
+    return res
+  }
+})
+
+describe('Router Configuration', () => {
+  beforeAll(async () => {
+    router.get('/error', () => {
+      throw new Error('Unexpected error')
+    })
+  })
+
+  it('should return a 500 response for a route that throws an error', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/error', {
+      method: 'GET'
+    }))
+    expect(response.status).toBe(500)
+    expect(await response.text()).toEqual('Error: Unexpected error')
+  })
+
+  it('should return a 404 response for a route that does not exist', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/does-not-exist', {
+      method: 'GET'
+    }))
+    expect(response.status).toBe(404)
+    expect(await response.text()).toEqual('Not Found!')
+  })
+})

package/test/smoke.test.js

@@ -0,0 +1,86 @@
+/* global describe, it, expect, beforeAll */
+
+const http = require('../index')
+const { router } = http({ port: 3000 })
+
+describe('Router', () => {
+  beforeAll(async () => {
+    router.use((req, next) => {
+      req.ctx = {
+        engine: 'bun'
+      }
+
+      return next()
+    })
+
+    router.get('/get-params/:id', (req) => {
+      return Response.json(req.params)
+    })
+
+    router.delete('/get-params/:id', () => {
+      return Response.json('OK')
+    })
+
+    router.get('/error', () => {
+      throw new Error('Unexpected error')
+    })
+
+    router.post('/create', async (req) => {
+      const body = await req.text()
+
+      return Response.json(JSON.parse(body))
+    })
+
+    router.get('/', (req) => {
+      return Response.json(req.ctx)
+    })
+  })
+
+  it('should return a JSON response with the request parameters for GET requests', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/get-params/123', {
+      method: 'GET'
+    }))
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ id: '123' })
+  })
+
+  it('should return a JSON response with the request parameters for DELETE requests', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/get-params/123', {
+      method: 'DELETE'
+    }))
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual('OK')
+  })
+
+  it('should return a JSON response with the request body for POST requests', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/create', {
+      method: 'POST',
+      body: JSON.stringify({ foo: 'bar' })
+    }))
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ foo: 'bar' })
+  })
+
+  it('should return a 404 response for a non-existent route', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/non-existent', {
+      method: 'GET'
+    }))
+    expect(response.status).toBe(404)
+  })
+
+  it('should return a 500 response for a route that throws an error', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/error', {
+      method: 'GET'
+    }))
+    expect(response.status).toBe(500)
+    expect(await response.text()).toEqual('Unexpected error')
+  })
+
+  it('should return a 200 response for a route that returns a Response object', async () => {
+    const response = await router.fetch(new Request('http://localhost:3000/', {
+      method: 'GET'
+    }))
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ engine: 'bun' })
+  })
+})