In Spring WebFlux, How to chaining methods from multiple services/repo, in order to 'delete' elements in multiples DB-Collections'?

Question

1) Contextualization about the problem:

I am trying 'delete' items in 03 different DB-Collections(Reactive MongoDB), using 03 different services/repo (userService + postService + userRepo);

My Goal is DELETE an object (in each collection) simultaneously, using the same chaining-code;

Below is the code for the above situation:

1.1) Code:

Current working status: not working;

Current behaviour: not executes any delete, weither delete-userService, delete-postService, or delete-userRepo.

@Slf4j
@Service
@AllArgsConstructor
public class UserService implements UserServiceInt {

  private final UserRepo userRepo;

  private final PostServiceInt postServ;

  private final CommentServiceInt comServ;

  private final CustomExceptions customExceptions;

  @Override
  public Mono<Void> deleteInThreeCollections(String id) {
    return userRepo
           .findById(id)
           .switchIfEmpty(customExceptions.userNotFoundException())
           
           .map(user -> {
             userRepo.delete(user); // First deletion - delete-method from userRepo
             return user;
           })

           .flatMapMany(user -> postServ.findPostsByAuthorId(user.getId()))
           .map(post -> {
             postServ.delete(post); // Second deletion - delete-method from postService
             return post;
           })

           .flatMap(post -> comServ.findCommentsByPostId(post.getPostId()))
           .map(comServ::delete) // Third deletion - delete-method from commentService
           .then()
           ;
  }
}

---

2) Question:

• How Can I delete different elements in different DB-Collections,
  • by using only ONE ‘chained delete method’ that uses THREE ‘delete methods’ from
    • THREE different services/repo (userService + postService + userRepo?

---

3) Updating:

Solution Found

@Override
 public Mono<Void> deleteInThreeCollections(String id) {
  return userRepo
         .findById(id)
         .switchIfEmpty(customExceptions.userNotFoundException())
         .flatMap(
                user -> postServ
                       .findPostsByAuthorId(user.getId())
                       .flatMap(
                              post -> comServ.findCommentsByPostId(
                                     post.getPostId())
                                             .flatMap(comServ::delete)
                                             .thenMany(
                                                    postServ.findPostsByAuthorId(
                                                           post.getAuthor()
                                                               .getId()))
                                             .flatMap(postServ::delete)
                               )
                       .then(userRepo.delete(user))
                 );
 }

Thanks a lot for any help

Answer 1

Suppose your someclass.delete() operations return with Mono<Something>.

The main problem is map won't subscribe to the inner publisher.

Here you have to use flatMap/concatMap... operations, they will subscribe to the inner publishers (eg xyz.delete)

If your delete method does not return with the deleted item, you can use then(object) to return with the given parameter.

As I see, you cannot do all deletes simultaneously but sequentially, because every operations input parameter is the output of the previous one. If you think about batching all posts or comments.. delete simultaneously, that is possible. You can collectList the id-s and create a batch operation (deleteByIdIn(list of ids)) or create a parallel flux and run simultaneously the delete operations (batch is better).

Here I'v created a minimal example with fake services to demonstrate it:

import org.junit.jupiter.api.Test
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import reactor.test.StepVerifier

data class User(
    val id: String
)

data class Post(
    val id: String
)

data class Comment(
    val id: String
)

class UserRepo {

    fun finById(id: String): Mono<User> {
        println("Find an user")
        return Mono.just(User("1"))
    }

    //example if delete gives back the object
    fun delete(user: User): Mono<User> {
        println("delete $user")
        return Mono.just(user)
    }

}

class PostServiceInt {

    fun findPostsByAuthorId(userId: String): Flux<Post> = Flux.fromIterable(listOf(Post("1"), Post("2")))

    //and if not
    fun delete(post: Post): Mono<Void> {
        println("delete $post")
        return Mono.empty()
    }

}


class CommentServiceInt {

    fun findCommentsByPostId(postId: String): Flux<Comment> = Flux.fromIterable(listOf(Comment("10"), Comment("7"),Comment("3"),Comment("4")))

    fun delete(comment: Comment): Mono<Comment> {
        println("delete $comment")
        return Mono.just(comment)
    }

}


class Example {

    val userRepo = UserRepo()
    val postServ = PostServiceInt()
    val comServ = CommentServiceInt()

    @Test
    fun test() {
        val result = userRepo.finById("1")
            .switchIfEmpty(Mono.error { RuntimeException() })
            .flatMap { user -> userRepo.delete(user) }
            .flatMapMany { user -> postServ.findPostsByAuthorId(user.id) }
            .flatMap { post -> postServ.delete(post).then(Mono.just(post)) }
            .flatMap { post -> comServ.findCommentsByPostId(post.id) }
            .flatMap { comment -> comServ.delete(comment) }

        StepVerifier.create(result)
            .expectNextCount(4)
            .verifyComplete()


    }
    
}