@srfnstack/spliffy 0.5.5 → 0.8.0

package/src/log.js

@@ -1,43 +0,0 @@
-const inspect = require( 'util' ).inspect
-const levelOrder = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 }
-let logAccess = true
-let logLevel = levelOrder.INFO
-
-const ifLevelEnabled = ( fn, level, args ) => {
-    const configLevel = levelOrder[logLevel] || levelOrder.INFO
-    if( !levelOrder[level] || levelOrder[level] >= configLevel ) {
-        fn( `[${new Date().toISOString()}] [${level}]  ${args.map( a => typeof a === 'string' ? a : inspect( a, { depth: null } ) ).join( ' ' )}` )
-    }
-}
-
-module.exports = {
-    setLogAccess( enable ) {
-        logAccess = !!enable
-    },
-    setLogLevel( level ) {
-        if( !levelOrder.hasOwnProperty( level ) ) {
-            throw `Invalid level: ${level}`
-        }
-        logLevel = level
-    },
-    warning( e ) {
-        ifLevelEnabled( console.warn, 'WARN', [...arguments] )
-    },
-    warn( e ) {
-        ifLevelEnabled( console.warn, 'WARN', [...arguments] )
-    },
-    info( e ) {
-        ifLevelEnabled( console.info, 'INFO', [...arguments] )
-    },
-    gne( e ) {
-        ifLevelEnabled( console.info, 'GOOD NEWS EVERYONE!', [...arguments] )
-    },
-    access( e ) {
-        if( logAccess ) {
-            ifLevelEnabled( console.info, 'ACCESS', [...arguments] )
-        }
-    },
-    error( e ) {
-        ifLevelEnabled( console.error, 'ERROR', [...arguments].map( arg => arg.stack ? arg.stack : arg ) )
-    }
-}

package/src/middleware.js

@@ -1,121 +0,0 @@
-const log = require( './log' )
-const uuid = require( 'uuid' ).v4
-/**
- * middleware is stored as an object where the properties are request methods the middleware applies to
- * if a middleware applies to all methods, the property ALL is used
- * example:
- * {
- *     GET: [(req,res,next)=>console.log('ice cream man')]
- *     POST: [(req,res,next)=>console.log('gelato')]
- *     ALL: [(req,res,next)=>console.log('bruce banner')]
- * }
- */
-const mergeMiddleware = ( incoming, existing ) => {
-    const mergeInto = cloneMiddleware( existing )
-
-    validateMiddleware( incoming )
-    if( Array.isArray( incoming ) ) {
-        mergeInto.ALL = ( existing.ALL || [] ).concat( incoming )
-    } else if( typeof incoming === 'object' ) {
-        for( let method in incoming ) {
-            let upMethod = method.toUpperCase()
-            mergeInto[upMethod] = ( mergeInto[method] || [] ).concat( incoming[upMethod] || [] )
-        }
-    }
-    return mergeInto
-}
-
-const cloneMiddleware = ( middleware ) => {
-    const clone = { ...middleware }
-    for( let method in middleware ) {
-        clone[method] = [...( middleware[method] || [] )]
-    }
-    return clone
-}
-
-/**
- * Ensure the given middleware is valid
- * @param middleware
- */
-const validateMiddleware = ( middleware ) => {
-    if( Array.isArray( middleware ) ) {
-        validateMiddlewareArray( middleware )
-    } else if( typeof middleware === 'object' ) {
-        for( let method in middleware ) {
-            //ensure methods are always available as uppercase
-            let upMethod = method.toUpperCase()
-            middleware[upMethod] = middleware[method]
-            validateMiddlewareArray( middleware[upMethod] )
-        }
-    } else {
-        throw new Error( 'Invalid middleware definition: ' + middleware )
-    }
-}
-
-const validateMiddlewareArray = ( arr ) => {
-    if( !Array.isArray( arr ) ) {
-        throw 'middleware must be an array of functions'
-    }
-    for(let f of arr){
-        if( typeof f !== 'function' ) {
-            throw 'Each element in the array of middleware must be a function'
-        }
-    }
-}
-
-async function executeMiddleware( middlewarez, req, res, reqErr ) {
-
-    const applicableMiddleware = ( middlewarez.ALL || [] ).concat( middlewarez[req.method] || [] )
-    const errorMiddleware = applicableMiddleware.filter( mw => mw.length === 4 )
-    const normalMiddleware = applicableMiddleware.filter( mw => mw.length === 3 )
-    let err
-    await new Promise( ( resolve, reject ) => {
-        let current = -1
-        let isError = false
-        const next = ( mwErr ) => {
-            if( !isError && mwErr ) {
-                isError = true
-                current = -1
-            }
-            if( res.writableEnded ) {
-                resolve()
-                return
-            }
-            current++
-            if( ( isError && current === errorMiddleware.length ) ||
-                ( !isError && current === normalMiddleware.length )
-            ) {
-                if( mwErr )
-                    reject( mwErr )
-                resolve()
-            } else {
-                try {
-                    let mw = isError ? errorMiddleware[current] : normalMiddleware[current]
-                    if( mwErr ) {
-                        mw( mwErr, req, res, next )
-                    } else {
-                        mw( req, res, next )
-                    }
-                } catch( e ) {
-
-                    log.error( 'Middleware threw exception', e )
-                    next( e )
-                }
-            }
-        }
-
-        next( reqErr )
-    } ).catch( e => {
-        err = e
-        return null
-    } )
-    if(err) throw err
-}
-
-module.exports = {
-    validateMiddlewareArray,
-    cloneMiddleware,
-    validateMiddleware,
-    mergeMiddleware,
-    executeMiddleware
-}

