GraphQLite

https://github.com/thecodingmachine/graphqlite
Admin
GraphQLite is a GraphQL library for PHP that allows you to use PHP attributes or annotations to...
Tokens:32,304
Snippets:427
Trust Score:7.8
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize and Run Server

Source: https://github.com/thecodingmachine/graphqlite/blob/master/examples/no-framework/README.md

Install project dependencies via Composer and start the built-in PHP development server.

```bash
composer install
php -S 127.0.0.1:8080
```

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

### Install Porpaginas library

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/pagination.mdx

Install the required dependency via Composer to enable pagination support.

```bash
$ composer require beberlei/porpaginas
```

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

### Install GraphQL upload package

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/file-uploads.mdx

Install the required dependency via Composer.

```console
$ composer require ecodev/graphql-upload
```

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

### Install GraphQLite-Laravel package

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package.md

Run this command in your project terminal to install the package via Composer.

```console
$ composer require thecodingmachine/graphqlite-laravel
```

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

### Install GraphQLite Universal Service Provider

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/universal-service-providers.md

Command to install the universal service provider package via Composer.

```console
$ composer require thecodingmachine/graphqlite-universal-service-provider
```

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

### Bootstrap GraphQLite with Service Providers

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/universal-service-providers.md

Example of initializing the container and retrieving the Schema or PSR-15 middleware.

```php
<?php
use Simplex\
Container;
use TheCodingMachine\GraphQLite\Http\Psr15GraphQLMiddlewareBuilder;
use TheCodingMachine\GraphQLite\Schema;
use TheCodingMachine\SymfonyCacheServiceProvider;
use TheCodingMachine\DoctrineAnnotationsServiceProvider;
use TheCodingMachine\GraphQLiteServiceProvider;

$container = new Container([
    new SymfonyCacheServiceProvider(),
    new DoctrineAnnotationsServiceProvider,
    new GraphQLiteServiceProvider()]);
$container->set('graphqlite.namespace.types', ['App\\Types']);
$container->set('graphqlite.namespace.controllers', ['App\\Controllers']);

$schema = $container->get(Schema::class);

// or if you want the PSR-15 middleware:

$middleware = $container->get(Psr15GraphQLMiddlewareBuilder::class);
```

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

### Configure composer.json for Service Provider

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/universal-service-providers.md

Example dependencies configuration for a project using the universal service provider.

```json
{
  "require": {
    "mnapoli/simplex": "^0.5",
    "thecodingmachine/graphqlite-universal-service-provider": "^3",
    "thecodingmachine/symfony-cache-universal-module": "^1"
  },
  "minimum-stability": "dev",
  "prefer-stable": true
}
```

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

### Define project dependencies in composer.json

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Required packages for the GraphQLite integration example.

```json
{
  "autoload": {
    "psr-4": {
      "App\\": "src/"
    }
  },
  "require": {
    "thecodingmachine/graphqlite": "^4",
    "laminas/laminas-diactoros": "^2",
    "laminas/laminas-stratigility": "^3",
    "laminas/laminas-httphandlerrunner": "^2",
    "mouf/picotainer": "^1.1",
    "symfony/cache": "^4.2"
  },
  "minimum-stability": "dev",
  "prefer-stable": true
}
```

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

### Execute login mutation

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle-advanced.mdx

Example of the login mutation to authenticate a user.

```graphql
mutation login {
  login(userName:"foo", password:"bar") {
    userName
    roles
  }
}
```

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

### Install GraphQL Playground

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package.md

Use Composer to add the GraphQL Playground package to your Laravel project.

```console
$ composer require mll-lab/laravel-graphql-playground
```

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

### Execute a GraphQL query

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/README.mdx

Example of a GraphQL query targeting the product field defined in the controller.

```graphql
{
  product(id: 42) {
    name
  }
}
```

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

### Execute basic GraphQL query

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/operation-complexity.md

A standard query example demonstrating how the complexity multiplier is applied to the books field.

```graphql
query {
    books {
        title
    }
}
```

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

### Install GraphQLite bundle via Composer

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle.md

Run this command in your project directory to add the GraphQLite bundle dependency.

```console
$ composer require thecodingmachine/graphqlite-bundle
```

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

### Configure the PSR-11 container

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Setup the container to provide the MiddlewarePipe, GraphQL middleware, cache, and schema factory.

```php
<?php

use GraphQL\Type\Schema;
use Mouf\Picotainer\Picotainer;
use Psr\Container\ContainerInterface;
use Psr\SimpleCache\CacheInterface;
use Symfony\Component\Cache\Simple\ApcuCache;
use TheCodingMachine\GraphQLite\Http\Psr15GraphQLMiddlewareBuilder;
use TheCodingMachine\GraphQLite\SchemaFactory;
use Laminas\Stratigility\MiddlewarePipe;

// Picotainer is a minimalist PSR-11 container.
return new Picotainer([
    MiddlewarePipe::class => function(ContainerInterface $container) {
        $pipe = new MiddlewarePipe();
        $pipe->pipe($container->get(WebonyxGraphqlMiddleware::class));
        return $pipe;
    },
    // The WebonyxGraphqlMiddleware is a PSR-15 compatible
    // middleware that exposes Webonyx schemas.
    WebonyxGraphqlMiddleware::class => function(ContainerInterface $container) {
        $builder = new Psr15GraphQLMiddlewareBuilder($container->get(Schema::class));
        return $builder->createMiddleware();
    },
    CacheInterface::class => function() {
        // Any PSR-16 cache should work - APCu is recommended for good
        // performance, but it requires that module to be enabled. For
        // small scale testing with zero dependencies, FilesystemCache
        // can be used instead.
        return new ApcuCache();
    },
    Schema::class => function(ContainerInterface $container) {
        // The magic happens here. We create a schema using GraphQLite SchemaFactory.
        $factory = new SchemaFactory($container->get(CacheInterface::class), $container);
        $factory->addNamespace('App');
        return $factory->createSchema();
    }
]);
```

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

