youshido-php / graphql Goto Github PK

mutation m {
  userEdit(id: 1000000, data: 0) {
    fullName
  }
}

mutation m {
  userEdit(id: 1000000, data: {unknownField: "a"}) {
    fullName
  }
}

        $productType = new ObjectType([
            'name' => 'ProductType',
            'fields' => [
                'sId' => new IntType(),
                'title' => new StringType(),
                'comments' => new StringType(),
                'price' => new FloatType(),
                'priceStr' => new StringType(),
                'finalPrice' => new FloatType(),
                'finalPriceStr' => new StringType(),
                'currency' => new StringType(),
                'Link' => new StringType(),
                'link' => new StringType(),
            ],
            'resolve' => function()     <------- is this allowed?
            {
                return [
                    'sId' => 100,
                    'title' => 'Starwar film',
                    'comments' => 'no comment',
                    'price' => 13.5,
                    'priceStr' => '$13.5',
                    'finalPrice' => 10.5,
                    'finalPriceStr' => '$10.5',
                    'currency' => 'USD',
                    'Link' => 'http://google.com',
                    'link' => 'http://google.com'
                ];
            }
        ]);

class PostType extends \Youshido\GraphQL\Type\Object\AbstractObjectType
{

    /**
     * @param \Youshido\GraphQL\Config\Object\ObjectTypeConfig|TypeConfigInterface $config
     * @return mixed
     */
    public function build($config)
    {
        $config->addField('id', [
            'type' => new IdType(),
            'resolve' => function ($value, $args){
                return $value['post_id'];
            },
        ]);

        if (!$resolved && $field->getType()->getNamedType()->getKind() == TypeMap::KIND_SCALAR) {
            $resolved = true;
        }
        if ($resolveFunction = $field->getConfig()->getResolveFunction()) {
           .....
            } else {
                $resolverValue = $resolveFunction($resolved ? $resolverValue : $contextValue, $fieldAst->getKeyValueArguments(), $resolveInfo);
            }
        }

query {
    user {
        ...fUser
        reservations {
            ...fReservation
        }
    }
}
fragment fReservation on Reservation {
    id
    ... on CourtReservation {
        players {
            id
            user {
                ...fUser
            }
        }
    }
    ... on ClassReservation {
        user {
            ...fUser
        }
    }
}
fragment fUser on User {
    id
    fullname
}

mutation { // or query or empty
  __typename
}

{
  "errors": [
    {
      "message": "Field \"__typename\" not found in type \"Mutation\"",
      "locations": [
        {
          "line": 20,
          "column": 3
        }
      ]
    }
  ]
}

{
            Post(id: 1) {
                title,
                User {
                    name
                }
            }
        }

query {
  posts {
    ...post
  }
}

mutation{
  Test(test:{
    a:[
    ],
    b:[
      {
        c:"aaaa"
      },
      {

      }
    ],
  }) {
    name
  }
}

$config -> addField('a' , ['type' => new ListType(new IntType())        , 'description' => 'a'])
        -> addField('b' , ['type' => new ListType(new InputObjectType([
                                       'name'    => 'test_b',
                                       'fields'  => [
                                         'c'           =>  new NonNullType(new StringType()),
                                         ]
                                         ]))
                                      ])
        -> addField('d' , ['type' => new InputObjectType([
                                       'name'    => 'test_d',
                                       'fields'  => [
                                         'c'           =>  new NonNullType(new StringType()),
                                         ]
                                         ])
                                      ])

mutation { createPart( id: 3, name: "Another test",  description: "Another  description", minimumStock: "12", notes: "Another note")  }

public function getRules()
    {
        return [
            'name'        => ['type' => TypeService::TYPE_STRING, 'required' => true],
            'description' => ['type' => TypeService::TYPE_STRING],
            'fields'      => ['type' => TypeService::TYPE_ARRAY_OF_FIELDS_CONFIG, 'final' => true],
            'interfaces'  => ['type' => TypeService::TYPE_ARRAY_OF_INTERFACES],
            'args'     => ['type' => TypeService::TYPE_ARRAY_OF_INPUT_FIELDS]
        ];
    }

<?php
namespace AppBundle\GraphQL\Mutation;

use AppBundle\GraphQL\Type\TestMutationInputType;
use Youshido\GraphQL\Config\Field\FieldConfig;
use Youshido\GraphQL\Execution\ResolveInfo;
use Youshido\GraphQL\Type\NonNullType;
use Youshido\GraphQL\Type\Scalar\IntType;
use Youshido\GraphQLBundle\Field\AbstractContainerAwareField;

class TestMutationField extends AbstractContainerAwareField
{

    /**
     * {@inheritdoc}
     */
    public function getType()
    {
        return new IntType();
    }

    /**
     * {@inheritdoc}
     */
    public function build(FieldConfig $config)
    {
        $config->addArgument('input', new NonNullType(new TestMutationInputType()));
    }

