Fixed comments and added tests

Author: ePasha

src/FSharp.Data.GraphQL.Server.AspNetCore/GraphQLRequestHandler.fs

@@ -15,30 +15,35 @@ open FsToolkit.ErrorHandling
 open FSharp.Data.GraphQL.Server
 open FSharp.Data.GraphQL.Shared
 
+/// <summary>
+/// Handles GraphQL requests using a provided root schema.
+/// </summary>
+/// <param name="httpContextAccessor">The accessor to the current HTTP context.</param>
+/// <param name="options">The options monitor for GraphQL options.</param>
+/// <param name="logger">The logger to log messages.</param>
 type DefaultGraphQLRequestHandler<'Root>
     (
-        // The accessor to the current HTTP context
         httpContextAccessor : IHttpContextAccessor,
-        // The options monitor for GraphQL options
         options : IOptionsMonitor<GraphQLOptions<'Root>>,
-        // The logger to log messages
         logger : ILogger<DefaultGraphQLRequestHandler<'Root>>
     ) =
     inherit GraphQLRequestHandler<'Root> (httpContextAccessor, options, logger)
 
-/// Provides logic to parse and execute GraphQL request
+/// <summary>
+/// Provides logic to parse and execute GraphQL requests.
+/// </summary>
+/// <param name="httpContextAccessor">The accessor to the current HTTP context.</param>
+/// <param name="options">The options monitor for GraphQL options.</param>
+/// <param name="logger">The logger to log messages.</param>
 and [<AbstractClass>] GraphQLRequestHandler<'Root>
     (
-        // The accessor to the current HTTP context
         httpContextAccessor : IHttpContextAccessor,
-        // The options monitor for GraphQL options
         options : IOptionsMonitor<GraphQLOptions<'Root>>,
-        // The logger to log messages
         logger : ILogger
     ) =
 
     let ctx = httpContextAccessor.HttpContext
-    let inputContext = fun () -> (HttpContextRequestExecutionContext ctx) :> IInputExecutionContext
+    let getInputContext = fun () -> (HttpContextRequestExecutionContext ctx) :> IInputExecutionContext
 
     let toResponse { DocumentId = documentId; Content = content; Metadata = metadata } =
 
