feat(client): accept InputStream and Path for file params (#311)

Author: stainless-app[bot]

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

@@ -3,23 +3,43 @@
 package com.withorb.api.core
 
 import com.fasterxml.jackson.annotation.JsonInclude
+import com.fasterxml.jackson.core.JsonGenerator
 import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.databind.SerializationFeature
+import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.cfg.CoercionAction.Fail
 import com.fasterxml.jackson.databind.cfg.CoercionInputShape.Integer
 import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
 import com.fasterxml.jackson.module.kotlin.jacksonMapperBuilder
+import java.io.InputStream
 
 fun jsonMapper(): JsonMapper =
     jacksonMapperBuilder()
         .addModule(Jdk8Module())
         .addModule(JavaTimeModule())
+        .addModule(SimpleModule().addSerializer(InputStreamJsonSerializer))
         .serializationInclusion(JsonInclude.Include.NON_ABSENT)
         .disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)
         .disable(SerializationFeature.FLUSH_AFTER_WRITE_VALUE)
         .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
         .disable(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS)
         .withCoercionConfig(String::class.java) { it.setCoercion(Integer, Fail) }
         .build()
+
+private object InputStreamJsonSerializer : BaseSerializer<InputStream>(InputStream::class) {
+
+    override fun serialize(
+        value: InputStream?,
+        gen: JsonGenerator?,
+        serializers: SerializerProvider?,
+    ) {
+        if (value == null) {
+            gen?.writeNull()
+        } else {
+            value.use { gen?.writeBinary(it.readBytes()) }
+        }
+    }
+}

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

@@ -27,6 +27,7 @@ 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.io.InputStream
 import java.util.Objects
 import java.util.Optional
 
@@ -508,7 +509,10 @@ private constructor(
             return MultipartField(
                 value,
                 contentType
-                    ?: if (value is KnownValue && value.value is ByteArray)
+                    ?: if (
+                        value is KnownValue &&
+                            (value.value is InputStream || value.value is ByteArray)
+                    )
                         "application/octet-stream"
                     else "text/plain; charset=utf-8",
                 filename,

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

@@ -9,6 +9,8 @@ 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.ByteArrayInputStream
+import java.io.InputStream
 import java.io.OutputStream
 import kotlin.jvm.optionals.getOrNull
 import org.apache.hc.client5.http.entity.mime.MultipartEntityBuilder
@@ -41,8 +43,18 @@ internal fun multipartFormData(
             MultipartEntityBuilder.create()
                 .apply {
                     fields.forEach { (name, field) ->
-                        val node = jsonMapper.valueToTree<JsonNode>(field.value)
-                        serializePart(name, node).forEach { (name, bytes) ->
+                        val knownValue = field.value.asKnown().getOrNull()
+                        val parts =
+                            if (knownValue is InputStream) {
+                                // Read directly from the `InputStream` instead of reading it all
+                                // into memory due to the `jsonMapper` serialization below.
+                                sequenceOf(name to knownValue)
+                            } else {
+                                val node = jsonMapper.valueToTree<JsonNode>(field.value)
+                                serializePart(name, node)
+                            }
+
+                        parts.forEach { (name, bytes) ->
                             addBinaryBody(
                                 name,
                                 bytes,
@@ -55,16 +67,19 @@ internal fun multipartFormData(
                 .build()
         }
 
-        private fun serializePart(name: String, node: JsonNode): Sequence<Pair<String, ByteArray>> =
+        private fun serializePart(
+            name: String,
+            node: JsonNode,
+        ): Sequence<Pair<String, InputStream>> =
             when (node.nodeType) {
                 JsonNodeType.MISSING,
                 JsonNodeType.NULL -> emptySequence()
-                JsonNodeType.BINARY -> sequenceOf(name to node.binaryValue())
-                JsonNodeType.STRING -> sequenceOf(name to node.textValue().toByteArray())
+                JsonNodeType.BINARY -> sequenceOf(name to ByteArrayInputStream(node.binaryValue()))
+                JsonNodeType.STRING -> sequenceOf(name to node.textValue().toInputStream())
                 JsonNodeType.BOOLEAN ->
-                    sequenceOf(name to node.booleanValue().toString().toByteArray())
+                    sequenceOf(name to node.booleanValue().toString().toInputStream())
                 JsonNodeType.NUMBER ->
-                    sequenceOf(name to node.numberValue().toString().toByteArray())
+                    sequenceOf(name to node.numberValue().toString().toInputStream())
                 JsonNodeType.ARRAY ->
                     node.elements().asSequence().flatMap { element ->
                         serializePart("$name[]", element)
@@ -77,6 +92,8 @@ internal fun multipartFormData(
                 null -> throw OrbInvalidDataException("Unexpected JsonNode type: ${node.nodeType}")
             }
 
+        private fun String.toInputStream(): InputStream = ByteArrayInputStream(toByteArray())
+
         override fun writeTo(outputStream: OutputStream) = entity.writeTo(outputStream)
 
         override fun contentType(): String = entity.contentType