openapi_first 1.4.3 → 2.0.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_first
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Andreas Haller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-07 00:00:00.000000000 Z
+date: 2024-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hana
@@ -110,33 +110,38 @@ files:
 - README.md
 - lib/openapi_first.rb
 - lib/openapi_first/body_parser.rb
+- lib/openapi_first/builder.rb
 - lib/openapi_first/configuration.rb
 - lib/openapi_first/definition.rb
-- lib/openapi_first/definition/operation.rb
-- lib/openapi_first/definition/path_item.rb
-- lib/openapi_first/definition/path_template.rb
-- lib/openapi_first/definition/request_body.rb
-- lib/openapi_first/definition/response.rb
-- lib/openapi_first/definition/responses.rb
 - lib/openapi_first/error_response.rb
+- lib/openapi_first/error_responses/default.rb
+- lib/openapi_first/error_responses/jsonapi.rb
 - lib/openapi_first/errors.rb
 - lib/openapi_first/failure.rb
 - lib/openapi_first/json_refs.rb
 - lib/openapi_first/middlewares/request_validation.rb
 - lib/openapi_first/middlewares/response_validation.rb
-- lib/openapi_first/plugins.rb
-- lib/openapi_first/plugins/default.rb
-- lib/openapi_first/plugins/default/error_response.rb
-- lib/openapi_first/plugins/jsonapi.rb
-- lib/openapi_first/plugins/jsonapi/error_response.rb
-- lib/openapi_first/request_validation/request_body_validator.rb
-- lib/openapi_first/request_validation/validator.rb
-- lib/openapi_first/response_validation/validator.rb
-- lib/openapi_first/runtime_request.rb
-- lib/openapi_first/runtime_response.rb
+- lib/openapi_first/request.rb
+- lib/openapi_first/request_parser.rb
+- lib/openapi_first/request_validator.rb
+- lib/openapi_first/response.rb
+- lib/openapi_first/response_parser.rb
+- lib/openapi_first/response_validator.rb
+- lib/openapi_first/router.rb
+- lib/openapi_first/router/find_content.rb
+- lib/openapi_first/router/find_response.rb
+- lib/openapi_first/router/path_template.rb
 - lib/openapi_first/schema.rb
 - lib/openapi_first/schema/validation_error.rb
 - lib/openapi_first/schema/validation_result.rb
+- lib/openapi_first/test.rb
+- lib/openapi_first/test/methods.rb
+- lib/openapi_first/validated_request.rb
+- lib/openapi_first/validated_response.rb
+- lib/openapi_first/validators/request_body.rb
+- lib/openapi_first/validators/request_parameters.rb
+- lib/openapi_first/validators/response_body.rb
+- lib/openapi_first/validators/response_headers.rb
 - lib/openapi_first/version.rb
 homepage: https://github.com/ahx/openapi_first
 licenses:
@@ -155,14 +160,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.1
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Implement HTTP APIs based on OpenApi 3.x

