@srfnstack/spliffy 0.5.5 → 0.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@srfnstack/spliffy",
-  "version": "0.5.5",
-  "author": "Robert Kempton <r@snow87.com>",
+  "version": "0.8.0",
+  "author": "snowbldr",
   "private": false,
   "homepage": "https://github.com/narcolepticsnowman/spliffy",
   "license": "MIT",
@@ -15,6 +15,11 @@
     "type": "git",
     "url": "git@github.com:narcolepticsnowman/spliffy.git"
   },
+  "scripts": {
+    "test": "npm run lint && 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"
+  },
   "keywords": [
     "node",
     "http",
@@ -24,12 +29,15 @@
     "rest"
   ],
   "dependencies": {
-    "cookie": "^0.4.0",
+    "cookie": "^0.4.1",
     "etag": "^1.8.1",
-    "uWebSockets.js": "uNetworking/uWebSockets.js#v19.3.0",
-    "uuid": "^3.3.3"
+    "uWebSockets.js": "uNetworking/uWebSockets.js#v20.4.0",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "helmet": "^4.6.0"
+    "standard": "^16.0.4",
+    "helmet": "^4.6.0",
+    "jest": "^27.3.1",
+    "node-fetch": "^2.6.6"
   }
 }

package/src/content-types.mjs

@@ -0,0 +1,75 @@
+export default {
+  '.aac': 'audio/aac',
+  '.abw': 'application/x-abiword',
+  '.arc': 'application/x-freearc',
+  '.avi': 'video/x-msvideo',
+  '.azw': 'application/vnd.amazon.ebook',
+  '.bin': 'application/octet-stream',
+  '.bmp': 'image/bmp',
+  '.bz': 'application/x-bzip',
+  '.bz2': 'application/x-bzip2',
+  '.csh': 'application/x-csh',
+  '.css': 'text/css',
+  '.csv': 'text/csv',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.epub': 'application/epub+zip',
+  '.gif': 'image/gif',
+  '.htm': 'text/html',
+  '.html': 'text/html',
+  '.ico': 'image/vnd.microsoft.icon',
+  '.ics': 'text/calendar',
+  '.jar': 'application/java-archive',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.js': 'text/javascript',
+  '.json': 'application/json',
+  '.jsonld': 'application/ld+json',
+  '.mid': 'audio/midi',
+  '.midi': 'audio/x-midi',
+  '.mjs': 'text/javascript',
+  '.mp3': 'audio/mpeg',
+  '.mpeg': 'video/mpeg',
+  '.mpkg': 'application/vnd.apple.installer+xml',
+  '.odp': 'application/vnd.oasis.opendocument.presentation',
+  '.ods': 'application/vnd.oasis.opendocument.spreadsheet',
+  '.odt': 'application/vnd.oasis.opendocument.text',
+  '.oga': 'audio/ogg',
+  '.ogv': 'video/ogg',
+  '.ogg': 'application/ogg',
+  '.ogx': 'application/ogg',
+  '.otf': 'font/otf',
+  '.png': 'image/png',
+  '.pdf': 'application/pdf',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.rar': 'application/x-rar-compressed',
+  '.rtf': 'application/rtf',
+  '.sh': 'application/x-sh',
+  '.svg': 'image/svg+xml',
+  '.swf': 'application/x-shockwave-flash',
+  '.tar': 'application/x-tar',
+  '.tif': 'image/tiff',
+  '.tiff': 'font/ttf',
+  '.ts': 'video/mp2t',
+  '.ttf': 'font/ttf ',
+  '.txt': 'text/plain',
+  '.vsd': 'application/vnd.visio',
+  '.wav': 'audio/wav',
+  '.weba': 'audio/webm',
+  '.webm': 'video/webm',
+  '.webp': 'image/webp',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.xhtml': 'application/xhtml+xml',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.xml': 'application/xml',
+  '.xul': 'application/vnd.mozilla.xul+xml',
+  '.zip': 'application/zip',
+  '.3gp': 'video/3gpp',
+  '.3g2': 'video/3gpp2',
+  '.7z': 'application/x-7z-compressed ',
+  default: 'application/octet-stream'
+}

