openapi_first 1.0.0.beta6 → 1.0.0

data/lib/openapi_first/definition/operation.rb

@@ -3,100 +3,113 @@
 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'
+require_relative 'responses'
 
 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
+  class Definition
+    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 operation_id
+        operation_object['operationId']
+      end
 
-    def read?
-      !write?
-    end
+      def read?
+        !write?
+      end
 
-    def write?
-      WRITE_METHODS.include?(method)
-    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 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 response_status_defined?(status)
+        responses.status_defined?(status)
+      end
 
-    def name
-      @name ||= "#{method.upcase} #{path} (#{operation_id})"
-    end
+      def_delegators :responses, :response_for
 
-    def query_parameters
-      @query_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'query' }, QueryParameters)
-    end
+      def schema_for(content_type)
+        content = @request_body_object['content']
+        return unless content&.any?
 
-    def path_parameters
-      @path_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'path' }, PathParameters)
-    end
+        content_schemas&.fetch(content_type) do
+          type = content_type.split(';')[0]
+          content_schemas[type] || content_schemas["#{type.split('/')[0]}/*"] || content_schemas['*/*']
+        end
+      end
 
-    IGNORED_HEADERS = Set['Content-Type', 'Accept', 'Authorization'].freeze
-    private_constant :IGNORED_HEADERS
+      def name
+        @name ||= "#{method.upcase} #{path} (#{operation_id})"
+      end
 
-    def header_parameters
-      @header_parameters ||= build_parameters(find_header_parameters, HeaderParameters)
-    end
+      def query_parameters
+        @query_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'query' }, QueryParameters)
+      end
 
-    def cookie_parameters
-      @cookie_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'cookie' }, CookieParameters)
-    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 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
+      def header_parameters
+        @header_parameters ||= build_parameters(find_header_parameters, HeaderParameters)
       end
-    end
 
-    private
+      def cookie_parameters
+        @cookie_parameters ||= build_parameters(all_parameters.filter { |p| p['in'] == 'cookie' }, CookieParameters)
+      end
 
-    attr_reader :operation_object
+      private
 
-    def build_parameters(parameters, klass)
-      klass.new(parameters, openapi_version:) if parameters.any?
-    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
+
+      def responses
+        @responses ||= Responses.new(self, operation_object['responses'])
+      end
+
+      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'])
+      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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
-require_relative 'schema'
+require_relative '../schema'
 
 module OpenapiFirst
   class Parameters

data/lib/openapi_first/definition/path_item.rb

@@ -3,21 +3,30 @@
 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
+  class Definition
+    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 operation(request_method)
+        return unless @path_item_object[request_method]
 
-    attr_reader :path
+        Operation.new(
+          @path, request_method, @path_item_object, openapi_version: @openapi_version
+        )
+      end
 
-    def find_operation(request_method)
-      return unless @path_item_object[request_method]
+      METHODS = %w[get head post put patch delete trace options].freeze
+      private_constant :METHODS
 
-      Operation.new(
-        @path, request_method, @path_item_object, openapi_version: @openapi_version
-      )
+      def operations
+        @operations ||= @path_item_object.slice(*METHODS).keys.map { |method| operation(method) }
+      end
     end
   end
 end

data/lib/openapi_first/definition/path_parameters.rb

@@ -2,12 +2,11 @@
 
 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])
+    def unpack(original_path_params)
+      OpenapiParameters::Path.new(@parameter_definitions).unpack(original_path_params)
     end
   end
 end

data/lib/openapi_first/definition/request_body.rb

@@ -1,32 +1,43 @@
 # frozen_string_literal: true
 
-require_relative 'has_content'
+require_relative '../schema'
 
 module OpenapiFirst
   class RequestBody
-    include HasContent
-
     def initialize(request_body_object, operation)
-      @object = request_body_object
+      @request_body_object = request_body_object
       @operation = operation
     end
 
     def description
-      @object['description']
+      @request_body_object['description']
     end
 
     def required?
