@srfnstack/spliffy 0.5.5 → 0.8.0

package/src/serverConfig.mjs

@@ -0,0 +1,84 @@
+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 = true
+  }
+
+  if (!('parseCookie' in config)) {
+    config.parseCookie = true
+  }
+
+  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 = true
+  }
+  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,56 +0,0 @@
-let defaultHandler = {
-    deserialize: o => {
-        try {
-            return JSON.parse( typeof o === 'string' ? o : String( o ) )
-        } catch( e ) {
-            return o
-        }
-    },
-    serialize: o => {
-        if( o instanceof Buffer || typeof o === 'string' ) {
-            return o
-        }
-        return {
-            contentType: 'application/json',
-            data: JSON.stringify( typeof o === 'object' ? o : o && o.toString() )
-        }
-    }
-};
-const contentHandlers = {
-    'application/json': {
-        deserialize: s => JSON.parse( typeof s === 'string' ? s : String( s ) ),
-        serialize: s => JSON.stringify( s )
-    },
-    'application/octet-stream': defaultHandler,
-    '*/*': defaultHandler
-}
-
-let _acceptsDefault = '*/*'
-
-function getHandler( contentType ) {
-    //content-type should be singular https://greenbytes.de/tech/webdav/rfc2616.html#rfc.section.14.17
-    let handler = contentHandlers[contentType];
-    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]
-}
-
-module.exports = {
-    serialize( content, contentType ) {
-        return getHandler( contentType ).serialize( content )
-    },
-    deserialize( content, contentType ) {
-        return getHandler( contentType ).deserialize( content )
-    },
-    initContentHandlers( handlers, acceptsDefault ) {
-        Object.assign( handlers, contentHandlers )
-        _acceptsDefault = acceptsDefault
-    }
-}

package/src/dispatcher.js

@@ -1,190 +0,0 @@
-const log = require( './log' )
-const serverConfig = require( './serverConfig' )
-const routes = require( './routes' )
-const content = require( './content' )
-const { executeMiddleware } = require( "./middleware" );
-const { decorateResponse } = require( './expressShim.js' )
-const { decorateRequest } = require( './expressShim.js' )
-const { HTTP_METHODS } = require( './routes.js' )
-const parseUrl = require( './parseUrl' )
-const uuid = require( 'uuid' ).v4
-
-/**
- * Actually handle an incoming request
- * @param url The url being requested
- * @param res The node response object
- * @param req The node request object
- * @param body The request body
- * @param handler The handler for the route
- * @param middleware The middleware that applies to this request
- */
-const handle = async ( url, res, req, body, handler, middleware ) => {
-    try {
-        if( body )
-            body = content.deserialize( body, req.headers['content-type'] )
-    } catch( e ) {
-        log.error( 'Failed to parse request.', e )
-        end( res, 400, 'Failed to parse request body' )
-        return
-    }
-
-    try {
-        let handled = handler[req.method](
-            {
-                url,
-                body,
-                headers: req.headers,
-                req,
-                res
-            } )
-        if( handled && handled.then && typeof handled.then == 'function' ) {
-            await handled.then( ( h ) => finalizeResponse( req, res, h ) )
-                .catch(
-                    e => {
-                        let refId = uuid()
-                        log.error( e, refId )
-                        handleError( res, e, refId )
-                    }
-                )
-        } else {
-            finalizeResponse( req, res, handled )
-        }
-
-    } catch( e ) {
-        let refId = uuid()
-        log.error( 'handler failed', e, refId )
-        await tryExecuteMiddleware( middleware, req, res, e, refId )
-        handleError( res, e, refId )
-    }
-}
-
-const handleError = ( res, e, refId ) => {
-    if( e.body && typeof e.body !== 'string' ) {
-        e.body = JSON.stringify( e.body )
-    }
-    if( serverConfig.current.errorTransformer ) {
-        e = serverConfig.current.errorTransformer( e, refId )
-    }
-    end( res, e.statusCode || e.status || 500, ( e.statusMessage || e.message || 'Internal Server Error' ) + ' refId: ' + refId, e.body || '' )
-}
-
-const end = ( res, code, message, body ) => {
-    res.statusCode = code
-    res.statusMessage = message
-    res.end( body || '' )
-}
-
-const logAccess = 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 ) => {
-    if( !res.ended ) {
-        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, 'OK' )
-        } else {
-            let code = 200
-            let message = 'OK'
-            let body = handled
-            if( handled.body || handled.status || handled.statusMessage || handled.statusCode || handled.headers ) {
-                body = handled.body
-                if( handled.headers ) {
-                    res.assignHeaders( handled.headers )
-                }
-                code = handled.statusCode || 200
-                message = handled.statusMessage || 'OK'
-            }
-            let contentType = res.getHeader( 'content-type' )
-
-            let serialized = content.serialize( body, contentType );
-            if( serialized && serialized.contentType && !contentType ) {
-                res.setHeader( 'content-type', serialized.contentType )
-            }
-            end( res, code, message, serialized && serialized.data || serialized )
-        }
-    } else {
-        log.warn( `Tried to finalize ended response for req: ${req.url}` )
-    }
-}
-
-async function tryExecuteMiddleware( middleware, req, res, e, refId ) {
-    if( !middleware ) return
-    try {
-        if( e )
-            await executeMiddleware( middleware, req, res, e )
-        else
-            await executeMiddleware( middleware, req, res )
-    } catch( e ) {
-        if( !refId ) refId = uuid()
-        console.log( 'Failed executing middleware while handling error: ' + e )
-        handleError( res, e, refId )
-    }
-}
-
-let currentDate = new Date().toUTCString()
-setInterval( () => currentDate = new Date().toUTCString(), 1000 )
-
-const handleRequest = async ( req, res ) => {
-    req = decorateRequest( req, res )
-    res = decorateResponse( res, req, finalizeResponse )
-
-    res.setHeader( 'server', 'uws' )
-    res.setHeader( 'date', currentDate )
-
-    let route = routes.find( req.spliffyUrl )
-    if( !route.handler && serverConfig.current.notFoundRoute ) {
-        route = routes.find( parseUrl( ...serverConfig.current.notFoundRoute.split( '?' ) ) )
-    }
-    if( !route.handler ) {
-        end( res, 404, 'Not Found' )
-    } else if( req.method === 'OPTIONS' || ( route.handler && route.handler[req.method] ) ) {
-        try {
-            let buffer
-
-            let 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 ) )
-                    } )
-            )
-            req.spliffyUrl.pathParameters = route.pathParameters
-            await tryExecuteMiddleware( route.middleware, req, res )
-            if( !res.writableEnded ) {
-                if( req.method === 'OPTIONS' && !route.handler.OPTIONS ) {
-                    res.setHeader( 'Allow', Object.keys( route.handler ).filter( key => HTTP_METHODS.indexOf( key ) > -1 ).join( ', ' ) )
-                    end( res, 204 )
-                } else {
-                    await handle( req.spliffyUrl, res, req, reqBody, route.handler, route.middleware )
-                }
-            }
-        } catch( e ) {
-            let refId = uuid()
-            log.error( 'Handling request failed', e, refId )
-            await tryExecuteMiddleware( route.middleware, req, res, e, refId );
-            if( !res.writableEnded )
-                handleError( res, e, refId )
-        }
-    } else {
-        end( res, 405, 'Method Not Allowed' )
-    }
-}
-
-module.exports =
-    function( res, req ) {
-        try {
-            if( serverConfig.current.logAccess ) {
-                res.onEnd = logAccess( req, res )
-            }
-            handleRequest( req, res )
-        } catch( e ) {
-            log.error( 'Failed handling request', e )
-        }
-    }

