protected function doResolve(FieldInterface $field, AstFieldInterface $ast, $parentValue = null)
{
/** @var AstQuery|AstField $ast */
$arguments = $this->parseArgumentsValues($field, $ast);
$astFields = $ast instanceof AstQuery ? $ast->getFields() : [];
$resolveInfo = $this->createResolveInfo($field, $astFields);
$this->assertClientHasFieldAccess($resolveInfo);
if ($field instanceof Field) {
if ($resolveFunc = $field->getConfig()->getResolveFunction()) {
if ($this->isServiceReference($resolveFunc)) {
$service = substr($resolveFunc[0], 1);
$method = $resolveFunc[1];
if (!$this->executionContext->getContainer()->has($service)) {
throw new ResolveException(sprintf('Resolve service "%s" not found for field "%s"', $service, $field->getName()));
}
$serviceInstance = $this->executionContext->getContainer()->get($service);
if (!method_exists($serviceInstance, $method)) {
throw new ResolveException(sprintf('Resolve method "%s" not found in "%s" service for field "%s"', $method, $service, $field->getName()));
}
return $serviceInstance->{$method}($parentValue, $arguments, $resolveInfo);
}
return $resolveFunc($parentValue, $arguments, $resolveInfo);
} else {
return TypeService::getPropertyValue($parentValue, $field->getName());
}
} else {
//instance of AbstractContainerAwareField
if (in_array('Symfony\\Component\\DependencyInjection\\ContainerAwareInterface', class_implements($field))) {
/** @var $field ContainerAwareInterface */
$field->setContainer($this->executionContext->getContainer()->getSymfonyContainer());
}
return $field->resolve($parentValue, $arguments, $resolveInfo);
}
}
public function assetTypeHasField(AbstractType $objectType, AstFieldInterface $ast)
{
/** @var AbstractObjectType $objectType */
if (!(TypeService::isObjectType($objectType) || TypeService::isInputObjectType($objectType)) || !$objectType->hasField($ast->getName())) {
throw new ResolveException(sprintf('Field "%s" not found in type "%s"', $ast->getName(), $objectType->getNamedType()->getName()), $ast->getLocation());
}
}
public function testScalarPrimitives()
{
foreach (TypeFactory::getScalarTypesNames() as $typeName) {
$scalarType = TypeFactory::getScalarType($typeName);
$testDataMethod = 'get' . $typeName . 'TestData';
$this->assertNotEmpty($scalarType->getDescription());
$this->assertEquals($scalarType->getKind(), TypeMap::KIND_SCALAR);
$this->assertEquals($scalarType->isCompositeType(), false);
$this->assertEquals(TypeService::isAbstractType($scalarType), false);
$this->assertEquals($scalarType->getType(), $scalarType);
$this->assertEquals($scalarType->getType(), $scalarType->getNamedType());
$this->assertNull($scalarType->getConfig());
foreach (call_user_func(['Youshido\\Tests\\DataProvider\\TestScalarDataProvider', $testDataMethod]) as list($data, $serialized, $isValid)) {
$this->assertSerialization($scalarType, $data, $serialized);
$this->assertParse($scalarType, $data, $serialized);
if ($isValid) {
$this->assertTrue($scalarType->isValidValue($data), $typeName . ' validation for :' . serialize($data));
} else {
$this->assertFalse($scalarType->isValidValue($data), $typeName . ' validation for :' . serialize($data));
}
}
}
try {
TypeFactory::getScalarType('invalid type');
} catch (\Exception $e) {
$this->assertEquals('Configuration problem with type invalid type', $e->getMessage());
}
$this->assertEquals('String', (string) new StringType());
}
/**
* NonNullType constructor.
*
* @param AbstractType|string $fieldType
*
* @throws ConfigurationException
*/
public function __construct($fieldType)
{
if (!TypeService::isGraphQLType($fieldType)) {
throw new ConfigurationException('NonNullType accepts only GraphpQL Types as argument');
}
if (TypeService::isScalarType($fieldType)) {
$fieldType = TypeFactory::getScalarType($fieldType);
}
$this->_typeOf = $fieldType;
}
public function __construct(array $config = [])
{
if (empty($config['type'])) {
$config['type'] = $this->getType();
$config['name'] = $this->getName();
}
if (TypeService::isScalarType($config['type'])) {
$config['type'] = TypeFactory::getScalarType($config['type']);
}
$this->config = new InputFieldConfig($config, $this, $this->isFinal);
$this->build($this->config);
}
public function resolve($value, array $args, ResolveInfo $info)
{
if ($resolveFunction = $this->getConfig()->getResolveFunction()) {
return $resolveFunction($value, $args, $info);
} else {
if (is_array($value) && array_key_exists($this->getName(), $value)) {
return $value[$this->getName()];
} elseif (is_object($value)) {
return TypeService::getPropertyValue($value, $this->getName());
} elseif ($this->getType()->getNamedType()->getKind() == TypeMap::KIND_SCALAR) {
return null;
} else {
throw new \Exception(sprintf('Property "%s" not found in resolve result', $this->getName()));
}
}
}
public function testNonNullType()
{
$stringType = new StringType();
$nonNullType = new NonNullType(new StringType());
$nonNullOnString = new NonNullType(TypeMap::TYPE_STRING);
$testArray = ['a' => 'b'];
$this->assertEquals($nonNullType->getName(), null, 'Empty non-null name');
$this->assertEquals($nonNullType->getKind(), TypeMap::KIND_NON_NULL);
$this->assertEquals($nonNullType->getType(), new NonNullType($stringType));
$this->assertEquals($nonNullType->getNullableType(), $stringType);
$this->assertEquals($nonNullType->getNullableType(), $nonNullOnString->getNullableType());
$this->assertEquals($nonNullType->getNamedType(), $stringType);
$this->assertEquals($nonNullType->getTypeOf(), $stringType);
$this->assertEquals($nonNullType->isCompositeType(), true);
$this->assertEquals(TypeService::isAbstractType($nonNullType), false);
$this->assertFalse($nonNullType->isValidValue(null));
$this->assertTrue($nonNullType->isValidValue($stringType));
$this->assertFalse($nonNullType->isValidValue(new \stdClass()));
$this->assertEquals($nonNullType->parseValue($testArray), '');
$this->assertEquals($nonNullType->resolve($testArray), $testArray);
}
/**
* @param string $type
*
* @throws ConfigurationException
* @return AbstractScalarType
*/
public static function getScalarType($type)
{
if (TypeService::isScalarType($type)) {
if (is_object($type)) {
$typeName = $type->getName();
if (empty(self::$objectsHash[$typeName])) {
self::$objectsHash[$typeName] = $type;
}
return self::$objectsHash[$typeName];
}
if (empty(self::$objectsHash[$type])) {
$name = ucfirst($type);
$name = $name == 'Datetime' ? 'DateTime' : $name;
$name = $name == 'Datetimetz' ? 'DateTimeTz' : $name;
$className = 'Youshido\\GraphQL\\Type\\Scalar\\' . $name . 'Type';
self::$objectsHash[$type] = new $className();
}
return self::$objectsHash[$type];
} else {
throw new ConfigurationException('Configuration problem with type ' . $type);
}
}
private function isInputField($data)
{
if (is_object($data)) {
if ($data instanceof InputFieldInterface) {
return true;
} else {
return TypeService::isInputType($data);
}
} else {
if (!isset($data['type'])) {
return false;
}
return TypeService::isInputType($data['type']);
}
}
public function testGetPropertyValue()
{
$arrayData = (new TestObjectType())->getData();
$this->assertEquals('John', TypeService::getPropertyValue($arrayData, 'name'));
$this->assertEquals('John', TypeService::getPropertyValue((object) $arrayData, 'name'));
}
/**
* @param mixed|AbstractType $type
* @return bool
*/
public static function isInputType($type)
{
if (is_object($type)) {
$namedType = $type->getNullableType()->getNamedType();
return $namedType instanceof AbstractScalarType || $type instanceof AbstractListType || $namedType instanceof AbstractInputObjectType || $namedType instanceof AbstractEnumType;
} else {
return TypeService::isScalarType($type);
}
}