ams_lazy_relationships 0.1.4 → 0.3.2

data/lib/ams_lazy_relationships/core/lazy_relationship_method.rb

@@ -39,7 +39,7 @@ module AmsLazyRelationships::Core
       @lazy_relationships[name] = lrm
 
       define_method :"lazy_#{name}" do
-        self.class.send(:load_lazy_relationship, lrm, object)
+        self.class.send(:load_lazy_relationship, name, object)
       end
     end
 

data/lib/ams_lazy_relationships/core/relationship_wrapper_methods.rb

@@ -19,7 +19,7 @@ module AmsLazyRelationships::Core
         define_singleton_method(
           "lazy_#{relationship_type}"
         ) do |relationship_name, options = {}, &block|
-          send(:define_lazy_association, relationship_type, relationship_name, options, block)
+          define_lazy_association(relationship_type, relationship_name, options, block)
         end
       end
     end
@@ -29,17 +29,22 @@ module AmsLazyRelationships::Core
 
       real_relationship_options = options.except(*lazy_relationship_option_keys)
 
-      block ||= lambda do |serializer|
-        # We need to evaluate the promise right before AMS tries
-        # to serialize it. Otherwise AMS will attempt to serialize nil values
-        # with a specific V1 serializer.
-        # Calling `itself` will evaluate the promise.
-        serializer.public_send("lazy_#{name}").tap(&:itself)
-      end
+      public_send(type, name.to_sym, real_relationship_options) do |serializer|
+        block_value = instance_exec(serializer, &block) if block
 
-      public_send(type, name.to_sym, real_relationship_options, &block)
+        if block && block_value != :nil
+          # respect the custom finder for lazy association
+          # @see https://github.com/rails-api/active_model_serializers/blob/v0.10.10/lib/active_model/serializer/reflection.rb#L165-L168
+          block_value
+        else
+          # provide default lazy association finder in a form of lambda,
+          # in order to play nice with possible `include_data` setting.
+          # @see lib/ams_lazy_relationships/extensions/reflection.rb
+          serializer.method("lazy_#{name}")
+        end
+      end
 
-      lazy_relationship(name, options.slice(*lazy_relationship_option_keys))
+      lazy_relationship(name, **options.slice(*lazy_relationship_option_keys))
     end
   end
 end

data/lib/ams_lazy_relationships/extensions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "ams_lazy_relationships/extensions/reflection"
+
+module AmsLazyRelationships
+  module Extensions
+  end
+end

data/lib/ams_lazy_relationships/extensions/reflection.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# There is a general problem inside AMS related to custom association finder
+# combined with `include_data` setting:
+#
+#   class BlogPostSerializer < BaseSerializer
+#     belongs_to :category do
+#       include_data :if_sideloaded
+#       object.categories.last
+#     end
+#   end
+#
+# The problem is that `belongs_to` block will be fully evaluated each time for
+# each object, and only after that AMS is able to take into account
+# `include_data` mode -
+# https://github.com/rails-api/active_model_serializers/blob/v0.10.10/lib/active_model/serializer/reflection.rb#L162-L163
+#
+#   def value(serializer, include_slice)
+#     # ...
+#     block_value = instance_exec(serializer, &block) if block
+#     return unless include_data?(include_slice)
+#     # ...
+#   end
+#
+# That causing redundant (and so huge potentially!) SQL queries and AR objects
+# allocation when `include_data` appears to be `false` but `belongs_to` block
+# defines instant (not a kind of AR::Relation) custom association finder.
+#
+# Described problem is a very specific use case for pure AMS applications.
+# The bad news is that `ams_lazy_relationships` always utilizes the
+# association block -
+# https://github.com/Bajena/ams_lazy_relationships/blob/v0.2.0/lib/ams_lazy_relationships/core/relationship_wrapper_methods.rb#L32-L36
+#
+# def define_lazy_association(type, name, options, block)
+#   #...
+#   block ||= lambda do |serializer|
+#     serializer.public_send("lazy_#{name}")
+#   end
+#
+#   public_send(type, name.to_sym, real_relationship_options, &block)
+#   #...
+# end
+#
+# This way we break `include_data` optimizations for the host application.
+#
+# In order to overcome that we are forced to monkey-patch
+# `AmsLazyRelationships::Extensions::Reflection#value` method and make it to be
+# ready for Proc returned by association block. This way we will use a kind of
+#
+#   block ||= lambda do |serializer|
+#     -> { serializer.public_send("lazy_#{name}") }
+#   end
+#
+# as association block, then AMS will evaluate it, get the value of `include_data`
+# setting, make a decision do we need to continue with that association, if so -
+# will finally evaluate the proc with lazy relationship inside it.
+
+module AmsLazyRelationships
+  module Extensions
+    module Reflection
+      def value(*)
+        case (block_value = super)
+        when Proc, Method then block_value.call
+        else block_value
+        end
+      end
+    end
+  end
+end
+
+::ActiveModel::Serializer::Reflection.prepend AmsLazyRelationships::Extensions::Reflection

