Rework build and add tests

Author: keynmol

.github/workflows/ci.yml

@@ -23,8 +23,17 @@ jobs:
       - name: Check formatting
         run: make code-check || echo "Run `make pre-ci`"
 
+      - name: Cache vcpkg
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/Library/Caches/sbt-vcpkg/vcpkg-install
+            ~/.cache/sbt-vcpkg/vcpkg-install
+            ~/.cache/sbt-vcpkg/vcpkg
+          key: ${{ runner.os }}-sbt-vcpkg
+
       - name: Test 
-        run: make test
+        run: make tests
 
       - name: Check documentation compiles and runs
         run: make check-docs && make run-example

.scalafix.conf

@@ -1,3 +1,3 @@
 OrganizeImports.groupedImports = Merge
 OrganizeImports.targetDialect = Scala3
-OrganizeImports.removeUnused = false
+OrganizeImports.removeUnused = true

Makefile

@@ -1,8 +1,9 @@
 check-docs:
-	scala-cli compile README.md smithy4s-fetch.scala project.scala
+	# scala-cli compile README.md *.scala 
+	echo "No supported yet"
 
-test:
-	scala-cli test .
+tests:
+	cs launch sn-vcpkg --contrib -- scala-cli curl s2n openssl zlib --rename curl=libcurl -- test .
 
 publish-snapshot:
 	scala-cli config publish.credentials s01.oss.sonatype.org env:SONATYPE_USERNAME env:SONATYPE_PASSWORD
@@ -17,7 +18,12 @@ code-check:
 	scala-cli fmt . --check
 
 run-example:
-	scala-cli run README.md project.scala smithy4s-fetch.scala -M helloWorld
+	scala-cli run README.md . -M helloWorld
 
 pre-ci:
 	scala-cli fmt .
+
+smithy4s:
+	cd test && \
+		rm -rf httpbin && \
+		cs launch smithy4s --contrib -- generate httpbin.smithy --skip resource --skip openapi

MonadThrowLikeTry.scala

@@ -0,0 +1,32 @@
+package smithy4s_curl
+
+import smithy4s.capability.MonadThrowLike
+import scala.util.*
+
+given MonadThrowLike[Try] with
+  def flatMap[A, B](fa: Try[A])(f: A => Try[B]): Try[B] = fa.flatMap(f)
+  def handleErrorWith[A](fa: Try[A])(f: Throwable => Try[A]): Try[A] =
+    fa match
+      case Failure(exception) => f(exception)
+      case _                  => fa
+
+  def pure[A](a: A): Try[A] = Success(a)
+  def raiseError[A](e: Throwable): Try[A] = Failure(e)
+  def zipMapAll[A](seq: IndexedSeq[Try[Any]])(f: IndexedSeq[Any] => A): Try[A] =
+    val b = IndexedSeq.newBuilder[Any]
+    b.sizeHint(seq.size)
+    var failure: Throwable = null
+
+    var i = 0
+
+    while failure == null && i < seq.length do
+      seq(i) match
+        case Failure(exception) => failure = exception
+        case Success(value)     => if failure == null then b += value
+
+      i += 1
+    end while
+
+    if failure != null then Failure(failure) else Try(f(b.result()))
+  end zipMapAll
+end given

README.md

