Hibernate reactive example functional

Author: velo

querydsl-examples/querydsl-example-hibernate-reactive-quarkus/pom.xml

@@ -24,6 +24,12 @@
   </dependencyManagement>
 
   <dependencies>
+    <dependency>
+      <groupId>io.github.openfeign.querydsl</groupId>
+      <artifactId>querydsl-hibernate-reactive</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+
     <dependency>
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-hibernate-reactive</artifactId>
@@ -59,11 +65,27 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
+          <annotationProcessorPaths>
+            <annotationProcessorPath>
+              <groupId>io.github.openfeign.querydsl</groupId>
+              <artifactId>querydsl-apt</artifactId>
+              <version>${project.version}</version>
+              <classifier>jpa</classifier>
+            </annotationProcessorPath>
+          </annotationProcessorPaths>
 
           <!-- the parameters=true option is critical so that RESTEasy works fine -->
           <parameters>true</parameters>
         </configuration>
+        <dependencies>
+          <dependency>
+            <groupId>io.github.openfeign.querydsl</groupId>
+            <artifactId>querydsl-apt</artifactId>
+            <version>${project.version}</version>
+          </dependency>
+        </dependencies>
       </plugin>
+
       <plugin>
         <!-- you need this specific version to integrate with the other build helpers -->
         <artifactId>maven-surefire-plugin</artifactId>

querydsl-examples/querydsl-example-hibernate-reactive-quarkus/src/main/java/com/querydsl/example/reactive/FruitsRoutes.java

@@ -6,6 +6,7 @@
 import static io.quarkus.vertx.web.Route.HttpMethod.POST;
 import static io.quarkus.vertx.web.Route.HttpMethod.PUT;
 
+import com.querydsl.jpa.hibernate.MutinyQueryFactory;
 import io.quarkus.vertx.web.Body;
 import io.quarkus.vertx.web.Param;
 import io.quarkus.vertx.web.Route;
@@ -26,17 +27,25 @@ public class FruitsRoutes {
 
   private static final Logger LOGGER = Logger.getLogger(FruitsRoutes.class.getName());
 
-  @Inject Mutiny.SessionFactory sf;
+  private final Mutiny.SessionFactory sf;
+  private final MutinyQueryFactory qf;
+
+  @Inject
+  public FruitsRoutes(Mutiny.SessionFactory sf) {
+    this.sf = sf;
+    qf = new MutinyQueryFactory(sf);
+  }
+
+  private static final QFruit f = new QFruit("f");
 
   @Route(methods = GET, path = "/")
   public Uni<List<Fruit>> getAll() {
-    return sf.withSession(
-        session -> session.createNamedQuery(Fruit.FIND_ALL, Fruit.class).getResultList());
+    return qf.withQuery(query -> query.select(f).from(f).orderBy(f.name.asc()).fetch());
   }
 
   @Route(methods = GET, path = "/:id")
   public Uni<Fruit> getSingle(@Param Integer id) {
-    return sf.withSession(session -> session.find(Fruit.class, id));
+    return qf.withQuery(query -> query.select(f).from(f).where(f.id.eq(id)).fetchOne());
   }
 
   @Route(methods = POST, path = "/")
@@ -56,32 +65,18 @@ public Uni<Fruit> update(@Body Fruit fruit, @Param Integer id) {
       return Uni.createFrom()
           .failure(new IllegalArgumentException("Fruit name was not set on request."));
     }
-    return sf.withTransaction(
-            (session, tx) ->
-                session
-                    .find(Fruit.class, id)
-                    // If entity exists then update it
-                    .onItem()
-                    .ifNotNull()
-                    .invoke(entity -> entity.setName(fruit.getName())))
-        // If entity not found, fail
+    return qf.withUpdate(
+            f, update -> update.where(f.id.eq(id)).set(f.name, fruit.getName()).execute())
         .onItem()
         .ifNull()
-        .fail();
+        .fail()
+        .flatMap(a -> qf.withSelectFrom(f, select -> select.where(f.id.eq(id)).fetchOne()));
   }
 
   @Route(methods = DELETE, path = "/:id")