package/src/nodeModuleHandler.js

@@ -1,54 +0,0 @@
-const fs = require( 'fs' )
-const path = require( 'path' )
-const serverConfig = require( './serverConfig' )
-const { mergeMiddleware } = require( "./middleware" );
-const { addStaticRoute } = require( "./routeUtil" );
-
-
-const stripLeadingSlash = p => p.startsWith( '/' ) ? p.substr( 1 ) : p
-
-module.exports = {
-    /**
-     This method will add all of the configured node_module files to the given routes.
-     The configured node moduleRoutes must be explicit files, no pattern matching is supported.
-     Generating the list of files using pattern matching yourself is highly discouraged.
-     It is much safer to explicitly list every file you wish to be served so you don't inadvertently serve additional files.
-     */
-    async addNodeModuleRoutes( routes ) {
-        let nodeModuleRoutes = serverConfig.current.nodeModuleRoutes;
-        if( nodeModuleRoutes && typeof nodeModuleRoutes === 'object' ) {
-            const nodeModulesDir = nodeModuleRoutes.nodeModulesPath ? path.resolve( nodeModuleRoutes.nodeModulesPath ) : path.resolve( serverConfig.current.routeDir, '..', 'node_modules' )
-            if( !fs.existsSync( nodeModulesDir ) ) {
-                throw new Error( `Unable to find node_modules dir at ${nodeModulesDir}` )
-            }
-            let prefix = nodeModuleRoutes.routePrefix || 'lib'
-            if( !Array.isArray( nodeModuleRoutes.files ) ) {
-                nodeModuleRoutes.files = [nodeModuleRoutes.files]
-            }
-            for( let file of nodeModuleRoutes.files ) {
-                let filePath, urlPath
-                if( file && typeof file === 'object' ) {
-                    filePath = path.join( nodeModulesDir, file.modulePath )
-                    urlPath = `${prefix}/${stripLeadingSlash( file.urlPath || file.modulePath )}`
-                } else if( file && typeof file === 'string' ) {
-                    filePath = path.join( nodeModulesDir, file )
-                    urlPath = `${prefix}/${stripLeadingSlash( file )}`
-                } else {
-                    throw new Error( 'Invalid node_module file: ' + file )
-                }
-
-                if( fs.existsSync( filePath ) ) {
-                    let parts = urlPath.split( '/' )
-                    let lastPart = parts.pop()
-                    let parent = parts.reduce( ( rts, part ) => rts[part] || ( rts[part] = {} ), routes )
-                    let mw = {}
-                    mergeMiddleware( serverConfig.current.middleware, mw )
-                    mergeMiddleware( nodeModuleRoutes.middleware || {}, mw )
-                    await addStaticRoute( parent, { name: lastPart }, filePath, mw )
-                } else {
-                    console.warn( `The specified node_modules file: ${file} does not exist and will not be served.` )
-                }
-            }
-        }
-    }
-}

