@srfnstack/spliffy 0.7.0 → 0.9.0

package/src/serverConfig.mjs

@@ -0,0 +1,96 @@
+import { initContentHandlers } from './content.mjs'
+import { validateMiddleware } from './middleware.mjs'
+import log from './log.mjs'
+
+const defaultHeaders = {
+  acceptsDefault: '*/*',
+  defaultContentType: '*/*'
+}
+// this is mainly for performance reasons
+const nonsense = [
+  'I\'m toasted',
+  'that hurt',
+  'your interwebs!',
+  'I see a light...',
+  'totally zooted',
+  'misplaced my bits',
+  'maybe reboot?',
+  'what was I doing again?',
+  'my cabbages!!!',
+  'Leeerrroooyyy Jeeenkins',
+  'at least I have chicken'
+]
+
+export const randomNonsense = () => `[OH NO, ${nonsense[Math.floor(Math.random() * nonsense.length)]}]`
+
+export async function initConfig (userConfig) {
+  const config = Object.assign({}, userConfig)
+
+  if (!('decodePathParameters' in config)) {
+    config.decodePathParameters = false
+  }
+
+  if (!('decodeQueryParams' in config)) {
+    config.decodeQueryParams = false
+  }
+
+  if (!('extendIncomingMessage' in config)) {
+    config.extendIncomingMessage = false
+  }
+
+  if (!('parseCookie' in config)) {
+    config.parseCookie = false
+  }
+
+  if (!('writeDateHeader' in config)) {
+    config.writeDateHeader = false
+  }
+
+  config.acceptsDefault = config.acceptsDefault || defaultHeaders.acceptsDefault
+  config.defaultContentType = config.defaultContentType || defaultHeaders.defaultContentType
+
+  config.contentHandlers = initContentHandlers(config.contentHandlers || {})
+  config.resolveWithoutExtension = config.resolveWithoutExtension || []
+  if (!Array.isArray(config.resolveWithoutExtension)) {
+    config.resolveWithoutExtension = [config.resolveWithoutExtension]
+  }
+
+  if (config.resolveWithoutExtension.indexOf('.htm') === -1) {
+    config.resolveWithoutExtension.push('.htm')
+  }
+  if (config.resolveWithoutExtension.indexOf('.html') === -1) {
+    config.resolveWithoutExtension.push('.html')
+  }
+
+  if (config.middleware) {
+    validateMiddleware(config.middleware)
+  }
+
+  if (!('logAccess' in config)) {
+    config.logAccess = false
+  }
+  if ('logLevel' in config) {
+    log.setLogLevel(config.logLevel)
+  }
+  if (!('ignoreFilesMatching' in config)) {
+    config.ignoreFilesMatching = []
+  } else if (!Array.isArray(config.ignoreFilesMatching)) {
+    config.ignoreFilesMatching = [config.ignoreFilesMatching]
+  }
+  if (!('allowTestFileRoutes' in config)) {
+    config.allowTestFileRoutes = false
+  }
+  config.port = config.port || 10420
+  if (!config.httpPort) {
+    config.httpPort = config.port - 1
+  }
+
+  if (config.logger) {
+    log.setLogger(config.logger)
+  }
+
+  if ((config.httpsKeyFile && !config.httpsCertFile) || (!config.httpsKeyFile && config.httpsCertFile)) {
+    throw new Error('You must provide both httpsKeyFile and httpsCertFile')
+  }
+  return config
+}

package/src/start.mjs

@@ -0,0 +1,25 @@
+import { initConfig, randomNonsense } from './serverConfig.mjs'
+import log from './log.mjs'
+import { startServer } from './server.mjs'
+
+export default async function (config) {
+  if (!config || !config.routeDir) {
+    throw new Error('You must supply a config object with at least a routeDir property. routeDir should be a full path.')
+  }
+  process
+    .on('unhandledRejection', (reason, p) => {
+      log.error(randomNonsense(), reason, 'Unhandled Rejection at Promise', p)
+    })
+    .on('uncaughtException', (err, origin) => {
+      log.error(randomNonsense(), `Caught unhandled exception: ${err}\n` +
+                `Exception origin: ${origin}`)
+    })
+
+  log.gne('Starting Spliffy!')
+  const configWithDefaults = await initConfig(config)
+  return startServer(configWithDefaults).catch(e => {
+    log.error(randomNonsense(), 'Exception during startup:', e)
+    // Spliffy threw an exception, or a route handler failed to load.
+    process.exit(420)
+  })
+}

