Enable run-time "filtering" based also on property name in @Conditional #2831

ivlcic · 2022-04-27T09:09:08Z

ivlcic
Apr 27, 2022

Hi, all!

Currently there is no option to do run-time filtering based on target property name.

This comes very handy when mapping larger object graphs from ORM frameworks, to block
unnecessary loading from database while reusing the mapping code.

I have implemented this feature with additional (@TargetPropertyName) annotated parameter in conditional / presence check methods.

I would like to make a pull request if this feature can be accepted.

For instance:

@Mapper
public interface MyMapper {

    MyMapper INSTANCE = Mappers.getMapper( MyMapper.class );

    Employee map(EmployeeDto employee);

    @Condition
    default <T> boolean isNotEmpty(Collection<T> collection, @TargetPropertyName String propName) {
        if ( "addresses".equalsIgnoreCase( propName ) ) {
            return false;
        }
        return collection != null && !collection.isEmpty();
    }

    @Condition
    default boolean isNotBlank(String value, @TargetPropertyName String propName) {
        if ( propName.equalsIgnoreCase( "lastName" ) ) {
            return false;
        }
        return value != null && !value.trim().isEmpty();
    }
}

Or even more complex example with passed @Context method parameter where run-time decisions based on target property name could be made:

@Mapper
public interface MyMapper {

    MyMapper INSTANCE = Mappers.getMapper( MyMapper.class );

    Employee map(EmployeeDto employee, @Context PresenceUtils utils);

    Address map(AddressDto addressDto, @Context PresenceUtils utils);

    class PresenceUtils {
        Set<String> visited = new LinkedHashSet<>();

        @Condition
        public boolean decide(String value, @TargetPropertyName String propName) {
            return true; //decide if continue mapping
        }
    }
}

And more interesting / real-life example where glob like pattern filtering could be applied:

interface Entity {}
interface Dto {}

class Employee implements Entity { //default constructor, getters and setters ommited
    String name;
    Employee boss;
    Address address;
    List<Employee> subordinates;
    String title;
}

class Address implements Entity { //default constructor, getters and setters ommited
    String street;
}

class EmployeeDto implements Dto { //default constructor, getters and setters ommited
    String name;
    EmployeeDto boss;
    AddressDto address;
    List<EmployeeDto> subordinates;
    String title;

    public EmployeeDto(String name, EmployeeDto boss, AddressDto address) {
        this.name = name;
        this.boss = boss;
        this.address = address;
    }

    public EmployeeDto(String name, AddressDto address, List<EmployeeDto> subordinates) {
        this.name = name;
        this.address = address;
        this.subordinates = subordinates;
    }
}

class AddressDto implements Dto { //default constructor, getters and setters ommited
    String street;

    public AddressDto(String street) {
        this.street = street;
    }
}

class MapContext {
    Set<String> ignoreProps = new HashSet<>();
    Deque<String> path = new LinkedList<>();
    Deque<String> visited = new LinkedList<>();
    String lastProp = null;

    @Condition
    public boolean collectAndFilter(@TargetPropertyName String propName) {
        if ( ignoreProps.contains( propName ) ) {
            return false;
        }
        this.lastProp = propName;
        this.path.offerLast( this.lastProp );
        this.visited.offerLast( String.join( ".", this.path ) );
        this.path.pollLast();
        return true;
    }
}

interface FirmMapper<E extends Entity, D extends Dto> {

    E map(D dto, @Context MapContext ctx);

    @BeforeMapping
    default void before(Object dto, @Context MapContext ctx) {
        if (ctx.lastProp != null && dto != null) {
            ctx.path.offerLast( ctx.lastProp );
        }
    }

    @AfterMapping
    default void after(Object dto, @Context MapContext ctx) {
        ctx.path.pollLast();
        ctx.lastProp = ctx.path.peekLast();
    }
}

@Mapper
interface EmployeeMapper extends FirmMapper<Employee, EmployeeDto> {
    EmployeeMapper INSTANCE = Mappers.getMapper( EmployeeMapper.class );
}

@Mapper
interface AddressMapper extends FirmMapper<Address, AddressDto> {
    AddressMapper INSTANCE = Mappers.getMapper( AddressMapper.class );
}

// more mappers ...

public void main(String args[]) {
    EmployeeMapper mapper = EmployeeMapper.INSTANCE;
    MapContext context = new MapContext();
    context.ignoreProps.add( "boss" ); //could be extended to glob like features

    EmployeeDto bossDto = new EmployeeDto( "Boss", new AddressDto("Testing st. 18"), new ArrayList<>() );
    bossDto.subordinates.add( new EmployeeDto( "Employee1", bossDto, new AddressDto("Street 1") ) );
    bossDto.subordinates.add( new EmployeeDto( "Employee2", bossDto, new AddressDto("Street 2") ) );
    bossDto.subordinates.add( new EmployeeDto( "Employee3", bossDto, new AddressDto("Street 3") ) );

    Employee boss = mapper.map( bossDto, context );
    System.out.printf( "Visited property name paths: \n%s\n", String.join( ", \n", context.visited ) );
    //Visited property name paths:
    //name,
    //address,
    //address.street,
    //subordinates,
    //subordinates.subordinates.name,
    //subordinates.subordinates.address,
    //subordinates.subordinates.address.street,
    //subordinates.subordinates.subordinates,
    //subordinates.subordinates.title,
    //subordinates.subordinates.name,
    //subordinates.subordinates.address,
    //subordinates.subordinates.address.street,
    //subordinates.subordinates.subordinates,
    //subordinates.subordinates.title,
    //subordinates.subordinates.name,
    //subordinates.subordinates.address,
    //subordinates.subordinates.address.street,
    //subordinates.subordinates.subordinates,
    //subordinates.subordinates.title,
    //title
}

