iknow_view_models 2.10.1 → 3.0.0

data/lib/view_model/active_record.rb

@@ -63,42 +63,58 @@ class ViewModel::ActiveRecord < ViewModel::Record
       _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
+    # Adds an association from the model to this viewmodel. The associated model
+    # will be recursively (de)serialized by its own viewmodel type, which will
+    # be inferred from the model name, or may be explicitly specified.
+    #
+    # An association to a root viewmodel type will be serialized with an
+    # indirect reference, while a child viewmodel type will be directly nested.
+    #
+    # - +as+ sets the name of the association in the viewmodel
+    #
+    # - +viewmodel+, +viewmodels+ specifies the viewmodel(s) to use for the
+    #   association
+    #
+    # - +external+ indicates an association external to the view. Externalized
+    #   associations are not included in (de)serializations of the parent, and
+    #   must be independently manipulated using `AssociationManipulation`.
+    #   External associations may only be made to root viewmodels.
+    #
     # - +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,
+                    as: nil,
                     viewmodel: nil,
                     viewmodels: nil,
-                    shared: false,
-                    optional: false,
+                    external: false,
+                    read_only: 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
+                    through_order_attr: nil)
 
       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")
+      if through
+        direct_association_name   = through
+        indirect_association_name = association_name
+      else
+        direct_association_name   = association_name
+        indirect_association_name = nil
       end
 
-      viewmodel_spec = viewmodel || viewmodels
+      target_viewmodels = Array.wrap(viewmodel || viewmodels)
 
-      association_data = AssociationData.new(vm_association_name, reflection, viewmodel_spec, shared, optional, through_to, through_order_attr)
+      association_data = AssociationData.new(
+        owner:                     self,
+        association_name:          vm_association_name,
+        direct_association_name:   direct_association_name,
+        indirect_association_name: indirect_association_name,
+        target_viewmodels:         target_viewmodels,
+        external:                  external,
+        read_only:                 read_only,
+        through_order_attr:        through_order_attr)
 
       _members[vm_association_name] = association_data
 
@@ -108,21 +124,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
         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
+          _serialize_association(vm_association_name, json, serialize_context: serialize_context)
         end
       end
     end
@@ -171,11 +173,6 @@ class ViewModel::ActiveRecord < ViewModel::Record
         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)
@@ -184,27 +181,18 @@ class ViewModel::ActiveRecord < ViewModel::Record
       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.)
-
+    # Constructs a preload specification of the required models for
+    # serializing/deserializing this view.
+    def eager_includes(serialize_context: new_serialize_context, include_referenced: true)
       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?)
+        next if association_data.external?
 
         child_context =
           if self.synthetic
             serialize_context
-          elsif association_data.shared?
+          elsif association_data.referenced?
             serialize_context.for_references
           else
             serialize_context.for_child(nil, association_name: assoc_name)
@@ -213,22 +201,22 @@ class ViewModel::ActiveRecord < ViewModel::Record
         case
         when association_data.through?
           viewmodel = association_data.direct_viewmodel
-          children = viewmodel.eager_includes(serialize_context: child_context, include_shared: include_shared)
+          children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced)
 
-        when !include_shared && association_data.shared?
-          children = nil # Load up to the shared model, but no further
+        when !include_referenced && association_data.referenced?
+          children = nil # Load up to the root viewmodel, 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)
+            children_by_klass[klass] = vm_class.eager_includes(serialize_context: child_context, include_referenced: include_referenced)
           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)
+          children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced)
         end
 
         association_specs[association_data.direct_reflection.name.to_s] = children
@@ -236,26 +224,26 @@ class ViewModel::ActiveRecord < ViewModel::Record
       DeepPreloader::Spec.new(association_specs)
     end
 
-    def dependent_viewmodels(seen = Set.new, include_shared: true)
+    def dependent_viewmodels(seen = Set.new, include_referenced: 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?
+        next unless include_referenced || !data.referenced?
         data.viewmodel_classes.each do |vm|
-          vm.dependent_viewmodels(seen, include_shared: include_shared)
+          vm.dependent_viewmodels(seen, include_referenced: include_referenced)
         end
       end
 
       seen
     end
 
-    def deep_schema_version(include_shared: true)
-      (@deep_schema_version ||= {})[include_shared] ||=
+    def deep_schema_version(include_referenced: true)
+      (@deep_schema_version ||= {})[include_referenced] ||=
         begin
-          dependent_viewmodels(include_shared: include_shared).each_with_object({}) do |view, h|
+          dependent_viewmodels(include_referenced: include_referenced).each_with_object({}) do |view, h|
             h[view.view_name] = view.schema_version
           end
         end
@@ -270,6 +258,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
     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
@@ -282,7 +271,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
 
   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?)
+      next if member_data.association? && member_data.external?
 
       member_context =
         case member_data
@@ -309,6 +298,13 @@ class ViewModel::ActiveRecord < ViewModel::Record
 
   def association_changed!(association_name)
     association_name = association_name.to_s
