Support for polymorphic associations

Author: vovimayhem

lib/fast_jsonapi/object_serializer.rb

@@ -147,7 +147,8 @@ def has_many(relationship_name, options = {})
           object_method_name: options[:object_method_name] || name,
           serializer: compute_serializer_name(serializer_key),
           relationship_type: :has_many,
-          cached: options[:cached] || false
+          cached: options[:cached] || false,
+          polymorphic: options.fetch(:polymorphic, false)
         }
         add_relationship(name, relationship)
       end
@@ -169,7 +170,8 @@ def belongs_to(relationship_name, options = {})
           object_method_name: options[:object_method_name] || name,
           serializer: compute_serializer_name(serializer_key),
           relationship_type: :belongs_to,
-          cached: options[:cached] || true
+          cached: options[:cached] || true,
+          polymorphic: options.fetch(:polymorphic, false)
         }
         add_relationship(name, relationship)
       end
@@ -191,7 +193,8 @@ def has_one(relationship_name, options = {})
           object_method_name: options[:object_method_name] || name,
           serializer: compute_serializer_name(serializer_key),
           relationship_type: :has_one,
-          cached: options[:cached] || false
+          cached: options[:cached] || false,
+          polymorphic: options.fetch(:polymorphic, false)
         }
         add_relationship(name, relationship)
       end

lib/fast_jsonapi/serialization_core.rb

@@ -26,6 +26,21 @@ def ids_hash(ids, record_type)
         id_hash(ids, record_type) # ids variable is just a single id here
       end
 
+      def id_hash_from_record(record)
+        { id: record.id.to_s, type: record.class.name.underscore.to_sym }
+      end
+
+      def ids_hash_from_record_and_relationship(record, relationship)
+        return ids_hash(record.send(relationship[:id_method_name]), relationship[:record_type]) \
+          unless relationship[:polymorphic]
+
+        object_method_name = relationship.fetch(:object_method_name, relationship[:name])
+        return unless associated_object = record.send(object_method_name)
+
+        return id_hash_from_record(associated_object) unless associated_object.respond_to? :map
+        associated_object.map { |object| id_hash_from_record(object) }
+      end
+
       def attributes_hash(record)
         attributes_hash = {}
         attributes_to_serialize.each do |key, method_name|
@@ -40,11 +55,9 @@ def relationships_hash(record, relationships = nil)
 
         relationships.each do |_k, relationship|
           name = relationship[:key]
-          id_method_name = relationship[:id_method_name]
-          record_type = relationship[:record_type]
           empty_case = relationship[:relationship_type] == :has_many ? [] : nil
           relationships_hash[name] = {
-            data: ids_hash(record.send(id_method_name), record_type) || empty_case
+            data: ids_hash_from_record_and_relationship(record, relationship) || empty_case
           }
         end
         relationships_hash

spec/lib/object_serializer_performance_spec.rb

@@ -3,6 +3,8 @@
 describe FastJsonapi::ObjectSerializer, performance: true do
   include_context 'movie class'
   include_context 'ams movie class'
+  include_context 'group class'
+  include_context 'ams group class'
 
   before(:all) { GC.disable }
   after(:all) { GC.enable }
@@ -107,4 +109,27 @@ def run_json_benchmark(message, movie_count, our_serializer, ams_serializer)
       end
     end
   end
+
+  context 'when comparing with AMS 0.10.x and with polymorphic has_many' do
+    [1, 25, 250, 1000].each do |group_count|
+      speed_factor = 5
+      it "should serialize #{group_count} records at least #{speed_factor} times faster than AMS" do
+        ams_groups = build_ams_groups(group_count)
+        groups = build_groups(group_count)
+        options = {}
+        our_serializer = GroupSerializer.new(groups, options)
+        ams_serializer = ActiveModelSerializers::SerializableResource.new(ams_groups)
+
+        message = "Serialize to JSON string #{group_count} with polymorphic has_many"
+        our_json, ams_json = run_json_benchmark(message, group_count, our_serializer, ams_serializer)
+
+        message = "Serialize to Ruby Hash #{group_count} with polymorphic has_many"
+        run_hash_benchmark(message, group_count, our_serializer, ams_serializer)
+
+        expect(our_json.length).to eq ams_json.length
+        expect { our_serializer.serialized_json }.to perform_faster_than { ams_serializer.to_json }.at_least(speed_factor).times
+        expect { our_serializer.serializable_hash }.to perform_faster_than { ams_serializer.as_json }.at_least(speed_factor).times
+      end
+    end
+  end
 end

