Ensure nested sideloads work, add multisort

Author: Lee Richmond

lib/jsonapi_compliable/base.rb

@@ -48,7 +48,7 @@ def render_jsonapi(scope, opts = {})
       resolved = scoped.respond_to?(:resolve) ? scoped.resolve : scoped
 
       options = default_jsonapi_render_options
-      options[:include] = forced_includes || Util::IncludeParams.scrub(query_hash[:include], resource.allowed_sideloads)
+      options[:include] = forced_includes || query_hash[:include]
       options[:jsonapi] = resolved
       options[:fields] = query_hash[:fields]
       options[:meta] ||= {}

lib/jsonapi_compliable/query.rb

@@ -21,10 +21,23 @@ def initialize(resource, params)
       @params = params
     end
 
+    def include_directive
+      @include_directive ||= JSONAPI::IncludeDirective.new(params[:include])
+    end
+
+    def include_hash
+      @include_hash ||= include_directive.to_hash
+    end
+
+    def all_requested_association_names
+      @all_requested_association_names ||= Util::Hash.keys(include_hash)
+    end
+
     def to_hash
       hash = { resource.type => self.class.default_hash }
-      resource.association_names.each do |name|
-        hash[name] = self.class.default_hash.except(:include)
+
+      all_requested_association_names.each do |name|
+        hash[name] = self.class.default_hash
       end
 
       fields = parse_fields({}, :fields)
@@ -37,7 +50,7 @@ def to_hash
       parse_filter(hash)
       parse_sort(hash)
       parse_pagination(hash)
-      parse_include(hash)
+      parse_include(hash, include_hash)
       parse_stats(hash)
 
       hash
@@ -55,8 +68,13 @@ def association?(name)
       resource.association_names.include?(name)
     end
 
-    def parse_include(hash)
-      hash[resource.type][:include] = JSONAPI::IncludeDirective.new(params[:include] || {}).to_hash
+    def parse_include(memo, incl_hash, namespace = nil)
+      namespace ||= resource.type
+
+      memo[namespace][:include] = incl_hash
+      incl_hash.each_pair do |key, sub_hash|
+        memo[key][:include] = parse_include(memo, sub_hash, key)
+      end
     end
 
     def parse_stats(hash)

lib/jsonapi_compliable/scoping/sort.rb

@@ -1,27 +1,29 @@
-# TODO: multisort
-
 module JsonapiCompliable
   class Scoping::Sort < Scoping::Base
     def custom_scope
       resource.sorting
     end
 
     def apply_standard_scope
-      resource.adapter.order(@scope, attribute, direction)
+      each_sort do |attribute, direction|
+        @scope = resource.adapter.order(@scope, attribute, direction)
+      end
+      @scope
     end
 
     def apply_custom_scope
-      custom_scope.call(@scope, attribute, direction)
+      each_sort do |attribute, direction|
+        @scope = custom_scope.call(@scope, attribute, direction)
+      end
+      @scope
     end
 
     private
 
-    def attribute
-      sort_param[0].keys.first
-    end
-
-    def direction
-      sort_param[0].values.first
+    def each_sort
+      sort_param.each do |sort_hash|
+        yield sort_hash.keys.first, sort_hash.values.first
+      end
     end
 
     def sort_param

lib/jsonapi_compliable/sideload.rb

@@ -59,10 +59,17 @@ def sideload(name)
       @sideloads[name]
     end
 
+    # Grab from nested sideloads, AND resource, recursively
     def to_hash
       { name => {} }.tap do |hash|
         @sideloads.each_pair do |key, sideload|
           hash[name][key] = sideload.to_hash[key]
+
+          if sideloading = sideload.resource.sideloading
+            sideloading.sideloads.each_pair do |k, s|
+              hash[name][k] = s.to_hash[k]
+            end
+          end
         end
       end
     end

spec/integration/resources_spec.rb renamed to spec/integration/active_record_spec.rb

@@ -2,10 +2,20 @@
 
 RSpec.describe 'integrated resources and adapters', type: :controller do
   module Integration
+    class GenreResource < JsonapiCompliable::Resource
+      type :genres
+      use_adapter JsonapiCompliable::Adapters::ActiveRecord
+    end
+
     class BookResource < JsonapiCompliable::Resource
       type :books
       use_adapter JsonapiCompliable::Adapters::ActiveRecord
       allow_filter :id
+
+      belongs_to :genre,
+        scope: -> { Genre.all },
+        foreign_key: :genre_id,
+        resource: GenreResource
     end
 
     class DwellingResource < JsonapiCompliable::Resource
@@ -82,14 +92,15 @@ def index
 
   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!(:book1)   { Book.create!(author: author1, genre: genre, title: 'The Shining') }