package/src/content.mjs

@@ -0,0 +1,95 @@
+import contentTypes from './content-types.mjs'
+import { parseQuery } from './url.mjs'
+
+const defaultHandler = {
+  deserialize: o => {
+    try {
+      return JSON.parse(o && o.toString())
+    } catch (e) {
+      return o
+    }
+  },
+  serialize: o => {
+    if (typeof o === 'string') {
+      return {
+        contentType: 'text/plain',
+        data: o
+      }
+    }
+    if (o instanceof Buffer) {
+      return {
+        contentType: 'application/octet-stream',
+        data: o
+      }
+    }
+    return {
+      contentType: 'application/json',
+      data: JSON.stringify(o)
+    }
+  }
+}
+
+const toFormData = (key, value) => {
+  if (Array.isArray(value)) {
+    return value.map(toFormData).flat()
+  } else if (typeof value === 'object') {
+    return Object.keys(value).map(k => toFormData(`${key}.${k}`, value[k])).flat()
+  } else {
+    return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+  }
+}
+
+const contentHandlers = {
+  'application/json': {
+    deserialize: s => JSON.parse(s && s.toString()),
+    serialize: o => JSON.stringify(o)
+  },
+  'text/plain': {
+    deserialize: s => s && s.toString(),
+    serialize: o => o && o.toString()
+  },
+  'application/octet-stream': defaultHandler,
+  'application/x-www-form-urlencoded': {
+    deserialize: s => s && parseQuery(s.toString(), true),
+    serialize: o => Object.keys(o).map(toFormData).flat().join('&')
+  },
+  '*/*': defaultHandler
+}
+
+function getHandler (contentType, acceptsDefault) {
+  if (!contentType) return contentHandlers[acceptsDefault]
+  // content-type is singular https://greenbytes.de/tech/webdav/rfc2616.html#rfc.section.14.17
+  let handler = contentHandlers[contentType]
+  if (!handler && contentType.indexOf(';') > -1) {
+    handler = contentHandlers[contentType.split(';')[0].trim()]
+  }
+  if (handler && typeof handler) {
+    if (typeof handler.serialize !== 'function') {
+      throw new Error(`Content handlers must provide a serialize function. ${handler}`)
+    }
+    if (typeof handler.deserialize !== 'function') {
+      throw new Error(`Content handlers must provide a deserialize function. ${handler}`)
+    }
+    return handler
+  }
+  return contentHandlers[acceptsDefault]
+}
+
+export function getContentTypeByExtension (name, staticContentTypes) {
+  const extension = name.indexOf('.') > -1 ? name.slice(name.lastIndexOf('.')).toLowerCase() : 'default'
+  const contentType = staticContentTypes?.[extension] || null
+
+  return contentType || contentTypes[extension]
+}
+
+export function serializeBody (content, contentType, acceptsDefault) {
+  return getHandler(contentType && contentType.toLowerCase(), acceptsDefault).serialize(content)
+}
+
+export function deserializeBody (content, contentType, acceptsDefault) {
+  return getHandler(contentType && contentType.toLowerCase(), acceptsDefault).deserialize(content)
+}
+
+export function initContentHandlers (handlers) {
+  return Object.assign({}, contentHandlers, handlers)
+}

package/src/decorator.mjs

