openapi_first 1.0.0.beta5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e6c1f8f1a6fffd91827a74f95b932bfd5be9d4a897f3704efd6313bac9e6be4
-  data.tar.gz: 59041cacdcb634bb25e5d23025c0f86afe97632918f1e10d6f67409d31ba5f9b
+  metadata.gz: 259995bd946bd53afc1b6ab3cc2d556811a8d775ba2714d1e13f0058f3049048
+  data.tar.gz: fe150a639f4ddbbf6190296c0fb70ee06c5116711a2716826934fc12b48b1622
 SHA512:
-  metadata.gz: 1955264ba1b60f477123cd1bbb71a14d611d598664965548a9ebe3c6508d5ac6e205dfe971bc7c1ebe6b27da78a48f1bf5d27239c886a9b4aa7db303224e0cfc
-  data.tar.gz: 2f25b5944e546a6619c2be01462008d358a0a80140594b0906ca62e9b152fa97b2b8225d0c137acbe29c64b7732bbd00d3f35459cd0b771b2b38c409303adde8
+  metadata.gz: ed09d09b5ad4c131134843ed0c7772eb6742b9bd98e6bb410d2c7fca3efe9a49875993b095a9590ee1a5ec9484301d5a58ed67b445fdd46aacbabedaf7e8160e
+  data.tar.gz: 9fe5c08c823aff23d979b9cd0652e4a63a8df424f98c037cb77e45c28c7fd232f24305df8024495b7bd50f4b99fbb8669d0f8a962b20ef2652907298ac7dd6cf

data/.github/workflows/ruby.yml

@@ -9,4 +9,5 @@ jobs:
       with:
         ruby-version: '3.1'
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-    - run: bundle exec rake
+    - run: BUNDLE_GEMFILE=Gemfile bundle exec rake
+    - run: BUNDLE_GEMFILE=Gemfile.rack2 bundle lock --add-platform x86_64-linux && bundle exec rake

data/CHANGELOG.md

@@ -1,11 +1,32 @@
 # Changelog
 
-## Unreleased
+## 1.0.0
+
+- Breaking: The default error uses application/problem+json content-type
+- Breaking: Moved rack middlewares to OpenapiFirst::Middlewares
+- Breaking: Rename OpenapiFirst::ResponseInvalid to OpenapiFirst::ResponseInvalidError
+- Breaking: Remove OpenapiFirst::Router
+- Breaking: Remove `env[OpenapiFirst::OPERATION]`. Use `env[OpenapiFirst::REQUEST]` instead.
+- Breaking: Remove `env[OpenapiFirst::REQUEST_BODY]`, `env[OpenapiFirst::PARAMS]`. Use `env[OpenapiFirst::REQUEST].body env[OpenapiFirst::REQUEST].params` instead.
+- Add interface to validate requests / responses without middlewares (see "Manual validation" in README)
+- Add OpenapiFirst.configure
+- Add OpenapiFirst.register, OpenapiFirst.plugin
+- Fix response header validation with Rack 3
+- Fixed: Add support for paths like `/{a}..{b}`
+
+## 1.0.0.beta6
+
+- Fix: Make response header validation work with rack 3
+- Refactor router
+  - Remove dependency hanami-router
+  - PathItem and Operation for a request can be found by calling methods on the Definitnion
+- Fixed https://github.com/ahx/openapi_first/issues/155
+- Breaking / Regression: A paths like /pets/{from}-{to} if there is a path "/pets/{id}"
 
 ## 1.0.0.beta5
 
 - Added: `OpenapiFirst::Config.default_options=` to set default options globally
-- Added: You can define custom error responses by subclassing `OpenapiFirst::ErrorResponse` and register it via `OpenapiFirst::Plugins.register_error_response(name, MyCustomErrorResponse)`
+- Added: You can define custom error responses by subclassing `OpenapiFirst::ErrorResponse` and register it via `OpenapiFirst.register_error_response(name, MyCustomErrorResponse)`
 
 ## 1.0.0.beta4
 

data/Gemfile

@@ -5,6 +5,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in openapi_first.gemspec
 gemspec
 
