jsonapi-resources 0.9.12 → 0.10.0.beta1

data/lib/jsonapi/relationship.rb

@@ -2,9 +2,10 @@ module JSONAPI
   class Relationship
     attr_reader :acts_as_set, :foreign_key, :options, :name,
                 :class_name, :polymorphic, :always_include_linkage_data,
-                :parent_resource, :eager_load_on_include
+                :parent_resource, :eager_load_on_include, :custom_methods,
+                :inverse_relationship, :allow_include
 
-    attr_accessor :_routed, :_warned_missing_route
+    attr_writer :allow_include
 
     def initialize(name, options = {})
       @name = name.to_s
@@ -14,26 +15,51 @@ module JSONAPI
       @parent_resource = options[:parent_resource]
       @relation_name = options.fetch(:relation_name, @name)
       @polymorphic = options.fetch(:polymorphic, false) == true
+      @polymorphic_relations = options[:polymorphic_relations]
       @always_include_linkage_data = options.fetch(:always_include_linkage_data, false) == true
-      @eager_load_on_include = options.fetch(:eager_load_on_include, true) == true
-      @_routed = false
-      @_warned_missing_route = false
+      @eager_load_on_include = options.fetch(:eager_load_on_include, false) == true
+      @allow_include = options[:allow_include]
+      @class_name = nil
+      @inverse_relationship = nil
 
-      exclude_links(options.fetch(:exclude_links, JSONAPI.configuration.default_exclude_links))
+      # Custom methods are reserved for use in resource finders. Not used in the default ActiveRelationResourceFinder
+      @custom_methods = options.fetch(:custom_methods, {})
     end
 
     alias_method :polymorphic?, :polymorphic
 
     def primary_key
+      # :nocov:
       @primary_key ||= resource_klass._primary_key
+      # :nocov:
     end
 
     def resource_klass
-      @resource_klass ||= @parent_resource.resource_for(@class_name)
+      @resource_klass ||= @parent_resource.resource_klass_for(@class_name)
     end
 
     def table_name
+      # :nocov:
       @table_name ||= resource_klass._table_name
+      # :nocov:
+    end
+
+    def self.polymorphic_types(name)
+      @poly_hash ||= {}.tap do |hash|
+        ObjectSpace.each_object do |klass|
+          next unless Module === klass
+          if ActiveRecord::Base > klass
+            klass.reflect_on_all_associations(:has_many).select{|r| r.options[:as] }.each do |reflection|
+              (hash[reflection.options[:as]] ||= []) << klass.name.downcase
+            end
+          end
+        end
+      end
+      @poly_hash[name.to_sym]
+    end
+
+    def polymorphic_relations
+      @polymorphic_relations ||= self.class.polymorphic_types(@relation_name)
     end
 
     def type
@@ -53,44 +79,14 @@ module JSONAPI
       end
     end
 
-    def type_for_source(source)
-      if polymorphic?
-        # try polymorphic type column before asking it from the resource record
-        if source._model.respond_to?(polymorphic_type)
-          model_type = source._model.send(polymorphic_type)
-          source.class.resource_for(model_type)._type if model_type
-        else
-          resource = source.public_send(name)
-          resource.class._type if resource
-        end
-      else
-        type
-      end
-    end
-
     def belongs_to?
+      # :nocov:
       false
+      # :nocov:
     end
 
-    def exclude_links(exclude)
-      case exclude
-        when :default, "default"
-          @_exclude_links = [:self, :related]
-        when :none, "none"
-          @_exclude_links = []
-        when Array
-          @_exclude_links = exclude.collect {|link| link.to_sym}
-        else
-          fail "Invalid exclude_links"
-      end
-    end
-
-    def _exclude_links
-      @_exclude_links ||= []
-    end
-
-    def exclude_link?(link)
-      _exclude_links.include?(link.to_sym)
+    def readonly?
+      @options[:readonly]
     end
 
     class ToOne < Relationship
@@ -101,38 +97,66 @@ module JSONAPI
         @class_name = options.fetch(:class_name, name.to_s.camelize)
         @foreign_key ||= "#{name}_id".to_sym
         @foreign_key_on = options.fetch(:foreign_key_on, :self)
-      end
-
-      def to_s
-        # :nocov:
-        "#{parent_resource}.#{name}(#{belongs_to? ? 'BelongsToOne' : 'ToOne'})"
-        # :nocov:
+        if parent_resource
+          @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type)
+        end
       end
 
       def belongs_to?
+        # :nocov:
         foreign_key_on == :self
+        # :nocov:
       end
 
       def polymorphic_type
         "#{name}_type" if polymorphic?
       end
+
+      def allow_include?(context = nil)
+        strategy = if @allow_include.nil?
+                     JSONAPI.configuration.default_allow_include_to_one
+                   else
+                     @allow_include
+                   end
+
+        if !!strategy == strategy #check for boolean
+          return strategy
+        elsif strategy.is_a?(Symbol) || strategy.is_a?(String)
+          parent_resource.send(strategy, context)
+        else
+          strategy.call(context)
+        end
+      end
     end
 
     class ToMany < Relationship
-      attr_reader :reflect, :inverse_relationship
+      attr_reader :reflect
 
       def initialize(name, options = {})
         super
         @class_name = options.fetch(:class_name, name.to_s.camelize.singularize)
         @foreign_key ||= "#{name.to_s.singularize}_ids".to_sym
         @reflect = options.fetch(:reflect, true) == true
-        @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type.to_s.singularize.to_sym) if parent_resource
+        if parent_resource
+          @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type.to_s.singularize.to_sym)
+        end
       end
 
