@srfnstack/spliffy 0.8.1 → 0.9.1

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@srfnstack/spliffy",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "author": "snowbldr",
   "private": false,
   "homepage": "https://github.com/narcolepticsnowman/spliffy",
   "license": "MIT",
+  "type": "module",
   "files": [
     "src/*",
     "LICENSE.txt",
     "README.md"
   ],
-  "main": "src/index.js",
+  "main": "src/index.mjs",
   "repository": {
     "type": "git",
     "url": "git@github.com:narcolepticsnowman/spliffy.git"

package/src/content.mjs

@@ -3,6 +3,7 @@ import { parseQuery } from './url.mjs'
 
 const defaultHandler = {
   deserialize: o => {
+    if (!o) return o
     try {
       return JSON.parse(o && o.toString())
     } catch (e) {
@@ -10,6 +11,7 @@ const defaultHandler = {
     }
   },
   serialize: o => {
+    if (!o) return { data: o }
     if (typeof o === 'string') {
       return {
         contentType: 'text/plain',
@@ -41,8 +43,8 @@ const toFormData = (key, value) => {
 
 const contentHandlers = {
   'application/json': {
-    deserialize: s => JSON.parse(s && s.toString()),
-    serialize: o => JSON.stringify(o)
+    deserialize: s => s && JSON.parse(s && s.toString()),
+    serialize: o => o && JSON.stringify(o)
   },
   'text/plain': {
     deserialize: s => s && s.toString(),
@@ -51,7 +53,7 @@ const contentHandlers = {
   '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('&')
+    serialize: o => o && Object.keys(o).map(toFormData).flat().join('&')
   },
   '*/*': defaultHandler
 }

package/src/decorator.mjs

@@ -1,10 +1,11 @@
 import cookie from 'cookie'
 import http from 'http'
-import { parseQuery, setMultiValueKey } from './url.mjs'
+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'
+
 const { Writable } = stream
 
 const addressArrayBufferToString = addrBuf => String.fromCharCode.apply(null, new Int8Array(addrBuf))
@@ -26,42 +27,54 @@ 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 } = {}) {
+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 = {}
-  // 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]
+  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]
+    }
   }
   const query = uwsReq.getQuery()
   req.path = uwsReq.getUrl()
   req.url = `${req.path}${query ? '?' + query : ''}`
   req.spliffyUrl = {
-    path: uwsReq.getUrl(),
-    query: parseQuery(uwsReq.getQuery(), decodeQueryParameters)
+    path: req.path,
+    query: query && parseQuery(query, decodeQueryParameters),
+    pathParameters: {}
   }
-  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.spliffyUrl.pathParameters[pathParameters[i]] =
+        decodePathParameters
+          ? decodeURIComponent(uwsReq.getParameter(i))
+          : uwsReq.getParameter(i)
     }
   }
   req.params = req.spliffyUrl.pathParameters
   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())
-  uwsReq.forEach((header, value) => setMultiValueKey(req.headers, normalizeHeader(header), value))
-  req.get = header => req.headers[normalizeHeader(header)]
+  req.get = header => req.headers[header]
   if (parseCookie && req.headers.cookie) {
     req.cookies = 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
@@ -114,31 +127,37 @@ export function decorateResponse (res, req, finalizeResponse, errorTransformer,
     return this
   }
 
-  function toArrayBuffer (buffer) {
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+  res.writeArrayBuffer = res.write
+  res.write = (chunk, encoding, cb) => {
+    try {
+      res.streaming = true
+      res.flushHeaders()
+      let result
+      if (chunk instanceof Buffer) {
+        result = res.writeArrayBuffer(toArrayBuffer(chunk))
+      } else if (typeof chunk === 'string') {
+        result = res.writeArrayBuffer(toArrayBuffer(Buffer.from(chunk, encoding || 'utf8')))
+      } else {
+        result = res.writeArrayBuffer(toArrayBuffer(Buffer.from(JSON.stringify(chunk), encoding || 'utf8')))
+      }
+      if (typeof cb === 'function') {
+        cb()
+      }
+      return result
+    } catch (e) {
+      if (typeof cb === 'function') {
+        cb(e)
+      } else {
+        throw e
+      }
+    }
   }
-
   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
-            }
-          }
-        }
+        write: res.write
       })
         .on('finish', res.end)
         .on('end', res.end)
