@superhero/http-server-using-oas 4.7.2

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Erik Landvall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/config.json

@@ -0,0 +1,49 @@
+{
+  "dependency":
+  {
+    "@superhero/http-server": true
+  },
+  "locator":
+  {
+    "@superhero/http-server-using-oas":
+    {
+      "uses":
+      [
+        "@superhero/oas",
+        "@superhero/http-server"
+      ]
+    },
+    "@superhero/http-server-using-oas/dispatcher/options":
+    {
+      "path": "./dispatcher/options.js",
+      "uses": [ "@superhero/http-server-using-oas" ]
+    },
+    "@superhero/http-server-using-oas/dispatcher/upstream/parameters":
+    {
+      "path": "./dispatcher/upstream/parameters.js",
+      "uses": [ "@superhero/http-server-using-oas" ]
+    },
+    "@superhero/http-server-using-oas/dispatcher/upstream/request-bodies":
+    {
+      "path": "./dispatcher/upstream/request-bodies.js",
+      "uses": [ "@superhero/http-server-using-oas" ]
+    },
+    "@superhero/http-server-using-oas/dispatcher/downstream/responses":
+    {
+      "path": "./dispatcher/downstream/responses.js",
+      "uses": [ "@superhero/http-server-using-oas" ]
+    }
+  },
+  "oas":
+  {
+    "components": 
+    {
+      "headers"       : {},
+      "parameters"    : {},
+      "requestBodies" : {},
+      "responses"     : {},
+      "schemas"       : {}
+    },
+    "paths": {}
+  }
+}

package/dispatcher/downstream/responses.js

@@ -0,0 +1,46 @@
+export function locate(locator)
+{
+  const oas = locator('@superhero/oas')
+  return new ResponsesMiddleware(oas)
+}
+
+export default class ResponsesMiddleware
+{
+  constructor(oas)
+  {
+    this.oas = oas
+  }
+
+  async dispatch(request, session)
+  {
+    await session.chain.next()
+
+    if(false === !!session.abortion.signal.aborted)
+    {
+      const 
+        status    = session.view.status,
+        responses = session.route.operation.responses
+
+      if(status in responses)
+      {
+        this.oas.responses.conform(responses[status], session.view)
+      }
+      else
+      {
+        const error = new Error(`Invalid status code: ${status}`)
+        error.code  = 'E_OAS_INVALID_RESPONSE_STATUS'
+        error.cause = `The operation supports status codes: ${Object.keys(responses).join(', ')}`
+        throw error
+      }
+    }
+  }
+
+  onError(reason, request, session)
+  {
+    const error   = new Error(`Invalid response for operation ${request.method} ${request.url}`)
+    error.code    = 'E_OAS_INVALID_RESPONSE'
+    error.status  = 400
+    error.cause   = reason
+    session.abortion.abort(error)
+  }
+}

package/dispatcher/options.js

