jsonapi_parameters 1.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: daa7f46ec2ca9f23be7199bf5b8ee043a1b40317ed96070f9b0025a624328eeb
-  data.tar.gz: 29b227bd32c0b86cb6b5e29c368bc4728a445c369f22852037b3ff6f8e929b07
+  metadata.gz: 8bcf0cd62169a18d8f485540f7fe27e85d2ed8278121fe19309d149b5c59141a
+  data.tar.gz: eef89bf8b7061bf21add79bd09ce3b164c6b0d91e0d8db2898de99e231ab7d36
 SHA512:
-  metadata.gz: 30da56dbc5654aed7331e5db54f54da59414fdf747a97c75755ba184af9e813a9ef50f7f2251f4af418ca04d11b54d353d1d4ca7c1e12a638e2049fa7bcae972
-  data.tar.gz: a67da822ec846764be2cc6a999a6a70655b7816b5be9b733770a2f4ec32246a39cf587260a2fdfe6fa6836fe0290cc0e08088b873a8649fb2e61ab1fab59d839
+  metadata.gz: fbb1868c672869c4e0b561012dba89ed444271bef9246be22df68b564e397e21d1058860ce5416748c5a662f960bbe5c424db56882e2163bc8ae6516861de00e
+  data.tar.gz: '0940555db68b3b48522dbb33d6f035334ff8b149731b71b597df5e148b0d0d900141dd5213202c76eac4a406b2721c273773a401d90ae94caf44ae90b7a0c34c'

data/README.md

@@ -1,17 +1,12 @@
 # JsonApi::Parameters
