Revert the changes related to jOOQ

application/src/main/java/org/cardanofoundation/ledgersync/repository/AddressTokenBalanceRepository.java

@@ -6,6 +6,6 @@
 
 @Repository
 public interface AddressTokenBalanceRepository
-        extends JpaRepository<AddressTokenBalance, Long> {
+        extends JpaRepository<AddressTokenBalance, Long>, CustomAddressTokenBalanceRepository {
 
 }

application/src/main/java/org/cardanofoundation/ledgersync/repository/CustomAddressTokenBalanceRepository.java

@@ -0,0 +1,15 @@
+package org.cardanofoundation.ledgersync.repository;
+
+import org.cardanofoundation.ledgersync.consumercommon.entity.AddressTokenBalance;
+import org.springframework.data.util.Pair;
+
+import java.util.Collection;
+
+public interface CustomAddressTokenBalanceRepository {
+
+    Collection<AddressTokenBalance> findAllByAddressFingerprintPairIn(
+            Collection<Pair<String, String>> addressFingerprintPairs);
+
+    Collection<AddressTokenBalance> findAllByAddressMultiAssetIdPairIn(
+            Collection<Pair<Long, Long>> addressMultiAssetIdPairs);
+}

application/src/main/java/org/cardanofoundation/ledgersync/repository/impl/CustomAddressTokenBalanceRepositoryImpl.java

@@ -0,0 +1,99 @@
+package org.cardanofoundation.ledgersync.repository.impl;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.Join;
+import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import org.cardanofoundation.ledgersync.consumercommon.entity.*;
+import org.cardanofoundation.ledgersync.repository.CustomAddressTokenBalanceRepository;
+import org.springframework.data.util.Pair;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collection;
+
+@Repository
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+@RequiredArgsConstructor
+public class CustomAddressTokenBalanceRepositoryImpl implements
+        CustomAddressTokenBalanceRepository {
+
+    @PersistenceContext
+    EntityManager entityManager;
+
+    @Override
+    @Transactional(readOnly = true, propagation = Propagation.REQUIRES_NEW)
+    public Collection<AddressTokenBalance> findAllByAddressFingerprintPairIn(
+            Collection<Pair<String, String>> addressFingerprintPairs) {
+        var criteriaBuilder = entityManager.getCriteriaBuilder();
+        var query = criteriaBuilder.createQuery(AddressTokenBalance.class);
+        Root<AddressTokenBalance> addressTokenBalanceRoot = query.from(AddressTokenBalance.class);
+        Join<AddressTokenBalance, Address> addressJoin =
+                addressTokenBalanceRoot.join(AddressTokenBalance_.address);
+        Join<AddressTokenBalance, MultiAsset> multiAssetJoin =
+                addressTokenBalanceRoot.join(AddressTokenBalance_.multiAsset);
+
+        Predicate[] predicates = addressFingerprintPairs.stream()
+                .map(addressFingerprintPair ->
+                        buildAddressTokenBalancePredicate(
+                                criteriaBuilder, addressJoin, multiAssetJoin, addressFingerprintPair))
+                .toArray(Predicate[]::new);
+
+        query.select(addressTokenBalanceRoot).where(criteriaBuilder.or(predicates));
+        return entityManager.createQuery(query).getResultList();
+    }
+
+    @Override
+    @Transactional(readOnly = true, propagation = Propagation.REQUIRES_NEW)
+    public Collection<AddressTokenBalance> findAllByAddressMultiAssetIdPairIn(
+            Collection<Pair<Long, Long>> addressMultiAssetIdPairs) {
+        var criteriaBuilder = entityManager.getCriteriaBuilder();
+        var query = criteriaBuilder.createQuery(AddressTokenBalance.class);
+        Root<AddressTokenBalance> addressTokenBalanceRoot = query.from(AddressTokenBalance.class);
+        Join<AddressTokenBalance, Address> addressJoin =
+                addressTokenBalanceRoot.join(AddressTokenBalance_.address);
+        Join<AddressTokenBalance, MultiAsset> multiAssetJoin =
+                addressTokenBalanceRoot.join(AddressTokenBalance_.multiAsset);
+
+        Predicate[] predicates = addressMultiAssetIdPairs.stream()
+                .map(addressMultiAssetIdPair ->
+                        buildAddressTokenBalancePredicateWithIdPair(
+                                criteriaBuilder, addressJoin, multiAssetJoin, addressMultiAssetIdPair))
+                .toArray(Predicate[]::new);
+
+        query.select(addressTokenBalanceRoot).where(criteriaBuilder.or(predicates));
+        return entityManager.createQuery(query).getResultList();
+    }
+
+    private static Predicate buildAddressTokenBalancePredicate(
+            CriteriaBuilder criteriaBuilder, Join<AddressTokenBalance, Address> addressJoin,
+            Join<AddressTokenBalance, MultiAsset> multiAssetJoin,
+            Pair<String, String> addressFingerprintPair) {
+        String address = addressFingerprintPair.getFirst();
+        String fingerprint = addressFingerprintPair.getSecond();
+        Predicate addressEquals = criteriaBuilder.equal(addressJoin.get(Address_.address), address);
+        Predicate fingerprintEquals = criteriaBuilder
+                .equal(multiAssetJoin.get(MultiAsset_.fingerprint), fingerprint);
+
+        return criteriaBuilder.and(addressEquals, fingerprintEquals);
+    }
+
+    private static Predicate buildAddressTokenBalancePredicateWithIdPair(
+            CriteriaBuilder criteriaBuilder, Join<AddressTokenBalance, Address> addressJoin,
+            Join<AddressTokenBalance, MultiAsset> multiAssetJoin,
+            Pair<Long, Long> addressMultiAssetIdPair) {
+        Long addressId = addressMultiAssetIdPair.getFirst();
+        Long multiAssetId = addressMultiAssetIdPair.getSecond();
+        Predicate addressEquals = criteriaBuilder.equal(addressJoin.get(BaseEntity_.id), addressId);
+        Predicate fingerprintEquals = criteriaBuilder
+                .equal(multiAssetJoin.get(BaseEntity_.id), multiAssetId);
+
+        return criteriaBuilder.and(addressEquals, fingerprintEquals);
+    }
+}

application/src/main/java/org/cardanofoundation/ledgersync/service/impl/AddressBalanceServiceImpl.java

@@ -9,7 +9,6 @@
 import org.cardanofoundation.ledgersync.consumercommon.entity.*;
 import org.cardanofoundation.ledgersync.projection.AddressTxBalanceProjection;
 import org.cardanofoundation.ledgersync.repository.*;
-import org.cardanofoundation.ledgersync.repository.custom.CustomAddressTokenBalanceRepository;
 import org.cardanofoundation.ledgersync.service.AddressBalanceService;
 import org.cardanofoundation.ledgersync.service.AggregatedDataCachingService;
 import org.cardanofoundation.ledgersync.service.BlockDataService;
@@ -43,7 +42,6 @@ public class AddressBalanceServiceImpl implements AddressBalanceService {
     AddressTokenRepository addressTokenRepository;
     AddressTxBalanceRepository addressTxBalanceRepository;
     AddressTokenBalanceRepository addressTokenBalanceRepository;
-    CustomAddressTokenBalanceRepository customAddressTokenBalanceRepository;
     StakeAddressRepository stakeAddressRepository;
 
     MultiAssetService multiAssetService;
@@ -157,7 +155,7 @@ public void rollbackAddressBalances(Collection<Tx> txs) {
                     .collect(Collectors.toSet());
 
             // Find all address token balance records
-            var addressTokenBalanceMap = customAddressTokenBalanceRepository
+            var addressTokenBalanceMap = addressTokenBalanceRepository
                     .findAllByAddressMultiAssetIdPairIn(addressMultiAssetIdPairs)
                     .stream()
                     .collect(Collectors.toMap(
@@ -336,7 +334,7 @@ private void handleAddressToken(Map<String, Tx> txMap, Map<String, Address> addr
         Map<Pair<String, String>, AddressTokenBalance> newAddressTokenBalanceMap = new HashMap<>();
 
         /*
-         * Create a map of ass-et fingerprint with its associated tx hashes
+         * Create a map of asset fingerprint with its associated tx hashes
          * It helps keeping track of how many txs an asset associates with
          */
         Map<String, Set<String>> fingerprintTxHashesMap = new HashMap<>();
@@ -375,7 +373,7 @@ private Map<Pair<Long, Long>, AddressTokenBalance> getAddressTokenBalanceMap(
         var queryBatches = Lists.partition(
                 new ArrayList<>(addressFingerprintPairs), ADDRESS_TOKEN_BALANCE_BATCH_QUERY_SIZE);
 
-        queryBatches.parallelStream().forEach(batch -> customAddressTokenBalanceRepository
+        queryBatches.parallelStream().forEach(batch -> addressTokenBalanceRepository
                 .findAllByAddressFingerprintPairIn(batch)
                 .parallelStream()
                 .forEach(addressTokenBalance -> {