request_handler 1.1.0 → 2.1.1

data/lib/request_handler/include_option_parser.rb

@@ -7,24 +7,37 @@ module RequestHandler
     def run
       return [] unless params.key?('include')
       options = fetch_options
-      raise IncludeParamsError, include: 'must not contain a space' if options.include? ' '
+      raise_error('INVALID_QUERY_PARAMETER', 'must not contain a space') if options.include?(' ')
       allowed_options(options.split(','))
     end
 
     def allowed_options(options)
       options.map do |option|
-        option.gsub!('.', ::RequestHandler.separator)
+        option.gsub!('.', ::RequestHandler.configuration.separator)
         begin
-          allowed_options_type.call(option).to_sym
-        rescue Dry::Types::ConstraintError
-          raise OptionNotAllowedError, option.to_sym => 'is not an allowed include option'
+          RequestHandler.configuration.validation_engine.validate!(option, allowed_options_type).output.to_sym
+        rescue Validation::Error
+          raise_error('OPTION_NOT_ALLOWED', "#{option} is not an allowed include option", OptionNotAllowedError)
         end
       end
     end
 
     def fetch_options
-      raise IncludeParamsError, include_options: 'query paramter must not be empty' if empty_param?('include')
+      raise_error('INVALID_QUERY_PARAMETER', 'must not be empty') if empty_param?('include')
       params.fetch('include') { '' }
     end
+
+    private
+
+    def raise_error(code, detail, error_klass = IncludeParamsError)
+      raise error_klass, [
+        {
+          status: '400',
+          code:   code,
+          detail: detail,
+          source: { parameter: 'include' }
+        }
+      ]
+    end
   end
 end

data/lib/request_handler/json_api_document_parser.rb

@@ -4,6 +4,8 @@ require 'request_handler/schema_parser'
 require 'request_handler/error'
 module RequestHandler
   class JsonApiDocumentParser < SchemaParser
+    NON_ATTRIBUTE_MEMBERS = %i[id type meta links].freeze
+
     def initialize(document:, schema:, schema_options: {})
       raise MissingArgumentError, "data": 'is missing' if document.nil?
       super(schema: schema, schema_options: schema_options)
@@ -19,7 +21,11 @@ module RequestHandler
 
     def flattened_document
       resource = document.fetch('data') do
-        raise BodyParamsError, resource: 'must contain data'
+        raise BodyParamsError, [{ code: 'INVALID_JSON_API',
+                                  status: '400',
+                                  title: 'Body is not valid JSON API payload',
+                                  detail: "Member 'data' is missing",
+                                  source: { pointer: '/' } }]
       end
       flatten_resource!(resource)
     end
@@ -37,6 +43,14 @@ module RequestHandler
       end
     end
 
+    def build_pointer(error)
+      non_nested_identifier = error[:schema_pointer] == error[:element].to_s
+      non_attribute_member = NON_ATTRIBUTE_MEMBERS.include?(error[:element])
+      ['/data',
+       ('attributes' unless non_attribute_member && non_nested_identifier),
+       error[:schema_pointer]].compact.join('/')
+    end
+
     attr_reader :document
   end
 end

data/lib/request_handler/multipart_parser.rb

@@ -1,33 +1,45 @@
 # frozen_string_literal: true
 
 require 'request_handler/error'
+require 'request_handler/base_parser'
 require 'request_handler/schema_parser'
 require 'request_handler/document_parser'
 
 module RequestHandler
-  class MultipartsParser
+  class MultipartsParser < BaseParser
     def initialize(request:, multipart_config:)
       @request = request
       @params = request.params
       @multipart_config = multipart_config
-      missing_arguments = []
-      missing_arguments << { multipart_config: 'is missing' } if multipart_config.nil?
-      raise MissingArgumentError, missing_arguments unless missing_arguments.empty?
+      raise MissingArgumentError, [{ multipart_config: 'is missing' }] if multipart_config.nil?
     end
 
     def run
-      multipart_config.each_with_object({}) do |(name, config), memo|
-        raise MultipartParamsError, multipart: "#{name} missing" if config[:required] && !params.key?(name.to_s)
+      deep_to_h(multipart_config).each_with_object({}) do |(name, config), indexed_parts|
+        validate_presence!(name) if config[:required]
         next if params[name.to_s].nil?
-        memo[name] = parse_part(name.to_s)
+        indexed_parts[name] = parse_part(name.to_s)
       end
     end
 
     private
 
