openapi_first 1.0.0.beta5 → 1.0.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e6c1f8f1a6fffd91827a74f95b932bfd5be9d4a897f3704efd6313bac9e6be4
-  data.tar.gz: 59041cacdcb634bb25e5d23025c0f86afe97632918f1e10d6f67409d31ba5f9b
+  metadata.gz: 8173c11075add6c2c7a1a6cf024ea86ba448b185574e346fe288afa3aafcf677
+  data.tar.gz: f3dcd95b9c06adcfcada5430a8412a3ee6ea37c1c117e79546436ade496c5778
 SHA512:
-  metadata.gz: 1955264ba1b60f477123cd1bbb71a14d611d598664965548a9ebe3c6508d5ac6e205dfe971bc7c1ebe6b27da78a48f1bf5d27239c886a9b4aa7db303224e0cfc
-  data.tar.gz: 2f25b5944e546a6619c2be01462008d358a0a80140594b0906ca62e9b152fa97b2b8225d0c137acbe29c64b7732bbd00d3f35459cd0b771b2b38c409303adde8
+  metadata.gz: d29578cdcc1573ff8903a7060a85e2b334b1ff908d4b3b7973e64b336ba414bfdf7b6fb762aff48cf0feaf78f5a29403d2d063b117fb1278bed628195363dd74
+  data.tar.gz: 0a6409930941ea9a1f4b734f49752ec18f8e9779ce6f5279e2db65022066500d8b7f9067af23625e780e20cf0d62f542c0a4b8388fea6f7cc37f63cd372baaf5

data/.github/workflows/ruby.yml

@@ -9,4 +9,5 @@ jobs:
       with:
         ruby-version: '3.1'
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-    - run: bundle exec rake
+    - run: BUNDLE_GEMFILE=Gemfile bundle exec rake
+    - run: BUNDLE_GEMFILE=Gemfile.rack2 bundle lock --add-platform x86_64-linux && bundle exec rake

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 1.0.0.beta6
+- Fix: Make response header validation work with rack 3
+- Refactor router
+  - Remove dependency hanami-router 
+  - PathItem and Operation for a request can be found by calling methods on the Definitnion
+- Fixed https://github.com/ahx/openapi_first/issues/155
+- Breaking / Regression: A paths like /pets/{from}-{to} if there is a path "/pets/{id}"
+
 ## 1.0.0.beta5
 
 - Added: `OpenapiFirst::Config.default_options=` to set default options globally

data/Gemfile

@@ -2,9 +2,10 @@
 
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in openapi_first.gemspec
 gemspec
 
+gem 'rack', '>= 3.0.0'
+
 group :test, :development do
   gem 'bundler'
   gem 'rack-test'

data/Gemfile.lock

@@ -1,12 +1,12 @@
 PATH
   remote: .
   specs:
-    openapi_first (1.0.0.beta5)
-      hanami-router (~> 2.0.0)
+    openapi_first (1.0.0.beta6)
       json_refs (~> 0.1, >= 0.1.7)
       json_schemer (~> 2.0.0)
       multi_json (~> 1.15)
-      openapi_parameters (>= 0.3.1, < 2.0)
+      mustermann-contrib (~> 3.0.0)
+      openapi_parameters (>= 0.3.2, < 2.0)
       rack (>= 2.2, < 4.0)
 
 GEM
@@ -15,10 +15,6 @@ GEM
     ast (2.4.2)
     diff-lcs (1.5.0)
     hana (1.3.7)
-    hanami-router (2.0.2)
-      mustermann (~> 3.0)
-      mustermann-contrib (~> 3.0)
-      rack (~> 2.0)
     hansi (0.2.1)
     json (2.6.3)
     json_refs (0.1.8)
@@ -34,7 +30,7 @@ GEM
     mustermann-contrib (3.0.0)
       hansi (~> 0.2.0)
       mustermann (= 3.0.0)
-    openapi_parameters (0.3.1)
+    openapi_parameters (0.3.2)
       rack (>= 2.2)
       zeitwerk (~> 2.6)
     parallel (1.23.0)
@@ -42,7 +38,7 @@ GEM
       ast (~> 2.4.1)
       racc
     racc (1.7.3)
-    rack (2.2.8)
+    rack (3.0.8)
     rack-test (2.1.0)
       rack (>= 1.3)
     rainbow (3.1.1)