spec/lib/serialization_core_spec.rb

@@ -2,6 +2,7 @@
 
 describe FastJsonapi::ObjectSerializer do
   include_context "movie class"
+  include_context 'group class'
 
   context 'when testing class methods of serialization core' do
     it 'returns correct hash when id_hash is called' do
@@ -16,6 +17,12 @@
       expect(result_hash).to be nil
     end
 
+    it 'returns the correct hash when ids_hash_from_record_and_relationship is called for a polymorphic association' do
+      relationship = { name: :groupees, relationship_type: :has_many, polymorphic: true }
+      results = GroupSerializer.send :ids_hash_from_record_and_relationship, group, relationship
+      expect(results).to include({ id: "1", type: :person }, { id: "2", type: :group })
+    end
+
     it 'returns correct hash when ids_hash is called' do
       inputs = [{ids: %w(1 2 3), record_type: :movie}, {ids: %w(x y z), record_type: 'person'}]
       inputs.each do |hash|
@@ -80,5 +87,4 @@
       expect(included_records.size).to eq 3
     end
   end
-
 end

spec/shared/contexts/ams_context.rb

@@ -37,6 +37,14 @@ class AMSMovieTypeSerializer < ActiveModel::Serializer
       type 'movie_type'
       attributes :name
     end
+
+    class AMSRole < ActiveModelSerializers::Model
+      attr_accessor :id, :name, :actor, :target
+    end
+
+    class AMSGroup < ActiveModelSerializers::Model
+      attr_accessor :id, :name
+    end
   end
 
   after(:context) do

spec/shared/contexts/ams_group_context.rb

@@ -0,0 +1,87 @@
+RSpec.shared_context 'ams group class' do
+  before(:context) do
+    # models
+    class AMSPerson < ActiveModelSerializers::Model
+      attr_accessor :id, :first_name, :last_name
+    end
+
+    class AMSGroup < ActiveModelSerializers::Model
+      attr_accessor :id, :name, :groupees
+    end
+
+    # serializers
+    class AMSPersonSerializer < ActiveModel::Serializer
+      type 'person'
+      attributes :first_name, :last_name
+    end
+
+    class AMSGroupSerializer < ActiveModel::Serializer
+      type 'group'
+      attributes :name
+      has_many :groupees
+    end
+  end
+
+  after(:context) do
+    classes_to_remove = %i[AMSPerson AMSGroup AMSPersonSerializer AMSGroupSerializer]
+    classes_to_remove.each do |klass_name|
+      Object.send(:remove_const, klass_name) if Object.constants.include?(klass_name)
+    end
+  end
+
+  let(:ams_groups) do
+    group_count = 0
+    person_count = 0
+    3.times.map do |i|
+      group = AMSGroup.new
+      group.id = group_count + 1
+      group.name = "Test Group #{group.id}"
+      group_count = group.id
+
+      person = AMSPerson.new
+      person.id = person_count + 1
+      person.last_name = "Last Name #{person.id}"
+      person.first_name = "First Name #{person.id}"
+      person_count = person.id
+
+      child_group = AMSGroup.new
+      child_group.id = group_count + 1
+      child_group.name = "Test Group #{child_group.id}"
+      group_count = child_group.id
+
+      group.groupees = [person, child_group]
+      group
+    end
+  end
+
+  let(:ams_person) do
+    ams_person = AMSPerson.new
+    ams_person.id = 3
+    ams_person
+  end
+
+  def build_ams_groups(count)
+    group_count = 0
+    person_count = 0
+    count.times.map do |i|
+      group = AMSGroup.new
+      group.id = group_count + 1
+      group.name = "Test Group #{group.id}"
+      group_count = group.id
+
+      person = AMSPerson.new
+      person.id = person_count + 1
+      person.last_name = "Last Name #{person.id}"
+      person.first_name = "First Name #{person.id}"
+      person_count = person.id
+
+      child_group = AMSGroup.new
+      child_group.id = group_count + 1
+      child_group.name = "Test Group #{child_group.id}"
+      group_count = child_group.id
+
+      group.groupees = [person, child_group]
+      group
+    end
+  end
+end