data/lib/openapi_first/definition/operation.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'set'
-require 'openapi_parameters'
-require_relative 'request_body'
-require_relative 'responses'
-
-module OpenapiFirst
-  class Definition
-    # Represents an operation object in the OpenAPI 3.X specification.
-    # Use this class to access information about the operation. Use `#[key]` to read the raw data.
-    # When using the middleware you can access the operation object via `env[OpenapiFirst::REQUEST].operation`.
-    class Operation
-      extend Forwardable
-
-      def_delegators :operation_object,
-                     :[]
-
-      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
-
-      # Returns the path of the operation as in the API description.
-      # @return [String] The path of the operation.
-      attr_reader :path
-
-      # Returns the (downcased) request method of the operation.
-      # Example: "get"
-      # @return [String] The request method of the operation.
-      attr_reader :method
-      alias request_method method
-
-      attr_reader :openapi_version # :nodoc:
-
-      # Returns the operation ID as defined in the API description.
-      # @return [String, nil]
-      def operation_id
-        operation_object['operationId']
-      end
-
-      # Checks if the operation is a read operation.
-      # This is the case for all request methods except POST, PUT, PATCH and DELETE.
-      # @return [Boolean] `true` if the operation is a read operation, `false` otherwise.
-      def read?
-        !write?
-      end
-
-      # Checks if the operation is a write operation.
-      # This is the case for POST, PUT, PATCH and DELETE request methods.
-      # @return [Boolean] `true` if the operation is a write operation, `false` otherwise.
-      # @deprecated Use {#write?} instead.
-      def write?
-        WRITE_METHODS.include?(method)
-      end
-
-      # Returns the request body definition if defined in the API description.
-      # @return [RequestBody, nil] The request body of the operation, or `nil` if not present.
-      def request_body
-        @request_body ||= RequestBody.new(operation_object['requestBody'], self) if operation_object['requestBody']
-      end
-
-      # Checks if a response status is defined for this operation.
-      # @param status [Integer, String] The response status to check.
-      # @return [Boolean] `true` if the response status is defined, `false` otherwise.
-      def response_status_defined?(status)
-        responses.status_defined?(status)
-      end
-
-      # Returns the response object for a given status.
-      # @param status [Integer, String] The response status.
-      # @param content_type [String] Content-Type of the current response.
-      # @return [Response, nil] The response object for the given status, or `nil` if not found.
-      def response_for(status, content_type)
-        responses.response_for(status, content_type)
-      end
-
-      # Returns the schema for a given content type.
-      # @param content_type [String] The content type.
-      # @return [Schema, nil] The schema for the given content type, or `nil` if not found.
-      def schema_for(content_type)
-        content = @request_body_object['content']
-        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
-
-      # Returns a unique name for this operation. Used for generating error messages.
-      # @visibility private
-      def name
-        @name ||= "#{method.upcase} #{path}"
-      end
-
-      # Returns the path parameters of the operation.
-      # @return [Array<Hash>] The path parameters of the operation.
-      def path_parameters
-        all_parameters['path']
-      end
-
-      # Returns the query parameters of the operation.
-      # Returns parameters defined on the path and in the operation.
-      # @return [Array<Hash>] The query parameters of the operation.
-      def query_parameters
-        all_parameters['query']
-      end
-
-      # Returns the header parameters of the operation.
-      # Returns parameters defined on the path and in the operation.
-      # @return [Array<Hash>] The header parameters of the operation.
-      def header_parameters
-        all_parameters['header']
-      end
-
-      # Returns the cookie parameters of the operation.
-      # Returns parameters defined on the path and in the operation.
-      # @return [Array<Hash>] The cookie parameters of the operation.
-      def cookie_parameters
-        all_parameters['cookie']
-      end
-
-      # Returns the schema for the path parameters.
-      # @visibility private
-      # @return [Schema, nil] The schema for the path parameters, or `nil` if not found.
-      def path_parameters_schema
-        @path_parameters_schema ||= build_schema(path_parameters)
-      end
-
-      # Returns the schema for the query parameters.
-      # @visibility private
-      # @return [Schema, nil] The schema for the query parameters, or `nil` if not found.
-      def query_parameters_schema
-        @query_parameters_schema ||= build_schema(query_parameters)
-      end
-
-      # Returns the schema for the header parameters.
-      # @visibility private
-      # @return [Schema, nil] The schema for the header parameters, or `nil` if not found.
-      def header_parameters_schema
-        @header_parameters_schema ||= build_schema(header_parameters)
-      end
-
-      # Returns the schema for the cookie parameters.
-      # @visibility private
-      # @return [Schema, nil] The schema for the cookie parameters, or `nil` if not found.
-      def cookie_parameters_schema
-        @cookie_parameters_schema ||= build_schema(cookie_parameters)
-      end
-
-      private
-
-      WRITE_METHODS = Set.new(%w[post put patch delete]).freeze
-      private_constant :WRITE_METHODS
-
-      IGNORED_HEADERS = Set['Content-Type', 'Accept', 'Authorization'].freeze
-      private_constant :IGNORED_HEADERS
-
-      def all_parameters
-        @all_parameters ||= (@path_item_object.fetch('parameters', []) + operation_object.fetch('parameters', []))
-                            .reject { |p| p['in'] == 'header' && IGNORED_HEADERS.include?(p['name']) }
-                            .group_by { _1['in'] }
-      end
-
-      def build_schema(parameters)
-        return unless parameters&.any?
-
-        init_schema = {
-          'type' => 'object',
-          'properties' => {},
-          'required' => []
-        }
-        schema = parameters.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
-
-      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
-    end
-  end
-end

data/lib/openapi_first/definition/path_item.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require_relative 'operation'
-require_relative 'path_template'
-
-module OpenapiFirst
-  class Definition
-    # A pathItem as defined in the OpenAPI document.
-    class PathItem
-      extend Forwardable
-
-      def initialize(path, path_item_object, openapi_version:)
-        @path = path
-        @path_item_object = path_item_object
-        @openapi_version = openapi_version
-        @path_template = PathTemplate.new(path)
-      end
-
-      attr_reader :path
-
-      def_delegator :@path_template, :match
-
-      def operation(request_method)
-        return unless @path_item_object[request_method]
-
-        Operation.new(
-          @path, request_method, @path_item_object, openapi_version: @openapi_version
-        )
-      end
-
-      METHODS = %w[get head post put patch delete trace options].freeze
-      private_constant :METHODS
-
-      def operations
-        @operations ||= @path_item_object.slice(*METHODS).keys.map { |method| operation(method) }
-      end
-    end
-  end
-end

data/lib/openapi_first/definition/request_body.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../schema'
-
-module OpenapiFirst
-  class Definition
-    # Represents a request body definition in the OpenAPI document that belongs to an operation.
-    class RequestBody
-      def initialize(request_body_object, operation)
-        @request_body_object = request_body_object
-        @operation = operation
-      end
-
-      def description
-        @request_body_object['description']
-      end
-
-      def required?
-        !!@request_body_object['required']
-      end
-
-      def schema_for(content_type)
-        content = @request_body_object['content']
-        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_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: true,
-                                                   openapi_version: @operation.openapi_version)
-        end
-      end
-    end
-  end
-end

