identity_cache 0.5.1 → 1.0.0

data/lib/identity_cache/cached/prefetcher.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    module Prefetcher
+      ASSOCIATION_FETCH_EVENT = "association_fetch.identity_cache"
+
+      class << self
+        def prefetch(klass, associations, records, load_strategy: LoadStrategy::Eager)
+          return if (records = records.to_a).empty?
+
+          case associations
+          when Symbol
+            fetch_association(load_strategy, klass, associations, records) {}
+          when Array
+            load_strategy.lazy_load do |lazy_loader|
+              associations.each do |association|
+                prefetch(klass, association, records, load_strategy: lazy_loader)
+              end
+            end
+          when Hash
+            load_strategy.lazy_load do |lazy_loader|
+              associations.each do |association, sub_associations|
+                fetch_association(lazy_loader, klass, association, records) do |next_level_records|
+                  if sub_associations.present?
+                    association_class = klass.reflect_on_association(association).klass
+                    prefetch(association_class, sub_associations, next_level_records, load_strategy: lazy_loader)
+                  end
+                end
+              end
+            end
+          else
+            raise TypeError, "Invalid associations class #{associations.class}"
+          end
+        end
+
+        private
+
+        def fetch_association(load_strategy, klass, association, records, &block)
+          unless records.first.class.should_use_cache?
+            ActiveRecord::Associations::Preloader.new.preload(records, association)
+            return yield
+          end
+
+          cached_association = klass.cached_association(association)
+          cached_association.fetch_async(load_strategy, records, &block)
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/primary_index.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module Cached
+    class PrimaryIndex
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def fetch(id)
+        id = cast_id(id)
+        return unless id
+        record = if model.should_use_cache?
+          object = CacheKeyLoader.load(self, id)
+          if object && object.id != id
+            IdentityCache.logger.error(
+              <<~MSG.squish
+                [IDC id mismatch] fetch_by_id_requested=#{id}
+                fetch_by_id_got=#{object.id}
+                for #{object.inspect[(0..100)]}
+              MSG
+            )
+          end
+          object
+        else
+          load_one_from_db(id)
+        end
+        record
+      end
+
+      def fetch_multi(ids)
+        ids.map! { |id| cast_id(id) }.compact!
+        id_to_record_hash = if model.should_use_cache?
+          id_to_record_hash = CacheKeyLoader.load_multi(self, ids)
+        else
+          load_multi_from_db(ids)
+        end
+        records = ids.map { |id| id_to_record_hash[id] }
+        records.compact!
+        records
+      end
+
+      def expire(id)
+        id = cast_id(id)
+        IdentityCache.cache.delete(cache_key(id))
+      end
+
+      def cache_key(id)
+        "#{model.rails_cache_key_namespace}#{cache_key_prefix}#{id}"
+      end
+
+      def load_one_from_db(id)
+        record = build_query(id).take
+        model.send(:setup_embedded_associations_on_miss, [record]) if record
+        record
+      end
+
+      def load_multi_from_db(ids)
+        return {} if ids.empty?
+
+        ids = ids.map { |id| model.connection.type_cast(id, id_column) }
+        records = build_query(ids).to_a
+        model.send(:setup_embedded_associations_on_miss, records)
+        records.index_by(&:id)
+      end
+
+      def cache_encode(record)
+        Encoder.encode(record)
+      end
+
+      def cache_decode(cache_value)
+        Encoder.decode(cache_value, model)
+      end
+
+      private
+
+      def cast_id(id)
+        model.type_for_attribute(model.primary_key).cast(id)
+      end
+
+      def id_column
+        @id_column ||= model.columns.detect { |c| c.name == model.primary_key }
+      end
+
+      def build_query(id_or_ids)
+        model.where(model.primary_key => id_or_ids).includes(model.send(:cache_fetch_includes))
+      end
+
+      def cache_key_prefix
+        @cache_key_prefix ||= "blob:#{model.base_class.name}:" \
+          "#{IdentityCache::CacheKeyGeneration.denormalized_schema_hash(model)}:"
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/recursive/association.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Recursive
+      class Association < Cached::Association # :nodoc:
+        def initialize(name, reflection:)
+          super
+          @dehydrated_variable_name = :"@dehydrated_#{name}"
+        end
+
+        attr_reader :dehydrated_variable_name
+
+        def build
+          reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{cached_accessor_name}
+              fetch_recursively_cached_association(
+                :#{records_variable_name},
+                :#{dehydrated_variable_name},
+                :#{name}
+              )
+            end
+          RUBY
+
+          ParentModelExpiration.add_parent_expiry_hook(self)
+        end
+
+        def read(record)
+          record.public_send(cached_accessor_name)
+        end
+
+        def write(record, records)
+          record.instance_variable_set(records_variable_name, records)
+        end
+
+        def clear(record)
+          if record.instance_variable_defined?(records_variable_name)
+            record.remove_instance_variable(records_variable_name)
+          end
+        end
+
+        def fetch(records)
+          fetch_async(LoadStrategy::Eager, records) { |child_records| child_records }
+        end
+
+        def fetch_async(load_strategy, records)
+          fetch_embedded_async(load_strategy, records) do
+            yield records.flat_map(&cached_accessor_name).tap(&:compact!)
+          end
+        end
+
+        def embedded_by_reference?
+          false
+        end
+
+        def embedded_recursively?
+          true
+        end
+
+        private
+
+        def embedded_fetched?(records)
+          record = records.first
+          super || record.instance_variable_defined?(dehydrated_variable_name)
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/recursive/has_many.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Recursive
+      class HasMany < Association # :nodoc:
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/recursive/has_one.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Recursive
+      class HasOne < Association # :nodoc:
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/reference/association.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Reference
+      class Association < Cached::Association # :nodoc:
+        def embedded_by_reference?
+          true
+        end
+
+        def embedded_recursively?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/reference/has_many.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Reference
+      class HasMany < Association # :nodoc:
+        def initialize(name, reflection:)
+          super
+          @cached_ids_name = "fetch_#{ids_name}"
+          @ids_variable_name = :"@#{ids_cached_reader_name}"
+        end
+
+        attr_reader :cached_ids_name, :ids_variable_name
+
+        def build
+          reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            attr_reader :#{ids_cached_reader_name}
+
+            def #{cached_ids_name}
+              #{ids_variable_name} ||= #{ids_name}
+            end
+
+            def #{cached_accessor_name}
+              association_klass = association(:#{name}).klass
+              if association_klass.should_use_cache? && !#{name}.loaded?
+                #{records_variable_name} ||= #{reflection.class_name}.fetch_multi(#{cached_ids_name})
+              else
+                #{name}.to_a
+              end
+            end
+          RUBY
+
+          ParentModelExpiration.add_parent_expiry_hook(self)
+        end
+
+        def read(record)
+          record.public_send(cached_ids_name)
+        end
+
+        def write(record, ids)
+          record.instance_variable_set(ids_variable_name, ids)
+        end
+
+        def clear(record)
+          [ids_variable_name, records_variable_name].each do |ivar|
+            if record.instance_variable_defined?(ivar)
+              record.remove_instance_variable(ivar)
+            end
+          end
+        end
+
+        def fetch(records)
+          fetch_async(LoadStrategy::Eager, records) { |child_records| child_records }
+        end
+
+        def fetch_async(load_strategy, records)
+          fetch_embedded_async(load_strategy, records) do
+            ids_to_parent_record = records.each_with_object({}) do |record, hash|
+              child_ids = record.send(cached_ids_name)
+              child_ids.each do |child_id|
+                hash[child_id] = record
+              end
+            end
+
+            load_strategy.load_multi(
+              reflection.klass.cached_primary_index,
+              ids_to_parent_record.keys
+            ) do |child_records_by_id|
+              parent_record_to_child_records = Hash.new { |h, k| h[k] = [] }
+
+              child_records_by_id.each do |id, child_record|
+                parent_record = ids_to_parent_record.fetch(id)
+                parent_record_to_child_records[parent_record] << child_record
+              end
+
+              parent_record_to_child_records.each do |parent, children|
+                parent.instance_variable_set(records_variable_name, children)
+              end
+
+              yield child_records_by_id.values.compact
+            end
+          end
+        end
+
+        private
+
+        def embedded_fetched?(records)
+          record = records.first
+          super || record.instance_variable_defined?(ids_variable_name)
+        end
+
+        def singular_name
+          name.to_s.singularize
+        end
+
+        def ids_name
+          "#{singular_name}_ids"
+        end
+
+        def ids_cached_reader_name
+          "cached_#{ids_name}"
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/cached/reference/has_one.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Cached
+    module Reference
+      class HasOne < Association # :nodoc:
+        def initialize(name, reflection:)
+          super
+          @cached_id_name = "fetch_#{id_name}"
+          @id_variable_name = :"@#{id_cached_reader_name}"
+        end
+
+        attr_reader :cached_id_name, :id_variable_name
+
+        def build
+          reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            attr_reader :#{id_cached_reader_name}
+
+            def #{cached_id_name}
+              return #{id_variable_name} if defined?(#{id_variable_name})
+              #{id_variable_name} = association(:#{name}).scope.ids.first
+            end
+
+            def #{cached_accessor_name}
+              association_klass = association(:#{name}).klass
+              if association_klass.should_use_cache? && !association(:#{name}).loaded?
+                #{records_variable_name} ||= #{reflection.class_name}.fetch(#{cached_id_name}) if #{cached_id_name}
+              else
+                #{name}
+              end
+            end
+          RUBY
+
+          ParentModelExpiration.add_parent_expiry_hook(self)
+        end
+
+        def read(record)
+          record.public_send(cached_id_name)
+        end
+
+        def write(record, id)
+          record.instance_variable_set(id_variable_name, id)
+        end
+
+        def clear(record)
+          [id_variable_name, records_variable_name].each do |ivar|
+            if record.instance_variable_defined?(ivar)
+              record.remove_instance_variable(ivar)
+            end
+          end
+        end
+
+        def fetch(records)
+          fetch_async(LoadStrategy::Eager, records) { |child_records| child_records }
+        end
+
+        def fetch_async(load_strategy, records)
+          fetch_embedded_async(load_strategy, records) do
+            ids_to_parent_record = records.each_with_object({}) do |record, hash|
+              child_id = record.send(cached_id_name)
+              hash[child_id] = record if child_id
+            end
+
+            load_strategy.load_multi(
+              reflection.klass.cached_primary_index,
+              ids_to_parent_record.keys
+            ) do |child_records_by_id|
+              parent_record_to_child_record = {}
+
+              child_records_by_id.each do |id, child_record|
+                parent_record = ids_to_parent_record.fetch(id)
+                parent_record_to_child_record[parent_record] ||= child_record
+              end
+
+              parent_record_to_child_record.each do |parent, child|
+                parent.instance_variable_set(records_variable_name, child)
+              end
+
+              yield child_records_by_id.values.compact
+            end
+          end
+        end
+
+        private
+
+        def embedded_fetched?(records)
+          record = records.first
+          super || record.instance_variable_defined?(id_variable_name)
+        end
+
+        def id_name
+          "#{name}_id"
+        end
+
+        def id_cached_reader_name
+          "cached_#{id_name}"
+        end
+      end
+    end
+  end
+end