@@ -0,0 +1,201 @@
+export function locate(locator)
+{
+  const specification = locator.config.find('oas')
+  return new OptionsDispatcher(specification)
+}
+
+export default class OptionsDispatcher
+{
+  constructor(specification)
+  {
+    this.specification = specification
+  }
+
+  dispatch(request, session)
+  {
+    const [ validResource, ...validOperations ] = session.route.operation.operationId.split('#')
+    const
+      output        = {},
+      components    = {},
+      paths         = {},
+      parameters    = {},
+      requestBodies = {},
+      responses     = {},
+      schemas       = {},
+      depth         = request.url.pathname.split('/').length
+
+    // Loop through all paths in the OpenAPI Specification and find the ones that 
+    // match the defined operation, or the beginning of the request path if no operation is defined...
+    for(const path in this.specification.paths || {})
+    {
+      let valid = false
+
+      // validate the path depending on if the operation-id specify a specific operation, or not...
+      if(validResource)
+      {
+        valid = validResource === path
+      }
+      // validate the beginning of the request path if no specific operation is defined...
+      else
+      {
+        const
+          partial = path.split('/').slice(0, depth).join('/'),
+          regexp  = partial.replace(/{[^}]+}/g, '([^/]*)')
+
+        valid = new RegExp(`^${regexp}$`).test(request.url.pathname)
+      }
+
+      // Only include a scoped version of the specification
+      if(valid)
+      {
+        paths[path] = { ...this.specification.paths[path] }
+
+        // Operations
+        for(let method in paths[path])
+        {
+          const lowerCasedMethod = method.toLowerCase()
+
+          switch(lowerCasedMethod)
+          {
+            case 'get':
+            case 'put':
+            case 'post':
+            case 'delete':
+            case 'options':
+            case 'head':
+            case 'patch':
+            case 'trace':
+            {
+              if(validOperations.langth === 0 // if not specified, then not concidered restrictive...
+              || validOperations.map(validMethod => validMethod.toLowerCase()).includes(lowerCasedMethod))
+              {
+                // break to proceed to process
+                break
+              }
+              else
+              {
+                // hide restricted methods
+                delete paths[path][method]
+                continue
+              }
+            }
+            default:
+            {
+              // ignore any non HTTP method
+              continue
+            }
+          }
+
+          const operation = paths[path][method]
+
+          // Parameters
+          for(let parameter of operation.parameters || [])
+          {
+            parameter = this.#augment(parameters, parameter.$ref) || parameter
+            // Parameters - schemas
+            this.#augmentSchemasRecursively(schemas, parameter.schema)
+          }
+
+          // Request Bodies
+          let 
+          requestBody = operation.requestBody || {}
+          requestBody = this.#augment(requestBodies, requestBody.$ref) || requestBody
+          this.#augment(requestBodies, requestBody.$ref)
+          // Request Bodies - schemas
+          for(const contentType in requestBody.content || {})
+          {
+            this.#augmentSchemasRecursively(schemas, operation.requestBody.content[contentType].schema)
+          }
+
+          // Responses
+          for(const status in operation.responses || {})
+          {
+            let
+            response = operation.responses[status] || {}
+            response = this.#augment(responses, response.$ref) || response
+            // Responses - schemas
+            for(const contentType in response.content || {})
+            {
+              this.#augmentSchemasRecursively(schemas, response.content[contentType].schema)
+            }
+          }
+        }
+      }
+    }
+
+    // Aport with a 404 error if no paths were found in the specification
+    if(false === Object.keys(paths).length)
+    {
+      const error  = new Error(`No endpoints found matching the requested path "${request.url.pathname}"`)
+      error.code   = 'E_OAS_NO_ENDPOINTS_FOUND'
+      error.status = 404
+      return session.abortion.abort(error)
+    }
+
+    output.openapi  = this.specification.openapi
+    output.info     = this.specification.info
+    output.paths    = paths
+
+    if(Object.keys(parameters)    .length)  components.parameters     = parameters
+    if(Object.keys(requestBodies) .length)  components.requestBodies  = requestBodies
+    if(Object.keys(responses)     .length)  components.responses      = responses
+    if(Object.keys(schemas)       .length)  components.schemas        = schemas
+    if(Object.keys(components)    .length)  output.components         = components
+
+    this.view.body = output
+  }
+
+  #augment(component, ref)
+  {
+    // only augment if the reference is defined
+    if('string' !== typeof ref) return
+
+    const [ uri, pointer ] = ref.split('#')
+
+    // only augment local references
+    if(true === !!uri) return
+
+    // component name
+    const name = pointer.split('/').pop()
+
+    // avoid redundant traversals and augmentations
+    if(name in component) return
+
+    // augment the component with the branch at the traversed pointer in the specification
+    const traversePath = pointer.split('/').filter(Boolean)
+    return component[name] = traversePath.reduce((obj, key) => obj && obj[key], this.specification)
+  }
+
+  #augmentSchemasRecursively(component, schema)
+  {
+    // avoid undefined schemas
+    if(false === !!schema) return
+    // loop through the schemas if it is an array
+    if(Array.isArray(schema)) return schema.forEach(schema => this.#augmentSchemasRecursively(component, schema))
+    // replace the schema with the augmented one, if the schema defined a reference
+    if(schema.$ref) schema = this.#augment(component, schema.$ref)
+    // avoid redundant processing
+    if(false === !!schema) return
+
+    this.#augmentSchemasRecursively(component, Object.values(schema.properties || {}))
+    this.#augmentSchemasRecursively(component, schema.additionalProperties)
+    this.#augmentSchemasRecursively(component, schema.propertyNames)
+    this.#augmentSchemasRecursively(component, schema.items)
+    this.#augmentSchemasRecursively(component, schema.allOf)
+    this.#augmentSchemasRecursively(component, schema.anyOf)
+    this.#augmentSchemasRecursively(component, schema.oneOf)
+    this.#augmentSchemasRecursively(component, schema.if)
+    this.#augmentSchemasRecursively(component, schema.not)
+    this.#augmentSchemasRecursively(component, schema.then)
+    this.#augmentSchemasRecursively(component, schema.else)
+  }
+
+  onError(reason, _, session)
+  {
+    const error  = new Error(`Server error occured while attempting to declare API options`)
+    error.code   = 'E_OAS_INVALID_REQUEST_PARAMETERS'
+    error.cause  = reason
+    error.status = 500
+    session.abortion.abort(error)
+  }
+}

