@srfnstack/spliffy 1.2.9 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@srfnstack/spliffy",
-  "version": "1.2.9",
+  "version": "1.4.0",
   "author": "snowbldr",
   "private": false,
   "homepage": "https://github.com/SRFNStack/spliffy",
@@ -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

@@ -1,213 +1,214 @@
 import cookie from 'cookie'
-import http from 'http'
 import { parseQuery } from './url.mjs'
-import log from './log.mjs'
 import { v4 as uuid } from 'uuid'
 import stream from 'stream'
-import httpStatusCodes, { defaultStatusMessages } from './httpStatusCodes.mjs'
+import { defaultStatusMessages } from './httpStatusCodes.mjs'
 
 const { Writable } = stream
 
-const addressArrayBufferToString = addrBuf => String.fromCharCode.apply(null, new Int8Array(addrBuf))
-const excludedMessageProps = {
-  setTimeout: true,
-  _read: true,
-  destroy: true,
-  _addHeaderLines: true,
-  _addHeaderLine: true,
-  _dump: true,
-  __proto__: true
-}
-
-const normalizeHeader = header => header.toLowerCase()
+export class SpliffyRequest {
+  constructor (uwsReq, paramToIndex, res, config) {
+    this.init(uwsReq, paramToIndex, res, config)
+  }
 
-const reqProtoProps = () => Object.keys(http.IncomingMessage.prototype).filter(p => !excludedMessageProps[p])
+  init (uwsReq, paramToIndex, res, config, method, urlPath) {
+    this.res = res
+    this._uwsReq = uwsReq
+    this._config = config
+    this._paramToIndex = paramToIndex
+    this.path = urlPath || (uwsReq ? uwsReq.getUrl() : '')
+    this.method = method || (uwsReq ? uwsReq.getMethod().toUpperCase() : '')
+    this._url = null
+    this._headers = null
+    this._spliffyUrl = null
+    this._cookies = null
+  }
 
-export const setCookie = (res) => function () {
-  return res.setHeader('Set-Cookie', [...(res.getHeader('Set-Cookie') || []), cookie.serialize(...arguments)])
-}
+  forceCache () {
+    if (this._headers === null) this._cacheHeaders()
+    if (this._spliffyUrl === null) this._cacheSpliffyUrl()
+  }
 
-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]
+  _cacheHeaders () {
+    if (this._headers === null) {
+      this._headers = {}
+      this._uwsReq.forEach((header, value) => { this._headers[header] = value })
     }
   }
