iknow_view_models 3.7.7 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 849a8c0a38a21b8d8d8c706aae9800c2d5b009a81e59432d501cc0cef8329db3
-  data.tar.gz: b9cfa60ace9c9f6af4c711f7ae11fd8aa76934bcef7d6e7b360b749fe667d4b4
+  metadata.gz: c6e6ce3aa96f51d7453e79412026e0d3bc840fbac2bcf8c19603564b158ea8a9
+  data.tar.gz: 7ded42908be86bf155b95325af28577dad6e9e4b3f030a14db6753a7b05146bc
 SHA512:
-  metadata.gz: 6e510f3a65791a27df5be2eabb889bd5a5addb84ee17f4e1b2f1ff7b76dfb1630978e3fc1b90bc1c26b36a83d9bb6892e9c3eb7e235b7f762946ab0c3b9b4ab4
-  data.tar.gz: 67f12f88ce24394ddcaa639008a66ea0120fa5e062463fed5c4d30e0f20a75e7dda7823f025304b3cf4d1cda9e5640cbe281f459aab22f84ed5a4d920eb7f9b6
+  metadata.gz: fb370a1c5d85fe6f3ea9037ef79e006548d691eb45a6db275e4b97040a76b27f65e6af6f29c1de7e2759792343e37c000dac7cd2accf420bfe199fef11b531ab
+  data.tar.gz: e16ef99251d41057f0a897e7e1ba3215715c27cb3d0b6ab5aa769df9656fa617fae410944fa45daac8e243929086bbf10c7a8472c890eb1320b9e2c719b246a4

data/lib/iknow_view_models/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IknowViewModels
-  VERSION = '3.7.7'
+  VERSION = '3.9.0'
 end

data/lib/view_model/active_record/update_context.rb

@@ -134,7 +134,15 @@ class ViewModel::ActiveRecord
 
         updates.each do |ref, update_data|
           viewmodel =
-            if update_data.new?
+            if update_data.auto_child_update?
+              raise ViewModel::DeserializationError::InvalidStructure.new(
+                      'Cannot make an automatic child update to a root node',
+                      ViewModel::Reference.new(update_data.viewmodel_class, nil))
+            elsif update_data.child_update?
+              raise ViewModel::DeserializationError::InvalidStructure.new(
+                      'Cannot update an existing root node without a specified id',
+                      ViewModel::Reference.new(update_data.viewmodel_class, nil))
+            elsif update_data.new?
               viewmodel_class.for_new_model(id: update_data.id)
             else
               viewmodel_class.new(existing_models[update_data.id])

data/lib/view_model/active_record/update_data.rb

@@ -520,9 +520,7 @@ class ViewModel::ActiveRecord
       end
     end
 
-    def new?
-      id.nil? || metadata.new?
-    end
+    delegate :new?, :child_update?, :auto_child_update?, to: :metadata
 
     def self.parse_hashes(root_subtree_hashes, referenced_subtree_hashes = {})
       valid_reference_keys = referenced_subtree_hashes.keys.to_set

data/lib/view_model/active_record/update_operation.rb

@@ -14,8 +14,7 @@ class ViewModel::ActiveRecord
 
     attr_accessor :viewmodel,
                   :update_data,
-                  :points_to,  # AssociationData => UpdateOperation (returns single new viewmodel to update fkey)
-                  :pointed_to, # AssociationData => UpdateOperation(s) (returns viewmodel(s) with which to update assoc cache)
+                  :association_updates, # AssociationData => UpdateOperation(s)
                   :reparent_to, # If node needs to update its pointer to a new parent, ParentData for the parent
                   :reposition_to, # if this node participates in a list under its parent, what should its position be?
                   :released_children # Set of children that have been released
@@ -23,13 +22,12 @@ class ViewModel::ActiveRecord
     delegate :attributes, to: :update_data
 
     def initialize(viewmodel, update_data, reparent_to: nil, reposition_to: nil)
