Allow accepting untyped inputs

Author: pkese

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

@@ -93,6 +93,8 @@ let inline tryConvertAst schema ast =
 
     convert true schema ast
 
+let compileByTypeCache = Collections.Concurrent.ConcurrentDictionary<InputDef, ExecuteInput>()
+
 let rec internal compileByType
     (inputObjectPath : FieldPath)
     (inputSource : InputSource)
@@ -103,6 +105,120 @@ let rec internal compileByType
 
     | Scalar scalarDef -> variableOrElse (InlineConstant >> scalarDef.CoerceInput)
     | InputCustom customDef -> fun inputContext value variables -> customDef.CoerceInput inputContext (InlineConstant value) variables
+
+    //| Nullable (InputObject objDef)
+    //| InputObject objDef when typeof<IDictionary<string,obj>>.IsAssignableFrom(objDef.Type) ->
+    | InputObject objDef when typeof<Dynamic.ExpandoObject>.IsAssignableFrom(objDef.Type) ->
+
+        let executeInputFn = compileByTypeCache.GetOrAdd(objDef, Func<_,_>(fun _ ->
+            let nestedFields =
+                seq {
+                    for fld in objDef.Fields do
+                        match fld.TypeDef with
+                        | InputObject innerObjDef
+                        | Nullable (InputObject innerObjDef)
+                        | List (InputObject innerObjDef) ->
+                            // If the field contains a nested input object with a proper InputObject type definition
+                            // then we'll use the built in `executeInput` functionality to populate it.
+                            // **Caveat**: some of these objects may be recursively defined, so we need to delay the invocation of compileByType,
+                            // otherwise we get stack overflow at GraphQL schema compilation time.
+                            let delayedExecuteInputStub getInputContext value variables =
+                                let innerExecuteInput =
+                                    compileByTypeCache.GetOrAdd(fld.TypeDef, Func<_,_>(fun _ ->
+                                        compileByType (box fld.Name :: inputObjectPath) inputSource (fld.TypeDef, fld.TypeDef) getInputContext
+                                    ))
+                                innerObjDef.ExecuteInput <- innerExecuteInput // replace ExecuteInput with true function on first call
+                                innerExecuteInput getInputContext value variables // call it
+                            innerObjDef.ExecuteInput <- delayedExecuteInputStub
+                            yield KeyValuePair(fld.Name, fld)
+                        | _ -> ()
+                }
+                |> Collections.Frozen.FrozenDictionary.ToFrozenDictionary
+
+            // Helper for populating fields from untyped input values
+            let rec getRawInputValue (variables:Variables) (value:InputValue)  =
+                match value with
+                | NullValue -> ValueNone
+                | StringValue s -> ValueSome (box s)
+                | IntValue i -> ValueSome (box i)
+                | FloatValue f -> ValueSome (box f)
+                | BooleanValue b -> ValueSome (box b)
+                | EnumValue e -> ValueSome (box e)
+                | ListValue lst -> ValueSome (box (lst |> Seq.map (fun el ->
+                    match getRawInputValue variables el with
+                    | ValueNone -> null
+                    | ValueSome v -> v
+                )))
+                | ObjectValue o ->
+                    let dict = Dictionary<string, obj>()
+                    for KeyValue (key, prop) in o do
+                        match getRawInputValue variables prop with
+                        | ValueNone -> ()
+                        | ValueSome v -> dict[key] <- v
+                    ValueSome (box dict)
+                | VariableName varName -> ValueSome (variables[varName])
+
+            // Populate dictionary from parsed ObjectValue (Map<string, InputValue>)
+            let populateFromTypedInputObj (props: Map<string, InputValue>) (variables:Variables) = result {
+                let o = Activator.CreateInstance(objDef.Type)
+                let dict = o :?> IDictionary<string, obj>
+                for KeyValue (key, prop) in props do
+                    match nestedFields.TryGetValue key with
+                    | true, fieldDef ->
+                        let! coerced = fieldDef.ExecuteInput getInputContext prop variables
+                        dict[key] <- normalizeOptional fieldDef.TypeDef.Type coerced
+                    | false, _ ->
+                        match prop |> getRawInputValue variables with
+                        | ValueNone -> ()
+                        | ValueSome v -> dict[key] <- v
+                return o
+            }
+
+            // Populate dictionary from variable value (untyped object)
+            let populateFromUntypedInputObj (props: IReadOnlyDictionary<string, obj>) (variables:Variables) = result {
+                let o = Activator.CreateInstance(objDef.Type)
+                let dict = o :?> IDictionary<string, obj>
+                for KeyValue (key, value) in props do
+                    match nestedFields.TryGetValue key with
+                    | true, fieldDef ->
+                        let inputValue = InputValue.OfObject value
+                        let! coerced =
+                            fieldDef.ExecuteInput getInputContext inputValue variables
+                        dict[key] <- normalizeOptional fieldDef.TypeDef.Type coerced
+                    | false, _ -> dict[key] <- value
+                return o
+            }
+
+            // return function: executeInput
+            fun ctxGetter value variables ->
+                match value with
+                | ObjectValue props -> populateFromTypedInputObj props variables
+                | VariableName variableName ->
+                    match variables.TryGetValue variableName with
+                    | true, found ->
+                        match found with
+                        | :? IReadOnlyDictionary<string, obj> as objectFields ->
+                            populateFromUntypedInputObj objectFields variables
+                        | null -> Ok null
+                        | _ ->
+                            Debugger.Break ()
+                            Error [
+                                { new IGQLError with
+                                    member _.Message = $"A variable '${variableName}' is not an object"
+                                }
+                            ]
+                    | false, _ -> Ok null
+                | NullValue -> populateFromTypedInputObj Map.empty variables
+                | IntValue _ | FloatValue _ | BooleanValue _ | StringValue _ | EnumValue _ | ListValue _ ->
+                    Error [
+                        { new IGQLError with
+                            member _.Message = $"Input object expected, but got scalar value"
+                        }
+                    ]
+        ))
+        objDef.ExecuteInput <- executeInputFn
+        executeInputFn
+
     | InputObject objDef ->
         let objType = objDef.Type
         let ctor = ReflectionHelper.matchConstructor objType (objDef.Fields |> Array.map _.Name)