data/lib/openapi_first/definition/response.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  class Definition
-    # Represents a response definition in the OpenAPI document.
-    # This is not a direct reflecton of the OpenAPI 3.X response definition, but a combination of
-    # status, content type and content schema.
-    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] operation The operation this response belongs to.
-      # @attr_reader [Integer] status The HTTP status code of the response definition.
-      # @attr_reader [String, nil] content_type Content type of this response.
-      # @attr_reader [Schema, nil] content_schema the Schema of the response body.
-      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

@@ -1,87 +0,0 @@
-# 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)
-        # According to OAS status has to be a string,
-        # but there are a few API descriptions out there that use integers because of YAML.
-        return @responses_object[status] if @responses_object.key?(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/plugins/default/error_response.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  module Plugins
-    module Default
-      # An error reponse that returns application/problem+json with a list of "errors"
-      # See also https://www.rfc-editor.org/rfc/rfc9457.html
-      class ErrorResponse
-        include OpenapiFirst::ErrorResponse
-
-        TITLES = {
-          not_found: 'Not Found',
-          method_not_allowed: 'Request Method Not Allowed',
-          unsupported_media_type: 'Unsupported Media Type',
-          invalid_body: 'Bad Request Body',
-          invalid_query: 'Bad Query Parameter',
-          invalid_header: 'Bad Request Header',
-          invalid_path: 'Bad Request Path',
-          invalid_cookie: 'Bad Request Cookie'
-        }.freeze
-        private_constant :TITLES
-
-        def body
-          result = {
-            title:,
-            status:
-          }
-          result[:errors] = errors if failure.errors
-          MultiJson.dump(result)
-        end
-
-        def type = failure.type
-
-        def title
-          TITLES.fetch(type)
-        end
-
-        def content_type
-          'application/problem+json'
-        end
-
-        def errors
-          key = pointer_key
-          failure.errors.map do |error|
-            {
-              message: error.error,
-              key => pointer(error.instance_location),
-              code: error.type
-            }
-          end
-        end
-
-        def pointer_key
-          case type
-          when :invalid_body
-            :pointer
-          when :invalid_query, :invalid_path
-            :parameter
-          when :invalid_header
-            :header
-          when :invalid_cookie
-            :cookie
-          end
-        end
-
-        def pointer(data_pointer)
-          return data_pointer if type == :invalid_body
-
-          data_pointer.delete_prefix('/')
-        end
-      end
-    end
-  end
-end

data/lib/openapi_first/plugins/default.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'default/error_response'
-
-module OpenapiFirst
-  module Plugins
-    module Default # :nodoc:
-      OpenapiFirst.register(:default, self)
-    end
-  end
-end

data/lib/openapi_first/plugins/jsonapi/error_response.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  module Plugins
-    module Jsonapi
-      # A JSON:API conform error response. See https://jsonapi.org/.
-      class ErrorResponse
-        include OpenapiFirst::ErrorResponse
-
-        def body
-          MultiJson.dump({ errors: serialized_errors })
-        end
-
-        def content_type
-          'application/vnd.api+json'
-        end
-
-        def serialized_errors
-          return default_errors unless failure.errors
-
-          key = pointer_key
-          failure.errors.map do |error|
-            {
-              status: status.to_s,
-              source: { key => pointer(error.instance_location) },
-              title: error.error,
-              code: error.type
-            }
-          end
-        end
-
-        def default_errors
-          [{
-            status: status.to_s,
-            title: Rack::Utils::HTTP_STATUS_CODES[status]
-          }]
-        end
-
-        def pointer_key
-          case failure.type
-          when :invalid_body
-            :pointer
-          when :invalid_query, :invalid_path
-            :parameter
-          when :invalid_header
-            :header
-          when :invalid_cookie
-            :cookie
-          end
-        end
-
-        def pointer(data_pointer)
-          return data_pointer if failure.type == :invalid_body
-
-          data_pointer.delete_prefix('/')
-        end
-      end
-    end
-  end
-end

data/lib/openapi_first/plugins/jsonapi.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'jsonapi/error_response'
-
-module OpenapiFirst
-  module Plugins
-    module Jsonapi # :nodoc:
-      OpenapiFirst.register(:jsonapi, self)
-    end
-  end
-end

data/lib/openapi_first/plugins.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  # Plugin System adapted from
-  # Polished Ruby Programming by Jeremy Evans
-  # https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=0
-  # @!visibility private
-  module Plugins
-    PLUGINS = {} # rubocop:disable Style/MutableConstant
-    private_constant :PLUGINS
-
-    def register(name, klass)
-      PLUGINS[name.to_sym] = klass
-    end
-
-    def plugin(name)
-      require "openapi_first/plugins/#{name}"
-      PLUGINS.fetch(name.to_sym)
-    end
-
-    def find_plugin(name)
-      PLUGINS.fetch(name)
-    end
-  end
-end