@srfnstack/spliffy 0.7.0 → 0.9.0

package/src/handler.js

@@ -1,262 +0,0 @@
-const log = require( './log' )
-const content = require( './content' )
-const { executeMiddleware } = require( "./middleware" );
-const { decorateResponse } = require( './decorator.js' )
-const { decorateRequest } = require( './decorator.js' )
-const uuid = require( 'uuid' ).v4
-const { Readable } = require( 'stream' )
-
-/**
- * Execute the handler
- * @param url The url being requested
- * @param res The uws response object
- * @param req The uws request object
- * @param body The request body
- * @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 ) => {
-    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(
-            {
-                url,
-                body,
-                headers: req.headers,
-                req,
-                res
-            } )
-        if( handled && typeof handled.then == 'function' ) {
-            await handled.then( ( h ) => finalizeResponse( req, res, h ) )
-                .catch(
-                    e => {
-                        let refId = uuid()
-                        log.error( 'handler failed', e, refId )
-                        endError( res, e, refId, errorTransformer )
-                    }
-                )
-        } else {
-            finalizeResponse( req, res, handled )
-        }
-
-    } catch( e ) {
-        let refId = uuid()
-        log.error( 'handler failed', e, refId )
-        await tryExecuteMiddleware( middleware, req, res, e, errorTransformer, refId )
-        endError( res, e, refId, errorTransformer )
-    }
-}
-
-const endError = ( res, e, refId, errorTransformer ) => {
-    if( e.body && typeof e.body !== 'string' ) {
-        e.body = JSON.stringify( e.body )
-    }
-    if( typeof errorTransformer === 'function' ) {
-        e = errorTransformer( e, refId )
-    }
-    end( res, e.statusCode || 500, ( e.statusMessage || 'Internal Server Error' ) + ' refId: ' + refId, e.body || '' )
-}
-
-const end = ( res, code, message, body ) => {
-    //status set directly on res wins
-    res.statusCode = res.statusCode || code
-    res.statusMessage = res.statusMessage || message
-    if( body instanceof Readable || res.streaming ) {
-        res.streaming = true
-        if( body instanceof Readable ) {
-            res.flushHeaders()
-            pipeResponse( res, body )
-        }
-        //handler is responsible for ending the response if they are streaming
-    } else {
-        res.end( serializeBody( body, res ) || '' )
-    }
-}
-
-const writeAccess = 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.finalized ) {
-        res.finalized = true
-        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 {
-            //if the returned object has known fields, treat it as a response object instead of the body
-            if( handled.body || handled.statusMessage || handled.statusCode || handled.headers ) {
-                if( handled.headers ) {
-                    res.assignHeaders( handled.headers )
-                }
-                end( res, handled.statusCode || 200, handled.statusMessage || 'OK', handled.body )
-            } else {
-                end( res, 200, 'OK', handled )
-            }
-        }
-    }
-}
-
-const pipeResponse = ( res, readStream, errorTransformer ) => {
-    readStream.on( 'data', res.write )
-        .on( 'end', res.end )
-        .on( 'error', e => {
-            try {
-                readStream.destroy()
-            } finally {
-                endError( res, e, uuid(), errorTransformer )
-            }
-        } )
-}
-
-const serializeBody = ( body, res ) => {
-    let contentType = res.getHeader( 'content-type' )
-    if( typeof body === 'string' ) {
-        if( !contentType ) {
-            res.headers['content-type'] = 'text/plain'
-        }
-        return body
-    } else if( body instanceof Readable ) {
-        return body
-    }
-    let serialized = content.serialize( body, contentType )
-
-    if( serialized && serialized.contentType && !contentType ) {
-        res.headers['content-type'] = serialized.contentType
-    }
-    return serialized && serialized.data || ''
-}
-
-async function tryExecuteMiddleware( middleware, req, res, e, errorTransformer, refId ) {
-    if( !middleware ) return
-
-    let applicableMiddleware = middleware[req.method]
-    if( middleware.ALL ) {
-        if( applicableMiddleware ) applicableMiddleware = middleware.ALL.concat( applicableMiddleware )
-        else applicableMiddleware = middleware.ALL
-    }
-
-    if( !applicableMiddleware || applicableMiddleware.length === 0 ) {
-        return
-    }
-    const errorMiddleware = applicableMiddleware.filter( mw => mw.length === 4 )
-    const middlewarez = applicableMiddleware.filter( mw => mw.length === 3 )
-    try {
-        if( e )
-            await executeMiddleware( middlewarez, errorMiddleware, req, res, e )
-        else
-            await executeMiddleware( middlewarez, errorMiddleware, req, res )
-    } catch( e ) {
-        if( !refId ) refId = uuid()
-        console.log( 'Failed executing middleware while handling error: ' + e )
-        endError( res, e, refId, errorTransformer )
-    }
-}
-
-let currentDate = new Date().toUTCString()
-setInterval( () => currentDate = new Date().toUTCString(), 1000 )
-
-const handleRequest = async ( req, res, handler, middleware, errorTransformer ) => {
-    res.headers['server'] = 'uWebSockets.js'
-    res.headers['date'] = currentDate
-
-    try {
-        let reqBody
-        if( !handler.streamRequestBody ) {
-            let buffer
-            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 ) )
-                    } )
-            )
-        } else {
-            reqBody = 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 )] ) )
-                if( isLast ) {
-                    reqBody.push( null )
-                }
-            } )
-        }
-        await tryExecuteMiddleware( middleware, req, res, errorTransformer )
-        if( !res.writableEnded && !res.ended ) {
-            await executeHandler( req.spliffyUrl, res, req, reqBody, handler, middleware, errorTransformer )
-        }
-    } catch( e ) {
-        let refId = uuid()
-        log.error( 'Handling request failed', e, refId )
-        await tryExecuteMiddleware( middleware, req, res, e, errorTransformer, refId );
-        if( !res.writableEnded )
-            endError( res, e, refId, errorTransformer )
-    }
-}
-const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE']
-module.exports =
-    {
-        create: ( handler, middleware, pathParameters, config ) => function( res, req ) {
-            try {
-                req = decorateRequest( req, pathParameters, res, config );
-                res = decorateResponse( res, req, finalizeResponse, config.errorTransformer, endError );
-
-                if( config.logAccess ) {
-                    res.onEnd = writeAccess( req, res )
-                }
-                handleRequest( req, res, handler, middleware, config.errorTransformer )
-            } catch( e ) {
-                log.error( 'Failed handling request', e )
-            }
-        },
-        notFound: config => ( res, req ) => {
-            try {
-                let params = config.defaultRoute && config.defaultRoute.pathParameters || []
-                req = decorateRequest( req, params, res, config );
-                res = decorateResponse( res, req, finalizeResponse );
-                if( config.logAccess ) {
-                    res.onEnd = writeAccess( req, res )
-                }
-                if( config.defaultRoute && typeof config.defaultRoute ) {
-                    let route = config.defaultRoute
-                    if( route.handlers && route.handlers[req.method] ) {
-                        handleRequest( req, res,
-                            config.defaultRoute.handlers[req.method],
-                            config.defaultRoute.middleware,
-                            config.errorTransformer
-                        )
-                    } else {
-                        res.statusCode = 405
-                        res.statusMessage = 'Method Not Allowed'
-                        res.end()
-                    }
-                } else {
-                    res.statusCode = 404
-                    res.statusMessage = 'Not Found'
-                    res.end()
-                }
-            } catch( e ) {
-                log.error( 'Failed handling request', e )
-            }
-        },
-        HTTP_METHODS
-    }

package/src/index.js

@@ -1,29 +0,0 @@
-const log = require( './log' )
-let url = require('./url')
-
-/**
- * Startup function for the spliffy server
- * Startup will exponentially back off on consecutive failures
- * @param config See https://github.com/narcolepticsnowman/spliffy#config
- * @returns {Promise<Server>} Either the https server if https is configured or the http server
- */
-const spliffy = ( config ) => require( './start' )( config )
-
-/**
- * A helper for creating a redirect handler
- * @param location The location to redirect to
- * @param permanent Whether this is a permanent redirect or not
- */
-spliffy.redirect = ( location, permanent = true ) => () => ( {
-    statusCode: permanent ? 301 : 302,
-    statusMessage: permanent ? 'Moved Permanently' : 'Found',
-    headers: {
-        'location': location
-    }
-} )
-
-spliffy.log = log
-spliffy.parseQuery = url.parseQuery
-spliffy.setMultiValueKey = url.setMultiValueKey
-
-module.exports = spliffy

