fast_jsonapi 1.1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: c8e9a2f191f153e38d68cdafd1d61432a065fa608f069cf29403e5392358f5ea
-  data.tar.gz: 4f11774e609f4a286850bf7a217cdb4525479097b5e594b27abf00e14586ab51
+SHA1:
+  metadata.gz: 346edf85242b61d0747883aaa7b62da16b1a8fec
+  data.tar.gz: 36d21132fe65b9c88e2f1afce9aa935ae094d7ec
 SHA512:
-  metadata.gz: dbad0552348467cbd2c40e9d49431a6995a152037e0224dcb9d2b7cf85c05656fb7a6c23e5a24ad13e8f54ab73019290096d127c55d690e33eb49df91f260ab9
-  data.tar.gz: a5a007f236ee50327bba65c678288a3adfb7c44d0864f2a5bcfe18f63a9275cf836e551c318d07dbd30a3eb4a705a121cea94e7d5668f702e4b119e00d73d8f0
+  metadata.gz: 9bb346d89aa234162c0bdc5f269e82735890ba6ebe60bb6e448506ef1d2d299c08be234b8acf4827fdc8860bee1439cc5dded54107b857ed536d2229c894519c
+  data.tar.gz: 3e4f56de96e171a931a5479edd16600fd6bc3fb586b1152a8b63a4e39fc73075d01a276bba831f577d74a951c494a5744d584e3a33f482c4139f410db40ebffb

data/README.md