### Calculate query complexity

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/operation-complexity.md

Examples of GraphQL queries used to demonstrate static complexity calculation.

```graphql
query {
    books {
        title
    }
}
```

```graphql
query {
    books {
        title
        author {
            name
        }
    }
}
```

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

### Service-based translation logic

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/extend-type.mdx

Example of retrieving a product name via a translation service.

```php
// You need to use a service to get the name of the product in the correct language.
$name = $translationService->getProductName($productId, $language);
```

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

### Execute a GraphQL Mutation

Source: https://github.com/thecodingmachine/graphqlite/blob/master/README.md

Example query to invoke the defined mutation.

```graphql
{
  updateProduct(product: {
    name: 'John Doe'
  }) {
    name
  }
}
```

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

### Implement Custom RootTypeMapper

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/custom-types.mdx

Example implementation of a type mapper that delegates to the next mapper in the chain.

```php
class AnyScalarTypeMapper implements RootTypeMapperInterface
{
    /** @var RootTypeMapperInterface */
    private $next;

    public function __construct(RootTypeMapperInterface $next)
    {
        $this->next = $next;
    }

    public function toGraphQLOutputType(Type $type, ?OutputType $subType, ReflectionMethod $refMethod, DocBlock $docBlockObj): ?OutputType
    {
        if ($type instanceof Scalar) {
            // AnyScalarType is a class implementing the Webonyx ScalarType type.
            return AnyScalarType::getInstance();
        }
        // If the PHPDoc type is not "Scalar", let's pass the control to the next type mapper in the chain
        return $this->next->toGraphQLOutputType($type, $subType, $refMethod, $docBlockObj);
    }

    public function toGraphQLInputType(Type $type, ?InputType $subType, string $argumentName, ReflectionMethod $refMethod, DocBlock $docBlockObj): ?InputType
    {
        if ($type instanceof Scalar) {
            // AnyScalarType is a class implementing the Webonyx ScalarType type.
            return AnyScalarType::getInstance();
        }
        // If the PHPDoc type is not "Scalar", let's pass the control to the next type mapper in the chain
        return $this->next->toGraphQLInputType($type, $subType, $argumentName, $refMethod, $docBlockObj);
    }

    /**
     * Returns a GraphQL type by name.
     * If this root type mapper can return this type in "toGraphQLOutputType" or "toGraphQLInputType", it should
     * also map these types by name in the "mapNameToType" method.
     *
     * @param string $typeName The name of the GraphQL type
     * @return NamedType|null
     */
    public function mapNameToType(string $typeName): ?NamedType
    {
        if ($typeName === AnyScalarType::NAME) {
            return AnyScalarType::getInstance();
        }
        return null;
    }
}
```

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

### Query Paginated Results in GraphQL

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package-advanced.mdx

Example of the GraphQL structure returned when using a paginator.

```graphql
products {
    items {      # The items for the selected page
        id
        name
    }
    totalCount   # The total count of items.
    lastPage     # Get the page number of the last available page.
    firstItem    # Get the "index" of the first item being paginated.
    lastItem     # Get the "index" of the last item being paginated.
    hasMorePages # Determine if there are more items in the data source.
    perPage      # Get the number of items shown per page.
    hasPages     # Determine if there are enough items to split into multiple pages.
    currentPage  # Determine the current page being paginated.
    isEmpty      # Determine if the list of items is empty or not.
    isNotEmpty   # Determine if the list of items is not empty.
}
```

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

### Define GraphQL schema types

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/operation-complexity.md

Example schema definition showing Query and Type structures for books and authors.

```graphql
type Query {
    books(take: Int = 10): [Book]
}

type Book {
    title
    author: Author
}

type Author {
    name
}
```

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

### Install Altair GraphQL Client

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package.md

Use Composer to add the Altair GraphQL client package to your Laravel project.

```console
$ composer require xkojimedia/laravel-altair-graphql
```

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

### Querying with Factory-generated Input

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/input-types.mdx

Example of a GraphQL query utilizing the input type generated by the factory.

```graphql
query {
  getCities(location: {
              latitude: 45.0,
              longitude: 0.0,
            },
            radius: 42)
  {
    id,
    name
  }
}
```

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

### Define a controller method with a custom object parameter

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/input-types.mdx

Initial setup showing a controller method expecting a Location object, which triggers a mapping error without proper configuration.

```php
class MyController
{
    /**
     * @return City[]
     */
    #[Query]
    public function getCities(Location $location, float $radius): array
    {
        // Some code that returns an array of cities.
    }
}

// Class Location is a simple value-object.
class Location
{
    private $latitude;
    private $longitude;

    public function __construct(float $latitude, float $longitude)
    {
        $this->latitude = $latitude;
        $this->longitude = $longitude;
    }

    public function getLatitude(): float
    {
        return $this->latitude;
    }

    public function getLongitude(): float
    {
        return $this->longitude;
    }
}
```

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

### Install Symfony validator bridge

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/validation.mdx

Command to add the bridge package to a project using Composer.

```bash
$ composer require thecodingmachine/graphqlite-symfony-validator-bridge
```

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

### Injecting ResolveInfo in a Query

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/argument-resolving.md

Example of using a parameter middleware to automatically inject the Webonyx ResolveInfo object into a query method.

```php
/**
 * @return Product[]
 */
#[Query]
public function products(ResolveInfo $info): array
```

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

### GraphQL fragment usage

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/inheritance-interfaces.mdx