+gem 'rack', '>= 3.0.0'
+
 group :test, :development do
   gem 'bundler'
   gem 'rack-test'

data/Gemfile.lock

@@ -1,12 +1,12 @@
 PATH
   remote: .
   specs:
-    openapi_first (1.0.0.beta5)
-      hanami-router (~> 2.0.0)
+    openapi_first (1.0.0)
       json_refs (~> 0.1, >= 0.1.7)
-      json_schemer (~> 2.0.0)
+      json_schemer (~> 2.1.0)
       multi_json (~> 1.15)
-      openapi_parameters (>= 0.3.1, < 2.0)
+      mustermann-contrib (~> 3.0.0)
+      openapi_parameters (>= 0.3.2, < 2.0)
       rack (>= 2.2, < 4.0)
 
 GEM
@@ -15,15 +15,11 @@ GEM
     ast (2.4.2)
     diff-lcs (1.5.0)
     hana (1.3.7)
-    hanami-router (2.0.2)
-      mustermann (~> 3.0)
-      mustermann-contrib (~> 3.0)
-      rack (~> 2.0)
     hansi (0.2.1)
-    json (2.6.3)
+    json (2.7.1)
     json_refs (0.1.8)
       hana
-    json_schemer (2.0.0)
+    json_schemer (2.1.1)
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       simpleidn (~> 0.2)
@@ -34,20 +30,20 @@ GEM
     mustermann-contrib (3.0.0)
       hansi (~> 0.2.0)
       mustermann (= 3.0.0)
-    openapi_parameters (0.3.1)
+    openapi_parameters (0.3.2)
       rack (>= 2.2)
       zeitwerk (~> 2.6)
-    parallel (1.23.0)
-    parser (3.2.2.4)
+    parallel (1.24.0)
+    parser (3.3.0.0)
       ast (~> 2.4.1)
       racc
     racc (1.7.3)
-    rack (2.2.8)
+    rack (3.0.8)
     rack-test (2.1.0)
       rack (>= 1.3)
     rainbow (3.1.1)
     rake (13.1.0)
-    regexp_parser (2.8.2)
+    regexp_parser (2.8.3)
     rexml (3.2.6)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
@@ -62,7 +58,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.1)
-    rubocop (1.57.2)
+    rubocop (1.59.0)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
@@ -70,7 +66,7 @@ GEM
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.28.1, < 2.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
     rubocop-ast (1.30.0)
@@ -81,17 +77,19 @@ GEM
       unf (~> 0.1.4)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.9)
+    unf_ext (0.0.9.1)
     unicode-display_width (2.5.0)
     zeitwerk (2.6.12)
 
 PLATFORMS
   arm64-darwin-21
+  arm64-darwin-22
   x86_64-linux
 
 DEPENDENCIES
   bundler
   openapi_first!
+  rack (>= 3.0.0)
   rack-test
   rake
   rspec

data/Gemfile.rack2

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rack', '< 3.0.0'
+
+group :test, :development do
+  gem 'bundler'
+  gem 'rack-test'
+  gem 'rake'
+  gem 'rspec'
+  gem 'rubocop'
+end

data/Gemfile.rack2.lock

@@ -0,0 +1,99 @@
+PATH
+  remote: .
+  specs:
+    openapi_first (1.0.0.beta6)
+      json_refs (~> 0.1, >= 0.1.7)
+      json_schemer (~> 2.1.0)
+      multi_json (~> 1.15)
+      mustermann-contrib (~> 3.0.0)
+      openapi_parameters (>= 0.3.2, < 2.0)
+      rack (>= 2.2, < 4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    hana (1.3.7)
+    hansi (0.2.1)
+    json (2.7.1)
+    json_refs (0.1.8)
+      hana
+    json_schemer (2.1.1)
+      hana (~> 1.3)
+      regexp_parser (~> 2.0)
+      simpleidn (~> 0.2)
+    language_server-protocol (3.17.0.3)
+    multi_json (1.15.0)
+    mustermann (3.0.0)
+      ruby2_keywords (~> 0.0.1)
+    mustermann-contrib (3.0.0)
+      hansi (~> 0.2.0)
+      mustermann (= 3.0.0)
+    openapi_parameters (0.3.2)
+      rack (>= 2.2)
+      zeitwerk (~> 2.6)
+    parallel (1.24.0)
+    parser (3.2.2.4)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.3)
+    rack (2.2.8)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rainbow (3.1.1)
+    rake (13.1.0)
+    regexp_parser (2.8.3)
+    rexml (3.2.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    rubocop (1.59.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.4)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
+    ruby2_keywords (0.0.5)
+    simpleidn (0.2.1)
+      unf (~> 0.1.4)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.9.1)
+    unicode-display_width (2.5.0)
+    zeitwerk (2.6.12)
+
+PLATFORMS
+  arm64-darwin-22
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  bundler
+  openapi_first!
+  rack (< 3.0.0)
+  rack-test
+  rake
+  rspec
+  rubocop
+
+BUNDLED WITH
+   2.5.3

