For repositories defined with interface/abstract entity class, only fields in abstract/entity class are projected

[mikereiche]

For repositories defined with interface/abstract entity class, only fields in abstract/entity class are projected.

To ensure that all the fields for the (unknown at that point) concrete class are projected, then '*' should be projected.
StringBasedN1qlQueryParser:

String projectedFields = i(b) + ".*";
if (resultClass != null  && !Modifier.isAbstract(resultClass.getModifiers()) /* for both interfaces and abstract classes */) {

Also - getFieldName() can be better by returning getName() in the event it cannot access 'field' for the fieldName (which can happen in abstract classes and interfaces).

BaseCouchbasePersistentProperty:
if(getField() == null){ // punt
return fieldName = getName();
}

[mikereiche]

I’m implementing this and I came across one further issue in testing. For a repository method like this for querying all concrete types of AbstractUser, spring data only has the AbstractUser type. And if adds the predicate type = ‘AbstractUser’, it’s not going to match anything because documents are stored with their concrete types.
public interface AbstractUserRepository extends CouchbaseRepository<AbstractUser, String>

List findByFirstname(String firstname);
The only way to solve this is to have a common @typealias (just put the @typealias on the abstract/interface should work). Suppose you use the “anyuser”, Then all types of users will be stored with type = “anyuser”, and also that will be the predicate used for querying - so it will match. The problem is that your TypeMapper (above) will map all documents with the alias “anyuser” to the same type - even though they possibly are different concrete types. So your TypeMapper will need means besides the alias to determine what classname to return from readAliasFrom.

TypeMapper

```

package ;

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.convert.DefaultCouchbaseTypeMapper;
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.ClassTypeInformation;
import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

import java.util.Collections;

public class TypeBasedCouchbaseTypeMapper extends DefaultTypeMapper implements CouchbaseTypeMapper {

private final String typeKey;

/**

• Create a new type mapper with the type key.
• @param typeKey the typeKey to use.
  */
  public TypeBasedCouchbaseTypeMapper(final String typeKey) {
  super(new AbstractingTypeAliasAccessor(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 AbstractingTypeAliasAccessor implements TypeAliasAccessor {

private final String typeKey;

public AbstractingTypeAliasAccessor(final String typeKey) {
this.typeKey = typeKey;
}

@OverRide
public Alias readAliasFrom(final CouchbaseDocument source) {
String alias = (String)source.get(typeKey);
if("user".equals(alias)){
String userType = (String)source.get("userType");
if("AdminUser".equals(userType)){
alias = "com.mycompany.domain.AdminUser";
} else {
alias = "com.mycompany.domain.RegularUser";
}
} else /* ... */ {
//
}
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);
}
}