-      self.viewmodel         = viewmodel
-      self.update_data       = update_data
-      self.points_to         = {}
-      self.pointed_to        = {}
-      self.reparent_to       = reparent_to
-      self.reposition_to     = reposition_to
-      self.released_children = []
+      self.viewmodel           = viewmodel
+      self.update_data         = update_data
+      self.association_updates = {}
+      self.reparent_to         = reparent_to
+      self.reposition_to       = reposition_to
+      self.released_children   = []
 
       @run_state = RunState::Pending
       @changed_associations = []
@@ -82,46 +80,47 @@ class ViewModel::ActiveRecord
           end
 
           # Visit attributes and associations as much as possible in the order
-          # that they're declared in the view.
-          member_ordering = viewmodel.class._members.keys.each_with_index.to_h
-
-          # update user-specified attributes
-          attribute_keys = attributes.keys.sort_by { |k| member_ordering[k] }
-          attribute_keys.each do |attr_name|
-            serialized_value = attributes[attr_name]
-
-            # Note that the VM::AR deserialization tree asserts ownership over any
-            # references it's provided, and so they're intentionally not passed on
-            # to attribute deserialization for use by their `using:` viewmodels. A
-            # (better?) alternative would be to provide them as reference-only
-            # hashes, to indicate that no modification can be permitted.
-            viewmodel.public_send("deserialize_#{attr_name}", serialized_value,
-                                  references: {},
-                                  deserialize_context: deserialize_context)
+          # that they're declared in the view. We can visit attributes and
+          # points-to associations before save, but points-from associations
+          # must be visited after save.
+          pre_save_members, post_save_members = viewmodel.class._members.values.partition do |member_data|
+            !member_data.association? || member_data.pointer_location == :local
           end
 
-          # Update points-to associations before save
-          points_to_keys = points_to.keys.sort_by do |association_data|
-            member_ordering[association_data.association_name]
-          end
+          pre_save_members.each do |member_data|
+            if member_data.association?
+              next unless association_updates.include?(member_data)
 
-          points_to_keys.each do |association_data|
-            child_operation = points_to[association_data]
+              child_operation = association_updates[member_data]
 
-            reflection = association_data.direct_reflection
-            debug "-> #{debug_name}: Updating points-to association '#{reflection.name}'"
+              reflection = member_data.direct_reflection
+              debug "-> #{debug_name}: Updating points-to association '#{reflection.name}'"
 
-            association = model.association(reflection.name)
-            new_target =
-              if child_operation
-                child_ctx = viewmodel.context_for_child(association_data.association_name, context: deserialize_context)
-                child_viewmodel = child_operation.run!(deserialize_context: child_ctx)
-                propagate_tree_changes(association_data, child_viewmodel.previous_changes)
+              association = model.association(reflection.name)
+              new_target =
+                if child_operation
+                  child_ctx = viewmodel.context_for_child(member_data.association_name, context: deserialize_context)
+                  child_viewmodel = child_operation.run!(deserialize_context: child_ctx)
+                  propagate_tree_changes(member_data, child_viewmodel.previous_changes)
 
-                child_viewmodel.model
-              end
-            association.writer(new_target)
-            debug "<- #{debug_name}: Updated points-to association '#{reflection.name}'"
+                  child_viewmodel.model
+                end
+              association.writer(new_target)
+              debug "<- #{debug_name}: Updated points-to association '#{reflection.name}'"
+            else
+              attr_name = member_data.name
+              next unless attributes.include?(attr_name)
+
+              serialized_value = attributes[attr_name]
+              # Note that the VM::AR deserialization tree asserts ownership over any
+              # references it's provided, and so they're intentionally not passed on
+              # to attribute deserialization for use by their `using:` viewmodels. A
+              # (better?) alternative would be to provide them as reference-only
+              # hashes, to indicate that no modification can be permitted.
+              viewmodel.public_send("deserialize_#{attr_name}", serialized_value,
+                                    references: {},
+                                    deserialize_context: deserialize_context)
+            end
           end
 
           # validate
@@ -144,12 +143,10 @@ class ViewModel::ActiveRecord
 
           # Update association cache of pointed-from associations after save: the
           # child update will have saved the pointer.
-          pointed_to_keys = pointed_to.keys.sort_by do |association_data|
-            member_ordering[association_data.association_name]
-          end
+          post_save_members.each do |association_data|
+            next unless association_updates.include?(association_data)
 
