Don't apply limits for negentropy...

composeApp/src/commonMain/kotlin/ac/cord/auxiliary/compose/database/dao/NostrEventDao.kt

@@ -66,47 +66,56 @@ interface NostrEventDao {
     ): Flow<List<LocalNostrEvent>>
 
     @Transaction
-    @Query("SELECT * FROM NostrEvent WHERE kind in (:kinds) AND createdAt > :since ORDER BY createdAt ASC")
+    @Query("SELECT * FROM NostrEvent WHERE kind in (:kinds) AND createdAt > :since ORDER BY createdAt ASC LIMIT :limit")
-    fun  getNostrEvents(kinds: Array<Kind>, since: Instant = GENESIS_AT): List<NostrEvent>
+    fun  getNostrEvents(
+        kinds: Array<Kind>,
+        since: Instant = GENESIS_AT,
+        limit: Int
+    ): List<NostrEvent>
 
     @Transaction
-    @Query("SELECT * FROM NostrEvent WHERE content LIKE '%' || :search || '%' AND kind in (:kinds) AND createdAt > :since ORDER BY createdAt ASC")
+    @Query("SELECT * FROM NostrEvent WHERE content LIKE '%' || :search || '%' AND kind in (:kinds) AND createdAt > :since ORDER BY createdAt ASC LIMIT :limit")
     fun  getFilteredNostrEvents(
         kinds: Array<Kind>,
         search: String,
-        since: Instant = GENESIS_AT
+        since: Instant = GENESIS_AT,
+        limit: Int
     ): List<NostrEvent>
 
     @Transaction
-    @Query("SELECT * FROM NostrEvent WHERE kind in (:kinds) AND id in (:ids) AND createdAt > :since ORDER BY createdAt ASC")
+    @Query("SELECT * FROM NostrEvent WHERE kind in (:kinds) AND id in (:ids) AND createdAt > :since ORDER BY createdAt ASC LIMIT :limit")
     fun  getFilteredNostrEvents(
         kinds: Array<Kind>,
         ids: Array<HexKey>,
-        since: Instant = GENESIS_AT
+        since: Instant = GENESIS_AT,
+        limit: Int
     ): List<NostrEvent>
 
     @Transaction
-    @Query("SELECT * FROM NostrEvent WHERE kind in (:kinds) AND pubKey in (:authors)  AND createdAt > :since ORDER BY createdAt ASC")
+    @Query("SELECT * FROM NostrEvent WHERE kind in (:kinds) AND pubKey in (:authors)  AND createdAt > :since ORDER BY createdAt ASC LIMIT :limit")
     fun  getAuthoredNostrEvents(
         kinds: Array<Kind>,
         authors: Array<HexKey>,
-        since: Instant = GENESIS_AT
+        since: Instant = GENESIS_AT,
+        limit: Int
     ): List<NostrEvent>
 
     @Transaction
-    @Query("SELECT * FROM NostrEvent WHERE tags LIKE '%' || :publicKey || '%' AND kind in (:kinds)  AND createdAt > :since ORDER BY createdAt ASC")
+    @Query("SELECT * FROM NostrEvent WHERE tags LIKE '%' || :publicKey || '%' AND kind in (:kinds)  AND createdAt > :since ORDER BY createdAt ASC LIMIT :limit")
     fun  getPublicKeyMentionedNostrEvents(
         kinds: Array<Kind>,
         publicKey: HexKey,
-        since: Instant = GENESIS_AT
+        since: Instant = GENESIS_AT,
+        limit: Int
     ): List<NostrEvent>
 
     @Transaction
-    @Query("SELECT * FROM NostrEvent WHERE tags LIKE '%' || :eventId || '%reply%' AND kind in (:kinds) AND createdAt > :since ORDER BY createdAt ASC")
+    @Query("SELECT * FROM NostrEvent WHERE tags LIKE '%' || :eventId || '%reply%' AND kind in (:kinds) AND createdAt > :since ORDER BY createdAt ASC LIMIT :limit")
     fun  getNostrEventReplies(
         kinds: Array<Kind>,
         eventId: HexKey,
-        since: Instant
+        since: Instant,
+        limit: Int
     ): List<NostrEvent>
 
     @Query("SELECT * FROM NostrEvent WHERE kind in (:kinds) ORDER BY savedAt DESC")

composeApp/src/commonMain/kotlin/ac/cord/auxiliary/compose/database/repository/DatabaseNostrRepository.kt

@@ -7,7 +7,6 @@ import ac.cord.auxiliary.compose.database.model.BroadcastNostrEventRequest
 import ac.cord.auxiliary.compose.database.model.Connection
 import ac.cord.auxiliary.compose.database.model.NegentropySynchronizeRequest
 import ac.cord.auxiliary.compose.database.model.NostrEvent
-import ac.cord.auxiliary.compose.database.model.NostrEventRelay
 import ac.cord.auxiliary.compose.database.model.Profile
 import ac.cord.auxiliary.compose.database.model.RecentSearch
 import ac.cord.auxiliary.compose.database.model.Relay
@@ -558,7 +557,10 @@ class DatabaseNostrRepository(
         }
     }
 
