How to convert Mono<Recipe> to Recipe without using block?

I am new to webflux and I am having a tough time converting the Mono to my Recipe without using block. I tried using flatmap and subscribe, but i couldn't get it to work.

@Override
    public Mono<Void> deleteById(String recipeId, String idToDelete) {

        log.debug("Deleting ingredient: " + recipeId + ":" + idToDelete);

        Recipe recipe = recipeReactiveRepository.findById(recipeId).block();

        if(recipe != null){
            log.debug("found recipe");

            Optional<Ingredient> ingredientOptional = recipe
                    .getIngredients()
                    .stream()
                    .filter(ingredient -> ingredient.getId().equals(idToDelete))
                    .findFirst();

            if(ingredientOptional.isPresent()){
                log.debug("found Ingredient");
                Ingredient ingredientToDelete = ingredientOptional.get();
                recipe.getIngredients().remove(ingredientOptional.get());
                recipeReactiveRepository.save(recipe);
            }
        } else {
            log.debug("Recipe Id Not found. Id:" + recipeId);
        }
        return Mono.empty();
    }

you should read up on the basics of reactive programming, just adding a Mono.empty() at the bottom doesnt make it reactive. Reactive means that you let the reactor establish a reactive chain of functions, so that the system, can itself switch threads when it needs to so that nothing is idleing.

You should never block in a reactive application. This will slow down your application and you could potentially end up with very bad performance.

So this is not allowed and should not be done.

Recipe recipe = recipeReactiveRepository.findById(recipeId).block();

So how should you do it, well you should declare a chain of functions to be performed on the returned Producer (Mono or Flux)

Here is one example of how it could be done.

return recipeReactiveRepository.findById(recipeId).flatMap(recepie -> {
    // here you will do your logic and return a Flux/Mono of something.
};

You are trying to write imperative code using a reactive library. For example, null is not allowed in Producers (monos and fluxes), so doing null checks is redundant is most cases.

Also reactive programming uses mostly pure functions so void functions or not chaining on return statements will break your code.

// Here you are just ignoring the return from the save, this will break the reactive chain and not be executed.
recipeReactiveRepository.save(recipe);

So you will always have to take care of you returns. On the other hand if you want to say ignore the return and return empty you can use the then operator.

So for example:

return recipeReactiveRepository.findById(recipeId).flatMap(recipe -> {

    // do things here then save and return

    return recipeReactiveRepository.save(updatedRecipe);

// Mono#then will make sure the return from recipeReactiveRepository#save
// is dropped, and will return a Mono#empty instead

}.then();   

If you want to learn reactive programming i highly encourage you to read the "getting started" section in the Reactor documentation.

Reactor Getting Started

So you understand the basic concepts, how it is written, because it is different from regular "standard" programming.