GH-2148 - Create new objects/collection on save.

If needed create new collections and object instances on save.
This can be the case if the underlying objects are immutable.

Author: michael-simons

src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java

@@ -267,9 +267,10 @@ private <T> T saveImpl(T instance) {
 		PersistentPropertyAccessor<T> propertyAccessor = entityMetaData.getPropertyAccessor(entityToBeSaved);
 		if (entityMetaData.isUsingInternalIds()) {
 			propertyAccessor.setProperty(entityMetaData.getRequiredIdProperty(), optionalInternalId.get());
-			entityToBeSaved = propertyAccessor.getBean();
 		}
-		return processRelations(entityMetaData, entityToBeSaved, isEntityNew, instance);
+		processRelations(entityMetaData, instance, propertyAccessor, isEntityNew);
+
+		return propertyAccessor.getBean();
 	}
 
 	private <T> DynamicLabels determineDynamicLabels(T entityToBeSaved, Neo4jPersistentEntity<?> entityMetaData) {
@@ -318,36 +319,41 @@ public <T> List<T> saveAll(Iterable<T> instances) {
 			return entities.stream().map(e -> saveImpl(e)).collect(Collectors.toList());
 		}
 
-		// we need to determine the `isNew` state of the entities before calling the id generator
-		List<Boolean> isNewIndicator = entities.stream().map(entity ->
-			neo4jMappingContext.getPersistentEntity(entity.getClass()).isNew(entity)
-		).collect(Collectors.toList());
+		class Tuple3<T> {
+			T t1;
+			boolean t2;
+			T t3;
+
+			Tuple3(T t1, boolean t2, T t3) {
+				this.t1 = t1;
+				this.t2 = t2;
+				this.t3 = t3;
+			}
+		}
 
-		List<T> entitiesToBeSaved = entities.stream().map(eventSupport::maybeCallBeforeBind)
+		List<Tuple3<T>> entitiesToBeSaved = entities.stream()
+				.map(e -> new Tuple3<>(e, neo4jMappingContext.getPersistentEntity(e.getClass()).isNew(e), eventSupport.maybeCallBeforeBind(e)))
 				.collect(Collectors.toList());
 
 		// Save roots
 		Function<T, Map<String, Object>> binderFunction = neo4jMappingContext.getRequiredBinderFunctionFor(domainClass);
-		List<Map<String, Object>> entityList = entitiesToBeSaved.stream().map(binderFunction)
+		List<Map<String, Object>> entityList = entitiesToBeSaved.stream().map(h -> h.t3).map(binderFunction)
 				.collect(Collectors.toList());
 		ResultSummary resultSummary = neo4jClient
 				.query(() -> renderer.render(cypherGenerator.prepareSaveOfMultipleInstancesOf(entityMetaData)))
 				.bind(entityList).to(Constants.NAME_OF_ENTITY_LIST_PARAM).run();
 
-		// Save related
-		entitiesToBeSaved.forEach(entityToBeSaved -> {
-			int positionInList = entitiesToBeSaved.indexOf(entityToBeSaved);
-			processRelations(entityMetaData, entityToBeSaved, isNewIndicator.get(positionInList),
-					entities.get(positionInList));
-		});
-
 		SummaryCounters counters = resultSummary.counters();
 		log.debug(() -> String.format(
 				"Created %d and deleted %d nodes, created %d and deleted %d relationships and set %d properties.",
 				counters.nodesCreated(), counters.nodesDeleted(), counters.relationshipsCreated(),
 				counters.relationshipsDeleted(), counters.propertiesSet()));
 
-		return entitiesToBeSaved;
+		// Save related
+		return entitiesToBeSaved.stream().map(t -> {
+			PersistentPropertyAccessor<T> propertyAccessor = entityMetaData.getPropertyAccessor(t.t3);
+			return processRelations(entityMetaData, t.t1, propertyAccessor, t.t2);
+		}).collect(Collectors.toList());
 	}
 
 	@Override
@@ -448,27 +454,37 @@ private <T> ExecutableQuery<T> createExecutableQuery(Class<T> domainType, String
 		return toExecutableQuery(preparedQuery);
 	}
 