package/src/expressShim.js

@@ -1,120 +0,0 @@
-const cookie = require( 'cookie' )
-const serverConfig = require( './serverConfig' )
-const http = require('http')
-const parseUrl = require( './parseUrl' )
-const setCookie = ( res ) => function() {
-    return res.setHeader( 'set-cookie', [...( res.getHeader( 'set-cookie' ) || [] ), cookie.serialize( ...arguments )] )
-}
-const log = require( './log' )
-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
-}
-
-/**
- * Provide a minimal set of shims to make most middleware, like passport, work
- * @type {{decorateResponse(*=, *=, *): *, decorateRequest(*): *}}
- */
-module.exports = {
-    setCookie,
-    decorateRequest( req, res ) {
-        let query = req.getQuery()
-        req.url = `${req.getUrl()}${query ? '?' + query : ''}`
-        req.spliffyUrl = parseUrl( req.getUrl(), req.getQuery() )
-        req.headers = {}
-        req.method = req.getMethod().toUpperCase()
-        req.remoteAddress = addressArrayBufferToString( res.getRemoteAddressAsText() )
-        req.proxiedRemoteAddress = addressArrayBufferToString( res.getProxiedRemoteAddressAsText() ) || undefined
-        req.forEach( ( header, value ) => req.headers[header] = value )
-        if( serverConfig.current.parseCookie && req.headers.cookie ) {
-            req.cookies = cookie.parse( req.headers.cookie ) || {}
-        }
-        //frameworks like passport like to modify the message prototype...
-        for(let p of Object.keys(http.IncomingMessage.prototype)){
-            if(!req[p] && !excludedMessageProps[p]) req[p] = http.IncomingMessage.prototype[p]
-        }
-        return req
-    },
-    decorateResponse( res, req, finalizeResponse ) {
-        res.onAborted( () => {
-            log.error( `Request to ${req.url} was aborted prematurely` )
-        } )
-        const writeHead = {}
-
-        res.headers = {}
-        res.headersSent = false
-        res.setHeader = ( header, value ) => {
-            res.headers[header.toLowerCase()] = value
-        }
-        res.removeHeader = header => delete res.headers[header.toLowerCase()]
-        res.flushHeaders = () => {
-            res.headersSent = true
-            // https://nodejs.org/api/http.html#http_response_writehead_statuscode_statusmessage_headers
-            //When headers have been set with response.setHeader(), they will be merged with any headers passed to response.writeHead(), with the headers passed to response.writeHead() given precedence.
-            Object.assign( res.headers, writeHead )
-            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 ) ) {
-                writeHead[header.toLowerCase()] = headers[header]
-            }
-        }
-        res.getHeader = header => {
-            let lc = header.toLowerCase()
-            return writeHead[lc] || res.headers[lc]
-        }
-        res.status = ( code ) => {
-            this.statusCode = code
-            return this
-        }
-
-        const ogEnd = res.end
-        res.ended = false
-        res.end = body => {
-            if( res.ended ) return
-            res.ended = true
-            if(!res.writableEnded){
-                res.writableEnded = true
-                res.writeStatus( `${res.statusCode} ${res.statusMessage}` )
-                res.flushHeaders()
-                ogEnd.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
-
-    }
-}