FLE Implemenation with Property Value Converter.

Closes #763.

Author: mikereiche

spring-data-couchbase/src/main/java/org/springframework/data/couchbase/config/AbstractCouchbaseConfiguration.java

@@ -21,6 +21,7 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -31,15 +32,21 @@
 import org.springframework.core.convert.converter.GenericConverter;
 import org.springframework.core.type.filter.AnnotationTypeFilter;
 import org.springframework.data.convert.CustomConversions;
+import org.springframework.data.convert.PropertyValueConverterFactory;
+import org.springframework.data.convert.PropertyValueConverterRegistrar;
+import org.springframework.data.convert.SimplePropertyValueConversions;
 import org.springframework.data.couchbase.CouchbaseClientFactory;
 import org.springframework.data.couchbase.SimpleCouchbaseClientFactory;
 import org.springframework.data.couchbase.core.CouchbaseTemplate;
 import org.springframework.data.couchbase.core.ReactiveCouchbaseTemplate;
 import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions;
+import org.springframework.data.couchbase.core.convert.CouchbasePropertyValueConverterFactory;
+import org.springframework.data.couchbase.core.convert.CryptoConverter;
 import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
 import org.springframework.data.couchbase.core.convert.OtherConverters;
 import org.springframework.data.couchbase.core.convert.translation.JacksonTranslationService;
 import org.springframework.data.couchbase.core.convert.translation.TranslationService;
+import org.springframework.data.couchbase.core.mapping.CouchbaseDocument;
 import org.springframework.data.couchbase.core.mapping.CouchbaseMappingContext;
 import org.springframework.data.couchbase.core.mapping.Document;
 import org.springframework.data.couchbase.repository.config.ReactiveRepositoryOperationsMapping;
@@ -274,6 +281,7 @@ public MappingCouchbaseConverter mappingCouchbaseConverter(CouchbaseMappingConte
 			CouchbaseCustomConversions couchbaseCustomConversions) {
 		MappingCouchbaseConverter converter = new MappingCouchbaseConverter(couchbaseMappingContext, typeKey());
 		converter.setCustomConversions(couchbaseCustomConversions);
+		couchbaseMappingContext.setSimpleTypeHolder(couchbaseCustomConversions.getSimpleTypeHolder());
 		return converter;
 	}
 