-	private <T> T processRelations(Neo4jPersistentEntity<?> neo4jPersistentEntity, Object parentObject,
-			boolean isParentObjectNew, Object parentEntity) {
+	/**
+	 * Starts of processing of the relationships.
+	 *
+	 * @param neo4jPersistentEntity  The description of the instance to save
+	 * @param originalInstance       The original parent instance. It is paramount to pass in the original instance (prior
+	 *                               to generating the id and prior to eventually create new instances via the property accessor,
+	 *                               so that we can reliable stop traversing relationships.
+	 * @param parentPropertyAccessor The property accessor of the parent, to modify the relationships
+	 * @param isParentObjectNew      A flag if the parent was new
+	 */
+	private <T> T processRelations(Neo4jPersistentEntity<?> neo4jPersistentEntity, T originalInstance,
+			PersistentPropertyAccessor<?> parentPropertyAccessor,
+			boolean isParentObjectNew) {
 
-		return processNestedRelations(neo4jPersistentEntity, parentObject, isParentObjectNew,
-				new NestedRelationshipProcessingStateMachine(parentEntity));
+		return processNestedRelations(neo4jPersistentEntity, parentPropertyAccessor, isParentObjectNew,
+				new NestedRelationshipProcessingStateMachine(originalInstance));
 	}
 
-	private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity, Object parentObject,
+	private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity, PersistentPropertyAccessor<?> propertyAccessor,
 			boolean isParentObjectNew, NestedRelationshipProcessingStateMachine stateMachine) {
 
-		PersistentPropertyAccessor<?> propertyAccessor = sourceEntity.getPropertyAccessor(parentObject);
 		Object fromId = propertyAccessor.getProperty(sourceEntity.getRequiredIdProperty());
 
 		sourceEntity.doWithAssociations((AssociationHandler<Neo4jPersistentProperty>) association -> {
 
 			// create context to bundle parameters
-			NestedRelationshipContext relationshipContext = NestedRelationshipContext.of(association, propertyAccessor,
-					sourceEntity);
+			NestedRelationshipContext relationshipContext = NestedRelationshipContext.of(association, propertyAccessor, sourceEntity);
 
+			Object rawValue = relationshipContext.getValue();
 			Collection<?> relatedValuesToStore = MappingSupport.unifyRelationshipValue(relationshipContext.getInverse(),
-					relationshipContext.getValue());
+					rawValue);
 
 			RelationshipDescription relationshipDescription = relationshipContext.getRelationship();
 			RelationshipDescription relationshipDescriptionObverse = relationshipDescription.getRelationshipObverse();
@@ -523,22 +539,26 @@ private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity, Obje
 
 			stateMachine.markRelationshipAsProcessed(fromId, relationshipDescription);
 
+			Neo4jPersistentProperty relationshipProperty = association.getInverse();
+
+			RelationshipHandler relationshipHandler = RelationshipHandler.forProperty(relationshipProperty, rawValue);
+
 			for (Object relatedValueToStore : relatedValuesToStore) {
 
 				// here a map entry is not always anymore a dynamic association
-				Object relatedNode = relationshipContext.identifyAndExtractRelationshipTargetNode(relatedValueToStore);
-				Neo4jPersistentEntity<?> targetEntity = neo4jMappingContext.getPersistentEntity(relatedNode.getClass());
+				Object relatedObjectBeforeCallbacks = relationshipContext.identifyAndExtractRelationshipTargetNode(relatedValueToStore);
+				Neo4jPersistentEntity<?> targetEntity = neo4jMappingContext.getPersistentEntity(relatedObjectBeforeCallbacks.getClass());
 
-				boolean isEntityNew = targetEntity.isNew(relatedNode);
+				boolean isEntityNew = targetEntity.isNew(relatedObjectBeforeCallbacks);
 
-				relatedNode = eventSupport.maybeCallBeforeBind(relatedNode);
+				Object newRelatedObject = eventSupport.maybeCallBeforeBind(relatedObjectBeforeCallbacks);
 
 				Long relatedInternalId;
 				// No need to save values if processed
 				if (stateMachine.hasProcessedValue(relatedValueToStore)) {
-					relatedInternalId = queryRelatedNode(relatedNode, targetEntity);
+					relatedInternalId = queryRelatedNode(newRelatedObject, targetEntity);
 				} else {
-					relatedInternalId = saveRelatedNode(relatedNode, relationshipContext.getAssociationTargetType(),
+					relatedInternalId = saveRelatedNode(newRelatedObject, relationshipContext.getAssociationTargetType(),
 							targetEntity);
 				}
 				stateMachine.markValueAsProcessed(relatedValueToStore);
@@ -569,16 +589,26 @@ private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity, Obje
 							.setProperty(idProperty, relationshipInternalId.get());
 				}
 
-				PersistentPropertyAccessor<?> targetPropertyAccessor = targetEntity.getPropertyAccessor(relatedNode);
-				// if an internal id is used this must get set to link this entity in the next iteration
+				PersistentPropertyAccessor<?> targetPropertyAccessor = targetEntity.getPropertyAccessor(newRelatedObject);
+				// if an internal id is used this must be set to link this entity in the next iteration
 				if (targetEntity.isUsingInternalIds()) {
 					targetPropertyAccessor.setProperty(targetEntity.getRequiredIdProperty(), relatedInternalId);
 				}
+
 				if (processState != ProcessState.PROCESSED_ALL_VALUES) {
-					processNestedRelations(targetEntity, targetPropertyAccessor.getBean(), isEntityNew, stateMachine);
+					processNestedRelations(targetEntity, targetPropertyAccessor, isEntityNew, stateMachine);
 				}
+
+				Object potentiallyRecreatedNewRelatedObject = MappingSupport.getRelationshipOrRelationshipPropertiesObject(neo4jMappingContext,
+								relationshipDescription.hasRelationshipProperties(),
+								relationshipProperty.isDynamicAssociation(),
+								relatedValueToStore,
+								targetPropertyAccessor);
+
+				relationshipHandler.handle(relatedValueToStore, relatedObjectBeforeCallbacks, potentiallyRecreatedNewRelatedObject);
 			}
 
+			relationshipHandler.applyFinalResultToOwner(propertyAccessor);
 		});
 
 		return (T) propertyAccessor.getBean();