-    override suspend fun getNostrFeedIds(synchronizationFilters: Array<SynchronizationFilter>): List<NostrEvent> {
+    override suspend fun getNostrFeedIds(
+        synchronizationFilters: Array<SynchronizationFilter>,
+        applyLimits: Boolean
+    ): List<NostrEvent> {
         if (synchronizationFilters.size == 1) {
             val synchronizationFilter = synchronizationFilters.first()
 
@@ -567,21 +569,36 @@ class DatabaseNostrRepository(
                     logger.d("observeFilteredNostrEvents: $synchronizationFilter")
                     database.nostrEventDao().getFilteredNostrEvents(
                         kinds = synchronizationFilter.kinds,
-                        search = synchronizationFilter.search
+                        search = synchronizationFilter.search,
+                        limit = if (applyLimits) {
+                            synchronizationFilter.limit ?: 50
+                        } else {
+                            -1
+                        }
                     )
                 }
                 synchronizationFilter.kinds != null && synchronizationFilter.ids != null -> {
                     logger.d("observeFilteredNostrEvents: $synchronizationFilter")
                     database.nostrEventDao().getFilteredNostrEvents(
                         kinds = synchronizationFilter.kinds,
-                        ids = synchronizationFilter.ids
+                        ids = synchronizationFilter.ids,
+                        limit = if (applyLimits) {
+                            synchronizationFilter.limit ?: 50
+                        } else {
+                            -1
+                        }
                     )
                 }
                 synchronizationFilter.kinds != null && synchronizationFilter.authors != null -> {
                     logger.d("observeAuthoredNostrEvents: $synchronizationFilter")
                     database.nostrEventDao().getAuthoredNostrEvents(
                         kinds = synchronizationFilter.kinds,
-                        authors = synchronizationFilter.authors
+                        authors = synchronizationFilter.authors,
+                        limit = if (applyLimits) {
+                            synchronizationFilter.limit ?: 50
+                        } else {
+                            -1
+                        }
                     )
                 }
                 synchronizationFilter.kinds != null && synchronizationFilter.since != null &&  synchronizationFilter.tags?.contains("e") == true && synchronizationFilter.tags["e"]?.first()?.isNotEmpty() == true -> {
@@ -589,14 +606,24 @@ class DatabaseNostrRepository(
                     database.nostrEventDao().getNostrEventReplies(
                         kinds = synchronizationFilter.kinds,
                         eventId = synchronizationFilter.tags["e"]?.first()!!,
-                        since = synchronizationFilter.since
+                        since = synchronizationFilter.since,
+                        limit = if (applyLimits) {
+                            synchronizationFilter.limit ?: 50
+                        } else {
+                            -1
+                        }
                     )
                 }
                 synchronizationFilter.kinds != null && synchronizationFilter.tags?.contains("p") == true && synchronizationFilter.tags["p"]?.first()?.isNotEmpty() == true -> {
                     logger.d("observePublicKeyMentionedNostrEvents: $synchronizationFilter")
                     database.nostrEventDao().getPublicKeyMentionedNostrEvents(
                         kinds = synchronizationFilter.kinds,
-                        publicKey = synchronizationFilter.tags["p"]?.first()!!
+                        publicKey = synchronizationFilter.tags["p"]?.first()!!,
+                        limit = if (applyLimits) {
+                            synchronizationFilter.limit ?: 50
+                        } else {
+                            -1
+                        }
                     )
                 }
                 else -> {
@@ -604,7 +631,12 @@ class DatabaseNostrRepository(
                     database.nostrEventDao().getNostrEvents(
                         kinds = arrayOf(
                             TextNoteEvent.KIND,
-                        )
+                        ),
+                        limit = if (applyLimits) {
+                            synchronizationFilter.limit ?: 50
+                        } else {
+                            -1
+                        }
                     )
                 }
             }

composeApp/src/commonMain/kotlin/ac/cord/auxiliary/compose/repository/NostrRepository.kt

@@ -107,7 +107,10 @@ interface NostrRepository {
 
     suspend fun observeNostrFeed(synchronizationFilter: SynchronizationFilter): Flow<List<LocalNostrEvent>>
 
-    suspend fun getNostrFeedIds(synchronizationFilters: Array<SynchronizationFilter>): List<NostrEvent>
+    suspend fun getNostrFeedIds(
+        synchronizationFilters: Array<SynchronizationFilter>,
+        applyLimits: Boolean = true
+    ): List<NostrEvent>
 
     suspend fun observeLocalNostrEventById(nostrEventId: String): Flow<LocalNostrEvent?>
 
@@ -259,7 +262,10 @@ interface NostrRepository {
                 TODO("Not yet implemented")
             }
 
-            override suspend fun getNostrFeedIds(synchronizationFilters: Array<SynchronizationFilter>): List<NostrEvent> {
+            override suspend fun getNostrFeedIds(
+                synchronizationFilters: Array<SynchronizationFilter>,
+                applyLimits: Boolean
+            ): List<NostrEvent> {
                 TODO("Not yet implemented")
             }
 

composeApp/src/commonMain/kotlin/ac/cord/auxiliary/compose/ui/view/model/NavigationViewModel.kt

@@ -226,7 +226,8 @@ class NavigationViewModel(
                     val events = nostrRepository.getNostrFeedIds(
                         arrayOf(
                             negentropySynchronizeRequest.synchronizationFilter
-                        )
+                        ),
+                        applyLimits = false
                     )
                     logger.d("Events: ${events.size}")
                     val storage = StorageVector().apply {
@@ -253,7 +254,7 @@ class NavigationViewModel(
                             tagsAll = negentropySynchronizeRequest.synchronizationFilter.tagsAll,
                             since = negentropySynchronizeRequest.synchronizationFilter.since?.epochSeconds,
                             until = negentropySynchronizeRequest.synchronizationFilter.until?.epochSeconds,
-                            limit = negentropySynchronizeRequest.synchronizationFilter.limit,
+                            limit = null, // We don't do limits when performing negentropy...
                             search = negentropySynchronizeRequest.synchronizationFilter.search
                         ),
                         initialMessage = negentropy.initiate().toHexString()