Migrated ObjectListFilter to voption

Author: xperiandri

README.md

@@ -399,7 +399,7 @@ type ObjectListFilter =
     | FilterField of FieldFilter<ObjectListFilter>
 ```
 
-And the value recovered by the filter in the query is usable in the `ResolveFieldContext` of the resolve function of the field. To easily access it, you can use the extension method `Filter`, wich returns an `ObjectListFilter option` (it does not have a value if the object doesn't implement a list with the middleware generic definition, or if the user didn't provide a filter input).
+And the value recovered by the filter in the query is usable in the `ResolveFieldContext` of the resolve function of the field. To easily access it, you can use the extension method `Filter`, which returns an `ObjectListFilter voption` (it does not have a value if the object doesn't implement a list with the middleware generic definition, or if the user didn't provide a filter input).
 
 ```fsharp
 Define.Field("friends", ListOf (Nullable CharacterType),

samples/relay-book-store/Domain.fs

@@ -20,7 +20,7 @@ module BookCursor =
             Title = get.Required.Field "t" Decode.string
         })
 
-    let tryDecode (x : string) : BookCursor option = option {
+    let tryDecode (x : string) : BookCursor voption = voption {
         let! bytes = Base64.tryDecode x
         let! json = Utf8.tryDecode bytes
 

samples/relay-book-store/Prelude.fs

@@ -3,11 +3,6 @@ namespace FSharp.Data.GraphQL.Samples.RelayBookStore
 [<AutoOpen>]
 module internal Prelude =
 
-    let vopt =
-        function
-        | Some x -> ValueSome x
-        | None -> ValueNone
-
     [<RequireQualifiedAccess>]
     module Base64 =
 

samples/relay-book-store/Schema.fs

@@ -53,34 +53,34 @@ let booksField =
 
                 let after =
                     ctx.TryArg ("after")
-                    |> Option.map (fun s ->
+                    |> ValueOption.map (fun s ->
                         match BookCursor.tryDecode s with
-                        | Some c -> c
-                        | None -> raise (GQLMessageException ("Invalid cursor value for after")))
+                        | ValueSome c -> c
+                        | ValueNone -> raise (GQLMessageException ("Invalid cursor value for after")))
 
                 let last = ctx.TryArg ("last")
 
                 let before =
                     ctx.TryArg ("before")
-                    |> Option.map (fun s ->
+                    |> ValueOption.map (fun s ->
                         match BookCursor.tryDecode s with
-                        | Some c -> c
-                        | None -> raise (GQLMessageException ("Invalid cursor value for before")))
+                        | ValueSome c -> c
+                        | ValueNone -> raise (GQLMessageException ("Invalid cursor value for before")))
 
                 match first, after, last, before with
-                | Some first, _, None, None ->
+                | ValueSome first, _, ValueNone, ValueNone ->
                     if first < 0 then
                         raise (GQLMessageException ($"first must be at least 0"))
 
-                    Forward (first, vopt after)
-                | None, None, Some last, _ ->
+                    Forward (first, after)
+                | ValueNone, ValueNone, ValueSome last, _ ->
                     if last < 0 then
                         raise (GQLMessageException ($"last must be at least 0"))
 
-                    Backward (last, vopt before)
-                | None, _, None, _ -> raise (GQLMessageException ($"Must specify first or last"))
-                | Some _, _, _, _ -> raise (GQLMessageException ($"Must not combine first with last or before"))
-                | _, _, Some _, _ -> raise (GQLMessageException ($"Must not combine last with first or after"))
+                    Backward (last, before)
+                | ValueNone, _, ValueNone, _ -> raise (GQLMessageException ($"Must specify first or last"))
+                | ValueSome _, _, _, _ -> raise (GQLMessageException ($"Must not combine first with last or before"))
+                | _, _, ValueSome _, _ -> raise (GQLMessageException ($"Must not combine last with first or after"))
 
             // The total number of edges in the data-store, not the number of edges in the page!
             let totalCount = async {

src/FSharp.Data.GraphQL.Server.Middleware/MiddlewareDefinitions.fs

@@ -1,6 +1,9 @@
 namespace FSharp.Data.GraphQL.Server.Middleware
 
+open System.Collections.Generic
+open System.Collections.Immutable
 open FsToolkit.ErrorHandling
+
 open FSharp.Data.GraphQL
 open FSharp.Data.GraphQL.Types.Patterns
 open FSharp.Data.GraphQL.Types
@@ -14,8 +17,8 @@ type internal QueryWeightMiddleware(threshold : float, reportToMetadata : bool)
                 then 0.0
                 else
                     match f.Definition.Metadata.TryFind<float>("queryWeight") with
-                    | Some w -> w
-                    | None -> 0.0
+                    | ValueSome w -> w
+                    | ValueNone -> 0.0
             // let rec getFields = function
             //     | ResolveValue -> []
             //     | SelectFields fields -> fields
@@ -82,7 +85,7 @@ type internal ObjectListFilterMiddleware<'ObjectType, 'ListType>(reportToMetadat
         next ctx
 
     let reportMiddleware (ctx : ExecutionContext) (next : ExecutionContext -> AsyncVal<GQLExecutionResult>) =
-        let rec collectArgs (acc : (string * ObjectListFilter) list) (fields : ExecutionInfo list) =
+        let rec collectArgs (acc : KeyValuePair<string, ObjectListFilter> list) (fields : ExecutionInfo list) =
             let fieldArgs field =
                 let filterResults =
                     field.Ast.Arguments
@@ -96,7 +99,7 @@ type internal ObjectListFilterMiddleware<'ObjectType, 'ListType>(reportToMetadat
                 | Ok filters ->
                     filters
                     |> removeNoFilter
-                    |> Seq.map (fun x -> field.Ast.AliasOrName, x)
+                    |> Seq.map (fun x -> KeyValuePair (field.Ast.AliasOrName, x))
                     |> Seq.toList
                     |> Ok
             match fields with
@@ -119,7 +122,8 @@ type internal ObjectListFilterMiddleware<'ObjectType, 'ListType>(reportToMetadat
             match reportToMetadata with
             | true ->
                 let! args = collectArgs [] ctx.ExecutionPlan.Fields
-                return { ctx with Metadata = ctx.Metadata.Add("filters", args) }
+                let filters = ImmutableDictionary.CreateRange args
+                return { ctx with Metadata = ctx.Metadata.Add("filters", filters) }
             | false -> return ctx
         }
         match ctxResult with

src/FSharp.Data.GraphQL.Server.Middleware/TypeSystemExtensions.fs

@@ -1,5 +1,9 @@
 namespace FSharp.Data.GraphQL.Server.Middleware
 
+open System
+open System.Collections.Immutable
+open FsToolkit.ErrorHandling
+
 open FSharp.Data.GraphQL.Types
 
 /// Contains extensions for the type system.
@@ -16,13 +20,23 @@ module TypeSystemExtensions =
         /// <param name="weight">A float value representing the weight that this field have on the query.</param>
         member this.WithQueryWeight (weight : float) : FieldDef<'Val> = this.WithMetadata (this.Metadata.Add ("queryWeight", weight))
 
+    type ObjectListFilters = ImmutableDictionary<string, ObjectListFilter>
+
+    type ExecutionContext with
+
+        /// <summary>
+        /// Gets the filters applied to the lists.
+        /// </summary>
+        member this.Filters = this.Metadata.TryFind<ObjectListFilters> "filters"
+
     type ResolveFieldContext with
 
         /// <summary>
         /// Gets the filter argument value for this field, if it does have one.
         /// Field argument is defined by the ObjectFilterMiddleware.
         /// </summary>
         member this.Filter =
-            match this.Args.TryFind ("filter") with
-            | Some (:? ObjectListFilter as f) -> Some f
-            | _ -> None
+            match this.Args.TryGetValue "filter" with
+            | true, (:? ObjectListFilter as f) -> ValueSome f
+            | false, _ -> ValueNone
+            | true, _ -> raise (InvalidOperationException "Invalid filter argument type.")

src/FSharp.Data.GraphQL.Server.Relay/Connections.fs

@@ -85,22 +85,17 @@ module Cursor =
 [<AutoOpen>]
 module Definitions =
 
-    let private vopt =
-        function
-        | Some x -> ValueSome x
-        | None -> ValueNone
-
     /// Active pattern used to match context arguments in order
     /// to construct Relay slice information.
     [<return: Struct>]
     let (|SliceInfo|_|) (ctx : ResolveFieldContext) =
         match ctx.TryArg "first", ctx.TryArg "after" with
-        | Some (first), None -> ValueSome (Forward (first, ValueNone))
-        | Some (first), (after) -> ValueSome (Forward (first, vopt after))
-        | None, _ ->
+        | ValueSome (first), ValueNone -> ValueSome (Forward (first, ValueNone))
+        | ValueSome (first), (after) -> ValueSome (Forward (first, after))
+        | ValueNone, _ ->
             match ctx.TryArg "last", ctx.TryArg "before" with
-            | Some (last), None -> ValueSome (Backward (last, ValueNone))
-            | Some (last), (before) -> ValueSome (Backward (last, vopt before))
+            | ValueSome (last), ValueNone -> ValueSome (Backward (last, ValueNone))
+            | ValueSome (last), (before) -> ValueSome (Backward (last, before))
             | _, _ -> ValueNone
 
     /// Object defintion representing information about pagination in context of Relay connection

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

@@ -115,7 +115,7 @@ let rec private abstractionInfo (ctx : PlanningContext) (parentDef : AbstractDef
             | None -> Map.empty
         | None ->
             match ctx.Schema.TryFindType typeName with
-            | Some (Abstract abstractDef) ->
+            | ValueSome (Abstract abstractDef) ->
                 abstractionInfo ctx abstractDef field ValueNone includer
             | _ ->
                 let pname = parentDef :?> NamedDef
@@ -153,9 +153,9 @@ let private doesFragmentTypeApply (schema: ISchema) fragment (objectType: Object
     | ValueNone -> true
     | ValueSome typeCondition ->
         match schema.TryFindType typeCondition with
-        | None -> false
-        | Some conditionalType when conditionalType.Name = objectType.Name -> true
-        | Some (Abstract conditionalType) -> schema.IsPossibleType conditionalType objectType
+        | ValueNone -> false
+        | ValueSome conditionalType when conditionalType.Name = objectType.Name -> true
+        | ValueSome (Abstract conditionalType) -> schema.IsPossibleType conditionalType objectType
         | _ -> false
 
 let private isDeferredField (field: Field) =
@@ -342,16 +342,14 @@ let private planVariables (schema: ISchema) (operation: OperationDefinition) =
     |> List.map (fun vdef ->
         let vname = vdef.VariableName
         match Values.tryConvertAst schema vdef.Type with
-        | None ->
+        | ValueNone ->
             Debug.Fail "Must be prevented by validation"
             raise (MalformedGQLQueryException $"GraphQL query defined variable '$%s{vname}' of type '%s{vdef.Type.ToString()}' which is not known in the current schema")
-        | Some tdef ->
-            match tdef with
-            | :? InputDef as idef ->
-                { VarDef.Name = vname; TypeDef = idef; DefaultValue = vdef.DefaultValue }
-            | _ ->
-                Debug.Fail "Must be prevented by validation"
-                raise (MalformedGQLQueryException $"GraphQL query defined variable '$%s{vname}' of type '%s{tdef.ToString()}' which is not an input type definition"))
+        | ValueSome (:? InputDef as idef) ->
+            { VarDef.Name = vname; TypeDef = idef; DefaultValue = vdef.DefaultValue }
+        | ValueSome tdef ->
+            Debug.Fail "Must be prevented by validation"
+            raise (MalformedGQLQueryException $"GraphQL query defined variable '$%s{vname}' of type '%s{tdef.ToString()}' which is not an input type definition"))
 
 let internal planOperation (ctx: PlanningContext) : ExecutionPlan =
     // Create artificial plan info to start with

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

@@ -73,21 +73,19 @@ let private normalizeOptional (outputType : Type) value =
 
 /// Tries to convert type defined in AST into one of the type defs known in schema.
 let inline tryConvertAst schema ast =
-    let rec convert isNullable (schema : ISchema) (ast : InputType) : TypeDef option =
+    let rec convert isNullable (schema : ISchema) (ast : InputType) : TypeDef voption =
         match ast with
         | NamedType name ->
-            match schema.TryFindType name with
-            | Some namedDef ->
-                Some (
-                    if isNullable then
-                        upcast namedDef.MakeNullable ()
-                    else
-                        upcast namedDef
-                )
-            | None -> None
+            schema.TryFindType name
+            |> ValueOption.map (fun namedDef ->
+                if isNullable then
+                    upcast namedDef.MakeNullable ()
+                else
+                    upcast namedDef
+            )
         | ListType inner ->
             convert true schema inner
-            |> Option.map (fun i ->
+            |> ValueOption.map (fun i ->
                 if isNullable then
                     upcast i.MakeList().MakeNullable ()
                 else
@@ -121,7 +119,7 @@ let rec internal compileByType
                     (fun (allParameters : _ ResizeArray) param ->
                         match
                             objDef.Fields
-                            // TODO: Improve parameter name matching logic  
+                            // TODO: Improve parameter name matching logic
                             |> Array.tryFind (fun field -> String.Equals (field.Name, param.Name, StringComparison.InvariantCultureIgnoreCase))
                         with
                         | Some field ->

src/FSharp.Data.GraphQL.Shared/Helpers/ObjAndStructConversions.fs

@@ -1,5 +1,6 @@
 namespace rec FSharp.Data.GraphQL
 
+open System.Linq
 open FsToolkit.ErrorHandling
 
 module internal ValueOption =
@@ -24,10 +25,25 @@ module internal Seq =
         |> Seq.where ValueOption.isSome
         |> Seq.map ValueOption.get
 
+    let vtryFind predicate seq =
+        seq
+        |> Seq.where predicate
+        |> Seq.map ValueSome
+        |> _.FirstOrDefault()
+
 module internal List =
 
-    let vchoose mapping list = list |> Seq.vchoose mapping |> List.ofSeq
+    let vchoose mapping list = list |> Seq.ofList |> Seq.vchoose mapping |> List.ofSeq
+
+    let vtryFind predicate list = list |> Seq.ofList |> Seq.vtryFind predicate
 
 module internal Array =
 
     let vchoose mapping array = array |> Seq.vchoose mapping |> Array.ofSeq
+
+module internal Map =
+
+    let vtryFind key (map : Map<_, _>) =
+        match map.TryGetValue key with
+        | true, value -> ValueSome value
+        | false, _ -> ValueNone