Serialize nested includes (#152)

Author: jshow

README.md

@@ -207,7 +207,7 @@ end
 
 ### Compound Document
 
-Support for top-level included member through ` options[:include] `.
+Support for top-level and nested included associations through ` options[:include] `.
 
 ```ruby
 options = {}
@@ -217,7 +217,7 @@ options[:links] = {
   next: '...',
   prev: '...'
 }
-options[:include] = [:actors]
+options[:include] = [:actors, :'actors.agency', :'actors.agency.state']
 MovieSerializer.new([movie, movie], options).serialized_json
 ```
 

lib/fast_jsonapi/object_serializer.rb

@@ -77,17 +77,7 @@ def process_options(options)
 
       if options[:include].present?
         @includes = options[:include].delete_if(&:blank?).map(&:to_sym)
-        validate_includes!(@includes)
-      end
-    end
-
-    def validate_includes!(includes)
-      return if includes.blank?
-
-      existing_relationships = self.class.relationships_to_serialize.keys.to_set
-
-      unless existing_relationships.superset?(includes.to_set)
-        raise ArgumentError, "One of keys from #{includes} is not specified as a relationship on the serializer"
+        self.class.validate_includes!(@includes)
       end
     end
 
@@ -193,7 +183,11 @@ def has_one(relationship_name, options = {}, &block)
         add_relationship(name, hash)
       end
 
-      alias belongs_to has_one
+      def belongs_to(relationship_name, options = {}, &block)
+        name = relationship_name.to_sym
+        hash = create_relationship_hash(relationship_name, :belongs_to, options, block)
+        add_relationship(name, hash)
+      end
 
       def create_relationship_hash(base_key, relationship_type, options, block)
         name = base_key.to_sym
@@ -234,6 +228,20 @@ def fetch_polymorphic_option(options)
         return option if option.respond_to? :keys
         {}
       end
+
+      def validate_includes!(includes)
+        return if includes.blank?
+
+        includes.detect do |include_item|
+          klass = self
+          parse_include_item(include_item).each do |parsed_include|
+            relationship_to_include = klass.relationships_to_serialize[parsed_include]
+            raise ArgumentError, "#{parsed_include} is not specified as a relationship on #{klass.name}" unless relationship_to_include
+
+            klass = relationship_to_include[:serializer].to_s.constantize
+          end
+        end
+      end
     end
   end
 end

lib/fast_jsonapi/serialization_core.rb

@@ -113,22 +113,48 @@ def to_json(payload)
         FastJsonapi::MultiToJson.to_json(payload) if payload.present?
       end
 
-      # includes handler
+      def parse_include_item(include_item)
+        return [include_item.to_sym] unless include_item.to_s.include?('.')
+        include_item.to_s.split('.').map { |item| item.to_sym }
+      end
 
+      def remaining_items(items)
+        return unless items.size > 1
+
+        items_copy = items.dup
+        items_copy.delete_at(0)
+        [items_copy.join('.').to_sym]
+      end
+
+      # includes handler
       def get_included_records(record, includes_list, known_included_objects, params = {})
-        includes_list.each_with_object([]) do |item, included_records|
-          included_objects = fetch_associated_object(record, @relationships_to_serialize[item], params)
-          next if included_objects.blank?
-
-          record_type = @relationships_to_serialize[item][:record_type]
-          serializer = @relationships_to_serialize[item][:serializer].to_s.constantize
-          relationship_type = @relationships_to_serialize[item][:relationship_type]
-          included_objects = [included_objects] unless relationship_type == :has_many
-          included_objects.each do |inc_obj|
-            code = "#{record_type}_#{inc_obj.id}"
-            next if known_included_objects.key?(code)
-            known_included_objects[code] = inc_obj
-            included_records << serializer.record_hash(inc_obj, params)
+        return unless includes_list.present?
+
+        includes_list.sort.each_with_object([]) do |include_item, included_records|
+          items = parse_include_item(include_item)
+          items.each do |item|
+            next unless relationships_to_serialize && relationships_to_serialize[item]
+
+            record_type = @relationships_to_serialize[item][:record_type]
+            serializer = @relationships_to_serialize[item][:serializer].to_s.constantize
+            relationship_type = @relationships_to_serialize[item][:relationship_type]
+
+            included_objects = fetch_associated_object(record, @relationships_to_serialize[item], params)
+            included_objects = [included_objects] unless relationship_type == :has_many
+            next if included_objects.blank?
+
+            included_objects.each do |inc_obj|
+              if remaining_items(items)
+                serializer_records = serializer.get_included_records(inc_obj, remaining_items(items), known_included_objects)
+                included_records.concat(serializer_records) unless serializer_records.empty?
+              end
+
+              code = "#{record_type}_#{inc_obj.id}"
+              next if known_included_objects.key?(code)
+
+              known_included_objects[code] = inc_obj
+              included_records << serializer.record_hash(inc_obj, params)
+            end
           end
         end
       end
@@ -146,7 +172,11 @@ def fetch_id(record, relationship, params)
           return object.id
         end
 
-        record.public_send(relationship[:id_method_name])
+        if relationship[:relationship_type] == :has_one
+          record.public_send(relationship[:object_method_name])&.id
+        else
+          record.public_send(relationship[:id_method_name])
+        end
       end
     end
   end

spec/lib/object_serializer_inheritance_spec.rb

@@ -10,6 +10,9 @@
       CountrySerializer
       Employee
       EmployeeSerializer
+      Photo
+      PhotoSerializer
+      EmployeeAccount
     ]
     classes_to_remove.each do |klass_name|
       Object.send(:remove_const, klass_name) if Object.constants.include?(klass_name)
