Quarkus - Neo4j

docker run --publish=7474:7474 --publish=7687:7687 -e 'NEO4J_AUTH=neo4j/secret' neo4j:4.0.0

public static Fruit from(Node node) {
    return new Fruit(node.id(), node.get("name").asString());
}

package org.acme.neo4j;

import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import org.neo4j.driver.Driver;

@Path("fruits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class FruitResource {

    @Inject
    Driver driver;
}

@GET
public CompletionStage<Response> get() {
    AsyncSession session = driver.asyncSession(); (1)
    return session
        .runAsync("MATCH (f:Fruit) RETURN f ORDER BY f.name")  (2)
        .thenCompose(cursor ->  (3)
            cursor.listAsync(record -> Fruit.from(record.get("f").asNode()))
        )
        .thenCompose(fruits ->  (4)
            session.closeAsync().thenApply(signal -> fruits)
        )
        .thenApply(Response::ok) (5)
        .thenApply(ResponseBuilder::build);
}

./mvnw compile quarkus:dev

curl localhost:8080/fruits

@POST
public CompletionStage<Response> create(Fruit fruit) {
    AsyncSession session = driver.asyncSession();
    return session
        .writeTransactionAsync(tx -> tx
            .runAsync("CREATE (f:Fruit {name: $name}) RETURN f", Values.parameters("name", fruit.name))
            .thenCompose(fn -> fn.singleAsync())
        )
        .thenApply(record -> Fruit.from(record.get("f").asNode()))
        .thenCompose(persistedFruit -> session.closeAsync().thenApply(signal -> persistedFruit))
        .thenApply(persistedFruit -> Response
            .created(URI.create("/fruits/" + persistedFruit.id))
            .build()
        );
}

curl -v -X "POST" "http://localhost:8080/fruits" \
     -H 'Content-Type: application/json; charset=utf-8' \
     -d $'{
  "name": "Banana"
}'

@GET
@Path("{id}")
public CompletionStage<Response> getSingle(@PathParam("id") Long id) {
    AsyncSession session = driver.asyncSession();
    return session
        .readTransactionAsync(tx -> tx
            .runAsync("MATCH (f:Fruit) WHERE id(f) = $id RETURN f", Values.parameters("id", id))
            .thenCompose(fn -> fn.singleAsync())
    )
    .handle((record, exception) -> {
        if(exception != null) {
            Throwable source = exception;
            if(exception instanceof CompletionException) {
                source = ((CompletionException)exception).getCause();
            }
            Status status = Status.INTERNAL_SERVER_ERROR;
            if(source instanceof NoSuchRecordException) {
                status = Status.NOT_FOUND;
            }
            return Response.status(status).build();
        } else  {
            return Response.ok(Fruit.from(record.get("f").asNode())).build();
        }
    })
    .thenCompose(response -> session.closeAsync().thenApply(signal -> response));
}

curl localhost:8080/fruits/42

@DELETE
@Path("{id}")
public CompletionStage<Response> delete(@PathParam("id") Long id) {

    AsyncSession session = driver.asyncSession();
    return session
        .writeTransactionAsync(tx -> tx
            .runAsync("MATCH (f:Fruit) WHERE id(f) = $id DELETE f", Values.parameters("id", id))
            .thenCompose(fn -> fn.consumeAsync()) (1)
        )
        .thenCompose(response -> session.closeAsync())
        .thenApply(signal -> Response.noContent().build());
}

curl -X DELETE localhost:8080/fruits/42

<dependencies>
    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-resteasy-mutiny</artifactId>
    </dependency>
</dependencies>

package org.acme.neo4j;

import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import org.neo4j.driver.Driver;
import org.neo4j.driver.reactive.RxResult;
import org.reactivestreams.Publisher;


@Path("reactivefruits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class ReactiveFruitResource {

    @Inject
    Driver driver;

    @GET
    @Produces(MediaType.SERVER_SENT_EVENTS)
    public Publisher<String> get() {
        // Create a stream from a resource we can close in a finalizer:
        return Multi.createFrom().resource(driver::rxSession,
                session -> session.readTransaction(tx -> {
                    RxResult result = tx.run("MATCH (f:Fruit) RETURN f.name as name ORDER BY f.name");
                    return Multi.createFrom().publisher(result.records())
                            .map(record -> record.get("name").asString());
                })
        ).withFinalizer(session -> {
            return Uni.createFrom().publisher(session.close());
        });
    }
}