@superhero/core 1.8.5 → 4.0.0-beta.1

package/http/server/dispatcher/error/request-timeout.js

@@ -1,12 +0,0 @@
-const HttpError = require('.')
-
-class RequestTimeout extends HttpError
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.status = 408
-  }
-}
-
-module.exports = RequestTimeout

package/http/server/dispatcher/error/server-error.js

@@ -1,12 +0,0 @@
-const HttpError = require('.')
-
-class ServerError extends HttpError
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.status = 500
-  }
-}
-
-module.exports = ServerError

package/http/server/dispatcher/error/service-unavailable.js

@@ -1,12 +0,0 @@
-const HttpError = require('.')
-
-class ServiceUnavailable extends HttpError
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.status = 503
-  }
-}
-
-module.exports = ServiceUnavailable

package/http/server/dispatcher/error/unauthorized.js

@@ -1,12 +0,0 @@
-const HttpError = require('.')
-
-class Unauthorized extends HttpError
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.status = 401
-  }
-}
-
-module.exports = Unauthorized

package/http/server/dispatcher/index.js

@@ -1,26 +0,0 @@
-const NotImplementedError = require('./error/not-implemented')
-
-class HttpDispatcher
-{
-  constructor(route, request, session, locator, view)
-  {
-    this.route    = route
-    this.request  = request
-    this.session  = session
-    this.locator  = locator
-    this.view     = view
-  }
-
-  dispatch()
-  {
-    const msg = '"dispatch" method is not implemented'
-    throw new NotImplementedError(msg)
-  }
-
-  onError(error)
-  {
-    throw error
-  }
-}
-
-module.exports = HttpDispatcher

package/http/server/dispatcher/rest.js

@@ -1,75 +0,0 @@
-const
-HttpDispatcher        = require('.'),
-BadRequestError       = require('./error/bad-request'),
-MethodNotAllowedError = require('./error/method-not-allowed'),
-NotImplementedError   = require('./error/not-implemented'),
-ServerError           = require('./error/server-error')
-
-class HttpDispatcherRest extends HttpDispatcher
-{
-  async dispatch()
-  {
-    const allowed = this.fetchAllowedMethods(this.route)
-
-    if(!allowed.includes(this.request.method))
-    {
-      this.view.headers['Allowed'] = allowed.join(',')
-      throw new MethodNotAllowedError(`Method not allowed: "${this.request.method}"`)
-    }
-
-    switch(this.request.method)
-    {
-      case 'OPTIONS':
-      {
-        this.view.headers['Allowed'] = allowed.join(',')
-        break
-      }
-      case 'GET'    :
-      case 'POST'   :
-      case 'PUT'    :
-      case 'DELETE' :
-      {
-        const action = this.request.method.toLowerCase()
-        await this[action]()
-        break
-      }
-      default :
-      {
-        const msg = `Unrecognized method "${method}", expected one of: "${allowed.join(',')}"`
-        throw new BadRequestError(msg)
-      }
-    }
-  }
-
-  fetchAllowedMethods(route)
-  {
-    if(!route.allowed)
-    {
-      throw new ServerError('No allowed methods are defined in the route')
-    }
-    if(!Array.isArray(route.allowed))
-    {
-      throw new ServerError('Allowed methods in route is not defined as an array')
-    }
-    if(!route.allowed.every((allowed) => typeof allowed === 'string'))
-    {
-      throw new ServerError('Allowed http method must be a set of strings')
-    }
-
-    const allowed = route.allowed.map((method) => method.toUpperCase())
-
-    if(!allowed.includes('OPTIONS'))
-    {
-      allowed.push('OPTIONS')
-    }
-
-    return allowed
-  }
-
-  get()     { throw new NotImplementedError }
-  post()    { throw new NotImplementedError }
-  put()     { throw new NotImplementedError }
-  delete()  { throw new NotImplementedError }
-}
-
-module.exports = HttpDispatcherRest

package/http/server/error/no-endpoint-defined-in-route.js

@@ -1,10 +0,0 @@
-class NoEndpointDefinedInRouteError extends Error
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.code = 'E_NO_ENDPOINT_DEFINED_IN_ROUTE'
-  }
-}
-
-module.exports = NoEndpointDefinedInRouteError

package/http/server/error/view-contract-not-honered.js

@@ -1,10 +0,0 @@
-class ViewContractNotHoneredError extends Error
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.code = 'E_VIEW_CONTRACT_NOT_HONERED'
-  }
-}
-
-module.exports = ViewContractNotHoneredError

package/http/server/index.js