package/src/staticHandler.mjs

@@ -0,0 +1,74 @@
+import fs from 'fs'
+import etag from 'etag'
+
+const readFile = async (fullPath) => await new Promise(
+  (resolve, reject) =>
+    fs.readFile(fullPath, (err, data) => {
+      if (err) reject(err)
+      else resolve(data)
+    }
+    )
+)
+
+const writeHeaders = (req, res, tag, stat, contentType, staticCacheControl) => {
+  if (req.headers['if-none-match'] === tag) {
+    res.statusCode = 304
+    return
+  }
+  res.writeHead(200, {
+    'Content-Type': contentType,
+    // content-length should not be included because transfer-encoding is chunked
+    // see https://datatracker.ietf.org/doc/html/rfc2616#section-4.4 sub section 3.
+    // Not all clients are compliant (node-fetch) and throw instead of ignoring the header as specified
+    'Cache-Control': staticCacheControl || 'max-age=600',
+    ETag: tag
+  })
+}
+
+const readStat = async path => new Promise((resolve, reject) =>
+  fs.stat(path, (err, stats) =>
+    err ? reject(err) : resolve(stats)
+  ))
+
+export function createStaticHandler (fullPath, contentType, cacheStatic, staticCacheControl) {
+  const cache = {}
+  return {
+    GET: async ({ req, res }) => {
+      if (cacheStatic) {
+        if (!cache.exists || !cache.stat) {
+          cache.exists = fs.existsSync(fullPath)
+          if (cache.exists) {
+            cache.stat = await readStat(fullPath)
+            cache.content = await readFile(fullPath)
+            cache.etag = etag(cache.content)
+          }
+        }
+        if (!cache.exists) {
+          return {
+            statusCode: 404
+          }
+        }
+        writeHeaders(req, res, cache.etag, cache.stat, contentType, staticCacheControl)
+        if (res.statusCode === 304) {
+          return
+        }
+        return cache.content
+      } else {
+        if (!fs.existsSync(fullPath)) {
+          return {
+            statusCode: 404
+          }
+        }
+        const stat = await readStat(fullPath)
+        writeHeaders(req, res, etag(stat), stat, contentType, staticCacheControl)
+        if (res.statusCode === 304) {
+          return
+        }
+        if (stat.size === 0) {
+          return ''
+        }
+        return fs.createReadStream(fullPath)
+      }
+    }
+  }
+}

package/src/url.mjs

@@ -0,0 +1,24 @@
+export function parseQuery (query, decodeQueryParams) {
+  const parsed = {}
+  if (query) {
+    if (decodeQueryParams) {
+      query = decodeURIComponent(query.replace(/\+/g, '%20'))
+    }
+    for (const param of query.split('&')) {
+      const eq = param.indexOf('=')
+      setMultiValueKey(parsed, param.substr(0, eq), param.substr(eq + 1))
+    }
+  }
+  return parsed
+}
+
+export function setMultiValueKey (obj, key, value) {
+  if (key in obj) {
+    if (!Array.isArray(obj[key])) {
+      obj[key] = [obj[key]]
+    }
+    obj[key].push(value)
+  } else {
+    obj[key] = value
+  }
+}

package/src/content-types.js