+    def validate_presence!(sidecar_name)
+      return if params.key?(sidecar_name.to_s)
+      raise multipart_params_error("missing required sidecar resource: #{sidecar_name}")
+    end
+
+    def multipart_params_error(detail = '')
+      MultipartParamsError.new([{
+                                 status: '400',
+                                 code: 'INVALID_MULTIPART_REQUEST',
+                                 detail: detail
+                               }])
+    end
+
     def parse_part(name)
-      params[name].fetch(:tempfile) { raise MultipartParamsError, multipart_file: 'missing' }
-      if lookup("#{name}.schema")
+      params[name].fetch(:tempfile) { raise MultipartParamsError, [{ multipart_file: 'missing' }] }
+      if lookup(multipart_config, "#{name}.schema")
         parse_data(name)
       else
         params[name]
@@ -36,12 +48,12 @@ module RequestHandler
 
     def parse_data(name)
       data = load_json(name)
-      type = lookup("#{name}.type")
+      type = lookup(multipart_config, "#{name}.type")
       DocumentParser.new(
         type:             type,
         document:         data,
-        schema:           lookup("#{name}.schema"),
-        schema_options:   execute_options(lookup("#{name}.options"))
+        schema:           lookup(multipart_config, "#{name}.schema"),
+        schema_options:   execute_options(lookup(multipart_config, "#{name}.options"))
       ).run
     end
 
@@ -51,17 +63,13 @@ module RequestHandler
       file = file.read
       MultiJson.load(file)
     rescue MultiJson::ParseError
-      raise MultipartParamsError, multipart_file: 'invalid JSON'
+      raise multipart_params_error('sidecar resource is not valid JSON')
     end
 
     def multipart_file(name)
       params[name][:tempfile]
     end
 
-    def lookup(key)
-      multipart_config.lookup!(key)
-    end
-
     def execute_options(options)
       return {} if options.nil?
       return options unless options.respond_to?(:call)

data/lib/request_handler/option_parser.rb

@@ -6,13 +6,13 @@ module RequestHandler
     def initialize(params:, allowed_options_type:)
       @params = params
       @allowed_options_type = allowed_options_type
-      raise InternalArgumentError, allowed_options_type: 'must be a Enum' unless enum?
+      raise InternalArgumentError, allowed_options_type: 'must be a Schema' unless schema?
     end
 
     private
 
-    def enum?
-      @allowed_options_type.class.equal?(Dry::Types::Enum)
+    def schema?
+      RequestHandler.configuration.validation_engine.valid_schema?(@allowed_options_type)
     end
 
     def empty_param?(param)

data/lib/request_handler/page_parser.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'request_handler/error'
+require 'request_handler/base_parser'
+
 module RequestHandler
-  class PageParser
+  class PageParser < BaseParser
     def initialize(params:, page_config:)
       missing_arguments = []
       missing_arguments << { params: 'is missing' } if params.nil?
@@ -14,11 +16,10 @@ module RequestHandler
     end
 
     def run
-      base = { number: extract_number, size: extract_size }
-      cfg = config.keys.reduce(base) do |memo, key|
+      cfg = deep_to_h(config).keys.reduce(base_page) do |memo, key|
         next memo if TOP_LEVEL_PAGE_KEYS.include?(key)
-        memo.merge!("#{key}#{::RequestHandler.separator}number".to_sym => extract_number(prefix: key),
-                    "#{key}#{::RequestHandler.separator}size".to_sym   => extract_size(prefix: key))
+        memo.merge!("#{key}#{separator}number".to_sym => extract_number(prefix: key),
+                    "#{key}#{separator}size".to_sym   => extract_size(prefix: key))
       end
       check_for_missing_options(cfg)
       cfg
@@ -29,17 +30,20 @@ module RequestHandler
     TOP_LEVEL_PAGE_KEYS = Set.new(%i[default_size max_size])
     attr_reader :page_options, :config
 
+    def base_page
+      { number: extract_number, size: extract_size }
+    end
+
     def check_for_missing_options(config)
       missing_arguments = page_options.keys - config.keys.map(&:to_s)
       return if missing_arguments.empty?
