openapi_first 0.20.0 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 033e7d24a78ecd8cd0c98bad90e49949612c47a2d0b83791cca3ec7149e91ff6
-  data.tar.gz: f2092ebe5ee49b86b9745c2a1d27d4a71b798ed1d91f1fad6ea8cc9750f3ddff
+  metadata.gz: 2248133fb2e0b761fb314629dcbfa7c9a6b7e0ac03b59887fe158968b17ed827
+  data.tar.gz: b0012d8af3c9dee1fa94334be7890e260f0173946129b53ec8f930f768f8de28
 SHA512:
-  metadata.gz: fc80eff5d2f0c30d1df07d9e7d58cec4dfab41b05467e503dfc4200c11670fe336d1f7ac723b770798708006419ddc1da689ce862b12385d673f03f9a4d4aef4
-  data.tar.gz: dbf86b5ce8a3b23f12af0311a5bad788b0b9841deff4f8170fe7de17acbad230b9a65806abf7eb73958bd123a76820f54b84f92a2c09a2dd54364c47bf5203f9
+  metadata.gz: c615c847efcd10cfd145bcc99ede55da2eaa76fe91b9d0ab3fdb159c20b6cc314309f583ba0b784c3e3493a7a534ed1836309807c549bd8c40b226f2f9bf77e9
+  data.tar.gz: 83c476b9b67ce15ad71e052af8360e013659da13fbbd8f86a55bae9d4bbcf08f4ac291187dfccc5786e957c65d2a3124366f007998c675b4a3e29bccaecf332a

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.0.5
   NewCops: enable
   SuggestExtensions: false
 Style/Documentation:

data/CHANGELOG.md

@@ -1,8 +1,26 @@
 # 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
+
+- Fix: Query parameter validation does not fail if header parameters are defined (Thanks to [JF Lalonde](https://github.com/JF-Lalonde))
+- Update Ruby dependency to >= 3.0.5
+- Handle simple form-data in request bodies (see https://github.com/ahx/openapi_first/issues/149)
+- Update to hanami-router 2.0.0 stable
 
 ## 0.20.0
+
 - You can pass a filepath to `spec:` now so you no longer have to call `OpenapiFirst.load` anymore.
 - Router is optional now.
   You no longer have to add `Router` to your middleware stack. You still can add it to customize behaviour by setting options, but you no longer have to add it.
@@ -49,7 +67,7 @@ Yanked. No useful changes.
 
 ## 0.14.1
 
-- Bugfix: Don't mix path- and operation-level parameters for request validation
+- Fix: Don't mix path- and operation-level parameters for request validation
 
 ## 0.14.0
 

data/Gemfile.lock

@@ -1,101 +1,110 @@
 PATH
   remote: .
   specs:
-    openapi_first (0.20.0)
+    openapi_first (1.0.0.beta1)
       deep_merge (>= 1.2.1)
-      hanami-router (= 2.0.alpha5)
-      hanami-utils (= 2.0.alpha3)
+      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:
     ast (2.4.2)
     coderay (1.1.3)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.2.2)
     deep_merge (1.2.2)
     diff-lcs (1.5.0)
-    dry-transformer (0.1.1)
+    dry-core (1.0.0)
+      concurrent-ruby (~> 1.0)
+      zeitwerk (~> 2.6)
+    dry-transformer (1.0.1)
+      zeitwerk (~> 2.6)
     ecma-re-validator (0.4.0)
       regexp_parser (~> 2.2)
     hana (1.3.7)
-    hanami-router (2.0.0.alpha5)
-      mustermann (~> 1.0)
-      mustermann-contrib (~> 1.0)
+    hanami-router (2.0.2)
+      mustermann (~> 3.0)
+      mustermann-contrib (~> 3.0)
       rack (~> 2.0)
-    hanami-utils (2.0.0.alpha3)
+    hanami-utils (2.0.3)
       concurrent-ruby (~> 1.0)
-      dry-transformer (~> 0.1)
+      dry-core (~> 1.0, < 2)
+      dry-transformer (~> 1.0, < 2)
     hansi (0.2.1)
-    json (2.6.2)
+    json (2.6.3)
     json_refs (0.1.7)
       hana
-    json_schemer (0.2.22)
+    json_schemer (0.2.24)
       ecma-re-validator (~> 0.3)
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       uri_template (~> 0.7)
     method_source (1.0.0)
     multi_json (1.15.0)
-    mustermann (1.1.2)
+    mustermann (3.0.0)
       ruby2_keywords (~> 0.0.1)
-    mustermann-contrib (1.1.2)
+    mustermann-contrib (3.0.0)
       hansi (~> 0.2.0)
-      mustermann (= 1.1.2)
+      mustermann (= 3.0.0)
+    openapi_parameters (0.2.0)
+      rack (>= 2.2)
+      zeitwerk (~> 2.6)
     parallel (1.22.1)
-    parser (3.1.2.1)
+    parser (3.2.1.1)
       ast (~> 2.4.1)
-    pry (0.14.1)
+    pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    rack (2.2.4)
+    rack (2.2.6.4)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.6.0)
+    regexp_parser (2.7.0)
     rexml (3.2.5)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
       rspec-expectations (~> 3.12.0)
       rspec-mocks (~> 3.12.0)
-    rspec-core (3.12.0)
+    rspec-core (3.12.1)
       rspec-support (~> 3.12.0)
-    rspec-expectations (3.12.0)
+    rspec-expectations (3.12.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.0)
+    rspec-mocks (3.12.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.0)
-    rubocop (1.37.1)
+    rubocop (1.48.1)
       json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.1.2.1)
