Experiment with deriving storage document from lookup query.

Author: christophstrobl

Diff for: spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MappingMongoConverter.java

@@ -17,17 +17,10 @@
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import org.bson.Document;
@@ -52,6 +45,7 @@
 import org.springframework.data.mapping.PreferredConstructor.Parameter;
 import org.springframework.data.mapping.callback.EntityCallbacks;
 import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mapping.model.BeanWrapperPropertyAccessorFactory;
 import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
 import org.springframework.data.mapping.model.DefaultSpELExpressionEvaluator;
 import org.springframework.data.mapping.model.EntityInstantiator;
@@ -814,8 +808,60 @@ protected void writePropertyInternal(@Nullable Object obj, DocumentAccessor acce
 			if (conversionService.canConvert(valueType.getType(), DocumentPointer.class)) {
 				accessor.put(prop, conversionService.convert(obj, DocumentPointer.class).getPointer());
 			} else {
+
+				MongoPersistentEntity<?> persistentEntity = mappingContext.getPersistentEntity(prop.getAssociationTargetType());
+				// TODO: Move this to helper for queries
+
+
+				if(!prop.getDocumentReference().lookup().toLowerCase().replaceAll("\\s", "").replaceAll("'","").equals("{_id:?#{#target}}")) {
+
+					String lookup = prop.getDocumentReference().lookup();
+					String targetLookup = lookup;
+
+					Pattern pattern = Pattern.compile("\\?#\\{#?[\\w\\d]*\\}");
+
+					Matcher matcher = pattern.matcher(lookup);
+					int index = 0;
+					Map<Integer, String> mapMap = new LinkedHashMap<>();
+					while(matcher.find()) {
+
+						String expr = matcher.group();
+						mapMap.put(Integer.valueOf(index), expr.substring(0, expr.length()-1).replace("?#{#", "").replace("?#{", "").replace("target.","").replaceAll("'",""));
+						targetLookup = targetLookup.replace(expr, index + "");
+						index++;
+					}
+
+					Document fetchDocument = Document.parse(targetLookup);
+
+					PersistentPropertyAccessor<?> propertyAccessor = BeanWrapperPropertyAccessorFactory.INSTANCE.getPropertyAccessor(prop.getOwner(), obj);
+
+
+					Document targetDocument = new Document();
+					for(Entry<String, Object> entry : fetchDocument.entrySet()) {
+
+						if(entry.getKey().equals("target")) {
+
+							String refKey = mapMap.get(entry.getValue());
+
+							if(persistentEntity.hasIdProperty()) {
+								targetDocument.put(refKey, persistentEntity.getIdentifierAccessor(obj).getIdentifier());
+							} else {
+								targetDocument.put(refKey, obj);
+							}
+							continue;
+						}
+
+						Object value = propertyAccessor.getProperty(persistentEntity.getPersistentProperty(entry.getKey()));
+						String refKey = mapMap.get(entry.getValue());
+						targetDocument.put(refKey, value);
+					}
+
+					accessor.put(prop, targetDocument);
+					return;
+				}
+
 				// just take the id as a reference
-				accessor.put(prop, mappingContext.getPersistentEntity(prop.getAssociationTargetType())
+				accessor.put(prop, persistentEntity
 						.getIdentifierAccessor(obj).getIdentifier());
 			}
 			return;

Diff for: spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateDocumentReferenceTests.java

@@ -38,7 +38,6 @@
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.annotation.Id;
-import org.springframework.data.annotation.PersistenceConstructor;
 import org.springframework.data.convert.WritingConverter;
 import org.springframework.data.mongodb.core.convert.LazyLoadingTestUtils;
 import org.springframework.data.mongodb.core.mapping.DocumentPointer;
@@ -807,16 +806,42 @@ void useReadingWriterConverterPairForLoading() {
 		template.save(root);
 
 		Document target = template.execute(db -> {
-			return db.getCollection(template.getCollectionName(SingleRefRoot.class))
-					.find(Filters.eq("_id", root.id)).first();
+			return db.getCollection(template.getCollectionName(SingleRefRoot.class)).find(Filters.eq("_id", root.id)).first();
 		});
 
-		assertThat(target).containsEntry("withReadingConverter", new Document("ref-key-from-custom-write-converter", root.withReadingConverter.id));
+		assertThat(target).containsEntry("withReadingConverter",
+				new Document("ref-key-from-custom-write-converter", root.withReadingConverter.id));
 
 		SingleRefRoot loaded = template.findOne(query(where("id").is(root.id)), SingleRefRoot.class);
 		assertThat(loaded.withReadingConverter).isInstanceOf(SimpleObjectRefWithReadingConverter.class);
 	}
 
+	@Test // GH-3602
+	void deriveMappingFromLookup() {
+
+		Publisher publisher = new Publisher();
+		publisher.id = "p-1";
+		publisher.acronym = "TOR";
+		publisher.name = "Tom Doherty Associates";
+
+		template.save(publisher);
+
+		Book book = new Book();
+		book.id = "book-1";
+		book.publisher = publisher;
+
+		template.save(book);
+
+		Document target = template.execute(db -> {
+			return db.getCollection(template.getCollectionName(Book.class)).find(Filters.eq("_id", book.id)).first();
+		});
+
+		assertThat(target).containsEntry("publisher", new Document("acc", publisher.acronym).append("n", publisher.name));
+
+		Book result = template.findOne(query(where("id").is(book.id)), Book.class);
+		assertThat(result.publisher).isNotNull();
+	}
+
 	@Data
 	static class SingleRefRoot {
 
@@ -956,7 +981,8 @@ class DocumentToSimpleObjectRefWithReadingConverter
 		@Override
 		public SimpleObjectRefWithReadingConverter convert(DocumentPointer<Document> source) {
 
-			Document document = client.getDatabase(DB_NAME).getCollection("simple-object-ref").find(Filters.eq("_id", source.getPointer().get("ref-key-from-custom-write-converter"))).first();
+			Document document = client.getDatabase(DB_NAME).getCollection("simple-object-ref")
+					.find(Filters.eq("_id", source.getPointer().get("ref-key-from-custom-write-converter"))).first();
 			return new SimpleObjectRefWithReadingConverter(document.getString("_id"), document.getString("value"));
 		}
 	}
@@ -1011,4 +1037,21 @@ public DocumentPointer<Document> convert(ReferencedObject source) {
 			return () -> new Document("", source);
 		}
 	}
+
+	@Data
+	static class Book {
+
+		String id;
+
+		@DocumentReference(lookup = "{ 'acronym' : ?#{acc}, 'name' : ?#{n} }") Publisher publisher;
+
+	}
+
+	static class Publisher {
+
+		String id;
+		String acronym;
+		String name;
+	}
+
 }