-      !!@object['required']
+      !!@request_body_object['required']
     end
 
-    private
+    def schema_for(content_type)
+      content = @request_body_object['content']
+      return unless content&.any?
 
-    def schema_write?
-      @operation.write?
+      content_schemas&.fetch(content_type) do
+        type = content_type.split(';')[0]
+        content_schemas[type] || content_schemas["#{type.split('/')[0]}/*"] || content_schemas['*/*']
+      end
     end
 
-    def content
-      @object['content']
+    private
+
+    def content_schemas
+      @content_schemas ||= @request_body_object['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: @operation.write?,
+                                                 openapi_version: @operation.openapi_version)
+      end
     end
   end
 end

data/lib/openapi_first/definition/response.rb

@@ -1,37 +1,25 @@
 # 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']
+  class Definition
+    class Response
+      def initialize(operation:, status:, response_object:, content_type:, content_schema:)
+        @operation = operation
+        @response_object = response_object
+        @status = status
+        @content_type = content_type
+        @content_schema = content_schema
+      end
+
+      attr_reader :operation, :status, :content_type, :content_schema
+
+      def headers
+        @response_object['headers']
+      end
+
+      def description
+        @response_object['description']
+      end
     end
   end
 end

data/lib/openapi_first/definition/responses.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'response'
+
+module OpenapiFirst
+  class Definition
+    # @visibility private
+    class Responses
+      def initialize(operation, responses_object)
+        @operation = operation
+        @responses_object = responses_object
+      end
+
+      def status_defined?(status)
+        !!find_response_object(status)
+      end
+
+      def response_for(status, response_content_type)
+        response_object = find_response_object(status)
+        return unless response_object
+        return response_without_content(status, response_object) unless content_defined?(response_object)
+
+        defined_content_type = find_defined_content_type(response_object, response_content_type)
+        return unless defined_content_type
+
+        content_schema = find_content_schema(response_object, response_content_type)
+        Response.new(operation:, status:, response_object:, content_type: defined_content_type, content_schema:)
+      end
+
+      private
+
+      attr_reader :openapi_version, :operation
+
+      def response_without_content(status, response_object)
+        Response.new(operation:, status:, response_object:, content_type: nil, content_schema: nil)
+      end
+
+      def find_defined_content_type(response_object, content_type)
+        return if content_type.nil?
+
+        content = response_object['content']
+        return content_type if content.key?(content_type)
+
+        type = content_type.split(';')[0]
+        return type if content.key?(type)
+
+        key = "#{type.split('/')[0]}/*"
+        return key if content.key?(key)
+
+        key = '*/*'
+        key if content.key?(key)
+      end
+
+      def content_defined?(response_object)
+        response_object['content']&.any?
+      end
+
+      def find_content_schema(response_object, response_content_type)
+        return unless response_content_type
+
+        content_object = find_response_body(response_object['content'], response_content_type)
+        content_schema_object = content_object&.fetch('schema', nil)
+        return unless content_schema_object
+
+        Schema.new(content_schema_object, write: false, openapi_version: operation.openapi_version)
+      end
+
+      def find_response_object(status)
+        @responses_object[status.to_s] ||
+          @responses_object["#{status / 100}XX"] ||
+          @responses_object["#{status / 100}xx"] ||
+          @responses_object['default']
+      end
+
+      def find_response_body(content, content_type)
+        content&.fetch(content_type) do |_|
+          type = content_type.split(';')[0]
+          content[type] || content["#{type.split('/')[0]}/*"] || content['*/*']
+        end
+      end
+    end
+  end
+end

data/lib/openapi_first/definition.rb

@@ -2,6 +2,7 @@
 
 require 'mustermann/template'
 require_relative 'definition/path_item'
+require_relative 'runtime_request'
 
 module OpenapiFirst
   # Represents an OpenAPI API Description document
@@ -14,31 +15,63 @@ module OpenapiFirst
       @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