-  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 decorateResponse (res, req, finalizeResponse, errorTransformer, endError, { acceptsDefault }) {
-  res.onAborted(() => {
-    res.ended = true
-    res.writableEnded = true
-    res.finalized = true
-    log.error(`Request to ${req.url} was aborted`)
-  })
-  res.acceptsDefault = acceptsDefault
-  res.headers = {}
-  res.headersSent = false
-  res.setHeader = (header, value) => {
-    res.headers[normalizeHeader(header)] = value
-  }
-  res.removeHeader = header => {
-    delete res.headers[normalizeHeader(header)]
-  }
-  res.flushHeaders = () => {
-    if (res.headersSent) return
-    if (!res.statusCode) res.statusCode = httpStatusCodes.OK
-    if (!res.statusMessage) res.statusMessage = defaultStatusMessages[res.statusCode]
-    res.headersSent = true
-    res.writeStatus(`${res.statusCode} ${res.statusMessage}`)
-    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())
-        }
-      } else {
-        res.writeHeader(header, res.headers[header].toString())
+  _cacheSpliffyUrl () {
+    if (this._spliffyUrl === null) {
+      const q = this._uwsReq.getQuery()
+      const p2i = this._paramToIndex
+      const params = {}
+      for (const name in p2i) {
+        params[name] = this._uwsReq.getParameter(p2i[name])
+      }
+      this._spliffyUrl = {
+        path: this.path,
+        query: (q && parseQuery(q, this._config.decodeQueryParameters)) || {},
+        param: name => params[name]
       }
     }
   }
-  res.writeHead = (status, headers) => {
-    res.statusCode = status
-    res.assignHeaders(headers)
+
+  get url () {
+    if (this._url === null) {
+      const q = this._uwsReq.getQuery()
+      this._url = q ? `${this.path}?${q}` : this.path
+    }
+    return this._url
   }
-  res.assignHeaders = headers => {
-    for (const header of Object.keys(headers)) {
-      res.headers[normalizeHeader(header)] = headers[header]
+
+  get headers () {
+    if (this._headers === null) this._cacheHeaders()
+    return this._headers
+  }
+
+  get spliffyUrl () {
+    if (this._spliffyUrl === null) this._cacheSpliffyUrl()
+    return this._spliffyUrl
+  }
+
+  get query () { return this.spliffyUrl.query }
+  get cookies () {
+    if (this._cookies === null) {
+      this._cookies = (this.headers.cookie && cookie.parse(this.headers.cookie)) || {}
     }
+    return this._cookies
   }
-  res.getHeader = header => {
-    return res.headers[normalizeHeader(header)]
+
+  get remoteAddress () {
+    const val = Buffer.from(this.res.getRemoteAddressAsText()).toString()
+    Object.defineProperty(this, 'remoteAddress', { value: val, enumerable: true })
+    return val
   }
-  res.status = (code) => {
-    res.statusCode = code
-    return this
+
+  get proxiedRemoteAddress () {
+    const val = Buffer.from(this.res.getProxiedRemoteAddressAsText()).toString()
+    Object.defineProperty(this, 'proxiedRemoteAddress', { value: val, enumerable: true })
+    return val
   }
 
-  res.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)
+  get (header) { return this.headers[header.toLowerCase()] }
+}
+
+export function decorateRequest (uwsReq, paramToIndex, res, config) {
+  return new SpliffyRequest(uwsReq, paramToIndex, res, config)
+}
+
+const resProto = {
+  setHeader (h, v) { this.headers[h.toLowerCase()] = v },
+  removeHeader (h) { delete this.headers[h.toLowerCase()] },
+  assignHeaders (headers) {
+    for (const h in headers) { this.headers[h.toLowerCase()] = headers[h] }
+  },
+  getHeader (h) { return this.headers[h.toLowerCase()] },
+  status (c) { this.statusCode = c; return this },
+  writeHead (s, h) { this.statusCode = s; if (h) this.assignHeaders(h) },
+  redirect (c, l) {
+    if (typeof c === 'string') { l = c; c = 301 }
+    return this._finalizeResponse(this._sReq, this, { statusCode: c, headers: { location: l } })
+  },
+  send (b) { return this._finalizeResponse(this._sReq, this, b) },
+  json (b) { return this._finalizeResponse(this._sReq, this, b) },
+  setCookie (n, v, o) {
+    const s = cookie.serialize(n, v, o)
+    const e = this.headers['set-cookie']
+    if (e) {
+      if (Array.isArray(e)) e.push(s)
+      else this.headers['set-cookie'] = [e, s]
+    } else this.headers['set-cookie'] = s
+  },
+  cookie (n, v, o) { return this.setCookie(n, v, o) },
+  flushHeaders (noCork) {
+    if (this.headersSent) return
+    this.headersSent = true
+    const flush = () => {
+      if (this.statusCode && this.statusCode !== 200) {
+        this.writeStatus(this.statusCode + ' ' + (defaultStatusMessages[this.statusCode] || ''))
+      }
+      const headers = this.headers
+      for (const h in headers) {
+        const v = headers[h]
+        if (Array.isArray(v)) {
+          for (let i = 0, l = v.length; i < l; i++) this.writeHeader(h, String(v[i]))
         } else {
-          throw e
+          this.writeHeader(h, String(v))
         }
       }
+    }
+    if (noCork) flush()
+    else this.cork(flush)
+  },
+  ensureOnAborted () {
+    if (this._onAbortedRegistered) return
+    this._onAbortedRegistered = true
+    this.onAborted(() => { this.ended = true; this.writableEnded = true; this.finalized = true })
+  },
+  write (chunk, encoding, cb) {
+    this.ensureOnAborted()
+    this.streaming = true
+    return this.cork(() => {
+      if (!this.headersSent) this.flushHeaders(true)
+      const result = this._uwsWrite((chunk instanceof Buffer || chunk instanceof Uint8Array || typeof chunk === 'string') ? chunk : JSON.stringify(chunk))
+      if (cb) cb()
+      return result
     })
-  }
-  let outStream
-  res.getWritable = () => {
-    if (!outStream) {
-      res.streaming = true
-      outStream = new Writable({
-        write: res.write
-      })
-        .on('finish', res.end)
-        .on('end', res.end)
-        .on('error', e => {
-          try {
-            outStream.destroy()
-          } finally {
-            endError(res, e, uuid(), errorTransformer)
-          }
-        })
+  },
+  end (body) {
+    if (this.ended) return
+    this.ended = true
+    this.writableEnded = true
+    this.cork(() => {
+      if (!this.headersSent) this.flushHeaders(true)
+      this._uwsEnd(body || '')
+    })
+    if (this.onEnd) this.onEnd()
+  },
+  getWritable () {
+    this.ensureOnAborted()
+    if (!this.outStream) {
+      this.streaming = true
+      this.outStream = new Writable({ write: (c, e, callback) => { this.write(c, e, callback) } })
+        .on('finish', () => this.end())
+        .on('error', e => { try { this.outStream.destroy() } finally { this._endError(this, e, uuid(), this._errorTransformer) } })
     }
-    return outStream
+    return this.outStream
   }
+}
+
+export function decorateResponse (res, sReq, finalizeResponse, errorTransformer, endError, config) {
+  res._sReq = sReq
+  res._finalizeResponse = finalizeResponse
+  res._errorTransformer = errorTransformer
+  res._endError = endError
+  res._onAbortedRegistered = false
+  res.ensureOnAborted = resProto.ensureOnAborted
+  res.acceptsDefault = config.acceptsDefault
+  res.headers = {}
+  res.headersSent = false
+  res.setHeader = resProto.setHeader
+  res.removeHeader = resProto.removeHeader
+  res.assignHeaders = resProto.assignHeaders
+  res.getHeader = resProto.getHeader
+  res.status = resProto.status
+  res.writeHead = resProto.writeHead
+  res.flushHeaders = resProto.flushHeaders
+  res.redirect = resProto.redirect
+  res.send = resProto.send
+  res.json = resProto.json
+  res.setCookie = resProto.setCookie
+  res.cookie = resProto.cookie
+
+  res._uwsWrite = res.write
+  res.write = resProto.write
+
+  res.getWritable = resProto.getWritable
 
-  const uwsEnd = res.end
+  res._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()
-    }
-  }
+  res.end = resProto.end
 
-  res.redirect = function (code, location) {
-    if (arguments.length === 1) {
-      location = code
-      code = httpStatusCodes.MOVED_PERMANENTLY
-    }
-    return finalizeResponse(req, res, {
-      statusCode: code,
-      headers: {
-        location: location
-      }
-    })
-  }
-  res.send = (body) => {
-    finalizeResponse(req, res, body)
-  }
-  res.json = res.send
-  res.setCookie = setCookie(res)
-  res.cookie = res.setCookie
   return res
 }

package/src/handler.mjs

@@ -1,40 +1,29 @@
 import log from './log.mjs'
 import { deserializeBody, serializeBody } from './content.mjs'
-import { invokeMiddleware } from './middleware.mjs'
-import { decorateResponse, decorateRequest } from './decorator.mjs'
+import { invokeMiddleware, preProcessMiddleware } from './middleware.mjs'
+import { decorateResponse, SpliffyRequest } from './decorator.mjs'
 import { v4 as uuid } from 'uuid'
 import stream from 'stream'
 const { Readable } = stream
 
-/**
- * Execute the handler
- * @param url The url being requested
- * @param res The uws response object
- * @param req The uws request object
- * @param bodyPromise The request body promise
- * @param handler The handler function for the route
- * @param middleware The middleware that applies to this request
- * @param errorTransformer An errorTransformer to convert error objects into response data
- */
-const executeHandler = async (url, res, req, bodyPromise, handler, middleware, errorTransformer) => {
-  try {
-    bodyPromise = bodyPromise.then(bodyContent => {
-      if (bodyContent instanceof Readable) return bodyContent
-      if (res.writableEnded) return
-      return deserializeBody(bodyContent, req.headers['content-type'], res.acceptsDefault)
-    })
-  } catch (e) {
-    log.error('Failed to parse request.', e)
-    end(res, 400, handler.statusCodeOverride)
-    return
-  }
+const NULL_PROMISE = Promise.resolve(null)
 
+const executeHandler = async (url, res, req, bodyPromise, handler, middleware, errorTransformer) => {
   try {
-    const handled = await handler({ url, bodyPromise, headers: req.headers, req, res })
-    finalizeResponse(req, res, handled, handler.statusCodeOverride)
+    const bodyContent = await (bodyPromise || NULL_PROMISE)
+    if (!res.writableEnded) {
+      const deserializedBody = (bodyContent instanceof Readable || !bodyContent)
+        ? bodyContent
+        : deserializeBody(bodyContent, req.headers['content-type'], res.acceptsDefault)
+
+      const handled = await handler({ url, bodyPromise: Promise.resolve(deserializedBody), headers: req.headers, req, res })
+      finalizeResponse(req, res, handled, handler.statusCodeOverride)
+    }
   } catch (e) {
     const refId = uuid()
-    await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    if (middleware) {
+      try { await executeMiddleware(middleware, req, res, errorTransformer, refId, e) } catch (me) { log.error(me) }
+    }
     endError(res, e, refId, errorTransformer)
   }
 }
@@ -48,199 +37,202 @@ const endError = (res, e, refId, errorTransformer) => {
   }
   res.headers['x-ref-id'] = refId
   const status = e.statusCode || 500
-  if (status === 500) {
-    log.error(e)
-  }
+  if (status === 500) log.error(e)
   end(res, status, null, e.body || '')
 }
 
 const end = (res, defaultStatusCode, statusCodeOverride, body) => {
-  // status set directly on res wins
   res.statusCode = statusCodeOverride || res.statusCode || defaultStatusCode
+  if (currentDate) res.setHeader('Date', currentDate)
   if (body instanceof Readable || res.streaming) {
     res.streaming = true
-    if (body instanceof Readable) {
-      pipeResponse(res, body)
-    }
-    // handler is responsible for ending the response if they are streaming
+    if (body instanceof Readable) pipeResponse(res, body)
   } else {
-    res.end(doSerializeBody(body, res) || '')
-  }
-}
-
-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()
-  return () => {
-    log.access(compressIpv6(req.remoteAddress), compressIpv6(res.proxiedRemoteAddress) || '', res.statusCode, req.method, req.url, new Date().getTime() - start + 'ms')
+    if (typeof body === 'string' || !body || body instanceof Buffer) {
+      res.end(body || '')
+    } else {
+      res.end(doSerializeBody(body, res) || '')
+    }
   }
 }
 
 const finalizeResponse = (req, res, handled, statusCodeOverride) => {
-  if (!res.finalized) {
-    if (!handled) {
-      // if no error was thrown, assume everything is fine. Otherwise each handler must return truthy which is un-necessary for methods that don't need to return anything
-      end(res, 200, statusCodeOverride)
-    } else {
-      // if the returned object has known fields, treat it as a response object instead of the body
-      if (handled.body || handled.statusMessage || handled.statusCode || handled.headers) {
-        if (handled.headers) {
-          res.assignHeaders(handled.headers)
-        }
-        res.statusMessage = handled.statusMessage || res.statusMessage
-        end(res, handled.statusCode || 200, statusCodeOverride, handled.body)
-      } else {
-        end(res, 200, statusCodeOverride, handled)
-      }
-    }
-    res.finalized = true
+  if (res.finalized) return
+  res.finalized = true
+
+  if (typeof handled === 'string' || !handled || handled instanceof Buffer) {
+    end(res, 200, statusCodeOverride, handled)
+  } else if (handled.body || handled.statusMessage || handled.statusCode || handled.headers) {
+    if (handled.headers) res.assignHeaders(handled.headers)
+    if (handled.statusMessage) res.statusMessage = handled.statusMessage
+    end(res, handled.statusCode || 200, statusCodeOverride, handled.body)
+  } else {
+    end(res, 200, statusCodeOverride, handled)
   }
 }
 
 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()
-      } finally {
-        endError(res, e, uuid(), errorTransformer)
-      }
+      try { readStream.destroy() } finally { endError(res, e, uuid(), errorTransformer) }
     })
 }
 
 const doSerializeBody = (body, res) => {
-  if (!body || typeof body === 'string' || body instanceof Readable) {
-    return body
-  }
-  const contentType = res.getHeader('content-type')
+  const contentType = res.headers['content-type']
   const serialized = serializeBody(body, contentType, res.acceptsDefault)
-
   if (serialized?.contentType && !contentType) {
     res.headers['content-type'] = serialized.contentType
   }
   return serialized?.data || ''
 }
 
-async function executeMiddleware (middleware, req, res, errorTransformer, refId, e) {
-  if (!middleware) return
-
-  let applicableMiddleware = middleware[req.method]
-  if (middleware.ALL) {
-    if (applicableMiddleware) applicableMiddleware = middleware.ALL.concat(applicableMiddleware)
-    else applicableMiddleware = middleware.ALL
-  }
-
-  if (!applicableMiddleware || applicableMiddleware.length === 0) {
-    return
-  }
+async function executeMiddleware (processedMiddleware, req, res, errorTransformer, refId, e) {
+  if (!processedMiddleware) return
+  const methodMiddleware = processedMiddleware[req.method]
+  const allMiddleware = processedMiddleware.ALL
   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)
   }
 }
 
-const handleRequest = async (req, res, handler, middleware, errorTransformer) => {
+export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE', 'WEBSOCKET']
+
+let currentDate = ''
+let dateInterval = null
+
+const handleRequest = async (sReq, res, handler, processedMiddleware, config) => {
   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))
-          })
-      )
-    } 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)
-        }
-      })
-      reqBody = Promise.resolve(readable)
+    let reqBodyPromise = NULL_PROMISE
+    if (sReq.method !== 'GET' && sReq.method !== 'HEAD') {
+      if (handler.streamRequestBody) {
+        const readable = new Readable({ read () {} })
+        reqBodyPromise = Promise.resolve(readable)
+        res.onData((data, isLast) => {
+          if (data.byteLength > 0 || isLast) {
+            readable.push(Buffer.concat([Buffer.from(data)]))
+            if (isLast) readable.push(null)
+          }
+        })
+      } else {
+        reqBodyPromise = new Promise(resolve => res.onData((data, isLast) => {
+          const chunk = Buffer.concat([Buffer.from(data)])
+          res._buffer = res._buffer ? Buffer.concat([res._buffer, chunk]) : chunk
+          if (isLast) resolve(res._buffer)
+        }))
+      }
     }
-    await executeMiddleware(middleware, req, res, errorTransformer)
-    if (!res.writableEnded && !res.ended) {
-      await executeHandler(req.spliffyUrl, res, req, reqBody, handler, middleware, errorTransformer)
+
+    if (processedMiddleware) {
+      await executeMiddleware(processedMiddleware, sReq, res, config.errorTransformer)
+      if (!res.writableEnded && !res.ended) {
+        await executeHandler(sReq.spliffyUrl, res, sReq, reqBodyPromise, handler, processedMiddleware, config.errorTransformer)
+      }
+    } else {
+      await executeHandler(sReq.spliffyUrl, res, sReq, reqBodyPromise, handler, null, config.errorTransformer)
     }
   } catch (e) {
     const refId = uuid()
-    await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
-    if (!res.writableEnded) { endError(res, e, refId, errorTransformer) }
+    if (processedMiddleware) {
+      await executeMiddleware(processedMiddleware, sReq, res, config.errorTransformer, refId, e)
+    }
+    if (!res.writableEnded) { endError(res, e, refId, config.errorTransformer) }
   }
 }
 
-export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE', 'WEBSOCKET']
+export const createHandler = (handler, middleware, paramToIndex, config, urlPath) => {
+  const processedMiddleware = preProcessMiddleware(middleware)
+  if (config.writeDateHeader && !dateInterval) {
+    currentDate = new Date().toUTCString()
+    dateInterval = setInterval(() => { currentDate = new Date().toUTCString() }, 1000)
+  }
 
-let currentDate = new Date().toISOString()
-setInterval(() => { currentDate = new Date().toISOString() }, 1000)
+  const isWildcardPath = urlPath?.indexOf('*') > -1
 
-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)
+  // Pre-allocated request object for sync path
+  const syncSReq = new SpliffyRequest(null, paramToIndex, null, config)
+  const syncContext = {
+    get url () { return syncSReq.spliffyUrl },
+    bodyPromise: NULL_PROMISE,
+    get headers () { return syncSReq.headers },
+    req: syncSReq,
+    res: null
+  }
 
-      if (config.logAccess) {
-        res.onEnd = writeAccess(req, res)
+  return function (res, req) {
+    try {
+      const rawMethod = req.getMethod()
+      if (!processedMiddleware && !handler.streamRequestBody && (rawMethod === 'get' || rawMethod === 'head')) {
+        // HYPER FAST PATH
+        const method = rawMethod === 'get' ? 'GET' : 'HEAD'
+        syncSReq.init(req, paramToIndex, res, config, method, isWildcardPath ? null : urlPath)
+        syncContext.res = res
+        decorateResponse(res, syncSReq, finalizeResponse, config.errorTransformer, endError, config)
+        const handled = handler(syncContext)
+        if (handled instanceof Promise) {
+          syncSReq.forceCache()
+          res.ensureOnAborted()
+          handled.then(h => finalizeResponse(syncSReq, res, h, handler.statusCodeOverride))
+            .catch(e => endError(res, e, uuid(), config.errorTransformer))
+        } else if (typeof handled === 'string' || handled instanceof Buffer) {
+          end(res, 200, handler.statusCodeOverride, handled)
+        } else {
+          finalizeResponse(syncSReq, res, handled, handler.statusCodeOverride)
+        }
+      } else {
+        const sReq = new SpliffyRequest(req, paramToIndex, res, config)
+        sReq.forceCache()
+        decorateResponse(res, sReq, finalizeResponse, config.errorTransformer, endError, config)
+        res.ensureOnAborted()
+
+        handleRequest(sReq, res, handler, processedMiddleware, config)
+          .catch(e => {
+            log.error('Failed handling request', e)
+            if (!res.writableEnded) {
+              res.statusCode = 500
+              res.end()
+            }
+          })
       }
-
-      if (config.writeDateHeader) {
-        res.headers.date = currentDate
+    } catch (e) {
+      log.error('Failed handling request', e)
+      if (!res.writableEnded) {
+        res.statusCode = 500
+        res.end()
       }
-
-      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()
+    }
   }
 }
 
 export const createNotFoundHandler = config => {
   const handler = config.defaultRouteHandler || config.notFoundRouteHandler
-  const params = handler?.pathParameters || []
+  const paramToIndex = handler?.paramToIndex || {}
   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)
-      }
+      const sReq = new SpliffyRequest(req, paramToIndex, res, config)
+      sReq.forceCache()
+      decorateResponse(res, sReq, finalizeResponse, config.errorTransformer, endError, config)
+      res.ensureOnAborted()
       if (handler && typeof handler === 'object') {
-        if (handler.handlers && typeof handler.handlers[req.method] === 'function') {
+        const processedMiddleware = preProcessMiddleware(handler.middleware)
+        if (handler.handlers && typeof handler.handlers[sReq.method] === 'function') {
+          const h = handler.handlers[sReq.method]
           if ('statusCodeOverride' in handler) {
-            handler.handlers[req.method].statusCodeOverride = handler.statusCodeOverride
+            h.statusCodeOverride = handler.statusCodeOverride
           }
-          handleRequest(req, res,
-            handler.handlers[req.method],
-            handler.middleware,
-            config.errorTransformer
-          ).catch((e) => {
-            log.error('Unexpected exception during request handling', e)
-            res.statusCode = 500
-          })
+          handleRequest(sReq, res, h, processedMiddleware, config)
+            .catch(e => {
+              log.error('Unexpected exception during request handling', e)
+              if (!res.writableEnded) {
+                res.statusCode = 500
+                res.end()
+              }
+            })
         } else {
           res.statusCode = 404
           res.end()

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)
       }
     }
 

package/src/routes.mjs

@@ -113,6 +113,10 @@ const buildJSHandlerRoute = async (name, filePath, urlPath, inheritedMiddleware,
   }
   const route = {
     pathParameters,
+    paramToIndex: pathParameters.reduce((acc, cur, i) => {
+      acc[cur] = i
+      return acc
+    }, {}),
     urlPath: `${urlPath}/${getPathPart(name)}`,
     filePath,
     handlers: {}
@@ -163,6 +167,10 @@ const buildStaticRoutes = (name, filePath, urlPath, inheritedMiddleware, pathPar
   const contentType = getContentTypeByExtension(name, config.staticContentTypes)
   const route = {
     pathParameters,
+    paramToIndex: pathParameters.reduce((acc, cur, i) => {
+      acc[cur] = i
+      return acc
+    }, {}),
     urlPath: `${urlPath}/${getPathPart(name)}`,
     filePath,
     handlers: createStaticHandler(filePath, contentType, config.cacheStatic, config.staticCacheControl),

package/src/server.mjs

@@ -102,7 +102,7 @@ export async function startServer (config) {
         if (method === 'WEBSOCKET') {
           theHandler = route.handlers[method]
         } else {
-          theHandler = createHandler(route.handlers[method], route.middleware, route.pathParameters, config)
+          theHandler = createHandler(route.handlers[method], route.middleware, route.paramToIndex, config, route.urlPath)
         }
         app[appMethods[method]](route.urlPath, theHandler)
         if (hadSlash && config.serveRoutesWithSlash) {