Correct way to pass data to reactive Qute with reactive panache.

[CarlosPanarello]

I'm building an app using Qute with Panache both reactives.
My qute template has a list where I'm using #for stament to create the rows from the query result.
My repository is returning a Multi<Object> but when I try to pass this to Template data method, I get an error that is not an iterable object, I change it to return Uni<List<Object>> and it works, but is this best/correct way to pass data to Qute, using Uni<List> I'm not breaking the reactive way to link the result query with Template render ?

Example:

Model with some Repository methods

package org.acme.model;

import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import io.vertx.mutiny.pgclient.PgPool;
import io.vertx.mutiny.sqlclient.Row;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

public class Fruit {

    public Long id;

    public String name;

    public Fruit() {
    }

    public Fruit(String name) {
        this.name = name;
    }

    public Fruit(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    private static Fruit from(Row row) {
        return new Fruit(row.getLong("id"), row.getString("name"));
    }

    public static Multi<Fruit> findAllMulti(PgPool client) {
        return client.query("SELECT id, name FROM fruits ORDER BY name ASC").execute()
                .onItem().transformToMulti(set -> Multi.createFrom().iterable(set))
                .onItem().transform(Fruit::from);
    }

    public static Uni<List<Fruit>> findAllUni(PgPool client) {
        return client.query("SELECT id, name FROM fruits ORDER BY name ASC").execute()
                .onItem().transformToUni(set -> Uni.createFrom().item(StreamSupport.stream(set.spliterator(),false).collect(Collectors.toList())))
                .onItem().transform(list -> list.stream().map(Fruit::from).collect(Collectors.toList()));
    }
}

Resource

package org.acme.resource;

import io.quarkus.qute.Template;
import io.quarkus.qute.TemplateInstance;
import io.quarkus.runtime.StartupEvent;
import io.smallrye.mutiny.Multi;
import jakarta.enterprise.event.Observes;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.MediaType;
import org.acme.model.Fruit;
import org.eclipse.microprofile.config.inject.ConfigProperty;

import static java.util.Objects.requireNonNull;

@Path("/fruit")
public class FruitResource {

    @Inject
    io.vertx.mutiny.pgclient.PgPool client;

    @Inject
    @ConfigProperty(name = "myapp.schema.create", defaultValue = "true")
    boolean schemaCreate;


    @GET
    @Produces(MediaType.TEXT_HTML)
    public TemplateInstance get(@QueryParam("name") String name) {
        return fruit
                .data("name", name)
                 // this way work but this is ok to use?
                .data("listFruit", Fruit.findAllUni(client));
                //Using Multi but this is not a iterable object and breaks the render.
                //.data("listFruit", Fruit.findAllMulti(client));
    }

    private final Template fruit;

    public FruitResource(Template fruit) {
        this.fruit = requireNonNull(fruit, "fruit is required");
    }

    void config(@Observes StartupEvent ev) {
        if (schemaCreate) {
            initdb();
        }
    }

    private void initdb() {
        client.query("DROP TABLE IF EXISTS fruits").execute()
                .flatMap(r -> client.query("CREATE TABLE fruits (id SERIAL PRIMARY KEY, name TEXT NOT NULL)").execute())
                .flatMap(r -> client.query("INSERT INTO fruits (name) VALUES ('Orange')").execute())
                .flatMap(r -> client.query("INSERT INTO fruits (name) VALUES ('Pear')").execute())
                .flatMap(r -> client.query("INSERT INTO fruits (name) VALUES ('Apple')").execute())
                .flatMap(r -> client.query("INSERT INTO fruits (name) VALUES ('Banana')").execute())
                .await().indefinitely();
    }

    @GET
    @Path("reactive")
    @Produces(MediaType.APPLICATION_JSON)
    public Multi<Fruit> get() {
        return Fruit.findAllMulti(client);
    }

}

Template

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Hello {name ?: "Qute"}</title>
</head>
<body>
<h1>Hello <b>{name ?: "Fruit"}</b></h1>

<p>Fruit Example using Quarkus RESTEasy & Qute</p>

<ul>
    {#for i in listFruit}
    <li>{i.name}</li>
    {/for}
</ul>

</body>
</html>

Dependencies and using Quarkus 3.7.1

<dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-resteasy-reactive-qute</artifactId>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-resteasy-reactive-jackson</artifactId>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-hibernate-reactive-rest-data-panache</artifactId>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-reactive-pg-client</artifactId>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-arc</artifactId>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-resteasy-reactive</artifactId>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-junit5</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <scope>test</scope>
    </dependency>

[quarkus-bot[bot]]

/cc @FroMage (panache), @loicmathieu (panache), @mkouba (qute)

[fercomunello]

You're not breaking the reactive concept when returning an Uni<List>.

There's a reference in the documentation explaining exactly that: https://quarkus.io/guides/getting-started-reactive

Reactive developers may wonder why we can’t return a stream of fruits directly. It tends to be a bad idea when dealing with a database. Relational databases do not handle streaming well. It’s a problem of protocols not designed for this use case. So, to stream rows from the database, you need to keep a connection (and sometimes a transaction) open until all the rows are consumed. If you have slow consumers, you break the golden rule of databases: don’t hold connections for too long. Indeed, the number of connections is rather low, and having consumers keeping them for too long will dramatically reduce the concurrency of your application. So, when possible, use a Uni<List> and load the content. If you have a large set of results, implement pagination.

So when you retrieve a Multi on some JAX-RS endpoint and then take a look at the HTTP response you'll see something like this:

HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
transfer-encoding: chunked

And when returning Uni:

HTTP/1.1 200 OK
content-length: 98
Content-Type: application/json;charset=UTF-8

See? When you return a Multi, the response is chunked, therefore it is not returned all at once; instead, it returns the content in multiple parts. I am not sure when we should apply this chunked concept, perhaps when we need to return a large file in a non-blocking fashion or something like that...

A more common use case for Multi's would be in situations that you need to handle backpressure and emit a lot of events per second/ms.

Also, an equivalent approach of the Uni reponse would be:

@GET
@Produces(MediaType.TEXT_HTML)
public Uni<TemplateInstance> get(@QueryParam("name") String name) {
    return Uni.createFrom().item(
        this.fruit.instance()
            .data("name", name)
            .data("listFruit", findAllUni())
    );
}

public static Uni<List<Fruit>> findAll() {
    return this.client.query("SELECT id, name FROM fruits ORDER BY name ASC").execute()
        .onItem().transform(rows -> {
            List<Fruit> fruits = new ArrayList<>();
            RowIterator<Row> iterator = rows.iterator();
            do {
                Row row = iterator.next();
                fruits.add(Fruit.from(row));
            } while (iterator.hasNext());
            return fruits;
        })
    ;
}

[mkouba]

Using Uni<List<Fruit>> is just fine. However, keep in mind that whenever Qute evaluates a Uni, in your example it's exactly once in the {#for i in listFruit}, it needs to subsribe to this Uni. So in your case, every evaluation results in a new query. You might need to configure the memoization of the Uni item/failure before it’s used as template data, i.e. myUni.memoize().indefinitely() - this way a subscription does not result in a new query since the result is "cached".

More details can be found in the docs.