openapi_first 0.21.0 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b8b03aaa251de1bdb5cbba71de089bf1ffc6b9dbb96512008f88e783c3cea27
-  data.tar.gz: 02eb6cec864e9b5ed272d4392b31fd9e006713d3a8b00df9b26e9a52fa68e555
+  metadata.gz: 2248133fb2e0b761fb314629dcbfa7c9a6b7e0ac03b59887fe158968b17ed827
+  data.tar.gz: b0012d8af3c9dee1fa94334be7890e260f0173946129b53ec8f930f768f8de28
 SHA512:
-  metadata.gz: e37e99e982f0ead9d54587683fa74491e69998f520b1cfb4993c9e1ee81273537dfdf1751c77daef856ab3c3051660589d2f8ac6e58508fd11d3ea130734d2a5
-  data.tar.gz: 6944ae2444da29928eeb12e70326505aa154f1c36a09f033083098b1e34be766b075257fd2459b94574370fa8cc417ef488f74dafcec6026eaab07a47f471445
+  metadata.gz: c615c847efcd10cfd145bcc99ede55da2eaa76fe91b9d0ab3fdb159c20b6cc314309f583ba0b784c3e3493a7a534ed1836309807c549bd8c40b226f2f9bf77e9
+  data.tar.gz: 83c476b9b67ce15ad71e052af8360e013659da13fbbd8f86a55bae9d4bbcf08f4ac291187dfccc5786e957c65d2a3124366f007998c675b4a3e29bccaecf332a

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Changelog
 
-## Unreleased
+## 1.0.0.beta1
+- Removed: `OpenapiFirst::Responder` and `OpenapiFirst::RackResponder`
+- Removed: `OpenapiFirst.app` and `OpenapiFirst.middleware`
+- Removed: `OpenapiFirst::Coverage`
+- Breaking: Parsed query and path parameters are available at `env[OpenapiFirst::PARAMS]`(or `env['openapi.params']`) instead of `OpenapiFirst::PARAMETERS`.
+- Breaking: Request body and parameters now use string keys instead of symbols!
+- Breaking: Query parameters are now parsed exactly like in the API description via the openapi_parameters gem. This means a couple of things:
+  - Query parameters now support `explode: true` (default) and `explode: false` for array and object parameters.
+  - Query parameters with brackets like 'filter[tag]' are no longer deconstructed into nested hashes, but accessible via the `filter[tag]` key.
+  - Query parameters are no longer interpreted as `style: deepObject` by default. If you want to use `style: deepObject`, for example to pass a nested hash as a query parameter like `filter[tag]`, you have to set `style: deepObject` explicitly.
+- Path parameters are now parsed exactly as in the API description via the openapi_parameters gem.
 
 ## 0.21.0
 

data/Gemfile.lock

@@ -1,14 +1,15 @@
 PATH
   remote: .
   specs:
-    openapi_first (0.21.0)
+    openapi_first (1.0.0.beta1)
       deep_merge (>= 1.2.1)
       hanami-router (~> 2.0.0)
       hanami-utils (~> 2.0.0)
       json_refs (~> 0.1, >= 0.1.7)
       json_schemer (~> 0.2.16)
       multi_json (~> 1.14)
-      rack (~> 2.2)
+      mustermann-contrib (~> 3.0.0)
+      rack (>= 2.2, < 4.0)
 
 GEM
   remote: https://rubygems.org/
@@ -50,13 +51,16 @@ GEM
     mustermann-contrib (3.0.0)
       hansi (~> 0.2.0)
       mustermann (= 3.0.0)
+    openapi_parameters (0.2.0)
+      rack (>= 2.2)
+      zeitwerk (~> 2.6)
     parallel (1.22.1)
-    parser (3.2.1.0)
+    parser (3.2.1.1)
       ast (~> 2.4.1)
     pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    rack (2.2.6.2)
+    rack (2.2.6.4)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rainbow (3.1.1)
@@ -72,23 +76,23 @@ GEM
     rspec-expectations (3.12.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.3)
+    rspec-mocks (3.12.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.0)
-    rubocop (1.45.1)
+    rubocop (1.48.1)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.2.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.24.1, < 2.0)
+      rubocop-ast (>= 1.26.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.26.0)
+    rubocop-ast (1.28.0)
       parser (>= 3.2.1.0)
-    ruby-progressbar (1.11.0)
+    ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)
     unicode-display_width (2.4.2)
     uri_template (0.7.0)
@@ -96,12 +100,11 @@ GEM
 
 PLATFORMS
   arm64-darwin-21
-  x86_64-darwin-20
-  x86_64-linux
 
 DEPENDENCIES
   bundler (~> 2)
   openapi_first!
+  openapi_parameters (~> 0.2, <= 2.0.0)
   pry
   rack-test (~> 1)
   rake (~> 13)
@@ -109,4 +112,4 @@ DEPENDENCIES
   rubocop
 
 BUNDLED WITH
-   2.3.7
+   2.3.10

data/README.md