+      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.23.0, < 2.0)
+      rubocop-ast (>= 1.26.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.23.0)
-      parser (>= 3.1.1.0)
-    ruby-progressbar (1.11.0)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.28.0)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)
-    unicode-display_width (2.3.0)
+    unicode-display_width (2.4.2)
     uri_template (0.7.0)
+    zeitwerk (2.6.7)
 
 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)
@@ -103,4 +112,4 @@ DEPENDENCIES
   rubocop
 
 BUNDLED WITH
-   2.3.7
+   2.3.10

data/README.md

@@ -6,35 +6,25 @@ 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
 
 This middleware returns a 400 status code with a body that describes the error if the request is not valid.
 
 ```ruby
-use OpenapiFirst::RequestValidatio, spec: 'openapi.yaml'
+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
 
@@ -110,132 +102,27 @@ use OpenapiFirst::ResponseValidation, spec: 'openapi.yaml' if ENV['RACK_ENV'] ==
 
 ## OpenapiFirst::Router
 
-This middleware first always used automatically, but you can add it to the top of your middleware stack if you want to change configuration.
+This middleware is used automatically, but you can add it to the top of your middleware stack if you want to change configuration.
 
 ```ruby
 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
 
 | Name           | Possible values      | Description                                                                                                                                                                                                                                                     | Default                            |
 | :------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
-| `spec:`        |                      | The path to the spec file or spec loaded via `OpenapiFirst.load`
-                                                                                                  |                                    |
+| `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)      |
 
-## 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
 
@@ -269,48 +156,10 @@ validator.validate(last_request, last_response)
 You can filter the URIs that should be handled by passing `only` to `OpenapiFirst.load`:
 
 ```ruby
-spec = OpenapiFirst.load('./openapi/openapi.yaml', only: '/pets'.method(:==))
+spec = OpenapiFirst.load('./openapi/openapi.yaml', only: { |path| path.starts_with? '/pets' })
 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,55 +1,53 @@
 PATH
   remote: ..
   specs:
-    openapi_first (0.20.0)
+    openapi_first (1.0.0.beta1)
       deep_merge (>= 1.2.1)
-      hanami-router (= 2.0.alpha5)
-      hanami-utils (= 2.0.alpha3)
+      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.2.3)
+    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.10.0)
+    benchmark-ips (2.12.0)
     benchmark-memory (0.2.0)
       memory_profiler (~> 1)
     builder (3.2.4)
-    committee (4.4.0)
+    committee (5.0.0)
       json_schema (~> 0.14, >= 0.14.3)
-      openapi_parser (>= 0.11.1, < 1.0)
+      openapi_parser (~> 1.0)
       rack (>= 1.5)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.2.2)
     deep_merge (1.2.2)
