@srfnstack/spliffy 0.5.5 → 0.8.0

package/src/httpStatusCodes.mjs

@@ -0,0 +1,103 @@
+export const defaultStatusMessages = {
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  300: 'Multiple Choice',
+  301: 'Moved Permanently',
+  302: 'Found',
+  303: 'See Other',
+  304: 'Not Modified',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Payload Too Large',
+  414: 'URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: 'I\'m a teapot',
+  420: 'Enhance Your Calm',
+  425: 'Too Early',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'Http Version Not Supported',
+  506: 'Variant Also Negotiates',
+  510: 'Not Extended',
+  511: 'Network Authentication Required'
+}
+
+export default {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTIPLE_CHOICE: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  ENHANCE_YOUR_CALM: 420,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
+}

package/src/{index.js → index.mjs}

@@ -1,25 +1,21 @@
-const log = require( './log' )
-
-/**
- * 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,
-    headers: {
-        'location': location
-    }
-} )
+export const redirect = (location, permanent = true) => () => ({
+  statusCode: permanent ? 301 : 302,
+  headers: {
+    location: location
+  }
+})
 
-spliffy.log = log
+export { default as log } from './log.mjs'
+export { parseQuery, setMultiValueKey } from './url.mjs'
 
-module.exports = spliffy
+/**
+ * Startup function for the spliffy server
+ * @param config See https://github.com/narcolepticsnowman/spliffy#config
+ * @returns {Promise<Server>} Either the https server if https is configured or the http server
+ */
+export { default } from './start.mjs'

package/src/log.mjs

@@ -0,0 +1,59 @@
+import util from 'util'
+
+const inspect = util.inspect
+const levelOrder = { TRACE: 10, DEBUG: 20, INFO: 30, ACCESS: 30, 'GOOD NEWS EVERYONE!': 30, WARN: 40, ERROR: 50, FATAL: 60, NONE: 100 }
+let logLevel = levelOrder.INFO
+
+const ifLevelEnabled = (fn, level, args) => {
+  const configLevel = levelOrder[logLevel] || levelOrder.INFO
+  if (levelOrder[level] >= configLevel) {
+    fn(`[${new Date().toISOString()}] [${level}]  ${args.map(a => typeof a === 'string' ? a : inspect(a, { depth: null })).join(' ')}`)
+  }
+}
+
+const callLog = (level, logImplFn, defaultFn, args) => {
+  if (logImpl && typeof logImpl[logImplFn] === 'function') {
+    logImpl[logImplFn](...args)
+  } else {
+    ifLevelEnabled(defaultFn, level, args)
+  }
+}
+
+let logImpl = null
+
+export default {
+  setLogLevel (level) {
+    level = level.toUpperCase()
+    if (!(level in levelOrder)) {
+      throw new Error(`Invalid level: ${level}`)
+    }
+    logLevel = level
+  },
+  setLogger (logger) {
+    logImpl = logger
+  },
+  trace () {
+    callLog('TRACE', 'trace', console.trace, [...arguments])
+  },
+  debug () {
+    callLog('DEBUG', 'debug', console.debug, [...arguments])
+  },
+  info () {
+    callLog('INFO', 'info', console.info, [...arguments])
+  },
+  gne () {
+    callLog('GOOD NEWS EVERYONE!', 'info', console.info, [...arguments])
+  },
+  access () {
+    callLog('ACCESS', 'info', console.info, [...arguments])
+  },
+  warn () {
+    callLog('WARN', 'warn', console.warn, [...arguments])
+  },
+  error () {
+    callLog('ERROR', 'error', console.error, [...arguments].map(arg => arg.stack ? arg.stack : arg))
+  },
+  fatal () {
+    callLog('ERROR', 'error', console.error, [...arguments].map(arg => arg.stack ? arg.stack : arg))
+  }
+}

package/src/middleware.mjs