+
+    association_data = self.class._association_data(association_name)
+
+    if association_data.read_only?
+      raise ViewModel::DeserializationError::ReadOnlyAssociation.new(association_name, blame_reference)
+    end
+
     unless @changed_associations.include?(association_name)
       @changed_associations << association_name
     end
@@ -321,10 +317,12 @@ class ViewModel::ActiveRecord < ViewModel::Record
   # 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?)
+      new:                         new_model?,
+      changed_attributes:          changed_attributes,
+      changed_associations:        changed_associations,
+      changed_nested_children:     changed_nested_children?,
+      changed_referenced_children: changed_referenced_children?,
+    )
   end
 
   def clear_changes!
@@ -365,14 +363,36 @@ class ViewModel::ActiveRecord < ViewModel::Record
     end
   end
 
+  def _serialize_association(association_name, json, serialize_context:)
+    associated = self.public_send(association_name)
+    association_data = self.class._association_data(association_name)
+
+    json.set! association_name do
+      case
+      when associated.nil?
+        json.null!
+      when association_data.referenced?
+        if association_data.collection?
+          json.array!(associated) do |target|
+            self.class.serialize_as_reference(target, json, serialize_context: serialize_context)
+          end
+        else
+          self.class.serialize_as_reference(associated, json, serialize_context: serialize_context)
+        end
+      else
+        self.class.serialize(associated, json, serialize_context: serialize_context)
+      end
+    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
+    # associations to roots start a new tree
     member_data = self.class._members[member_name.to_s]
-    if member_data.is_a?(AssociationData) && member_data.shared?
+    if member_data.association? && member_data.referenced?
       return context.for_references
     end
 

data/lib/view_model/after_transaction_runner.rb

@@ -4,31 +4,16 @@
 # `add_to_transaction`, the abstract method `after_transaction` will be invoked
 # by AR's callbacks.
 module ViewModel::AfterTransactionRunner
-  # Rails' internal API
-  def committed!(*)
-    after_commit
-  end
+  def committed!; end
 
   def before_committed!
-    before_commit
+    after_transaction
   end
 
   def rolledback!(*)
-    after_rollback
-  end
-
-  def trigger_transactional_callbacks?
-    true
+    after_transaction
   end
 
-  # Our simplified API
-
-  def before_commit; end
-
-  def after_commit; end
-
-  def after_rollback; end
-
   def add_to_transaction
     if connection.transaction_open?
       connection.add_transaction_record(self)

data/lib/view_model/callbacks.rb

@@ -11,9 +11,9 @@ module ViewModel::Callbacks
   # callbacks instance with additional instance method access to the view,
   # context and extra context-dependent parameters.
   module CallbackEnvContext
-    def method_missing(method, ...)
+    def method_missing(method, *args, &block)
       if _callbacks.respond_to?(method, true)
-        _callbacks.send(method, ...)
+        _callbacks.send(method, *args, &block)
       else
         super
       end

data/lib/view_model/changes.rb

@@ -5,18 +5,20 @@ require 'view_model/utils/collections'
 class ViewModel::Changes
   using ViewModel::Utils::Collections
 
-  attr_reader :new, :changed_attributes, :changed_associations, :changed_children, :deleted
+  attr_reader :new, :changed_attributes, :changed_associations, :changed_nested_children, :changed_referenced_children, :deleted
 
   alias new? new
   alias deleted? deleted
-  alias changed_children? changed_children
+  alias changed_nested_children? changed_nested_children
+  alias changed_referenced_children? changed_referenced_children
 
-  def initialize(new: false, changed_attributes: [], changed_associations: [], changed_children: false, deleted: false)
-    @new                  = new
-    @changed_attributes   = changed_attributes.map(&:to_s)
-    @changed_associations = changed_associations.map(&:to_s)
-    @changed_children     = changed_children
-    @deleted              = deleted
+  def initialize(new: false, changed_attributes: [], changed_associations: [], changed_nested_children: false, changed_referenced_children: false, deleted: false)
+    @new                         = new
+    @changed_attributes          = changed_attributes.map(&:to_s)
+    @changed_associations        = changed_associations.map(&:to_s)
+    @changed_nested_children     = changed_nested_children
+    @changed_referenced_children = changed_referenced_children
+    @deleted                     = deleted
   end
 
   def contained_to?(associations: [], attributes: [])
@@ -34,17 +36,22 @@ class ViewModel::Changes
     new? || deleted? || changed_attributes.present? || changed_associations.present?
   end
 
