fix(agent): stop the update route from writing foreign keys from relationships

packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_related_route.rb

@@ -6,7 +6,9 @@ def build(args = {})
 
         relation = context.collection.schema[:fields][args[:params]['relation_name']]
         context.child_collection = if relation.type == 'PolymorphicManyToOne'
-                                     context.datasource.get_collection(args[:params]['data']['type'])
+                                     if (type = args.dig(:params, 'data', 'type'))
+                                       context.datasource.get_collection(type)
+                                     end
                                    else
                                      context.datasource.get_collection(relation.foreign_collection)
                                    end

packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/related/update_related.rb

@@ -89,7 +89,7 @@ def update_polymorphic_many_to_one(relation, parent_primary_key_values, linked_p
                               )
                             end
 
-            polymorphic_type = context.child_collection.name.gsub('__', '::')
+            polymorphic_type = context.child_collection&.name&.gsub('__', '::')
             context.collection.update(
               context.caller,
               scoped_fk_owner_filter(parent_primary_key_values, context),

packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/update.rb

@@ -23,6 +23,7 @@ def handle_request(args = {})
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )
+          drop_relationships!(args)
           data = format_attributes(args, context.collection)
           context.collection.update(context.caller, filter, data)
           records = context.collection.list(context.caller, filter, ProjectionFactory.all(context.collection))
@@ -37,6 +38,15 @@ def handle_request(args = {})
             )
           }
         end
+
+        private
+
+        # The frontend writes relations through PUT /:collection/:id/relationships/:name, which fires
+        # before this route. Honouring the relationships block here would turn the untouched relations
+        # it always resends as `data: null` into foreign keys set to nil. Parity with agent-nodejs.
+        def drop_relationships!(args)
+          args[:params][:data].delete(:relationships)
+        end
       end
     end
   end

packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/related/update_related_spec.rb

@@ -194,6 +194,22 @@ module Related
               expect(result).to eq({ content: nil, status: 204 })
             end
 
+            it 'clears the foreign key and its type field on a polymorphic_many_to_one relation' do
+              allow(@datasource.get_collection('address')).to receive(:update).and_return(true)
+
+              args[:params]['collection_name'] = 'address'
+              args[:params]['relation_name'] = 'addressable'
+              args[:params]['data'] = nil
+              args[:params]['id'] = 1
+
+              result = update.handle_request(args)
+
+              expect(@datasource.get_collection('address')).to have_received(:update) do |_caller, _filter, data|
+                expect(data).to eq({ 'addressable_id' => nil, 'addressable_type' => nil })
+              end
+              expect(result).to eq({ content: nil, status: 204 })
+            end
+
             it 'call handle_request on a one_to_one relation' do
               allow(permissions).to receive(:get_scope)
                 .and_return(Nodes::ConditionTreeLeaf.new('author_id', Operators::NOT_EQUAL, 99))

packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/update_spec.rb

@@ -101,60 +101,100 @@ def respond_to?(arg)
             end
           end
 
-          describe 'with polymorphic many to one relation' do
-            it 'call update with polymorphic foreign key and type' do
-              collection_company = build_collection(
-                name: 'company',
+          describe 'with relationships in the payload' do
+            let(:collection_creator) do
+              build_collection(
+                name: 'creator',
                 schema: {
                   fields: {
                     'id' => ColumnSchema.new(
                       column_type: 'Number',
                       is_primary_key: true,
                       filter_operators: [Operators::IN, Operators::EQUAL]
-                    ),
-                    'name' => ColumnSchema.new(column_type: 'String')
+                    )
                   }
                 }
               )
+            end
 
-              collection_member = build_collection(
-                name: 'member',
+            let(:collection_experience) do
+              build_collection(
+                name: 'experience',
                 schema: {
                   fields: {
                     'id' => ColumnSchema.new(
                       column_type: 'Number',
                       is_primary_key: true,
                       filter_operators: [Operators::IN, Operators::EQUAL]
                     ),
+                    'name' => ColumnSchema.new(column_type: 'String'),
+                    'creator_id' => ColumnSchema.new(column_type: 'Number'),
+                    'creator' => Relations::ManyToOneSchema.new(
+                      foreign_collection: 'creator',
+                      foreign_key: 'creator_id',
+                      foreign_key_target: 'id'
+                    ),
                     'memberable_id' => ColumnSchema.new(column_type: 'Number'),
                     'memberable_type' => ColumnSchema.new(column_type: 'String'),
                     'memberable' => Relations::PolymorphicManyToOneSchema.new(
-                      foreign_collections: ['company'],
+                      foreign_collections: ['creator'],
                       foreign_key: 'memberable_id',
                       foreign_key_type_field: 'memberable_type',
-                      foreign_key_targets: { 'company' => 'id' }
+                      foreign_key_targets: { 'creator' => 'id' }
                     )
                   }
                 }
               )
+            end
 
-              @datasource.add_collection(collection_company)
-              @datasource.add_collection(collection_member)
+            before do
+              @datasource.add_collection(collection_creator)
+              @datasource.add_collection(collection_experience)
+              args[:params]['collection_name'] = 'experience'
+              args[:params]['id'] = '1'
+              allow(@datasource.get_collection('experience'))
+                .to receive_messages(list: [{ 'id' => 1, 'name' => 'edited' }], update: true)
+            end
 
+            it 'does not write a many to one foreign key sent as data null' do
               args[:params][:data] = {
-                attributes: {},
-                relationships: { 'memberable' => { 'data' => { 'type' => 'Company', 'id' => 5 } } }
+                attributes: { 'name' => 'edited' },
+                relationships: { 'creator' => { 'data' => nil } }
               }
-              args[:params]['collection_name'] = 'member'
-              args[:params]['id'] = '1'
-              member = { 'id' => 1, 'memberable_id' => 5, 'memberable_type' => 'Company' }
-              allow(@datasource.get_collection('member')).to receive_messages(list: [member], update: true)
 
               update.handle_request(args)
-              expect(@datasource.get_collection('member')).to have_received(:update) do |caller, filter, data|
-                expect(caller).to be_instance_of(Components::Caller)
-                expect(data).to eq({ 'memberable_id' => 5, 'memberable_type' => 'Company' })
-                expect(filter.condition_tree.to_h).to eq(field: 'id', operator: Operators::EQUAL, value: 1)
+
+              expect(@datasource.get_collection('experience')).to have_received(:update) do |_caller, _filter, data|
+                expect(data).to eq({ 'name' => 'edited' })
+              end
+            end
+
+            it 'does not write a polymorphic foreign key nor its type field' do
+              args[:params][:data] = {
+                attributes: { 'name' => 'edited' },
+                relationships: { 'memberable' => { 'data' => { 'type' => 'creator', 'id' => 5 } } }
+              }
+
+              update.handle_request(args)
+
+              expect(@datasource.get_collection('experience')).to have_received(:update) do |_caller, _filter, data|
+                expect(data).to eq({ 'name' => 'edited' })
+              end
+            end
+
+            it 'keeps the attributes of a payload mixing touched and untouched relations' do
+              args[:params][:data] = {
+                attributes: { 'name' => 'edited' },
+                relationships: {
+                  'creator' => { 'data' => nil },
+                  'memberable' => { 'data' => { 'type' => 'creator', 'id' => 5 } }
+                }
+              }
+
+              update.handle_request(args)
+
+              expect(@datasource.get_collection('experience')).to have_received(:update) do |_caller, _filter, data|
+                expect(data).to eq({ 'name' => 'edited' })
               end
             end
           end