formField fails if custom unmarshaller is in scope

[marekzebrowski]

formField directive fails if there is too generic unmarshaller in scope, that prevents FieldMagnet machinery to work.
It can happen quite a lot - for example when using akka-http-json4s or other generic unmarshaller.

Reproducer https://github.com/marekzebrowski/akka-http-form-field-bug

If it is not solvable, maybe a word of warning in documentation, or a guide how to write own unmarshaller would be helpful

[ktoso]

Yeah sounds like a docs thing, thanks for reporting.
Up for grabs if someone has the time! :)

[marekzebrowski]

I wonder if it is a bug. Defined marshaller should work only for application/json content-type. Request in test-case is application/x-www-form-urlencoded. If it is not a bug, it is at least confusing

[silvaren]

Not sure sure if this is the same issue, but it looks very similar. When using circe + akka-http-json support for JSON (which I believe provides generic unmarshallers to the scope) as in:

  private def route(implicit mat: Materializer) = {
    import Directives._
    import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport._
    import io.circe.generic.auto._

    pathSingleSlash {
      post {
        entity(as[Foo]) { foo =>
          complete {
            foo
          }
        }
      }
    } ~
      path("formurlencoded") {
        post {
          formFields('coolKey) { coolKey =>
            complete(s"The cool value is '${coolKey}'")
          }
        }
      }
  }

If I run and test the second route:
curl -d "coolKey=coolValue" -X POST http://localhost:8000/formurlencoded

I get the following error:
The request's Content-Type is not supported. Expected: application/json or multipart/form-data

But if I remove the JSON support it works correctly. Full issue on akka-http-json, but it might be actually an Akka HTTP issue.

[jrudolph]

Yes, it's an anti-pattern to bring generic implicits into scope that are able to marshal/unmarshal everything. When you think about it, it is somewhat obvious that this cannot work. So, the recommendation is to never provide something like

def unmarshaller[T]: FromEntityUnmarshaller[T]

where T is basically unconstrained.

[jrudolph]

I think we can still improve the situation for formField directives. Right now the FieldMagnet machinery expects implicit FromEntityUnmarshaller[StrictForm] everywhere. Keeping it implicit allows you to override what kind of content the formField directive is able to interpret as a form field and how to parse it. In reality no one will actually override it because the formField directive is thought to be used with multipart/formdata and application/x-www-form-urlencoded payloads. I think we should deprecate the existing implicits and move them into a superclass and provide implicits that don't require that particular implicit (but use a concrete unmarshaller instead).

[koertkuipers]

Yes, it's an anti-pattern to bring generic implicits into scope that are able to marshal/unmarshal everything. When you think about it, it is somewhat obvious that this cannot work. So, the recommendation is to never provide something like

def unmarshaller[T]: FromEntityUnmarshaller[T]

where T is basically unconstrained.

is is not clear to me how we can add an unmarshaller for type T then? to add support for another content type without disabling existing content types?
if we want to support multiple unmarshallers for a type T, which to me is a reasonable thing to want to do, is the problem that this cannot be captured in the current design using a typeclass for T?

[jrudolph]

The original ticket was about a generic unmarshaller. You cannot bring an unmarshaller into scope that claims to unmarshal everything, this will conflict with other unmarshallers.

And yes, to some degree the typeclass pattern cannot solve the case where you have several different unmarshallers in scope for a single concrete type. The implicit / typeclass pattern must use static information to figure out a single instance.

That said, if you want to support multiple content types for a single concrete target type, you can create a composite Unmarshaller that supports all those content types using Unmarshaller.firstOf and make only that one implicit (or bring only that one into scope). Is that what you are after?