openapi_first 0.10.2 → 0.12.0

data/benchmarks/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: ..
   specs:
-    openapi_first (0.10.2)
+    openapi_first (0.12.0)
       deep_merge (>= 1.2.1)
-      hanami-router (~> 2.0.alpha2)
+      hanami-router (~> 2.0.alpha3)
       hanami-utils (~> 2.0.alpha1)
       json_schemer (~> 0.2)
       multi_json (~> 1.14)
@@ -13,7 +13,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3)
+    activesupport (6.0.3.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -25,9 +25,9 @@ GEM
     benchmark-memory (0.1.2)
       memory_profiler (~> 0.9)
     builder (3.2.4)
-    committee (3.3.0)
+    committee (4.0.0)
       json_schema (~> 0.14, >= 0.14.3)
-      openapi_parser (>= 0.6.1)
+      openapi_parser (>= 0.11.1)
       rack (>= 1.5)
     concurrent-ruby (1.1.6)
     deep_merge (1.2.1)
@@ -55,7 +55,7 @@ GEM
       dry-logic (~> 1.0, >= 1.0.2)
     ecma-re-validator (0.2.1)
       regexp_parser (~> 1.2)
-    grape (1.3.2)
+    grape (1.3.3)
       activesupport
       builder
       dry-types (>= 1.1)
@@ -63,7 +63,7 @@ GEM
       rack (>= 1.3.0)
       rack-accept
     hana (1.3.6)
-    hanami-router (2.0.0.alpha2)
+    hanami-router (2.0.0.alpha3)
       mustermann (~> 1.0)
       mustermann-contrib (~> 1.0)
       rack (~> 2.0)
@@ -72,7 +72,7 @@ GEM
       transproc (~> 1.0)
     hansi (0.2.0)
     hash-deep-merge (0.1.1)
-    i18n (1.8.2)
+    i18n (1.8.3)
       concurrent-ruby (~> 1.0)
     json_schema (0.20.8)
     json_schemer (0.2.11)
@@ -82,7 +82,7 @@ GEM
       uri_template (~> 0.7)
     memory_profiler (0.9.14)
     mini_portile2 (2.4.0)
-    minitest (5.14.0)
+    minitest (5.14.1)
     multi_json (1.14.1)
     mustermann (1.1.1)
       ruby2_keywords (~> 0.0.1)
@@ -101,14 +101,14 @@ GEM
       hash-deep-merge
       mustermann-contrib (~> 1.1.1)
       nokogiri
-    openapi_parser (0.10.0)
-    public_suffix (4.0.4)
+    openapi_parser (0.11.2)
+    public_suffix (4.0.5)
     rack (2.2.2)
     rack-accept (0.4.5)
       rack (>= 0.4)
     rack-protection (2.0.8.1)
       rack
-    regexp_parser (1.7.0)
+    regexp_parser (1.7.1)
     ruby2_keywords (0.0.2)
     seg (1.2.0)
     sinatra (2.0.8.1)

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

@@ -13,4 +13,9 @@ module Web
 end
 
 oas_path = File.absolute_path('./openapi.yaml', __dir__)
-App = OpenapiFirst.app(oas_path, namespace: Web)
+
+App = OpenapiFirst.app(
+  oas_path,
+  namespace: Web,
+  raise_error: OpenapiFirst.env == 'test'
+)

data/lib/openapi_first.rb

@@ -8,7 +8,8 @@ require 'openapi_first/inbox'
 require 'openapi_first/router'
 require 'openapi_first/request_validation'
 require 'openapi_first/response_validator'
-require 'openapi_first/operation_resolver'
+require 'openapi_first/response_validation'
+require 'openapi_first/responder'
 require 'openapi_first/app'
 
 module OpenapiFirst
@@ -18,6 +19,10 @@ module OpenapiFirst
   INBOX = 'openapi_first.inbox'
   HANDLER = 'openapi_first.handler'
 
+  def self.env
+    ENV['RACK_ENV'] || ENV['HANAMI_ENV'] || ENV['RAILS_ENV']
+  end
+
   def self.load(spec_path, only: nil)
     content = YAML.load_file(spec_path)
     raw = OasParser::Parser.new(spec_path, content).resolve
@@ -26,14 +31,14 @@ module OpenapiFirst
     Definition.new(parsed)
   end
 
-  def self.app(spec, namespace:)
+  def self.app(spec, namespace:, raise_error: false)
     spec = OpenapiFirst.load(spec) if spec.is_a?(String)
-    App.new(nil, spec, namespace: namespace)
+    App.new(nil, spec, namespace: namespace, raise_error: raise_error)
   end
 
-  def self.middleware(spec, namespace:)
+  def self.middleware(spec, namespace:, raise_error: false)
     spec = OpenapiFirst.load(spec) if spec.is_a?(String)
-    AppWithOptions.new(spec, namespace: namespace)
+    AppWithOptions.new(spec, namespace: namespace, raise_error: raise_error)
   end
 
   class AppWithOptions
@@ -48,5 +53,42 @@ module OpenapiFirst
   end
 
   class Error < StandardError; end
-  class ResponseCodeNotFoundError < Error; end
+  class NotFoundError < Error; end
+  class NotImplementedError < RuntimeError; end
+  class ResponseInvalid < Error; end
+  class ResponseCodeNotFoundError < ResponseInvalid; end
+  class ResponseContentTypeNotFoundError < ResponseInvalid; end
+  class ResponseBodyInvalidError < ResponseInvalid; end
+
+  class RequestInvalidError < Error
+    def initialize(serialized_errors)
+      message = error_message(serialized_errors)
+      super message
+    end
+
+    private
+
+    def error_message(errors)
+      errors.map do |error|
+        [human_source(error), human_error(error)].compact.join(' ')
+      end.join(', ')
+    end
+
+    def human_source(error)
+      return unless error[:source]
+
+      source_key = error[:source].keys.first
+      source = {
+        pointer: 'Request body invalid:',
+        parameter: 'Query parameter invalid:'
+      }.fetch(source_key, source_key)
+      name = error[:source].values.first
+      source += " #{name}" unless name.nil? || name.empty?
+      source
+    end
+
+    def human_error(error)
+      error[:title]
+    end
+  end
 end

data/lib/openapi_first/app.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
 require 'rack'
+require 'logger'
 
 module OpenapiFirst
   class App
-    def initialize(
-      parent_app,
-      spec,
-      namespace:
-    )
+    def initialize(parent_app, spec, namespace:, raise_error:)
       @stack = Rack::Builder.app do
         freeze_app
-        use OpenapiFirst::Router,
-            spec: spec,
-            namespace: namespace,
-            parent_app: parent_app
-        use OpenapiFirst::RequestValidation
-        run OpenapiFirst::OperationResolver.new
+        use OpenapiFirst::Router, spec: spec, raise_error: raise_error, parent_app: parent_app
+        use OpenapiFirst::RequestValidation, raise_error: raise_error
+        use OpenapiFirst::ResponseValidation if raise_error
+        run OpenapiFirst::Responder.new(
+          spec: spec,
+          namespace: namespace
+        )
       end
     end
 

data/lib/openapi_first/definition.rb

@@ -4,24 +4,15 @@ require_relative 'operation'
 
 module OpenapiFirst
   class Definition
+    attr_reader :filepath
+
     def initialize(parsed)
+      @filepath = parsed.path
       @spec = parsed
     end
 
     def operations
       @spec.endpoints.map { |e| Operation.new(e) }
     end
-
-    def find_operation!(request)
-      @spec
-        .path_by_path(request.path)
-        .endpoint_by_method(request.request_method.downcase)
-    end
-
-    def find_operation(request)
-      find_operation!(request)
-    rescue OasParser::PathNotFound, OasParser::MethodNotFound
-      nil
-    end
   end
 end

data/lib/openapi_first/find_handler.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module OpenapiFirst
+  class FindHandler
+    def initialize(spec, namespace)
+      @namespace = namespace
+      @handlers = spec.operations.each_with_object({}) do |operation, hash|
+        operation_id = operation.operation_id
+        handler = find_handler(operation_id)
+        if handler.nil?
+          warn "#{self.class.name} cannot not find handler for '#{operation.operation_id}' (#{operation.method} #{operation.path}). This operation will be ignored." # rubocop:disable Layout/LineLength
+          next
+        end
+        hash[operation_id] = handler
+      end
+    end
+
+    def [](operation_id)
+      @handlers[operation_id]
+    end
+
+    def find_handler(operation_id)
+      name = operation_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 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)
+      return ->(params, res) { klass.new.call(params, res) } if klass.instance_method(:initialize).arity.zero?
+
+      ->(params, res) { klass.new(params.env).call(params, res) }
+    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/operation.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'json_schemer'
 require_relative 'utils'
