Remove [<AllowNullLiteral>] attribute from Json.ISerializer and Xml.ISerializer (#685)

* Remove [<AllowNullLiteral>] attribute from Json.ISerializer

* Remove [<AllowNullLiteral>] attribute from Xml.ISerializer

* Tests: add more Json and Xml tests

* Add json route to the EndpointRoutingApp sample project, and update it to .NET 9

* Update the NewtonsoftJson sample to .NET 9, enable the checknulls verification and fix the code to deal with it

Author: 64J0

samples/EndpointRoutingApp/EndpointRoutingApp.fsproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

samples/EndpointRoutingApp/Program.fs

@@ -8,6 +8,13 @@ open Microsoft.Extensions.Hosting
 open Giraffe
 open Giraffe.EndpointRouting
 
+type Car =
+    {
+        Brand: string
+        Color: string
+        ReleaseYear: int
+    }
+
 let handler1: HttpHandler =
     fun (_: HttpFunc) (ctx: HttpContext) -> ctx.WriteTextAsync "Hello World"
 
@@ -21,6 +28,23 @@ let handler3 (a: string, b: string, c: string, d: int) : HttpHandler =
 let handlerNamed (petId: int) : HttpHandler =
     fun (_: HttpFunc) (ctx: HttpContext) -> sprintf "PetId: %i" petId |> ctx.WriteTextAsync
 
+/// Example request:
+///
+/// ```bash
+/// curl -v localhost:5000/json -X Post -d '{"brand":"Ford", "color":"Black", "releaseYear":2015}'
+/// ```
+let jsonHandler: HttpHandler =
+    fun (next: HttpFunc) (ctx: HttpContext) ->
+        task {
+            match! ctx.BindJsonAsync<Car>() with
+            | {
+                  Brand = _brand
+                  Color = _color
+                  ReleaseYear = releaseYear
+              } when releaseYear >= 1990 -> return! json {| Message = "Valid car" |} next ctx
+            | _ -> return! (setStatusCode 400 >=> json {| Message = "Invalid car year" |}) next ctx
+        }
+
 let endpoints =
     [
         subRoute "/foo" [ GET [ route "/bar" (text "Aloha!") ] ]
@@ -38,6 +62,7 @@ let endpoints =
         ]
         // Not specifying a http verb means it will listen to all verbs
         subRoute "/sub" [ route "/test" handler1 ]
+        POST [ route "/json" jsonHandler ]
     ]
 
 let notFoundHandler = "Not Found" |> text |> RequestErrors.notFound

samples/NewtonsoftJson/NewtonsoftJson.fsproj

@@ -2,7 +2,8 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>

samples/NewtonsoftJson/Program.fs

@@ -40,21 +40,30 @@ module NewtonsoftJson =
                 }
                 :> Task
 
-            member __.Deserialize<'T>(json: string) =
-                JsonConvert.DeserializeObject<'T>(json, settings)
+            member __.Deserialize<'T>(json: string) : 'T =
+                match JsonConvert.DeserializeObject<'T>(json, settings) with
+                | null -> failwith "Deserialized object is null"
+                | (notNull: 'T) -> notNull
 
-            member __.Deserialize<'T>(bytes: byte array) =
+            member __.Deserialize<'T>(bytes: byte array) : 'T =
                 let json = Encoding.UTF8.GetString bytes
-                JsonConvert.DeserializeObject<'T>(json, settings)
 
-            member __.DeserializeAsync<'T>(stream: Stream) =
+                match JsonConvert.DeserializeObject<'T>(json, settings) with
+                | null -> failwith "Deserialized object is null"
+                | (notNull: 'T) -> notNull
+
+            member __.DeserializeAsync<'T>(stream: Stream) : Task<'T> =
                 task {
                     use memoryStream = rmsManager.GetStream("giraffe-json-deserialize")
                     do! stream.CopyToAsync(memoryStream)
                     memoryStream.Seek(0L, SeekOrigin.Begin) |> ignore
                     use streamReader = new StreamReader(memoryStream)
                     use jsonTextReader = new JsonTextReader(streamReader)
-                    return serializer.Deserialize<'T>(jsonTextReader)
+
+                    return
+                        match serializer.Deserialize<'T>(jsonTextReader) with
+                        | null -> failwith "Deserialized object is null"
+                        | (notNull: 'T) -> notNull
                 }
 
 type JsonResponse = { Foo: string; Bar: string; Age: int }
@@ -67,23 +76,22 @@ let notFoundHandler = "Not Found" |> text |> RequestErrors.notFound
 let configureServices (services: IServiceCollection) =
     services
         .AddSingleton<Json.ISerializer>(fun serviceProvider ->
-            NewtonsoftJson.Serializer(
-                JsonSerializerSettings(),
+            let rmsManager =
                 serviceProvider.GetService<Microsoft.IO.RecyclableMemoryStreamManager>()
-            )
-            :> Json.ISerializer
+                |> function
+                    | null -> Microsoft.IO.RecyclableMemoryStreamManager()
+                    | notNull -> notNull
+
+            NewtonsoftJson.Serializer(JsonSerializerSettings(), rmsManager) :> Json.ISerializer
         )
         .AddRouting()
         .AddResponseCaching()
         .AddGiraffe()
     |> ignore
 
 let configureApp (appBuilder: IApplicationBuilder) =
-    appBuilder
-        .UseRouting()
-        .UseResponseCaching()
-        .UseEndpoints(fun e -> e.MapGiraffeEndpoints(endpoints))
-        .UseGiraffe(notFoundHandler)
+    appBuilder.UseRouting().UseResponseCaching().UseEndpoints(_.MapGiraffeEndpoints(endpoints)).UseGiraffe
+        notFoundHandler
 
 [<EntryPoint>]
 let main (args: string array) : int =

src/Giraffe/Json.fs

@@ -12,7 +12,6 @@ module Json =
     /// Interface defining JSON serialization methods.
     /// Use this interface to customize JSON serialization in Giraffe.
     /// </summary>
-    [<AllowNullLiteral>]
     type ISerializer =
         abstract member SerializeToString<'T> : 'T -> string
         abstract member SerializeToBytes<'T> : 'T -> byte array

src/Giraffe/Xml.fs

@@ -6,7 +6,6 @@ module Xml =
     /// Interface defining XML serialization methods.
     /// Use this interface to customize XML serialization in Giraffe.
     /// </summary>
-    [<AllowNullLiteral>]
     type ISerializer =
         abstract member Serialize: obj -> byte array
         abstract member Deserialize<'T> : string -> 'T

tests/Giraffe.Tests/Giraffe.Tests.fsproj

@@ -20,6 +20,8 @@
     <Compile Include="HttpContextExtensionsTests.fs" />
     <Compile Include="StreamingTests.fs" />
     <Compile Include="PreconditionalTests.fs" />
+    <Compile Include="JsonTests.fs" />
+    <Compile Include="XmlTests.fs" />
   </ItemGroup>
 
   <ItemGroup>