everything works but nullaway still fails

Signed-off-by: Gerrit Meier <[email protected]>

Author: meistermeier

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

@@ -33,6 +33,7 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.apache.commons.logging.LogFactory;
 import org.apiguardian.api.API;
@@ -87,7 +88,7 @@
 import org.springframework.data.neo4j.core.mapping.SpringDataCypherDsl;
 import org.springframework.data.neo4j.core.mapping.callback.EventSupport;
 import org.springframework.data.neo4j.core.schema.TargetNode;
-import org.springframework.data.neo4j.core.support.UserDefinedChangeEvaluator;
+import org.springframework.data.neo4j.core.support.NeedsUpdateEvaluator;
 import org.springframework.data.neo4j.core.transaction.Neo4jTransactionManager;
 import org.springframework.data.neo4j.repository.NoResultException;
 import org.springframework.data.neo4j.repository.query.QueryFragments;
@@ -157,7 +158,8 @@ public boolean isReadOnly() {
 
 	@Nullable
 	private TransactionTemplate transactionTemplateReadOnly;
-	private final Map<Class, UserDefinedChangeEvaluator> userDefinedChangeEvaluators = new HashMap<>();
+
+	private final Map<Class, NeedsUpdateEvaluator> needsUpdateEvaluators = new HashMap<>();
 
 	public Neo4jTemplate(Neo4jClient neo4jClient) {
 		this(neo4jClient, new Neo4jMappingContext());
@@ -454,15 +456,19 @@ public <T> T save(T instance) {
 	private <T> T saveImpl(T instance, @Nullable Collection<PropertyFilter.ProjectedPath> includedProperties,
 			@Nullable NestedRelationshipProcessingStateMachine stateMachine) {
 
-		if ((stateMachine != null && stateMachine.hasProcessedValue(instance))
-			|| (this.userDefinedChangeEvaluators.containsKey(instance.getClass()) && !this.userDefinedChangeEvaluators.get(instance.getClass()).needsUpdate(instance))) {
+		if (stateMachine != null && stateMachine.hasProcessedValue(instance)) {
 			return instance;
 		}
 
 		Neo4jPersistentEntity<?> entityMetaData = this.neo4jMappingContext
 			.getRequiredPersistentEntity(instance.getClass());
 		boolean isEntityNew = entityMetaData.isNew(instance);
 
+		if (!isEntityNew && this.needsUpdateEvaluators.containsKey(instance.getClass())
+				&& !this.needsUpdateEvaluators.get(instance.getClass()).needsUpdate(instance)) {
+			return instance;
+		}
+
 		T entityToBeSaved = this.eventSupport.maybeCallBeforeBind(instance);
 
 		DynamicLabels dynamicLabels = determineDynamicLabels(entityToBeSaved, entityMetaData);
@@ -612,9 +618,16 @@ class Tuple3<T> {
 		}
 
 		List<Tuple3<T>> entitiesToBeSaved = entities.stream()
+			.filter(e -> entityMetaData.isNew(e) || !this.needsUpdateEvaluators.containsKey(e.getClass())
+					|| this.needsUpdateEvaluators.get(e.getClass()).needsUpdate(e))
 			.map(e -> new Tuple3<>(e, entityMetaData.isNew(e), this.eventSupport.maybeCallBeforeBind(e)))
 			.collect(Collectors.toList());
 
+		List<T> unprocessedEntities = entities.stream()
+			.filter(e -> !entityMetaData.isNew(e) && (this.needsUpdateEvaluators.containsKey(e.getClass())
+					&& !this.needsUpdateEvaluators.get(e.getClass()).needsUpdate(e)))
+			.toList();
+
 		// Save roots
 		@SuppressWarnings("unchecked") // We can safely assume here that we have a
 										// humongous collection with only one single type
@@ -640,7 +653,7 @@ class Tuple3<T> {
 
 		// Save related
 		var stateMachine = new NestedRelationshipProcessingStateMachine(this.neo4jMappingContext, null, null);
-		return entitiesToBeSaved.stream().map(t -> {
+		return Stream.of(entitiesToBeSaved.stream().map(t -> {
 			PersistentPropertyAccessor<T> propertyAccessor = entityMetaData.getPropertyAccessor(t.modifiedInstance);
 			Neo4jPersistentProperty idProperty = entityMetaData.getRequiredIdProperty();
 			Object id = TemplateSupport.convertIdValues(this.neo4jMappingContext, idProperty,
@@ -652,7 +665,7 @@ class Tuple3<T> {
 							((includedProperties != null && !includedProperties.isEmpty()) || includeProperty != null)
 									? pps : includedPropertiesByClass.get(t.modifiedInstance.getClass()),
 							entityMetaData));
-		}).collect(Collectors.toList());
+		}).collect(Collectors.toList()), unprocessedEntities).flatMap(Collection::stream).toList();
 	}
 
 	@Override
@@ -984,18 +997,18 @@ private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity,
 				var skipUpdateOfEntity = !isNewEntity;
 				if (relatedValueToStore instanceof MappingSupport.RelationshipPropertiesWithEntityHolder rpweh) {
 					var relatedEntity = rpweh.getRelatedEntity();
-					skipUpdateOfEntity &= this.userDefinedChangeEvaluators.containsKey(relatedEntity.getClass())
-							&& !this.userDefinedChangeEvaluators.get(relatedEntity.getClass()).needsUpdate(relatedEntity);
+					skipUpdateOfEntity &= this.needsUpdateEvaluators.containsKey(relatedEntity.getClass())
+							&& !this.needsUpdateEvaluators.get(relatedEntity.getClass()).needsUpdate(relatedEntity);
 				}
 				else {
-					skipUpdateOfEntity &= this.userDefinedChangeEvaluators.containsKey(relatedValueToStore.getClass())
-							&& !this.userDefinedChangeEvaluators.get(relatedValueToStore.getClass()).needsUpdate(relatedValueToStore);
+					skipUpdateOfEntity &= this.needsUpdateEvaluators.containsKey(relatedValueToStore.getClass())
+							&& !this.needsUpdateEvaluators.get(relatedValueToStore.getClass())
+								.needsUpdate(relatedValueToStore);
 				}
 				Object newRelatedObject = stateMachine.hasProcessedValue(relatedObjectBeforeCallbacksApplied)
 						? stateMachine.getProcessedAs(relatedObjectBeforeCallbacksApplied)
-						: skipUpdateOfEntity
-							? relatedObjectBeforeCallbacksApplied
-							: this.eventSupport.maybeCallBeforeBind(relatedObjectBeforeCallbacksApplied);
+						: skipUpdateOfEntity ? relatedObjectBeforeCallbacksApplied
+								: this.eventSupport.maybeCallBeforeBind(relatedObjectBeforeCallbacksApplied);
 
 				Object relatedInternalId;
 				Entity savedEntity = null;
@@ -1004,7 +1017,7 @@ private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity,
 					relatedInternalId = stateMachine.getObjectId(relatedValueToStore);
 				}
 				else {
-					if ((isNewEntity || relationshipDescription.cascadeUpdates()) && !skipUpdateOfEntity) {
+					if (isNewEntity || (relationshipDescription.cascadeUpdates() && !skipUpdateOfEntity)) {
 						savedEntity = saveRelatedNode(newRelatedObject, targetEntity, includeProperty,
 								currentPropertyPath);
 					}
@@ -1341,8 +1354,9 @@ public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 			}
 		}
 		setTransactionManager(transactionManager);
-		this.userDefinedChangeEvaluators.putAll(beanFactory.getBeanProvider(UserDefinedChangeEvaluator.class).stream()
-				.collect(Collectors.toMap(e -> e.getEvaluatingClass(), e -> e)));
+		this.needsUpdateEvaluators.putAll(beanFactory.getBeanProvider(NeedsUpdateEvaluator.class)
+			.stream()
+			.collect(Collectors.toMap(e -> e.getEvaluatingClass(), e -> e)));
 	}
 
 	// only used for the CDI configuration

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

@@ -92,6 +92,7 @@
 import org.springframework.data.neo4j.core.mapping.SpringDataCypherDsl;
 import org.springframework.data.neo4j.core.mapping.callback.ReactiveEventSupport;
 import org.springframework.data.neo4j.core.schema.TargetNode;
+import org.springframework.data.neo4j.core.support.NeedsUpdateEvaluator;
 import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager;
 import org.springframework.data.neo4j.repository.query.QueryFragments;
 import org.springframework.data.neo4j.repository.query.QueryFragmentsAndParameters;
@@ -158,6 +159,8 @@ public boolean isReadOnly() {
 
 	private Function<Named, FunctionInvocation> elementIdOrIdFunction;
 
+	private final Map<Class, NeedsUpdateEvaluator> needsUpdateEvaluators = new HashMap<>();
+
 	public ReactiveNeo4jTemplate(ReactiveNeo4jClient neo4jClient, Neo4jMappingContext neo4jMappingContext) {
 		this(neo4jClient, neo4jMappingContext, null);
 	}
@@ -652,31 +655,45 @@ private <T> Flux<T> saveAllImpl(Iterable<T> instances,
 				: Objects.requireNonNullElseGet(includedProperties, List::of);
 
 		Neo4jPersistentEntity<?> entityMetaData = this.neo4jMappingContext.getRequiredPersistentEntity(domainClass);
+
+		List<T> entitiesToProcess = entities.stream()
+			.filter(e -> this.neo4jMappingContext.getRequiredPersistentEntity(e.getClass()).isNew(e)
+					|| !this.needsUpdateEvaluators.containsKey(e.getClass())
+					|| this.needsUpdateEvaluators.get(e.getClass()).needsUpdate(e))
+			.collect(Collectors.toList());
+
+		List<T> unprocessedEntities = entities.stream()
+			.filter(e -> !this.neo4jMappingContext.getRequiredPersistentEntity(e.getClass()).isNew(e)
+					&& (this.needsUpdateEvaluators.containsKey(e.getClass())
+							&& !this.needsUpdateEvaluators.get(e.getClass()).needsUpdate(e)))
+			.toList();
+
 		if (heterogeneousCollection || entityMetaData.isUsingInternalIds() || entityMetaData.hasVersionProperty()
 				|| entityMetaData.getDynamicLabelsProperty().isPresent()) {
 			log.debug("Saving entities using single statements.");
 
 			NestedRelationshipProcessingStateMachine stateMachine = new NestedRelationshipProcessingStateMachine(
 					this.neo4jMappingContext);
 
-			return Flux.fromIterable(entities)
+			return Flux.fromIterable(entitiesToProcess)
 				.concatMap(e -> this.saveImpl(e,
 						((includedProperties != null && !includedProperties.isEmpty()) || includeProperty != null) ? pps
 								: includedPropertiesByClass.get(e.getClass()),
-						stateMachine));
+						stateMachine))
+				.concatWith(Flux.fromIterable(unprocessedEntities));
 		}
 
 		@SuppressWarnings("unchecked") // We can safely assume here that we have a
 										// humongous collection with only one single type
 										// being either T or extending it
 		Function<T, Map<String, Object>> binderFunction = TemplateSupport.createAndApplyPropertyFilter(pps,
 				entityMetaData, this.neo4jMappingContext.getRequiredBinderFunctionFor((Class<T>) domainClass));
-		return (Flux<T>) Flux.deferContextual((ctx) -> Flux.fromIterable(entities)
+		return (Flux<T>) Flux.deferContextual((ctx) -> Flux.fromIterable(entitiesToProcess)
 			// Map all entities into a tuple <Original, OriginalWasNew>
 			.map(e -> Tuples.of(e, entityMetaData.isNew(e)))
 			// Map that tuple into a tuple <<Original, OriginalWasNew>,
 			// PotentiallyModified>
-			.zipWith(Flux.fromIterable(entities).flatMapSequential(this.eventSupport::maybeCallBeforeBind))
+			.zipWith(Flux.fromIterable(entitiesToProcess).flatMapSequential(this.eventSupport::maybeCallBeforeBind))
 			// And for my own sanity, back into a flat Tuple3
 			.map(nested -> Tuples.of(nested.getT1().getT1(), nested.getT1().getT2(), nested.getT2()))
 			.collectList()
@@ -709,7 +726,8 @@ private <T> Flux<T> saveAllImpl(Iterable<T> instances,
 			}))))
 			.contextWrite(ctx -> ctx
 				.put("stateMachine", new NestedRelationshipProcessingStateMachine(this.neo4jMappingContext, null, null))
-				.put("knownRelIds", new HashSet<>()));
+				.put("knownRelIds", new HashSet<>()))
+			.concatWith(Flux.fromIterable(unprocessedEntities));
 	}
 
 	@Override
