openapi_first 1.0.0.beta5 → 1.0.0

data/lib/openapi_first/definition/operation.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'set'
+require_relative 'request_body'
+require_relative 'query_parameters'
+require_relative 'header_parameters'
+require_relative 'path_parameters'
+require_relative 'cookie_parameters'
+require_relative 'responses'
+
+module OpenapiFirst
+  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 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_status_defined?(status)
+        responses.status_defined?(status)
+      end
+
+      def_delegators :responses, :response_for
+
+      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
+
+      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
+
+      private
+
+      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'])
+        end
+      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,32 @@
+# frozen_string_literal: true
+
+require_relative 'operation'
+
+module OpenapiFirst
+  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]
+
+        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/path_parameters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'openapi_parameters'
+require_relative 'parameters'
+
+module OpenapiFirst
+  class PathParameters < Parameters
+    def unpack(original_path_params)
+      OpenapiParameters::Path.new(@parameter_definitions).unpack(original_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,43 @@
+# frozen_string_literal: true
+
+require_relative '../schema'
+
+module OpenapiFirst
+  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: @operation.write?,
+                                                 openapi_version: @operation.openapi_version)
+      end
+    end
+  end
+end

data/lib/openapi_first/definition/response.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  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

@@ -1,24 +1,77 @@
 # frozen_string_literal: true
 
-require_relative 'operation'
+require 'mustermann/template'
+require_relative 'definition/path_item'
+require_relative 'runtime_request'
 
 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
-      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
-      end
+      @paths = resolved['paths']
+      @openapi_version = detect_version(resolved)
+    end
+
+    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
+
+    def response(rack_request, rack_response)
+      request(rack_request).response(rack_response)
+    end
+
+    def operations
+      @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,45 +1,40 @@
 # frozen_string_literal: true
 
 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 :failure
 
-    attr_reader :env, :request_validation_error
-
-    def_delegators :@request_validation_error, :status, :location, :schema_validation
-
-    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

data/lib/openapi_first/failure.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  class Failure
+    FAILURE = :openapi_first_validation_failure
+
+    TYPES = {
+      not_found: [NotFoundError, 'Request path is not defined.'],
+      method_not_allowed: [RequestInvalidError, 'Request method is not defined.'],
+      unsupported_media_type: [RequestInvalidError, 'Request content type is not defined.'],
+      invalid_body: [RequestInvalidError, 'Request body invalid:'],
+      invalid_query: [RequestInvalidError, 'Query parameter is invalid:'],
+      invalid_header: [RequestInvalidError, 'Request header is invalid:'],
+      invalid_path: [RequestInvalidError, 'Path segment is invalid:'],
+      invalid_cookie: [RequestInvalidError, 'Cookie value is invalid:'],
+      response_not_found: [ResponseNotFoundError, 'Response is not defined.'],
+      invalid_response_body: [ResponseInvalidError, 'Response body is invalid:'],
+      invalid_response_header: [ResponseInvalidError, 'Response header is invalid:']
+    }.freeze
+    private_constant :TYPES
+
+    # @param error_type [Symbol] See Failure::TYPES.keys
+    # @param errors [Array<OpenapiFirst::Schema::ValidationResult>]
+    def self.fail!(error_type, message: nil, errors: nil)
+      throw FAILURE, new(
+        error_type,
+        message:,
+        errors:
+      )
+    end
+
+    # @param type [Symbol] See TYPES.keys
+    # @param message [String] A generic error message
+    # @param errors [Array<OpenapiFirst::Schema::ValidationError>]
+    def initialize(error_type, message: nil, errors: nil)
+      unless TYPES.key?(error_type)
+        raise ArgumentError,
+              "error_type must be one of #{TYPES.keys} but was #{error_type.inspect}"
+      end
+
+      @error_type = error_type
+      @message = message
+      @errors = errors
+    end
+
+    attr_reader :error_type, :message, :errors
+
+    # Raise an exception that fits the failure.
+    def raise!
+      exception, message_prefix = TYPES.fetch(error_type)
+
+      raise exception, "#{message_prefix} #{@message || errors&.map(&:error)&.join('. ')}"
+    end
+  end
+end

data/lib/openapi_first/middlewares/request_validation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rack'
+module OpenapiFirst
+  module Middlewares
+    # A Rack middleware to validate requests against an OpenAPI API description
+    class RequestValidation
+      # @param app The parent Rack application
+      # @param options An optional Hash of configuration options to override defaults
+      #   :raise_error    A Boolean indicating whether to raise an error if validation fails.
+      #                   default: false
+      #   :error_response The Class to use for error responses.
+      #                   default: OpenapiFirst::Plugins::Default::ErrorResponse (Config.default_options.error_response)
+      def initialize(app, options = {})
+        @app = app
+        @raise = options.fetch(:raise_error, OpenapiFirst.configuration.request_validation_raise_error)
+        @error_response_class = error_response(options[:error_response])
+
+        spec = options.fetch(:spec)
+        raise "You have to pass spec: when initializing #{self.class}" unless spec
+
+        @definition = spec.is_a?(Definition) ? spec : OpenapiFirst.load(spec)
+      end
+
+      def call(env)
+        request = find_request(env)
+        return @app.call(env) unless request
+
+        failure = if @raise
+                    request.validate!
+                  else
+                    request.validate
+                  end
+        return @error_response_class.new(failure:).render if failure
+
+        @app.call(env)
+      end
+
+      private
+
+      def find_request(env)
+        env[REQUEST] ||= @definition.request(Rack::Request.new(env))
+      end
+
+      def error_response(mod)
+        return OpenapiFirst.plugin(mod)::ErrorResponse if mod.is_a?(Symbol)
+
+        mod || OpenapiFirst.configuration.request_validation_error_response
+      end
+    end
+  end
+end