+  let!(:book2)   { Book.create!(author: author1, genre: genre, 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') }
+  let(:genre)    { Genre.create!(name: 'Horror') }
 
   def ids_for(type)
     json_includes(type).map { |b| b['id'].to_i }
@@ -115,6 +126,11 @@ def ids_for(type)
     expect(json_included_types).to match_array(%w(books))
   end
 
+  it 'allows nested sideloading' do
+    get :index, params: { include: 'books.genre' }
+    expect(json_included_types).to match_array(%w(books genres))
+  end
+
   context 'sideloading has_many' do
     # TODO: may want to blow up here, only for index action
     it 'allows pagination of sideloaded resource' do

spec/query_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe JsonapiCompliable::Query do
   let(:resource) { double(type: :authors, association_names: [:books]).as_null_object }
-  let(:params)   { {} }
+  let(:params)   { { include: 'books' } }
   let(:instance) { described_class.new(resource, params) }
 
   describe '#to_hash' do
@@ -13,10 +13,20 @@
         expect(subject[:authors][:filter]).to eq({})
       end
 
-      it 'defaults associations' do
+      it 'does not default associations' do
         expect(subject[:books][:filter]).to eq({})
       end
 
+      context 'when association is not requested' do
+        before do
+          params.delete(:include)
+        end
+
+        it 'does not default the association query' do
+          expect(subject).to_not have_key(:books)
+        end
+      end
+
       context 'when filter param present' do
         before do
           params[:filter] = { id: 1, books: { title: 'foo' } }
@@ -156,24 +166,32 @@
     end
 
     describe 'include' do
-      it 'defaults main entity' do
-        expect(subject[:authors][:include]).to eq({})
+      it 'sets main entity' do
+        expect(subject[:authors][:include]).to eq(books: {})
       end
 
-      it 'does NOT default associations' do
-        expect(subject[:books]).to_not have_key(:include)
+      it 'sets associations' do
+        expect(subject[:books][:include]).to eq({})
       end
 
       context 'when include param present' do
         before do
-          params[:include] = 'books.genre,state'
+          params[:include] = 'books.genre.owner,state'
         end
 
         it 'transforms to hash' do
           expect(subject[:authors][:include]).to eq({
-            books: { genre: {} },
+            books: { genre: { owner: {} } },
             state: {}
           })
+          expect(subject[:books][:include]).to eq({
+            genre: { owner: {} }
+          })
+          expect(subject[:genre][:include]).to eq({
+            owner: {}
+          })
+          expect(subject[:owner][:include]).to eq({})
+          expect(subject[:state][:include]).to eq({})
         end
       end
     end

spec/resource_spec.rb

@@ -128,12 +128,18 @@
   end
 
   describe '#association_names' do
-    it 'collects all sideloads' do
+    it 'collects nested + resource sideloads' do
       klass.allow_sideload :books do
-        allow_sideload :genre
+        genre_resource = Class.new(JsonapiCompliable::Resource) do
+          allow_sideload :from_genre_resource do
+            allow_sideload :nested_from_genre_resource
+          end
+        end
+        allow_sideload :genre, resource: genre_resource
       end
-      klass.allow_sideload :state
-      expect(instance.association_names).to eq([:books, :genre, :state])
+      klass.allow_sideload :state, polymorphic: true
+      expect(instance.association_names)
+        .to match_array([:books, :genre, :state, :from_genre_resource, :nested_from_genre_resource])
     end
 
     context 'when no whitelist' do

spec/sorting_spec.rb

@@ -12,8 +12,8 @@ def index
   end
 
   before do
-    Author.create!(first_name: 'Stephen')
-    Author.create!(first_name: 'Philip')
+    Author.create!(first_name: 'Stephen', last_name: 'King')
+    Author.create!(first_name: 'Philip', last_name: 'Dick')
   end
 
   it 'defaults sort to resource default_sort' do
@@ -43,6 +43,26 @@ def index
       it { is_expected.to eq(%w(Stephen Philip)) }
     end
 
+    context 'when prefixed with type' do
+      let(:sort_param) { 'authors.first_name' }
+
+      it { is_expected.to eq(%w(Philip Stephen)) }
+    end
+
+    context 'when passed multisort' do
+      let(:sort_param) { 'first_name,last_name' }
+
+      before do
+        Author.create(first_name: 'Stephen', last_name: 'Adams')
+      end
+
+      it 'sorts correctly' do
+        get :index, params: { sort: sort_param }
+        last_names = json_items.map { |n| n['last_name'] }
+        expect(last_names).to eq(%w(Dick Adams King))
+      end
+    end
+
     context 'when given a custom sort function' do
       let(:sort_param) { 'first_name' }