openapi_first 0.20.0 → 1.0.0.beta1

data/benchmarks/benchmarks.rb

@@ -18,7 +18,8 @@ examples = [
   [Rack::MockRequest.env_for('/hello?filter[id]=1,2'), 200]
 ]
 
-apps = Dir['./apps/*.ru'].each_with_object({}) do |config, hash|
+glob = ARGV[0] || './apps/*.ru'
+apps = Dir[glob].each_with_object({}) do |config, hash|
   hash[config] = Rack::Builder.parse_file(config).first
 end
 apps.freeze

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/body_parser_middleware.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'multi_json'
+
+module OpenapiFirst
+  class BodyParserMiddleware
+    def initialize(app, options = {})
+      @app = app
+      @raise = options.fetch(:raise_error, false)
+    end
+
+    RACK_INPUT = 'rack.input'
+    ROUTER_PARSED_BODY = 'router.parsed_body'
+
+    def call(env)
+      env[ROUTER_PARSED_BODY] = parse_body(env)
+      @app.call(env)
+    rescue BodyParsingError => e
+      raise if @raise
+
+      err = { title: "Failed to parse body as #{env['CONTENT_TYPE']}", status: '400' }
+      err[:detail] = e.cause unless ENV['RACK_ENV'] == 'production'
+      errors = [err]
+
+      Rack::Response.new(
+        MultiJson.dump(errors: errors),
+        400,
+        Rack::CONTENT_TYPE => 'application/vnd.api+json'
+      ).finish
+    end
+
+    private
+
+    def parse_body(env)
+      request = Rack::Request.new(env)
+      body = read_body(request)
+      return if body.empty?
+
+      return MultiJson.load(body) if request.media_type =~ (/json/i) && (request.media_type =~ /json/i)
+      return request.POST if request.form_data?
+
+      body
+    rescue MultiJson::ParseError => e
+      raise BodyParsingError, e
+    end
+
+    def read_body(request)
+      body = request.body.read
+      request.body.rewind
+      body
+    end
+  end
+end

data/lib/openapi_first/errors.rb

@@ -22,6 +22,8 @@ module OpenapiFirst
 
   class ResponseBodyInvalidError < ResponseInvalid; end
 
+  class BodyParsingError < Error; end
+
   class RequestInvalidError < Error
     def initialize(serialized_errors)
       message = error_message(serialized_errors)

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,17 +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 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?
@@ -88,6 +76,30 @@ module OpenapiFirst
       "#{method.upcase} #{path} (#{operation_id})"
     end
 
+    def valid_request_content_type?(request_content_type)
+      content = operation_object.dig('requestBody', 'content')
+      return unless content
+
+      !!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)
@@ -107,45 +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 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,58 +19,49 @@ module OpenapiFirst
       operation = env[OPERATION]
       return @app.call(env) unless operation
 
-      env[INBOX] = {}
-      catch(:halt) do
-        validate_query_parameters!(env, operation, env[PARAMETERS])
-        req = Rack::Request.new(env)
-        content_type = req.content_type
+      error = catch(:error) do
+        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!(content_type, operation)
-        body = req.body.read
-        req.body.rewind
-        parse_and_validate_request_body!(env, content_type, body, operation)
-        @app.call(env)
+        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
+        raise RequestInvalidError, error[:errors] if @raise
+
+        return validation_error_response(error[:status], error[:errors])
       end
+      @app.call(env)
     end
 
     private
 
-    def halt(response)
-      throw :halt, response
-    end
-
-    def parse_and_validate_request_body!(env, content_type, body, operation)
+    def validate_request_body!(operation, body, content_type)
       validate_request_body_presence!(body, operation)
-      return if body.empty?
+      return if content_type.nil?
 
       schema = operation&.request_body_schema(content_type)
       return unless schema
 
-      parsed_request_body = parse_request_body!(body)
-      errors = schema.validate(parsed_request_body)
-      halt_with_error(400, serialize_request_body_errors(errors)) if errors.any?
-      env[INBOX].merge! env[REQUEST_BODY] = Utils.deep_symbolize(parsed_request_body)
-    end
-
-    def parse_request_body!(body)
-      MultiJson.load(body)
-    rescue MultiJson::ParseError => e
-      err = { title: 'Failed to parse body as JSON' }
-      err[:detail] = e.cause unless ENV['RACK_ENV'] == 'production'
-      halt_with_error(400, [err])
+      errors = schema.validate(body)
+      throw_error(400, serialize_request_body_errors(errors)) if errors.any?
+      body
     end
 
-    def validate_request_content_type!(content_type, operation)
-      return if operation.request_body.dig('content', content_type)
-
-      halt_with_error(415)
+    def validate_request_content_type!(operation, content_type)
+      operation.valid_request_content_type?(content_type) || throw_error(415)
     end
 
     def validate_request_body_presence!(body, operation)
-      return unless operation.request_body['required'] && body.empty?
+      return unless operation.request_body['required'] && body.nil?
 
-      halt_with_error(415, 'Request body is required')
+      throw_error(415, 'Request body is required')
     end
 
     def default_error(status, title = Rack::Utils::HTTP_STATUS_CODES[status])