@@ -0,0 +1,205 @@
+import cookie from 'cookie'
+import http from 'http'
+import { parseQuery, setMultiValueKey } from './url.mjs'
+import log from './log.mjs'
+import { v4 as uuid } from 'uuid'
+import stream from 'stream'
+import httpStatusCodes, { 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()
+
+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)])
+}
+
+export function decorateRequest (uwsReq, pathParameters, res, { decodeQueryParameters, decodePathParameters, parseCookie } = {}) {
+  // uwsReq can't be used in async functions because it gets de-allocated when the handler function returns
+  const req = {}
+  // 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]
+  }
+  const query = uwsReq.getQuery()
+  req.path = uwsReq.getUrl()
+  req.url = `${req.path}${query ? '?' + query : ''}`
+  req.spliffyUrl = {
+    path: uwsReq.getUrl(),
+    query: parseQuery(uwsReq.getQuery(), decodeQueryParameters)
+  }
+  req.spliffyUrl.pathParameters = {}
+  if (pathParameters && pathParameters.length > 0) {
+    for (const i in pathParameters) {
+      req.spliffyUrl.pathParameters[pathParameters[i]] = decodePathParameters
+        ? decodeURIComponent(uwsReq.getParameter(i))
+        : uwsReq.getParameter(i)
+    }
+  }
+  req.params = req.spliffyUrl.pathParameters
+  req.headers = {}
+  req.method = uwsReq.getMethod().toUpperCase()
+  req.remoteAddress = addressArrayBufferToString(res.getRemoteAddressAsText())
+  req.proxiedRemoteAddress = addressArrayBufferToString(res.getProxiedRemoteAddressAsText())
+  uwsReq.forEach((header, value) => setMultiValueKey(req.headers, normalizeHeader(header), value))
+  req.get = header => req.headers[normalizeHeader(header)]
+  if (parseCookie && req.headers.cookie) {
+    req.cookies = cookie.parse(req.headers.cookie) || {}
+  }
+  return req
+}
+
+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())
+      }
+    }
+  }
+  res.writeHead = (status, headers) => {
+    res.statusCode = status
+    res.assignHeaders(headers)
+  }
+  res.assignHeaders = headers => {
+    for (const header of Object.keys(headers)) {
+      res.headers[normalizeHeader(header)] = headers[header]
+    }
+  }
+  res.getHeader = header => {
+    return res.headers[normalizeHeader(header)]
+  }
+  res.status = (code) => {
+    res.statusCode = code
+    return this
+  }
+
+  function toArrayBuffer (buffer) {
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+  }
+
+  let outStream
+  res.getWritable = () => {
+    if (!outStream) {
+      res.streaming = true
+      outStream = new Writable({
+        write: (chunk, encoding, cb) => {
+          try {
+            res.flushHeaders()
+            const result = res.write(chunk)
+            if (typeof cb === 'function') {
+              cb()
+            }
+            return result
+          } catch (e) {
+            if (typeof cb === 'function') {
+              cb(e)
+            } else {
+              throw e
+            }
+          }
+        }
+      })
+        .on('finish', res.end)
+        .on('end', res.end)
+        .on('error', e => {
+          try {
+            outStream.destroy()
+          } finally {
+            endError(res, e, uuid(), errorTransformer)
+          }
+        })
+    }
+    return outStream
+  }
+  res.writeArrayBuffer = res.write
+  res.write = chunk => {
+    res.streaming = true
+    res.flushHeaders()
+    if (chunk instanceof Buffer) {
+      return res.writeArrayBuffer(toArrayBuffer(chunk))
+    } else if (typeof chunk === 'string') {
+      return res.writeArrayBuffer(toArrayBuffer(Buffer.from(chunk, 'utf8')))
+    } else {
+      return res.writeArrayBuffer(toArrayBuffer(Buffer.from(JSON.stringify(chunk), 'utf8')))
+    }
+  }
+
+  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.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) {
+      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

@@ -0,0 +1,240 @@
+import log from './log.mjs'
+import { deserializeBody, serializeBody } from './content.mjs'
+import { invokeMiddleware } from './middleware.mjs'
+import { decorateResponse, decorateRequest } 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 body The request body
+ * @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, body, handler, middleware, errorTransformer) => {
+  try {
+    if (body) body = deserializeBody(body, req.headers['content-type'], res.acceptsDefault)
+  } catch (e) {
+    log.error('Failed to parse request.', e)
+    end(res, 400, handler.statusCodeOverride)
+    return
+  }
+
+  try {
+    const handled = await handler({ url, body, headers: req.headers, req, res })
+    finalizeResponse(req, res, handled, handler.statusCodeOverride)
+  } catch (e) {
+    const refId = uuid()
+    log.error('handler failed', e, refId)
+    await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    endError(res, e, refId, errorTransformer)
+  }
+}
+
+const endError = (res, e, refId, errorTransformer) => {
+  if (e.body && typeof e.body !== 'string') {
+    e.body = JSON.stringify(e.body)
+  }
+  if (typeof errorTransformer === 'function') {
+    e = errorTransformer(e, refId)
+  }
+  res.headers['x-ref-id'] = refId
+  end(res, e.statusCode || 500, null, e.body || '')
+}
+
+const end = (res, defaultStatusCode, statusCodeOverride, body) => {
+  // status set directly on res wins
+  res.statusCode = statusCodeOverride || res.statusCode || defaultStatusCode
+  if (body instanceof Readable || res.streaming) {
+    res.streaming = true
+    if (body instanceof Readable) {
+      res.flushHeaders()
+      pipeResponse(res, body)
+    }
+    // handler is responsible for ending the response if they are streaming
+  } else {
+    res.end(doSerializeBody(body, res) || '')
+  }
+}
+
+const writeAccess = function (req, res) {
+  const start = new Date().getTime()
+  return () => {
+    log.access(req.remoteAddress, res.proxiedRemoteAddress || '', res.statusCode, req.method, req.url, new Date().getTime() - start + 'ms')
+  }
+}
+
+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
+  }
+}
+
+const pipeResponse = (res, readStream, errorTransformer) => {
+  readStream.on('data', res.write)
+    .on('end', res.end)
+    .on('error', e => {
+      try {
+        readStream.destroy()
+      } finally {
+        endError(res, e, uuid(), errorTransformer)
+      }
+    })
+}
+
+const doSerializeBody = (body, res) => {
+  const contentType = res.getHeader('content-type')
+  if (typeof body === 'string') {
+    if (!contentType) {
+      res.headers['content-type'] = 'text/plain'
+    }
+    return body
+  } else if (body instanceof Readable) {
+    return body
+  }
+  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
+  }
+  if (e) {
+    await invokeMiddleware(applicableMiddleware.filter(mw => mw.length === 4), req, res, e)
+  } else {
+    await invokeMiddleware(applicableMiddleware.filter(mw => mw.length === 3), req, res)
+  }
+}
+
+let currentDate = new Date().toUTCString()
+setInterval(() => { currentDate = new Date().toUTCString() }, 1000)
+
+const handleRequest = async (req, res, handler, middleware, errorTransformer) => {
+  res.headers.date = currentDate
+
+  try {
+    let reqBody
+    if (!handler.streamRequestBody) {
+      let buffer
+      reqBody = await 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 {
+      reqBody = new Readable({
+        read: () => {
+        }
+      })
+      res.onData(async (data, isLast) => {
+        if (data.byteLength === 0 && !isLast) return
+        // data must be copied so it isn't lost
+        reqBody.push(Buffer.concat([Buffer.from(data)]))
+        if (isLast) {
+          reqBody.push(null)
+        }
+      })
+    }
+    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()
+    log.error('Handling request failed', e, refId)
+    await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
+    if (!res.writableEnded) { endError(res, e, refId, errorTransformer) }
+  }
+}
+
+export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE']
+
+export const createHandler = (handler, middleware, pathParameters, config) => function (res, req) {
+  try {
+    req = decorateRequest(req, pathParameters, res, config)
+    res = decorateResponse(res, req, finalizeResponse, config.errorTransformer, endError, config)
+
+    if (config.logAccess) {
+      res.onEnd = writeAccess(req, res)
+    }
+    handleRequest(req, res, handler, middleware, config.errorTransformer)
+      .catch(e => log.error('Failed handling request', e))
+  } catch (e) {
+    log.error('Failed handling request', e)
+  }
+}
+
+export const createNotFoundHandler = config => {
+  const handler = config.defaultRouteHandler || config.notFoundRouteHandler
+  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
+          }
+          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 = 405
+          res.end()
+        }
+      } else {
+        res.statusCode = 404
+        res.end()
+      }
+    } catch (e) {
+      log.error('Failed handling request', e)
+    }
+  }
+}