public interface IBaseRepository<TEntity, TFilter> {
    CompletableFuture<List<TEntity>> getRange(@NotNull TFilter filter);
    CompletableFuture<TEntity> getItem(@NotNull Object id);
    TEntity getItemReference(@NotNull Object id);
    CompletableFuture<List<TEntity>> getAll(@NotNull TFilter filter);
    CompletableFuture<Long> count(@NotNull TFilter filter);
    CompletableFuture<Void> update(@NotNull TEntity entity);
    CompletableFuture<Void> add(@NotNull TEntity entity);
    CompletableFuture<Void> remove(@NotNull TEntity entity);
    CompletableFuture<Void> update(@NotNull List<TEntity> items);
    CompletableFuture<List<TEntity>> add(@NotNull List<TEntity> items);
    CompletableFuture<Void> remove(@NotNull List<TEntity> items);
}

    @Override
    public CompletableFuture<Void> add(@NotNull TEntity entity) {
        return CompletableFuture.runAsync(() -> {
            EntityManager entityManager = factory.createEntityManager();
            try {
                EntityTransaction transaction = entityManager.getTransaction();
                try {
                    transaction.begin();
                    entityManager.persist(entity);
                    transaction.commit();
                } catch (Exception ex) {
                    transaction.rollback();
                    throw ex;
                }
            } catch (Exception ex) {
                LOGGER.error(this.getClass().getName() + " add item error ", ex);
                throw ex;
            } finally {
                entityManager.close();
            }
        }, executor);
    }

class Synchronous {
    // I/0 operations: blocking, synchronous
    <T> T fetchFromDb(Class<T> entityClass, long id) { return null; }
    String sendHttpGet(String url) { return null; }
    void sendEmail(String to, String content) { }

    // the business logic: synchronous
    void runBusinessProcess() {
        User user = fetchFromDb(User.class, 42);
        String profile = sendHttpGet(
            "http://profile_service/get/" + user.getProfileId());
        sendEmail(user.getEmail(), "Your profile is: " + profile);
    }
}

class Wrappers {
    // I/O operations: non-blocking, asynchronous
    <T> CompletableFuture<T> fetchFromDb(Class<T> entityClass, long id) { return null; }
    CompletableFuture<String> sendHttpGet(String url) { return null; }
    CompletableFuture<Void> sendEmail(String to, String content) { return null; }

    // the bussines logic: asynchronous
    CompletableFuture<Void> runBusinessProcess() {
        // thenCompose: also known as flatMap, combines two futures
        return fetchFromDb(User.class, 42).thenCompose(user -> {
            // storing the intermediate result in variables
            CompletableFuture<String> httpResult = 
              sendHttpGet("http://profile_service/get/" + user.getProfileId());
              
            return httpResult.thenCompose(profile ->
                    sendEmail(user.getEmail(), "Your profile is: " + profile));
        });
    }
}

return CompletableFuture.runAsync(() -> {
...
 }, executor);

        CompletableFuture task1 = callService1(context);
        CompletableFuture task2 = callService2(context);

        return CompletableFuture
            .allOf(task1, task2)
            .thenCompose(nop -> callService3(context))
            .thenApply(nop -> callService4(context)).getResult());