Paginate getting bans

core/src/main/kotlin/supplier/CacheEntitySupplier.kt

@@ -198,9 +198,13 @@ public class CacheEntitySupplier(private val kord: Kord) : EntitySupplier {
         return Ban(data, kord)
     }
 
-    override fun getGuildBans(guildId: Snowflake): Flow<Ban> = cache.query<BanData> {
-        idEq(BanData::guildId, guildId)
-    }.asFlow().map { Ban(it, kord) }
+    override fun getGuildBans(guildId: Snowflake, limit: Int?): Flow<Ban> {
+        checkLimit(limit)
+        return cache.query<BanData> { idEq(BanData::guildId, guildId) }
+            .asFlow()
+            .map { Ban(it, kord) }
+            .limit(limit)
+    }
 
     override fun getGuildMembers(guildId: Snowflake, limit: Int?): Flow<Member> {
         checkLimit(limit)

core/src/main/kotlin/supplier/EntitySupplier.kt

@@ -288,7 +288,7 @@ public interface EntitySupplier {
      * The returned flow is lazily executed, any [RequestException] will be thrown on
      * [terminal operators](https://kotlinlang.org/docs/reference/coroutines/flow.html#terminal-flow-operators) instead.
      */
-    public fun getGuildBans(guildId: Snowflake): Flow<Ban>
+    public fun getGuildBans(guildId: Snowflake, limit: Int? = null): Flow<Ban>
 
     /**
      * Requests the [members][Member] of the [Guild] with the given [guildId].

core/src/main/kotlin/supplier/FallbackEntitySupplier.kt

@@ -76,8 +76,8 @@ private class FallbackEntitySupplier(val first: EntitySupplier, val second: Enti
     override suspend fun getGuildBanOrNull(guildId: Snowflake, userId: Snowflake): Ban? =
         first.getGuildBanOrNull(guildId, userId) ?: second.getGuildBanOrNull(guildId, userId)
 
-    override fun getGuildBans(guildId: Snowflake): Flow<Ban> =
-        first.getGuildBans(guildId).switchIfEmpty(second.getGuildBans(guildId))
+    override fun getGuildBans(guildId: Snowflake, limit: Int?): Flow<Ban> =
+        first.getGuildBans(guildId, limit).switchIfEmpty(second.getGuildBans(guildId, limit))
 
     override fun getGuildMembers(guildId: Snowflake, limit: Int?): Flow<Member> =
         first.getGuildMembers(guildId, limit).switchIfEmpty(second.getGuildMembers(guildId, limit))

core/src/main/kotlin/supplier/RestEntitySupplier.kt

@@ -161,10 +161,16 @@ public class RestEntitySupplier(public val kord: Kord) : EntitySupplier {
             emit(Role(RoleData.from(guildId, roleData), kord))
     }
 
-    override fun getGuildBans(guildId: Snowflake): Flow<Ban> = flow {
-        for (banData in guild.getGuildBans(guildId))
-            emit(Ban(BanData.from(guildId, banData), kord))
-    }
+    // maxBatchSize: see https://discord.com/developers/docs/resources/guild#get-guild-bans
+    override fun getGuildBans(guildId: Snowflake, limit: Int?): Flow<Ban> =
+        limitedPagination(limit, maxBatchSize = 1000) { batchSize ->
+            paginateForwards(batchSize, idSelector = { it.user.id }) { after ->
+                guild.getGuildBans(guildId, position = after, limit = batchSize)
+            }
+        }.map {
+            val data = BanData.from(guildId, it)
+            Ban(data, kord)
+        }
 
     // maxBatchSize: see https://discord.com/developers/docs/resources/guild#list-guild-members
     override fun getGuildMembers(guildId: Snowflake, limit: Int?): Flow<Member> =

core/src/main/kotlin/supplier/StoreEntitySupplier.kt

@@ -108,8 +108,8 @@ public class StoreEntitySupplier(
         return storeAndReturn(supplier.getGuildBanOrNull(guildId, userId)) { it.data }
     }
 
-    override fun getGuildBans(guildId: Snowflake): Flow<Ban> {
-        return storeOnEach(supplier.getGuildBans(guildId)) { it.data }
+    override fun getGuildBans(guildId: Snowflake, limit: Int?): Flow<Ban> {
+        return storeOnEach(supplier.getGuildBans(guildId, limit)) { it.data }
     }
 
     override fun getGuildMembers(guildId: Snowflake, limit: Int?): Flow<Member> {

rest/src/main/kotlin/service/GuildService.kt

@@ -192,8 +192,15 @@ public class GuildService(requestHandler: RequestHandler) : RestService(requestH
             auditLogReason(reason)
         }
 
-    public suspend fun getGuildBans(guildId: Snowflake): List<BanResponse> = call(Route.GuildBansGet) {
+    public suspend fun getGuildBans(
+        guildId: Snowflake,
+        position: Position.BeforeOrAfter? = null,
+        limit: Int? = null,
+    ): List<BanResponse> = call(Route.GuildBansGet) {
         keys[Route.GuildId] = guildId
+
+        limit?.let { parameter("limit", it) }
+        position?.let { parameter(it.key, it.value) }
     }
 
     public suspend fun getGuildBan(guildId: Snowflake, userId: Snowflake): BanResponse = call(Route.GuildBanGet) {