-      def to_s
-        # :nocov:
-        "#{parent_resource}.#{name}(ToMany)"
-        # :nocov:
+      def allow_include?(context = nil)
+        strategy = if @allow_include.nil?
+                     JSONAPI.configuration.default_allow_include_to_many
+                   else
+                     @allow_include
+                   end
+
+        if !!strategy == strategy #check for boolean
+          return strategy
+        elsif strategy.is_a?(Symbol) || strategy.is_a?(String)
+          parent_resource.send(strategy, context)
+        else
+          strategy.call(context)
+        end
+
       end
     end
   end

data/lib/jsonapi/request_parser.rb

@@ -1,132 +1,253 @@
-require 'jsonapi/operation'
-require 'jsonapi/paginator'
-
 module JSONAPI
   class RequestParser
-    attr_accessor :fields, :include, :filters, :sort_criteria, :errors, :operations,
-                  :resource_klass, :context, :paginator, :source_klass, :source_id,
+    attr_accessor :fields, :include, :filters, :sort_criteria, :errors, :controller_module_path,
+                  :context, :paginator, :source_klass, :source_id,
                   :include_directives, :params, :warnings, :server_error_callbacks
 
     def initialize(params = nil, options = {})
       @params = params
+      if params
+        controller_path = params.fetch(:controller, '')
+        @controller_module_path = controller_path.include?('/') ? controller_path.rpartition('/').first + '/' : ''
+      else
+        @controller_module_path = ''
+      end
+
       @context = options[:context]
       @key_formatter = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
       @errors = []
       @warnings = []
-      @operations = []
-      @fields = {}
-      @filters = {}
-      @sort_criteria = nil
-      @source_klass = nil
-      @source_id = nil
-      @include_directives = nil
-      @paginator = nil
-      @id = nil
       @server_error_callbacks = options.fetch(:server_error_callbacks, [])
+    end
+
+    def error_object_overrides
+      {}
+    end
+
+    def each(_response_document)
+      operation = setup_base_op(params)
+      if @errors.any?
+        fail JSONAPI::Exceptions::Errors.new(@errors)
+      else
+        yield operation
+      end
+    rescue ActionController::ParameterMissing => e
+      fail JSONAPI::Exceptions::ParameterMissing.new(e.param, error_object_overrides)
+    end
 
-      setup_action(@params)
+    def transactional?
+      case params[:action]
+        when 'index', 'show_related_resource', 'index_related_resources', 'show', 'show_relationship'
+          return false
+        else
+          return true
+      end
     end
 
-    def setup_action(params)
+    def setup_base_op(params)
       return if params.nil?
 
-      @resource_klass ||= Resource.resource_for(params[:controller]) if params[:controller]
+      resource_klass = Resource.resource_klass_for(params[:controller]) if params[:controller]
 
       setup_action_method_name = "setup_#{params[:action]}_action"
       if respond_to?(setup_action_method_name)
         raise params[:_parser_exception] if params[:_parser_exception]
-        send(setup_action_method_name, params)
+        send(setup_action_method_name, params, resource_klass)
       end
     rescue ActionController::ParameterMissing => e
