ams_lazy_relationships 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ec3f81fd1d54428b4881ba8ec0631dbf2587d0b136f9fe9baecd29b9ac9d627
-  data.tar.gz: 9e7f106d42380915cfa2c0a475be0403951a8c632675d3cd5b4d8b3b0e25ec37
+  metadata.gz: d299c4294fa21bc85d59919b153f88de9f78a4ed9a2f2d7f87cf98cdc8093706
+  data.tar.gz: 9a66c679744b7e8128ce492209f3743e397cb0f3d1eec93097667c7c0e142863
 SHA512:
-  metadata.gz: ae977d3dcbde64175dd581ac341fa7db034dd7347ebd486d5c0b09808215cf7742ad8126cc6ca6c946406453d44a32125805488c6131ef981b777e40bdac0e18
-  data.tar.gz: 4a772034ef0eaa1aaf8d50fde4452e1a5e0ded1ddf00571838c159950e6a23e3185e5ff5c5c427def22909744e83928ebf6a204f52973c34047a025442892d6f
+  metadata.gz: 2683f61c4107464423359aecb53193f6e5d9de727812916282e7eb6c3848541fc3212d4be773d288044582ef29ba7832d2558fd80e60fed0af2ef833dc2bb858
+  data.tar.gz: c9c777b5d1d56ad21289db010206cc20aa61225eacd9041a29f68745942e72696bee19acfef86eca4d08dba34152ff3e6ba3a1d0833296a0759c91e6203583f2

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## [v0.2.0](https://github.com/Bajena/ams_lazy_relationships/tree/v0.2.0) (2020-01-11)
+[Full Changelog](https://github.com/Bajena/ams_lazy_relationships/compare/v0.1.5...v0.2.0)
+
+**Merged pull requests:**
+
+- Lazy dig [\#44](https://github.com/Bajena/ams_lazy_relationships/pull/44) ([stokarenko](https://github.com/stokarenko))
+
 ## [v0.1.5](https://github.com/Bajena/ams_lazy_relationships/tree/v0.1.5) (2020-01-08)
 [Full Changelog](https://github.com/Bajena/ams_lazy_relationships/compare/v0.1.4...v0.1.5)
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ams_lazy_relationships (0.1.5)
+    ams_lazy_relationships (0.2.0)
       active_model_serializers
       batch-loader (~> 1)
 

data/README.md

@@ -163,6 +163,24 @@ class BlogPostSerializer < BaseSerializer
 end
 ```
 
+#### Example 6: Lazy dig through relationships
+In additional to previous example you may want to make use of nested lazy relationship without rendering of any nested record.
+There is an `lazy_dig` method to be used for that:
+
+```ruby
+class AuthorSerializer < BaseSerializer
+  lazy_relationship :address
+end
+
+class BlogPostSerializer < BaseSerializer
+  lazy_relationship :author
+
+  attribute :author_address do
+    lazy_dig(:author, :address)&.full_address
+  end
+end
+```
+
 ## Performance comparison with vanilla AMS
 
 In general the bigger and more complex your serialized records hierarchy is and the more latency you have in your DB the more you'll benefit from using this gem. 

data/lib/ams_lazy_relationships/core.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ams_lazy_relationships/core/lazy_relationship_method"
+require "ams_lazy_relationships/core/lazy_dig_method"
 require "ams_lazy_relationships/core/relationship_wrapper_methods"
 require "ams_lazy_relationships/core/evaluation"
 
@@ -18,6 +19,7 @@ module AmsLazyRelationships::Core
 
   def self.included(klass)
     klass.send :extend, ClassMethods
+    klass.send :include, LazyDigMethod
     klass.send :prepend, Initializer
 
     klass.send(:define_relationship_wrapper_methods)
@@ -48,7 +50,7 @@ module AmsLazyRelationships::Core
     def initialize(*)
       super
 
-      self.class.send(:load_all_lazy_relationships, object)
+      self.class.send(:init_all_lazy_relationships, object)
     end
   end
 end

data/lib/ams_lazy_relationships/core/evaluation.rb

@@ -8,26 +8,47 @@ module AmsLazyRelationships::Core
     LAZY_NESTING_LEVELS = 3
     NESTING_START_LEVEL = 1
 
+    # Loads the lazy relationship
+    #
+    # @param relation_name [Symbol] relation name to be loaded
+    # @param object [Object] Lazy relationships will be loaded for this record.
+    def load_lazy_relationship(relation_name, object)
+      lrm = lazy_relationships[relation_name]
+      unless lrm
+        raise ArgumentError, "Undefined lazy '#{relation_name}' relationship for '#{name}' serializer"
+      end
+
+      # We need to evaluate the promise right before serializer tries
+      # to touch it. Otherwise the various side effects can happen:
+      # 1. AMS will attempt to serialize nil values with a specific V1 serializer
+      # 2. `lazy_association ? 'exists' : 'missing'` expression will always
+      #     equal to 'exists'
+      # 3. `lazy_association&.id` expression can raise NullPointer exception
+      #
+      # Calling `__sync` will evaluate the promise.
+      init_lazy_relationship(lrm, object).__sync
+    end
+
     # Recursively loads the tree of lazy relationships
     # The nesting is limited to 3 levels.
     #
     # @param object [Object] Lazy relationships will be loaded for this record.
     # @param level [Integer] Current nesting level
-    def load_all_lazy_relationships(object, level = NESTING_START_LEVEL)
+    def init_all_lazy_relationships(object, level = NESTING_START_LEVEL)
       return if level >= LAZY_NESTING_LEVELS
       return unless object
 
       return unless lazy_relationships
 
       lazy_relationships.each_value do |lrm|
-        load_lazy_relationship(lrm, object, level)
+        init_lazy_relationship(lrm, object, level)
       end
     end
 
     # @param lrm [LazyRelationshipMeta] relationship data
     # @param object [Object] Object to load the relationship for
     # @param level [Integer] Current nesting level
-    def load_lazy_relationship(lrm, object, level = NESTING_START_LEVEL)
+    def init_lazy_relationship(lrm, object, level = NESTING_START_LEVEL)
       load_for_object = if lrm.load_for.present?
                           object.public_send(lrm.load_for)
                         else
@@ -35,7 +56,7 @@ module AmsLazyRelationships::Core
                         end
 
       lrm.loader.load(load_for_object) do |batch_records|
-        deep_load_for_yielded_records(
+        deep_init_for_yielded_records(
           batch_records,
           lrm,
           level
@@ -43,21 +64,28 @@ module AmsLazyRelationships::Core
       end
     end
 
-    def deep_load_for_yielded_records(batch_records, lrm, level)
+    def deep_init_for_yielded_records(batch_records, lrm, level)
       # There'll be no more nesting if there's no
       # reflection for this relationship. We can skip deeper lazy loading.
       return unless lrm.reflection
 
       Array.wrap(batch_records).each do |r|
-        deep_load_for_yielded_record(r, lrm, level)
+        deep_init_for_yielded_record(r, lrm, level)
       end
     end
 
-    def deep_load_for_yielded_record(batch_record, lrm, level)
-      serializer = serializer_for(batch_record, lrm.reflection.options)
+    def deep_init_for_yielded_record(batch_record, lrm, level)
+      serializer = lazy_serializer_for(batch_record, lrm: lrm)
       return unless serializer
 
-      serializer.send(:load_all_lazy_relationships, batch_record, level + 1)
+      serializer.send(:init_all_lazy_relationships, batch_record, level + 1)
+    end
+
+    def lazy_serializer_for(object, lrm: nil, relation_name: nil)
+      lrm ||= lazy_relationships[relation_name]
+      return unless lrm&.reflection
+
+      serializer_for(object, lrm.reflection.options)
     end
   end
 end

data/lib/ams_lazy_relationships/core/lazy_dig_method.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AmsLazyRelationships::Core
+  # Provides `lazy_dig` as an instance method for serializers, in order to make
+  # possible to dig relationships in depth just like `Hash#dig` do, keeping the
+  # laziness and N+1-free evaluation.
+  module LazyDigMethod
+    # @param relation_names [Array<Symbol>] the sequence of relation names
+    #   to dig through.
+    # @return [ActiveRecord::Base, Array<ActiveRecord::Base>, nil] ActiveRecord
+    #   objects found by digging through the sequence of nested relationships.
+    #   Singular or plural nature of returned value depends from the
+    #   singular/plural nature of the chain of relation_names.
+    #
+    # @example
+    #   class AuthorSerializer < BaseSerializer
+    #     lazy_belongs_to :address
+    #     lazy_has_many :rewards
+    #   end
+    #
+    #   class BlogPostSerializer < BaseSerializer
+    #     lazy_belongs_to :author
+    #
+    #     attribute :author_address do
+    #       # returns single AR object or nil
+    #       lazy_dig(:author, :address)&.full_address
+    #     end
+    #
+    #     attribute :author_rewards do
+    #       # returns an array of AR objects
+    #       lazy_dig(:author, :rewards).map(&:description)
+    #     end
+    #   end
+    def lazy_dig(*relation_names)
+      relationships = {
+        multiple: false,
+        data: [{
+          serializer: self.class,
+          object: object
+        }]
+      }
+
+      relation_names.each do |relation_name|
+        lazy_dig_relationship!(relation_name, relationships)
+      end
+
+      objects = relationships[:data].map { |r| r[:object] }
+
+      relationships[:multiple] ? objects : objects.first
+    end
+
+    private
+
+    def lazy_dig_relationship!(relation_name, relationships)
+      relationships[:data].map! do |serializer:, object:|
+        next_objects = lazy_dig_next_objects!(relation_name, serializer, object)
+        next unless next_objects
+
+        relationships[:multiple] ||= next_objects.respond_to?(:to_ary)
+
+        lazy_dig_next_relationships!(relation_name, serializer, next_objects)
+      end
+
+      relationships[:data].flatten!
+      relationships[:data].compact!
+    end
+
+    def lazy_dig_next_objects!(relation_name, serializer, object)
+      serializer&.send(
+        :load_lazy_relationship,
+        relation_name,
+        object
+      )
+    end
+
+    def lazy_dig_next_relationships!(relation_name, serializer, next_objects)
+      Array.wrap(next_objects).map do |next_object|
+        next_serializer = serializer.send(
+          :lazy_serializer_for,
+          next_object,
+          relation_name: relation_name
+        )
+
+        {
+          serializer: next_serializer,
+          object: next_object
+        }
+      end
+    end
+  end
+end

data/lib/ams_lazy_relationships/core/lazy_relationship_method.rb

@@ -39,15 +39,7 @@ module AmsLazyRelationships::Core
       @lazy_relationships[name] = lrm
 
       define_method :"lazy_#{name}" do
-        # We need to evaluate the promise right before serializer tries
-        # to touch it. Otherwise the various side effects can happen:
-        # 1. AMS will attempt to serialize nil values with a specific V1 serializer
-        # 2. `lazy_association ? 'exists' : 'missing'` expression will always
-        #     equal to 'exists'
-        # 3. `lazy_association&.id` expression can raise NullPointer exception
-        #
-        # Calling `__sync` will evaluate the promise.
-        self.class.send(:load_lazy_relationship, lrm, object).__sync
+        self.class.send(:load_lazy_relationship, name, object)
       end
     end
 

data/lib/ams_lazy_relationships/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AmsLazyRelationships
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ams_lazy_relationships
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Jan Bajena
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-08 00:00:00.000000000 Z
+date: 2020-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -306,6 +306,7 @@ files:
 - lib/ams_lazy_relationships.rb
 - lib/ams_lazy_relationships/core.rb
 - lib/ams_lazy_relationships/core/evaluation.rb
+- lib/ams_lazy_relationships/core/lazy_dig_method.rb
 - lib/ams_lazy_relationships/core/lazy_relationship_meta.rb
 - lib/ams_lazy_relationships/core/lazy_relationship_method.rb
 - lib/ams_lazy_relationships/core/relationship_wrapper_methods.rb