Adds a :links option to the relationship macros

This allows specifying a `:links` option to a has_many/has_one
relationship, which means you can specify `self` or `related` links as
per the JSON API spec (these are often useful for not loading all
associated objects in a single payload)

Author: nikz

lib/fast_jsonapi/object_serializer.rb

@@ -194,7 +194,7 @@ def add_relationship(relationship)
         self.relationships_to_serialize = {} if relationships_to_serialize.nil?
         self.cachable_relationships_to_serialize = {} if cachable_relationships_to_serialize.nil?
         self.uncachable_relationships_to_serialize = {} if uncachable_relationships_to_serialize.nil?
-        
+
         if !relationship.cached
           self.uncachable_relationships_to_serialize[relationship.name] = relationship
         else
@@ -240,7 +240,8 @@ def create_relationship(base_key, relationship_type, options, block)
           relationship_type: relationship_type,
           cached: options[:cached],
           polymorphic: fetch_polymorphic_option(options),
-          conditional_proc: options[:if]
+          conditional_proc: options[:if],
+          links: options[:links]
         )
       end
 

lib/fast_jsonapi/relationship.rb

@@ -1,6 +1,6 @@
 module FastJsonapi
   class Relationship
-    attr_reader :key, :name, :id_method_name, :record_type, :object_method_name, :object_block, :serializer, :relationship_type, :cached, :polymorphic, :conditional_proc
+    attr_reader :key, :name, :id_method_name, :record_type, :object_method_name, :object_block, :serializer, :relationship_type, :cached, :polymorphic, :conditional_proc, :links
 
     def initialize(
       key:,
@@ -13,7 +13,8 @@ def initialize(
       relationship_type:,
       cached: false,
       polymorphic:,
-      conditional_proc:
+      conditional_proc:,
+      links:
     )
       @key = key
       @name = name
@@ -26,14 +27,16 @@ def initialize(
       @cached = cached
       @polymorphic = polymorphic
       @conditional_proc = conditional_proc
+      @links = links || {}
     end
 
-    def serialize(record, serialization_params, output_hash)
+    def serialize(record, serialization_params, output_hash, &block)
       if include_relationship?(record, serialization_params)
         empty_case = relationship_type == :has_many ? [] : nil
         output_hash[key] = {
-          data: ids_hash_from_record_and_relationship(record, serialization_params) || empty_case
+          data: ids_hash_from_record_and_relationship(record, serialization_params) || empty_case,
         }
+        add_links_hash(record, serialization_params, output_hash) if links.present?
       end
     end
 
@@ -95,5 +98,11 @@ def fetch_id(record, params)
 
       record.public_send(id_method_name)
     end
+
+    def add_links_hash(record, params, output_hash)
+      output_hash[key][:links] = links.each_with_object({}) do |(key, method), hash|
+        Link.new(key: key, method: method).serialize(record, params, hash)
+      end
+    end
   end
 end

spec/lib/object_serializer_relationship_links_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context 'movie class'
+
+  context "params option" do
+    let(:hash) { serializer.serializable_hash }
+
+    before(:context) do
+      class MovieSerializer
+        has_many :actors, links: {
+          self:    :actors_relationship_url,
+          related: -> (object, params = {}) {
+            "#{params.has_key?(:secure) ? "https" : "http"}://movies.com/movies/#{object.name.parameterize}/actors/"
+          }
+        }
+      end
+    end
+
+    context "generating links for a serializer relationship" do
+      let(:params) { {  } }
+      let(:options_with_params) { { params: params } }
+      let(:relationship_url) { "http://movies.com/#{movie.id}/relationships/actors" }
+      let(:related_url) { "http://movies.com/movies/#{movie.name.parameterize}/actors/" }
+
+      context "with a single record" do
+        let(:serializer) { MovieSerializer.new(movie, options_with_params) }
+        let(:links) { hash.dig(:data, :relationships, :actors, :links) }
+
+        it "handles relationship links that call a method" do
+          expect(links).to be_present
+          expect(links[:self]).to eq(relationship_url)
+        end
+
+        it "handles relationship links that call a proc" do
+          expect(links).to be_present
+          expect(links[:related]).to eq(related_url)
+        end
+
+        context "with serializer params" do
+          let(:params) { { secure: true } }
+          let(:secure_related_url) { related_url.gsub("http", "https") }
+
+          it "passes the params to the link serializer correctly" do
+            expect(links).to be_present
+            expect(links[:related]).to eq(secure_related_url)
+          end
+        end
+      end
+
+    end
+  end
+end

spec/shared/contexts/movie_context.rb

@@ -61,6 +61,10 @@ def local_name(locale = :english)
       def url
         "http://movies.com/#{id}"
       end
+
+      def actors_relationship_url
+        "#{url}/relationships/actors"
+      end
     end
 
     class Actor