data/README.md

@@ -1,175 +1,144 @@
-# OpenapiFirst
+# openapi_first
 
-[![Join the chat at https://gitter.im/openapi_first/community](https://badges.gitter.im/openapi_first/community.svg)](https://gitter.im/openapi_first/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+OpenapiFirst helps to implement HTTP APIs based on an [OpenAPI](https://www.openapis.org/) API description. It supports OpenAPI 3.0 and 3.1. It offers request and response validation to ensure that your implementation follows exactly the API description.
 
-OpenapiFirst helps to implement HTTP APIs based on an [OpenAPI](https://www.openapis.org/) API description. It supports OpenAPI 3.0 and 3.1.
+This makes your API description reliable, reason about API design and use various tooling on top of OpenAPI.
 
-It provides these Rack middlewares:
+## Contents
 
-- [`OpenapiFirst::RequestValidation`](#request-validation) – Validates the request against the API description and returns 400 if the request is invalid.
-- [`OpenapiFirst::ResponseValidation`](#response-validation) Validates the response and raises an exception if the response body is invalid.
-- [`OpenapiFirst::Router`](#openapifirstrouter) – This internal middleware is added automatically when using request/response validation. It adds the OpenAPI operation for the current request to the Rack env.
+<!-- TOC -->
 
-Using Request and Response validation together ensures that your implementation follows exactly the API description. This enables you to use the API description as a single source of truth for your API, reason about details and use various tooling.
+- [Manual use](#manual-use)
+- [Rack Middlewares](#rack-middlewares)
+- [Configuration](#configuration)
+- [Development](#development)
 
-## Request Validation
+<!-- /TOC -->
 
-The `OpenapiFirst::RequestValidation` middleware returns a 400 status code with a body that describes the error if the request is not valid.
+## Manual use
 
-```ruby
-use OpenapiFirst::RequestValidation, spec: 'openapi.yaml'
-```
-
-It adds these fields to the Rack env:
-
-- `env[OpenapiFirst::PARAMS]` – The parsed parameters (query, path) for the current request (string keyed)
-- `env[OpenapiFirst::REQUEST_BODY]` – The parsed request body (string keyed)
-- `env[OpenapiFirst::OPERATION]` (Added via Router) – The Operation object for the current request. This is an instance of `OpenapiFirst::Operation`.
-
-### Options and defaults
-
-| Name              | Possible values                                                 | Description                                                                                        | Default                            |
-| :---------------- | --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ---------------------------------- |
-| `spec:`           |                                                                 | The path to the spec file or spec loaded via `OpenapiFirst.load`                                   |
-| `raise_error:`    | `false`, `true`                                                 | If set to true the middleware raises `OpenapiFirst::RequestInvalidError` instead of returning 4xx. | `false` (don't raise an exception) |
-| `error_response:` | `:default`, `:json_api`, Your implementation of `ErrorResponse` | :default                                                                                           |
-
-The error responses conform with [JSON:API](https://jsonapi.org).
-
-Here's an example response body for a missing query parameter "search":
+Load the API description:
 
-```json
-http-status: 400
-content-type: "application/json"
+```ruby
+require 'openapi_first'
 
-{
-  "errors": [
-    {
-      "title": "is missing",
-      "source": {
-        "parameter": "search"
-      }
-    }
-  ]
-}
+definition = OpenapiFirst.load('petstore.yaml')
 ```
 
-### Parameters
-
-The `RequestValidation` middleware adds `env[OpenapiFirst::PARAMS]` (or `env['openapi.params']` ) with the converted query and path parameters. This only includes the parameters that are defined in the API description. It supports every [`style` and `explode` value as described](https://spec.openapis.org/oas/latest.html#style-examples) in the OpenAPI 3.0 and 3.1 specs. So you can do things these:
+Validate request / response:
 
 ```ruby
-# GET /pets/filter[id]=1,2,3
-env[OpenapiFirst::PARAMS] # => { 'filter[id]' => [1,2,3] }
 
-# GET /colors/.blue.black.brown?format=csv
-env[OpenapiFirst::PARAMS] # => { 'color_names' => ['blue', 'black', 'brown'], 'format' => 'csv' }
-
-# And a lot more.
+# Find the request
+rack_request = Rack::Request.new(env)
+request = definition.request(rack_request)
+
+# Inspect the request and access parsed parameters
+request.known? # Is the request defined in the API description?
+request.parsed_body # alias: body
+request.path_parameters
+request.query # alias: query_parameters
+request.params # Merged path and query parameters
+request.headers
+request.cookies
+
+# Validate the request
+request.validate # Returns OpenapiFirst:::Failure if validation fails
+request.validate! # Raises OpenapiFirst::RequestInvalidError or OpenapiFirst::NotFoundError if validation fails
+
+# Find the response
+rack_response = Rack::Response[*app.call(env)]
+response = request.response(rack_response) # or definition.response(rack_request, rack_response)
+
+# Validate response
+response.validate # Returns OpenapiFirst::Failure
+response.validate! # Raises OpenapiFirst::ResponseInvalidError or OpenapiFirst::ResponseNotFoundError if validation fails
 ```
 
-Integration for specific webframeworks is ongoing. Don't hesitate to create an issue with you specific needs.
-
-### Request body validation
-
-This middleware adds the parsed request body to `env[OpenapiFirst::REQUEST_BODY]`.
-
-The middleware will return a status `415` if the requests content type does not match or `400` if the request body is invalid.
-
-### Header, Cookie, Query and Path parameter validation
-
-The `RequestValidation` middleware validates the request headers, cookies and path parameters as defined in you API description. It returns a `400` status code if the request is invalid. It adds the parsed merged _path_ and _query_ parameters to `env['openapi.params']`.
-Separate parsed parameters are made available by location at `env['openapi.path_params']`, `env['openapi.query']`, `env['openapi.headers']`, `env['openapi.cookies']` as well if you need to access them separately.
-
-### readOnly / writeOnly properties
-
-Request validation fails if request includes a property with `readOnly: true`.
-
-Response validation fails if response body includes a property with `writeOnly: true`.
-
-## Response validation
-
-The `OpenapiFirst::ResponseValidation` middleware is especially useful when testing. It _always_ raises an error if the response is not valid.
+OpenapiFirst uses [`multi_json`](https://rubygems.org/gems/multi_json).
 
-```ruby
-use OpenapiFirst::ResponseValidation, spec: 'openapi.yaml' if ENV['RACK_ENV'] == 'test'
-```
+## Rack Middlewares
 
-### Options
+All middlewares add a _request_ object to the current Rack env at `env[OpenapiFirst::REQUEST]`), which is in an instance of `OpenapiFirst::RuntimeRequest` that responds to `.params`, `.parsed_body` etc.
 
-| Name    | Possible values | Description                                                      | Default |
-| :------ | --------------- | ---------------------------------------------------------------- | ------- |
-| `spec:` |                 | The path to the spec file or spec loaded via `OpenapiFirst.load` |
+This gives you access to the converted request parameters and body exaclty as described in your API description instead of relying on Rack alone to parse the request. This only includes query parameters that are defined in the API description. It supports every [`style` and `explode` value as described](https://spec.openapis.org/oas/latest.html#style-examples) in the OpenAPI 3.0 and 3.1 specs.
 
-## OpenapiFirst::Router
+### Request validation
 
-This middleware is used automatically, but you can add it to the top of your middleware stack if you want to customize the behavior via options.
+The request validation middleware returns a 4xx if the request is invalid or not defined in the API description.
 
 ```ruby
-use OpenapiFirst::Router, spec: './openapi/openapi.yaml'
+use OpenapiFirst::Middlewares::RequestValidation, spec: 'openapi.yaml'
 ```
 
-This middleware adds `env['openapi.operation']` which holds an instance of `OpenapiFirst::Operation` that responds to `#operation_id`, `#path` (and `#[]` to access raw fields).
+#### Options
 
-### Options and defaults
+| Name              | Possible values                                                           | Description                                                                                                                         |
+| :---------------- | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `spec:`           |                                                                           | The path to the spec file or spec loaded via `OpenapiFirst.load`                                                                    |
+| `raise_error:`    | `false` (default), `true`                                                 | If set to true the middleware raises `OpenapiFirst::RequestInvalidError` or `OpenapiFirst::NotFoundError` instead of returning 4xx. |
+| `error_response:` | `:default` (default), `:json_api`, Your implementation of `ErrorResponse` | :default                                                                                                                            |
 
-| Name           | Possible values      | Description                                                                                                                                                                                                                                                     | Default                            |
-| :------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
-| `spec:`        |                      | The path to the spec file or spec loaded via `OpenapiFirst.load`                                                                                                                                                                                                |                                    |
-| `raise_error:` | `false`, `true`      | If set to true the middleware raises `OpenapiFirst::NotFoundError` when a path or method was not found in the API description. This is useful during testing to spot an incomplete API description.                                                             | `false` (don't raise an exception) |
-| `not_found:`   | `:continue`, `:halt` | If set to `:continue` the middleware will not return 404 (405, 415), but just pass handling the request to the next middleware or application in the Rack stack. If combined with `raise_error: true` `raise_error` gets preference and an exception is raised. | `:halt` (return 4xx response)      |
+Here's an example response body about an invalid request body. See also [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457).
 
-## Global configuration
-
-You can configure default options gobally via `OpenapiFirst::Config`:
+```json
+http-status: 400
+content-type: "application/problem+json"
 
-```ruby
-OpenapiFirst::Config.default_options = {
-  error_response: :json_api,
-  request_validation_raise_error: true
+{
+  "title": "Bad Request Body",
+  "status": 400,
+  "errors": [
+    {
+      "message": "value at `/data/name` is not a string",
+      "pointer": "/data/name",
+      "code": "string"
+    },
+    {
+      "message": "number at `/data/numberOfLegs` is less than: 2",
+      "pointer": "/data/numberOfLegs",
+      "code": "minimum"
+    },
+    {
+      "message": "object at `/data` is missing required properties: mandatory",
+      "pointer": "/data",
+      "code": "required"
+    }
+  ]
 }
 ```
 
-## Alternatives
-
-This gem is inspired by [committee](https://github.com/interagent/committee) (Ruby) and [connexion](https://github.com/zalando/connexion) (Python).
-
-Here's a [comparison between committee and openapi_first](https://gist.github.com/ahx/1538c31f0652f459861713b5259e366a).
+#### readOnly / writeOnly properties
 
-## Try it out
+Request validation fails if request includes a property with `readOnly: true`.
 
-See [examples](examples).
+Response validation fails if response body includes a property with `writeOnly: true`.
 
-## Installation
+### Response validation
 
-Add this line to your application's Gemfile:
+This middleware is especially useful when testing. It _always_ raises an error if the response is not valid.
 
 ```ruby
-gem 'openapi_first'
+use OpenapiFirst::Middlewares::ResponseValidation, spec: 'openapi.yaml' if ENV['RACK_ENV'] == 'test'
 ```
 
-OpenapiFirst uses [`multi_json`](https://rubygems.org/gems/multi_json).
-
-## Manual response validation
-
-Instead of using the ResponseValidation middleware you can validate the response in your test manually via [rack-test](https://github.com/rack-test/rack-test) and ResponseValidator.
+#### Options
 
-```ruby
-# In your test (rspec example):
-require 'openapi_first'
-validator = OpenapiFirst::ResponseValidator.new('petstore.yaml')
-
-# This will raise an exception if it found an error
-validator.validate(last_request, last_response)
-```
+| Name    | Possible values | Description                                                      |
+| :------ | --------------- | ---------------------------------------------------------------- |
+| `spec:` |                 | The path to the spec file or spec loaded via `OpenapiFirst.load` |
 
-## Handling only certain paths
+## Configuration
 
-You can filter the URIs that should be handled by passing `only` to `OpenapiFirst.load`:
+You can configure default options globally:
 
 ```ruby
-spec = OpenapiFirst.load('./openapi/openapi.yaml', only: { |path| path.starts_with? '/pets' })
-run OpenapiFirst.app(spec, namespace: Pets)
+OpenapiFirst.configure do |config|
+  # Specify which plugin is used to render error responses returned by the request validation middleware (defaults to :default)
+  config.request_validation_error_response = :json_api
+  # Configure if the response validation middleware should raise an exception (defaults to false)
+  config.request_validation_raise_error = true
+end
 ```
 
 ## Development
@@ -180,11 +149,11 @@ See `bundle exec rake` to run the linter and the tests.
 
 Run `bundle exec rspec` to run the tests only.
 
-## Benchmarks
+### Benchmarks
 
 [Results](https://gist.github.com/ahx/e6ffced58bd2e8d5baffb2f4d2c1f823)
 
-### Run benchmarks
+Run benchmarks:
 
 ```sh
 cd benchmarks
@@ -192,8 +161,8 @@ bundle
 bundle exec ruby benchmarks.rb
 ```
 
-## Contributing
+### Contributing
 
-If you have a question or an idea or found a bug don't hesitate to [create an issue on GitHub](https://github.com/ahx/openapi_first/issues) or [reach out via chat](https://gitter.im/openapi_first/community).
+If you have a question or an idea or found a bug don't hesitate to [create an issue](https://github.com/ahx/openapi_first/issues) or [start a discussion](https://github.com/ahx/openapi_first/discussions).
 
 Pull requests are very welcome as well, of course. Feel free to create a "draft" pull request early on, even if your change is still work in progress. 🤗

data/lib/openapi_first/body_parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'multi_json'
+
+module OpenapiFirst
+  class BodyParser
+    class ParsingError < StandardError; end
+
+    def parse(request, content_type)
+      body = read_body(request)
+      return if body.empty?
+
+      return MultiJson.load(body) if content_type =~ (/json/i) && (content_type =~ /json/i)
+      return request.POST if request.form_data?
+
+      body
+    rescue MultiJson::ParseError
+      raise ParsingError, 'Failed to parse body as JSON'
+    end
+
+    private
+
+    def read_body(request)
+      body = request.body.read
+      request.body.rewind
+      body
+    end
+  end
+end

data/lib/openapi_first/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  class Configuration
+    def initialize
+      @request_validation_error_response = OpenapiFirst.plugin(:default)::ErrorResponse
+      @request_validation_raise_error = false
+    end
+
+    attr_reader :request_validation_error_response, :request_validation_raise_error
+
+    def request_validation_error_response=(mod)
+      @request_validation_error_response = if mod.is_a?(Symbol)
+                                             OpenapiFirst.plugin(:default)::ErrorResponse
+                                           else
+                                             mod
+                                           end
+    end
+  end
+end

data/lib/openapi_first/definition/cookie_parameters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'openapi_parameters'
+require_relative 'parameters'
+
+module OpenapiFirst
+  class CookieParameters < Parameters
+    def unpack(env)
+      OpenapiParameters::Cookie.new(@parameter_definitions).unpack(env['HTTP_COOKIE'])
+    end
+  end
+end

data/lib/openapi_first/definition/header_parameters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'openapi_parameters'
+require_relative 'parameters'
+
+module OpenapiFirst
+  class HeaderParameters < Parameters
+    def unpack(env)
+      OpenapiParameters::Header.new(@parameter_definitions).unpack_env(env)
+    end
+  end
+end