@@ -29,13 +29,14 @@ Latest version: [![smithy4s-curl Scala version support](https://index.scala-lang
 For example's sake, let's say we have a smithy4s service that models one of the endpoints from https://httpbin.org, defined using [smithy4s-deriving](https://github.com/neandertech/smithy4s-deriving) (note we're using [Scala CLI](https://scala-cli.virtuslab.org) for this demo):
 
 ```scala
-//> using dep "tech.neander::smithy4s-deriving::0.0.2"
+//> using dep "tech.neander::smithy4s-deriving::0.0.0-SNAPSHOT"
 //> using platform scala-native
 //> using scala 3.4.2
 //> using option -Wunused:all
 
 import scala.annotation.experimental
 import smithy4s.*, deriving.{given, *}, aliases.*
+import scala.util.Try
 
 case class Response(headers: Map[String, String], origin: String, url: String)
     derives Schema
@@ -44,7 +45,7 @@ case class Response(headers: Map[String, String], origin: String, url: String)
 trait HttpbinService derives API:
   @readonly
   @httpGet("/get")
-  def get(): Response
+  def get(): Try[Response]
 ```
 
 ***Note** that we only need to use `@experimental` annotation because we are using smithy4s-deriving.*
@@ -58,10 +59,11 @@ import smithy4s_curl.*
 
 @main @experimental
 def helloWorld = 
-  val service: HttpbinService = 
+  val service = 
     SimpleRestJsonCurlClient(
       API.service[HttpbinService],
-      "https://httpbin.org"
+      "https://httpbin.org",
+      SyncCurlClient()
      ).make.unliftService
 
   println(service.get())

SimpleRestJsonCodecs.scala

@@ -0,0 +1,192 @@
+package smithy4s_curl
+
+import curl.all as C
+import smithy4s.Blob
+import smithy4s.client.*
+import smithy4s.codecs.BlobEncoder
+import smithy4s.http.HttpUriScheme.{Http, Https}
+import smithy4s.http.{
+  HttpDiscriminator,
+  HttpMethod,
+  HttpRequest,
+  HttpResponse,
+  HttpUnaryClientCodecs,
+  HttpUri,
+  HttpUriScheme,
+  Metadata
+}
+import smithy4s.json.Json
+import smithy4s_curl.*
+
+import scala.scalanative.unsigned.*
+import scala.util.{Failure, Success, Try}
+
+import scalanative.unsafe.*
+import util.chaining.*
+
+private[smithy4s_curl] object SimpleRestJsonCodecs
+    extends SimpleRestJsonCodecs(1024, false, false)
+
+private[smithy4s_curl] case class SimpleRestJsonCodecs(
+    maxArity: Int,
+    explicitDefaultsEncoding: Boolean,
+    hostPrefixInjection: Boolean
+):
+  private val hintMask =
+    alloy.SimpleRestJson.protocol.hintMask
+
+  def fromSmithy4sHttpUri(uri: smithy4s.http.HttpUri): String =
+    val qp = uri.queryParams
+    val newValue =
+      uri.scheme match
+        case Http  => "http"
+        case Https => "https"
+    val hostName = uri.host
+    val port =
+      uri.port
+        .filterNot(p => uri.host.endsWith(s":$p"))
+        .map(":" + _.toString)
+        .getOrElse("")
+
+    val path = "/" + uri.path.mkString("/")
+    val query =
+      if qp.isEmpty then ""
+      else
+        var b = "?"
+        qp.zipWithIndex.map:
+          case ((key, values), idx) =>
+            if idx != 0 then b += "&"
+            b += key
+            for
+              i <- 0 until values.length
+              value = values(i)
+            do
+              if i == 0 then b += "=" + value
+              else b += s"&$key=$value"
+            end for
+
+        b
+
+    s"$newValue://$hostName$port$path$query"
+  end fromSmithy4sHttpUri
+
+  def toSmithy4sHttpUri(
+      uri: String,
+      pathParams: Option[smithy4s.http.PathParams] = None
+  ): smithy4s.http.HttpUri =
+
+    import C.CURLUPart.*
+    import C.CURLUcode.*
+
+    Zone:
+      implicit z =>
+
+        val url = C.curl_url()
+
+        checkU(
+          C.curl_url_set(
+            url,
+            CURLUPART_URL,
+            toCString(uri),
+            0.toUInt
+          )
+        )
+
+        def getPart(part: C.CURLUPart): String =
+          val scheme = stackalloc[Ptr[Byte]](1)
+
+          checkU(C.curl_url_get(url, part, scheme, 0.toUInt))
+
+          val str = fromCString(!scheme)
+
+          C.curl_free(!scheme)
+
+          str
+        end getPart
+
+        val httpScheme = getPart(CURLUPART_SCHEME) match
+          case "https" => HttpUriScheme.Https
+          case "http"  => HttpUriScheme.Http
+          case other =>
+            throw UnsupportedOperationException(
+              s"Protocol `${other}` is not supported"
+            )
+
+        val port = Try(getPart(CURLUPART_PORT)) match
+          case Failure(CurlUrlParseException(CURLUE_NO_PORT, _)) =>
+            None
+          case Success(value) => Some(value.toInt)
+
+          case Failure(other) => throw other
+
+        val host = getPart(CURLUPART_HOST)
+        val path = getPart(CURLUPART_PATH)
+
+        val cleanedPath: IndexedSeq[String] =
+          path.tail
+            // drop the guaranteed leading slash, so that we don't produce an empty segment for it
+            .tail
+            // splitting an empty path would produce a single element, so we special-case to empty
+            .match
+              case ""    => IndexedSeq.empty[String]
+              case other => other.split("/")
+
+        HttpUri(
+          httpScheme,
+          host,
+          port,
+          cleanedPath,
+          Map.empty,
+          pathParams
+        )
+  end toSmithy4sHttpUri
+
+  val jsonCodecs = Json.payloadCodecs
+    .withJsoniterCodecCompiler(
+      Json.jsoniter
+        .withHintMask(hintMask)
+        .withMaxArity(maxArity)
+        .withExplicitDefaultsEncoding(explicitNulls = true)
+    )
+
+  val payloadEncoders: BlobEncoder.Compiler =
+    jsonCodecs.encoders
+
+  val payloadDecoders =
+    jsonCodecs.decoders
+
+  val errorHeaders = List(
+    smithy4s.http.errorTypeHeader
+  )
+
+  def makeClientCodecs(
+      uri: String
+  ): UnaryClientCodecs.Make[Try, HttpRequest[Blob], HttpResponse[Blob]] =
+    val baseRequest = HttpRequest(
+      HttpMethod.POST,
+      toSmithy4sHttpUri(uri, None),
+      Map.empty,
+      Blob.empty
+    )
+
+    HttpUnaryClientCodecs.builder
+      .withBodyEncoders(payloadEncoders)
+      .withSuccessBodyDecoders(payloadDecoders)
+      .withErrorBodyDecoders(payloadDecoders)
+      .withErrorDiscriminator(resp =>
+        Success(HttpDiscriminator.fromResponse(errorHeaders, resp))
+      )
+      .withMetadataDecoders(Metadata.Decoder)
+      .withMetadataEncoders(
+        Metadata.Encoder.withExplicitDefaultsEncoding(
+          explicitDefaultsEncoding
+        )
+      )
+      .withBaseRequest(_ => Success(baseRequest))
+      .withRequestMediaType("application/json")
+      .withRequestTransformation[HttpRequest[Blob]](Success(_))
+      .withResponseTransformation[HttpResponse[Blob]](Success(_))
+      .withHostPrefixInjection(hostPrefixInjection)
+      .build()
+  end makeClientCodecs
+end SimpleRestJsonCodecs