@@ -143,8 +148,8 @@ and [<AbstractClass>] GraphQLRequestHandler<'Root>
     let executeIntrospectionQuery (executor : Executor<_>) (ast : Ast.Document voption) : Task<IResult> = task {
         let! result =
             match ast with
-            | ValueNone -> executor.AsyncExecute (IntrospectionQuery.Definition, inputContext)
-            | ValueSome ast -> executor.AsyncExecute (ast, inputContext)
+            | ValueNone -> executor.AsyncExecute (IntrospectionQuery.Definition, getInputContext)
+            | ValueSome ast -> executor.AsyncExecute (ast, getInputContext)
 
         let response = result |> toResponse
         return (TypedResults.Ok response) :> IResult
@@ -229,7 +234,7 @@ and [<AbstractClass>] GraphQLRequestHandler<'Root>
 
         let! result =
             Async.StartImmediateAsTask (
-                executor.AsyncExecute (content.Ast, inputContext, root, ?variables = variables, ?operationName = operationName),
+                executor.AsyncExecute (content.Ast, getInputContext, root, ?variables = variables, ?operationName = operationName),
                 cancellationToken = ctx.RequestAborted
             )
 

src/FSharp.Data.GraphQL.Server.AspNetCore/GraphQLWebsocketMiddleware.fs

@@ -10,7 +10,6 @@ open System.Text.Json
 open System.Text.Json.Serialization
 open System.Threading
 open System.Threading.Tasks
-open FSharp.Data.GraphQL.Shared
 open Microsoft.AspNetCore.Http
 open Microsoft.Extensions.Hosting
 open Microsoft.Extensions.Logging
@@ -169,24 +168,24 @@ type GraphQLWebSocketMiddleware<'Root>
 
         let sendMsg = sendMessageViaSocket serializerOptions socket
         let rcv () = socket |> rcvMsgViaSocket serializerOptions
-        let inputContext = fun () -> (HttpContextRequestExecutionContext httpContext) :> IInputExecutionContext
+        let getInputContext = fun () -> (HttpContextRequestExecutionContext httpContext) :> IInputExecutionContext
 
         let sendOutput id (output : SubscriptionExecutionResult) =
             sendMsg (Next (id, output))
 
         let sendSubscriptionResponseOutput id subscriptionResult =
             match subscriptionResult with
             | SubscriptionResult output -> { Data = ValueSome output; Errors = [] } |> sendOutput id
-            | SubscriptionErrors (_, errors) ->
+            | SubscriptionErrors (output, errors) ->
                 logger.LogWarning ("Subscription errors: {subscriptionErrors}", (String.Join ('\n', errors |> Seq.map (fun x -> $"- %s{x.Message}"))))
                 { Data = ValueNone; Errors = errors } |> sendOutput id
 
         let sendDeferredResponseOutput id deferredResult =
             match deferredResult with
-            | DeferredResult (obj, _) ->
+            | DeferredResult (obj, path) ->
                 let output = obj :?> Dictionary<string, obj>
                 { Data = ValueSome output; Errors = [] } |> sendOutput id
-            | DeferredErrors (_, errors, _) ->
+            | DeferredErrors (obj, errors, _) ->
                 logger.LogWarning (
                     "Deferred response errors: {deferredErrors}",
                     (String.Join ('\n', errors |> Seq.map (fun x -> $"- %s{x.Message}")))
@@ -276,11 +275,11 @@ type GraphQLWebSocketMiddleware<'Root>
                                     let variables = query.Variables |> Skippable.toOption
                                     let! planExecutionResult =
                                         let root = options.RootFactory httpContext
-                                        options.SchemaExecutor.AsyncExecute (query.Query, inputContext, root, ?variables = variables)
+                                        options.SchemaExecutor.AsyncExecute (query.Query, getInputContext, root, ?variables = variables)
                                     do! planExecutionResult |> applyPlanExecutionResult id socket
                             with ex ->
                                 logger.LogError (ex, "Unexpected error during subscription with id '{id}'", id)
-                                do! sendMsg (Error (id, [Shared.NameValueLookup([ ("subscription", "Unexpected error during subscription" :> obj) ])]))
+                                do! sendMsg (Error (id, [NameValueLookup([ ("subscription", "Unexpected error during subscription" :> obj) ])]))
                         | ClientComplete id ->
                             "ClientComplete" |> logMsgWithIdReceived id
                             subscriptions

src/FSharp.Data.GraphQL.Server.AspNetCore/Helpers.fs

@@ -3,10 +3,8 @@ namespace FSharp.Data.GraphQL.Server.AspNetCore
 open System
 open System.Text
 open FSharp.Data.GraphQL
-open FSharp.Data.GraphQL.Shared
 open Microsoft.AspNetCore.Http
 
-
 [<AutoOpen>]
 module Helpers =
 
@@ -59,10 +57,7 @@ type HttpContextRequestExecutionContext (httpContext : HttpContext) =
                 Error "Request does not have form content type"
             else
                 let form = httpContext.Request.Form
-                let maybeFile =
-                    form.Files
-                    |> Seq.tryFind (fun f -> f.Name = key)
 
-                match maybeFile with
-                | Some file -> Ok (file.OpenReadStream())
-                | None -> Error $"File with key '{key}' not found"
+                match (form.Files |> Seq.vtryFind (fun f -> f.Name = key)) with
+                | ValueSome file -> Ok (file.OpenReadStream())
+                | ValueNone -> Error $"File with key '{key}' not found"

src/FSharp.Data.GraphQL.Server.AspNetCore/HttpContext.fs

@@ -6,7 +6,6 @@ open System.Collections.Immutable
 open System.IO
 open System.Runtime.CompilerServices
 open System.Text.Json
-open FSharp.Data.GraphQL
 open Microsoft.AspNetCore.Http
 open Microsoft.Extensions.DependencyInjection
 open Microsoft.Extensions.Options
@@ -22,7 +21,7 @@ type HttpContext with
     /// </summary>
     /// <typeparam name="'T">Type to deserialize to</typeparam>
     /// <returns>
-    /// Retruns a <see cref="System.Threading.Tasks.Task{T}"/>Deserialized object or
+    /// Returns a <see cref="System.Threading.Tasks.Task{T}"/>Deserialized object or
     /// <see cref="ProblemDetails">ProblemDetails</see> as <see cref="IResult">IResult</see>
     /// if a body could not be deserialized.
     /// </returns>
@@ -32,10 +31,23 @@ type HttpContext with
         let request = ctx.Request
 
         try
-            if not request.Body.CanSeek then
-                request.EnableBuffering()
+            let! jsonStream =
+                task {
+                    if request.HasFormContentType then
+                        let! form = request.ReadFormAsync(ctx.RequestAborted)
+                        match form.TryGetValue("operations") with
+                        | true, values when values.Count > 0 ->
+                            let bytes = System.Text.Encoding.UTF8.GetBytes(values[0])
+                            return new MemoryStream(bytes) :> Stream
+                        | _ ->
+                            return request.Body
+                    else
+                        if not request.Body.CanSeek then
+                            request.EnableBuffering()
+                        return request.Body
+                }
 
-            return! JsonSerializer.DeserializeAsync<'T>(request.Body, serializerOptions, ctx.RequestAborted)
+            return! JsonSerializer.DeserializeAsync<'T>(jsonStream, serializerOptions, ctx.RequestAborted)
         with :? JsonException ->
             let body = request.Body
             body.Seek(0, SeekOrigin.Begin) |> ignore

src/FSharp.Data.GraphQL.Server/Execution.fs

@@ -445,11 +445,11 @@ let private (|String|Other|) (o : obj) =
     | :? string as s -> String s
     | _ -> Other
 
-let private executeQueryOrMutation (resultSet: (string * ExecutionInfo) []) (ctx: ExecutionContext) (objDef: ObjectDef) (inputContext : InputExecutionContextProvider) (rootValue : obj) : AsyncVal<GQLExecutionResult> =
+let private executeQueryOrMutation (resultSet: (string * ExecutionInfo) []) (ctx: ExecutionContext) (objDef: ObjectDef) (rootValue : obj) : AsyncVal<GQLExecutionResult> =
     let executeRootOperation (name, info) =
         let fDef = info.Definition
         let argDefs = ctx.FieldExecuteMap.GetArgs(ctx.ExecutionPlan.RootDef.Name, info.Definition.Name)
-        match getArgumentValues argDefs info.Ast.Arguments inputContext ctx.Variables with
+        match getArgumentValues argDefs info.Ast.Arguments ctx.GetInputContext ctx.Variables with
         | Error errs -> asyncVal { return Error (errs |> List.map GQLProblemDetails.OfError) }
         | Ok args ->
             let path = [ box info.Identifier ]
@@ -465,7 +465,7 @@ let private executeQueryOrMutation (resultSet: (string * ExecutionInfo) []) (ctx
             let execute = ctx.FieldExecuteMap.GetExecute(ctx.ExecutionPlan.RootDef.Name, info.Definition.Name)
             asyncVal {
                 let! result =
-                    executeResolvers inputContext fieldCtx path rootValue (resolveField execute fieldCtx rootValue)
+                    executeResolvers ctx.GetInputContext fieldCtx path rootValue (resolveField execute fieldCtx rootValue)
                     |> AsyncVal.rescue path ctx.Schema.ParseError
                 let result =
                     match result with
@@ -545,7 +545,7 @@ let private compileObject (objDef: ObjectDef) (executeFields: FieldDef -> unit)
         )
     )
 
-let internal compileSchema (inputContext : InputExecutionContextProvider) (ctx : SchemaCompileContext)  =
+let internal compileSchema (ctx : SchemaCompileContext)  =
     ctx.Schema.TypeMap.ToSeq()
     |> Seq.iter (fun (tName, x) ->
         match x with
@@ -555,10 +555,10 @@ let internal compileSchema (inputContext : InputExecutionContextProvider) (ctx :
                     match sub with
                     | :? SubscriptionFieldDef as subField -> compileSubscriptionField subField
                     | _ -> failwith $"Schema error: subscription object '%s{subDef.Name}' does have a field '%s{sub.Name}' that is not a subscription field definition."
-                ctx.Schema.SubscriptionProvider.Register { Name = sub.Name; Filter = filter }) inputContext
+                ctx.Schema.SubscriptionProvider.Register { Name = sub.Name; Filter = filter }) ctx.GetInputContext
         | Object objDef ->
-            compileObject objDef (fun fieldDef -> ctx.FieldExecuteMap.SetExecute(tName, fieldDef)) inputContext
-        | InputObject inputDef -> compileInputObject inputDef inputContext
+            compileObject objDef (fun fieldDef -> ctx.FieldExecuteMap.SetExecute(tName, fieldDef)) ctx.GetInputContext
+        | InputObject inputDef -> compileInputObject inputDef ctx.GetInputContext
         | _ -> ())
 
 let internal coerceVariables (variables: VarDef list) (inputContext : InputExecutionContextProvider) (vars: ImmutableDictionary<string, JsonElement>) = result {
@@ -650,7 +650,7 @@ let internal coerceVariables (variables: VarDef list) (inputContext : InputExecu
 
 #nowarn "0046"
 
-let internal executeOperation (inputContext : InputExecutionContextProvider) (ctx : ExecutionContext) : AsyncVal<GQLExecutionResult> =
+let internal executeOperation (ctx : ExecutionContext) : AsyncVal<GQLExecutionResult> =
     let includeResults =
         ctx.ExecutionPlan.Fields
         |> List.map (
@@ -669,15 +669,15 @@ let internal executeOperation (inputContext : InputExecutionContextProvider) (ct
         |> Seq.map (fun info -> (info.Identifier, info))
         |> Seq.toArray
     match ctx.ExecutionPlan.Operation.OperationType with
-    | Query -> executeQueryOrMutation resultSet ctx ctx.Schema.Query inputContext ctx.RootValue
+    | Query -> executeQueryOrMutation resultSet ctx ctx.Schema.Query ctx.RootValue
     | Mutation ->
         match ctx.Schema.Mutation with
-        | Some m -> executeQueryOrMutation resultSet ctx m inputContext ctx.RootValue
+        | Some m -> executeQueryOrMutation resultSet ctx m ctx.RootValue
         | None -> raise(InvalidOperationException("Attempted to make a mutation but no mutation schema was present!"))
     | Subscription ->
         match ctx.Schema.Subscription with
         | Some s ->
-            match executeSubscription resultSet inputContext ctx s ctx.RootValue with
+            match executeSubscription resultSet ctx.GetInputContext ctx s ctx.RootValue with
             | Ok data -> AsyncVal.wrap(GQLExecutionResult.Stream(ctx.ExecutionPlan.DocumentId, data, ctx.Metadata))
             | Error errs -> asyncVal { return GQLExecutionResult.Error(ctx.ExecutionPlan.DocumentId, errs, ctx.Metadata) }