iknow_view_models 2.8.4

data/lib/view_model/active_record/association_manipulation.rb

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+# Mix-in for VM::ActiveRecord providing direct manipulation of
+# directly-associated entities. Avoids loading entire collections.
+module ViewModel::ActiveRecord::AssociationManipulation
+  def load_associated(association_name, scope: nil, eager_include: true, serialize_context: self.class.new_serialize_context)
+    association_data = self.class._association_data(association_name)
+    direct_reflection = association_data.direct_reflection
+
+    association = self.model.association(direct_reflection.name)
+    association_scope = association.scope
+
+    if association_data.through?
+      raise ArgumentError.new("Polymorphic through relationships not supported yet") if association_data.polymorphic?
+      associated_viewmodel = association_data.viewmodel_class
+      direct_viewmodel     = association_data.direct_viewmodel
+    else
+      associated_viewmodel = association.klass.try { |k| association_data.viewmodel_class_for_model!(k) }
+      direct_viewmodel     = associated_viewmodel
+    end
+
+    if direct_viewmodel._list_member?
+      association_scope = association_scope.order(direct_viewmodel._list_attribute_name)
+    end
+
+    if association_data.through?
+      association_scope = associated_viewmodel.model_class
+                            .joins(association_data.indirect_reflection.inverse_of.name)
+                            .merge(association_scope)
+    end
+
+    association_scope = association_scope.merge(scope) if scope
+
+    vms = association_scope.map { |model| associated_viewmodel.new(model) }
+
+    if eager_include
+      child_context = self.context_for_child(association_name, context: serialize_context)
+      ViewModel.preload_for_serialization(vms, serialize_context: child_context)
+    end
+
+    if association_data.collection?
+      vms
+    else
+      if vms.size > 1
+        raise ViewModel::DeserializationError::Internal.new("Internal error: encountered multiple records for single association #{association_name}", self.blame_reference)
+      end
+      vms.first
+    end
+  end
+
+  # Replace the current member(s) of an association with the provided hash(es).
+  def replace_associated(association_name, update_hash, references: {}, deserialize_context: self.class.new_deserialize_context)
+    association_data = self.class._association_data(association_name)
+
+    # TODO: structure checking
+
+    if association_data.through? || association_data.shared?
+      is_fupdate =
+        association_data.collection? &&
+        update_hash.is_a?(Hash) &&
+        update_hash[ViewModel::ActiveRecord::TYPE_ATTRIBUTE] == ViewModel::ActiveRecord::FUNCTIONAL_UPDATE_TYPE
+
+      if is_fupdate
+        update_hash[ViewModel::ActiveRecord::ACTIONS_ATTRIBUTE].each_with_index do |action, i|
+          action_type_name = action[ViewModel::ActiveRecord::TYPE_ATTRIBUTE]
+          if action_type_name == ViewModel::ActiveRecord::FunctionalUpdate::Remove::NAME
+            # Remove actions are always type/id refs; others need to be translated to proper refs
+            next
+          end
+
+          association_references = convert_updates_to_references(
+            action[ViewModel::ActiveRecord::VALUES_ATTRIBUTE],
+            key: "#{action_type_name}_#{i}")
+          references.merge!(association_references)
+          action[ViewModel::ActiveRecord::VALUES_ATTRIBUTE] =
+            association_references.each_key.map { |ref| { ViewModel::REFERENCE_ATTRIBUTE => ref } }
+        end
+      else
+        update_hash = ViewModel::Utils.wrap_one_or_many(update_hash) do |sh|
+          association_references = convert_updates_to_references(sh, key: 'replace')
+          references.merge!(association_references)
+          association_references.each_key.map { |ref| { ViewModel::REFERENCE_ATTRIBUTE => ref } }
+        end
+      end
+    end
+
+    root_update_hash = {
+      ViewModel::ID_ATTRIBUTE   => self.id,
+      ViewModel::TYPE_ATTRIBUTE => self.class.view_name,
+      association_name.to_s     => update_hash,
+    }
+
+    root_update_viewmodel = self.class.deserialize_from_view(root_update_hash, references: references, deserialize_context: deserialize_context)
+
+    root_update_viewmodel._read_association(association_name)
+  end
+
+  # Create or update members of a associated collection. For an ordered
+  # collection, the items are inserted either before `before`, after `after`, or
+  # at the end.
+  def append_associated(association_name, subtree_hash_or_hashes, references: {}, before: nil, after: nil, deserialize_context: self.class.new_deserialize_context)
+    if self.changes.changed?
+      raise ArgumentError.new('Invalid call to append_associated on viewmodel with pending changes')
+    end
+
+    association_data = self.class._association_data(association_name)
+    direct_reflection = association_data.direct_reflection
+    raise ArgumentError.new("Cannot append to single association '#{association_name}'") unless association_data.collection?
+
+    ViewModel::Utils.wrap_one_or_many(subtree_hash_or_hashes) do |subtree_hashes|
+      model_class.transaction do
+        ViewModel::Callbacks.wrap_deserialize(self, deserialize_context: deserialize_context) do |hook_control|
+          association_changed!(association_name)
+          deserialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeValidate, self)
+
+          if association_data.through?
+            raise ArgumentError.new("Polymorphic through relationships not supported yet") if association_data.polymorphic?
+
+            direct_viewmodel_class = association_data.direct_viewmodel
+            root_update_data, referenced_update_data = construct_indirect_append_updates(association_data, subtree_hashes, references)
+          else
+            direct_viewmodel_class = association_data.viewmodel_class
+            root_update_data, referenced_update_data = construct_direct_append_updates(association_data, subtree_hashes, references)
+          end
+
+          update_context = ViewModel::ActiveRecord::UpdateContext.build!(root_update_data, referenced_update_data, root_type: direct_viewmodel_class)
+
+          # Provide information about what was updated
+          deserialize_context.updated_associations = root_update_data.map(&:updated_associations)
+                                                       .inject({}) { |acc, assocs| acc.deep_merge(assocs) }
+
+          # Set new parent
+          new_parent = ViewModel::ActiveRecord::UpdateOperation::ParentData.new(direct_reflection.inverse_of, self)
+          update_context.root_updates.each { |update| update.reparent_to = new_parent }
+
+          # Set place in list.
+          if direct_viewmodel_class._list_member?
+            new_positions = select_append_positions(association_data,
+                                                    direct_viewmodel_class._list_attribute_name,
+                                                    update_context.root_updates.count,
+                                                    before: before, after: after)
+
+            update_context.root_updates.zip(new_positions).each do |update, new_pos|
+              update.reposition_to = new_pos
+            end
+          end
+
+          # Because append_associated can take from other parents, edit-check previous parents (other than this model)
+          unless association_data.through?
+            inverse_assoc_name = direct_reflection.inverse_of.name
+
+            previous_parent_ids = Set.new
+            update_context.root_updates.each do |update|
+              update_model    = update.viewmodel.model
+              parent_model_id = update_model.read_attribute(update_model
+                                                              .association(inverse_assoc_name)
+                                                              .reflection.foreign_key)
+
+              if parent_model_id && parent_model_id != self.id
+                previous_parent_ids << parent_model_id
+              end
+            end
+
+            if previous_parent_ids.present?
+              previous_parents = self.class.find(previous_parent_ids.to_a, eager_include: false)
+
+              previous_parents.each do |parent_view|
+                ViewModel::Callbacks.wrap_deserialize(parent_view, deserialize_context: deserialize_context) do |pp_hook_control|
+                  changes = ViewModel::Changes.new(changed_associations: [association_name])
+                  deserialize_context.run_callback(ViewModel::Callbacks::Hook::OnChange, parent_view, changes: changes)
+                  pp_hook_control.record_changes(changes)
+                end
+              end
+            end
+          end
+
+          child_context = self.context_for_child(association_name, context: deserialize_context)
+          updated_viewmodels = update_context.run!(deserialize_context: child_context)
+
+          if association_data.through?
+            updated_viewmodels.map! do |direct_vm|
+              direct_vm._read_association(association_data.indirect_reflection.name)
+            end
+          end
+
+          # Finalize the parent
+          final_changes = self.clear_changes!
+
+          # Could happen if hooks attempted to change the parent, which aren't
+          # valid since we're only editing children here.
+          unless final_changes.contained_to?(associations: [association_name.to_s])
+            raise ViewModel::DeserializationError::InvalidParentEdit.new(final_changes, blame_reference)
+          end
+
+          deserialize_context.run_callback(ViewModel::Callbacks::Hook::OnChange, self, changes: final_changes)
+          hook_control.record_changes(final_changes)
+
+          updated_viewmodels
+        end
+      end
+    end
+  end
+
+  # Removes the association between the models represented by this viewmodel and
+  # the provided associated viewmodel. The associated model will be
+  # garbage-collected if the assocation is specified with `dependent: :destroy`
+  # or `:delete_all`
+  def delete_associated(association_name, associated_id, type: nil, deserialize_context: self.class.new_deserialize_context)
+    if self.changes.changed?
+      raise ArgumentError.new('Invalid call to delete_associated on viewmodel with pending changes')
+    end
+
+    association_data = self.class._association_data(association_name)
+    direct_reflection = association_data.direct_reflection
+
+    unless association_data.collection?
+      raise ArgumentError.new("Cannot remove element from single association '#{association_name}'")
+    end
+
+    check_association_type!(association_data, type)
+    target_ref = ViewModel::Reference.new(type || association_data.viewmodel_class, associated_id)
+
+    model_class.transaction do
+      ViewModel::Callbacks.wrap_deserialize(self, deserialize_context: deserialize_context) do |hook_control|
+        association_changed!(association_name)
+        deserialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeValidate, self)
+
+        association = self.model.association(direct_reflection.name)
+        association_scope = association.scope
+
+        if association_data.through?
+          raise ArgumentError.new('Polymorphic through relationships not supported yet') if association_data.polymorphic?
+
+          direct_viewmodel = association_data.direct_viewmodel
+          association_scope = association_scope.where(association_data.indirect_reflection.foreign_key => associated_id)
+        else
+          # viewmodel type for current association: nil in case of empty polymorphic association
+          direct_viewmodel = association.klass.try { |k| association_data.viewmodel_class_for_model!(k) }
+
+          if association_data.pointer_location == :local
+            # If we hold the pointer, we can immediately check if the type and id match.
+            if target_ref != ViewModel::Reference.new(direct_viewmodel, model.read_attribute(direct_reflection.foreign_key))
+              raise ViewModel::DeserializationError::AssociatedNotFound.new(association_name.to_s, target_ref, blame_reference)
+            end
+          else
+            # otherwise add the target constraint to the association scope
+            association_scope = association_scope.where(id: associated_id)
+          end
+        end
+
+        models = association_scope.to_a
+
+        if models.blank?
+          raise ViewModel::DeserializationError::AssociatedNotFound.new(association_name.to_s, target_ref, blame_reference)
+        elsif models.size > 1
+          raise ViewModel::DeserializationError::Internal.new(
+                  "Internal error: encountered multiple records for #{target_ref} in association #{association_name}",
+                  blame_reference)
+        end
+
+        child_context = self.context_for_child(association_name, context: deserialize_context)
+        child_vm = direct_viewmodel.new(models.first)
+
+        ViewModel::Callbacks.wrap_deserialize(child_vm, deserialize_context: child_context) do |child_hook_control|
+          changes = ViewModel::Changes.new(deleted: true)
+          child_context.run_callback(ViewModel::Callbacks::Hook::OnChange, child_vm, changes: changes)
+          child_hook_control.record_changes(changes)
+
+          association.delete(child_vm.model)
+        end
+
+        self.children_changed!
+        final_changes = self.clear_changes!
+
+        unless final_changes.contained_to?(associations: [association_name.to_s])
+          raise ViewModel::DeserializationError::InvalidParentEdit.new(final_changes, blame_reference)
+        end
+
+        deserialize_context.run_callback(ViewModel::Callbacks::Hook::OnChange, self, changes: final_changes)
+        hook_control.record_changes(final_changes)
+
+        child_vm
+      end
+    end
+  end
+
+  private
+
+  def construct_direct_append_updates(association_data, subtree_hashes, references)
+    ViewModel::ActiveRecord::UpdateData.parse_hashes(subtree_hashes, references)
+  end
+
+  def construct_indirect_append_updates(association_data, subtree_hashes, references)
+    indirect_reflection = association_data.indirect_reflection
+    direct_viewmodel_class = association_data.direct_viewmodel
+
+    # Construct updates for the provided indirectly-associated hashes
+    indirect_update_data, referenced_update_data = ViewModel::ActiveRecord::UpdateData.parse_hashes(subtree_hashes, references)
+
+    # Convert associated update data to references
+    indirect_references = convert_updates_to_references(indirect_update_data, key: 'indirect_append')
+    referenced_update_data.merge!(indirect_references)
+
+    # Find any existing models for the direct association: need to re-use any
+    # existing join-table entries, to maintain single membership of each
+    # associate.
+    # TODO: this won't handle polymorphic associations! In the case of polymorphism,
+    #       need to join on (type, id) pairs instead.
+    if association_data.polymorphic?
+      raise ArgumentError.new("Internal error: append_association is not yet supported for polymorphic indirect associations")
+    end
+
+    existing_indirect_associates = indirect_update_data.map { |upd| upd.id unless upd.new? }.compact
+
+    direct_association_scope = model.association(association_data.direct_reflection.name).scope
+
+    existing_direct_ids = direct_association_scope
+                            .where(indirect_reflection.foreign_key => existing_indirect_associates)
+                            .pluck(indirect_reflection.foreign_key, :id)
+                            .to_h
+
+    direct_update_data = indirect_references.map do |ref_name, update|
+      existing_id = existing_direct_ids[update.id] unless update.new?
+
+      metadata = ViewModel::Metadata.new(existing_id,
+                                         direct_viewmodel_class.view_name,
+                                         direct_viewmodel_class.schema_version,
+                                         existing_id.nil?)
+
+      ViewModel::ActiveRecord::UpdateData.new(
+        direct_viewmodel_class,
+        metadata,
+        { indirect_reflection.name.to_s => { ViewModel::REFERENCE_ATTRIBUTE => ref_name }},
+        [ref_name])
+    end
+
+    return direct_update_data, referenced_update_data
+  end
+
+  def convert_updates_to_references(indirect_update_data, key:)
+    indirect_update_data.each.with_index.with_object({}) do |(update, i), indirect_references|
+      indirect_references["__#{key}_ref_#{i}"] = update
+    end
+  end
+
+  # TODO: this functionality could reasonably be extracted into `acts_as_manual_list`.
+  def select_append_positions(association_data, position_attr, append_count, before:, after:)
+    direct_reflection = association_data.direct_reflection
+    association_scope = model.association(direct_reflection.name).scope
+
+    search_key =
+      if association_data.through?
+        association_data.indirect_reflection.foreign_key
+      else
+        :id
+      end
+
+    if (relative_ref = (before || after))
+      relative_target = association_scope.where(search_key => relative_ref.model_id).select(:position)
+      if before
+        end_pos, start_pos = association_scope.where("#{position_attr} <= (?)", relative_target).order("#{position_attr} DESC").limit(2).pluck(:position)
+      else
+        start_pos, end_pos = association_scope.where("#{position_attr} >= (?)", relative_target).order("#{position_attr} ASC").limit(2).pluck(:position)
+      end
+
+      if start_pos.nil? && end_pos.nil?
+        # Attempted to insert relative to ref that's not in the association
+        raise ViewModel::DeserializationError::AssociatedNotFound.new(association_data.association_name.to_s,
+                                                                      relative_ref,
+                                                                      blame_reference)
+      end
+    else
+      start_pos = association_scope.maximum(position_attr)
+      end_pos   = nil
+    end
+
+    ActsAsManualList.select_positions(start_pos, end_pos, append_count)
+  end
+
+  def check_association_type!(association_data, type)
+    if type && !association_data.accepts?(type)
+      raise ViewModel::SerializationError.new(
+              "Type error: association '#{direct_reflection.name}' can't refer to viewmodel #{type.view_name}")
+    elsif association_data.polymorphic? && !type
+      raise ViewModel::SerializationError.new(
+              "Need to specify target viewmodel type for polymorphic association '#{direct_reflection.name}'")
+    end
+  end
+end