@@ -29,6 +29,7 @@ Fast JSON API serialized 250 records in 3.01 ms
   * [Key Transforms](#key-transforms)
   * [Collection Serialization](#collection-serialization)
   * [Caching](#caching)
+  * [Params](#params)
 * [Contributing](#contributing)
 
 
@@ -60,7 +61,7 @@ $ bundle install
 You can use the bundled generator if you are using the library inside of
 a Rails project:
 
-    rails g Serializer Movie name year
+    rails g serializer Movie name year
 
 This will create a new serializer in `app/serializers/movie_serializer.rb`
 
@@ -173,7 +174,7 @@ By default, attributes are read directly from the model property of the same nam
 ```ruby
 class MovieSerializer
   include FastJsonapi::ObjectSerializer
-  
+
   attribute :name
 end
 ```
@@ -183,9 +184,9 @@ Custom attributes that must be serialized but do not exist on the model can be d
 ```ruby
 class MovieSerializer
   include FastJsonapi::ObjectSerializer
-  
+
   attributes :name, :year
-  
+
   attribute :name_with_year do |object|
     "#{object.name} (#{object.year})"
   end
@@ -197,21 +198,51 @@ The block syntax can also be used to override the property on the object:
 ```ruby
 class MovieSerializer
   include FastJsonapi::ObjectSerializer
-  
+
   attribute :name do |object|
     "#{object.name} Part 2"
   end
 end
 ```
 
+### Links Per Object
+Links are defined in FastJsonapi using the `link` method. By default, link are read directly from the model property of the same name.In this example, `public_url` is expected to be a property of the object being serialized.
+
+You can configure the method to use on the object for example a link with key `self` will get set to the value returned by a method called `url` on the movie object.
+
+You can also use a block to define a url as shown in `custom_url`. You can access params in these blocks as well as shown in `personalized_url`
+
+```ruby
+class MovieSerializer
+  include FastJsonapi::ObjectSerializer
+
+  link :public_url
+
+  link :self, :url
+
+  link :custom_url do |object|
+    "http://movies.com/#{object.name}-(#{object.year})"
+  end
+
+  link :personalized_url do |object, params|
+    "http://movies.com/#{object.name}-#{params[:user].reference_code}"
+  end
+end
+```
+
 ### Compound Document
 
-Support for top-level included member through ` options[:include] `.
+Support for top-level and nested included associations through ` options[:include] `.
 
 ```ruby
 options = {}
 options[:meta] = { total: 2 }
-options[:include] = [:actors]
+options[:links] = {
+  self: '...',
+  next: '...',
+  prev: '...'
+}
+options[:include] = [:actors, :'actors.agency', :'actors.agency.state']
 MovieSerializer.new([movie, movie], options).serialized_json
 ```
 
@@ -219,11 +250,17 @@ MovieSerializer.new([movie, movie], options).serialized_json
 
 ```ruby
 options[:meta] = { total: 2 }
+options[:links] = {
+  self: '...',
+  next: '...',
+  prev: '...'
+}
 hash = MovieSerializer.new([movie, movie], options).serializable_hash
 json_string = MovieSerializer.new([movie, movie], options).serialized_json
 ```
 
 ### Caching
+Requires a `cache_key` method be defined on model:
 
 ```ruby
 class MovieSerializer
@@ -234,17 +271,56 @@ class MovieSerializer
 end
 ```
 
+### Params
+
+In some cases, attribute values might require more information than what is
+available on the record, for example, access privileges or other information
+related to a current authenticated user. The `options[:params]` value covers these
+cases by allowing you to pass in a hash of additional parameters necessary for
+your use case.
+
+Leveraging the new params is easy, when you define a custom attribute or relationship with a
+block you opt-in to using params by adding it as a block parameter.
+
+```ruby
+class MovieSerializer
+  class MovieSerializer
+  include FastJsonapi::ObjectSerializer
+
+  attributes :name, :year
+  attribute :can_view_early do |movie, params|
+    # in here, params is a hash containing the `:current_user` key
+    params[:current_user].is_employee? ? true : false
+  end
+
+  belongs_to :primary_agent do |movie, params|
+    # in here, params is a hash containing the `:current_user` key
+    params[:current_user].is_employee? ? true : false
+  end
+end
+
+# ...
+current_user = User.find(cookies[:current_user_id])
+serializer = MovieSerializer.new(movie, {params: {current_user: current_user}})
+serializer.serializable_hash
+```
+
+Custom attributes and relationships that only receive the resource are still possible by defining
+the block to only receive one argument.
+
 ### Customizable Options
 
 Option | Purpose | Example
 ------------ | ------------- | -------------
 set_type | Type name of Object | ```set_type :movie ```
 set_id | ID of Object | ```set_id :owner_id ```
-cache_options | Hash to enable caching and set cache length | ```cache_options enabled: true, cache_length: 12.hours```
+cache_options | Hash to enable caching and set cache length | ```cache_options enabled: true, cache_length: 12.hours, race_condition_ttl: 10.seconds```
 id_method_name | Set custom method name to get ID of an object | ```has_many :locations, id_method_name: :place_ids ```
 object_method_name | Set custom method name to get related objects | ```has_many :locations, object_method_name: :places ```
 record_type | Set custom Object Type for a relationship | ```belongs_to :owner, record_type: :user```
-serializer | Set custom Serializer for a relationship | ```has_many :actors, serializer: :custom_actor```
+serializer | Set custom Serializer for a relationship | ```has_many :actors, serializer: :custom_actor``` or ```has_many :actors, serializer: MyApp::Api::V1::ActorSerializer```
+polymorphic | Allows different record types for a polymorphic association | ```has_many :targets, polymorphic: true```
+polymorphic | Sets custom record types for each object class in a polymorphic association | ```has_many :targets, polymorphic: { Person => :person, Group => :group }```
 
 ### Instrumentation
 
@@ -304,4 +380,3 @@ rspec spec --tag performance:true
 Join the Netflix Studio Engineering team and help us build gems like this!
 
 * [Senior Ruby Engineer](https://jobs.netflix.com/jobs/864893)
-* [Senior Platform Engineer](https://jobs.netflix.com/jobs/865783)

data/lib/extensions/has_one.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-begin
-  require 'active_record'
-
+if defined?(::ActiveRecord)
   ::ActiveRecord::Associations::Builder::HasOne.class_eval do
     # Based on
     # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/associations/builder/collection_association.rb#L50
@@ -12,11 +10,11 @@ begin
       name = reflection.name
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name}_id
+          # if an attribute is already defined with this methods name we should just use it
+          return read_attribute(__method__) if has_attribute?(__method__)
           association(:#{name}).reader.try(:id)
         end
       CODE
     end
   end
-rescue LoadError
-  # active_record can't be loaded so we shouldn't try to monkey-patch it.
 end

data/lib/fast_jsonapi/instrumentation/skylight/normalizers/base.rb

@@ -0,0 +1,7 @@
+require 'skylight'
+
+SKYLIGHT_NORMALIZER_BASE_CLASS = begin
+  ::Skylight::Core::Normalizers::Normalizer
+rescue NameError
+  ::Skylight::Normalizers::Normalizer
+end

data/lib/fast_jsonapi/instrumentation/skylight/normalizers/serializable_hash.rb

@@ -1,11 +1,11 @@
-require 'skylight'
+require 'fast_jsonapi/instrumentation/skylight/normalizers/base'
 require 'fast_jsonapi/instrumentation/serializable_hash'
 
 module FastJsonapi
   module Instrumentation
     module Skylight
       module Normalizers
-        class SerializableHash < Skylight::Normalizers::Normalizer
+        class SerializableHash < SKYLIGHT_NORMALIZER_BASE_CLASS
 
           register FastJsonapi::ObjectSerializer::SERIALIZABLE_HASH_NOTIFICATION
 

data/lib/fast_jsonapi/instrumentation/skylight/normalizers/serialized_json.rb

@@ -1,11 +1,11 @@
-require 'skylight'
+require 'fast_jsonapi/instrumentation/skylight/normalizers/base'
 require 'fast_jsonapi/instrumentation/serializable_hash'
 
 module FastJsonapi
   module Instrumentation
     module Skylight
       module Normalizers
-        class SerializedJson < Skylight::Normalizers::Normalizer
+        class SerializedJson < SKYLIGHT_NORMALIZER_BASE_CLASS
 
           register FastJsonapi::ObjectSerializer::SERIALIZED_JSON_NOTIFICATION
 

data/lib/fast_jsonapi/multi_to_json.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 # Usage:
 #   class Movie
 #     def to_json(payload)

data/lib/fast_jsonapi/object_serializer.rb

@@ -10,8 +10,8 @@ module FastJsonapi
     extend ActiveSupport::Concern
     include SerializationCore
 
-    SERIALIZABLE_HASH_NOTIFICATION = 'render.fast_jsonapi.serializable_hash'.freeze
-    SERIALIZED_JSON_NOTIFICATION = 'render.fast_jsonapi.serialized_json'.freeze
+    SERIALIZABLE_HASH_NOTIFICATION = 'render.fast_jsonapi.serializable_hash'
+    SERIALIZED_JSON_NOTIFICATION = 'render.fast_jsonapi.serialized_json'
 
     included do
       # Set record_type based on the name of the serializer class
@@ -34,11 +34,12 @@ module FastJsonapi
     def hash_for_one_record
       serializable_hash = { data: nil }
       serializable_hash[:meta] = @meta if @meta.present?
+      serializable_hash[:links] = @links if @links.present?
 
       return serializable_hash unless @resource
 
-      serializable_hash[:data] = self.class.record_hash(@resource)
-      serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects) if @includes.present?
+      serializable_hash[:data] = self.class.record_hash(@resource, @params)
+      serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects, @params) if @includes.present?
       serializable_hash
     end
 
@@ -48,13 +49,14 @@ module FastJsonapi
       data = []
       included = []
       @resource.each do |record|
-        data << self.class.record_hash(record)
-        included.concat self.class.get_included_records(record, @includes, @known_included_objects) if @includes.present?
+        data << self.class.record_hash(record, @params)
+        included.concat self.class.get_included_records(record, @includes, @known_included_objects, @params) if @includes.present?
       end
 
       serializable_hash[:data] = data
       serializable_hash[:included] = included if @includes.present?
       serializable_hash[:meta] = @meta if @meta.present?
+      serializable_hash[:links] = @links if @links.present?
       serializable_hash
     end
 
@@ -69,20 +71,13 @@ module FastJsonapi
 
       @known_included_objects = {}
       @meta = options[:meta]
+      @links = options[:links]
+      @params = options[:params] || {}
+      raise ArgumentError.new("`params` option passed to serializer must be a hash") unless @params.is_a?(Hash)
 
       if options[:include].present?
         @includes = options[:include].delete_if(&:blank?).map(&:to_sym)
-        validate_includes!(@includes)
-      end
-    end
-
-    def validate_includes!(includes)
-      return if includes.blank?
-
-      existing_relationships = self.class.relationships_to_serialize.keys.to_set
-
-      unless existing_relationships.superset?(includes.to_set)
-        raise ArgumentError, "One of keys from #{includes} is not specified as a relationship on the serializer"
+        self.class.validate_includes!(@includes)
       end
     end
 
@@ -91,6 +86,20 @@ module FastJsonapi
     end
 
     class_methods do
+
+      def inherited(subclass)
+        super(subclass)
+        subclass.attributes_to_serialize = attributes_to_serialize.dup if attributes_to_serialize.present?
+        subclass.relationships_to_serialize = relationships_to_serialize.dup if relationships_to_serialize.present?
+        subclass.cachable_relationships_to_serialize = cachable_relationships_to_serialize.dup if cachable_relationships_to_serialize.present?
+        subclass.uncachable_relationships_to_serialize = uncachable_relationships_to_serialize.dup if uncachable_relationships_to_serialize.present?
+        subclass.transform_method = transform_method
+        subclass.cache_length = cache_length
+        subclass.race_condition_ttl = race_condition_ttl
+        subclass.data_links = data_links
+        subclass.cached = cached
+      end
+
       def reflected_record_type
         return @reflected_record_type if defined?(@reflected_record_type)
 
@@ -108,11 +117,11 @@ module FastJsonapi
           dash: :dasherize,
           underscore: :underscore
         }
-        @transform_method = mapping[transform_name.to_sym]
+        self.transform_method = mapping[transform_name.to_sym]
       end
 
       def run_key_transform(input)
-        if @transform_method.present?
+        if self.transform_method.present?
           input.to_s.send(*@transform_method).to_sym
         else
           input.to_sym
@@ -135,6 +144,7 @@ module FastJsonapi
       def cache_options(cache_options)
         self.cached = cache_options[:enabled] || false
         self.cache_length = cache_options[:cache_length] || 5.minutes
+        self.race_condition_ttl = cache_options[:race_condition_ttl] || 5.seconds
       end
 
       def attributes(*attributes_list, &block)
@@ -162,67 +172,54 @@ module FastJsonapi
         self.relationships_to_serialize[name] = relationship
      end
 
-      def has_many(relationship_name, options = {})
+      def has_many(relationship_name, options = {}, &block)
         name = relationship_name.to_sym
-        singular_name = relationship_name.to_s.singularize
-        serializer_key = options[:serializer] || singular_name.to_sym
-        key = options[:key] || run_key_transform(relationship_name)
-        record_type = options[:record_type] || run_key_transform(singular_name)
-        relationship = {
-          key: key,
-          name: name,
-          id_method_name: options[:id_method_name] || (singular_name + '_ids').to_sym,
-          record_type: record_type,
-          object_method_name: options[:object_method_name] || name,
-          serializer: compute_serializer_name(serializer_key),
-          relationship_type: :has_many,
-          cached: options[:cached] || false,
-          polymorphic: fetch_polymorphic_option(options)
-        }
-        add_relationship(name, relationship)
+        hash = create_relationship_hash(relationship_name, :has_many, options, block)
+        add_relationship(name, hash)
       end
 
-      def belongs_to(relationship_name, options = {})
+      def has_one(relationship_name, options = {}, &block)
         name = relationship_name.to_sym
-        serializer_key = options[:serializer] || relationship_name.to_sym
-        key = options[:key] || run_key_transform(relationship_name)
-        record_type = options[:record_type] || run_key_transform(relationship_name)
-        add_relationship(name, {
-          key: key,
-          name: name,
-          id_method_name: options[:id_method_name] || (relationship_name.to_s + '_id').to_sym,
-          record_type: record_type,
-          object_method_name: options[:object_method_name] || name,
-          serializer: compute_serializer_name(serializer_key),
-          relationship_type: :belongs_to,
-          cached: options[:cached] || true,
-          polymorphic: fetch_polymorphic_option(options)
-        })
+        hash = create_relationship_hash(relationship_name, :has_one, options, block)
+        add_relationship(name, hash)
       end
 
-      def has_one(relationship_name, options = {})
+      def belongs_to(relationship_name, options = {}, &block)
         name = relationship_name.to_sym
-        serializer_key = options[:serializer] || name
-        key = options[:key] || run_key_transform(relationship_name)
-        record_type = options[:record_type] || run_key_transform(relationship_name)
-        add_relationship(name, {
-          key: key,
+        hash = create_relationship_hash(relationship_name, :belongs_to, options, block)
+        add_relationship(name, hash)
+      end
+
+      def create_relationship_hash(base_key, relationship_type, options, block)
+        name = base_key.to_sym
+        if relationship_type == :has_many
+          base_serialization_key = base_key.to_s.singularize
+          base_key_sym = base_serialization_key.to_sym
+          id_postfix = '_ids'
+        else
+          base_serialization_key = base_key
+          base_key_sym = name
+          id_postfix = '_id'
+        end
+        {
+          key: options[:key] || run_key_transform(base_key),
           name: name,
-          id_method_name: options[:id_method_name] || (relationship_name.to_s + '_id').to_sym,
-          record_type: record_type,
+          id_method_name: options[:id_method_name] || "#{base_serialization_key}#{id_postfix}".to_sym,
+          record_type: options[:record_type] || run_key_transform(base_key_sym),
           object_method_name: options[:object_method_name] || name,
-          serializer: compute_serializer_name(serializer_key),
-          relationship_type: :has_one,
+          object_block: block,
+          serializer: compute_serializer_name(options[:serializer] || base_key_sym),
+          relationship_type: relationship_type,
           cached: options[:cached] || false,
           polymorphic: fetch_polymorphic_option(options)
-        })
+        }
       end
 
       def compute_serializer_name(serializer_key)
+        return serializer_key unless serializer_key.is_a? Symbol
         namespace = self.name.gsub(/()?\w+Serializer$/, '')
         serializer_name = serializer_key.to_s.classify + 'Serializer'
-        return (namespace + serializer_name).to_sym if namespace.present?
-        (serializer_key.to_s.classify + 'Serializer').to_sym
+        (namespace + serializer_name).to_sym
       end
 
       def fetch_polymorphic_option(options)
@@ -231,6 +228,27 @@ module FastJsonapi
         return option if option.respond_to? :keys
         {}
       end
+
+      def link(link_name, link_method_name = nil, &block)
+        self.data_links = {} if self.data_links.nil?
+        link_method_name = link_name if link_method_name.nil?
+        key = run_key_transform(link_name)
+        self.data_links[key] = block || link_method_name
+      end
+
+      def validate_includes!(includes)
+        return if includes.blank?
+
+        includes.detect do |include_item|
+          klass = self
+          parse_include_item(include_item).each do |parsed_include|
+            relationship_to_include = klass.relationships_to_serialize[parsed_include]
+            raise ArgumentError, "#{parsed_include} is not specified as a relationship on #{klass.name}" unless relationship_to_include
+            raise NotImplementedError if relationship_to_include[:polymorphic].is_a?(Hash)
+            klass = relationship_to_include[:serializer].to_s.constantize
+          end
+        end
+      end
     end
   end
 end

data/lib/fast_jsonapi/serialization_core.rb

@@ -4,6 +4,8 @@ require 'active_support/concern'
 require 'fast_jsonapi/multi_to_json'
 
 module FastJsonapi
+  MandatoryField = Class.new(StandardError)
+
   module SerializationCore
     extend ActiveSupport::Concern
 
@@ -13,16 +15,23 @@ module FastJsonapi
                       :relationships_to_serialize,
                       :cachable_relationships_to_serialize,
                       :uncachable_relationships_to_serialize,
+                      :transform_method,
                       :record_type,
                       :record_id,
                       :cache_length,
-                      :cached
+                      :race_condition_ttl,
+                      :cached,
+                      :data_links
       end
     end
 
     class_methods do
-      def id_hash(id, record_type)
-        return { id: id.to_s, type: record_type } if id.present?
+      def id_hash(id, record_type, default_return=false)
+        if id.present?
+          { id: id.to_s, type: record_type }
+        else
+          default_return ? { id: nil, type: record_type } : nil
+        end
       end
 
       def ids_hash(ids, record_type)
@@ -33,19 +42,18 @@ module FastJsonapi
       def id_hash_from_record(record, record_types)
         # memoize the record type within the record_types dictionary, then assigning to record_type:
         record_type = record_types[record.class] ||= record.class.name.underscore.to_sym
-        { id: record.id.to_s, type: record_type }
+        id_hash(record.id, record_type)
       end
 
-      def ids_hash_from_record_and_relationship(record, relationship)
+      def ids_hash_from_record_and_relationship(record, relationship, params = {})
         polymorphic = relationship[:polymorphic]
 
         return ids_hash(
-          record.public_send(relationship[:id_method_name]),
+          fetch_id(record, relationship, params),
           relationship[:record_type]
         ) unless polymorphic
 
-        object_method_name = relationship.fetch(:object_method_name, relationship[:name])
-        return unless associated_object = record.send(object_method_name)
+        return unless associated_object = fetch_associated_object(record, relationship, params)
 
         return associated_object.map do |object|
           id_hash_from_record object, polymorphic
@@ -54,69 +62,131 @@ module FastJsonapi
         id_hash_from_record associated_object, polymorphic
       end
 
-      def attributes_hash(record)
+      def links_hash(record, params = {})
+        data_links.each_with_object({}) do |(key, method), link_hash|
+          link_hash[key] = if method.is_a?(Proc)
+            method.arity == 1 ? method.call(record) : method.call(record, params)
+          else
+            record.public_send(method)
+          end
+        end
+      end
+
+      def attributes_hash(record, params = {})
         attributes_to_serialize.each_with_object({}) do |(key, method), attr_hash|
-          attr_hash[key] = method.is_a?(Proc) ? method.call(record) : record.public_send(method)
+          attr_hash[key] = if method.is_a?(Proc)
+            method.arity == 1 ? method.call(record) : method.call(record, params)
+          else
+            record.public_send(method)
+          end
         end
       end
 
-      def relationships_hash(record, relationships = nil)
+      def relationships_hash(record, relationships = nil, params = {})
         relationships = relationships_to_serialize if relationships.nil?
 
         relationships.each_with_object({}) do |(_k, relationship), hash|
           name = relationship[:key]
           empty_case = relationship[:relationship_type] == :has_many ? [] : nil
           hash[name] = {
-            data: ids_hash_from_record_and_relationship(record, relationship) || empty_case
+            data: ids_hash_from_record_and_relationship(record, relationship, params) || empty_case
           }
         end
       end
 
-      def record_hash(record)
+      def record_hash(record, params = {})
         if cached
-          record_hash = Rails.cache.fetch(record.cache_key, expires_in: cache_length) do
-            id = record_id ? record.send(record_id) : record.id
-            temp_hash = id_hash(id, record_type) || { id: nil, type: record_type }
-            temp_hash[:attributes] = attributes_hash(record) if attributes_to_serialize.present?
+          record_hash = Rails.cache.fetch(record.cache_key, expires_in: cache_length, race_condition_ttl: race_condition_ttl) do
+            temp_hash = id_hash(id_from_record(record), record_type, true)
+            temp_hash[:attributes] = attributes_hash(record, params) if attributes_to_serialize.present?
             temp_hash[:relationships] = {}
-            temp_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize) if cachable_relationships_to_serialize.present?
+            temp_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize, params) if cachable_relationships_to_serialize.present?
+            temp_hash[:links] = links_hash(record, params) if data_links.present?
             temp_hash
           end
-          record_hash[:relationships] = record_hash[:relationships].merge(relationships_hash(record, uncachable_relationships_to_serialize)) if uncachable_relationships_to_serialize.present?
+          record_hash[:relationships] = record_hash[:relationships].merge(relationships_hash(record, uncachable_relationships_to_serialize, params)) if uncachable_relationships_to_serialize.present?
           record_hash
         else
-          id = record_id ? record.send(record_id) : record.id
-          record_hash = id_hash(id, record_type) || { id: nil, type: record_type }
-          record_hash[:attributes] = attributes_hash(record) if attributes_to_serialize.present?
-          record_hash[:relationships] = relationships_hash(record) if relationships_to_serialize.present?
+          record_hash = id_hash(id_from_record(record), record_type, true)
+          record_hash[:attributes] = attributes_hash(record, params) if attributes_to_serialize.present?
+          record_hash[:relationships] = relationships_hash(record, nil, params) if relationships_to_serialize.present?
+          record_hash[:links] = links_hash(record, params) if data_links.present?
           record_hash
         end
       end
 
+      def id_from_record(record)
+         return record.send(record_id) if record_id
+         raise MandatoryField, 'id is a mandatory field in the jsonapi spec' unless record.respond_to?(:id)
+         record.id
+      end
+
       # Override #to_json for alternative implementation
       def to_json(payload)
         FastJsonapi::MultiToJson.to_json(payload) if payload.present?
       end
 
-      # includes handler
+      def parse_include_item(include_item)
+        return [include_item.to_sym] unless include_item.to_s.include?('.')
+        include_item.to_s.split('.').map { |item| item.to_sym }
+      end
 
-      def get_included_records(record, includes_list, known_included_objects)
-        includes_list.each_with_object([]) do |item, included_records|
-          object_method_name = @relationships_to_serialize[item][:object_method_name]
-          record_type = @relationships_to_serialize[item][:record_type]
-          serializer = @relationships_to_serialize[item][:serializer].to_s.constantize
-          relationship_type = @relationships_to_serialize[item][:relationship_type]
-          included_objects = record.send(object_method_name)
-          next if included_objects.blank?
-          included_objects = [included_objects] unless relationship_type == :has_many
-          included_objects.each do |inc_obj|
-            code = "#{record_type}_#{inc_obj.id}"
-            next if known_included_objects.key?(code)
-            known_included_objects[code] = inc_obj
-            included_records << serializer.record_hash(inc_obj)
+      def remaining_items(items)
+        return unless items.size > 1
+
+        items_copy = items.dup
+        items_copy.delete_at(0)
+        [items_copy.join('.').to_sym]
+      end
+
+      # includes handler
+      def get_included_records(record, includes_list, known_included_objects, params = {})
+        return unless includes_list.present?
+
+        includes_list.sort.each_with_object([]) do |include_item, included_records|
+          items = parse_include_item(include_item)
+          items.each do |item|
+            next unless relationships_to_serialize && relationships_to_serialize[item]
+            raise NotImplementedError if @relationships_to_serialize[item][:polymorphic].is_a?(Hash)
+            record_type = @relationships_to_serialize[item][:record_type]
+            serializer = @relationships_to_serialize[item][:serializer].to_s.constantize
+            relationship_type = @relationships_to_serialize[item][:relationship_type]
+
+            included_objects = fetch_associated_object(record, @relationships_to_serialize[item], params)
+            next if included_objects.blank?
+            included_objects = [included_objects] unless relationship_type == :has_many
+
+            included_objects.each do |inc_obj|
+              if remaining_items(items)
+                serializer_records = serializer.get_included_records(inc_obj, remaining_items(items), known_included_objects)
+                included_records.concat(serializer_records) unless serializer_records.empty?
+              end
+
+              code = "#{record_type}_#{inc_obj.id}"
+              next if known_included_objects.key?(code)
+
+              known_included_objects[code] = inc_obj
+              included_records << serializer.record_hash(inc_obj, params)
+            end
           end
         end
       end
+
+      def fetch_associated_object(record, relationship, params)
+        return relationship[:object_block].call(record, params) unless relationship[:object_block].nil?
+        record.send(relationship[:object_method_name])
+      end
+
+      def fetch_id(record, relationship, params)
+        unless relationship[:object_block].nil?
+          object = relationship[:object_block].call(record, params)
+
+          return object.map(&:id) if object.respond_to? :map
+          return object.id
+        end
+
+        record.public_send(relationship[:id_method_name])
+      end
     end
   end
 end

data/lib/fast_jsonapi/version.rb

@@ -0,0 +1,3 @@
+module FastJsonapi
+  VERSION = "1.2"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_jsonapi
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: '1.2'
 platform: ruby
 authors:
 - Shishir Kakaraddi
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-01 00:00:00.000000000 Z
+date: 2018-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -197,11 +197,13 @@ files:
 - lib/fast_jsonapi/instrumentation/serializable_hash.rb
 - lib/fast_jsonapi/instrumentation/serialized_json.rb
 - lib/fast_jsonapi/instrumentation/skylight.rb
+- lib/fast_jsonapi/instrumentation/skylight/normalizers/base.rb
 - lib/fast_jsonapi/instrumentation/skylight/normalizers/serializable_hash.rb
 - lib/fast_jsonapi/instrumentation/skylight/normalizers/serialized_json.rb
 - lib/fast_jsonapi/multi_to_json.rb
 - lib/fast_jsonapi/object_serializer.rb
 - lib/fast_jsonapi/serialization_core.rb
+- lib/fast_jsonapi/version.rb
 - lib/generators/serializer/USAGE
 - lib/generators/serializer/serializer_generator.rb
 - lib/generators/serializer/templates/serializer.rb.tt
@@ -218,7 +220,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -226,7 +228,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: fast JSON API(jsonapi.org) serializer