Example of using fragments to access fields specific to the User type when querying a Contact.

```graphql
contact {
    name
    ... User {
       email
    }
}
```

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

### Setup Apollo client with CSRF support

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package.md

Configure an Apollo client to extract the XSRF-TOKEN from cookies and include it in the X-CSRF-TOKEN header for every request.

```js
import { ApolloClient, ApolloLink, InMemoryCache, HttpLink } from 'apollo-boost';

const httpLink = new HttpLink({ uri: 'https://api.example.com/graphql' });

const authLink = new ApolloLink((operation, forward) => {
  // Retrieve the authorization token from local storage.
  const token = localStorage.getItem('auth_token');

  // Get the XSRF-TOKEN that is set by Laravel on each request
  var cookieValue = document.cookie.replace(/(?:(?:^|.*;\s*)XSRF-TOKEN\s*\=\s*([^;]*).*$)|^.*$/, "$1");

  // Use the setContext method to set the X-CSRF-TOKEN header back.
  operation.setContext({
    headers: {
      'X-CSRF-TOKEN': cookieValue
    }
  });

  // Call the next link in the middleware chain.
  return forward(operation);
});

const client = new ApolloClient({
  link: authLink.concat(httpLink), // Chain it with the HttpLink
  cache: new InMemoryCache()
});
```

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

### GraphQL N+1 Query Example

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/prefetch-method.mdx

A standard GraphQL query structure that often triggers the N+1 problem when fetching related entities.

```graphql
{
    posts {
        id
        user {
            id
        }
    }
}
```

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

### Initialize GraphQLite without a framework

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Create a schema and execute queries manually using SchemaFactory and PSR-11/PSR-16 dependencies.

```php
<?php
use GraphQL\GraphQL;
use GraphQL\Type\Schema;
use TheCodingMachine\GraphQLite\SchemaFactory;
use TheCodingMachine\GraphQLite\Context\Context;

// $cache is a PSR-16 compatible cache.
// $container is a PSR-11 compatible container.
$factory = new SchemaFactory($cache, $container);
$factory->addNamespace('App');

$schema = $factory->createSchema();

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

$result = GraphQL::executeQuery($schema, $query, null, new Context(), $variableValues);
$output = $result->toArray();

header('Content-Type: application/json');
echo json_encode($output);
```

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

### Enable GraphQL routes

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle.md

Import the GraphQLite bundle routes in your configuration file.

```yaml
# Add these 2 lines to config/routes.yaml
graphqlite_bundle:
  resource: '@GraphQLiteBundle/Resources/config/routes.xml'
```

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

### Initialize the GraphQL Schema

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Create a schema instance using the SchemaFactory, requiring a PSR-16 cache and PSR-11 container.

```php
use TheCodingMachine\GraphQLite\SchemaFactory;

// $cache is a PSR-16 compatible cache
// $container is a PSR-11 compatible container
$factory = new SchemaFactory($cache, $container);
$factory->addNamespace('App');

$schema = $factory->createSchema();
```

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

### Publish configuration file

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package.md

Use this Artisan command to publish the package configuration file to your project.

```console
$ php artisan vendor:publish --provider="TheCodingMachine\GraphQLite\Laravel\Providers\GraphQLiteServiceProvider"
```

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

### Implement a parameter middleware

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/argument-resolving.md

Create a class implementing ParameterMiddlewareInterface to inspect parameters and delegate to a resolver if a specific attribute is found.

```php
class ContainerParameterHandler implements ParameterMiddlewareInterface
{
    /** @var ContainerInterface */
    private $container;

    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations, ParameterHandlerInterface $next): ParameterInterface
    {
        // The $parameterAnnotations object can be used to fetch any attribute implementing ParameterAnnotationInterface
        $autowire = $parameterAnnotations->getAnnotationByType(Autowire::class);

        if ($autowire === null) {
            // If there is no matching attribute, this middleware cannot handle the parameter. Let's ask
            // the next middleware in the chain (using the $next object)
            return $next->mapParameter($parameter, $docBlock, $paramTagType, $parameterAnnotations);
        }

        // We found a #[Autowire] attribute, let's return a parameter resolver.
        return new ContainerParameter($this->container, $parameter->getType());
    }
}
```

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

### Configure GraphQLite middleware

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package.md

Update the configuration file to switch from the default web middleware to the api middleware for server-to-server connections.

```php
<?php
return [
    'middleware' => ['api'],
    'guard' => ['api'],
];
```

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

### Example validation error response

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package-advanced.mdx

The JSON structure returned when validation rules fail during a GraphQL request.

```json
{
    "errors": [
        {
            "message": "The email must be a valid email address.",
            "extensions": {
                "argument": "email"
            }
        },
        {
            "message": "The password must be greater than or equal 8 characters.",
            "extensions": {
                "argument": "password"
            }
        }
    ]
}
```

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

### Implement type extension with dependency injection

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/extend-type.mdx

Use #[ExtendType] to create a service class that adds fields to the Product type.

```php
namespace App\Types;

use TheCodingMachine\GraphQLite\Annotations\ExtendType;
use TheCodingMachine\GraphQLite\Annotations\Field;
use App\Entities\Product;

#[ExtendType(class: Product::class)]
class ProductType
{
    private $translationService;

    public function __construct(TranslationServiceInterface $translationService)
    {
        $this->translationService = $translationService;
    }

    #[Field]
    public function getName(Product $product, string $language): string
    {
        return $this->translationService->getProductName($product->getId(), $language);
    }
}
```

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

### Initialize the Laminas RequestHandlerRunner

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Entry point for the application to handle incoming PSR-7 requests.