@@ -0,0 +1,90 @@
+import log from './log.mjs'
+/**
+ * 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')]
+ * }
+ */
+export 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 (const method in incoming) {
+      const upMethod = method.toUpperCase()
+      mergeInto[upMethod] = (mergeInto[method] || []).concat(incoming[upMethod] || [])
+    }
+  }
+  return mergeInto
+}
+
+export const cloneMiddleware = (middleware) => {
+  const clone = { ...middleware }
+  for (const method in middleware) {
+    clone[method] = [...(middleware[method] || [])]
+  }
+  return clone
+}
+
+/**
+ * Ensure the given middleware is valid
+ * @param middleware
+ */
+export const validateMiddleware = (middleware) => {
+  if (Array.isArray(middleware)) {
+    validateMiddlewareArray(middleware)
+  } else if (typeof middleware === 'object') {
+    for (const method in middleware) {
+      // ensure methods are always available as uppercase
+      const upMethod = method.toUpperCase()
+      middleware[upMethod] = middleware[method]
+      validateMiddlewareArray(middleware[upMethod])
+    }
+  } else {
+    throw new Error('Invalid middleware definition: ' + middleware)
+  }
+}
+
+export const validateMiddlewareArray = (arr) => {
+  if (!Array.isArray(arr)) {
+    throw new Error('middleware must be an array of functions')
+  }
+  for (const f of arr) {
+    if (typeof f !== 'function') {
+      throw new Error('Each element in the array of middleware must be a function')
+    }
+  }
+}
+
+export async function invokeMiddleware (middleware, req, res, reqErr) {
+  await new Promise((resolve, reject) => {
+    let current = -1
+    const next = (err) => {
+      if (err) reject(err)
+      if (res.writableEnded) {
+        resolve()
+        return
+      }
+      current++
+      if (current === middleware.length) {
+        resolve()
+      } else {
+        try {
+          if (reqErr) middleware[current](reqErr, req, res, next)
+          else middleware[current](req, res, next)
+        } catch (e) {
+          log.error('Middleware threw exception', e)
+          reject(e)
+        }
+      }
+    }
+
+    next()
+  })
+}

package/src/nodeModuleHandler.mjs

