GH-2207 - Improve the pair of isEntity and isAssociation.

This introduces the idea of a "writable property": Something that can be
written "as is" to the database. This is a rather complicated decision
to make due to the constructs we support back from Neo4j-OGM days.

It goes hand in hand with the decision whether a given property on a
entity of the domain describes an association: Everything that is either
explicitly annotated with `@Relationship` or is not something that would
appear as a graph property is an association.

A property on the domain model on the other hand is an entity when it is
not something that can be written directly to the graph.

That leaves the special case of entities with properties: Those life
quite literally between entities, as associations with properties. To
make them work in the context of Spring Data Commons, they must be
treated as entities and in a dedicated way in our converters. This is
now encapsulated in the (already) existing dedicated method
`isEntityWithRelationshipProperties()`. However, this method is no longer
called from `isEntity()` to solve the cyclic meaning here.

Author: michael-simons

src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jPersistentProperty.java

@@ -48,6 +48,13 @@ final class DefaultNeo4jPersistentProperty extends AnnotationBasedPersistentProp
 		implements Neo4jPersistentProperty {
 
 	private final Lazy<String> graphPropertyName;
+	/**
+	 * A flag whether this is a writeable property: Something that ends up on a Neo4j node or relationship.
+	 */
+	private final Lazy<Boolean> isWritableProperty;
+	/**
+	 * A flag whether this domain property manifests itself as a relationship in Neo4j.
+	 */
 	private final Lazy<Boolean> isAssociation;
 
 	private final Neo4jMappingContext mappingContext;
@@ -68,15 +75,22 @@ final class DefaultNeo4jPersistentProperty extends AnnotationBasedPersistentProp
 		this.mappingContext = mappingContext;
 
 		this.graphPropertyName = Lazy.of(this::computeGraphPropertyName);
+
+		this.isWritableProperty = Lazy.of(() -> {
+			Class<?> targetType = getActualType();
+			return simpleTypeHolder.isSimpleType(targetType) // The driver can do this
+				   || this.mappingContext.hasCustomWriteTarget(targetType) // Some converter in the context can do this
+				   || isAnnotationPresent(ConvertWith.class) // An explicit converter can do this
+				   || isComposite(); // Our composite converter can do this
+		});
+
 		this.isAssociation = Lazy.of(() -> {
 
 			// Bail out early, this is pretty much explicit
 			if (isAnnotationPresent(Relationship.class)) {
 				return true;
 			}
-			Class<?> targetType = getActualType();
-			return !(simpleTypeHolder.isSimpleType(targetType) || this.mappingContext.hasCustomWriteTarget(targetType)
-					|| isAnnotationPresent(TargetNode.class) || isComposite() || isAnnotationPresent(ConvertWith.class));
+			return !(isWritableProperty.get() || isAnnotationPresent(TargetNode.class));
 		});
 
 		this.customConversion = Lazy.of(() -> {
@@ -186,7 +200,12 @@ public boolean isAssociation() {
 
 	@Override
 	public boolean isEntity() {
-		return super.isEntity() && isAssociation() || (isEntityWithRelationshipProperties() && !isComposite());
+		return super.isEntity() && !isWritableProperty.get();
+	}
+
+	@Override
+	public boolean isEntityWithRelationshipProperties() {
+		return isEntity() && ((Neo4jPersistentEntity<?>) getOwner()).isRelationshipPropertiesEntity();
 	}
 
 	private static Function<Object, Value> nullSafeWrite(Function<Object, Value> delegate) {
@@ -207,11 +226,6 @@ public Function<Value, Object> getOptionalReadingConverter() {
 		return customConversion.getOptional().map(c -> nullSafeRead(c::read)).orElse(null);
 	}
 
-	@Override
-	public boolean isEntityWithRelationshipProperties() {
-		return super.isEntity() && ((Neo4jPersistentEntity<?>) getOwner()).isRelationshipPropertiesEntity();
-	}
-
 	/**
 	 * Computes the target name of this property.
 	 *