```php
<?php

use Laminas\Diactoros\Response;
use Laminas\Diactoros\ServerRequest;
use Laminas\Diactoros\ServerRequestFactory;
use Laminas\HttpHandlerRunner\Emitter\SapiStreamEmitter;
use Laminas\Stratigility\Middleware\ErrorResponseGenerator;
use Laminas\Stratigility\MiddlewarePipe;
use Laminas\Diactoros\Server;
use Laminas\HttpHandlerRunner\RequestHandlerRunner;

require_once __DIR__ . '/vendor/autoload.php';

$container = require 'config/container.php';

$serverRequestFactory = [ServerRequestFactory::class, 'fromGlobals'];

$errorResponseGenerator = function (Throwable $e) {
    $generator = new ErrorResponseGenerator();
    return $generator($e, new ServerRequest(), new Response());
};

$runner = new RequestHandlerRunner(
    $container->get(MiddlewarePipe::class),
    new SapiStreamEmitter(),
    $serverRequestFactory,
    $errorResponseGenerator
);
$runner->run();
```

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

### Define a standard Product class

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/multiple-output-types.mdx

The base PHP class mapped to the default GraphQL output type.

```php
#[Type]
class Product
{
    // ...

    #[Field]
    public function getName(): string
    {
        return $this->name;
    }

    #[Field]
    public function getPrice(): ?float
    {
        return $this->price;
    }
}
```

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

### Create a GraphQLite controller

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Define a controller with a query method annotated for GraphQL.

```php
namespace App\Controllers;

use TheCodingMachine\GraphQLite\Annotations\Query;

class MyController
{
    #[Query]
    public function hello(string $name): string
    {
        return 'Hello '.$name;
    }
}
```

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

### Validate user input in controller

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/validation.mdx

Example of using the ValidatorInterface to validate a domain object and throwing a ValidationFailedException within a mutation.

```php
use Symfony
Component\Validator\Validator\ValidatorInterface;
use TheCodingMachine\GraphQLite\Validator\ValidationFailedException

class UserController
{
    private $validator;

    public function __construct(ValidatorInterface $validator)
    {
        $this->validator = $validator;
    }

    #[Mutation]
    public function createUser(string $email, string $password): User
    {
        $user = new User($email, $password);

        // Let's validate the user
        $errors = $this->validator->validate($user);

        // Throw an appropriate GraphQL exception if validation errors are encountered
        ValidationFailedException::throwException($errors);

        // No errors? Let's continue and save the user
        // ...
    }
}
```

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

### Create PSR-15 GraphQL middleware

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Use Psr15GraphQLMiddlewareBuilder to generate a middleware instance for PSR-15 compatible frameworks.

```php
// $schema is an instance of the GraphQL schema returned by SchemaFactory::createSchema (see previous chapter)
$builder = new Psr15GraphQLMiddlewareBuilder($schema);

$middleware = $builder->createMiddleware();

// You can now inject your middleware in your favorite PSR-15 compatible framework.
// For instance:
$zendMiddlewarePipe->pipe($middleware);
```

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

### Configure GraphQLite settings

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package.md

Edit this file to define controller and type namespaces, debug levels, and middleware settings.

```php
<?php

use GraphQL\Error\Debug;

return [
    /*
     |--------------------------------------------------------------------------
     | GraphQLite Configuration
     |--------------------------------------------------------------------------
     |
     | Use this configuration to customize the namespace of the controllers and
     | types.
     | These namespaces must be autoloadable from Composer.
     | GraphQLite will find the path of the files based on composer.json settings.
     |
     | You can put a single namespace, or an array of namespaces.
     |
     */
    'controllers' => 'App\\Http\\Controllers',
    'types' => 'App\\',
    'debug' => Debug::RETHROW_UNSAFE_EXCEPTIONS,
    'uri' => env('GRAPHQLITE_URI', '/graphql'),
    'middleware' => ['web'],
    'guard' => ['web'],
];
```

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

### Execute GraphQL Query

Source: https://github.com/thecodingmachine/graphqlite/blob/master/examples/no-framework/README.md

Send a POST request to the local server to test the GraphQL endpoint.

```bash
curl -X POST -d '{"query":"{ hello(name: \"World\") }"}' -H "Content-Type: application/json" http://localhost:8080/
```

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

### Implementing the Prefetch Method

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/prefetch-method.mdx

Using the #[Prefetch] attribute to define a bulk data retrieval method within a GraphQLite type class.

```php
#[Type]
class PostType {
    /**
     * @param mixed $prefetchedUsers
     * @return User
     */
    #[Field]
    public function getUser(#[Prefetch("prefetchUsers")] $prefetchedUsers): User
    {
        // This method will receive the $prefetchedUsers as first argument. This is the return value of the "prefetchUsers" method below.
        // Using this prefetched list, it should be easy to map it to the post
    }

    /**
     * @param Post[] $posts
     * @return mixed
     */
    public static function prefetchUsers(iterable $posts)
    {
        // This function is called only once per GraphQL request
        // with the list of posts. You can fetch the list of users
        // associated with this posts in a single request,
        // for instance using a "IN" query in SQL or a multi-fetch
        // in your cache back-end.
    }
}
```

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

### Define the base Product entity

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/extend-type.mdx

The initial class definition using the #[Type] and #[Field] attributes.

```php
namespace App\Entities;

use TheCodingMachine\GraphQLite\Annotations\Field;
use TheCodingMachine\GraphQLite\Annotations\Type;

#[Type]
class Product
{
    // ...

    #[Field]
    public function getId(): string
    {
        return $this->id;
    }

    #[Field]
    public function getPrice(): ?float
    {
        return $this->price;
    }
}
```

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

### Initialize Webonyx context

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Pass the GraphQLite Context object to the Webonyx execution engine to enable features like prefetching.

