Merge pull request #362 from mickhansen/fix-input-list-arrays

allow input lists from query/AST to be mapped to an internal array type

Author: jberzy

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

@@ -65,18 +65,25 @@ let rec internal compileByType (errMsg: string) (inputDef: InputDef): ExecuteInp
                 | None -> null
             | _ -> null
     | List (Input innerdef) ->
+        let isArray = inputDef.Type.IsArray
         let inner = compileByType errMsg innerdef
         let cons, nil = ReflectionHelper.listOfType innerdef.Type
+
         fun value variables ->
             match value with
             | ListValue list ->
                 let mappedValues = list |> List.map (fun value -> inner value variables)
-                nil |> List.foldBack cons mappedValues
+                if isArray then
+                    ReflectionHelper.arrayOfList innerdef.Type mappedValues
+                else
+                    nil |> List.foldBack cons mappedValues
             | Variable variableName -> variables.[variableName]
             | _ ->
                 // try to construct a list from single element
                 let single = inner value variables
-                if single = null then null else cons single nil
+                if single = null then null else
+                    if isArray then ReflectionHelper.arrayOfList innerdef.Type [single]
+                    else cons single nil
     | Nullable (Input innerdef) ->
         let inner = compileByType errMsg innerdef
         let some, none, _ = ReflectionHelper.optionOfType innerdef.Type

src/FSharp.Data.GraphQL.Shared/Prolog.fs

@@ -118,6 +118,18 @@ module internal ReflectionHelper =
             fun item list -> cons.Invoke (null, [| item; list |])
         (cons, nil)
 
+    /// <summary>
+    /// used to create array from list of type <paramref name="t"/> given at runtime.
+    /// </summary>
+    /// <param name="t">runtime type for array type construction</param>
+    /// <param name="l">input list</param>
+    let arrayOfList (t: Type) (l : _ list) =
+        let array = System.Array.CreateInstance(t, l.Length)
+        l |> List.iteri (fun i v ->
+            array.SetValue(v, i)
+        )
+        array :> obj
+
     /// <summary>
     /// Returns pair of function constructors for `some(value)` and `none`
     /// used to create option of type <paramref name="t"/> given at runtime.

tests/FSharp.Data.GraphQL.Tests/VariablesTests.fs

@@ -24,15 +24,21 @@ type TestInput = {
     b: string option seq option
     c: string
     d: string option
+    e: string option array option
 }
+
+let InputArrayOf(innerDef : #TypeDef<'Val>) : ListOfDef<'Val, 'Val array> =
+  ListOf innerDef
+
 let TestInputObject =
   Define.InputObject<TestInput>(
     name = "TestInputObject",
     fields = [
         Define.Input("a", Nullable String)
-        Define.Input("b", Nullable(ListOf (Nullable String)))
+        Define.Input("b", Nullable( ListOf (Nullable String)) )
         Define.Input("c", String)
         Define.Input("d", Nullable TestComplexScalar)
+        Define.Input("e", Nullable( InputArrayOf (Nullable String)) )
     ])
 
 type TestNestedInput = {
@@ -85,9 +91,9 @@ let schema = Schema(TestType)
 
 [<Fact>]
 let ``Execute handles objects and nullability using inline structs with complex input`` () =
-    let ast = parse """{ fieldWithObjectInput(input: {a: "foo", b: ["bar"], c: "baz"}) }"""
+    let ast = parse """{ fieldWithObjectInput(input: {a: "foo", b: ["bar"], c: "baz", e: ["baf"]}) }"""
     let actual = sync <| Executor(schema).AsyncExecute(ast)
-    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null}""" ]
+    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null,"e":["baf"]}""" ]
     match actual with
     | Direct(data, errors) ->
       empty errors
@@ -98,7 +104,7 @@ let ``Execute handles objects and nullability using inline structs with complex
 let ``Execute handles objects and nullability using inline structs and properly parses single value to list`` () =
     let ast = parse """{ fieldWithObjectInput(input: {a: "foo", b: "bar", c: "baz"}) }"""
     let actual = sync <| Executor(schema).AsyncExecute(ast)
-    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null}""" ]
+    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null,"e":null}""" ]
     match actual with
     | Direct(data, errors) ->
       empty errors
@@ -120,7 +126,7 @@ let ``Execute handles objects and nullability using inline structs and doesn't u
 let ``Execute handles objects and nullability using inline structs and proprely coerces complex scalar types`` () =
     let ast = parse """{ fieldWithObjectInput(input: {c: "foo", d: "SerializedValue"}) }"""
     let actual = sync <| Executor(schema).AsyncExecute(ast)
-    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":null,"b":null,"c":"foo","d":"DeserializedValue"}"""]
+    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":null,"b":null,"c":"foo","d":"DeserializedValue","e":null}"""]
     match actual with
     | Direct(data, errors) ->
       empty errors
@@ -133,9 +139,9 @@ let ``Execute handles variables with complex inputs`` () =
           fieldWithObjectInput(input: $input)
         }"""
     let params' : Map<string, obj> =
-        Map.ofList ["input", upcast { a = Some "foo"; b = Some (upcast [ Some "bar"]) ; c = "baz"; d = None }]
+        Map.ofList ["input", upcast { a = Some "foo"; b = Some (upcast [| Some "bar"|]) ; c = "baz"; d = None; e = None }]
     let actual = sync <| Executor(schema).AsyncExecute(ast, variables = params')
-    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null}""" ]
+    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null,"e":null}""" ]
     match actual with
     | Direct(data, errors) ->
       empty errors
@@ -148,7 +154,7 @@ let ``Execute handles variables with default value when no value was provided``
             fieldWithObjectInput(input: $input)
           }"""
     let actual = sync <| Executor(schema).AsyncExecute(ast)
-    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null}""" ]
+    let expected = NameValueLookup.ofList [ "fieldWithObjectInput", upcast """{"a":"foo","b":["bar"],"c":"baz","d":null,"e":null}""" ]
     match actual with
     | Direct(data, errors) ->
       empty errors