-    dry-configurable (0.14.0)
+    dry-core (1.0.0)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.6)
-    dry-container (0.9.0)
+      zeitwerk (~> 2.6)
+    dry-inflector (1.0.0)
+    dry-logic (1.5.0)
       concurrent-ruby (~> 1.0)
-      dry-configurable (~> 0.13, >= 0.13.0)
-    dry-core (0.7.1)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-transformer (1.0.1)
+      zeitwerk (~> 2.6)
+    dry-types (1.7.1)
       concurrent-ruby (~> 1.0)
-    dry-inflector (0.2.1)
-    dry-logic (1.2.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.5, >= 0.5)
-    dry-transformer (0.1.1)
-    dry-types (1.5.1)
-      concurrent-ruby (~> 1.0)
-      dry-container (~> 0.3)
-      dry-core (~> 0.5, >= 0.5)
-      dry-inflector (~> 0.1, >= 0.1.2)
-      dry-logic (~> 1.0, >= 1.0.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)
-    grape (1.6.2)
+    grape (1.7.0)
       activesupport
       builder
       dry-types (>= 1.1)
@@ -57,62 +55,64 @@ GEM
       rack (>= 1.3.0)
       rack-accept
     hana (1.3.7)
-    hanami-api (0.2.0)
-      hanami-router (~> 2.0.alpha)
-    hanami-router (2.0.0.alpha5)
-      mustermann (~> 1.0)
-      mustermann-contrib (~> 1.0)
+    hanami-api (0.3.0)
+      hanami-router (~> 2.0)
+    hanami-router (2.0.2)
+      mustermann (~> 3.0)
+      mustermann-contrib (~> 3.0)
       rack (~> 2.0)
-    hanami-utils (2.0.0.alpha3)
+    hanami-utils (2.0.3)
       concurrent-ruby (~> 1.0)
-      dry-transformer (~> 0.1)
-    hansi (0.2.0)
-    i18n (1.10.0)
+      dry-core (~> 1.0, < 2)
+      dry-transformer (~> 1.0, < 2)
+    hansi (0.2.1)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     json_refs (0.1.7)
       hana
     json_schema (0.21.0)
-    json_schemer (0.2.22)
+    json_schemer (0.2.24)
       ecma-re-validator (~> 0.3)
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       uri_template (~> 0.7)
-    memory_profiler (1.0.0)
-    minitest (5.15.0)
+    memory_profiler (1.0.1)
+    minitest (5.18.0)
     multi_json (1.15.0)
-    mustermann (1.1.1)
+    mustermann (3.0.0)
       ruby2_keywords (~> 0.0.1)
-    mustermann-contrib (1.1.1)
+    mustermann-contrib (3.0.0)
       hansi (~> 0.2.0)
-      mustermann (= 1.1.1)
-    mustermann-grape (1.0.1)
+      mustermann (= 3.0.0)
+    mustermann-grape (1.0.2)
       mustermann (>= 1.0.0)
     nio4r (2.5.8)
-    openapi_parser (0.15.0)
-    puma (5.6.5)
+    openapi_parser (1.0.0)
+    puma (6.2.0)
       nio4r (~> 2.0)
-    rack (2.2.3.1)
+    rack (2.2.6.4)
     rack-accept (0.4.5)
       rack (>= 0.4)
-    rack-protection (2.2.0)
+    rack-protection (3.0.5)
       rack
-    regexp_parser (2.6.0)
-    roda (3.54.0)
+    regexp_parser (2.8.0)
+    roda (3.66.0)
       rack
     ruby2_keywords (0.0.5)
     seg (1.2.0)
-    sinatra (2.2.0)
-      mustermann (~> 1.0)
-      rack (~> 2.2)
-      rack-protection (= 2.2.0)
+    sinatra (3.0.5)
+      mustermann (~> 3.0)
+      rack (~> 2.2, >= 2.2.4)
+      rack-protection (= 3.0.5)
       tilt (~> 2.0)
     syro (3.2.1)
       rack (>= 1.6.0)
       seg
-    tilt (2.0.10)
-    tzinfo (2.0.4)
+    tilt (2.1.0)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     uri_template (0.7.0)
+    zeitwerk (2.6.7)
 
 PLATFORMS
   arm64-darwin-21

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)