@@ -92,6 +88,7 @@ PLATFORMS
 DEPENDENCIES
   bundler
   openapi_first!
+  rack (>= 3.0.0)
   rack-test
   rake
   rspec

data/Gemfile.rack2

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rack', '< 3.0.0'
+
+group :test, :development do
+  gem 'bundler'
+  gem 'rack-test'
+  gem 'rake'
+  gem 'rspec'
+  gem 'rubocop'
+end

data/lib/openapi_first/{body_parser_middleware.rb → body_parser.rb}

@@ -3,21 +3,7 @@
 require 'multi_json'
 
 module OpenapiFirst
-  class BodyParserMiddleware
-    def initialize(app)
-      @app = app
-    end
-
-    ROUTER_PARSED_BODY = 'router.parsed_body'
-    private_constant :ROUTER_PARSED_BODY
-
-    def call(env)
-      env[ROUTER_PARSED_BODY] = parse_body(env)
-      @app.call(env)
-    end
-
-    private
-
+  class BodyParser
     def parse_body(env)
       request = Rack::Request.new(env)
       body = read_body(request)
@@ -31,6 +17,8 @@ module OpenapiFirst
       raise BodyParsingError, 'Failed to parse body as application/json'
     end
 
+    private
+
     def read_body(request)
       body = request.body.read
       request.body.rewind

data/lib/openapi_first/definition/cookie_parameters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'openapi_parameters'
+require_relative 'parameters'
+
+module OpenapiFirst
+  class CookieParameters < Parameters
+    def unpack(env)
+      OpenapiParameters::Cookie.new(@parameter_definitions).unpack(env['HTTP_COOKIE'])
+    end
+  end
+end

data/lib/openapi_first/definition/has_content.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'schema'
+
+module OpenapiFirst
+  module HasContent
+    def schema_for(content_type)
+      return unless content&.any?
+
+      content_schemas&.fetch(content_type) do
+        type = content_type.split(';')[0]
+        content_schemas[type] || content_schemas["#{type.split('/')[0]}/*"] || content_schemas['*/*']
+      end
+    end
+
+    private
+
+    def content
+      raise NotImplementedError
+    end
+
+    def schema_write?
+      raise NotImplementedError
+    end
+
+    def content_schemas
+      @content_schemas ||= content&.each_with_object({}) do |kv, result|
+        type, media_type = kv
+        schema_object = media_type['schema']
+        next unless schema_object
+
+        result[type] = Schema.new(schema_object, write: schema_write?,
+                                                 openapi_version: @operation.openapi_version)
+      end
+    end
+  end
+end

data/lib/openapi_first/definition/header_parameters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'openapi_parameters'
+require_relative 'parameters'
+
+module OpenapiFirst
+  class HeaderParameters < Parameters
+    def unpack(env)
+      OpenapiParameters::Header.new(@parameter_definitions).unpack_env(env)
+    end
+  end
+end

data/lib/openapi_first/definition/operation.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'set'
+require_relative 'request_body'
+require_relative 'response'
+require_relative 'query_parameters'
+require_relative 'header_parameters'
+require_relative 'path_parameters'
+require_relative 'cookie_parameters'
+require_relative 'schema'
+
+module OpenapiFirst
+  class Operation
+    extend Forwardable
+    def_delegators :operation_object,
+                   :[],
+                   :dig
+
+    WRITE_METHODS = Set.new(%w[post put patch delete]).freeze
+    private_constant :WRITE_METHODS
+
+    attr_reader :path, :method, :openapi_version
+
+    def initialize(path, request_method, path_item_object, openapi_version:)
+      @path = path
+      @method = request_method
+      @path_item_object = path_item_object
+      @openapi_version = openapi_version
+      @operation_object = @path_item_object[request_method]
+    end
+
+    def operation_id
+      operation_object['operationId']
+    end
+
+    def read?
+      !write?
+    end
+
+    def write?
+      WRITE_METHODS.include?(method)
+    end
+
+    def request_body
+      @request_body ||= RequestBody.new(operation_object['requestBody'], self) if operation_object['requestBody']
+    end
+
+    def response_for(status)
+      response_object = operation_object.dig('responses', status.to_s) ||
+                        operation_object.dig('responses', "#{status / 100}XX") ||
+                        operation_object.dig('responses', "#{status / 100}xx") ||
+                        operation_object.dig('responses', 'default')
+      Response.new(status, response_object, self) if response_object
+    end
+
+    def name
+      @name ||= "#{method.upcase} #{path} (#{operation_id})"
+    end
+
+    def query_parameters
+      @query_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'query' }, QueryParameters)
+    end
+
+    def path_parameters
+      @path_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'path' }, PathParameters)
+    end
+
+    IGNORED_HEADERS = Set['Content-Type', 'Accept', 'Authorization'].freeze
+    private_constant :IGNORED_HEADERS
+
+    def header_parameters
+      @header_parameters ||= build_parameters(find_header_parameters, HeaderParameters)
+    end
+
+    def cookie_parameters
+      @cookie_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'cookie' }, CookieParameters)
+    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
+
+    attr_reader :operation_object
+
+    def build_parameters(parameters, klass)
+      klass.new(parameters, openapi_version:) if parameters.any?
+    end
+
+    def find_header_parameters
+      all_parameters.filter do |p|
+        p['in'] == 'header' && !IGNORED_HEADERS.include?(p['name'])
+      end
+    end
+  end
+end