+    def request(rack_request)
+      path_item, path_params = find_path_item_and_params(rack_request.path)
+      operation = path_item&.operation(rack_request.request_method.downcase)
+      RuntimeRequest.new(
+        request: rack_request,
+        path_item:,
+        operation:,
+        path_params:
+      )
+    end
 
-        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 }
+    def response(rack_request, rack_response)
+      request(rack_request).response(rack_response)
     end
 
     def operations
-      methods = %w[get head post put patch delete trace options]
-      @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
+      @operations ||= path_items.flat_map(&:operations)
+    end
+
+    def path(pathname)
+      return unless paths.key?(pathname)
+
+      PathItem.new(pathname, paths[pathname], openapi_version:)
     end
 
     private
 
+    def path_items
+      @path_items ||= paths.flat_map do |path, path_item_object|
+        PathItem.new(path, path_item_object, openapi_version:)
+      end
+    end
+
+    def find_path_item_and_params(request_path)
+      if paths.key?(request_path)
+        return [
+          PathItem.new(request_path, paths[request_path], openapi_version:),
+          {}
+        ]
+      end
+      search_for_path_item(request_path)
+    end
+
+    def search_for_path_item(request_path)
+      paths.find do |path, path_item_object|
+        template = Mustermann::Template.new(path)
+        path_params = template.params(request_path)
+        next unless path_params
+        next unless path_params.size == template.names.size
+
+        return [
+          PathItem.new(path, path_item_object, openapi_version:),
+          path_params
+        ]
+      end
+    end
+
     def detect_version(resolved)
       (resolved['openapi'] || resolved['swagger'])[0..2]
     end

data/lib/openapi_first/error_response.rb

@@ -1,47 +1,40 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module OpenapiFirst
-  # This is the base class for error responses
-  class ErrorResponse
-    ## @param request [Hash] The Rack request env
-    ## @param request_validation_error [OpenapiFirst::RequestValidationError]
-    def initialize(env, request_validation_error)
-      @env = env
-      @request_validation_error = request_validation_error
+  # This is the base module for error responses
+  module ErrorResponse
+    ## @param failure [OpenapiFirst::Failure]
+    def initialize(failure: nil)
+      @failure = failure
     end
 
-    extend Forwardable
-
-    attr_reader :env, :request_validation_error
-
-    def_delegators :@request_validation_error, :status, :location, :schema_validation
+    attr_reader :failure
 
-    def validation_output
-      schema_validation&.output
+    # The response body
+    def body
+      raise NotImplementedError
     end
 
-    def schema
-      schema_validation&.schema
+    # The response content-type
+    def content_type
+      raise NotImplementedError
     end
 
-    def data
-      schema_validation&.data
-    end
+    STATUS = {
+      not_found: 404,
+      method_not_allowed: 405,
+      unsupported_media_type: 415
+    }.freeze
+    private_constant :STATUS
 
-    def message
-      request_validation_error.message
+    # The response status
+    def status
+      STATUS[failure.error_type] || 400
     end
 
+    # Render this error response
     def render
       Rack::Response.new(body, status, Rack::CONTENT_TYPE => content_type).finish
     end
-
-    def content_type = 'application/json'
-
-    def body
-      raise NotImplementedError
-    end
   end
 end

data/lib/openapi_first/errors.rb

@@ -2,20 +2,8 @@
 
 module OpenapiFirst
   class Error < StandardError; end
-
   class NotFoundError < Error; end
-
-  class ResponseInvalid < Error; end
-
-  class ResponseCodeNotFoundError < ResponseInvalid; end
-
-  class ResponseContentTypeNotFoundError < ResponseInvalid; end
-
-  class ResponseBodyInvalidError < ResponseInvalid; end
-
-  class ResponseHeaderInvalidError < ResponseInvalid; end
-
-  class BodyParsingError < Error; end
-
   class RequestInvalidError < Error; end
+  class ResponseNotFoundError < Error; end
+  class ResponseInvalidError < Error; end
 end