move core to be mpp

build.gradle.kts

@@ -33,7 +33,18 @@ subprojects {
       }
 
       sourceSets {
+        val commonMain by getting {
+          dependencies {
+            implementation(rootProject.libs.kotlin.stdlibCommon)
+          }
+        }
+
+        val jvmMain by getting {
+          dependsOn(commonMain)
+        }
+
         val commonTest by getting {
+          dependsOn(commonMain)
           dependencies {
             implementation(rootProject.libs.coroutines.core)
             implementation(rootProject.libs.kotest.assertionsCore)
@@ -42,6 +53,7 @@ subprojects {
         }
 
         val jvmTest by getting {
+          dependsOn(commonMain)
           dependencies {
             implementation(rootProject.libs.kotest.runnerJUnit5)
           }

clients/http4k-client/src/jvmMain/kotlin/arrow/endpoint/http4k/client/interpreter.kt

@@ -82,8 +82,6 @@ public fun <I, E, O> Endpoint<I, E, O>.toRequest(baseUrl: String, i: I): Request
 
   return when (val body = info.body) {
     is Body.ByteArray -> r4.body(MemoryBody(body.byteArray))
-    is Body.ByteBuffer -> r4.body(MemoryBody(body.byteBuffer))
-    is Body.InputStream -> r4.body(body.inputStream)
     is Body.String -> r4.body(body.string)
     null -> r4
   }
@@ -150,8 +148,6 @@ private fun EndpointOutput<*>.getOutputParams(
   when (val output = this) {
     is EndpointOutput.Single<*> -> when (val single = (output as EndpointOutput.Single<Any?>)) {
       is EndpointIO.ByteArrayBody -> single.codec.decode(response.body.payload.array())
-      is EndpointIO.ByteBufferBody -> single.codec.decode(response.body.payload)
-      is EndpointIO.InputStreamBody -> single.codec.decode(response.body.stream)
       is EndpointIO.StringBody -> single.codec.decode(response.body.toString())
 
       is EndpointIO.Empty -> single.codec.decode(Unit)

clients/ktor-client/src/jvmMain/kotlin/arrow/endpoint/ktor/client/KtorClientInterpreter.kt

@@ -81,8 +81,6 @@ public fun <I, E, O> Endpoint<I, E, O>.toRequestBuilder(baseUrl: String, input:
     }
     body = when (val body = info.body) {
       is Body.ByteArray -> ByteArrayContent(body.byteArray/* contentType,  statusCode*/)
-      is Body.ByteBuffer -> ByteArrayContent(body.byteBuffer.array())
-      is Body.InputStream -> ByteArrayContent(body.inputStream.readBytes())
 
       // TODO fix ContentType
       is Body.String -> TextContent(body.string, ContentType.Text.Plain)
@@ -150,8 +148,6 @@ private suspend fun EndpointOutput<*>.outputParams(
     is EndpointOutput.Single<*> ->
       when (this) {
         is EndpointIO.ByteArrayBody -> codec.decode(response.receive())
-        is EndpointIO.ByteBufferBody -> codec.decode(ByteBuffer.wrap(response.receive<ByteArray>()))
-        is EndpointIO.InputStreamBody -> codec.decode(response.receive())
         is EndpointIO.StringBody -> codec.decode(response.receive())
         is EndpointIO.Empty -> codec.decode(Unit)
         is EndpointIO.Header -> codec.decode(headers.getAll(name).orEmpty())

clients/spring-web-client/src/jvmMain/kotlin/arrow/endpoint/spring/client/restTemplateInterpreter.kt

@@ -125,8 +125,6 @@ private fun EndpointOutput<*>.getOutputParams(
   when (val output = this) {
     is EndpointOutput.Single<*> -> when (val single = (output as EndpointOutput.Single<Any?>)) {
       is EndpointIO.ByteArrayBody -> single.codec.decode(response.body.readBytes())
-      is EndpointIO.ByteBufferBody -> single.codec.decode(ByteBuffer.wrap(response.body.readBytes()))
-      is EndpointIO.InputStreamBody -> single.codec.decode(response.body.readBytes().inputStream())
       is EndpointIO.StringBody -> single.codec.decode(String(response.body.readBytes()))
       is EndpointIO.Empty -> single.codec.decode(Unit)
       is EndpointOutput.FixedStatusCode -> single.codec.decode(Unit)

clients/spring-web-flux-client/src/jvmMain/kotlin/arrow/endpoint/spring/client/webClientInterpreter.kt

@@ -120,14 +120,6 @@ private suspend fun EndpointOutput<*>.getOutputParams(
   when (val output = this) {
     is EndpointOutput.Single<*> -> when (val single = (output as EndpointOutput.Single<Any?>)) {
       is EndpointIO.ByteArrayBody -> single.codec.decode(response.awaitBodyOrNull(ByteArray::class) ?: byteArrayOf())
-      is EndpointIO.ByteBufferBody -> single.codec.decode(
-        response.awaitBodyOrNull(ByteBuffer::class) ?: ByteBuffer.wrap(byteArrayOf())
-      )
-      is EndpointIO.InputStreamBody -> single.codec.decode(
-        ByteArrayInputStream(
-          response.awaitBodyOrNull(ByteArray::class) ?: byteArrayOf()
-        )
-      )
       is EndpointIO.StringBody -> single.codec.decode(response.awaitBodyOrNull(String::class) ?: "")
       is EndpointIO.Empty -> single.codec.decode(Unit)
       is EndpointOutput.FixedStatusCode -> single.codec.decode(Unit)

core/build.gradle.kts

@@ -1,18 +1,13 @@
 kotlin {
   sourceSets {
     commonMain {
-      dependencies {
-        implementation(kotlin("stdlib", Version.kotlin))
-        implementation(Libs.kotlinxCoroutines)
-        implementation(Libs.ktorio)
-      }
-    }
-
-    jvmMain {
       dependencies {
         // Needed for Uri MatchNamedGroupCollection, ties us to JDK8
         // TODO https://app.clickup.com/t/kt7qd2
-        implementation(kotlin("stdlib-jdk8", Version.kotlin))
+        api(libs.arrow.core)
+        implementation(libs.kotlin.stdlibJDK8)
+        implementation(libs.coroutines.core)
+        api(libs.ktor.io)
       }
     }
   }

core/src/commonMain/kotlin/arrow/endpoint/ArrowEndpoint.kt

@@ -100,12 +100,6 @@ public object ArrowEndpoint {
   public fun byteArrayBody(): EndpointIO.ByteArrayBody<ByteArray> =
     EndpointIO.ByteArrayBody(Codec.byteArray, EndpointIO.Info.empty())
 
-  public fun byteBufferBody(): EndpointIO.ByteBufferBody<ByteChannel> =
-    EndpointIO.ByteBufferBody(Codec.byteBuffer, EndpointIO.Info.empty())
-
-  public fun inputStreamBody(): EndpointIO.InputStreamBody<ByteReadChannel> =
-    EndpointIO.InputStreamBody(Codec.inputStream, EndpointIO.Info.empty())
-
   public fun <A> formBody(codec: Codec<String, A, CodecFormat.XWwwFormUrlencoded>): EndpointIO.StringBody<A> =
     anyFromStringBody(codec)
 

core/src/commonMain/kotlin/arrow/endpoint/EndpointIO.kt

@@ -3,9 +3,8 @@ package arrow.endpoint
 import arrow.core.Tuple4
 import arrow.core.Tuple5
 import arrow.endpoint.model.CodecFormat
-import java.io.InputStream
-import java.nio.ByteBuffer
-import java.nio.charset.Charset
+import io.ktor.utils.io.charsets.Charset
+import kotlin.jvm.JvmName
 
 // Elements that can occur in both input and output
 // Such as body, headers, etc
@@ -90,32 +89,6 @@ public sealed interface EndpointIO<A> : EndpointInput<A>, EndpointOutput<A> {
     }
   }
 
-  public data class ByteBufferBody<T>(
-    override val codec: Codec<ByteBuffer, T, CodecFormat>,
-    override val info: Info<T>
-  ) : BinaryBody<ByteBuffer, T> {
-    override fun <B> copyWith(c: Codec<ByteBuffer, B, CodecFormat>, i: Info<B>): ByteBufferBody<B> =
-      ByteBufferBody(c, i)
-
-    override fun toString(): String {
-      val format = codec.format.mediaType
-      return "{body as $format}"
-    }
-  }
-
-  public data class InputStreamBody<T>(
-    override val codec: Codec<InputStream, T, CodecFormat>,
-    override val info: Info<T>
-  ) : BinaryBody<InputStream, T> {
-    override fun <B> copyWith(c: Codec<InputStream, B, CodecFormat>, i: Info<B>): InputStreamBody<B> =
-      InputStreamBody(c, i)
-
-    override fun toString(): String {
-      val format = codec.format.mediaType
-      return "{body as $format}"
-    }
-  }
-
   public data class Info<T>(val description: String?, val examples: List<Example<T>>, val deprecated: Boolean) {
     public fun description(d: String): Info<T> = copy(description = d)
     public fun example(): T? = examples.firstOrNull()?.value

core/src/commonMain/kotlin/arrow/endpoint/client/RequestInfo.kt

@@ -67,16 +67,9 @@ public fun <I> EndpointInput<I>.requestInfo(
       is EndpointIO.ByteArrayBody -> {
         body = Body.ByteArray(codec.encode(value), codec.format)
       }
-      is EndpointIO.ByteBufferBody -> {
-        body = Body.ByteBuffer(codec.encode(value), codec.format)
-      }
-      is EndpointIO.InputStreamBody -> {
-        body = Body.InputStream(codec.encode(value), codec.format)
-      }
       is EndpointIO.StringBody -> {
         body = Body.String(charset, codec.encode(value), codec.format)
       }
-
       is EndpointIO.Empty -> Unit
       is EndpointInput.FixedMethod -> {
         method = this.m

core/src/commonMain/kotlin/arrow/endpoint/model/Rfc3986.kt

@@ -5,9 +5,7 @@ import arrow.core.left
 import arrow.core.right
 import io.ktor.utils.io.charsets.Charset
 import io.ktor.utils.io.charsets.Charsets
-import io.ktor.utils.io.charsets.decode
 import io.ktor.utils.io.core.toByteArray
-import kotlin.experimental.and
 
 internal object Rfc3986 {
   private val AlphaNum: Set<Char> = (('a'..'z') + ('A'..'Z') + ('0'..'9')).toSet()
@@ -99,7 +97,7 @@ internal object Rfc3986 {
           // "%x" will cause an exception to be thrown
           if ((i < numChars) && (c == '%'))
             return UriError.IllegalArgument("URLDecoder: Incomplete trailing escape (%) pattern").left()
-          sb.append(bytes.joinToString { it.toString(16)}, startIndex = 0, endIndex = pos)
+          sb.append(bytes.joinToString { it.toString(16) }, startIndex = 0, endIndex = pos)
           needToChange = true
         }
         else -> {
@@ -111,12 +109,13 @@ internal object Rfc3986 {
     return (if (needToChange) sb.toString() else this).right()
   }
 
-  // private fun Byte.format(): String = "%02X".format(this)
+  private val hexArray: CharArray
+    get() = "0123456789ABCDEF".toCharArray()
 
-  // TODO: previously Jvm specific with String.format("%02x", this), check if this is cohesive
   private fun Byte.format(): String {
-    val decimal = this.and(0xff.toByte())
-    val hex = decimal.toUInt().toString(16)
-    return if(hex.length.mod(2) == 1) "0$hex" else hex
+    val v = toInt().and(0xFF)
+    val a = hexArray[v ushr 4]
+    val b = hexArray[v and 0x0F]
+    return "$a$b"
   }
 }

core/src/commonMain/kotlin/arrow/endpoint/server/interpreter/OutputValues.kt

@@ -100,14 +100,6 @@ internal data class OutputValues(
           val mapping = output.codec as Mapping<ByteArray, Any?>
           ov.withBody(Body.ByteArray(mapping.encode(value.asAny), output.codec.format), output)
         }
-        is EndpointIO.ByteBufferBody -> {
-          val mapping = output.codec as Mapping<ByteBuffer, Any?>
-          ov.withBody(Body.ByteBuffer(mapping.encode(value.asAny), output.codec.format), output)
-        }
-        is EndpointIO.InputStreamBody -> {
-          val mapping = output.codec as Mapping<InputStream, Any?>
-          ov.withBody(Body.InputStream(mapping.encode(value.asAny), output.codec.format), output)
-        }
         is EndpointIO.StringBody -> {
           val mapping = output.codec as Mapping<String, Any?>
           ov.withBody(Body.String(output.charset, mapping.encode(value.asAny), output.codec.format), output)

core/src/jvmMain/kotlin/arrow/endpoint/Codec.kt

@@ -1,10 +1,11 @@
 package arrow.endpoint
 
 import arrow.endpoint.model.CodecFormat
-import io.ktor.utils.io.charsets.Charset
 import java.io.InputStream
 import java.math.BigDecimal
 import java.nio.ByteBuffer
+import kotlin.text.Charsets
+import java.nio.charset.Charset
 import java.time.Duration as JavaDuration
 import java.time.Instant
 import java.time.LocalDate

core/src/jvmMain/kotlin/arrow/endpoint/Schema.kt

@@ -19,23 +19,31 @@ public val Schema.Companion.inputStream: Schema<InputStream>
 
 public val Schema.Companion.instant: Schema<Instant>
   get() = Schema.DateTime()
+
 public val Schema.Companion.zonedDateTime: Schema<ZonedDateTime>
   get() = Schema.DateTime()
+
 public val Schema.Companion.offsetDateTime: Schema<OffsetDateTime>
   get() = Schema.DateTime()
+
 public val Schema.Companion.date: Schema<java.util.Date>
   get() = Schema.DateTime()
 
 public val Schema.Companion.localDateTime: Schema<LocalDateTime>
   get() = Schema.String()
+
 public val Schema.Companion.localDate: Schema<LocalDate>
   get() = Schema.String()
+
 public val Schema.Companion.zoneOffset: Schema<ZoneOffset>
   get() = Schema.String()
+
 public val Schema.Companion.javaDuration: Schema<Duration>
   get() = Schema.String()
+
 public val Schema.Companion.localTime: Schema<LocalTime>
   get() = Schema.String()
+
 public val Schema.Companion.offsetTime: Schema<OffsetTime>
   get() = Schema.String()
 

servers/ktor-server/src/jvmMain/kotlin/arrow/endpoint/ktor/server/KtorHttpServerInterpreter.kt

@@ -27,7 +27,6 @@ import io.ktor.http.HttpStatusCode
 import io.ktor.http.RequestConnectionPoint
 import io.ktor.http.content.ByteArrayContent
 import io.ktor.http.content.OutgoingContent
-import io.ktor.http.content.OutputStreamContent
 import io.ktor.http.content.TextContent
 import io.ktor.http.withCharset
 import io.ktor.request.host
@@ -39,8 +38,6 @@ import io.ktor.response.header
 import io.ktor.response.respond
 import io.ktor.util.flattenEntries
 import io.ktor.util.toByteArray
-import io.ktor.utils.io.jvm.javaio.toInputStream
-import java.nio.ByteBuffer
 
 public fun <I, E, O> Application.install(ses: ServerEndpoint<I, E, O>): Unit =
   install(listOf(ses))
@@ -73,23 +70,11 @@ public fun ServerResponse.outgoingContent(): OutgoingContent? =
       body.contentType(),
       HttpStatusCode.fromValue(code.code)
     )
-    is Body.ByteBuffer -> ByteArrayContent(
-      body.toByteArray(),
-      body.contentType(),
-      HttpStatusCode.fromValue(code.code)
-    )
     is Body.String -> TextContent(
       body.string,
       body.contentType(),
       HttpStatusCode.fromValue(code.code)
     )
-    is Body.InputStream -> OutputStreamContent(
-      {
-        body.inputStream.copyTo(this)
-      },
-      body.contentType(),
-      HttpStatusCode.fromValue(code.code)
-    )
     else -> null
   }
 
@@ -135,8 +120,6 @@ internal class KtorRequestBody(private val ctx: ApplicationCall) : RequestBody {
     val body = ctx.request.receiveChannel()
     return when (bodyType) {
       is EndpointIO.ByteArrayBody -> body.toByteArray()
-      is EndpointIO.ByteBufferBody -> ByteBuffer.wrap(body.toByteArray())
-      is EndpointIO.InputStreamBody -> body.toInputStream()
       is EndpointIO.StringBody -> body.toByteArray().toString(bodyType.charset)
     } as R
   }

servers/spring-web-server/src/jvmMain/kotlin/arrow/endpoint/spring/server/SpringWebServerInterpreter.kt

@@ -80,9 +80,7 @@ private class SpringRequestBody(
     val body: DataBuffer? = request.awaitBodyOrNull()
     return when (bodyType) {
       is EndpointIO.ByteArrayBody -> toByteArray(body)
-      is EndpointIO.ByteBufferBody -> body?.asByteBuffer()
-      is EndpointIO.InputStreamBody -> body?.asInputStream()
-      is EndpointIO.StringBody -> body?.toString(Charsets.UTF_8)
+       is EndpointIO.StringBody -> body?.toString(Charsets.UTF_8)
     } as R
   }
 

test/src/jvmMain/kotlin/arrow/endpoint/test/MockWebServer.kt

@@ -52,8 +52,6 @@ internal class RequestBody(val ctx: RecordedRequest) : RequestBody {
   override suspend fun <R> toRaw(bodyType: EndpointIO.Body<R, *>): R {
     return when (bodyType) {
       is EndpointIO.ByteArrayBody -> withContext(Dispatchers.IO) { ctx.body.readByteArray() }
-      is EndpointIO.ByteBufferBody -> withContext(Dispatchers.IO) { ByteBuffer.wrap(ctx.body.readByteArray()) }
-      is EndpointIO.InputStreamBody -> ctx.body.inputStream()
       is EndpointIO.StringBody -> withContext(Dispatchers.IO) { ctx.body.readByteArray().toString(bodyType.charset) }
     } as R
   }
@@ -78,8 +76,6 @@ public fun RecordedRequest.toServerRequest(): ServerRequest =
 public fun MockResponse.setBody(response: ServerResponse): MockResponse =
   when (val r = response.body) {
     is Body.ByteArray -> setBody(Buffer().apply { write(r.byteArray) })
-    is Body.ByteBuffer -> setBody(Buffer().apply { write(r.byteBuffer) })
-    is Body.InputStream -> setBody(Buffer().apply { readFrom(r.inputStream) })
     is Body.String -> setBody(r.string)
     else -> this
   }