-      @errors.concat(JSONAPI::Exceptions::ParameterMissing.new(e.param).errors)
+      @errors.concat(JSONAPI::Exceptions::ParameterMissing.new(e.param, error_object_overrides).errors)
+    rescue JSONAPI::Exceptions::Error => e
+      e.error_object_overrides.merge! error_object_overrides
+      @errors.concat(e.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
+    def setup_index_action(params, resource_klass)
+      fields = parse_fields(resource_klass, params[:fields])
+      include_directives = parse_include_directives(resource_klass, params[:include])
+      filters = parse_filters(resource_klass, params[:filter])
+      sort_criteria = parse_sort_criteria(resource_klass, params[:sort])
+      paginator = parse_pagination(resource_klass, params[:page])
+
+      JSONAPI::Operation.new(
+          :find,
+          resource_klass,
+          context: context,
+          filters: filters,
+          include_directives: include_directives,
+          sort_criteria: sort_criteria,
+          paginator: paginator,
+          fields: fields
+      )
     end
 
-    def setup_get_related_resource_action(params)
-      resolve_singleton_id(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[:relationship])
+    def setup_show_related_resource_action(params, resource_klass)
+      source_klass = Resource.resource_klass_for(params.require(:source))
+      source_id = source_klass.verify_key(params.require(source_klass._as_parent_key), @context)
+
+      fields = parse_fields(resource_klass, params[:fields])
+      include_directives = parse_include_directives(resource_klass, params[:include])
+
+      relationship_type = params[:relationship].to_sym
+
+      JSONAPI::Operation.new(
+          :show_related_resource,
+          resource_klass,
+          context: @context,
+          relationship_type: relationship_type,
+          source_klass: source_klass,
+          source_id: source_id,
+          fields: fields,
+          include_directives: include_directives
+      )
     end
 
-    def setup_get_related_resources_action(params)
-      resolve_singleton_id(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[:relationship])
+    def setup_index_related_resources_action(params, resource_klass)
+      source_klass = Resource.resource_klass_for(params.require(:source))
+      source_id = source_klass.verify_key(params.require(source_klass._as_parent_key), @context)
+
+      fields = parse_fields(resource_klass, params[:fields])
+      include_directives = parse_include_directives(resource_klass, params[:include])
+      filters = parse_filters(resource_klass, params[:filter])
+      sort_criteria = parse_sort_criteria(resource_klass, params[:sort])
+      paginator = parse_pagination(resource_klass, params[:page])
+      relationship_type = params[:relationship]
+
+      JSONAPI::Operation.new(
+          :show_related_resources,
+          resource_klass,
+          context: @context,
+          relationship_type: relationship_type,
+          source_klass: source_klass,
+          source_id: source_id,
+          filters: filters,
+          sort_criteria: sort_criteria,
+          paginator: paginator,
+          fields: fields,
+          include_directives: include_directives
+      )
     end
 
-    def setup_show_action(params)
-      resolve_singleton_id(params)
-      parse_fields(params[:fields])
-      parse_include_directives(params[:include])
-      parse_filters(params[:filter])
+    def setup_show_action(params, resource_klass)
+      fields = parse_fields(resource_klass, params[:fields])
+      include_directives = parse_include_directives(resource_klass, params[:include])
+      id = params[:id]
 
-      @id = params[:id]
-      add_show_operation
+      JSONAPI::Operation.new(
+          :show,
+          resource_klass,
+          context: @context,
+          id: id,
+          include_directives: include_directives,
+          fields: fields,
+          allowed_resources: params[:allowed_resources]
+      )
     end
 
-    def setup_show_relationship_action(params)
-      resolve_singleton_id(params)
-      add_show_relationship_operation(params[:relationship], params.require(@resource_klass._as_parent_key))
+    def setup_show_relationship_action(params, resource_klass)
+      relationship_type = params[:relationship]
+      parent_key = params.require(resource_klass._as_parent_key)
+      include_directives = parse_include_directives(resource_klass, params[:include])
+      filters = parse_filters(resource_klass, params[:filter])
+      sort_criteria = parse_sort_criteria(resource_klass, params[:sort])
+      paginator = parse_pagination(resource_klass, params[:page])
+
+      JSONAPI::Operation.new(
+          :show_relationship,
+          resource_klass,
+          context: @context,
+          relationship_type: relationship_type,
+          parent_key: resource_klass.verify_key(parent_key),
+          filters: filters,
+          sort_criteria: sort_criteria,
+          paginator: paginator,
+          fields: fields,
+          include_directives: include_directives
+      )
     end
 
-    def setup_create_action(params)
-      parse_fields(params[:fields])
-      parse_include_directives(params[:include])
-      parse_add_operation(params.require(:data))
+    def setup_create_action(params, resource_klass)
+      fields = parse_fields(resource_klass, params[:fields])
+      include_directives = parse_include_directives(resource_klass, params[:include])
+
+      data = params.require(:data)
+
+      unless data.respond_to?(:each_pair)
+        fail JSONAPI::Exceptions::InvalidDataFormat.new(error_object_overrides)
+      end
+
+      verify_type(data[:type], resource_klass)
+
+      data = parse_params(resource_klass, data, resource_klass.creatable_fields(@context))
+
+      JSONAPI::Operation.new(
+          :create_resource,
+          resource_klass,
+          context: @context,
+          data: data,
+          fields: fields,
+          include_directives: include_directives,
+          warnings: @warnings
+      )
     end
 
-    def setup_create_relationship_action(params)
-      resolve_singleton_id(params)
-      parse_modify_relationship_action(params, :add)
+    def setup_create_relationship_action(params, resource_klass)
+      parse_modify_relationship_action(:add, params, resource_klass)
     end
 
-    def setup_update_relationship_action(params)
-      resolve_singleton_id(params)
-      parse_modify_relationship_action(params, :update)
+    def setup_update_relationship_action(params, resource_klass)
+      parse_modify_relationship_action(:update, params, resource_klass)
     end
 
-    def setup_update_action(params)
-      resolve_singleton_id(params)
-      parse_fields(params[:fields])
-      parse_include_directives(params[:include])
-      parse_replace_operation(params.require(:data), params[:id])
+    def setup_update_action(params, resource_klass)
+      fields = parse_fields(resource_klass, params[:fields])
+      include_directives = parse_include_directives(resource_klass, params[:include])
+
+      data = params.require(:data)
+      key = params[:id]
+
+      fail JSONAPI::Exceptions::InvalidDataFormat.new(error_object_overrides) unless data.respond_to?(:each_pair)
+
+      fail JSONAPI::Exceptions::MissingKey.new(error_object_overrides) if data[:id].nil?
+
+      resource_id = data.require(:id)
+      # Singleton resources may not have the ID set in the URL
+      if key
+        fail JSONAPI::Exceptions::KeyNotIncludedInURL.new(resource_id) if key.to_s != resource_id.to_s
+      end
+
+      data.delete(:id)
+
+      verify_type(data[:type], resource_klass)
+
+      JSONAPI::Operation.new(
+          :replace_fields,
+          resource_klass,
+          context: @context,
+          resource_id: resource_id,
+          data: parse_params(resource_klass, data, resource_klass.updatable_fields(@context)),
+          fields: fields,
+          include_directives: include_directives,
+          warnings: @warnings
+      )
     end
 
-    def setup_destroy_action(params)
-      resolve_singleton_id(params)
-      parse_remove_operation(params)
+    def setup_destroy_action(params, resource_klass)
+      JSONAPI::Operation.new(
+          :remove_resource,
+          resource_klass,
+          context: @context,
+          resource_id: resource_klass.verify_key(params.require(:id), @context))
     end
 
-    def setup_destroy_relationship_action(params)
-      resolve_singleton_id(params)
-      parse_modify_relationship_action(params, :remove)
+    def setup_destroy_relationship_action(params, resource_klass)
+      parse_modify_relationship_action(:remove, params, resource_klass)
     end
 
-    def parse_modify_relationship_action(params, modification_type)
+    def parse_modify_relationship_action(modification_type, params, resource_klass)
       relationship_type = params.require(:relationship)
-      parent_key = params.require(@resource_klass._as_parent_key)
-      relationship = @resource_klass._relationship(relationship_type)
+
+      parent_key = params.require(resource_klass._as_parent_key)
+      relationship = resource_klass._relationship(relationship_type)
 
       # Removals of to-one relationships are done implicitly and require no specification of data
       data_required = !(modification_type == :remove && relationship.is_a?(JSONAPI::Relationship::ToOne))
@@ -134,75 +255,74 @@ module JSONAPI
       if data_required
         data = params.fetch(:data)
         object_params = { relationships: { format_key(relationship.name) => { data: data } } }
-        verified_params = parse_params(object_params, @resource_klass.updatable_fields(@context))
 
-        parse_arguments = [verified_params, relationship, parent_key]
+        verified_params = parse_params(resource_klass, object_params, resource_klass.updatable_fields(@context))
+
+        parse_arguments = [resource_klass, verified_params, relationship, parent_key]
       else
-        parse_arguments = [params, relationship, parent_key]
+        parse_arguments = [resource_klass, params, relationship, parent_key]
       end
 
       send(:"parse_#{modification_type}_relationship_operation", *parse_arguments)
     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)