-      missing_arguments.map! { |e| e.gsub(::RequestHandler.separator, '.') }
+      missing_arguments.map! { |e| e.gsub(separator, '.') }
       warn 'client sent unknown option ' + missing_arguments.to_s unless missing_arguments.empty?
     end
 
     def extract_number(prefix: nil)
       number_string = lookup_nested_params_key('number', prefix) || 1
-      error_msg = { :"#{prefix}#{::RequestHandler.separator}number" => 'must be a positive Integer' }
-      check_int(string: number_string, error_msg: error_msg)
+      check_int(string: number_string, param: "#{prefix}.number")
     end
 
     def extract_size(prefix: nil)
@@ -59,16 +63,24 @@ module RequestHandler
     def fetch_and_check_size(prefix)
       size_string = lookup_nested_params_key('size', prefix)
       return nil if size_string.nil?
-      error_msg = { :"#{prefix}#{::RequestHandler.separator}size" => 'must be a positive Integer' }
-      check_int(string: size_string, error_msg: error_msg) unless size_string.nil?
+      check_int(string: size_string, param: "#{prefix}.size") unless size_string.nil?
     end
 
-    def check_int(string:, error_msg:)
+    def check_int(string:, param:)
       output = Integer(string)
-      raise PageParamsError, error_msg unless output > 0
+      raise_page_param_error!(param) unless output > 0
       output
     rescue ArgumentError
-      raise PageParamsError, error_msg
+      raise_page_param_error!(param)
+    end
+
+    def raise_page_param_error!(param)
+      raise PageParamsError, [{
+        code: 'INVALID_QUERY_PARAMETER',
+        status: '400',
+        detail: 'must be a positive integer',
+        source: { parameter: "page[#{param}]" }
+      }]
     end
 
     def apply_max_size_constraint(size, prefix)
@@ -86,11 +98,11 @@ module RequestHandler
 
     def lookup_nested_config_key(key, prefix)
       key = prefix ? "#{prefix}.#{key}" : key
-      config.lookup!(key)
+      lookup(config, key)
     end
 
     def lookup_nested_params_key(key, prefix)
-      key = prefix ? "#{prefix}#{::RequestHandler.separator}#{key}" : key
+      key = prefix ? "#{prefix}#{separator}#{key}" : key
       page_options.fetch(key, nil)
     end
 
@@ -98,12 +110,16 @@ module RequestHandler
       ::RequestHandler.configuration.logger.warn(message)
     end
 
-    def raise_no_default_size(prefix, sep = ::RequestHandler.separator)
+    def raise_no_default_size(prefix, sep = separator)
       raise NoConfigAvailableError, :"#{prefix}#{sep}size" => 'has no default_size'
     end
 
-    def raise_not_positive(prefix, key, sep = ::RequestHandler.separator)
+    def raise_not_positive(prefix, key, sep = separator)
       raise InternalArgumentError, :"#{prefix}#{sep}#{key}" => 'must be a positive Integer'
     end
+
+    def separator
+      ::RequestHandler.configuration.separator
+    end
   end
 end

data/lib/request_handler/query_parser.rb

@@ -14,6 +14,14 @@ module RequestHandler
 
     def run
       validate_schema(query)
+    rescue SchemaValidationError => e
+      raise ExternalArgumentError, (e.errors.map do |schema_error|
+        param = schema_error[:source][:pointer]
+        { status: '400',
+          code: "#{query[param] ? 'INVALID' : 'MISSING'}_QUERY_PARAMETER",
+          detail: schema_error[:detail],
+          source: { parameter: param } }
+      end)
     end
 
     private

data/lib/request_handler/schema_parser.rb

@@ -8,7 +8,7 @@ module RequestHandler
       missing_arguments << { schema: 'is missing' } if schema.nil?
       missing_arguments << { schema_options: 'is missing' } if schema_options.nil?
       raise MissingArgumentError, missing_arguments unless missing_arguments.empty?
-      raise InternalArgumentError, schema: 'must be a Schema' unless schema.is_a?(Dry::Validation::Schema)
+      raise InternalArgumentError, schema: 'must be a Schema' unless validation_engine.valid_schema?(schema)
       @schema = schema
       @schema_options = schema_options
     end
@@ -17,28 +17,57 @@ module RequestHandler
 
     def validate_schema(data, with: schema)
       raise MissingArgumentError, data: 'is missing' if data.nil?
-      data = deep_symbolize_keys(data) if with.rules.keys.first.is_a?(Symbol)
       validator = validate(data, schema: with)
       validation_failure?(validator)
       validator.output
     end
 
     def validate(data, schema:)
