Migrate frontend to use Tapir endpoints

app/src/main/scala/api.helpers.scala

@@ -1,10 +1,11 @@
 package twotm8
 
 import snunit.*
-import scala.util.Try
+
+import java.util.UUID
 import scala.util.Failure
 import scala.util.Success
-import java.util.UUID
+import scala.util.Try
 
 trait ApiHelpers:
   inline def handleException(inline handler: Handler): Handler = req =>

app/src/main/scala/api.scala

@@ -4,8 +4,8 @@ package api
 import roach.RoachException
 import roach.RoachFatalException
 import snunit.tapir.SNUnitInterpreter.*
-import sttp.tapir.server.*
 import sttp.tapir.*
+import sttp.tapir.server.*
 
 import java.util.UUID
 
@@ -50,9 +50,8 @@ class Api(app: App):
       .serverLogicSuccess(delete_twot)
   )
 
-  private def validateBearer(bearer: String): Either[ErrorInfo, AuthContext] =
-    val jwt = JWT(bearer)
-    app.validate(jwt) match
+  private def validateBearer(bearer: JWT): Either[ErrorInfo, AuthContext] =
+    app.validate(bearer) match
       case None =>
         Left(ErrorInfo.Unauthorized())
       case Some(auth) =>
@@ -115,9 +114,8 @@ class Api(app: App):
     end if
   end create_twot
 
-  private def delete_twot(auth: AuthContext)(uuid: UUID): Unit =
+  private def delete_twot(auth: AuthContext)(twotId: TwotId): Unit =
     val authorId = auth.author
-    val twotId = TwotId(uuid)
 
     app.delete_twot(authorId, twotId)
 

app/src/main/scala/auth.scala

@@ -1,19 +1,19 @@
 package twotm8
 
-import scala.scalanative.unsafe.*
-import scala.scalanative.libc.*
-
-import scala.util.Using
-import java.util.UUID
+import openssl.OpenSSL
 import openssl.functions.*
 import openssl.types.*
+
 import java.time.Instant
-import scala.concurrent.duration.*
-import scala.scalanative.posix.time
 import java.util.Base64
+import java.util.UUID
 import java.{util as ju}
+import scala.concurrent.duration.*
+import scala.scalanative.libc.*
+import scala.scalanative.posix.time
+import scala.scalanative.unsafe.*
 import scala.util.Try
-import openssl.OpenSSL
+import scala.util.Using
 
 object Auth:
   def validate(

app/src/main/scala/db.scala

@@ -1,7 +1,9 @@
 package twotm8
 package db
 
-import roach.{Database, Codec}
+import roach.Codec
+import roach.Database
+
 import java.util.UUID
 import scala.scalanative.unsafe.*
 import scala.util.Using

app/src/main/scala/server.scala

@@ -6,8 +6,8 @@ import scribe.format.Formatter
 import scribe.handler.LogHandler
 import scribe.writer.SystemErrWriter
 import snunit.*
-import snunit.tapir.*
 import snunit.tapir.SNUnitInterpreter.*
+import snunit.tapir.*
 import twotm8.db.DB
 
 import scala.concurrent.duration.*

build.sbt

@@ -9,7 +9,7 @@ Global / onChangedBuildSource := ReloadOnSourceChanges
 val Versions = new {
   val Scala = "3.2.0"
   val SNUnit = "0.0.24"
-  val Tapir = "1.0.6"
+  val Tapir = "1.1.0"
   val upickle = "2.0.0"
   val scribe = "3.10.3"
   val Laminar = "0.14.2"
@@ -57,9 +57,12 @@ lazy val frontend =
         "org.scala-js" %%% "scalajs-dom" % Versions.scalajsDom,
         "com.raquo" %%% "waypoint" % Versions.waypoint,
         "com.lihaoyi" %%% "upickle" % Versions.upickle,
+        "com.softwaremill.sttp.tapir" %%% "tapir-sttp-client" % Versions.Tapir,
+        "com.softwaremill.retry" %%% "retry" % "0.3.5",
         "com.github.japgolly.scalacss" %%% "core" % Versions.scalacss
       )
     )
+    .dependsOn(shared.js)
 
 lazy val app =
   project