@@ -1115,12 +1133,17 @@ private <T> Mono<T> processNestedRelations(Neo4jPersistentEntity<?> sourceEntity
 						.getRequiredPersistentEntity(relatedObjectBeforeCallbacksApplied.getClass());
 					boolean isNewEntity = targetEntity.isNew(relatedObjectBeforeCallbacksApplied);
 
+					var related = (relatedValueToStore instanceof MappingSupport.RelationshipPropertiesWithEntityHolder rpweh)
+							? rpweh.getRelatedEntity() : relatedValueToStore;
+
+					var skipUpdateOfEntity = !isNewEntity && this.needsUpdateEvaluators.containsKey(related.getClass())
+							&& !this.needsUpdateEvaluators.get(related.getClass()).needsUpdate(related);
 					return Mono.deferContextual(ctx ->
 
 				(stateMachine.hasProcessedValue(relatedObjectBeforeCallbacksApplied)
 						? Mono.just(stateMachine.getProcessedAs(relatedObjectBeforeCallbacksApplied))
-						: this.eventSupport.maybeCallBeforeBind(relatedObjectBeforeCallbacksApplied))
-
+						: skipUpdateOfEntity ? Mono.just(relatedObjectBeforeCallbacksApplied)
+								: this.eventSupport.maybeCallBeforeBind(relatedObjectBeforeCallbacksApplied))
 					.flatMap(newRelatedObject -> {
 
 						Mono<Tuple2<AtomicReference<Object>, AtomicReference<Entity>>> queryOrSave;
@@ -1134,7 +1157,7 @@ private <T> Mono<T> processNestedRelations(Neo4jPersistentEntity<?> sourceEntity
 						}
 						else {
 							Mono<Entity> savedEntity;
-							if (isNewEntity || relationshipDescription.cascadeUpdates()) {
+							if (isNewEntity || (relationshipDescription.cascadeUpdates() && !skipUpdateOfEntity)) {
 								savedEntity = saveRelatedNode(newRelatedObject, targetEntity, includeProperty,
 										currentPropertyPath);
 							}
@@ -1468,6 +1491,9 @@ public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 			}
 		}
 		setTransactionManager(reactiveTransactionManager);
+		this.needsUpdateEvaluators.putAll(beanFactory.getBeanProvider(NeedsUpdateEvaluator.class)
+			.stream()
+			.collect(Collectors.toMap(e -> e.getEvaluatingClass(), e -> e)));
 	}
 
 	private void setTransactionManager(@Nullable ReactiveTransactionManager reactiveTransactionManager) {

src/main/java/org/springframework/data/neo4j/core/support/NeedsUpdateEvaluator.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2011-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.neo4j.core.support;
+
+/**
+ * Interface to implement for a concrete implementation (not an inherited class or
+ * interface). Returns if an entity and its relationships needs to be processed for
+ * updates or not.
+ *
+ * @param <T> type to implement the needs update logic for
+ * @author Gerrit Meier
+ */
+public interface NeedsUpdateEvaluator<T> {
+
+	/**
+	 * Report if this entity needs to be considered for an update. This includes possible
+	 * relationships.
+	 * @param instance instance of type `T` to check
+	 * @return true, if it should be processed
+	 */
+	default boolean needsUpdate(T instance) {
+		return true;
+	}
+
+	Class<T> getEvaluatingClass();
+
+}