@@ -1,195 +0,0 @@
-const
-NoEndpointDefinedInRouteError = require('./error/no-endpoint-defined-in-route'),
-ViewContractNotHoneredError   = require('./error/view-contract-not-honered')
-
-class HttpServer
-{
-  /**
-   * @param {http.Server} server
-   */
-  constructor(server, requestBuilder, sessionBuilder, routeBuilder,
-              dispatcherCollectionBuilder, dispatcherChain, configuration,
-              locator, eventbus, domainFactory)
-  {
-    this.server                       = server
-    this.requestBuilder               = requestBuilder
-    this.sessionBuilder               = sessionBuilder
-    this.routeBuilder                 = routeBuilder
-    this.dispatcherCollectionBuilder  = dispatcherCollectionBuilder
-    this.dispatcherChain              = dispatcherChain
-    this.configuration                = configuration
-    this.locator                      = locator
-    this.eventbus                     = eventbus
-    this.domainFactory                = domainFactory
-  }
-
-  listen(...args)
-  {
-    this.server.listen(...args)
-  }
-
-  onListening(done)
-  {
-    return this.server.listening
-    ? done()
-    : this.server.once('listening', done)
-  }
-
-  close()
-  {
-    return new Promise((accept, reject) =>
-      this.server.close((error) =>
-        error
-        ? reject(error)
-        : accept()))
-  }
-
-  onRequest(input, output)
-  {
-    const domain = this.domainFactory.create()
-
-    domain.add(input)
-    domain.add(output)
-
-    domain.on('error', this.onError.bind(this, input, output, domain))
-    input.on('aborted', this.onAborted.bind(this, output))
-    output.on('timeout', this.onTimeout.bind(this, output))
-    output.on('finish', this.onFinish .bind(this, input, output, domain))
-
-    domain.run(() => this.dispatch(input, output, domain))
-  }
-
-  onAborted(output)
-  {
-    output.end()
-  }
-
-  onFinish(input, output, domain)
-  {
-    let
-    emitters = 0,
-    timeouts = 0
-
-    for(const member of domain.members)
-      'removeAllListeners' in member
-      ? emitters++
-      : timeouts++
-
-    if(domain.members.length > 2)
-    {
-      const msg =
-      [
-        `Finished session did not clear all domain members!`,
-        `Expected: 2 (response and request)`,
-        `Recieved: ${domain.members.length}`,
-        `Emitters: ${emitters}`,
-        `Timeouts: ${timeouts}`
-      ].join('\n')
-
-      this.eventbus.emit('core.warning', msg)
-    }
-
-    domain.exit()
-    domain.removeAllListeners()
-    input .removeAllListeners()
-    output.removeAllListeners()
-  }
-
-  onTimeout(output)
-  {
-    output.writeHead(408)
-    output.end('Request Timeout')
-  }
-
-  onError(input, output, domain, error)
-  {
-    switch(error.code)
-    {
-      case 'E_HTTP_DISPATCHER':
-      {
-        output.writeHead(error.status)
-        output.end(error.message)
-        break
-      }
-      case 'E_NO_ENDPOINT_DEFINED_IN_ROUTE':
-      {
-        this.eventbus.emit('core.error', error)
-
-        output.writeHead(404)
-        output.end('Endpoint Not Found')
-        break
-      }
-      default:
-      {
-        this.eventbus.emit('core.error', error)
-
-        output.writeHead(500)
-        output.end('Internal Server Error')
-        break
-      }
-    }
-  }
-
-  async dispatch(input, output, domain)
-  {
-    const
-    routes    = this.configuration.find('http.server.routes'),
-    session   = await this.sessionBuilder.build(input, output, domain),
-    request   = await this.requestBuilder.build(input),
-    route     = await this.routeBuilder.build(routes, request),
-    viewModel = this.createViewModel()
-
-    if(!route.endpoint)
-    {
-      const msg = `No endpoint defined in route for the request: ${request.method} -> ${request.url}`
-      throw new NoEndpointDefinedInRouteError(msg)
-    }
-
-    const dispatchers = await this.dispatcherCollectionBuilder.build(route, request, session, viewModel)
-    await this.dispatcherChain.dispatch(dispatchers)
-
-    if(!output.finished)
-    {
-      output.writeProcessing()
-
-      const
-      viewType  = viewModel.meta.view || route.view || 'http/server/view',
-      view      = this.locator.locate(viewType)
-
-      if(typeof view.write !== 'function')
-      {
-        const msg = `The service "${viewType}" does not honer the view contract`
-        throw new ViewContractNotHoneredError(msg)
-      }
-
-      await view.write(output, viewModel, route)
-    }
-  }
-
-  /**
-   * Allowing the body to be set, in order to be able to have arrays and strings as a response body
-   * @returns {Object} frozen
-   */
-  createViewModel()
-  {
-    let body = {}
-
-    const viewModel =
-    {
-      get body()
-      {
-        return body
-      },
-      set body(_body)
-      {
-        body = _body
-      },
-      headers : {},
-      meta    : {}
-    }
-
-    return Object.freeze(viewModel)
-  }
-}
-
-module.exports = HttpServer

