request_handler 1.1.0 → 2.1.1

data/lib/request_handler/builder/options_builder.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+require 'request_handler/builder/headers_builder'
+require 'request_handler/builder/page_builder'
+require 'request_handler/builder/include_options_builder'
+require 'request_handler/builder/sort_options_builder'
+require 'request_handler/builder/filter_builder'
+require 'request_handler/builder/query_builder'
+require 'request_handler/builder/body_builder'
+require 'request_handler/builder/multipart_builder'
+require 'request_handler/builder/fieldsets_builder'
+
+module RequestHandler
+  module Builder
+    class OptionsBuilder < Base
+      Options = Struct.new(:page, :include_options, :sort_options, :filter, :query, :body,
+                           :multipart, :fieldsets, :headers)
+
+      def create_klass_struct
+        @result = Options.new
+      end
+
+      def page(&block)
+        @result.page = build_page(&block)
+      end
+
+      def include_options(&block)
+        @result.include_options = build_include_options(&block)
+      end
+
+      def sort_options(&block)
+        @result.sort_options = build_sort_options(&block)
+      end
+
+      def filter(&block)
+        @result.filter = build_filter(&block)
+      end
+
+      def query(&block)
+        @result.query = build_query(&block)
+      end
+
+      def body(&block)
+        @result.body = build_body(&block)
+      end
+
+      def multipart(&block)
+        @result.multipart = build_multipart(&block)
+      end
+
+      def fieldsets(&block)
+        @result.fieldsets = build_fieldsets(&block)
+      end
+
+      def headers(&block)
+        @result.headers = build_headers(&block)
+      end
+
+      def build_page(&block)
+        Docile.dsl_eval(PageBuilder.new, &block).build
+      end
+
+      def build_include_options(&block)
+        Docile.dsl_eval(IncludeOptionsBuilder.new, &block).build
+      end
+
+      def build_sort_options(&block)
+        Docile.dsl_eval(SortOptionsBuilder.new, &block).build
+      end
+
+      def build_filter(&block)
+        Docile.dsl_eval(FilterBuilder.new, &block).build
+      end
+
+      def build_query(&block)
+        Docile.dsl_eval(QueryBuilder.new, &block).build
+      end
+
+      def build_body(&block)
+        Docile.dsl_eval(BodyBuilder.new, &block).build
+      end
+
+      def build_multipart(&block)
+        Docile.dsl_eval(MultipartBuilder.new, &block).build
+      end
+
+      def build_fieldsets(&block)
+        Docile.dsl_eval(FieldsetsBuilder.new, &block).build
+      end
+
+      def build_headers(&block)
+        Docile.dsl_eval(HeadersBuilder.new, &block).build
+      end
+    end
+  end
+end

data/lib/request_handler/builder/page_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+require 'request_handler/builder/page_resource_builder'
+
+module RequestHandler
+  module Builder
+    class PageBuilder < Base
+      def create_klass_struct
+        @result = OpenStruct.new
+      end
+
+      def default_size(value)
+        @result.default_size = value
+      end
+
+      def max_size(value)
+        @result.max_size = value
+      end
+
+      def resource(name, &block)
+        @result[name.to_sym] = build_page_resource(&block)
+      end
+
+      def build_page_resource(&block)
+        Docile.dsl_eval(PageResourceBuilder.new, &block).build
+      end
+    end
+  end
+end

data/lib/request_handler/builder/page_resource_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+
+module RequestHandler
+  module Builder
+    class PageResourceBuilder < Base
+      PageResource = Struct.new(:default_size, :max_size)
+
+      def create_klass_struct
+        @result = PageResource.new
+      end
+
+      def default_size(value)
+        @result.default_size = value
+      end
+
+      def max_size(value)
+        @result.max_size = value
+      end
+    end
+  end
+end

data/lib/request_handler/builder/query_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+
+module RequestHandler
+  module Builder
+    class QueryBuilder < Base
+      Query = Struct.new(:schema, :options)
+
+      def create_klass_struct
+        @result = Query.new
+      end
+
+      def schema(value)
+        @result.schema = value
+      end
+
+      def options(value)
+        @result.options = value
+      end
+    end
+  end
+end

data/lib/request_handler/builder/sort_options_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+
+module RequestHandler
+  module Builder
+    class SortOptionsBuilder < Base
+      SortOptions = Struct.new(:allowed, :defaults)
+
+      def create_klass_struct
+        @result = SortOptions.new
+      end
+
+      def allowed(value)
+        @result.allowed = value
+      end
+
+      def defaults(value)
+        @result.defaults = value
+      end
+    end
+  end
+end