-Simple JSON:API compliant parameters translator.
+Simple [JSON:API](https://jsonapi.org/) compliant parameters translator.
 
 [![Gem Version](https://badge.fury.io/rb/jsonapi_parameters.svg)](https://badge.fury.io/rb/jsonapi_parameters)
 [![Maintainability](https://api.codeclimate.com/v1/badges/84fd5b548eea8d7e18af/maintainability)](https://codeclimate.com/github/visualitypl/jsonapi_parameters/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/84fd5b548eea8d7e18af/test_coverage)](https://codeclimate.com/github/visualitypl/jsonapi_parameters/test_coverage)
+[![CircleCI](https://circleci.com/gh/visualitypl/jsonapi_parameters.svg?style=svg)](https://circleci.com/gh/visualitypl/jsonapi_parameters)
 
-#### The problem
-
-JSON:API standard specifies not only responses (that can be handled nicely, using gems like [fast_jsonapi from Netflix](https://github.com/Netflix/fast_jsonapi)), but also the request structure. 
-
-#### The solution
-
-As we couldn't find any gem that would make it easier in Rails to use these structures, we decided to create something that will work for us - a translator that transforms JSON:API compliant request parameter strucure into a Railsy structure.
+[Documentation](https://github.com/visualitypl/jsonapi_parameters/wiki)
 
 ## Usage
 
@@ -75,243 +70,82 @@ Relationship parameters are being read from two optional trees:
 
 If you provide any related resources in the `relationships` table, this gem will also look for corresponding, `included` resources and their attributes. Thanks to that this gem supports nested attributes, and will try to translate these included resources and pass them along.
 
-##### belongs_to
+For more examples take a look at [Relationships](https://github.com/visualitypl/jsonapi_parameters/wiki/Relationships) in the wiki documentation.
 
-Passing a resource that is a single entity in relationships tree will make JsonApi::Parameters assume that it is a `belongs_to` relationship. 
 
-###### Without included entity
-Example:
-
-```
-class Movie < ActiveRecord::Model
-    belongs_to :director
-end
-```
+### Plain Ruby / outside Rails
 
-Request body:
+```ruby
 
-```
-{
-    data: {
-        type: 'movies',
-        attributes: {
-          title: 'The Terminator',
-        },
-        relationships: {
-          director: {
-            data: {
-              id: 682, type: 'directors'
-            }
-          }
-        }
-    }
+params = { # JSON:API compliant parameters here
+	# ...
 }
-```
 
-Will translate to:
+class Translator
+  include JsonApi::Parameters
+end
+translator = Translator.new
 
+translator.jsonapify(params)
 ```
-{
-  movie: {
-    title: 'The Terminator',
-    director_id: 682
-  }
-}
-```
-
-
-###### With included entity:
-Example:
+ 
+## Mime Type
 
-```
-class Movie < ActiveRecord::Model
-    belongs_to :director
-    
-    accepts_nested_attributes_for :director
-end
-```
+As [stated in the JSON:API specification](https://jsonapi.org/#mime-types) correct mime type for JSON:API input should be [`application/vnd.api+json`](http://www.iana.org/assignments/media-types/application/vnd.api+json). 
 
-Request body:
-```
-{
-    data: {
-        type: 'movies',
-        attributes: {
-          title: 'The Terminator',
-        },
-        relationships: {
-          director: {
-            data: {
-              id: 682, type: 'directors'
-            }
-          }
-        }
-    },
-    included: [
-        {
-            type: 'directors',
-            id: 682,
-            attributes: { 
-                name: 'Some guy'
-            }
-        }
-    ]
-}
-```
+This gem's intention is to make input consumption as easy as possible. Hence, it [registers this mime type for you](lib/jsonapi_parameters/core_ext/action_dispatch/http/mime_type.rb).
 
-Will translate to:   
-```
-{
-  movie: {
-    title: 'The Terminator',
-    director_attributes: { id: 682, name: 'Some guy' }
-  }
-}
-```
+## Stack limit
 
-##### has_many
+In theory, any payload may consist of infinite amount of relationships (and so each relationship may have its own, included, infinite amount of nested relationships).
+Because of that, it is a potential vector of attack. 
 
-Passing a resource that is a an array of entities in relationships tree will make JsonApi::Parameters assume that it is a `has_many` relationship. 
+For this reason we have introduced a default limit of stack levels that JsonApi::Parameters will go down through while parsing the payloads. 
 
-###### Without included entity
-Example:
+This default limit is 3, and can be overwritten by specifying the custom limit.
 
-```
-class Movie < ActiveRecord::Model
-    has_many :genres
+#### Ruby
+``` 
+class Translator
+    include JsonApi::Parameters
 end
-```
 
-Request body:
+translator = Translator.new
 
-```
-{
-    data: {
-        type: 'movies',
-        attributes: {
-          title: 'The Terminator',
-        },
-        relationships: {
-          genres: {
-            data: [{
-              id: 1, type: 'genres'
-            },
-            {
-              id: 2, type: 'genres'
-            }]
-          }
-        }
-    }
-}
-```
+translator.jsonapify(custom_stack_limit: 4)
 
-Will translate to:
+# OR
+ 
+translator.stack_limit = 4
+translator.jsonapify.(...)
+``` 
 
+#### Rails
 ```
-{
-  movie: {
-    title: 'The Terminator',
-    genre_ids: [1, 2]
-  }
-}
-```
+# config/initializers/jsonapi_parameters.rb
 
-
-###### With included entity:
-Example:
-
-```
-class Movie < ActiveRecord::Model
-    has_many :genres
-    
-    accepts_nested_attributes_for :genres
+def create_params
+    params.from_jsonapi(custom_stack_limit: 4).require(:user).permit(
+        entities_attributes: { subentities_attributes: { ... } }
+    )
 end
-```
 
-Request body:
-```
-{
-  data: {
-    type: 'movies',
-    attributes: {
-      title: 'The Terminator',
-    },
-    relationships: {
-      genres: {
-        data: [{
-                 id: 1, type: 'genres'
-               }]
-      }
-    }
-  },
-  included: [
-    {
-      type: 'genres',
-      id: 1,
-      attributes: {
-        name: 'Genre one'
-      }
-    }
-  ]
-}
-```
-
-Will translate to:   
-```
-{
-  movie: {
-    title: 'The Terminator',
-    genres_attributes: [{ id: 1, name: 'Genre one' }]
-  }
-}
-```
-
-
-#### Casing
-
-If the input is in a different convention than `:snake`, you should specify that.
- 
- You can do it in two ways: 
- * in an initializer, simply create `initializers/jsonapi_parameters.rb` with contents similar to: 
- ```ruby
- # config/initializers/jsonapi_parameters.rb
-  
-  JsonApi::Parameters.ensure_underscore_translation = true
- 
- ```
+# OR
  
- * while calling `.from_jsonapi`, for instance: `.from_jsonapi(:camel)`. **The value does not really matter, as anything different than `:snake` will result in deep keys transformation provided by [ActiveSupport](https://apidock.com/rails/v4.1.8/Hash/deep_transform_keys).**
-
-### Plain Ruby / outside Rails
-
-```ruby
-
-params = { # JSON:API compliant parameters here
-	# ...
-}
+def create_params
+    params.stack_level = 4
 
-class Translator
-  include JsonApi::Parameters
+    params.from_jsonapi.require(:user).permit(entities_attributes: { subentities_attributes: { ... } })
+ensure
+    params.reset_stack_limit!
 end
-translator = Translator.new
-
-translator.jsonapify(params)
 ```
 
-#### Casing
-
-If the input is in a different convention than `:snake`, you should specify that.
- 
- You can do it in two ways:
- 
- * by a global setting: `JsonApi::Parameters.ensure_underscore_translation = true` 
- * while calling `.jsonapify`, for instance: `.jsonapify(params, naming_convention: :camel)`. **The value does not really matter, as anything different than `:snake` will result in deep keys transformation provided by [ActiveSupport](https://apidock.com/rails/v4.1.8/Hash/deep_transform_keys).**
- 
-## Mime Type
+## Customization
 
-As [stated in the JSON:API specification](https://jsonapi.org/#mime-types) correct mime type for JSON:API input should be [`application/vnd.api+json`](http://www.iana.org/assignments/media-types/application/vnd.api+json). 
+If you need custom relationship handling (for instance, if you have a relationship named `scissors` that is plural, but it actually is a single entity), you can use Handlers to define appropriate behaviour.
 
-This gems intention is to make input consumption as easy as possible. Hence, it [registers this mime type for you](lib/jsonapi_parameters/core_ext/action_dispatch/http/mime_type.rb). 
+Read more at [Relationship Handlers](https://github.com/visualitypl/jsonapi_parameters/wiki/Relationship-handlers).
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/jsonapi_parameters.rb

@@ -1,6 +1,6 @@
 require 'jsonapi_parameters/parameters'
+require 'jsonapi_parameters/handlers'
 require 'jsonapi_parameters/translator'
 require 'jsonapi_parameters/core_ext'
+require 'jsonapi_parameters/stack_limit'
 require 'jsonapi_parameters/version'
-
-require 'active_support/inflector'

data/lib/jsonapi_parameters/core_ext/action_controller/parameters.rb

@@ -9,7 +9,7 @@ class ActionController::Parameters
     from_jsonapi(*args)
   end
 
-  def from_jsonapi(naming_convention = :snake)
-    @from_jsonapi ||= self.class.new jsonapify(self, naming_convention: naming_convention)
+  def from_jsonapi(naming_convention = :snake, custom_stack_limit: stack_limit)
+    @from_jsonapi ||= self.class.new jsonapify(self, naming_convention: naming_convention, custom_stack_limit: custom_stack_limit)
   end
 end

data/lib/jsonapi_parameters/default_handlers/base_handler.rb

@@ -0,0 +1,30 @@
+module JsonApi
+  module Parameters
+    module Handlers
+      module DefaultHandlers
+        class BaseHandler
+          attr_reader :relationship_key, :relationship_value, :included
+
+          def self.call(key, val, included)
+            new(key, val, included).handle
+          end
+
+          def initialize(relationship_key, relationship_value, included)
+            @relationship_key = relationship_key
+            @relationship_value = relationship_value
+            @included = included
+          end
+
+          def find_included_object(related_id:, related_type:)
+            included.find do |included_object_enum|
+              included_object_enum[:id] &&
+                included_object_enum[:id] == related_id &&
+                included_object_enum[:type] &&
+                included_object_enum[:type] == related_type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_parameters/default_handlers/nil_relation_handler.rb

@@ -0,0 +1,29 @@
+require 'active_support/inflector'
+
+require_relative './base_handler'
+
+module JsonApi
+  module Parameters
+    module Handlers
+      module DefaultHandlers
+        class NilRelationHandler < BaseHandler
+          include ActiveSupport::Inflector
+
+          def handle
+            # Graceful fail if nil on to-many association
+            # in case the relationship key is, for instance, `billable_hours`,
+            # we have to assume that it is a to-many relationship.
+            if pluralize(relationship_key).to_sym == relationship_key
+              raise NotImplementedError.new(
+                'plural resource cannot be nullified - please create a custom handler for this relation'
+              )
+            end
+
+            # Handle with empty hash.
+            ToOneRelationHandler.new(relationship_key, {}, {}).handle
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_parameters/default_handlers/to_many_relation_handler.rb

@@ -0,0 +1,55 @@
+require 'active_support/inflector'
+
+module JsonApi
+  module Parameters
+    module Handlers
+      module DefaultHandlers
+        class ToManyRelationHandler < BaseHandler
+          include ActiveSupport::Inflector
+
+          attr_reader :with_inclusion, :vals, :key
+
+          def handle
+            @with_inclusion = !relationship_value.empty?
+
+            prepare_relationship_vals
+
+            generate_key
+
+            [key, vals]
+          end
+
+          private
+
+          def prepare_relationship_vals
+            @vals = relationship_value.map do |relationship|
+              related_id = relationship.dig(:id)
+              related_type = relationship.dig(:type)
+
+              included_object = find_included_object(
+                related_id: related_id, related_type: related_type
+              ) || {}
+
+              # If at least one related object has not been found in `included` tree,
+              # we should not attempt to "#{relationship_key}_attributes" but
+              # "#{relationship_key}_ids" instead.
+              @with_inclusion &= !included_object.empty?
+
+              if with_inclusion
+                { **(included_object[:attributes] || {}), id: related_id }.tap do |body|
+                  body[:relationships] = included_object[:relationships] if included_object.key?(:relationships) # Pass nested relationships
+                end
+              else
+                relationship.dig(:id)
+              end
+            end
+          end
+
+          def generate_key
+            @key = (with_inclusion ? "#{pluralize(relationship_key)}_attributes" : "#{singularize(relationship_key)}_ids").to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_parameters/default_handlers/to_one_relation_handler.rb

@@ -0,0 +1,30 @@
+require 'active_support/inflector'
+
+module JsonApi
+  module Parameters
+    module Handlers
+      module DefaultHandlers
+        class ToOneRelationHandler < BaseHandler
+          include ActiveSupport::Inflector
+
+          def handle
+            related_id = relationship_value.dig(:id)
+            related_type = relationship_value.dig(:type)
+
+            included_object = find_included_object(
+              related_id: related_id, related_type: related_type
+            ) || {}
+
+            return ["#{singularize(relationship_key)}_id".to_sym, related_id] if included_object.empty?
+
+            included_object = { **(included_object[:attributes] || {}), id: related_id }.tap do |body|
+              body[:relationships] = included_object[:relationships] if included_object.key?(:relationships) # Pass nested relationships
+            end
+
+            ["#{singularize(relationship_key)}_attributes".to_sym, included_object]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_parameters/handlers.rb

@@ -0,0 +1,46 @@
+require_relative 'default_handlers/nil_relation_handler'
+require_relative 'default_handlers/to_many_relation_handler'
+require_relative 'default_handlers/to_one_relation_handler'
+
+module JsonApi
+  module Parameters
+    module Handlers
+      include DefaultHandlers
+
+      DEFAULT_HANDLER_SET = {
+        to_many: ToManyRelationHandler,
+        to_one: ToOneRelationHandler,
+        nil: NilRelationHandler
+      }.freeze
+
+      module_function
+
+      def add_handler(handler_name, klass)
+        handlers[handler_name.to_sym] = klass
+      end
+
+      def set_resource_handler(resource_key, handler_key)
+        unless handlers.key?(handler_key)
+          raise NotImplementedError.new(
+            'handler_key does not match any registered handlers'
+          )
+        end
+
+        resource_handlers[resource_key.to_sym] = handler_key.to_sym
+      end
+
+      def reset_handlers
+        @handlers = DEFAULT_HANDLER_SET.dup
+        @resource_handlers = {}
+      end
+
+      def resource_handlers
+        @resource_handlers ||= {}
+      end
+
+      def handlers
+        @handlers ||= DEFAULT_HANDLER_SET.dup
+      end
+    end
+  end
+end

data/lib/jsonapi_parameters/stack_limit.rb

@@ -0,0 +1,45 @@
+module JsonApi
+  module Parameters
+    LIMIT = 3
+
+    class StackLevelTooDeepError < StandardError
+    end
+
+    def stack_limit=(val)
+      @stack_limit = val
+    end
+
+    def stack_limit
+      @stack_limit || LIMIT
+    end
+
+    def reset_stack_limit
+      @stack_limit = LIMIT
+    end
+
+    private
+
+    def initialize_stack(custom_stack_limit)
+      @current_stack_level = 0
+      @stack_limit = custom_stack_limit
+    end
+
+    def increment_stack_level!
+      @current_stack_level += 1
+
+      raise StackLevelTooDeepError.new(stack_exception_message) if @current_stack_level > stack_limit
+    end
+
+    def decrement_stack_level
+      @current_stack_level -= 1
+    end
+
+    def reset_stack_level
+      @current_stack_level = 0
+    end
+
+    def stack_exception_message
+      "Stack level of nested payload is too deep: #{@current_stack_level}/#{stack_limit}. Please see the documentation on how to overwrite the limit."
+    end
+  end
+end

data/lib/jsonapi_parameters/translator.rb

@@ -3,7 +3,9 @@ require 'active_support/inflector'
 module JsonApi::Parameters
   include ActiveSupport::Inflector
 
-  def jsonapify(params, naming_convention: :snake)
+  def jsonapify(params, naming_convention: :snake, custom_stack_limit: stack_limit)
+    initialize_stack(custom_stack_limit)
+
     jsonapi_translate(params, naming_convention: naming_convention)
   end
 
@@ -15,7 +17,9 @@ module JsonApi::Parameters
     return params if params.nil? || params.empty?
 
     @jsonapi_unsafe_hash = if naming_convention != :snake || JsonApi::Parameters.ensure_underscore_translation
-                             params.deep_transform_keys { |key| key.to_s.underscore.to_sym }
+                             params = params.deep_transform_keys { |key| key.to_s.underscore.to_sym }
+                             params[:data][:type] = params[:data][:type].underscore if params.dig(:data, :type)
+                             params
                            else
                              params.deep_symbolize_keys
                            end
@@ -36,20 +40,11 @@ module JsonApi::Parameters
   def jsonapi_main_body
     jsonapi_unsafe_params.tap do |param|
       jsonapi_relationships.each do |relationship_key, relationship_value|
-        relationship_value = relationship_value[:data]
-        key, val = case relationship_value
-                   when Array
-                     handle_to_many_relation(relationship_key, relationship_value)
-                   when Hash
-                     handle_to_one_relation(relationship_key, relationship_value)
-                   when nil
-                     handle_nil_relation(relationship_key)
-                   else
-                     raise jsonapi_not_implemented_err
-                   end
-        param[key] = val
+        param = handle_relationships(param, relationship_key, relationship_value)
       end
     end
+  ensure
+    reset_stack_level
   end
 
   def jsonapi_unsafe_params
@@ -60,85 +55,63 @@ module JsonApi::Parameters
     end
   end
 
-  def jsonapi_included
-    @jsonapi_included ||= @jsonapi_unsafe_hash[:included] || []
-  end
-
   def jsonapi_relationships
     @jsonapi_relationships ||= @jsonapi_unsafe_hash.dig(:data, :relationships) || []
   end
 
-  def handle_to_many_relation(relationship_key, relationship_value)
-    with_inclusion = !relationship_value.empty?
-
-    vals = relationship_value.map do |relationship|
-      related_id = relationship.dig(:id)
-      related_type = relationship.dig(:type)
-
-      included_object = find_included_object(
-        related_id: related_id, related_type: related_type
-      ) || {}
-
-      # If at least one related object has not been found in `included` tree,
-      # we should not attempt to "#{relationship_key}_attributes" but
-      # "#{relationship_key}_ids" instead.
-      with_inclusion &= !included_object.empty?
-
-      if with_inclusion
-        included_object.delete(:type)
-        included_object[:attributes].merge(id: related_id)
-      else
-        relationship.dig(:id)
-      end
-    end
-
-    # We may have smells in our value array as `with_inclusion` may have been changed at some point
-    # but not in the beginning.
-    # Because of that we should clear it and make sure the results are unified (e.g. array of ids)
-    unless with_inclusion
-      vals.map do |val|
-        val.dig(:attributes, :id) if val.is_a?(Hash)
-      end
-    end
-
-    key = with_inclusion ? "#{pluralize(relationship_key)}_attributes".to_sym : "#{singularize(relationship_key)}_ids".to_sym
-
-    [key, vals]
-  end
-
-  def handle_to_one_relation(relationship_key, relationship_value)
-    related_id = relationship_value.dig(:id)
-    related_type = relationship_value.dig(:type)
-
-    included_object = find_included_object(
-      related_id: related_id, related_type: related_type
-    ) || {}
-
-    return ["#{singularize(relationship_key)}_id".to_sym, related_id] if included_object.empty?
-
-    included_object.delete(:type)
-    included_object = included_object[:attributes].merge(id: related_id)
-    ["#{singularize(relationship_key)}_attributes".to_sym, included_object]
+  def jsonapi_included
+    @jsonapi_included ||= @jsonapi_unsafe_hash[:included] || []
   end
 
-  def handle_nil_relation(relationship_key)
-    # Graceful fail if nil on to-many association.
-    raise jsonapi_not_implemented_err if pluralize(relationship_key).to_sym == relationship_key
-
-    # Handle with empty hash.
-    handle_to_one_relation(relationship_key, {})
+  def handle_relationships(param, relationship_key, relationship_value)
+    increment_stack_level!
+
+    relationship_value = relationship_value[:data]
+    handler_args = [relationship_key, relationship_value, jsonapi_included]
+    handler = if Handlers.resource_handlers.key?(relationship_key)
+                Handlers.handlers[Handlers.resource_handlers[relationship_key]]
+              else
+                case relationship_value
+                when Array
+                  Handlers.handlers[:to_many]
+                when Hash
+                  Handlers.handlers[:to_one]
+                when nil
+                  Handlers.handlers[:nil]
+                else
+                  raise NotImplementedError.new('relationship resource linkage has to be a type of Array, Hash or nil')
+                end
+              end
+
+    key, val = handler.call(*handler_args)
+
+    param[key] = handle_nested_relationships(val)
+
+    param
+  ensure
+    decrement_stack_level
   end
 
-  def find_included_object(related_id:, related_type:)
-    jsonapi_included.find do |included_object_enum|
-      included_object_enum[:id] &&
-        included_object_enum[:id] == related_id &&
-        included_object_enum[:type] &&
-        included_object_enum[:type] == related_type
+  def handle_nested_relationships(val)
+    # We can only consider Hash relationships (which imply to-one relationship) and Array relationships (which imply to-many).
+    # Each type has a different handling method, though in both cases we end up passing the nested relationship recursively to handle_relationship
+    # (and yes, this may go on indefinitely, basically we're going by the relationship levels, deeper and deeper)
+    case val
+    when Array
+      relationships_with_nested_relationships = val.select { |rel| rel.is_a?(Hash) && rel.dig(:relationships) }
+      relationships_with_nested_relationships.each do |relationship_with_nested_relationship|
+        relationship_with_nested_relationship.delete(:relationships).each do |rel_key, rel_val|
+          relationship_with_nested_relationship = handle_relationships(relationship_with_nested_relationship, rel_key, rel_val)
+        end
+      end
+    when Hash
+      if val.key?(:relationships)
+        val.delete(:relationships).each do |rel_key, rel_val|
+          val = handle_relationships(val, rel_key, rel_val)
+        end
+      end
     end
-  end
 
-  def jsonapi_not_implemented_err
-    NotImplementedError.new('relationship member must either be an Array or a Hash')
+    val
   end
 end

data/lib/jsonapi_parameters/version.rb

@@ -1,5 +1,5 @@
 module JsonApi
   module Parameters
-    VERSION = '1.0.0'.freeze
+    VERSION = '2.2.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi_parameters
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Visuality
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-28 00:00:00.000000000 Z
+date: 2020-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -321,7 +321,13 @@ files:
 - lib/jsonapi_parameters/core_ext.rb
 - lib/jsonapi_parameters/core_ext/action_controller/parameters.rb
 - lib/jsonapi_parameters/core_ext/action_dispatch/http/mime_type.rb
+- lib/jsonapi_parameters/default_handlers/base_handler.rb
+- lib/jsonapi_parameters/default_handlers/nil_relation_handler.rb
+- lib/jsonapi_parameters/default_handlers/to_many_relation_handler.rb
+- lib/jsonapi_parameters/default_handlers/to_one_relation_handler.rb
+- lib/jsonapi_parameters/handlers.rb
 - lib/jsonapi_parameters/parameters.rb
+- lib/jsonapi_parameters/stack_limit.rb
 - lib/jsonapi_parameters/translator.rb
 - lib/jsonapi_parameters/version.rb
 homepage: https://github.com/visualitypl/jsonapi_parameters
@@ -343,7 +349,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Translator for JSON:API compliant parameters