GraphQL\Utils\AST::astFromValue PHP Method

    static function astFromValue($value, InputType $type)
    {
        if ($type instanceof NonNull) {
            $astValue = self::astFromValue($value, $type->getWrappedType());
            if ($astValue instanceof NullValueNode) {
                return null;
            }
            return $astValue;
        }
        if ($value === null) {
            return new NullValueNode([]);
        }
        // Convert PHP array to GraphQL list. If the GraphQLType is a list, but
        // the value is not an array, convert the value using the list's item type.
        if ($type instanceof ListOfType) {
            $itemType = $type->getWrappedType();
            if (is_array($value) || $value instanceof \Traversable) {
                $valuesNodes = [];
                foreach ($value as $item) {
                    $itemNode = self::astFromValue($item, $itemType);
                    if ($itemNode) {
                        $valuesNodes[] = $itemNode;
                    }
                }
                return new ListValueNode(['values' => $valuesNodes]);
            }
            return self::astFromValue($value, $itemType);
        }
        // Populate the fields of the input object by creating ASTs from each value
        // in the PHP object according to the fields in the input type.
        if ($type instanceof InputObjectType) {
            $isArray = is_array($value);
            $isArrayLike = $isArray || $value instanceof \ArrayAccess;
            if ($value === null || !$isArrayLike && !is_object($value)) {
                return null;
            }
            $fields = $type->getFields();
            $fieldNodes = [];
            foreach ($fields as $fieldName => $field) {
                if ($isArrayLike) {
                    $fieldValue = isset($value[$fieldName]) ? $value[$fieldName] : null;
                } else {
                    $fieldValue = isset($value->{$fieldName}) ? $value->{$fieldName} : null;
                }
                // Have to check additionally if key exists, since we differentiate between
                // "no key" and "value is null":
                if (null !== $fieldValue) {
                    $fieldExists = true;
                } else {
                    if ($isArray) {
                        $fieldExists = array_key_exists($fieldName, $value);
                    } else {
                        if ($isArrayLike) {
                            /** @var \ArrayAccess $value */
                            $fieldExists = $value->offsetExists($fieldName);
                        } else {
                            $fieldExists = property_exists($value, $fieldName);
                        }
                    }
                }
                if ($fieldExists) {
                    $fieldNode = self::astFromValue($fieldValue, $field->getType());
                    if ($fieldNode) {
                        $fieldNodes[] = new ObjectFieldNode(['name' => new NameNode(['value' => $fieldName]), 'value' => $fieldNode]);
                    }
                }
            }
            return new ObjectValueNode(['fields' => $fieldNodes]);
        }
        // Since value is an internally represented value, it must be serialized
        // to an externally represented value before converting into an AST.
        if ($type instanceof LeafType) {
            $serialized = $type->serialize($value);
        } else {
            throw new InvariantViolation("Must provide Input Type, cannot use: " . Utils::printSafe($type));
        }
        if (null === $serialized) {
            return null;
        }
        // Others serialize based on their corresponding PHP scalar types.
        if (is_bool($serialized)) {
            return new BooleanValueNode(['value' => $serialized]);
        }
        if (is_int($serialized)) {
            return new IntValueNode(['value' => $serialized]);
        }
        if (is_float($serialized)) {
            if ((int) $serialized == $serialized) {
                return new IntValueNode(['value' => $serialized]);
            }
            return new FloatValueNode(['value' => $serialized]);
        }
        if (is_string($serialized)) {
            // Enum types use Enum literals.
            if ($type instanceof EnumType) {
                return new EnumValueNode(['value' => $serialized]);
            }
            // ID types can use Int literals.
            $asInt = (int) $serialized;
            if ($type instanceof IDType && (string) $asInt === $serialized) {
                return new IntValueNode(['value' => $serialized]);
            }
            // Use json_encode, which uses the same string encoding as GraphQL,
            // then remove the quotes.
            return new StringValueNode(['value' => substr(json_encode($serialized), 1, -1)]);
        }
        throw new InvariantViolation('Cannot convert value to AST: ' . Utils::printSafe($serialized));
    }

 /**
  * @it converts input objects
  */
 public function testConvertsInputObjects()
 {
     $inputObj = new InputObjectType(['name' => 'MyInputObj', 'fields' => ['foo' => Type::float(), 'bar' => $this->myEnum()]]);
     $expected = new ObjectValue(['fields' => [$this->objectField('foo', new IntValue(['value' => '3'])), $this->objectField('bar', new EnumValue(['value' => 'HELLO']))]]);
     $data = ['foo' => 3, 'bar' => 'HELLO'];
     $this->assertEquals($expected, AST::astFromValue($data, $inputObj));
     $this->assertEquals($expected, AST::astFromValue((object) $data, $inputObj));
 }