-          pointed_to_keys.each do |association_data|
-            child_operation = pointed_to[association_data]
+            child_operation = association_updates[association_data]
             reflection = association_data.direct_reflection
 
             debug "-> #{debug_name}: Updating pointed-to association '#{reflection.name}'"
@@ -265,13 +262,7 @@ class ViewModel::ActiveRecord
     end
 
     def add_update(association_data, update)
-      target =
-        case association_data.pointer_location
-        when :remote then pointed_to
-        when :local then  points_to
-        end
-
-      target[association_data] = update
+      self.association_updates[association_data] = update
     end
 
     private
@@ -300,6 +291,26 @@ class ViewModel::ActiveRecord
         case
         when update_data.new?
           child_viewmodel_class.for_new_model(id: update_data.id)
+        when update_data.child_update?
+          if association_data.collection?
+            raise ViewModel::DeserializationError::InvalidStructure.new(
+                    'Cannot update existing children of a collection association without specified ids',
+                    ViewModel::Reference.new(update_data.viewmodel_class, nil))
+          end
+
+          child = previous_child_viewmodels[0]
+
+          if child.nil?
+            unless update_data.auto_child_update?
+              raise ViewModel::DeserializationError::PreviousChildNotFound.new(
+                    association_data.association_name.to_s,
+                    self.blame_reference)
+            end
+
+            child = child_viewmodel_class.for_new_model
+          end
+
+          child
         when existing_child = previous_by_key[key]
           existing_child
         when taken_child = update_context.try_take_released_viewmodel(key)

data/lib/view_model/deserialization_error.rb

@@ -211,6 +211,23 @@ class ViewModel
       end
     end
 
+    class PreviousChildNotFound < NotFound
+      attr_reader :association
+
+      def initialize(association, blame_nodes)
+        @association = association
+        super(blame_nodes)
+      end
+
+      def detail
+        "No child currently exists to update for association '#{association}'"
+      end
+
+      def meta
+        super.merge(association: association)
+      end
+    end
+
     class DuplicateNodes < InvalidRequest
       attr_reader :type
 

data/lib/view_model/schemas.rb

@@ -21,7 +21,7 @@ class ViewModel::Schemas
       'description' => 'viewmodel update',
       'properties'  => { ViewModel::TYPE_ATTRIBUTE    => { 'type' => 'string' },
                          ViewModel::ID_ATTRIBUTE      => ID_SCHEMA,
-                         ViewModel::NEW_ATTRIBUTE     => { 'type' => 'boolean' },
+                         ViewModel::NEW_ATTRIBUTE     => { 'oneOf' => [{ 'type' => 'boolean' }, { 'type' => 'string', 'enum' => ['auto'] }] },
                          ViewModel::VERSION_ATTRIBUTE => { 'type' => 'integer' } },
       'required'    => [ViewModel::TYPE_ATTRIBUTE],
     }.freeze

data/lib/view_model.rb

@@ -11,6 +11,22 @@ class ViewModel
   ID_ATTRIBUTE        = 'id'
   TYPE_ATTRIBUTE      = '_type'
   VERSION_ATTRIBUTE   = '_version'
+
+  # The optional _new attribute specifies explicitly whether a deserialization
+  # is to an new or existing model. The behaviour of _new is as follows:
+  #  * true  - Always create a new model, using the id if provided, error if
+  #            a model with that id already exists
+  #  * false - Never create a new model. If id isn’t provided, it's an error
+  #            unless the viewmodel is being deserialized in the context of a
+  #            singular association, in which case it's implicitly referring
+  #            to the current child of that association, and is an error if
+  #            that child doesn't exist.
+  # * nil    - Create a new model if `id` is not specified, otherwise update the
+  #            existing record with `id`, and error if it doesn't exist.
+  # * 'auto' - Can only be used when the viewmodel is being deserialized in the
+  #            context of a singular association. `id` must not be specified. If
+  #            the association currently has a child, update it, otherwise
+  #            create a new one.
   NEW_ATTRIBUTE       = '_new'
 
   BULK_UPDATE_TYPE       = '_bulk_update'