-  def changed_tree?
-    changed? || changed_children?
+  def changed_nested_tree?
+    changed? || changed_nested_children?
+  end
+
+  def changed_owned_tree?
+    changed? || changed_nested_children? || changed_referenced_children?
   end
 
   def to_h
     {
-      'changed_attributes'   => changed_attributes.dup,
-      'changed_associations' => changed_associations.dup,
-      'new'                  => new?,
-      'changed_children'     => changed_children?,
-      'deleted'              => deleted?,
+      'changed_attributes'          => changed_attributes.dup,
+      'changed_associations'        => changed_associations.dup,
+      'new'                         => new?,
+      'changed_nested_children'     => changed_nested_children?,
+      'changed_referenced_children' => changed_referenced_children?,
+      'deleted'                     => deleted?,
     }
   end
 
@@ -52,7 +59,8 @@ class ViewModel::Changes
     return false unless other.is_a?(ViewModel::Changes)
 
     self.new? == other.new? &&
-      self.changed_children? == other.changed_children? &&
+      self.changed_nested_children? == other.changed_nested_children? &&
+      self.changed_referenced_children? == other.changed_referenced_children? &&
       self.deleted? == other.deleted? &&
       self.changed_attributes.contains_exactly?(other.changed_attributes) &&
       self.changed_associations.contains_exactly?(other.changed_associations)

data/lib/view_model/config.rb

@@ -10,7 +10,7 @@ ViewModel::Config = Value.new(
 
 class ViewModel::Config
   def self.configure!(&block)
-    if instance_variable_defined?(:@instance)
+    if configured?
       raise ArgumentError.new('ViewModel library already configured')
     end
 
@@ -18,8 +18,12 @@ class ViewModel::Config
     @instance = builder.build!(&block)
   end
 
+  def self.configured?
+    instance_variable_defined?(:@instance)
+  end
+
   def self._option(opt)
-    configure! unless instance_variable_defined?(:@instance)
+    configure! unless configured?
     @instance[opt]
   end
 

data/lib/view_model/deserialization_error.rb

@@ -226,6 +226,19 @@ class ViewModel
       end
     end
 
+    class DuplicateOwner < InvalidRequest
+      attr_reader :association_name
+
+      def initialize(association_name, parents)
+        @association_name = association_name
+        super(parents)
+      end
+
+      def detail
+        "Multiple parents attempted to claim the same owned '#{association_name}' reference: " + nodes.map(&:to_s).join(", ")
+      end
+    end
+
     class ParentNotFound < NotFound
       def detail
         "Could not resolve release from previous parent for the following owned viewmodel(s): " +
@@ -251,6 +264,24 @@ class ViewModel
       end
     end
 
+    class ReadOnlyAssociation < DeserializationError
+      status 400
+      attr_reader :association
+
+      def initialize(association, node)
+        @association = association
+        super([node])
+      end
+
+      def detail
+        "Cannot edit read only association '#{association}'"
+      end
+
+      def meta
+        super.merge(association: association)
+      end
+    end
+
     class ReadOnlyType < DeserializationError
       status 400
       detail "Deserialization not defined for view type"

data/lib/view_model/deserialize_context.rb

@@ -1,16 +1,12 @@
+# frozen_string_literal: true
+
 require 'view_model/traversal_context'
 
 class ViewModel::DeserializeContext < ViewModel::TraversalContext
   class SharedContext < ViewModel::TraversalContext::SharedContext
-    # During deserialization, collects a tree of viewmodel association names that
-    # were updated. Used to ensure that updated associations are always included
-    # in response serialization after deserialization, even if hidden by default.
-    attr_accessor :updated_associations
   end
 
   def self.shared_context_class
     SharedContext
   end
-
-  delegate :updated_associations, :"updated_associations=", to: :shared_context
 end

data/lib/view_model/error_view.rb

@@ -25,10 +25,11 @@ class ViewModel::ErrorView < ViewModel::Record
 
   # Ruby exceptions should never be serialized in production
   def serialize_exception(json, serialize_context:)
-    if ViewModel::Config.show_cause_in_error_view
-      super
-    else
-      json.exception nil
-    end
+    super if ViewModel::Config.show_cause_in_error_view
+  end
+
+  # Only serialize causes for aggregation errors.
+  def serialize_causes(*)
+    super if model.aggregation?
   end
 end

data/lib/view_model/record/attribute_data.rb

@@ -3,23 +3,28 @@
 class ViewModel::Record::AttributeData
   attr_reader :name, :model_attr_name, :attribute_viewmodel, :attribute_serializer
 
-  def initialize(name, model_attr_name, attribute_viewmodel, attribute_serializer, array, optional, read_only, write_once)
+  def initialize(name:,
+                 model_attr_name:,
+                 attribute_viewmodel:,
+                 attribute_serializer:,
+                 array:,
+                 read_only:,
+                 write_once:)
     @name                 = name
     @model_attr_name      = model_attr_name
     @attribute_viewmodel  = attribute_viewmodel
     @attribute_serializer = attribute_serializer
     @array                = array
-    @optional             = optional
     @read_only            = read_only
     @write_once           = write_once
   end
 
-  def array?
-    @array
+  def association?
+    false
   end
 
-  def optional?
-    @optional
+  def array?
+    @array
   end
 
   def read_only?