@@ -1,75 +0,0 @@
-module.exports = {
-    '.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.js

@@ -1,98 +0,0 @@
-const contentTypes = require( './content-types.js' )
-const { parseQuery } = require( "./url" );
-let 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 )
-        }
-    }
-};
-
-let 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,
-}
-
-let _acceptsDefault = '*/*'
-
-function getHandler( contentType ) {
-    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]
-}
-
-function getContentTypeByExtension( name, staticContentTypes ) {
-    const extension = name.indexOf( '.' ) > -1 ? name.slice( name.lastIndexOf( '.' ) ).toLowerCase() : 'default'
-    let contentType = staticContentTypes && staticContentTypes[extension] || null
-
-    return contentType ? contentType : contentTypes[extension]
-}
-
-module.exports = {
-    serialize( content, contentType ) {
-        return getHandler( contentType && contentType.toLowerCase() ).serialize( content )
-    },
-    deserialize( content, contentType ) {
-        return getHandler( contentType && contentType.toLowerCase() ).deserialize( content )
-    },
-    initContentHandlers( handlers, acceptsDefault ) {
-        Object.assign( handlers, contentHandlers )
-        _acceptsDefault = acceptsDefault
-    },
-    getContentTypeByExtension
-}

package/src/decorator.js

@@ -1,202 +0,0 @@
-const cookie = require( 'cookie' )
-const http = require( 'http' )
-const { parseQuery, setMultiValueKey } = require( './url' )
-const log = require( './log' )
-const uuid = require( "uuid" ).v4;
-const { Writable } = require( 'stream' )
-
-const setCookie = ( res ) => function() {
-    return res.setHeader( 'Set-Cookie', [...( res.getHeader( 'Set-Cookie' ) || [] ), cookie.serialize( ...arguments )] )
-}
-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] )
-
-/**
- * Provide a minimal set of shims to make most middleware, like passport, work
- * @type {{decorateResponse(*=, *=, *): *, decorateRequest(*): *}}
- */
-module.exports = {
-    setCookie,
-    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
-        let 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( let p of reqProtoProps() ) {
-            if( !req[p] ) req[p] = http.IncomingMessage.prototype[p]
-        }
-        let 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( let 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
-    },
-    decorateResponse( res, req, finalizeResponse, errorTransformer, endError ) {
-        res.onAborted( () => {
-            res.ended = true
-            res.writableEnded = true
-            res.finalized = true
-            log.error( `Request to ${req.url} was aborted` )
-        } )
-
-        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 = 200
-            if( !res.statusMessage ) res.statusMessage = 'OK'
-            res.headersSent = true
-            res.writeStatus( `${res.statusCode} ${res.statusMessage}` )
-            if( typeof res.onFlushHeaders === 'function' ) {
-                res.onFlushHeaders( res )
-            }
-            for( let header of Object.keys( res.headers ) ) {
-                if( Array.isArray( res.headers[header] ) ) {
-                    for( let multiple of res.headers[header] ) {
-                        res.writeHeader( header, multiple.toString() )
-                    }
-                } else {
-                    res.writeHeader( header, res.headers[header].toString() )
-                }
-            }
-        }
-        res.writeHead = ( status, headers ) => {
-            this.statusCode = status
-            res.assignHeaders( headers )
-        }
-        res.assignHeaders = headers => {
-            for( let header of Object.keys( headers ) ) {
-                res.headers[normalizeHeader( header )] = headers[header]
-            }
-        }
-        res.getHeader = header => {
-            return res.headers[normalizeHeader( header )]
-        }
-        res.status = ( code ) => {
-            this.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()
-                            res.write( chunk )
-                            cb()
-                        } catch (e) {
-                            cb(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 ) {
-                res.writeArrayBuffer( toArrayBuffer( chunk ) )
-            } else if( typeof chunk === 'string' ) {
-                res.writeArrayBuffer( toArrayBuffer( Buffer.from( chunk, 'utf8' ) ) )
-            } else {
-                res.writeArrayBuffer( toArrayBuffer( Buffer.from( JSON.stringify( chunk ), 'utf8' ) ) )
-            }
-        }
-
-        const uwsEnd = res.end;
-        res.ended = false
-        res.end = body => {
-            if( res.ended ) {
-                return
-            }
-            res.ended = true
-            //provide writableEnded like node does, with slightly different behavior
-            if( !res.writableEnded ) {
-                res.writableEnded = true
-                res.flushHeaders()
-                uwsEnd.call( res, body )
-            }
-            if( typeof res.onEnd === 'function' ) {
-                res.onEnd()
-            }
-        }
-
-        res.redirect = function( code, location ) {
-            if( arguments.length === 1 ) {
-                location = code
-                code = 301
-            }
-            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
-
-    }
-}