+    def parse_pagination(resource_klass, page)
+      paginator_name = resource_klass._paginator
+      JSONAPI::Paginator.paginator_for(paginator_name).new(page) unless paginator_name == :none
     end
 
-    def parse_pagination(page)
-      paginator_name = @resource_klass._paginator
-      @paginator = JSONAPI::Paginator.paginator_for(paginator_name).new(page) unless paginator_name == :none
-    rescue JSONAPI::Exceptions::Error => e
-      @errors.concat(e.errors)
-    end
-
-    def parse_fields(fields)
-      return if fields.nil?
-
+    def parse_fields(resource_klass, fields)
       extracted_fields = {}
 
+      return extracted_fields if fields.nil?
+
       # Extract the fields for each type from the fields parameters
       if fields.is_a?(ActionController::Parameters)
         fields.each do |field, value|
-          resource_fields = value.split(',') unless value.nil? || value.empty?
+          if value.is_a?(Array)
+            resource_fields = value
+          else
+            resource_fields = value.split(',') unless value.nil? || value.empty?
+          end
           extracted_fields[field] = resource_fields
         end
       else
-        fail JSONAPI::Exceptions::InvalidFieldFormat.new
+        fail JSONAPI::Exceptions::InvalidFieldFormat.new(error_object_overrides)
       end
 
       # Validate the fields
+      validated_fields = {}
       extracted_fields.each do |type, values|
         underscored_type = unformat_key(type)
-        extracted_fields[type] = []
+        validated_fields[type] = []
         begin
           if type != format_key(type)
-            fail JSONAPI::Exceptions::InvalidResource.new(type)
+            fail JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides)
           end
-          type_resource = Resource.resource_for(@resource_klass.module_path + underscored_type.to_s)
+          type_resource = Resource.resource_klass_for(resource_klass.module_path + underscored_type.to_s)
         rescue NameError
-          fail JSONAPI::Exceptions::InvalidResource.new(type)
+          fail JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides)
         end
 
         if type_resource.nil?
-          fail JSONAPI::Exceptions::InvalidResource.new(type)
+          fail JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides)
         else
           unless values.nil?
             valid_fields = type_resource.fields.collect { |key| format_key(key) }
             values.each do |field|
               if valid_fields.include?(field)
-                extracted_fields[type].push unformat_key(field)
+                validated_fields[type].push unformat_key(field)
               else
-                fail JSONAPI::Exceptions::InvalidField.new(type, field)
+                fail JSONAPI::Exceptions::InvalidField.new(type, field, error_object_overrides)
               end
             end
           else
-            fail JSONAPI::Exceptions::InvalidField.new(type, 'nil')
+            fail JSONAPI::Exceptions::InvalidField.new(type, 'nil', error_object_overrides)
           end
         end
       end
 
-      @fields = extracted_fields.deep_transform_keys { |key| unformat_key(key) }
+      validated_fields.deep_transform_keys { |key| unformat_key(key) }
     end
 
     def check_include(resource_klass, include_parts)
@@ -210,243 +330,146 @@ module JSONAPI
 
       relationship = resource_klass._relationship(relationship_name)
       if relationship && format_key(relationship_name) == include_parts.first
+        unless relationship.allow_include?(context)
+          fail JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type), include_parts.first)
+        end
+
         unless include_parts.last.empty?
-          check_include(Resource.resource_for(resource_klass.module_path + relationship.class_name.to_s.underscore), include_parts.last.partition('.'))
+          check_include(Resource.resource_klass_for(resource_klass.module_path + relationship.class_name.to_s.underscore),
+                        include_parts.last.partition('.'))
         end
       else
         fail JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type), include_parts.first)
       end
+      true
     end
 
-    def parse_include_directives(raw_include)
+    def parse_include_directives(resource_klass, raw_include)
       return unless raw_include
 
-      unless JSONAPI.configuration.allow_include
-        fail JSONAPI::Exceptions::ParameterNotAllowed.new(:include)
-      end
-
       included_resources = []
       begin
-        included_resources += Array(CSV.parse_line(raw_include))
+        included_resources += raw_include.is_a?(Array) ? raw_include : CSV.parse_line(raw_include) || []
       rescue CSV::MalformedCSVError
-        fail JSONAPI::Exceptions::InvalidInclude.new(format_key(@resource_klass._type), raw_include)
+        fail JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type), raw_include)
       end
 
