openapi_first 0.6.10 → 0.7.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07a70e89bc5624bdd59ce6b021bca7482f583a0b2a6b3b38e77f7241ec99b5b9
-  data.tar.gz: cd4de92064ab68e06726e08bf7095b0f559686621ba09c5c18ce903e73941555
+  metadata.gz: 4885473ec6373b0fcfd9baace6175296f362099ba8ee73de0b8c1538b3420504
+  data.tar.gz: 5a72ae579e67bcb17c33debb3adbcae1cdaae09ad98ccc0e1158a59719d00115
 SHA512:
-  metadata.gz: 757428e2000f46da3575d0e3b7614a5e4e23c93dde1dd178cda0266b7e065dd84d2acf4310b2567176e58f8fbfa74e9a8b3cf712001bac351f8a07671a2ab371
-  data.tar.gz: c295ac507d28d0c30b6454c74ee5c74777d004cae60bbad0498345b775630260177cdcc86f586a9e16360eb1547fce1f52c7d1e0f148af4ce56d0a6eca65d0a8
+  metadata.gz: d2783c23798622b8bcc6c6f9520272d0477760d405f9879d4dc39e94b1d361b3873a87147ccef81e0ba3ec5c59e67941f645e41caf52dd221ddb915167140c6d
+  data.tar.gz: d540387f504454feca50ea746ef87745aed68e841bc5eb734c8d2e3419676e221a8dd93404601f010e3725152cd0e0e9a2775a1646690b8f4e5b62fbd8d7ca93

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+- Make use of hanami-router, because it's fast
+- Remove OpenapiFirst::Coverage
+- Remove option `allow_unknown_query_paramerters`
+- Move the namespace option to Router
+- Convert numeric parameters to `Integer` or `Float`
+
 ## 0.6.9
 - Removed radix tree, because of a bug (https://github.com/namusyaka/r2ree-ruby/issues/2)
 

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    openapi_first (0.6.10)
+    openapi_first (0.7.0.alpha1)
+      hanami-router (~> 2.0.alpha2)
+      hanami-utils (~> 2.0.alpha1)
       json_schemer (~> 0.2)
       multi_json (~> 1.14)
-      mustermann-contrib (~> 1.1.1)
       oas_parser (~> 0.24)
       rack (~> 2.2)
 
@@ -25,9 +26,16 @@ GEM
     concurrent-ruby (1.1.6)
     deep_merge (1.2.1)
     diff-lcs (1.3)
-    ecma-re-validator (0.2.1)
+    ecma-re-validator (0.2.0)
       regexp_parser (~> 1.2)
     hana (1.3.5)
+    hanami-router (2.0.0.alpha2)
+      mustermann (~> 1.0)
+      mustermann-contrib (~> 1.0)
+      rack (~> 2.0)
+    hanami-utils (2.0.0.alpha1)
+      concurrent-ruby (~> 1.0)
+      transproc (~> 1.0)
     hansi (0.2.0)
     hash-deep-merge (0.1.1)
     i18n (1.8.2)
@@ -38,7 +46,7 @@ GEM
       hana (~> 1.3)
       regexp_parser (~> 1.5)
       uri_template (~> 0.7)
-    method_source (0.9.2)
+    method_source (1.0.0)
     mini_portile2 (2.4.0)
     minitest (5.14.0)
     multi_json (1.14.1)
@@ -58,12 +66,12 @@ GEM
       mustermann-contrib (~> 1.1.1)
       nokogiri
     parallel (1.19.1)
-    parser (2.7.0.4)
+    parser (2.7.0.5)
       ast (~> 2.4.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    public_suffix (4.0.4)
+    pry (0.13.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    public_suffix (4.0.3)
     rack (2.2.2)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
@@ -77,7 +85,7 @@ GEM
       rspec-mocks (~> 3.9.0)
     rspec-core (3.9.1)
       rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    rspec-expectations (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
@@ -95,7 +103,8 @@ GEM
     ruby-progressbar (1.10.1)
     ruby2_keywords (0.0.2)
     thread_safe (0.3.6)
-    tzinfo (1.2.7)
+    transproc (1.1.1)
+    tzinfo (1.2.6)
       thread_safe (~> 0.1)
     unicode-display_width (1.6.1)
     uri_template (0.7.0)

data/README.md

@@ -36,8 +36,6 @@ Handler functions (`find_pet`) are called with two arguments:
 - `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`.
 
-You can also use the provided Rack middlewares to auto-implement only certain aspects of the request-response flow like query parameter or request body parameter validation based on your OpenAPI file. Read on to learn how.
-
 ### Handling only certain paths
 
 You can filter the URIs that should be handled by pass ing `only` to `OpenapiFirst.load`:
@@ -57,9 +55,9 @@ run OpenapiFirst.middleware('./openapi/openapi.yaml', namespace: Pets)
 
 When using the middleware, all requests that are not part of the API description will be passed to the next app.
 
-## Try it out
+### Try it out
 
-See [example](examples)
+See [examples](examples).
 
 
 ## Installation
@@ -72,21 +70,31 @@ gem 'openapi_first'
 
 OpenapiFirst uses [`multi_json`](https://rubygems.org/gems/multi_json).
 
-## How it works
+## Handlers
 
-OpenapiFirst offers Rack middlewares to auto-implement different aspects for request handling:
+OpenapiFirst 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.
 
-- Request validation
-- Mapping request to a function call
+It works like this:
 
-It starts by adding a router middleware:
+- "create_pet" or "createPet" or "create pet" calls `MyApi.create_pet(params, response)`
+- "some_things.create" calls: `MyApi::SomeThings.create(params, response)`
+- "pets#create" calls: `MyApi::Pets::Create.new.call(params, response)`
 
-```ruby
-spec = OpenapiFirst.load('petstore.yaml')
-use OpenapiFirst::Router, spec: spec
-```
+These handler methods 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
+
+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:
 
-If the request is not valid, these middlewares return a 400 status code with a body that describes the error. If unkwon routes in your application exist, which are not specified in the API description, set `:allow_unknown_operation` to `true`.
+- Calling `res.write "things"` (see [Rack::Response](https://www.rubydoc.info/github/rack/rack/Rack/Response))
+- Returning a value from the function (see example above) (this will always converted to JSON)
+
+## Request validation
+
+If the request is not valid, these middlewares return a 400 status code with a body that describes the error.
 
 The error responses conform with [JSON:API](https://jsonapi.org).
 
@@ -107,18 +115,12 @@ content-type: "application/vnd.api+json"
   ]
 }
 ```
-## Request validation
-
-```ruby
-# Add the middleware:
-use OpenapiFirst::RequestValidation
-```
 
-## Query parameter validation
+### Parameter validation
 
-By default OpenapiFirst does not allow additional query parameters and will respond with 400 if additional parameters are sent. You can allow additional parameters with `allow_allow_unknown_query_parameters: true`:
+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.
+Note that is currently does not convert date, date-time or time formats and that conversion is currently on done for path and query parameters, but not for request bodies.
 
-The middleware filteres all top-level query parameters and adds these to the Rack env: `env[OpenapiFirst::QUERY_PARAMS]`.
 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.
 
 _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))._
@@ -132,54 +134,6 @@ This will add the parsed request body to `env[OpenapiFirst::REQUEST_BODY]`.
 
 tbd.
 
-## Mapping the request to a method call
-
-OpenapiFirst uses a `OperationResolver` middleware to map the HTTP request to a method call.
-
-The resolver function is found via the [`operationId`](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#operation-object) attribute in your API description like this:
-
-- `create_pet` will map to `MyApi.create_pet(params, response)`
-- `some_things.create` will map to `MyApi::SomeThings.create(params, response)`
-- `pets#create` will map to `MyApi::Pets::Create.new.call(params, response)` (like [Hanami::Router](https://github.com/hanami/router#controllers))
-
-These handler methods 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
-
-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 from the function (see example above) (this will always converted to JSON)
-
-### Adding the middleware
-
-```ruby
-# Define some methods
-module MyApi
-  def self.create_pet(params, res)
-    res.status = 201
-    {
-      id: '1',
-      name: params['name']
-    }
-  end
-end
-
-# Add the middleware:
-use OpenapiFirst::OperationResolver, namespace: MyApi
-# If the operation was not found in the OAS file, the next app will be called
-
-# OR use it as a Rack app via `run`:
-run OpenapiFirst::OperationResolver, namespace: Pets
-# If the operation was not found, this will return 404
-
-# Now make a request like
-# POST /pets, { name: 'Oscar' }
-```
-
 ## Response validation
 
 Response validation is useful to make sure your app responds as described in your API description. You usually do this in your tests using [rack-test](https://github.com/rack-test/rack-test).

data/benchmarks/Gemfile

@@ -6,7 +6,7 @@ gem 'benchmark-ips'
 gem 'benchmark-memory'
 gem 'committee'
 gem 'grape'
-gem 'hanami-router', '~> 2.0.0.alpha1'
+gem 'hanami-router', '~> 2.0.0.alpha2'
 gem 'multi_json'
 gem 'openapi_first', path: '../'
 gem 'sinatra'

data/benchmarks/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: ..
   specs:
-    openapi_first (0.6.9)
+    openapi_first (0.7.0.alpha1)
+      hanami-router (~> 2.0.alpha2)
+      hanami-utils (~> 2.0.alpha1)
       json_schemer (~> 0.2)
       multi_json (~> 1.14)
-      mustermann-contrib (~> 1.1.1)
       oas_parser (~> 0.24)
       rack (~> 2.2)
 
@@ -44,7 +45,7 @@ GEM
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.2)
       dry-equalizer (~> 0.2)
-    dry-types (1.3.1)
+    dry-types (1.4.0)
       concurrent-ruby (~> 1.0)
       dry-container (~> 0.3)
       dry-core (~> 0.4, >= 0.4.4)
@@ -65,12 +66,15 @@ GEM
       mustermann (~> 1.0)
       mustermann-contrib (~> 1.0)
       rack (~> 2.0)
+    hanami-utils (2.0.0.alpha1)
+      concurrent-ruby (~> 1.0)
+      transproc (~> 1.0)
     hansi (0.2.0)
     hash-deep-merge (0.1.1)
     i18n (1.8.2)
       concurrent-ruby (~> 1.0)
     json_schema (0.20.8)
-    json_schemer (0.2.10)
+    json_schemer (0.2.11)
       ecma-re-validator (~> 0.2)
       hana (~> 1.3)
       regexp_parser (~> 1.5)
@@ -116,6 +120,7 @@ GEM
       seg
     thread_safe (0.3.6)
     tilt (2.0.10)
+    transproc (1.1.1)
     tzinfo (1.2.6)
       thread_safe (~> 0.1)
     uri_template (0.7.0)
@@ -129,7 +134,7 @@ DEPENDENCIES
   benchmark-memory
   committee
   grape
-  hanami-router (~> 2.0.0.alpha1)
+  hanami-router (~> 2.0.0.alpha2)
   multi_json
   openapi_first!
   sinatra

data/benchmarks/apps/openapi_first_resolve_only.ru

@@ -19,5 +19,5 @@ namespace = Module.new do
 end
 
 spec = OpenapiFirst.load(File.absolute_path('./openapi.yaml', __dir__))
-use OpenapiFirst::Router, spec: spec
-run OpenapiFirst::OperationResolver.new(namespace: namespace)
+use OpenapiFirst::Router, spec: spec, namespace: namespace
+run OpenapiFirst::OperationResolver.new

data/lib/openapi_first/app.rb

@@ -5,18 +5,18 @@ require 'rack'
 module OpenapiFirst
   class App
     def initialize(
-      app,
+      parent_app,
       spec,
-      namespace:,
-      allow_unknown_operation: !app.nil?
+      namespace:
     )
       @stack = Rack::Builder.app do
         freeze_app
         use OpenapiFirst::Router,
             spec: spec,
-            allow_unknown_operation: allow_unknown_operation
+            namespace: namespace,
+            parent_app: parent_app
         use OpenapiFirst::RequestValidation
-        run OpenapiFirst::OperationResolver.new(app, namespace: namespace)
+        run OpenapiFirst::OperationResolver.new
       end
     end
 

data/lib/openapi_first/coverage.rb

@@ -13,15 +13,16 @@ module OpenapiFirst
     end
 
     def call(env)
-      operation = @spec.find_operation(Rack::Request.new(env))
+      response = @app.call(env)
+      operation = env[OPERATION]
       @to_be_called.delete(endpoint_id(operation)) if operation
-      @app.call(env)
+      response
     end
 
     private
 
     def endpoint_id(operation)
-      "#{operation.path.path}##{operation.method}"
+      "#{operation.path}##{operation.method}"
     end
   end
 end

data/lib/openapi_first/definition.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'operation'
+
 module OpenapiFirst
   class Definition
     def initialize(parsed)
@@ -7,7 +9,7 @@ module OpenapiFirst
     end
 
     def operations
-      @spec.endpoints
+      @spec.endpoints.map { |e| Operation.new(e) }
     end
 
     def find_operation!(request)

data/lib/openapi_first/operation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module OpenapiFirst
+  class Operation
+    extend Forwardable
+    def_delegators :@operation,
+                   :parameters,
+                   :method,
+                   :request_body,
+                   :operation_id
+
+    def initialize(parsed)
+      @operation = parsed
+    end
+
+    def path
+      @operation.path.path
+    end
+
+    def parameters_json_schema
+      @parameters_json_schema ||= build_parameters_json_schema
+    end
+
+    def content_type_for(status)
+      content = @operation
+                .response_by_code(status.to_s, use_default: true)
+                .content
+      content.keys[0] if content
+    end
+
+    private
+
+    def build_parameters_json_schema
+      return unless @operation.parameters&.any?
+
+      @operation.parameters.each_with_object(
+        'type' => 'object',
+        'required' => [],
+        'properties' => {}
+      ) do |parameter, schema|
+        schema['required'] << parameter.name if parameter.required
+        schema['properties'][parameter.name] = parameter.schema
+      end
+    end
+  end
+end

data/lib/openapi_first/operation_resolver.rb

@@ -4,55 +4,28 @@ require 'rack'
 
 module OpenapiFirst
   class OperationResolver
-    NOT_FOUND = Rack::Response.new('', 404).finish.freeze
-    DEFAULT_APP = ->(_env) { NOT_FOUND }
-
-    def initialize(app = DEFAULT_APP, options) # rubocop:disable Style/OptionalArguments
-      @app = app
-      @namespace = options.fetch(:namespace)
-    end
-
-    def call(env) # rubocop:disable Metrics/AbcSize
+    def call(env)
       operation = env[OpenapiFirst::OPERATION]
-      return @app.call(env) unless operation
-
-      operation_id = operation.operation_id
       res = Rack::Response.new
       params = build_params(env)
-      handler = find_handler(operation_id)
+      handler = env[HANDLER]
       result = handler.call(params, res)
-      res.write MultiJson.dump(result) if result && res.body.empty?
-      res[Rack::CONTENT_TYPE] ||= find_content_type(operation, res.status)
+      res.write serialize(result) if result && res.body.empty?
+      res[Rack::CONTENT_TYPE] ||= operation.content_type_for(res.status)
       res.finish
     end
 
-    def find_handler(operation_id)
-      if operation_id.include?('.')
-        module_name, method_name = operation_id.split('.')
-        return @namespace.const_get(module_name.camelize).method(method_name)
-      end
-
-      if operation_id.include?('#')
-        module_name, class_name = operation_id.split('#')
-        return @namespace.const_get(module_name.camelize)
-                         .const_get(class_name.camelize).new
-      end
-      @namespace.method(operation_id)
-    end
-
     private
 
-    def find_content_type(operation, status)
-      content = operation
-                .response_by_code(status.to_s, use_default: true)
-                .content
-      content.keys[0] if content
+    def serialize(result)
+      return result if result.is_a?(String)
+
+      MultiJson.dump(result)
     end
 
     def build_params(env)
       sources = [
-        env[PATH_PARAMS],
-        env[QUERY_PARAMS],
+        env[PARAMS],
         env[REQUEST_BODY]
       ].tap(&:compact!)
       Params.new(env).merge!(*sources)
@@ -64,7 +37,7 @@ module OpenapiFirst
 
     def initialize(env)
       @env = env
-      super()
+      super
     end
   end
 end

data/lib/openapi_first/request_validation.rb

@@ -3,25 +3,21 @@
 require 'rack'
 require 'json_schemer'
 require 'multi_json'
-require_relative 'query_parameters'
 require_relative 'validation_format'
 
 module OpenapiFirst
-  class RequestValidation
-    def initialize(app, options = {})
+  class RequestValidation # rubocop:disable Metrics/ClassLength
+    def initialize(app, _options = {})
       @app = app
-      @allow_unknown_query_parameters = options.fetch(
-        :allow_unknown_query_parameters, false
-      )
     end
 
     def call(env) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       operation = env[OpenapiFirst::OPERATION]
       return @app.call(env) unless operation
 
-      req = Rack::Request.new(env)
       catch(:halt) do
-        validate_query_parameters!(env, operation, req.params)
+        validate_query_parameters!(env, operation, env[PARAMS])
+        req = Rack::Request.new(env)
         content_type = req.content_type
         return @app.call(env) unless operation.request_body
 
@@ -33,6 +29,8 @@ module OpenapiFirst
       end
     end
 
+    private
+
     def halt(response)
       throw :halt, response
     end
@@ -83,10 +81,10 @@ module OpenapiFirst
       ).finish
     end
 
-    def request_body_schema(content_type, endpoint)
-      return unless endpoint
+    def request_body_schema(content_type, operation)
+      return unless operation
 
-      endpoint.request_body.content[content_type]&.fetch('schema')
+      operation.request_body.content[content_type]&.fetch('schema')
     end
 
     def serialize_request_body_errors(validation_errors)
@@ -100,27 +98,25 @@ module OpenapiFirst
     end
 
     def validate_query_parameters!(env, operation, params)
-      json_schema = QueryParameters.new(
-        operation: operation,
-        allow_unknown_parameters: @allow_unknown_query_parameters
-      ).to_json_schema
-
+      json_schema = operation.parameters_json_schema
       return unless json_schema
 
+      params = filtered_params(json_schema, params)
       errors = JSONSchemer.schema(json_schema).validate(params)
       if errors.any?
         halt error_response(400, serialize_query_parameter_errors(errors))
       end
-      env[QUERY_PARAMS] = allowed_params(json_schema, params)
+      env[PARAMS] = params
     end
 
-    def allowed_params(json_schema, params)
+    def filtered_params(json_schema, params)
       json_schema['properties']
-        .keys
-        .each_with_object({}) do |parameter_name, filtered|
+        .each_with_object({}) do |key_value, result|
+          parameter_name, schema = key_value
           next unless params.key?(parameter_name)
 
-          filtered[parameter_name] = params[parameter_name]
+          value = params[parameter_name]
+          result[parameter_name] = parse_parameter(value, schema)
         end
     end
 
@@ -131,5 +127,18 @@ module OpenapiFirst
         }.update(ValidationFormat.error_details(error))
       end
     end
+
+    def parse_parameter(value, schema)
+      return filtered_params(schema, value) if schema['properties']
+
+      begin
+        return Integer(value, 10) if schema['type'] == 'integer'
+        return Float(value) if schema['type'] == 'number'
+      rescue ArgumentError
+        value
+      end
+
+      value
+    end
   end
 end

data/lib/openapi_first/router.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 require 'rack'
-require 'json_schemer'
-require 'multi_json'
-require 'mustermann/template'
+require 'hanami/router'
+require_relative 'utils'
 
 module OpenapiFirst
   class Router
@@ -11,25 +10,75 @@ module OpenapiFirst
 
     def initialize(app, options)
       @app = app
-      @spec = options.fetch(:spec)
-      @allow_unknown_operation = options.fetch(:allow_unknown_operation, false)
+      @namespace = options.fetch(:namespace)
+      @parent_app = options.fetch(:parent_app, nil)
+      @router = build_router(options.fetch(:spec).operations)
     end
 
     def call(env)
-      req = Rack::Request.new(env)
-      operation = env[OPERATION] = @spec.find_operation(req)
-      path_params = find_path_params(operation, req)
-      env[PATH_PARAMS] = path_params if path_params
-      return @app.call(env) if operation || @allow_unknown_operation
+      route = @router.recognize(env)
+      return route.endpoint.call(env) if route.routable?
+
+      return @parent_app.call(env) if @parent_app
 
       NOT_FOUND
     end
 
-    def find_path_params(operation, req)
-      return unless operation&.path_parameters&.any?
+    def find_handler(operation_id) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      name = operation_id.match(/:*(.*)/)&.to_a&.at(1)
+      return if name.nil?
+
+      if name.include?('.')
+        module_name, method_name = name.split('.')
+        klass = find_const(@namespace, module_name)
+        return klass&.method(Utils.underscore(method_name))
+      end
+      if name.include?('#')
+        module_name, klass_name = name.split('#')
+        const = find_const(@namespace, module_name)
+        klass = find_const(const, klass_name)
+        return ->(params, res) { klass.new.call(params, res) }
+      end
+      method_name = Utils.underscore(name)
+      return unless @namespace.respond_to?(method_name)
+
+      @namespace.method(method_name)
+    end
+
+    private
+
+    def find_const(parent, name)
+      name = Utils.classify(name)
+      return unless parent.const_defined?(name, false)
+
+      parent.const_get(name, false)
+    end
 
-      pattern = Mustermann::Template.new(operation.path.path)
-      pattern.params(req.path)
+    def build_router(operations) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      router = Hanami::Router.new {}
+      operations.each do |operation|
+        normalized_path = operation.path.gsub('{', ':').gsub('}', '')
+        if operation.operation_id.nil?
+          warn "operationId is missing in '#{operation.method} #{operation.path}'. I am ignoring this operation." # rubocop:disable Layout/LineLength
+          next
+        end
+        handler = find_handler(operation.operation_id)
+        if handler.nil?
+          warn "could not find handler for '#{operation.operation_id}' (#{operation.method} #{operation.path}). I am ignoring this operation." # rubocop:disable Layout/LineLength
+          next
+        end
+        router.public_send(
+          operation.method,
+          normalized_path,
+          to: lambda do |env|
+            env[OPERATION] = operation
+            env[PARAMS] = Utils.deep_stringify(env['router.params'])
+            env[HANDLER] = handler
+            @app.call(env)
+          end
+        )
+      end
+      router
     end
   end
 end

data/lib/openapi_first/utils.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'hanami/utils/string'
+
+module OpenapiFirst
+  module Utils
+    def self.underscore(string)
+      Hanami::Utils::String.underscore(string)
+    end
+
+    def self.classify(string)
+      Hanami::Utils::String.classify(string)
+    end
+
+    def self.deep_stringify(params) # rubocop:disable Metrics/MethodLength
+      params.each_with_object({}) do |(key, value), output|
+        output[key.to_s] =
+          case value
+          when ::Hash
+            deep_stringify(value)
+          when Array
+            value.map do |item|
+              item.is_a?(::Hash) ? deep_stringify(item) : item
+            end
+          else
+            value
+          end
+      end
+    end
+  end
+end

data/lib/openapi_first/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiFirst
-  VERSION = '0.6.10'
+  VERSION = '0.7.0.alpha1'
 end

data/lib/openapi_first.rb

@@ -12,9 +12,9 @@ require 'openapi_first/app'
 
 module OpenapiFirst
   OPERATION = 'openapi_first.operation'
-  PATH_PARAMS = 'openapi_first.path_params'
+  PARAMS = 'openapi_first.params'
   REQUEST_BODY = 'openapi_first.parsed_request_body'
-  QUERY_PARAMS = 'openapi_first.query_params'
+  HANDLER = 'openapi_first.handler'
 
   def self.load(spec_path, only: nil)
     content = YAML.load_file(spec_path)

data/openapi_first.gemspec

@@ -32,9 +32,10 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'hanami-router', '~> 2.0.alpha2'
+  spec.add_dependency 'hanami-utils', '~> 2.0.alpha1'
   spec.add_dependency 'json_schemer', '~> 0.2'
   spec.add_dependency 'multi_json', '~> 1.14'
-  spec.add_dependency 'mustermann-contrib', '~> 1.1.1'
   spec.add_dependency 'oas_parser', '~> 0.24'
   spec.add_dependency 'rack', '~> 2.2'
 

metadata

@@ -1,57 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: openapi_first
 version: !ruby/object:Gem::Version
-  version: 0.6.10
+  version: 0.7.0.alpha1
 platform: ruby
 authors:
 - Andreas Haller
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-17 00:00:00.000000000 Z
+date: 2020-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: json_schemer
+  name: hanami-router
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 2.0.alpha2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 2.0.alpha2
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: hanami-utils
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: 2.0.alpha1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: 2.0.alpha1
 - !ruby/object:Gem::Dependency
-  name: mustermann-contrib
+  name: json_schemer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
 - !ruby/object:Gem::Dependency
   name: oas_parser
   requirement: !ruby/object:Gem::Requirement
@@ -160,7 +174,6 @@ files:
 - benchmarks/apps/hanami_router.ru
 - benchmarks/apps/openapi.yaml
 - benchmarks/apps/openapi_first.ru
-- benchmarks/apps/openapi_first_request_validation_only.ru
 - benchmarks/apps/openapi_first_resolve_only.ru
 - benchmarks/apps/sinatra.ru
 - benchmarks/apps/syro.ru
@@ -175,11 +188,12 @@ files:
 - lib/openapi_first/app.rb
 - lib/openapi_first/coverage.rb
 - lib/openapi_first/definition.rb
+- lib/openapi_first/operation.rb
 - lib/openapi_first/operation_resolver.rb
-- lib/openapi_first/query_parameters.rb
 - lib/openapi_first/request_validation.rb
 - lib/openapi_first/response_validator.rb
 - lib/openapi_first/router.rb
+- lib/openapi_first/utils.rb
 - lib/openapi_first/validation.rb
 - lib/openapi_first/validation_format.rb
 - lib/openapi_first/version.rb
@@ -202,9 +216,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.2
 signing_key: 

data/benchmarks/apps/openapi_first_request_validation_only.ru

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'openapi_first'
-require 'syro'
-require 'multi_json'
-
-app = Syro.new do
-  on 'hello' do
-    on :id do
-      get do
-        res.json MultiJson.dump(hello: 'world', id: inbox[:id])
-      end
-    end
-
-    get do
-      res.json [MultiJson.dump(hello: 'world')]
-    end
-
-    post do
-      res.status = 201
-      res.json MultiJson.dump(hello: 'world')
-    end
-  end
-end
-
-spec = OpenapiFirst.load(File.absolute_path('./openapi.yaml', __dir__))
-use OpenapiFirst::Router, spec: spec
-use OpenapiFirst::RequestValidation
-
-run app

data/lib/openapi_first/query_parameters.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  class QueryParameters
-    def initialize(operation:, allow_unknown_parameters: false)
-      @operation = operation
-      @allow_unknown_parameters = allow_unknown_parameters
-    end
-
-    def to_json_schema
-      return unless @operation&.query_parameters&.any?
-
-      @operation.query_parameters.each_with_object(
-        'type' => 'object',
-        'required' => [],
-        'additionalProperties' => @allow_unknown_parameters,
-        'properties' => {}
-      ) do |parameter, schema|
-        schema['required'] << parameter.name if parameter.required
-        schema['properties'][parameter.name] = parameter.schema
-      end
-    end
-  end
-end