switch to query execution maybe?

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/aot/generated/MongoBlocks.java

@@ -21,14 +21,15 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import org.springframework.data.mongodb.BindableMongoExpression;
-import org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind;
+import org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery;
 import org.springframework.data.mongodb.core.MongoOperations;
 import org.springframework.data.mongodb.core.query.BasicQuery;
 import org.springframework.data.mongodb.repository.Hint;
 import org.springframework.data.mongodb.repository.ReadPreference;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.PagedExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.SlicedExecution;
 import org.springframework.data.repository.aot.generate.AotRepositoryMethodBuilder.MethodGenerationMetadata;
 import org.springframework.data.repository.core.RepositoryInformation;
-import org.springframework.data.support.PageableExecutionUtils;
 import org.springframework.javapoet.CodeBlock;
 import org.springframework.javapoet.CodeBlock.Builder;
 import org.springframework.javapoet.TypeName;
@@ -71,11 +72,16 @@ public class MongoBlocks {
 			Object actualReturnType = isProjecting ? metadata.getActualReturnType() : repositoryInformation.getDomainType();
 
 			if (isProjecting) {
-				builder.addStatement("$T<$T> finder = $L.query($T.class).as($T.class).matching($L)", TerminatingFind.class,
+				// builder.addStatement("$T<$T> finder = $L.query($T.class).as($T.class).matching($L)", TerminatingFind.class,
-						actualReturnType, mongoOpsRef, repositoryInformation.getDomainType(), actualReturnType, queryVariableName);
+				// actualReturnType, mongoOpsRef, repositoryInformation.getDomainType(), actualReturnType, queryVariableName);
+				builder.addStatement("$T<$T> finder = $L.query($T.class).as($T.class)", FindWithQuery.class, actualReturnType,
+						mongoOpsRef, repositoryInformation.getDomainType(), actualReturnType);
 			} else {
-				builder.addStatement("$T<$T> finder = $L.query($T.class).matching($L)", TerminatingFind.class, actualReturnType,
+				// builder.addStatement("$T<$T> finder = $L.query($T.class).matching($L)", TerminatingFind.class,
-						mongoOpsRef, repositoryInformation.getDomainType(), queryVariableName);
+				// actualReturnType,
+				// mongoOpsRef, repositoryInformation.getDomainType(), queryVariableName);
+				builder.addStatement("$T<$T> finder = $L.query($T.class)", FindWithQuery.class, actualReturnType, mongoOpsRef,
+						repositoryInformation.getDomainType());
 			}
 
 			String terminatingMethod = "all()";
@@ -87,14 +93,24 @@ public class MongoBlocks {
 				}
 			}
 
-			if (!metadata.returnsPage()) {
+			if (metadata.returnsPage()) {
-				builder.addStatement("return finder.$L", terminatingMethod);
+				// builder.addStatement("return finder.$L", terminatingMethod);
+				builder.addStatement("return new $T(finder, $L).execute($L)", PagedExecution.class,
+						metadata.getPageableParameterName(), queryVariableName);
+			} else if (metadata.returnsSlice()) {
+				builder.addStatement("return new $T(finder, $L).execute($L)", SlicedExecution.class,
+						metadata.getPageableParameterName(), queryVariableName);
 			} else {
-				builder.addStatement("return $T.getPage(finder.$L, $L, () -> finder.count())", PageableExecutionUtils.class, terminatingMethod,
+				builder.addStatement("return finder.matching($L).$L", queryVariableName, terminatingMethod);
-					metadata.getPageableParameterName());
+				// builder.addStatement("return $T.getPage(finder.$L, $L, () -> finder.count())", PageableExecutionUtils.class,
+				// terminatingMethod,
+				// metadata.getPageableParameterName());
 			}
 
+			// new MongoQueryExecution.PagedExecution(finder, page).execute(query);
+
 			return builder.build();
+
 		}
 
 	}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryExecution.java

@@ -54,7 +54,7 @@ import com.mongodb.client.result.DeleteResult;
  * @author Christoph Strobl
  */
 @FunctionalInterface
-interface MongoQueryExecution {
+public interface MongoQueryExecution {
 
 	@Nullable
 	Object execute(Query query);
@@ -66,12 +66,12 @@ interface MongoQueryExecution {
 	 * @author Christoph Strobl
 	 * @since 1.5
 	 */
-	final class SlicedExecution implements MongoQueryExecution {
+	final class SlicedExecution<T> implements MongoQueryExecution {
 
-		private final FindWithQuery<?> find;
+		private final FindWithQuery<T> find;
 		private final Pageable pageable;
 
-		public SlicedExecution(ExecutableFindOperation.FindWithQuery<?> find, Pageable pageable) {
+		public SlicedExecution(ExecutableFindOperation.FindWithQuery<T> find, Pageable pageable) {
 
 			Assert.notNull(find, "Find must not be null");
 			Assert.notNull(pageable, "Pageable must not be null");
@@ -82,7 +82,7 @@ interface MongoQueryExecution {
 
 		@Override
 		@SuppressWarnings({ "unchecked", "rawtypes" })
-		public Object execute(Query query) {
+		public Slice<T> execute(Query query) {
 
 			int pageSize = pageable.getPageSize();
 
@@ -92,7 +92,7 @@ interface MongoQueryExecution {
 
 			boolean hasNext = result.size() > pageSize;
 
-			return new SliceImpl<Object>(hasNext ? result.subList(0, pageSize) : result, pageable, hasNext);
+			return new SliceImpl<T>(hasNext ? result.subList(0, pageSize) : result, pageable, hasNext);
 		}
 	}
 
@@ -103,12 +103,12 @@ interface MongoQueryExecution {
 	 * @author Mark Paluch
 	 * @author Christoph Strobl
 	 */
-	final class PagedExecution implements MongoQueryExecution {
+	final class PagedExecution<T> implements MongoQueryExecution {
 
-		private final FindWithQuery<?> operation;
+		private final FindWithQuery<T> operation;
 		private final Pageable pageable;
 
-		public PagedExecution(ExecutableFindOperation.FindWithQuery<?> operation, Pageable pageable) {
+		public PagedExecution(ExecutableFindOperation.FindWithQuery<T> operation, Pageable pageable) {
 
 			Assert.notNull(operation, "Operation must not be null");
 			Assert.notNull(pageable, "Pageable must not be null");
@@ -118,11 +118,11 @@ interface MongoQueryExecution {
 		}
 
 		@Override
-		public Object execute(Query query) {
+		public Page<T> execute(Query query) {
 
 			int overallLimit = query.getLimit();
 
-			TerminatingFind<?> matching = operation.matching(query);
+			TerminatingFind<T> matching = operation.matching(query);
 
 			// Apply raw pagination
 			query.with(pageable);

spring-data-mongodb/src/test/java/example/aot/UserRepository.java

@@ -20,6 +20,7 @@ import java.util.List;
 import org.springframework.data.domain.Limit;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.mongodb.repository.Query;
 import org.springframework.data.mongodb.repository.ReadPreference;
@@ -45,5 +46,6 @@ public interface UserRepository extends CrudRepository<User, String> {
     List<User> findUserByLastnameStartingWith(String lastname, Limit limit);
     List<User> findUserByLastnameStartingWith(String lastname, Sort sort, Limit limit);
 
-    Page<User> findUserByFirstnameStartingWith(String lastname, Pageable page);
+    Page<User> findUserByFirstnameStartingWith(String firstname, Pageable page);
+    Slice<User> findUserByFirstnameLike(String firstname, Pageable page);
 }