data/lib/request_handler/concerns/config_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RequestHandler
+  module Concerns
+    module ConfigHelper
+      def lookup!(hash, key)
+        lookup(hash, key) || (raise NoConfigAvailableError, key.to_sym => 'is not configured')
+      end
+
+      def lookup(config, key)
+        config.dig(*symbolize_key(key))
+      end
+
+      def symbolize_key(key)
+        key.split('.').map(&:to_sym)
+      end
+
+      def deep_to_h(obj)
+        obj.to_h.transform_values do |v|
+          v.is_a?(OpenStruct) || v.is_a?(Struct) ? deep_to_h(v) : v
+        end
+      end
+    end
+  end
+end

data/lib/request_handler/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'docile'
+
+module RequestHandler
+  class Config
+    def initialize(&block)
+      @config = Docile.dsl_eval(RequestHandler::Builder::OptionsBuilder.new, &block).build
+    end
+
+    attr_accessor :config
+
+    def lookup!(key)
+      lookup(key) || (raise NoConfigAvailableError, key.to_sym => 'is not configured')
+    end
+
+    def lookup(key)
+      @config.dig(*symbolize_key(key))
+    end
+
+    private
+
+    def symbolize_key(key)
+      key.split('.').map(&:to_sym)
+    end
+
+    def deep_to_h(obj)
+      obj.to_h.transform_values do |v|
+        v.is_a?(OpenStruct) || v.is_a?(Struct) ? deep_to_h(v) : v
+      end
+    end
+  end
+end

data/lib/request_handler/error.rb

@@ -18,15 +18,26 @@ module RequestHandler
   end
   class ExternalBaseError < BaseError
   end
+  class JsonApiError < ExternalBaseError
+    def message
+      @errors.map do |error|
+        "#{error[:code]}: #{error[:source]} #{error[:detail]}"
+      end.join(',\n')
+    end
+
+    def errors
+      RequestHandler.configuration.raise_jsonapi_errors ? @errors : []
+    end
+  end
   class MissingArgumentError < InternalBaseError
   end
-  class ExternalArgumentError < ExternalBaseError
+  class ExternalArgumentError < JsonApiError
   end
   class InternalArgumentError < InternalBaseError
   end
-  class SchemaValidationError < ExternalBaseError
+  class SchemaValidationError < JsonApiError
   end
-  class OptionNotAllowedError < ExternalBaseError
+  class OptionNotAllowedError < JsonApiError
   end
   class NoConfigAvailableError < InternalBaseError
   end

data/lib/request_handler/fieldsets_parser.rb

@@ -7,9 +7,10 @@ module RequestHandler
     def initialize(params:, allowed: {}, required: [])
       @params = params
       allowed.reject! { |_k, v| v == false }
-      allowed.each_value do |option|
-        raise InternalArgumentError, allowed: 'must be a Enum or a Boolean' unless
-              option.is_a?(Dry::Types::Enum) || option.is_a?(TrueClass)
+      allowed.each_pair do |_key, value|
+        raise InternalArgumentError, allowed: 'must be a Schema or a Boolean' unless
+          RequestHandler.configuration.validation_engine.valid_schema?(value) ||
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
       end
       @allowed = allowed
       raise InternalArgumentError, required: 'must be an Array' unless required.is_a?(Array)
@@ -39,25 +40,48 @@ module RequestHandler
       if allowed[type] == true
         option.to_sym
       else
-        allowed[type].call(option).to_sym
+        RequestHandler.configuration.validation_engine.validate!(option, allowed[type]).output.to_sym
       end
-    rescue Dry::Types::ConstraintError
-      raise FieldsetsParamsError, fieldsets: "invalid field: <#{option}> for type: #{type}"
+    rescue Validation::Error
+      raise FieldsetsParamsError, [{ code: 'INVALID_QUERY_PARAMETER',
+                                     status: '400',
+                                     detail: "allowed fieldset does not include '#{option}'",
+                                     source: { parameter: "fields[#{type}]" } }]
     end
 
     def check_required_fieldsets_types(fieldsets)
