NullReferenceException when using routeBind with Sum Type

[mamcx]

This is a weird one:

type Sorted =
        | Name
        | Code

type QueryCustomer = {sort:Customers.Sorted}

        routeBind<QueryCustomer> "/customers/{sortBy}" ( fun sortBy ->
            LOG.Information("PATH: /customers/{Sort}", sortBy.sort)
            let str = 
                match sortBy.sort with
                | Customers.Name -> "n"
                | Customers.Code -> "n"

When a wrong path is called (like /customers/bla) it get converted to this:

{{sort = null;}}

Instead of give a 404 as expected. Is very unexpected that Giraffe somehow broke the union type here.

Giraffe Version="0.1.0-beta-700"

[JonCanning]

routeBind creates a dictionary and uses JObject to convert that into a type

Giraffe/src/Giraffe/HttpHandlers.fs

Line 246 in 57d2b6f

let routeBind<'T> (route: string) (routeHandler : 'T -> HttpHandler) : HttpHandler =

For this to work with a union, you're going to have to create a JsonConverter so it knows how to convert the string. It's a bit hairy.

[<JsonConverter(typeof<SortedConverter>)>]
type Sorted =
| Name
| Code
  static member convert value =
    match value.ToString().ToLower() with
    | "name" -> Name
    | "code" -> Code
    | value -> invalidArg "value" value
and 
  SortedConverter() =
    inherit JsonConverter()
      override __.CanConvert t = t = typeof<Sorted>
      override __.WriteJson(_, _, _) = invalidOp "WriteJson"
      override __.ReadJson(reader, _, _, _) =
        reader.Value
        |> Sorted.convert
        |> box

I imagine something smarter could be achieved using reflection...

[mamcx]

This is no the expected behavior from a native F# library. I understand why is like that, so maybe is better to clarify to have a CLI_MUTABLE struct? Or get a map instead?

[dustinmoris]

Hi @mamcx, yes we should document this until we find time to add union support. I think it would be worth to have a look if there is already an F# library which extends Json.NET for better F# type support otherwise we could write our own converters using reflection as @JonCanning suggested.

[mamcx]

I'm using https://github.com/Microsoft/fsharplu/wiki/fsharplu.json and it serialize right the F# types. 2018-01-13 17:46 GMT-05:00 Dustin Moris Gorski <notifications@github.com>:

…

Hi @mamcx <https://github.com/mamcx>, yes we should document this until we find time to add union support. I think it would be worth to have a look if there is already an F# library which extends Json.NET for better F# type support otherwise we could write our own converters using reflection as @JonCanning <https://github.com/joncanning> suggested. — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub <#206 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAOlh0nvgve3Gbsml5lcJBViez7FJH7mks5tKTJQgaJpZM4RdQ6X> .

-- Mario A.Montoya Gerente http://www.elmalabarista.com Haz pedidos & facturas con tu iPhone: http://www.elmalabarista.co <http://www.elmalabarista.com/>*m/bestseller*

[dustinmoris]

Hi @mamcx,

In your example the route /customers/bla technically matches the pattern /customers/{sortBy}, but bla is an invalid value for Sorted.

I think there are a few ways how this could be handled:

• If bla fails to parse to Sorted then throw exception
• if bla fails to parse to Sorted then abort route (which will eventually end up at the 404 if no other handler picks up the request)
• If bla fails to parse to Sorted then set the value to null

Probably the first or second option make the most sense. Sounds like you prefer the second, is that correct?

Also regarding FSharpLu, did you get routeBind working with that library or did you refer to FSharpLu as a resource to look up how they parse union types?

[mamcx]

I expect the second to hold. The reason is that is exactly why I using the union type and not just a string, ie, why "int" work, but "Int Or String" not?

In python, I could use a regex to parse the posibilities.

[dustinmoris]

Ok, makes sense...

Could you please explain what you meant by

I'm using https://github.com/Microsoft/fsharplu/wiki/fsharplu.json and it
serialize right the F# types.

How did you use FSharpLu with the previous version of Giraffe?

[mamcx]

This is how I do this:

open Microsoft.FSharpLu
let toJson (value:'T) =
    Json.Compact.serialize value

let contentJson (value:'T): HttpHandler =
    let json = value |> toJson
    setHttpHeader "Content-Type" "application/json; charset=utf-8"
    >=> setBodyAsString json

let getCustomer(sort) =
    use db = openConn()
    ServerApi.getCustomer(db, sort)
    |> contentJson

I just replace the json calls with my own things, without inject into Giraffe (I don't like much magic ;), also waiting for the support to streaming large data to see how it could be...)

[mamcx]

I think the problem is more universal. For example:

[<CLIMutable>]
type LoginViewModel =
    {
        Email : string
        Password : string
    }

let handlePostToken =
    fun (next : HttpFunc) (ctx : HttpContext) ->
        task {
            let! model = ctx.BindJsonAsync<LoginViewModel>()

            // authenticate user
            
            let tokenResult = generateToken model.Email

            return! json tokenResult next ctx
        }

In BindJsonAsync it get a System.NullReferenceException (when try to post with empty data (like POST /auth). The thing is binding is parsing and that could fail. I'm ok with wrap into a try/except but then at least provide a custom exception so is clear the problem is parsing and not something else. Or make it a Option instead.

[dustinmoris]

Hi, this should be fixed in today's 1.1.0 release. Please let me know if you encounter any more issues!