Add support for compound keys defined using @IdClass

[bfg]

Hi.

I have JPA entity which uses composite primary key:

@Entity
@IdClass(EntityId.class)
public class SomeEntity implements Serializable {
    @Id
    @Column(name = "message_id", updatable = false, nullable = false)
    @Type(type = "pg-uuid")
    private UUID firstId;

    @Id
    @Column(name = "recipient_id", updatable = false, nullable = false)
    @Type(type = "pg-uuid")
    private UUID secondId;

Everything works as expected using spring-data repository backed by postgresql, but trying to create spring-data-mock thows an exception:

com.mmnaseri.utils.spring.data.error.MultipleIdPropertiesException: There are multiple properties in class SomeEntity that are annotated as the ID property
    at com.mmnaseri.utils.spring.data.domain.impl.id.AnnotatedFieldIdPropertyResolver$1.doWith(AnnotatedFieldIdPropertyResolver.java:37)

It would be absolutely awesome if this would be supported by spring-data-mock, because i don't need to bring up the whole spring context for testing.

[mmnaseri]

Hi,

Thanks for using this framework. I completely understand your pain, which is what got me to implement this framework in the first place.

TL;DR I will try to implement this feature as soon as possible.

Background

Currently the DataStore abstraction which mimics the behavior of a simple key-value store expects the keys to every entity to be a Serializable value. This value is resolved from the entities by accessing a given key property.

Solution

The first order of business is to add EmbeddedKey as a viable key designator. This will allow for classes marked as Embeddable to be used as compound keys. This is without key generation, of course:

@Embeddable
public class AccountOwnershipKey implements Serializable {}

@Entity
public class AccountOwnership {

    @EmbeddedKey
    private AccountOwnershipKey key;

}

public interface AccountOwnershipRepository<AccountOwnership, AccountOwnershipRepository> {
     // omitted for brevity
}

final AccountOwnershipRepository repository  = builder()
                                                 .withoutGeneratingKeys()
                                                 .mock(AccountOwnershipRepository.class);

For better support, it would be more extensible to add one level of indirection between keys and data stores, so that there is a Serializable class that acts as the intermediary and the key resolver actually figures out the schema for this class and its relationship with the original entity.

Using IdClass

Given the following entity definition:

@Entity
@IdClass(MembershipKey.class)
public class Membership {

    @Id
    private Long personId;

    @Id
    private Long groupId;

}

The MembershipKey class will have to be defined like this:

public class MembershipKey implements Serializable {

    private Long personId;
    private Long groupId;

    // getters and setters omitted

}

will allow for the following repository definition:

public interface MembershipRepository extends JpaRepository<Membership, MembershipKey> {
     // omitted for brevity
}

To support this use case, I will need to add a new key resolver which will provide a level of indirection around the key so that a key can be automatically instantiated for each entity and that its value can be bound both ways to the properties of the entity.

Note

This comment was updated with a solution for the specific feature being requested after I -- finally -- spotted the @IdClass annotation on the provided sample.

[mmnaseri]

So, started working on this with the following entity class as a sample:

package com.mmnaseri.utils.samples.spring.data.jpa.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;

/**
 * @author Mohammad Milad Naseri ([email protected])
 * @since 1.0 (7/18/16)
 */
@Entity
@IdClass(AccountAccessKey.class)
public class AccountAccess {

    @Id
    @Column
    private String userId;

    @Id
    @Column
    private String accountId;

    @Column
    private AccountAccessType accessType;

    public String getUserId() {
        return userId;
    }

    public AccountAccess setUserId(String userId) {
        this.userId = userId;
        return this;
    }

    public String getAccountId() {
        return accountId;
    }

    public AccountAccess setAccountId(String accountId) {
        this.accountId = accountId;
        return this;
    }

    public void setAccessType(AccountAccessType accessType) {
        this.accessType = accessType;
    }

    public AccountAccessType getAccessType() {
        return accessType;
    }

}

and the following repository definition:

package com.mmnaseri.utils.samples.spring.data.jpa.repository;

import com.mmnaseri.utils.samples.spring.data.jpa.model.AccountAccess;
import com.mmnaseri.utils.samples.spring.data.jpa.model.AccountAccessKey;
import com.mmnaseri.utils.samples.spring.data.jpa.model.AccountAccessType;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

/**
 * @author Mohammad Milad Naseri ([email protected])
 * @since 1.0 (7/18/16)
 */
public interface AccountAccessRepository extends JpaRepository<AccountAccess, AccountAccessKey> {

    List<AccountAccess> findByUserId(String userId);

    List<AccountAccess> findByUserIdAndAccessType(String userId, AccountAccessType accessType);

    List<AccountAccess> findByAccountIdAndAccessType(String accountId, AccountAccessType accessType);

}

These are examples taken from the spring-data-mock-sample-jpa module which will be made available once the feature is properly supported.

[JNFrazao]

Hello,

I am working with Spring Boot tests, using Spring Data Mock and I am facing this issue.

I noticed that your have started working on it, and I would like to know if you have any update regarding it.

Thanks,
Joao