Fix query execution mode detection for aggregate types that implement Streamable.

We now short-circuit the QueryMethod.isCollectionQuery() algorithm in case we find the concrete domain type or any subclass of it.

Fixes #2869.

Author: odrotbohm

src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java

@@ -96,12 +96,13 @@ public TypeInformation<?> getReturnType(Method method) {
 		return returnType;
 	}
 
+	@Override
 	public Class<?> getReturnedDomainClass(Method method) {
 
 		TypeInformation<?> returnType = getReturnType(method);
+		returnType = ReactiveWrapperConverters.unwrapWrapperTypes(returnType);
 
-		return QueryExecutionConverters.unwrapWrapperTypes(ReactiveWrapperConverters.unwrapWrapperTypes(returnType))
-				.getType();
+		return QueryExecutionConverters.unwrapWrapperTypes(returnType, getDomainTypeInformation()).getType();
 	}
 
 	public Class<?> getRepositoryInterface() {

src/main/java/org/springframework/data/repository/query/QueryMethod.java

@@ -31,6 +31,7 @@
 import org.springframework.data.repository.util.QueryExecutionConverters;
 import org.springframework.data.repository.util.ReactiveWrapperConverters;
 import org.springframework.data.util.Lazy;
+import org.springframework.data.util.NullableWrapperConverters;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.util.Assert;
 
@@ -270,7 +271,15 @@ private boolean calculateIsCollectionQuery() {
 			return false;
 		}
 
-		Class<?> returnType = metadata.getReturnType(method).getType();
+		TypeInformation<?> returnTypeInformation = metadata.getReturnType(method);
+
+		// Check against simple wrapper types first
+		if (metadata.getDomainTypeInformation()
+				.isAssignableFrom(NullableWrapperConverters.unwrapActualType(returnTypeInformation))) {
+			return false;
+		}
+
+		Class<?> returnType = returnTypeInformation.getType();
 
 		if (QueryExecutionConverters.supports(returnType) && !QueryExecutionConverters.isSingleValue(returnType)) {
 			return true;

src/main/java/org/springframework/data/repository/util/QueryExecutionConverters.java

@@ -84,6 +84,7 @@ public abstract class QueryExecutionConverters {
 	private static final Set<Class<?>> ALLOWED_PAGEABLE_TYPES = new HashSet<>();
 	private static final Map<Class<?>, ExecutionAdapter> EXECUTION_ADAPTER = new HashMap<>();
 	private static final Map<Class<?>, Boolean> supportsCache = new ConcurrentReferenceHashMap<>();
+	private static final TypeInformation<Void> VOID_INFORMATION = TypeInformation.of(Void.class);
 
 	static {
 
@@ -233,15 +234,21 @@ public static Object unwrap(@Nullable Object source) {
 	}
 
 	/**
-	 * Recursively unwraps well known wrapper types from the given {@link TypeInformation}.
+	 * Recursively unwraps well known wrapper types from the given {@link TypeInformation} but aborts at the given
+	 * reference type.
 	 *
 	 * @param type must not be {@literal null}.
+	 * @param reference must not be {@literal null}.
 	 * @return will never be {@literal null}.
 	 */
-	public static TypeInformation<?> unwrapWrapperTypes(TypeInformation<?> type) {
+	public static TypeInformation<?> unwrapWrapperTypes(TypeInformation<?> type, TypeInformation<?> reference) {
 
 		Assert.notNull(type, "type must not be null");
 
+		if (reference.isAssignableFrom(type)) {
+			return type;
+		}
+
 		Class<?> rawType = type.getType();
 
 		boolean needToUnwrap = type.isCollectionLike() //
@@ -251,7 +258,17 @@ public static TypeInformation<?> unwrapWrapperTypes(TypeInformation<?> type) {
 				|| supports(rawType) //
 				|| Stream.class.isAssignableFrom(rawType);
 
-		return needToUnwrap ? unwrapWrapperTypes(type.getRequiredComponentType()) : type;
+		return needToUnwrap ? unwrapWrapperTypes(type.getRequiredComponentType(), reference) : type;
+	}
+
+	/**
+	 * Recursively unwraps well known wrapper types from the given {@link TypeInformation}.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @return will never be {@literal null}.
+	 */
+	public static TypeInformation<?> unwrapWrapperTypes(TypeInformation<?> type) {
+		return unwrapWrapperTypes(type, VOID_INFORMATION);
 	}
 
 	/**

src/test/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadataUnitTests.java

@@ -22,15 +22,21 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Stream;
 
+
+import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.querydsl.User;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.Repository;
 import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.data.util.Streamable;
 
 /**
  * Unit tests for {@link AbstractRepositoryMetadata}.
@@ -113,6 +119,25 @@ void doesNotUnwrapCustomTypeImplementingIterable() throws Exception {
 		assertThat(metadata.getReturnedDomainClass(method)).isEqualTo(Container.class);
 	}
 
+	@TestFactory // GH-2869
+	Stream<DynamicTest> detectsReturnTypesForStreamableAggregates() throws Exception {
+
+		var metadata = AbstractRepositoryMetadata.getMetadata(StreamableAggregateRepository.class);
+		var methods = Stream.of(
+				Map.entry("findBy", StreamableAggregate.class),
+				Map.entry("findSubTypeBy", StreamableAggregateSubType.class),
+				Map.entry("findAllBy", StreamableAggregate.class),
+				Map.entry("findOptional", StreamableAggregate.class));
+
+		return DynamicTest.stream(methods, //
+				it -> it.getKey() + "'s returned domain class is " + it.getValue(), //
+				it -> {
+
+					var method = StreamableAggregateRepository.class.getMethod(it.getKey());
+					assertThat(metadata.getReturnedDomainClass(method)).isEqualTo(it.getValue());
+				});
+	}
+
 	interface UserRepository extends Repository<User, Long> {
 
 		User findSingle();
@@ -157,4 +182,20 @@ interface ContainerRepository extends Repository<Container, Long> {
 
 	interface CompletePageableAndSortingRepository extends PagingAndSortingRepository<Container, Long> {}
 
+	// GH-2869
+
+	static abstract class StreamableAggregate implements Streamable<Object> {}
+
+	interface StreamableAggregateRepository extends Repository<StreamableAggregate, Object> {
+
+		StreamableAggregate findBy();
+
+		StreamableAggregateSubType findSubTypeBy();
+
+		Streamable<StreamableAggregate> findAllBy();
+
+		Optional<StreamableAggregate> findOptional();
+	}
+
+	static abstract class StreamableAggregateSubType extends StreamableAggregate {}
 }

src/test/java/org/springframework/data/repository/query/QueryMethodUnitTests.java

@@ -23,12 +23,16 @@
 
 import java.io.Serializable;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
 import java.util.stream.Stream;
 
 import org.eclipse.collections.api.list.ImmutableList;
+import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
@@ -38,6 +42,7 @@
 import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.core.support.AbstractRepositoryMetadata;
 import org.springframework.data.repository.core.support.DefaultRepositoryMetadata;
+import org.springframework.data.util.Streamable;
 
 /**
  * Unit tests for {@link QueryMethod}.
@@ -257,6 +262,28 @@ void considersEclipseCollectionCollectionQuery() throws Exception {
 		assertThat(queryMethod.isCollectionQuery()).isTrue();
 	}
 
+	@TestFactory // GH-2869
+	Stream<DynamicTest> doesNotConsiderQueryMethodReturningAggregateImplementingStreamableACollectionQuery()
+			throws Exception {
+
+		var metadata = AbstractRepositoryMetadata.getMetadata(StreamableAggregateRepository.class);
+		var stream = Stream.of(
+				Map.entry("findBy", false),
+				Map.entry("findSubTypeBy", false),
+				Map.entry("findAllBy", true),
+				Map.entry("findOptionalBy", false));
+
+		return DynamicTest.stream(stream, //
+				it -> it.getKey() + " considered collection query -> " + it.getValue(), //
+				it -> {
+
+					var method = StreamableAggregateRepository.class.getMethod(it.getKey());
+					var queryMethod = new QueryMethod(method, metadata, factory);
+
+					assertThat(queryMethod.isCollectionQuery()).isEqualTo(it.getValue());
+				});
+	}
+
 	interface SampleRepository extends Repository<User, Serializable> {
 
 		String pagingMethodWithInvalidReturnType(Pageable pageable);
@@ -324,4 +351,21 @@ abstract class Container implements Iterable<Element> {}
 	interface ContainerRepository extends Repository<Container, Long> {
 		Container someMethod();
 	}
+
+	// GH-2869
+
+	static abstract class StreamableAggregate implements Streamable<Object> {}
+
+	interface StreamableAggregateRepository extends Repository<StreamableAggregate, Object> {
+
+		StreamableAggregate findBy();
+
+		StreamableAggregateSubType findSubTypeBy();
+
+		Optional<StreamableAggregate> findOptionalBy();
+
+		Streamable<StreamableAggregate> findAllBy();
+	}
+
+	static abstract class StreamableAggregateSubType extends StreamableAggregate {}
 }