package/dispatcher/upstream/parameters.js

@@ -0,0 +1,35 @@
+export function locate(locator)
+{
+  const oas = locator('@superhero/oas')
+  return new ParametersMiddleware(oas)
+}
+
+export default class ParametersMiddleware
+{
+  constructor(oas)
+  {
+    this.oas = oas
+  }
+
+  dispatch(request, session)
+  {
+    const parameters = session.route.operation.parameters
+
+    if(parameters)
+    {
+      for(const parameter of parameters)
+      {
+        this.oas.parameters.conform(parameter, request)
+      }
+    }
+  }
+
+  onError(reason, request, session)
+  {
+    const error  = new Error(`Invalid request-parameters for operation ${request.method} ${request.url}`)
+    error.code   = 'E_OAS_INVALID_REQUEST_PARAMETERS'
+    error.cause  = reason
+    error.status = 400
+    session.abortion.abort(error)
+  }
+}

package/dispatcher/upstream/request-bodies.js

@@ -0,0 +1,28 @@
+export function locate(locator)
+{
+  const oas = locator('@superhero/oas')
+  return new RequestBodiesMiddleware(oas)
+}
+
+export default class RequestBodiesMiddleware
+{
+  constructor(oas)
+  {
+    this.oas = oas
+  }
+
+  dispatch(request, session)
+  {
+    const requestBody = session.route.operation.requestBody
+    requestBody && this.oas.requestBodies.conform(requestBody, request)
+  }
+
+  onError(reason, request, session)
+  {
+    const error  = new Error(`Invalid request-body for operation ${request.method} ${request.url}`)
+    error.code   = 'E_OAS_INVALID_REQUEST_BODY'
+    error.cause  = reason
+    error.status = 400
+    session.abortion.abort(error)
+  }
+}

package/index.js