-      return if included_resources.empty?
+      return if included_resources.nil?
 
       begin
         result = included_resources.compact.map do |included_resource|
-          check_include(@resource_klass, included_resource.partition('.'))
+          check_include(resource_klass, included_resource.partition('.'))
           unformat_key(included_resource).to_s
         end
 
-        @include_directives = JSONAPI::IncludeDirectives.new(@resource_klass, result)
+        return JSONAPI::IncludeDirectives.new(resource_klass, result)
       rescue JSONAPI::Exceptions::InvalidInclude => e
         @errors.concat(e.errors)
-        @include_directives = JSONAPI::IncludeDirectives.new(@resource_klass, [])
+        return {}
       end
     end
 
-    def parse_filters(filters)
-      return unless filters
+    def parse_filters(resource_klass, filters)
+      parsed_filters = {}
 
-      unless JSONAPI.configuration.allow_filter
-        fail JSONAPI::Exceptions::ParameterNotAllowed.new(:filter)
+      # apply default filters
+      resource_klass._allowed_filters.each do |filter, opts|
+        next if opts[:default].nil? || !parsed_filters[filter].nil?
+        parsed_filters[filter] = opts[:default]
       end
 
+      return parsed_filters unless filters
+
       unless filters.class.method_defined?(:each)
         @errors.concat(JSONAPI::Exceptions::InvalidFiltersSyntax.new(filters).errors)
-        return
+        return {}
       end
 
-      filters.each do |key, value|
-
-        unformatted_key = unformat_key(key)
-        if resource_klass._allowed_filter?(unformatted_key)
-          @filters[unformatted_key] = value
-        elsif unformatted_key.to_s.include?('.')
-          parse_relationship_filter(unformatted_key, value)
-        else
-          return @errors.concat(Exceptions::FilterNotAllowed.new(unformatted_key).errors)
-        end
+      unless JSONAPI.configuration.allow_filter
+        fail JSONAPI::Exceptions::ParameterNotAllowed.new(:filter)
       end
-    end
-
-    def parse_relationship_filter(key, value)
-      included_resource_name, filter_method = key.to_s.split('.')
-      filter_method = filter_method.to_sym if filter_method.present?
-
-      if included_resource_name
-        relationship = resource_klass._relationship(included_resource_name || '')
-
-        unless relationship
-          return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
-        end
-
-        unless  relationship.resource_klass._allowed_filter?(filter_method)
-          return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
-        end
 
-        unless @include_directives.try(:include_config, relationship.name.to_sym).present?
-          return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
+      filters.each do |key, value|
+        filter = unformat_key(key)
+        if resource_klass._allowed_filter?(filter)
+          parsed_filters[filter] = value
+        else
+          fail JSONAPI::Exceptions::FilterNotAllowed.new(key)
         end
-
-        verified_filter = relationship.resource_klass.verify_filters({ filter_method => value }, @context)
-        @include_directives.merge_filter(relationship.name, verified_filter)
-      else
-        return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
       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
+      parsed_filters
     end
 
-    def parse_sort_criteria(sort_criteria)
+    def parse_sort_criteria(resource_klass, sort_criteria)
       return unless sort_criteria.present?
 
       unless JSONAPI.configuration.allow_sort
         fail JSONAPI::Exceptions::ParameterNotAllowed.new(:sort)
       end
 
-      sorts = []
-      begin
-        raw = URI::DEFAULT_PARSER.unescape(sort_criteria)
-        sorts += CSV.parse_line(raw)
-      rescue CSV::MalformedCSVError
-        fail JSONAPI::Exceptions::InvalidSortCriteria.new(format_key(@resource_klass._type), raw)
+      if sort_criteria.is_a?(Array)
+        sorts = sort_criteria
+      elsif sort_criteria.is_a?(String)
+        begin
+          raw = URI.unescape(sort_criteria)
+          sorts = CSV.parse_line(raw)
+        rescue CSV::MalformedCSVError
+          fail JSONAPI::Exceptions::InvalidSortCriteria.new(format_key(resource_klass._type), raw)
+        end
       end
 
       @sort_criteria = sorts.collect do |sort|
         if sort.start_with?('-')
-          sort_criteria = { field: unformat_key(sort[1..-1]).to_s }
-          sort_criteria[:direction] = :desc
+          criteria = { field: unformat_key(sort[1..-1]).to_s }
+          criteria[:direction] = :desc
         else
-          sort_criteria = { field: unformat_key(sort).to_s }
-          sort_criteria[:direction] = :asc
+          criteria = { field: unformat_key(sort).to_s }
+          criteria[:direction] = :asc
         end
 
-        check_sort_criteria(@resource_klass, sort_criteria)
-        sort_criteria
+        check_sort_criteria(resource_klass, criteria)
+        criteria
       end
     end
 
     def check_sort_criteria(resource_klass, sort_criteria)
       sort_field = sort_criteria[:field]
-      sortable_fields = resource_klass.sortable_fields(context)
 
-      unless sortable_fields.include?sort_field.to_sym
+      unless resource_klass.sortable_field?(sort_field.to_sym, context)
         fail JSONAPI::Exceptions::InvalidSortCriteria.new(format_key(resource_klass._type), sort_field)
       end
     end
 
