refactor: remove the two-lambda CursorPaginationStrategy constructor

The single-pass (Response) -> CursorResult extractor is now the only way
to construct the strategy. The two-lambda form drained the single-use
response body twice per page and only existed for back-compat; drop it
outright rather than deprecate.

Author: OmarAlJarrah

sdk-core/api/sdk-core.api

@@ -1963,9 +1963,6 @@ public final class org/dexpace/sdk/core/pagination/CursorPaginationStrategy : or
 	public fun <init> (Lkotlin/jvm/functions/Function1;)V
 	public fun <init> (Lkotlin/jvm/functions/Function1;Ljava/lang/String;)V
 	public synthetic fun <init> (Lkotlin/jvm/functions/Function1;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public fun <init> (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;)V
-	public fun <init> (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Ljava/lang/String;)V
-	public synthetic fun <init> (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun parse (Lorg/dexpace/sdk/core/http/response/Response;Lorg/dexpace/sdk/core/http/request/Request;)Lorg/dexpace/sdk/core/pagination/Page;
 }
 

sdk-core/src/main/kotlin/org/dexpace/sdk/core/pagination/CursorPaginationStrategy.kt

@@ -47,37 +47,6 @@ public class CursorPaginationStrategy<T>
         private val extractor: (Response) -> CursorResult<T>,
         private val cursorQueryParam: String = "cursor",
     ) : PaginationStrategy<T> {
-        /**
-         * Creates a strategy from two body-reading lambdas.
-         *
-         * @deprecated Each lambda drains the single-use response body separately, so the body
-         *   is read twice per page. Use the single-pass [extractor] constructor that returns a
-         *   [CursorResult] instead.
-         */
-        @Deprecated(
-            message =
-                "Two body-reading lambdas drain the single-use response body twice per page. " +
-                    "Pass a single extractor returning a CursorResult instead. The suggested " +
-                    "replacement only changes the API shape: collapse the two lambdas into one " +
-                    "that reads the body a single time, otherwise it still double-drains.",
-            replaceWith =
-                ReplaceWith(
-                    "CursorPaginationStrategy({ response -> " +
-                        "CursorResult(itemsExtractor(response), cursorExtractor(response)) }, " +
-                        "cursorQueryParam)",
-                    "org.dexpace.sdk.core.pagination.CursorResult",
-                ),
-        )
-        @JvmOverloads
-        public constructor(
-            itemsExtractor: (Response) -> List<T>,
-            cursorExtractor: (Response) -> String?,
-            cursorQueryParam: String = "cursor",
-        ) : this(
-            extractor = { response -> CursorResult(itemsExtractor(response), cursorExtractor(response)) },
-            cursorQueryParam = cursorQueryParam,
-        )
-
         override fun parse(
             response: Response,
             initialRequest: Request,

sdk-core/src/test/kotlin/org/dexpace/sdk/core/pagination/CursorSingleReadTest.kt

@@ -14,7 +14,6 @@ import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 import kotlin.test.assertNull
 
 /**
@@ -107,63 +106,6 @@ class CursorSingleReadTest {
         assertNull(end.nextCursor)
     }
 
-    @Test
-    @Suppress("DEPRECATION")
-    fun `deprecated two-lambda constructor still paginates for back-compat`() {
-        // The legacy two-lambda constructor is retained but deprecated; it delegates to the
-        // single-pass path. This proves existing callers keep working. The two lambdas read
-        // disjoint parts of the response (items from the body, cursor from a header) so the
-        // single-use body is not the thing being drained twice — that double-drain trap is
-        // exactly what the deprecation steers callers away from.
-        val client = StubHttpClient()
-        client.on("https://api.example.com/items") { req ->
-            textResponse(req, "a,b", extraHeaders = mapOf("X-Next-Cursor" to "more"))
-        }
-        client.on("https://api.example.com/items?cursor=more") { req ->
-            textResponse(req, "c")
-        }
-
-        val itemsExtractor: (Response) -> List<String> = { resp ->
-            val body = resp.body!!.source().use { it.readUtf8() }
-            if (body.isEmpty()) emptyList() else body.split(",")
-        }
-        val cursorExtractor: (Response) -> String? = { resp ->
-            resp.headers.get("X-Next-Cursor")
-        }
-
-        val strategy = CursorPaginationStrategy(itemsExtractor, cursorExtractor)
-        val paginator = Paginator(client, initialRequest(), strategy)
-
-        assertEquals(listOf("a", "b", "c"), paginator.iterateAll().toList())
-        assertEquals(2, client.callCount)
-    }
-
-    @Test
-    @Suppress("DEPRECATION")
-    fun `deprecated two-lambda constructor double-drains when both lambdas read the body`() {
-        // Documents the hazard the single-pass API exists to remove: when both legacy lambdas
-        // read the body, the single-use response is drained twice and the second read fails.
-        val client = StubHttpClient()
-        client.on("https://api.example.com/items") { req ->
-            singleUseResponse(req, "items=a,b\ncursor=")
-        }
-
-        val itemsExtractor: (Response) -> List<String> = { resp ->
-            val body = resp.body!!.source().use { it.readUtf8() }
-            body.substringAfter("items=").substringBefore('\n').split(",")
-        }
-        val cursorExtractor: (Response) -> String? = { resp ->
-            // Second read of the same single-use body — this is the double-drain.
-            resp.body!!.source().use { it.readUtf8() }
-            null
-        }
-
-        val strategy = CursorPaginationStrategy(itemsExtractor, cursorExtractor)
-        val paginator = Paginator(client, initialRequest(), strategy)
-
-        assertFailsWith<IllegalStateException> { paginator.iterateAll().toList() }
-    }
-
     @Test
     fun `single read extractor honours a custom cursor query param`() {
         val client = StubHttpClient()