package/src/parseUrl.js

@@ -1,43 +0,0 @@
-const serverConfig = require( './serverConfig' )
-
-module.exports = ( path, query ) => {
-    let parsed = { path: path, query: {} }
-    if( query ) {
-        if( serverConfig.current.decodeQueryParameters ) {
-            query = decodeURIComponent( query.replace( /\+/g, '%20' ) )
-        }
-        let key = ''
-        let value = ''
-        let isKey = true
-
-        for( let i = 0; i <= query.length; i++ ) {
-            if( i === query.length || query[i] === '&' ) {
-                //trailing or consecutive &
-                if( key === '' && value === '' ) continue
-
-                if( parsed.query[key] ) {
-                    if( !Array.isArray( parsed.query[key] ) ) {
-                        parsed.query[key] = [parsed.query[key]]
-                    }
-                    parsed.query[key].push( value )
-                } else {
-                    parsed.query[key] = value
-                }
-
-                key = ''
-                value = ''
-                isKey = true
-            } else if( query[i] === '=' ) {
-                isKey = false
-            } else {
-                if( isKey ) {
-                    key += query[i]
-                } else {
-                    value += query[i]
-                }
-            }
-
-        }
-    }
-    return parsed
-}

package/src/routeUtil.js

@@ -1,67 +0,0 @@
-const staticHandler = require( './staticHandler' )
-const serverConfig = require( './serverConfig' )
-const contentTypes = require( './content-types.js' )
-
-const addRoute = ( routes, path, name, route ) => {
-    let routeData = getNewRouteData( name, routes )
-    if( routes[routeData.name] ) {
-        throw `Duplicate route name found for route file ${path}`
-    }
-    routes[routeData.name] = Object.assign( routeData.route, route )
-}
-
-const addStaticRoute = async ( routes, f, path, inheritedMiddleware ) => {
-    const extension = f.name.indexOf( '.' ) > -1 ? f.name.slice( f.name.lastIndexOf( '.' ) ).toLowerCase() : 'default'
-    let contentType = serverConfig.current.staticContentTypes && serverConfig.current.staticContentTypes[extension] || null
-
-    contentType = contentType ? contentType : contentTypes[extension]
-    let route = {
-        handler: await staticHandler.create( path, contentType ),
-        static: true,
-        middleware: inheritedMiddleware
-    }
-
-    addRoute( routes, path, f.name, route )
-    for( let ext of serverConfig.current.resolveWithoutExtension ) {
-        if( f.name.endsWith( ext ) ) {
-            addRoute( routes, path, f.name.substr( 0, f.name.length - ext.length ), route )
-        }
-    }
-}
-
-
-/**
- * Build a route data with an initialized route object
- * @param name The name of the route
- * @param routes The current routes, used for validation
- * @returns {{route: {}, name: *}|{route: {key: string}, name: string}|{route: {catchall: boolean}, name: string}}
- */
-const getNewRouteData = ( name, routes ) => {
-    if( name.startsWith( '$' ) && name.indexOf( '.' ) === -1 ) {
-        if( 'variable' in routes ) {
-            throw `You can not have two path variables in the same dir. Conflicting handlers: ${name} and \$${routes.variable.key}.`
-        }
-        return {
-            name: 'variable',
-            route: {
-                key: name.substr( 1 )
-            }
-        }
-    } else if( name.endsWith( '+' ) ) {
-        return {
-            name: name.substr( 0, name.length - 1 ),
-            route: {
-                catchall: true
-            }
-        }
-    } else {
-        return { name, route: {} }
-    }
-}
-
-
-module.exports = {
-    getNewRouteData,
-    addStaticRoute,
-    addRoute
-}

package/src/routes.js