package/src/log.js

@@ -1,43 +0,0 @@
-const inspect = require( 'util' ).inspect
-const levelOrder = { DEBUG: 0, INFO: 1, 'GOOD NEWS EVERYONE!': 1, WARN: 2, ERROR: 3, NONE: 4 }
-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,116 +0,0 @@
-const log = require( './log' )
-/**
- * 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( middleware, errorMiddleware, req, res, reqErr ) {
-    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 === middleware.length )
-            ) {
-                if( mwErr )
-                    reject( mwErr )
-                resolve()
-            } else {
-                try {
-                    let mw = isError ? errorMiddleware[current] : middleware[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,63 +0,0 @@
-const fs = require( 'fs' )
-const path = require( 'path' )
-const { mergeMiddleware } = require( "./middleware" );
-const staticHandler = require( './staticHandler' )
-const { getContentTypeByExtension } = require( './content' )
-
-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.
-     */
-    getNodeModuleRoutes(config) {
-        let nodeModuleRoutes = config.nodeModuleRoutes;
-        let routes = []
-        if( nodeModuleRoutes && typeof nodeModuleRoutes === 'object' ) {
-            const nodeModulesDir = nodeModuleRoutes.nodeModulesPath ? path.resolve( nodeModuleRoutes.nodeModulesPath ) : path.resolve( config.routeDir, '..', 'node_modules' )
-            if( !fs.existsSync( nodeModulesDir ) ) {
-                throw new Error( `Unable to find node_modules dir at ${nodeModulesDir}` )
-            }
-            let prefix = stripLeadingSlash(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 mw = {}
-                    mergeMiddleware( config.middleware, mw )
-                    mergeMiddleware( nodeModuleRoutes.middleware || {}, mw )
-                    routes.push( {
-                        pathParameters: [],
-                        urlPath,
-                        filePath,
-                        handlers: staticHandler.create(
-                            filePath, getContentTypeByExtension(lastPart, config.staticContentTypes),
-                            config.cacheStatic, config.staticCacheControl
-                        ),
-                        middleware: mw
-                    } )
-                } else {
-                    console.warn( `The specified node_modules file: ${file} does not exist and will not be served.` )
-                }
-            }
-        }
-        return routes
-    }
-}

