GraphQL PHP

https://github.com/webonyx/graphql-php
Admin
GraphQL PHP is a feature-complete implementation of the GraphQL specification in PHP, providing...
Tokens:212,488
Snippets:1,504
Trust Score:8.1
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup: Clone and install dependencies

Source: https://github.com/webonyx/graphql-php/blob/master/CONTRIBUTING.md

Clone the repository, navigate into the directory, and install dependencies with Composer.

```sh
git clone <your-fork-url>
cd graphql-php
composer install
```

--------------------------------

### Run the example server and test with curl

Source: https://github.com/webonyx/graphql-php/blob/master/docs/getting-started.md

These commands start a PHP built-in server and send a test query to the GraphQL endpoint.

```sh
php -S localhost:8080 graphql.php
curl http://localhost:8080 -d '{"query": "query { echo(message: \"Hello World\") }" }'
```

--------------------------------

### Install ReactPHP dependencies

Source: https://github.com/webonyx/graphql-php/blob/master/examples/04-async-php/reactphp/hello-world-http-server/README.md

Install the required ReactPHP dependencies for this example.

```bash
composer require react/promise react/http
```

--------------------------------

### Install amphp/http-server

Source: https://github.com/webonyx/graphql-php/blob/master/examples/04-async-php/amphp/http-server/README.md

Install the AMPHP HTTP server package required for this example.

```bash
composer require amphp/http-server
```

--------------------------------

### GraphQL query example

Source: https://github.com/webonyx/graphql-php/blob/master/docs/getting-started.md

This is the GraphQL query that the hello world example is designed to handle.

```graphql
query {
  echo(message: "Hello World")
}
```

--------------------------------

### Run the GraphQL server

Source: https://github.com/webonyx/graphql-php/blob/master/examples/04-async-php/amphp/http-server/README.md

Run the GraphQL HTTP server locally using the AMPHP example.

```bash
php graphql.php
```

--------------------------------

### Install graphql-php with Composer

Source: https://github.com/webonyx/graphql-php/blob/master/README.md

Install the graphql-php package via Composer. Run this command in your project root to add the library as a dependency.

```sh
composer require webonyx/graphql-php
```

--------------------------------

### GraphQL type system example

Source: https://github.com/webonyx/graphql-php/blob/master/docs/concepts.md

Pseudo-language example of a GraphQL type system with BlogPost and User types, showing field definitions and types.

```graphql
type BlogPost {
    title: String!
    author: User
    body: String
}

type User {
    id: Id!
    firstName: String
    lastName: String
}
```

--------------------------------

### Run local test server

Source: https://github.com/webonyx/graphql-php/blob/master/examples/00-hello-world/README.md

Starts a PHP built-in web server on localhost:8080 serving the graphql.php file.

```bash
php -S localhost:8080 graphql.php
```

--------------------------------

### Example GraphQL query with fragment

Source: https://github.com/webonyx/graphql-php/blob/master/examples/01-blog/README.md

Example query to explore the schema. Includes a fragment for comments and demonstrates field arguments, aliases, and commented-out fields that trigger validation errors or error reporting when uncommented.

```graphql
{
  viewer {
    id
    email
  }
  user(id: "2") {
    id
    email
  }
  stories(after: "1") {
    id
    body
    comments {
      ...CommentView
    }
  }
  lastStoryPosted {
    id
    hasViewerLiked
    author {
      id
      photo(size: ICON) {
        id
        url
        size
        width
        height
        # Uncomment following line to see validation error:
        # nonExistingField

        # Uncomment to see error reporting for fields with exceptions thrown in resolvers
        # fieldWithError
        # nonNullFieldWithError
      }
      lastStoryPosted {
        id
      }
    }
    body(format: HTML, maxLength: 10)
  }
}

fragment CommentView on Comment {
  id
  body
  totalReplyCount
  replies {
    id
    body
  }
}
```

--------------------------------

### Install AMPHP v3

Source: https://github.com/webonyx/graphql-php/blob/master/examples/04-async-php/amphp-v3/event-loop/README.md

Install AMPHP v3 as a dependency for the project.

```sh
composer require amphp/amp:^3
```

--------------------------------

### GraphQL type system in graphql-php

Source: https://github.com/webonyx/graphql-php/blob/master/docs/concepts.md

The same type system example expressed in graphql-php, using ObjectType and Type helpers to define User and BlogPost types.

```php
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\ObjectType;

$userType = new ObjectType([
    'name' => 'User',
    'fields' => [
        'id' => Type::nonNull(Type::id()),
        'firstName' => Type::string(),
        'lastName' => Type::string()
    ]
]);

$blogPostType = new ObjectType([
    'name' => 'BlogPost',
    'fields' => [
        'title' => Type::nonNull(Type::string()),
        'author' => $userType
    ]
]);
```

--------------------------------

### AST::fromArray() example

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Example usage of AST::fromArray() converting an associative array representation of an AST into a GraphQL\Language\AST\Node instance. The example creates a ListValueNode with two StringValueNode values and a location. The resulting node's values prop is a lazily-evaluated NodeList.

```php
AST::fromArray([
    'kind' => 'ListValue',
    'values' => [
        ['kind' => 'StringValue', 'value' => 'my str'],
        ['kind' => 'StringValue', 'value' => 'my other str']
    ],
    'loc' => ['start' => 21, 'end' => 25]
]);
```

--------------------------------

### Equivalent full form with type key

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/object-types.md

Shows the equivalent of the shorthand notation, where each field is an array with a 'type' key. This is the expanded form of the shorthand example.

