Fix conversion of types when mapping Aggregation pipeline

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>4.4.0-SNAPSHOT</version>
+	<version>4.4.x-GH-4722-SNAPSHOT</version>
 	<packaging>pom</packaging>
 
 	<name>Spring Data MongoDB</name>

spring-data-mongodb-benchmarks/pom.xml

@@ -7,7 +7,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>4.4.0-SNAPSHOT</version>
+		<version>4.4.x-GH-4722-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb-distribution/pom.xml

@@ -15,7 +15,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>4.4.0-SNAPSHOT</version>
+		<version>4.4.x-GH-4722-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb/pom.xml

@@ -13,7 +13,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>4.4.0-SNAPSHOT</version>
+		<version>4.4.x-GH-4722-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

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

@@ -62,7 +62,7 @@ static List<Document> toDocument(List<AggregationOperation> operations, Aggregat
 				if (operation instanceof InheritsFieldsAggregationOperation || exposedFieldsOperation.inheritsFields()) {
 					contextToUse = contextToUse.inheritAndExpose(fields);
 				} else {
-					contextToUse = fields.exposesNoFields() ? DEFAULT_CONTEXT
+					contextToUse = fields.exposesNoFields() ? ConverterAwareNoOpContext.instance(rootContext)
 							: contextToUse.expose(fields);
 				}
 			}
@@ -72,6 +72,39 @@ static List<Document> toDocument(List<AggregationOperation> operations, Aggregat
 		return operationDocuments;
 	}
 
+	private static class ConverterAwareNoOpContext implements AggregationOperationContext {
+
+		AggregationOperationContext ctx;
+
+		static ConverterAwareNoOpContext instance(AggregationOperationContext ctx) {
+
+			if(ctx instanceof ConverterAwareNoOpContext noOpContext) {
+				return noOpContext;
+			}
+
+			return new ConverterAwareNoOpContext(ctx);
+		}
+
+		ConverterAwareNoOpContext(AggregationOperationContext ctx) {
+			this.ctx = ctx;
+		}
+
+		@Override
+		public Document getMappedObject(Document document, @Nullable Class<?> type) {
+			return ctx.getMappedObject(document, null);
+		}
+
+		@Override
+		public FieldReference getReference(Field field) {
+			return new DirectFieldReference(new ExposedField(field, true));
+		}
+
+		@Override
+		public FieldReference getReference(String name) {
+			return new DirectFieldReference(new ExposedField(new AggregationField(name), true));
+		}
+	}
+
 	/**
 	 * Simple {@link AggregationOperationContext} that just returns {@link FieldReference}s as is.
 	 *

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationOperationRendererUnitTests.java

@@ -15,18 +15,29 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
-import static org.mockito.Mockito.*;
-import static org.springframework.data.domain.Sort.Direction.*;
-import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;
-
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.springframework.data.domain.Sort.Direction.DESC;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.project;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.sort;
+
+import java.time.ZonedDateTime;
 import java.util.List;
+import java.util.Set;
 
+import org.assertj.core.api.Assertions;
+import org.bson.Document;
 import org.junit.jupiter.api.Test;
-
 import org.springframework.data.annotation.Id;
+import org.springframework.data.convert.ConverterBuilder;
+import org.springframework.data.convert.CustomConversions;
+import org.springframework.data.convert.CustomConversions.StoreConversions;
+import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.convert.NoOpDbRefResolver;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
+import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.test.util.MongoTestMappingContext;
 
 /**
@@ -47,32 +58,56 @@ void nonFieldsExposingAggregationOperationContinuesWithSameContextForNextStage()
 		verify(stage2).toPipelineStages(eq(rootContext));
 	}
 
-	record TestRecord(@Id String field1, String field2, LayerOne layerOne) {
-		record LayerOne(List<LayerTwo> layerTwo) {
-		}
+	@Test
+	void contextShouldCarryOnRelaxedFieldMapping() {
 
-		record LayerTwo(LayerThree layerThree) {
-		}
+		MongoTestMappingContext ctx = new MongoTestMappingContext(cfg -> {
+			cfg.initialEntitySet(TestRecord.class);
+		});
+
+		MappingMongoConverter mongoConverter = new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, ctx);
 
-		record LayerThree(int fieldA, int fieldB)
-		{}
+		Aggregation agg = Aggregation.newAggregation(Aggregation.unwind("layerOne.layerTwo"),
+				project().and("layerOne.layerTwo.layerThree").as("layerOne.layerThree"),
+				sort(DESC, "layerOne.layerThree.fieldA"));
+
+		AggregationOperationRenderer.toDocument(agg.getPipeline().getOperations(),
+				new RelaxedTypeBasedAggregationOperationContext(TestRecord.class, ctx, new QueryMapper(mongoConverter)));
 	}
 
-	@Test
-	void xxx() {
+	@Test // GH-4722
+	void appliesConversionToValuesUsedInAggregation() {
 
 		MongoTestMappingContext ctx = new MongoTestMappingContext(cfg -> {
 			cfg.initialEntitySet(TestRecord.class);
 		});
 
 		MappingMongoConverter mongoConverter = new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, ctx);
-
-		Aggregation agg = Aggregation.newAggregation(
-			Aggregation.unwind("layerOne.layerTwo"),
-			project().and("layerOne.layerTwo.layerThree").as("layerOne.layerThree"),
-			sort(DESC, "layerOne.layerThree.fieldA")
+		mongoConverter.setCustomConversions(new CustomConversions(StoreConversions.NONE,
+				Set.copyOf(ConverterBuilder.writing(ZonedDateTime.class, String.class, ZonedDateTime::toString)
+						.andReading(it -> ZonedDateTime.parse(it)).getConverters())));
+		mongoConverter.afterPropertiesSet();
+
+		var agg = Aggregation.newAggregation(Aggregation.sort(Direction.DESC, "version"),
+				Aggregation.group("entityId").first(Aggregation.ROOT).as("value"), Aggregation.replaceRoot("value"),
+				Aggregation.match(Criteria.where("createdDate").lt(ZonedDateTime.now())) // here is the problem
 		);
 
-		AggregationOperationRenderer.toDocument(agg.getPipeline().getOperations(), new RelaxedTypeBasedAggregationOperationContext(TestRecord.class, ctx, new QueryMapper(mongoConverter)));
+		List<Document> document = AggregationOperationRenderer.toDocument(agg.getPipeline().getOperations(),
+				new RelaxedTypeBasedAggregationOperationContext(TestRecord.class, ctx, new QueryMapper(mongoConverter)));
+		Assertions.assertThat(document).last()
+				.extracting(it -> it.getEmbedded(List.of("$match", "createdDate", "$lt"), Object.class))
+				.isInstanceOf(String.class);
+	}
+
+	record TestRecord(@Id String field1, String field2, LayerOne layerOne) {
+		record LayerOne(List<LayerTwo> layerTwo) {
+		}
+
+		record LayerTwo(LayerThree layerThree) {
+		}
+
+		record LayerThree(int fieldA, int fieldB) {
+		}
 	}
 }