@@ -70,7 +73,7 @@ lazy val app =
     .settings(vcpkgNativeConfig())
     .settings(
       scalaVersion := Versions.Scala,
-      vcpkgDependencies := Set("libpq", "openssl", "libidn2"),
+      vcpkgDependencies := Set("libpq", "openssl"),
       libraryDependencies += "com.softwaremill.sttp.model" %%% "core" % "1.5.2",
       libraryDependencies += "com.outr" %%% "scribe" % Versions.scribe,
       libraryDependencies += "com.lihaoyi" %%% "upickle" % Versions.upickle,

frontend/src/main/scala/RetryingBackend.scala

@@ -0,0 +1,43 @@
+package twotm8
+package frontend
+
+import scalacss.internal.LengthUnit.ex
+import sttp.capabilities.Effect
+import sttp.client3.*
+import sttp.model.Method
+
+import scala.concurrent.Future
+import scala.concurrent.duration.*
+
+class RetryingBackend[P](
+    delegate: SttpBackend[Future, P]
+)(using stability: Stability)
+    extends DelegateSttpBackend[Future, P](delegate):
+  import scala.concurrent.ExecutionContext.Implicits.global
+
+  private given retry.Success[
+    (Request[?, ?], Either[Throwable, Response[?]])
+  ]((req, res) => !RetryWhen.Default(req, res))
+
+  // The default timer is currently broken in JS
+  // https://github.com/softwaremill/odelay/pull/19
+  private given odelay.Timer = odelay.js.JsTimer.newTimer
+
+  override def send[T, R >: P & Effect[Future]](
+      request: Request[T, R]
+  ): Future[Response[T]] =
+    retry
+      .Backoff(stability.maxRetries, stability.delay)
+      .apply {
+        delegate
+          .send(request)
+          .transform(tryResponse =>
+            scala.util.Success((request, tryResponse.toEither))
+          )
+      }
+      .flatMap {
+        case (_, Right(response)) => Future.successful(response)
+        case (_, Left(exception)) => Future.failed(exception)
+      }
+
+end RetryingBackend

frontend/src/main/scala/api.client.scala

@@ -7,152 +7,107 @@ import com.raquo.laminar.api.L.*
 import com.raquo.waypoint.*
 import org.scalajs.dom
 import org.scalajs.dom.Fetch.fetch
+import org.scalajs.dom.RequestInit
 import org.scalajs.dom.*
 import org.scalajs.dom.experimental.ResponseInit
+import sttp.client3.FetchBackend
+import sttp.client3.SttpBackend
+import sttp.tapir.Endpoint
+import sttp.tapir.Endpoint.apply
+import sttp.tapir.client.sttp.SttpClientInterpreter
+import twotm8.api.ErrorInfo
+import twotm8.api.ErrorInfo.Unauthorized
+import twotm8.api.Payload
+import twotm8.endpoints.*
+import twotm8.frontend.RetryingBackend
 import upickle.default.ReadWriter
 
 import scala.concurrent.Future
 import scala.scalajs.js
 import scala.scalajs.js.JSON
 import scala.scalajs.js.Promise
-import twotm8.frontend.Responses.ThoughtLeaderProfile
-import org.scalajs.dom.RequestInit
 
 object ApiClient extends ApiClient(using Stability())
 
 class ApiClient(using Stability):
-  import scala.scalajs.js
-  import js.Thenable.Implicits.*
   import scala.concurrent.ExecutionContext.Implicits.global
 
-  extension (req: Future[Response])
-    def authenticated[A](f: Response => Future[A]): Future[Either[Error, A]] =
-      req.flatMap { resp =>
-        if resp.status == 401 then Future.successful(Left(Error.Unauthorized))
-        else f(resp).map(Right.apply)
-      }
+  private val backend = RetryingBackend(FetchBackend())
+  private val interpreter = SttpClientInterpreter()
 
-  def get_profile(
-      author: String,
-      token: Option[Token]
-  ): Future[Responses.ThoughtLeaderProfile] =
-    exponentialFetch(
-      s"/api/thought_leaders/$author",
-      addAuth(new RequestInit {}, token)
-    ).flatMap { resp =>
-      resp
-        .json()
-        .map(fromJson[Responses.ThoughtLeaderProfile])
-    }
-
-  def me(tok: Token): Future[Either[Error, ThoughtLeaderProfile]] =
-    val req = new RequestInit {}
-    req.method = HttpMethod.GET
-    exponentialFetch("/api/thought_leaders/me", addAuth(req, tok))
-      .authenticated { resp =>
-        resp.json().map(fromJson[Responses.ThoughtLeaderProfile])
-      }
+  def get_profile(author: String, token: Option[Token]) = interpreter
+    .toSecureClientThrowErrors(endpoints.get_thought_leader, None, backend)
+    .apply(token.map(_.value))
+    .apply(author)
 
-  def is_authenticated(token: Token): Future[Boolean] =
-    me(token).map(_.isRight)
+  def me(token: Token) =
+    interpreter
+      .toSecureClientThrowDecodeFailures(endpoints.get_me, None, backend)
+      .apply(token.value)
+      .apply(())
 
   def get_wall(token: Token) =
-    exponentialFetch("/api/twots/wall", addAuth(new RequestInit {}, token))
-      .authenticated { resp =>
-        resp.json().map(fromJson[List[Responses.Twot]])
-      }
-
-  private def addAuth(rq: RequestInit, tok: Token) =
-    rq.headers = js.Dictionary("Authorization" -> s"Bearer ${tok.value}")
-    rq
-
-  private def addAuth(rq: RequestInit, tokenMaybe: Option[Token]) =
-    tokenMaybe.foreach { tok =>
-      rq.headers = js.Dictionary("Authorization" -> s"Bearer ${tok.value}")
-    }
-    rq
-
-  def login(
-      payload: Payloads.Login
-  ): Future[Either[String, Responses.TokenResponse]] =
-    val req = new RequestInit {}
-    req.method = HttpMethod.POST
-    req.body = toJsonString(payload)
-
-    exponentialFetch(s"/api/auth/login", req, forceRetry = true)
-      .flatMap { resp =>
-        if resp.ok then
-          resp.json().map(fromJson[Responses.TokenResponse]).map(Right.apply)
-        else resp.text().map(txt => Left(txt))
-
-      }
-  end login
-
-  def register(payload: Payloads.Register): Future[Option[String]] =
-    val req = new RequestInit {}
-    req.method = HttpMethod.PUT
-    req.body = toJsonString(payload)
-
-    exponentialFetch(s"/api/auth/register", req)
-      .flatMap { resp =>
-        if resp.ok then Future.successful(None)
-        else resp.text().map(txt => Some(txt))
-
+    interpreter
+      .toSecureClientThrowDecodeFailures(endpoints.get_wall, None, backend)
+      .apply(token.value)
+      .apply(())
+
+  def register(payload: Payload.Register) =
+    interpreter
+      .toClientThrowDecodeFailures(endpoints.register, None, backend)
+      .apply(payload)
+      .map {
+        case Right(_)        => None
+        case Left(errorInfo) => Some(errorInfo.message)
       }
-  end register
-
-  def create(payload: Payloads.Create, token: Token) =
-    val req = new RequestInit {}
-    req.method = HttpMethod.POST
-    req.body = toJsonString(payload)
-
-    exponentialFetch(s"/api/twots/create", addAuth(req, token))
-      .authenticated { resp =>
-        if resp.ok then Future.successful(None)
-        else resp.text().map(txt => Some(txt))
 
+  def login(payload: Payload.Login) = interpreter
+    .toClientThrowDecodeFailures(endpoints.login, None, backend)
+    .apply(payload)
+
+  def create(payload: Payload.Create, token: Token) =
+    interpreter
+      .toSecureClientThrowDecodeFailures(endpoints.create_twot, None, backend)
+      .apply(token.value)
+      .apply(payload)
+      .map {
+        case Right(_)                    => Right(None)
+        case Left(Unauthorized(message)) => Left(Unauthorized(message))
+        case Left(errorInfo)             => Right(Some(errorInfo.message))
       }
-  end create
-
-  def delete_twot(id: String, token: Token) =
-    val req = new RequestInit {}
-    req.method = HttpMethod.DELETE
 
-    exponentialFetch(s"/api/twots/$id", addAuth(req, token))
-      .authenticated(resp => Future.successful(resp.ok))
-
-  def set_uwotm8(
-      payload: Payloads.Uwotm8,
-      state: Boolean,
-      token: Token
-  ) =
-    val req = new RequestInit {}
-    req.method = if state then HttpMethod.PUT else HttpMethod.DELETE
-    req.body = toJsonString(payload)
+  def delete_twot(twotId: TwotId, token: Token) =
+    interpreter
+      .toSecureClientThrowDecodeFailures(endpoints.delete_twot, None, backend)
+      .apply(token.value)
+      .apply(twotId)
 
-    exponentialFetch(s"/api/twots/uwotm8", addAuth(req, token))
-      .authenticated { resp =>
-        if resp.ok then Future.successful(None)
-        else resp.text().map(txt => Some(txt))
+  def set_follow(payload: Payload.Follow, state: Boolean, token: Token) =
+    val endpoint =
+      if state then endpoints.add_follower else endpoints.delete_follower
+    set(payload, endpoint, token)
+  end set_follow
 
-      }
+  def set_uwotm8(payload: Payload.Uwotm8, state: Boolean, token: Token) =
+    val endpoint =
+      if state then endpoints.add_uwotm8 else endpoints.delete_uwotm8
+    set(payload, endpoint, token)
   end set_uwotm8
 
-  def set_follow(
-      payload: Payloads.Follow,
-      state: Boolean,
+  private def set[T, U](
+      payload: T,
+      endpoint: Endpoint[JWT, T, ErrorInfo, U, Any],
       token: Token
   ) =
-    val req = new RequestInit {}
-    req.method = if state then HttpMethod.PUT else HttpMethod.DELETE
-    req.body = toJsonString(payload)
-
-    exponentialFetch(s"/api/thought_leaders/follow", addAuth(req, token))
-      .authenticated { resp =>
-        if resp.ok then Future.successful(None)
-        else resp.text().map(txt => Some(txt))
-
+    interpreter
+      .toSecureClientThrowDecodeFailures(endpoint, None, backend)
+      .apply(token.value)
+      .apply(payload)
+      .map {
+        case Right(_)                    => Right(None)
+        case Left(Unauthorized(message)) => Left(Unauthorized(message))
+        case Left(errorInfo)             => Right(Some(errorInfo.message))
       }
-  end set_follow
+  end set
 
 end ApiClient