Add option linkage_always option to sideloads, add tests

Author: jkeen

lib/graphiti/sideload.rb

@@ -42,6 +42,14 @@ def initialize(name, opts)
       @group_name            = opts[:group_name]
       @polymorphic_child     = opts[:polymorphic_child]
       @parent                = opts[:parent]
+
+      @linkage_always        = if opts[:linkage_always].nil?
+                                 # option not provided, use default
+                                 type == :belongs_to
+                               else
+                                 !!opts[:linkage_always]
+                               end
+
       if polymorphic_child?
         parent.resource.polymorphic << resource_class
       end
@@ -112,6 +120,10 @@ def polymorphic_has_many?
       !!@polymorphic_as
     end
 
+    def linkage_always?
+      !!@linkage_always
+    end
+
     def link?
       return true if link_proc
 

lib/graphiti/util/serializer_relationships.rb

@@ -54,7 +54,7 @@ def block
 
           # include relationship links for belongs_to relationships
           # https://github.com/graphiti-api/graphiti/issues/167
-          linkage always: true if sideload_ref.type == :belongs_to
+          linkage always: sideload_ref.linkage_always?
 
           if link_ref
             if @proxy.query.links?

spec/sideloading_spec.rb

@@ -215,46 +215,128 @@ class PositionSideload < ::Graphiti::Sideload::HasMany
   end
 
   describe "has_many macro" do
-    before do
-      resource.class_eval do
-        has_many :positions do
-          scope do |employee_ids|
-            {
-              type: :positions,
-              conditions: {employee_id: employee_ids},
-            }
+    context "with includes" do
+      before do
+        resource.class_eval do
+          has_many :positions do
+            scope do |employee_ids|
+              {
+                type: :positions,
+                conditions: {employee_id: employee_ids},
+              }
+            end
           end
         end
+        params[:include] = "positions"
       end
-      params[:include] = "positions"
-    end
 
-    it "works" do
-      render
-      expect(included("positions").map(&:id)).to eq([1, 2])
+      it "works" do
+        render
+        expect(included("positions").map(&:id)).to eq([1, 2])
+      end
+
+      it "includes relationship linkage" do
+        render
+        jsonapi_data.each do |record|
+          data = record.relationships["positions"]["data"]
+          expect(data.pluck(:type).uniq).to match_array(["positions"])
+          expect(data.pluck(:id).uniq).to match_array(["1", "2"])
+        end
+      end
+
+      context "when custom foreign key given" do
+        before do
+          PORO::DB.data[:positions][0] = {id: 1, e_id: 1}
+          PORO::DB.data[:positions][1] = {id: 2, e_id: 1}
+
+          resource.class_eval do
+            has_many :positions, foreign_key: :e_id do
+              scope do |employee_ids|
+                {
+                  type: :positions,
+                  conditions: {e_id: employee_ids},
+                }
+              end
+            end
+          end
+          params[:include] = "positions"
+        end
+
+        it "is used" do
+          render
+          expect(included("positions").map(&:id)).to eq([1, 2])
+        end
+      end
     end
 
-    context "when custom foreign key given" do
+    context "without includes and default linkage" do
       before do
-        PORO::DB.data[:positions][0] = {id: 1, e_id: 1}
-        PORO::DB.data[:positions][1] = {id: 2, e_id: 1}
-
         resource.class_eval do
-          has_many :positions, foreign_key: :e_id do
+          has_many :positions do
             scope do |employee_ids|
               {
                 type: :positions,
-                conditions: {e_id: employee_ids},
+                conditions: {employee_id: employee_ids},
               }
             end
           end
         end
-        params[:include] = "positions"
+        render
       end
 
-      it "is used" do
+      it "does not include anything" do
+        expect {
+          included("positions")
+        }.to raise_error(GraphitiSpecHelpers::Errors::NoSideloads)
+      end
+
+      it "specifies meta[:included] = false" do
+        jsonapi_data.each do |record|
+          expect(record.relationships["positions"]["meta"]["included"]).to eq(false)
+        end
+      end
+
+      it "does not includes relationship linkage" do
+        jsonapi_data.each do |record|
+          data = record.relationships["positions"]["data"]
+          expect(data).to be_nil
+        end
+      end
+    end
+
+    context "without includes and linkage always: true" do
+      before do
+        resource.class_eval do
+          has_many :positions, linkage_always: true do
+            scope do |employee_ids|
+              {
+                type: :positions,
+                conditions: {employee_id: employee_ids},
+              }
+            end
+          end
+        end
         render
-        expect(included("positions").map(&:id)).to eq([1, 2])
+      end
+
+      it "does not include anything" do
+        expect {
+          included("positions")
+        }.to raise_error(GraphitiSpecHelpers::Errors::NoSideloads)
+      end
+
+      it "does not have meta[:included] = false" do
+        jsonapi_data.each do |record|
+          expect(record.relationships["positions"].dig("meta", "included")).to be_nil
+        end
+      end
+
+      it "includes relationship linkage" do
+        jsonapi_data.each do |record|
+          data = record.relationships["positions"]["data"]
+          expect(data.pluck(:type).uniq).to match_array(["positions"])
+          expect(data.pluck(:id).uniq).to match_array(["1", "2"])
+        end
       end
     end
   end
@@ -270,23 +352,92 @@ def self.name
 
     let(:base_scope) { {type: :positions} }
 
-    before do
-      resource.class_eval do
-        belongs_to :employee do
-          scope do |employee_ids|
-            {
-              type: :employees,
-              conditions: {id: employee_ids},
-            }
+    context "with includes" do
+      before do
+        resource.class_eval do
+          belongs_to :employee do
+            scope do |employee_ids|
+              {
+                type: :employees,
+                conditions: {id: employee_ids},
+              }
+            end
           end
         end
+        params[:include] = "employee"
+      end
+
+      it "works" do
+        render
+        expect(included("employees").map(&:id)).to eq([1])
+      end
+
+      it "has relationship linkage" do
+        render
+
+        jsonapi_data.each do |record|
+          data = record.relationships["employee"]["data"]
+
+          expect(data[:type]).to eq("employees")
+          expect(data[:id]).to eq("1")
+        end
       end
-      params[:include] = "employee"
     end
 
-    it "works" do
-      render
-      expect(included("employees").map(&:id)).to eq([1])
+    context "with default linkage" do
+      before do
+        resource.class_eval do
+          belongs_to :employee do
+            scope do |employee_ids|
+              {
+                type: :employees,
+                conditions: {id: employee_ids},
+              }
+            end
+          end
+        end
+      end
+
+      it "has relationship linkage" do
+        render
+
+        jsonapi_data.each do |record|
+          data = record.relationships["employee"]["data"]
+
+          expect(data[:type]).to eq("employees")
+          expect(data[:id]).to eq("1")
+        end
+      end
+    end
+
+    context "with linkage: false" do
+      before do
+        resource.class_eval do
+          belongs_to :employee, linkage_always: false do
+            scope do |employee_ids|
+              {
+                type: :employees,
+                conditions: {id: employee_ids},
+              }
+            end
+          end
+        end
+      end
+
+      it "works" do
+        render
+        expect(included("employees").map(&:id)).to eq([1])
+      end
+
+      it "has no relationship linkage" do
+        render
+
+        jsonapi_data.each do |record|
+          data = record.relationships["employee"]
+
+          expect(data.keys).to_not include('data')
+        end
+      end
     end
   end