spec/shared/contexts/group_context.rb

@@ -0,0 +1,153 @@
+RSpec.shared_context 'group class' do
+
+  # Person, Group Classes and serializers
+  before(:context) do
+    # models
+    class Person
+      attr_accessor :id, :first_name, :last_name
+    end
+
+    class Group
+      attr_accessor :id, :name, :groupees # Let's assume groupees can be Person or Group objects
+    end
+
+    # serializers
+    class PersonSerializer
+      include FastJsonapi::ObjectSerializer
+      set_type :person
+      attributes :first_name, :last_name
+    end
+
+    class GroupSerializer
+      include FastJsonapi::ObjectSerializer
+      set_type :group
+      attributes :name
+      has_many :groupees, polymorphic: true
+    end
+  end
+
+
+  # Namespaced PersonSerializer
+  before(:context) do
+    # namespaced model stub
+    module AppName
+      module V1
+        class PersonSerializer
+          include FastJsonapi::ObjectSerializer
+          # to test if compute_serializer_name works
+        end
+      end
+    end
+  end
+
+
+  # Hyphenated keys for the serializer
+  before(:context) do
+    class HyphenPersonSerializer
+      include FastJsonapi::ObjectSerializer
+      use_hyphen
+      set_type :person
+      attributes :first_name, :last_name
+    end
+
+    class HyphenGroupSerializer
+      include FastJsonapi::ObjectSerializer
+      use_hyphen
+      set_type :group
+      attributes :name
+      has_many :groupees
+    end
+  end
+
+
+  # Movie and Actor struct
+  before(:context) do
+    PersonStruct = Struct.new(
+      :id, :first_name, :last_name
+    )
+
+    GroupStruct = Struct.new(
+      :id, :name, :groupees, :groupee_ids
+    )
+  end
+
+  after(:context) do
+    classes_to_remove = %i[
+      Person
+      PersonSerializer
+      Group
+      GroupSerializer
+      AppName::V1::PersonSerializer
+      PersonStruct
+      GroupStruct
+      HyphenPersonSerializer
+      HyphenGroupSerializer
+    ]
+    classes_to_remove.each do |klass_name|
+      Object.send(:remove_const, klass_name) if Object.constants.include?(klass_name)
+    end
+  end
+
+  let(:group_struct) do
+    group = GroupStruct.new
+    group[:id] = 1
+    group[:name] = 'Group 1'
+    group[:groupees] = []
+
+    person = PersonStruct.new
+    person[:id] = 1
+    person[:last_name] = "Last Name 1"
+    person[:first_name] = "First Name 1"
+
+    child_group = GroupStruct.new
+    child_group[:id] = 2
+    child_group[:name] = 'Group 2'
+
+    group.groupees = [person, child_group]
+    group
+  end
+
+  let(:group) do
+    group = Group.new
+    group.id = 1
+    group.name = 'Group 1'
+
+    person = Person.new
+    person.id = 1
+    person.last_name = "Last Name 1"
+    person.first_name = "First Name 1"
+
+    child_group = Group.new
+    child_group.id = 2
+    child_group.name = 'Group 2'
+
+    group.groupees = [person, child_group]
+    group
+  end
+
+  def build_groups(count)
+    group_count = 0
+    person_count = 0
+
+    count.times.map do |i|
+      group = Group.new
+      group.id = group_count + 1
+      group.name = "Test Group #{group.id}"
+      group_count = group.id
+
+      person = Person.new
+      person.id = person_count + 1
+      person.last_name = "Last Name #{person.id}"
+      person.first_name = "First Name #{person.id}"
+      person_count = person.id
+
+      child_group = Group.new
+      child_group.id = group_count + 1
+      child_group.name = "Test Group #{child_group.id}"
+      group_count = child_group.id
+
+      group.groupees = [person, child_group]
+      group
+    end
+  end
+end