Initial reactive repositories

dal/hibernate-dal/hibernate-cache/src/main/java/com/nexblocks/authguard/dal/hibernate/cache/HibernateAccountLocksRepository.java

@@ -8,7 +8,7 @@
 import com.nexblocks.authguard.dal.model.AccountLockDO;
 
 import java.util.Collection;
-import java.util.concurrent.CompletableFuture;
+import io.smallrye.mutiny.Uni;
 import java.util.function.Function;
 
 public class HibernateAccountLocksRepository extends AbstractHibernateRepository<AccountLockDO>
@@ -24,11 +24,10 @@ public HibernateAccountLocksRepository(final ReactiveQueryExecutor queryExecutor
     }
 
     @Override
-    public CompletableFuture<Collection<AccountLockDO>> findByAccountId(final long accountId) {
+    public Uni<Collection<AccountLockDO>> findByAccountId(final long accountId) {
         return queryExecutor
                 .getAList(session -> session.createNamedQuery(GET_BY_ACCOUNT_ID, AccountLockDO.class)
                         .setParameter(ACCOUNT_ID_FIELD, accountId))
-                .subscribeAsCompletionStage()
-                .thenApply(Function.identity());
+                .map(Function.identity());
     }
 }

dal/hibernate-dal/hibernate-cache/src/main/java/com/nexblocks/authguard/dal/hibernate/cache/HibernateAccountTokensRepository.java

@@ -8,7 +8,7 @@
 import com.nexblocks.authguard.dal.model.AccountTokenDO;
 
 import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