    /**
     * {@inheritdoc}
     */
    public function resolve($value, array $args, ResolveInfo $info)
    {
        return 0;
    }
}

<?php
namespace AppBundle\GraphQL\Input;

use Youshido\GraphQL\Type\InputObject\AbstractInputObjectType;
use Youshido\GraphQL\Type\ListType\ListType;
use Youshido\GraphQL\Type\NonNullType;
use Youshido\GraphQL\Type\Scalar\StringType;

class TestMutationInputType extends AbstractInputObjectType
{

    /**
     * {@inheritdoc}
     */
    public function build($config)
    {
        $config->addFields([
            'nullField' => new StringType(),
            'nonNullField' => new NonNullType(new StringType()),
        ]);
    }
}

{
  "data": {
    "testMutation": null
  },
  "errors": [
    {
      "message": "Not valid type for argument \"input\" in query \"testMutation\""
    }
  ]
}

type Query {
  user: User
} 
type User {
  key: Int
}

{
  user {
    key { // empty selection, causing invalid query

    }
  }
}

{
  "errors": [
    {
      "message": "Syntax Error GraphQL request (5:5) Expected Name, found }\n\n4:       \n5:     }\n       ^\n6:   }\n",
      "locations": [
        {
          "line": 5,
          "column": 5
        }
      ]
    }
  ]
}

{
  "data": {
    "user": {
      "key": null
    }
  }
}

{
            oneComparison: Post(id: 1) {
                title
            }
            twoComparison: Post(id: 1) {
                ...Fields
            }
        }
        