data/lib/ams_lazy_relationships/loaders/association.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "ams_lazy_relationships/loaders/base"
+
 module AmsLazyRelationships
   module Loaders
     # Lazy loads (has_one/has_many/has_many_through/belongs_to) ActiveRecord
     # associations for ActiveRecord models
-    class Association
+    class Association < Base
       # @param model_class_name [String] The name of AR class for which the
       #   associations are loaded. E.g. When loading comment.blog_post
       #   it'd be "BlogPost".
@@ -15,31 +17,13 @@ module AmsLazyRelationships
         @association_name = association_name
       end
 
-      # Lazy loads and yields the data when evaluating
-      # @param record [Object] an object for which we're loading the data
-      # @param block [Proc] a block to execute when data is evaluated.
-      #  Loaded data is yielded as a block argument.
-      def load(record, &block)
-        BatchLoader.for(record).batch(key: batch_key, replace_methods: false) do |records, loader|
-          data = load_data(records, loader)
-
-          block&.call(data)
-        end
-      end
-
       private
 
       attr_reader :model_class_name, :association_name
 
       def load_data(records, loader)
-        # It may happen that same record comes here twice (e.g. wrapped
-        # in a decorator and non-wrapped). In this case Associations::Preloader
-        # stores duplicated records in has_many relationships for some reason.
-        # Calling uniq(&:id) solves the problem.
-        records_to_preload = records.uniq(&:id)
-
         ::ActiveRecord::Associations::Preloader.new.preload(
-          records_to_preload, association_name
+          records_to_preload(records), association_name
         )
 
         data = []
@@ -52,8 +36,28 @@ module AmsLazyRelationships
         data = data.flatten.compact.uniq
       end
 
-      def batch_key
-        "#{model_class_name}/#{association_name}"
+      def batch_key(_)
+        @batch_key ||= "#{model_class_name}/#{association_name}"
+      end
+
+      def records_to_preload(records)
+        # It may happen that same record comes here twice (e.g. wrapped
+        # in a decorator and non-wrapped). In this case Associations::Preloader
+        # stores duplicated records in has_many relationships for some reason.
+        # Calling uniq(&:id) solves the problem.
+        #
+        # One more case when duplicated records appear in has_many relationships
+        # is the recent assignation to `accept_nested_attributes_for` setter.
+        # ActiveRecord will not mark the association as `loaded` but in same
+        # time will keep internal representation of the nested records created
+        # by `accept_nested_attributes_for`. Then Associations::Preloader is
+        # going to merge internal state of associated records with the same
+        # records recently stored in DB. `r.association(association_name).reset`
+        # effectively fixes that.
+        records.
+          uniq(&:id).
+          reject { |r| r.association(association_name).loaded? }.
+          each { |r| r.association(association_name).reset }
       end
     end
   end

