jsonapi-resources 0.3.3 → 0.4.0

data/lib/jsonapi/paginator.rb

@@ -3,7 +3,7 @@ module JSONAPI
     def initialize(params)
     end
 
-    def apply(relation)
+    def apply(relation, order_options)
       # relation
     end
 
@@ -19,9 +19,10 @@ end
 class OffsetPaginator < JSONAPI::Paginator
   def initialize(params)
     parse_pagination_params(params)
+    verify_pagination_params
   end
 
-  def apply(relation)
+  def apply(relation, order_options)
     relation.offset(@offset).limit(@limit)
   end
 
@@ -35,27 +36,34 @@ class OffsetPaginator < JSONAPI::Paginator
 
       @offset = validparams[:offset] ? validparams[:offset].to_i : 0
       @limit = validparams[:limit] ? validparams[:limit].to_i : JSONAPI.configuration.default_page_size
-
-      if @limit < 1
-        raise JSONAPI::Exceptions::InvalidPageValue.new(:limit, validparams[:limit])
-      elsif @limit > JSONAPI.configuration.maximum_page_size
-        raise JSONAPI::Exceptions::InvalidPageValue.new(:limit, validparams[:limit],
-                                                        "Limit exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
-      end
     else
       raise JSONAPI::Exceptions::InvalidPageObject.new
     end
   rescue ActionController::UnpermittedParameters => e
     raise JSONAPI::Exceptions::PageParametersNotAllowed.new(e.params)
   end
+
+  def verify_pagination_params
+    if @limit < 1
+      raise JSONAPI::Exceptions::InvalidPageValue.new(:limit, @limit)
+    elsif @limit > JSONAPI.configuration.maximum_page_size
+      raise JSONAPI::Exceptions::InvalidPageValue.new(:limit, @limit,
+        "Limit exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
+    end
+
+    if @offset < 0
+      raise JSONAPI::Exceptions::InvalidPageValue.new(:offset, @offset)
+    end
+  end
 end
 
 class PagedPaginator < JSONAPI::Paginator
   def initialize(params)
     parse_pagination_params(params)
+    verify_pagination_params
   end
 
-  def apply(relation)
+  def apply(relation, order_options)
     offset = (@number - 1) * @size
     relation.offset(offset).limit(@size)
   end
@@ -70,13 +78,6 @@ class PagedPaginator < JSONAPI::Paginator
 
       @size = validparams[:size] ? validparams[:size].to_i : JSONAPI.configuration.default_page_size
       @number = validparams[:number] ? validparams[:number].to_i : 1
-
-      if @size < 1
-        raise JSONAPI::Exceptions::InvalidPageValue.new(:size, validparams[:size])
-      elsif @size > JSONAPI.configuration.maximum_page_size
-        raise JSONAPI::Exceptions::InvalidPageValue.new(:size, validparams[:size],
-                                                        "size exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
-      end
     else
       @size = JSONAPI.configuration.default_page_size
       @number = params.to_i
@@ -84,4 +85,17 @@ class PagedPaginator < JSONAPI::Paginator
   rescue ActionController::UnpermittedParameters => e
     raise JSONAPI::Exceptions::PageParametersNotAllowed.new(e.params)
   end
+
+  def verify_pagination_params
+    if @size < 1
+      raise JSONAPI::Exceptions::InvalidPageValue.new(:size, @size)
+    elsif @size > JSONAPI.configuration.maximum_page_size
+      raise JSONAPI::Exceptions::InvalidPageValue.new(:size, @size,
+        "size exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
+    end
+
+    if @number < 1
+      raise JSONAPI::Exceptions::InvalidPageValue.new(:number, @number)
+    end
+  end
 end

data/lib/jsonapi/request.rb

@@ -4,71 +4,121 @@ require 'jsonapi/paginator'
 module JSONAPI
   class Request
     attr_accessor :fields, :include, :filters, :sort_criteria, :errors, :operations,
-                  :resource_klass, :context, :paginator, :source_klass, :source_id
+                  :resource_klass, :context, :paginator, :source_klass, :source_id,
+                  :include_directives
 
     def initialize(params = nil, options = {})
-      @context = options.fetch(:context, nil)
+      @context = options[:context]
       @key_formatter = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
       @errors = []
       @operations = []
       @fields = {}
-      @include = []
       @filters = {}
-      @sort_criteria = []
+      @sort_criteria = [{field: 'id', direction: :asc}]
       @source_klass = nil
       @source_id = nil
+      @include_directives = nil
+      @paginator = nil
+      @id = nil
 
-      setup(params) if params
+      setup_action(params)
     end
 
-    def setup(params)
+    def setup_action(params)
+      return if params.nil?
+
       @resource_klass ||= Resource.resource_for(params[:controller]) if params[:controller]
 
       unless params.nil?
-        case params[:action]
-          when 'index'
-            parse_fields(params[:fields])
-            parse_include(params[:include])
-            parse_filters(params[:filter])
-            parse_sort_criteria(params[:sort])
-            parse_pagination(params[:page])
-          when 'get_related_resource', 'get_related_resources'
-            @source_klass = Resource.resource_for(params.require(:source))
-            @source_id = @source_klass.verify_key(params.require(@source_klass._as_parent_key), @context)
-            parse_fields(params[:fields])
-            parse_include(params[:include])
-            parse_filters(params[:filter])
-            parse_sort_criteria(params[:sort])
-            parse_pagination(params[:page])
-          when 'show'
-            parse_fields(params[:fields])
-            parse_include(params[:include])
-          when 'create'
-            parse_fields(params[:fields])
-            parse_include(params[:include])
-            parse_add_operation(params.require(:data))
-          when 'create_association'
-            parse_add_association_operation(params.require(:data),
-                                            params.require(:association),
-                                            params.require(@resource_klass._as_parent_key))
-          when 'update_association'
-            parse_update_association_operation(params.fetch(:data),
-                                               params.require(:association),
-                                               params.require(@resource_klass._as_parent_key))
-          when 'update'
-            parse_fields(params[:fields])
-            parse_include(params[:include])
-            parse_replace_operation(params.require(:data), params.require(@resource_klass._primary_key))
-          when 'destroy'
-            parse_remove_operation(params)
-          when 'destroy_association'
-            parse_remove_association_operation(params)
+        setup_action_method_name = "setup_#{params[:action]}_action"
+        if respond_to?(setup_action_method_name)
+          send(setup_action_method_name, params)
         end
       end
     rescue ActionController::ParameterMissing => e
       @errors.concat(JSONAPI::Exceptions::ParameterMissing.new(e.param).errors)
     end
 
+    def setup_index_action(params)
+      parse_fields(params[:fields])
+      parse_include_directives(params[:include])
+      set_default_filters
+      parse_filters(params[:filter])
+      parse_sort_criteria(params[:sort])
+      parse_pagination(params[:page])
+      add_find_operation
+    end
+
+    def setup_get_related_resource_action(params)
+      initialize_source(params)
+      parse_fields(params[:fields])
+      parse_include_directives(params[:include])
+      set_default_filters
+      parse_filters(params[:filter])
+      parse_sort_criteria(params[:sort])
+      parse_pagination(params[:page])
+      add_show_related_resource_operation(params[:association])
+    end
+
+    def setup_get_related_resources_action(params)
+      initialize_source(params)
+      parse_fields(params[:fields])
+      parse_include_directives(params[:include])
+      set_default_filters
+      parse_filters(params[:filter])
+      parse_sort_criteria(params[:sort])
+      parse_pagination(params[:page])
+      add_show_related_resources_operation(params[:association])
+    end
+
+    def setup_show_action(params)
+      parse_fields(params[:fields])
+      parse_include_directives(params[:include])
+      @id = params[:id]
+      add_show_operation
+    end
+
+    def setup_show_association_action(params)
+      add_show_association_operation(params[:association], params.require(@resource_klass._as_parent_key))
+    end
+
+    def setup_create_action(params)
+      parse_fields(params[:fields])
+      parse_include_directives(params[:include])
+      parse_add_operation(params.require(:data))
+    end
+
+    def setup_create_association_action(params)
+      parse_add_association_operation(params.require(:data),
+                                      params.require(:association),
+                                      params.require(@resource_klass._as_parent_key))
+    end
+
+    def setup_update_association_action(params)
+      parse_update_association_operation(params.fetch(:data),
+                                         params.require(:association),
+                                         params.require(@resource_klass._as_parent_key))
+    end
+
+    def setup_update_action(params)
+      parse_fields(params[:fields])
+      parse_include_directives(params[:include])
+      parse_replace_operation(params.require(:data), params.require(:id))
+    end
+
+    def setup_destroy_action(params)
+      parse_remove_operation(params)
+    end
+
+    def setup_destroy_association_action  (params)
+      parse_remove_association_operation(params)
+    end
+
+    def initialize_source(params)
+      @source_klass = Resource.resource_for(params.require(:source))
+      @source_id = @source_klass.verify_key(params.require(@source_klass._as_parent_key), @context)
+    end
+
     def parse_pagination(page)
       paginator_name = @resource_klass._paginator
       @paginator = JSONAPI::Paginator.paginator_for(paginator_name).new(page) unless paginator_name == :none
@@ -142,22 +192,29 @@ module JSONAPI
       end
     end
 
-    def parse_include(include)
+    def parse_include_directives(include)
       return if include.nil?
 
       included_resources = CSV.parse_line(include)
       return if included_resources.nil?
 
-      @include = []
+      include = []
       included_resources.each do |included_resource|
         check_include(@resource_klass, included_resource.partition('.'))
-        @include.push(unformat_key(included_resource).to_s)
+        include.push(unformat_key(included_resource).to_s)
       end
+
+      @include_directives = JSONAPI::IncludeDirectives.new(include)
     end
 
     def parse_filters(filters)
       return unless filters
-      @filters = {}
+
+      unless filters.class.method_defined?(:each)
+        @errors.concat(JSONAPI::Exceptions::InvalidFiltersSyntax.new(filters).errors)
+        return
+      end
+
       filters.each do |key, value|
         filter = unformat_key(key)
         if @resource_klass._allowed_filter?(filter)
@@ -168,18 +225,23 @@ module JSONAPI
       end
     end
 
+    def set_default_filters
+      @resource_klass._allowed_filters.each do |filter, opts|
+        next if opts[:default].nil? || !@filters[filter].nil?
+        @filters[filter] = opts[:default]
+      end
+    end
+
     def parse_sort_criteria(sort_criteria)
       return unless sort_criteria
 
       @sort_criteria = CSV.parse_line(URI.unescape(sort_criteria)).collect do |sort|
-        sort_criteria = {field: unformat_key(sort[1..-1]).to_s}
-        if sort.start_with?('+', ' ')
-          sort_criteria[:direction] = :asc
-        elsif sort.start_with?('-')
+        if sort.start_with?('-')
+          sort_criteria = {field: unformat_key(sort[1..-1]).to_s}
           sort_criteria[:direction] = :desc
         else
-          @errors.concat(JSONAPI::Exceptions::InvalidSortFormat
-                           .new(format_key(resource_klass._type), sort).errors)
+          sort_criteria = {field: unformat_key(sort).to_s}
+          sort_criteria[:direction] = :asc
         end
 
         check_sort_criteria(@resource_klass, sort_criteria)
@@ -197,27 +259,96 @@ module JSONAPI
       end
     end
 
+    def add_find_operation
+      @operations.push JSONAPI::FindOperation.new(
+                         @resource_klass,
+                         {
+                           filters: @filters,
+                           include_directives: @include_directives,
+                           sort_criteria: @sort_criteria,
+                           paginator: @paginator
+                         }
+                       )
+    end
+
+    def add_show_operation
+      @operations.push JSONAPI::ShowOperation.new(
+                         @resource_klass,
+                         {
+                           id: @id,
+                           include_directives: @include_directives
+                         }
+                       )
+    end
+
+    def add_show_association_operation(association_type, parent_key)
+      @operations.push JSONAPI::ShowAssociationOperation.new(
+                         @resource_klass,
+                         {
+                           association_type: association_type,
+                           parent_key: @resource_klass.verify_key(parent_key)
+                         }
+                       )
+    end
+
+    def add_show_related_resource_operation(association_type)
+      @operations.push JSONAPI::ShowRelatedResourceOperation.new(
+                         @resource_klass,
+                         {
+                           association_type: association_type,
+                           source_klass: @source_klass,
+                           source_id: @source_id
+                         }
+                       )
+    end
+
+    def add_show_related_resources_operation(association_type)
+      @operations.push JSONAPI::ShowRelatedResourcesOperation.new(
+                         @resource_klass,
+                         {
+                           association_type: association_type,
+                           source_klass: @source_klass,
+                           source_id: @source_id,
+                           filters: @source_klass.verify_filters(@filters, @context),
+                           sort_criteria: @sort_criteria,
+                           paginator: @paginator
+                         }
+                       )
+    end
+
+    # TODO: Please remove after `createable_fields` is removed
+    # :nocov:
+    def creatable_fields
+      if @resource_klass.respond_to?(:createable_fields)
+        creatable_fields = @resource_klass.createable_fields(@context)
+      else
+        creatable_fields = @resource_klass.creatable_fields(@context)
+      end
+    end
+    # :nocov:
+
     def parse_add_operation(data)
-      Array.wrap(data).each do |p|
-        values = parse_params(verify_and_remove_type(p), @resource_klass.createable_fields(@context))
-        @operations.push JSONAPI::CreateResourceOperation.new(@resource_klass, values)
+      Array.wrap(data).each do |params|
+        verify_type(params[:type])
+
+        data = parse_params(params, creatable_fields)
+        @operations.push JSONAPI::CreateResourceOperation.new(
+                           @resource_klass,
+                           {
+                             data: data
+                           }
+                         )
       end
     rescue JSONAPI::Exceptions::Error => e
       @errors.concat(e.errors)
     end
 
-    def verify_and_remove_type(params)
-      #remove type and verify it matches the resource
-      if unformat_key(params[:type]) == @resource_klass._type
-        params.delete(:type)
-      else
-        if params[:type].nil?
-          raise JSONAPI::Exceptions::ParameterMissing.new(:type)
-        else
-          raise JSONAPI::Exceptions::InvalidResource.new(params[:type])
-        end
+    def verify_type(type)
+      if type.nil?
+        raise JSONAPI::Exceptions::ParameterMissing.new(:type)
+      elsif unformat_key(type).to_sym != @resource_klass._type
+        raise JSONAPI::Exceptions::InvalidResource.new(type)
       end
-      params
     end
 
     def parse_has_one_links_object(raw)
@@ -264,65 +395,70 @@ module JSONAPI
       checked_has_many_associations = {}
 
       params.each do |key, value|
-        if key == 'links' || key == :links
-          value.each do |link_key, link_value|
-            param = unformat_key(link_key)
-
-            association = @resource_klass._association(param)
-
-            if association.is_a?(JSONAPI::Association::HasOne)
-              if link_value.nil?
-                linkage = nil
-              else
-                linkage = link_value[:linkage]
-              end
+        case key.to_s
+          when 'relationships'
+            value.each do |link_key, link_value|
+              param = unformat_key(link_key)
+
+              association = @resource_klass._association(param)
+
+              if association.is_a?(JSONAPI::Association::HasOne)
+                if link_value.nil?
+                  linkage = nil
+                else
+                  linkage = link_value[:data]
+                end
 
-              links_object = parse_has_one_links_object(linkage)
-              # Since we do not yet support polymorphic associations we will raise an error if the type does not match the
-              # association's type.
-              # ToDo: Support Polymorphic associations
-              if links_object[:type] && (links_object[:type].to_s != association.type.to_s)
-                raise JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
-              end
+                links_object = parse_has_one_links_object(linkage)
+                # Since we do not yet support polymorphic associations we will raise an error if the type does not match the
+                # association's type.
+                # ToDo: Support Polymorphic associations
+                if links_object[:type] && (links_object[:type].to_s != association.type.to_s)
+                  raise JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+                end
 
-              unless links_object[:id].nil?
-                association_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
-                checked_has_one_associations[param] = association_resource.verify_key(links_object[:id], @context)
-              else
-                checked_has_one_associations[param] = nil
-              end
-            elsif association.is_a?(JSONAPI::Association::HasMany)
-              if link_value.is_a?(Array) && link_value.length == 0
-                linkage = []
-              elsif link_value.is_a?(Hash)
-                linkage = link_value[:linkage]
-              else
-                raise JSONAPI::Exceptions::InvalidLinksObject.new
-              end
+                unless links_object[:id].nil?
+                  association_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
+                  checked_has_one_associations[param] = association_resource.verify_key(links_object[:id], @context)
+                else
+                  checked_has_one_associations[param] = nil
+                end
+              elsif association.is_a?(JSONAPI::Association::HasMany)
+                if link_value.is_a?(Array) && link_value.length == 0
+                  linkage = []
+                elsif link_value.is_a?(Hash)
+                  linkage = link_value[:data]
+                else
+                  raise JSONAPI::Exceptions::InvalidLinksObject.new
+                end
 
-              links_object = parse_has_many_links_object(linkage)
+                links_object = parse_has_many_links_object(linkage)
 
-              # Since we do not yet support polymorphic associations we will raise an error if the type does not match the
-              # association's type.
-              # ToDo: Support Polymorphic associations
+                # Since we do not yet support polymorphic associations we will raise an error if the type does not match the
+                # association's type.
+                # ToDo: Support Polymorphic associations
 
-              if links_object.length == 0
-                checked_has_many_associations[param] = []
-              else
-                if links_object.length > 1 || !links_object.has_key?(unformat_key(association.type).to_s)
-                  raise JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
-                end
+                if links_object.length == 0
+                  checked_has_many_associations[param] = []
+                else
+                  if links_object.length > 1 || !links_object.has_key?(unformat_key(association.type).to_s)
+                    raise JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+                  end
 
-                links_object.each_pair do |type, keys|
-                  association_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(type).to_s)
-                  checked_has_many_associations[param] = association_resource.verify_keys(keys, @context)
+                  links_object.each_pair do |type, keys|
+                    association_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(type).to_s)
+                    checked_has_many_associations[param] = association_resource.verify_keys(keys, @context)
+                  end
                 end
               end
             end
-          end
-        else
-          param = unformat_key(key)
-          checked_attributes[param] = unformat_value(param, value)
+          when 'id'
+            checked_attributes['id'] = unformat_value(:id, value)
+          when 'attributes'
+            value.each do |key, value|
+              param = unformat_key(key)
+              checked_attributes[param] = unformat_value(param, value)
+            end
         end
       end
 
@@ -335,35 +471,58 @@ module JSONAPI
 
     def unformat_value(attribute, value)
       value_formatter = JSONAPI::ValueFormatter.value_formatter_for(@resource_klass._attribute_options(attribute)[:format])
-      value_formatter.unformat(value, @context)
+      value_formatter.unformat(value)
     end
 
     def verify_permitted_params(params, allowed_fields)
       formatted_allowed_fields = allowed_fields.collect { |field| format_key(field).to_sym }
       params_not_allowed = []
+
       params.each do |key, value|
-        if key == 'links' || key == :links
-          value.each_key do |links_key|
-            params_not_allowed.push(links_key) unless formatted_allowed_fields.include?(links_key.to_sym)
-          end
-        else
-          params_not_allowed.push(key) unless formatted_allowed_fields.include?(key.to_sym)
+        case key.to_s
+          when 'relationships'
+            value.each_key do |links_key|
+              params_not_allowed.push(links_key) unless formatted_allowed_fields.include?(links_key.to_sym)
+            end
+          when 'attributes'
+            value.each do |attr_key, attr_value|
+              params_not_allowed.push(attr_key) unless formatted_allowed_fields.include?(attr_key.to_sym)
+            end
+          when 'type', 'id'
+          else
+            params_not_allowed.push(key)
         end
       end
+
       raise JSONAPI::Exceptions::ParametersNotAllowed.new(params_not_allowed) if params_not_allowed.length > 0
     end
 
+    # TODO: Please remove after `updateable_fields` is removed
+    # :nocov:
+    def updatable_fields
+      if @resource_klass.respond_to?(:updateable_fields)
+        @resource_klass.updateable_fields(@context)
+      else
+        @resource_klass.updatable_fields(@context)
+      end
+    end
+    # :nocov:
+
     def parse_add_association_operation(data, association_type, parent_key)
       association = resource_klass._association(association_type)
 
       if association.is_a?(JSONAPI::Association::HasMany)
-        object_params = {links: {association.name => {linkage: data}}}
-        verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
-
-        @operations.push JSONAPI::CreateHasManyAssociationOperation.new(resource_klass,
-                                                                        parent_key,
-                                                                        association_type,
-                                                                        verified_param_set[:has_many].values[0])
+        object_params = {relationships: {format_key(association.name) => {data: data}}}
+        verified_param_set = parse_params(object_params, updatable_fields)
+
+        @operations.push JSONAPI::CreateHasManyAssociationOperation.new(
+                           resource_klass,
+                           {
+                             resource_id: parent_key,
+                             association_type: association_type,
+                             data: verified_param_set[:has_many].values[0]
+                           }
+                         )
       end
     end
 
@@ -371,31 +530,38 @@ module JSONAPI
       association = resource_klass._association(association_type)
 
       if association.is_a?(JSONAPI::Association::HasOne)
-        object_params = {links: {association.name => {linkage: data}}}
-
-        verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
-
-        @operations.push JSONAPI::ReplaceHasOneAssociationOperation.new(resource_klass,
-                                                                        parent_key,
-                                                                        association_type,
-                                                                        verified_param_set[:has_one].values[0])
+        object_params = {relationships: {format_key(association.name) => {data: data}}}
+        verified_param_set = parse_params(object_params, updatable_fields)
+
+        @operations.push JSONAPI::ReplaceHasOneAssociationOperation.new(
+                           resource_klass,
+                           {
+                             resource_id: parent_key,
+                             association_type: association_type,
+                             key_value: verified_param_set[:has_one].values[0]
+                           }
+                         )
       else
         unless association.acts_as_set
           raise JSONAPI::Exceptions::HasManySetReplacementForbidden.new
         end
 
-        object_params = {links: {association.name => {linkage: data}}}
-        verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
-
-        @operations.push JSONAPI::ReplaceHasManyAssociationOperation.new(resource_klass,
-                                                                         parent_key,
-                                                                         association_type,
-                                                                         verified_param_set[:has_many].values[0])
+        object_params = {relationships: {format_key(association.name) => {data: data}}}
+        verified_param_set = parse_params(object_params, updatable_fields)
+
+        @operations.push JSONAPI::ReplaceHasManyAssociationOperation.new(
+                           resource_klass,
+                           {
+                             resource_id: parent_key,
+                             association_type: association_type,
+                             data: verified_param_set[:has_many].values[0]
+                           }
+                         )
       end
     end
 
     def parse_single_replace_operation(data, keys)
-      if data[@resource_klass._primary_key].nil?
+      if data[:id].nil?
         raise JSONAPI::Exceptions::MissingKey.new
       end
 
@@ -404,19 +570,24 @@ module JSONAPI
         raise JSONAPI::Exceptions::ParameterMissing.new(:type)
       end
 
-      key = data[@resource_klass._primary_key]
+      key = data[:id]
       if !keys.include?(key)
         raise JSONAPI::Exceptions::KeyNotIncludedInURL.new(key)
       end
 
-      if !keys.include?(@resource_klass._primary_key)
+      if !keys.include?(:id)
         data.delete(:id)
       end
 
-      @operations.push(JSONAPI::ReplaceFieldsOperation.new(@resource_klass,
-                                                           key,
-                                                           parse_params(verify_and_remove_type(data),
-                                                                        @resource_klass.updateable_fields(@context))))
+      verify_type(data[:type])
+
+      @operations.push JSONAPI::ReplaceFieldsOperation.new(
+                         @resource_klass,
+                         {
+                           resource_id: key,
+                           data: parse_params(data, updatable_fields)
+                         }
+                       )
     end
 
     def parse_replace_operation(data, keys)
@@ -437,10 +608,15 @@ module JSONAPI
     end
 
     def parse_remove_operation(params)
-      keys = parse_key_array(params.permit(@resource_klass._primary_key)[@resource_klass._primary_key])
+      keys = parse_key_array(params.permit(:id)[:id])
 
       keys.each do |key|
-        @operations.push JSONAPI::RemoveResourceOperation.new(@resource_klass, key)
+        @operations.push JSONAPI::RemoveResourceOperation.new(
+                           @resource_klass,
+                           {
+                             resource_id: key
+                           }
+                         )
       end
     rescue ActionController::UnpermittedParameters => e
       @errors.concat(JSONAPI::Exceptions::ParametersNotAllowed.new(e.params).errors)
@@ -457,15 +633,23 @@ module JSONAPI
       if association.is_a?(JSONAPI::Association::HasMany)
         keys = parse_key_array(params[:keys])
         keys.each do |key|
-          @operations.push JSONAPI::RemoveHasManyAssociationOperation.new(resource_klass,
-                                                                          parent_key,
-                                                                          association_type,
-                                                                          key)
+          @operations.push JSONAPI::RemoveHasManyAssociationOperation.new(
+                             resource_klass,
+                             {
+                               resource_id: parent_key,
+                               association_type: association_type,
+                               associated_key: key
+                             }
+                           )
         end
       else
-        @operations.push JSONAPI::RemoveHasOneAssociationOperation.new(resource_klass,
-                                                                       parent_key,
-                                                                       association_type)
+        @operations.push JSONAPI::RemoveHasOneAssociationOperation.new(
+                           resource_klass,
+                           {
+                             resource_id: parent_key,
+                             association_type: association_type
+                           }
+                         )
       end
     end