package/src/routes.js

@@ -1,137 +0,0 @@
-const { validateMiddleware, mergeMiddleware } = require( "./middleware" )
-const staticHandler = require( './staticHandler' )
-const { getContentTypeByExtension } = require( "./content" )
-const fs = require( 'fs' )
-const path = require( 'path' )
-const { HTTP_METHODS } = require( './handler' )
-
-const isVariable = part => part.startsWith( '$' )
-const getVariableName = part => part.substr( 1 )
-const getPathPart = name => {
-    if( name === 'index' ) {
-        return ''
-    }
-    if( name.startsWith( '$' ) ) {
-        return `:${name.substr( 1 )}`
-    } else if( name.endsWith( '+' ) ) {
-        return `${name.substr( 0, name.length - 1 )}/*`
-    } else {
-        return name
-    }
-}
-const ignoreHandlerFields = { middleware: true, streamRequestBody: true }
-const doFindRoutes = ( config, currentFile, filePath, urlPath, pathParameters, inheritedMiddleware ) => {
-    let routes = []
-    let name = currentFile.name;
-    if( currentFile.isDirectory() ) {
-        if( isVariable( name ) ) {
-            pathParameters = pathParameters.concat( getVariableName( name ) )
-        }
-        const files = fs.readdirSync( filePath, { withFileTypes: true } )
-
-        const dirMiddleware = files
-            .filter( f => f.name.endsWith( '.mw.js' ) )
-            .map( f => {
-                let mw = require( filePath + '/' + f.name )
-                if( !mw.middleware ) {
-                    throw new Error( `${filePath + '/' + f.name} must export a middleware property` )
-                }
-                validateMiddleware( mw.middleware )
-                return mw.middleware
-            } )
-            .reduce( ( result, incoming ) => mergeMiddleware( incoming, result ), inheritedMiddleware )
-
-        routes = routes.concat( (
-                files
-                    .filter( f => !f.name.endsWith( '.mw.js' ) )
-                    .map(
-                        ( f ) => doFindRoutes(
-                            config,
-                            f,
-                            filePath + '/' + f.name,
-                            urlPath + '/' + getPathPart( name ),
-                            pathParameters,
-                            dirMiddleware
-                        )
-                    )
-            ).flat()
-        )
-    } else if( !config.staticMode && name.endsWith( '.rt.js' ) ) {
-        name = name.substr( 0, name.length - '.rt.js'.length )
-        if( isVariable( name ) ) {
-            pathParameters = pathParameters.concat( getVariableName( name ) )
-        }
-        let route = {
-            pathParameters,
-            urlPath: `${urlPath}/${getPathPart( name )}`,
-            filePath,
-            handlers: {}
-        }
-        const handlers = require( filePath )
-        route.middleware = mergeMiddleware( handlers.middleware || [], inheritedMiddleware )
-        for( let method of Object.keys( handlers ).filter( k => !ignoreHandlerFields[k] ) ) {
-            if( HTTP_METHODS.indexOf( method ) === -1 ) {
-                throw `Method: ${method} in file ${filePath} is not a valid http method. It must be one of: ${HTTP_METHODS}. Method names must be all uppercase.`
-            }
-            let loadedHandler = handlers[method]
-            let handler = loadedHandler
-            if( typeof loadedHandler.handler === 'function' ) {
-                handler = loadedHandler.handler
-            }
-            if( typeof handler !== 'function' ) {
-                throw `Request method ${method} in file ${filePath} must be a function. Got: ${handlers[method]}`
-            }
-            if( !loadedHandler.hasOwnProperty( 'streamRequestBody' ) ) {
-                handler.streamRequestBody = handlers.streamRequestBody
-            } else {
-                handler.streamRequestBody = loadedHandler.streamRequestBody
-            }
-            route.handlers[method] = handler
-        }
-        routes.push( route )
-    } else {
-        if( isVariable( name ) ) {
-            pathParameters = pathParameters.concat( getVariableName( name ) )
-        }
-        let contentType = getContentTypeByExtension( name, config.staticContentTypes )
-        let route = {
-            pathParameters,
-            urlPath: `${urlPath}/${getPathPart( name )}`,
-            filePath,
-            handlers: staticHandler.create( filePath, contentType,
-                config.cacheStatic, config.staticCacheControl ),
-            middleware: inheritedMiddleware
-        }
-
-        if( !route.handlers.OPTIONS ) {
-
-        }
-
-        routes.push( route )
-
-        for( let ext of config.resolveWithoutExtension ) {
-            if( name.endsWith( ext ) ) {
-                let noExtRoute = Object.assign( {}, route )
-                noExtRoute.urlPath = `${urlPath}/${getPathPart( name.substr( 0, name.length - ext.length ) )}`
-                routes.push( noExtRoute )
-            }
-        }
-    }
-    return routes
-}
-
-
-module.exports = {
-    findRoutes(config) {
-        const fullRouteDir = path.resolve( config.routeDir )
-        if( !fs.existsSync( fullRouteDir ) ) {
-            throw `can't find route directory: ${fullRouteDir}`
-        }
-        let appMiddleware = mergeMiddleware( config.middleware || [], {} )
-        return fs.readdirSync( fullRouteDir, { withFileTypes: true } )
-            .map(
-                f => doFindRoutes( config, f, fullRouteDir + '/' + f.name, '', [], appMiddleware )
-            )
-            .flat()
-    }
-}

package/src/secure.js

@@ -1,39 +0,0 @@
-const fs = require( 'fs' )
-const log = require( './log' )
-const path = require( 'path' )
-const uws = require( 'uWebSockets.js' )
-
-const startHttpRedirect = ( host, port) => {
-    //redirect http to https
-    uws.App().any( "/*",
-        ( req, res ) => {
-            try {
-                res.writeHead( 301, { 'Location': `https://${req.headers.host}:${port}${req.url}` } )
-                res.end()
-            } catch( e ) {
-                log.error( `Failed to handle http request on port ${port}`, req.url, e )
-            }
-        }
-    ).listen( 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 getHttpsApp = ({ key, cert }) => {
-    if( !key || !cert ) throw 'You must set secure.key and secure.cert in the config to use https!'
-    let keyPath = path.resolve( key )
-    let certPath = path.resolve( 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}`
-    return uws.App( {
-        key_file_name: keyPath,
-        cert_file_name: certPath
-    } )
-}
-module.exports = {
-    getHttpsApp, startHttpRedirect
-}