```php
use TheCodingMachine\GraphQLite\Context\Context;

$result = GraphQL::executeQuery($schema, $query, null, new Context(), $variableValues);
```

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

### Register bundle in AppKernel

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle.md

Add the GraphQLite bundle to the registered bundles list in AppKernel.php for non-Flex applications.

```php
<?php

class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = array(
            // other bundles...
            new TheCodingMachine\GraphQLite\Bundle\GraphQLiteBundle,
        );
    }
}
```

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

### Implement a Field Middleware

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/field-middlewares.md

Create a class implementing FieldMiddlewareInterface to inspect annotations and conditionally hide fields by returning null.

```php
namespace App\Middlewares;

use App\Annotations\OnlyDebug;
use TheCodingMachine\GraphQLite\Middlewares\FieldMiddlewareInterface;
use GraphQL\Type\Definition\FieldDefinition;
use TheCodingMachine\GraphQLite\QueryFieldDescriptor;

/**
 * Middleware in charge of hiding a field if it is annotated with #[OnlyDebug] and the DEBUG constant is not set
 */
class OnlyDebugFieldMiddleware implements FieldMiddlewareInterface
{
    public function process(QueryFieldDescriptor $queryFieldDescriptor, FieldHandlerInterface $fieldHandler): ?FieldDefinition
    {
        $annotations = $queryFieldDescriptor->getMiddlewareAnnotations();

        /**
         * @var OnlyDebug $onlyDebug
         */
        $onlyDebug = $annotations->getAnnotationByType(OnlyDebug::class);

        if ($onlyDebug !== null && !DEBUG) {
            // If the onlyDebug attribute is present, returns null.
            // Returning null will hide the field.
            return null;
        }

        // Otherwise, let's continue the middleware pipe without touching anything.
        return $fieldHandler->handle($queryFieldDescriptor);
    }
}
```

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

### Implementing custom exceptions

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/error-handling.mdx

Creating a custom exception class by implementing GraphQLExceptionInterface.

```php
class ValidationException extends Exception implements GraphQLExceptionInterface
{
    /**
     * Returns true when exception message is safe to be displayed to a client.
     */
    public function isClientSafe(): bool
    {
        return true;
    }

    /**
     * Returns the "extensions" object attached to the GraphQL error.
     *
     * @return array<string, mixed>
     */
    public function getExtensions(): array
    {
        return [];
    }
}
```

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

### Export GraphQL schema using artisan command

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package-advanced.mdx

Executes the schema export command to generate an SDL file for use with external tools.

```console
$ ./artisan graphqlite:export-schema --output=schema.graphql
```

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

### Configure GraphQLite namespaces

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle.md

Define the namespaces for your GraphQL controllers and types in the configuration file.

```yaml
graphqlite:
  namespace:
    # The namespace(s) that will store your GraphQLite controllers.
    # It accept either a string or a list of strings.
    controllers: App\GraphQLController\
    # The namespace(s) that will store your GraphQL types and factories.
    # It accept either a string or a list of strings.
    types:
    - App\Types\
    - App\Entity\
```

```yaml
graphqlite:
  namespace:
    # The namespace(s) that will store your GraphQLite controllers.
    # It accept either a string or a list of strings.
    controllers: App\GraphqlController\
    # The namespace(s) that will store your GraphQL types and factories.
    # It accept either a string or a list of strings.
    types:
    - App\Types\
    - App\Entity\
```

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

### Transform a class into an Input Type using #[Input]

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/input-types.mdx

Annotate a class with #[Input] and its properties with #[Field] to enable automatic instantiation from GraphQL input arguments.

```php
#[Input]
class Location
{

    #[Field]
    private ?string $name = null;

    #[Field]
    private float $latitude;

    #[Field]
    private float $longitude;

    public function __construct(float $latitude, float $longitude)
    {
        $this->latitude = $latitude;
        $this->longitude = $longitude;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }

    public function getLatitude(): float
    {
        return $this->latitude;
    }

    public function getLongitude(): float
    {
        return $this->longitude;
    }
}
```

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

### Declaring Multiple Factories for One Class

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/input-types.mdx

Combine #[Factory] and #[UseInputType] to handle multiple ways of creating the same PHP class depending on the context.

```php
/**
 * This class contains 2 factories to create Product objects.
 * The "getProduct" method is used by default to map "Product" classes.
 * The "createProduct" method will generate another input type named "CreateProductInput"
 */
class ProductFactory
{
    // ...

    /**
     * This factory will be used by default to map "Product" classes.
     */
    #[Factory(name: "ProductRefInput", default: true)]
    public function getProduct(string $id): Product
    {
        return $this->productRepository->findById($id);
    }
    /**
     * We specify a name for this input type explicitly.
     */
    #[Factory(name: "CreateProductInput", default: false)]
    public function createProduct(string $name, string $type): Product
    {
        return new Product($name, $type);
    }
}

class ProductController
{
    /**
     * The "createProduct" factory will be used for this mutation.
     */
    #[Mutation]
    #[UseInputType(for: "$product", inputType: "CreateProductInput!")]
    public function saveProduct(Product $product): Product
    {
        // ...
    }

    /**
     * The default "getProduct" factory will be used for this query.
     *
     * @return Color[]
     */
    #[Query]
    public function availableColors(Product $product): array
    {
        // ...
    }
}
```

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

### Prefetching with Input Arguments

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/prefetch-method.mdx

Passing additional GraphQL arguments to a prefetch method to filter or modify the bulk data retrieval.

