@srfnstack/spliffy 1.2.8 → 1.3.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@srfnstack/spliffy",
-  "version": "1.2.8",
+  "version": "1.3.0",
   "author": "snowbldr",
   "private": false,
   "homepage": "https://github.com/SRFNStack/spliffy",
   "license": "MIT",
   "type": "module",
   "engines": {
-    "node": ">=16 <=20"
+    "node": ">=20 <=24"
   },
   "files": [
     "src/*",
@@ -22,7 +22,8 @@
   "scripts": {
     "test": "npm run lint:fix && jest",
     "lint": "standard --env jest src ./*js && standard --env jest --env browser --global Prism docs example",
-    "lint:fix": "standard --env jest --fix src ./*js && standard --env jest --env browser --global Prism --fix docs example"
+    "lint:fix": "standard --env jest --fix src ./*js && standard --env jest --env browser --global Prism --fix docs example",
+    "bench": "node bench/compare.mjs"
   },
   "keywords": [
     "node",
@@ -39,6 +40,7 @@
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.56.0"
   },
   "devDependencies": {
+    "autocannon": "^8.0.0",
     "helmet": "^4.6.0",
     "jest": "^27.3.1",
     "node-fetch": "^2.6.7",

package/src/decorator.mjs

@@ -8,7 +8,8 @@ import httpStatusCodes, { defaultStatusMessages } from './httpStatusCodes.mjs'
 
 const { Writable } = stream
 
-const addressArrayBufferToString = addrBuf => String.fromCharCode.apply(null, new Int8Array(addrBuf))
+const addressArrayBufferToString = addrBuf => Buffer.from(addrBuf).toString()
+
 const excludedMessageProps = {
   setTimeout: true,
   _read: true,
@@ -19,73 +20,78 @@ const excludedMessageProps = {
   __proto__: true
 }
 
-const normalizeHeader = header => header.toLowerCase()
-
 const reqProtoProps = () => Object.keys(http.IncomingMessage.prototype).filter(p => !excludedMessageProps[p])
 
-export const setCookie = (res) => function () {
-  return res.setHeader('Set-Cookie', [...(res.getHeader('Set-Cookie') || []), cookie.serialize(...arguments)])
-}
+class SpliffyRequest {
+  constructor (uwsReq, pathParameters, res, config) {
+    const query = uwsReq.getQuery()
+    this.res = res
+    this.path = uwsReq.getUrl()
+    this.url = query ? `${this.path}?${query}` : this.path
+    this.method = uwsReq.getMethod().toUpperCase()
+    this.headers = {}
+    uwsReq.forEach((header, value) => {
+      this.headers[header] = value
+    })
+
+    if (config.extendIncomingMessage) {
+      for (const p of reqProtoProps()) {
+        if (!this[p]) this[p] = http.IncomingMessage.prototype[p]
+      }
+    }
+
+    const paramToIndex = pathParameters.reduce((acc, cur, i) => {
+      acc[cur] = i
+      return acc
+    }, {})
 
-export function decorateRequest (uwsReq, pathParameters, res, {
-  decodeQueryParameters,
-  decodePathParameters,
-  parseCookie,
-  extendIncomingMessage
-} = {}) {
-  // uwsReq can't be used in async functions because it gets de-allocated when the handler function returns
-  const req = {}
-  if (extendIncomingMessage) {
-    // frameworks like passport like to modify the message prototype
-    // Setting the prototype of req is not desirable because the entire api of IncomingMessage is not supported
-    for (const p of reqProtoProps()) {
-      if (!req[p]) req[p] = http.IncomingMessage.prototype[p]
+    this.spliffyUrl = {
+      path: this.path,
+      query: (query && parseQuery(query, config.decodeQueryParameters)) || {},
+      param: name => uwsReq.getParameter(paramToIndex[name])
     }
+    this.query = this.spliffyUrl.query
+    if (config.parseCookie) {
+      this.cookies = (this.headers.cookie && cookie.parse(this.headers.cookie)) || {}
+    }
+  }
+
+  get remoteAddress () {
+    const val = addressArrayBufferToString(this.res.getRemoteAddressAsText())
+    Object.defineProperty(this, 'remoteAddress', { value: val, enumerable: true })
+    return val
+  }
+
+  get proxiedRemoteAddress () {
+    const val = addressArrayBufferToString(this.res.getProxiedRemoteAddressAsText())
+    Object.defineProperty(this, 'proxiedRemoteAddress', { value: val, enumerable: true })
+    return val
+  }
+
+  get (header) {
+    return this.headers[header.toLowerCase()]
   }
-  const query = uwsReq.getQuery()
-  req.path = uwsReq.getUrl()
-  req.url = `${req.path}${query ? '?' + query : ''}`
-  const paramToIndex = pathParameters.reduce((acc, cur, i) => {
-    acc[cur] = i
-    return acc
-  }, {})
-  req.spliffyUrl = {
-    path: req.path,
-    query: (query && parseQuery(query, decodeQueryParameters)) || {},
-    param: name => uwsReq.getParameter(paramToIndex[name])
-  }
-  req.query = req.spliffyUrl.query
-  req.headers = {}
-  uwsReq.forEach((header, value) => { req.headers[header] = value })
-  req.method = uwsReq.getMethod().toUpperCase()
-  req.remoteAddress = addressArrayBufferToString(res.getRemoteAddressAsText())
-  req.proxiedRemoteAddress = addressArrayBufferToString(res.getProxiedRemoteAddressAsText())
-  req.get = header => req.headers[header]
-  if (parseCookie) {
-    req.cookies = (req.headers.cookie && cookie.parse(req.headers.cookie)) || {}
-  }
-  return req
 }
 
-function toArrayBuffer (buffer) {
-  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+export function decorateRequest (uwsReq, pathParameters, res, config) {
+  return new SpliffyRequest(uwsReq, pathParameters, res, config)
 }
 
-export function decorateResponse (res, req, finalizeResponse, errorTransformer, endError, { acceptsDefault }) {
+export function decorateResponse (res, req, finalizeResponse, errorTransformer, endError, config) {
   res.onAborted(() => {
     res.ended = true
     res.writableEnded = true
     res.finalized = true
     log.error(`Request to ${req.url} was aborted`)
   })
-  res.acceptsDefault = acceptsDefault
+  res.acceptsDefault = config.acceptsDefault
   res.headers = {}
   res.headersSent = false
   res.setHeader = (header, value) => {
-    res.headers[normalizeHeader(header)] = value
+    res.headers[header.toLowerCase()] = value
   }
   res.removeHeader = header => {
-    delete res.headers[normalizeHeader(header)]
+    delete res.headers[header.toLowerCase()]
   }
   res.flushHeaders = () => {
     if (res.headersSent) return
@@ -96,118 +102,106 @@ export function decorateResponse (res, req, finalizeResponse, errorTransformer,
     if (typeof res.onFlushHeaders === 'function') {
       res.onFlushHeaders(res)
     }
-    for (const header of Object.keys(res.headers)) {
-      if (Array.isArray(res.headers[header])) {
-        for (const multiple of res.headers[header]) {
-          res.writeHeader(header, multiple.toString())
+    for (const header in res.headers) {
+      const val = res.headers[header]
+      if (Array.isArray(val)) {
+        for (let i = 0; i < val.length; i++) {
+          res.writeHeader(header, val[i].toString())
         }
       } else {
-        res.writeHeader(header, res.headers[header].toString())
+        res.writeHeader(header, val.toString())
       }
     }
   }
   res.writeHead = (status, headers) => {
     res.statusCode = status
-    res.assignHeaders(headers)
+    if (headers) res.assignHeaders(headers)
   }
   res.assignHeaders = headers => {
-    for (const header of Object.keys(headers)) {
-      res.headers[normalizeHeader(header)] = headers[header]
+    for (const header in headers) {
+      res.headers[header.toLowerCase()] = headers[header]
     }
   }
   res.getHeader = header => {
-    return res.headers[normalizeHeader(header)]
+    return res.headers[header.toLowerCase()]
   }
   res.status = (code) => {
     res.statusCode = code
-    return this
+    return res
   }
 
-  res.uwsWrite = res.write
+  const uwsWrite = res.write
   res.write = (chunk, encoding, cb) => {
     res.cork(() => {
-      try {
-        res.streaming = true
-        res.flushHeaders()
-        let data
-        if (chunk instanceof Buffer) {
-          data = toArrayBuffer(chunk)
-        } else if (typeof chunk === 'string') {
-          data = toArrayBuffer(Buffer.from(chunk, encoding || 'utf8'))
-        } else {
-          data = toArrayBuffer(Buffer.from(JSON.stringify(chunk), encoding || 'utf8'))
-        }
-        const result = res.uwsWrite(data)
-        if (typeof cb === 'function') {
-          cb()
-        }
-        return result
-      } catch (e) {
-        if (typeof cb === 'function') {
-          cb(e)
-        } else {
-          throw e
-        }
+      res.streaming = true
+      res.flushHeaders()
+      let data
+      if (chunk instanceof Buffer || chunk instanceof Uint8Array || typeof chunk === 'string') {
+        data = chunk
+      } else {
+        data = JSON.stringify(chunk)
       }
+      const result = uwsWrite.call(res, data)
+      if (typeof cb === 'function') cb()
+      return result
     })
   }
-  let outStream
+
   res.getWritable = () => {
-    if (!outStream) {
+    if (!res.outStream) {
       res.streaming = true
-      outStream = new Writable({
-        write: res.write
+      res.outStream = new Writable({
+        write: (chunk, encoding, callback) => {
+          res.write(chunk, encoding, callback)
+        }
       })
-        .on('finish', res.end)
-        .on('end', res.end)
+        .on('finish', () => res.end())
         .on('error', e => {
           try {
-            outStream.destroy()
+            res.outStream.destroy()
           } finally {
             endError(res, e, uuid(), errorTransformer)
           }
         })
     }
-    return outStream
+    return res.outStream
   }
 
   const uwsEnd = res.end
   res.ended = false
   res.end = body => {
-    if (res.ended) {
-      return
-    }
-    // provide writableEnded like node does, with slightly different behavior
-    if (!res.writableEnded) {
-      res.cork(() => {
-        res.flushHeaders()
-        uwsEnd.call(res, body)
-        res.writableEnded = true
-        res.ended = true
-      })
-    }
-    if (typeof res.onEnd === 'function') {
-      res.onEnd()
-    }
+    if (res.ended) return
+    res.cork(() => {
+      if (!res.headersSent) res.flushHeaders()
+      uwsEnd.call(res, body || '')
+      res.writableEnded = true
+      res.ended = true
+      if (typeof res.onEnd === 'function') res.onEnd()
+    })
   }
 
-  res.redirect = function (code, location) {
-    if (arguments.length === 1) {
+  res.redirect = (code, location) => {
+    if (typeof code === 'string') {
       location = code
       code = httpStatusCodes.MOVED_PERMANENTLY
     }
     return finalizeResponse(req, res, {
       statusCode: code,
-      headers: {
-        location: location
-      }
+      headers: { location }
     })
   }
-  res.send = (body) => {
-    finalizeResponse(req, res, body)
-  }
+  res.send = (body) => finalizeResponse(req, res, body)
   res.json = res.send
-  res.setCookie = setCookie(res)
+  res.setCookie = (name, value, options) => {
+    const serialized = cookie.serialize(name, value, options)
+    const existing = res.getHeader('Set-Cookie')
+    if (existing) {
+      if (Array.isArray(existing)) existing.push(serialized)
+      else res.setHeader('Set-Cookie', [existing, serialized])
+    } else {
+      res.setHeader('Set-Cookie', serialized)
+    }
+  }
   res.cookie = res.setCookie
   return res
 }

package/src/handler.mjs

@@ -1,6 +1,6 @@
 import log from './log.mjs'
 import { deserializeBody, serializeBody } from './content.mjs'
-import { invokeMiddleware } from './middleware.mjs'
+import { invokeMiddleware, preProcessMiddleware } from './middleware.mjs'
 import { decorateResponse, decorateRequest } from './decorator.mjs'
 import { v4 as uuid } from 'uuid'
 import stream from 'stream'
@@ -34,7 +34,9 @@ const executeHandler = async (url, res, req, bodyPromise, handler, middleware, e
     finalizeResponse(req, res, handled, handler.statusCodeOverride)
   } catch (e) {
     const refId = uuid()
-    await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    if (middleware) {
+      await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    }
     endError(res, e, refId, errorTransformer)
   }
 }
@@ -73,9 +75,9 @@ const ipv6CompressRegex = /\b:?(?:0+:?){2,}/g
 const compressIpv6 = ip => ip && ip.includes(':') ? ip.replaceAll(ipv6CompressRegex, '::') : ip
 
 const writeAccess = function (req, res) {
-  const start = new Date().getTime()
+  const start = Date.now()
   return () => {
-    log.access(compressIpv6(req.remoteAddress), compressIpv6(res.proxiedRemoteAddress) || '', res.statusCode, req.method, req.url, new Date().getTime() - start + 'ms')
+    log.access(compressIpv6(req.remoteAddress), compressIpv6(res.proxiedRemoteAddress) || '', res.statusCode, req.method, req.url, Date.now() - start + 'ms')
   }
 }
 
@@ -101,8 +103,8 @@ const finalizeResponse = (req, res, handled, statusCodeOverride) => {
 }
 
 const pipeResponse = (res, readStream, errorTransformer) => {
-  readStream.on('data', res.write)
-    .on('end', res.end)
+  readStream.on('data', chunk => res.write(chunk))
+    .on('end', () => res.end())
     .on('error', e => {
       try {
         readStream.destroy()
@@ -125,22 +127,18 @@ const doSerializeBody = (body, res) => {
   return serialized?.data || ''
 }
 
-async function executeMiddleware (middleware, req, res, errorTransformer, refId, e) {
-  if (!middleware) return
+async function executeMiddleware (processedMiddleware, req, res, errorTransformer, refId, e) {
+  if (!processedMiddleware) return
 
-  let applicableMiddleware = middleware[req.method]
-  if (middleware.ALL) {
-    if (applicableMiddleware) applicableMiddleware = middleware.ALL.concat(applicableMiddleware)
-    else applicableMiddleware = middleware.ALL
-  }
+  const methodMiddleware = processedMiddleware[req.method]
+  const allMiddleware = processedMiddleware.ALL
 
-  if (!applicableMiddleware || applicableMiddleware.length === 0) {
-    return
-  }
   if (e) {
-    await invokeMiddleware(applicableMiddleware.filter(mw => mw.length === 4), req, res, e)
+    if (allMiddleware?.error) await invokeMiddleware(allMiddleware.error, req, res, e)
+    if (methodMiddleware?.error) await invokeMiddleware(methodMiddleware.error, req, res, e)
   } else {
-    await invokeMiddleware(applicableMiddleware.filter(mw => mw.length === 3), req, res)
+    if (allMiddleware?.normal) await invokeMiddleware(allMiddleware.normal, req, res)
+    if (methodMiddleware?.normal) await invokeMiddleware(methodMiddleware.normal, req, res)
   }
 }
 
@@ -148,39 +146,47 @@ const handleRequest = async (req, res, handler, middleware, errorTransformer) =>
   try {
     let reqBody
     if (!handler.streamRequestBody) {
-      let buffer
-      reqBody = new Promise(
-        resolve =>
-          res.onData(async (data, isLast) => {
-            if (isLast) {
-              buffer = data.byteLength > 0 ? Buffer.concat([buffer, Buffer.from(data)].filter(b => b)) : buffer
-              resolve(buffer)
-            }
-            buffer = Buffer.concat([buffer, Buffer.from(data)].filter(b => b))
-          })
-      )
+      if (req.method === 'GET' || req.method === 'HEAD') {
+        reqBody = Promise.resolve(null)
+      } else {
+        let buffer
+        reqBody = new Promise(
+          resolve =>
+            res.onData((data, isLast) => {
+              const chunk = Buffer.concat([Buffer.from(data)])
+              buffer = buffer ? Buffer.concat([buffer, chunk]) : chunk
+              if (isLast) {
+                resolve(buffer)
+              }
+            })
+        )
+      }
     } else {
       const readable = new Readable({
         read: () => {
         }
       })
-      res.onData(async (data, isLast) => {
-        if (data.byteLength === 0 && !isLast) return
-        // data must be copied so it isn't lost
-        readable.push(Buffer.concat([Buffer.from(data)]))
-        if (isLast) {
-          readable.push(null)
+      res.onData((data, isLast) => {
+        if (data.byteLength > 0 || isLast) {
+          readable.push(Buffer.concat([Buffer.from(data)]))
+          if (isLast) {
+            readable.push(null)
+          }
         }
       })
       reqBody = Promise.resolve(readable)
     }
-    await executeMiddleware(middleware, req, res, errorTransformer)
+    if (middleware) {
+      await executeMiddleware(middleware, req, res, errorTransformer)
+    }
     if (!res.writableEnded && !res.ended) {
       await executeHandler(req.spliffyUrl, res, req, reqBody, handler, middleware, errorTransformer)
     }
   } catch (e) {
     const refId = uuid()
-    await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    if (middleware) {
+      await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    }
     if (!res.writableEnded) { endError(res, e, refId, errorTransformer) }
   }
 }
@@ -190,31 +196,41 @@ export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS',
 let currentDate = new Date().toISOString()
 setInterval(() => { currentDate = new Date().toISOString() }, 1000)
 
-export const createHandler = (handler, middleware, pathParameters, config) => function (res, req) {
-  try {
-    res.cork(() => {
-      req = decorateRequest(req, pathParameters, res, config)
-      res = decorateResponse(res, req, finalizeResponse, config.errorTransformer, endError, config)
+export const createHandler = (handler, middleware, pathParameters, config) => {
+  const processedMiddleware = preProcessMiddleware(middleware)
+  return function (res, req) {
+    try {
+      res.cork(() => {
+        req = decorateRequest(req, pathParameters, res, config)
+        res = decorateResponse(res, req, finalizeResponse, config.errorTransformer, endError, config)
 
-      if (config.logAccess) {
-        res.onEnd = writeAccess(req, res)
-      }
+        if (config.logAccess) {
+          // pre-fetch IPs for logging while still safe
+          req._ra = req.remoteAddress
+          req._pra = req.proxiedRemoteAddress
+          res.onEnd = writeAccess(req, res)
+        }
 
-      if (config.writeDateHeader) {
-        res.headers.date = currentDate
-      }
+        if (config.writeDateHeader) {
+          res.headers.date = currentDate
+        }
 
-      handleRequest(req, res, handler, middleware, config.errorTransformer)
-        .catch(e => {
-          log.error('Failed handling request', e)
-          res.statusCode = 500
-          res.end()
-        })
-    })
-  } catch (e) {
-    log.error('Failed handling request', e)
-    res.statusCode = 500
-    res.end()
+        handleRequest(req, res, handler, processedMiddleware, config.errorTransformer)
+          .catch(e => {
+            log.error('Failed handling request', e)
+            if (!res.writableEnded) {
+              res.statusCode = 500
+              res.end()
+            }
+          })
+      })
+    } catch (e) {
+      log.error('Failed handling request', e)
+      if (!res.writableEnded) {
+        res.statusCode = 500
+        res.end()
+      }
+    }
   }
 }
 
@@ -223,32 +239,41 @@ export const createNotFoundHandler = config => {
   const params = handler?.pathParameters || []
   return (res, req) => {
     try {
-      req = decorateRequest(req, params, res, config)
-      res = decorateResponse(res, req, finalizeResponse, config.errorTransformer, endError, config)
-      if (config.logAccess) {
-        res.onEnd = writeAccess(req, res)
-      }
-      if (handler && typeof handler === 'object') {
-        if (handler.handlers && typeof handler.handlers[req.method] === 'function') {
-          if ('statusCodeOverride' in handler) {
-            handler.handlers[req.method].statusCodeOverride = handler.statusCodeOverride
+      res.cork(() => {
+        req = decorateRequest(req, params, res, config)
+        res = decorateResponse(res, req, finalizeResponse, config.errorTransformer, endError, config)
+        if (config.logAccess) {
+          req._ra = req.remoteAddress
+          req._pra = req.proxiedRemoteAddress
+          res.onEnd = writeAccess(req, res)
+        }
+        if (handler && typeof handler === 'object') {
+          const processedMiddleware = preProcessMiddleware(handler.middleware)
+          if (handler.handlers && typeof handler.handlers[req.method] === 'function') {
+            const h = handler.handlers[req.method]
+            if ('statusCodeOverride' in handler) {
+              h.statusCodeOverride = handler.statusCodeOverride
+            }
+            handleRequest(req, res,
+              h,
+              processedMiddleware,
+              config.errorTransformer
+            ).catch((e) => {
+              log.error('Unexpected exception during request handling', e)
+              if (!res.writableEnded) {
+                res.statusCode = 500
+                res.end()
+              }
+            })
+          } else {
+            res.statusCode = 404
+            res.end()
           }
-          handleRequest(req, res,
-            handler.handlers[req.method],
-            handler.middleware,
-            config.errorTransformer
-          ).catch((e) => {
-            log.error('Unexpected exception during request handling', e)
-            res.statusCode = 500
-          })
         } else {
           res.statusCode = 404
           res.end()
         }
-      } else {
-        res.statusCode = 404
-        res.end()
-      }
+      })
     } catch (e) {
       log.error('Failed handling request', e)
     }

package/src/middleware.mjs

@@ -61,26 +61,39 @@ export const validateMiddlewareArray = (arr) => {
   }
 }
 
+export function preProcessMiddleware (middleware) {
+  if (!middleware) return null
+  const processed = {}
+  let hasAny = false
+  for (const method in middleware) {
+    const list = middleware[method]
+    if (list && list.length > 0) {
+      processed[method] = {
+        normal: list.filter(mw => mw.length <= 3),
+        error: list.filter(mw => mw.length === 4)
+      }
+      hasAny = true
+    }
+  }
+  return hasAny ? processed : null
+}
+
 export async function invokeMiddleware (middleware, req, res, reqErr) {
-  await new Promise((resolve, reject) => {
-    let current = -1
+  if (!middleware || middleware.length === 0) return
+  return new Promise((resolve, reject) => {
+    let current = 0
     const next = (err) => {
-      if (err) reject(err)
-      if (res.writableEnded) {
-        resolve()
-        return
+      if (err) return reject(err)
+      if (res.writableEnded || current === middleware.length) {
+        return resolve()
       }
-      current++
-      if (current === middleware.length) {
-        resolve()
-      } else {
-        try {
-          if (reqErr) middleware[current](reqErr, req, res, next)
-          else middleware[current](req, res, next)
-        } catch (e) {
-          log.error('Middleware threw exception', e)
-          reject(e)
-        }
+      const mw = middleware[current++]
+      try {
+        if (reqErr) mw(reqErr, req, res, next)
+        else mw(req, res, next)
+      } catch (e) {
+        log.error('Middleware threw exception', e)
+        reject(e)
       }
     }