```php
'fields' => [
    'id' => ['type' => Type::id()],
    'fieldName' => ['type' => $fieldName]
]
```

--------------------------------

### JSON response for hero query

Source: https://github.com/webonyx/graphql-php/blob/master/docs/concepts.md

Example JSON response for the hero query, showing the structure of the returned data.

```json
{
  "hero": {
    "name": "R2-D2",
    "friends": [
      { "name": "Luke Skywalker" },
      { "name": "Han Solo" },
      { "name": "Leia Organa" }
    ]
  }
}
```

--------------------------------

### Schema definition language example

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/index.md

Defines a schema using the GraphQL schema definition language, including a query type, mutation type, and an input type. This example shows the syntax for defining types and fields with non-null and list modifiers.

```graphql
schema {
  query: Query
  mutation: Mutation
}

type Query {
  greetings(input: HelloInput!): String!
}

input HelloInput {
  firstName: String!
  lastName: String
}
```

--------------------------------

### Before: AST serialization with nulls

Source: https://github.com/webonyx/graphql-php/blob/master/UPGRADE.md

Example of json-serialized AST before the change, including null fields like 'loc', 'alias', and 'selectionSet'.

```json
{
  "kind": "Field",
  "loc": null,
  "name": {
    "kind": "Name",
    "loc": null,
    "value": "id"
  },
  "alias": null,
  "arguments": [],
  "directives": [],
  "selectionSet": null
}
```

--------------------------------

### Example error entry with debug message and trace

Source: https://github.com/webonyx/graphql-php/blob/master/docs/error-handling.md

Shows the structure of an error entry when using DebugFlag::INCLUDE_DEBUG_MESSAGE | DebugFlag::INCLUDE_TRACE. The trace is formatted from the original exception.

```php
[
    'message' => 'Internal server error',
    'locations' => [
        ['line' => 10, 'column' => 2],
    ],
    'path' => [
        'listField',
        0,
        'fieldWithException',
    ],
    'extensions' => [
        'debugMessage' => 'Actual exception message',
        'trace' => [
            // Formatted original exception trace
        ],
    ],
]
```

--------------------------------

### PHP nowdoc example for test assertions

Source: https://github.com/webonyx/graphql-php/blob/master/CONTRIBUTING.md

Use PHP native nowdoc syntax for multiline strings in tests, with a tag like GRAPHQL, PHP, or JSON when the content is in a specific grammar.

```php
self::assertSomeOutputExactlyMatches(
    <<<'GRAPHQL'
    type Foo {
      bar: Baz
    }

    GRAPHQL,
    $output
);
```

--------------------------------

### Reported error for safe exception

Source: https://github.com/webonyx/graphql-php/blob/master/docs/error-handling.md

Example of the error entry produced when a ClientAware safe exception is thrown, showing the full error message and location/path details.

```php
[
    'message' => 'My reported error',
    'locations' => [
        ['line' => 10, 'column' => 2],
    ],
    'path' => [
        'path',
        'to',
        'fieldWithException',
    ]
];
```

--------------------------------

### GraphQL query for lastStory with author

Source: https://github.com/webonyx/graphql-php/blob/master/docs/data-fetching.md

Example GraphQL query that requests the lastStory's title and author's name. This query is used to demonstrate how graphql-php traverses fields and calls resolve functions.

```graphql
{
  lastStory {
    title
    author {
      name
    }
  }
}
```

--------------------------------

### Invisible types example

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/interfaces.md

Shows a schema where Cat and Dog implement Animal but are not directly referenced by any field, making them invisible to introspection.

```graphql
type Query {
    animal: Animal
}

interface Animal {...}

type Cat implements Animal {...}
type Dog implements Animal {...}
```

--------------------------------

### curl request to GraphQL API

Source: https://github.com/webonyx/graphql-php/blob/master/examples/05-type-config-decorator/README.md

Sends a GraphQL query to the running API at localhost:8080. The query requests tracksForHome with title, thumbnail, and author fields. Use this after starting the server with `php -S localhost:8080 graphql.php`.

```bash
curl --data '{"query": "{ tracksForHome { title thumbnail author { id name } } }"}' --header "Content-Type: application/json" http://localhost:8080
```

--------------------------------

### Lazy loading types with a type registry and typeLoader

Source: https://github.com/webonyx/graphql-php/blob/master/docs/schema-definition.md

A complete type registry example for lazy loading GraphQL types. It defines StoryType and AuthorType with fields as callbacks, a Types registry that caches and lazily loads types via typeLoader, and an api/index.php that uses the registry with a typeLoader. The typeLoader must always return the same instance of a type, enforced by caching.