data/lib/openapi_first/definition/parameters.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'schema'
+
+module OpenapiFirst
+  class Parameters
+    extend Forwardable
+
+    def initialize(parameter_definitions, openapi_version:)
+      @parameter_definitions = parameter_definitions
+      @openapi_version = openapi_version
+    end
+
+    def_delegators :parameters, :map
+
+    def empty?
+      @parameter_definitions.empty?
+    end
+
+    def schema
+      @schema ||= build_schema
+    end
+
+    def parameters
+      @parameter_definitions.map do |parameter_object|
+        OpenapiParameters::Parameter.new(parameter_object)
+      end
+    end
+
+    private
+
+    def build_schema
+      init_schema = {
+        'type' => 'object',
+        'properties' => {},
+        'required' => []
+      }
+      schema = @parameter_definitions.each_with_object(init_schema) do |parameter_def, result|
+        parameter = OpenapiParameters::Parameter.new(parameter_def)
+        result['properties'][parameter.name] = parameter.schema if parameter.schema
+        result['required'] << parameter.name if parameter.required?
+      end
+      Schema.new(schema, openapi_version: @openapi_version)
+    end
+  end
+end

data/lib/openapi_first/definition/path_item.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'operation'
+
+module OpenapiFirst
+  class PathItem
+    def initialize(path, path_item_object, openapi_version:)
+      @path = path
+      @path_item_object = path_item_object
+      @openapi_version = openapi_version
+    end
+
+    attr_reader :path
+
+    def find_operation(request_method)
+      return unless @path_item_object[request_method]
+
+      Operation.new(
+        @path, request_method, @path_item_object, openapi_version: @openapi_version
+      )
+    end
+  end
+end

data/lib/openapi_first/definition/path_parameters.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'openapi_parameters'
+require_relative 'parameters'
+require_relative '../router'
+
+module OpenapiFirst
+  class PathParameters < Parameters
+    def unpack(env)
+      OpenapiParameters::Path.new(@parameter_definitions).unpack(env[Router::RAW_PATH_PARAMS])
+    end
+  end
+end

data/lib/openapi_first/definition/query_parameters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'openapi_parameters'
+require_relative 'parameters'
+
+module OpenapiFirst
+  class QueryParameters < Parameters
+    def unpack(env)
+      OpenapiParameters::Query.new(@parameter_definitions).unpack(env['QUERY_STRING'])
+    end
+  end
+end

data/lib/openapi_first/definition/request_body.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'has_content'
+
+module OpenapiFirst
+  class RequestBody
+    include HasContent
+
+    def initialize(request_body_object, operation)
+      @object = request_body_object
+      @operation = operation
+    end
+
+    def description
+      @object['description']
+    end
+
+    def required?
+      !!@object['required']
+    end
+
+    private
+
+    def schema_write?
+      @operation.write?
+    end
+
+    def content
+      @object['content']
+    end
+  end
+end

data/lib/openapi_first/definition/response.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'has_content'
+
+module OpenapiFirst
+  class Response
+    include HasContent
+
+    def initialize(status, response_object, operation)
+      @status = status&.to_i
+      @object = response_object
+      @operation = operation
+    end
+
+    attr_reader :status
+
+    def description
+      @object['description']
+    end
+
+    def headers
+      @object['headers']
+    end
+
+    def content?
+      !!content&.any?
+    end
+
+    private
+
+    def schema_write? = false
+
+    def content
+      @object['content']
+    end
+  end
+end