-      return fieldsets if (required - fieldsets.keys).empty?
-      raise FieldsetsParamsError, fieldsets: 'missing required fieldsets parameter'
+      missing = required - fieldsets.keys
+      return fieldsets if missing.empty?
+      raise_missing_fieldsets!(missing)
     end
 
     def raise_invalid_field_option(type)
-      return if allowed.key?(type)
-      raise OptionNotAllowedError, fieldsets: "fieldsets for type: #{type} not allowed"
+      return if allowed.dig(type)
+      raise OptionNotAllowedError, [
+        {
+          code: 'INVALID_QUERY_PARAMETER',
+          status: '400',
+          detail: "fieldset for '#{type}' not allowed",
+          source: { parameter: "fields[#{type}]" }
+        }
+      ]
     end
 
     def raise_missing_fields_param
       return if required.empty?
-      raise FieldsetsParamsError, fieldsets: 'missing required fields options'
+      raise_missing_fieldsets!(required)
+    end
+
+    def raise_missing_fieldsets!(missing)
+      errors = missing.map do |type|
+        {
+          code: 'MISSING_QUERY_PARAMETER',
+          status: '400',
+          source: { parameter: '' },
+          detail: "missing required parameter fields[#{type}]"
+        }
+      end
+      raise FieldsetsParamsError, errors
     end
 
     attr_reader :params, :allowed, :required

data/lib/request_handler/filter_parser.rb

@@ -7,7 +7,7 @@ module RequestHandler
     def initialize(params:, schema:, additional_url_filter:, schema_options: {})
       super(schema: schema, schema_options: schema_options)
       @filter = params.fetch('filter') { {} }
-      raise FilterParamsError, filter: 'must be a Hash' unless @filter.is_a?(Hash)
+      raise FilterParamsError, [jsonapi_filter_syntax_error] unless @filter.is_a?(Hash)
       Array(additional_url_filter).each do |key|
         key = key.to_s
         raise build_error(key) unless @filter[key].nil?
@@ -17,6 +17,14 @@ module RequestHandler
 
     def run
       validate_schema(filter)
+    rescue SchemaValidationError => e
+      raise FilterParamsError, (e.errors.map do |schema_error|
+        source_param = "filter[#{schema_error[:source][:pointer]}]"
+        {
+          detail: schema_error[:detail],
+          **jsonapi_filter_base_error(source_param: source_param)
+        }
+      end)
     end
 
     private
@@ -25,6 +33,22 @@ module RequestHandler
       InternalArgumentError.new(filter: 'the filter key was set twice')
     end
 
+    def jsonapi_filter_base_error(source_param:)
+      {
+        status: '400',
+        code: 'INVALID_QUERY_PARAMETER',
+        source: { parameter: source_param }
+      }
+    end
+
+    def jsonapi_filter_syntax_error
+      {
+        **jsonapi_filter_base_error(source_param: 'filter'),
+        links: { about: 'https://jsonapi.org/recommendations/#filtering' },
+        detail: 'Filter parameter must conform to JSON API recommendation'
+      }
+    end
+
     attr_reader :filter
   end
 end

data/lib/request_handler/header_parser.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require 'request_handler/schema_parser'
 require 'request_handler/error'
+
 module RequestHandler
-  class HeaderParser
-    def initialize(env:)
+  class HeaderParser < SchemaParser
+    def initialize(env:, schema: nil, schema_options: {})
+      super(schema: schema, schema_options: schema_options) unless schema.nil?
+
       raise MissingArgumentError, env: 'is missing' if env.nil?
       @headers = Helper.deep_transform_keys_in_object(env.select { |k, _v| k.start_with?('HTTP_') }) do |k|
         k[5..-1].downcase.to_sym
@@ -11,11 +15,34 @@ module RequestHandler
     end
 
     def run
-      headers
+      return headers if schema.nil?
+
+      validate_headers!
     end
 
     private
 
+    def validate_headers!
+      validate_schema(headers)
+    rescue SchemaValidationError => e
+      raise ExternalArgumentError, external_argument_error_params(e)
+    end
+
+    def external_argument_error_params(error)
+      error.errors.map do |schema_error|
+        header = schema_error[:source][:pointer]
+        {
+          status: '400',
+          code: "#{headers[header.to_sym] ? 'INVALID' : 'MISSING'}_HEADER",
+          detail: "#{format_header_name(header)} #{schema_error[:detail]}"
+        }
+      end
+    end
+
+    def format_header_name(name)
+      name.split('_').map(&:capitalize).join('-')
+    end
+
     attr_reader :headers
   end
 end