data/lib/ams_lazy_relationships/loaders/base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module AmsLazyRelationships
+  module Loaders
+    # A base class for all the loaders. A correctly defined loader requires
+    # the `load_data` and `batch_key` methods.
+    class Base
+      # Lazy loads and yields the data when evaluating
+      # @param record [Object] an object for which we're loading the data
+      # @param block [Proc] a block to execute when data is evaluated.
+      #  Loaded data is yielded as a block argument.
+      def load(record, &block)
+        BatchLoader.for(record).batch(
+          key: batch_key(record),
+          # Replacing methods can be costly, especially on objects with lots
+          # of methods (like AR methods). Let's disable it.
+          # More info:
+          # https://github.com/exAspArk/batch-loader/tree/v1.4.1#replacing-methods
+          replace_methods: false
+        ) do |records, loader|
+          data = load_data(records, loader)
+
+          block&.call(data)
+        end
+      end
+
+      protected
+
+      # Loads required data for all records gathered by the batch loader.
+      # Assigns data to records by calling the `loader` lambda.
+      # @param records [Array<Object>] Array of all gathered records.
+      # @param loader [Proc] Proc used for assigning the batch loaded data to
+      #   records. First argument is the record and the second is the data
+      #   loaded for it.
+      # @returns [Array<Object>] Array of loaded objects
+      def load_data(_records, _loader)
+        raise "Implement in child"
+      end
+
+      # Computes a batching key based on currently evaluated record
+      # @param record [Object]
+      # @returns [String] Batching key
+      def batch_key(_record)
+        raise "Implement in child"
+      end
+    end
+  end
+end

data/lib/ams_lazy_relationships/loaders/direct.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "ams_lazy_relationships/loaders/base"
+
 module AmsLazyRelationships
   module Loaders
     # Lazy loads data in a "dumb" way - just executes the provided block when needed
-    class Direct
+    class Direct < Base
       # @param relationship_name [Symbol] used for building cache key. Also if the
       #   `load_block` param is `nil` the loader will just call `relationship_name`
       #   method on the record being processed.
@@ -14,30 +16,22 @@ module AmsLazyRelationships
         @load_block = load_block
       end
 
-      # Lazy loads and yields the data when evaluating
-      # @param record [Object] an object for which we're loading the data
-      # @param block [Proc] a block to execute when data is evaluated.
-      #  Loaded data is yielded as a block argument.
-      def load(record, &block)
-        BatchLoader.for(record).batch(key: cache_key(record), replace_methods: false) do |records, loader|
-          data = []
-          records.each do |r|
-            value = calculate_value(r)
-            data << value
-            loader.call(r, value)
-          end
-
-          data = data.flatten.compact.uniq
-
-          block&.call(data)
-        end
-      end
-
       private
 
       attr_reader :relationship_name, :load_block
 
-      def cache_key(record)
+      def load_data(records, loader)
+        data = []
+        records.each do |r|
+          value = calculate_value(r)
+          data << value
+          loader.call(r, value)
+        end
+
+        data = data.flatten.compact.uniq
+      end
+
+      def batch_key(record)
         "#{record.class}/#{relationship_name}"
       end
 

data/lib/ams_lazy_relationships/loaders/simple_belongs_to.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "ams_lazy_relationships/loaders/base"
+
 module AmsLazyRelationships
   module Loaders
     # Batch loads parent ActiveRecord records for given record by foreign key.
     # Useful when the relationship is not a standard ActiveRecord relationship.
-    class SimpleBelongsTo
+    class SimpleBelongsTo < Base
       # @param association_class_name [String] The name of AR class being the parent
       #   record of the records being loaded. E.g. When loading comment.blog_post
       #   it'd be "BlogPost".
@@ -18,25 +20,11 @@ module AmsLazyRelationships
         @foreign_key = foreign_key.to_sym
       end
 
-      # Lazy loads and yields the data when evaluating
-      # @param record [Object] an object for which we're loading the belongs to data
-      # @param block [Proc] a block to execute when data is evaluated
-      #  Loaded data is yielded as a block argument.
-      def load(record, &block)
-        BatchLoader.for(record).batch(key: cache_key(record), replace_methods: false) do |records, loader|
-          data = load_data(records)
-
-          block&.call(data)
-
-          resolve(records, data, loader)
-        end
-      end
-
       private
 
       attr_reader :association_class_name, :foreign_key
 
-      def load_data(records)
+      def load_data(records, loader)
         data_ids = records.map(&foreign_key).compact.uniq
         data = if data_ids.present?
                  association_class_name.constantize.where(id: data_ids)
