Improve ergonomics for Kotlin wrapper (#744)

oguzkocer · web-flow · commit b1a6e1dd42ce · 2025-05-27T12:41:46.000-06:00
* Rename to `WpRequestResult.Success.response`

* Add a `successfulResponse` helper to `WpRequestResult`

* Limit `ParsedUrl`'s Kotlin exposure by using `java.net.URL`

* Publish Kotlin sources
diff --git a/native/kotlin/api/android/src/androidTest/kotlin/rs/wordpress/api/android/UsersEndpointAndroidTest.kt b/native/kotlin/api/android/src/androidTest/kotlin/rs/wordpress/api/android/UsersEndpointAndroidTest.kt
@@ -4,20 +4,20 @@ import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import rs.wordpress.api.kotlin.WpApiClient
 import rs.wordpress.api.kotlin.WpRequestResult
-import uniffi.wp_api.ParsedUrl
 import uniffi.wp_api.UserListParams
 import uniffi.wp_api.WpAuthenticationProvider
+import java.net.URL
 
 class UsersEndpointAndroidTest {
     // https://developer.android.com/studio/run/emulator-networking
     private val siteUrl = "http://10.0.2.2"
-    private val client = WpApiClient(ParsedUrl.parse(siteUrl), WpAuthenticationProvider.none())
+    private val client = WpApiClient(URL(siteUrl), WpAuthenticationProvider.none())
 
     @Test
     fun testUserListRequest() = runTest {
         val result = client.request { requestBuilder ->
             requestBuilder.users().listWithViewContext(params = UserListParams())
         }
-        assert(result is WpRequestResult.WpRequestSuccess)
+        assert(result is WpRequestResult.Success)
     }
 }
diff --git a/native/kotlin/api/kotlin/build.gradle.kts b/native/kotlin/api/kotlin/build.gradle.kts
@@ -8,6 +8,9 @@ plugins {
 }
 
 java {
+    withJavadocJar()
+    withSourcesJar()
+
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
     toolchain {
@@ -124,6 +127,9 @@ tasks.named("processIntegrationTestResources").configure {
     dependsOn(rootProject.tasks.named("copyTestMedia"))
     dependsOn(rootProject.tasks.named("copySampleJSON"))
 }
+tasks.named("sourcesJar").configure {
+    dependsOn(generateUniFFIBindingsTask)
+}
 
 project.afterEvaluate {
     publishing {
diff --git a/native/kotlin/api/kotlin/src/integrationTest/kotlin/IntegrationTestHelpers.kt b/native/kotlin/api/kotlin/src/integrationTest/kotlin/IntegrationTestHelpers.kt
@@ -25,14 +25,14 @@ fun defaultApiClient(): WpApiClient {
 }
 
 fun <T> WpRequestResult<T>.assertSuccess() {
-    assert(this is WpRequestResult.WpRequestSuccess)
+    assert(this is WpRequestResult.Success)
 }
 
 fun <T> WpRequestResult<T>.assertSuccessAndRetrieveData(): T {
-    assert(this is WpRequestResult.WpRequestSuccess) {
+    assert(this is WpRequestResult.Success) {
         "Request wasn't successful: $this"
     }
-    return (this as WpRequestResult.WpRequestSuccess).data
+    return (this as WpRequestResult.Success).response
 }
 
 fun <T> WpRequestResult<T>.wpErrorCode(): WpErrorCode {
diff --git a/native/kotlin/api/kotlin/src/integrationTest/kotlin/ManualParserTest.kt b/native/kotlin/api/kotlin/src/integrationTest/kotlin/ManualParserTest.kt
@@ -2,6 +2,7 @@ package rs.wordpress.api.kotlin
 
 import kotlinx.coroutines.test.runTest
 import org.junit.jupiter.api.Test
+import uniffi.wp_api.ParsedUrl
 import uniffi.wp_api.UniffiWpApiRequestBuilder
 import uniffi.wp_api.UserListParams
 import uniffi.wp_api.WpAuthenticationProvider
@@ -19,7 +20,7 @@ class ManualParserTest {
     @Test
     fun testUserListManualRequestAndParsing() = runTest {
         val requestBuilder = UniffiWpApiRequestBuilder(
-            apiUrlResolver = WpOrgSiteApiUrlResolver(apiRootUrl = testCredentials.apiRootUrl),
+            apiUrlResolver = WpOrgSiteApiUrlResolver(apiRootUrl = ParsedUrl(testCredentials.apiRootUrl)),
             authProvider
         )
         val userListRequest = requestBuilder.users().listWithEditContext(UserListParams())
diff --git a/native/kotlin/api/kotlin/src/integrationTest/kotlin/TestCredentials.kt b/native/kotlin/api/kotlin/src/integrationTest/kotlin/TestCredentials.kt
@@ -3,8 +3,8 @@ package rs.wordpress.api.kotlin
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
-import uniffi.wp_api.ParsedUrl
 import java.io.File
+import java.net.URL
 import java.text.SimpleDateFormat
 import java.util.TimeZone
 
@@ -44,5 +44,5 @@ data class TestCredentials(
         }
     }
 
-    val apiRootUrl by lazy { ParsedUrl.parse("$siteUrl/wp-json") }
+    val apiRootUrl by lazy { URL("$siteUrl/wp-json") }
 }
diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/ApiDiscoveryResult.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/ApiDiscoveryResult.kt
@@ -4,20 +4,20 @@ import uniffi.wp_api.AutoDiscoveryAttemptSuccess
 import uniffi.wp_api.FetchAndParseApiRootFailure
 import uniffi.wp_api.FindApiRootFailure
 import uniffi.wp_api.ParseUrlException
-import uniffi.wp_api.ParsedUrl
+import java.net.URL
 
 sealed class ApiDiscoveryResult {
     data class Success(val success: AutoDiscoveryAttemptSuccess) : ApiDiscoveryResult()
     data class FailureParseSiteUrl(
         val error: ParseUrlException
     ) : ApiDiscoveryResult()
     data class FailureFindApiRoot(
-        val parsedSiteUrl: ParsedUrl,
+        val parsedSiteUrl: URL,
         val findApiRootFailure: FindApiRootFailure
     ) : ApiDiscoveryResult()
     data class FailureFetchAndParseApiRoot(
-        val parsedSiteUrl: ParsedUrl,
-        val apiRootUrl: ParsedUrl,
+        val parsedSiteUrl: URL,
+        val apiRootUrl: URL,
         val fetchAndParseApiRootFailure: FetchAndParseApiRootFailure
     ) : ApiDiscoveryResult()
 }
diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/JetpackApiClient.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/JetpackApiClient.kt
@@ -13,6 +13,7 @@ import uniffi.wp_api.WpApiMiddlewarePipeline
 import uniffi.wp_api.WpAppNotifier
 import uniffi.wp_api.WpAuthenticationProvider
 import uniffi.wp_api.WpOrgSiteApiUrlResolver
+import java.net.URL
 
 class JetpackApiClient(
     apiUrlResolver: ApiUrlResolver,
@@ -22,13 +23,13 @@ class JetpackApiClient(
     private val dispatcher: CoroutineDispatcher = Dispatchers.IO
 ) {
     constructor(
-        wpOrgSiteApiRootUrl: ParsedUrl,
+        wpOrgSiteApiRootUrl: URL,
         authProvider: WpAuthenticationProvider,
         requestExecutor: RequestExecutor = WpRequestExecutor(),
         appNotifier: WpAppNotifier = EmptyAppNotifier(),
         dispatcher: CoroutineDispatcher = Dispatchers.IO
     ) : this(
-        apiUrlResolver = WpOrgSiteApiUrlResolver(apiRootUrl = wpOrgSiteApiRootUrl),
+        apiUrlResolver = WpOrgSiteApiUrlResolver(apiRootUrl = ParsedUrl.parse(wpOrgSiteApiRootUrl.toString())),
         authProvider,
         requestExecutor,
         appNotifier,
@@ -58,7 +59,7 @@ class JetpackApiClient(
         executeRequest: suspend (UniffiJetpackApiClient) -> T
     ): WpRequestResult<T> = withContext(dispatcher) {
         try {
-            WpRequestResult.WpRequestSuccess(data = executeRequest(requestBuilder))
+            WpRequestResult.Success(response = executeRequest(requestBuilder))
         } catch (exception: WpApiException) {
             mapWpApiExceptionToWpRequestResult(exception)
         }
diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/ParsedUrl.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/ParsedUrl.kt
@@ -0,0 +1,8 @@
+package rs.wordpress.api.kotlin
+
+import uniffi.wp_api.ParsedUrl
+import java.net.URL
+
+operator fun ParsedUrl.Companion.invoke(url: URL) = parse(url.toString())
+
+fun ParsedUrl.toURL(): URL = URL(this.url())
diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpApiClient.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpApiClient.kt
@@ -13,6 +13,7 @@ import uniffi.wp_api.WpApiMiddlewarePipeline
 import uniffi.wp_api.WpAppNotifier
 import uniffi.wp_api.WpAuthenticationProvider
 import uniffi.wp_api.WpOrgSiteApiUrlResolver
+import java.net.URL
 
 class WpApiClient(
     apiUrlResolver: ApiUrlResolver,
@@ -22,13 +23,13 @@ class WpApiClient(
     private val dispatcher: CoroutineDispatcher = Dispatchers.IO
 ) {
     constructor(
-        wpOrgSiteApiRootUrl: ParsedUrl,
+        wpOrgSiteApiRootUrl: URL,
         authProvider: WpAuthenticationProvider,
         requestExecutor: RequestExecutor = WpRequestExecutor(),
         appNotifier: WpAppNotifier = EmptyAppNotifier(),
         dispatcher: CoroutineDispatcher = Dispatchers.IO
     ) : this(
-        apiUrlResolver = WpOrgSiteApiUrlResolver(apiRootUrl = wpOrgSiteApiRootUrl),
+        apiUrlResolver = WpOrgSiteApiUrlResolver(apiRootUrl = ParsedUrl.parse(wpOrgSiteApiRootUrl.toString())),
         authProvider,
         requestExecutor,
         appNotifier,
@@ -58,7 +59,7 @@ class WpApiClient(
         executeRequest: suspend (UniffiWpApiClient) -> T
     ): WpRequestResult<T> = withContext(dispatcher) {
         try {
-            WpRequestResult.WpRequestSuccess(data = executeRequest(requestBuilder))
+            WpRequestResult.Success(response = executeRequest(requestBuilder))
         } catch (exception: WpApiException) {
             mapWpApiExceptionToWpRequestResult(exception)
         }
diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpComApiClient.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpComApiClient.kt
@@ -39,7 +39,7 @@ class WpComApiClient(
         executeRequest: suspend (UniffiWpComApiClient) -> T
     ): WpRequestResult<T> = withContext(dispatcher) {
         try {
-            WpRequestResult.WpRequestSuccess(data = executeRequest(requestBuilder))
+            WpRequestResult.Success(response = executeRequest(requestBuilder))
         } catch (exception: WpApiException) {
             mapWpApiExceptionToWpRequestResult(exception)
         }
diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpLoginClient.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpLoginClient.kt
@@ -28,13 +28,13 @@ class WpLoginClient(
                     error = exception.error,
                 )
                 is AutoDiscoveryAttemptFailure.FindApiRoot -> ApiDiscoveryResult.FailureFindApiRoot(
-                    parsedSiteUrl = exception.parsedSiteUrl,
+                    parsedSiteUrl = exception.parsedSiteUrl.toURL(),
                     findApiRootFailure = exception.findApiRootFailure,
                 )
 
                 is AutoDiscoveryAttemptFailure.FetchAndParseApiRoot -> ApiDiscoveryResult.FailureFetchAndParseApiRoot(
-                    parsedSiteUrl = exception.parsedSiteUrl,
-                    apiRootUrl = exception.apiRootUrl,
+                    parsedSiteUrl = exception.parsedSiteUrl.toURL(),
+                    apiRootUrl = exception.apiRootUrl.toURL(),
                     fetchAndParseApiRootFailure = exception.fetchAndParseApiRootFailure
                 )
             }
diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpRequestResult.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpRequestResult.kt
@@ -5,7 +5,7 @@ import uniffi.wp_api.WpErrorCode
 import uniffi.wp_api.WpRedirect
 
 sealed class WpRequestResult<T> {
-    data class WpRequestSuccess<T>(val data: T) : WpRequestResult<T>()
+    data class Success<T>(val response: T) : WpRequestResult<T>()
     data class WpError<T>(
         val errorCode: WpErrorCode,
         val errorMessage: String,
@@ -40,4 +40,10 @@ sealed class WpRequestResult<T> {
         val statusCode: UShort,
         val response: String,
     ) : WpRequestResult<T>()
+
+    fun successfulResponse(): T? =
+        when (this) {
+            is Success -> this.response
+            else -> null
+        }
 }
diff --git a/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/domain/AuthenticatedSite.kt b/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/domain/AuthenticatedSite.kt
@@ -1,5 +1,5 @@
 package rs.wordpress.example.shared.domain
 
-import uniffi.wp_api.ParsedUrl
+import java.net.URL
 
-data class AuthenticatedSite(val name: String, val apiRootUrl: ParsedUrl)
+data class AuthenticatedSite(val name: String, val apiRootUrl: URL)
diff --git a/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/repository/AuthenticationRepository.kt b/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/repository/AuthenticationRepository.kt
@@ -1,9 +1,9 @@
 package rs.wordpress.example.shared.repository
 
 import rs.wordpress.example.shared.domain.AuthenticatedSite
-import uniffi.wp_api.ParsedUrl
 import uniffi.wp_api.WpAuthentication
 import uniffi.wp_api.wpAuthenticationFromUsernameAndPassword
+import java.net.URL
 
 class AuthenticationRepository(
     localTestSiteUrl: String,
@@ -14,16 +14,16 @@ class AuthenticationRepository(
 
     init {
         addAuthenticatedSite(
-            ParsedUrl.parse(localTestSiteUrl),
-            ParsedUrl.parse("$localTestSiteUrl/wp-json"),
+            URL(localTestSiteUrl),
+            URL("$localTestSiteUrl/wp-json"),
             localTestSiteUsername,
             localTestSitePassword
         )
     }
 
-    fun addAuthenticatedSite(siteUrl: ParsedUrl, apiRootUrl: ParsedUrl, username: String, password: String): Boolean {
+    fun addAuthenticatedSite(siteUrl: URL, apiRootUrl: URL, username: String, password: String): Boolean {
         if (username.isNotEmpty() && password.isNotEmpty()) {
-            authenticatedSites[AuthenticatedSite(name = siteUrl.url(), apiRootUrl)] =
+            authenticatedSites[AuthenticatedSite(name = siteUrl.toString(), apiRootUrl)] =
                 wpAuthenticationFromUsernameAndPassword(username, password)
             return true
         }
diff --git a/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/ui/plugins/PluginListViewModel.kt b/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/ui/plugins/PluginListViewModel.kt
@@ -30,7 +30,7 @@ class PluginListViewModel(private val authRepository: AuthenticationRepository)
                 }
             }
             return when (pluginsResult) {
-                is WpRequestResult.WpRequestSuccess -> pluginsResult.data.data
+                is WpRequestResult.Success -> pluginsResult.response.data
                 else -> listOf()
             }
         }
diff --git a/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/ui/users/UserListViewModel.kt b/native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/ui/users/UserListViewModel.kt
@@ -30,7 +30,7 @@ class UserListViewModel(private val authRepository: AuthenticationRepository) {
                 }
             }
             return when (usersResult) {
-                is WpRequestResult.WpRequestSuccess -> usersResult.data.data
+                is WpRequestResult.Success -> usersResult.response.data
                 else -> throw IllegalStateException("User list request should succeed: $usersResult")
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,14 @@ fun defaultApiClient(): WpApiClient {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`fun <T> WpRequestResult<T>.assertSuccess() {`
`28`		`- assert(this is WpRequestResult.WpRequestSuccess)`
	`28`	`+ assert(this is WpRequestResult.Success)`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`fun <T> WpRequestResult<T>.assertSuccessAndRetrieveData(): T {`
`32`		`- assert(this is WpRequestResult.WpRequestSuccess) {`
	`32`	`+ assert(this is WpRequestResult.Success) {`
`33`	`33`	`"Request wasn't successful: $this"`
`34`	`34`	`}`
`35`		`- return (this as WpRequestResult.WpRequestSuccess).data`
	`35`	`+ return (this as WpRequestResult.Success).response`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`fun <T> WpRequestResult<T>.wpErrorCode(): WpErrorCode {`
Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,8 @@ package rs.wordpress.api.kotlin`
`3`	`3`	`import kotlinx.serialization.SerialName`
`4`	`4`	`import kotlinx.serialization.Serializable`
`5`	`5`	`import kotlinx.serialization.json.Json`
`6`		`-import uniffi.wp_api.ParsedUrl`
`7`	`6`	`import java.io.File`
	`7`	`+import java.net.URL`
`8`	`8`	`import java.text.SimpleDateFormat`
`9`	`9`	`import java.util.TimeZone`
`10`	`10`
`@@ -44,5 +44,5 @@ data class TestCredentials(`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- val apiRootUrl by lazy { ParsedUrl.parse("$siteUrl/wp-json") }`
	`47`	`+ val apiRootUrl by lazy { URL("$siteUrl/wp-json") }`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ class WpComApiClient(`
`39`	`39`	`executeRequest: suspend (UniffiWpComApiClient) -> T`
`40`	`40`	`): WpRequestResult<T> = withContext(dispatcher) {`
`41`	`41`	`try {`
`42`		`- WpRequestResult.WpRequestSuccess(data = executeRequest(requestBuilder))`
	`42`	`+ WpRequestResult.Success(response = executeRequest(requestBuilder))`
`43`	`43`	`} catch (exception: WpApiException) {`
`44`	`44`	`mapWpApiExceptionToWpRequestResult(exception)`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,13 +28,13 @@ class WpLoginClient(`
`28`	`28`	`error = exception.error,`
`29`	`29`	`)`
`30`	`30`	`is AutoDiscoveryAttemptFailure.FindApiRoot -> ApiDiscoveryResult.FailureFindApiRoot(`
`31`		`- parsedSiteUrl = exception.parsedSiteUrl,`
	`31`	`+ parsedSiteUrl = exception.parsedSiteUrl.toURL(),`
`32`	`32`	`findApiRootFailure = exception.findApiRootFailure,`
`33`	`33`	`)`
`34`	`34`
`35`	`35`	`is AutoDiscoveryAttemptFailure.FetchAndParseApiRoot -> ApiDiscoveryResult.FailureFetchAndParseApiRoot(`
`36`		`- parsedSiteUrl = exception.parsedSiteUrl,`
`37`		`- apiRootUrl = exception.apiRootUrl,`
	`36`	`+ parsedSiteUrl = exception.parsedSiteUrl.toURL(),`
	`37`	`+ apiRootUrl = exception.apiRootUrl.toURL(),`
`38`	`38`	`fetchAndParseApiRootFailure = exception.fetchAndParseApiRootFailure`
`39`	`39`	`)`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class PluginListViewModel(private val authRepository: AuthenticationRepository)`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`return when (pluginsResult) {`
`33`		`- is WpRequestResult.WpRequestSuccess -> pluginsResult.data.data`
	`33`	`+ is WpRequestResult.Success -> pluginsResult.response.data`
`34`	`34`	`else -> listOf()`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class UserListViewModel(private val authRepository: AuthenticationRepository) {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`return when (usersResult) {`
`33`		`- is WpRequestResult.WpRequestSuccess -> usersResult.data.data`
	`33`	`+ is WpRequestResult.Success -> usersResult.response.data`
`34`	`34`	`else -> throw IllegalStateException("User list request should succeed: $usersResult")`
`35`	`35`	`}`
`36`	`36`	`}`