data/lib/openapi_first/{json_schema → definition/schema}/result.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module OpenapiFirst
-  class JsonSchema
+  class Schema
     Result = Struct.new(:output, :schema, :data, keyword_init: true) do
       def valid? = output['valid']
       def error? = !output['valid']

data/lib/openapi_first/{json_schema.rb → definition/schema.rb}

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require 'json_schemer'
-require_relative 'json_schema/result'
+require_relative 'schema/result'
 
 module OpenapiFirst
-  class JsonSchema
+  class Schema
     attr_reader :schema
 
     SCHEMAS = {

data/lib/openapi_first/definition.rb

@@ -1,19 +1,39 @@
 # frozen_string_literal: true
 
-require_relative 'operation'
+require 'mustermann/template'
+require_relative 'definition/path_item'
 
 module OpenapiFirst
   # Represents an OpenAPI API Description document
   class Definition
-    attr_reader :filepath, :operations
+    attr_reader :filepath, :paths, :openapi_version
 
     def initialize(resolved, filepath)
       @filepath = filepath
+      @paths = resolved['paths']
+      @openapi_version = detect_version(resolved)
+    end
+
+    # @param request_path String
+    def find_path_item_and_params(request_path)
+      matches = paths.each_with_object([]) do |kv, result|
+        path, path_item_object = kv
+        template = Mustermann::Template.new(path)
+        path_params = template.params(request_path)
+        next unless path_params
+
+        path_item = PathItem.new(path, path_item_object, openapi_version:)
+        result << [path_item, path_params]
+      end
+      # Thanks to open ota42y/openapi_parser for this part
+      matches.min_by { |match| match[1].size }
+    end
+
+    def operations
       methods = %w[get head post put patch delete trace options]
-      @operations = resolved['paths'].flat_map do |path, path_item|
-        path_item.slice(*methods).map do |request_method, _operation_object|
-          Operation.new(path, request_method, path_item, openapi_version: detect_version(resolved))
-        end
+      @operations ||= paths.flat_map do |path, path_item_object|
+        path_item = PathItem.new(path, path_item_object, openapi_version:)
+        path_item_object.slice(*methods).keys.map { |method| path_item.find_operation(method) }
       end
     end
 

data/lib/openapi_first/error_response.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 module OpenapiFirst
   # This is the base class for error responses
   class ErrorResponse

data/lib/openapi_first/request_body_validator.rb

@@ -5,37 +5,33 @@ module OpenapiFirst
     def initialize(operation, env)
       @operation = operation
       @env = env
-      @parsed_request_body = env[REQUEST_BODY]
     end
 
     def validate!
-      content_type = Rack::Request.new(@env).content_type
-      validate_request_content_type!(@operation, content_type)
-      validate_request_body!(@operation, @parsed_request_body, content_type)
-    end
+      request_body = @operation.request_body
+      return unless request_body
 
-    private
+      request_content_type = Rack::Request.new(@env).content_type
+      schema = request_body.schema_for(request_content_type)
+      RequestValidation.fail!(415, :header) unless schema
 
-    def validate_request_content_type!(operation, content_type)
-      operation.valid_request_content_type?(content_type) || RequestValidation.fail!(415, :header)
+      parsed_request_body = BodyParser.new.parse_body(@env)
+      RequestValidation.fail!(400, :body) if request_body.required? && parsed_request_body.nil?
+
+      validate_body!(parsed_request_body, schema)
+      parsed_request_body
+    rescue BodyParsingError => e
+      RequestValidation.fail!(400, :body, message: e.message)
     end
 
-    def validate_request_body!(operation, body, content_type)
-      validate_request_body_presence!(body, operation)
-      return if content_type.nil?
+    private
 
-      schema = operation&.request_body_schema(content_type)
-      return unless schema
+    def validate_body!(parsed_request_body, schema)
+      request_body_schema = schema
+      return unless request_body_schema
 
-      schema_validation = schema.validate(body)
+      schema_validation = request_body_schema.validate(parsed_request_body)
       RequestValidation.fail!(400, :body, schema_validation:) if schema_validation.error?
-      body
-    end
-
-    def validate_request_body_presence!(body, operation)
-      return unless operation.request_body['required'] && body.nil?
-
-      RequestValidation.fail!(400, :body)
     end
   end
 end