package/http/server/locator.js

@@ -1,34 +0,0 @@
-const HttpServer = require('.')
-
-class HttpServerLocator
-{
-  constructor(locator)
-  {
-    this.locator = locator
-  }
-
-  locate()
-  {
-    const
-    configuration               = this.locator.locate('configuration'),
-    serverOptions               = configuration.find('http.server.options'),
-    server                      = require('http').createServer(serverOptions),
-    requestBuilder              = this.locator.locate('http/server/request/builder'),
-    sessionFactory              = this.locator.locate('http/server/session/builder'),
-    routeBuilder                = this.locator.locate('http/server/route/builder'),
-    dispatcherCollectionBuilder = this.locator.locate('http/server/dispatcher/collection/builder'),
-    dispatcherChain             = this.locator.locate('http/server/dispatcher/chain'),
-    eventbus                    = this.locator.locate('eventbus'),
-    domainFactory               = require('domain'),
-    httpServer                  = new HttpServer(server, requestBuilder, sessionFactory, routeBuilder,
-                                                 dispatcherCollectionBuilder, dispatcherChain, configuration,
-                                                 this.locator, eventbus, domainFactory)
-
-    server.timeout = configuration.find('http.server.timeout')
-    server.on('request', httpServer.onRequest.bind(httpServer))
-
-    return httpServer
-  }
-}
-
-module.exports = HttpServerLocator

package/http/server/request/builder/index.js

@@ -1,53 +0,0 @@
-const
-url         = require('url'),
-querystring = require('querystring')
-
-class HttpRequestBuilder
-{
-  constructor(deepfreeze)
-  {
-    this.deepfreeze = deepfreeze
-  }
-
-  async build(input)
-  {
-    const
-    parsedUrl = url.parse(input.url, true),
-    request   =
-    {
-      headers : input.headers,
-      method  : input.method.toUpperCase(),
-      url     : parsedUrl.pathname.replace(/\/+$/g, ''),
-      query   : parsedUrl.query,
-      body    : await this.fetchBody(input)
-    }
-
-    return this.deepfreeze.freeze(request)
-  }
-
-  async fetchBody(input)
-  {
-    return new Promise((accept, reject) =>
-    {
-      let body = ''
-
-      input.on('error',  reject)
-      input.on('data',   (data)  => body += data)
-      input.on('end',    ()      => this.parseBody(input.headers['content-type'], body).then(accept).catch(reject))
-    })
-  }
-
-  async parseBody(contentType, body)
-  {
-    switch(contentType)
-    {
-      case 'application/json':
-        return JSON.parse(body || '{}')
-
-      default:
-        return querystring.parse(body)
-    }
-  }
-}
-
-module.exports = HttpRequestBuilder

package/http/server/request/builder/locator.js

@@ -1,20 +0,0 @@
-const HttpRequestBuilder = require('.')
-
-class HttpRequestBuilderLocator
-{
-  constructor(locator)
-  {
-    this.locator = locator
-  }
-
-  locate()
-  {
-    const
-    deepfreeze          = this.locator.locate('deepfreeze'),
-    httpRequestBuilder  = new HttpRequestBuilder(deepfreeze)
-
-    return httpRequestBuilder
-  }
-}
-
-module.exports = HttpRequestBuilderLocator

package/http/server/route/builder/error/dto-invalid-reference.js

@@ -1,10 +0,0 @@
-class DtoInvalidReferenceError extends ReferenceError
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.code = 'E_DTO_INVALID_REFERENCE'
-  }
-}
-
-module.exports = DtoInvalidReferenceError

package/http/server/route/builder/error/routes-invalid-type.js

@@ -1,10 +0,0 @@
-class RoutesInvalidTypeError extends TypeError
-{
-  constructor(...args)
-  {
-    super(...args)
-    this.code = 'E_ROUTES_INVALID_TYPE'
-  }
-}
-
-module.exports = RoutesInvalidTypeError

package/http/server/route/builder/index.js

