wip

Author: juliano

README.md

@@ -12,7 +12,7 @@ To get started check the documentation on [https://pokeapi.co/docs/v2](https://p
 Add the following to your build.sbt:
 
 ```scala
-libraryDependencies += "io.github.juliano" % "pokeapi-scala_3" % "0.3.0"
+libraryDependencies += "io.github.juliano" % "pokeapi-scala_3" % "0.4.0"
 ```
 
 ### `Sttp` backends support
@@ -21,7 +21,7 @@ This client is written using [sttp](https://sttp.softwaremill.com/en/latest/inde
 
 ## Usage
 
-Instantiate a backend implicitly, create a `PokeApiClient()` and start consuming the api, calling `client.send(PokeRequest(id | name))`. Most requests accept an `id: Long` or `name: String` (have a look at [Scala 3 Union Types](https://docs.scala-lang.org/scala3/book/types-union.html)).
+Instantiate a backend, use it create a `PokeApiClient(backend)` and start consuming the api, calling `client.send(PokeRequest(id | name))`. Most requests accept an `id: Long` or `name: String` (have a look at [Scala 3 Union Types](https://docs.scala-lang.org/scala3/book/types-union.html)).
 
 It's possible to [list / paginate resources](https://pokeapi.co/docs/v2#resource-listspagination-section) as well, calling `client.send(PokeRequest.resourceList(offset: Int, limit: Int))`
 
@@ -35,43 +35,23 @@ Every response is automatically cached in memory, making all subsequent requests
 
 ```scala
 import io.github.juliano.pokeapi.requests.BerryRequest
-import sttp.client3.{ HttpClientSyncBackend, Identity, SttpBackend }
+import sttp.client4.httpclient.HttpClientSyncBackend
 
-given backend: SttpBackend[Identity, Any] = HttpClientSyncBackend()
-val client = PokeApiClient()
+val client = PokeApiClient(HttpClientSyncBackend())
 
 val berry = client.send(BerryRequest(1))
 println(berry.name)
 ```
 
-### Try
-
-```scala
-import io.github.juliano.pokeapi.requests.MoveRequest
-import sttp.client3.{ SttpBackend, TryHttpURLConnectionBackend }
-import scala.util.*
-
-given backend: SttpBackend[Try, Any] = TryHttpURLConnectionBackend()
-val client = PokeApiClient()
-
-client.send(MoveRequest("pound")) match {
-    case Success(move) => println(move.names)
-    case Failure(t)    => println(s"Failed with: $t")
-}
-```
-
 ### Future
 
 ```scala
 import io.github.juliano.pokeapi.requests.ContestTypeRequest
-import sttp.capabilities.WebSockets
-import sttp.client3.{ HttpClientFutureBackend, SttpBackend }
+import sttp.client4.httpclient.HttpClientFutureBackend
 import scala.concurrent.ExecutionContext.Implicits.global
-import scala.concurrent.Future
 import scala.util.*
 
-given backend: SttpBackend[Future, WebSockets] = HttpClientFutureBackend()
-val client = PokeApiClient()
+val client = PokeApiClient(HttpClientFutureBackend())
 
 client.send(ContestTypeRequest(1)).onComplete {
     case Success(contest) => println(contest.names)
@@ -83,10 +63,10 @@ client.send(ContestTypeRequest(1)).onComplete {
 
 ```scala
 import io.github.juliano.pokeapi.requests.PokemonRequest
-import sttp.client3.asynchttpclient.zio.AsyncHttpClientZioBackend
+import sttp.client4.asynchttpclient.zio.AsyncHttpClientZioBackend
 import zio.{ Runtime, Unsafe, ZIO }
 
-val client = AsyncHttpClientZioBackend().map(implicit backend => PokeApiClient())
+val client = AsyncHttpClientZioBackend().map(implicit backend => PokeApiClient(backend))
 
 val zio = client.flatMap(_.send(PokemonRequest("bulbasaur")))
 val pokemon = Unsafe.unsafeCompat { implicit u =>
@@ -101,14 +81,30 @@ print(pokemon.id)
 import cats.effect.IO
 import cats.effect.unsafe.implicits.global
 import io.github.juliano.pokeapi.requests.LocationRequest
-import sttp.client3.asynchttpclient.cats.AsyncHttpClientCatsBackend
+import sttp.client4.asynchttpclient.cats.AsyncHttpClientCatsBackend
 
-val client = AsyncHttpClientCatsBackend[IO]().map(implicit backend => PokeApiClient())
+val client = AsyncHttpClientCatsBackend[IO]().map(implicit backend => PokeApiClient(backend))
 
 val list = client.flatMap(_.send(LocationRequest.resourceList())).unsafeRunSync()
 print(list.count)
 ```
 
+### Pekko
+
+```scala
+import io.github.juliano.pokeapi.requests.MoveRequest
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.util.*
+import sttp.client4.pekkohttp.PekkoHttpBackend
+
+val client = PokeApiClient(PekkoHttpBackend())
+
+client.send(MoveRequest("pound")).onComplete {
+    case Success(move) => println(move.names)
+    case Failure(t)    => println(s"Failed with: $t")
+}
+```
+
 You can find more examples using Fs2, Armaria and okhttp [in the tests](https://github.com/juliano/pokeapi-scala/tree/main/src/test/scala/io/github/juliano/pokeapi)
 
 ## Contributing

build.sbt

@@ -22,19 +22,21 @@ lazy val pokeapi = project
     scalafmtOnCompile := true,
     scalacOptions := Seq("-Xmax-inlines", "64"),
     libraryDependencies ++= Seq(
-      "com.softwaremill.sttp.client3" %% "core"                           % "3.9.3",
-      "com.softwaremill.sttp.client3" %% "zio-json"                       % "3.9.3",
+      "com.softwaremill.sttp.client4" %% "core"                           % "4.0.0-M9",
+      "com.softwaremill.sttp.client4" %% "zio-json"                       % "4.0.0-M9",
       "com.github.blemale"            %% "scaffeine"                      % "5.2.1",
       "org.scalameta"                 %% "munit"                          % "1.0.0-M11" % Test,
-      "com.softwaremill.sttp.client3" %% "armeria-backend-cats"           % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "async-http-client-backend-cats" % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "fs2"                            % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "async-http-client-backend-fs2"  % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "zio"                            % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "async-http-client-backend-zio"  % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "armeria-backend-zio"            % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "armeria-backend"                % "3.9.3"     % Test,
-      "com.softwaremill.sttp.client3" %% "okhttp-backend"                 % "3.9.3"     % Test
+      "com.softwaremill.sttp.client4" %% "armeria-backend-cats"           % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "async-http-client-backend-cats" % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "fs2"                            % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "async-http-client-backend-fs2"  % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "zio"                            % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "async-http-client-backend-zio"  % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "armeria-backend-zio"            % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "armeria-backend"                % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "okhttp-backend"                 % "4.0.0-M9"  % Test,
+      "com.softwaremill.sttp.client4" %% "pekko-http-backend"             % "4.0.0-M9"  % Test,
+      "org.apache.pekko"              %% "pekko-stream"                   % "1.0.2"     % Test
     ),
     excludeDependencies ++= Seq(
       "org.scala-lang.modules" % "scala-collection-compat_2.13"

src/main/scala/io/github/juliano/pokeapi/PokeApiClient.scala

@@ -2,19 +2,17 @@ package io.github.juliano.pokeapi
 
 import com.github.blemale.scaffeine.{ Cache, Scaffeine }
 import io.github.juliano.pokeapi.PokeApiClient.*
-import sttp.client3.*
-import sttp.client3.ziojson.asJson
+import sttp.client4.*
+import sttp.client4.ziojson.asJson
 import sttp.model.{ MediaType, Uri }
 import sttp.monad.MonadError
 import sttp.monad.syntax.MonadErrorOps
 import zio.json.JsonDecoder
 
 import scala.concurrent.duration.DurationInt
 
-case class PokeApiClient[F[_], +P](host: ApiHost = ApiHost.default)(using
-    backend: SttpBackend[F, P]
-):
-  given monadError: MonadError[F] = backend.responseMonad
+case class PokeApiClient[F[_]](backend: Backend[F], host: ApiHost = ApiHost.default):
+  given monadError: MonadError[F] = backend.monad
   private val cache: Cache[String, Product] = Scaffeine().build[String, Product]()
 
   def send[A](request: PokeRequest[A])(using JsonDecoder[A]): F[A] =
@@ -25,8 +23,8 @@ case class PokeApiClient[F[_], +P](host: ApiHost = ApiHost.default)(using
         doSend(request).flatMap {
           case Right(value) =>
             cache.put(request.toString, value.asInstanceOf[Product])
-            monadError.unit(value)
-          case Left(error) => monadError.error(error)
+            monadError.unit(value.asInstanceOf[A])
+          case Left(error) => monadError.error(new Exception(error.toString))
         }
 
   private def doSend[A](
@@ -39,7 +37,7 @@ case class PokeApiClient[F[_], +P](host: ApiHost = ApiHost.default)(using
 
 object PokeApiClient:
   type FailureResponse = ResponseException[String, String]
-  type SttpRequest[A]  = Request[Either[FailureResponse, A], Any]
+  type SttpRequest[A]  = Request[Either[FailureResponse, A]]
 
   trait PokeRequest[A](id: String | Long):
     val resource: String

src/test/scala/io/github/juliano/pokeapi/BerriesSuite.scala

@@ -1,11 +1,10 @@
 package io.github.juliano.pokeapi
 
 import io.github.juliano.pokeapi.requests.*
-import sttp.client3.{ HttpClientSyncBackend, Identity, SttpBackend }
+import sttp.client4.httpclient.HttpClientSyncBackend
 
 class BerriesSuite extends munit.FunSuite:
-  given backend: SttpBackend[Identity, Any] = HttpClientSyncBackend()
-  val client = PokeApiClient()
+  val client = PokeApiClient(HttpClientSyncBackend())
 
   test("berry by id") {
     val berry = client.send(BerryRequest(1))

src/test/scala/io/github/juliano/pokeapi/ContestsSuite.scala

@@ -1,14 +1,10 @@
 package io.github.juliano.pokeapi
 
 import io.github.juliano.pokeapi.requests.*
-import sttp.capabilities.WebSockets
-import sttp.client3.{ HttpClientFutureBackend, SttpBackend }
-
-import scala.concurrent.Future
+import sttp.client4.httpclient.HttpClientFutureBackend
 
 class ContestsSuite extends FutureSuite:
-  given backend: SttpBackend[Future, WebSockets] = HttpClientFutureBackend()
-  val client = PokeApiClient()
+  val client = PokeApiClient(HttpClientFutureBackend())
 
   spec("contest type by id", ContestTypeRequest(1), _.name == "cool")
   spec("contest type by name", ContestTypeRequest("cool"), _.id == 1)

src/test/scala/io/github/juliano/pokeapi/EncountersSuite.scala

@@ -3,12 +3,10 @@ package io.github.juliano.pokeapi
 import cats.effect.IO
 import cats.effect.unsafe.implicits.global
 import io.github.juliano.pokeapi.requests.*
-import sttp.client3.SttpBackend
-import sttp.client3.armeria.cats.ArmeriaCatsBackend
+import sttp.client4.armeria.cats.ArmeriaCatsBackend
 
 class EncountersSuite extends munit.FunSuite:
-  given backend: SttpBackend[IO, Any] = ArmeriaCatsBackend[IO]()
-  val client: PokeApiClient[IO, Any] = PokeApiClient()
+  val client: PokeApiClient[IO] = PokeApiClient(ArmeriaCatsBackend[IO]())
 
   test("enconter method by id") {
     val encounterMethod = client.send(EncounterMethodRequest(1)).unsafeRunSync()

src/test/scala/io/github/juliano/pokeapi/EvolutionSuite.scala

@@ -2,10 +2,11 @@ package io.github.juliano.pokeapi
 
 import cats.effect.IO
 import io.github.juliano.pokeapi.requests.{ EvolutionChainRequest, EvolutionTriggerRequest }
-import sttp.client3.asynchttpclient.fs2.AsyncHttpClientFs2Backend
+import sttp.client4.asynchttpclient.fs2.AsyncHttpClientFs2Backend
 
 class EvolutionSuite extends Fs2Suite:
-  val client = AsyncHttpClientFs2Backend.resource[IO]().map(implicit backend => PokeApiClient())
+  val client =
+    AsyncHttpClientFs2Backend.resource[IO]().map(implicit backend => PokeApiClient(backend))
 
   spec("evolution chain by id", EvolutionChainRequest(1), _.babyTriggerItem.isEmpty)
   spec("evolution chain resource list", EvolutionChainRequest.resourceList(), _.count == 541)

src/test/scala/io/github/juliano/pokeapi/GamesSuite.scala

@@ -2,10 +2,10 @@ package io.github.juliano.pokeapi
 
 import cats.effect.IO
 import io.github.juliano.pokeapi.requests.*
-import sttp.client3.httpclient.fs2.HttpClientFs2Backend
+import sttp.client4.httpclient.fs2.HttpClientFs2Backend
 
 class GamesSuite extends Fs2Suite:
-  val client = HttpClientFs2Backend.resource[IO]().map(implicit backend => PokeApiClient())
+  val client = HttpClientFs2Backend.resource[IO]().map(implicit backend => PokeApiClient(backend))
 
   spec("generation by id", GenerationRequest(1), _.name == "generation-i")
   spec("generation by name", GenerationRequest("generation-i"), _.id == 1)

src/test/scala/io/github/juliano/pokeapi/ItemsSuite.scala

@@ -1,10 +1,10 @@
 package io.github.juliano.pokeapi;
 
 import io.github.juliano.pokeapi.requests.*
-import sttp.client3.httpclient.zio.HttpClientZioBackend
+import sttp.client4.httpclient.zio.HttpClientZioBackend
 
 class ItemsSuite extends ZIOSuite:
-  val client = HttpClientZioBackend().map(implicit backend => PokeApiClient())
+  val client = HttpClientZioBackend().map(implicit backend => PokeApiClient(backend))
 
   spec("item by id", ItemRequest(1), _.name == "master-ball")
   spec("item by name", ItemRequest("master-ball"), _.id == 1)

src/test/scala/io/github/juliano/pokeapi/LocationsSuite.scala

@@ -2,10 +2,10 @@ package io.github.juliano.pokeapi
 
 import cats.effect.IO
 import io.github.juliano.pokeapi.requests.*
-import sttp.client3.asynchttpclient.cats.AsyncHttpClientCatsBackend
+import sttp.client4.asynchttpclient.cats.AsyncHttpClientCatsBackend
 
 class LocationsSuite extends CatsSuite:
-  val client = AsyncHttpClientCatsBackend[IO]().map(implicit backend => PokeApiClient())
+  val client = AsyncHttpClientCatsBackend[IO]().map(implicit backend => PokeApiClient(backend))
 
   spec("location by id", LocationRequest(1), _.name == "canalave-city")
   spec("location by name", LocationRequest("canalave-city"), _.id == 1)

src/test/scala/io/github/juliano/pokeapi/MachinesSuite.scala

@@ -2,12 +2,10 @@ package io.github.juliano.pokeapi
 
 import io.github.juliano.pokeapi.requests.MachineRequest
 import sttp.capabilities.WebSockets
-import sttp.client3.{ Identity, SttpBackend }
-import sttp.client3.okhttp.OkHttpSyncBackend
+import sttp.client4.okhttp.OkHttpSyncBackend
 
 class MachinesSuite extends munit.FunSuite:
-  given backend: SttpBackend[Identity, WebSockets] = OkHttpSyncBackend()
-  val client = PokeApiClient()
+  val client = PokeApiClient(OkHttpSyncBackend())
 
   test("machine by id") {
     val machine = client.send(MachineRequest(1))

src/test/scala/io/github/juliano/pokeapi/MovesSuite.scala

@@ -1,13 +1,10 @@
 package io.github.juliano.pokeapi
 
 import io.github.juliano.pokeapi.requests.*
-import sttp.client3.{ SttpBackend, TryHttpURLConnectionBackend }
+import sttp.client4.pekkohttp.PekkoHttpBackend
 
-import scala.util.Try
-
-class MovesSuite extends TrySuite:
-  given backend: SttpBackend[Try, Any] = TryHttpURLConnectionBackend()
-  val client = PokeApiClient()
+class MovesSuite extends FutureSuite:
+  val client = PokeApiClient(PekkoHttpBackend())
 
   spec("move by id", MoveRequest(1), _.name == "pound")
   spec("move by name", MoveRequest("pound"), _.id == 1)

src/test/scala/io/github/juliano/pokeapi/PokemonSuite.scala

@@ -1,10 +1,10 @@
 package io.github.juliano.pokeapi
 
 import io.github.juliano.pokeapi.requests.*
-import sttp.client3.asynchttpclient.zio.AsyncHttpClientZioBackend
+import sttp.client4.asynchttpclient.zio.AsyncHttpClientZioBackend
 
 class PokemonSuite extends ZIOSuite:
-  val client = AsyncHttpClientZioBackend().map(implicit backend => PokeApiClient())
+  val client = AsyncHttpClientZioBackend().map(implicit backend => PokeApiClient(backend))
 
   spec("ability by id", AbilityRequest(1), _.name == "stench")
   spec("ability by name", AbilityRequest("stench"), _.id == 1)

src/test/scala/io/github/juliano/pokeapi/UtilitySuite.scala

@@ -1,10 +1,10 @@
 package io.github.juliano.pokeapi
 
 import io.github.juliano.pokeapi.requests.LanguageRequest
-import sttp.client3.armeria.zio.ArmeriaZioBackend
+import sttp.client4.armeria.zio.ArmeriaZioBackend
 
 class UtilitySuite extends ZIOSuite:
-  val client = ArmeriaZioBackend().map(implicit backend => PokeApiClient())
+  val client = ArmeriaZioBackend().map(implicit backend => PokeApiClient(backend))
 
   spec("language by id", LanguageRequest(1), _.name == "ja-Hrkt")
   spec("language by name", LanguageRequest("ja-Hrkt"), _.id == 1)