Move off deprecated API where possible.

See: #4990

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

@@ -26,7 +26,8 @@ import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
 import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.AggregationUpdate;
-import org.springframework.data.mongodb.core.aggregation.RelaxedTypeBasedAggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.FieldLookupPolicy;
+import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.convert.UpdateMapper;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
@@ -158,8 +159,9 @@ abstract class BulkOperationsSupport {
 	private List<Document> mapUpdatePipeline(AggregationUpdate source) {
 
 		Class<?> type = entity().isPresent() ? entity().map(PersistentEntity::getType).get() : Object.class;
-		AggregationOperationContext context = new RelaxedTypeBasedAggregationOperationContext(type,
-				updateMapper().getMappingContext(), queryMapper());
+
+		AggregationOperationContext context = new TypeBasedAggregationOperationContext(type,
+				updateMapper().getMappingContext(), queryMapper(), FieldLookupPolicy.relaxed());
 
 		return new AggregationUtil(queryMapper(), queryMapper().getMappingContext()).createPipeline(source, context);
 	}

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

@@ -44,7 +44,7 @@ import org.springframework.data.mongodb.core.aggregation.AggregationOperationCon
 import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
 import org.springframework.data.mongodb.core.aggregation.AggregationPipeline;
 import org.springframework.data.mongodb.core.aggregation.AggregationUpdate;
-import org.springframework.data.mongodb.core.aggregation.RelaxedTypeBasedAggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.FieldLookupPolicy;
 import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
@@ -407,7 +407,8 @@ class QueryOperations {
 				if (entry.getValue() instanceof MongoExpression mongoExpression) {
 
 					AggregationOperationContext ctx = entity == null ? Aggregation.DEFAULT_CONTEXT
-							: new RelaxedTypeBasedAggregationOperationContext(entity.getType(), mappingContext, queryMapper);
+							: new TypeBasedAggregationOperationContext(entity.getType(), mappingContext, queryMapper,
+									FieldLookupPolicy.relaxed());
 
 					evaluated.put(entry.getKey(), AggregationExpression.from(mongoExpression).toDocument(ctx));
 				} else {
@@ -895,8 +896,8 @@ class QueryOperations {
 
 			Class<?> type = domainType != null ? domainType : Object.class;
 
-			AggregationOperationContext context = new RelaxedTypeBasedAggregationOperationContext(type, mappingContext,
-					queryMapper);
+			AggregationOperationContext context = new TypeBasedAggregationOperationContext(type, mappingContext, queryMapper,
+					FieldLookupPolicy.relaxed());
 			return aggregationUtil.createPipeline((AggregationUpdate) update, context);
 		}
 

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

@@ -15,7 +15,7 @@
  */
 package org.springframework.data.mongodb.core;
 
-import static org.springframework.data.mongodb.core.query.SerializationUtils.*;
+import static org.springframework.data.mongodb.core.query.SerializationUtils.serializeToJsonSafely;
 
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -89,8 +89,8 @@ import org.springframework.data.mongodb.core.aggregation.AggregationOperationCon
 import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
 import org.springframework.data.mongodb.core.aggregation.AggregationOptions.Builder;
 import org.springframework.data.mongodb.core.aggregation.AggregationPipeline;
+import org.springframework.data.mongodb.core.aggregation.FieldLookupPolicy;
 import org.springframework.data.mongodb.core.aggregation.PrefixingDelegatingAggregationOperationContext;
-import org.springframework.data.mongodb.core.aggregation.RelaxedTypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
 import org.springframework.data.mongodb.core.convert.DbRefResolver;
@@ -109,7 +109,18 @@ import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.core.mapping.MongoSimpleTypes;
-import org.springframework.data.mongodb.core.mapping.event.*;
+import org.springframework.data.mongodb.core.mapping.event.AfterConvertEvent;
+import org.springframework.data.mongodb.core.mapping.event.AfterDeleteEvent;
+import org.springframework.data.mongodb.core.mapping.event.AfterLoadEvent;
+import org.springframework.data.mongodb.core.mapping.event.AfterSaveEvent;
+import org.springframework.data.mongodb.core.mapping.event.BeforeConvertEvent;
+import org.springframework.data.mongodb.core.mapping.event.BeforeDeleteEvent;
+import org.springframework.data.mongodb.core.mapping.event.BeforeSaveEvent;
+import org.springframework.data.mongodb.core.mapping.event.MongoMappingEvent;
+import org.springframework.data.mongodb.core.mapping.event.ReactiveAfterConvertCallback;
+import org.springframework.data.mongodb.core.mapping.event.ReactiveAfterSaveCallback;
+import org.springframework.data.mongodb.core.mapping.event.ReactiveBeforeConvertCallback;
+import org.springframework.data.mongodb.core.mapping.event.ReactiveBeforeSaveCallback;
 import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions;
 import org.springframework.data.mongodb.core.query.BasicQuery;
 import org.springframework.data.mongodb.core.query.Collation;
@@ -2120,8 +2131,8 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati
 			AggregationOperationContext context = agg instanceof TypedAggregation typedAggregation
 					? new TypeBasedAggregationOperationContext(typedAggregation.getInputType(),
 							getConverter().getMappingContext(), queryMapper)
-					: new RelaxedTypeBasedAggregationOperationContext(Object.class, mappingContext, queryMapper);
-
+					: new TypeBasedAggregationOperationContext(Object.class, mappingContext, queryMapper,
+							FieldLookupPolicy.relaxed());
 			return agg.toPipeline(new PrefixingDelegatingAggregationOperationContext(context, "fullDocument",
 					Arrays.asList("operationType", "fullDocument", "documentKey", "updateDescription", "ns")));
 		}

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

@@ -145,7 +145,6 @@ public class TypeBasedAggregationOperationContext implements AggregationOperatio
 	 * @param type The domain type to map fields to.
 	 * @return a more relaxed {@link AggregationOperationContext}.
 	 * @since 3.1
-	 * @see RelaxedTypeBasedAggregationOperationContext
 	 */
 	public AggregationOperationContext continueOnMissingFieldReference(Class<?> type) {
 		return new TypeBasedAggregationOperationContext(type, mappingContext, mapper, FieldLookupPolicy.relaxed());

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

@@ -37,7 +37,6 @@ import org.bson.BsonValue;
 import org.bson.Document;
 import org.bson.conversions.Bson;
 import org.bson.types.ObjectId;
-import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.converter.Converter;
@@ -57,7 +56,8 @@ import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.model.PropertyValueProvider;
 import org.springframework.data.mongodb.MongoExpression;
 import org.springframework.data.mongodb.core.aggregation.AggregationExpression;
-import org.springframework.data.mongodb.core.aggregation.RelaxedTypeBasedAggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.FieldLookupPolicy;
+import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter.NestedDocument;
 import org.springframework.data.mongodb.core.convert.MongoConversionContext.OperatorContext;
 import org.springframework.data.mongodb.core.convert.MongoConversionContext.QueryOperatorContext;
@@ -419,7 +419,8 @@ public class QueryMapper {
 		if (keyword.isSample()) {
 
 			Example<?> example = keyword.getValue();
-			return exampleMapper.getMappedExample(example, entity != null ? entity : mappingContext.getRequiredPersistentEntity(example.getProbeType()));
+			return exampleMapper.getMappedExample(example,
+					entity != null ? entity : mappingContext.getRequiredPersistentEntity(example.getProbeType()));
 		}
 
 		if (keyword.isJsonSchema()) {
@@ -558,7 +559,8 @@ public class QueryMapper {
 
 		if (source instanceof AggregationExpression age) {
 			return entity == null ? age.toDocument() : //
-					age.toDocument(new RelaxedTypeBasedAggregationOperationContext(entity.getType(), this.mappingContext, this));
+					age.toDocument(new TypeBasedAggregationOperationContext(entity.getType(), this.mappingContext, this,
+							FieldLookupPolicy.relaxed()));
 		}
 
 		if (source instanceof MongoExpression exr) {
@@ -680,7 +682,8 @@ public class QueryMapper {
 		MongoPersistentProperty property = documentField.getProperty();
 
 		OperatorContext criteriaContext = new QueryOperatorContext(
-				isKeyword(documentField.name) ? documentField.name : "$eq", property != null ? property.getFieldName() : documentField.name);
+				isKeyword(documentField.name) ? documentField.name : "$eq",
+				property != null ? property.getFieldName() : documentField.name);
 
 		MongoConversionContext conversionContext;
 		if (valueConverter instanceof MongoConversionContext mcc) {
@@ -694,7 +697,8 @@ public class QueryMapper {
 	}
 
 	@SuppressWarnings("NullAway")
-	protected @Nullable Object convertValueWithConversionContext(Field documentField, @Nullable Object sourceValue, @Nullable Object value,
+	protected @Nullable Object convertValueWithConversionContext(Field documentField, @Nullable Object sourceValue,
+			@Nullable Object value,
 			PropertyValueConverter<Object, Object, ValueConversionContext<MongoPersistentProperty>> valueConverter,
 			MongoConversionContext conversionContext) {
 
@@ -729,7 +733,7 @@ public class QueryMapper {
 	}
 
 	@Nullable
-	@SuppressWarnings({"unchecked", "NullAway"})
+	@SuppressWarnings({ "unchecked", "NullAway" })
 	private Object convertIdField(Field documentField, Object source) {
 
 		Object value = source;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/package-info.java

@@ -2,5 +2,4 @@
  * MongoDB-specific JSON schema implementation classes.
  */
 @org.jspecify.annotations.NullMarked
-@org.springframework.lang.NonNullFields
 package org.springframework.data.mongodb.core.schema;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/package-info.java

@@ -2,5 +2,4 @@
  * MongoDB schema validation specifics.
  */
 @org.jspecify.annotations.NullMarked
-@org.springframework.lang.NonNullFields
 package org.springframework.data.mongodb.core.validation;

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

@@ -15,9 +15,13 @@
  */
 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.newAggregation;
+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;
@@ -30,7 +34,6 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
 import org.springframework.data.annotation.Id;
 import org.springframework.data.convert.ConverterBuilder;
 import org.springframework.data.convert.CustomConversions;
@@ -74,8 +77,8 @@ public class AggregationOperationRendererUnitTests {
 				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)));
+		AggregationOperationRenderer.toDocument(agg.getPipeline().getOperations(), new TypeBasedAggregationOperationContext(
+				TestRecord.class, ctx, new QueryMapper(mongoConverter), FieldLookupPolicy.relaxed()));
 	}
 
 	@Test // GH-4722
@@ -97,7 +100,8 @@ public class AggregationOperationRendererUnitTests {
 		);
 
 		List<Document> document = AggregationOperationRenderer.toDocument(agg.getPipeline().getOperations(),
-				new RelaxedTypeBasedAggregationOperationContext(TestRecord.class, ctx, new QueryMapper(mongoConverter)));
+				new TypeBasedAggregationOperationContext(TestRecord.class, ctx, new QueryMapper(mongoConverter),
+						FieldLookupPolicy.relaxed()));
 		Assertions.assertThat(document).last()
 				.extracting(it -> it.getEmbedded(List.of("$match", "createdDate", "$lt"), Object.class))
 				.isInstanceOf(String.class);

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

@@ -15,10 +15,21 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
-import static org.springframework.data.mongodb.core.DocumentTestUtils.*;
-import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;
-import static org.springframework.data.mongodb.core.query.Criteria.*;
-import static org.springframework.data.mongodb.test.util.Assertions.*;
+import static org.springframework.data.mongodb.core.DocumentTestUtils.getAsDocument;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.DEFAULT_CONTEXT;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.bucket;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.group;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.match;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.newAggregation;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.newAggregationOptions;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.project;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.replaceRoot;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.sort;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.stage;
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.unwind;
+import static org.springframework.data.mongodb.core.query.Criteria.where;
+import static org.springframework.data.mongodb.test.util.Assertions.assertThat;
+import static org.springframework.data.mongodb.test.util.Assertions.assertThatIllegalArgumentException;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -146,7 +157,7 @@ public class AggregationUnitTests {
 
 		Document agg = newAggregation( //
 				replaceRoot().withDocument().andValue("value").as("field")) //
-						.toDocument("foo", Aggregation.DEFAULT_CONTEXT);
+				.toDocument("foo", Aggregation.DEFAULT_CONTEXT);
 
 		@SuppressWarnings("unchecked")
 		Document unwind = ((List<Document>) agg.get("pipeline")).get(0);
@@ -599,8 +610,9 @@ public class AggregationUnitTests {
 
 		MongoMappingContext mappingContext = new MongoMappingContext();
 		Document target = new Aggregation(bucket("start"), project("_id")).toDocument("collection-1",
-				new RelaxedTypeBasedAggregationOperationContext(BookWithFieldAnnotation.class, mappingContext,
-						new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext))));
+				new TypeBasedAggregationOperationContext(BookWithFieldAnnotation.class, mappingContext,
+						new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)),
+						FieldLookupPolicy.relaxed()));
 
 		assertThat(extractPipelineElement(target, 1, "$project")).isEqualTo(Document.parse(" { \"_id\" : 1 }"));
 	}
@@ -609,11 +621,12 @@ public class AggregationUnitTests {
 	void shouldNotConvertIncludeExcludeValuesForProjectOperation() {
 
 		MongoMappingContext mappingContext = new MongoMappingContext();
-		RelaxedTypeBasedAggregationOperationContext context = new RelaxedTypeBasedAggregationOperationContext(
-				WithRetypedIdField.class, mappingContext,
-				new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)));
+		AggregationOperationContext context = new TypeBasedAggregationOperationContext(WithRetypedIdField.class,
+				mappingContext, new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)),
+				FieldLookupPolicy.relaxed());
 		Document document = project(WithRetypedIdField.class).toDocument(context);
-		assertThat(document).isEqualTo(new Document("$project", new Document("_id", 1).append("renamed-field", 1).append("entries", 1)));
+		assertThat(document)
+				.isEqualTo(new Document("$project", new Document("_id", 1).append("renamed-field", 1).append("entries", 1)));
 	}
 
 	@Test // GH-4038