@@ -1,88 +0,0 @@
-const
-RoutesInvalidTypeError    = require('./error/routes-invalid-type'),
-DtoInvalidReferenceError  = require('./error/dto-invalid-reference')
-
-class HttpRouteBuilder
-{
-  constructor(deepmerge)
-  {
-    this.deepmerge = deepmerge
-  }
-
-  build(routes, request)
-  {
-    if(typeof routes !== 'object')
-    {
-      throw new RoutesInvalidTypeError(`routes must be built from an object`)
-    }
-
-    const
-    validRoutes = this.fetchValidRoutes(routes, request),
-    route       = this.deepmerge.merge({}, ...validRoutes)
-
-    route.dto = this.composeDto(request, route.dto)
-
-    return route
-  }
-
-  fetchValidRoutes(routes, request)
-  {
-    const validRoutes = []
-    for(const name in routes)
-    {
-      const
-      route   = routes[name],
-      url     = route.url     && new RegExp(`^${route.url.replace(/\/+$/g, '')}$`),
-      method  = route.method  && new RegExp(`^${route.method}$`, 'i')
-
-      if(request.url    .match(url)
-      && request.method .match(method))
-      {
-        validRoutes.push(route)
-
-        // once we found an endpoint, the route is completed
-        if(route.endpoint)
-        {
-          break
-        }
-      }
-    }
-    return validRoutes
-  }
-
-  composeDto(request, map)
-  {
-    const dto = {}
-    for(const key in map)
-      for(const type in map[key])
-        switch(type)
-        {
-          case 'body':
-          {
-            const body_key = map[key][type]
-            dto[key] = request.body[body_key]
-            break
-          }
-          case 'url':
-          {
-            const url_index = parseInt(map[key][type])
-            dto[key] = request.url.split('/')[url_index]
-            break
-          }
-          case 'query':
-          {
-            const query_key = map[key][type]
-            dto[key] = request.query[query_key]
-            break
-          }
-          default:
-          {
-            throw new DtoInvalidReferenceError(`type "${type}" is not recognized for request to DTO mapping`)
-          }
-        }
-
-    return dto
-  }
-}
-
-module.exports = HttpRouteBuilder

package/http/server/route/builder/locator.js

@@ -1,20 +0,0 @@
-const HttpRouteBuilder = require('.')
-
-class HttpRouteBuilderLocator
-{
-  constructor(locator)
-  {
-    this.locator = locator
-  }
-
-  locate()
-  {
-    const
-    deepmerge = this.locator.locate('deepmerge'),
-    builder   = new HttpRouteBuilder(deepmerge)
-
-    return builder
-  }
-}
-
-module.exports = HttpRouteBuilderLocator

package/http/server/session/builder/index.js

@@ -1,34 +0,0 @@
-const Cookies = require('cookies')
-
-class SessionBuilder
-{
-  build(request, response, domain)
-  {
-    let cookies
-
-    const session =
-    {
-      domain,
-
-      request,
-
-      response,
-
-      set cookies(value)
-      {
-        throw new Error('"cookies" can not be set on session, protected member')
-      },
-
-      get cookies()
-      {
-        return cookies
-        ? cookies
-        : cookies = new Cookies(request, response)
-      }
-    }
-
-    return session
-  }
-}
-
-module.exports = SessionBuilder

package/http/server/session/builder/locator.js

@@ -1,11 +0,0 @@
-const SessionBuilder = require('.')
-
-class SessionBuilderLocator
-{
-  locate()
-  {
-    return new SessionBuilder
-  }
-}
-
-module.exports = SessionBuilderLocator

package/http/server/view/index.js

@@ -1,12 +0,0 @@
-class HttpView
-{
-  write(output, viewModel)
-  {
-    viewModel.headers['Content-Length'] = Buffer.byteLength(viewModel.body)
-
-    output.writeHead(viewModel.meta.status || 200, viewModel.headers)
-    output.end(viewModel.body)
-  }
-}
-
-module.exports = HttpView

package/http/server/view/json/index.js

@@ -1,17 +0,0 @@
-class HttpViewJson
-{
-  write(output, viewModel, route)
-  {
-    const body = viewModel.meta.pretty || route.pretty
-    ? JSON.stringify(viewModel.body, null, 2)
-    : JSON.stringify(viewModel.body)
-
-    viewModel.headers['Content-Type']   = 'application/json'
-    viewModel.headers['Content-Length'] = Buffer.byteLength(body)
-
-    output.writeHead(viewModel.meta.status || 200, viewModel.headers)
-    output.end(body)
-  }
-}
-
-module.exports = HttpViewJson