0http-bun 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 BackendStack21.js
+
+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,36 @@
+# Introduction
+Experimental, bun-based HTTP framework inspired by 0http!
+
+## Usage
+```js
+const http = require('0http-bun')
+
+const { router } = http({})
+router.use((req, next) => {
+  req.ctx = {
+    engine: 'bun'
+  }
+
+  return next()
+})
+router.get('/:id', async (req) => {
+  return Response.json(req.params)
+})
+router.post('/', async (req) => {
+  return new Response('POST')
+})
+router.delete('/:id', async (req) => {
+  return Response.json(req.params, {
+    status: 200
+  })
+})
+
+module.exports = {
+  port: 3000,
+  fetch: (request) => router.lookup(request)
+}
+```
+
+# Support / Donate 💚
+You can support the maintenance of this project: 
+- PayPal: https://www.paypal.me/kyberneees

package/demos/basic.js

@@ -0,0 +1,27 @@
+/* global Response */
+const http = require('../index')
+
+const { router } = http({})
+router.use((req, next) => {
+  req.ctx = {
+    engine: 'bun'
+  }
+
+  return next()
+})
+router.get('/:id', async (req) => {
+  return Response.json(req.params)
+})
+router.post('/', async (req) => {
+  return new Response('POST')
+})
+router.delete('/:id', async (req) => {
+  return Response.json(req.params, {
+    status: 200
+  })
+})
+
+module.exports = {
+  port: 3000,
+  fetch: (request) => router.lookup(request)
+}

package/index.js

@@ -0,0 +1,7 @@
+module.exports = (config = {}) => {
+  const router = config.router || require('./lib/router/sequential')(config)
+
+  return {
+    router
+  }
+}

package/lib/next.js

@@ -0,0 +1,35 @@
+module.exports = function next (middlewares, req, index, routers = {}, defaultRoute, errorHandler) {
+  const middleware = middlewares[index]
+  if (!middleware) {
+    return defaultRoute(req)
+  }
+
+  function step (err) {
+    if (err) {
+      return errorHandler(err, req)
+    } else {
+      return next(middlewares, req, index + 1, routers, 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)
+    }
+  } catch (err) {
+    return errorHandler(err, req)
+  }
+}

package/lib/router/sequential.js

@@ -0,0 +1,104 @@
+/* global Response */
+
+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) => {
+      const res = new Response(null, {
+        status: 404
+      })
+
+      return res
+    }
+  }
+  if (config.errorHandler === undefined) {
+    config.errorHandler = (err, req) => {
+      const res = new Response(err.message, {
+        status: 500
+      })
+
+      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
+
+  const _use = router.use
+
+  router.use = (prefix, ...middlewares) => {
+    if (typeof prefix === 'function') {
+      middlewares = [prefix, ...middlewares]
+      prefix = '/'
+    }
+    _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 = async (req, step) => {
+    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()
+        })
+      }
+
+      if (!req.params) {
+        req.params = {}
+      }
+      Object.assign(req.params, match.params)
+
+      return next(middlewares, req, 0, routers, config.defaultRoute, config.errorHandler)
+    } else {
+      return config.defaultRoute(req)
+    }
+  }
+
+  router.on = (method, pattern, ...handlers) => router.add(method, pattern, handlers)
+
+  return router
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "0http-bun",
+  "version": "0.0.1",
+  "description": "0http alternative for Bun",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "lru-cache": "^7.10.1",
+    "regexparam": "^2.0.0",
+    "trouter": "^3.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BackendStack21/0http-bun.git"
+  },
+  "keywords": [
+    "http",
+    "server",
+    "rest",
+    "api",
+    "web",
+    "bun"
+  ],
+  "author": "Rolando Santamaria Maso <kyberneees@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/BackendStack21/0http-bun/issues"
+  },
+  "homepage": "https://github.com/BackendStack21/0http-bun#readme"
+}