+require_relative 'response_object'
 
 module OpenapiFirst
   class Operation
@@ -24,17 +26,38 @@ module OpenapiFirst
       @parameters_json_schema ||= build_parameters_json_schema
     end
 
+    def parameters_schema
+      @parameters_schema ||= parameters_json_schema && JSONSchemer.schema(parameters_json_schema)
+    end
+
     def content_type_for(status)
-      content = @operation
-                .response_by_code(status.to_s, use_default: true)
-                .content
+      content = response_for(status)['content']
       content.keys[0] if content
+    end
+
+    def response_schema_for(status, content_type)
+      content = response_for(status)['content']
+      return if content.nil? || content.empty?
+
+      media_type = content[content_type]
+      unless media_type
+        message = "Response content type not found '#{content_type}' for '#{name}'"
+        raise ResponseContentTypeNotFoundError, message
+      end
+      media_type['schema']
+    end
+
+    def response_for(status)
+      @operation.response_by_code(status.to_s, use_default: true).raw
     rescue OasParser::ResponseCodeNotFound
-      operation_name = "#{method.upcase} #{path}"
-      message = "Response status code or default not found: #{status} for '#{operation_name}'" # rubocop:disable Layout/LineLength
+      message = "Response status code or default not found: #{status} for '#{name}'"
       raise OpenapiFirst::ResponseCodeNotFoundError, message
     end
 