```php
// StoryType.php
use GraphQL\Type\Definition\ObjectType;

final class StoryType extends ObjectType
{
    public function __construct()
    {
        parent::__construct([
            'fields' => static fn (): array => [
                'author' => [
                    'type' => Types::author(),
                    'resolve' => static fn (Story $story): ?Author => DataSource::findUser($story->authorId),
                ],
            ],
        ]);
    }
}

// AuthorType.php
use GraphQL\Type\Definition\ObjectType;

final class AuthorType extends ObjectType
{
    public function __construct()
    {
        parent::__construct([
            'description' => 'Writer of books',
            'fields' => static fn (): array => [
                'firstName' => Types::string(),
            ],
        ]);
    }
}

// Types.php
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\NamedType;

final class Types
{
    /** @var array<string, Type&NamedType> */
    private static array $types = [];

    /** @return Type&NamedType */
    public static function load(string $typeName): Type
    {
        if (isset(self::$types[$typeName])) {
            return self::$types[$typeName];
        }

        // For every type, this class must define a method with the same name
        // but the first letter is in lower case.
        $methodName = match ($typeName) {
            'ID' => 'id',
            default => lcfirst($typeName),
        };
        if (! method_exists(self::class, $methodName)) {
            throw new \Exception("Unknown GraphQL type: {$typeName}.");
        }

        $type = self::{$methodName}(); // @phpstan-ignore-line variable static method call
        if (is_callable($type)) {
            $type = $type();
        }

        return self::$types[$typeName] = $type;
    }

    /** @return Type&NamedType */
    private static function byClassName(string $className): Type
    {
        $classNameParts = explode('\\', $className);
        $baseClassName = end($classNameParts);
        // All type classes must use the suffix Type.
        // This prevents name collisions between types and PHP keywords.
        $typeName = preg_replace('~Type$~', '', $baseClassName);

        // Type loading is very similar to PHP class loading, but keep in mind
        // that the **typeLoader** must always return the same instance of a type.
        // We can enforce that in our type registry by caching known types.
        return self::$types[$typeName] ??= new $className;
    }

    /** @return \Closure(): (Type&NamedType) */
    private static function lazyByClassName(string $className): \Closure
    {
        return static fn () => self::byClassName($className);
    }

    public static function boolean(): ScalarType { return Type::boolean(); }
    public static function float(): ScalarType { return Type::float(); }
    public static function id(): ScalarType { return Type::id(); }
    public static function int(): ScalarType { return Type::int(); }
    public static function string(): ScalarType { return Type::string(); }
    public static function author(): callable { return self::lazyByClassName(AuthorType::class); }
    public static function story(): callable { return self::lazyByClassName(StoryType::class); }
    ...
}

// api/index.php
use GraphQL\Type\Definition\ObjectType;

$schema = new Schema([
    'query' => new ObjectType([
        'name' => 'Query',
        'fields' => static fn() => [
            'story' => [
                'args'=>[
                  'id' => Types::int(),
                ],
                'type' => Types::story(),
                'description' => 'Returns my A',
                'resolve' => static fn ($rootValue, array $args): ?Story => DataSource::findStory($args['id']),
            ],
        ],
    ]),
    'typeLoader' => Types::load(...),
]);
```

--------------------------------

### Create ServerConfig and StandardServer

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Shows how to create a ServerConfig instance and pass it to a StandardServer constructor.

```php
$config = GraphQL\Server\ServerConfig::create()
    ->setSchema($mySchema)
    ->setContext($myContext);

$server = new GraphQL\Server\StandardServer($config);
```

--------------------------------

### Create SchemaConfig and Schema

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Shows how to create a SchemaConfig instance, set the query type and a type loader, and pass the config to a new Schema.

```php
$config = SchemaConfig::create()
    ->setQuery($myQueryType)
    ->setTypeLoader($myTypeLoader);

$schema = new Schema($config);
```

--------------------------------

### Run unit tests

Source: https://github.com/webonyx/graphql-php/blob/master/CONTRIBUTING.md

Execute the test suite using Composer.

```sh
composer test
```

--------------------------------

### FormattedError::toSafeTrace

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static method on FormattedError to get a safe, serializable error trace.

```APIDOC
## toSafeTrace

### Description
Returns the error trace as a serializable array, suitable for debugging.

### Method
toSafeTrace

### Signature
```php
static function toSafeTrace(Throwable $error): array
```

### Parameters
- **error** (Throwable) - Required - The error to extract the trace from.

### Return Value
- **array** - An array of trace entries, each containing optional keys: file, line, function, call.
```

--------------------------------

### ServerConfig::create

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static factory method to create a ServerConfig instance from an array of options.

```APIDOC
## ServerConfig::create

### Description
Creates a new ServerConfig instance from an array of options. If no array is passed, returns an empty config.

### Method
static

### Signature
`static function create(array $config = []): self`

### Parameters
- **$config** (array<string, mixed>) - Optional - Configuration options array.

### Return Value
- **self** - A new ServerConfig instance.

### Exceptions
- **InvariantViolation** - Thrown if the configuration is invalid.

### Example
```php
$config = GraphQL\Server\ServerConfig::create([
    'schema' => $mySchema,
]);
```
```

--------------------------------

### GraphQL\Language\Visitor::removeNode

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static method to get a marker that removes the current node when returned from a visitor function.

```APIDOC
## [STATIC] GraphQL\Language\Visitor::removeNode

### Description
Returns marker for removing the current node.

### Method
static function

### Signature
`static function removeNode(): GraphQL\Language\VisitorRemoveNode`

### Return Value
- **GraphQL\Language\VisitorRemoveNode** - A marker object to remove the current node.

### Example
```php
Visitor::visit($ast, [
    'enter' => function (Node $node) {
        return Visitor::removeNode();
    }
]);
```
```

--------------------------------

### Run benchmarks

Source: https://github.com/webonyx/graphql-php/blob/master/CONTRIBUTING.md

Check performance of performance critical code with PHPBench.

```sh
composer bench
```

--------------------------------

### GraphQL\Language\Visitor::stop

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static method to get a marker that stops the visitor completely when returned from a visitor function.

```APIDOC
## [STATIC] GraphQL\Language\Visitor::stop

### Description
Returns marker for stopping the visitor completely.

### Method
static function

### Signature
`static function stop(): GraphQL\Language\VisitorStop`

### Return Value
- **GraphQL\Language\VisitorStop** - A marker object to stop the visitor.

### Example
```php
Visitor::visit($ast, [
    'enter' => function (Node $node) {
        return Visitor::stop();
    }
]);
```
```

--------------------------------

