feat: rewrite promisify logic

Author: pi0

README.md

@@ -1,7 +1,7 @@
 # h2
 
-[![npm](https://img.shields.io/npm/dm/h-2.svg?style=flat-square)](https://npmjs.com/package/h-2)
-[![npm (scoped with tag)](https://img.shields.io/npm/v/h-2/latest.svg?style=flat-square)](https://npmjs.com/package/h-2)
+[![npm](https://img.shields.io/npm/dm/@nuxt/h2.svg?style=flat-square)](https://npmjs.com/package/@nuxt/h2)
+[![npm (scoped with tag)](https://img.shields.io/npm/v/@nuxt/h2/latest.svg?style=flat-square)](https://npmjs.com/package/@nuxt/h2)
 
 > h2 is a 3 kB modern and environment agnostic http framework
 
@@ -11,8 +11,8 @@
 - Compatibile with connect/express middleware
 - Tree-shakable and zero dependency
 - Promise and `aync/await` support
-- Lazy loading middleware
-- Basic router
+- Lazy loading
+- Basic Router
 
 > See [un](https://github.com/nuxt-contrib/un) for workers support
 
@@ -31,13 +31,14 @@ const { Server } = require('http')
 const { createApp } = require('@nuxt/h2')
 
 const app = createApp()
-app.use('/', () => 'Hello world!')
+
 app.use('/api', (req) => ({ url: req.url }))
+app.use('/', () => 'Hello world!')
 
 const port = process.env.PORT || 3000
 const server = new Server(app.handle)
 server.listen(port, () => {
-  console.log(`Listening on: http://localhost:${port}`
+  console.log(`Listening on: http://localhost:${port}`)
 })
 ```
 
@@ -48,44 +49,6 @@ server.listen(port, () => {
 - `redirect (req, location, code)`
 - `lazy (handle)`
 
-## `promisifyHandle`
-
-Optionally you can use express or your own middleware system by directly using this utility and not using app stack.
-
-Converts handle/middleware into a promisified async version:
-
-- Ensures if handle is an `async` function or returning `Promise`, error is passed to the next middleware
-- If middleware supports a third param (`next` callback) it will be piped to the promise chain
-- If middleware returns or calls `next(null, value)` it will be piped to the promise chain
-  - Otherwise resolves promise to `response.writableEnded` to indicate response is ended or not
-
-**Why?**
-
-- Avoid unhandled promise rejections since developers usually create `async` middleware without handling errors
-- Allow directly using any middleware (like `serve-static`) by awaiting on it
-- Convert vanilla http server into a modern handler supporting async and json!
-
-**Example:** Register middleware and ensure it is safe using async operations
-
-```js
-const express = require('express')
-
-const app = express()
-
-const test = async (req, res) => {
-  await Promise.reject(new Error('oops!'))
-}
-
-app.use('/api/test', promisifyHandle(test))
-```
-
-**Example:** Use `serve-static` as an awaitable utility
-
-```js
-const serveStatic = promisifyHandle(require('serve-static'))
-const served = await serveStatic(req, res)
-```
-
 ## License
 
 MIT

package.json

@@ -20,6 +20,7 @@
     "@nuxtjs/eslint-config-typescript": "latest",
     "@types/node": "latest",
     "eslint": "latest",
+    "express": "^4.17.1",
     "jest": "^26.6.3",
     "siroc": "latest",
     "standard-version": "latest",

src/app.ts

@@ -18,8 +18,9 @@ export function createApp (): App {
         }
         req.url = originalUrl.substr(layer.route.length)
       }
-      // Direct return support
+
       const val = await layer.handle(req, res)
+
       const type = typeof val
       if (type === 'string') {
         send(res, val, MIMES.html)

src/index.ts

@@ -2,3 +2,4 @@ export * from './app'
 export * from './promisify'
 export * from './types'
 export * from './utils'
+export * from './lazy'

src/lazy.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from 'http'
+import { LazyHandle, Handle } from './types'
+
+export function lazy (handle: LazyHandle): Handle {
+  let _promise: Promise<Handle>
+
+  const resolve = () => {
+    if (!_promise) {
+      _promise = Promise.resolve(handle()).then((r: any) => r.default || r)
+    }
+    return _promise
+  }
+
+  return function (req: IncomingMessage, res: ServerResponse) {
+    return resolve().then(h => h(req, res))
+  }
+}

src/promisify.ts

@@ -1,33 +1,25 @@
 import type { IncomingMessage, ServerResponse } from 'http'
-import type { Handle, PHandle, NextFn } from './types'
+import type { Handle, Middleware } from './types'
 
-export function promisifyHandle (handle: Handle): PHandle {
-  const hasNext = handle.length >= 3 /* req,res,next */
-  if (hasNext) {
-    return function _promisified (req, res, next) {
-      return callHandle(req, res, handle, next)
-    }
-  } else {
-    return function _promisified (req, res) {
-      return callHandle(req, res, handle)
-    }
+export function promisifyHandle (handle: Handle | Middleware): Handle {
+  return function (req: IncomingMessage, res: ServerResponse) {
+    return callHandle(handle as Handle, req, res)
   }
 }
 
-function callHandle (req: IncomingMessage, res: ServerResponse, handle: Handle, next?: NextFn) {
-  const promise = new Promise((resolve, reject) => {
-    const _next = next ? (err?: Error, val?: any) => err ? reject(err) : resolve(val) : undefined
-    let _promise
+function callHandle (handle: Middleware, req: IncomingMessage, res: ServerResponse) {
+  return new Promise((resolve, reject) => {
+    const next = (err?: Error) => err ? reject(err) : resolve()
     try {
-      _promise = handle(req, res, _next)
+      const returned = handle(req, res, next)
+      if (returned !== undefined) {
+        resolve(returned)
+      } else {
+        res.once('close', next)
+        res.once('error', next)
+      }
     } catch (err) {
-      reject(err)
-    }
-    if (!next) {
-      resolve(_promise)
+      next(err)
     }
   })
-  return promise
-    .then((val?: any) => next ? next() : (val === undefined ? res.writableEnded : val))
-    .catch(err => next && next(err))
 }

src/types.ts

@@ -1,14 +1,12 @@
 import type { IncomingMessage, ServerResponse } from 'http'
 
-export type NextFn = (err?: Error) => any
+export type Handle = (req: IncomingMessage, res: ServerResponse) => any
 
-export type Handle = (req: IncomingMessage, res: ServerResponse, next?: NextFn) => any
-
-export type PHandle = (req: IncomingMessage, res: ServerResponse, next?: NextFn) => Promise<any>
+export type Middleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any
 
 export interface Layer {
   route: string
-  handle: PHandle
+  handle: Handle
 }
 
 export type Stack = Layer[]
@@ -22,23 +20,3 @@ export interface App {
   handle: Handle
   use: (route: string, handle: Handle) => void
 }
-
-export type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le'
-  | 'ucs2' | 'ucs-2' | 'base64' | 'latin1' | 'binary' | 'hex'
-
-export type Callback<E = Error | null | undefined> = (error?: E) => void
-
-export type HeadersObject = { [key: string]: string | string[] | undefined }
-
-export interface CallContext {
-  url?: string
-  method?: string
-  headers?: HeadersObject
-  host?: string
-  protocol?: 'http' | 'https' | string
-
-  req?: IncomingMessage
-  res?: ServerResponse
-
-  [key: string]: any
-}

src/utils.ts

@@ -1,5 +1,4 @@
 import type { ServerResponse } from 'http'
-import { LazyHandle, Handle } from './types'
 
 export const MIMES = {
   html: 'text/html',
@@ -37,14 +36,3 @@ export function redirect (res: ServerResponse, location: string, code = 302) {
   defaultContentType(res, MIMES.html)
   res.end(location)
 }
-
-export function lazy (handle: LazyHandle): Handle {
-  let _promise: Promise<Handle>
-  const resolve = () => (
-    _promise = _promise ||
-    Promise.resolve(handle()).then((r: any) => r.default || r)
-  )
-  return function _lazy (req, res) {
-    return resolve().then(h => h(req, res))
-  }
-}

test/fixture/server.js

@@ -0,0 +1,23 @@
+const { Server } = require('http')
+const express = require('express')
+const { createApp } = require('../..')
+
+function createExpress () {
+  const app = express()
+  app.use('/', (_req, res) => {
+    res.json({ express: 'works' })
+  })
+  return app
+}
+
+const app = createApp()
+
+app.use('/api/hello', req => ({ url: req.url }))
+app.use('/api/express', createExpress())
+app.use('/', () => 'Hello world!')
+
+const port = process.env.PORT || 3000
+const server = new Server(app.handle)
+server.listen(port, () => {
+  console.log(`Listening on: http://localhost:${port}`)
+})