@@ -80,10 +71,15 @@ module OpenapiFirst
       }
     end
 
-    def halt_with_error(status, errors = [default_error(status)])
-      raise RequestInvalidError, errors if @raise
+    def throw_error(status, errors = [default_error(status)])
+      throw :error, {
+        status: status,
+        errors: errors
+      }
+    end
 
-      halt Rack::Response.new(
+    def validation_error_response(status, errors)
+      Rack::Response.new(
         MultiJson.dump(errors: errors),
         status,
         Rack::CONTENT_TYPE => 'application/vnd.api+json'
@@ -100,32 +96,29 @@ module OpenapiFirst
       end
     end
 
-    def validate_query_parameters!(env, operation, params)
-      schema = operation.parameters_schema
-      return unless schema
-
-      params = filtered_params(schema.raw_schema, params)
-      params = Utils.deep_stringify(params)
-      errors = schema.validate(params)
-      halt_with_error(400, serialize_query_parameter_errors(errors)) if errors.any?
-      params = Utils.deep_symbolize(params)
-      env[PARAMETERS] = params
-      env[INBOX].merge! 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
         {
@@ -133,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

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'rack'
+require 'multi_json'
 require 'hanami/router'
+require_relative 'body_parser_middleware'
 
 module OpenapiFirst
   class Router
@@ -10,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)
@@ -26,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
@@ -37,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
 
@@ -54,26 +57,53 @@ module OpenapiFirst
       env[ORIGINAL_PATH] = env[Rack::PATH_INFO]
       env[Rack::PATH_INFO] = Rack::Request.new(env).path
       @router.call(env)
+    rescue BodyParsingError => e
+      handle_body_parsing_error(e)
     ensure
       env[Rack::PATH_INFO] = env.delete(ORIGINAL_PATH) if env[ORIGINAL_PATH]
     end
 
+    def handle_body_parsing_error(exception)
+      err = { title: 'Failed to parse body as application/json', status: '400' }
+      err[:detail] = exception.cause unless ENV['RACK_ENV'] == 'production'
+      errors = [err]
+      raise RequestInvalidError, errors if @raise
+
+      Rack::Response.new(
+        MultiJson.dump(errors: errors),
+        400,
+        Rack::CONTENT_TYPE => 'application/vnd.api+json'
+      ).finish
+    end
+
     def build_router(operations)
-      router = Hanami::Router.new
-      operations.each do |operation|
-        normalized_path = operation.path.gsub('{', ':').gsub('}', '')
-        router.public_send(
-          operation.method,
-          normalized_path,
-          to: lambda do |env|
-            env[OPERATION] = operation
-            env[PARAMETERS] = env['router.params']
-            env[Rack::PATH_INFO] = env.delete(ORIGINAL_PATH)
-            @app.call(env)
-          end
-        )
+      router = Hanami::Router.new.tap do |r|
+        operations.each do |operation|
+          normalized_path = operation.path.gsub('{', ':').gsub('}', '')
+          r.public_send(
+            operation.method,
+            normalized_path,
+            to: build_route(operation)
+          )
+        end
+      end
+      raise_error = @raise
+      Rack::Builder.app do
+        use BodyParserMiddleware, raise_error: raise_error
+        run router
+      end
+    end
+
+    def build_route(operation)
+      lambda do |env|
+        env[OPERATION] = operation
+        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
-      router
     end
   end
 end

data/lib/openapi_first/schema_validation.rb

@@ -17,6 +17,7 @@ module OpenapiFirst
         insert_property_defaults: true,
         before_property_validation: proc do |data, property, property_schema, parent|
           convert_nullable(data, property, property_schema, parent)
+          binary_format(data, property, property_schema, parent)
         end
       )
     end
@@ -27,6 +28,14 @@ module OpenapiFirst
 
     private
 
+    def binary_format(data, property, property_schema, _parent)
+      return unless property_schema.is_a?(Hash) && property_schema['format'] == 'binary'
+
+      property_schema['type'] = 'object'
+      property_schema.delete('format')
+      data[property].transform_keys!(&:to_s)
+    end
+
     def convert_nullable(_data, _property, property_schema, _parent)
       return unless property_schema.is_a?(Hash) && property_schema['nullable'] && property_schema['type']
 

data/lib/openapi_first/use_router.rb

@@ -11,9 +11,7 @@ module OpenapiFirst
     def call(env)
       return super if env.key?(OPERATION)
 
-      @router ||= Router.new(lambda { |e|
-                               super(e)
-                             }, spec: @options.fetch(:spec), raise_error: @options.fetch(:raise_error, false))
+      @router ||= Router.new(->(e) { super(e) }, @options)
       @router.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.20.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

@@ -32,17 +32,19 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.6.0'
+  spec.required_ruby_version = '>= 3.0.5'
 
   spec.add_runtime_dependency 'deep_merge', '>= 1.2.1'
-  spec.add_runtime_dependency 'hanami-router', '2.0.alpha5'
-  spec.add_runtime_dependency 'hanami-utils', '2.0.alpha3'
+  spec.add_runtime_dependency 'hanami-router', '~> 2.0.0'
+  spec.add_runtime_dependency 'hanami-utils', '~> 2.0.0'
   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'