-    def add_find_operation
-      @operations.push JSONAPI::Operation.new(:find,
-        @resource_klass,
-        context: @context,
-        filters: @filters,
-        include_directives: @include_directives,
-        sort_criteria: @sort_criteria,
-        paginator: @paginator,
-        fields: @fields
-      )
-    end
-
-    def add_show_operation
-      @operations.push JSONAPI::Operation.new(:show,
-        @resource_klass,
-        context: @context,
-        id: @id,
-        include_directives: @include_directives,
-        fields: @fields
-      )
-    end
-
-    def add_show_relationship_operation(relationship_type, parent_key)
-      @operations.push JSONAPI::Operation.new(:show_relationship,
-        @resource_klass,
-        context: @context,
-        relationship_type: relationship_type,
-        parent_key: @resource_klass.verify_key(parent_key)
-      )
-    end
-
-    def add_show_related_resource_operation(relationship_type)
-      @operations.push JSONAPI::Operation.new(:show_related_resource,
-        @resource_klass,
-        context: @context,
-        relationship_type: relationship_type,
-        source_klass: @source_klass,
-        source_id: @source_id,
-        fields: @fields,
-        include_directives: @include_directives
-      )
-    end
-
-    def add_show_related_resources_operation(relationship_type)
-      @operations.push JSONAPI::Operation.new(:show_related_resources,
-        @resource_klass,
-        context: @context,
-        relationship_type: relationship_type,
-        source_klass: @source_klass,
-        source_id: @source_id,
-        filters: @filters,
-        sort_criteria: @sort_criteria,
-        paginator: @paginator,
-        fields: @fields,
-        include_directives: @include_directives
-      )
-    end
-
-    def parse_add_operation(params)
-      fail JSONAPI::Exceptions::InvalidDataFormat unless params.respond_to?(:each_pair)
-
-      verify_type(params[:type])
-
-      data = parse_params(params, @resource_klass.creatable_fields(@context))
-      @operations.push JSONAPI::Operation.new(:create_resource,
-        @resource_klass,
-        context: @context,
-        data: data,
-        fields: @fields,
-        include_directives: @include_directives
-      )
-    rescue JSONAPI::Exceptions::Error => e
-      @errors.concat(e.errors)
-    end
-
-    def verify_type(type)
+    def verify_type(type, resource_klass)
       if type.nil?
         fail JSONAPI::Exceptions::ParameterMissing.new(:type)
-      elsif unformat_key(type).to_sym != @resource_klass._type
-        fail JSONAPI::Exceptions::InvalidResource.new(type)
+      elsif unformat_key(type).to_sym != resource_klass._type
+        fail JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides)
       end
     end
 
     def parse_to_one_links_object(raw)
       if raw.nil?
         return {
-          type: nil,
-          id: nil
+            type: nil,
+            id: nil
         }
       end
 
       if !(raw.is_a?(Hash) || raw.is_a?(ActionController::Parameters)) ||
-         raw.keys.length != 2 || !(raw.key?('type') && raw.key?('id'))
-        fail JSONAPI::Exceptions::InvalidLinksObject.new
+          raw.keys.length != 2 || !(raw.key?('type') && raw.key?('id'))
+        fail JSONAPI::Exceptions::InvalidLinksObject.new(error_object_overrides)
       end
 
       {
-        type: unformat_key(raw['type']).to_s,
-        id: raw['id']
+          type: unformat_key(raw['type']).to_s,
+          id: raw['id']
       }
     end
 
     def parse_to_many_links_object(raw)
-      fail JSONAPI::Exceptions::InvalidLinksObject.new if raw.nil?
+      fail JSONAPI::Exceptions::InvalidLinksObject.new(error_object_overrides) if raw.nil?
 
       links_object = {}
       if raw.is_a?(Array)
@@ -456,12 +479,12 @@ module JSONAPI
           links_object[link_object[:type]].push(link_object[:id])
         end
       else
-        fail JSONAPI::Exceptions::InvalidLinksObject.new
+        fail JSONAPI::Exceptions::InvalidLinksObject.new(error_object_overrides)
       end
       links_object
     end
 
-    def parse_params(params, allowed_fields)
+    def parse_params(resource_klass, params, allowed_fields)
       verify_permitted_params(params, allowed_fields)
 
       checked_attributes = {}
@@ -470,37 +493,37 @@ module JSONAPI
 
       params.each do |key, value|
         case key.to_s
-        when 'relationships'
-          value.each do |link_key, link_value|
-            param = unformat_key(link_key)
-            relationship = @resource_klass._relationship(param)
-
-            if relationship.is_a?(JSONAPI::Relationship::ToOne)
-              checked_to_one_relationships[param] = parse_to_one_relationship(link_value, relationship)
-            elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
-              parse_to_many_relationship(link_value, relationship) do |result_val|
-                checked_to_many_relationships[param] = result_val
+          when 'relationships'
+            value.each do |link_key, link_value|
+              param = unformat_key(link_key)
+              relationship = resource_klass._relationship(param)
+
+              if relationship.is_a?(JSONAPI::Relationship::ToOne)
+                checked_to_one_relationships[param] = parse_to_one_relationship(resource_klass, link_value, relationship)
+              elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
+                parse_to_many_relationship(resource_klass, link_value, relationship) do |result_val|
+                  checked_to_many_relationships[param] = result_val
+                end
               end
             end
-          end
-        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
+          when 'id'
+            checked_attributes['id'] = unformat_value(resource_klass, :id, value)
+          when 'attributes'
+            value.each do |key, value|
+              param = unformat_key(key)
+              checked_attributes[param] = unformat_value(resource_klass, param, value)
+            end
         end
       end
 
       return {
-        'attributes' => checked_attributes,
-        'to_one' => checked_to_one_relationships,
-        'to_many' => checked_to_many_relationships
+          'attributes' => checked_attributes,
+          'to_one' => checked_to_one_relationships,
+          'to_many' => checked_to_many_relationships
       }.deep_transform_keys { |key| unformat_key(key) }
     end
 