@@ -20,10 +36,36 @@ class ViewModel
   # Migrations leave a metadata attribute _migrated on any views that they
   # alter. This attribute is accessible as metadata when deserializing migrated
   # input, and is included in the output serialization sent to clients.
-  MIGRATED_ATTRIBUTE  = '_migrated'
+  MIGRATED_ATTRIBUTE = '_migrated'
 
   Metadata = Struct.new(:id, :view_name, :schema_version, :new, :migrated) do
-    alias_method :new?, :new
+    # Does this metadata describe deserialization to a new model, either by
+    # {new: true} or {new: nil, id: nil}
+    def new?
+      if new.nil?
+        id.nil?
+      else
+        new == true
+      end
+    end
+
+    # Does this metadata describe an change to the anonymous child of a singular
+    # association
+    def child_update?
+      explicit_child_update? || auto_child_update?
+    end
+
+    # Does this metadata describe an update to the already-existing anonymous
+    # child of a singular association
+    def explicit_child_update?
+      new == false && id.nil?
+    end
+
+    # Does this child metadata describe an create-or-update to the anonymous
+    # child of a singular association
+    def auto_child_update?
+      new == 'auto'
+    end
   end
 
   class << self
@@ -119,9 +161,14 @@ class ViewModel
       id             = hash.delete(ViewModel::ID_ATTRIBUTE)
       type_name      = hash.delete(ViewModel::TYPE_ATTRIBUTE)
       schema_version = hash.delete(ViewModel::VERSION_ATTRIBUTE)
-      new            = hash.delete(ViewModel::NEW_ATTRIBUTE) { false }
+      new            = hash.delete(ViewModel::NEW_ATTRIBUTE)
       migrated       = hash.delete(ViewModel::MIGRATED_ATTRIBUTE) { false }
 
+      if id && new == 'auto'
+        raise ViewModel::DeserializationError::InvalidSyntax.new(
+                "An explicit id must not be specified with an 'auto' child update")
+      end
+
       Metadata.new(id, type_name, schema_version, new, migrated)
     end
 

data/test/unit/view_model/active_record/belongs_to_test.rb

@@ -85,7 +85,7 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     end
   end
 
-  def test_belongs_to_create
+  def test_belongs_to_create_implicit_new
     @model1.update(child: nil)
 
     alter_by_view!(ModelView, @model1) do |view, _refs|
@@ -95,6 +95,108 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     assert_equal('cheese', @model1.child.name)
   end
 
+  def test_belongs_to_create
+    @model1.update(child: nil)
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', '_new' => true, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+  end
+
+  def test_belongs_to_create_with_id
+    @model1.update(child: nil)
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', 'id' => 9999, '_new' => true, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(9999, @model1.child.id)
+  end
+
+  def test_belongs_to_create_with_colliding_id
+    child_id = @model1.child_id
+    @model1.update(child: nil)
+
+    ex = assert_raises(ViewModel::DeserializationError::UniqueViolation) do
+      alter_by_view!(ModelView, @model1) do |view, _refs|
+        view['child'] = { '_type' => 'Child', 'id' => child_id, '_new' => true, 'name' => 'cheese' }
+      end
+    end
+
+    assert_equal(['id'], ex.columns)
+    assert_equal([ViewModel::Reference.new(ChildView, child_id)], ex.nodes)
+  end
+
+  def test_belongs_to_create_child_with_auto
+    @model1.update(child: nil)
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', '_new' => 'auto', 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+  end
+
+  def test_belongs_to_edit_implicit_new
+    child_id = @model1.child_id
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', 'id' => child_id, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
+  end
+
+  def test_belongs_to_edit
+    child_id = @model1.child_id
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', 'id' => child_id, '_new' => false, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
+  end
+
+  def test_belongs_to_edit_child_without_id
+    child_id = @model1.child_id
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', '_new' => false, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
+  end
+
+  def test_belongs_to_one_edit_without_id_no_child
+    @model1.update(child: nil)
+
+    ex = assert_raises(ViewModel::DeserializationError::PreviousChildNotFound) do
+      alter_by_view!(ModelView, @model1) do |view, _refs|
+        view['child'] = { '_type' => 'Child', '_new' => false, 'name' => 'cheese' }
+      end
+    end
+
+    assert_equal('child', ex.association)
+    assert_equal([ViewModel::Reference.new(ModelView, @model1.id)], ex.nodes)
+  end
+
+  def test_belongs_to_edit_child_with_auto
+    child_id = @model1.child_id
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', '_new' => 'auto', 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
+  end
+
   def test_belongs_to_replace
     old_child = @model1.child
 