@@ -152,18 +171,6 @@ export function decorateResponse (res, req, finalizeResponse, 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

package/src/handler.mjs

@@ -11,14 +11,18 @@ const { Readable } = stream
  * @param url The url being requested
  * @param res The uws response object
  * @param req The uws request object
- * @param body The request body
+ * @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, body, handler, middleware, errorTransformer) => {
+const executeHandler = async (url, res, req, bodyPromise, handler, middleware, errorTransformer) => {
   try {
-    if (body) body = deserializeBody(body, req.headers['content-type'], res.acceptsDefault)
+    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)
@@ -26,7 +30,7 @@ const executeHandler = async (url, res, req, body, handler, middleware, errorTra
   }
 
   try {
-    const handled = await handler({ url, body, headers: req.headers, req, res })
+    const handled = await handler({ url, bodyPromise, headers: req.headers, req, res })
     finalizeResponse(req, res, handled, handler.statusCodeOverride)
   } catch (e) {
     const refId = uuid()
@@ -103,15 +107,10 @@ const pipeResponse = (res, readStream, 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) {
+  if (!body || typeof body === 'string' || body instanceof Readable) {
     return body
   }
+  const contentType = res.getHeader('content-type')
   const serialized = serializeBody(body, contentType, res.acceptsDefault)
 
   if (serialized?.contentType && !contentType) {
@@ -139,17 +138,12 @@ async function executeMiddleware (middleware, req, res, errorTransformer, refId,
   }
 }
 
-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(
+      reqBody = new Promise(
         resolve =>
           res.onData(async (data, isLast) => {
             if (isLast) {
@@ -160,18 +154,19 @@ const handleRequest = async (req, res, handler, middleware, errorTransformer) =>
           })
       )
     } else {
-      reqBody = new Readable({
+      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
-        reqBody.push(Buffer.concat([Buffer.from(data)]))
+        readable.push(Buffer.concat([Buffer.from(data)]))
         if (isLast) {
-          reqBody.push(null)
+          readable.push(null)
         }
       })
+      reqBody = Promise.resolve(readable)
     }
     await executeMiddleware(middleware, req, res, errorTransformer)
     if (!res.writableEnded && !res.ended) {
@@ -187,6 +182,9 @@ const handleRequest = async (req, res, handler, middleware, errorTransformer) =>
 
 export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE']
 
+let currentDate = new Date().toISOString()
+setInterval(() => { currentDate = new Date().toISOString() }, 1000)
+
 export const createHandler = (handler, middleware, pathParameters, config) => function (res, req) {
   try {
     req = decorateRequest(req, pathParameters, res, config)
@@ -195,10 +193,21 @@ export const createHandler = (handler, middleware, pathParameters, config) => fu
     if (config.logAccess) {
       res.onEnd = writeAccess(req, res)
     }
+
+    if (config.writeDateHeader) {
+      res.headers.date = currentDate
+    }
+
     handleRequest(req, res, handler, middleware, config.errorTransformer)
-      .catch(e => log.error('Failed handling request', e))
+      .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()
   }
 }
 

package/src/middleware.mjs

@@ -37,9 +37,7 @@ export const cloneMiddleware = (middleware) => {
  * @param middleware
  */
 export const validateMiddleware = (middleware) => {
-  if (Array.isArray(middleware)) {
-    validateMiddlewareArray(middleware)
-  } else if (typeof middleware === 'object') {
+  if (!Array.isArray(middleware) && typeof middleware === 'object') {
     for (const method in middleware) {
       // ensure methods are always available as uppercase
       const upMethod = method.toUpperCase()
@@ -47,7 +45,7 @@ export const validateMiddleware = (middleware) => {
       validateMiddlewareArray(middleware[upMethod])
     }
   } else {
-    throw new Error('Invalid middleware definition: ' + middleware)
+    validateMiddlewareArray(middleware)
   }
 }
 

package/src/routes.mjs

@@ -27,12 +27,16 @@ const getPathPart = name => {
 const filterTestFiles = config => f => (!f.name.endsWith('.test.js') && !f.name.endsWith('.test.mjs')) || config.allowTestFileRoutes
 const filterIgnoredFiles = config => f => !config.ignoreFilesMatching.filter(p => p).find(pattern => f.name.match(pattern))
 const ignoreHandlerFields = { middleware: true, streamRequestBody: true }
+
+const isRouteFile = name => name.endsWith('.rt.js') || name.endsWith('.rt.mjs') || name.endsWith('.rt.cjs')
+const isMiddlewareFile = name => name.endsWith('.mw.js') || name.endsWith('.mw.mjs') || name.endsWith('.mw.cjs')
+
 const doFindRoutes = async (config, currentFile, filePath, urlPath, pathParameters, inheritedMiddleware) => {
   const routes = []
   const name = currentFile.name
   if (currentFile.isDirectory()) {
     routes.push(...(await findRoutesInDir(name, filePath, urlPath, inheritedMiddleware, pathParameters, config)))
-  } else if (!config.staticMode && (name.endsWith('.rt.js') || name.endsWith('.rt.mjs'))) {
+  } else if (!config.staticMode && isRouteFile(name)) {
     routes.push(await buildJSHandlerRoute(name, filePath, urlPath, inheritedMiddleware, pathParameters))
   } else {
     routes.push(...buildStaticRoutes(name, filePath, urlPath, inheritedMiddleware, pathParameters, config))
@@ -47,6 +51,14 @@ const importModules = async (config, dirPath, files) => Promise.all(
     .map(f => path.join(dirPath, f.name))
     .map(mwPath => import(`file://${mwPath}`)
       .then(module => ({ module, mwPath }))
+      .catch(e => {
+        // Hack to workaround https://github.com/nodejs/modules/issues/471
+        if (e instanceof SyntaxError) {
+          const newError = new SyntaxError(`${e.message}. In file: ${mwPath}`)
+          newError.stack = e.stack
+          throw newError
+        }
+      })
     ))
 
 const findRoutesInDir = async (name, filePath, urlPath, inheritedMiddleware, pathParameters, config) => {
@@ -55,9 +67,7 @@ const findRoutesInDir = async (name, filePath, urlPath, inheritedMiddleware, pat
   }
   const files = await readdir(filePath, { withFileTypes: true })
 
-  const middlewareModules = await importModules(config, filePath,
-    files.filter(f => f.name.endsWith('.mw.js') || f.name.endsWith('.mw.mjs'))
-  )
+  const middlewareModules = await importModules(config, filePath, files.filter(f => isMiddlewareFile(f.name)))
   const dirMiddleware = middlewareModules.map(({ module, mwPath }) => {
     const middleware = module.middleware || module.default?.middleware
     if (!middleware) {
@@ -73,7 +83,7 @@ const findRoutesInDir = async (name, filePath, urlPath, inheritedMiddleware, pat
     .reduce((result, incoming) => mergeMiddleware(incoming, result), inheritedMiddleware)
 
   return Promise.all(files
-    .filter(f => !f.name.endsWith('.mw.js') && !f.name.endsWith('.mw.mjs'))
+    .filter(f => !isMiddlewareFile(f.name))
     .filter(filterTestFiles(config))
     .filter(filterIgnoredFiles(config))
     .map(
@@ -90,7 +100,7 @@ const findRoutesInDir = async (name, filePath, urlPath, inheritedMiddleware, pat
 }
 
 const buildJSHandlerRoute = async (name, filePath, urlPath, inheritedMiddleware, pathParameters) => {
-  if (name.endsWith('.mjs')) {
+  if (name.endsWith('.mjs') || name.endsWith('.cjs')) {
     name = name.substr(0, name.length - '.rt.mjs'.length)
   } else {
     name = name.substr(0, name.length - '.rt.js'.length)
@@ -104,10 +114,25 @@ const buildJSHandlerRoute = async (name, filePath, urlPath, inheritedMiddleware,
     filePath,
     handlers: {}
   }
-  const module = await import(`file://${filePath}`)
+  let module
+  try {
+    module = await import(`file://${filePath}`)
+  } catch (e) {
+    // Hack to workaround https://github.com/nodejs/modules/issues/471
+    if (e instanceof SyntaxError) {
+      const newError = new SyntaxError(`${e.message}. In file: ${filePath}`)
+      newError.stack = e.stack
+      throw newError
+    }
+  }
   const handlers = module.default
-
-  route.middleware = mergeMiddleware(handlers.middleware || [], inheritedMiddleware)
+  try {
+    route.middleware = mergeMiddleware(handlers.middleware || [], inheritedMiddleware)
+  } catch (e) {
+    const err = new Error(`Failed to load middleware for route: ${filePath}`)
+    err.stack += `\nCaused By: ${e.stack}`
+    throw err
+  }
   for (const method of Object.keys(handlers).filter(k => !ignoreHandlerFields[k])) {
     if (HTTP_METHODS.indexOf(method) === -1) {
       throw new Error(`Method: ${method} in file ${filePath} is not a valid http method. It must be one of: ${HTTP_METHODS}. Method names must be all uppercase.`)

package/src/server.mjs

@@ -21,14 +21,14 @@ const appMethods = {
   CONNECT: 'connect',
   TRACE: 'trace'
 }
-const optionsHandler = (config, methods) => {
+const optionsHandler = (config, middleware, methods) => {
   return createHandler(() => ({
     headers: {
       allow: methods
     },
     statusCode: 204
   }),
-  [],
+  middleware,
   [],
   config
   )
@@ -102,7 +102,7 @@ export async function startServer (config) {
         }
       }
       if (!route.handlers.OPTIONS) {
-        app.options(route.urlPath, optionsHandler(config, Object.keys(route.handlers).join(', ')))
+        app.options(route.urlPath, optionsHandler(config, route.middleware, Object.keys(route.handlers).join(', ')))
       }
     }
 

package/src/serverConfig.mjs

@@ -27,11 +27,23 @@ export async function initConfig (userConfig) {
   const config = Object.assign({}, userConfig)
 
   if (!('decodePathParameters' in config)) {
-    config.decodePathParameters = true
+    config.decodePathParameters = false
+  }
+
+  if (!('decodeQueryParams' in config)) {
+    config.decodeQueryParams = false
+  }
+
+  if (!('extendIncomingMessage' in config)) {
+    config.extendIncomingMessage = false
   }
 
   if (!('parseCookie' in config)) {
-    config.parseCookie = true
+    config.parseCookie = false
+  }
+
+  if (!('writeDateHeader' in config)) {
+    config.writeDateHeader = false
   }
 
   config.acceptsDefault = config.acceptsDefault || defaultHeaders.acceptsDefault
@@ -55,7 +67,7 @@ export async function initConfig (userConfig) {
   }
 
   if (!('logAccess' in config)) {
-    config.logAccess = true
+    config.logAccess = false
   }
   if ('logLevel' in config) {
     log.setLogLevel(config.logLevel)