@@ -6,26 +6,11 @@ OpenapiFirst helps to implement HTTP APIs based on an [OpenApi](https://www.open
 
 Start with writing an OpenAPI file that describes the API, which you are about to implement. Use a [validator](https://github.com/stoplightio/spectral/) to make sure the file is valid.
 
-You can use OpenapiFirst via its [Rack middlewares](#rack-middlewares) or in [standalone mode](#standalone-usage).
-
-## 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).
-
-## Rack middlewares
-
 OpenapiFirst consists of these Rack middlewares:
 
 - [`OpenapiFirst::RequestValidation`](#OpenapiFirst::RequestValidation) – Validates the request against the API description and returns 400 if the request is invalid.
 - [`OpenapiFirst::ResponseValidation`](#OpenapiFirst::ResponseValidation) Validates the response and raises an exception if the response body is invalid.
-- [`OpenapiFirst::Router`](#OpenapiFirst::Router) – This internal middleware is added automatically before request/response validation. Finds the OpenAPI operation for the current request or returns 404 if no operation was found. This can be customized by adding it yourself.
-
-
-And these Rack apps:
-- [`OpenapiFirst::Responder`](#OpenapiFirst::Responder) calls the [handler](#handlers) found for the operation, sets the correct content-type and serializes the response body to json if needed.
-- [`OpenapiFirst::RackResponder`](#OpenapiFirst::RackResponder) calls the [handler](#handlers) found for the operation as a normal Rack application (`call(env)`) and returns the result as is.
+- [`OpenapiFirst::Router`](#OpenapiFirst::Router) – This internal middleware is added automatically when using request/response validation. It adds the OpenAPI operation for the current request to the Rack env or returns 404 if no operation was found.
 
 ## OpenapiFirst::RequestValidation
 
@@ -35,6 +20,11 @@ This middleware returns a 400 status code with a body that describes the error i
 use OpenapiFirst::RequestValidation, spec: 'openapi.yaml'
 ```
 
+This will add these fields to the Rack env:
+- `env[OpenapiFirst::OPERATION]` – The Operation object for the current request. This is an instance of `OpenapiFirst::Operation`.
+- `env[OpenapiFirst::PARAMS]` – The parsed parameters (query, path) for the current request (string keyed)
+- `env[OpenapiFirst::REQUEST_BODY]` – The parsed request body (string keyed)
+
 ### Options and defaults
 
 | Name           | Possible values | Description                                                                                        | Default                            |
@@ -62,26 +52,28 @@ content-type: "application/vnd.api+json"
 }
 ```
 
-This middleware adds `env[OpenapiFirst::INBOX]` which holds the (filtered) path and query parameters and the parsed request body.
-
-### Parameter validation
+### Parameters
 
-The middleware filteres all top-level query parameters and paths parameters and tries to convert numeric values. Meaning, if you have an `:something_id` path with `type: integer`, it will try convert the value to an integer.
 
-It just works with a parameter with `name: filter[age]`.
+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:
 
-OpenapiFirst also supports `type: array` for query parameters and will convert `items` just as described above. [`style`](http://spec.openapis.org/oas/v3.0.3#style-values) and `explode` attributes are not supported for query parameters. It will always act as if `style: form` and `explode: false` were used for query parameters.
+```ruby
+# GET /pets/filter[id]=1,2,3
+env[OpenapiFirst::PARAMS] # => { 'filter[id]' => [1,2,3] }
 
-Conversion is currently done only for path and query parameters, but not for the request body. OpenapiFirst currently does not convert date, date-time or time formats.
+# GET /colors/.blue.black.brown?format=csv
+env[OpenapiFirst::PARAMS] # => { 'color_names' => ['blue', 'black', 'brown'], 'format' => 'csv' }
 
-If you want to forbid _nested_ query parameters you will need to use [`additionalProperties: false`](https://json-schema.org/understanding-json-schema/reference/object.html#properties) in your query parameter JSON schema.
+# And a lot more.
+```
 
-_OpenapiFirst always treats query parameters like [`style: deepObject`](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#style-values), **but** it just works with nested objects (`filter[foo][bar]=baz`) (see [this discussion](https://github.com/OAI/OpenAPI-Specification/issues/1706))._
+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.
-This will also add the parsed request body to `env[OpenapiFirst::REQUEST_BODY]`.
 
 ### Header, Cookie, Path parameter validation
 
@@ -116,7 +108,7 @@ This middleware is used automatically, but you can add it to the top of your mid
 use OpenapiFirst::Router, spec: './openapi/openapi.yaml'
 ```
 
-This middleware adds `env[OpenapiFirst::OPERATION]` which holds an Operation object that responds to `#operation_id`, `#path` (and `#[]` to access raw fields).
+This middleware adds `env[OpenapiFirst::OPERATION]` which holds an Operation object that responds to `#operation_id`, `#path` (and `#[string]` to access raw fields).
 
 ### Options and defaults
 
@@ -126,115 +118,11 @@ This middleware adds `env[OpenapiFirst::OPERATION]` which holds an Operation obj
 | `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)      |
 
-## OpenapiFirst::RackResponder
-
-This Rack endpoint maps the HTTP request to a method call based on the [operationId](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#operation-object) in your API description and calls it as a normal Rack application.
-It does not not serialize objects as JSON or adds a content-type.
-
-```ruby
-run OpenapiFirst::RackResponder
-```
-
-### Options
-
-| Name         | Description                                                                                                                                                                                       |
-| :----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `namespace:` | Optional. A class or module where to find the handler method.                                                                                                                                     |
-| `resolver:`  | Optional. An object that responds to `#call(operation)` and returns a [handler](#handlers). By default this is an instance of [DefaultOperationResolver](#OpenapiFirst::DefaultOperationResolver) |
-
-## OpenapiFirst::Responder
-
-This Rack endpoint maps the HTTP request to a method call based on the [operationId](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#operation-object) in your API description and calls it. Responder also adds a content-type to the response.
-
-```ruby
-run OpenapiFirst::Responder
-```
-
-### Options
-
-| Name         | Description                                                                                                                                                                                       |
-| :----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `namespace:` | Optional. A class or module where to find the handler method.                                                                                                                                     |
-| `resolver:`  | Optional. An object that responds to `#call(operation)` and returns a [handler](#handlers). By default this is an instance of [DefaultOperationResolver](#OpenapiFirst::DefaultOperationResolver) |
-
-### OpenapiFirst::DefaultOperationResolver
-
-This is the default way to look up a handler method for an operation. Handlers are always looked up in a namespace module that needs to be specified.
-
-It works like this:
-
-- An operationId "create_pet" or "createPet" or "create pet" calls `MyApi.create_pet(params, response)`
-- "some_things.create" calls: `MyApi::SomeThings.create(params, response)`
-- "pets#create" instantiates the class once (`MyApi::Pets::Create.new) and calls it on every request(`instance.call(params, response)`).
-
-### Handlers
-
-These handler methods are called with two arguments:
-
-- `params` - Holds the parsed request body, filtered query params and path parameters (same as `env[OpenapiFirst::INBOX]`)
-- `res` - Holds a Rack::Response that you can modify if needed
-
-You can call `params.env` to access the Rack env (just like in [Hanami actions](https://guides.hanamirb.org/actions/parameters/))
-
-There are two ways to set the response body:
-
-- Calling `res.write "things"` (see [Rack::Response](https://www.rubydoc.info/github/rack/rack/Rack/Response))
-- Returning a value which will get converted to JSON
-
-## Standalone usage
-
-Instead of composing these middlewares yourself you can use `OpenapiFirst.app`.
-
-```ruby
-module Pets
-  def self.find_pet(params, res)
-    {
-      id: params[:id],
-      name: 'Oscar'
-    }
-  end
-end
-
-# In config.ru:
-require 'openapi_first'
-run OpenapiFirst.app(
-  './openapi/openapi.yaml',
-  namespace: Pets,
-  response_validation: ENV['RACK_ENV'] == 'test',
-  router_raise_error:  ENV['RACK_ENV'] == 'test'
-)
-```
-
-The above will use the mentioned Rack middlewares to:
-
-- Validate the request and respond with 400 if the request does not match with your API description
-- Map the request to a method call `Pets.find_pet` based on the `operationId` in the API description
-- Set the response content type according to your spec (here with the default status code `200`)
-
-### Options and defaults
-
-| Name                              | Possible values | Description                                                                                                                                          | Default |
-| :-------------------------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
-| `spec_path`                       |                 | A filepath to an OpenAPI definition file.                                                                                                            |
-| `namespace:`                      |                 | A class or module where to find the handler methods.                                                                                                 |
-| `response_validation:`            | `true`, `false` | If set to true it raises an exception if the response is invalid. This is useful during testing.                                                     | `false` |
-| `router_raise_error:`             | `true`, `false` | If set to true it raises an exception (subclass of `OpenapiFirst::Error` when a request path/method is not specified. This is useful during testing. | `false` |
-| `request_validation_raise_error:` | `true`, `false` | If set to true it raises an exception (subclass of `OpenapiFirst::Error` when a request is not valid.                                                | `false` |
-| `resolver:`                       |                 | Option to customize finding the [handler](#handlers) method for an operation. See [OpenapiFirst::Responder](#OpenapiFirst::Responder) for details.   |
-
-Handler functions (`find_pet`) are called with two arguments:
-
-- `params` - Holds the parsed request body, filtered query params and path parameters
-- `res` - Holds a Rack::Response that you can modify if needed
-  If you want to access to plain Rack env you can call `params.env`.
-
-## If your API description does not contain all endpoints
+## Alternatives
 
-```ruby
-run OpenapiFirst.middleware('./openapi/openapi.yaml', namespace: Pets)
-```
+This gem is inspired by [committee](https://github.com/interagent/committee) (Ruby) and [connexion](https://github.com/zalando/connexion) (Python).
 
-Here all requests that are not part of the API description will be passed to the next app.
+Here's a [comparison between committee and openapi_first](https://gist.github.com/ahx/1538c31f0652f459861713b5259e366a).
 
 ## Try it out
 
@@ -272,44 +160,6 @@ spec = OpenapiFirst.load('./openapi/openapi.yaml', only: { |path| path.starts_wi
 run OpenapiFirst.app(spec, namespace: Pets)
 ```
 
-## Coverage
-
-(This is a bit experimental. Please try it out and give feedback.)
-
-`OpenapiFirst::Coverage` helps you make sure, that you have called all endpoints of your OAS file when running tests via `rack-test`.
-
-```ruby
-# In your test (rspec example):
-require 'openapi_first/coverage'
-
-describe MyApp do
-  include Rack::Test::Methods
-
-  before(:all) do
-    @app_wrapper = OpenapiFirst::Coverage.new(MyApp, 'petstore.yaml')
-  end
-
-  after(:all) do
-    message = "The following paths have not been called yet: #{@app_wrapper.to_be_called}"
-    expect(@app_wrapper.to_be_called).to be_empty
-  end
-
-  # Overwrite `#app` to make rack-test call the wrapped app
-  def app
-    @app_wrapper
-  end
-
-  it 'does things' do
-    get '/i/my/stuff'
-    # …
-  end
-end
-```
-
-## Mocking
-
-Out of scope. Use [Prism](https://github.com/stoplightio/prism) or [fakeit](https://github.com/JustinFeng/fakeit).
-
 ## Development
 
 Run `bin/setup` to install dependencies.

data/benchmarks/Gemfile.lock

@@ -1,24 +1,25 @@
 PATH
   remote: ..
   specs:
-    openapi_first (0.21.0)
+    openapi_first (1.0.0.beta1)
       deep_merge (>= 1.2.1)
       hanami-router (~> 2.0.0)
       hanami-utils (~> 2.0.0)
       json_refs (~> 0.1, >= 0.1.7)
       json_schemer (~> 0.2.16)
       multi_json (~> 1.14)
-      rack (~> 2.2)
+      mustermann-contrib (~> 3.0.0)
+      rack (>= 2.2, < 4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.4.2)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
-    benchmark-ips (2.11.0)
+    benchmark-ips (2.12.0)
     benchmark-memory (0.2.0)
       memory_profiler (~> 1)
     builder (3.2.4)
@@ -26,7 +27,7 @@ GEM
       json_schema (~> 0.14, >= 0.14.3)
       openapi_parser (~> 1.0)
       rack (>= 1.5)
-    concurrent-ruby (1.2.0)
+    concurrent-ruby (1.2.2)
     deep_merge (1.2.2)
     dry-core (1.0.0)
       concurrent-ruby (~> 1.0)
@@ -38,11 +39,11 @@ GEM
       zeitwerk (~> 2.6)
     dry-transformer (1.0.1)
       zeitwerk (~> 2.6)
-    dry-types (1.7.0)
+    dry-types (1.7.1)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 1.0, < 2)
-      dry-inflector (~> 1.0, < 2)
-      dry-logic (>= 1.4, < 2)
+      dry-core (~> 1.0)
+      dry-inflector (~> 1.0)
+      dry-logic (~> 1.4)
       zeitwerk (~> 2.6)
     ecma-re-validator (0.4.0)
       regexp_parser (~> 2.2)
@@ -76,7 +77,7 @@ GEM
       regexp_parser (~> 2.0)
       uri_template (~> 0.7)
     memory_profiler (1.0.1)
-    minitest (5.17.0)
+    minitest (5.18.0)
     multi_json (1.15.0)
     mustermann (3.0.0)
       ruby2_keywords (~> 0.0.1)
@@ -87,15 +88,15 @@ GEM
       mustermann (>= 1.0.0)
     nio4r (2.5.8)
     openapi_parser (1.0.0)
-    puma (6.1.0)
+    puma (6.2.0)
       nio4r (~> 2.0)
-    rack (2.2.6.2)
+    rack (2.2.6.4)
     rack-accept (0.4.5)
       rack (>= 0.4)
     rack-protection (3.0.5)
       rack
-    regexp_parser (2.7.0)
-    roda (3.65.0)
+    regexp_parser (2.8.0)
+    roda (3.66.0)
       rack
     ruby2_keywords (0.0.5)
     seg (1.2.0)
@@ -107,7 +108,7 @@ GEM
     syro (3.2.1)
       rack (>= 1.6.0)
       seg
-    tilt (2.0.11)
+    tilt (2.1.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     uri_template (0.7.0)

data/benchmarks/apps/openapi_first.ru

@@ -5,7 +5,7 @@ require 'openapi_first'
 
 namespace = Module.new do
   def self.find_thing(params, _res)
-    { hello: 'world', id: params.fetch(:id) }
+    { hello: 'world', id: params.fetch('id') }
   end
 
   def self.find_things(_params, _res)

data/examples/app.rb

@@ -1,22 +1,18 @@
 # frozen_string_literal: true
 
 require 'openapi_first'
+require 'rack'
 
-module Web
-  module Things
-    class Index
-      def call(_params, _response)
-        { hello: 'world' }
-      end
-    end
-  end
-end
+# This example is a bit contrived, but it shows what you could do with the middlewares
+
+App = Rack::Builder.new do
+  use OpenapiFirst::RequestValidation, raise_error: true, spec: File.expand_path('./openapi.yaml', __dir__)
+  use OpenapiFirst::ResponseValidation
 
-oas_path = File.absolute_path('./openapi.yaml', __dir__)
+  handlers = {
+    'things#index' => ->(_env) { [200, { 'Content-Type' => 'application/json' }, ['{"hello": "world"}']] }
+  }
+  not_found = ->(_env) { [404, {}, []] }
 
-App = OpenapiFirst.app(
-  oas_path,
-  namespace: Web,
-  router_raise_error: OpenapiFirst.env == 'test',
-  response_validation: OpenapiFirst.env == 'test'
-)
+  run ->(env) { handlers.fetch(env[OpenapiFirst::OPERATION].operation_id, not_found).call(env) }
+end

data/lib/openapi_first/operation.rb

@@ -4,10 +4,9 @@ require 'forwardable'
 require 'set'
 require_relative 'schema_validation'
 require_relative 'utils'
-require_relative 'response_object'
 
 module OpenapiFirst
-  class Operation # rubocop:disable Metrics/ClassLength
+  class Operation
     extend Forwardable
     def_delegators :operation_object,
                    :[],
@@ -40,24 +39,6 @@ module OpenapiFirst
       operation_object['requestBody']
     end
 
-    def parameters_schema
-      @parameters_schema ||= begin
-        parameters_json_schema = build_parameters_json_schema
-        parameters_json_schema && SchemaValidation.new(parameters_json_schema)
-      end
-    end
-
-    def query_parameters_schema
-      @query_parameters_schema ||= begin
-        query_parameters_json_schema = build_query_parameters_json_schema
-        query_parameters_json_schema && SchemaValidation.new(query_parameters_json_schema)
-      end
-    end
-
-    def content_types_for(status)
-      response_for(status)['content']&.keys
-    end
-
     def response_schema_for(status, content_type)
       content = response_for(status)['content']
       return if content.nil? || content.empty?
@@ -102,6 +83,23 @@ module OpenapiFirst
       !!find_content_for_content_type(content, request_content_type)
     end
 
+    def query_parameters
+      @query_parameters ||= all_parameters.filter { |p| p['in'] == 'query' }
+    end
+
+    def path_parameters
+      @path_parameters ||= all_parameters.filter { |p| p['in'] == 'path' }
+    end
+
+    def all_parameters
+      @all_parameters ||= begin
+        parameters = @path_item_object['parameters']&.dup || []
+        parameters_on_operation = operation_object['parameters']
+        parameters.concat(parameters_on_operation) if parameters_on_operation
+        parameters
+      end
+    end
+
     private
 
     def response_by_code(status)
@@ -121,55 +119,5 @@ module OpenapiFirst
         content[type] || content["#{type.split('/')[0]}/*"] || content['*/*']
       end
     end
-
-    def build_parameters_json_schema
-      parameters = all_parameters
-      return unless parameters&.any?
-
-      parameters.each_with_object(new_node) do |parameter, schema|
-        params = Rack::Utils.parse_nested_query(parameter['name'])
-        generate_schema(schema, params, parameter)
-      end
-    end
-
-    def build_query_parameters_json_schema
-      query_parameters = all_parameters.reject { |field, _value| field['in'] == 'header' }
-      return unless query_parameters&.any?
-
-      query_parameters.each_with_object(new_node) do |parameter, schema|
-        params = Rack::Utils.parse_nested_query(parameter['name'])
-        generate_schema(schema, params, parameter)
-      end
-    end
-
-    def all_parameters
-      parameters = @path_item_object['parameters']&.dup || []
-      parameters_on_operation = operation_object['parameters']
-      parameters.concat(parameters_on_operation) if parameters_on_operation
-      parameters
-    end
-
-    def generate_schema(schema, params, parameter)
-      required = Set.new(schema['required'])
-      params.each do |key, value|
-        required << key if parameter['required']
-        if value.is_a? Hash
-          property_schema = new_node
-          generate_schema(property_schema, value, parameter)
-          Utils.deep_merge!(schema['properties'], { key => property_schema })
-        else
-          schema['properties'][key] = parameter['schema']
-        end
-      end
-      schema['required'] = required.to_a
-    end
-
-    def new_node
-      {
-        'type' => 'object',
-        'required' => [],
-        'properties' => {}
-      }
-    end
   end
 end

data/lib/openapi_first/request_validation.rb

@@ -2,12 +2,12 @@
 
 require 'rack'
 require 'multi_json'
-require_relative 'inbox'
 require_relative 'use_router'
 require_relative 'validation_format'
+require 'openapi_parameters'
 
 module OpenapiFirst
-  class RequestValidation # rubocop:disable Metrics/ClassLength
+  class RequestValidation
     prepend UseRouter
 
     def initialize(app, options = {})
@@ -19,17 +19,17 @@ module OpenapiFirst
       operation = env[OPERATION]
       return @app.call(env) unless operation
 
-      env[INBOX] = {}
       error = catch(:error) do
-        params = validate_query_parameters!(operation, env[PARAMETERS])
-        env[INBOX].merge! env[PARAMETERS] = params if params
-        req = Rack::Request.new(env)
+        query_params = OpenapiParameters::Query.new(operation.query_parameters).unpack(env['QUERY_STRING'])
+        validate_query_parameters!(operation, query_params)
+        env[PARAMS].merge!(query_params)
+
         return @app.call(env) unless operation.request_body
 
-        validate_request_content_type!(operation, req.content_type)
-        parsed_request_body = parse_and_validate_request_body!(operation, req)
-        env[REQUEST_BODY] = parsed_request_body
-        env[INBOX].merge! parsed_request_body if parsed_request_body.is_a?(Hash)
+        content_type = Rack::Request.new(env).content_type
+        validate_request_content_type!(operation, content_type)
+        parsed_request_body = env[REQUEST_BODY]
+        validate_request_body!(operation, parsed_request_body, content_type)
         nil
       end
       if error
@@ -42,23 +42,15 @@ module OpenapiFirst
 
     private
 
-    ROUTER_PARSED_BODY = 'router.parsed_body'
-
-    def parse_and_validate_request_body!(operation, request)
-      env = request.env
-
-      body = env.delete(ROUTER_PARSED_BODY) if env.key?(ROUTER_PARSED_BODY)
-
+    def validate_request_body!(operation, body, content_type)
       validate_request_body_presence!(body, operation)
-      return if body.nil?
+      return if content_type.nil?
 
-      schema = operation&.request_body_schema(request.content_type)
+      schema = operation&.request_body_schema(content_type)
       return unless schema
 
       errors = schema.validate(body)
       throw_error(400, serialize_request_body_errors(errors)) if errors.any?
-      return Utils.deep_symbolize(body) if body.is_a?(Hash)
-
       body
     end
 
@@ -104,30 +96,29 @@ module OpenapiFirst
       end
     end
 
-    def validate_query_parameters!(operation, params)
-      schema = operation.query_parameters_schema
-      return unless schema
-
-      params = filtered_params(schema.raw_schema, params)
-      params = Utils.deep_stringify(params)
-      errors = schema.validate(params)
-      throw_error(400, serialize_query_parameter_errors(errors)) if errors.any?
-      Utils.deep_symbolize(params)
+    def build_json_schema(parameter_defs)
+      init_schema = {
+        'type' => 'object',
+        'properties' => {},
+        'required' => []
+      }
+      parameter_defs.each_with_object(init_schema) do |parameter_def, schema|
+        parameter = OpenapiParameters::Parameter.new(parameter_def)
+        schema['properties'][parameter.name] = parameter.schema if parameter.schema
+        schema['required'] << parameter.name if parameter.required?
+      end
     end
 
-    def filtered_params(json_schema, params)
-      json_schema['properties']
-        .each_with_object({}) do |key_value, result|
-          parameter_name = key_value[0].to_sym
-          schema = key_value[1]
-          next unless params.key?(parameter_name)
+    def validate_query_parameters!(operation, params)
+      parameter_defs = operation.query_parameters
+      return unless parameter_defs&.any?
 
-          value = params[parameter_name]
-          result[parameter_name] = parse_parameter(value, schema)
-        end
+      json_schema = build_json_schema(parameter_defs)
+      errors = SchemaValidation.new(json_schema).validate(params)
+      throw_error(400, serialize_parameter_errors(errors)) if errors.any?
     end
 
-    def serialize_query_parameter_errors(validation_errors)
+    def serialize_parameter_errors(validation_errors)
       validation_errors.map do |error|
         pointer = error['data_pointer'][1..].to_s
         {
@@ -135,41 +126,5 @@ module OpenapiFirst
         }.update(ValidationFormat.error_details(error))
       end
     end
-
-    def parse_parameter(value, schema)
-      return filtered_params(schema, value) if schema['properties']
-
-      return parse_array_parameter(value, schema) if schema['type'] == 'array'
-
-      parse_simple_value(value, schema)
-    end
-
-    def parse_array_parameter(value, schema)
-      return value if value.nil? || value.empty?
-
-      array = value.is_a?(Array) ? value : value.split(',')
-      return array unless schema['items']
-
-      array.map! { |e| parse_simple_value(e, schema['items']) }
-    end
-
-    def parse_simple_value(value, schema)
-      return to_boolean(value) if schema['type'] == 'boolean'
-
-      begin
-        return Integer(value, 10) if schema['type'] == 'integer'
-        return Float(value) if schema['type'] == 'number'
-      rescue ArgumentError
-        value
-      end
-      value
-    end
-
-    def to_boolean(value)
-      return true if value == 'true'
-      return false if value == 'false'
-
-      value
-    end
   end
 end

data/lib/openapi_first/router.rb

@@ -12,7 +12,6 @@ module OpenapiFirst
       options
     )
       @app = app
-      @parent_app = options.fetch(:parent_app, nil)
       @raise = options.fetch(:raise_error, false)
       @not_found = options.fetch(:not_found, :halt)
       spec = options.fetch(:spec)
@@ -28,8 +27,6 @@ module OpenapiFirst
       env[OPERATION] = nil
       response = call_router(env)
       if env[OPERATION].nil?
-        return @parent_app.call(env) if @parent_app # This should only happen if used via OpenapiFirst.middleware
-
         raise_error(env) if @raise
 
         return @app.call(env) if @not_found == :continue
@@ -39,6 +36,10 @@ module OpenapiFirst
     end
 
     ORIGINAL_PATH = 'openapi_first.path_info'
+    private_constant :ORIGINAL_PATH
+
+    ROUTER_PARSED_BODY = 'router.parsed_body'
+    private_constant :ROUTER_PARSED_BODY
 
     private
 
@@ -96,8 +97,11 @@ module OpenapiFirst
     def build_route(operation)
       lambda do |env|
         env[OPERATION] = operation
-        env[PARAMETERS] = env['router.params']
-        env[Rack::PATH_INFO] = env.delete(ORIGINAL_PATH)
+        path_info = env.delete(ORIGINAL_PATH)
+        env[REQUEST_BODY] = env.delete(ROUTER_PARSED_BODY) if env.key?(ROUTER_PARSED_BODY)
+        route_params = Utils::StringKeyedHash.new(env['router.params'])
+        env[PARAMS] = OpenapiParameters::Path.new(operation.path_parameters).unpack(route_params)
+        env[Rack::PATH_INFO] = path_info
         @app.call(env)
       end
     end

data/lib/openapi_first/utils.rb

@@ -18,12 +18,18 @@ module OpenapiFirst
       Hanami::Utils::String.classify(string)
     end
 
-    def self.deep_symbolize(hash)
-      Hanami::Utils::Hash.deep_symbolize(hash)
-    end
+    class StringKeyedHash
+      def initialize(original)
+        @orig = original
+      end
+
+      def key?(key)
+        @orig.key?(key.to_sym)
+      end
 
-    def self.deep_stringify(hash)
-      Hanami::Utils::Hash.deep_stringify(hash)
+      def [](key)
+        @orig[key.to_sym]
+      end
     end
   end
 end

data/lib/openapi_first/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiFirst
-  VERSION = '0.21.0'
+  VERSION = '1.0.0.beta1'
 end

data/lib/openapi_first.rb

@@ -5,19 +5,15 @@ require 'json_refs'
 require_relative 'openapi_first/definition'
 require_relative 'openapi_first/version'
 require_relative 'openapi_first/errors'
-require_relative 'openapi_first/inbox'
 require_relative 'openapi_first/router'
 require_relative 'openapi_first/request_validation'
 require_relative 'openapi_first/response_validator'
 require_relative 'openapi_first/response_validation'
-require_relative 'openapi_first/responder'
-require_relative 'openapi_first/app'
 
 module OpenapiFirst
-  OPERATION = 'openapi_first.operation'
-  PARAMETERS = 'openapi_first.parameters'
-  REQUEST_BODY = 'openapi_first.parsed_request_body'
-  INBOX = 'openapi_first.inbox'
+  OPERATION = 'openapi.operation'
+  PARAMS = 'openapi.params'
+  REQUEST_BODY = 'openapi.parsed_request_body'
   HANDLER = 'openapi_first.handler'
 
   def self.env
@@ -50,32 +46,4 @@ module OpenapiFirst
       response_validation: response_validation
     )
   end
-
-  def self.middleware(
-    spec,
-    namespace:,
-    router_raise_error: false,
-    request_validation_raise_error: false,
-    response_validation: false
-  )
-    spec = OpenapiFirst.load(spec) unless spec.is_a?(Definition)
-    AppWithOptions.new(
-      spec,
-      namespace: namespace,
-      router_raise_error: router_raise_error,
-      request_validation_raise_error: request_validation_raise_error,
-      response_validation: response_validation
-    )
-  end
-
-  class AppWithOptions
-    def initialize(spec, options)
-      @spec = spec
-      @options = options
-    end
-
-    def new(app)
-      App.new(app, @spec, **@options)
-    end
-  end
 end

data/openapi_first.gemspec

@@ -40,9 +40,11 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'json_refs', '~> 0.1', '>= 0.1.7'
   spec.add_runtime_dependency 'json_schemer', '~> 0.2.16'
   spec.add_runtime_dependency 'multi_json', '~> 1.14'
-  spec.add_runtime_dependency 'rack', '~> 2.2'
+  spec.add_runtime_dependency 'mustermann-contrib', '~> 3.0.0'
+  spec.add_runtime_dependency 'rack', '>= 2.2', '< 4.0'
 
   spec.add_development_dependency 'bundler', '~> 2'
+  spec.add_development_dependency 'openapi_parameters', '~> 0.2', '<= 2.0.0'
   spec.add_development_dependency 'rack-test', '~> 1'
   spec.add_development_dependency 'rake', '~> 13'
   spec.add_development_dependency 'rspec', '~> 3'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_first
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Andreas Haller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2023-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge
@@ -101,19 +101,39 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.14'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: mustermann-contrib
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -128,6 +148,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: openapi_parameters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
@@ -214,25 +254,17 @@ files:
 - examples/config.ru
 - examples/openapi.yaml
 - lib/openapi_first.rb
-- lib/openapi_first/app.rb
 - lib/openapi_first/body_parser_middleware.rb
-- lib/openapi_first/coverage.rb
-- lib/openapi_first/default_operation_resolver.rb
 - lib/openapi_first/definition.rb
 - lib/openapi_first/errors.rb
-- lib/openapi_first/inbox.rb
 - lib/openapi_first/operation.rb
-- lib/openapi_first/rack_responder.rb
 - lib/openapi_first/request_validation.rb
-- lib/openapi_first/responder.rb
-- lib/openapi_first/response_object.rb
 - lib/openapi_first/response_validation.rb
 - lib/openapi_first/response_validator.rb
 - lib/openapi_first/router.rb
 - lib/openapi_first/schema_validation.rb
 - lib/openapi_first/use_router.rb
 - lib/openapi_first/utils.rb
-- lib/openapi_first/validation.rb
 - lib/openapi_first/validation_format.rb
 - lib/openapi_first/version.rb
 - openapi_first.gemspec
@@ -252,9 +284,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.0.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key:

data/lib/openapi_first/app.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack'
-
-module OpenapiFirst
-  class App
-    def initialize( # rubocop:disable Metrics/ParameterLists
-      parent_app,
-      spec,
-      namespace:,
-      router_raise_error: false,
-      request_validation_raise_error: false,
-      response_validation: false,
-      resolver: nil
-    )
-      @stack = Rack::Builder.app do
-        freeze_app
-        use OpenapiFirst::Router, spec: spec, raise_error: router_raise_error, parent_app: parent_app
-        use OpenapiFirst::RequestValidation, raise_error: request_validation_raise_error
-        use OpenapiFirst::ResponseValidation if response_validation
-        run OpenapiFirst::Responder.new(namespace: namespace, resolver: resolver)
-      end
-    end
-
-    def call(env)
-      @stack.call(env)
-    end
-  end
-end

data/lib/openapi_first/coverage.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  class Coverage
-    attr_reader :to_be_called
-
-    def initialize(app, spec)
-      @app = app
-      @spec = spec
-      @to_be_called = spec.operations.map do |operation|
-        endpoint_id(operation)
-      end
-    end
-
-    def call(env)
-      response = @app.call(env)
-      operation = env[OPERATION]
-      @to_be_called.delete(endpoint_id(operation)) if operation
-      response
-    end
-
-    private
-
-    def endpoint_id(operation)
-      "#{operation.path}##{operation.method}"
-    end
-  end
-end

data/lib/openapi_first/default_operation_resolver.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'utils'
-
-module OpenapiFirst
-  class DefaultOperationResolver
-    def initialize(namespace)
-      @namespace = namespace
-      @handlers = {}
-    end
-
-    def call(operation)
-      @handlers[operation.name] ||= begin
-        id = handler_id(operation)
-        find_handler(id) if id
-      end
-    end
-
-    def find_handler(id)
-      name = id.match(/:*(.*)/)&.to_a&.at(1)
-      return if name.nil?
-
-      catch :halt do
-        return find_class_method_handler(name) if name.include?('.')
-        return find_instance_method_handler(name) if name.include?('#')
-      end
-      method_name = Utils.underscore(name)
-      return unless @namespace.respond_to?(method_name)
-
-      @namespace.method(method_name)
-    end
-
-    def handler_id(operation)
-      id = operation['x-handler'] || operation['operationId']
-      if id.nil?
-        raise HandlerNotFoundError,
-              "operationId or x-handler is missing in '#{operation.method} #{operation.path}' so I cannot find a handler for this operation." # rubocop:disable Layout/LineLength
-      end
-
-      id
-    end
-
-    def find_class_method_handler(name)
-      module_name, method_name = name.split('.')
-      klass = find_const(@namespace, module_name)
-      klass.method(Utils.underscore(method_name))
-    end
-
-    def find_instance_method_handler(name)
-      module_name, klass_name = name.split('#')
-      const = find_const(@namespace, module_name)
-      klass = find_const(const, klass_name)
-      klass.new
-    end
-
-    def find_const(parent, name)
-      name = Utils.classify(name)
-      throw :halt unless parent.const_defined?(name, false)
-
-      parent.const_get(name, false)
-    end
-  end
-end

data/lib/openapi_first/inbox.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  # An instance of this gets passed to handler functions in the Responder.
-  class Inbox < Hash
-    attr_reader :env
-
-    def initialize(env)
-      @env = env
-      super()
-    end
-  end
-end

data/lib/openapi_first/rack_responder.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'responder'
-
-module OpenapiFirst
-  class RackResponder < Responder
-    def call(env)
-      operation = env[OpenapiFirst::OPERATION]
-      find_handler(operation)&.call(env)
-    end
-  end
-end

data/lib/openapi_first/responder.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack'
-require 'multi_json'
-require_relative 'inbox'
-require_relative 'default_operation_resolver'
-
-module OpenapiFirst
-  class Responder
-    def initialize(namespace: nil, resolver: nil)
-      @resolver = resolver || DefaultOperationResolver.new(namespace)
-      @namespace = namespace
-    end
-
-    def call(env)
-      operation = env[OpenapiFirst::OPERATION]
-      res = Rack::Response.new
-      handler = find_handler(operation)
-      result = handler.call(inbox(env), res)
-      res.write serialize(result) if result && res.body.empty?
-      res[Rack::CONTENT_TYPE] ||= operation.content_types_for(res.status)&.first
-      res.finish
-    end
-
-    private
-
-    def inbox(env)
-      Inbox.new(env).tap { |i| i.merge!(env[INBOX]) if env[INBOX] }
-    end
-
-    def find_handler(operation)
-      handler = @resolver.call(operation)
-      raise NotImplementedError, "Could not find handler for #{operation.name}" unless handler
-
-      handler
-    end
-
-    def serialize(result)
-      return result if result.is_a?(String)
-
-      MultiJson.dump(result)
-    end
-  end
-end

data/lib/openapi_first/response_object.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module OpenapiFirst
-  # Represents an OpenAPI Response Object
-  class ResponseObject
-    extend Forwardable
-    def_delegators :@parsed,
-                   :content
-
-    def_delegators :@raw,
-                   :[]
-
-    def initialize(parsed)
-      @parsed = parsed
-      @raw = parsed.raw
-    end
-  end
-end

data/lib/openapi_first/validation.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  class Validation
-    attr_reader :errors
-
-    def initialize(errors)
-      @errors = errors
-    end
-
-    def errors?
-      !errors.empty?
-    end
-  end
-end