```php
#[Type]
class PostType {
    /**
     * @param mixed $prefetchedComments
     * @return Comment[]
     */
    #[Field]
    public function getComments(#[Prefetch("prefetchComments")] $prefetchedComments): array
    {
        // ...
    }

    /**
     * @param Post[] $posts
     * @return mixed
     */
    public static function prefetchComments(iterable $posts, bool $hideSpam, int $filterByScore)
    {
        // Parameters passed after the first parameter (hideSpam, filterByScore...) are automatically exposed
        // as GraphQL arguments for the "comments" field.
    }
}
```

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

### Implement Simple Paginator in a Query

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/laravel-package-advanced.mdx

Use Paginator for simple pagination when total count and last page information is not required.

```php
class MyController
{
    /**
     * @return Product[]
     */
    #[Query]
    public function products(): Illuminate\\Pagination\\Paginator
    {
        return Product::simplePaginate(15);
    }
}
```

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

### Register controller in the container

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Add the controller to the container configuration so it can be resolved.

```php
use App\Controllers\MyController;

return new Picotainer([
    // ...

    // We declare the controller in the container.
    MyController::class => function() {
        return new MyController();
    },
]);
```

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

### Configure SchemaFactory settings

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Customize the schema behavior by configuring authentication, authorization, type mappers, and performance modes.

```php
// Configure an authentication service (to resolve the #[Logged] attributes).
$factory->setAuthenticationService(new VoidAuthenticationService());
// Configure an authorization service (to resolve the #[Right] attributes).
$factory->setAuthorizationService(new VoidAuthorizationService());
// Change the naming convention of GraphQL types globally.
$factory->setNamingStrategy(new NamingStrategy());
// Add a custom type mapper.
$factory->addTypeMapper($typeMapper);
// Add a custom type mapper using a factory to create it.
// Type mapper factories are useful if you need to inject the "recursive type mapper" into your type mapper constructor.
$factory->addTypeMapperFactory($typeMapperFactory);
// Add a root type mapper.
$factory->addRootTypeMapper($rootTypeMapper);
// Add a parameter mapper.
$factory->addParameterMapper($parameterMapper);
// Add a query provider. These are used to find queries and mutations in the application.
$factory->addQueryProvider($queryProvider);
// Add a query provider using a factory to create it.
// Query provider factories are useful if you need to inject the "fields builder" into your query provider constructor.
$factory->addQueryProviderFactory($queryProviderFactory);
// Set a default InputType validator service to handle validation on all `Input` annotated types
$factory->setInputTypeValidator($validator);
// Add custom options to the Webonyx underlying Schema.
$factory->setSchemaConfig($schemaConfig);
// Control whether PHP docblock summaries are used as a fallback description for schema elements
// that do not provide an explicit `description` on their attribute. Enabled by default for
// backwards compatibility. See [Schema descriptions](descriptions.md) for the precedence rule
// and security rationale.
$factory->setDocblockDescriptionsEnabled(false);
// Configures the time-to-live for the GraphQLite cache. Defaults to 2 seconds in dev mode.
$factory->setGlobTtl(2);
// Enables prod-mode (cache settings optimized for best performance).
// This is a shortcut for `$schemaFactory->setGlobTtl(null)`
$factory->prodMode();
// Enables dev-mode (this is the default mode: cache settings optimized for best developer experience).
// This is a shortcut for `$schemaFactory->setGlobTtl(2)`
$factory->devMode();
```

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

### ProductType service structure

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/extend-type.mdx

The class structure required for the type extension service.

```php
class ProductType
{
    private $translationService;

    public function __construct(TranslationServiceInterface $translationService)
    {
        $this->translationService = $translationService;
    }

    // ...
```

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

### Type-hinting against an interface

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/autowiring.mdx

Prefer type-hinting against interfaces to allow for flexible implementation swapping.

```php

    #[Field]
    public function getName(#[Autowire] TranslatorInterface $translator): string
    {
        // Good. You can switch translator implementation any time.
    }

```

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

### Define explicit schema descriptions with attributes

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/descriptions.md

Use the description argument within GraphQLite attributes to explicitly set documentation for types, fields, and operations.

```php
use TheCodingMachine\GraphQLite\Annotations\Query;
use TheCodingMachine\GraphQLite\Annotations\Type;

#[Type(description: 'A library book available for checkout.')]
class Book
{
    #[Field(description: 'The book title as it appears on the cover.')]
    public function getTitle(): string { /* ... */ }
}

class LibraryController
{
    #[Query(description: 'Fetch a single library book.')]
    public function book(): Book { /* ... */ }
}
```

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

### Implement FieldMiddlewareInterface

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/field-middlewares.md

The interface required for creating custom field middlewares in GraphQLite.

```php
/**
 * Your middleware must implement this interface.
 */
interface FieldMiddlewareInterface
{
    public function process(QueryFieldDescriptor $queryFieldDescriptor, FieldHandlerInterface $fieldHandler): ?FieldDefinition;
}
```

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

### Generated GraphQL schema output

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/custom-types.mdx

The resulting GraphQL schema representation for the defined Product type.

```graphql
type Product {
    id: String!
}
```

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

### GraphQL schema representation of a custom type

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/queries.mdx

The equivalent GraphQL type language definition for the annotated Product class.

```graphql
Type Product {
    name: String!
    price: Float
}
```

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

### Implement Deferred Field Resolution in GraphQLite

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/type-mapping.mdx

Demonstrates using Closures for deferred execution and Deferred instances for custom output types and DataLoader integration.

```php
#[Type]
class Product
{
    // ...

    /**
     * @return Closure(): string
     */
    #[Field]
    public function getName(): Closure
    {
        return fn() => $this->name;
    }

    #[Field(outputType: "Float")]
    public function getPrice(): Deferred
    {
        return new Deferred(fn() => $this->price);
    }

    #[Field(outputType: "[String!]!")]
    public function getCategories(#[Autowire('categoryDataLoader')] DataLoader $categoryDataLoader): SyncPromise
    {
        return $categoryDataLoader->load($this->id)->adoptedPromise;
    }
}
```

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

