perf: fix N+1 queries, unbounded purge, missing index, and redundant fetch

- Add left join fetch k.branch to findSoftDeletedByIdsAndProjectId to
  eliminate lazy-load per key in restoreKeys
- Change purge scheduler to paginated ID-only query instead of loading
  all expired key entities into memory
- Add partial index key_project_deleted_at_not_null for trash queries
- Eliminate double-fetch in permanentlyDelete by using lightweight
  project ID check instead of full entity load

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: bdshadow

backend/api/src/main/kotlin/io/tolgee/api/v2/controllers/keys/KeyTrashController.kt

@@ -147,9 +147,10 @@ class KeyTrashController(
   fun permanentlyDelete(
     @PathVariable keyId: Long,
   ) {
-    val key =
-      keyService.findSoftDeletedByIdsAndProjectId(listOf(keyId), projectHolder.project.id).firstOrNull()
-        ?: throw NotFoundException(Message.KEY_NOT_FOUND)
-    keyService.hardDeleteMultiple(listOf(key.id))
+    val projectIds = keyService.getSoftDeletedProjectIdsForKeyIds(listOf(keyId))
+    if (projectIds.isEmpty() || projectIds.single() != projectHolder.project.id) {
+      throw NotFoundException(Message.KEY_NOT_FOUND)
+    }
+    keyService.hardDeleteMultiple(listOf(keyId))
   }
 }

backend/data/src/main/kotlin/io/tolgee/repository/KeyRepository.kt

@@ -511,13 +511,17 @@ interface KeyRepository : JpaRepository<Key, Long> {
     pageable: Pageable,
   ): Page<KeySearchResultView>
 
-  @Query("from Key k where k.deletedAt is not null and k.deletedAt < :before")
-  fun findAllSoftDeletedBefore(before: Date): List<Key>
+  @Query("select k.id from Key k where k.deletedAt is not null and k.deletedAt < :before")
+  fun findSoftDeletedIdsBefore(
+    before: Date,
+    pageable: Pageable,
+  ): Page<Long>
 
   @Query(
     """
     from Key k
     left join fetch k.namespace
+    left join fetch k.branch
     where k.id in :ids and k.project.id = :projectId and k.deletedAt is not null
     """,
   )

backend/data/src/main/kotlin/io/tolgee/service/key/KeyService.kt

@@ -418,8 +418,11 @@ class KeyService(
     return keyRepository.findSoftDeletedByProjectId(projectId, branch, pageable)
   }
 
-  fun findAllSoftDeletedBefore(before: Date): List<Key> {
-    return keyRepository.findAllSoftDeletedBefore(before)
+  fun findSoftDeletedIdsBefore(
+    before: Date,
+    pageable: Pageable,
+  ): Page<Long> {
+    return keyRepository.findSoftDeletedIdsBefore(before, pageable)
   }
 
   fun findSoftDeletedByIdsAndProjectId(
@@ -429,6 +432,10 @@ class KeyService(
     return keyRepository.findSoftDeletedByIdsAndProjectId(ids, projectId)
   }
 
+  fun getSoftDeletedProjectIdsForKeyIds(keyIds: List<Long>): List<Long> {
+    return keyRepository.getSoftDeletedProjectIdsForKeyIds(keyIds)
+  }
+
   @Transactional
   fun deleteAllByProject(projectId: Long) {
     keyMetaService.deleteAllByProject(projectId)

backend/data/src/main/kotlin/io/tolgee/service/key/KeyTrashPurgeScheduler.kt

@@ -10,6 +10,7 @@ import io.tolgee.util.logger
 import io.tolgee.util.runSentryCatching
 import org.springframework.boot.context.event.ApplicationReadyEvent
 import org.springframework.context.event.EventListener
+import org.springframework.data.domain.PageRequest
 import org.springframework.stereotype.Component
 import org.springframework.transaction.PlatformTransactionManager
 import java.time.Duration
@@ -38,21 +39,26 @@ class KeyTrashPurgeScheduler(
 
   private fun purgeExpiredKeys() {
     val cutoffDate = currentDateProvider.date.addDays(-RETENTION_DAYS)
-    val expiredKeys =
-      executeInNewTransaction(transactionManager) {
-        keyService.findAllSoftDeletedBefore(cutoffDate)
-      }
+    var totalPurged = 0
+
+    do {
+      val batch =
+        executeInNewTransaction(transactionManager) {
+          keyService.findSoftDeletedIdsBefore(cutoffDate, PageRequest.of(0, BATCH_SIZE))
+        }
 
-    if (expiredKeys.isEmpty()) return
+      if (batch.isEmpty) break
 
-    expiredKeys.map { it.id }.chunked(BATCH_SIZE).forEach { batch ->
       executeInNewTransaction(transactionManager) {
-        keyService.hardDeleteMultiple(batch)
+        keyService.hardDeleteMultiple(batch.content)
       }
-      logger.info("Purged {} expired trashed keys", batch.size)
-    }
+      totalPurged += batch.numberOfElements
+      logger.info("Purged {} expired trashed keys", batch.numberOfElements)
+    } while (batch.hasNext())
 
-    logger.info("Total purged {} expired trashed keys older than {}", expiredKeys.size, cutoffDate)
+    if (totalPurged > 0) {
+      logger.info("Total purged {} expired trashed keys older than {}", totalPurged, cutoffDate)
+    }
   }
 
   companion object {

backend/data/src/main/resources/db/changelog/schema.xml

@@ -5152,4 +5152,16 @@
             <!-- Old indexes would need manual recreation if rolling back -->
         </rollback>
     </changeSet>
+
+    <!-- Key soft-delete: partial index for trash queries (deleted_at IS NOT NULL) -->
+    <changeSet author="dbocharov" id="1739900000000-5" runInTransaction="false">
+        <sql>
+            create index concurrently if not exists key_project_deleted_at_not_null
+                on public.key (project_id, deleted_at)
+                where deleted_at is not null;
+        </sql>
+        <rollback>
+            drop index concurrently if exists key_project_deleted_at_not_null;
+        </rollback>
+    </changeSet>
 </databaseChangeLog>