+import io.smallrye.mutiny.Uni;
 
 public class HibernateAccountTokensRepository extends AbstractHibernateRepository<AccountTokenDO>
         implements AccountTokensRepository {
@@ -22,21 +22,20 @@ public HibernateAccountTokensRepository(final ReactiveQueryExecutor queryExecuto
     }
 
     @Override
-    public CompletableFuture<Optional<AccountTokenDO>> getByToken(final String token) {
+    public Uni<Optional<AccountTokenDO>> getByToken(final String token) {
         return queryExecutor.getSingleResult(session -> session.createNamedQuery(GET_BY_TOKEN, AccountTokenDO.class)
-                .setParameter(TOKEN_FIELD, token))
-                .subscribeAsCompletionStage();
+                .setParameter(TOKEN_FIELD, token));
     }
 
     @Override
-    public CompletableFuture<Optional<AccountTokenDO>> deleteToken(final String token) {
+    public Uni<Optional<AccountTokenDO>> deleteToken(final String token) {
         return getByToken(token)
-                .thenCompose(opt -> {
+                .flatMap(opt -> {
                     if (opt.isPresent()) {
-                        return delete(opt.get().getId()).subscribeAsCompletionStage();
+                        return delete(opt.get().getId());
                     }
 
-                    return CompletableFuture.completedFuture(Optional.empty());
+                    return Uni.createFrom().item(Optional.empty());
                 });
     }
 }

dal/hibernate-dal/hibernate-cache/src/main/java/com/nexblocks/authguard/dal/hibernate/cache/HibernateSessionsRepository.java

@@ -9,7 +9,7 @@
 
 import java.util.List;
 import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
+import io.smallrye.mutiny.Uni;
 
 public class HibernateSessionsRepository extends AbstractHibernateRepository<SessionDO>
         implements SessionsRepository {
@@ -23,30 +23,28 @@ public HibernateSessionsRepository(final ReactiveQueryExecutor queryExecutor) {
     }
 
     @Override
-    public CompletableFuture<Optional<SessionDO>> getByToken(final String token) {
+    public Uni<Optional<SessionDO>> getByToken(final String token) {
         return queryExecutor.getSingleResult(session -> session.createNamedQuery(GET_BY_TOKEN, SessionDO.class)
-                .setParameter(TOKEN_FIELD, token))
-                .subscribeAsCompletionStage();
+                .setParameter(TOKEN_FIELD, token));
     }
 
     @Override
-    public CompletableFuture<Optional<SessionDO>> deleteByToken(final String sessionToken) {
+    public Uni<Optional<SessionDO>> deleteByToken(final String sessionToken) {
         return getByToken(sessionToken)
-                .thenCompose(opt -> {
+                .flatMap(opt -> {
                     if (opt.isPresent()) {
-                        return delete(opt.get().getId()).subscribeAsCompletionStage();
+                        return delete(opt.get().getId());
                     }
 
-                    return CompletableFuture.completedFuture(Optional.empty());
+                    return Uni.createFrom().item(Optional.empty());
                 });
     }
 
     @Override
-    public CompletableFuture<List<SessionDO>> findByAccountId(final long accountId, final String domain) {
+    public Uni<List<SessionDO>> findByAccountId(final long accountId, final String domain) {
         return queryExecutor.getAList(session -> session.createNamedQuery(GET_BY_ACCOUNT_ID, SessionDO.class)
                 .setParameter(CommonFields.DOMAIN, domain)
-                .setParameter(CommonFields.ACCOUNT_ID, accountId))
-                .subscribeAsCompletionStage();
+                .setParameter(CommonFields.ACCOUNT_ID, accountId));
 
     }
 }

dal/hibernate-dal/hibernate-cache/src/test/java/com/nexblocks/authguard/dal/hibernate/cache/HibernateAccountLocksRepositoryTest.java

@@ -55,13 +55,13 @@ void getByToken() {
                 .build();
 
         final AccountLockDO persisted = repository.save(accountLock).subscribeAsCompletionStage().join();
-        final Collection<AccountLockDO> retrieved = repository.findByAccountId(accountLock.getAccountId()).join();
+        final Collection<AccountLockDO> retrieved = repository.findByAccountId(accountLock.getAccountId()).subscribeAsCompletionStage().join();
 
         assertThat(retrieved).containsOnly(persisted);
     }
 
     @Test
     void getByTokenNonExistent() {
-        assertThat(repository.findByAccountId(0).join()).isEmpty();
+        assertThat(repository.findByAccountId(0).subscribeAsCompletionStage().join()).isEmpty();
     }
 }

dal/hibernate-dal/hibernate-cache/src/test/java/com/nexblocks/authguard/dal/hibernate/cache/HibernateAccountTokensRepositoryTest.java

@@ -71,13 +71,13 @@ void getByToken() {
                 .build();
 
         final AccountTokenDO persisted = repository.save(accountToken).subscribeAsCompletionStage().join();
-        final Optional<AccountTokenDO> retrieved = repository.getByToken(token).join();
+        final Optional<AccountTokenDO> retrieved = repository.getByToken(token).subscribeAsCompletionStage().join();
 
         assertThat(retrieved).contains(persisted);
     }
 
     @Test
     void getByTokenNonExistent() {
-        assertThat(repository.getByToken("nothing").join()).isEmpty();
+        assertThat(repository.getByToken("nothing").subscribeAsCompletionStage().join()).isEmpty();
     }
 }

dal/hibernate-dal/hibernate-cache/src/test/java/com/nexblocks/authguard/dal/hibernate/cache/HibernateSessionsRepositoryTest.java

@@ -45,7 +45,7 @@ public void getByToken() {
                 .build();
 
         final SessionDO persisted = repository.save(session).subscribeAsCompletionStage().join();
-        final Optional<SessionDO> retrieved = repository.getByToken(token).join();
+        final Optional<SessionDO> retrieved = repository.getByToken(token).subscribeAsCompletionStage().join();
 
         assertThat(retrieved).contains(persisted);
     }

dal/hibernate-dal/hibernate-common/src/main/java/com/nexblocks/authguard/dal/hibernate/common/ByteArrayTypeContributor.java

@@ -0,0 +1,22 @@
+package com.nexblocks.authguard.dal.hibernate.common;
+
+import org.hibernate.boot.model.TypeContributions;
+import org.hibernate.boot.model.TypeContributor;
+import org.hibernate.service.ServiceRegistry;
+import org.hibernate.type.BasicType;
+import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaType;
+import org.hibernate.type.descriptor.jdbc.VarbinaryJdbcType;
+import org.hibernate.type.internal.BasicTypeImpl;
+
+
+public class ByteArrayTypeContributor implements TypeContributor {
+    @Override
+    public void contribute(TypeContributions typeContributions, ServiceRegistry serviceRegistry) {
+        BasicType<?> byteArrayType = new BasicTypeImpl<>(
+                new PrimitiveByteArrayJavaType(),
+                new VarbinaryJdbcType()
+        );
+
+        typeContributions.contributeType(byteArrayType);
+    }
+}

dal/hibernate-dal/hibernate-common/src/main/java/com/nexblocks/authguard/dal/hibernate/common/QueryExecutor.java

@@ -7,7 +7,7 @@
 import jakarta.persistence.NoResultException;
 import java.util.List;
 import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
+import io.smallrye.mutiny.Uni;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
@@ -20,27 +20,27 @@ public QueryExecutor(final SessionProvider sessionProvider) {
         this.sessionProvider = sessionProvider;
     }
 
-    public <T> CompletableFuture<T> persistAndReturn(final T entity) {
+    public <T> Uni<T> persistAndReturn(final T entity) {
         return doInNewTransaction(session -> session.persist(entity))
-                .thenApply(ignored -> entity);
+                .map(ignored -> entity);
     }
 
-    public <T> CompletableFuture<Optional<T>> updateAndReturn(final T entity) {
+    public <T> Uni<Optional<T>> updateAndReturn(final T entity) {
         return doInNewTransaction(session -> session.update(entity))
-                .thenApply(ignored -> Optional.of(entity));
+                .map(ignored -> Optional.of(entity));
     }
 
-    public <T> CompletableFuture<Optional<T>> getById(final String id, final Class<T> entityType) {
+    public <T> Uni<Optional<T>> getById(final String id, final Class<T> entityType) {
         return inNewTransaction(session -> session.get(entityType, id))
-                .thenApply(Optional::ofNullable);
+                .map(Optional::ofNullable);
     }
 
-    public <T> CompletableFuture<Optional<T>> getById(final Long id, final Class<T> entityType) {
+    public <T> Uni<Optional<T>> getById(final Long id, final Class<T> entityType) {
         return inNewTransaction(session -> session.get(entityType, id))
-                .thenApply(Optional::ofNullable);
+                .map(Optional::ofNullable);
     }
 
-    public <T> CompletableFuture<Optional<T>> getSingleResult(final Function<Session, Query<T>> sessionQuery) {
+    public <T> Uni<Optional<T>> getSingleResult(final Function<Session, Query<T>> sessionQuery) {
         return inNewTransaction(session -> {
             final Query<T> query = sessionQuery.apply(session);
 
@@ -52,14 +52,14 @@ public <T> CompletableFuture<Optional<T>> getSingleResult(final Function<Session
         });
     }
 
-    public <T> CompletableFuture<List<T>> getAList(final Function<Session, Query<T>> sessionQuery) {
+    public <T> Uni<List<T>> getAList(final Function<Session, Query<T>> sessionQuery) {
         return inNewTransaction(session -> {
             final Query<T> query = sessionQuery.apply(session);
             return query.getResultList();
         });
     }
 
-    public <T> CompletableFuture<List<T>> getAList(final Function<Session, Query<T>> sessionQuery,
+    public <T> Uni<List<T>> getAList(final Function<Session, Query<T>> sessionQuery,
                                                    final int limit) {
         return inNewTransaction(session -> {
             final Query<T> query = sessionQuery.apply(session);
@@ -69,45 +69,46 @@ public <T> CompletableFuture<List<T>> getAList(final Function<Session, Query<T>>
         });
     }
 
-    public <T> CompletableFuture<Optional<T>> deleteById(final String id, final Class<T> entityType) {
+    public <T> Uni<Optional<T>> deleteById(final String id, final Class<T> entityType) {
         return getById(id, entityType)
-                .thenCompose(retrieved -> {
+                .flatMap(retrieved -> {
                     if (retrieved.isPresent()) {
                         return doInNewTransaction(session -> session.delete(retrieved.get()))
-                                .thenApply(ignored -> retrieved);
+                                .map(ignored -> retrieved);
                     } else {
-                        return CompletableFuture.completedFuture(Optional.empty());
+                        return Uni.createFrom().item(Optional.empty());
                     }
                 });
     }
 
-    public <T> CompletableFuture<Optional<T>> deleteById(final Long id, final Class<T> entityType) {
+    public <T> Uni<Optional<T>> deleteById(final Long id, final Class<T> entityType) {
         return getById(id, entityType)
-                .thenCompose(retrieved -> {
+                .flatMap(retrieved -> {
                     if (retrieved.isPresent()) {
                         return doInNewTransaction(session -> session.delete(retrieved.get()))
-                                .thenApply(ignored -> retrieved);
+                                .map(ignored -> retrieved);
                     } else {
-                        return CompletableFuture.completedFuture(Optional.empty());
+                        return Uni.createFrom().item(Optional.empty());
                     }
                 });
     }
 
-    CompletableFuture<Void> doInNewTransaction(final Consumer<Session> consumer) {
-        return CompletableFuture.runAsync(() -> {
-
+    Uni<Void> doInNewTransaction(final Consumer<Session> consumer) {
+        return Uni.createFrom().item(() -> {
             try (Session session = sessionProvider.newBlockingSession()) {
                 session.beginTransaction();
 
                 consumer.accept(session);
 
                 session.getTransaction().commit();
             }
+
+            return null;
         });
     }
 
-    <T> CompletableFuture<T> inNewTransaction(final Function<Session, T> function) {
-        return CompletableFuture.supplyAsync(() -> {
+    <T> Uni<T> inNewTransaction(final Function<Session, T> function) {
+        return Uni.createFrom().item(() -> {
             final Session session = sessionProvider.newBlockingSession();
 
             session.beginTransaction();

dal/hibernate-dal/hibernate-common/src/main/java/com/nexblocks/authguard/dal/hibernate/common/ReactiveQueryExecutor.java

@@ -1,23 +1,25 @@
 package com.nexblocks.authguard.dal.hibernate.common;
 
+import com.google.inject.Inject;
 import io.smallrye.mutiny.Uni;
-import jakarta.inject.Inject;
 import org.hibernate.reactive.mutiny.Mutiny;
 
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
 
 public class ReactiveQueryExecutor {
     private final Mutiny.SessionFactory sessionFactory;
 
-    @Inject
     public ReactiveQueryExecutor(final Mutiny.SessionFactory sessionFactory) {
         this.sessionFactory = sessionFactory;
     }
 
+    public Mutiny.SessionFactory getSessionFactory() {
+        return sessionFactory;
+    }
+
     @Inject
     public ReactiveQueryExecutor(final SessionProvider sessionProvider) {
         this.sessionFactory = sessionProvider.getFactory();

dal/hibernate-dal/hibernate-common/src/main/java/com/nexblocks/authguard/dal/hibernate/common/SessionProvider.java

@@ -25,6 +25,12 @@ public SessionProvider(final Properties hibernateProperties) {
         final Configuration configuration = entityMapping(new Configuration())
                 .addProperties(hibernateProperties);
 
+        Properties extra = new Properties();
+
+//        extra.put("hibernate.type_contributors", ByteArrayTypeContributor.class.getCanonicalName());
+
+        configuration.addProperties(extra);
+
         factory = configuration.buildSessionFactory(
                         new ReactiveServiceRegistryBuilder()
                                 .applySettings(configuration.getProperties() )