@@ -650,7 +663,8 @@ public class AggregationUnitTests {
 		MongoMappingContext mappingContext = new MongoMappingContext();
 		QueryMapper queryMapper = new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext));
 
-		List<Document> documents = newAggregation(City.class, aggregationOperations).toPipeline(new RelaxedTypeBasedAggregationOperationContext(City.class, mappingContext, queryMapper));
+		List<Document> documents = newAggregation(City.class, aggregationOperations)
+				.toPipeline(new RelaxedTypeBasedAggregationOperationContext(City.class, mappingContext, queryMapper));
 		assertThat(documents.get(2)).isEqualTo("{ $sort : { 'serial_number' : -1, 'label_name' : -1 } }");
 	}
 
@@ -658,12 +672,12 @@ public class AggregationUnitTests {
 	void fieldsExposingContextShouldUseCustomFieldNameFromRelaxedRootContext() {
 
 		MongoMappingContext mappingContext = new MongoMappingContext();
-		RelaxedTypeBasedAggregationOperationContext context = new RelaxedTypeBasedAggregationOperationContext(
-				WithRetypedIdField.class, mappingContext,
-				new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)));
+		AggregationOperationContext context = new TypeBasedAggregationOperationContext(WithRetypedIdField.class,
+				mappingContext, new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)),
+				FieldLookupPolicy.relaxed());
 
