Create /media endpoint

native/kotlin/api/kotlin/build.gradle.kts

@@ -115,13 +115,13 @@ val generateUniFFIBindingsTask = tasks.register<Exec>("generateUniFFIBindings")
     inputs.dir("$cargoProjectRoot/$rustModuleName/")
 }
 
-
 tasks.named("compileKotlin").configure {
     dependsOn(generateUniFFIBindingsTask)
 }
 tasks.named("processIntegrationTestResources").configure {
     dependsOn(rootProject.tasks.named("copyDesktopJniLibs"))
     dependsOn(rootProject.tasks.named("copyTestCredentials"))
+    dependsOn(rootProject.tasks.named("copyTestMedia"))
 }
 
 project.afterEvaluate {

native/kotlin/api/kotlin/src/integrationTest/kotlin/IntegrationTestHelpers.kt

@@ -1,5 +1,7 @@
 package rs.wordpress.api.kotlin
 
+import okhttp3.OkHttpClient
+import okhttp3.Request
 import uniffi.wp_api.UserId
 import uniffi.wp_api.WpErrorCode
 
@@ -26,3 +28,9 @@ fun <T> WpRequestResult<T>.wpErrorCode(): WpErrorCode {
     assert(this is WpRequestResult.WpError)
     return (this as WpRequestResult.WpError).errorCode
 }
+
+fun restoreTestServer() {
+    OkHttpClient().newCall(
+        Request.Builder().url("http://localhost:4000/restore?db=true&plugins=true").build()
+    ).execute()
+}

native/kotlin/api/kotlin/src/integrationTest/kotlin/MediaEndpointTest.kt

@@ -3,9 +3,11 @@ package rs.wordpress.api.kotlin
 import kotlinx.coroutines.test.runTest
 import org.junit.jupiter.api.Assertions.assertNull
 import org.junit.jupiter.api.Test
+import uniffi.wp_api.MediaCreateParams
 import uniffi.wp_api.MediaListParams
 import uniffi.wp_api.SparseMediaFieldWithEditContext
 import uniffi.wp_api.wpAuthenticationFromUsernameAndPassword
+import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 
 private const val MEDIA_ID_611: Long = 611
@@ -63,4 +65,18 @@ class MediaEndpointTest {
         assertNotNull(sparseMedia)
         assertNull(sparseMedia.slug)
     }
+
+    @Test
+    fun testCreateMediaRequest() = runTest {
+        val title = "Testing media upload from Kotlin"
+        val response = client.request { requestBuilder ->
+            requestBuilder.media().create(
+                params = MediaCreateParams(title = title),
+                "test_media.jpg",
+                "image/jpg"
+            )
+        }.assertSuccessAndRetrieveData().data
+        assertEquals(title, response.title.rendered)
+        restoreTestServer()
+    }
 }

native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpApiClient.kt

@@ -42,6 +42,9 @@ constructor(
                     statusCode = exception.statusCode,
                     reason = exception.reason
                 )
