use Custom NotFound error for SimpleRestJsonBuilder generated routes

[ShahOdin]

with the http4s SimpleRestJsonBuilder I want to return a custom NotFoundError so I added the following middleware:

import cats.MonadThrow
import cats.data.Kleisli
import org.http4s.{HttpApp, Request, Response}
import smithy4s.my.api.errors.NotFound
import cats.syntax.all.*
import smithy4s.Service
import smithy4s.http4s.ServerEndpointMiddleware

object OrNotFoundMiddleware:

  def apply[F[_]: MonadThrow]: ServerEndpointMiddleware[F] = new ServerEndpointMiddleware[F]:
    override def prepare[Alg[_[_, _, _, _, _]]](
                                                 service: Service[Alg]
                                               )(endpoint: service.Endpoint[_, _, _, _, _]): HttpApp[F] => HttpApp[F] = app =>
      Kleisli[F, Request[F], Response[F]](r =>
        app.run(r).attemptT.getOrRaise(
          NotFound(
            message = "message goes here."
          )
        )
      )

This is of course technically incorrect as it recovers from all internal errors not just the cases where the request can't be matched against any smithy generated routes

Note that SimpleRestJsonBuilder.routes(...).resources gives me HttpRoutes as opposed to HttpApp, so when I put the service together I have no choice but to then add route.orNotFound.

I'd have expected the middleware to pick up the NotFound but I still get the default Not Found response from http4s itself.

So that doesn't work. any potential other ways I could do this?

[Baccata]

This is a problem that should be solved by an old-fashioned http4s middleware. The smithy4s endpoint specific middleware operates at a different level, once a request have matched a specific endpoint. If your user get a NotFound, it's because the request didn't match any of the endpoints, so the smithy4s "server endpoint middleware" is not applicable. Even modelling "NotFound" as a error in smithy is arguably not pertinent.

All you need is roughly :

def change404[F[_] : MonadThrow](app : HttpApp[F]):  HttpApp[F] = HttpApp.of[F] { req => 
     app.run(req).flatMap { response => 
        // if response status code is 404 then change response 
     }
}

[ShahOdin]

Even modelling "NotFound" as a error in smithy is arguably not pertinent.

I have an open api given to me to implement :)

an old-fashioned http4s middleware.

okay thanks. Is there a nice way of converting a smithy generated shape into http4s's Response?

[kubukoz]

there is a way... but I'd call it pretty convoluted. Basically, smithy4s doesn't expose all the pieces directly in a public API so you have to copy-paste a bunch of stuff from internals:

//> using dep com.disneystreaming.smithy4s::smithy4s-http4s:0.18.15

import smithy4s.json.Json
import smithy4s.codecs.BlobEncoder
import smithy4s.http.HttpUnaryServerCodecs
import smithy4s.http.HttpResponse
import smithy4s.http.Metadata
import smithy4s.http4s.*
import cats.effect.Concurrent
import smithy4s.Blob
import org.http4s.Request
import smithy4s.http4s.kernel.*
import smithy4s.interopcats.*
import cats.syntax.all.*
import org.http4s.Response
import smithy4s.schema.Schema
import smithy4s.schema.OperationSchema
import smithy4s.ShapeId
import smithy4s.schema.ErrorSchema
import scala.reflect.ClassTag
import cats.effect.IO
import cats.effect.IOApp

object demo {
  // this part is mostly from SimpleRestJsonCodecs
  // with irrelevant parts removed

  val hintMask = alloy.SimpleRestJson.protocol.hintMask

  val jsonCodecs = Json
    .payloadCodecs
    .withJsoniterCodecCompiler(
      Json
        .jsoniter
        .withHintMask(hintMask)
        .withMaxArity(Int.MaxValue) // irrelevant for the encoding side
        .withExplicitDefaultsEncoding(false) // up to you
    )

  val payloadEncoders: BlobEncoder.Compiler = jsonCodecs.encoders

  val payloadDecoders = jsonCodecs.decoders

  val errorHeaders = List(
    smithy4s.http.errorTypeHeader,
    smithy4s.http.amazonErrorTypeHeader,
  )

  def makeServerCodecs[F[_]: Concurrent] = {
    val baseResponse = HttpResponse(200, Map.empty, Blob.empty)
    HttpUnaryServerCodecs
      .builder
      .withSuccessBodyEncoders(payloadEncoders)
      .withErrorBodyEncoders(payloadEncoders)
      .withErrorTypeHeaders(errorHeaders*)
      .withMetadataEncoders(Metadata.Encoder)
      .withBaseResponse(_ => baseResponse.pure[F])
      .withResponseMediaType("application/json")
      .withWriteEmptyStructs(!_.isUnit)
      .withResponseTransformation(fromSmithy4sHttpResponse[F](_).pure[F])
      .build()
  }

  //
  //
  //
  trait NotFoundWriter[F[_], A] {
    def write(notFound: A): F[Response[F]]
  }

  object NotFoundWriter {

    def instance[F[_]: Concurrent, A <: Throwable: ClassTag: Schema]: NotFoundWriter[F, A] = {
      // kinda hacky, because ErrorSchema doesn't have a public constructor
      object errorSchema extends ErrorSchema.Companion[A] {
        override def id: ShapeId = implicitly[Schema[A]].shapeId
        override def schema: Schema[A] = implicitly[Schema[A]]
        override def liftError(throwable: Throwable): Option[A] =
          throwable match {
            case a: A => Some(a)
            case _    => None
          }
        override def unliftError(e: A): Throwable = e
      }

      val codecs = makeServerCodecs[F].apply(
        Schema
          .operation(ShapeId("dummy", "DummyOp"))
          .withError(errorSchema.errorSchema)
      )

      nf => codecs.errorEncoder(nf)
    }

  }

}

// example, using NotFound from smithy4s-tests, but you'd be using your own


import smithy4s.example.NotFoundError

object DemoApp extends IOApp.Simple {

  def run: IO[Unit] = demo
    .NotFoundWriter
    .instance[IO, NotFoundError]
    .write(NotFoundError("foo"))
    .flatMap { response =>
      IO.println(response) *>
        response.bodyText.compile.string.flatMap(IO.println)
    }

}

personally, I wouldn't go for it.

[kubukoz]

I think this only really makes sense if you only have one Smithy service - otherwise, you'd need to guarantee that all the services involved declare the same 404-code error type. It is possible, but it's a pretty specific usecase, and generally the "not found because there's no known endpoint for this" problem isn't what Smithy tries to solve.