jsonapi-resources 0.8.3 → 0.9.0.beta1

data/lib/jsonapi/error_codes.rb

@@ -7,7 +7,6 @@ module JSONAPI
   PARAM_NOT_ALLOWED = '105'
   PARAM_MISSING = '106'
   INVALID_FILTER_VALUE = '107'
-  COUNT_MISMATCH = '108'
   KEY_ORDER_MISMATCH = '109'
   KEY_NOT_INCLUDED_IN_URL = '110'
   INVALID_INCLUDE = '112'
@@ -20,6 +19,7 @@ module JSONAPI
   INVALID_FIELD_FORMAT = '119'
   INVALID_FILTERS_SYNTAX = '120'
   SAVE_FAILED = '121'
+  INVALID_DATA_FORMAT = '122'
   FORBIDDEN = '403'
   RECORD_NOT_FOUND = '404'
   NOT_ACCEPTABLE = '406'
@@ -36,7 +36,6 @@ module JSONAPI
       PARAM_NOT_ALLOWED => 'PARAM_NOT_ALLOWED',
       PARAM_MISSING => 'PARAM_MISSING',
       INVALID_FILTER_VALUE => 'INVALID_FILTER_VALUE',
-      COUNT_MISMATCH => 'COUNT_MISMATCH',
       KEY_ORDER_MISMATCH => 'KEY_ORDER_MISMATCH',
       KEY_NOT_INCLUDED_IN_URL => 'KEY_NOT_INCLUDED_IN_URL',
       INVALID_INCLUDE => 'INVALID_INCLUDE',
@@ -49,6 +48,7 @@ module JSONAPI
       INVALID_FIELD_FORMAT => 'INVALID_FIELD_FORMAT',
       INVALID_FILTERS_SYNTAX => 'INVALID_FILTERS_SYNTAX',
       SAVE_FAILED => 'SAVE_FAILED',
+      INVALID_DATA_FORMAT => 'INVALID_DATA_FORMAT',
       FORBIDDEN => 'FORBIDDEN',
       RECORD_NOT_FOUND => 'RECORD_NOT_FOUND',
       NOT_ACCEPTABLE => 'NOT_ACCEPTABLE',

data/lib/jsonapi/exceptions.rb

@@ -1,6 +1,12 @@
 module JSONAPI
   module Exceptions
-    class Error < RuntimeError; end
+    class Error < RuntimeError
+      def errors
+        # :nocov:
+        raise NotImplementedError, "Subclass of Error must implement errors method"
+        # :nocov:
+      end
+    end
 
     class InternalServerError < Error
       attr_accessor :exception
@@ -10,7 +16,7 @@ module JSONAPI
       end
 
       def errors
-        unless Rails.env.production?
+        if JSONAPI.configuration.include_backtraces_in_errors
           meta = Hash.new
           meta[:exception] = exception.message
           meta[:backtrace] = exception.backtrace
@@ -204,6 +210,17 @@ module JSONAPI
       end
     end
 
