Support derived queries on repositories defined with an abstract entity class.

Motivation:
Currently an abstract entity class specified in the repository definition can
be used for the predicate typeKey = typeAlias(of abstract entity class) in
queries. Since documents are stored with typeKey = typeAlias(of concrete class)
those queries will never match any documents.  To allow this to work,
all of the abstract entity class an all concrete subclasses must use the
same typeAlias.

Once those documents are found, regardless of their concrete class,
they will all have the same typeKey = typeAlias, instead of having the
typeAlias specific to the concrete class. Additional information in
the stored document is needed to identify the concrete class (subtype
in the example test case), as well as a TypeMapper to interpret that
 information.

Changes:
This allows a common TypeAlias to be used for the purpose of the predicate
typeKey = typeAlias, and the determination of the concrete type by
implementing an AbstractingMappingCouchbaseConverter that inspects the
'subtype' property.

Closes #1365.

Author: mikereiche

src/main/java/org/springframework/data/couchbase/core/CouchbaseTemplateSupport.java

@@ -87,6 +87,18 @@ public CouchbaseDocument encodeEntity(final Object entityToEncode) {
 	public <T> T decodeEntity(String id, String source, long cas, Class<T> entityClass, String scope, String collection) {
 		final CouchbaseDocument converted = new CouchbaseDocument(id);
 		converted.setId(id);
+
+		// this is the entity class defined for the repository. It may not be the class of the document that was read
+		// we will reset it after reading the document
+		//
+		// This will fail for the case where:
+		// 1) The version is defined in the concrete class, but not in the abstract class; and
+		// 2) The constructor takes a "long version" argument resulting in an exception would be thrown if version in
+		// the source is null.
+		// We could expose from the MappingCouchbaseConverter determining the persistent entity from the source,
+		// but that is a lot of work to do every time just for this very rare and avoidable case.
+		// TypeInformation<? extends R> typeToUse = typeMapper.readType(source, type);
+
 		CouchbasePersistentEntity persistentEntity = couldBePersistentEntity(entityClass);
 
 		if (persistentEntity == null) { // method could return a Long, Boolean, String etc.
@@ -99,14 +111,26 @@ public <T> T decodeEntity(String id, String source, long cas, Class<T> entityCla
 			return (T) set.iterator().next().getValue();
 		}
 
+		CouchbaseDocument doc = (CouchbaseDocument) translationService.decode(source, converted);
+		// if possible, set the version property in the source so that if the constructor has a long version argument,
+		// it will have a value an not fail (as null is not a valid argument for a long argument). This possible failure
+		// can be avoid by defining the argument as Long instead of long.
+		// persistentEntity is still the (possibly abstract) class specified in the repository definition
+		// it's possible that the abstract class does not have a version property, and this won't be able to set the version
 		if (cas != 0 && persistentEntity.getVersionProperty() != null) {
-			converted.put(persistentEntity.getVersionProperty().getName(), cas);
+			doc.put(persistentEntity.getVersionProperty().getName(), cas);
 		}
 
-		T readEntity = converter.read(entityClass, (CouchbaseDocument) translationService.decode(source, converted));
+		// if the constructor has an argument that is long version, then it will fail if it is not available as 'null'
+		// is not a legal value for a long.
+		// Version doesn't come from
+		// 'source', it comes from the cas argument to decodeEntity which is set later.
+		T readEntity = converter.read(entityClass, doc);
 		final ConvertingPropertyAccessor<T> accessor = getPropertyAccessor(readEntity);
 
-		if (persistentEntity.getVersionProperty() != null) {
+		persistentEntity = couldBePersistentEntity(readEntity.getClass());
+
+		if (cas != 0 && persistentEntity.getVersionProperty() != null) {
 			accessor.setProperty(persistentEntity.getVersionProperty(), cas);
 		}
 		N1qlJoinResolver.handleProperties(persistentEntity, accessor, template.reactive(), id, scope, collection);

src/main/java/org/springframework/data/couchbase/core/mapping/BasicCouchbasePersistentProperty.java

@@ -77,6 +77,10 @@ public String getFieldName() {
 		if (fieldName != null) {
 			return fieldName;
 		}
+		if (getField() == null) { // use the name of the property - instead of getting an NPE trying to use field
+			return fieldName = getName();
+		}
+
 		Field annotationField = getField().getAnnotation(Field.class);
 
 		if (annotationField != null) {

src/main/java/org/springframework/data/couchbase/repository/query/StringBasedN1qlQueryParser.java

@@ -20,6 +20,7 @@
 import static org.springframework.data.couchbase.core.support.TemplateUtils.SELECT_CAS;
 import static org.springframework.data.couchbase.core.support.TemplateUtils.SELECT_ID;
 
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -192,8 +193,8 @@ private String getProjectedOrDistinctFields(String b, Class resultClass, String
 		if (distinctFields != null && distinctFields.length != 0) {
 			return i(distinctFields).toString();
 		}
-		String projectedFields = i(b) + ".*";
-		if (resultClass != null) {
+		String projectedFields = i(b) + ".*"; // if we can't get further information of the fields needed project everything
+		if (resultClass != null && !Modifier.isAbstract(resultClass.getModifiers())) {
 			PersistentEntity persistentEntity = couchbaseConverter.getMappingContext().getPersistentEntity(resultClass);
 			StringBuilder sb = new StringBuilder();
 			getProjectedFieldsInternal(b, null, sb, persistentEntity, typeField, fields, distinctFields != null);
@@ -528,9 +529,8 @@ public N1qlSpelValues(String selectClause, String entityFields, String bucket, S
 	}
 
 	// copied from StringN1qlBasedQuery
-	private N1QLExpression getExpression(ParameterAccessor accessor,
-			ReturnedType returnedType, SpelExpressionParser parser,
-			QueryMethodEvaluationContextProvider evaluationContextProvider) {
+	private N1QLExpression getExpression(ParameterAccessor accessor, ReturnedType returnedType,
+			SpelExpressionParser parser, QueryMethodEvaluationContextProvider evaluationContextProvider) {
 		boolean isCountQuery = queryMethod.isCountQuery();
 		Object[] runtimeParameters = getParameters(accessor);
 		EvaluationContext evaluationContext = evaluationContextProvider.getEvaluationContext(queryMethod.getParameters(),

src/test/java/org/springframework/data/couchbase/core/CustomTypeKeyIntegrationTests.java

@@ -62,8 +62,7 @@ void saveSimpleEntityCorrectlyWithDifferentTypeKey() {
 		assertEquals(user, modified);
 
 		GetResult getResult = clientFactory.getCollection(null).get(user.getId());
-		assertEquals("org.springframework.data.couchbase.domain.User",
-				getResult.contentAsObject().getString(CUSTOM_TYPE_KEY));
+		assertEquals("abstractuser", getResult.contentAsObject().getString(CUSTOM_TYPE_KEY));
 		assertFalse(getResult.contentAsObject().containsKey(DefaultCouchbaseTypeMapper.DEFAULT_TYPE_KEY));
 		operations.removeById(User.class).one(user.getId());
 	}

src/test/java/org/springframework/data/couchbase/domain/AbstractUser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2020 the original author or authors
+ * Copyright 2012-2022 the original author or authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,35 +16,21 @@
 
 package org.springframework.data.couchbase.domain;
 
-import java.util.Objects;
-
-import org.springframework.data.annotation.CreatedBy;
-import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.Id;
-import org.springframework.data.annotation.LastModifiedBy;
-import org.springframework.data.annotation.LastModifiedDate;
-import org.springframework.data.annotation.PersistenceConstructor;
-import org.springframework.data.annotation.Transient;
-import org.springframework.data.annotation.Version;
-import org.springframework.data.couchbase.core.mapping.Document;
+import org.springframework.data.annotation.TypeAlias;
+import org.springframework.data.couchbase.core.mapping.Field;
 
 /**
  * User entity for tests
  *
  * @author Michael Reiche
  */
-
+@TypeAlias(AbstractingTypeMapper.Type.ABSTRACTUSER)
 public abstract class AbstractUser extends ComparableEntity {
-
-	@Version protected long version;
 	@Id protected String id;
 	protected String firstname;
 	protected String lastname;
-	@Transient protected String transientInfo;
-	@CreatedBy protected String createdBy;
-	@CreatedDate protected long createdDate;
-	@LastModifiedBy protected String lastModifiedBy;
-	@LastModifiedDate protected long lastModifiedDate;
+	@Field(AbstractingTypeMapper.SUBTYPE) protected String subtype;
 
 	public String getId() {
 		return id;
@@ -53,53 +39,4 @@ public String getId() {
 	public String getFirstname() {
 		return firstname;
 	}
-
-	public String getLastname() {
-		return lastname;
-	}
-
-	public long getCreatedDate() {
-		return createdDate;
-	}
-
-	public void setCreatedDate(long createdDate) {
-		this.createdDate = createdDate;
-	}
-
-	public String getCreatedBy() {
-		return createdBy;
-	}
-
-	public void setCreatedBy(String createdBy) {
-		this.createdBy = createdBy;
-	}
-
-	public long getLastModifiedDate() {
-		return lastModifiedDate;
-	}
-
-	public String getLastModifiedBy() {
-		return lastModifiedBy;
-	}
-
-	public long getVersion() {
-		return version;
-	}
-
-	public void setVersion(long version) {
-		this.version = version;
-	}
-
-	@Override
-	public int hashCode() {
-		return Objects.hash(getId(), firstname, lastname);
-	}
-
-	public String getTransientInfo() {
-		return transientInfo;
-	}
-
-	public void setTransientInfo(String something) {
-		transientInfo = something;
-	}
 }

src/test/java/org/springframework/data/couchbase/domain/AbstractUserRepository.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2021 the original author or authors
+ * Copyright 2012-2022 the original author or authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,28 +19,28 @@
 import java.util.List;
 import java.util.stream.Stream;
 
-import com.couchbase.client.java.query.QueryScanConsistency;
 import org.springframework.data.couchbase.repository.CouchbaseRepository;
 import org.springframework.data.couchbase.repository.Query;
 import org.springframework.data.couchbase.repository.ScanConsistency;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 import com.couchbase.client.java.json.JsonArray;
+import com.couchbase.client.java.query.QueryScanConsistency;
 
 /**
  * AbstractUser Repository for tests
  * 
  * @author Michael Reiche
  */
 @Repository
-@ScanConsistency(query=QueryScanConsistency.REQUEST_PLUS)
+@ScanConsistency(query = QueryScanConsistency.REQUEST_PLUS)
 public interface AbstractUserRepository extends CouchbaseRepository<AbstractUser, String> {
 
 	@Query("#{#n1ql.selectEntity} where (meta().id = $1)")
 	AbstractUser myFindById(String id);
 
-	List<User> findByFirstname(String firstname);
+	List<AbstractUser> findByFirstname(String firstname);
 
 	Stream<User> findByLastname(String lastname);
 

src/test/java/org/springframework/data/couchbase/domain/AbstractingMappingCouchbaseConverter.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2022 the original author or authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.couchbase.domain;
+
+import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
+import org.springframework.data.couchbase.core.mapping.CouchbasePersistentEntity;
+import org.springframework.data.couchbase.core.mapping.CouchbasePersistentProperty;
+import org.springframework.data.mapping.context.MappingContext;
+
+/**
+ * MappingConverter that uses AbstractTypeMapper
+ *
+ * @author Michael Reiche
+ */
+public class AbstractingMappingCouchbaseConverter extends MappingCouchbaseConverter {
+
+	/**
+	 * this constructer creates a TypeBasedCouchbaseTypeMapper with the specified typeKey while MappingCouchbaseConverter
+	 * uses a DefaultCouchbaseTypeMapper typeMapper = new DefaultCouchbaseTypeMapper(typeKey != null ? typeKey :
+	 * TYPEKEY_DEFAULT);
+	 *
+	 * @param mappingContext
+	 * @param typeKey - the typeKey to be used (normally "_class")
+	 */
+	public AbstractingMappingCouchbaseConverter(
+			final MappingContext<? extends CouchbasePersistentEntity<?>, CouchbasePersistentProperty> mappingContext,
+			final String typeKey) {
+		super(mappingContext, typeKey);
+		this.typeMapper = new AbstractingTypeMapper(typeKey);
+	}
+
+}

src/test/java/org/springframework/data/couchbase/domain/AbstractingTypeMapper.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2022 the original author or authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.data.couchbase.domain;
+
+import java.util.Collections;
+
+import org.springframework.data.convert.DefaultTypeMapper;
+import org.springframework.data.convert.TypeAliasAccessor;
+import org.springframework.data.couchbase.core.convert.CouchbaseTypeMapper;
+import org.springframework.data.couchbase.core.mapping.CouchbaseDocument;
+import org.springframework.data.mapping.Alias;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.util.TypeInformation;
+
+/**
+ * TypeMapper that leverages subtype 
+ *
+ * @author Michael Reiche
+ */
+public class AbstractingTypeMapper extends DefaultTypeMapper<CouchbaseDocument> implements CouchbaseTypeMapper {
+
+	public static final String SUBTYPE = "subtype";
+	private final String typeKey;
+
+	public static class Type {
+		public static final String ABSTRACTUSER = "abstractuser", USER = "user", OTHERUSER = "otheruser";
+	}
+
+	/**
+	 * Create a new type mapper with the type key.
+	 *
+	 * @param typeKey the typeKey to use.
+	 */
+	public AbstractingTypeMapper(final String typeKey) {
+		super(new CouchbaseDocumentTypeAliasAccessor(typeKey), (MappingContext) null, Collections
+				.singletonList(new org.springframework.data.couchbase.core.convert.TypeAwareTypeInformationMapper()));
+		this.typeKey = typeKey;
+	}
+
+	@Override
+	public String getTypeKey() {
+		return this.typeKey;
+	}
+
+	public static final class CouchbaseDocumentTypeAliasAccessor implements TypeAliasAccessor<CouchbaseDocument> {
+
+		private final String typeKey;
+
+		public CouchbaseDocumentTypeAliasAccessor(final String typeKey) {
+			this.typeKey = typeKey;
+		}
+
+		@Override
+		public Alias readAliasFrom(final CouchbaseDocument source) {
+			String alias = (String) source.get(typeKey);
+			if (Type.ABSTRACTUSER.equals(alias)) {
+				String subtype = (String) source.get(AbstractingTypeMapper.SUBTYPE);
+				if (Type.OTHERUSER.equals(subtype)) {
+					alias = OtherUser.class.getName();
+				} else if (Type.USER.equals(subtype)) {
+					alias = User.class.getName();
+				} else {
+					throw new RuntimeException(
+							"no mapping for type " + SUBTYPE + "=" + subtype + " in type " + alias + " source=" + source);
+				}
+			}
+			return Alias.ofNullable(alias);
+		}
+
+		@Override
+		public void writeTypeTo(final CouchbaseDocument sink, final Object alias) {
+			if (typeKey != null) {
+				sink.put(typeKey, alias);
+			}
+		}
+	}
+
+	@Override
+	public Alias getTypeAlias(TypeInformation<?> info) {
+		return getAliasFor(info);
+	}
+
+}