@srfnstack/spliffy 0.7.0 → 0.8.0

package/src/server.js

@@ -1,83 +0,0 @@
-const log = require( './log' )
-const { getNodeModuleRoutes } = require( "./nodeModuleHandler" );
-const uws = require( 'uWebSockets.js' )
-const handler = require( './handler' )
-const { findRoutes } = require( './routes' )
-const { getHttpsApp, startHttpRedirect } = require( './secure' )
-
-const state = {
-    routes: {},
-    initialized: false
-}
-const appMethods = {
-    GET: 'get',
-    POST: 'post',
-    PUT: 'put',
-    PATCH: 'patch',
-    DELETE: 'del',
-    OPTIONS: 'options',
-    HEAD: 'head',
-    CONNECT: 'connect',
-    TRACE: 'trace'
-}
-const optionsHandler = methods => {
-    return () => ( {
-        headers: {
-            allow: methods,
-        },
-        statusCode: 204
-    } )
-};
-
-/**
- * Load the routes
- */
-const start = config => {
-    if( !state.initialized ) {
-        state.initialized = true
-        const routes = [...findRoutes( config ), ...getNodeModuleRoutes( config )]
-        let app, port
-        if( config.secure ) {
-            app = getHttpsApp( config.secure )
-            port = config.secure.port || 14420
-            startHttpRedirect( config.host, config.port )
-        } else {
-            app = uws.App()
-            port = config.port
-        }
-        for( let route of routes ) {
-            if( config.printRoutes ) {
-                log.info( 'Configured Route: ', route )
-            }
-            let routePattern = `^${route.urlPath.replace( /:[^/]+/g, "[^/]+" ).replace( /\*/g, ".*" )}$`
-            if( config.notFoundRoute && config.notFoundRoute.match( routePattern ) ) {
-                config.defaultRoute = route
-            }
-            for( let method in route.handlers ) {
-                let theHandler = handler.create( route.handlers[method], route.middleware, route.pathParameters, config );
-                app[appMethods[method]]( route.urlPath, theHandler )
-                if( route.urlPath.endsWith( '/' ) && route.urlPath.length > 1 ) {
-                    app[appMethods[method]]( route.urlPath.substr( 0, route.urlPath.length - 1 ), theHandler )
-                }
-            }
-            if( !route.handlers.OPTIONS ) {
-                app.options( route.urlPath, optionsHandler( Object.keys( route.handlers ).join( ', ' ) ) )
-            }
-        }
-
-        if( config.notFoundRoute && !config.defaultRoute ) {
-            log.warn( 'No route matched default route: ' + config.notFoundRoute )
-        }
-        app.any( '/*', handler.notFound( config ) )
-        app.listen( config.host || '0.0.0.0', config.port, ( token ) => {
-            if( token ) {
-                log.gne( `Server initialized at ${new Date().toISOString()} and listening on port ${port}` )
-            } else {
-                throw new Error( `Failed to start server on port ${port}` )
-            }
-        } )
-    }
-}
-module.exports = {
-    start
-}

package/src/serverConfig.js

@@ -1,69 +0,0 @@
-const content = require( './content' )
-const { validateMiddleware } = require( './middleware.js' )
-const log = require( './log' )
-
-const defaultHeaders = {
-    acceptsDefault: '*/*',
-    defaultContentType: '*/*'
-}
-//this is mainly for performance reason
-const nonsense = [
-    `I'm toasted`,
-    'that hurt',
-    'feels bad man :(',
-    `squirrel! ~-{  }:>`,
-    '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'
-]
-
-module.exports = {
-    randomNonsense: () => `[OH NO, ${nonsense[Math.floor( Math.random() * nonsense.length )]}]`,
-    init( userConfig ) {
-        const config = Object.assign( {}, userConfig )
-
-        if( !config.hasOwnProperty( 'decodePathParameters' ) ) {
-            config.decodePathParameters = true
-        }
-
-        if( !config.hasOwnProperty( 'parseCookie' ) ) {
-            config.parseCookie = true
-        }
-
-        config.acceptsDefault = config.acceptsDefault || defaultHeaders.acceptsDefault
-        config.defaultContentType = config.defaultContentType || defaultHeaders.defaultContentType
-
-        content.initContentHandlers(config.contentHandlers||{}, config.acceptsDefault)
-        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( !config.hasOwnProperty( 'logAccess' ) ) {
-            config.logAccess = true
-        }
-        log.setLogAccess( config.logAccess )
-        if( config.hasOwnProperty( 'logLevel' ) ) {
-            log.setLogLevel( config.logLevel )
-        }
-        config.port = config.port || 10420
-        return config
-    }
-}

package/src/start.js

@@ -1,21 +0,0 @@
-const serverConfig = require( './serverConfig' )
-const log = require( './log' )
-const server = require('./server')
-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.'
-    }
-    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!' )
-    server.start(serverConfig.init( config ))
-}

package/src/staticHandler.js

@@ -1,77 +0,0 @@
-const fs = require( 'fs' )
-const etag = require( '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
-        res.statusMessage = 'Not Modified'
-        return
-    }
-    res.writeHead( 200, {
-        'Content-Type': contentType,
-        'Content-Length': stat.size,
-        '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 )
-    ) )
-
-module.exports = {
-    create: ( 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,
-                            statusMessage: 'Not Found'
-                        }
-                    }
-                    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,
-                            statusMessage: 'Not Found'
-                        }
-                    }
-                    let 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.js

@@ -1,26 +0,0 @@
-
-module.exports = {
-    parseQuery: ( query, decodeQueryParams ) => {
-        let parsed = {}
-        if( query ) {
-            if( decodeQueryParams ) {
-                query = decodeURIComponent( query.replace( /\+/g, '%20' ) )
-            }
-            for(let param of query.split('&')){
-               let eq = param.indexOf('=')
-               module.exports.setMultiValueKey(parsed, param.substr(0, eq), param.substr(eq+1))
-            }
-        }
-        return parsed
-    },
-    setMultiValueKey: ( obj, key, value ) => {
-        if( obj.hasOwnProperty(key) ) {
-            if( !Array.isArray( obj[key] ) ) {
-                obj[key] = [obj[key]]
-            }
-            obj[key].push( value )
-        } else {
-            obj[key] = value
-        }
-    }
-}