-  public Uni<Fruit> delete(@Param Integer id, HttpServerResponse response) {
-    return sf.withTransaction(
-            (session, tx) ->
-                session
-                    .find(Fruit.class, id)
-                    // If entity exists then delete it
-                    .onItem()
-                    .ifNotNull()
-                    .call(
-                        entity -> session.remove(entity).invoke(() -> response.setStatusCode(204))))
-        // If entity not found, fail
+  public Uni<Integer> delete(@Param Integer id, HttpServerResponse response) {
+    return qf.withDelete(f, delete -> delete.where(f.id.eq(id)).execute())
+        .invoke(() -> response.setStatusCode(204))
         .onItem()
         .ifNull()
         .fail();

querydsl-libraries/querydsl-core/pom.xml

@@ -27,6 +27,12 @@
       <groupId>io.projectreactor</groupId>
       <artifactId>reactor-core</artifactId>
     </dependency>
+    <dependency>
+      <groupId>io.smallrye.reactive</groupId>
+      <artifactId>mutiny</artifactId>
+      <version>2.6.0</version>
+      <optional>true</optional>
+    </dependency>
 
     <!-- alias dependencies -->
     <dependency>

querydsl-libraries/querydsl-core/src/main/java/com/querydsl/core/dml/mutiny/MutinyDMLClause.java

@@ -0,0 +1,18 @@
+package com.querydsl.core.dml.mutiny;
+
+import io.smallrye.mutiny.Uni;
+
+/**
+ * Parent interface for DML clauses
+ *
+ * @param <C> concrete subtype
+ */
+public interface MutinyDMLClause<C extends MutinyDMLClause<C>> {
+
+  /**
+   * Execute the clause and return the amount of affected rows
+   *
+   * @return amount of affected rows or empty if not available
+   */
+  Uni<Integer> execute();
+}

querydsl-libraries/querydsl-core/src/main/java/com/querydsl/core/dml/mutiny/MutinyDeleteClause.java

@@ -0,0 +1,11 @@
+package com.querydsl.core.dml.mutiny;
+
+import com.querydsl.core.FilteredClause;
+
+/**
+ * {@code ReactiveDeleteClause} defines a generic interface for Delete clauses
+ *
+ * @param <C> concrete subtype
+ */
+public interface MutinyDeleteClause<C extends MutinyDeleteClause<C>>
+    extends MutinyDMLClause<C>, FilteredClause<C> {}

querydsl-libraries/querydsl-core/src/main/java/com/querydsl/core/dml/mutiny/MutinyFetchable.java

@@ -0,0 +1,42 @@
+package com.querydsl.core.dml.mutiny;
+
+import com.querydsl.core.Query;
+import io.smallrye.mutiny.Uni;
+import java.util.List;
+
+/**
+ * {@code MutinyFetchable} defines default projection methods for {@link Query} implementations. All
+ * Querydsl query implementations should implement this interface.
+ *
+ * @param <T> result type
+ */
+public interface MutinyFetchable<T> {
+
+  /**
+   * Get the projection as a typed Flux.
+   *
+   * @return result
+   */
+  Uni<List<T>> fetch();
+
+  /**
+   * Get the first result of the projection.
+   *
+   * @return first result
+   */
+  Uni<T> fetchFirst();
+
+  /**
+   * Get the projection as a unique result.
+   *
+   * @return first result
+   */
+  Uni<T> fetchOne();
+
+  /**
+   * Get the count of matched elements
+   *
+   * @return row count
+   */
+  Uni<Long> fetchCount();
+}

querydsl-libraries/querydsl-core/src/main/java/com/querydsl/core/dml/mutiny/MutinyFetchableQuery.java

@@ -0,0 +1,45 @@
+package com.querydsl.core.dml.mutiny;
+
+import com.querydsl.core.ResultTransformer;
+import com.querydsl.core.SimpleQuery;
+import com.querydsl.core.Tuple;
+import com.querydsl.core.types.Expression;
+import org.reactivestreams.Publisher;
+
+/**
+ * {@code FetchableQuery} extends {@link MutinyFetchable} and {@link SimpleQuery} with projection
+ * changing methods and result aggregation functionality using {@link ResultTransformer} instances.
+ *
+ * @param <T> element type
+ * @param <Q> concrete subtype
+ */
+public interface MutinyFetchableQuery<T, Q extends MutinyFetchableQuery<T, Q>>
+    extends SimpleQuery<Q>, MutinyFetchable<T> {
+
+  /**
+   * Change the projection of this query
+   *
+   * @param <U>
+   * @param expr new projection
+   * @return the current object
+   */
+  <U> MutinyFetchableQuery<U, ?> select(Expression<U> expr);
+
+  /**
+   * Change the projection of this query
+   *
+   * @param exprs new projection
+   * @return the current object
+   */
+  MutinyFetchableQuery<Tuple, ?> select(Expression<?>... exprs);
+
+  /**
+   * Apply the given transformer to this {@code ReactiveFetchableQuery} instance and return the
+   * results
+   *
+   * @param <S>
+   * @param transformer result transformer
+   * @return transformed result
+   */
+  <S> Publisher<S> transform(MutinyResultTransformer<S> transformer);
+}

querydsl-libraries/querydsl-core/src/main/java/com/querydsl/core/dml/mutiny/MutinyFetchableQueryBase.java

@@ -0,0 +1,36 @@
+package com.querydsl.core.dml.mutiny;
+
+import com.querydsl.core.support.QueryBase;
+import com.querydsl.core.support.QueryMixin;
+import com.querydsl.core.types.SubQueryExpression;
+import org.reactivestreams.Publisher;
+
+/**
+ * {@code FetchableQueryBase} extends the {@link QueryBase} class to provide default implementations
+ * of the methods of the {@link com.querydsl.core.dml.reactive.ReactiveFetchable} interface
+ *
+ * @param <T> result type
+ * @param <Q> concrete subtype
+ */
+public abstract class MutinyFetchableQueryBase<T, Q extends MutinyFetchableQueryBase<T, Q>>
+    extends QueryBase<Q> implements MutinyFetchable<T> {
+
+  public MutinyFetchableQueryBase(QueryMixin<Q> queryMixin) {
+    super(queryMixin);
+  }
+
+  public <T> Publisher<T> transform(MutinyResultTransformer<T> transformer) {
+    return transformer.transform((MutinyFetchableQuery<?, ?>) this);
+  }
+
+  @Override
+  public final boolean equals(Object o) {
+    if (o == this) {
+      return true;
+    } else if (o instanceof SubQueryExpression<?> s) {
+      return s.getMetadata().equals(queryMixin.getMetadata());
+    } else {
+      return false;
+    }
+  }
+}