### Fetching a service by identifier

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/autowiring.mdx

Specify a custom service identifier in the #[Autowire] attribute, though this is discouraged as it mimics the service locator anti-pattern.

```php
#[Autowire(identifier: "translator")]
```

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

### #[Factory]

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/attributes-reference.md

The #[Factory] attribute declares a method as a factory for converting GraphQL input types into PHP objects.

```APIDOC
## #[Factory]

### Description
The `#[Factory]` attribute is used to declare a factory that turns GraphQL input types into objects.

### Applies on
Methods from classes in the "types" namespace.

### Parameters
- **name** (string) - Optional - The name of the input type.
- **default** (bool) - Optional - If true, this factory will be used by default for its PHP return type.
- **description** (string) - Optional - Description of the GraphQL input type produced by this factory.
```

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

### Define a proxy type with #[Type]

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/external-type-declaration.mdx

Use the class attribute within #[Type] to associate a proxy class with a domain entity. The proxy class must be registered as a service in the application container.

```php
namespace App\Types;

use TheCodingMachine\GraphQLite\Annotations\Type;
use TheCodingMachine\GraphQLite\Annotations\Field;
use App\Entities\Product;

#[Type(class: Product::class)]
class ProductType
{
    #[Field]
    public function getId(Product $product): string
    {
        return $product->getId();
    }
}
```

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

### Throwing a GraphQLException

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/error-handling.mdx

Basic usage of throwing a GraphQLException to trigger a GraphQL error.

```php
use TheCodingMachine\GraphQLite\Exceptions\GraphQLException;

throw new GraphQLException("Exception message");
```

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

### Registering security services with SchemaFactory

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/implementing-security.md

Register custom implementations of authentication and authorization services to enable #[Logged] and #[Right] attribute resolution.

```php
// Configure an authentication service (to resolve the #[Logged] attribute).
$schemaFactory->setAuthenticationService($myAuthenticationService);
// Configure an authorization service (to resolve the #[Right] attribute).
$schemaFactory->setAuthorizationService($myAuthorizationService);
```

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

### Register Factory with SchemaFactory

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/custom-types.mdx

Register the custom factory instance to the schema factory.

```php
$schemaFactory->addRootTypeMapperFactory(new AnyScalarTypeMapperFactory());
```

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

### Compare #[Security] and #[Right] usage

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/fine-grained-security.mdx

The is_granted function within #[Security] provides functionality similar to the #[Right] attribute but allows for more complex expressions.

```php
#[Security("is_granted('ROLE_ADMIN')")]
```

```php
#[Right("ROLE_ADMIN")]
```

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

### Configure Query Complexity Limit

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/operation-complexity.md

Use the limitQueryComplexity method on the middleware builder to set a maximum cost for queries. Ensure the limit accounts for introspection queries, which typically cost around 107 points.

```php
$builder = new Psr15GraphQLMiddlewareBuilder($schema);

// Total query cost cannot exceed 1000 points
$builder->limitQueryComplexity(1000);
```

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

### Define a GraphQL subscription in a controller

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/subscriptions.mdx

Annotate a controller method with #[Subscription] to define a subscription. The outputType attribute specifies the GraphQL type returned by the subscription.

```php
namespace App\Controller;

use TheCodingMachine\GraphQLite\Annotations\Mutation;

class ProductController
{
    #[Subscription(outputType: 'Product')]
    public function productAdded(?ID $categoryId = null): void
    {
        // Some code that sets up any connections, stores the subscription details, etc.
    }
}
```

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

### Configure PSR-15 middleware builder

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Customize the middleware behavior using the builder's setter methods for endpoints, error handling, and factory configuration.

```php
$builder->setUrl("/graphql"); // Modify the URL endpoint (defaults to /graphql)

$config = $builder->getConfig(); // Returns a Webonyx ServerConfig object.
// Define your own formatter and error handlers for Webonyx.
$config->setErrorFormatter([ExceptionHandler::class, 'errorFormatter']);
$config->setErrorsHandler([ExceptionHandler::class, 'errorHandler']);

$builder->setConfig($config);

$builder->setResponseFactory(new ResponseFactory()); // Set a PSR-18 ResponseFactory (not needed if you are using zend-framework/zend-diactoros ^2
$builder->setStreamFactory(new StreamFactory()); // Set a PSR-18 StreamFactory (not needed if you are using zend-framework/zend-diactoros ^2
$builder->setHttpCodeDecider(new HttpCodeDecider()); // Set a class in charge of deciding the HTTP status code based on the response.

// Configure the server to use Apollo automatic persisted queries with given cache and an optional time-to-live.
// See https://www.apollographql.com/docs/apollo-server/performance/apq/
$builder->useAutomaticPersistedQueries($cache, new DateInterval('PT1H'));
```

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

### #[Decorate]

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/attributes-reference.md

The #[Decorate] attribute is used to extend or modify an input type that was previously declared with the #[Factory] attribute.

```APIDOC
## #[Decorate]

### Description
Extends or modifies an input type declared with the #[Factory] attribute. Applies on methods from classes in the "types" namespace.

### Parameters
- **name** (string) - Required - The GraphQL input type name extended by this decorator.
```

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

### Implement FromSourceFieldsInterface for dynamic fields

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/external-type-declaration.mdx

Use this interface to return an array of SourceFieldInterface objects at runtime, allowing for conditional field registration.

```php
use TheCodingMachine\GraphQLite\FromSourceFieldsInterface;