### StandardServer usage with array config and ServerConfig

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Two ways to instantiate and run a StandardServer: with an array configuration or with a ServerConfig instance. Both call handleRequest() to process the HTTP request.

```php
$server = new StandardServer([
  'schema' => $mySchema
]);
$server->handleRequest();
```

```php
$config = GraphQL\Server\ServerConfig::create()
    ->setSchema($mySchema)
    ->setContext($myContext);

$server = new GraphQL\Server\StandardServer($config);
$server->handleRequest();
```

--------------------------------

### ServerConfig::create method

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static factory method that creates a ServerConfig from an array of options, or returns an empty config if no array is passed.

```php
/**
 * Converts an array of options to instance of ServerConfig
 * (or just returns empty config when array is not passed).
 *
 * @param array<string, mixed> $config
 *
 * @api
 *
 * @throws InvariantViolation
 */
static function create(array $config = []): self
```

--------------------------------

### GraphQL\Language\Visitor::skipNode

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static method to get a marker that skips the subtree at the current node when returned from a visitor function.

```APIDOC
## [STATIC] GraphQL\Language\Visitor::skipNode

### Description
Returns marker for skipping the subtree at the current node.

### Method
static function

### Signature
`static function skipNode(): GraphQL\Language\VisitorSkipNode`

### Return Value
- **GraphQL\Language\VisitorSkipNode** - A marker object to skip the current node's subtree.

### Example
```php
Visitor::visit($ast, [
    'enter' => function (Node $node) {
        return Visitor::skipNode();
    }
]);
```
```

--------------------------------

### SDL multiple interfaces before change

Source: https://github.com/webonyx/graphql-php/blob/master/UPGRADE.md

Shows the old SDL syntax for implementing multiple interfaces using commas.

```graphql
type Foo implements Bar, Baz {
  field: Type
}
```

--------------------------------

### StandardServer::__construct signature

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Constructor for StandardServer. Accepts either a ServerConfig instance or an array of configuration options. Throws InvariantViolation on invalid configuration.

```php
/**
 * @param ServerConfig|array<string, mixed> $config
 *
 * @api
 *
 * @throws InvariantViolation
 */
function __construct($config)
```

--------------------------------

### Generate class reference docs

Source: https://github.com/webonyx/graphql-php/blob/master/CONTRIBUTING.md

Generate the class reference documentation.

```sh
composer docs
```

--------------------------------

### SDL multiple interfaces after change

Source: https://github.com/webonyx/graphql-php/blob/master/UPGRADE.md

Shows the new SDL syntax for implementing multiple interfaces using ampersands.

```graphql
type Foo implements Bar & Baz {
  field: Type
}
```

--------------------------------

### SDL scalar with @specifiedBy directive

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/scalars.md

When building a schema from SDL, the @specifiedBy directive is parsed automatically. This example shows the SDL syntax for attaching a specification URL to a scalar.

```graphql
scalar UUID @specifiedBy(url: "https://tools.ietf.org/html/rfc4122")
```

--------------------------------

### Build a schema from a GraphQL file with BuildSchema::build()

Source: https://github.com/webonyx/graphql-php/blob/master/docs/schema-definition-language.md

Creates an executable schema instance from a schema.graphql file using BuildSchema::build(). The resulting schema has no resolvers by default and relies on the default field resolver and root value.

```php
use GraphQL\Utils\BuildSchema;

$contents = file_get_contents('schema.graphql');
$schema = BuildSchema::build($contents);
```

--------------------------------

### GraphQL\Language\Visitor::visit method signature

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Method signature for GraphQL\Language\Visitor::visit(). Accepts the AST root, a visitor array, and an optional keyMap. Throws \Exception.

```php
/**
 * Visit the AST (see class description for details).
 *
 * @param NodeList<Node>|Node $root
 * @param VisitorArray $visitor
 * @param array<string, mixed>|null $keyMap
 *
 * @throws \Exception
 *
 * @return mixed
 *
 * @api
 */
static function visit(object $root, array $visitor, ?array $keyMap = null)
```

--------------------------------

### Add custom validation rule globally

Source: https://github.com/webonyx/graphql-php/blob/master/docs/executing-queries.md

Adds a custom validation rule globally to the standard set of rules. This example adds the DisableIntrospection rule, which will apply to all query validations.

```php
use GraphQL\Validator\Rules;
use GraphQL\Validator\DocumentValidator;

// Add to standard set of rules globally:
DocumentValidator::addRule(new Rules\DisableIntrospection());
```

--------------------------------

### Using @include directive in a GraphQL query

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/directives.md

Example query using the built-in @include directive. If the $withFriends variable is false, the friends field is excluded from the response and never executed.

```graphql
query Hero($episode: Episode, $withFriends: Boolean!) {
  hero(episode: $episode) {
    name
    friends @include(if: $withFriends) {
      name
    }
  }
}
```

--------------------------------

### Create schema with SchemaConfig instance

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Creates a schema using a SchemaConfig instance, setting query and mutation root types before passing the config to the Schema constructor.

```php
$config = GraphQL\Type\SchemaConfig::create()
    ->setQuery($MyAppQueryRootType)
    ->setMutation($MyAppMutationRootType);

$schema = new GraphQL\Type\Schema($config);
```

--------------------------------

### Enable query batching with StandardServer

Source: https://github.com/webonyx/graphql-php/blob/master/docs/executing-queries.md

Enables query batching on the StandardServer by passing the 'queryBatching' option set to true in the server configuration array.

```php
use GraphQL\Server\StandardServer;

$server = new StandardServer([
    'queryBatching' => true
]);
```