data/lib/view_model/active_record/cache.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'iknow_cache'
+
+# Cache for ViewModels that wrap ActiveRecord models.
+class ViewModel::ActiveRecord::Cache
+  require 'view_model/active_record/cache/cacheable_view'
+
+  class UncacheableViewModelError < RuntimeError; end
+
+  attr_reader :viewmodel_class
+
+  # If cache_group: is specified, it must be a group of a single key: `:id`
+  def initialize(viewmodel_class, cache_group: nil)
+    @viewmodel_class = viewmodel_class
+    @cache_group = cache_group || create_default_cache_group # requires @viewmodel_class
+    @cache = @cache_group.register_cache(cache_name)
+  end
+
+  def delete(*ids)
+    ids.each do |id|
+      @cache_group.delete_all(key_for(id))
+    end
+  end
+
+  def clear
+    @cache_group.invalidate_cache_group
+  end
+
+  def fetch_by_viewmodel(viewmodels, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
+    ids = viewmodels.map(&:id)
+    fetch(ids, initial_viewmodels: viewmodels, locked: false, serialize_context: serialize_context)
+  end
+
+  def fetch(ids, initial_viewmodels: nil, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
+    data_serializations = Array.new(ids.size)
+    worker = CacheWorker.new(serialize_context: serialize_context)
+
+    # If initial root viewmodels were provided, visit them to ensure that they
+    # are visible. Other than this, no traversal callbacks are performed, as a
+    # view may be resolved from the cache without ever loading its viewmodel.
+    # Note that if unlocked, these views will be reloaded as part of obtaining a
+    # share lock. If the visibility of this viewmodel can change due to edits,
+    # it is necessary to obtain a lock before calling `fetch`.
+    initial_viewmodels&.each do |v|
+      serialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeVisit, v)
+      serialize_context.run_callback(ViewModel::Callbacks::Hook::AfterVisit, v)
+    end
+
+    # Collect input array positions for each id, allowing duplicates
+    positions = ids.each_with_index.with_object({}) do |(id, i), h|
+      (h[id] ||= []) << i
+    end
+
+    # Fetch duplicates only once
+    ids = positions.keys
+
+    # Load existing serializations from the cache
+    cached_serializations = worker.load_from_cache(self, ids)
+    cached_serializations.each do |id, data|
+      positions[id].each do |idx|
+        data_serializations[idx] = data
+      end
+    end
+
+    # Resolve and serialize missing views
+    missing_ids = ids.to_set.subtract(cached_serializations.keys)
+
+    # If initial viewmodels have been locked, we can serialize them for cache
+    #  misses.
+    available_viewmodels =
+      if locked
+        initial_viewmodels&.each_with_object({}) do |vm, h|
+          h[vm.id] = vm if missing_ids.include?(vm.id)
+        end
+      end
+
+    @viewmodel_class.transaction do
+      # Load remaining views and serialize
+      viewmodels = worker.find_and_preload_viewmodels(@viewmodel_class, missing_ids.to_a,
+                                                      available_viewmodels: available_viewmodels)
+
+      loaded_serializations = worker.serialize_and_cache(viewmodels)
+      loaded_serializations.each do |id, data|
+        positions[id].each do |idx|
+          data_serializations[idx] = data
+        end
+      end
+
+      # Resolve references
+      worker.resolve_references!
+
+      return data_serializations, worker.resolved_references
+    end
+  end
+
+  class CacheWorker
+    SENTINEL = Object.new
+    WorklistEntry = Struct.new(:ref_name, :viewmodel)
+
+    attr_reader :serialize_context, :resolved_references
+
+    def initialize(serialize_context:)
+      @worklist            = {}
+      @resolved_references = {}
+      @serialize_context   = serialize_context
+    end
+
+    def resolve_references!
+      @serialize_context = serialize_context.for_references
+
+      while @worklist.present?
+        type_name, required_entries = @worklist.shift
+        viewmodel_class = ViewModel::Registry.for_view_name(type_name)
+
+        required_entries.each do |_id, entry|
+          @resolved_references[entry.ref_name] = SENTINEL
+        end
+
+        if viewmodel_class < CacheableView
+          cached_serializations = load_from_cache(viewmodel_class.viewmodel_cache, required_entries.keys)
+          cached_serializations.each do |id, data|
+            ref_name = required_entries.delete(id).ref_name
+            @resolved_references[ref_name] = data
+          end
+        end
+
+        # Load remaining entries from database
+        available_viewmodels = required_entries.each_with_object({}) do |(id, entry), h|
+          h[id] = entry.viewmodel if entry.viewmodel
+        end
+
+        viewmodels = find_and_preload_viewmodels(viewmodel_class, required_entries.keys,
+                                                 available_viewmodels: available_viewmodels)
+
+        loaded_serializations = serialize_and_cache(viewmodels)
+        loaded_serializations.each do |id, data|
+          ref_name = required_entries[id].ref_name
+          @resolved_references[ref_name] = data
+        end
+      end
+    end
+
+    # Loads the specified entities from the cache and returns a hash of
+    # {id=>serialized_view}. Any references encountered are added to the
+    # worklist.
+    def load_from_cache(viewmodel_cache, ids)
+      cached_serializations = viewmodel_cache.load(ids, serialize_context: serialize_context)
+
+      cached_serializations.each_with_object({}) do |(id, cached_serialization), result|
+        add_refs_to_worklist(cached_serialization[:ref_cache])
+        result[id] = cached_serialization[:data]
+      end
+    end
+
+    # Serializes the specified preloaded viewmodels and returns a hash of
+    # {id=>serialized_view}. If the viewmodel type is cacheable, it will be
+    # added to the cache. Any references encountered during serialization are
+    # added to the worklist.
+    def serialize_and_cache(viewmodels)
+      viewmodels.each_with_object({}) do |viewmodel, result|
+        data_serialization = Jbuilder.encode do |json|
+          ViewModel.serialize(viewmodel, json, serialize_context: serialize_context)
+        end
+
+        referenced_viewmodels = serialize_context.extract_referenced_views!
+        add_viewmodels_to_worklist(referenced_viewmodels)
+
+        if viewmodel.class < CacheableView
+          cacheable_references = referenced_viewmodels.transform_values { |vm| cacheable_reference(vm) }
+          viewmodel.class.viewmodel_cache.store(viewmodel.id, data_serialization, cacheable_references,
+                                                serialize_context: serialize_context)
+        end
+
+        result[viewmodel.id] = data_serialization
+      end
+    end
+
+    # Resolves viewmodels for the provided ids from the database or
+    # available_viewmodels and shallowly preloads them.
+    def find_and_preload_viewmodels(viewmodel_class, ids, available_viewmodels: nil)
+      viewmodels = []
+
+      if available_viewmodels.present?
+        ids = ids.reject do |id|
+          if (vm = available_viewmodels[id])
+            viewmodels << vm
+          end
+        end
+      end
+
+      if ids.present?
+        found = viewmodel_class.find(ids,
+                                     eager_include: false,
+                                     lock: "FOR SHARE",
+                                     serialize_context: serialize_context)
+        viewmodels.concat(found)
+      end
+
+      ViewModel.preload_for_serialization(viewmodels,
+                                          include_shared: false,
+                                          lock: "FOR SHARE",
+                                          serialize_context: serialize_context)
+
+      viewmodels
+    end
+
+    # Store VM references in the cache as viewmodel name + id pairs.
+    def cacheable_reference(viewmodel)
+      [viewmodel.class.view_name, viewmodel.id]
+    end
+
+    def add_refs_to_worklist(cacheable_references)
+      cacheable_references.each do |ref_name, (type, id)|
+        next if resolved_references.has_key?(ref_name)
+        (@worklist[type] ||= {})[id] = WorklistEntry.new(ref_name, nil)
+      end
+    end
+
+    def add_viewmodels_to_worklist(referenced_viewmodels)
+      referenced_viewmodels.each do |ref_name, viewmodel|
+        next if resolved_references.has_key?(ref_name)
+        (@worklist[viewmodel.class.view_name] ||= {})[viewmodel.id] = WorklistEntry.new(ref_name, viewmodel)
+      end
+    end
+  end
+
+  def key_for(id)
+    cache.key.new(id)
+  end
+
+  def id_for(key)
+    key[:id]
+  end
+
+  # Save the provided serialization and reference data in the cache
+  def store(id, data_serialization, ref_cache, serialize_context:)
+    cache.write(key_for(id), { data: data_serialization, ref_cache: ref_cache })
+  end
+
+  def load(ids, serialize_context:)
+    keys = ids.map { |id| key_for(id) }
+    results = cache.read_multi(keys)
+    results.transform_keys! { |key| id_for(key) }
+  end
+
+  private
+
+  attr_reader :cache
+
+  def create_default_cache_group
+    IknowCache.register_group(@viewmodel_class.name, :id)
+  end
+
+  # Statically version the terminal cache based on the deep schema versions of
+  # the constituent viewmodels, so that viewmodel changes force invalidation.
+  def cache_name
+    "#{@viewmodel_class.name}_#{cache_version}"
+  end
+
+  def cache_version
+    version_string = @viewmodel_class.deep_schema_version(include_shared: false).to_a.sort.join(',')
+    Base64.urlsafe_encode64(Digest::MD5.digest(version_string))
+  end
+end