data/test/unit/view_model/active_record/has_many_test.rb

@@ -107,7 +107,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert(pv.model.children.blank?)
   end
 
-  def test_create_has_many
+  def test_create_has_many_implicit_new
     view = { '_type'    => 'Model',
              'name'     => 'p',
              'children' => [{ '_type' => 'Child', 'name' => 'c1' },
@@ -123,6 +123,64 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert_equal(%w[c1 c2], pv.model.children.map(&:name))
   end
 
+  def test_create_has_many
+    view = { '_type'    => 'Model',
+             'name'     => 'p',
+             'children' => [{ '_type' => 'Child', '_new' => true, 'name' => 'c1' },
+                            { '_type' => 'Child', '_new' => true, 'name' => 'c2' },] }
+
+    context = viewmodel_class.new_deserialize_context
+    pv = viewmodel_class.deserialize_from_view(view, deserialize_context: context)
+
+    assert_contains_exactly(
+      [pv.to_reference, pv.children[0].to_reference, pv.children[1].to_reference],
+      context.valid_edit_refs)
+
+    assert_equal(%w[c1 c2], pv.model.children.map(&:name))
+  end
+
+  def test_create_has_many_with_id
+    view = { '_type'    => 'Model',
+             'name'     => 'p',
+             'children' => [{ '_type' => 'Child', 'id' => 9998, '_new' => true, 'name' => 'c1' },
+                            { '_type' => 'Child', 'id' => 9999, '_new' => true, 'name' => 'c2' },] }
+
+    context = viewmodel_class.new_deserialize_context
+    pv = viewmodel_class.deserialize_from_view(view, deserialize_context: context)
+
+    assert_contains_exactly(
+      [pv.to_reference, pv.children[0].to_reference, pv.children[1].to_reference],
+      context.valid_edit_refs)
+
+    assert_equal(%w[c1 c2], pv.model.children.map(&:name))
+  end
+
+  def test_create_has_many_auto
+    view = { '_type'    => 'Model',
+             'name'     => 'p',
+             'children' => [{ '_type' => 'Child', '_new' => 'auto', 'name' => 'c1' }] }
+
+    context = viewmodel_class.new_deserialize_context
+    ex = assert_raises(ViewModel::DeserializationError::InvalidStructure) do
+      viewmodel_class.deserialize_from_view(view, deserialize_context: context)
+    end
+    assert_match(/existing children of a collection association without specified ids/, ex.message)
+    assert_equal([ViewModel::Reference.new(ChildView, nil)], ex.nodes)
+  end
+
+  def test_update_has_many_without_id
+    view = { '_type'    => 'Model',
+             'name'     => 'p',
+             'children' => [{ '_type' => 'Child', '_new' => false, 'name' => 'c1' }] }
+
+    context = viewmodel_class.new_deserialize_context
+    ex = assert_raises(ViewModel::DeserializationError::InvalidStructure) do
+      viewmodel_class.deserialize_from_view(view, deserialize_context: context)
+    end
+    assert_match(/existing children of a collection association without specified ids/, ex.message)
+    assert_equal([ViewModel::Reference.new(ChildView, nil)], ex.nodes)
+  end
+
   def test_nil_multiple_association
     view = {
       '_type' => 'Model',

data/test/unit/view_model/active_record/has_one_test.rb

@@ -98,7 +98,7 @@ class ViewModel::ActiveRecord::HasOneTest < ActiveSupport::TestCase
     assert_nil(pv.model.child)
   end
 
-  def test_has_one_create
+  def test_has_one_create_implicit_new
     @model1.update(child: nil)
 
     alter_by_view!(ModelView, @model1) do |view, _refs|
@@ -108,12 +108,106 @@ class ViewModel::ActiveRecord::HasOneTest < ActiveSupport::TestCase
     assert_equal('t', @model1.child.name)
   end
 
-  def test_has_one_update
+  def test_has_one_create
+    @model1.update(child: nil)
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', '_new' => true, 'name' => 't' }
+    end
+
+    assert_equal('t', @model1.child.name)
+  end
+
+  def test_has_one_create_with_id
+    @model1.update(child: nil)
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', 'id' => 9999, '_new' => true, 'name' => 't' }
+    end
+
+    assert_equal('t', @model1.child.name)
+    assert_equal(9999, @model1.child.id)
+  end
+
+  def test_has_one_create_with_colliding_id
+    child_id = @model2.child.id
+    @model1.update(child: nil)
+
+    ex = assert_raises(ViewModel::DeserializationError::UniqueViolation) do
+      alter_by_view!(ModelView, @model1) do |view, _refs|
+        view['child'] = { '_type' => 'Child', 'id' => child_id, '_new' => true, 'name' => 'cheese' }
+      end
+    end
+
+    assert_equal(['id'], ex.columns)
+    assert_equal([ViewModel::Reference.new(ChildView, child_id)], ex.nodes)
+  end
+
+  def test_has_one_create_child_with_auto
+    @model1.update(child: nil)
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', '_new' => 'auto', 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+  end
+
+  def test_has_one_edit_implicit_new
+    child_id = @model1.child.id
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', 'id' => child_id, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
+  end
+
+  def test_has_one_edit
+    child_id = @model1.child.id
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', 'id' => child_id, '_new' => false, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
+  end
+
+  def test_has_one_edit_without_id
+    child_id = @model1.child.id
+
+    alter_by_view!(ModelView, @model1) do |view, _refs|
+      view['child'] = { '_type' => 'Child', '_new' => false, 'name' => 'cheese' }
+    end
+
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
+  end
+
+  def test_has_one_edit_without_id_no_child
+    @model1.update(child: nil)
+
+    ex = assert_raises(ViewModel::DeserializationError::PreviousChildNotFound) do
+      alter_by_view!(ModelView, @model1) do |view, _refs|
+        view['child'] = { '_type' => 'Child', '_new' => false, 'name' => 'cheese' }
+      end
+    end
+
+    assert_equal('child', ex.association)
+    assert_equal([ViewModel::Reference.new(ModelView, @model1.id)], ex.nodes)
+  end
+
+  def test_belongs_to_edit_child_with_auto
+    child_id = @model1.child.id
+
     alter_by_view!(ModelView, @model1) do |view, _refs|
-      view['child']['name'] = 'hello'
+      view['child'] = { '_type' => 'Child', '_new' => 'auto', 'name' => 'cheese' }
     end
 
-    assert_equal('hello', @model1.child.name)
+    assert_equal('cheese', @model1.child.name)
+    assert_equal(child_id, @model1.child.id)
   end
 
   def test_has_one_destroy

data/test/unit/view_model/active_record_test.rb

@@ -127,6 +127,30 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
     assert_equal([ViewModel::Reference.new(ParentView, 9999)], ex.nodes)
   end
 
+  def test_create_implicit_id_raises
+    view = {
+      '_type' => 'Parent',
+      '_new'  => false,
+    }
+    ex = assert_raises(ViewModel::DeserializationError::InvalidStructure) do
+      ParentView.deserialize_from_view(view)
+    end
+    assert_match(/existing root node without a specified id/, ex.message)
+    assert_equal([ViewModel::Reference.new(ParentView, nil)], ex.nodes)
+  end
+
+  def test_create_auto_raises
+    view = {
+      '_type' => 'Parent',
+      '_new'  => 'auto',
+    }
+    ex = assert_raises(ViewModel::DeserializationError::InvalidStructure) do
+      ParentView.deserialize_from_view(view)
+    end
+    assert_match(/automatic child update to a root node/, ex.message)
+    assert_equal([ViewModel::Reference.new(ParentView, nil)], ex.nodes)
+  end
+
   def test_read_only_raises_with_id
     view = {
       '_type' => 'Parent',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.7.7
+  version: 3.9.0
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-15 00:00:00.000000000 Z
+date: 2024-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack