iknow_view_models 2.8.4

data/lib/view_model/access_control_error.rb

@@ -0,0 +1,10 @@
+class ViewModel::AccessControlError < ViewModel::AbstractErrorWithBlame
+  attr_reader :detail
+  status 403
+  code "AccessControl.Forbidden"
+
+  def initialize(detail, nodes = [])
+    @detail = detail
+    super(nodes)
+  end
+end

data/lib/view_model/active_record.rb

@@ -0,0 +1,383 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_record"
+
+require "view_model"
+require "view_model/record"
+
+require "lazily"
+require "concurrent"
+
+class ViewModel::ActiveRecord < ViewModel::Record
+  # Defined before requiring components so components can refer to them at parse time
+
+  # for functional updates
+  FUNCTIONAL_UPDATE_TYPE = "_update"
+  ACTIONS_ATTRIBUTE      = "actions"
+  VALUES_ATTRIBUTE       = "values"
+  BEFORE_ATTRIBUTE       = "before"
+  AFTER_ATTRIBUTE        = "after"
+
+  require 'view_model/utils/collections'
+  require 'view_model/active_record/association_data'
+  require 'view_model/active_record/update_data'
+  require 'view_model/active_record/update_context'
+  require 'view_model/active_record/update_operation'
+  require 'view_model/active_record/visitor'
+  require 'view_model/active_record/cloner'
+  require 'view_model/active_record/cache'
+  require 'view_model/active_record/association_manipulation'
+
+  include AssociationManipulation
+
+  attr_reader :changed_associations
+
+  class << self
+    attr_reader   :_list_attribute_name
+    attr_accessor :synthetic
+
+    delegate :transaction, to: :model_class
+
+    def should_register?
+      super && !synthetic
+    end
+
+    # Specifies that the model backing this viewmodel is a member of an
+    # `acts_as_manual_list` collection.
+    def acts_as_list(attr = :position)
+      @_list_attribute_name = attr
+
+      @generated_accessor_module.module_eval do
+        define_method('_list_attribute') do
+          model.public_send(attr)
+        end
+
+        define_method('_list_attribute=') do |x|
+          model.public_send(:"#{attr}=", x)
+        end
+      end
+    end
+
+    def _list_member?
+      _list_attribute_name.present?
+    end
+
+    # Specifies an association from the model to be recursively serialized using
+    # another viewmodel. If the target viewmodel is not specified, attempt to
+    # locate a default viewmodel based on the name of the associated model.
+    # TODO document harder
+    # - +through+ names an ActiveRecord association that will be used like an
+    #   ActiveRecord +has_many:through:+.
+    # - +through_order_attr+ the through model is ordered by the given attribute
+    #   (only applies to when +through+ is set).
+    def association(association_name,
+                    viewmodel: nil,
+                    viewmodels: nil,
+                    shared: false,
+                    optional: false,
+                    through: nil,
+                    through_order_attr: nil,
+                    as: nil)
+
+      if through
+        model_association_name = through
+        through_to             = association_name
+      else
+        model_association_name = association_name
+        through_to             = nil
+      end
+
+      vm_association_name = (as || association_name).to_s
+
+      reflection = model_class.reflect_on_association(model_association_name)
+
+      if reflection.nil?
+        raise ArgumentError.new("Association #{model_association_name} not found in #{model_class.name} model")
+      end
+
+      viewmodel_spec = viewmodel || viewmodels
+
+      association_data = AssociationData.new(vm_association_name, reflection, viewmodel_spec, shared, optional, through_to, through_order_attr)
+
+      _members[vm_association_name] = association_data
+
+      @generated_accessor_module.module_eval do
+        define_method vm_association_name do
+          _read_association(vm_association_name)
+        end
+
+        define_method :"serialize_#{vm_association_name}" do |json, serialize_context: self.class.new_serialize_context|
+          associated = self.public_send(vm_association_name)
+          json.set! vm_association_name do
+            case
+            when associated.nil?
+              json.null!
+            when association_data.through?
+              json.array!(associated) do |through_target|
+                self.class.serialize_as_reference(through_target, json, serialize_context: serialize_context)
+              end
+            when shared
+              self.class.serialize_as_reference(associated, json, serialize_context: serialize_context)
+            else
+              self.class.serialize(associated, json, serialize_context: serialize_context)
+            end
+          end
+        end
+      end
+    end
+
+    # Specify multiple associations at once
+    def associations(*assocs, **args)
+      assocs.each { |assoc| association(assoc, **args) }
+    end
+
+    ## Load instances of the viewmodel by id(s)
+    def find(id_or_ids, scope: nil, lock: nil, eager_include: true, serialize_context: new_serialize_context)
+      find_scope = self.model_class.all
+      find_scope = find_scope.order(:id).lock(lock) if lock
+      find_scope = find_scope.merge(scope) if scope
+
+      ViewModel::Utils.wrap_one_or_many(id_or_ids) do |ids|
+        models = find_scope.where(id: ids).to_a
+
+        if models.size < ids.size
+          missing_ids = ids - models.map(&:id)
+          if missing_ids.present?
+            raise ViewModel::DeserializationError::NotFound.new(
+                    missing_ids.map { |id| ViewModel::Reference.new(self, id) })
+          end
+        end
+
+        vms = models.map { |m| self.new(m) }
+        ViewModel.preload_for_serialization(vms, lock: lock, serialize_context: serialize_context) if eager_include
+        vms
+      end
+    end
+
+    ## Load instances of the viewmodel by scope
+    ## TODO: is this too much of a encapsulation violation?
+    def load(scope: nil, eager_include: true, lock: nil, serialize_context: new_serialize_context)
+      load_scope = self.model_class.all
+      load_scope = load_scope.lock(lock) if lock
+      load_scope = load_scope.merge(scope) if scope
+      vms = load_scope.map { |model| self.new(model) }
+      ViewModel.preload_for_serialization(vms, lock: lock, serialize_context: serialize_context) if eager_include
+      vms
+    end
+
+    def deserialize_from_view(subtree_hash_or_hashes, references: {}, deserialize_context: new_deserialize_context)
+      model_class.transaction do
+        ViewModel::Utils.wrap_one_or_many(subtree_hash_or_hashes) do |subtree_hashes|
+          root_update_data, referenced_update_data = UpdateData.parse_hashes(subtree_hashes, references)
+
+          # Provide information about what was updated
+          deserialize_context.updated_associations = root_update_data
+                                                       .map { |upd| upd.updated_associations }
+                                                       .inject({}) { |acc, assocs| acc.deep_merge(assocs) }
+
+          _updated_viewmodels =
+            UpdateContext
+              .build!(root_update_data, referenced_update_data, root_type: self)
+              .run!(deserialize_context: deserialize_context)
+        end
+      end
+    end
+
+    def eager_includes(serialize_context: new_serialize_context, include_shared: true)
+      # When serializing, we need to (recursively) include all intrinsic
+      # associations and also those optional (incl. shared) associations
+      # specified in the serialize_context.
+
+      # when deserializing, we start with intrinsic non-shared associations. We
+      # then traverse the structure of the tree to deserialize to map out which
+      # optional or shared associations are used from each type. We then explore
+      # from the root type to build an preload specification that will include
+      # them all. (We can subsequently use this same structure to build a
+      # serialization context featuring the same associations.)
+
+      association_specs = {}
+      _members.each do |assoc_name, association_data|
+        next unless association_data.is_a?(AssociationData)
+        next unless serialize_context.includes_member?(assoc_name, !association_data.optional?)
+
+        child_context =
+          if self.synthetic
+            serialize_context
+          elsif association_data.shared?
+            serialize_context.for_references
+          else
+            serialize_context.for_child(nil, association_name: assoc_name)
+          end
+
+        case
+        when association_data.through?
+          viewmodel = association_data.direct_viewmodel
+          children = viewmodel.eager_includes(serialize_context: child_context, include_shared: include_shared)
+
+        when !include_shared && association_data.shared?
+          children = nil # Load up to the shared model, but no further
+
+        when association_data.polymorphic?
+          children_by_klass = {}
+          association_data.viewmodel_classes.each do |vm_class|
+            klass = vm_class.model_class.name
+            children_by_klass[klass] = vm_class.eager_includes(serialize_context: child_context, include_shared: include_shared)
+          end
+          children = DeepPreloader::PolymorphicSpec.new(children_by_klass)
+
+        else
+          viewmodel = association_data.viewmodel_class
+          children = viewmodel.eager_includes(serialize_context: child_context, include_shared: include_shared)
+        end
+
+        association_specs[association_data.direct_reflection.name.to_s] = children
+      end
+      DeepPreloader::Spec.new(association_specs)
+    end
+
+    def dependent_viewmodels(seen = Set.new, include_shared: true)
+      return if seen.include?(self)
+
+      seen << self
+
+      _members.each_value do |data|
+        next unless data.is_a?(AssociationData)
+        next unless include_shared || !data.shared?
+        data.viewmodel_classes.each do |vm|
+          vm.dependent_viewmodels(seen, include_shared: include_shared)
+        end
+      end
+
+      seen
+    end
+
+    def deep_schema_version(include_shared: true)
+      (@deep_schema_version ||= {})[include_shared] ||=
+        begin
+          dependent_viewmodels(include_shared: include_shared).each_with_object({}) do |view, h|
+            h[view.view_name] = view.schema_version
+          end
+        end
+    end
+
+    def cacheable!(**opts)
+      include ViewModel::ActiveRecord::Cache::CacheableView
+      create_viewmodel_cache!(**opts)
+    end
+
+    # internal
+    def _association_data(association_name)
+      association_data = self._members[association_name.to_s]
+      raise ArgumentError.new("Invalid association '#{association_name}'") unless association_data.is_a?(AssociationData)
+      association_data
+    end
+  end
+
+  def initialize(*)
+    super
+    model_is_new! if model.new_record?
+    @changed_associations = []
+  end
+
+  def serialize_members(json, serialize_context: self.class.new_serialize_context)
+    self.class._members.each do |member_name, member_data|
+      next unless serialize_context.includes_member?(member_name, !member_data.optional?)
+
+      member_context =
+        case member_data
+        when AssociationData
+          self.context_for_child(member_name, context: serialize_context)
+        else
+          serialize_context
+        end
+
+      self.public_send("serialize_#{member_name}", json, serialize_context: member_context)
+    end
+  end
+
+  def destroy!(deserialize_context: self.class.new_deserialize_context)
+    model_class.transaction do
+      ViewModel::Callbacks.wrap_deserialize(self, deserialize_context: deserialize_context) do |hook_control|
+        changes = ViewModel::Changes.new(deleted: true)
+        deserialize_context.run_callback(ViewModel::Callbacks::Hook::OnChange, self, changes: changes)
+        hook_control.record_changes(changes)
+        model.destroy!
+      end
+    end
+  end
+
+  def association_changed!(association_name)
+    association_name = association_name.to_s
+    unless @changed_associations.include?(association_name)
+      @changed_associations << association_name
+    end
+  end
+
+  def associations_changed?
+    @changed_associations.present?
+  end
+
+  # Additionally pass `changed_associations` while constructing changes.
+  def changes
+    ViewModel::Changes.new(
+      new:                  new_model?,
+      changed_attributes:   changed_attributes,
+      changed_associations: changed_associations,
+      changed_children:     changed_children?)
+  end
+
+  def clear_changes!
+    super.tap do
+      @changed_associations = []
+    end
+  end
+
+  def _read_association(association_name)
+    association_data = self.class._association_data(association_name)
+
+    associated = model.public_send(association_data.direct_reflection.name)
+    return nil if associated.nil?
+
+    case
+    when association_data.through?
+      # associated here are join_table models; we need to get the far side out
+      if association_data.direct_viewmodel._list_member?
+        associated.order(association_data.direct_viewmodel._list_attribute_name)
+      end
+
+      associated.map do |through_model|
+        model = through_model.public_send(association_data.indirect_reflection.name)
+        association_data.viewmodel_class_for_model!(model.class).new(model)
+      end
+
+    when association_data.collection?
+      associated_viewmodel_class = association_data.viewmodel_class
+      associated_viewmodels = associated.map { |x| associated_viewmodel_class.new(x) }
+      if associated_viewmodel_class._list_member?
+        associated_viewmodels.sort_by!(&:_list_attribute)
+      end
+      associated_viewmodels
+
+    else
+      associated_viewmodel_class = association_data.viewmodel_class_for_model!(associated.class)
+      associated_viewmodel_class.new(associated)
+    end
+  end
+
+  def context_for_child(member_name, context:)
+    # Synthetic viewmodels don't exist as far as the traversal context is
+    # concerned: pass through the child context received from the parent
+    return context if self.class.synthetic
+
+    # Shared associations start a new tree
+    member_data = self.class._members[member_name.to_s]
+    if member_data.is_a?(AssociationData) && member_data.shared?
+      return context.for_references
+    end
+
+    super
+  end
+
+  self.abstract_class = true
+end

data/lib/view_model/active_record/association_data.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+# TODO consider rephrase scope for consistency
+class ViewModel::ActiveRecord::AssociationData
+  attr_reader :direct_reflection, :association_name
+
+  def initialize(association_name, direct_reflection, viewmodel_classes, shared, optional, through_to, through_order_attr)
+    @association_name   = association_name
+    @direct_reflection  = direct_reflection
+    @shared             = shared
+    @optional           = optional
+    @through_to         = through_to
+    @through_order_attr = through_order_attr
+
+    if viewmodel_classes
+      @viewmodel_classes = Array.wrap(viewmodel_classes).map! do |v|
+        case v
+        when String, Symbol
+          ViewModel::Registry.for_view_name(v.to_s)
+        when Class
+          v
+        else
+          raise ArgumentError.new("Invalid viewmodel class: #{v.inspect}")
+        end
+      end
+    end
+
+    if through?
+      # Through associations must always be an owned direct association to a
+      # shared indirect target. We expect the user to set shared: true to
+      # express the ownership of the indirect target, but this direct
+      # association to the intermediate is in fact owned. This ownership
+      # property isn't directly used anywhere: the synthetic intermediate
+      # viewmodel is only used in the deserialization update operations, which
+      # directly understands the semantics of through associations.
+      raise ArgumentError.new("Through associations must be to a shared target") unless @shared
+      raise ArgumentError.new("Through associations must be `has_many`") unless direct_reflection.macro == :has_many
+    end
+  end
+
+  # reflection for the target of this association: indirect if through, direct otherwise
+  def target_reflection
+    if through?
+      indirect_reflection
+    else
+      direct_reflection
+    end
+  end
+
+  def polymorphic?
+    target_reflection.polymorphic?
+  end
+
+  def viewmodel_classes
+    # If we weren't given explicit viewmodel classes, try to work out from the
+    # names. This should work unless the association is polymorphic.
+    @viewmodel_classes ||=
+      begin
+        model_class = target_reflection.klass
+        if model_class.nil?
+          raise "Couldn't derive target class for association '#{target_reflection.name}"
+        end
+        inferred_view_name = ViewModel::Registry.default_view_name(model_class.name)
+        viewmodel_class = ViewModel::Registry.for_view_name(inferred_view_name) # TODO: improve error message to show it's looking for default name
+        [viewmodel_class]
+      end
+  end
+
+  private def model_to_viewmodel
+    @model_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
+      h[vm.model_class] = vm
+    end
+  end
+
+  private def name_to_viewmodel
+    @name_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
+      h[vm.view_name] = vm
+      vm.view_aliases.each do |view_alias|
+        h[view_alias] = vm
+      end
+    end
+  end
+
+  def shared?
+    @shared
+  end
+
+  def optional?
+    @optional
+  end
+
+  def pointer_location # TODO name
+    case direct_reflection.macro
+    when :belongs_to
+      :local
+    when :has_one, :has_many
+      :remote
+    end
+  end
+
+  def viewmodel_class_for_model(model_class)
+    model_to_viewmodel[model_class]
+  end
+
+  def viewmodel_class_for_model!(model_class)
+    vm_class = viewmodel_class_for_model(model_class)
+    if vm_class.nil?
+      raise ArgumentError.new(
+              "Invalid viewmodel model for association '#{target_reflection.name}': '#{model_class.name}'")
+    end
+    vm_class
+  end
+
+  def viewmodel_class_for_name(name)
+    name_to_viewmodel[name]
+  end
+
+  def viewmodel_class_for_name!(name)
+    vm_class = viewmodel_class_for_name(name)
+    if vm_class.nil?
+      raise ArgumentError.new(
+              "Invalid viewmodel name for association '#{target_reflection.name}': '#{name}'")
+    end
+    vm_class
+  end
+
+  def accepts?(viewmodel_class)
+    viewmodel_classes.include?(viewmodel_class)
+  end
+
+  def viewmodel_class
+    unless viewmodel_classes.size == 1
+      raise ArgumentError.new("More than one possible class for association '#{target_reflection.name}'")
+    end
+    viewmodel_classes.first
+  end
+
+  def through?
+    @through_to.present?
+  end
+
+  def direct_viewmodel
+    @direct_viewmodel ||= begin
+      raise 'not a through association' unless through?
+
+      # Join table viewmodel class
+
+      # For A has_many B through T; where this association is defined on A
+
+      # Copy into scope for new class block
+      direct_reflection   = self.direct_reflection    # A -> T
+      indirect_reflection = self.indirect_reflection  # T -> B
+      through_order_attr  = @through_order_attr
+      viewmodel_classes   = self.viewmodel_classes
+
+      Class.new(ViewModel::ActiveRecord) do
+        self.synthetic = true
+        self.model_class = direct_reflection.klass
+        self.view_name = direct_reflection.klass.name
+        association indirect_reflection.name, shared: true, optional: false, viewmodels: viewmodel_classes
+        acts_as_list through_order_attr if through_order_attr
+      end
+    end
+  end
+
+  def indirect_reflection
+    @indirect_reflection ||=
+      direct_reflection.klass.reflect_on_association(ActiveSupport::Inflector.singularize(@through_to))
+  end
+
+  def collection?
+    through? || direct_reflection.collection?
+  end
+
+  def indirect_association_data
+    direct_viewmodel._association_data(indirect_reflection.name)
+  end
+end