Removed fs2 jawn

build.sbt

@@ -146,8 +146,7 @@ lazy val http4s = module("http4s") {
     .settings(
       description := "http4s based client for kubernetes",
       libraryDependencies ++= Seq(
-        "org.http4s" %%% "http4s-client" % "0.23.27",
-        "org.typelevel" %%% "jawn-fs2" % "2.4.0"
+        "org.http4s" %%% "http4s-client" % "0.23.27"
       )
     )
     .dependsOn(client, jawn)

modules/http4s-ember/.js/src/main/scala/PlatformCompanion.scala

@@ -102,10 +102,10 @@ private[http4s] abstract class PlatformCompanion[F[_]: Async: Files: Env]
             "Cannot find where/how to connect using the provided config!"
           ).raiseError
         )
-      case Some((cluster, server, auth)) =>
+      case Some((clusterData, server, auth)) =>
         ssl(
-          caFile = cluster.`certificate-authority`,
-          caData = cluster.`certificate-authority-data`,
+          caFile = clusterData.`certificate-authority`,
+          caData = clusterData.`certificate-authority-data`,
           clientCert = auth.`client-certificate-data`,
           clientCertFile = auth.`client-certificate`,
           clientKey = auth.`client-key-data`,

modules/http4s-ember/.native/src/main/scala/PlatformCompanion.scala

@@ -95,10 +95,10 @@ private[http4s] abstract class PlatformCompanion[F[_]: Async: Files: Env]
             "Cannot find where/how to connect using the provided config!"
           ).raiseError
         )
-      case Some((cluster, server, auth)) =>
+      case Some((clusterData, server, auth)) =>
         client(
-          caFile = cluster.`certificate-authority`,
-          caData = cluster.`certificate-authority-data`,
+          caFile = clusterData.`certificate-authority`,
+          caData = clusterData.`certificate-authority-data`,
           clientCert = auth.`client-certificate-data`,
           clientCertFile = auth.`client-certificate`,
           clientKey = auth.`client-key-data`,

modules/http4s/.jvm/src/main/scala/JVMPlatform.scala

@@ -68,8 +68,8 @@ private[http4s] abstract class JVMPlatform[F[_]](implicit
             "Cannot find where/how to connect using the provided config!"
           ).raiseError
         )
-      case Some((cluster, server, auth)) =>
-        val sslContext = F.blocking(SSLContexts.from(cluster, auth))
+      case Some((clusterData, server, auth)) =>
+        val sslContext = F.blocking(SSLContexts.from(clusterData, auth))
 
         Resource
           .eval(sslContext)

modules/http4s/src/main/scala/Http4sBackend.scala

@@ -107,6 +107,29 @@ final class Http4sBackend[F[_], T] private (client: Client[F])(implicit
       )
     )
 
+  private def parseJsonStream: fs2.Pipe[F, Byte, T] = {
+    import dev.hnaderi.k8s.jawn
+    import org.typelevel.jawn._
+    import fs2.{Pull, Chunk}
+
+    implicit val jawnFacade: Facade.SimpleFacade[T] = jawn.jawnFacade[T]
+    def go(
+        parser: AsyncParser[T]
+    )(s: Stream[F, Chunk[Byte]]): Pull[F, T, Unit] = {
+      def handle(attempt: Either[ParseException, collection.Seq[T]]) =
+        attempt.fold(Pull.raiseError[F], js => Pull.output(Chunk.from(js)))
+
+      s.pull.uncons1.flatMap {
+        case Some((a, stream)) =>
+          handle(parser.absorb(a.toByteBuffer)) >> go(parser)(stream)
+        case None =>
+          handle(parser.finish()) >> Pull.done
+      }
+    }
+
+    src => go(AsyncParser[T](AsyncParser.ValueStream))(src.chunks).stream
+  }
+
   override def connect[O: Decoder](
       url: String,
       verb: APIVerb,
@@ -115,15 +138,11 @@ final class Http4sBackend[F[_], T] private (client: Client[F])(implicit
       cookies: Seq[(String, String)]
   ): Stream[F, O] = {
     import Stream._
-    import org.typelevel.jawn.fs2._
-    import dev.hnaderi.k8s.jawn
-    import org.typelevel.jawn.Facade
-    implicit val jawnFacade: Facade.SimpleFacade[T] = jawn.jawnFacade[T]
 
     eval(urlFrom(url, params))
       .map(methodFor(verb)(_, Headers(headers) ++ cookiesFor(cookies)))
       .flatMap(client.stream(_))
-      .flatMap(_.body.chunks.parseJsonStream[T])
+      .flatMap(_.body.through(parseJsonStream))
       .flatMap { s =>
         s.decodeTo[O]
           .fold(err => raiseError[F](new Exception(s"$err\n$s")), emit(_))

modules/sttp/.jvm/src/main/scala/SttpJVM.scala

@@ -59,8 +59,8 @@ private[client] trait SttpJVM[F[_]] {
         throw new IllegalArgumentException(
           "Cannot find where/how to connect using the provided config!"
         )
-      case Some((cluster, server, auth)) =>
-        val ssl = SSLContexts.from(cluster, auth)
+      case Some((clusterData, server, auth)) =>
+        val ssl = SSLContexts.from(clusterData, auth)
         HttpClient[SttpF[F, *]](
           server,
           SttpKBackend[F, T](buildWithSSLContext(ssl)),
@@ -124,8 +124,8 @@ private[client] trait SttpJVM[F[_]] {
     val str = readFile(config)
     manifest.parse[Config](str) match {
       case Left(error) => throw error
-      case Right(config) =>
-        fromConfig(config, context = context, cluster = cluster)
+      case Right(configData) =>
+        fromConfig(configData, context = context, cluster = cluster)
     }
   }