Skip preloading of polymorphic relations, better handling of serialization with partially preloaded relations, resolves #889

Author: DavidMikeSimon

lib/jsonapi/cached_resource_fragment.rb

@@ -6,14 +6,14 @@ def self.fetch_fragments(resource_klass, serializer, context, cache_ids)
       context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
       context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
 
-      results = self.lookup(resource_klass, serializer_config_key, context_key, cache_ids)
+      results = self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
 
       miss_ids = results.select{|k,v| v.nil? }.keys
       unless miss_ids.empty?
         find_filters = {resource_klass._primary_key => miss_ids.uniq}
         find_options = {context: context}
         resource_klass.find(find_filters, find_options).each do |resource|
-          (id, cr) = write(resource_klass, resource, serializer, serializer_config_key, context_key)
+          (id, cr) = write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
           results[id] = cr
         end
       end
@@ -29,28 +29,16 @@ def self.fetch_fragments(resource_klass, serializer, context, cache_ids)
       return results
     end
 
-    def self.from_cache_value(resource_klass, h)
-      new(
-        resource_klass,
-        h.fetch(:id),
-        h.fetch(:type),
-        h.fetch(:fetchable),
-        h.fetch(:rels, nil),
-        h.fetch(:links, nil),
-        h.fetch(:attrs, nil),
-        h.fetch(:meta, nil)
-      )
-    end
-
-    attr_reader :resource_klass, :id, :type, :fetchable_fields, :relationships,
+    attr_reader :resource_klass, :id, :type, :context, :fetchable_fields, :relationships,
                 :links_json, :attributes_json, :meta_json,
                 :preloaded_fragments
 
-    def initialize(resource_klass, id, type, fetchable_fields, relationships,
+    def initialize(resource_klass, id, type, context, fetchable_fields, relationships,
                    links_json, attributes_json, meta_json)
       @resource_klass = resource_klass
       @id = id
       @type = type
+      @context = context
       @fetchable_fields = Set.new(fetchable_fields)
 
       # Relationships left uncompiled because we'll often want to insert included ids on retrieval
@@ -76,9 +64,14 @@ def to_cache_value
       }
     end
 
+    def to_real_resource
+      rs = Resource.resource_for(self.type).find_by_keys([self.id], {context: self.context})
+      return rs.try(:first)
+    end
+
     private
 
-    def self.lookup(resource_klass, serializer_config_key, context_key, cache_ids)
+    def self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
       type = resource_klass._type
 
       keys = cache_ids.map do |(id, cache_key)|
@@ -89,20 +82,35 @@ def self.lookup(resource_klass, serializer_config_key, context_key, cache_ids)
       return keys.each_with_object({}) do |key, hash|
         (_, id, _, _) = key
         if hits.has_key?(key)
-          hash[id] = self.from_cache_value(resource_klass, hits[key])
+          hash[id] = self.from_cache_value(resource_klass, context, hits[key])
         else
           hash[id] = nil
         end
       end
     end
 
-    def self.write(resource_klass, resource, serializer, serializer_config_key, context_key)
+    def self.from_cache_value(resource_klass, context, h)
+      new(
+        resource_klass,
+        h.fetch(:id),
+        h.fetch(:type),
+        context,
+        h.fetch(:fetchable),
+        h.fetch(:rels, nil),
+        h.fetch(:links, nil),
+        h.fetch(:attrs, nil),
+        h.fetch(:meta, nil)
+      )
+    end
+
+    def self.write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
       (id, cache_key) = resource.cache_id
       json = serializer.object_hash(resource) # No inclusions passed to object_hash
       cr = self.new(
         resource_klass,
         json['id'],
         json['type'],
+        context,
         resource.fetchable_fields,
         json['relationships'],
         json['links'],

lib/jsonapi/resource.rb

@@ -1133,8 +1133,15 @@ def preload_included_fragments(resources, records, serializer, options)
 
           # For each step on the path, figure out what the actual table name/alias in the join
           # will be, and include the primary key of that table in our list of fields to select
+          non_polymorphic = true
           path.each do |elem|
             relationship = klass._relationships[elem]
+            if relationship.polymorphic
+              # Can't preload through a polymorphic belongs_to association, ResourceSerializer
+              # will just have to bypass the cache and load the real Resource.
+              non_polymorphic = false
+              break
+            end
             assocs_path << relationship.relation_name(options).to_sym
             # Converts [:a, :b, :c] to Rails-style { :a => { :b => :c }}
             ar_hash = assocs_path.reverse.reduce{|memo, step| { step => memo } }
@@ -1148,6 +1155,7 @@ def preload_included_fragments(resources, records, serializer, options)
             klass = relationship.resource_klass
             pluck_attrs << table[klass._primary_key]
           end
+          next unless non_polymorphic
 
           # Pre-fill empty hashes for each resource up to the end of the path.
           # This allows us to later distinguish between a preload that returned nothing

lib/jsonapi/resource_serializer.rb

@@ -298,8 +298,11 @@ def cached_relationships_hash(source, include_directives)
       h = source.relationships || {}
       return h unless include_directives.has_key?(:include_related)
 
-      relationships = source.resource_klass._relationships.select{|k,v| source.fetchable_fields.include?(k) }
+      relationships = source.resource_klass._relationships.select do |k,v|
+        source.fetchable_fields.include?(k)
+      end
 
+      real_res = nil
       relationships.each do |rel_name, relationship|
         key = @key_formatter.format(rel_name)
         to_many = relationship.is_a? JSONAPI::Relationship::ToMany
@@ -310,7 +313,17 @@ def cached_relationships_hash(source, include_directives)
             h[key][:data] = to_many ? [] : nil
           end
 
-          source.preloaded_fragments[key].each do |id, f|
+          fragments = source.preloaded_fragments[key]
+          if fragments.nil?
+            # The resources we want were not preloaded, we'll have to bypass the cache.
+            # This happens when including through belongs_to polymorphic relationships
+            if real_res.nil?
+              real_res = source.to_real_resource
+            end
+            relation_resources = [real_res.public_send(rel_name)].flatten(1).compact
+            fragments = relation_resources.map{|r| [r.id, r]}.to_h
+          end
+          fragments.each do |id, f|
             add_resource(f, ia)
 
             if h.has_key?(key)

test/controllers/controller_test.rb

@@ -1923,6 +1923,36 @@ def test_tags_show_multiple_with_nonexistent_ids_at_the_beginning
   end
 end
 
+class PicturesControllerTest < ActionController::TestCase
+  def test_pictures_index
+    assert_cacheable_get :index
+    assert_response :success
+    assert_equal 3, json_response['data'].size
+  end
+
+  def test_pictures_index_with_polymorphic_include_one_level
+    assert_cacheable_get :index, params: {include: 'imageable'}
+    assert_response :success
+    assert_equal 3, json_response['data'].size
+    assert_equal 2, json_response['included'].size
+  end
+end
+
+class DocumentsControllerTest < ActionController::TestCase
+  def test_documents_index
+    assert_cacheable_get :index
+    assert_response :success
+    assert_equal 1, json_response['data'].size
+  end
+
+  def test_documents_index_with_polymorphic_include_one_level
+    assert_cacheable_get :index, params: {include: 'pictures'}
+    assert_response :success
+    assert_equal 1, json_response['data'].size
+    assert_equal 1, json_response['included'].size
+  end
+end
+
 class ExpenseEntriesControllerTest < ActionController::TestCase
   def setup
     JSONAPI.configuration.json_key_format = :camelized_key