-      if schema_options.empty?
-        schema.call(data)
-      else
-        schema.with(schema_options).call(data)
-      end
+      validation_engine.validate(data, schema, options: schema_options)
     end
 
     def validation_failure?(validator)
-      return unless validator.failure?
-      errors = validator.errors.each_with_object({}) do |(k, v), memo|
-        add_note(v, k, memo)
+      return if validator.valid?
+
+      errors = build_errors(validator.errors).map do |error|
+        jsonapi_error(error)
       end
       raise SchemaValidationError, errors
     end
 
+    def build_errors(error_hash, path = [])
+      errors = []
+      error_hash.each do |k, v|
+        errors += build_errors(v, path << k).flatten if v.is_a?(Hash)
+        v.each { |error| errors << error(path, k, error) } if v.is_a?(Array)
+        errors << error(path, k, v) if v.is_a?(String)
+      end
+      errors
+    end
+
+    def error(path, element, failure)
+      schema_pointer = validation_engine.error_pointer(failure) || (path + [element]).join('/')
+      {
+        schema_pointer:  schema_pointer,
+        element: element,
+        message: validation_engine.error_message(failure)
+      }
+    end
+
+    def jsonapi_error(error)
+      {
+        status: '422',
+        code: 'INVALID_RESOURCE_SCHEMA',
+        title: 'Invalid resource',
+        detail: error[:message],
+        source: { pointer: build_pointer(error) }
+      }
+    end
+
+    def build_pointer(error)
+      error[:schema_pointer]
+    end
+
     def add_note(v, k, memo)
       memo[k] = if v.is_a? Array
                   v.join(' ')
@@ -48,17 +77,8 @@ module RequestHandler
       memo
     end
 
-    def deep_symbolize_keys(hash)
-      mem = {}
-      hash.map do |key, value|
-        if value.is_a?(Hash)
-          value = deep_symbolize_keys(value)
-        elsif value.is_a?(Array)
-          value.map! { |v| v.is_a?(Hash) ? deep_symbolize_keys(v) : v }
-        end
-        mem[key.to_sym] = value
-      end
-      mem
+    def validation_engine
+      RequestHandler.configuration.validation_engine
     end
 
     attr_reader :schema, :schema_options

data/lib/request_handler/sort_option_parser.rb

@@ -8,26 +8,26 @@ module RequestHandler
     def run
       return [] unless params.key?('sort')
       sort_options = parse_options(fetch_options)
-      raise SortParamsError, sort_options: 'must be unique' if duplicates?(sort_options)
+      raise SortParamsError, [jsonapi_error('sort options must be unique')] if duplicates?(sort_options)
       sort_options
     end
 
     def fetch_options
-      raise SortParamsError, sort_options: 'the query paramter must not be empty' if empty_param?('sort')
+      raise SortParamsError, [jsonapi_error('must not be empty')] if empty_param?('sort')
       params.fetch('sort') { '' }.split(',')
     end
 
     def parse_options(options)
       options.map do |option|
         name, order = parse_option(option)
-        name.gsub!('.', ::RequestHandler.separator)
+        name.gsub!('.', ::RequestHandler.configuration.separator)
         allowed_option(name)
         SortOption.new(name, order)
       end
     end
 
     def parse_option(option)
-      raise SortParamsError, sort_options: 'must not contain a space' if option.include? ' '
+      raise SortParamsError, [jsonapi_error('must not contain spaces')] if option.include? ' '
       if option.start_with?('-')
         [option[1..-1], :desc]
       else
@@ -36,13 +36,24 @@ module RequestHandler
     end
 
     def allowed_option(name)
-      allowed_options_type.call(name)
-    rescue Dry::Types::ConstraintError
-      raise OptionNotAllowedError, name.to_sym => 'is not an allowed sort option'
+      RequestHandler.configuration.validation_engine.validate!(name, allowed_options_type).output
+    rescue Validation::Error
+      raise OptionNotAllowedError, [jsonapi_error("#{name} is not an allowed sort option")]
     end
 
     def duplicates?(options)
       !options.uniq!(&:field).nil?
     end
+
+    private
+
+    def jsonapi_error(detail)
+      {
+        code: 'INVALID_QUERY_PARAMETER',
+        status: '400',
+        source: { parameter: 'sort' },
+        detail: detail
+      }
+    end
   end
 end