@@ -1,191 +0,0 @@
-const fs = require( 'fs' )
-const path = require( 'path' )
-const serverConfig = require( './serverConfig' )
-const log = require( './log' )
-const { validateMiddleware, mergeMiddleware } = require( "./middleware" );
-const { getNewRouteData, addRoute, addStaticRoute } = require( "./routeUtil" );
-const { addNodeModuleRoutes } = require( "./nodeModuleHandler" );
-const state = {
-    routes: {},
-    initializing: false,
-    hasPendingFsEvent: false
-}
-const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE']
-
-/**
- * Recursively walk the specified directory to discover all of the routes and middleware
- * @param currentFile The file or directory to search for routes
- * @param path The full path to the current file
- * @param inheritedMiddleware Middleware that is inherited from the app or parent routes
- * @returns {Promise<{} | Promise<(Promise<(Promise<T | never>|{})[] | never>|{})[] | never>>}
- */
-const findRoutes = async ( currentFile, path, inheritedMiddleware ) => {
-    let routes = {}
-    if( currentFile.isDirectory() ) {
-
-        let routeData = getNewRouteData( currentFile.name, routes )
-        const files = fs.readdirSync( path, { withFileTypes: true } )
-
-        const routeMiddleware = files
-            .filter( f => f.name.endsWith( '.mw.js' ) )
-            .map( f => {
-                let exports = require( path + '/' + f.name )
-                if( !exports.middleware ) {
-                    throw new Error( '.mw.js files must export a middleware property' )
-                }
-                validateMiddleware( exports.middleware )
-                return exports.middleware
-            } )
-            .reduce( ( result, incoming ) => mergeMiddleware( incoming, result ), inheritedMiddleware )
-
-        return Promise.all( files
-            .filter( f => !f.name.endsWith( '.mw.js' ) )
-            .map(
-                ( f ) => findRoutes( f, path + '/' + f.name, routeMiddleware )
-            )
-        )
-            .then(
-                routes => ( {
-                    [routeData.name]: routes.reduce(
-                        ( res, route ) => {
-                            for( let name of Object.keys( route ) ) {
-                                if( res[name] ) {
-                                    throw `Duplicate route name ${name} found in path: ${path}`
-                                }
-                            }
-                            return Object.assign( res, route )
-                        },
-                        routeData.route
-                    )
-                } )
-            )
-    } else if( !serverConfig.current.staticMode && currentFile.name.endsWith( '.rt.js' ) ) {
-        addRoute( routes, path, currentFile.name.substr( 0, currentFile.name.length - '.rt.js'.length ), buildRoute( {}, path, inheritedMiddleware ) )
-    } else {
-        await addStaticRoute( routes, currentFile, path, inheritedMiddleware )
-    }
-    return routes
-}
-
-
-/**
- * load and gather data about the specified route handler file
- * @param route The initialized route data
- * @param path The full path to the file
- * @param inheritedMiddleware The inherited middleware
- * @returns {*}
- */
-const buildRoute = ( route, path, inheritedMiddleware ) => {
-    let handlers = require( path )
-
-    route.handler = {}
-    route.middleware = mergeMiddleware( handlers.middleware || [], inheritedMiddleware )
-    //remove the middleware property if it was set so validation can still pass and to ensure we don't make bogus handlers
-    delete handlers.middleware
-    for( let method in handlers ) {
-        if( HTTP_METHODS.indexOf( method ) === -1 ) {
-            throw `Method: ${method} in file ${path} is not a valid http method. It must be one of: ${HTTP_METHODS}. Method names must be all uppercase.`
-        }
-        let handler = handlers[method]
-        if( typeof handler !== 'function' ) {
-            throw `Request method ${method} must be a function. Got: ${handlers[method]}`
-        }
-        route.handler[method] = handler
-    }
-
-    return route
-}
-
-/**
- * Load the routes
- */
-const init = async () => {
-    if( !state.initializing ) {
-        state.initializing = true
-        const fullRouteDir = path.resolve( serverConfig.current.routeDir )
-        if( !fs.existsSync( fullRouteDir ) ) {
-            throw `can't find route directory: ${fullRouteDir}`
-        }
-        let appMiddleware = mergeMiddleware( serverConfig.current.middleware || [], {} )
-        return Promise.all(
-            fs.readdirSync( fullRouteDir, { withFileTypes: true } )
-                .map(
-                    ( f ) => findRoutes( f, fullRouteDir + '/' + f.name, appMiddleware )
-                )
-        ).then(
-            routes => {
-                state.initializing = false
-                state.routes = routes.reduce(
-                    ( res, route ) => {
-                        for( let name of Object.keys( route ) ) {
-                            if( res[name] ) {
-                                throw `Duplicate route name ${name} found in path: ${fullRouteDir}`
-                            }
-                        }
-                        return Object.assign( res, route )
-                    }, {} )
-                return state.routes
-            }
-        ).then( addNodeModuleRoutes )
-    }
-
-}
-const getRoute = ( part, route, pathParameters ) => {
-    if( part in route ) {
-        return route[part]
-    } else if( route.variable ) {
-        pathParameters[route.variable.key] = serverConfig.current.decodePathParameters ? decodeURIComponent( part.replace( /\+/g, '%20' ) ) : part
-        return route.variable || {}
-    }
-}
-
-module.exports = {
-    init,
-    HTTP_METHODS,
-    validateMiddleware,
-    /**
-     * Find a handler for the given url
-     * @param url
-     * @returns {{}|{handler: ({}|{GET}|*|{GET}), pathParameters}}
-     */
-    find: ( url ) => {
-        let prefix = serverConfig.current.routePrefix
-        let path = url.path
-        if( prefix ) {
-            if( !url.path.startsWith( '/' + prefix ) ) {
-                return {}
-            }
-            path = url.path.substr( 1 + ( prefix && prefix.length + 1 || 0 ) )
-        }
-
-        let route = state.routes
-        let buf = ''
-        let pathParameters = {}
-
-        if( path === '' || path === '/' ) {
-            route = getRoute( 'index', route, pathParameters ) || {}
-        } else {
-            for( let i = 1; i <= path.length; i++ ) {
-                if( i === path.length || path[i] === '/' ) {
-                    //trailing or consecutive /
-                    if(buf === '') continue
-                    route = getRoute( buf, route, pathParameters )
-                    buf = ''
-                    if( !route ) {
-                        route = {}
-                        break
-                    } else if( route.catchall ) {
-                        break
-                    }
-                } else {
-                    buf += path[i]
-                }
-            }
-        }
-        return {
-            handler: route && ( route.handler || ( route.index && route.index.handler ) ),
-            pathParameters: pathParameters,
-            middleware: route && ( route.middleware || ( route.index && route.index.middleware ) )
-        }
-    }
-}