@@ -0,0 +1,135 @@
+export async function locate(locator)
+{
+  const
+    server  = locator.locate('@superhero/http-server'),
+    oas     = locator.locate('@superhero/oas')
+
+  return new HttpServerUsingOas(server, oas)
+}
+
+/** 
+ * A class that integrates the HTTP server and OAS (OpenAPI Specification) components.
+ * Use the service to set routes based off the configiured OAS specifications.
+ */
+export default class HttpServerUsingOas
+{
+  /**
+   * @param {@superhero/http-server} server - The HTTP server instance.
+   * @param {@superhero/oas} oas - The OpenAPI Specification instance.
+   */
+  constructor(server, oas)
+  {
+    this.server = server
+    this.oas    = oas
+  }
+
+  /**
+   * Set a route by mapping an OpenAPI operation to a dispatcher.
+   * 
+   * @param {string} path - The operation to validate.
+   * @param {string} method - The HTTP method of the operation.
+   * @param {string} dispatcher - The dispatcher to handle the operation.
+   * @param {Array<string>} [middlewares=[]] - Optional middlewares to apply to the route.
+   * 
+   * @throws {TypeError}  - E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_PATH
+   * @throws {TypeError}  - E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_METHOD
+   * @throws {TypeError}  - E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_DISPATCHER
+   * @throws {Error}      - E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_OPERATION
+   * @throws {Error}      - E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_CONTENT_TYPE
+   */
+  setOasRoute(path, method, dispatcher, middlewares = [])
+  {
+    if('string' !== typeof path)
+    {
+      const error = new TypeError(`The path must be a string, received ${typeof path}`)
+      error.code  = 'E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_PATH'
+      throw error
+    }
+
+    if('string' !== typeof method)
+    {
+      const error = new TypeError(`The method must be a string, received ${typeof method}`)
+      error.code  = 'E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_METHOD'
+      throw error
+    }
+
+    if(false === !!dispatcher)
+    {
+      const error = new TypeError(`The dispatcher must be set when setting an OAS route`)
+      error.code  = 'E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_DISPATCHER'
+      throw error
+    }
+
+    method = method.toLowerCase()
+
+    const route = { dispatcher, conditions:[], middlewares:[] }
+    let operation
+
+    try
+    {
+      operation = this.oas.specification.paths[path][method]
+      this.oas.validateOperation(operation)
+      operation = this.oas.denormalizeOperation(operation)
+    }
+    catch(reason)
+    {
+      const error = new Error(`Invalid method "${method}" in path "${path}"`)
+      error.code  = 'E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_OPERATION'
+      error.cause = reason
+      throw error
+    }
+
+    route['condition.method'] = method
+    route.conditions.push('@superhero/http-server/condition/upstream/method')
+
+    if(operation.requestBody?.content)
+    {
+      const supportedContentTypes     = Object.keys(operation.requestBody.content)
+      route['condition.content-type'] = supportedContentTypes
+
+      for(const supportedContentType of supportedContentTypes)
+      {
+        route['content-type.' + supportedContentType] = this.requestBodyContentTypeRouteMap(supportedContentType)
+      }
+
+      route.conditions.push('@superhero/http-server/condition/upstream/header/content-type')
+      route.middlewares.push('@superhero/http-server/dispatcher/upstream/header/content-type')
+    }
+
+    route.condition = path.replace(/\{([^}]+)\}/g, ':$1')
+    route.middlewares.push('@superhero/http-server-using-oas/dispatcher/upstream/parameters')
+    route.middlewares.push('@superhero/http-server-using-oas/dispatcher/upstream/request-bodies')
+    route.middlewares.push('@superhero/http-server-using-oas/dispatcher/downstream/responses')
+    route.middlewares.push(...[middlewares].flat())
+
+    Object.defineProperty(route, 'operation', { value: operation })
+
+    this.server.router.set(`${method} ${path}`, route)
+  }
+
+  /**
+   * Returns a middleware that can be used to resolve the content-type of the request-body.
+   * 
+   * @param {string} supportedContentType - The content type to map.
+   * @returns {string} - The middleware path to handle the request body content-type.
+   * 
+   * @throws {Error} - E_OAS_UNSUPPORTED_CONTENT_TYPE
+   */
+  requestBodyContentTypeRouteMap(supportedContentType)
+  {
+    switch(supportedContentType)
+    {
+      case 'application/json': 
+      {
+        return '@superhero/http-server/dispatcher/upstream/header/content-type/' + supportedContentType
+      }
+      default:
+      {
+        const error = new Error(`Unsupported content type "${supportedContentType}" in request body`)
+        error.code  = 'E_HTTP_SERVER_USING_OAS_SET_ROUTE_INVALID_CONTENT_TYPE'
+        error.cause = `For the moment, the only request body supported has content-type: "application/json"`
+        throw error 
+      }
+    }
+  }
+}

package/index.test.js