-		TypedAggregation<WithRetypedIdField> agg = newAggregation(WithRetypedIdField.class,
-				unwind("entries"), match(where("foo").is("value 2")));
+		TypedAggregation<WithRetypedIdField> agg = newAggregation(WithRetypedIdField.class, unwind("entries"),
+				match(where("foo").is("value 2")));
 		List<Document> pipeline = agg.toPipeline(context);
 
 		Document fields = getAsDocument(pipeline.get(1), "$match");
@@ -685,7 +699,8 @@ public class AggregationUnitTests {
 
 	public class WithRetypedIdField {
 
-		@Id @org.springframework.data.mongodb.core.mapping.Field private String id;
+		@Id
+		@org.springframework.data.mongodb.core.mapping.Field private String id;
 
 		@org.springframework.data.mongodb.core.mapping.Field("renamed-field") private String foo;
 

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

@@ -126,7 +126,7 @@ public class ObjectOperatorsUnitTests {
 		MappingMongoConverter converter = new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, new MongoMappingContext());
 		converter.afterPropertiesSet();
 
-		assertThat(ObjectOperators.getValueOf("population").toDocument(new RelaxedTypeBasedAggregationOperationContext(ZipInfo.class, converter.getMappingContext(), new QueryMapper(converter))))
+		assertThat(ObjectOperators.getValueOf("population").toDocument(new TypeBasedAggregationOperationContext(ZipInfo.class, converter.getMappingContext(), new QueryMapper(converter), FieldLookupPolicy.relaxed())))
 				.isEqualTo(Document.parse("{ $getField : { field :  \"pop\", input : \"$$CURRENT\" } }"));
 	}
 
@@ -143,7 +143,7 @@ public class ObjectOperatorsUnitTests {
 		MappingMongoConverter converter = new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, new MongoMappingContext());
 		converter.afterPropertiesSet();
 
-		assertThat(ObjectOperators.setValueTo("population", "robin").toDocument(new RelaxedTypeBasedAggregationOperationContext(ZipInfo.class, converter.getMappingContext(), new QueryMapper(converter))))
+		assertThat(ObjectOperators.setValueTo("population", "robin").toDocument(new TypeBasedAggregationOperationContext(ZipInfo.class, converter.getMappingContext(), new QueryMapper(converter), FieldLookupPolicy.relaxed())))
 				.isEqualTo(Document.parse("{ $setField : { field : \"pop\", value : \"robin\", input : \"$$CURRENT\" }}"));
 	}
 

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

