request_handler 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbf5f683f749e9a5431fe1d07a250c43e72446ddc4fdbb472acd7b06d737fad6
-  data.tar.gz: e12067caf9c5ec19b306a00d89666fac1a862449f8a68d17cb3ccda42e4a0cde
+  metadata.gz: c6f03be51da1bccf44ba08a55724d6cd68c8dd43817e5b1e74f427b9ae1164f7
+  data.tar.gz: 942131e22d64ee316f7e7c690c9c1a6af0d5c589459d2bc77786e86a940fe342
 SHA512:
-  metadata.gz: df12c3277ca4cb9d73bd8a1661427db90b257bc263e10f40344775a4e3f6f7c8f558a5873cfacab95d888cd7d3ea6e835b72ebc2aa9c176117196530e5a585a2
-  data.tar.gz: a53b49ccdfde6d9fb929263729972bc5732f01e2997848299ce1dbec187be23a565b5a745ca00dc6cd5765b20bff62ccc2b729abd80bb8ad3965f1ce457e4808
+  metadata.gz: f50ec83b0dc218d07d9f9703f929696f761dfd812e2a1dd5230d2e901f20ac1c4141d8674a332d08ecf3297dd7e3a3af4514e7330e37d341db92efc1dc660714
+  data.tar.gz: 7e0b0d58b1f0fd697432c9e3f0fb4447b983510bc643acde7713db1c3bc8de23a4209bd45e80ce9f255458ba0c83c5dbd9f22eca672280c98363e85a6cd3c429

data/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [2.0.0] - 2019-11-19
+### Changed
+- BREAKING: Required configuration of validation engine
+- BREAKING: Dynamic resource keys in config DSL are not supported anymore and
+  have to be defined via the `resource` key
+
+### Added
+- Support for dry-* 1.x
+
+### Removed
+- BREAKING: Dry dependencies were removed and should manually be added
+- BREAKING: Support for config inheritance
+- BREAKING: Support for dry-* 0.x
+
 ## [1.3.0] - 2019-05-21
 ### Added
 - Serializable JSONAPI error objects out of validation failures

data/Gemfile

@@ -9,5 +9,7 @@ group :development, :test do
   gem 'danger'
   gem 'danger-commit_lint'
   gem 'danger-rubocop'
+  gem 'dry-types', '~> 1.0'
+  gem 'dry-validation', '~> 1.0'
   gem 'rspec_junit_formatter'
 end

data/README.md

@@ -26,34 +26,51 @@ Or install it yourself as:
 
 ## Configuration
 
+You have to chose a validation engine and configure it globally:
+```ruby
+RequestHandler.configure do |config|
+  config.validation_engine = RequestHandler::Validation::DryEngine
+end
+```
+
+If you want to use the included dry engine you also have to add the dry gems to
+your Gemfile:
+```ruby
+  gem 'dry-validation', '~> 1.0'
+  gem 'dry-types', '~> 1.0'
+```
+Note that only dry >= 1.0 is supported.
+
 The default logger and separator can be changed globally:
 
 ```ruby
-RequestHandler.configure do
-  logger Logger.new(STDERR)
-  separator '____'
-  validation_engine RequestHandler::Validation::DryEngine
+RequestHandler.configure do |config|
+  config.logger = Logger.new(STDERR)
+  config.separator = '____'
 end
 ```
 
 JSON:API-style error data can be included in validation errors raised by `RequestHandler`.
 
 ```ruby
-RequestHandler.configure do
-  raise_jsonapi_errors = true # default: false
+RequestHandler.configure do |config|
+  config.raise_jsonapi_errors = true # default: false
 end
 ```
 
 
 ### Validation Engine