@@ -44,6 +32,8 @@ module AmsLazyRelationships
                  []
                end
 
+        resolve(records, data, loader)
+
         data
       end
 
@@ -56,7 +46,7 @@ module AmsLazyRelationships
         end
       end
 
-      def cache_key(record)
+      def batch_key(record)
         "#{record.class}/#{association_class_name}"
       end
     end

data/lib/ams_lazy_relationships/loaders/simple_has_many.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "ams_lazy_relationships/loaders/base"
+
 module AmsLazyRelationships
   module Loaders
     # Batch loads ActiveRecord records belonging to given record by foreign key.
     # Useful when the relationship is not a standard ActiveRecord relationship.
-    class SimpleHasMany
+    class SimpleHasMany < Base
       # @param association_class_name [String] Name of the ActiveRecord class
       #   e.g. in case when loading blog_post.comments it'd be "Comment"
       # @param foreign_key [Symbol] association's foreign key.
@@ -14,31 +16,18 @@ module AmsLazyRelationships
         @foreign_key = foreign_key.to_sym
       end
 
-      # Lazy loads and yields the data when evaluating
-      # @param record [Object] an object for which we're loading the has many data
-      # @param block [Proc] a block to execute when data is evaluated.
-      #  Loaded data is yielded as a block argument.
-      def load(record, &block)
-        key = "#{record.class}/#{association_class_name}"
-        BatchLoader.for(record).batch(key: key, replace_methods: false) do |records, loader|
-          data = load_data(records)
-
-          block&.call(data)
-
-          resolve(records, data, loader)
-        end
-      end
-
       private
 
       attr_reader :association_class_name, :foreign_key
 
-      def load_data(records)
+      def load_data(records, loader)
         # Some records use UUID class as id - it's safer to cast them to strings
         record_ids = records.map { |r| r.id.to_s }
         association_class_name.constantize.where(
           foreign_key => record_ids
-        )
+        ).tap do |data|
+          resolve(records, data, loader)
+        end
       end
 
       def resolve(records, data, loader)
@@ -48,6 +37,10 @@ module AmsLazyRelationships
           loader.call(r, data[r.id.to_s] || [])
         end
       end
+
+      def batch_key(record)
+        "#{record.class}/#{association_class_name}"
+      end
     end
   end
 end

data/lib/ams_lazy_relationships/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ams_lazy_relationships
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.2
 platform: ruby
 authors:
 - Jan Bajena
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-02 00:00:00.000000000 Z
+date: 2021-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.10.0.rc4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.10.0.rc4
 - !ruby/object:Gem::Dependency
   name: batch-loader
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +66,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.17'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: db-query-matchers
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +128,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -238,16 +224,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: undercover
   requirement: !ruby/object:Gem::Requirement
@@ -266,16 +252,30 @@ dependencies:
   name: with_model
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-memory
   requirement: !ruby/object:Gem::Requirement
@@ -314,17 +314,26 @@ files:
 - bin/console
 - bin/setup
 - gemfiles/.bundle/config
+- gemfiles/ams_0.10.0.gemfile
 - gemfiles/ams_0.10.0.rc4.gemfile
+- gemfiles/ams_0.10.10.gemfile
 - gemfiles/ams_0.10.2.gemfile
+- gemfiles/ams_0.10.3.gemfile
 - gemfiles/ams_0.10.8.gemfile
+- gemfiles/batch_loader_1.gemfile
+- gemfiles/batch_loader_2.gemfile
 - 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
+- lib/ams_lazy_relationships/extensions.rb
+- lib/ams_lazy_relationships/extensions/reflection.rb
 - lib/ams_lazy_relationships/loaders.rb
 - lib/ams_lazy_relationships/loaders/association.rb
+- lib/ams_lazy_relationships/loaders/base.rb
 - lib/ams_lazy_relationships/loaders/direct.rb
 - lib/ams_lazy_relationships/loaders/simple_belongs_to.rb
 - lib/ams_lazy_relationships/loaders/simple_has_many.rb
@@ -351,8 +360,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: ActiveModel Serializers addon for eliminating N+1 queries problem from the