@@ -15,7 +15,7 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.bson.Document;
 import org.junit.jupiter.api.Test;
@@ -133,9 +133,9 @@ class SelectionOperatorUnitTests {
 	void firstNMapsFieldNamesCorrectly() {
 
 		MongoMappingContext mappingContext = new MongoMappingContext();
-		RelaxedTypeBasedAggregationOperationContext aggregationContext = new RelaxedTypeBasedAggregationOperationContext(
-				Player.class, mappingContext,
-				new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)));
+		AggregationOperationContext aggregationContext = new TypeBasedAggregationOperationContext(Player.class,
+				mappingContext, new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)),
+				FieldLookupPolicy.relaxed());
 
 		Document document = SelectionOperators.First.first(3).of("score").toDocument(aggregationContext);
 
@@ -154,9 +154,9 @@ class SelectionOperatorUnitTests {
 	void lastNMapsFieldNamesCorrectly() {
 
 		MongoMappingContext mappingContext = new MongoMappingContext();
-		RelaxedTypeBasedAggregationOperationContext aggregationContext = new RelaxedTypeBasedAggregationOperationContext(
-				Player.class, mappingContext,
-				new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)));
+		AggregationOperationContext aggregationContext = new TypeBasedAggregationOperationContext(Player.class,
+				mappingContext, new QueryMapper(new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mappingContext)),
+				FieldLookupPolicy.relaxed());
 
 		Document document = SelectionOperators.Last.last(3).of("score").toDocument(aggregationContext);
 

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