@@ -0,0 +1,279 @@
+import Core     from '@superhero/core'
+import Request  from '@superhero/http-request'
+import assert   from 'node:assert'
+import util     from 'node:util'
+import { suite, test, beforeEach } from 'node:test'
+
+util.inspect.defaultOptions.depth = 3
+
+suite('@superhero/http-server-using-oas', () => 
+{
+  let core
+
+  beforeEach(async () => 
+  {
+    if(beforeEach.skip)
+    {
+      return
+    }
+
+    if(core)
+    {
+      await core.destroy()
+    }
+
+    core = new Core()
+    await core.add('@superhero/oas')
+    await core.add('@superhero/http-server')
+    await core.add('@superhero/http-server-using-oas')
+
+    core.locate.set('placeholder', { dispatch: () => 'placeholder' })
+  })
+
+  test('Can set a simple specification', async () => 
+  {
+    const specification = 
+      { paths:
+        { '/foo': 
+          { get:  { responses: { 200: {} }},
+            post: { responses: { 200: {} }}
+          },
+          '/bar':
+          { put:  { responses: { 200: {} }} }}}
+
+    core.locate.config.assign({ oas:specification })
+
+    await core.bootstrap()
+
+    const oas = core.locate('@superhero/http-server-using-oas')
+    oas.setOasRoute('/foo', 'get',  'placeholder')
+    oas.setOasRoute('/foo', 'post', 'placeholder')
+    oas.setOasRoute('/bar', 'put',  'placeholder')
+
+    assert.ok(oas.server.router.has('get /foo'),  'Route for "get /foo" should be added')
+    assert.ok(oas.server.router.has('post /foo'), 'Route for "post /foo" should be added')
+    assert.ok(oas.server.router.has('put /bar'),  'Route for "put /bar" should be added')
+  })
+
+  test('Can add middleware for requestBody content', async () => 
+  {
+    const specification =
+      { paths:
+        { '/foo':
+          { post:
+            { requestBody : { content: { 'application/json': {} } },
+              responses   : { 200: {} } }}}}
+
+    core.locate.config.assign({ oas:specification })
+    await core.bootstrap()
+    const oas = core.locate('@superhero/http-server-using-oas')
+    
+    oas.setOasRoute('/foo', 'post', 'placeholder')
+
+    const
+      route                 = oas.server.router.get('post /foo'),
+      requestBodyMiddleware = core.locate('@superhero/http-server-using-oas/dispatcher/upstream/request-bodies'),
+      hasRequestBodies      = route.route.middlewares.includes(requestBodyMiddleware)
+
+    assert.ok(hasRequestBodies, 'Middleware for requestBody should be added')
+    assert.equal(
+      route.route['content-type.application/json'],
+      '@superhero/http-server/dispatcher/upstream/header/content-type/application/json')
+  })
+
+  test('Can add middleware for parameters', async () => 
+  {
+    const specification = 
+      { paths: 
+        { '/foo': 
+          { get: 
+            { parameters  : [],
+              responses   : { 200: {} } }}}}
+
+    core.locate.config.assign({ oas:specification })
+    await core.bootstrap()
+    const oas = core.locate('@superhero/http-server-using-oas')
+
+    oas.setOasRoute('/foo', 'get', 'placeholder')
+
+    const
+      route                 = oas.server.router.get('get /foo'),
+      parametersMiddleware  = core.locate('@superhero/http-server-using-oas/dispatcher/upstream/parameters'),
+      hasParameters         = route.route.middlewares.includes(parametersMiddleware)
+
+    assert.ok(hasParameters, 'Middleware for parameters should be added')
+  })
+
+  test('Specification with reference to components', async sub => 
+  {
+    const specification =
+      { components:
+        { headers:
+          { ContentType: 
+            { required: true, 
+              schema: { type: 'string' }}
+          },
+          parameters:
+          { DefaultFoo:   { name: 'foo', in: 'query',  required: true,  schema: { '$ref': '#/components/schemas/String' }, nullable: true, default: null },
+            RequiredFoo:  { name: 'foo', in: 'query',  required: true,  schema: { '$ref': '#/components/schemas/String' }},
+            PathFoo:      { name: 'foo', in: 'path',   required: true,  schema: { '$ref': '#/components/schemas/String' }},
+            QueryFoo:     { name: 'foo', in: 'query',  required: false, schema: { '$ref': '#/components/schemas/String' }},
+            HeaderFoo:    { name: 'foo', in: 'header', required: false, schema: { '$ref': '#/components/schemas/String' }}
+          },
+          requestBodies:
+          { ExampleRequestBody: { '$ref': '#/components/requestBodies/GenericRequestBody' },
+            GenericRequestBody:
+            { required: true,
+              content: { 'application/json': { schema: { '$ref': '#/components/schemas/Foo' }}}}
+          },
+          responses:
+          { SuccessResult:
+            { description: 'Successful result',
+              headers: { 'Content-Type': { '$ref': '#/components/headers/ContentType' }},
+              content: { 'application/json': { schema: { '$ref': '#/components/schemas/Result' }}}
+            },
+            BadRequest:
+            { description: 'Bad Request',
+              schema: { '$ref': '#/components/schemas/Result' }}
+          },
+          schemas:
+          { String: { type: 'string' },
+            Foo:
+            { type: 'object',
+              properties: { foo: { '$ref': '#/components/schemas/String' }}},
+            Result:
+            { type: 'object',
+              properties: { result: { '$ref': '#/components/schemas/String' } }}
+          }
+        },
+        paths:
+        { '/example/default':
+          { get:
+            { parameters: [{ '$ref': '#/components/parameters/DefaultFoo' }],
+              responses:
+              { 200: { '$ref': '#/components/responses/SuccessResult' },
+                400: { '$ref': '#/components/responses/BadRequest' }}}
+          },
+          '/example/required':
+          { get:
+            { parameters: [{ '$ref': '#/components/parameters/RequiredFoo' }],
+              responses:
+              { 200: { '$ref': '#/components/responses/SuccessResult' },
+                400: { '$ref': '#/components/responses/BadRequest' }}}
+          },
+          '/example/foo/{foo}':
+          { get:
+            { parameters: [{ '$ref': '#/components/parameters/PathFoo' }],
+              responses:
+              { 200: { '$ref': '#/components/responses/SuccessResult' },
+                400: { '$ref': '#/components/responses/BadRequest' }}}
+          },
+          '/example':
+          { get:
+            { parameters:
+              [ { '$ref': '#/components/parameters/QueryFoo'  },
+                { '$ref': '#/components/parameters/HeaderFoo' }
+              ],
+              responses:
+              { 200: { '$ref': '#/components/responses/SuccessResult' },
+                400: { '$ref': '#/components/responses/BadRequest' }}
+            },
+            post:
+            { requestBody: { '$ref': '#/components/requestBodies/ExampleRequestBody' },
+              responses:
+              { 200: { '$ref': '#/components/responses/SuccessResult' },
+                400: { '$ref': '#/components/responses/BadRequest' }}}}}}
+
+    core.locate.config.assign({ oas:specification })
+    await core.bootstrap()
+    const oas = core.locate('@superhero/http-server-using-oas')
+    const
+      dispatcher1 = { dispatch: (request, session) => session.view.body.result = request.param.foo },
+      dispatcher2 = { dispatch: (request, session) => session.view.body.result = request.body.foo  }
+
+    core.locate.set('test/dispatcher/1', dispatcher1)
+    core.locate.set('test/dispatcher/2', dispatcher2)
+
+    oas.setOasRoute('/example',           'get',  'test/dispatcher/1')
+    oas.setOasRoute('/example',           'post', 'test/dispatcher/2')
+    oas.setOasRoute('/example/foo/{foo}', 'get',  'test/dispatcher/1')
+    oas.setOasRoute('/example/required',  'get',  'placeholder')
+    oas.setOasRoute('/example/default',   'get',  'placeholder')
+
+    const
+      route                     = oas.server.router.get('get /example'),
+      parametersMiddleware      = core.locate('@superhero/http-server-using-oas/dispatcher/upstream/parameters'),
+      requestBodiesMiddleware   = core.locate('@superhero/http-server-using-oas/dispatcher/upstream/request-bodies'),
+      responsesMiddleware       = core.locate('@superhero/http-server-using-oas/dispatcher/downstream/responses')
+
+    assert.ok(route, 'route for "get /example" should exist')
+    assert.ok(route.route.middlewares.includes(parametersMiddleware))
+    assert.ok(route.route.middlewares.includes(requestBodiesMiddleware))
+    assert.ok(route.route.middlewares.includes(responsesMiddleware))
+
+    assert.equal(route.route['condition.method'], 'get', 'Correct GET method condition')
+
+    const httpServer = core.locate('@superhero/http-server')
+    await httpServer.listen()
+
+    beforeEach.skip = true
+
+    await sub.test('GET method using default parameter query parameter', async () =>
+    {
+      const
+        baseUrl   = `http://localhost:${httpServer.gateway.address().port}`,
+        request   = new Request({ url: baseUrl, doNotThrowOnErrorStatus: true }),
+        response  = await request.get({ url: '/example/default?foo=query', headers: { 'connection': 'close', 'content-type': 'application/json' }})
+
+      assert.equal(response.status, 200, '200 status code for GET method')
+      assert.equal(response.body.result, null, 'Correct response body for GET method')
+    })
+
+    await sub.test('GET method not using required parameter', async () =>
+    {
+      const
+        baseUrl   = `http://localhost:${httpServer.gateway.address().port}`,
+        request   = new Request({ url: baseUrl, doNotThrowOnErrorStatus: true }),
+        response  = await request.get({ url: '/example/required', headers: { 'connection': 'close', 'content-type': 'application/json' }})
+
+      assert.equal(response.status, 400, '400 status code for GET method')
+    })
+
+    await sub.test('GET method using bar parameter', async () =>
+    {
+      const
+        baseUrl   = `http://localhost:${httpServer.gateway.address().port}`,
+        request   = new Request({ url: baseUrl, doNotThrowOnErrorStatus: true }),
+        response  = await request.get({ url: '/example/foo/bar', headers: { 'connection': 'close', 'content-type': 'application/json' }})
+
+      assert.equal(response.status, 200, '200 status code for GET method')
+      assert.equal(response.body.result, 'bar', 'Correct response body for GET method')
+    })
+
+    await sub.test('GET method using header parameter', async () =>
+    {
+      const
+        baseUrl   = `http://localhost:${httpServer.gateway.address().port}`,
+        request   = new Request({ url: baseUrl, doNotThrowOnErrorStatus: true }),
+        response  = await request.get({ url: '/example', headers: { 'foo':'header', 'connection': 'close', 'content-type': 'application/json' }})
+
+      assert.equal(response.status, 200, '200 status code for GET method')
+      assert.equal(response.body.result, 'header', 'Correct response body for GET method')
+    })
+
+    await sub.test('POST method using request body', async () =>
+    {
+      const
+        baseUrl   = `http://localhost:${httpServer.gateway.address().port}`,
+        request   = new Request({ url: baseUrl, doNotThrowOnErrorStatus: true }),
+        response  = await request.post({ url: '/example', body: { foo: 'body' }, headers: { 'connection': 'close', 'content-type': 'application/json' }})
+
+      assert.equal(response.status, 200, '200 status code for POST method')
+      assert.equal(response.body.result, 'body', 'Correct response body for POST method')
+    })
+
+    beforeEach.skip = false
+
+    await httpServer.close()
+  })
+})

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@superhero/http-server-using-oas",
+  "version": "4.7.2",
+  "description": "Integrates the HTTP server and OAS (OpenAPI Specification) @superhero components",
+  "keywords": [
+    "HTTP 2.0",
+    "HTTP 1.1",
+    "HTTPS",
+    "OAS",
+    "OpenAPI",
+    "Router"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./index.js",
+    "./dispatcher/*" : "./dispatcher/*.js",
+    "./dispatcher/downstream/*" : "./dispatcher/downstream/*.js",
+    "./dispatcher/upstream/*" : "./dispatcher/upstream/*.js"
+  },
+  "scripts": {
+    "syntax-check": "syntax-check",
+    "test": "syntax-check; node --test --test-reporter=@superhero/audit/reporter --experimental-test-coverage"
+  },
+  "dependencies": {
+    "@superhero/oas": "4.7.2",
+    "@superhero/http-server": "4.7.2"
+  },
+  "devDependencies": {
+    "@superhero/audit": "4.7.2",
+    "@superhero/syntax-check": "0.0.2",
+    "@superhero/http-request": "4.7.2",
+    "@superhero/core": "4.7.2"
+  },
+  "author": {
+    "name": "Erik Landvall",
+    "email": "erik@landvall.se"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/superhero/http-server-using-oas"
+  }
+}