+    class InvalidDataFormat < Error
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::INVALID_DATA_FORMAT,
+                            status: :bad_request,
+                            title: I18n.translate('jsonapi-resources.exceptions.invalid_data_format.title',
+                                                  default: 'Invalid data format'),
+                            detail: I18n.translate('jsonapi-resources.exceptions.invalid_data_format.detail',
+                                                   default: 'Data must be a hash.'))]
+      end
+    end
+
     class InvalidLinksObject < Error
       def errors
         [JSONAPI::Error.new(code: JSONAPI::INVALID_LINKS_OBJECT,
@@ -320,17 +337,6 @@ module JSONAPI
       end
     end
 
-    class CountMismatch < Error
-      def errors
-        [JSONAPI::Error.new(code: JSONAPI::COUNT_MISMATCH,
-                            status: :bad_request,
-                            title: I18n.translate('jsonapi-resources.exceptions.count_mismatch.title',
-                                                  default: 'Count to key mismatch'),
-                            detail: I18n.translate('jsonapi-resources.exceptions.count_mismatch.detail',
-                                                   default: 'The resource collection does not contain the same number of objects as the number of keys.'))]
-      end
-    end
-
     class KeyNotIncludedInURL < Error
       attr_accessor :key
       def initialize(key)

data/lib/jsonapi/formatter.rb

@@ -13,6 +13,10 @@ module JSONAPI
         return FormatterWrapperCache.new(self)
       end
 
+      def uncached
+        return self
+      end
+
       def formatter_for(format)
         "#{format.to_s.camelize}Formatter".safe_constantize
       end
@@ -80,6 +84,10 @@ module JSONAPI
     def cached
       self
     end
+
+    def uncached
+      return @formatter_klass
+    end
   end
 end
 
@@ -113,7 +121,13 @@ end
 class DefaultValueFormatter < JSONAPI::ValueFormatter
   class << self
     def format(raw_value)
-      raw_value
+      case raw_value
+        when Date, Time, DateTime, ActiveSupport::TimeWithZone, BigDecimal
+          # Use the as_json methods added to various base classes by ActiveSupport
+          return raw_value.as_json
+        else
+          return raw_value
+      end
     end
   end
 end

data/lib/jsonapi/include_directives.rb

@@ -36,6 +36,10 @@ module JSONAPI
       get_includes(@include_directives_hash)
     end
 
+    def paths
+      delve_paths(get_includes(@include_directives_hash, false))
+    end
+
     private
 
     def get_related(current_path)
@@ -59,9 +63,12 @@ module JSONAPI
       current
     end
 
-    def get_includes(directive)
-      directive[:include_related].select { |k,v| v[:include_in_join] }.map do |name, directive|
-        sub = get_includes(directive)
+    def get_includes(directive, only_joined_includes = true)
+      ir = directive[:include_related]
+      ir = ir.select { |k,v| v[:include_in_join] } if only_joined_includes
+
+      ir.map do |name, sub_directive|
+        sub = get_includes(sub_directive, only_joined_includes)
         sub.any? ? { name => sub } : name
       end
     end
@@ -76,5 +83,18 @@ module JSONAPI
         related[:include] = true
       end
     end
+
+    def delve_paths(obj)
+      case obj
+        when Array
+          obj.map{|elem| delve_paths(elem)}.flatten(1)
+        when Hash
+          obj.map{|k,v| [[k]] + delve_paths(v).map{|path| [k] + path } }.flatten(1)
+        when Symbol, String
+          [[obj]]
+        else
+          raise "delve_paths cannot descend into #{obj.class.name}"
+      end
+    end
   end
 end

data/lib/jsonapi/processor.rb

@@ -11,9 +11,9 @@ module JSONAPI
                                        :replace_fields,
                                        :replace_to_one_relationship,
                                        :replace_polymorphic_to_one_relationship,
-                                       :create_to_many_relationship,
-                                       :replace_to_many_relationship,
-                                       :remove_to_many_relationship,
+                                       :create_to_many_relationships,
+                                       :replace_to_many_relationships,
+                                       :remove_to_many_relationships,
                                        :remove_to_one_relationship,
                                        :operation
 
@@ -71,12 +71,21 @@ module JSONAPI
       fields = params[:fields]
 
       verified_filters = resource_klass.verify_filters(filters, context)
-      resource_records = resource_klass.find(verified_filters,
-                                             context: context,
-                                             include_directives: include_directives,
-                                             sort_criteria: sort_criteria,
-                                             paginator: paginator,
-                                             fields: fields)
+      find_options = {
+        context: context,
+        include_directives: include_directives,
+        sort_criteria: sort_criteria,
+        paginator: paginator,
+        fields: fields
+      }
+
+      resource_records = if params[:cache_serializer]
+        resource_klass.find_serialized_with_caching(verified_filters,
+                                                    params[:cache_serializer],
+                                                    find_options)
+      else
+        resource_klass.find(verified_filters, find_options)
+      end
 
       page_options = {}
       if (JSONAPI.configuration.top_level_meta_include_record_count ||
@@ -104,10 +113,19 @@ module JSONAPI
 
       key = resource_klass.verify_key(id, context)
 
-      resource_record = resource_klass.find_by_key(key,
-                                                   context: context,
-                                                   include_directives: include_directives,
-                                                   fields: fields)
+      find_options = {
+        context: context,
+        include_directives: include_directives,
+        fields: fields
+      }
+
+      resource_record = if params[:cache_serializer]
+        resource_klass.find_by_key_serialized_with_caching(key,
+                                                           params[:cache_serializer],
+                                                           find_options)
+      else
+        resource_klass.find_by_key(key, find_options)
+      end
 
       return JSONAPI::ResourceOperationResult.new(:ok, resource_record)
     end
@@ -129,6 +147,7 @@ module JSONAPI
       relationship_type = params[:relationship_type].to_sym
       fields = params[:fields]
 
+      # TODO Should fetch related_resource from cache if caching enabled
       source_resource = source_klass.find_by_key(source_id, context: context, fields: fields)
 
       related_resource = source_resource.public_send(relationship_type)
@@ -141,20 +160,37 @@ module JSONAPI
       source_id = params[:source_id]
       relationship_type = params[:relationship_type]
       filters = params[:filters]
-      include_directives = params[:include_directives]
       sort_criteria = params[:sort_criteria]
       paginator = params[:paginator]
       fields = params[:fields]
+      include_directives = params[:include_directives]
 
       source_resource ||= source_klass.find_by_key(source_id, context: context, fields: fields)
 
-      related_resources = source_resource.public_send(relationship_type,
-                                                      context: context,
-                                                      filters: filters,
-                                                      include_directives: include_directives,
-                                                      sort_criteria: sort_criteria,
-                                                      paginator: paginator,
-                                                      fields: fields)
+      rel_opts = {
+        filters:  filters,
+        sort_criteria: sort_criteria,
+        paginator: paginator,
+        fields: fields,
+        context: context,
+        include_directives: include_directives
+      }
+
+      related_resources = nil
+      if params[:cache_serializer]
+        # TODO Could also avoid instantiating source_resource as actual Resource by
+        # allowing LinkBuilder to accept CachedResourceFragment as source in
+        # relationships_related_link
+        scope = source_resource.public_send(:"records_for_#{relationship_type}", rel_opts)
+        relationship = source_klass._relationship(relationship_type)
+        related_resources = relationship.resource_klass.find_serialized_with_caching(
+          scope,
+          params[:cache_serializer],
+          rel_opts
+        )
+      else
+        related_resources = source_resource.public_send(relationship_type, rel_opts)
+      end
 
       if ((JSONAPI.configuration.top_level_meta_include_record_count) ||
           (paginator && paginator.class.requires_record_count) ||
@@ -240,7 +276,7 @@ module JSONAPI
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
 
-    def create_to_many_relationship
+    def create_to_many_relationships
       resource_id = params[:resource_id]
       relationship_type = params[:relationship_type].to_sym
       data = params[:data]
@@ -251,7 +287,7 @@ module JSONAPI
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
 
-    def replace_to_many_relationship
+    def replace_to_many_relationships
       resource_id = params[:resource_id]
       relationship_type = params[:relationship_type].to_sym
       data = params.fetch(:data)
@@ -262,15 +298,21 @@ module JSONAPI
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
 
-    def remove_to_many_relationship
+    def remove_to_many_relationships
       resource_id = params[:resource_id]
       relationship_type = params[:relationship_type].to_sym
-      associated_key = params[:associated_key]
+      associated_keys = params[:associated_keys]
 
       resource = resource_klass.find_by_key(resource_id, context: context)
-      result = resource.remove_to_many_link(relationship_type, associated_key)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+      complete = true
+      associated_keys.each do |key|
+        result = resource.remove_to_many_link(relationship_type, key)
+        if complete && result != :completed
+          complete = false
+        end
+      end
+      return JSONAPI::OperationResult.new(complete ? :no_content : :accepted)
     end
 
     def remove_to_one_relationship

data/lib/jsonapi/relationship_builder.rb

@@ -53,10 +53,30 @@ module JSONAPI
       }
       .fetch(type)
 
-      define_on_resource associated_records_method_name do
+      define_on_resource associated_records_method_name do |options = {}|
         relationship = self.class._relationships[relationship_name]
         relation_name = relationship.relation_name(context: @context)
-        records_for(relation_name)
+        records = records_for(relation_name)
+
+        resource_klass = relationship.resource_klass
+
+        filters = options.fetch(:filters, {})
+        unless filters.nil? || filters.empty?
+          records = resource_klass.apply_filters(records, filters, options)
+        end
+
+        sort_criteria =  options.fetch(:sort_criteria, {})
+        unless sort_criteria.nil? || sort_criteria.empty?
+          order_options = relationship.resource_klass.construct_order_options(sort_criteria)
+          records = resource_klass.apply_sort(records, order_options, @context)
+        end
+
+        paginator = options[:paginator]
+        if paginator
+          records = resource_klass.apply_pagination(records, paginator, order_options)
+        end
+
+        records
       end
 
       associated_records_method_name
@@ -122,25 +142,7 @@ module JSONAPI
         relationship = self.class._relationships[relationship_name]
 
         resource_klass = relationship.resource_klass
-        records = public_send(associated_records_method_name)
-
-        filters = options.fetch(:filters, {})
-        unless filters.nil? || filters.empty?
-          records = resource_klass.apply_filters(records, filters, options)
-        end
-
-        records = resource_klass.apply_includes(records, options)
-
-        sort_criteria = options.fetch(:sort_criteria, {})
-        unless sort_criteria.nil? || sort_criteria.empty?
-          order_options = relationship.resource_klass.construct_order_options(sort_criteria)
-          records = resource_klass.apply_sort(records, order_options, @context)
-        end
-
-        paginator = options[:paginator]
-        if paginator
-          records = resource_klass.apply_pagination(records, paginator, order_options)
-        end
+        records = public_send(associated_records_method_name, options)
 
         return records.collect do |record|
           if relationship.polymorphic?

data/lib/jsonapi/request_parser.rb

@@ -122,7 +122,7 @@ module JSONAPI
       if data_required
         data = params.fetch(:data)
         object_params = { relationships: { format_key(relationship.name) => { data: data } } }
-        verified_params = parse_params(object_params, updatable_fields)
+        verified_params = parse_params(object_params, @resource_klass.updatable_fields(@context))
 
         parse_arguments = [verified_params, relationship, parent_key]
       else
@@ -201,7 +201,7 @@ module JSONAPI
       relationship = resource_klass._relationship(relationship_name)
       if relationship && format_key(relationship_name) == include_parts.first
         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_for(@resource_klass.module_path + relationship.class_name.to_s.underscore), include_parts.last.partition('.'))
         end
       else
         @errors.concat(JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type),
@@ -346,30 +346,19 @@ module JSONAPI
       )
     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(params)
+      fail JSONAPI::Exceptions::InvalidDataFormat unless params.respond_to?(:each_pair)
 
-    def parse_add_operation(data)
-      Array.wrap(data).each do |params|
-        verify_type(params[:type])
+      verify_type(params[:type])
 
-        data = parse_params(params, creatable_fields)
-        @operations.push JSONAPI::Operation.new(:create_resource,
-          @resource_klass,
-          context: @context,
-          data: data,
-          fields: @fields,
-          include_directives: @include_directives
-        )
-      end
+      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
@@ -567,20 +556,9 @@ module JSONAPI
       end
     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_relationship_operation(verified_params, relationship, parent_key)
       if relationship.is_a?(JSONAPI::Relationship::ToMany)
-        @operations.push JSONAPI::Operation.new(:create_to_many_relationship,
+        @operations.push JSONAPI::Operation.new(:create_to_many_relationships,
           resource_klass,
           context: @context,
           resource_id: parent_key,
@@ -612,13 +590,15 @@ module JSONAPI
           fail JSONAPI::Exceptions::ToManySetReplacementForbidden.new
         end
         options[:data] = verified_params[:to_many].values[0]
-        operation_type = :replace_to_many_relationship
+        operation_type = :replace_to_many_relationships
       end
 
       @operations.push 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
@@ -634,38 +614,23 @@ module JSONAPI
         @resource_klass,
         context: @context,
         resource_id: key,
-        data: parse_params(data, updatable_fields),
+        data: parse_params(data, @resource_klass.updatable_fields(@context)),
         fields: @fields,
         include_directives: @include_directives
       )
     end
 
     def parse_replace_operation(data, keys)
-      if data.is_a?(Array)
-        fail JSONAPI::Exceptions::CountMismatch if keys.count != data.count
-
-        data.each do |object_params|
-          parse_single_replace_operation(object_params, keys)
-        end
-      else
-        parse_single_replace_operation(data, [keys],
-                                       id_key_presence_check_required: keys.present?)
-      end
-
+      parse_single_replace_operation(data, [keys], id_key_presence_check_required: keys.present?)
     rescue JSONAPI::Exceptions::Error => e
       @errors.concat(e.errors)
     end
 
     def parse_remove_operation(params)
-      keys = parse_key_array(params.require(:id))
-
-      keys.each do |key|
-        @operations.push JSONAPI::Operation.new(:remove_resource,
-          @resource_klass,
-          context: @context,
-          resource_id: key
-        )
-      end
+      @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
@@ -678,25 +643,15 @@ module JSONAPI
       )
 
       if relationship.is_a?(JSONAPI::Relationship::ToMany)
+        operation_args = operation_base_args.dup
         keys = params[:to_many].values[0]
-        keys.each do |key|
-          operation_args = operation_base_args.dup
-          operation_args[1] = operation_args[1].merge(associated_key: key)
-          @operations.push JSONAPI::Operation.new(:remove_to_many_relationship,
-            *operation_args
-          )
-        end
+        operation_args[1] = operation_args[1].merge(associated_keys: keys)
+        @operations.push JSONAPI::Operation.new(:remove_to_many_relationships, *operation_args)
       else
-        @operations.push JSONAPI::Operation.new(:remove_to_one_relationship,
-          *operation_base_args
-        )
+        @operations.push JSONAPI::Operation.new(:remove_to_one_relationship, *operation_base_args)
       end
     end
 
-    def parse_key_array(raw)
-      @resource_klass.verify_keys(raw.split(/,/), context)
-    end
-
     def format_key(key)
       @key_formatter.format(key)
     end