#[Type(class: Product::class)]
class ProductType implements FromSourceFieldsInterface
{
    /**
     * Dynamically returns the array of source fields
     * to be fetched from the original object.
     *
     * @return SourceFieldInterface[]
     */
    public function getSourceFields(): array
    {
        // You may want to enable fields conditionally based on feature flags...
        if (ENABLE_STATUS_GLOBALLY) {
            return [
                new SourceField(['name'=>'status', 'annotations'=>[new Logged()]]),
            ];
        } else {
            return [];
        }
    }
}
```

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

### Warm schema at worker bootstrap

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/troubleshooting.md

Force schema resolution during worker startup to prevent race conditions in long-lived PHP runtimes.

```php
$schema = $factory->createSchema();
$schema->getTypeMap();   // forces every lazy type to resolve while single-threaded
```

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

### Register parameter middleware with SchemaFactory

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/argument-resolving.md

Use the addParameterMiddleware method on the SchemaFactory instance to register a custom parameter handler.

```php
$schemaFactory->addParameterMiddleware(new ContainerParameterHandler($container));
```

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

### Configure GraphQLite security settings

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle-advanced.mdx

Defines the security configuration for the GraphQLite bundle in Symfony.

```yaml
graphqlite:
  security:
    enable_login: auto # Default setting
    enable_me: auto # Default setting
```

```yaml
graphqlite:
  security:
    enable_login: on
```

```yaml
graphqlite:
  security:
    enable_login: off
```

```yaml
graphqlite:
  security:
    firewall_name: main # default value
```

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

### Create RootTypeMapperFactory

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/custom-types.mdx

Factory class responsible for instantiating the custom type mapper.

```php
class AnyScalarTypeMapperFactory implements RootTypeMapperFactoryInterface
{
    public function create(RootTypeMapperInterface $next, RootTypeMapperFactoryContext $context): RootTypeMapperInterface
    {
        return new AnyScalarTypeMapper($next);
    }
}
```

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

### Defining a Factory

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/input-types.mdx

Use the #[Factory] attribute on a method to automatically create a GraphQL input type based on the method parameters.

```php
class MyFactory
{
    /**
     * The Factory attribute will create automatically a LocationInput input type in GraphQL.
     */
    #[Factory]
    public function createLocation(float $latitude, float $longitude): Location
    {
        return new Location($latitude, $longitude);
    }
}
```

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

### Configure API security and complexity limits

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle-advanced.mdx

Controls introspection and query complexity/depth limits for the GraphQL API.

```yaml
graphqlite:
  security:
    introspection: false
```

```yaml
graphqlite:
  security:
    maximum_query_complexity: 314
    maximum_query_depth: 42
```

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

### Disable autoloading for class discovery

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/other-frameworks.mdx

Override the default class finder to use include_once instead of autoloading, useful for legacy codebases with incorrect namespaces.

```php
use Kcs\ClassFinder\Finder\ComposerFinder;
use TheCodingMachine\GraphQLite\SchemaFactory;

$factory = new SchemaFactory($cache, $container);
$factory->addNamespace('App')
        ->setFinder(
            (new ComposerFinder())->useAutoloading(false)
        );

$schema = $factory->createSchema();
```

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

### Implement an interface in a PHP class

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/inheritance-interfaces.mdx

Implement a PHP interface in a class marked with #[Type] to automatically satisfy the GraphQL interface requirements.

```php
#[Type]
class User implements UserInterface
{
    public function getUserName(): string;
}
```

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

### Return a default value on security failure

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/fine-grained-security.mdx

Use the failWith attribute to return a default value instead of throwing an error when the security condition is not met.

```php
#[Query]
#[Security(expression: "is_granted('CAN_SEE_MARGIN', this)", failWith: null)]
public function getMargin(): float
{
    // ...
}
```

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

### Annotate a Data Class for GraphQL

Source: https://github.com/thecodingmachine/graphqlite/blob/master/README.md

Use #[Type], #[Input], and #[Field] attributes to map a PHP class to a GraphQL schema.

```php
#[Type]
#[Input(update: true)]
class Product
{
    #[Field]
    public function getName(): string
    {
        return $this->name;
    }
    
    #[Field]
    public function setName(string $name): void
    {
        $this->name = $name;
    }
    
    // ...
```

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

### Register a Field Middleware

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/field-middlewares.md

Register the middleware instance with the SchemaFactory to include it in the GraphQLite processing pipeline.

```php
$schemaFactory->addFieldMiddleware(new OnlyDebugFieldMiddleware());
```

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

### Use docblock summaries as description fallback

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/descriptions.md

GraphQLite automatically uses the PHP docblock summary as the GraphQL description if no explicit description argument is provided in the attribute.

```php
/**
 * Fetch a single library book.
 */
#[Query]
public function book(): Book { /* ... */ }
```

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

### Configure advanced error handling

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/symfony-bundle.md

Customize debug settings for error handling in the graphqlite.yaml configuration file.

```yaml
graphqlite:
  # ...
  debug:
    # Include exception messages in output when an error arises.
    INCLUDE_DEBUG_MESSAGE: false
    # Include stacktrace in output when an error arises.
    INCLUDE_TRACE: false
    # Exceptions are not caught by the engine and propagated to Symfony.
    RETHROW_INTERNAL_EXCEPTIONS: false
    # Exceptions that do not implement ClientAware interface are
    # not caught by the engine and propagated to Symfony.
    RETHROW_UNSAFE_EXCEPTIONS: true
```

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

### Map a PHP interface to a GraphQL interface

Source: https://github.com/thecodingmachine/graphqlite/blob/master/website/docs/inheritance-interfaces.mdx

Apply the #[Type] attribute to a PHP interface to expose it as a GraphQL interface.

```php
#[Type]
interface UserInterface
{
    #[Field]
    public function getUserName(): string;
}
```
Tokens:
Raw