no more yaml

Author: Quafadas

build.sc

@@ -29,7 +29,6 @@ object project extends ScalaModule with PublishModule with FormatFix /*with Scal
     ivy"com.monovore::decline::2.4.1",
     ivy"com.monovore::decline-effect::2.4.1",
     ivy"com.lihaoyi::os-lib:0.10.1",
-    ivy"io.circe::circe-yaml::0.15.1",
     ivy"com.outr::scribe-cats::3.13.5"
   )
 
@@ -73,10 +72,6 @@ Resolution failed for 2 modules:
   com.outr:scribe-cats_native0.4_3:3.13.5
         not found: /Users/simon/.ivy2/local/com.outr/scribe-cats_native0.4_3/3.13.5/ivys/ivy.xml
         not found: https://repo1.maven.org/maven2/com/outr/scribe-cats_native0.4_3/3.13.5/scribe-cats_native0.4_3-3.13.5.pom
-  io.circe:circe-yaml_native0.4_3:0.15.1
-        not found: /Users/simon/.ivy2/local/io.circe/circe-yaml_native0.4_3/0.15.1/ivys/ivy.xml
-        not found: https://repo1.maven.org/maven2/io/circe/circe-yaml_native0.4_3/0.15.1/circe-yaml_native0.4_3-0.15.1.pom
-
 --------------------------------------------
 
 For additional information on library dependencies, see the docs at

project/src/live.server.scala

@@ -24,6 +24,10 @@ import _root_.io.circe.*
 import _root_.io.circe.Encoder
 
 import ProxyConfig.Equilibrium
+import ProxyConfig.Server
+import com.comcast.ip4s.Host
+import cats.data.NonEmptyList
+import ProxyConfig.LocationMatcher
 
 sealed trait FrontendEvent derives Encoder.AsObject
 
@@ -247,12 +251,53 @@ object LiveServer
           .withHandler(minimumLevel = Some(Level.get(lvl).get))
           .replace()
 
-        val proxyConfig: Resource[IO, Option[Equilibrium]] = proxyTarget
+        // val proxyConfig: Resource[IO, Option[Equilibrium]] = proxyTarget
+        //   .zip(pathPrefix)
+        //   .traverse {
+        //     (pt, prfx) =>
+        //       ProxyConfig.loadYaml[IO](makeProxyConfig(port, pt, prfx)).toResource
+        //   }
+
+        val proxyConf2: Resource[IO, Option[Equilibrium]] = proxyTarget
           .zip(pathPrefix)
           .traverse {
             (pt, prfx) =>
-              ProxyConfig.loadYaml[IO](makeProxyConfig(port, pt, prfx)).toResource
+              // ProxyConfig.loadYaml[IO](makeProxyConfig(port, pt, prfx)).toResource
+              IO(
+                Equilibrium(
+                  ProxyConfig.HttpProxyConfig(
+                    servers = NonEmptyList(
+                      Server(
+                        listen = port,
+                        serverNames = List("localhost"),
+                        locations = List(
+                          ProxyConfig.Location(
+                            matcher = LocationMatcher.Prefix(prfx),
+                            proxyPass = s"http://$$backend"
+                          )
+                        )
+                      ),
+                      List()
+                    ),
+                    upstreams = List(
+                      ProxyConfig.Upstream(
+                        name = "backend",
+                        servers = NonEmptyList(
+                          ProxyConfig.UpstreamServer(
+                            host = Host.fromString("localhost").get,
+                            port = pt,
+                            weight = 5
+                          ),
+                          List()
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+
           }
+          .toResource
 
         val server = for
           _ <- logger
@@ -268,7 +313,7 @@ object LiveServer
           outDirPath = fs2.io.file.Path(outDir)
           baseDirPath = fs2.io.file.Path(baseDir)
 
-          proxyRoutes: HttpRoutes[IO] <- makeProxyRoutes(client, pathPrefix, proxyConfig)(logger)
+          proxyRoutes: HttpRoutes[IO] <- makeProxyRoutes(client, pathPrefix, proxyConf2)(logger)
 
           _ <- buildRunner(
             buildTool,

project/src/proxy.config.scala

@@ -1,26 +1,14 @@
 import com.comcast.ip4s.*
 
 import cats.data.NonEmptyList
-import cats.effect.kernel.*
-import cats.syntax.all.*
 
-import io.circe.*
-import io.circe.yaml.parser
+import cats.syntax.all.*
 
 object ProxyConfig:
 
-  def loadYaml[F[_]: Async](content: String): F[Equilibrium] =
-    parser.parse(content).liftTo[F].flatMap(_.as[Equilibrium].liftTo[F])
-
   case class Equilibrium(
-      http: Http
+      http: HttpProxyConfig
   )
-  object Equilibrium:
-    implicit val decoder: Decoder[Equilibrium] = new Decoder[Equilibrium]:
-      def apply(c: HCursor): Decoder.Result[Equilibrium] = for http <- c.downField("http").as[Http]
-      yield Equilibrium(http)
-  end Equilibrium
-
   sealed trait LocationMatcher
   object LocationMatcher:
     case class Exact(value: String) extends LocationMatcher
@@ -30,120 +18,33 @@ object ProxyConfig:
     object ModifierSymbol:
       case object Exact extends ModifierSymbol
       case object Prefix extends ModifierSymbol
-
-      implicit val decoder: Decoder[ModifierSymbol] = Decoder[String].emap {
-        case "=" => Exact.asRight
-        case _   => "Invalid Modifier".asLeft
-      }
     end ModifierSymbol
-
-    // Add Regex Support via dynamapath
-    // case object CaseSensitiveRegex(d: Path) extends LocationModifier // TODO Add CaseSenstive Option
   end LocationMatcher
 
   case class Location(
       // key modifier defaults to Prefix, can override to =
       matcher: LocationMatcher,
       proxyPass: String // Has Our variables
   )
-  object Location:
-    def decoder(
-        upstreams: Map[String, Upstream]
-    ) = new Decoder[Location]:
-      def apply(c: HCursor): Decoder.Result[Location] = for
-        modifier <- c
-          .downField("modifier")
-          .as[Option[LocationMatcher.ModifierSymbol]]
-          .map(_.getOrElse(LocationMatcher.ModifierSymbol.Prefix))
-        out <- modifier match
-          case LocationMatcher.ModifierSymbol.Exact =>
-            c.downField("matcher").as[String].map(LocationMatcher.Exact(_))
-          case LocationMatcher.ModifierSymbol.Prefix =>
-            c.downField("matcher").as[String].map(LocationMatcher.Prefix(_))
-        // TODO support all positions not only tail position
-        proxy <- c
-          .downField("proxyPass")
-          .as[String](Decoder[String].emap {
-            s =>
-              if !s.contains("$") then s.asRight
-              else
-                s.split('$')
-                  .lastOption
-                  .toRight("Value doesnt exist in split")
-                  .flatMap {
-                    variable =>
-                      if upstreams.contains(variable) then s.asRight
-                      else s"Variable $variable not present in upstreams".asLeft
-                  }
-
-          })
-      yield Location(out, proxy)
-  end Location
 
   case class Server(
       listen: Port,
       serverNames: List[String],
       locations: List[Location]
   )
-  object Server:
-    def decoder(
-        upstreams: Map[String, Upstream]
-    ) = new Decoder[Server]:
-      def apply(c: HCursor): Decoder.Result[Server] = for
-        listen <-
-          if !c.downField("listen").failed then
-            c.downField("listen")
-              .as[Int]
-              .flatMap {
-                Port.fromInt(_).toRight(DecodingFailure("Invalid Port", List.empty))
-              }
-          else port"8080".asRight
-        names <- c.downField("serverNames").as[List[String]]
-        locations <- c.downField("locations").as[List[Location]](Decoder.decodeList(Location.decoder(upstreams)))
-      yield Server(listen, names, locations)
-  end Server
-
   case class UpstreamServer(
       host: Host,
       port: Port,
       weight: Int
   )
-  object UpstreamServer:
-    implicit val decoder: Decoder[UpstreamServer] = new Decoder[UpstreamServer]:
-      def apply(c: HCursor): Decoder.Result[UpstreamServer] = for
-        host <- c
-          .downField("host")
-          .as[String]
-          .flatMap(s => Host.fromString(s).toRight(DecodingFailure("Invalid Host", List.empty)))
-        port <- c
-          .downField("port")
-          .as[Int]
-          .flatMap(i => Port.fromInt(i).toRight(DecodingFailure("Invalid Port", List.empty)))
-        weight <- c.downField("weight").as[Option[Int]].map(_.getOrElse(1))
-      yield UpstreamServer(host, port, weight)
-  end UpstreamServer
   case class Upstream(
       name: String,
       servers: NonEmptyList[UpstreamServer]
   )
-  object Upstream:
-    implicit val decoder: Decoder[Upstream] = new Decoder[Upstream]:
-      def apply(c: HCursor): Decoder.Result[Upstream] = (
-        c.downField("name").as[String],
-        c.downField("servers").as[NonEmptyList[UpstreamServer]]
-      ).mapN(Upstream(_, _))
-  end Upstream
 
-  case class Http(
+  case class HttpProxyConfig(
       servers: NonEmptyList[Server],
       upstreams: List[Upstream]
   )
-  object Http:
-    implicit val decoder: Decoder[Http] = new Decoder[Http]:
-      def apply(c: HCursor): Decoder.Result[Http] = for
-        upstreams <- c.downField("upstreams").as[List[Upstream]]
-        map = upstreams.groupBy(_.name).map(t => t._1 -> t._2.head).toMap
-        servers <- c.downField("servers").as[NonEmptyList[Server]](Decoder.decodeNonEmptyList(Server.decoder(map)))
-      yield Http(servers, upstreams)
-  end Http
+
 end ProxyConfig

project/test/src/ConfigSpec.scala

@@ -116,7 +116,7 @@ class PlaywrightTest extends munit.FunSuite:
       assertEquals(out.statusCode, 404)
   }
 
-  files.test("proxy server") {
+  files.test("proxy server".only) {
     testDir =>
       val backendPort = 8089
       val thisTestPort = 3005