Spring data-rest: set null value by PATCH request

All 3 options from egorlitvinenko's answer will solve the described problem but will have another one:

• All other properties which were not specified in PATCH request would be "nullified" too.

Seems like spring-data-rest, issue-345 was already fixed in v2.2.x.

It is possible to achieve that using Map<String,Object> as a request body a then you can extract data using forEach on map.

Example Controller:

@PatchMapping("api/entity/{entityId}")
ResponseEntity<EntityDto> modifyEntity(@PathVariable UUID entityId,
        @RequestBody Map<String, Object> modifyEntityData) {

    EntityDto modifiedEntity = entityService
            .modifyEntity(entityId, modifyEntityData);

    return ResponseEntity
            .status(HttpStatus.OK)
            .body(modifiedEntity );
}

Example Service:

@Transactional
public EntityDto modifyEntity(UUID entityId, Map<String, Object> modifyEntityData) {

    // I assume you have a method that returns Entity by its Id in service
    Entity entityToModify = findEntity(entityId);

    entityToModify = applyChangesToEntity(entityToModify, modifyEntityData);

    // And mapper that returns dto (ofc optional)
    return EntityMapper.mapEntityToDto(entityToModify);
}

private EntityDto applyChangesToEntity(Entity exisistingEntity, 
                                       Map<String, Object> modifyEntityData) {

    modifyEntityData.forEach((key, value) -> {
        switch (key) {
            case "deleteDate" -> {
                // Check if null
                if (value == null) {
                    exisistingEntity.setDeleteDate(null);
                    break;
                }

                // If value is present you can do w/e you want 
                if (validateValueOk(value)) {
                    exisistingEntity.setDeleteDate(value.toString());
                } else {
                    throw new RuntimeException("DeleteDate must be valid or other message");
                }
            }
            // HERE MORE CASES
            default -> throw new RuntimeException("Message");
        }
    });

    return exisistingEntity;
}

As an alternative to Łukasz Mączka's solution, if you want to still receive an instance of Foo in your Controller, you can create a Deserializer class, using reflection for a generic approach.

import com.fasterxml.jackson.databind.JsonDeserializer;

public class FooDeserializer extends JsonDeserializer<Foo> {

  @Autowired
  private FooService service; 
  
  @Override
  public Foo deserialize(JsonParser p, DeserializationContext ctxt) {
    ObjectMapper objectMapper = (ObjectMapper) p.getCodec();
    JsonNode patchNode = objectMapper.readTree(p);

    // If editting, start with entity stored on db, otherwise create a new one
    Long id = extractEntityIdFromPathVariable();
    Foo instance = id!=null ? service.findById(id) : new Foo();
    if (instance==null) throw new EntityNotFoundException();

    // For every field sent in the payload... (fields not sent are not considered)
    patchNode.fields().forEachRemaining(entry -> {
      String fieldName = entry.getKey();
      JsonNode valueNode = entry.getValue();

      Field f = Foo.class.getDeclaredField(fieldName);

      if (valueNode instanceof NullNode) { // If value of field in the payload is null, set it to null in the instance
        // THIS IS THE SOLUTION TO YOUR PROBLEM :)
        f.set(instance, (Object)null);
      } else { // Otherwise, map it to the correspondant type and set it in the instance
        f.set(instance, new ObjectMapper().treeToValue(valueNode, f.getType()));
      }
    });
    return foo;
  }

  private Long extractEntityIdFromPathVariable() {
    // Extract the entity ID from the URL path variable
    String pathInfo = request.getRequestURI();
    if (pathInfo != null) {
      String[] pathSegments = pathInfo.split("/");   
      if (pathSegments.length > 1) {
        try {
          return Long.parseLong(pathSegments[pathSegments.length-1]);
        } catch (NumberFormatException e) {
          // Handle the case where the path variable is not a valid I
        }
      }
    }
    // Handle the case where the ID is not found in the path
    return null;
  }

}

There are some exceptions you need to handle here. I did not include them to simplify the code.

Then, define it as the default serializer in your Foo class:

import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

@JsonDeserialize(using = FooDeserializer.class)
public class Foo {
  protected Date deleteDate;
  ...
}

Make sure the fields you are editing are public or protected (in the last, the model and the deserializer classes must be in the same package). Otherwise the set won't work.

As an alternative, you can get the java.lang.reflect.Method through Foo.class.getMethod(), using String.format() to merge fieldName with the method name (probably prepending "set" to it).

Finally, in your controller method you just have to call the save method on the repository, as the deserializer is called before the controller method and so the argument you get there already has the "cleaned" version. :)

public FooController {
  @PatchMapping("{id}")
  public Foo fooEdit(@RequestBody Foo foo) {
    return fooRepository.save(foo);
  }
}