--------------------------------

### SchemaConfig::create

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static factory method to create a SchemaConfig instance from an array of options.

```APIDOC
## SchemaConfig::create

### Description
Creates a new SchemaConfig instance from an array of options. If no options are provided, returns an empty config.

### Method
static function create(array $options = []): self

### Parameters
- **$options** (array) - Optional - Schema configuration options array.

### Return Value
- SchemaConfig instance.

### Example
```php
$config = SchemaConfig::create([
    'query' => $myQueryType,
    'typeLoader' => $myTypeLoader,
]);
```
```

--------------------------------

### StandardServer basic usage with handleRequest()

Source: https://github.com/webonyx/graphql-php/blob/master/docs/executing-queries.md

Basic usage of the StandardServer with plain PHP. It parses PHP globals and emits a response.

```php
use GraphQL\Server\StandardServer;

$server = new StandardServer([/* server options, see below */]);
$server->handleRequest(); // parses PHP globals and emits response
```

--------------------------------

### GraphQL query with variable filters and JSON variable

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/inputs.md

Shows a GraphQL query using a variable for filters and the corresponding JSON variable definition. The query and JSON are part of the same example: the query declares the variable, and the JSON provides its value.

```graphql
query ($filters: StoryFiltersInput!) {
  stories(filters: $filters) {
    ...
  }
}
```

```json
{
  "filters": {
    "author": "1",
    "popular": false
  }
}
```

--------------------------------

### Create schema with array config

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Creates a schema by passing an array with 'query' and 'mutation' root types to the Schema constructor.

```php
$schema = new GraphQL\Type\Schema([
  'query' => $MyAppQueryRootType,
  'mutation' => $MyAppMutationRootType,
]);
```

--------------------------------

### StandardServer with PSR-7 request/response

Source: https://github.com/webonyx/graphql-php/blob/master/docs/executing-queries.md

Shows how to use the StandardServer with PSR-7 request/response interfaces. It demonstrates both processPsrRequest() and an alternative approach using executePsrRequest() and manual JSON encoding.

```php
use GraphQL\Server\StandardServer;
use GraphQL\Executor\ExecutionResult;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;

/** @var RequestInterface $psrRequest */
/** @var ResponseInterface $psrResponse */
/** @var StreamInterface $psrBodyStream */
$server = new StandardServer([/* server options, see below */]);
$psrResponse = $server->processPsrRequest($psrRequest, $psrResponse, $psrBodyStream);


// Alternatively create PSR-7 response yourself:

/** @var ExecutionResult|ExecutionResult[] $result */
$result = $server->executePsrRequest($psrRequest);
$jsonResult = json_encode($result, JSON_THROW_ON_ERROR);
$psrResponse = new SomePsr7ResponseImplementation($jsonResult );
```

--------------------------------

### Covariant return types for interface fields

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/interfaces.md

Example of covariant return types for interface fields, where an implementing object type may change the field type to a more specific type. Here, type B implements interface A and changes field1 from A to B.

```graphql
interface A {
  field1: A
}

type B implements A {
  field1: B
}
```

--------------------------------

### Define an InputObjectType with fields

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/inputs.md

Creates an InputObjectType named 'StoryFiltersInput' with three fields: author (ID), popular (Boolean), and tags (list of strings). Each field includes a description for documentation. This example demonstrates the basic structure for defining input object types in graphql-php.

```php
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\InputObjectType;

$filters = new InputObjectType([
    'name' => 'StoryFiltersInput',
    'fields' => [
        'author' => [
            'type' => Type::id(),
            'description' => 'Only show stories with this author id'
        ],
        'popular' => [
            'type' => Type::boolean(),
            'description' => 'Only show popular stories (liked by several people)'
        ],
        'tags' => [
            'type' => Type::listOf(Type::string()),
            'description' => 'Only show stories which contain all of those tags'
        ]
    ]
]);
```

--------------------------------

### Batched query request body

Source: https://github.com/webonyx/graphql-php/blob/master/docs/executing-queries.md

Example of a batched query request body. Each element is a separate GraphQL query. When using the Server with query batching enabled, deferred resolvers are not isolated, so this batch can be resolved with a single database request if the user field is deferred.

```json
[
  {
    "query": "{user(id: 1) { id }}"
  },
  {
    "query": "{user(id: 2) { id }}"
  },
  {
    "query": "{user(id: 3) { id }}"
  }
]
```

--------------------------------

### Configure GraphQL server with ServerConfig

Source: https://github.com/webonyx/graphql-php/blob/master/docs/executing-queries.md

Use this snippet to configure a GraphQL server with a fluid interface, providing IDE autocomplete and static time validation. It sets the schema, a custom error formatter, and a debug flag before creating a StandardServer instance.

```php
use GraphQL\Server\ServerConfig;
use GraphQL\Server\StandardServer;

$config = ServerConfig::create()
    ->setSchema($schema)
    ->setErrorFormatter($myFormatter)
    ->setDebugFlag($debug)
;

$server = new StandardServer($config);
```

--------------------------------

### GraphQL query causing N+1 problem

Source: https://github.com/webonyx/graphql-php/blob/master/docs/data-fetching.md

Example GraphQL query that triggers the N+1 problem: fetching 10 stories and their authors would naively require up to 10 separate data store calls. This query is used to illustrate the need for deferred resolution.

```graphql
{
  topStories(limit: 10) {
    title
    author {
      name
      email
    }
  }
}
```

--------------------------------

### Run static analysis

Source: https://github.com/webonyx/graphql-php/blob/master/CONTRIBUTING.md

Execute PHPStan to validate code correctness.