-    def parse_to_one_relationship(link_value, relationship)
+    def parse_to_one_relationship(resource_klass, link_value, relationship)
       if link_value.nil?
         linkage = nil
       else
@@ -509,12 +532,12 @@ module JSONAPI
 
       links_object = parse_to_one_links_object(linkage)
       if !relationship.polymorphic? && links_object[:type] && (links_object[:type].to_s != relationship.type.to_s)
-        fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+        fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type], error_object_overrides)
       end
 
       unless links_object[:id].nil?
-        resource = self.resource_klass || Resource
-        relationship_resource = resource.resource_for(unformat_key(relationship.options[:class_name] || links_object[:type]).to_s)
+        resource = resource_klass || Resource
+        relationship_resource = resource.resource_klass_for(unformat_key(relationship.options[:class_name] || links_object[:type]).to_s)
         relationship_id = relationship_resource.verify_key(links_object[:id], @context)
         if relationship.polymorphic?
           { id: relationship_id, type: unformat_key(links_object[:type].to_s) }
@@ -526,57 +549,35 @@ module JSONAPI
       end
     end
 
-    def parse_to_many_relationship(link_value, relationship, &add_result)
-      if link_value.is_a?(Array) && link_value.length == 0
-        linkage = []
-      elsif (link_value.is_a?(Hash) || link_value.is_a?(ActionController::Parameters))
+    def parse_to_many_relationship(resource_klass, link_value, relationship, &add_result)
+      if (link_value.is_a?(Hash) || link_value.is_a?(ActionController::Parameters))
         linkage = link_value[:data]
       else
-        fail JSONAPI::Exceptions::InvalidLinksObject.new
+        fail JSONAPI::Exceptions::InvalidLinksObject.new(error_object_overrides)
       end
 
       links_object = parse_to_many_links_object(linkage)
 
+      # Since we do not yet support polymorphic to_many relationships we will raise an error if the type does not match the
+      # relationship's type.
+      # ToDo: Support Polymorphic relationships
+
       if links_object.length == 0
         add_result.call([])
       else
-        if relationship.polymorphic?
-          polymorphic_results = []
-
-          links_object.each_pair do |type, keys|
-            resource = self.resource_klass || Resource
-            type_name = unformat_key(type).to_s
-
-            relationship_resource_klass = resource.resource_for(relationship.class_name)
-            relationship_klass = relationship_resource_klass._model_class
-
-            linkage_object_resource_klass = resource.resource_for(type_name)
-            linkage_object_klass = linkage_object_resource_klass._model_class
-
-            unless linkage_object_klass == relationship_klass || linkage_object_klass.in?(relationship_klass.subclasses)
-              fail JSONAPI::Exceptions::TypeMismatch.new(type_name)
-            end
-
-            relationship_ids = relationship_resource_klass.verify_keys(keys, @context)
-             polymorphic_results << { type: type, ids: relationship_ids }
-          end
-
-          add_result.call polymorphic_results
-        else
-          relationship_type = unformat_key(relationship.type).to_s
-
-          if links_object.length > 1 || !links_object.has_key?(relationship_type)
-            fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
-          end
+        if links_object.length > 1 || !links_object.has_key?(unformat_key(relationship.type).to_s)
+          fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type], error_object_overrides)
+        end
 
-          relationship_resource = Resource.resource_for(@resource_klass.module_path + relationship_type)
-          add_result.call relationship_resource.verify_keys(links_object[relationship_type], @context)
+        links_object.each_pair do |type, keys|
+          relationship_resource = Resource.resource_klass_for(resource_klass.module_path + unformat_key(type).to_s)
+          add_result.call relationship_resource.verify_keys(keys, @context)
         end
       end
     end
 
-    def unformat_value(attribute, value)
-      value_formatter = JSONAPI::ValueFormatter.value_formatter_for(@resource_klass._attribute_options(attribute)[:format])
+    def unformat_value(resource_klass, attribute, value)
+      value_formatter = JSONAPI::ValueFormatter.value_formatter_for(resource_klass._attribute_options(attribute)[:format])
       value_formatter.unformat(value)
     end
 
@@ -586,45 +587,45 @@ module JSONAPI
 
       params.each do |key, value|
         case key.to_s
-        when 'relationships'
-          value.keys.each do |links_key|
-            unless formatted_allowed_fields.include?(links_key.to_sym)
-              if JSONAPI.configuration.raise_if_parameters_not_allowed
-                fail JSONAPI::Exceptions::ParameterNotAllowed.new(links_key)
-              else
-                params_not_allowed.push(links_key)
-                value.delete links_key
+          when 'relationships'
+            value.keys.each do |links_key|
+              unless formatted_allowed_fields.include?(links_key.to_sym)
+                if JSONAPI.configuration.raise_if_parameters_not_allowed
+                  fail JSONAPI::Exceptions::ParameterNotAllowed.new(links_key, error_object_overrides)
+                else
+                  params_not_allowed.push(links_key)
+                  value.delete links_key
+                end
               end
             end
-          end
-        when 'attributes'
-          value.each do |attr_key, attr_value|
-            unless formatted_allowed_fields.include?(attr_key.to_sym)
+          when 'attributes'
+            value.each do |attr_key, _attr_value|
+              unless formatted_allowed_fields.include?(attr_key.to_sym)
+                if JSONAPI.configuration.raise_if_parameters_not_allowed
+                  fail JSONAPI::Exceptions::ParameterNotAllowed.new(attr_key, error_object_overrides)
+                else
+                  params_not_allowed.push(attr_key)
+                  value.delete attr_key
+                end
+              end
+            end
+          when 'type'
+          when 'id'
+            unless formatted_allowed_fields.include?(:id)
               if JSONAPI.configuration.raise_if_parameters_not_allowed
