N+1 issue

GET /people?limit=10&start=0

GET /person/luke

GET /planet/tatooine
GET /person/luke/starshipConnection?page=1&limit=2

GET /starship/X-wing
GET /starship/ImperialShuttle
				

“GraphQL prevents HTTP overfetching”

Tailor made endpoint (RPC)

Connections are good for dynamic data

Don't trust it, it's opaque

Inserting data

Mutations

mutation createReview($episode: String!, $content: String!) {
  createReview(episode: $episode, content: $content) {
    content
    film {
      title
    }
  }
}
                

Variables can also be used on Queries

Simple syntax error

{
  "errors": [
    {
      "message": "Variable \"$episode\" of required type \"String!\" was not provided.",
      "locations": [
        {
          "line": 2,
          "column": 16
        }
      ]
    }
  ]
}
                

Runtime error

{
  "data": {
    "review": null
  },
  "errors": [
    {
      "message": "Episode not found",
      "locations": [
        {
          "line": 2,
          "column": 30
        }
      ]
    }
  ]
}
                

Defining an object type

$humanType = new ObjectType([
    'name' => 'Human',
    'description' => 'A humanoid creature in the Star Wars universe.',
    'fields' => [
        'id' => [
            'type' => Type::nonNull(Type::string()),
            'description' => 'The id of the human.',
        ],
        'name' => [
            'type' => Type::string(),
            'description' => 'The name of the human.',
        ]
    ],
    'resolveType' => function ($obj) use (&$humanType) {
        if (isset($humans[$obj['id']])) {
            return $humanType;
        }
    },
]);
                

Query

$queryString = '
    query HeroNameQuery {
        hero {
            name
        }
    }
';

$result = GraphQL::execute(
  StarWarsSchema::build(),
  $queryString
)
                

Declare an interface

# character.types.yml
Character:
  type: interface
  config:
    fields:
      id:
        type: "String"
      name:
        type: "String"
                        

# continuation of character.types.yml
...
  # Character.config.fields:
      friends:
        type: "[Character]"
        description: "The friends of the character."
      appearsIn:
        type: "[Film]"
        description: "Which movies they appear in."
                        

Declare the objects

# human.types.yml
Human:
  type: object
  config:
    fields:
      id:
        type: "String"
      name:
        type: "String"
      homeWorld:
        type: World
    interfaces: [Character]
    isTypeOf: true
                        

# droid.types.yml
Droid:
  type: object
  config:
    fields:
      id:
        type: "String"
      name:
        type: "String"
      homeWorld:
        type: World
    interfaces: [Character]
    isTypeOf: true
                        

Interfaces aren't required

Entry point

# query.types.yml
Query:
  type: object
  config:
    description: "All Star Wars queries"
    fields:
      allHumans:
        type: "[Human]"
        resolve: "@=resolver('allHumans', [args])" # Symfony Expression Language
      human:
        type: "Human"
        resolve: "@=resolver('human', [args['id'])" # Symfony Expression Language
        args:
          id:
            description: "Human's UUID"
            type: "String!"
                

Resolving it...

# services.yml
services:
  graphql.starwars.resolver.human:
    class: Mefi/GraphQL/Starwars/Resolver/HumanResolver
    arguments:
      - "@repository.human"
    tags:
      - { name: overblog_graphql.resolver, alias: "allHumans", method: "resolveAllHumans" }
      - { name: overblog_graphql.resolver, alias: "human", method: "resolveHuman" }
                

# query.types.yml
# Query.config
fields:
  allHumans:
    type: "[Human]"
    resolve: "@=resolver('allHumans', [args])"
                

Resolving it...

namespace Mefi\GraphQL\Starwars\Resolver;

use Overblog\GraphQLBundle\Definition\Argument;

class HumanResolver
{
    // Injected repository, properties and etc ...

    public function resolveAllHumans(Argument $args): array
    {
        // Do something with the $args
        return $this->humanRepository->findAll();
    }

    public function resolveHuman(string $humanId): Human
    {
        // Your business logic could be here, criterias, firewall, etc
        return $this->humanRepository->findById($humanId);
    }
}
                

Throwing errors

class HumanResolver
{
    // Injected repository, properties and etc ...
    // resolveAllHumans ...

    public function resolveHuman(string $humanId): Human
    {
        try {
            return $this->humanRepository->findById($humanId);
        } catch (HumanNotFoundException $e) {
            throw new UserError('This human was eliminated', 0, $e);
        }
    }
}
                

Possible errors Exceptions

throw new UserError('This human was eliminated');

throw new UserWarning('This human is sleeping');

throw new UserErrors(
    [
        new UserError('Human A not found', 0, $previousException),
        'Human B not found',
    ]
);
                

Awesome... drop the mic

Limiting query by depth

/** @var \GraphQL\Validator\Rules\QueryDepth $queryDepth */
$queryDepth = DocumentValidator::getRule('QueryDepth');
$queryDepth->setMaxQueryDepth($maxQueryDepth = 10);

GraphQL::execute(/*...*/);
                

# app/config/config.yml
overblog_graphql:
  security:
    query_max_depth: 10
                

Limiting query by complexity

/** @var \GraphQL\Validator\Rules\QueryComplexity $queryComplexity */
$queryComplexity = DocumentValidator::getRule('QueryComplexity');
$queryComplexity->setMaxQueryComplexity($maxQueryComplexity = 110);

GraphQL::execute(/*...*/);
                

# app/config/config.yml
overblog_graphql:
  security:
    query_max_complexity: 1000
                

Custom field complexity

# Query.types.yml

Query:
  type: object
  config:
    fields:
      droid:
        type: "Droid"
        complexity: '@=1000 + childrenComplexity'
        args:
          id:
            description: "id of the droid"
            type: "String!"
        resolve: "@=resolver('character_droid', [args])"
        

Security

Field access Control

# human.types.yml

Human:
  type: object
  config:
    fields:
      id:
        type: "String"
        access: "@=isSuperAdmin()"
                 

Field publicly visible

# human.types.yml

Human:
  type: object
  config:
    fields:
      id:
        type: "String"
        public: "@=service('security.authorization_checker').isGranted('ROLE_ADMIN')"
                 

Human:
  type: object
  fieldsDefaultPublic: "@=service('my_service').isGranted(typeName, fieldName)"
  config:
    fields:
      id:
        type: "String"
                 

Limiting data

namespace Mefi\GraphQL\Starwars\Resolver;

use Overblog\GraphQLBundle\Definition\Argument;

class HumanResolver
{
    // Injected repository, properties and etc ...

    public function resolveAllHumans(Argument $args): array
    {
        return $this->humanRepository->findAll();
        $criteria = Criteria::create()
        $criteria->where(
            Criteria::expr()->eq('race', $this->currentUser->getRace())
        );
        return $this->humanRepository->findAllByCriteria($criteria);
    }
}
                

Jetbrains autocomplete

Atom autocomplete

GraphiQL

GraphDoc

graphqlviz

GraphQL Network for chrome