```sh
composer stan
```

--------------------------------

### PHP: Define Object Types with ObjectType constructor

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/object-types.md

Use this snippet to define object types in graphql-php using the inline style. It creates a User type with string fields and a Story type with a body field, an author field with a resolve function, and a likes field with arguments and a resolve function. The example demonstrates how to configure field types, descriptions, arguments, and resolvers.

```php
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;
use GraphQL\Examples\Blog\Data\DataSource;
use GraphQL\Examples\Blog\Data\Story;

$userType = new ObjectType([
    'name' => 'User',
    'description' => 'Our blog visitor',
    'fields' => [
        'firstName' => [
            'type' => Type::string(),
            'description' => 'User first name'
        ],
        'email' => Type::string()
    ]
]);

$blogStory = new ObjectType([
    'name' => 'Story',
    'fields' => [
        'body' => Type::string(),
        'author' => [
            'type' => $userType,
            'description' => 'Story author',
            'resolve' => fn (Story $blogStory): ?User => DataSource::findUser($blogStory->authorId),
        ],
        'likes' => [
            'type' => Type::listOf($userType),
            'description' => 'List of users who liked the story',
            'args' => [
                'limit' => [
                    'type' => Type::int(),
                    'description' => 'Limit the number of recent likes returned',
                    'defaultValue' => 10
                ]
            ],
            'resolve' => fn (Story $blogStory, array $args): array => DataSource::findLikes($blogStory->id, $args['limit']),
        ]
    ]
]);
```

--------------------------------

### New: String and block string descriptions

Source: https://github.com/webonyx/graphql-php/blob/master/UPGRADE.md

New way to define descriptions using strings or block strings in the GraphQL language. This is the official method now.

```graphql
"Description"
type Dog {
  ...
}

"""
Long Description
"""
type Dog {
  ...
}
```

--------------------------------

### StandardServer::__construct

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Constructor for the StandardServer class.

```APIDOC
## StandardServer::__construct

### Description
Creates a new StandardServer instance with the provided configuration.

### Method
__construct

### Parameters
- **$config** (ServerConfig|array<string, mixed>) - Required - Server configuration, either a ServerConfig instance or an array of configuration options.

### Exceptions
- InvariantViolation

```

--------------------------------

### Create the GraphQL endpoint (graphql.php)

Source: https://github.com/webonyx/graphql-php/blob/master/docs/getting-started.md

This PHP script creates a GraphQL endpoint. It builds a schema, reads the raw input, executes the query, and returns the JSON response. It also handles exceptions by returning an error array.

```php
use GraphQL\GraphQL;
use GraphQL\Type\Schema;

$schema = new Schema([
    'query' => $queryType
]);

$rawInput = file_get_contents('php://input');
$input = json_decode($rawInput, true);
$query = $input['query'];
$variableValues = isset($input['variables']) ? $input['variables'] : null;

try {
    $rootValue = ['prefix' => 'You said: '];
    $result = GraphQL::executeQuery($schema, $query, $rootValue, null, $variableValues);
    $output = $result->toArray();
} catch (\Exception $e) {
    $output = [
        'errors' => [
            [
                'message' => $e->getMessage()
            ]
        ]
    ];
}
header('Content-Type: application/json');
echo json_encode($output, JSON_THROW_ON_ERROR);
```

--------------------------------

### Migrate adapter from AmpPromiseAdapter to AmpFutureAdapter

Source: https://github.com/webonyx/graphql-php/blob/master/examples/04-async-php/amphp-v3/event-loop/README.md

Shows the migration from AmpPromiseAdapter (AMPHP v2) to AmpFutureAdapter (AMPHP v3).

```php
// Before (amphp/amp ^2)
use GraphQL\Executor\Promise\Adapter\AmpPromiseAdapter;
$adapter = new AmpPromiseAdapter();

// After (amphp/amp ^3)
use GraphQL\Executor\Promise\Adapter\AmpFutureAdapter;
$adapter = new AmpFutureAdapter();
```

--------------------------------

### create

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Creates a new promise using a resolver function.

```APIDOC
## create

### Description
Creates a Promise from a resolver callable that provides resolve and reject functions.

### Method
create

### Signature
```php
function create(callable $resolver): GraphQL\Executor\Promise\Promise
```

### Parameters
- **$resolver** (callable) - Required - A callable receiving `$resolve` and `$reject` callbacks.

### Return Value
- **GraphQL\Executor\Promise\Promise** - The created promise.
```

--------------------------------

### Create schema with SchemaConfig

Source: https://github.com/webonyx/graphql-php/blob/master/docs/schema-definition.md

Use this snippet to create a schema with a fluid interface, enabling IDE auto-completion and static time validation. It sets the query type and a type loader via SchemaConfig, then passes the config to the Schema constructor.

```php
use GraphQL\Type\SchemaConfig;
use GraphQL\Type\Schema;

$config = SchemaConfig::create()
    ->setQuery($myQueryType)
    ->setTypeLoader($myTypeLoader);

$schema = new Schema($config);
```

--------------------------------

### Enable experimental CoroutineExecutor

Source: https://github.com/webonyx/graphql-php/blob/master/UPGRADE.md

Enables the experimental CoroutineExecutor by setting it as the implementation factory. This is disabled by default.

```php
use GraphQL\Executor\Executor;
use GraphQL\Experimental\Executor\CoroutineExecutor;

Executor::setImplementationFactory([CoroutineExecutor::class, 'create']);
```

--------------------------------

### SchemaConfig::create()

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static factory method that creates a SchemaConfig from an options array, or returns an empty config if no array is passed. Throws InvariantViolation on invalid options.

