Update project version to 7.1.3 and modify indexer grouping logic to move only dependent indexers to their dependency's group (#94)

Author: daithihearn

build.gradle.kts

@@ -20,7 +20,7 @@ jacoco {
 
 group = "org.vechain"
 
-val projectVersion = System.getenv("PROJECT_VERSION") ?: "7.1.2"
+val projectVersion = System.getenv("PROJECT_VERSION") ?: "7.1.3"
 version = projectVersion
 
 val isSnapshot = version.toString().endsWith("SNAPSHOT")

src/main/kotlin/org.vechain.indexer/IndexerRunner.kt

@@ -11,6 +11,7 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
+import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withTimeoutOrNull
 import org.slf4j.Logger
@@ -181,7 +182,7 @@ open class IndexerRunner {
         }
 
         // Wait for all fast syncs, then cancel early processing
-        fastSyncJobs.forEach { it.join() }
+        fastSyncJobs.joinAll()
         processingJob.cancel()
     }
 

src/main/kotlin/org.vechain.indexer/utils/IndexerOrderUtils.kt

@@ -59,8 +59,9 @@ internal object IndexerOrderUtils {
 
     /**
      * Groups indexers by block number proximity. Indexers within [threshold] blocks of each other
-     * are placed in the same group. Dependencies are forced into the same group even if far apart.
-     * Each group is topologically ordered internally.
+     * are placed in the same group. When a dependency spans groups, only the dependent indexer is
+     * moved to its dependency's group (not the entire group). Each group is topologically ordered
+     * internally.
      *
      * @param indexers The list of indexers to group
      * @param threshold Maximum block gap allowed within a group
@@ -77,7 +78,7 @@ internal object IndexerOrderUtils {
         var currentGroup = mutableListOf(sorted[0])
         groups.add(currentGroup)
 
-        for (i in 1 until sorted.size) {
+        for (i in 1 ..< sorted.size) {
             val gap = sorted[i].getCurrentBlockNumber() - sorted[i - 1].getCurrentBlockNumber()
             if (gap > threshold) {
                 currentGroup = mutableListOf()
@@ -86,26 +87,23 @@ internal object IndexerOrderUtils {
             currentGroup.add(sorted[i])
         }
 
-        // Force dependent indexers into the same group
+        // Move dependent indexers to their dependency's group
         val indexerToGroup = mutableMapOf<Indexer, Int>()
         groups.forEachIndexed { idx, group -> group.forEach { indexerToGroup[it] = idx } }
 
-        // Merge groups when a dependency relationship spans groups
-        var merged = true
-        while (merged) {
-            merged = false
+        var moved = true
+        while (moved) {
+            moved = false
             for (indexer in indexers) {
                 val dep = indexer.dependsOn ?: continue
                 val indexerGroupIdx = indexerToGroup[indexer] ?: continue
                 val depGroupIdx = indexerToGroup[dep] ?: continue
                 if (indexerGroupIdx != depGroupIdx) {
-                    // Merge into the lower-numbered group (earlier blocks)
-                    val targetIdx = minOf(indexerGroupIdx, depGroupIdx)
-                    val sourceIdx = maxOf(indexerGroupIdx, depGroupIdx)
-                    groups[targetIdx].addAll(groups[sourceIdx])
-                    groups[sourceIdx].forEach { indexerToGroup[it] = targetIdx }
-                    groups[sourceIdx].clear()
-                    merged = true
+                    // Move only the dependent indexer to its dependency's group
+                    groups[indexerGroupIdx].remove(indexer)
+                    groups[depGroupIdx].add(indexer)
+                    indexerToGroup[indexer] = depGroupIdx
+                    moved = true
                 }
             }
         }

src/test/kotlin/org/vechain/indexer/utils/IndexerOrderUtilsTest.kt

@@ -347,6 +347,21 @@ internal class IndexerOrderUtilsTest {
             expectThat(result.size).isEqualTo(1)
         }
 
+        @Test
+        fun `should move only dependent indexer not entire group`() {
+            // parent@100, child@1000 depends on parent, independent@1050
+            val parent = createMockIndexer("parent", currentBlock = 100L)
+            val child = createMockIndexer("child", dependsOn = parent, currentBlock = 1000L)
+            val independent = createMockIndexer("independent", currentBlock = 1050L)
+
+            val result = IndexerOrderUtils.proximityGroups(listOf(parent, child, independent), 100)
+
+            // child moves to parent's group, independent stays in its own group
+            expectThat(result.size).isEqualTo(2)
+            expectThat(result[0]).containsExactly(parent, child)
+            expectThat(result[1]).containsExactly(independent)
+        }
+
         @Test
         fun `should merge transitive dependency groups`() {
             // A depends on B, B is far from A but close to C