Zegveld · 2022-04-28T10:22:03Z

Zegveld
Apr 28, 2022
Collaborator

Feel free to work on it, here is the existing feature request: #2688

The suggested annotation there is @TargetProperty.

0 replies

ivlcic · 2022-04-28T12:05:31Z

ivlcic
Apr 28, 2022
Author

Ok, I'll rename the annotation and issue a pull request.

Do I have to write the documentation also or it's better to leave it for afterwards - documentation maintainer?

1 reply

filiphr May 30, 2022
Maintainer

Thanks a lot for the PR @ivlcic, sorry that it takes us a bit of time to do the proper review.

I think that we can write the docs once we iron out the PR, once we agree about how it works, then you could add the docs for it. Are you OK with that?

mirkoluchi · 2023-11-24T14:13:48Z

mirkoluchi
Nov 24, 2023

Would it be possible to ease the filtering using a hypothetical @TargetPropertyPath annotation, providing the path of the target property rather than just the name?

Example:

class ContactDTO{
    String fullName;
    AddressDTO address;
    List<PhoneDTO> phones;
}

class AddressDTO{
   String address;
   String country;
}

class PhoneDTO{
   String number;
   String type;
}

interface ContactMapper{

   ContactDTO map(ContactEntity contact);

   @Condition
   default <T> boolean shouldMapProperty(@TargetPropertyPath String propertyPath) {
        // property on the root object
        if("fullName".equals(propertyPath)){
           return true; 
        }

        // property on the nested AddressDTO object, specifying that of the nested 'address' field I just want to map the 'country' property
        if("address.country".equals(propertyPath)) {
             return true; 
        }
        
        // property on the nested collection of PhoneDTO objects, specifying that - for first phone in the list, I just want to map the number)
        if("phones[0].number".equals(propertyPath)) {
           return true; 
        }

        return false;
   }

 }

3 replies

filiphr Nov 26, 2023
Maintainer

That would be a bit more complicated. However, you do have access to the Mapping target. so you could do something like

interface ContactMapper{

   ContactDTO map(ContactEntity contact);

   @Condition
   default <T> boolean shouldMapProperty(@MappingTarget ContactDTO ignored, @TargetPropertyName String propertyName) {
        if("fullName".equals(propertyName)) {
           return true; 
        }

        return false;
   }

   @Condition
   default <T> boolean shouldMapProperty(@MappingTarget AddressDTO ignored, @TargetPropertyName String propertyName) {
        if("country".equals(propertyName)) {
             return true; 
        }

        return false;
   }

   @Condition
   default <T> boolean shouldMapProperty(@MappingTarget PhoneDTO ignored, ignored @TargetPropertyName String propertyName) {       
        // This one is a bit more complicated. However, you might be able to solve it with some `@Context`
        if("number".equals(propertyName)) {
           return true; 
        }

        return false;
   }

 }

mirkoluchi Nov 27, 2023

Yes, but that solution is problematic when multiple targets exist with the same type. In that case there is no way to disambiguate the property, unless we somehow take into account the order of mapping statements which I would prefer not to do since it's internal stuff of the generated mapping code.
The only approach, in my opinion, is to provide - as I said - a more complete information about the property being mapped, for instance its path.

filiphr Dec 3, 2023
Maintainer

Providing the path is not as simple as you think. Having the structure your the example in mind let's take a look at the following mapper:

@Mapper
public interface MyMapper {

    ContactDTO map(ContactEntity contact);

    AddressDTO map(AddressEntity address);

    PhoneDTO map(PhoneEntity phone);
    
}

MapStruct is going to use the defined methods for mapping AddressEntity -> AddressDTO and PhoneEntity -> PhoneDTO. What would the TargetPropertyPath then be? For complex scenarios like this I would instead suggest that you use @Context and pass it to the mapping method. Then you can combine that with @BeforeMapping / @AfterMapping / @Conditional and compute the current parent.

Uh oh!

Enable run-time "filtering" based also on property name in @Conditional #2831

Uh oh!

Uh oh!

ivlcic Apr 27, 2022

Replies: 3 comments · 4 replies

Uh oh!

Zegveld Apr 28, 2022 Collaborator

Uh oh!

ivlcic Apr 28, 2022 Author

Uh oh!

filiphr May 30, 2022 Maintainer

Uh oh!

Uh oh!

mirkoluchi Nov 24, 2023

Uh oh!

filiphr Nov 26, 2023 Maintainer

Uh oh!

Uh oh!

mirkoluchi Nov 27, 2023

Uh oh!

filiphr Dec 3, 2023 Maintainer

ivlcic
Apr 27, 2022

Replies: 3 comments 4 replies

Zegveld
Apr 28, 2022
Collaborator

ivlcic
Apr 28, 2022
Author

filiphr May 30, 2022
Maintainer

mirkoluchi
Nov 24, 2023

filiphr Nov 26, 2023
Maintainer

filiphr Dec 3, 2023
Maintainer