package/src/secure.js

@@ -1,53 +0,0 @@
-const serverConfig = require( './serverConfig' )
-const fs = require( 'fs' )
-const log = require( './log' )
-const path = require( 'path' )
-const uws = require( 'uWebSockets.js' )
-
-const startHttpRedirect = () => {
-    //redirect http to https
-    let port = serverConfig.current.port;
-    uws.App().any( "/*",
-        ( req, res ) => {
-            try {
-                res.writeHead( 301, { 'Location': `https://${req.headers.host}:${serverConfig.current.port}${req.url}` } )
-                res.end()
-            } catch( e ) {
-                log.error( `Failed to handle http request on port ${serverConfig.current.port}`, req.url, e )
-            }
-        }
-    ).listen( serverConfig.current.host || '0.0.0.0', port, ( token ) => {
-        if( token ) {
-            log.gne( `Http redirect server initialized at ${new Date().toISOString()} and listening on port ${port}` )
-        } else {
-            throw new Error( `Failed to start server on port ${port}` )
-        }
-    } )
-}
-
-let startServer = () => {
-    const secure = serverConfig.current.secure
-    if( !secure.key || !secure.cert ) throw 'You must supply an secure key and cert!'
-    let keyPath = path.resolve( secure.key )
-    let certPath = path.resolve( secure.cert )
-    if( !fs.existsSync( keyPath ) ) throw `Can't find https key file: ${keyPath}`
-    if( !fs.existsSync( certPath ) ) throw `Can't find https cert file: ${keyPath}`
-    let port = secure.port || 14420;
-    uws.App( {
-        key_file_name: secure.key,
-        cert_file_name: secure.cert
-    } ).listen( serverConfig.current.host || '0.0.0.0', port, ( token ) => {
-        if( token ) {
-            log.gne( `Https server initialized at ${new Date().toISOString()} and listening on port ${port}` )
-        } else {
-            throw new Error( `Failed to start server on port ${port}` )
-        }
-    } )
-
-}
-module.exports = {
-    startHttps: () => {
-        startServer()
-        startHttpRedirect()
-    }
-}