@@ -397,26 +405,39 @@ protected boolean autoIndexCreation() {
 	/**
 	 * Register custom Converters in a {@link CustomConversions} object if required. These {@link CustomConversions} will
 	 * be registered with the {@link #mappingCouchbaseConverter(CouchbaseMappingContext, CouchbaseCustomConversions)} )}
-	 * and {@link #couchbaseMappingContext(CustomConversions)}. Returns an empty {@link CustomConversions} instance by
-	 * default.
+	 * and {@link #couchbaseMappingContext(CustomConversions)}.
 	 *
-	 * @param cryptoManagerOptional optional cryptoManager. Make varargs for backwards compatibility.
 	 * @return must not be {@literal null}.
 	 */
 	@Bean(name = BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
-	public CustomConversions customConversions(CryptoManager... cryptoManagerOptional) {
-		assert (cryptoManagerOptional == null || cryptoManagerOptional.length <= 1);
-		CryptoManager cryptoManager = cryptoManagerOptional != null && cryptoManagerOptional.length == 1
-				? cryptoManagerOptional[0]
-				: null;
+	public CustomConversions customConversions() {
+		return customConversions(cryptoManager());
+	}
+
+	/**
+	 * Register custom Converters in a {@link CustomConversions} object if required. These {@link CustomConversions} will
+	 * be registered with the {@link #mappingCouchbaseConverter(CouchbaseMappingContext, CouchbaseCustomConversions)} )}
+	 * and {@link #couchbaseMappingContext(CustomConversions)}.
+	 *
+	 * @param cryptoManager
+	 * @return must not be {@literal null}.
+	 */
+	public CustomConversions customConversions(CryptoManager cryptoManager) {
 		List<GenericConverter> newConverters = new ArrayList();
 		// the cryptoConverters take an argument, so they cannot be created in the
 		// static block of CouchbaseCustomConversions. And they must be set before the super() constructor
-		// in CouchbaseCustomerConversions
-		if (cryptoManager != null) {
-			newConverters.addAll(OtherConverters.getCryptoConverters(cryptoManager));
-		}
-		return new CouchbaseCustomConversions(newConverters);
+		// in CouchbaseCustomConversions
+		CustomConversions customConversions = CouchbaseCustomConversions.create( configurationAdapter -> {
+					SimplePropertyValueConversions valueConversions = new SimplePropertyValueConversions();
+					valueConversions.setConverterFactory(new CouchbasePropertyValueConverterFactory(cryptoManager));
+					valueConversions.setValueConverterRegistry(new PropertyValueConverterRegistrar()
+							.registerConverter(CouchbaseDocument.class, "", new CryptoConverter(cryptoManager))// unnecessary?
+							.buildRegistry());
+			configurationAdapter.setPropertyValueConversions(valueConversions);
+			configurationAdapter.registerConverters(newConverters);
+				});
+
+		return customConversions;
 	}
 
 	@Bean

spring-data-couchbase/src/main/java/org/springframework/data/couchbase/core/convert/AbstractCouchbaseConverter.java

@@ -17,12 +17,14 @@
 package org.springframework.data.couchbase.core.convert;
 
 import java.util.Collections;
+import java.util.Map;
 
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.support.GenericConversionService;
 import org.springframework.data.convert.CustomConversions;
+import org.springframework.data.couchbase.core.mapping.CouchbaseDocument;
 import org.springframework.data.couchbase.core.mapping.CouchbasePersistentProperty;
 import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
 import org.springframework.data.mapping.model.EntityInstantiators;
@@ -99,7 +101,7 @@ public void afterPropertiesSet() {
 
 	/**
 	 * This convertForWriteIfNeeded takes a property and accessor so that the annotations can be accessed (ie. @Encrypted)
-	 * 
+	 *
 	 * @param prop the property to be converted to the class that would actually be stored.
 	 * @param accessor the property accessor
 	 * @return
@@ -110,6 +112,63 @@ public Object convertForWriteIfNeeded(CouchbasePersistentProperty prop, Converti
 		if (value == null) {
 			return null;
 		}
+		if (conversions.hasValueConverter(prop)) {
+			CouchbaseDocument encrypted = (CouchbaseDocument) conversions.getPropertyValueConversions()
+					.getValueConverter(prop).write(value, new CouchbaseConversionContext(prop, (MappingCouchbaseConverter)this, accessor));
+			return encrypted;
+		}
+		Class<?> targetClass = Object.class;
+
+		if (prop.findAnnotation(com.couchbase.client.java.encryption.annotation.Encrypted.class) != null) {
+			targetClass = Map.class;
+		}
+		boolean canConvert = this.conversionService.canConvert(new TypeDescriptor(prop.getField()),
+				TypeDescriptor.valueOf(targetClass));
+		if (canConvert) {
+			return this.conversionService.convert(value, new TypeDescriptor(prop.getField()),
+					TypeDescriptor.valueOf(targetClass));
+		}
+
+		Object result = this.conversions.getCustomWriteTarget(prop.getType()) //
+				.map(it -> this.conversionService.convert(value, new TypeDescriptor(prop.getField()),
+						TypeDescriptor.valueOf(it))) //
+				.orElseGet(() -> Enum.class.isAssignableFrom(value.getClass()) ? ((Enum<?>) value).name() : value);
+
+		return result;
+
+	}
+
+	/**
+	 * This convertForWriteIfNeeded takes a property and accessor so that the annotations can be accessed (ie. @Encrypted)
+	 *
+	 * @param prop the property to be converted to the class that would actually be stored.
+	 * @param accessor the property accessor
+	 * @return
+	 */
+//@Override
+	public Object convertForWriteIfNeeded2(CouchbasePersistentProperty prop, ConvertingPropertyAccessor<Object> accessor) {
+		Object value = accessor.getProperty(prop, prop.getType());
+		if (value == null) {
+			return null;
+		}
+		/*
+		if (conversions.hasValueConverter(prop)) {
+			CouchbaseDocument encrypted = (CouchbaseDocument) conversions.getPropertyValueConversions()
+					.getValueConverter(prop).write(value, new CouchbaseConversionContext(prop, (MappingCouchbaseConverter)this, accessor));
+			return encrypted;
+		}
+		 */
+		Class<?> targetClass = Object.class;
+
+		if (prop.findAnnotation(com.couchbase.client.java.encryption.annotation.Encrypted.class) != null) {
+			targetClass = Map.class;
+		}
+		boolean canConvert = this.conversionService.canConvert(new TypeDescriptor(prop.getField()),
+				TypeDescriptor.valueOf(targetClass));
+		if (canConvert) {
+			return this.conversionService.convert(value, new TypeDescriptor(prop.getField()),
+					TypeDescriptor.valueOf(targetClass));
+		}
 
 		Object result = this.conversions.getCustomWriteTarget(prop.getType()) //
 				.map(it -> this.conversionService.convert(value, new TypeDescriptor(prop.getField()),
@@ -123,7 +182,7 @@ public Object convertForWriteIfNeeded(CouchbasePersistentProperty prop, Converti
 	/**
 	 * This convertForWriteIfNeed takes only the value to convert. It cannot access the annotations of the Field being
 	 * converted.
-	 * 
+	 *
 	 * @param value the value to be converted to the class that would actually be stored.
 	 * @return
 	 */
@@ -145,13 +204,13 @@ public Object convertToCouchbaseType(Object value,  TypeInformation<?> typeInfor
 		if (value == null) {
 			return null;
 		}
-	
+
 		return this.conversions.getCustomWriteTarget(value.getClass()) //
 				.map(it -> (Object) this.conversionService.convert(value, it)) //
 				.orElseGet(() -> Enum.class.isAssignableFrom(value.getClass()) ? ((Enum<?>) value).name() : value);
-	
+
 	}
-	
+
 	@Override
 	public Object convertToCouchbaseType(String source) {
 		return source;
@@ -162,4 +221,9 @@ public Object convertToCouchbaseType(String source) {
 	public Class<?> getWriteClassFor(Class<?> clazz) {
 		return this.conversions.getCustomWriteTarget(clazz).orElse(clazz);
 	}
+
+	@Override
+	public CustomConversions getConversions(){
+		return conversions;
+	}
 }

spring-data-couchbase/src/main/java/org/springframework/data/couchbase/core/convert/CouchbaseConversionContext.java

@@ -0,0 +1,52 @@
+package org.springframework.data.couchbase.core.convert;
+
+import org.springframework.beans.PropertyAccessor;
+import org.springframework.data.convert.ValueConversionContext;
+import org.springframework.data.couchbase.core.mapping.CouchbasePersistentProperty;
+import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
+import org.springframework.data.util.TypeInformation;
+import org.springframework.lang.Nullable;
+
+/**
+ * {@link ValueConversionContext} that allows to delegate read/write to an underlying {@link CouchbaseConverter}.
+ *
+ * @author Christoph Strobl
+ * @since 3.4
+ */
+public class CouchbaseConversionContext implements ValueConversionContext<CouchbasePersistentProperty> {
+
+	private final CouchbasePersistentProperty persistentProperty;
+	private final MappingCouchbaseConverter couchbaseConverter;
+	private final ConvertingPropertyAccessor propertyAccessor;
+
+	public CouchbaseConversionContext(CouchbasePersistentProperty persistentProperty,
+																		MappingCouchbaseConverter couchbaseConverter, ConvertingPropertyAccessor accessor) {
+
+		this.persistentProperty = persistentProperty;
+		this.couchbaseConverter = couchbaseConverter;
+		this.propertyAccessor = accessor;
+	}
+
+	@Override
+	public CouchbasePersistentProperty getProperty() {
+		return persistentProperty;
+	}
+
+	@Override
+	public <T> T write(@Nullable Object value, TypeInformation<T> target) {
+		return (T) ValueConversionContext.super.write(value, target);
+	}
+
+	@Override
+	public <T> T read(@Nullable Object value, TypeInformation<T> target) {
+		return ValueConversionContext.super.read(value, target);
+	}
+
+	public MappingCouchbaseConverter getConverter(){
+		return couchbaseConverter;
+	}
+
+	public ConvertingPropertyAccessor getAccessor(){
+		return propertyAccessor;
+	}
+}

spring-data-couchbase/src/main/java/org/springframework/data/couchbase/core/convert/CouchbaseConverter.java

@@ -16,6 +16,7 @@
 
 package org.springframework.data.couchbase.core.convert;
 
+import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.convert.EntityConverter;
 import org.springframework.data.convert.EntityReader;
 import org.springframework.data.couchbase.core.mapping.CouchbaseDocument;
@@ -80,4 +81,10 @@ Object convertForWriteIfNeeded(final CouchbasePersistentProperty source,
 	// Object convertToCouchbaseType(Object source, TypeInformation<?> typeInformation);
 	//
 	// Object convertToCouchbaseType(String source);
+
+	/**
+	 * return the conversions
+	 * @return conversions
+	 */
+	CustomConversions getConversions();
 }