improvements and (a lot of) fixes

Author: ljtfreitas

arrow/build.gradle.kts

@@ -37,15 +37,18 @@ val kotlinCompileAttributes: KotlinCompile.() -> Unit = {
     sourceCompatibility = "11"
     targetCompatibility = "11"
 
-    kotlinOptions.freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn"
+    kotlinOptions {
+        jvmTarget = "11"
+        freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn"
+    }
 }
 
 tasks.compileKotlin.configure(kotlinCompileAttributes)
 tasks.compileTestKotlin.configure(kotlinCompileAttributes)
 
 dependencies {
     implementation(project(":core"))
-    implementation(project(":kotlin"))
+    api(project(":kotlin"))
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:1.6.4")
     api("io.arrow-kt:arrow-core-jvm:1.1.2")
     api("io.arrow-kt:arrow-fx-coroutines:1.1.2")

arrow/src/main/kotlin/com/github/ljtfreitas/julian/k/arrow/EitherResponseT.kt

@@ -32,6 +32,8 @@ import com.github.ljtfreitas.julian.Promise
 import com.github.ljtfreitas.julian.Response
 import com.github.ljtfreitas.julian.ResponseFn
 import com.github.ljtfreitas.julian.ResponseT
+import java.lang.reflect.Type
+import java.lang.reflect.WildcardType
 
 object EitherResponseT : ResponseT<Any, Either<Throwable, Any>> {
 
@@ -46,13 +48,19 @@ object EitherResponseT : ResponseT<Any, Either<Throwable, Any>> {
 
     override fun adapted(endpoint: Endpoint): JavaType = endpoint.returnType().parameterized()
         .map { it.actualTypeArguments[1] }
+        .map(::argument)
         .orElseGet { Any::class.java }
         .let(JavaType::valueOf)
 
+    private fun argument(type: Type) : Type =
+        if (type is WildcardType && type.upperBounds.isNotEmpty())
+            argument(type.upperBounds.first())
+        else type
+
     override fun <A> bind(endpoint: Endpoint, next: ResponseFn<A, Any>) = object : ResponseFn<A, Either<Throwable, Any>> {
 
         @Suppress("UNCHECKED_CAST")
-        override fun run(response: Promise<out Response<A>>, arguments: Arguments): Promise<Either<Throwable, Any>> {
+        override fun run(response: Promise<out Response<A, out Throwable>>, arguments: Arguments): Promise<Either<Throwable, Any>> {
             val leftClassType: Class<out Any> = JavaType.valueOf(endpoint.returnType().parameterized()
                 .map(JavaType.Parameterized::firstArg)
                 .orElse(Throwable::class.java))

arrow/src/main/kotlin/com/github/ljtfreitas/julian/k/arrow/EvalResponseT.kt

@@ -30,19 +30,27 @@ import com.github.ljtfreitas.julian.Promise
 import com.github.ljtfreitas.julian.Response
 import com.github.ljtfreitas.julian.ResponseFn
 import com.github.ljtfreitas.julian.ResponseT
+import java.lang.reflect.Type
+import java.lang.reflect.WildcardType
 
 object EvalResponseT : ResponseT<Any, Eval<Any>> {
 
     override fun test(endpoint: Endpoint) = endpoint.returnType().`is`(Eval::class.java)
 
     override fun adapted(endpoint: Endpoint): JavaType = endpoint.returnType().parameterized()
         .map(JavaType.Parameterized::firstArg)
+        .map(::argument)
         .orElseGet { Any::class.java }
         .let(JavaType::valueOf)
 
+    private fun argument(type: Type) : Type =
+        if (type is WildcardType && type.upperBounds.isNotEmpty())
+            argument(type.upperBounds.first())
+        else type
+
     override fun <A> bind(endpoint: Endpoint, next: ResponseFn<A, Any>) = object : ResponseFn<A, Eval<Any>> {
 
-        override fun join(response: Promise<out Response<A>>, arguments: Arguments): Eval<Any> = Eval.later {
+        override fun join(response: Promise<out Response<A, out Throwable>>, arguments: Arguments): Eval<Any> = Eval.later {
             next.join(response, arguments)
         }
 

arrow/src/main/kotlin/com/github/ljtfreitas/julian/k/arrow/NonEmptyListResponseT.kt

@@ -23,9 +23,6 @@
 package com.github.ljtfreitas.julian.k.arrow
 
 import arrow.core.NonEmptyList
-import arrow.core.Option
-import arrow.core.nel
-import arrow.core.toOption
 import com.github.ljtfreitas.julian.Arguments
 import com.github.ljtfreitas.julian.Endpoint
 import com.github.ljtfreitas.julian.JavaType
@@ -35,7 +32,6 @@ import com.github.ljtfreitas.julian.ResponseFn
 import com.github.ljtfreitas.julian.ResponseT
 import java.lang.reflect.Type
 import java.lang.reflect.WildcardType
-import java.util.stream.Stream
 
 object NonEmptyListResponseT : ResponseT<Collection<Any>, NonEmptyList<Any>> {
 
@@ -48,13 +44,13 @@ object NonEmptyListResponseT : ResponseT<Collection<Any>, NonEmptyList<Any>> {
         .let { JavaType.parameterized(Collection::class.java, it) }
 
     private fun argument(type: Type) : Type =
-        if (type is WildcardType && type.lowerBounds.isNotEmpty())
-            argument(type.lowerBounds.first())
+        if (type is WildcardType && type.upperBounds.isNotEmpty())
+            argument(type.upperBounds.first())
         else type
 
     override fun <A> bind(endpoint: Endpoint, next: ResponseFn<A, Collection<Any>>) = object : ResponseFn<A, NonEmptyList<Any>> {
 
-        override fun run(response: Promise<out Response<A?>>, arguments: Arguments): Promise<NonEmptyList<Any>> =
+        override fun run(response: Promise<out Response<A?, out Throwable>>, arguments: Arguments): Promise<NonEmptyList<Any>> =
             next.run(response, arguments).then { NonEmptyList.fromListUnsafe(it.toList()) }
 
         override fun returnType(): JavaType = next.returnType()

arrow/src/main/kotlin/com/github/ljtfreitas/julian/k/arrow/OptionResponseT.kt

@@ -31,19 +31,27 @@ import com.github.ljtfreitas.julian.Promise
 import com.github.ljtfreitas.julian.Response
 import com.github.ljtfreitas.julian.ResponseFn
 import com.github.ljtfreitas.julian.ResponseT
+import java.lang.reflect.Type
+import java.lang.reflect.WildcardType
 
 object OptionResponseT : ResponseT<Any, Option<Any>> {
 
     override fun test(endpoint: Endpoint) = endpoint.returnType().`is`(Option::class.java)
 
     override fun adapted(endpoint: Endpoint): JavaType = endpoint.returnType().parameterized()
         .map(JavaType.Parameterized::firstArg)
+        .map(::argument)
         .orElseGet { Any::class.java }
         .let(JavaType::valueOf)
 
+    private fun argument(type: Type) : Type =
+        if (type is WildcardType && type.upperBounds.isNotEmpty())
+            argument(type.upperBounds.first())
+        else type
+
     override fun <A> bind(endpoint: Endpoint, next: ResponseFn<A, Any>) = object : ResponseFn<A, Option<Any>> {
 
-        override fun run(response: Promise<out Response<A?>>, arguments: Arguments): Promise<Option<Any>> =
+        override fun run(response: Promise<out Response<A?, out Throwable>>, arguments: Arguments): Promise<Option<Any>> =
             next.run(response, arguments).then { it.toOption() }
 
         override fun returnType(): JavaType = next.returnType()

arrow/src/main/kotlin/com/github/ljtfreitas/julian/k/arrow/RecoverableEitherResponseT.kt

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2021 Tiago de Freitas Lima
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.github.ljtfreitas.julian.k.arrow
+
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
+import com.github.ljtfreitas.julian.Arguments
+import com.github.ljtfreitas.julian.Endpoint
+import com.github.ljtfreitas.julian.JavaType
+import com.github.ljtfreitas.julian.Kind
+import com.github.ljtfreitas.julian.Promise
+import com.github.ljtfreitas.julian.Response
+import com.github.ljtfreitas.julian.ResponseFn
+import com.github.ljtfreitas.julian.ResponseT
+import com.github.ljtfreitas.julian.http.RecoverableHTTPResponse
+import java.lang.reflect.Type
+import java.lang.reflect.WildcardType
+import java.util.Optional
+import java.util.function.Supplier
+
+object RecoverableEitherResponseT : ResponseT<Any, Either<Any, Any>> {
+
+    override fun test(endpoint: Endpoint) = endpoint.returnType().let { returnType ->
+        returnType.`is`(Either::class.java)
+            && returnType.parameterized()
+                    .map(JavaType.Parameterized::firstArg)
+                    .map(::argument)
+                    .map(JavaType::valueOf)
+                    .filter { left -> !left.compatible(Throwable::class.java) }
+                    .isPresent
+    }
+
+    override fun adapted(endpoint: Endpoint): JavaType = endpoint.returnType().parameterized()
+        .map { it.actualTypeArguments[1] }
+        .map(::argument)
+        .orElseGet { Any::class.java }
+        .let(JavaType::valueOf)
+
+    private fun argument(type: Type) : Type =
+        if (type is WildcardType && type.upperBounds.isNotEmpty())
+            argument(type.upperBounds.first())
+        else type
+
+    override fun <A> bind(endpoint: Endpoint, next: ResponseFn<A, Any>) = object : ResponseFn<A, Either<Any, Any>> {
+
+        override fun run(response: Promise<out Response<A, out Throwable>>, arguments: Arguments): Promise<Either<Any, Any>> {
+            val leftClassType: Class<out Any> = JavaType.valueOf(endpoint.returnType().parameterized()
+                .map(JavaType.Parameterized::firstArg)
+                .orElse(Any::class.java))
+                .rawClassType()
+
+            val left: Promise<Optional<Promise<Either<Any, Any>>>> = response.then { r ->
+                r.cast(object : Kind<RecoverableHTTPResponse<A>>() {})
+                    .map { recoverable -> recoverable.recover(leftClassType) }
+                    .map { recovered -> Promise.done(recovered) }
+                    .map { recovered -> recovered.bind { rec -> rec.fold({ success -> Promise.done(success) }, { failure -> Promise.failed(failure)})} }
+                    .map { recovered -> recovered.then { it.left() } }
+            }
+
+            val right = Supplier<Promise<Either<Any, Any>>> { next.run(response, arguments).then { it.right() } }
+
+            return left.bind { recovered -> recovered.orElseGet(right) }
+        }
+
+        override fun returnType() = next.returnType()
+    }
+}
+
+class RecoverableEitherResponseTProxy : ResponseT<Any, Either<Any, Any>> by RecoverableEitherResponseT

arrow/src/main/kotlin/com/github/ljtfreitas/julian/k/arrow/fx/EffectResponseT.kt

@@ -50,7 +50,7 @@ object EffectResponseT : ResponseT<Any, Effect<Exception, Any>> {
     override fun <A> bind(endpoint: Endpoint, next: ResponseFn<A, Any>) = object : ResponseFn<A, Effect<Exception, Any>> {
 
         @Suppress("UNCHECKED_CAST")
-        override fun join(response: Promise<out Response<A>>, arguments: Arguments): Effect<Exception, Any> {
+        override fun join(response: Promise<out Response<A, out Throwable>>, arguments: Arguments): Effect<Exception, Any> {
             val leftClassType: Class<out Exception> = JavaType.valueOf(endpoint.returnType().parameterized()
                 .map(JavaType.Parameterized::firstArg)
                 .orElse(Exception::class.java))

arrow/src/main/resources/META-INF/services/com.github.ljtfreitas.julian.ResponseT

@@ -2,4 +2,5 @@ com.github.ljtfreitas.julian.k.arrow.EitherResponseTProxy
 com.github.ljtfreitas.julian.k.arrow.EvalResponseTProxy
 com.github.ljtfreitas.julian.k.arrow.NonEmptyListResponseTProxy
 com.github.ljtfreitas.julian.k.arrow.OptionResponseTProxy
+com.github.ljtfreitas.julian.k.arrow.RecoverableEitherResponseTProxy
 com.github.ljtfreitas.julian.k.arrow.fx.EffectResponseTProxy

arrow/src/test/kotlin/com/github/ljtfreitas/julian/k/arrow/EitherResponseTTest.kt

@@ -94,7 +94,7 @@ class EitherResponseTTest : DescribeSpec({
 
                 val promise: Promise<Either<Throwable, Any>> = fn.run(Promise.failed(failure), Arguments.empty())
 
-                promise.subscribe(object : Subscriber<Either<Throwable, Any>> {
+                promise.subscribe(object : Subscriber<Either<Throwable, Any>, Throwable> {
 
                     override fun success(value: Either<Throwable, Any>) {
                         fail("it was expected a failure, not a successful value :(")

arrow/src/test/kotlin/com/github/ljtfreitas/julian/k/arrow/RecoverableEitherResponseTTest.kt

@@ -0,0 +1,136 @@
+package com.github.ljtfreitas.julian.k.arrow
+
+import arrow.core.Either
+import com.github.ljtfreitas.julian.Arguments
+import com.github.ljtfreitas.julian.Endpoint
+import com.github.ljtfreitas.julian.ObjectResponseT
+import com.github.ljtfreitas.julian.Promise
+import com.github.ljtfreitas.julian.Response
+import com.github.ljtfreitas.julian.Subscriber
+import com.github.ljtfreitas.julian.http.FailureHTTPResponse
+import com.github.ljtfreitas.julian.http.HTTPClientFailureResponseException.BadRequest
+import com.github.ljtfreitas.julian.http.HTTPHeader
+import com.github.ljtfreitas.julian.http.HTTPHeaders
+import com.github.ljtfreitas.julian.http.HTTPResponse
+import com.github.ljtfreitas.julian.http.RecoverableHTTPResponse
+import com.github.ljtfreitas.julian.http.UnrecoverableHTTPResponseException
+import com.github.ljtfreitas.julian.http.codec.HTTPResponseReaders
+import com.github.ljtfreitas.julian.http.codec.StringHTTPMessageCodec
+import com.github.ljtfreitas.julian.k.javaType
+import io.kotest.assertions.arrow.core.shouldBeLeft
+import io.kotest.assertions.arrow.core.shouldBeRight
+import io.kotest.assertions.fail
+import io.kotest.core.spec.style.DescribeSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import io.mockk.every
+import io.mockk.mockk
+import java.io.IOException
+
+class RecoverableEitherResponseTTest : DescribeSpec({
+
+    val subject = RecoverableEitherResponseT
+
+    val endpoint = mockk<Endpoint>()
+
+    describe("a ResponseT instance for Either<L, R> values (left is a recovered value!)") {
+
+        describe("predicates") {
+
+            it("supports Either<Left, Right> as function return type") {
+                every { endpoint.returnType() } returns javaType<Either<String, String>>()
+
+                subject.test(endpoint) shouldBe true
+            }
+
+            it("it does not support Throwable (or sub-exceptions) as left argument.") {
+                every { endpoint.returnType() } returns javaType<Either<Throwable, String>>()
+
+                subject.test(endpoint) shouldBe false
+            }
+
+            it("sub-exceptions does not supported as left argument, too") {
+                every { endpoint.returnType() } returns javaType<Either<IOException, String>>()
+
+                subject.test(endpoint) shouldBe false
+            }
+        }
+
+        describe("adapt to expected type") {
+
+            it("we must to adapt to Right argument from either (Either<Left, Right> -> Right)") {
+                every { endpoint.returnType() } returns javaType<Either<Any, String>>()
+
+                subject.adapted(endpoint) shouldBe javaType<String>()
+            }
+        }
+
+        describe("bind") {
+
+            every { endpoint.returnType() } returns javaType<Either<String, String>>()
+
+            val fn = subject.bind<String>(endpoint = endpoint, next = ObjectResponseT<Any>().bind(endpoint, null))
+
+            it("bind a value T to Either<String, T>") {
+                val expected = "hello"
+
+                val either = fn.join(Promise.done(Response.done(expected)), Arguments.empty())
+
+                either shouldBeRight expected
+            }
+
+            it("we are able to recover a response failure to Either<String, T>") {
+                val expected = "oops"
+
+                val badRequest = BadRequest(
+                    HTTPHeaders(listOf(HTTPHeader(HTTPHeader.CONTENT_TYPE, "text/plain"))),
+                    Promise.done(expected.toByteArray())
+                )
+
+                val failure = FailureHTTPResponse<String>(badRequest)
+
+                val response = Promise.done<HTTPResponse<String>>(
+                    RecoverableHTTPResponse(
+                        failure,
+                        HTTPResponseReaders(listOf(StringHTTPMessageCodec()))
+                    )
+                )
+
+                val either = fn.join(response, Arguments.empty())
+
+                either shouldBeLeft expected
+            }
+
+            it("in case it's impossible to convert the response to the desired recovered value, we get a failed Promise") {
+                every { endpoint.returnType() } returns javaType<Either<MyFailure, String>>()
+
+                val badRequest = BadRequest(
+                    HTTPHeaders(listOf(HTTPHeader(HTTPHeader.CONTENT_TYPE, "text/plain"))),
+                    Promise.done("oops".toByteArray())
+                )
+
+                val failure = FailureHTTPResponse<String>(badRequest)
+
+                val codec = StringHTTPMessageCodec()  // isn't able to convert String to MyFailure
+
+                val response = Promise.done<HTTPResponse<String>>(RecoverableHTTPResponse(failure, HTTPResponseReaders(listOf(codec))))
+
+                val promise = fn.run(response, Arguments.empty())
+
+                promise.subscribe(object : Subscriber<Either<Any, Any>, Throwable> {
+
+                    override fun success(value: Either<Any, Any>?) {
+                        fail("a success value was not expected here...")
+                    }
+
+                    override fun failure(failure: Throwable) {
+                        failure.shouldBeInstanceOf<UnrecoverableHTTPResponseException>()
+                    }
+
+                })
+            }
+        }
+    }
+})
+
+class MyFailure