@@ -0,0 +1,61 @@
+import fs from 'fs'
+import path from 'path'
+import { mergeMiddleware } from './middleware.mjs'
+import { createStaticHandler } from './staticHandler.mjs'
+import { getContentTypeByExtension } from './content.mjs'
+
+const stripLeadingSlash = p => p.startsWith('/') ? p.substr(1) : p
+
+/**
+ 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.
+ */
+export function getNodeModuleRoutes (config) {
+  const nodeModuleRoutes = config.nodeModuleRoutes
+  const 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}`)
+    }
+    const prefix = stripLeadingSlash(nodeModuleRoutes.routePrefix || 'lib')
+    if (!Array.isArray(nodeModuleRoutes.files)) {
+      nodeModuleRoutes.files = [nodeModuleRoutes.files]
+    }
+    for (const 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)) {
+        const parts = urlPath.split('/')
+        const lastPart = parts.pop()
+        const mw = {}
+        mergeMiddleware(config.middleware, mw)
+        mergeMiddleware(nodeModuleRoutes.middleware || {}, mw)
+        routes.push({
+          pathParameters: [],
+          urlPath,
+          filePath,
+          handlers: createStaticHandler(
+            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.mjs

@@ -0,0 +1,180 @@
+import { validateMiddleware, mergeMiddleware } from './middleware.mjs'
+import { createStaticHandler } from './staticHandler.mjs'
+import { getContentTypeByExtension } from './content.mjs'
+import fs from 'fs'
+import path from 'path'
+import { HTTP_METHODS } from './handler.mjs'
+import util from 'util'
+
+const { promisify } = util
+
+const readdir = promisify(fs.readdir)
+
+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 filterTestFiles = config => f => (!f.name.endsWith('.test.js') && !f.name.endsWith('.test.mjs')) || config.allowTestFileRoutes
+const filterIgnoredFiles = config => f => !config.ignoreFilesMatching.filter(p => p).find(pattern => f.name.match(pattern))
+const ignoreHandlerFields = { middleware: true, streamRequestBody: true }
+const doFindRoutes = async (config, currentFile, filePath, urlPath, pathParameters, inheritedMiddleware) => {
+  const routes = []
+  const name = currentFile.name
+  if (currentFile.isDirectory()) {
+    routes.push(...(await findRoutesInDir(name, filePath, urlPath, inheritedMiddleware, pathParameters, config)))
+  } else if (!config.staticMode && (name.endsWith('.rt.js') || name.endsWith('.rt.mjs'))) {
+    routes.push(await buildJSHandlerRoute(name, filePath, urlPath, inheritedMiddleware, pathParameters))
+  } else {
+    routes.push(...buildStaticRoutes(name, filePath, urlPath, inheritedMiddleware, pathParameters, config))
+  }
+  return routes
+}
+
+const importModules = async (config, dirPath, files) => Promise.all(
+  files
+    .filter(filterTestFiles(config))
+    .filter(filterIgnoredFiles(config))
+    .map(f => path.join(dirPath, f.name))
+    .map(mwPath => import(`file://${mwPath}`)
+      .then(module => ({ module, mwPath }))
+    ))
+
+const findRoutesInDir = async (name, filePath, urlPath, inheritedMiddleware, pathParameters, config) => {
+  if (isVariable(name)) {
+    pathParameters = pathParameters.concat(getVariableName(name))
+  }
+  const files = await readdir(filePath, { withFileTypes: true })
+
+  const middlewareModules = await importModules(config, filePath,
+    files.filter(f => f.name.endsWith('.mw.js') || f.name.endsWith('.mw.mjs'))
+  )
+  const dirMiddleware = middlewareModules.map(({ module, mwPath }) => {
+    const middleware = module.middleware || module.default?.middleware
+    if (!middleware) {
+      throw new Error(`${mwPath} must export a middleware property or have a middleware property on the default export`)
+    }
+    try {
+      validateMiddleware(middleware)
+    } catch (e) {
+      throw new Error('Failed to load middleware in file ' + mwPath + '\n' + e.message + '\n' + e.stack)
+    }
+    return middleware
+  })
+    .reduce((result, incoming) => mergeMiddleware(incoming, result), inheritedMiddleware)
+
+  return Promise.all(files
+    .filter(f => !f.name.endsWith('.mw.js') && !f.name.endsWith('.mw.mjs'))
+    .filter(filterTestFiles(config))
+    .filter(filterIgnoredFiles(config))
+    .map(
+      (f) => doFindRoutes(
+        config,
+        f,
+        path.join(filePath, f.name),
+        urlPath + '/' + getPathPart(name),
+        pathParameters,
+        dirMiddleware
+      )
+    ))
+    .then(routes => routes.flat())
+}
+
+const buildJSHandlerRoute = async (name, filePath, urlPath, inheritedMiddleware, pathParameters) => {
+  if (name.endsWith('.mjs')) {
+    name = name.substr(0, name.length - '.rt.mjs'.length)
+  } else {
+    name = name.substr(0, name.length - '.rt.js'.length)
+  }
+  if (isVariable(name)) {
+    pathParameters = pathParameters.concat(getVariableName(name))
+  }
+  const route = {
+    pathParameters,
+    urlPath: `${urlPath}/${getPathPart(name)}`,
+    filePath,
+    handlers: {}
+  }
+  const module = await import(`file://${filePath}`)
+  const handlers = module.default
+
+  route.middleware = mergeMiddleware(handlers.middleware || [], inheritedMiddleware)
+  for (const method of Object.keys(handlers).filter(k => !ignoreHandlerFields[k])) {
+    if (HTTP_METHODS.indexOf(method) === -1) {
+      throw new Error(`Method: ${method} in file ${filePath} is not a valid http method. It must be one of: ${HTTP_METHODS}. Method names must be all uppercase.`)
+    }
+    const loadedHandler = handlers[method]
+    let handler = loadedHandler
+    if (typeof loadedHandler.handler === 'function') {
+      handler = loadedHandler.handler
+    }
+    if (typeof handler !== 'function') {
+      throw new Error(`Request method ${method} in file ${filePath} must be a function. Got: ${handlers[method]}`)
+    }
+    if (!('streamRequestBody' in loadedHandler)) {
+      handler.streamRequestBody = handlers.streamRequestBody
+    } else {
+      handler.streamRequestBody = loadedHandler.streamRequestBody
+    }
+    route.handlers[method] = handler
+  }
+  return route
+}
+
+const buildStaticRoutes = (name, filePath, urlPath, inheritedMiddleware, pathParameters, config) => {
+  const routes = []
+  if (isVariable(name)) {
+    pathParameters = pathParameters.concat(getVariableName(name))
+  }
+  const contentType = getContentTypeByExtension(name, config.staticContentTypes)
+  const route = {
+    pathParameters,
+    urlPath: `${urlPath}/${getPathPart(name)}`,
+    filePath,
+    handlers: createStaticHandler(filePath, contentType, config.cacheStatic, config.staticCacheControl),
+    middleware: inheritedMiddleware
+  }
+
+  routes.push(route)
+
+  for (const ext of config.resolveWithoutExtension) {
+    if (name.endsWith(ext)) {
+      const strippedName = name.substr(0, name.length - ext.length)
+      // in the index case we need to add both the stripped and an empty path so it will resolve the parent
+      if (strippedName === 'index') {
+        const noExtRoute = Object.assign({}, route)
+        noExtRoute.urlPath = `${urlPath}/${strippedName}`
+        routes.push(noExtRoute)
+      }
+      const noExtRoute = Object.assign({}, route)
+      noExtRoute.urlPath = `${urlPath}/${getPathPart(strippedName)}`
+      routes.push(noExtRoute)
+    }
+  }
+  return routes
+}
+
+export async function findRoutes (config) {
+  const fullRouteDir = path.resolve(config.routeDir)
+  if (!fs.existsSync(fullRouteDir)) {
+    throw new Error(`can't find route directory: ${fullRouteDir}`)
+  }
+  const appMiddleware = mergeMiddleware(config.middleware || [], {})
+  const files = await readdir(fullRouteDir, { withFileTypes: true })
+  return Promise.all(files
+    .filter(filterTestFiles(config))
+    .filter(filterIgnoredFiles(config))
+    .map(
+      f => doFindRoutes(config, f, path.join(fullRouteDir, f.name), '', [], appMiddleware)
+    ))
+    .then(routes => routes.flat())
+}