+    def name
+      "#{method.upcase} #{path} (#{operation_id})"
+    end
+
     private
 
     def build_parameters_json_schema

data/lib/openapi_first/request_validation.rb

@@ -4,12 +4,16 @@ require 'rack'
 require 'json_schemer'
 require 'multi_json'
 require_relative 'inbox'
+require_relative 'router_required'
 require_relative 'validation_format'
 
 module OpenapiFirst
   class RequestValidation # rubocop:disable Metrics/ClassLength
-    def initialize(app, _options = {})
+    prepend RouterRequired
+
+    def initialize(app, raise_error: false)
       @app = app
+      @raise = raise_error
     end
 
     def call(env) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -46,34 +50,32 @@ module OpenapiFirst
 
       parsed_request_body = parse_request_body!(body)
       errors = validate_json_schema(schema, parsed_request_body)
-      if errors.any?
-        halt(error_response(400, serialize_request_body_errors(errors)))
-      end
+      halt_with_error(400, serialize_request_body_errors(errors)) if errors.any?
       env[INBOX].merge! env[REQUEST_BODY] = parsed_request_body
     end
 
     def parse_request_body!(body)
-      MultiJson.load(body)
+      MultiJson.load(body, symbolize_keys: true)
     rescue MultiJson::ParseError => e
       err = { title: 'Failed to parse body as JSON' }
       err[:detail] = e.cause unless ENV['RACK_ENV'] == 'production'
-      halt(error_response(400, [err]))
+      halt_with_error(400, [err])
     end
 
     def validate_request_content_type!(content_type, operation)
       return if operation.request_body.content[content_type]
 
-      halt(error_response(415))
+      halt_with_error(415)
     end
 
     def validate_request_body_presence!(body, operation)
       return unless operation.request_body.required && body.empty?
 
-      halt(error_response(415, 'Request body is required'))
+      halt_with_error(415, 'Request body is required')
     end
 
     def validate_json_schema(schema, object)
-      JSONSchemer.schema(schema).validate(object)
+      schema.validate(Utils.deep_stringify(object))
     end
 
     def default_error(status, title = Rack::Utils::HTTP_STATUS_CODES[status])
@@ -83,8 +85,10 @@ module OpenapiFirst
       }
     end
 
-    def error_response(status, errors = [default_error(status)])
-      Rack::Response.new(
+    def halt_with_error(status, errors = [default_error(status)])
+      raise RequestInvalidError, errors if @raise
+
+      halt Rack::Response.new(
         MultiJson.dump(errors: errors),
         status,
         Rack::CONTENT_TYPE => 'application/vnd.api+json'
@@ -94,7 +98,8 @@ module OpenapiFirst
     def request_body_schema(content_type, operation)
       return unless operation
 
-      operation.request_body.content[content_type]&.fetch('schema')
+      schema = operation.request_body.content[content_type]&.fetch('schema')
+      JSONSchemer.schema(schema) if schema
     end
 
     def serialize_request_body_errors(validation_errors)
@@ -112,10 +117,11 @@ module OpenapiFirst
       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
+      errors = validate_json_schema(
+        operation.parameters_schema,
+        params
+      )
+      halt_with_error(400, serialize_query_parameter_errors(errors)) if errors.any?
       env[PARAMETERS] = params
       env[INBOX].merge! params
     end
@@ -123,7 +129,8 @@ module OpenapiFirst
     def filtered_params(json_schema, params)
       json_schema['properties']
         .each_with_object({}) do |key_value, result|
-          parameter_name, schema = key_value
+          parameter_name = key_value[0].to_sym
+          schema = key_value[1]
           next unless params.key?(parameter_name)
 
           value = params[parameter_name]