@@ -19,7 +22,14 @@
   class User
     attr_accessor :id, :first_name, :last_name
 
-    attr_accessor :address_ids, :country_id, :photo_id
+    attr_accessor :address_ids, :country_id
+
+    def photo
+      p = Photo.new
+      p.id = 1
+      p.user_id = id
+      p
+    end
   end
 
   class UserSerializer
@@ -36,6 +46,15 @@ class UserSerializer
     has_one :photo
   end
 
+  class Photo
+    attr_accessor :id, :user_id
+  end
+
+  class PhotoSerializer
+    include FastJsonapi::ObjectSerializer
+    attributes :id, :name
+  end
+
   class Country
     attr_accessor :id, :name
   end
@@ -45,9 +64,19 @@ class CountrySerializer
     attributes :name
   end
 
+  class EmployeeAccount
+    attr_accessor :id, :employee_id
+  end
+
   class Employee < User
     attr_accessor :id, :location, :compensation
-    attr_accessor :account_id
+
+    def account
+      a = EmployeeAccount.new
+      a.id = 1
+      a.employee_id = id
+      a
+    end
   end
 
   class EmployeeSerializer < UserSerializer

spec/lib/object_serializer_spec.rb

@@ -2,6 +2,7 @@
 
 describe FastJsonapi::ObjectSerializer do
   include_context 'movie class'
+  include_context 'group class'
 
   context 'when testing instance methods of object serializer' do
     it 'returns correct hash when serializable_hash is called' do
@@ -12,7 +13,7 @@
       serializable_hash = MovieSerializer.new([movie, movie], options).serializable_hash
 
       expect(serializable_hash[:data].length).to eq 2
-      expect(serializable_hash[:data][0][:relationships].length).to eq 3
+      expect(serializable_hash[:data][0][:relationships].length).to eq 4
       expect(serializable_hash[:data][0][:attributes].length).to eq 2
 
       expect(serializable_hash[:meta]).to be_instance_of(Hash)
@@ -126,6 +127,85 @@
     end
   end
 
