Support QueryResultConverter for delete, replace and update operations.

Original Pull Request: #4949

Author: christophstrobl

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableRemoveOperation.java

@@ -19,6 +19,7 @@
 
 import org.springframework.data.mongodb.core.query.CriteriaDefinition;
 import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Contract;
 
 import com.mongodb.client.result.DeleteResult;
 
@@ -54,11 +55,36 @@ public interface ExecutableRemoveOperation {
 	 */
 	<T> ExecutableRemove<T> remove(Class<T> domainType);
 
+	interface TerminatingResults<T> {
+
+		/**
+		 * Map the query result to a different type using {@link QueryResultConverter}.
+		 *
+		 * @param <R> {@link Class type} of the result.
+		 * @param converter the converter, must not be {@literal null}.
+		 * @return new instance of {@link ExecutableFindOperation.TerminatingResults}.
+		 * @throws IllegalArgumentException if {@link QueryResultConverter converter} is {@literal null}.
+		 * @since x.y
+		 */
+		@Contract("_ -> new")
+		<R> TerminatingResults<R> map(QueryResultConverter<? super T, ? extends R> converter);
+
+		/**
+		 * Remove and return all matching documents. <br/>
+		 * <strong>NOTE:</strong> The entire list of documents will be fetched before sending the actual delete commands.
+		 * Also, {@link org.springframework.context.ApplicationEvent}s will be published for each and every delete
+		 * operation.
+		 *
+		 * @return empty {@link List} if no match found. Never {@literal null}.
+		 */
+		List<T> findAndRemove();
+	}
+
 	/**
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface TerminatingRemove<T> {
+	interface TerminatingRemove<T> extends TerminatingResults<T> {
 
 		/**
 		 * Remove all documents matching.
@@ -73,16 +99,6 @@ interface TerminatingRemove<T> {
 		 * @return the {@link DeleteResult}. Never {@literal null}.
 		 */
 		DeleteResult one();
-
-		/**
-		 * Remove and return all matching documents. <br/>
-		 * <strong>NOTE:</strong> The entire list of documents will be fetched before sending the actual delete commands.
-		 * Also, {@link org.springframework.context.ApplicationEvent}s will be published for each and every delete
-		 * operation.
-		 *
-		 * @return empty {@link List} if no match found. Never {@literal null}.
-		 */
-		List<T> findAndRemove();
 	}
 
 	/**
@@ -105,7 +121,6 @@ interface RemoveWithCollection<T> extends RemoveWithQuery<T> {
 		RemoveWithQuery<T> inCollection(String collection);
 	}
 
-
 	/**
 	 * @author Christoph Strobl
 	 * @since 2.0

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableRemoveOperationSupport.java

@@ -48,26 +48,28 @@ public <T> ExecutableRemove<T> remove(Class<T> domainType) {
 
 		Assert.notNull(domainType, "DomainType must not be null");
 
-		return new ExecutableRemoveSupport<>(tempate, domainType, ALL_QUERY, null);
+		return new ExecutableRemoveSupport<>(tempate, domainType, ALL_QUERY, null, QueryResultConverter.entity());
 	}
 
 	/**
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	static class ExecutableRemoveSupport<T> implements ExecutableRemove<T>, RemoveWithCollection<T> {
+	static class ExecutableRemoveSupport<S, T> implements ExecutableRemove<T>, RemoveWithCollection<T> {
 
 		private final MongoTemplate template;
-		private final Class<T> domainType;
+		private final Class<S> domainType;
 		private final Query query;
 		@Nullable private final String collection;
+		private final QueryResultConverter<? super S, ? extends T> resultConverter;
 
-		public ExecutableRemoveSupport(MongoTemplate template, Class<T> domainType, Query query,
-				@Nullable String collection) {
+		public ExecutableRemoveSupport(MongoTemplate template, Class<S> domainType, Query query,
+				@Nullable String collection, QueryResultConverter<? super S, ? extends T> resultConverter) {
 			this.template = template;
 			this.domainType = domainType;
 			this.query = query;
 			this.collection = collection;
+			this.resultConverter = resultConverter;
 		}
 
 		@Override
@@ -76,7 +78,7 @@ public RemoveWithQuery<T> inCollection(String collection) {
 
 			Assert.hasText(collection, "Collection must not be null nor empty");
 
-			return new ExecutableRemoveSupport<>(template, domainType, query, collection);
+			return new ExecutableRemoveSupport<>(template, domainType, query, collection, resultConverter);
 		}
 
 		@Override
@@ -85,7 +87,7 @@ public TerminatingRemove<T> matching(Query query) {
 
 			Assert.notNull(query, "Query must not be null");
 
-			return new ExecutableRemoveSupport<>(template, domainType, query, collection);
+			return new ExecutableRemoveSupport<>(template, domainType, query, collection, resultConverter);
 		}
 
 		@Override
@@ -103,7 +105,12 @@ public List<T> findAndRemove() {
 
 			String collectionName = getCollectionName();
 
-			return template.doFindAndDelete(collectionName, query, domainType);
+			return template.doFindAndDelete(collectionName, query, domainType, resultConverter);
+		}
+
+		@Override
+		public <R> TerminatingResults<R> map(QueryResultConverter<? super T, ? extends R> converter) {
+			return new ExecutableRemoveSupport<>(template, (Class) domainType, query, collection, converter);
 		}
 
 		private String getCollectionName() {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableUpdateOperation.java

@@ -18,13 +18,15 @@
 import java.util.Optional;
 
 import org.jspecify.annotations.Nullable;
+import org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingResults;
 import org.springframework.data.mongodb.core.aggregation.AggregationUpdate;
 import org.springframework.data.mongodb.core.query.CriteriaDefinition;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.data.mongodb.core.query.UpdateDefinition;
 
 import com.mongodb.client.result.UpdateResult;
+import org.springframework.lang.Contract;
 
 /**
  * {@link ExecutableUpdateOperation} allows creation and execution of MongoDB update / findAndModify / findAndReplace
@@ -69,6 +71,19 @@ public interface ExecutableUpdateOperation {
 	 */
 	interface TerminatingFindAndModify<T> {
 
+
+		/**
+		 * Map the query result to a different type using {@link QueryResultConverter}.
+		 *
+		 * @param <R> {@link Class type} of the result.
+		 * @param converter the converter, must not be {@literal null}.
+		 * @return new instance of {@link TerminatingFindAndModify}.
+		 * @throws IllegalArgumentException if {@link QueryResultConverter converter} is {@literal null}.
+		 * @since x.y
+		 */
+		@Contract("_ -> new")
+		<R> TerminatingFindAndModify<R> map(QueryResultConverter<? super T, ? extends R> converter);
+
 		/**
 		 * Find, modify and return the first matching document.
 		 *
@@ -130,6 +145,18 @@ default Optional<T> findAndReplace() {
 		 */
 		@Nullable
 		T findAndReplaceValue();
+
+		/**
+		 * Map the query result to a different type using {@link QueryResultConverter}.
+		 *
+		 * @param <R> {@link Class type} of the result.
+		 * @param converter the converter, must not be {@literal null}.
+		 * @return new instance of {@link TerminatingFindAndModify}.
+		 * @throws IllegalArgumentException if {@link QueryResultConverter converter} is {@literal null}.
+		 * @since x.y
+		 */
+		@Contract("_ -> new")
+		<R> TerminatingFindAndReplace<R> mapResult(QueryResultConverter<? super T, ? extends R> converter);
 	}
 
 	/**

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableUpdateOperationSupport.java

@@ -47,31 +47,33 @@ public <T> ExecutableUpdate<T> update(Class<T> domainType) {
 
 		Assert.notNull(domainType, "DomainType must not be null");
 
-		return new ExecutableUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null, null, null, domainType);
+		return new ExecutableUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null, null, null, domainType, QueryResultConverter.entity());
 	}
 
 	/**
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
 	@SuppressWarnings("rawtypes")
-	static class ExecutableUpdateSupport<T>
+	static class ExecutableUpdateSupport<S, T>
 			implements ExecutableUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T>,
 			FindAndReplaceWithOptions<T>, TerminatingFindAndReplace<T>, FindAndReplaceWithProjection<T> {
 
 		private final MongoTemplate template;
-		private final Class domainType;
+		private final Class<?> domainType;
 		private final Query query;
 		@Nullable private final UpdateDefinition update;
 		@Nullable private final String collection;
 		@Nullable private final FindAndModifyOptions findAndModifyOptions;
 		@Nullable private final FindAndReplaceOptions findAndReplaceOptions;
 		@Nullable private final Object replacement;
-		private final Class<T> targetType;
+		private final QueryResultConverter<? super S, ? extends T> resultConverter;
+		private final Class<S> targetType;
 
-		ExecutableUpdateSupport(MongoTemplate template, Class domainType, Query query, @Nullable UpdateDefinition update,
+		ExecutableUpdateSupport(MongoTemplate template, Class<?> domainType, Query query, @Nullable UpdateDefinition update,
 				@Nullable String collection, @Nullable FindAndModifyOptions findAndModifyOptions,
-				@Nullable FindAndReplaceOptions findAndReplaceOptions, @Nullable Object replacement, Class<T> targetType) {
+				@Nullable FindAndReplaceOptions findAndReplaceOptions, @Nullable Object replacement, Class<S> targetType,
+			QueryResultConverter<? super S, ? extends T> resultConverter) {
 
 			this.template = template;
 			this.domainType = domainType;
@@ -82,6 +84,7 @@ static class ExecutableUpdateSupport<T>
 			this.findAndReplaceOptions = findAndReplaceOptions;
 			this.replacement = replacement;
 			this.targetType = targetType;
+			this.resultConverter = resultConverter;
 		}
 
 		@Override
@@ -91,7 +94,7 @@ public TerminatingUpdate<T> apply(UpdateDefinition update) {
 			Assert.notNull(update, "Update must not be null");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
-					findAndReplaceOptions, replacement, targetType);
+					findAndReplaceOptions, replacement, targetType, resultConverter);
 		}
 
 		@Override
@@ -101,7 +104,7 @@ public UpdateWithQuery<T> inCollection(String collection) {
 			Assert.hasText(collection, "Collection must not be null nor empty");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
-					findAndReplaceOptions, replacement, targetType);
+					findAndReplaceOptions, replacement, targetType, resultConverter);
 		}
 
 		@Override
@@ -111,7 +114,7 @@ public TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options) {
 			Assert.notNull(options, "Options must not be null");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options,
-					findAndReplaceOptions, replacement, targetType);
+					findAndReplaceOptions, replacement, targetType, resultConverter);
 		}
 
 		@Override
@@ -121,7 +124,7 @@ public FindAndReplaceWithProjection<T> replaceWith(T replacement) {
 			Assert.notNull(replacement, "Replacement must not be null");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
-					findAndReplaceOptions, replacement, targetType);
+					findAndReplaceOptions, replacement, targetType, resultConverter);
 		}
 
 		@Override
@@ -131,7 +134,7 @@ public FindAndReplaceWithProjection<T> withOptions(FindAndReplaceOptions options
 			Assert.notNull(options, "Options must not be null");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
-					options, replacement, targetType);
+					options, replacement, targetType, resultConverter);
 		}
 
 		@Override
@@ -143,7 +146,7 @@ public TerminatingReplace withOptions(ReplaceOptions options) {
 				target.upsert();
 			}
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
-					target, replacement, targetType);
+					target, replacement, targetType, resultConverter);
 		}
 
 		@Override
@@ -153,7 +156,7 @@ public UpdateWithUpdate<T> matching(Query query) {
 			Assert.notNull(query, "Query must not be null");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
-					findAndReplaceOptions, replacement, targetType);
+					findAndReplaceOptions, replacement, targetType, resultConverter);
 		}
 
 		@Override
@@ -163,7 +166,7 @@ public <R> FindAndReplaceWithOptions<R> as(Class<R> resultType) {
 			Assert.notNull(resultType, "ResultType must not be null");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
-					findAndReplaceOptions, replacement, resultType);
+					findAndReplaceOptions, replacement, resultType, QueryResultConverter.entity());
 		}
 
 		@Override
@@ -181,22 +184,35 @@ public UpdateResult upsert() {
 			return doUpdate(true, true);
 		}
 
+		@Override
+		public <R> TerminatingFindAndModify<R> map(QueryResultConverter<? super T, ? extends R> converter) {
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+				findAndReplaceOptions, replacement, targetType, this.resultConverter.andThen(converter));
+		}
+
+		@Override
+		public <R> TerminatingFindAndReplace<R> mapResult(QueryResultConverter<? super T, ? extends R> converter) {
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+				findAndReplaceOptions, replacement, targetType, this.resultConverter.andThen(converter));
+		}
+
 		@Override
 		@SuppressWarnings("NullAway")
 		public @Nullable T findAndModifyValue() {
 
 			return template.findAndModify(query, update,
 					findAndModifyOptions != null ? findAndModifyOptions : new FindAndModifyOptions(), targetType,
-					getCollectionName());
+					getCollectionName(), resultConverter);
 		}
 
 		@Override
 		@SuppressWarnings({ "unchecked", "NullAway" })
 		public @Nullable T findAndReplaceValue() {
 
 			return (T) template.findAndReplace(query, replacement,
-					findAndReplaceOptions != null ? findAndReplaceOptions : FindAndReplaceOptions.empty(), domainType,
-					getCollectionName(), targetType);
+					findAndReplaceOptions != null ? findAndReplaceOptions : FindAndReplaceOptions.empty(), (Class) domainType,
+					getCollectionName(), targetType, (QueryResultConverter) resultConverter);
 		}
 
 		@Override