+                is WpApiException.MediaFileNotFound -> WpRequestResult.MediaFileNotFound(
+                    filePath = exception.filePath
+                )
                 is WpApiException.ResponseParsingException -> WpRequestResult.ResponseParsingError(
                     reason = exception.reason,
                     response = exception.response,

native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpRequestExecutor.kt

@@ -3,13 +3,19 @@ package rs.wordpress.api.kotlin
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.MultipartBody
 import okhttp3.OkHttpClient
 import okhttp3.Request
+import okhttp3.RequestBody.Companion.asRequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
+import uniffi.wp_api.MediaUploadRequest
+import uniffi.wp_api.MediaUploadRequestExecutionException
 import uniffi.wp_api.RequestExecutor
 import uniffi.wp_api.WpNetworkHeaderMap
 import uniffi.wp_api.WpNetworkRequest
 import uniffi.wp_api.WpNetworkResponse
+import java.io.File
 
 class WpRequestExecutor(
     private val okHttpClient: OkHttpClient = OkHttpClient(),
@@ -29,6 +35,45 @@ class WpRequestExecutor(
                 }
             }
 
+            okHttpClient.newCall(requestBuilder.build()).execute().use { response ->
+                return@withContext WpNetworkResponse(
+                    body = response.body?.bytes() ?: ByteArray(0),
+                    statusCode = response.code.toUShort(),
+                    headerMap = WpNetworkHeaderMap.fromMultiMap(response.headers.toMultimap())
+                )
+            }
+        }
+
+    override suspend fun uploadMedia(mediaUploadRequest: MediaUploadRequest): WpNetworkResponse =
+        withContext(dispatcher) {
+            val requestBuilder = Request.Builder().url(mediaUploadRequest.url())
+            val multipartBodyBuilder = MultipartBody.Builder()
+                .setType(MultipartBody.FORM)
+            mediaUploadRequest.mediaParams().forEach { (k, v) ->
+                multipartBodyBuilder.addFormDataPart(k, v)
+            }
+            val filePath = mediaUploadRequest.filePath()
+            val file =
+                WpRequestExecutor::class.java.classLoader?.getResource(filePath)?.file?.let {
+                    File(
+                        it
+                    )
+                } ?: throw MediaUploadRequestExecutionException.MediaFileNotFound(filePath)
+            multipartBodyBuilder.addFormDataPart(
+                name = "file",
+                filename = file.name,
+                body = file.asRequestBody(mediaUploadRequest.fileContentType().toMediaType())
+            )
+            requestBuilder.method(
+                method = mediaUploadRequest.method().toString(),
+                body = multipartBodyBuilder.build()
+            )
+            mediaUploadRequest.headerMap().toMap().forEach { (key, values) ->
+                values.forEach { value ->
+                    requestBuilder.addHeader(key, value)
+                }
+            }
+
             okHttpClient.newCall(requestBuilder.build()).execute().use { response ->
                 return@withContext WpNetworkResponse(
                     body = response.body?.bytes() ?: ByteArray(0),

native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpRequestResult.kt

@@ -20,6 +20,10 @@ sealed class WpRequestResult<T> {
         val reason: String,
     ) : WpRequestResult<T>()
 
+    class MediaFileNotFound<T>(
+        val filePath: String
+    ) : WpRequestResult<T>()
+
     class SiteUrlParsingError<T>(
         val reason: String,
     ) : WpRequestResult<T>()

native/kotlin/build.gradle.kts

@@ -77,10 +77,21 @@ fun setupJniAndBindings() {
         into(jniLibsPath)
     }
 
+    tasks.register<Delete>("deleteTestResources") {
+        delete = setOf(generatedTestResourcesPath)
+    }
+
     tasks.register<Copy>("copyTestCredentials") {
+        dependsOn(tasks.named("deleteTestResources"))
         from("$cargoProjectRoot/test_credentials.json")
         into(generatedTestResourcesPath)
     }
+
+    tasks.register<Copy>("copyTestMedia") {
+        dependsOn(tasks.named("deleteTestResources"))
+        from("$cargoProjectRoot/test_media.jpg")
+        into(generatedTestResourcesPath)
+    }
 }
 
 fun getNativeLibraryExtension(): String {

native/swift/Sources/wordpress-api/Exports.swift

@@ -90,6 +90,7 @@ public typealias PostsRequestListWithEmbedContextResponse = WordPressAPIInternal
 
 // MARK: - Media
 public typealias SparseMedia = WordPressAPIInternal.SparseMedia
+public typealias MediaUploadRequest = WordPressAPIInternal.MediaUploadRequest
 public typealias MediaWithEditContext = WordPressAPIInternal.MediaWithEditContext
 public typealias MediaWithViewContext = WordPressAPIInternal.MediaWithViewContext
 public typealias MediaWithEmbedContext = WordPressAPIInternal.MediaWithEmbedContext

native/swift/Sources/wordpress-api/SafeRequestExecutor.swift

@@ -20,7 +20,11 @@ extension SafeRequestExecutor {
 
 }
 
-extension URLSession: RequestExecutor {}
+extension URLSession: RequestExecutor {
+    public func uploadMedia(mediaUploadRequest: MediaUploadRequest) async throws -> WpNetworkResponse {
+        try WpNetworkResponse(body: Data(), statusCode: 500, headerMap: .fromMap(hashMap: [:]))
+    }
+}
 
 extension URLSession: SafeRequestExecutor {
 

native/swift/Tests/wordpress-api/Support/HTTPStubs.swift

@@ -30,6 +30,10 @@ final class HTTPStubs: SafeRequestExecutor {
         }
     }
 
+    func uploadMedia(mediaUploadRequest: MediaUploadRequest) async throws -> WpNetworkResponse {
+        try WpNetworkResponse(body: Data(), statusCode: 500, headerMap: .fromMap(hashMap: [:]))
+    }
+
     private func stub(for request: WpNetworkRequest) -> WpNetworkResponse? {
         stubs.first { stub in stub.condition(request) }?
             .response

wp_api/src/api_error.rs

@@ -23,6 +23,8 @@ pub enum WpApiError {
         status_code: Option<u16>,
         reason: String,
     },
+    #[error("Media file not found at file path: {}", file_path)]
+    MediaFileNotFound { file_path: String },
     #[error("Error while parsing. \nReason: {}\nResponse: {}", reason, response)]
     ResponseParsingError { reason: String, response: String },
     #[error("Error while parsing site url: {}", reason)]
@@ -320,6 +322,21 @@ pub enum RequestExecutionError {
     },
 }
 
+#[derive(Debug, PartialEq, Eq, thiserror::Error, uniffi::Error)]
+pub enum MediaUploadRequestExecutionError {
+    #[error(
+        "Request execution failed!\nStatus Code: '{:?}'.\nResponse: '{}'",
+        status_code,
+        reason
+    )]
+    RequestExecutionFailed {
+        status_code: Option<u16>,
+        reason: String,
+    },
+    #[error("Media file not found at file path: {}", file_path)]
+    MediaFileNotFound { file_path: String },
+}
+
 impl From<RequestExecutionError> for WpApiError {
     fn from(value: RequestExecutionError) -> Self {
         match value {
@@ -333,3 +350,20 @@ impl From<RequestExecutionError> for WpApiError {
         }
     }
 }
+
+impl From<MediaUploadRequestExecutionError> for WpApiError {
+    fn from(value: MediaUploadRequestExecutionError) -> Self {
+        match value {
+            MediaUploadRequestExecutionError::RequestExecutionFailed {
+                status_code,
+                reason,
+            } => Self::RequestExecutionFailed {
+                status_code,
+                reason,
+            },
+            MediaUploadRequestExecutionError::MediaFileNotFound { file_path } => {
+                Self::MediaFileNotFound { file_path }
+            }
+        }
+    }
+}

wp_api/src/lib.rs

@@ -1,7 +1,10 @@
 #![allow(dead_code, unused_variables)]
 
 pub use api_client::{WpApiClient, WpApiRequestBuilder};
-pub use api_error::{ParsedRequestError, RequestExecutionError, WpApiError, WpError, WpErrorCode};
+pub use api_error::{
+    MediaUploadRequestExecutionError, ParsedRequestError, RequestExecutionError, WpApiError,
+    WpError, WpErrorCode,
+};
 pub use parsed_url::{ParseUrlError, ParsedUrl};
 use plugins::*;
 use serde::{Deserialize, Serialize};