package/src/server.mjs

@@ -0,0 +1,126 @@
+import log from './log.mjs'
+import { getNodeModuleRoutes } from './nodeModuleHandler.mjs'
+import uws from 'uWebSockets.js'
+import { createHandler, createNotFoundHandler } from './handler.mjs'
+import { findRoutes } from './routes.mjs'
+import path from 'path'
+import fs from 'fs'
+
+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 = (config, methods) => {
+  return createHandler(() => ({
+    headers: {
+      allow: methods
+    },
+    statusCode: 204
+  }),
+  [],
+  [],
+  config
+  )
+}
+
+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}`)
+    }
+  })
+}
+
+const getHttpsApp = (key, cert) => {
+  const keyPath = path.resolve(key)
+  const certPath = path.resolve(cert)
+  if (!fs.existsSync(keyPath)) throw new Error(`Can't find https key file: ${keyPath}`)
+  if (!fs.existsSync(certPath)) throw new Error(`Can't find https cert file: ${keyPath}`)
+  return uws.App({
+    key_file_name: keyPath,
+    cert_file_name: certPath
+  })
+}
+
+export async function startServer (config) {
+  if (!state.initialized) {
+    state.initialized = true
+    const routes = [...(await findRoutes(config)), ...getNodeModuleRoutes(config)]
+    let app, port
+    if (config.httpsKeyFile) {
+      app = getHttpsApp(config.secure)
+      port = config.secure.port || 14420
+      startHttpRedirect(config.host, config.port || 10420)
+    } else {
+      app = uws.App()
+      port = config.port || 10420
+    }
+
+    for (const route of routes) {
+      if (config.printRoutes) {
+        log.info('Configured Route: ', route)
+      }
+      const routePattern = `^${route.urlPath.replace(/:[^/]+/g, '[^/]+').replace(/\*/g, '.*')}$`
+      if (config.notFoundRoute && config.notFoundRoute.match(routePattern)) {
+        config.notFoundRouteHandler = route
+        route.statusCodeOverride = 404
+      }
+      if (config.defaultRoute && config.defaultRoute.match(routePattern)) {
+        config.defaultRouteHandler = route
+      }
+      for (const method in route.handlers) {
+        const theHandler = createHandler(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.urlPath.endsWith('/*')) {
+          app[appMethods[method]](route.urlPath.substr(0, route.urlPath.length - 2), theHandler)
+        }
+      }
+      if (!route.handlers.OPTIONS) {
+        app.options(route.urlPath, optionsHandler(config, Object.keys(route.handlers).join(', ')))
+      }
+    }
+
+    if (config.notFoundRoute && !config.notFoundRouteHandler) {
+      log.warn('No route matched not found route: ' + config.notFoundRoute)
+    }
+    if (config.defaultRoute && !config.defaultRouteHandler) {
+      log.warn('No route matched default route: ' + config.notFoundRoute)
+    }
+
+    app.any('/*', createNotFoundHandler(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}`)
+      }
+    })
+    return app
+  }
+}