Issue with Determining Insert or Update Operation in Morphia EntityInterceptor

[PLin2023]

I'm trying to add automatic filling functionality to the entity class. Here's how you can use it:

@AutoFill(strategy = AutoFill.Strategy.Insert)
private LocalDateTime createdAt;

The following is the main code implementing the EntityInterceptor interface:

public class EnhanceProcessor implements EntityInterceptor {

    @Override
    public void prePersist(Object ent, Document document, Datastore datastore) {
        process(ent);
    }

    private void process(Object entity) {
        Class<?> entityClass = entity.getClass();
        Field[] fields = entityClass.getDeclaredFields();
        boolean isInsert = isInsert(entity);
        for (Field field : fields) {
            if (field.isAnnotationPresent(AutoFill.class)) {
                field.setAccessible(true);
                AutoFill annotation = field.getAnnotation(AutoFill.class);
                AutoFill.Strategy[] annotationStrategies = annotation.strategy();
                for (AutoFill.Strategy annotationStrategy : annotationStrategies) {
                    if ((annotationStrategy == AutoFill.Strategy.Insert && isInsert) ||
                            (annotationStrategy == AutoFill.Strategy.Update && !isInsert) ||
                            annotationStrategy == AutoFill.Strategy.InsertAndUpdate) {
                        try {
                            if (field.getType() == LocalDateTime.class) {
                                field.set(entity, LocalDateTime.now());
                            }
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    private boolean isInsert(Object entity) {
        Class<?> entityClass = entity.getClass();
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Id.class)) {
                field.setAccessible(true);
                try {
                    Object idValue = field.get(entity);
                    return idValue == null;
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }
}

As mentioned above, I encountered an issue where isInsert always returns false. During my debugging process, I discovered that Morphia always assigns values to properties annotated with @Id before prePersist, which makes it impossible for me to determine whether the current operation is an insert or update based on the id's nullability. Additionally, I haven't found any method that can provide the current operation type, which makes it difficult for me to extend the framework.

Could you please let me know if there is a solution to this problem? Thank you very much for your assistance!

Server Version: "6.3.1"
Driver Version: "4.6.1"
Morphia Version: "2.3.2"

[evanchooly]

Off the top of my head, the easiest way would be to version your entity and check that the version is 1 (I think. that order is a bit fuzzy and i don't have that code in front of me right now.) Any other value would indicate that it's an update and not the initial insert.

[PLin2023]

Thank you very much for your response. According to your suggestion, I should introduce a version field in the entity to identify the current version of the entity. Based on my understanding, it should be in the following form:

@AutoFill(strategy = AutoFill.Strategy.InsertAndUpdate)
private LocalDateTime updatedAt;
// Introduce the "version" field here.
private Integer version;

However, this approach would require me to manually add a version field to each class. If I want to use @AutoFill, maybe inheritance can work, but it still requires introducing additional content that was not necessary before.

So, I came up with the following solution. Just like using _t to indicate the current class of the entity, I can also use _v to indicate the current version number and increment it during each prePersist operation. However, I quickly realized that this is not feasible because retrieving _t would mean making another request to MongoDB.

public @interface AutoFill {
    // ...Omitting other code.
    String discriminatorKey() default "_v";
}

private boolean isInsert(Object entity) {
        // Connect to MongoDB and retrieve the entity corresponding to the current objectId. If it is null, it indicates that the current entity is an insert.
        // If we additionally connect to MongoDB here, the _t field will not be utilized at all, but this clearly leads to a performance decrease.
        // The following is pseudocode.
       Object ent = getEntityById(entity.id) 
       return null == ent;
}

As mentioned above, this approach is clearly not an optimal solution.
Currently, I haven't found a suitable solution to determine whether the current operation is an insert without explicitly introducing additional fields.
As a temporary alternative, I am using the following approach, which can be found on GitHub at the following link: messenger-backend
@AutoFill

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface AutoFill {
    Strategy[] strategy() default {Strategy.Insert};

    enum Strategy {
        Insert, Update, InsertAndUpdate
    }

    String versionKey() default "version";
}

public class EnhanceProcessor implements EntityInterceptor {

    @Override
    public void prePersist(Object ent, Document document, Datastore datastore) {
        process(ent);
    }

    private void process(Object entity) {
        Class<?> entityClass = entity.getClass();
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(NotNull.class)) {
                field.setAccessible(true);
                try {
                    Object value = field.get(entity);
                    if (value == null) {
                        throw new FieldNotNullableException(field.getName());
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
  
            if (field.isAnnotationPresent(AutoFill.class)) {
                field.setAccessible(true);
                AutoFill annotation = field.getAnnotation(AutoFill.class);

                boolean isInsert = isInsert(entity, entityClass, annotation);
                AutoFill.Strategy[] annotationStrategies = annotation.strategy();

                for (AutoFill.Strategy annotationStrategy : annotationStrategies) {
                    if ((annotationStrategy == AutoFill.Strategy.Insert && isInsert) ||
                            (annotationStrategy == AutoFill.Strategy.Update && !isInsert) ||
                            annotationStrategy == AutoFill.Strategy.InsertAndUpdate) {
                        try {
                            if (field.getType() == LocalDateTime.class) {
                                field.set(entity, LocalDateTime.now());
                            }

                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    private static boolean isInsert(Object entity, Class<?> entityClass, AutoFill annotation) {
        String versionKey = annotation.versionKey();
        Field versionField;
        long version = 0;
        try {
            versionField = entityClass.getDeclaredField(versionKey);
            versionField.setAccessible(true);

            boolean isVersionLock = versionField.getAnnotation(Version.class) != null;
            Class<?> type = null;

            type = versionField.getType();
            if (type != Integer.class && type != int.class && type != Long.class && type != long.class) {
                throw new RuntimeException("version field must be Integer, int, Long or long");
            }
            switch (type.getSimpleName()) {
                case "Integer" -> {
                    Object o = versionField.get(entity);
                    if (o != null) {
                        version = (Integer) o;
                    }
                }
                case "int" -> version = versionField.getInt(entity);
                case "Long" -> {
                    Object o = versionField.get(entity);
                    if (o != null) {
                        version = (Long) o;
                    }
                }
                case "long" -> version = versionField.getLong(entity);
            }

            if (version == 0 && !isVersionLock) {
                switch (Objects.requireNonNull(type).getSimpleName()) {
                    case "Integer", "Long" -> versionField.set(entity, 1);
                    case "int" -> versionField.setInt(entity, 1);
                    case "long" -> versionField.setLong(entity, 1);
                }
                return true;
            }

            if (version == 1 && isVersionLock) {
                return true;
            }
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return false;
    }
}

However, in the process, I encountered a strange issue. In the following test (com.mjl.messenger.entity.UserTests), I set an email that does not exist in the database (the email field has a unique index type), and the data is successfully inserted. However, the test fails and throws an error stating that the email already exists in the database. Interestingly, when I move the save code to the controller (com.mjl.messenger.api.auth.AuthController), this issue does not occur at all.

@RunWith(org.springframework.test.context.junit4.SpringRunner.class)
@SpringBootTest(classes = MessengerApplication.class)
public class UserTests {

    @Autowired
    private Datastore datastore;

    @Test
    public void testInsert() {
        User user = User.builder()
                .name("PLin202311")
                .email("grontylion11@foxmail.com")
                .hashedPassword("123456")
                .build();
        System.out.println(datastore.save(user));
    }
}

[PLin2023]

Checking the option below can resolve the issue of Test being executed repeatedly.
Must check the top option(Delegate IDE build/run) actions to Maven!

[evanchooly]

I was actually referring to using Morphia's built-in versioning to manage those values for you. It will always be a Long and you can simply check that it equals 1 for an insert.

[PLin2023]

I got it. Thank you very much for your response.