```php
/**
 * Converts an array of options to instance of SchemaConfig
 * (or just returns empty config when array is not passed).
 *
 * @phpstan-param SchemaConfigOptions $options
 *
 * @throws InvariantViolation
 *
 * @api
 */
static function create(array $options = []): self
```

--------------------------------

### Traverse and edit AST with Visitor::visit enter/leave

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Basic usage of GraphQL\Language\Visitor::visit() with generic enter and leave callbacks. The original AST is not modified; a new edited AST is returned.

```php
$editedAST = Visitor::visit($ast, [
    'enter' => function (Node $node, $key, $parent, array $path, array $ancestors) {
        // ...
    },
    'leave' => function (Node $node, $key, $parent, array $path, array $ancestors) {
        // ...
    }
]);
```

--------------------------------

### Try mutation with curl

Source: https://github.com/webonyx/graphql-php/blob/master/examples/00-hello-world/README.md

Sends a GraphQL mutation to the local server to sum two numbers.

```bash
curl --data '{"query": "mutation { sum(x: 2, y: 2) }" }' --header "Content-Type: application/json" http://localhost:8080
```

--------------------------------

### Try query with curl

Source: https://github.com/webonyx/graphql-php/blob/master/examples/00-hello-world/README.md

Sends a GraphQL query to the local server to echo a message.

```bash
curl --data '{"query": "query { echo(message: \"Hello World\") }" }' --header "Content-Type: application/json" http://localhost:8080
```

--------------------------------

### Generic enter/leave visitors for any node

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Generic visitors that trigger upon entering and leaving any node in the AST.

```php
Visitor::visit($ast, [
    'enter' => function (Node $node) {
        // enter any node
    },
    'leave' => function (Node $node) {
        // leave any node
    }
]);
```

--------------------------------

### Enable legacy SDL interfaces option

Source: https://github.com/webonyx/graphql-php/blob/master/UPGRADE.md

Uses the 'allowLegacySDLImplementsInterfaces' parser option to allow the legacy comma-separated interface syntax during migration.

```php
Parser::parse($source, [ 'allowLegacySDLImplementsInterfaces' => true])
```

--------------------------------

### Before: operation key in standard server request

Source: https://github.com/webonyx/graphql-php/blob/master/UPGRADE.md

Before the change, the standard server expected the key 'operation' for multi-op queries.

```json
{
  "queryId": "persisted-query-id",
  "operation": "QueryFromPersistedDocument",
  "variables": {}
}
```

--------------------------------

### Executor::promiseToExecute()

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static method to execute a GraphQL document asynchronously using a promise adapter.

```APIDOC
## [STATIC] Executor::promiseToExecute()

### Description
Same as execute(), but requires a promise adapter and returns a promise that is always fulfilled with an ExecutionResult and never rejected. Useful for async PHP platforms.

### Method
static function

### Signature
```php
static function promiseToExecute(
    GraphQL\Executor\Promise\PromiseAdapter $promiseAdapter,
    GraphQL\Type\Schema $schema,
    GraphQL\Language\AST\DocumentNode $documentNode,
    $rootValue = null,
    $contextValue = null,
    ?array $variableValues = null,
    ?string $operationName = null,
    ?callable $fieldResolver = null,
    ?callable $argsMapper = null
): GraphQL\Executor\Promise\Promise
```

### Parameters
- **$promiseAdapter** (GraphQL\Executor\Promise\PromiseAdapter) - Required - The promise adapter to use for async execution.
- **$schema** (GraphQL\Type\Schema) - Required - The GraphQL schema against which to execute the document.
- **$documentNode** (GraphQL\Language\AST\DocumentNode) - Required - The parsed GraphQL document to execute.
- **$rootValue** (mixed) - Optional - The root value passed to resolvers.
- **$contextValue** (mixed) - Optional - The context value passed to resolvers.
- **$variableValues** (array<string, mixed>|null) - Optional - A map of variable values for the operation.
- **$operationName** (string|null) - Optional - The name of the operation to execute if multiple are present.
- **$fieldResolver** (callable|null) - Optional - A custom field resolver function.
- **$argsMapper** (callable|null) - Optional - A custom arguments mapper function.

### Return Value
- **GraphQL\Executor\Promise\Promise** - A promise that resolves to an ExecutionResult.

### Example
```php
$promise = Executor::promiseToExecute($promiseAdapter, $schema, $documentNode, $rootValue, $contextValue, $variableValues, $operationName);
```
```

--------------------------------

### BuildSchema::buildAST

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static method to build a GraphQL schema from an AST document node.

```APIDOC
## BuildSchema::buildAST

### Description
Builds a GraphQLSchema from an AST document node. If no schema definition is provided, it looks for types named Query and Mutation. The resulting schema has no resolve methods, so execution will use default resolvers.

### Method
static function buildAST

### Signature
```php
static function buildAST(
    GraphQL\Language\AST\DocumentNode $ast,
    ?callable $typeConfigDecorator = null,
    array $options = [],
    ?callable $fieldConfigDecorator = null
): GraphQL\Type\Schema
```

### Parameters
- **$ast** (GraphQL\Language\AST\DocumentNode) - Required - The AST of the schema from the parser.
- **$typeConfigDecorator** (callable|null) - Optional - A decorator for type configuration.
- **$options** (array<string, bool>) - Optional - Build options. Possible keys: `assumeValid` (bool, default false), `assumeValidSDL` (bool, default false).
- **$fieldConfigDecorator** (callable|null) - Optional - A decorator for field configuration.

### Return Value
- **GraphQL\Type\Schema** - The constructed schema.

### Throws
- \Exception
- \ReflectionException
- Error
- InvariantViolation

### Example
```php
$ast = Parser::parse($sdl);
$schema = BuildSchema::buildAST($ast);
```
```