-Per default this gem uses the `DryEngine` which relies on dry-validation. All
-examples in this Readme assume you are using this default engine. However
-you can also use the builtin `DefinitionEngine`, which uses [Definition](https://github.com/Goltergaul/definition) as validation library:
+You have to chose a validation engine and configure it globally (see
+configuration section above).
+All examples in this Readme assume you are using the `DryEngine` which relies on
+dry-validation. However you can also use the builtin `DefinitionEngine`, which
+uses [Definition](https://github.com/Goltergaul/definition) as validation
+library:
 
 ```ruby
-RequestHandler.configure do
+RequestHandler.configure do |config|
   require 'request_handler/validation/definition_engine'
-  validation_engine RequestHandler::Validation::DefinitionEngine
+  config.validation_engine = RequestHandler::Validation::DefinitionEngine
 end
 ```
 
@@ -85,14 +102,13 @@ defines if the JsonApiDocumentParser or JsonParser is used.
 If nothing is defined, JsonApiDocumentParser will be used by default.
 
 ```ruby
-require "dry-validation"
 require "request_handler"
 class DemoHandler < RequestHandler::Base
   options do
     page do
       default_size 10
       max_size 20
-      comments do
+      resource :comments do
         default_size 20
         max_size 100
       end
@@ -108,11 +124,11 @@ class DemoHandler < RequestHandler::Base
 
     filter do
       schema(
-        Dry::Validation.Params do
-          configure do
-            option :foo
+        Class.new(Dry::Validation::Contract) do
+          option :foo
+          params do
+            required(:name).filled(:string)
           end
-          required(:name).filled(:str?)
         end
       )
       additional_url_filter %i(user_id id)
@@ -122,8 +138,8 @@ class DemoHandler < RequestHandler::Base
 
     query do
       schema(
-        Dry::Validation.Params do
-          optional(:name).filled(:str?)
+        Dry::Schema.Params do
+          optional(:name).filled(:string)
         end
       )
     end
@@ -131,11 +147,11 @@ class DemoHandler < RequestHandler::Base
     body do
       type :jsonapi
       schema(
-        Dry::Validation.JSON do
-          configure do
-            option :foo
+        Class.new(Dry::Validation::Contract) do
+          option :foo
+          json do
+            required(:id).filled(:string)
           end
-          required(:id).filled(:str?)
         end
       )
       options(->(_handler, _request) { { foo: "bar" } })
@@ -208,19 +224,19 @@ file related to the question
 class CreateQuestionHandler < RequestHandler::Base
   options do
     multipart do
-      question do
+      resource :question do
         required true
         type "json"
         schema(
-          Dry::Validation.JSON do
-            required(:id).filled(:str?)
-            required(:type).filled(:str?)
-            required(:content).filled(:str?)
+          Dry::Schema.JSON do
+            required(:id).filled(:string)
+            required(:type).filled(:string)
+            required(:content).filled(:string)
           end
         )
       end
 
-      file do
+      resource :file do
         # no validation necessary
       end
     end
@@ -317,6 +333,128 @@ get "/users/:user_id/posts" do
 end
 ```
 
+## v1 to v2 migration guide
+Multiple breaking changes were introduced with request_handler 2.0. This section
+describes which steps have to be taken in order to migrate from 1.x to 2.0.
+
+### Configure validation engine
+By default the DryEngine was used in 1.0. You now have to explicitly configure
+a validation engine:
+
+```ruby
+RequestHandler.configure do |config|
+  config.validation_engine = RequestHandler::Validation::DryEngine
+end
+```
+
+### Add dry dependency if you use the DryEngine
+Since the DryEngine is not configured by default anymore, the dependency to the
+dry gems could be removed from request_handler. If you use the DryEngine
+simply add the dry-gems to your Gemfile:
+
+```ruby
+gem 'dry-validation', '~> 1.0'
+gem 'dry-types', '~> 1.0'
+```
+Note that only dry >= 1.0 is supported.
+
+### Define custom resources via the `resource` key
+In request_handler 1.x it was possible to define custom resource names like this:
+
+```ruby
+options  do
+  fieldsets do
+    allowed do
+      posts schema
+    end
+  end
+end
+```
+
+This was possible in multiple places (`page`, `multipart`, `fieldsets.allowed`).
+Starting with version 2.0 you will have to define those custom resources via the
+`resource` key:
+
+```ruby
+options do
+  fieldsets do
+    allowed do
+      resource :posts, schema
+    end
+  end
+end
+```
+
+### Use dry-* 1.x instead of dry-* 0.x if you use the DryEngine
+Some of the most common required changes are listed here:
+
+* Use `Dry::Schema.Params` instead of `Dry::Validation.Schema`
+* Use `Dry::Schema.JSON` instead of `Dry::Validation.JSON`
+* If you use some more complex validation rules with options like this:
+
+```
+Dry::Validation.Params do
+  configure do
+    option :query_id
+  end
+  required(:id).value(eql?: query_id)
+end
+
+options(->(_parser, request) { { query_id: request.params['id'] } })
+```
+
+please rewrite it using `Dry::Validation::Contract` like this:
+
+```
+Class.new(Dry::Validation::Contract) do
+  option :query_id
+  params do
+    required(:id).value(:string)
+  end
+  rule(:id) do
+    key.failure('invalid id') unless values[:id] == query_id
+  end
+end)
+options(->(_parser, request) { { query_id: request.params['id'] } })
+```
+
+A useful guide for upgrading to dry 1 types, validations and schemas can be
+found [here](https://www.morozov.is/2019/05/31/upgrading-dry-gems.html).
+
+Also please refer to the official docs of
+[dry-schema](https://dry-rb.org/gems/dry-schema) and
+[dry-validation](https://dry-rb.org/gems/dry-validation).
+
+### Remove config inheritance
+It was possible to (partially) overwrite configs defined in a request-handler
+super-class:
+```
+class Parent < RequestHandler::Base
+  options  do
+    page do
+      comments do
+        default_size 20
+      end
+    end
+  end
+end
+```
+
+```ruby
+class Child < Parent
+  options  do
+    page do
+      comments do
+        default_size 10
+      end
+    end
+  end
+end
+```
+
+Support for this has been fully removed. If you overwrite configs in subclasses
+please remove the inheritance and define the two request-handlers separately.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can

data/lib/request_handler/base.rb

@@ -10,22 +10,22 @@ require 'request_handler/multipart_parser'
 require 'request_handler/fieldsets_parser'
 require 'request_handler/query_parser'
 require 'request_handler/helper'
-require 'confstruct'
+require 'request_handler/builder/options_builder'
+require 'request_handler/concerns/config_helper'
+require 'request_handler/config'
+
 module RequestHandler
   class Base
+    include RequestHandler::Concerns::ConfigHelper
+
     class << self
       def options(&block)
-        @config ||= ::Confstruct::Configuration.new
-        @config.configure(&block)
-      end
-
-      def inherited(subclass)
-        return if @config.nil?
-        subclass.config = @config.deep_copy
+        @config = Config.new(&block)
       end
 
       attr_accessor :config
     end
+
     def initialize(request:)
       raise MissingArgumentError, request: 'is missing' if request.nil?
       @request = request
@@ -38,7 +38,7 @@ module RequestHandler
     def page_params
       @page_params ||= PageParser.new(
         params:      params,
-        page_config: lookup!('page')
+        page_config: config.lookup!('page')
       ).run
     end
 
@@ -82,9 +82,9 @@ module RequestHandler
       defaults = fetch_defaults('filter.defaults', {})
       defaults.merge(FilterParser.new(
         params:                params,
-        schema:                lookup!('filter.schema'),
-        additional_url_filter: lookup('filter.additional_url_filter'),
-        schema_options:        execute_options(lookup('filter.options'))
+        schema:                config.lookup!('filter.schema'),
+        additional_url_filter: config.lookup('filter.additional_url_filter'),
+        schema_options:        execute_options(config.lookup('filter.options'))
       ).run)
     end
 
@@ -100,7 +100,7 @@ module RequestHandler
       defaults = fetch_defaults("#{type}.defaults", [])
       result = parser.new(
         params:               params,
-        allowed_options_type: lookup!("#{type}.allowed")
+        allowed_options_type: config.lookup!("#{type}.allowed")
       ).run
       result.empty? ? defaults : result
     end
@@ -108,35 +108,35 @@ module RequestHandler
     def parse_body_params
       BodyParser.new(
         request:          request,
-        schema:           lookup!('body.schema'),
-        schema_options:   execute_options(lookup('body.options')),
-        type:             lookup('body.type')
+        schema:           config.lookup!('body.schema'),
+        schema_options:   execute_options(config.lookup('body.options')),
+        type:             config.lookup('body.type')
       ).run
     end
 
     def parse_multipart_params
       MultipartsParser.new(
         request:           request,
-        multipart_config: lookup!('multipart')
+        multipart_config: config.lookup!('multipart').to_h
       ).run
     end
 
     def parse_fieldsets_params
       FieldsetsParser.new(params:   params,
-                          allowed:  lookup!('fieldsets.allowed'),
-                          required: lookup('fieldsets.required') || []).run
+                          allowed:  config.lookup!('fieldsets.allowed'),
+                          required: config.lookup('fieldsets.required') || []).run
     end
 
     def parse_query_params
       QueryParser.new(
         params:         params,
-        schema:         lookup!('query.schema'),
-        schema_options: execute_options(lookup('query.options'))
+        schema:         config.lookup!('query.schema'),
+        schema_options: execute_options(config.lookup('query.options'))
       ).run
     end
 
     def fetch_defaults(key, default)
-      value = lookup(key)
+      value = config.lookup(key)
       return default if value.nil?
       return value unless value.respond_to?(:call)
       value.call(request)
@@ -148,26 +148,20 @@ module RequestHandler
       options.call(self, request)
     end
 
-    def lookup!(key)
-      config.lookup!(key).tap do |data|
-        raise NoConfigAvailableError, key.to_sym => 'is not configured' if data.nil?
-      end
-    end
-
-    def lookup(key)
-      config.lookup!(key)
-    end
-
     def params
       raise MissingArgumentError, params: 'is missing' if request.params.nil?
       raise ExternalArgumentError, [] unless request.params.is_a?(Hash)
       @params ||= Helper.deep_transform_keys_in_object(request.params) do |k|
-        k.to_s.gsub('.', ::RequestHandler.separator)
+        k.to_s.gsub('.', separator)
       end
     end
 
     def config
       self.class.instance_variable_get('@config')
     end
+
+    def separator
+      ::RequestHandler.configuration.separator
+    end
   end
 end

data/lib/request_handler/base_parser.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'request_handler/concerns/config_helper'
+
+module RequestHandler
+  class BaseParser
+    include RequestHandler::Concerns::ConfigHelper
+  end
+end

data/lib/request_handler/builder/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module RequestHandler
+  module Builder
+    class Base
+      attr_accessor :result
+
+      def initialize
+        create_klass_struct
+      end
+
+      def create_klass_struct
+        raise NotImplementedError
+      end
+
+      def build
+        result
+      end
+    end
+  end
+end

data/lib/request_handler/builder/body_builder.rb

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

data/lib/request_handler/builder/fieldsets_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+require 'request_handler/builder/fieldsets_resource_builder'
+
+module RequestHandler
+  module Builder
+    class FieldsetsBuilder < Base
+      Fieldsets = Struct.new(:allowed, :required)
+
+      def create_klass_struct
+        @result = Fieldsets.new
+      end
+
+      def allowed(&block)
+        @result.allowed = build_fieldsets_resource(&block)
+      end
+
+      def required(value)
+        @result.required = value
+      end
+
+      def build_fieldsets_resource(&block)
+        Docile.dsl_eval(FieldsetsResourceBuilder.new, &block).build
+      end
+    end
+  end
+end

data/lib/request_handler/builder/fieldsets_resource_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "request_handler/builder/base"
+
+module RequestHandler
+  module Builder
+    class FieldsetsResourceBuilder < Base
+      def create_klass_struct
+        @result = OpenStruct.new
+      end
+
+      def resource(name, value)
+        @result[name.to_sym] = value
+      end
+    end
+  end
+end

data/lib/request_handler/builder/filter_builder.rb

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

data/lib/request_handler/builder/include_options_builder.rb

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

data/lib/request_handler/builder/multipart_builder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+require 'request_handler/builder/multipart_resource_builder'
+
+module RequestHandler
+  module Builder
+    class MultipartBuilder < Base
+      def create_klass_struct
+        @result = OpenStruct.new
+      end
+
+      def resource(name, &block)
+        @result[name.to_sym] = build_multipart_resource(&block)
+      end
+
+      def build_multipart_resource(&block)
+        Docile.dsl_eval(MultipartResourceBuilder.new, &block).build
+      end
+    end
+  end
+end

data/lib/request_handler/builder/multipart_resource_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+
+module RequestHandler
+  module Builder
+    class MultipartResourceBuilder < Base
+      MultipartResource = Struct.new(:required, :schema, :type, :options)
+
+      def create_klass_struct
+        @result = MultipartResource.new
+      end
+
+      def type(value)
+        @result.type = value
+      end
+
+      def required(value)
+        @result.required = value
+      end
+
+      def resource(name, &block)
+        @result[name.to_sym] = build_multipart_resource(&block)
+      end
+
+      def schema(value)
+        @result.schema = value
+      end
+
+      def options(value)
+        @result.options = value
+      end
+    end
+  end
+end