openapi_first 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ceb641d45921bafb376d7fe7ea3a2f42b76c8900a5d8598e6ef018afca0304e
-  data.tar.gz: 123c15a5a4a149e69a40773b0a62543257f3145fbc06c788207e65757ba3c404
+  metadata.gz: b6f86609c16829b7f0f94d837167a44e4cf93b38a392ac34b93a9ff9d7a794fc
+  data.tar.gz: 1524298280aa89e6cbae16ce80259ed1d0928b4018747eb6c3385ebed0e8db8b
 SHA512:
-  metadata.gz: 3e279fa5f4239b1f41020b788370377535ef5cf959d2f2a23df61240310d4b729484e0a1154ff11250e21164c15b1ab285b3173fc2f2e3ac84603a5722e60ec7
-  data.tar.gz: f96790f87324ea1ce7f78b6d3b41f86de709f990edf26a97ce1ad01b7929229198f9114ceb33d1aad94912211253ddc26dce6acae5566b386c805bb1219d886d
+  metadata.gz: a0d30f3482838dd995f44b5ede610ada74ff1a5d2c2e29a1b3fa109da98cbc5cd42bf8616b4f7e6c79b558d1c16b77ca1eb85b4fc82bcbd9e40c6dcf75aea927
+  data.tar.gz: 7f87349cd6fa98cef19f929db3deeb1c94a9b2eed759f23f592ba145c315726cfe8ff3f5fb3f50444b566a5d95b94370439015fd995554ecececc7029adff9ec

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 2.2.0
+
+- Fix support for discriminator in response bodies if no mapping is defined (https://github.com/ahx/openapi_first/issues/285)
+- Fix support for discriminator in request bodies if no mapping is defined
+- Replace bundled json_refs fork with own code
+- Better error messages when OpenAPI file has invalid references ("$ref")
+- Autoload OpenapiFirst::Test module. There is no need to `require 'openapi_first/test'` anymore.
+- Remove multi_json dependency. openapi_first uses multi_json if available or the default json gem otherwise.
+  If you want to use multi_json, make sure to add it to your Gemfile.
+
 ## 2.1.1
 
 - Fix issue with non file downloads / JSON responses https://github.com/ahx/openapi_first/issues/281

data/README.md

@@ -79,8 +79,6 @@ validated_response.parsed_headers
 definition.validate_response(rack_request,rack_response, raise_error: true) # Raises OpenapiFirst::ResponseInvalidError or OpenapiFirst::ResponseNotFoundError
 ```
 
-OpenapiFirst uses [`multi_json`](https://rubygems.org/gems/multi_json).
-
 ## Rack Middlewares
 
 ### Request validation
@@ -210,7 +208,6 @@ Here is how to set it up for Rails integration tests:
 
 ```ruby
 # test_helper.rb
-require 'openapi_first/test'
 OpenapiFirst::Test.register('openapi/v1.openapi.yaml')
 ```
 

data/lib/openapi_first/body_parser.rb

@@ -1,32 +1,45 @@
 # frozen_string_literal: true
 
-require 'multi_json'
-
 module OpenapiFirst
   # @!visibility private
-  class BodyParser
-    def initialize(content_type)
-      @is_json = :json if /json/i.match?(content_type)
+  module BodyParser
+    def self.[](content_type)
+      case content_type
+      when /json/i
+        JsonBodyParser
+      when %r{multipart/form-data}i
+        MultipartBodyParser
+      else
+        DefaultBodyParser
+      end
+    end
+
+    def self.read_body(request)
+      body = request.body&.read
+      request.body.rewind if request.body.respond_to?(:rewind)
+      body
     end
 
-    def parse(request)
+    JsonBodyParser = lambda do |request|
       body = read_body(request)
       return if body.nil? || body.empty?
 
-      return MultiJson.load(body) if @is_json
-      return request.POST if request.form_data?
-
-      body
-    rescue MultiJson::ParseError
+      JSON.parse(body)
+    rescue JSON::ParserError
       Failure.fail!(:invalid_body, message: 'Failed to parse request body as JSON')
     end
 
-    private
+    MultipartBodyParser = lambda do |request|
+      request.POST.transform_values do |value|
+        value.is_a?(Hash) && value[:tempfile] ? value[:tempfile].read : value
+      end
+    end
 
-    def read_body(request)
-      body = request.body&.read
-      request.body.rewind if request.body.respond_to?(:rewind)
-      body
+    # This returns the post data parsed by rack or the raw body
+    DefaultBodyParser = lambda do |request|
+      return request.POST if request.form_data?
+
+      read_body(request)
     end
   end
 end

data/lib/openapi_first/builder.rb

@@ -1,33 +1,59 @@
 # frozen_string_literal: true
 
+require 'json_schemer'
+require_relative 'json_pointer'
+require_relative 'ref_resolver'
+
 module OpenapiFirst
   # Builds parts of a Definition
   # This knows how to read a resolved OpenAPI document and build {Request} and {Response} objects.
-  class Builder
+  class Builder # rubocop:disable Metrics/ClassLength
     REQUEST_METHODS = %w[get head post put patch delete trace options].freeze
 
     # Builds a router from a resolved OpenAPI document.
-    # @param resolved [Hash] The resolved OpenAPI document.
+    # @param contents [Hash] The OpenAPI document Hash.
     # @param config [OpenapiFirst::Configuration] The configuration object.
-    def self.build_router(resolved, config)
-      openapi_version = (resolved['openapi'] || resolved['swagger'])[0..2]
-      new(resolved, config, openapi_version).router
+    def self.build_router(contents, filepath:, config:)
+      new(contents, filepath:, config:).router
     end
 
-    def initialize(resolved, config, openapi_version)
-      @resolved = resolved
+    def initialize(contents, filepath:, config:)
+      @schemer_configuration = JSONSchemer::Configuration.new(
+        meta_schema: detect_meta_schema(contents, filepath),
+        insert_property_defaults: true
+      )
       @config = config
-      @openapi_version = openapi_version
+      @contents = RefResolver.for(contents, dir: filepath && File.dirname(filepath))
     end
 
-    attr_reader :resolved, :openapi_version, :config
+    attr_reader :config
+    private attr_reader :schemer_configuration
+
+    def detect_meta_schema(document, filepath)
+      # Copied from JSONSchemer 🙇🏻‍♂️
+      version = document['openapi']
+      case version
+      when /\A3\.1\.\d+\z/
+        @document_schema = JSONSchemer.openapi31_document
+        document.fetch('jsonSchemaDialect') { JSONSchemer::OpenAPI31::BASE_URI.to_s }
+      when /\A3\.0\.\d+\z/
+        @document_schema = JSONSchemer.openapi30_document
+        JSONSchemer::OpenAPI30::BASE_URI.to_s
+      else
+        raise Error, "Unsupported OpenAPI version #{version.inspect} #{filepath}"
+      end
+    end
 
     def router # rubocop:disable Metrics/MethodLength
       router = OpenapiFirst::Router.new
-      resolved['paths'].each do |path, path_item_object|
-        path_item_object.slice(*REQUEST_METHODS).keys.map do |request_method|
+      @contents.fetch('paths').each do |path, path_item_object|
+        path_item_object.resolved.keys.intersection(REQUEST_METHODS).map do |request_method|
           operation_object = path_item_object[request_method]
-          build_requests(path, request_method, operation_object, path_item_object).each do |request|
+          parameters = operation_object['parameters']&.resolved.to_a.chain(path_item_object['parameters']&.resolved.to_a)
+          parameters = parse_parameters(parameters)
+
+          build_requests(path:, request_method:, operation_object:,
+                         parameters:).each do |request|
             router.add_request(
               request,
               request_method:,
@@ -35,7 +61,7 @@ module OpenapiFirst
               content_type: request.content_type
             )
           end
-          build_responses(operation_object).each do |response|
+          build_responses(responses: operation_object['responses']).each do |response|
             router.add_response(
               response,
               request_method:,
@@ -49,33 +75,120 @@ module OpenapiFirst
       router
     end
 
-    def build_requests(path, request_method, operation_object, path_item_object)
-      hooks = config.hooks
-      path_item_parameters = path_item_object['parameters']
-      parameters = operation_object['parameters'].to_a.chain(path_item_parameters.to_a)
-      required_body = operation_object.dig('requestBody', 'required') == true
-      result = operation_object.dig('requestBody', 'content')&.map do |content_type, content|
-        Request.new(path:, request_method:, operation_object:, parameters:, content_type:,
-                    content_schema: content['schema'], required_body:, hooks:, openapi_version:)
+    def parse_parameters(parameters)
+      grouped_parameters = group_parameters(parameters)
+      ParsedParameters.new(
+        query: grouped_parameters[:query],
+        path: grouped_parameters[:path],
+        cookie: grouped_parameters[:cookie],
+        header: grouped_parameters[:header],
+        query_schema: build_parameter_schema(grouped_parameters[:query]),
+        path_schema: build_parameter_schema(grouped_parameters[:path]),
+        cookie_schema: build_parameter_schema(grouped_parameters[:cookie]),
+        header_schema: build_parameter_schema(grouped_parameters[:header])
+      )
+    end
+
+    def build_parameter_schema(parameters)
+      schema = build_parameters_schema(parameters)
+
+      JSONSchemer.schema(schema,
+                         configuration: schemer_configuration,
+                         after_property_validation: config.hooks[:after_request_parameter_property_validation])
+    end
+
+    def build_requests(path:, request_method:, operation_object:, parameters:)
+      required_body = operation_object['requestBody']&.resolved&.fetch('required', false) == true
+      result = operation_object.dig('requestBody', 'content')&.map do |content_type, content_object|
+        content_schema = content_object['schema'].schema(
+          configuration: schemer_configuration,
+          after_property_validation: config.hooks[:after_request_body_property_validation]
+        )
+        Request.new(path:, request_method:,
+                    operation_object: operation_object.resolved,
+                    parameters:, content_type:,
+                    content_schema:,
+                    required_body:)
       end || []
       return result if required_body
 
       result << Request.new(
-        path:, request_method:, operation_object:,
+        path:, request_method:, operation_object: operation_object.resolved,
         parameters:, content_type: nil, content_schema: nil,
-        required_body:, hooks:, openapi_version:
+        required_body:
       )
     end
 
-    def build_responses(operation_object)
-      Array(operation_object['responses']).flat_map do |status, response_object|
-        headers = response_object['headers']
+    def build_responses(responses:)
+      return [] unless responses
+
+      responses.flat_map do |status, response_object|
+        headers = response_object['headers']&.resolved
+        headers_schema = JSONSchemer::Schema.new(
+          build_headers_schema(headers),
+          configuration: schemer_configuration
+        )
         response_object['content']&.map do |content_type, content_object|
-          content_schema = content_object['schema']
-          Response.new(status:, headers:, content_type:, content_schema:, openapi_version:)
-        end || Response.new(status:, headers:, content_type: nil,
-                            content_schema: nil, openapi_version:)
+          content_schema = content_object['schema'].schema(configuration: schemer_configuration)
+          Response.new(status:,
+                       headers:,
+                       headers_schema:,
+                       content_type:,
+                       content_schema:)
+        end || Response.new(status:, headers:, headers_schema:, content_type: nil,
+                            content_schema: nil)
+      end
+    end
+
+    IGNORED_HEADER_PARAMETERS = Set['Content-Type', 'Accept', 'Authorization'].freeze
+    private_constant :IGNORED_HEADER_PARAMETERS
+
+    def group_parameters(parameter_definitions)
+      result = {}
+      parameter_definitions&.each do |parameter|
+        (result[parameter['in'].to_sym] ||= []) << parameter
+      end
+      result[:header]&.reject! { IGNORED_HEADER_PARAMETERS.include?(_1['name']) }
+      result
+    end
+
+    def build_headers_schema(headers_object)
+      return unless headers_object&.any?
+
+      properties = {}
+      required = []
+      headers_object.each do |name, header|
+        schema = header['schema']
+        next if name.casecmp('content-type').zero?
+
+        properties[name] = schema if schema
+        required << name if header['required']
       end
+      {
+        'properties' => properties,
+        'required' => required
+      }
     end
+
+    def build_parameters_schema(parameters)
+      return unless parameters
+
+      properties = {}
+      required = []
+      parameters.each do |parameter|
+        schema = parameter['schema']
+        name = parameter['name']
+        properties[name] = schema if schema
+        required << name if parameter['required']
+      end
+
+      {
+        'properties' => properties,
+        'required' => required
+      }
+    end
+
+    ParsedParameters = Data.define(:path, :query, :header, :cookie, :path_schema, :query_schema, :header_schema,
+                                   :cookie_schema)
   end
 end

data/lib/openapi_first/definition.rb

@@ -22,16 +22,16 @@ module OpenapiFirst
     # @return [Router]
     attr_reader :router
 
-    # @param resolved [Hash] The resolved OpenAPI document.
+    # @param contents [Hash] The OpenAPI document.
     # @param filepath [String] The file path of the OpenAPI document.
-    def initialize(resolved, filepath = nil)
+    def initialize(contents, filepath = nil)
       @filepath = filepath
       @config = OpenapiFirst.configuration.clone
       yield @config if block_given?
       @config.freeze
-      @router = Builder.build_router(resolved, @config)
-      @resolved = resolved
-      @paths = resolved['paths'].keys # TODO: Move into builder as well
+      @router = Builder.build_router(contents, filepath:, config:)
+      @resolved = contents
+      @paths = @router.routes.map(&:path).to_a.uniq # TODO: Refactor
     end
 
     # Gives access to the raw resolved Hash. Like `mydefinition['components'].dig('schemas', 'Stations')`

data/lib/openapi_first/error_responses/default.rb

@@ -26,7 +26,7 @@ module OpenapiFirst
           status:
         }
         result[:errors] = errors if failure.errors
-        MultiJson.dump(result)
+        JSON.generate(result)
       end
 
       def type = failure.type

data/lib/openapi_first/error_responses/jsonapi.rb

@@ -8,7 +8,7 @@ module OpenapiFirst
       OpenapiFirst.register_error_response(:jsonapi, self)
 
       def body
-        MultiJson.dump({ errors: serialized_errors })
+        JSON.generate({ errors: serialized_errors })
       end
 
       def content_type

data/lib/openapi_first/file_loader.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module OpenapiFirst
+  # @!visibility private
+  module FileLoader
+    module_function
+
+    def load(file_path)
+      raise FileNotFoundError, "File not found #{file_path}" unless File.exist?(file_path)
+
+      body = File.read(file_path)
+      extname = File.extname(file_path)
+      return JSON.parse(body) if extname == '.json'
+      return YAML.unsafe_load(body) if ['.yaml', '.yml'].include?(extname)
+
+      body
+    end
+  end
+end

data/lib/openapi_first/json.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This tries to load MultiJson if available to keep compatibility
+# with MultiJson until next major version
+
+begin
+  require 'multi_json'
+  module OpenapiFirst
+    # Compatibility with MultiJson
+    # @visibility private
+    module JSON
+      ParserError = MultiJson::ParseError
+
+      def self.parse(string)
+        MultiJson.load(string)
+      end
+
+      def self.generate(object)
+        MultiJson.dump(object)
+      end
+    end
+  end
+rescue LoadError
+  require 'json'
+  puts 'openapi_first uses the default json gem'
+end

data/lib/openapi_first/json_pointer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  # Functions to handle JSON Pointers
+  # @!visibility private
+  module JsonPointer
+    ESCAPE_CHARS = { '~' => '~0', '/' => '~1', '+' => '%2B' }.freeze
+    ESCAPE_REGEX = Regexp.union(ESCAPE_CHARS.keys)
+
+    module_function
+
+    def append(root, *tokens)
+      "#{root}/" + tokens.map do |token|
+        escape_json_pointer_token(token)
+      end.join('/')
+    end
+
+    def escape_json_pointer_token(token)
+      token.to_s.gsub(ESCAPE_REGEX, ESCAPE_CHARS)
+    end
+  end
+end

data/lib/openapi_first/ref_resolver.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'json_schemer'
+
+module OpenapiFirst
+  # This is here to give traverse an OAD while keeping $refs intact
+  # @visibility private
+  module RefResolver
+    def self.load(file_path)
+      contents = OpenapiFirst::FileLoader.load(file_path)
+      self.for(contents, dir: File.dirname(File.expand_path(file_path)))
+    end
+
+    def self.for(value, context: value, dir: Dir.pwd)
+      case value
+      when ::Hash
+        Hash.new(value, context:, dir:)
+      when ::Array
+        Array.new(value, context:, dir:)
+      when ::NilClass
+        nil
+      else
+        Simple.new(value)
+      end
+    end
+
+    # @visibility private
+    module Diggable
+      def dig(*keys)
+        keys.inject(self) do |result, key|
+          break unless result.respond_to?(:[])
+
+          result[key]
+        end
+      end
+    end
+
+    # @visibility private
+    module Resolvable
+      def initialize(value, context: value, dir: nil)
+        @value = value
+        @context = context
+        @dir = dir
+      end
+
+      # The value of this node
+      attr_reader :value
+      # The path of the file sytem directory where this was loaded from
+      attr_reader :dir
+      # The object where this node was found in
+      attr_reader :context
+
+      def resolve_ref(pointer)
+        if pointer.start_with?('#')
+          value = Hana::Pointer.new(pointer[1..]).eval(context)
+          raise "Unknown reference #{pointer} in #{context}" unless value
+
+          return RefResolver.for(value, dir:)
+        end
+
+        relative_path, file_pointer = pointer.split('#')
+        full_path = File.expand_path(relative_path, dir)
+        return RefResolver.load(full_path) unless file_pointer
+
+        file_contents = FileLoader.load(full_path)
+        new_dir = File.dirname(full_path)
+        value = Hana::Pointer.new(file_pointer).eval(file_contents)
+        RefResolver.for(value, dir: new_dir)
+      end
+    end
+
+    # @visibility private
+    class Simple
+      include Resolvable
+
+      def resolved = value
+    end
+
+    # @visibility private
+    class Hash
+      include Resolvable
+      include Diggable
+      include Enumerable
+
+      def resolved
+        return resolve_ref(value['$ref']).value if value.key?('$ref')
+
+        value
+      end
+
+      def [](key)
+        return resolve_ref(@value['$ref'])[key] if !@value.key?(key) && @value.key?('$ref')
+
+        RefResolver.for(@value[key], dir:, context:)
+      end
+
+      def fetch(key)
+        return resolve_ref(@value['$ref']).fetch(key) if !@value.key?(key) && @value.key?('$ref')
+
+        RefResolver.for(@value.fetch(key), dir:, context:)
+      end
+
+      def each
+        resolved.each do |key, value|
+          yield key, RefResolver.for(value, dir:, context:)
+        end
+      end
+
+      def schema(options = {})
+        ref_resolver = JSONSchemer::CachedResolver.new do |uri|
+          FileLoader.load(File.join(dir, uri.path))
+        end
+        root = JSONSchemer::Schema.new(context, ref_resolver:, **options)
+        JSONSchemer::Schema.new(value, nil, root, **options)
+      end
+    end
+
+    # @visibility private
+    class Array
+      include Resolvable
+      include Diggable
+
+      def [](index)
+        item = @value[index]
+        return resolve_ref(item['$ref']) if item.is_a?(::Hash) && item.key?('$ref')
+
+        RefResolver.for(item, dir:, context:)
+      end
+
+      def resolved
+        value.map do |item|
+          if item.respond_to?(:key?) && item.key?('$ref')
+            resolve_ref(item['$ref']).resolved
+          else
+            item
+          end
+        end
+      end
+    end
+  end
+end