+  context 'nested includes' do
+    it 'has_many to belongs_to: returns correct nested includes when serializable_hash is called' do
+      # 3 actors, 3 agencies
+      include_object_total = 6
+
+      options = {}
+      options[:include] = [:actors, :'actors.agency']
+      serializable_hash = MovieSerializer.new([movie], options).serializable_hash
+
+      expect(serializable_hash[:included]).to be_instance_of(Array)
+      expect(serializable_hash[:included].length).to eq include_object_total
+      (0..include_object_total-1).each do |include|
+        expect(serializable_hash[:included][include]).to be_instance_of(Hash)
+      end
+
+      options[:include] = [:'actors.agency']
+      serializable_hash = MovieSerializer.new([movie], options).serializable_hash
+
+      expect(serializable_hash[:included]).to be_instance_of(Array)
+      expect(serializable_hash[:included].length).to eq include_object_total
+      (0..include_object_total-1).each do |include|
+        expect(serializable_hash[:included][include]).to be_instance_of(Hash)
+      end
+    end
+
+    it '`has_many` to `belongs_to` to `belongs_to` - returns correct nested includes when serializable_hash is called' do
+      # 3 actors, 3 agencies, 1 state
+      include_object_total = 7
+
+      options = {}
+      options[:include] = [:actors, :'actors.agency', :'actors.agency.state']
+      serializable_hash = MovieSerializer.new([movie], options).serializable_hash
+
+      expect(serializable_hash[:included]).to be_instance_of(Array)
+      expect(serializable_hash[:included].length).to eq include_object_total
+
+      actors_serialized = serializable_hash[:included].find_all { |included| included[:type] == :actor }.map { |included| included[:id].to_i }
+      agencies_serialized = serializable_hash[:included].find_all { |included| included[:type] == :agency }.map { |included| included[:id].to_i }
+      states_serialized = serializable_hash[:included].find_all { |included| included[:type] == :state }.map { |included| included[:id].to_i }
+
+      movie.actors.each do |actor|
+        expect(actors_serialized).to include(actor.id)
+      end
+
+      agencies = movie.actors.map(&:agency).uniq
+      agencies.each do |agency|
+        expect(agencies_serialized).to include(agency.id)
+      end
+
+      states = agencies.map(&:state).uniq
+      states.each do |state|
+        expect(states_serialized).to include(state.id)
+      end
+    end
+    it 'has_many => has_one returns correct nested includes when serializable_hash is called' do
+      options = {}
+      options[:include] = [:movies, :'movies.advertising_campaign']
+      serializable_hash = MovieTypeSerializer.new([movie_type], options).serializable_hash
+
+      movies_serialized = serializable_hash[:included].find_all { |included| included[:type] == :movie }.map { |included| included[:id].to_i }
+      advertising_campaigns_serialized = serializable_hash[:included].find_all { |included| included[:type] == :advertising_campaign }.map { |included| included[:id].to_i }
+
+      movies = movie_type.movies
+      movies.each do |movie|
+        expect(movies_serialized).to include(movie.id)
+      end
+
+      advertising_campaigns = movies.map(&:advertising_campaign)
+      advertising_campaigns.each do |advertising_campaign|
+        expect(advertising_campaigns_serialized).to include(advertising_campaign.id)
+      end
+    end
+    it 'polymorphic' do
+      options = {}
+      options[:include] = [:groupees]
+      serializable_hash = GroupSerializer.new([group], options).serializable_hash
+    end
+  end
+
   context 'when testing included do block of object serializer' do
     it 'should set default_type based on serializer class name' do
       class BlahSerializer

spec/lib/object_serializer_struct_spec.rb

@@ -12,7 +12,7 @@
       serializable_hash = MovieSerializer.new([movie_struct, movie_struct], options).serializable_hash
 
       expect(serializable_hash[:data].length).to eq 2
-      expect(serializable_hash[:data][0][:relationships].length).to eq 3
+      expect(serializable_hash[:data][0][:relationships].length).to eq 4
       expect(serializable_hash[:data][0][:attributes].length).to eq 2
 
       expect(serializable_hash[:meta]).to be_instance_of(Hash)