        fragment Fields on Post {
            title
        }

{Test{
  name,
  bla {
  }
}}

type Query {
  getSomething(sort:SortType): String //sort not required
}

query SomeQuery($sort:SortType) {
  getSomething(sort: $sort)
}

{}

{
  "errors": [
    {
      "message": "Variable \"sort\" does not exist for query \"getSomething\""
    }
  ]
}

type Query {
  user: User
} 
type User {
  key: Int
}

{
  user {
    key { 
      someKey // trying to sub-select on Int
    }
  }
}

{
  "errors": [
    {
      "message": "Field \"key\" of type \"Int\" must not have a sub selection.",
      "locations": [
        {
          "line": 3,
          "column": 9
        }
      ]
    }
  ]
}

{
  "data": {
    "user": {
      "key": null
    }
  }
}

query queryWithVariable($abc:String) {
  userById(id: 2) {
    ...someFragment
  }
}

<?php
use Youshido\GraphQL\Type\Object\ObjectType;
use Youshido\GraphQL\Type\Scalar\StringType;

// creating a root query structure
$rootQueryType = new ObjectType([
    // name for the root query type doesn't matter, by the convention it's RootQueryType
    'name'   => 'RootQueryType',
    'fields' => [
        'latestPost' => new ObjectType([ // the Post type will be extended from the generic ObjectType
            'name'    => 'Post', // name of our type – "Post"
            'fields'  => [
                'title'   => new StringType(),  // defining the "title" field, type - String
                'summary' => new StringType(),  // defining the "summary" field, also a String type
            ],
            'resolve' => function () {          // this is a resolve function
                return [                        // for now it returns a static array with data
                    "title"   => "New approach in API has been revealed",
                    "summary" => "This post describes a new approach to create and maintain APIs",
                ];
            }
        ])
    ]
]);

{
  user(id: 2) {
    ...user
  }
}

fragment user on UserUnion {
  ... on User {
    id
  }
}

$config->addField('id', [
  'type' => new NonNullType(new IntType()),
  'resolve' => function() { return null; }
]);

{
      "message": "Cannot return null for non-nullable field User.id.",
      "locations": [
        {
          "line": 5,
          "column": 5
        }
      ]
    }

{ foo { bar(value:"baz") } }

query nestedQuery($value:String!){
  foo {
    bar(value:$value)
}

mutation
{createPost(
  title: 'Copa America', 
  description: ' Latest results ',
  authors: [  
     {name: 'Maradona', email: '[email protected]' } ,
     {name: 'Messi', email: '[email protected]' } ]  
)}

if (!$argumentType->isValidValue($argumentType->parseValue($argument->getValue()->getValue()))) {

query {
  somethingThatReturnsAUnion(foo: "bar") {
     ... on Something { // Something is a valid type for this union!
        id
     }
  }
}

{
  "errors": [
    {
      "message": "Config is not valid for TestType\nField \"values\" expected to be \"type\" but got \"array\""
    }
  ]
}

use \Youshido\GraphQL\Type\Object\AbstractObjectType;
use \Youshido\GraphQL\Type\Scalar\IdType;
use \Youshido\GraphQL\Type\Scalar\StringType;
use \Youshido\GraphQL\Type\Scalar\DateType;
use \Youshido\GraphQL\Type\Scalar\BooleanType;
use \Youshido\GraphQL\Type\ListType\ListType;
use \Youshido\GraphQL\Type\Enum\AbstractEnumType;

class TestType extends AbstractEnumType
{
    public function getValues()
    {
        $result = array();
        $result[]= array(
                'value' => 1,
                'name' => "aaa-", 
            );
        $result[]= array(
                'value' => 2,
                'name' => "bbb", 
        );
        return $result;
    }


}

{
  user(id: 11457349) {

  } 
}

query userById($offset:Int) {
  user(id: 2) {
    id
    photoAlbums(offset: $offset) {
      edges {
        id
      }
    }
  }
}

{
  "data": {
    "user": {
      "id": 2,
      "photoAlbums": null
    }
  },
  "errors": [
    {
      "message": "Variable \"offset\" does not exist for query \"photoAlbums\""
    }
  ]
}

{
  user(id: 2) {
    id
    photoAlbums {
      edges {
        id
      }
    }
  }
}

{
  "data": {
    "user": {
      "id": 2,
      "photoAlbums": {
        "edges": [
          {
            "id": 10000965
          },
          ....
        ]
      }
    }
  }
}

public function build(TypeConfigInterface $config)
{
    $config
        ->addField('title', new NonNullType(new StringType()), [
            'description'       => 'This field contains a post title',
            'isDeprecated'      => true,
            'deprecationReason' => 'field title is now deprecated',
            'args'              => [
                'truncated' => new BooleanType()
            ],
            'resolve'           => function ($value, $args) {
                return (!empty($args['truncated'])) ? explode(' ', $value)[0] . '...' : $value;
            }
        ])
        ->addField('summary', new StringType())
        ->addField('likeCount', new IntType());
    $config->addArgument('id', new IntType());
}

public function resolve($value, $args, $info)
{
    return [
        "title"     => "Title for the latest Post",
        "summary"   => "Post summary",
        "likeCount" => 2
    ];
}

class TodoType extends AbstractObjectType
{
    public function build($config)
    {
        $config->addFields([
            'id' => new NonNullType(new IdType()),
            'title' => new StringType(),
            'completed' => new BooleanType(),
            'expire' => new DateTimeType("d-m-Y")
        ]);
    }

}

fragment todo on Todo {
  id
  title
  completed
  expire
}

{
  todos {
    ...todo
  }
}

{
  "data": {
    "todos": [
      null
    ]
  },
  "errors": [
    {
      "message": "Not valid resolved type for field \"expire\""
    }
  ]
}

mutation {
   save(id:1, title: "todo mod", expire: null) {
    ...todo
  }
}

{
  "data": {
    "save": null,
    "toggleAll": [
      null
    ]
  },
  "errors": [
    {
      "message": "Not valid type for argument \"expire\" in query \"save\"",
      "locations": [
        {
          "line": 10,
          "column": 34
        }
      ]
    },
    {
      "message": "Not valid resolved type for field \"expire\""
    }
  ]
}

type Query {
  user: User
} 
type User {
  key: Int!
}

{
  user {
    key 
  }
}

{
  "data": {
    "user": null
  },
  "errors": [
    {
      "message": "Cannot return null for non-nullable field User.key.",
      "locations": [
        {
          "line": 3,
          "column": 5
        }
      ]
    }
  ]
}

{
  "data": {
    "user": {
      "key": null
    }
  }
}

{
  name
  primaryAddress
}

{
  "name": "Bob",
  "primaryAddress": {

        },
        "__cloner__": {

        },
        "__isInitialized__": false
      }
}

<?php
namespace App\AppBundle\GraphQL;

use Youshido\GraphQL\Type\ListType\ListType;
use Youshido\GraphQL\Type\Object\AbstractObjectType;
use Youshido\GraphQL\Type\Scalar\BooleanType;
use Youshido\GraphQL\Type\Scalar\DateTimeTzType;
use Youshido\GraphQL\Type\Scalar\DateType;
use Youshido\GraphQL\Type\Scalar\FloatType;
use Youshido\GraphQL\Type\Scalar\IdType;
use Youshido\GraphQL\Type\Scalar\IntType;
use Youshido\GraphQL\Type\Scalar\StringType;

class PersonType extends AbstractObjectType {

    /**
     * @param mixed $config
     */
    public function build($config) {
        return $config
        ->addFields(['name' => ['type' => new StringType(), 'description' => 'The name of the person']])
        ->addFields(['primaryAddress' => ['type' => new AddressType(), 'description' => 'Their primary address']])
    }

    /**
     */
    public function getName() {
        return "Person";
    }
}

class AddressType extends AbstractObjectType {

    /**
     * @param mixed $config
     */
    public function build($config) {
        return $config
                      ->addFields(['street' => ['type' => new StringType(), 'description' => 'The street']])
                      ->addFields(['postcode' => ['type' => new StringType(), 'description' => 'The postcode']]);
    }

    /**
     */
    public function getName() {
        return 'Address';
    }
}

public function isValidValue($value)
    {
        if (is_object($value)) {
            return true;
        }
        return is_int($value);
    }

 public function serialize($value)
    {
        if ($value === null || !is_object($value)) {
            return null;
        }
        return $value->getTimestamp();
    }

mutation {
  upvote(idPhotos:[320131273]) {
    id
  }
}

$config->addArgument('idPhotos', new NonNullType(new ListType(new IntType())));

$config->addArgument('idPhotos', new NonNullType(new ListType(new NonNullType(new IntType()))));