--------------------------------

### InputObjectType Constructor

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/inputs.md

Documentation for creating Input Object Types in graphql-php, including constructor configuration and field options.

```APIDOC
## InputObjectType Constructor

### Description
Creates a new Input Object Type instance with the provided configuration.

### Method
Constructor

### Endpoint
`new InputObjectType(array $config)`

### Parameters
#### Configuration Array
- **name** (string) - Required - Unique name of this object type within Schema
- **description** (string) - Optional - Plain-text description of this type for clients
- **isOneOf** (bool) - Optional - Indicates that an Input Object is a OneOf Input Object (requires exactly one field)
- **parseValue** (callable) - Optional - Converts incoming values from array representation to something else
- **fields** (iterable|callable) - Required - An iterable describing object fields or callable returning such an iterable

### Field Configuration
Each entry in `fields` is an array with the following options:
- **name** (string) - Optional - Name of the input field (inferred from array key if not set)
- **type** (Type) - Required - Instance of an input type (Scalar, Enum, InputObjectType, or combinations with nonNull and listOf)
- **defaultValue** (scalar) - Optional - Default value of this input field
- **description** (string) - Optional - Plain-text description of this input field
- **deprecationReason** (string) - Optional - Reason for deprecating this input field

### Request Example
```php
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\InputObjectType;

$filters = new InputObjectType([
    'name' => 'StoryFiltersInput',
    'fields' => [
        'author' => [
            'type' => Type::id(),
            'description' => 'Only show stories with this author id'
        ],
        'popular' => [
            'type' => Type::boolean(),
            'description' => 'Only show popular stories (liked by several people)'
        ],
        'tags' => [
            'type' => Type::listOf(Type::string()),
            'description' => 'Only show stories which contain all of those tags'
        ]
    ]
]);
```

### Response
No return value (constructor). The created instance represents the Input Object Type definition.
```

--------------------------------

### BuildSchema::build

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Static method to build a GraphQL schema from a source document.

```APIDOC
## BuildSchema::build

### Description
Builds a GraphQLSchema directly from a source document (string, Source, or parsed AST). This is a static helper method.

### Method
static function build

### Signature
```php
static function build(
    $source,
    ?callable $typeConfigDecorator = null,
    array $options = [],
    ?callable $fieldConfigDecorator = null
): GraphQL\Type\Schema
```

### Parameters
- **$source** (DocumentNode|Source|string) - Required - The source document to build the schema from.
- **$typeConfigDecorator** (callable|null) - Optional - A decorator for type configuration.
- **$options** (array<string, bool>) - Optional - Build options. Possible keys: `assumeValid` (bool, default false), `assumeValidSDL` (bool, default false).
- **$fieldConfigDecorator** (callable|null) - Optional - A decorator for field configuration.

### Return Value
- **GraphQL\Type\Schema** - The constructed schema.

### Throws
- \Exception
- \ReflectionException
- Error
- InvariantViolation
- SyntaxError

### Example
```php
$schema = BuildSchema::build($source);
```
```

--------------------------------

### Create a GraphQL schema with GraphQL\Type\Schema

Source: https://github.com/webonyx/graphql-php/blob/master/docs/schema-definition.md

Creates a GraphQL schema instance with the required query type and optional mutation type. The constructor accepts an array with 'query' and 'mutation' keys.

```php
use GraphQL\Type\Schema;

$schema = new Schema([
    'query' => $queryType,
    'mutation' => $mutationType,
]);
```

--------------------------------

### Execute query asynchronously with GraphQL::promiseToExecute

Source: https://github.com/webonyx/graphql-php/blob/master/docs/data-fetching.md

Switch from executeQuery to promiseToExecute to enable async field resolution. Requires a Promise A+ compatible adapter and that resolve functions return promises instead of GraphQL\Deferred.

```php
use GraphQL\GraphQL;
use GraphQL\Executor\ExecutionResult;

$promise = GraphQL::promiseToExecute(
    $promiseAdapter,
    $schema,
    $queryString,
    $rootValue = null,
    $contextValue = null,
    $variableValues = null,
    $operationName = null,
    $fieldResolver = null,
    $validationRules = null
);
$promise->then(fn (ExecutionResult $result): array => $result->toArray());
```

--------------------------------

### Schema constructor

Source: https://github.com/webonyx/graphql-php/blob/master/docs/class-reference.md

Constructor for the Schema class. Accepts either a SchemaConfig instance or an array of configuration options. Throws InvariantViolation on invalid configuration.

```php
/**
 * @param SchemaConfig|array<string, mixed> $config
 *
 * @phpstan-param SchemaConfig|SchemaConfigOptions $config
 *
 * @throws InvariantViolation
 *
 * @api
 */
function __construct($config)
```

--------------------------------

### Full form with name and type keys

Source: https://github.com/webonyx/graphql-php/blob/master/docs/type-definitions/object-types.md

Shows the full form of field definitions, where each field is an array with 'name' and 'type' keys. This is the most explicit way to define fields.

```php
'fields' => [
    ['name' => 'id', 'type' => Type::id()],
    ['name' => 'fieldName', 'type' => $fieldName]
]
```

--------------------------------

### Apply automatic code style fixes

Source: https://github.com/webonyx/graphql-php/blob/master/CONTRIBUTING.md

Run php-cs-fixer to automatically fix code style issues.

```sh
composer fix
```
Tokens:
Raw