Add polymorphic associations

Author: Lee Richmond

lib/jsonapi_compliable/adapters/active_record_sideloading.rb

@@ -65,6 +65,55 @@ def has_one(association_name, scope:, resource:, foreign_key:, primary_key: :id,
           instance_eval(&blk) if blk
         end
       end
+
+      def has_and_belongs_to_many(association_name, scope:, resource:, foreign_key:, primary_key: :id, as: nil, &blk)
+        through = foreign_key.keys.first
+        fk      = foreign_key.values.first
+        _scope  = scope
+
+        allow_sideload association_name, resource: resource do
+          scope do |parents|
+            _scope.call.joins(through).where(through => { fk => parents.map { |p| p.send(primary_key) } })
+          end
+
+          assign do |parents, children|
+            parents.each do |parent|
+              parent.association(association_name).loaded!
+              relevant_children = children.select { |c| c.send(through).any? { |ct| ct.send(fk) == parent.send(primary_key) } }
+              relevant_children.each do |c|
+                parent.association(association_name).add_to_target(c, :skip_callbacks)
+              end
+            end
+          end
+
+          instance_eval(&blk) if blk
+        end
+      end
+
+      def polymorphic_belongs_to(association_name, group_by:, groups:, &blk)
+        allow_sideload association_name, polymorphic: true do
+          group_by(&group_by)
+
+          groups.each_pair do |type, config|
+            primary_key = config[:primary_key] || :id
+            foreign_key = config[:foreign_key]
+
+            allow_sideload type, resource: config[:resource] do
+              scope do |parents|
+                config[:scope].call.where(primary_key => parents.map { |p| p.send(foreign_key) })
+              end
+
+              assign do |parents, children|
+                parents.each do |parent|
+                  parent.send(:"#{association_name}=", children.find { |c| c.send(primary_key) == parent.dwelling_id })
+                end
+              end
+            end
+          end
+        end
+
+        instance_eval(&blk) if blk
+      end
     end
   end
 end

lib/jsonapi_compliable/scope.rb

@@ -39,11 +39,8 @@ def query_hash
     def sideload(results, includes)
       includes.each_pair do |name, nested|
         if @resource.allowed_sideloads.has_key?(name)
-          sideload         = @resource.sideload(name)
-          sideload_scope   = sideload.scope_proc.call(results)
-          sideload_scope   = Scope.new(sideload_scope, sideload.resource, @query, namespace: sideload.name)
-          sideload_results = sideload_scope.resolve
-          sideload.assign_proc.call(results, sideload_results)
+          sideload = @resource.sideload(name)
+          sideload.resolve(results, @query)
         end
       end
     end

lib/jsonapi_compliable/sideload.rb

@@ -1,15 +1,27 @@
 module JsonapiCompliable
   class Sideload
-    attr_reader :name, :resource, :sideloads, :scope_proc, :assign_proc
+    attr_reader :name,
+      :resource,
+      :polymorphic,
+      :sideloads,
+      :scope_proc,
+      :assign_proc,
+      :grouper
 
     def initialize(name, opts)
-      @name = name
-      @resource = (opts[:resource] || Class.new(Resource)).new
-      @sideloads = {}
+      @name               = name
+      @resource           = (opts[:resource] || Class.new(Resource)).new
+      @sideloads          = {}
+      @polymorphic        = !!opts[:polymorphic]
+      @polymorphic_groups = {} if polymorphic?
 
       extend @resource.adapter.sideloading_module
     end
 
+    def polymorphic?
+      @polymorphic == true
+    end
+
     def scope(&blk)
       @scope_proc = blk
     end
@@ -18,10 +30,29 @@ def assign(&blk)
       @assign_proc = blk
     end
 
+    def group_by(&grouper)
+      @grouper = grouper
+    end
+
+    def resolve(parents, query, namespace = nil)
+      namespace ||= name
+
+      if polymorphic?
+        resolve_polymorphic(parents, query)
+      else
+        resolve_basic(parents, query, namespace)
+      end
+    end
+
     def allow_sideload(name, opts = {}, &blk)
       sideload = Sideload.new(name, opts)
       sideload.instance_eval(&blk) if blk
-      @sideloads[name] = sideload
+
+      if polymorphic?
+        @polymorphic_groups[name] = sideload
+      else
+        @sideloads[name] = sideload
+      end
     end
 
     def sideload(name)
@@ -35,5 +66,21 @@ def to_hash
         end
       end
     end
+
+    private
+
+    def resolve_polymorphic(parents, query)
+      parents.group_by(&@grouper).each_pair do |group_type, group_members|
+        sideload_for_group = @polymorphic_groups[group_type]
+        sideload_for_group.resolve(group_members, query, name)
+      end
+    end
+
+    def resolve_basic(parents, query, namespace)
+      sideload_scope   = scope_proc.call(parents)
+      sideload_scope   = Scope.new(sideload_scope, resource, query, namespace: namespace)
+      sideload_results = sideload_scope.resolve
+      assign_proc.call(parents, sideload_results)
+    end
   end
 end

spec/integration/resources_spec.rb

@@ -8,6 +8,11 @@ class BookResource < JsonapiCompliable::Resource
       allow_filter :id
     end
 
+    class DwellingResource < JsonapiCompliable::Resource
+      type :dwellings
+      use_adapter JsonapiCompliable::Adapters::ActiveRecord
+    end
+
     class StateResource < JsonapiCompliable::Resource
       type :states
       use_adapter JsonapiCompliable::Adapters::ActiveRecord
@@ -18,6 +23,12 @@ class BioResource < JsonapiCompliable::Resource
       use_adapter JsonapiCompliable::Adapters::ActiveRecord
     end
 
+    class HobbyResource < JsonapiCompliable::Resource
+      type :hobbies
+      allow_filter :id
+      use_adapter JsonapiCompliable::Adapters::ActiveRecord
+    end
+
     class AuthorResource < JsonapiCompliable::Resource
       type :authors
       use_adapter JsonapiCompliable::Adapters::ActiveRecord
@@ -38,6 +49,26 @@ class AuthorResource < JsonapiCompliable::Resource
         foreign_key: :author_id,
         scope: -> { Bio.all },
         resource: BioResource
+
+      has_and_belongs_to_many :hobbies,
+        resource: HobbyResource,
+        scope: -> { Hobby.all },
+        foreign_key: { author_hobbies: :author_id }
+
+      polymorphic_belongs_to :dwelling,
+        group_by: proc { |author| author.dwelling_type },
+        groups: {
+          'House' => {
+            foreign_key: :dwelling_id,
+            resource: DwellingResource,
+            scope: -> { House.all }
+          },
+          'Condo' => {
+            foreign_key: :dwelling_id,
+            resource: DwellingResource,
+            scope: -> { Condo.all }
+          }
+        }
     end
   end
 
@@ -49,15 +80,19 @@ def index
     end
   end
 
-  let!(:author1) { Author.create!(first_name: 'Stephen', state: state) }
-  let!(:author2) { Author.create!(first_name: 'George') }
+  let!(:author1) { Author.create!(first_name: 'Stephen', dwelling: house, state: state) }
+  let!(:author2) { Author.create!(first_name: 'George', dwelling: condo) }
   let!(:book1)   { Book.create!(author: author1, title: 'The Shining') }
   let!(:book2)   { Book.create!(author: author1, title: 'The Stand') }
   let!(:state)   { State.create!(name: 'Maine') }
   let!(:bio)     { Bio.create!(author: author1, picture: 'imgur', description: 'author bio') }
+  let!(:hobby1)  { Hobby.create!(name: 'Fishing', authors: [author1]) }
+  let!(:hobby2)  { Hobby.create!(name: 'Woodworking', authors: [author1]) }
+  let(:house)    { House.new(name: 'Cozy') }
+  let(:condo)    { Condo.new(name: 'Modern') }
 
-  def book_ids
-    json_includes('books').map { |b| b['id'].to_i }
+  def ids_for(type)
+    json_includes(type).map { |b| b['id'].to_i }
   end
 
   it 'allows basic sorting' do
@@ -84,17 +119,17 @@ def book_ids
     # TODO: may want to blow up here, only for index action
     it 'allows pagination of sideloaded resource' do
       get :index, params: { include: 'books', page: { books: { size: 1, number: 2 } } }
-      expect(book_ids).to eq([book2.id])
+      expect(ids_for('books')).to eq([book2.id])
     end
 
     it 'allows sorting of sideloaded resource' do
       get :index, params: { include: 'books', sort: '-books.title' }
-      expect(book_ids).to eq([book2.id, book1.id])
+      expect(ids_for('books')).to eq([book2.id, book1.id])
     end
 
     it 'allows filtering of sideloaded resource' do
       get :index, params: { include: 'books', filter: { books: { id: book2.id } } }
-      expect(book_ids).to eq([book2.id])
+      expect(ids_for('books')).to eq([book2.id])
     end
 
     it 'allows extra fields for sideloaded resource' do
@@ -150,6 +185,66 @@ def book_ids
     end
   end
 
+  context 'sideloading has_and_belongs_to_many' do
+    it 'allows sorting of sideloaded resource' do
+      get :index, params: { include: 'hobbies', sort: '-hobbies.name' }
+      expect(ids_for('hobbies')).to eq([hobby2.id, hobby1.id])
+    end
+
+    it 'allows filtering of sideloaded resource' do
+      get :index, params: { include: 'hobbies', filter: { hobbies: { id: hobby2.id } } }
+      expect(ids_for('hobbies')).to eq([hobby2.id])
+    end
+
+    it 'allows extra fields for sideloaded resource' do
+      get :index, params: { include: 'hobbies', extra_fields: { hobbies: 'reason' } }
+      hobby = json_includes('hobbies')[0]
+      expect(hobby['name']).to be_present
+      expect(hobby['description']).to be_present
+      expect(hobby['reason']).to eq('hobby reason')
+    end
+
+    it 'allows sparse fieldsets for the sideloaded resource' do
+      get :index, params: { include: 'hobbies', fields: { hobbies: 'name' } }
+      hobby = json_includes('hobbies')[0]
+      expect(hobby['name']).to be_present
+      expect(hobby).to_not have_key('description')
+      expect(hobby).to_not have_key('reason')
+    end
+  end
+
+  context 'sideloading polymorphic belongs_to' do
+    it 'allows extra fields for the sideloaded resource' do
+      get :index, params: {
+        include: 'dwelling',
+        extra_fields: { houses: 'house_price', condos: 'condo_price' }
+      }
+      house = json_includes('houses')[0]
+      expect(house['name']).to be_present
+      expect(house['house_description']).to be_present
+      expect(house['house_price']).to eq(1_000_000)
+      condo = json_includes('condos')[0]
+      expect(condo['name']).to be_present
+      expect(condo['condo_description']).to be_present
+      expect(condo['condo_price']).to eq(500_000)
+    end
+
+    it 'allows sparse fieldsets for the sideloaded resource' do
+      get :index, params: {
+        include: 'dwelling',
+        fields: { houses: 'name', condos: 'condo_description' }
+      }
+      house = json_includes('houses')[0]
+      expect(house['name']).to be_present
+      expect(house).to_not have_key('house_description')
+      expect(house).to_not have_key('house_price')
+      condo = json_includes('condos')[0]
+      expect(condo['condo_description']).to be_present
+      expect(condo).to_not have_key('name')
+      expect(condo).to_not have_key('condo_price')
+    end
+  end
+
   context 'when overriding the resource' do
     before do
       controller.class_eval do

spec/sideload_spec.rb

@@ -37,7 +37,6 @@ def foo
   end
 
   describe '#allow_sideload' do
-
     it 'assigns a new sideload' do
       instance.allow_sideload :bar
       expect(instance.sideloads[:bar]).to be_a(JsonapiCompliable::Sideload)
@@ -50,6 +49,23 @@ def foo
       expect(instance.sideloads[:bar].instance_variable_get(:@foo))
         .to eq('foo')
     end
+
+    context 'when polymorphic' do
+      before do
+        opts[:polymorphic] = true
+      end
+
+      it 'adds a new sideload to polymorphic groups' do
+        instance.allow_sideload :bar
+        groups = instance.instance_variable_get(:@polymorphic_groups)
+        expect(groups[:bar]).to be_a(JsonapiCompliable::Sideload)
+      end
+
+      it 'does not add to sideloads' do
+        instance.allow_sideload :bar
+        expect(instance.sideloads).to be_empty
+      end
+    end
   end
 
   describe '#to_hash' do