package/src/serverConfig.js

@@ -1,70 +0,0 @@
-const content = require( './content' )
-const { validateMiddleware } = require( './middleware.js' )
-const log = require( './log' )
-let current = {}
-const defaultHeaders = {
-    acceptsDefault: '*/*',
-    defaultContentType: '*/*'
-}
-//this is mainly for performance reason
-const nonsense = [
-    'Is it getting hot in here?',
-    'Ouch...',
-    'Not feeling so good',
-    'Look a squirrel!',
-    'I swear I only had 3',
-    'I see a light...',
-    'Totally zooted',
-    'Where are my pants?',
-    'Somebody, anyone, help!',
-    'What was I doing again?',
-    'Burninating the codeessss',
-    'Leeeeerrrooooyyy Jeeenkins',
-    'At least I have chicken'
-]
-
-module.exports = {
-    current,
-    randomNonsense: () => `~[OHNO]{${nonsense[Math.floor( Math.random() * nonsense.length )]}}~`,
-    init( config ) {
-        Object.assign( current, config )
-
-
-        if( !config.hasOwnProperty( 'decodePathParameters' ) ) {
-            current.decodePathParameters = true
-        }
-
-        if( !config.hasOwnProperty( 'parseCookie' ) ) {
-            current.parseCookie = true
-        }
-
-        current.acceptsDefault = config.acceptsDefault || defaultHeaders.acceptsDefault
-        current.defaultContentType = config.defaultContentType || defaultHeaders.defaultContentType
-
-        content.initContentHandlers(config.contentHandlers||{}, current.acceptsDefault)
-        current.resolveWithoutExtension = current.resolveWithoutExtension || []
-        if( !Array.isArray( current.resolveWithoutExtension ) ) {
-            current.resolveWithoutExtension = [current.resolveWithoutExtension]
-        }
-
-        if( current.resolveWithoutExtension.indexOf( '.htm' ) === -1 ) {
-            current.resolveWithoutExtension.push( '.htm' )
-        }
-        if( current.resolveWithoutExtension.indexOf( '.html' ) === -1 ) {
-            current.resolveWithoutExtension.push( '.html' )
-        }
-
-        if( current.middleware ) {
-            validateMiddleware( current.middleware )
-        }
-
-        if( !current.hasOwnProperty( 'logAccess' ) ) {
-            current.logAccess = true
-        }
-        log.setLogAccess( current.logAccess )
-        if( current.hasOwnProperty( 'logLevel' ) ) {
-            log.setLogLevel( current.logLevel )
-        }
-        current.port = config.port || 10420
-    }
-}

package/src/start.js

@@ -1,39 +0,0 @@
-const serverConfig = require( './serverConfig' )
-const dispatcher = require( './dispatcher' )
-const routes = require( './routes' )
-const secure = require( './secure' )
-const log = require( './log' )
-const uws = require( 'uWebSockets.js' )
-const { randomNonsense } = require( "./serverConfig" );
-
-module.exports = async function( config ) {
-    if( !config || !config.routeDir ) {
-        throw 'You must supply a config object with at least a routeDir property. routeDir should be a full path.'
-    }
-    log.gne( 'Starting Spliffy!' )
-    serverConfig.init( config )
-    log.info( 'Loading routes' )
-    await routes.init()
-    log.gne( 'Routes Initialized!' )
-
-    if( config.secure ) {
-        secure.startHttps( config.secure )
-    } else {
-        uws.App().any( '/*', dispatcher )
-            .listen( serverConfig.current.host || '0.0.0.0', serverConfig.current.port, ( token ) => {
-                if( token ) {
-                    log.gne( `Server initialized at ${new Date().toISOString()} and listening on port ${serverConfig.current.port}` )
-                } else {
-                    throw new Error( `Failed to start server on port ${serverConfig.current.port}` )
-                }
-            } )
-    }
-    process
-        .on( 'unhandledRejection', ( reason, p ) => {
-            log.error( randomNonsense(), reason, 'Unhandled Rejection at Promise', p )
-        } )
-        .on( 'uncaughtException', ( err, origin ) => {
-            log.error( randomNonsense(), `Caught exception: ${err}\n` +
-                `Exception origin: ${origin}` )
-        } )
-}