chore(client)!: refactor multipart formdata impl (#296)

chore(internal): move `HttpRequestBodies` file
chore(internal): extract function for checking for lists in json fields
# Migration
1. Builder methods that used to take `contentType` and `filename` as positional parameters after the main argument now no longer do. To set a custom `contentType` or `filename`, pass `MultipartField`, which can be constructed via `MultipartField.builder()`.
2. It's unlikely you were referencing it, but `MultipartFormValue` is now called `MultipartField` if you were.

Author: stainless-app[bot]

orb-java-core/src/main/kotlin/com/withorb/api/core/Check.kt

@@ -5,6 +5,18 @@ package com.withorb.api.core
 fun <T : Any> checkRequired(name: String, value: T?): T =
     checkNotNull(value) { "`$name` is required, but was not set" }
 
+@JvmSynthetic
+internal fun <T : Any> checkKnown(name: String, value: JsonField<T>): T =
+    value.asKnown().orElseThrow {
+        IllegalStateException("`$name` is not a known type: ${value.javaClass.simpleName}")
+    }
+
+@JvmSynthetic
+internal fun <T : Any> checkKnown(name: String, value: MultipartField<T>): T =
+    value.value.asKnown().orElseThrow {
+        IllegalStateException("`$name` is not a known type: ${value.javaClass.simpleName}")
+    }
+
 @JvmSynthetic
 internal fun checkLength(name: String, value: String, length: Int): String =
     value.also {

orb-java-core/src/main/kotlin/com/withorb/api/core/HttpRequestBodies.kt

@@ -27,10 +27,8 @@ import com.fasterxml.jackson.databind.node.JsonNodeType.POJO
 import com.fasterxml.jackson.databind.node.JsonNodeType.STRING
 import com.fasterxml.jackson.databind.ser.std.NullSerializer
 import com.withorb.api.errors.OrbInvalidDataException
-import java.nio.charset.Charset
 import java.util.Objects
 import java.util.Optional
-import org.apache.hc.core5.http.ContentType
 
 @JsonDeserialize(using = JsonField.Deserializer::class)
 sealed class JsonField<out T : Any> {
@@ -287,12 +285,12 @@ private constructor(
             return true
         }
 
-        return other is KnownValue<*> && value == other.value
+        return other is KnownValue<*> && value contentEquals other.value
     }
 
-    override fun hashCode() = value.hashCode()
+    override fun hashCode() = contentHash(value)
 
-    override fun toString() = value.toString()
+    override fun toString() = value.contentToString()
 
     companion object {
         @JsonCreator @JvmStatic fun <T : Any> of(value: T) = KnownValue(value)
@@ -462,15 +460,63 @@ annotation class ExcludeMissing
 )
 annotation class NoAutoDetect
 
-class MultipartFormValue<T>
-internal constructor(
-    val name: String,
-    val value: T,
-    val contentType: ContentType,
-    val filename: String? = null,
+class MultipartField<T : Any>
+private constructor(
+    @get:JvmName("value") val value: JsonField<T>,
+    @get:JvmName("contentType") val contentType: String,
+    private val filename: String?,
 ) {
 
-    private val hashCode: Int by lazy { contentHash(name, value, contentType, filename) }
+    companion object {
+
+        @JvmStatic fun <T : Any> of(value: T?) = builder<T>().value(value).build()
+
+        @JvmStatic fun <T : Any> of(value: JsonField<T>) = builder<T>().value(value).build()
+
+        @JvmStatic fun <T : Any> builder() = Builder<T>()
+    }
+
+    fun filename(): Optional<String> = Optional.ofNullable(filename)
+
+    @JvmSynthetic
+    internal fun <R : Any> map(transform: (T) -> R): MultipartField<R> =
+        MultipartField.builder<R>()
+            .value(value.map(transform))
+            .contentType(contentType)
+            .filename(filename)
+            .build()
+
+    /** A builder for [MultipartField]. */
+    class Builder<T : Any> internal constructor() {
+
+        private var value: JsonField<T>? = null
+        private var contentType: String? = null
+        private var filename: String? = null
+
+        fun value(value: JsonField<T>) = apply { this.value = value }
+
+        fun value(value: T?) = value(JsonField.ofNullable(value))
+
+        fun contentType(contentType: String) = apply { this.contentType = contentType }
+
+        fun filename(filename: String?) = apply { this.filename = filename }
+
+        fun filename(filename: Optional<String>) = filename(filename.orElse(null))
+
+        fun build(): MultipartField<T> {
+            val value = checkRequired("value", value)
+            return MultipartField(
+                value,
+                contentType
+                    ?: if (value is KnownValue && value.value is ByteArray)
+                        "application/octet-stream"
+                    else "text/plain; charset=utf-8",
+                filename,
+            )
+        }
+    }
+
+    private val hashCode: Int by lazy { contentHash(value, contentType, filename) }
 
     override fun hashCode(): Int = hashCode
 
@@ -479,63 +525,12 @@ internal constructor(
             return true
         }
 
-        return other is MultipartFormValue<*> &&
-            name == other.name &&
-            value contentEquals other.value &&
+        return other is MultipartField<*> &&
+            value == other.value &&
             contentType == other.contentType &&
             filename == other.filename
     }
 
     override fun toString(): String =
-        "MultipartFormValue{name=$name, contentType=$contentType, filename=$filename, value=${valueToString()}}"
-
-    private fun valueToString(): String =
-        when (value) {
-            is ByteArray -> "ByteArray of size ${value.size}"
-            else -> value.toString()
-        }
-
-    companion object {
-        internal fun fromString(
-            name: String,
-            value: String,
-            contentType: ContentType,
-        ): MultipartFormValue<String> = MultipartFormValue(name, value, contentType)
-
-        internal fun fromBoolean(
-            name: String,
-            value: Boolean,
-            contentType: ContentType,
-        ): MultipartFormValue<Boolean> = MultipartFormValue(name, value, contentType)
-
-        internal fun fromLong(
-            name: String,
-            value: Long,
-            contentType: ContentType,
-        ): MultipartFormValue<Long> = MultipartFormValue(name, value, contentType)
-
-        internal fun fromDouble(
-            name: String,
-            value: Double,
-            contentType: ContentType,
-        ): MultipartFormValue<Double> = MultipartFormValue(name, value, contentType)
-
-        internal fun <T : Enum> fromEnum(
-            name: String,
-            value: T,
-            contentType: ContentType,
-        ): MultipartFormValue<T> = MultipartFormValue(name, value, contentType)
-
-        internal fun fromByteArray(
-            name: String,
-            value: ByteArray,
-            contentType: ContentType,
-            filename: String? = null,
-        ): MultipartFormValue<ByteArray> = MultipartFormValue(name, value, contentType, filename)
-    }
-}
-
-internal object ContentTypes {
-    val DefaultText = ContentType.create(ContentType.TEXT_PLAIN.mimeType, Charset.forName("UTF-8"))
-    val DefaultBinary = ContentType.DEFAULT_BINARY
+        "MultipartField{value=$value, contentType=$contentType, filename=$filename}"
 }

orb-java-core/src/main/kotlin/com/withorb/api/core/Values.kt

@@ -0,0 +1,89 @@
+// File generated from our OpenAPI spec by Stainless.
+
+@file:JvmName("HttpRequestBodies")
+
+package com.withorb.api.core.http
+
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.databind.node.JsonNodeType
+import com.withorb.api.core.MultipartField
+import com.withorb.api.errors.OrbInvalidDataException
+import java.io.OutputStream
+import kotlin.jvm.optionals.getOrNull
+import org.apache.hc.client5.http.entity.mime.MultipartEntityBuilder
+import org.apache.hc.core5.http.ContentType
+import org.apache.hc.core5.http.HttpEntity
+
+@JvmSynthetic
+internal inline fun <reified T> json(jsonMapper: JsonMapper, value: T): HttpRequestBody =
+    object : HttpRequestBody {
+        private val bytes: ByteArray by lazy { jsonMapper.writeValueAsBytes(value) }
+
+        override fun writeTo(outputStream: OutputStream) = outputStream.write(bytes)
+
+        override fun contentType(): String = "application/json"
+
+        override fun contentLength(): Long = bytes.size.toLong()
+
+        override fun repeatable(): Boolean = true
+
+        override fun close() {}
+    }
+
+@JvmSynthetic
+internal fun multipartFormData(
+    jsonMapper: JsonMapper,
+    fields: Map<String, MultipartField<*>>,
+): HttpRequestBody =
+    object : HttpRequestBody {
+        private val entity: HttpEntity by lazy {
+            MultipartEntityBuilder.create()
+                .apply {
+                    fields.forEach { (name, field) ->
+                        val node = jsonMapper.valueToTree<JsonNode>(field.value)
+                        serializePart(name, node).forEach { (name, bytes) ->
+                            addBinaryBody(
+                                name,
+                                bytes,
+                                ContentType.parseLenient(field.contentType),
+                                field.filename().getOrNull(),
+                            )
+                        }
+                    }
+                }
+                .build()
+        }
+
+        private fun serializePart(name: String, node: JsonNode): Sequence<Pair<String, ByteArray>> =
+            when (node.nodeType) {
+                JsonNodeType.MISSING,
+                JsonNodeType.NULL -> emptySequence()
+                JsonNodeType.BINARY -> sequenceOf(name to node.binaryValue())
+                JsonNodeType.STRING -> sequenceOf(name to node.textValue().toByteArray())
+                JsonNodeType.BOOLEAN ->
+                    sequenceOf(name to node.booleanValue().toString().toByteArray())
+                JsonNodeType.NUMBER ->
+                    sequenceOf(name to node.numberValue().toString().toByteArray())
+                JsonNodeType.ARRAY ->
+                    node.elements().asSequence().flatMap { element ->
+                        serializePart("$name[]", element)
+                    }
+                JsonNodeType.OBJECT ->
+                    node.fields().asSequence().flatMap { (key, value) ->
+                        serializePart("$name[$key]", value)
+                    }
+                JsonNodeType.POJO,
+                null -> throw OrbInvalidDataException("Unexpected JsonNode type: ${node.nodeType}")
+            }
+
+        override fun writeTo(outputStream: OutputStream) = entity.writeTo(outputStream)
+
+        override fun contentType(): String = entity.contentType
+
+        override fun contentLength(): Long = entity.contentLength
+
+        override fun repeatable(): Boolean = entity.isRepeatable
+
+        override fun close() = entity.close()
+    }