@@ -15,7 +15,8 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
 import java.util.List;
 
@@ -60,7 +61,7 @@ class SetOperationUnitTests {
 
 		assertThat(
 				new SetOperation("scoresWithMappedField.student", "value").toPipelineStages(contextFor(ScoresWrapper.class)))
-						.containsExactly(Document.parse("{\"$set\" : {\"scoresWithMappedField.student_name\":\"value\"}}"));
+				.containsExactly(Document.parse("{\"$set\" : {\"scoresWithMappedField.student_name\":\"value\"}}"));
 	}
 
 	@Test // DATAMONGO-2331
@@ -75,7 +76,7 @@ class SetOperationUnitTests {
 
 		assertThat(
 				new SetOperation("student", Fields.field("homework")).toPipelineStages(contextFor(ScoresWithMappedField.class)))
-						.containsExactly(Document.parse("{\"$set\" : {\"student_name\":\"$home_work\"}}"));
+				.containsExactly(Document.parse("{\"$set\" : {\"student_name\":\"$home_work\"}}"));
 	}
 
 	@Test // DATAMONGO-2331
@@ -83,8 +84,8 @@ class SetOperationUnitTests {
 
 		assertThat(new SetOperation("scoresWithMappedField.student", Fields.field("scoresWithMappedField.homework"))
 				.toPipelineStages(contextFor(ScoresWrapper.class)))
-						.containsExactly(Document
-								.parse("{\"$set\" : {\"scoresWithMappedField.student_name\":\"$scoresWithMappedField.home_work\"}}"));
+				.containsExactly(Document
+						.parse("{\"$set\" : {\"scoresWithMappedField.student_name\":\"$scoresWithMappedField.home_work\"}}"));
 	}
 
 	@Test // DATAMONGO-2363
@@ -102,7 +103,7 @@ class SetOperationUnitTests {
 
 		assertThat(SetOperation.builder().set("totalHomework").toValueOf(ArithmeticOperators.valueOf("homework").sum())
 				.toPipelineStages(contextFor(Scores.class)))
-						.containsExactly(Document.parse("{\"$set\" : {\"totalHomework\": { \"$sum\" : \"$homework\" }}}"));
+				.containsExactly(Document.parse("{\"$set\" : {\"totalHomework\": { \"$sum\" : \"$homework\" }}}"));
 	}
 
 	@Test // GH-4933
@@ -144,8 +145,8 @@ class SetOperationUnitTests {
 				new MongoMappingContext());
 		mongoConverter.afterPropertiesSet();
 
-		return new RelaxedTypeBasedAggregationOperationContext(type, mongoConverter.getMappingContext(),
-				new QueryMapper(mongoConverter));
+		return new TypeBasedAggregationOperationContext(type, mongoConverter.getMappingContext(),
+				new QueryMapper(mongoConverter), FieldLookupPolicy.relaxed());
 	}
 
 	static class Scores {