-                fail JSONAPI::Exceptions::ParameterNotAllowed.new(attr_key)
+                fail JSONAPI::Exceptions::ParameterNotAllowed.new(:id, error_object_overrides)
               else
-                params_not_allowed.push(attr_key)
-                value.delete attr_key
+                params_not_allowed.push(:id)
+                params.delete :id
               end
             end
-          end
-        when 'type'
-        when 'id'
-          unless formatted_allowed_fields.include?(:id)
+          else
             if JSONAPI.configuration.raise_if_parameters_not_allowed
-              fail JSONAPI::Exceptions::ParameterNotAllowed.new(:id)
+              fail JSONAPI::Exceptions::ParameterNotAllowed.new(key, error_object_overrides)
             else
-              params_not_allowed.push(:id)
-              params.delete :id
+              params_not_allowed.push(key)
+              params.delete key
             end
-          end
-        else
-          if JSONAPI.configuration.raise_if_parameters_not_allowed
-            fail JSONAPI::Exceptions::ParameterNotAllowed.new(key)
-          else
-            params_not_allowed.push(key)
-            params.delete key
-          end
         end
       end
 
@@ -638,23 +639,24 @@ module JSONAPI
       end
     end
 
-    def parse_add_relationship_operation(verified_params, relationship, parent_key)
+    def parse_add_relationship_operation(resource_klass, verified_params, relationship, parent_key)
       if relationship.is_a?(JSONAPI::Relationship::ToMany)
-        @operations.push JSONAPI::Operation.new(:create_to_many_relationships,
-          resource_klass,
-          context: @context,
-          resource_id: parent_key,
-          relationship_type: relationship.name,
-          data: verified_params[:to_many].values[0]
+        return JSONAPI::Operation.new(
+            :create_to_many_relationships,
+            resource_klass,
+            context: @context,
+            resource_id: parent_key,
+            relationship_type: relationship.name,
+            data: verified_params[:to_many].values[0]
         )
       end
     end
 
-    def parse_update_relationship_operation(verified_params, relationship, parent_key)
+    def parse_update_relationship_operation(resource_klass, verified_params, relationship, parent_key)
       options = {
-        context: @context,
-        resource_id: parent_key,
-        relationship_type: relationship.name
+          context: @context,
+          resource_id: parent_key,
+          relationship_type: relationship.name
       }
 
       if relationship.is_a?(JSONAPI::Relationship::ToOne)
@@ -675,70 +677,23 @@ module JSONAPI
         operation_type = :replace_to_many_relationships
       end
 
-      @operations.push JSONAPI::Operation.new(operation_type, resource_klass, options)
+      JSONAPI::Operation.new(operation_type, resource_klass, options)
     end
 
-    def parse_single_replace_operation(data, keys, id_key_presence_check_required: true)
-      fail JSONAPI::Exceptions::InvalidDataFormat unless data.respond_to?(:each_pair)
-
-      fail JSONAPI::Exceptions::MissingKey.new if data[:id].nil?
-
-      key = data[:id].to_s
-      if id_key_presence_check_required && !keys.include?(key)
-        fail JSONAPI::Exceptions::KeyNotIncludedInURL.new(key)
-      end
-
-      data.delete(:id) unless keys.include?(:id)
-
-      verify_type(data[:type])
-
-      @operations.push JSONAPI::Operation.new(:replace_fields,
-        @resource_klass,
-        context: @context,
-        resource_id: key,
-        data: parse_params(data, @resource_klass.updatable_fields(@context)),
-        fields: @fields,
-        include_directives: @include_directives
-      )
-    end
-
-    def parse_replace_operation(data, keys)
-      parse_single_replace_operation(data, [keys],
-                                     id_key_presence_check_required: keys.present? && !@resource_klass.singleton?)
-    rescue JSONAPI::Exceptions::Error => e
-      @errors.concat(e.errors)
-    end
-
-    def parse_remove_operation(params)
-      @operations.push JSONAPI::Operation.new(:remove_resource,
-        @resource_klass,
-        context: @context,
-        resource_id: @resource_klass.verify_key(params.require(:id), context))
-    rescue JSONAPI::Exceptions::Error => e
-      @errors.concat(e.errors)
-    end
-
-    def parse_remove_relationship_operation(params, relationship, parent_key)
+    def parse_remove_relationship_operation(resource_klass, params, relationship, parent_key)
       operation_base_args = [resource_klass].push(
-        context: @context,
-        resource_id: parent_key,
-        relationship_type: relationship.name
+          context: @context,
+          resource_id: parent_key,
+          relationship_type: relationship.name
       )
 
       if relationship.is_a?(JSONAPI::Relationship::ToMany)
         operation_args = operation_base_args.dup
         keys = params[:to_many].values[0]
         operation_args[1] = operation_args[1].merge(associated_keys: keys)
-        @operations.push JSONAPI::Operation.new(:remove_to_many_relationships, *operation_args)
+        JSONAPI::Operation.new(:remove_to_many_relationships, *operation_args)
       else
-        @operations.push JSONAPI::Operation.new(:remove_to_one_relationship, *operation_base_args)
-      end
-    end
-
-    def resolve_singleton_id(params)
-      if @resource_klass.singleton? && params[:id].nil?
-        key = @resource_klass.singleton_key(context)
-        params[:id] = key
+        JSONAPI::Operation.new(:remove_to_one_relationship, *operation_base_args)
       end
     end