GH-2537 - Fix serialization of the target node of relationship property entities.

This should have gone into a separate field in parallel to properties,
not into the properties itself.

Fixes #2537 and also adds a test for the specific question asked in the
ticket.

Author: michael-simons

src/main/java/org/springframework/data/neo4j/repository/query/Neo4jNestedMapEntityWriter.java

@@ -119,12 +119,10 @@ Map<String, Object> writeImpl(@Nullable Object source, Map<String, Object> sink,
 		addLabels(sink, entity, propertyAccessor);
 		addRelations(sink, entity, propertyAccessor, seenObjects);
 		if (initialObject && entity.isRelationshipPropertiesEntity()) {
-			@SuppressWarnings("unchecked")
-			Map<String, Object> propertyMap = (Map<String, Object>) sink.get(Constants.NAME_OF_PROPERTIES_PARAM);
 			entity.doWithProperties((PropertyHandler<Neo4jPersistentProperty>) p -> {
 				if (p.isAnnotationPresent(TargetNode.class)) {
-					Map<String, Object> target = this.writeImpl(propertyAccessor.getProperty(p), new HashMap<>(), seenObjects, false);
-					propertyMap.put("__target__", Values.value(target));
+					Value target = Values.value(this.writeImpl(propertyAccessor.getProperty(p), new HashMap<>(), seenObjects, false));
+					sink.put("__target__", target);
 				}
 			});
 		}

src/test/java/org/springframework/data/neo4j/integration/issues/gh2323/GH2323IT.java

@@ -19,9 +19,11 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
@@ -68,6 +70,17 @@ protected static void setupData(@Autowired BookmarkCapture bookmarkCapture) {
 		}
 	}
 
+	@BeforeEach
+	protected void removeRelationships(@Autowired BookmarkCapture bookmarkCapture) {
+		try (Session session = neo4jConnectionSupport.getDriver().session(bookmarkCapture.createSessionConfig());
+				Transaction transaction = session.beginTransaction();
+		) {
+			transaction.run("MATCH ()- [r:KNOWS]-() delete r").consume();
+			transaction.commit();
+			bookmarkCapture.seedWith(session.lastBookmark());
+		}
+	}
+
 	@Test // GH-2323
 	void listOfRelationshipPropertiesShouldBeUnwindable(@Autowired PersonService personService) {
 		Person person = personService.updateRel(personId, Arrays.asList("German"));
@@ -79,14 +92,40 @@ void listOfRelationshipPropertiesShouldBeUnwindable(@Autowired PersonService per
 		});
 	}
 
+	@Test // GH-2537
+	void ensureRelationshipsAreSerialized(@Autowired PersonService personService) {
+
+		Optional<Person> optionalPerson = personService.updateRel2(personId, Arrays.asList("German"));
+		assertThat(optionalPerson).isPresent().hasValueSatisfying(person -> {
+			assertThat(person.getKnownLanguages()).hasSize(1);
+			assertThat(person.getKnownLanguages()).first().satisfies(knows -> {
+				assertThat(knows.getDescription()).isEqualTo("Some description");
+				assertThat(knows.getLanguage()).extracting(Language::getName).isEqualTo("German");
+			});
+		});
+	}
+
 	@Repository
 	public interface PersonRepository extends Neo4jRepository<Person, String> {
 
-		@Query("UNWIND $relations As rel WITH rel " +
-			   "CREATE (f:Person {id: $from}) - [r:KNOWS {description: rel.__properties__.description}] -> (t:Language {name: rel.__properties__.__target__.__id__}) "
-			   +
-			   "RETURN f, collect(r), collect(t)")
+		// Using separate id and than relationships on top level
+		@Query(""
+			   + "UNWIND $relations As rel WITH rel "
+			   + "MATCH (f:Person {id: $from}) "
+			   + "MATCH (t:Language {name: rel.__target__.__id__}) "
+			   + "CREATE (f)- [r:KNOWS {description: rel.__properties__.description}] -> (t) "
+			   + "RETURN f, collect(r), collect(t)"
+		)
 		Person updateRel(@Param("from") String from, @Param("relations") List<Knows> relations);
+
+		// Using the whole person object
+		@Query(""
+			   + "UNWIND $person.__properties__.KNOWS As rel WITH rel "
+			   + "MATCH (f:Person {id: $person.__id__}) "
+			   + "MATCH  (t:Language {name: rel.__target__.__id__}) "
+			   + "CREATE (f) - [r:KNOWS {description: rel.__properties__.description}] -> (t) "
+			   + "RETURN f, collect(r), collect(t)")
+		Person updateRel2(@Param("person") Person person);
 	}
 
 	@Service
@@ -105,6 +144,21 @@ public Person updateRel(String from, List<String> languageNames) {
 					.collect(Collectors.toList());
 			return personRepository.updateRel(from, knownLanguages);
 		}
+
+		public Optional<Person> updateRel2(String id, List<String> languageNames) {
+
+			Optional<Person> original = personRepository.findById(id);
+			if (original.isPresent()) {
+				Person person = original.get();
+				List<Knows> knownLanguages = languageNames.stream().map(Language::new)
+						.map(language -> new Knows("Some description", language))
+						.collect(Collectors.toList());
+				person.setKnownLanguages(knownLanguages);
+				return Optional.of(personRepository.updateRel2(person));
+			}
+
+			return original;
+		}
 	}
 
 	@Configuration

src/test/java/org/springframework/data/neo4j/integration/issues/gh2323/Person.java

@@ -52,4 +52,8 @@ public String getName() {
 	public List<Knows> getKnownLanguages() {
 		return knownLanguages;
 	}
+
+	public void setKnownLanguages(List<Knows> knownLanguages) {
+		this.knownLanguages = knownLanguages;
+	}
 }

src/test/java/org/springframework/data/neo4j/repository/query/Neo4jNestedMapEntityWriterTest.java

@@ -146,10 +146,10 @@ void relationshipPropertiesShouldBeSerializedWithTargetNodeWhenPassedFirstToWrit
 		Map<String, Value> properties = (Map<String, Value>) result.get("__properties__");
 		assertThat(properties).containsEntry("description", Values.value("Some description"));
 
-		assertThat(properties).hasEntrySatisfying("__target__", isAMapValue);
-		properties = properties.get("__target__").asMap(Function.identity());
-		assertThat(properties).containsEntry("__id__", Values.value("German"));
-		assertThat(properties).hasEntrySatisfying("__properties__", isAMapValue);
+		assertThat(result).hasEntrySatisfying("__target__", isAMapValue);
+		Map<String, Value> target = ((Value) result.get("__target__")).asMap(Function.identity());
+		assertThat(target).containsEntry("__id__", Values.value("German"));
+		assertThat(target).hasEntrySatisfying("__properties__", isAMapValue);
 	}
 
 	@Test // DATAGRAPH-1452