@srfnstack/spliffy 1.3.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@srfnstack/spliffy",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "author": "snowbldr",
   "private": false,
   "homepage": "https://github.com/SRFNStack/spliffy",

package/src/decorator.mjs

@@ -1,207 +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 => Buffer.from(addrBuf).toString()
-
-const excludedMessageProps = {
-  setTimeout: true,
-  _read: true,
-  destroy: true,
-  _addHeaderLines: true,
-  _addHeaderLine: true,
-  _dump: true,
-  __proto__: true
-}
-
-const reqProtoProps = () => Object.keys(http.IncomingMessage.prototype).filter(p => !excludedMessageProps[p])
+export class SpliffyRequest {
+  constructor (uwsReq, paramToIndex, res, config) {
+    this.init(uwsReq, paramToIndex, res, config)
+  }
 
-class SpliffyRequest {
-  constructor (uwsReq, pathParameters, res, config) {
-    const query = uwsReq.getQuery()
+  init (uwsReq, paramToIndex, res, config, method, urlPath) {
     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
-    })
+    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
+  }
+
+  forceCache () {
+    if (this._headers === null) this._cacheHeaders()
+    if (this._spliffyUrl === null) this._cacheSpliffyUrl()
+  }
+
+  _cacheHeaders () {
+    if (this._headers === null) {
+      this._headers = {}
+      this._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]
+  _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]
       }
     }
+  }
 
-    const paramToIndex = pathParameters.reduce((acc, cur, i) => {
-      acc[cur] = i
-      return acc
-    }, {})
-
-    this.spliffyUrl = {
-      path: this.path,
-      query: (query && parseQuery(query, config.decodeQueryParameters)) || {},
-      param: name => uwsReq.getParameter(paramToIndex[name])
+  get url () {
+    if (this._url === null) {
+      const q = this._uwsReq.getQuery()
+      this._url = q ? `${this.path}?${q}` : this.path
     }
-    this.query = this.spliffyUrl.query
-    if (config.parseCookie) {
-      this.cookies = (this.headers.cookie && cookie.parse(this.headers.cookie)) || {}
+    return this._url
+  }
+
+  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
   }
 
   get remoteAddress () {
-    const val = addressArrayBufferToString(this.res.getRemoteAddressAsText())
+    const val = Buffer.from(this.res.getRemoteAddressAsText()).toString()
     Object.defineProperty(this, 'remoteAddress', { value: val, enumerable: true })
     return val
   }
 
   get proxiedRemoteAddress () {
-    const val = addressArrayBufferToString(this.res.getProxiedRemoteAddressAsText())
+    const val = Buffer.from(this.res.getProxiedRemoteAddressAsText()).toString()
     Object.defineProperty(this, 'proxiedRemoteAddress', { value: val, enumerable: true })
     return val
   }
 
-  get (header) {
-    return this.headers[header.toLowerCase()]
-  }
+  get (header) { return this.headers[header.toLowerCase()] }
 }
 
-export function decorateRequest (uwsReq, pathParameters, res, config) {
-  return new SpliffyRequest(uwsReq, pathParameters, res, config)
+export function decorateRequest (uwsReq, paramToIndex, res, config) {
+  return new SpliffyRequest(uwsReq, paramToIndex, res, config)
 }
 
-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 = config.acceptsDefault
-  res.headers = {}
-  res.headersSent = false
-  res.setHeader = (header, value) => {
-    res.headers[header.toLowerCase()] = value
-  }
-  res.removeHeader = header => {
-    delete res.headers[header.toLowerCase()]
-  }
-  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 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())
+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 {
+          this.writeHeader(h, String(v))
         }
-      } else {
-        res.writeHeader(header, val.toString())
       }
     }
-  }
-  res.writeHead = (status, headers) => {
-    res.statusCode = status
-    if (headers) res.assignHeaders(headers)
-  }
-  res.assignHeaders = headers => {
-    for (const header in headers) {
-      res.headers[header.toLowerCase()] = headers[header]
-    }
-  }
-  res.getHeader = header => {
-    return res.headers[header.toLowerCase()]
-  }
-  res.status = (code) => {
-    res.statusCode = code
-    return res
-  }
-
-  const uwsWrite = res.write
-  res.write = (chunk, encoding, cb) => {
-    res.cork(() => {
-      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()
+    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
     })
-  }
-
-  res.getWritable = () => {
-    if (!res.outStream) {
-      res.streaming = true
-      res.outStream = new Writable({
-        write: (chunk, encoding, callback) => {
-          res.write(chunk, encoding, callback)
-        }
-      })
-        .on('finish', () => res.end())
-        .on('error', e => {
-          try {
-            res.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 res.outStream
+    return this.outStream
   }
+}
 
-  const uwsEnd = res.end
+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
+
+  res._uwsEnd = res.end
   res.ended = false
-  res.end = body => {
-    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.end = resProto.end
 
-  res.redirect = (code, location) => {
-    if (typeof code === 'string') {
-      location = code
-      code = httpStatusCodes.MOVED_PERMANENTLY
-    }
-    return finalizeResponse(req, res, {
-      statusCode: code,
-      headers: { location }
-    })
-  }
-  res.send = (body) => finalizeResponse(req, res, body)
-  res.json = res.send
-  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,41 +1,28 @@
 import log from './log.mjs'
 import { deserializeBody, serializeBody } from './content.mjs'
 import { invokeMiddleware, preProcessMiddleware } from './middleware.mjs'
-import { decorateResponse, decorateRequest } from './decorator.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()
     if (middleware) {
-      await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+      try { await executeMiddleware(middleware, req, res, errorTransformer, refId, e) } catch (me) { log.error(me) }
     }
     endError(res, e, refId, errorTransformer)
   }
@@ -50,55 +37,37 @@ 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 = Date.now()
-  return () => {
-    log.access(compressIpv6(req.remoteAddress), compressIpv6(res.proxiedRemoteAddress) || '', res.statusCode, req.method, req.url, Date.now() - 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)
   }
 }
 
@@ -106,21 +75,13 @@ const pipeResponse = (res, readStream, errorTransformer) => {
   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
   }
@@ -129,10 +90,8 @@ const doSerializeBody = (body, res) => {
 
 async function executeMiddleware (processedMiddleware, req, res, errorTransformer, refId, e) {
   if (!processedMiddleware) return
-
   const methodMiddleware = processedMiddleware[req.method]
   const allMiddleware = processedMiddleware.ALL
-
   if (e) {
     if (allMiddleware?.error) await invokeMiddleware(allMiddleware.error, req, res, e)
     if (methodMiddleware?.error) await invokeMiddleware(methodMiddleware.error, req, res, e)
@@ -142,80 +101,96 @@ async function executeMiddleware (processedMiddleware, req, res, errorTransforme
   }
 }
 
-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) {
-      if (req.method === 'GET' || req.method === 'HEAD') {
-        reqBody = Promise.resolve(null)
+    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 {
-        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)
-              }
-            })
-        )
+        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)
+        }))
       }
-    } else {
-      const readable = new Readable({
-        read: () => {
-        }
-      })
-      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)
-    }
-    if (middleware) {
-      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()
-    if (middleware) {
-      await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    if (processedMiddleware) {
+      await executeMiddleware(processedMiddleware, sReq, res, config.errorTransformer, refId, e)
     }
-    if (!res.writableEnded) { endError(res, e, refId, errorTransformer) }
+    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
+
+  // 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
+  }
 
-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) {
-          // 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
+      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(req, res, handler, processedMiddleware, config.errorTransformer)
+        handleRequest(sReq, res, handler, processedMiddleware, config)
           .catch(e => {
             log.error('Failed handling request', e)
             if (!res.writableEnded) {
@@ -223,7 +198,7 @@ export const createHandler = (handler, middleware, pathParameters, config) => {
               res.end()
             }
           })
-      })
+      }
     } catch (e) {
       log.error('Failed handling request', e)
       if (!res.writableEnded) {
@@ -236,44 +211,36 @@ export const createHandler = (handler, middleware, pathParameters, config) => {
 
 export const createNotFoundHandler = config => {
   const handler = config.defaultRouteHandler || config.notFoundRouteHandler
-  const params = handler?.pathParameters || []
+  const paramToIndex = handler?.paramToIndex || {}
   return (res, req) => {
     try {
-      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) => {
+      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') {
+        const processedMiddleware = preProcessMiddleware(handler.middleware)
+        if (handler.handlers && typeof handler.handlers[sReq.method] === 'function') {
+          const h = handler.handlers[sReq.method]
+          if ('statusCodeOverride' in handler) {
+            h.statusCodeOverride = handler.statusCodeOverride
+          }
+          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()
-          }
         } else {
           res.statusCode = 404
           res.end()
         }
-      })
+      } else {
+        res.statusCode = 404
+        res.end()
+      }
     } catch (e) {
       log.error('Failed handling request', e)
     }

package/src/index.mjs

@@ -29,3 +29,5 @@ export { default } from './start.mjs'
  * @return {string} The full path to the directory the module is in
  */
 export const moduleDirname = metaUrl => path.dirname(fileURLToPath(metaUrl))
+
+export * from './errors.mjs'

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