Use a parameter middleware if you want to alter the way arguments are injected in a method
+or if you want to alter the way input types are imported (for instance if you want to add a validation step)
+
+As an example, GraphQLite uses *parameter middlewares* internally to:
+
+- Inject the Webonyx GraphQL resolution object when you type-hint on the `ResolveInfo` object. For instance:
+
+ ```php
+ /**
+ * @return Product[]
+ */
+ #[Query]
+ public function products(ResolveInfo $info): array
+ ```
+
+ In the query above, the `$info` argument is filled with the Webonyx `ResolveInfo` class thanks to the
+ [`ResolveInfoParameterHandler parameter middleware`](https://github.com/thecodingmachine/graphqlite/blob/master/src/Mappers/Parameters/ResolveInfoParameterHandler.php)
+- Inject a service from the container when you use the `#[Autowire]` attribute
+- Perform validation with the `#[Validate]` attribute (in Laravel package)
+
+
+
+**Parameter middlewares**
+
+
+ By default, if a user tries to access an unauthorized query/mutation/subscription/field, an error is
+ raised and the query fails.
+
+
+## Not throwing errors
+
+If you do not want an error to be thrown when a user attempts to query a field/query/mutation/subscription
+they have no access to, you can use the `#[FailWith]` attribute.
+
+The `#[FailWith]` attribute contains the value that will be returned for users with insufficient rights.
+
+```php
+class UserController
+{
+ /**
+ * If a user is not logged or if the user has not the right "CAN_VIEW_USER_LIST",
+ * the value returned will be "null".
+ *
+ * @return User[]
+ */
+ #[Query]
+ #[Logged]
+ #[Right("CAN_VIEW_USER_LIST")]
+ #[FailWith(value: null)]
+ public function users(int $limit, int $offset): array
+ {
+ // ...
+ }
+}
+```
+
+## Injecting the current user as a parameter
+
+Use the `#[InjectUser]` attribute to get an instance of the current user logged in.
+
+```php
+namespace App\Controller;
+
+use TheCodingMachine\GraphQLite\Annotations\Query;
+use TheCodingMachine\GraphQLite\Annotations\InjectUser;
+
+class ProductController
+{
+ /**
+ * @return Product
+ */
+ #[Query]
+ public function product(
+ int $id,
+ #[InjectUser]
+ User $user
+ ): Product
+ {
+ // ...
+ }
+}
+```
+
+The `#[InjectUser]` attribute can be used next to:
+
+* `#[Query]` attributes
+* `#[Mutation]` attributes
+* `#[Field]` attributes
+
+The object injected as the current user depends on your framework. It is in fact the object returned by the
+["authentication service" configured in GraphQLite](implementing-security.md). If user is not authenticated and
+parameter's type is not nullable, an authorization exception is thrown, similar to `#[Logged]` attribute.
+
+## Hiding fields / queries / mutations / subscriptions
+
+By default, a user analysing the GraphQL schema can see all queries/mutations/subscriptions/types available.
+Some will be available to him and some won't.
+
+If you want to add an extra level of security (or if you want your schema to be kept secret to unauthorized users),
+you can use the `#[HideIfUnauthorized]` attribute. Beware of [it's limitations](annotations-reference.md).
+
+```php
+class UserController
+{
+ /**
+ * If a user is not logged or if the user has not the right "CAN_VIEW_USER_LIST",
+ * the schema will NOT contain the "users" query at all (so trying to call the
+ * "users" query will result in a GraphQL "query not found" error.
+ *
+ * @return User[]
+ */
+ #[Query]
+ #[Logged]
+ #[Right("CAN_VIEW_USER_LIST")]
+ #[HideIfUnauthorized]
+ public function users(int $limit, int $offset): array
+ {
+ // ...
+ }
+}
+```
+
+While this is the most secured mode, it can have drawbacks when working with development tools
+(you need to be logged as admin to fetch the complete schema).
+
+The "HideIfUnauthorized" mode was the default mode in GraphQLite 3 and is optional from GraphQLite 4+.
diff --git a/website/versioned_docs/version-8.0.0/automatic-persisted-queries.mdx b/website/versioned_docs/version-8.0.0/automatic-persisted-queries.mdx
new file mode 100644
index 0000000000..f505a869f4
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/automatic-persisted-queries.mdx
@@ -0,0 +1,61 @@
+---
+id: automatic-persisted-queries
+title: Automatic persisted queries
+sidebar_label: Automatic persisted queries
+---
+
+## The problem
+
+Clients send queries to GraphQLite as HTTP requests that include the GraphQL string of the query to execute.
+Depending on your graph's schema, the size of a valid query string might be arbitrarily large.
+As query strings become larger, increased latency and network usage can noticeably degrade client performance.
+
+To combat this, GraphQL servers use a technique called "persisted queries". The basic idea is instead of
+sending the whole query string, clients only send it's unique identifier. The server then finds the actual
+query string by given identifier and use that as if the client sent the whole query in the first place.
+That helps improve GraphQL network performance with zero build-time configuration by sending smaller GraphQL HTTP requests.
+A smaller request payload reduces bandwidth utilization and speeds up GraphQL Client loading times.
+
+## Apollo APQ
+
+[Automatic persisted queries (APQ) is technique created by Apollo](https://www.apollographql.com/docs/apollo-server/performance/apq/)
+and is aimed to implement a simple automatic way of persisting queries. Queries are cached on the server side,
+along with its unique identifier (always its SHA-256 hash). Clients can send this identifier instead of the
+corresponding query string, thus reducing request sizes dramatically (response sizes are unaffected).
+
+To persist a query string, GraphQLite server must first receive it from a requesting client.
+Consequently, each unique query string must be sent to Apollo Server at least once.
+After any client sends a query string to persist, every client that executes that query can then benefit from APQ.
+
+```mermaid
+sequenceDiagram;
+ Client app->>GraphQL Server: Sends SHA-256 hash of query string to execute
+ Note over GraphQL Server: Fails to find persisted query string
+ GraphQL Server->>Client app: Responds with error
+ Client app->>GraphQL Server: Sends both query string AND hash
+ Note over GraphQL Server: Persists query string and hash
+ GraphQL Server->>Client app: Executes query and returns result
+ Note over Client app: Time passes
+ Client app->>GraphQL Server: Sends SHA-256 hash of query string to execute
+ Note over GraphQL Server: Finds persisted query string
+ GraphQL Server->>Client app: Executes query and returns result
+```
+
+Persisted queries are especially effective when clients send queries as GET requests.
+This enables clients to take advantage of the browser cache and integrate with a CDN.
+
+Because query identifiers are deterministic hashes, clients can generate them at runtime. No additional build steps are required.
+
+## Setup
+
+To use Automatic persisted queries with GraphQLite, you may use
+`useAutomaticPersistedQueries` method when building your PSR-15 middleware:
+
+```php
+$builder = new Psr15GraphQLMiddlewareBuilder($schema);
+
+// You need to provide a PSR compatible cache and a TTL for queries. The best cache would be some kind
+// of in-memory cache with a limit on number of entries to make sure your cache can't be maliciously spammed with queries.
+$builder->useAutomaticPersistedQueries($cache, new DateInterval('PT1H'));
+```
+
diff --git a/website/versioned_docs/version-8.0.0/autowiring.mdx b/website/versioned_docs/version-8.0.0/autowiring.mdx
new file mode 100644
index 0000000000..825241afe0
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/autowiring.mdx
@@ -0,0 +1,107 @@
+---
+id: autowiring
+title: Autowiring services
+sidebar_label: Autowiring services
+---
+
+GraphQLite can automatically inject services in your fields/queries/mutations signatures.
+
+Some of your fields may be computed. In order to compute these fields, you might need to call a service.
+
+Most of the time, your `#[Type]` attribute will be put on a model. And models do not have access to services.
+Hopefully, if you add a type-hinted service in your field's declaration, GraphQLite will automatically fill it with
+the service instance.
+
+## Sample
+
+Let's assume you are running an international store. You have a `Product` class. Each product has many names (depending
+on the language of the user).
+
+```php
+namespace App\Entities;
+
+use TheCodingMachine\GraphQLite\Annotations\Autowire;
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Type;
+
+use Symfony\Component\Translation\TranslatorInterface;
+
+#[Type]
+class Product
+{
+ // ...
+
+ #[Field]
+ public function getName(
+ #[Autowire]
+ TranslatorInterface $translator
+ ): string
+ {
+ return $translator->trans('product_name_'.$this->id);
+ }
+}
+```
+
+When GraphQLite queries the name, it will automatically fetch the translator service.
+
+As with most autowiring solutions, GraphQLite assumes that the service identifier
+in the container is the fully qualified class name of the type-hint. So in the example above, GraphQLite will
+look for a service whose name is Symfony\Component\Translation\TranslatorInterface.
+
+## Best practices
+
+It is a good idea to refrain from type-hinting on concrete implementations.
+Most often, your field declaration will be in your model. If you add a type-hint on a service, you are binding your domain
+with a particular service implementation. This makes your code tightly coupled and less testable.
+
+While GraphQLite offers the possibility to specify the name of the service to be
+autowired, we would like to emphasize that this is highly discouraged. Hard-coding a container
+identifier in the code of your class is akin to using the "service locator" pattern, which is known to be an
+anti-pattern. Please refrain from doing this as much as possible.
+
+## Alternative solution
+
+You may find yourself uncomfortable with the autowiring mechanism of GraphQLite. For instance maybe:
+
+- Your service identifier in the container is not the fully qualified class name of the service (this is often true if you are not using a container supporting autowiring)
+- You do not want to inject a service in a domain object
+- You simply do not like the magic of injecting services in a method signature
+
+If you do not want to use autowiring and if you still need to access services to compute a field, please read on
+the next chapter to learn [how to extend a type](extend-type).
diff --git a/website/versioned_docs/version-8.0.0/custom-types.mdx b/website/versioned_docs/version-8.0.0/custom-types.mdx
new file mode 100644
index 0000000000..3db2bec5bd
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/custom-types.mdx
@@ -0,0 +1,219 @@
+---
+id: custom-types
+title: Custom types
+sidebar_label: Custom types
+---
+
+In some special cases, you want to override the GraphQL return type that is attributed by default by GraphQLite.
+
+For instance:
+
+```php
+#[Type(class: Product::class)]
+class ProductType
+{
+ #[Field]
+ public function getId(Product $source): string
+ {
+ return $source->getId();
+ }
+}
+```
+
+In the example above, GraphQLite will generate a GraphQL schema with a field `id` of type `string`:
+
+```graphql
+type Product {
+ id: String!
+}
+```
+
+GraphQL comes with an `ID` scalar type. But PHP has no such type. So GraphQLite does not know when a variable
+is an `ID` or not.
+
+You can help GraphQLite by manually specifying the output type to use:
+
+```php
+ #[Field(outputType: "ID")]
+```
+
+## Usage
+
+The `outputType` attribute will map the return value of the method to the output type passed in parameter.
+
+You can use the `outputType` attribute in the following annotations:
+
+* `#[Query]`
+* `#[Mutation]`
+* `#[Subscription]`
+* `#[Field]`
+* `#[SourceField]`
+* `#[MagicField]`
+
+## Registering a custom output type (advanced)
+
+In order to create a custom output type, you need to:
+
+1. Design a class that extends `GraphQL\Type\Definition\ObjectType`.
+2. Register this class in the GraphQL schema.
+
+You'll find more details on the [Webonyx documentation](https://webonyx.github.io/graphql-php/type-definitions/object-types/).
+
+---
+
+In order to find existing types, the schema is using *type mappers* (classes implementing the `TypeMapperInterface` interface).
+
+You need to make sure that one of these type mappers can return an instance of your type. The way you do this will depend on the framework
+you use.
+
+### Symfony users
+
+Any class extending `GraphQL\Type\Definition\ObjectType` (and available in the container) will be automatically detected
+by Symfony and added to the schema.
+
+If you want to automatically map the output type to a given PHP class, you will have to explicitly declare the output type
+as a service and use the `graphql.output_type` tag:
+
+```yaml
+# config/services.yaml
+services:
+ App\MyOutputType:
+ tags:
+ - { name: 'graphql.output_type', class: 'App\MyPhpClass' }
+```
+
+### Other frameworks
+
+The easiest way is to use a `StaticTypeMapper`. Use this class to register custom output types.
+
+```php
+// Sample code:
+$staticTypeMapper = new StaticTypeMapper(
+ // Let's register a type that maps by default to the "MyClass" PHP class
+ types: [
+ MyClass::class => new MyCustomOutputType()
+ ],
+
+ // If you don't want your output type to map to any PHP class by default, use:
+ notMappedTypes: [
+ new MyCustomOutputType()
+ ],
+);
+
+// Register the static type mapper in your application using the SchemaFactory instance
+$schemaFactory->addTypeMapper($staticTypeMapper);
+```
+
+## Registering a custom scalar type (advanced)
+
+If you need to add custom scalar types, first, check the [GraphQLite Misc. Types library](https://github.com/thecodingmachine/graphqlite-misc-types).
+It contains a number of "out-of-the-box" scalar types ready to use and you might find what you need there.
+
+You still need to develop your custom scalar type? Ok, let's get started.
+
+In order to add a scalar type in GraphQLite, you need to:
+
+- create a [Webonyx custom scalar type](https://webonyx.github.io/graphql-php/type-system/scalar-types/#writing-custom-scalar-types).
+ You do this by creating a class that extends `GraphQL\Type\Definition\ScalarType`.
+- create a "type mapper" that will map PHP types to the GraphQL scalar type. You do this by writing a class implementing the `RootTypeMapperInterface`.
+- create a "type mapper factory" that will be in charge of creating your "type mapper".
+
+```php
+interface RootTypeMapperInterface
+{
+ /**
+ * @param \ReflectionMethod|\ReflectionProperty $reflector
+ */
+ public function toGraphQLOutputType(Type $type, ?OutputType $subType, $reflector, DocBlock $docBlockObj): OutputType;
+
+ /**
+ * @param \ReflectionMethod|\ReflectionProperty $reflector
+ */
+ public function toGraphQLInputType(Type $type, ?InputType $subType, string $argumentName, $reflector, DocBlock $docBlockObj): InputType;
+
+ public function mapNameToType(string $typeName): NamedType;
+}
+```
+
+The `toGraphQLOutputType` and `toGraphQLInputType` are meant to map a return type (for output types) or a parameter type (for input types)
+to your GraphQL scalar type. Return your scalar type if there is a match or `null` if there no match.
+
+The `mapNameToType` should return your GraphQL scalar type if `$typeName` is the name of your scalar type.
+
+RootTypeMapper are organized **in a chain** (they are actually middlewares).
+Each instance of a `RootTypeMapper` holds a reference on the next root type mapper to be called in the chain.
+
+For instance:
+
+```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;
+ }
+}
+```
+
+Now, in order to create an instance of your `AnyScalarTypeMapper` class, you need an instance of the `$next` type mapper in the chain.
+How do you get the `$next` type mapper? Through a factory:
+
+```php
+class AnyScalarTypeMapperFactory implements RootTypeMapperFactoryInterface
+{
+ public function create(RootTypeMapperInterface $next, RootTypeMapperFactoryContext $context): RootTypeMapperInterface
+ {
+ return new AnyScalarTypeMapper($next);
+ }
+}
+```
+
+Now, you need to register this factory in your application, and we are done.
+
+You can register your own root mapper factories using the `SchemaFactory::addRootTypeMapperFactory()` method.
+
+```php
+$schemaFactory->addRootTypeMapperFactory(new AnyScalarTypeMapperFactory());
+```
+
+If you are using the Symfony bundle, the factory will be automatically registered, you have nothing to do (the service
+is automatically tagged with the "graphql.root_type_mapper_factory" tag).
diff --git a/website/versioned_docs/version-8.0.0/doctrine-annotations-attributes.mdx b/website/versioned_docs/version-8.0.0/doctrine-annotations-attributes.mdx
new file mode 100644
index 0000000000..058c276a95
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/doctrine-annotations-attributes.mdx
@@ -0,0 +1,102 @@
+---
+id: doctrine-annotations-attributes
+title: Doctrine annotations VS PHP8 attributes
+sidebar_label: Annotations VS Attributes
+---
+
+GraphQLite is heavily relying on the concept of annotations (also called attributes in PHP 8+).
+
+## Doctrine annotations
+
+GraphQL allows to have several errors for one request. If you have several
+GraphQLException thrown for the same request, the HTTP status code used will be the highest one.
+
+## Customizing the extensions section
+
+You can customize the whole "extensions" section with the 5th parameter of the constructor:
+
+```php
+throw new GraphQLException("Field required", 400, null, "VALIDATION", ['field' => 'name']);
+```
+
+will generate:
+
+```json
+{
+ "errors": [
+ {
+ "message": "Field required",
+ "extensions": {
+ "field": "name"
+ }
+ }
+ ]
+}
+```
+
+## Writing your own exceptions
+
+Rather that throwing the base `GraphQLException`, you should consider writing your own exception.
+
+Any exception that implements interface `TheCodingMachine\GraphQLite\Exceptions\GraphQLExceptionInterface` will be displayed
+in the GraphQL "errors" section.
+
+```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
+ */
+ public function getExtensions(): array
+ {
+ return [];
+ }
+}
+```
+
+## Many errors for one exception
+
+Sometimes, you need to display several errors in the response. But of course, at any given point in your code, you can
+throw only one exception.
+
+If you want to display several exceptions, you can bundle these exceptions in a `GraphQLAggregateException` that you can
+throw.
+
+```php
+use TheCodingMachine\GraphQLite\Exceptions\GraphQLAggregateException;
+
+#[Query]
+public function createProduct(string $name, float $price): Product
+{
+ $exceptions = new GraphQLAggregateException();
+
+ if ($name === '') {
+ $exceptions->add(new GraphQLException('Name cannot be empty', 400, null, 'VALIDATION'));
+ }
+ if ($price <= 0) {
+ $exceptions->add(new GraphQLException('Price must be positive', 400, null, 'VALIDATION'));
+ }
+
+ if ($exceptions->hasExceptions()) {
+ throw $exceptions;
+ }
+}
+```
+
+## Webonyx exceptions
+
+GraphQLite is based on the wonderful webonyx/GraphQL-PHP library. Therefore, the Webonyx exception mechanism can
+also be used in GraphQLite. This means you can throw a `GraphQL\Error\Error` exception or any exception implementing
+[`GraphQL\Error\ClientAware` interface](http://webonyx.github.io/graphql-php/error-handling/#errors-in-graphql)
+
+Actually, the `TheCodingMachine\GraphQLite\Exceptions\GraphQLExceptionInterface` extends Webonyx's `ClientAware` interface.
+
+## Behaviour of exceptions that do not implement ClientAware
+
+If an exception that does not implement `ClientAware` is thrown, by default, GraphQLite will not catch it.
+
+The exception will propagate to your framework error handler/middleware that is in charge of displaying the classical error page.
+
+You can [change the underlying behaviour of Webonyx to catch any exception and turn them into GraphQL errors](http://webonyx.github.io/graphql-php/error-handling/#debugging-tools).
+The way you adjust the error settings depends on the framework you are using ([Symfony](symfony-bundle.md), [Laravel](laravel-package.md)).
+
+To be clear: we strongly discourage changing this setting. We strongly believe that the
+default "RETHROW_UNSAFE_EXCEPTIONS" setting of Webonyx is the only sane setting (only putting in "errors" section exceptions
+designed for GraphQL).
diff --git a/website/versioned_docs/version-8.0.0/extend-input-type.mdx b/website/versioned_docs/version-8.0.0/extend-input-type.mdx
new file mode 100644
index 0000000000..abe2818dd9
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/extend-input-type.mdx
@@ -0,0 +1,75 @@
+---
+id: extend-input-type
+title: Extending an input type
+sidebar_label: Extending an input type
+---
+
+Available in GraphQLite 4.0+
+
+
+
+Fields exposed in a GraphQL input type do not need to be all part of the factory method.
+
+Just like with output type (that can be [extended using the `ExtendType` attribute](extend-type.mdx)), you can extend/modify
+an input type using the `#[Decorate]` attribute.
+
+Use the `#[Decorate]` attribute to add additional fields to an input type that is already declared by a `#[Factory]` attribute,
+or to modify the returned object.
+
+
+ The #[Decorate] attribute is very useful in scenarios where you cannot touch the #[Factory] method.
+ This can happen if the #[Factory] method is defined in a third-party library or if the #[Factory] method is part
+ of auto-generated code.
+
+
+Let's assume you have a `Filter` class used as an input type. You most certainly have a `#[Factory]` to create the input type.
+
+```php
+class MyFactory
+{
+ #[Factory]
+ public function createFilter(string $name): Filter
+ {
+ // Let's assume you have a flexible 'Filter' class that can accept any kind of filter
+ $filter = new Filter();
+ $filter->addFilter('name', $name);
+ return $filter;
+ }
+}
+```
+
+Assuming you **cannot** modify the code of this factory, you can still modify the GraphQL input type generated by
+adding a "decorator" around the factory.
+
+```php
+class MyDecorator
+{
+ #[Decorate(inputTypeName: "FilterInput")]
+ public function addTypeFilter(Filter $filter, string $type): Filter
+ {
+ $filter->addFilter('type', $type);
+ return $filter;
+ }
+}
+```
+
+In the example above, the "Filter" input type is modified. We add an additional "type" field to the input type.
+
+A few things to notice:
+
+- The decorator takes the object generated by the factory as first argument
+- The decorator MUST return an object of the same type (or a sub-type)
+- The decorator CAN contain additional parameters. They will be added to the fields of the GraphQL input type.
+- The `#[Decorate]` attribute must contain a `inputTypeName` attribute that contains the name of the GraphQL input type
+ that is decorated. If you did not specify this name in the `#[Factory]` attribute, this is by default the name of the
+ PHP class + "Input" (for instance: "Filter" => "FilterInput")
+
+
+
+ Heads up! The MyDecorator class must exist in the container of your
+ application and the container identifier MUST be the fully qualified class name.
+
+ If you are using the Symfony bundle (or a framework with autowiring like Laravel), this is usually
+ not an issue as the container will automatically create the controller entry if you do not explicitly
+ declare it.
+
diff --git a/website/versioned_docs/version-8.0.0/extend-type.mdx b/website/versioned_docs/version-8.0.0/extend-type.mdx
new file mode 100644
index 0000000000..44d5ac9327
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/extend-type.mdx
@@ -0,0 +1,135 @@
+---
+id: extend-type
+title: Extending a type
+sidebar_label: Extending a type
+---
+
+
+Fields exposed in a GraphQL type do not need to be all part of the same class.
+
+Use the `#[ExtendType]` attribute to add additional fields to a type that is already declared.
+
+
+ Extending a type has nothing to do with type inheritance.
+ If you are looking for a way to expose a class and its children classes, have a look at
+ the
Inheritance section
+
Heads up! The ProductType class must exist in the container of your
+application and the container identifier MUST be the fully qualified class name.
+If you are using the Symfony bundle (or a framework with autowiring like Laravel), this
+is usually not an issue as the container will automatically create the controller entry if you do not explicitly
+declare it.
+
+```php
+#[Field]
+public function getName(Product $product, string $language): string
+{
+ return $this->translationService->getProductName($product->getId(), $language);
+}
+```
+
+The `#[Field]` attribute is used to add the "name" field to the `Product` type.
+
+Take a close look at the signature. The first parameter is the "resolved object" we are working on.
+Any additional parameters are used as arguments.
+
+Using the "[Type language](https://graphql.org/learn/schema/#type-language)" notation, we defined a type extension for
+the GraphQL "Product" type:
+
+```graphql
+Extend type Product {
+ name(language: !String): String!
+}
+```
+
+Type extension is a very powerful tool. Use it to add fields that needs to be
+computed from services not available in the entity.
+
diff --git a/website/versioned_docs/version-8.0.0/external-type-declaration.mdx b/website/versioned_docs/version-8.0.0/external-type-declaration.mdx
new file mode 100644
index 0000000000..428fad7f8e
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/external-type-declaration.mdx
@@ -0,0 +1,149 @@
+---
+id: external-type-declaration
+title: External type declaration
+sidebar_label: External type declaration
+---
+
+In some cases, you cannot or do not want to put an attribute on a domain class.
+
+For instance:
+
+* The class you want to annotate is part of a third party library and you cannot modify it
+* You are doing domain-driven design and don't want to clutter your domain object with attributes from the view layer
+* etc.
+
+## `#[Type]` attribute with the `class` attribute
+
+GraphQLite allows you to use a *proxy* class thanks to the `#[Type]` attribute with the `class` attribute:
+
+```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();
+ }
+}
+```
+
+The `ProductType` class must be in the *types* namespace. You configured this namespace when you installed GraphQLite.
+
+The `ProductType` class is actually a **service**. You can therefore inject dependencies in it.
+
+Heads up! The ProductType class must exist in the container of your application and the container identifier MUST be the fully qualified class name.
+If you are using the Symfony bundle (or a framework with autowiring like Laravel), this
+is usually not an issue as the container will automatically create the controller entry if you do not explicitly
+declare it.
+
+In methods with a `#[Field]` attribute, the first parameter is the *resolved object* we are working on. Any additional parameters are used as arguments.
+
+## `#[SourceField]` attribute
+
+If you don't want to rewrite all *getters* of your base class, you may use the `#[SourceField]` attribute:
+
+```php
+use TheCodingMachine\GraphQLite\Annotations\Type;
+use TheCodingMachine\GraphQLite\Annotations\SourceField;
+use App\Entities\Product;
+
+#[Type(class: Product::class)]
+#[SourceField(name: "name")]
+#[SourceField(name: "price")]
+class ProductType
+{
+}
+```
+
+By doing so, you let GraphQLite know that the type exposes the `getName` method of the underlying `Product` object.
+
+Internally, GraphQLite will look for methods named `name()`, `getName()` and `isName()`).
+You can set different name to look for with `sourceName` attribute.
+
+## `#[MagicField]` attribute
+
+If your object has no getters, but instead uses magic properties (using the magic `__get` method), you should use the `#[MagicField]` attribute:
+
+```php
+use TheCodingMachine\GraphQLite\Annotations\Type;
+use TheCodingMachine\GraphQLite\Annotations\SourceField;
+use App\Entities\Product;
+
+#[Type]
+#[MagicField(name: "name", outputType: "String!")]
+#[MagicField(name: "price", outputType: "Float")]
+class ProductType
+{
+ public function __get(string $property) {
+ // return some magic property
+ }
+}
+```
+
+By doing so, you let GraphQLite know that the type exposes "name" and the "price" magic properties of the underlying `Product` object.
+You can set different name to look for with `sourceName` attribute.
+
+This is particularly useful in frameworks like Laravel, where Eloquent is making a very wide use of such properties.
+
+Please note that GraphQLite has no way to know the type of a magic property. Therefore, you have specify the GraphQL type
+of each property manually.
+
+### Authentication and authorization
+
+You may also check for logged users or users with a specific right using the "annotations" argument.
+
+```php
+use TheCodingMachine\GraphQLite\Annotations\Type;
+use TheCodingMachine\GraphQLite\Annotations\SourceField;
+use TheCodingMachine\GraphQLite\Annotations\Logged;
+use TheCodingMachine\GraphQLite\Annotations\Right;
+use TheCodingMachine\GraphQLite\Annotations\FailWith;
+use App\Entities\Product;
+
+#[Type(class: Product::class)]
+#[SourceField(name: "name")]
+#[SourceField(name: "price", annotations: [new Logged(), new Right("CAN_ACCESS_Price"), new FailWith(null)])]
+class ProductType extends AbstractAnnotatedObjectType
+{
+}
+```
+
+Any attributes described in the [Authentication and authorization page](authentication-authorization.mdx), or any attribute this is actually a ["field middleware"](field-middlewares.md) can be used in the `#[SourceField]` "annotations" argument.
+
+## Declaring fields dynamically (without attributes)
+
+In some very particular cases, you might not know exactly the list of `#[SourceField]` attributes at development time.
+If you need to decide the list of `#[SourceField]` at runtime, you can implement the `FromSourceFieldsInterface`:
+
+```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 [];
+ }
+ }
+}
+```
diff --git a/website/versioned_docs/version-8.0.0/field-middlewares.md b/website/versioned_docs/version-8.0.0/field-middlewares.md
new file mode 100644
index 0000000000..df7b2bfaee
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/field-middlewares.md
@@ -0,0 +1,135 @@
+---
+id: field-middlewares
+title: Adding custom attributes with Field middlewares
+sidebar_label: Custom attributes
+---
+
+Available in GraphQLite 4.0+
+
+Just like the `#[Logged]` or `#[Right]` attribute, you can develop your own attribute that extends/modifies the behaviour of a field/query/mutation.
+
+
+ If you want to create an attribute that targets a single argument (like
#[AutoWire]), you should rather check the documentation about
custom argument resolving
+
+ If you are a Symfony user, you might already be used to the #[Security] attribute. Most of the inspiration
+ of this attribute comes from Symfony. Warning though! GraphQLite's #[Security] attribute and
+ Symfony's #[Security] attribute are slightly different. Especially, the two attributes do not live
+ in the same namespace!
+
+
+## The `is_granted` function
+
+Use the `is_granted` function to check if a user has a special right.
+
+```php
+#[Security("is_granted('ROLE_ADMIN')")]
+```
+
+is similar to
+
+```php
+#[Right("ROLE_ADMIN")]
+```
+
+In addition, the `is_granted` function accepts a second optional parameter: the "scope" of the right.
+
+```php
+#[Query]
+#[Security("is_granted('POST_SHOW', post)")]
+public function getPost(Post $post): array
+{
+ // ...
+}
+```
+
+In the example above, the `getPost` method can be called only if the logged user has the 'POST_SHOW' permission on the
+`$post` object. You can notice that the `$post` object comes from the parameters.
+
+## Accessing method parameters
+
+All parameters passed to the method can be accessed in the `#[Security]` expression.
+
+```php
+#[Query]
+#[Security(expression: "startDate < endDate", statusCode: 400, message: "End date must be after start date")]
+public function getPosts(DateTimeImmutable $startDate, DateTimeImmutable $endDate): array
+{
+ // ...
+}
+```
+
+In the example above, we tweak a bit the Security attribute purpose to do simple input validation.
+
+## Setting HTTP code and error message
+
+You can use the `statusCode` and `message` attributes to set the HTTP code and GraphQL error message.
+
+```php
+#[Query]
+#[Security(expression: "is_granted('POST_SHOW', post)", statusCode: 404, message: "Post not found (let's pretend the post does not exists!)")]
+public function getPost(Post $post): array
+{
+ // ...
+}
+```
+
+Note: since a single GraphQL call contain many errors, 2 errors might have conflicting HTTP status code.
+The resulting status code is up to the GraphQL middleware you use. Most of the time, the status code with the
+higher error code will be returned.
+
+## Setting a default value
+
+If you do not want an error to be thrown when the security condition is not met, you can use the `failWith` attribute
+to set a default value.
+
+```php
+#[Query]
+#[Security(expression: "is_granted('CAN_SEE_MARGIN', this)", failWith: null)]
+public function getMargin(): float
+{
+ // ...
+}
+```
+
+The `failWith` attribute behaves just like the [`#[FailWith]` attribute](authentication-authorization.mdx#not-throwing-errors)
+but for a given `#[Security]` attribute.
+
+You cannot use the `failWith` attribute along `statusCode` or `message` attributes.
+
+## Accessing the user
+
+You can use the `user` variable to access the currently logged user.
+You can use the `is_logged()` function to check if a user is logged or not.
+
+
+```php
+#[Query]
+#[Security("is_logged() && user.age > 18")]
+public function getNSFWImages(): array
+{
+ // ...
+}
+```
+
+## Accessing the current object
+
+You can use the `this` variable to access any (public) property / method of the current class.
+
+```php
+class Post {
+ #[Field]
+ #[Security("this.canAccessBody(user)")]
+ public function getBody(): array
+ {
+ // ...
+ }
+
+ public function canAccessBody(User $user): bool
+ {
+ // Some custom logic here
+ }
+}
+```
+
+## Available scope
+
+The `#[Security]` attribute can be used in any query, mutation or field, so anywhere you have a `#[Query]`, `#[Mutation]`
+or `#[Field]` attribute.
+
+## How to restrict access to a given resource
+
+The `is_granted` method can be used to restrict access to a specific resource.
+
+```php
+#[Security("is_granted('POST_SHOW', post)")]
+```
+
+If you are wondering how to configure these fine-grained permissions, this is not something that GraphQLite handles
+itself. Instead, this depends on the framework you are using.
+
+If you are using Symfony, you will [create a custom voter](https://symfony.com/doc/current/security/voters.html).
+
+If you are using Laravel, you will [create a Gate or a Policy](https://laravel.com/docs/6.x/authorization).
+
+If you are using another framework, you need to know that the `is_granted` function simply forwards the call to
+the `isAllowed` method of the configured `AuthorizationSerice`. See [Connecting GraphQLite to your framework's security module
+](implementing-security.md) for more details
diff --git a/website/versioned_docs/version-8.0.0/getting-started.md b/website/versioned_docs/version-8.0.0/getting-started.md
new file mode 100644
index 0000000000..4eadcfa3fe
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/getting-started.md
@@ -0,0 +1,16 @@
+---
+id: getting-started
+title: Getting started
+sidebar_label: Getting Started
+---
+
+GraphQLite is a framework agnostic library. You can use it in any PHP project as long as you know how to
+inject services in your favorite framework's container.
+
+Currently, we provide bundle/packages to help you get started with Symfony, Laravel and any framework compatible
+with container-interop/service-provider.
+
+- [Get started with Symfony](symfony-bundle.md)
+- [Get started with Laravel](laravel-package.md)
+- [Get started with a framework compatible with container-interop/service-provider](universal-service-providers.md)
+- [Get started with another framework (or no framework)](other-frameworks.mdx)
diff --git a/website/versioned_docs/version-8.0.0/implementing-security.md b/website/versioned_docs/version-8.0.0/implementing-security.md
new file mode 100644
index 0000000000..88bbd8f7f2
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/implementing-security.md
@@ -0,0 +1,57 @@
+---
+id: implementing-security
+title: Connecting GraphQLite to your framework's security module
+sidebar_label: Connecting security to your framework
+---
+
+
+ At the time of writing, the Symfony Bundle and the Laravel package handle this implementation. For the latest documentation, please see their respective Github repositories.
+
+
+GraphQLite needs to know if a user is logged or not, and what rights it has.
+But this is specific of the framework you use.
+
+To plug GraphQLite to your framework's security mechanism, you will have to provide two classes implementing:
+
+* `TheCodingMachine\GraphQLite\Security\AuthenticationServiceInterface`
+* `TheCodingMachine\GraphQLite\Security\AuthorizationServiceInterface`
+
+Those two interfaces act as adapters between GraphQLite and your framework:
+
+```php
+interface AuthenticationServiceInterface
+{
+ /**
+ * Returns true if the "current" user is logged
+ */
+ public function isLogged(): bool;
+
+ /**
+ * Returns an object representing the current logged user.
+ * Can return null if the user is not logged.
+ */
+ public function getUser(): ?object;
+}
+```
+
+```php
+interface AuthorizationServiceInterface
+{
+ /**
+ * Returns true if the "current" user has access to the right "$right"
+ *
+ * @param mixed $subject The scope this right applies on. $subject is typically an object or a FQCN. Set $subject to "null" if the right is global.
+ */
+ public function isAllowed(string $right, $subject = null): bool;
+}
+```
+
+You need to write classes that implement these interfaces. Then, you must register those classes with GraphQLite.
+It you are [using the `SchemaFactory`](other-frameworks.mdx), you can register your classes using:
+
+```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);
+```
diff --git a/website/versioned_docs/version-8.0.0/inheritance-interfaces.mdx b/website/versioned_docs/version-8.0.0/inheritance-interfaces.mdx
new file mode 100644
index 0000000000..5467492c52
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/inheritance-interfaces.mdx
@@ -0,0 +1,162 @@
+---
+id: inheritance-interfaces
+title: Inheritance and interfaces
+sidebar_label: Inheritance and interfaces
+---
+
+## Modeling inheritance
+
+Some of your entities may extend other entities. GraphQLite will do its best to represent this hierarchy of objects in GraphQL using interfaces.
+
+Let's say you have two classes, `Contact` and `User` (which extends `Contact`):
+
+```php
+#[Type]
+class Contact
+{
+ // ...
+}
+
+#[Type]
+class User extends Contact
+{
+ // ...
+}
+```
+
+Now, let's assume you have a query that returns a contact:
+
+```php
+class ContactController
+{
+ #[Query]
+ public function getContact(): Contact
+ {
+ // ...
+ }
+}
+```
+
+When writing your GraphQL query, you are able to use fragments to retrieve fields from the `User` type:
+
+```graphql
+contact {
+ name
+ ... User {
+ email
+ }
+}
+```
+
+Written in [GraphQL type language](https://graphql.org/learn/schema/#type-language), the representation of types
+would look like this:
+
+```graphql
+interface ContactInterface {
+ // List of fields declared in Contact class
+}
+
+type Contact implements ContactInterface {
+ // List of fields declared in Contact class
+}
+
+type User implements ContactInterface {
+ // List of fields declared in Contact and User classes
+}
+```
+
+Behind the scene, GraphQLite will detect that the `Contact` class is extended by the `User` class.
+Because the class is extended, a GraphQL `ContactInterface` interface is created dynamically.
+
+The GraphQL `User` type will also automatically implement this `ContactInterface`. The interface contains all the fields
+available in the `Contact` type.
+
+## Mapping interfaces
+
+If you want to create a pure GraphQL interface, you can also add a `#[Type]` attribute on a PHP interface.
+
+```php
+#[Type]
+interface UserInterface
+{
+ #[Field]
+ public function getUserName(): string;
+}
+```
+
+This will automatically create a GraphQL interface whose description is:
+
+```graphql
+interface UserInterface {
+ userName: String!
+}
+```
+
+### Implementing interfaces
+
+You don't have to do anything special to implement an interface in your GraphQL types.
+Simply "implement" the interface in PHP and you are done!
+
+```php
+#[Type]
+class User implements UserInterface
+{
+ public function getUserName(): string;
+}
+```
+
+This will translate in GraphQL schema as:
+
+```graphql
+interface UserInterface {
+ userName: String!
+}
+
+type User implements UserInterface {
+ userName: String!
+}
+```
+
+Please note that you do not need to put the `#[Field]` attribute again in the implementing class.
+
+### Interfaces without an explicit implementing type
+
+You don't have to explicitly put a `#[Type]` attribute on the class implementing the interface (though this
+is usually a good idea).
+
+```php
+/**
+ * Look, this class has no #Type attribute
+ */
+class User implements UserInterface
+{
+ public function getUserName(): string;
+}
+```
+
+```php
+class UserController
+{
+ #[Query]
+ public function getUser(): UserInterface // This will work!
+ {
+ // ...
+ }
+}
+```
+
+If GraphQLite cannot find a proper GraphQL Object type implementing an interface, it
+will create an object type "on the fly".
+
+In the example above, because the `User` class has no `#[Type]` attribute, GraphQLite will
+create a `UserImpl` type that implements `UserInterface`.
+
+```graphql
+interface UserInterface {
+ userName: String!
+}
+
+type UserImpl implements UserInterface {
+ userName: String!
+}
+```
diff --git a/website/versioned_docs/version-8.0.0/input-types.mdx b/website/versioned_docs/version-8.0.0/input-types.mdx
new file mode 100644
index 0000000000..9b5be40278
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/input-types.mdx
@@ -0,0 +1,333 @@
+---
+id: input-types
+title: Input types
+sidebar_label: Input types
+---
+
+Let's assume you are developing an API that returns a list of cities around a location.
+
+Your GraphQL query might look like this:
+
+```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;
+ }
+}
+```
+
+If you try to run this code, you will get the following error:
+
+```
+CannotMapTypeException: cannot map class "Location" to a known GraphQL input type. Check your TypeMapper configuration.
+```
+
+You are running into this error because GraphQLite does not know how to handle the `Location` object.
+
+In GraphQL, an object passed in parameter of a query or mutation (or any field) is called an **Input Type**.
+
+There are two ways for declaring that type, in GraphQLite: using the [`#[Input]` attribute](#input-attribute) or a [Factory method](#factory).
+
+## #\[Input\] Attribute
+
+Using the `#[Input]` attribute, we can transform the `Location` class, in the example above, into an input type. Just add the `#[Field]` attribute to the corresponding properties:
+
+```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;
+ }
+}
+```
+
+Now if you call the `getCities` query, from the controller in the first example, the `Location` object will be automatically instantiated with the user provided, `latitude` / `longitude` properties, and passed to the controller as a parameter.
+
+There are some important things to notice:
+
+- The `#[Field]` attribute is recognized on properties for Input Type, as well as setters.
+- There are 3 ways for fields to be resolved:
+ - Via constructor if corresponding properties are mentioned as parameters with the same names - exactly as in the example above.
+ - If properties are public, they will be just set without any additional effort - no constructor required.
+ - For private or protected properties implemented, a public setter is required (if they are not set via the constructor). For example `setLatitude(float $latitude)`. You can also put the `#[Field]` attribute on the setter, instead of the property, allowing you to have use many other attributes (`Security`, `Right`, `Autowire`, etc.).
+- For validation of these Input Types, see the [Custom InputType Validation section](validation#custom-inputtype-validation).
+- It's advised to use the `#[Input]` attribute on DTO style input type objects and not directly on your model objects. Using it on your model objects can cause coupling in undesirable ways.
+
+### Multiple Input Types from the same class
+
+Simple usage of the `#[Input]` attribute on a class creates a GraphQL input named by class name + "Input" suffix if a class name does not end with it already. Ex. `LocationInput` for `Location` class.
+
+You can add multiple `#[Input]` attributed to the same class, give them different names and link different fields.
+Consider the following example:
+
+```php
+#[Input(name: 'CreateUserInput', default: true)]
+#[Input(name: 'UpdateUserInput', update: true)]
+class UserInput
+{
+
+ #[Field]
+ public string $username;
+
+ #[Field(for: 'CreateUserInput')]
+ public string $email;
+
+ #[Field(for: 'CreateUserInput', inputType: 'String!')]
+ #[Field(for: 'UpdateUserInput', inputType: 'String')]
+ public string $password;
+
+ protected ?int $age;
+
+
+ #[Field]
+ public function setAge(?int $age): void
+ {
+ $this->age = $age;
+ }
+}
+```
+
+There are 2 input types added to the `UserInput` class: `CreateUserInput` and `UpdateUserInput`. A few notes:
+- `CreateUserInput` input will be used by default for this class.
+- Field `username` is created for both input types, and it is required because the property type is not nullable.
+- Field `email` will appear only for `CreateUserInput` input.
+- Field `password` will appear for both. For `CreateUserInput` it'll be the required field and for `UpdateUserInput` optional.
+- Field `age` is optional for both input types.
+
+Note that `update: true` argument for `UpdateUserInput`. It should be used when input type is used for a partial update,
+It makes all fields optional and removes all default values from thus prevents setting default values via setters or directly to public properties.
+In example above if you use the class as `UpdateUserInput` and set only `username` the other ones will be ignored.
+In PHP 7 they will be set to `null`, while in PHP 8 they will be in not initialized state - this can be used as a trick
+to check if user actually passed a value for a certain field.
+
+## Factory
+
+A **Factory** is a method that takes in parameter all the fields of the input type and return an object.
+
+Here is an example of factory:
+
+```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);
+ }
+}
+```
+
+and now, you can run query like this:
+
+```graphql
+query {
+ getCities(location: {
+ latitude: 45.0,
+ longitude: 0.0,
+ },
+ radius: 42)
+ {
+ id,
+ name
+ }
+}
+```
+
+- Factories must be declared with the **#[Factory]** attribute.
+- The parameters of the factories are the field of the GraphQL input type
+
+A few important things to notice:
+
+- The container MUST contain the factory class. The identifier of the factory MUST be the fully qualified class name of the class that contains the factory.
+ This is usually already the case if you are using a container with auto-wiring capabilities
+- We recommend that you put the factories in the same directories as the types.
+
+### Specifying the input type name
+
+The GraphQL input type name is derived from the return type of the factory.
+
+Given the factory below, the return type is "Location", therefore, the GraphQL input type will be named "LocationInput".
+
+```php
+#[Factory]
+public function createLocation(float $latitude, float $longitude): Location
+{
+ return new Location($latitude, $longitude);
+}
+```
+
+In case you want to override the input type name, you can use the "name" attribute of the #[Factory] attribute:
+
+```php
+#[Factory(name: 'MyNewInputName', default: true)]
+```
+
+Note that you need to add the "default" attribute is you want your factory to be used by default (more on this in
+the next chapter).
+
+Unless you want to have several factories for the same PHP class, the input type name will be completely transparent
+to you, so there is no real reason to customize it.
+
+### Forcing an input type
+
+You can use the `#[UseInputType]` attribute to force an input type of a parameter.
+
+Let's say you want to force a parameter to be of type "ID", you can use this:
+
+```php
+#[Factory]
+#[UseInputType(for: "$id", inputType:"ID!")]
+public function getProductById(string $id): Product
+{
+ return $this->productRepository->findById($id);
+}
+```
+
+### Declaring several input types for the same PHP class
+Available in GraphQLite 4.0+
+
+There are situations where a given PHP class might use one factory or another depending on the context.
+
+This is often the case when your objects map database entities.
+In these cases, you can use combine the use of `#[UseInputType]` and `#[Factory]` attribute to achieve your goal.
+
+Here is an annotated sample:
+
+```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
+ {
+ // ...
+ }
+}
+```
+
+### Ignoring some parameters
+Available in GraphQLite 4.0+
+
+GraphQLite will automatically map all your parameters to an input type.
+But sometimes, you might want to avoid exposing some of those parameters.
+
+Image your `getProductById` has an additional `lazyLoad` parameter. This parameter is interesting when you call
+directly the function in PHP because you can have some level of optimisation on your code. But it is not something that
+you want to expose in the GraphQL API. Let's hide it!
+
+```php
+#[Factory]
+public function getProductById(
+ string $id,
+ #[HideParameter]
+ bool $lazyLoad = true
+ ): Product
+{
+ return $this->productRepository->findById($id, $lazyLoad);
+}
+```
+
+With the `#[HideParameter]` attribute, you can choose to remove from the GraphQL schema any argument.
+
+To be able to hide an argument, the argument must have a default value.
diff --git a/website/versioned_docs/version-8.0.0/internals.md b/website/versioned_docs/version-8.0.0/internals.md
new file mode 100644
index 0000000000..93c7e958b8
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/internals.md
@@ -0,0 +1,142 @@
+---
+id: internals
+title: Internals
+sidebar_label: Internals
+---
+
+## Mapping types
+
+The core of GraphQLite is its ability to map PHP types to GraphQL types. This mapping is performed by a series of
+"type mappers".
+
+GraphQLite contains 4 categories of type mappers:
+
+- **Parameter mappers**
+- **Root type mappers**
+- **Recursive (class) type mappers**
+- **(class) type mappers**
+
+```mermaid
+graph TD;
+ classDef custom fill:#cfc,stroke:#7a7,stroke-width:2px,stroke-dasharray: 5, 5;
+ subgraph RootTypeMapperInterface
+ NullableTypeMapperAdapter-->CompoundTypeMapper
+ IteratorTypeMapper-->YourCustomRootTypeMapper
+ CompoundTypeMapper-->IteratorTypeMapper
+ YourCustomRootTypeMapper-->MyCLabsEnumTypeMapper
+ MyCLabsEnumTypeMapper-->EnumTypeMapper
+ EnumTypeMapper-->BaseTypeMapper
+ BaseTypeMapper-->FinalRootTypeMapper
+ end
+ subgraph RecursiveTypeMapperInterface
+ BaseTypeMapper-->RecursiveTypeMapper
+ end
+ subgraph TypeMapperInterface
+ RecursiveTypeMapper-->YourCustomTypeMapper
+ YourCustomTypeMapper-->PorpaginasTypeMapper
+ PorpaginasTypeMapper-->GlobTypeMapper
+ end
+ class YourCustomRootTypeMapper,YourCustomTypeMapper custom;
+```
+
+## Root type mappers
+
+(Classes implementing the [`RootTypeMapperInterface`](https://github.com/thecodingmachine/graphqlite/blob/master/src/Mappers/Root/RootTypeMapperInterface.php))
+
+These type mappers are the first type mappers called.
+
+They are responsible for:
+
+- mapping scalar types (for instance mapping the "int" PHP type to GraphQL Integer type)
+- detecting nullable/non-nullable types (for instance interpreting "?int" or "int|null")
+- mapping list types (mapping a PHP array to a GraphQL list)
+- mapping union types
+- mapping enums
+
+Root type mappers have access to the *context* of a type: they can access the PHP DocBlock and read annotations.
+If you want to write a custom type mapper that needs access to annotations, it needs to be a "root type mapper".
+
+GraphQLite provides 6 classes implementing `RootTypeMapperInterface`:
+
+- `NullableTypeMapperAdapter`: a type mapper in charge of making GraphQL types non-nullable if the PHP type is non-nullable
+- `IteratorTypeMapper`: a type mapper in charge of iterable types (for instance: `MyIterator|User[]`)
+- `CompoundTypeMapper`: a type mapper in charge of union types
+- `MyCLabsEnumTypeMapper`: maps MyCLabs/enum types to GraphQL enum types (Deprecated: use native enums)
+- `EnumTypeMapper`: maps PHP enums to GraphQL enum types
+- `BaseTypeMapper`: maps scalar types and lists. Passes the control to the "recursive type mappers" if an object is encountered.
+- `FinalRootTypeMapper`: the last type mapper of the chain, used to throw error if no other type mapper managed to handle the type.
+
+Type mappers are organized in a chain; each type-mapper is responsible for calling the next type mapper.
+
+```mermaid
+graph TD;
+ classDef custom fill:#cfc,stroke:#7a7,stroke-width:2px,stroke-dasharray: 5, 5;
+ subgraph RootTypeMapperInterface
+ NullableTypeMapperAdapter-->CompoundTypeMapper
+ CompoundTypeMapper-->IteratorTypeMapper
+ IteratorTypeMapper-->YourCustomRootTypeMapper
+ YourCustomRootTypeMapper-->MyCLabsEnumTypeMapper
+ MyCLabsEnumTypeMapper-->EnumTypeMapper
+ EnumTypeMapper-->BaseTypeMapper
+ BaseTypeMapper-->FinalRootTypeMapper
+ end
+ class YourCustomRootTypeMapper custom;
+```
+
+## Class type mappers
+
+(Classes implementing the [`TypeMapperInterface`](https://github.com/thecodingmachine/graphqlite/blob/master/src/Mappers/TypeMapperInterface.php))
+
+Class type mappers are mapping PHP classes to GraphQL object types.
+
+GraphQLite provide 3 default implementations:
+
+- `CompositeTypeMapper`: a type mapper that delegates mapping to other type mappers using the Composite Design Pattern.
+- `GlobTypeMapper`: scans classes in a directory for the `#[Type]` or `#[ExtendType]` attribute and maps those to GraphQL types
+- `PorpaginasTypeMapper`: maps and class implementing the Porpaginas `Result` interface to a [special paginated type](pagination.mdx).
+
+### Registering a type mapper in Symfony
+
+If you are using the GraphQLite Symfony bundle, you can register a type mapper by tagging the service with the "graphql.type_mapper" tag.
+
+### Registering a type mapper using the SchemaFactory
+
+If you are using the `SchemaFactory` to bootstrap GraphQLite, you can register a type mapper using the `SchemaFactory::addTypeMapper` method.
+
+## Recursive type mappers
+
+(Classes implementing the [`RecursiveTypeMapperInterface`](https://github.com/thecodingmachine/graphqlite/blob/master/src/Mappers/RecursiveTypeMapperInterface.php))
+
+There is only one implementation of the `RecursiveTypeMapperInterface`: the `RecursiveTypeMapper`.
+
+Standard "class type mappers" are mapping a given PHP class to a GraphQL type. But they do not handle class hierarchies.
+This is the role of the "recursive type mapper".
+
+Imagine that class "B" extends class "A" and class "A" maps to GraphQL type "AType".
+
+Since "B" *is a* "A", the "recursive type mapper" role is to make sure that "B" will also map to GraphQL type "AType".
+
+## Parameter mapper middlewares
+
+"Parameter middlewares" are used to decide what argument should be injected into a parameter.
+
+Let's have a look at a simple query:
+
+```php
+/**
+ * @return Product[]
+ */
+#[Query]
+public function products(ResolveInfo $info): array
+```
+
+As you may know, [the `ResolveInfo` object injected in this query comes from Webonyx/GraphQL-PHP library](query-plan.mdx).
+GraphQLite knows that is must inject a `ResolveInfo` instance because it comes with a [`ResolveInfoParameterHandler`](https://github.com/thecodingmachine/graphqlite/blob/master/src/Mappers/Parameters/ResolveInfoParameterHandler.php) class
+that implements the [`ParameterMiddlewareInterface`](https://github.com/thecodingmachine/graphqlite/blob/master/src/Mappers/Parameters/ParameterMiddlewareInterface.php)).
+
+You can register your own parameter middlewares using the `SchemaFactory::addParameterMiddleware()` method, or by tagging the
+service as "graphql.parameter_middleware" if you are using the Symfony bundle.
+
+
+ Use a parameter middleware if you want to inject an argument in a method and if this argument is not a GraphQL input type or if you want to alter the way input types are imported (for instance if you want to add a validation step)
+
diff --git a/website/versioned_docs/version-8.0.0/laravel-package-advanced.mdx b/website/versioned_docs/version-8.0.0/laravel-package-advanced.mdx
new file mode 100644
index 0000000000..3341538023
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/laravel-package-advanced.mdx
@@ -0,0 +1,221 @@
+---
+id: laravel-package-advanced
+title: "Laravel package: advanced usage"
+sidebar_label: Laravel specific features
+---
+
+
+
Be advised! This documentation will be removed in a future release. For current and up-to-date Laravel extension specific documentation, please see the
Github repository.
+
+ Be sure to type hint on the class (Illuminate\Pagination\LengthAwarePaginator) and not on the interface (Illuminate\Contracts\Pagination\LengthAwarePaginator). The interface itself is not iterable (it does not extend Traversable) and therefore, GraphQLite will refuse to iterate over it.
+
+
+### Simple paginator
+
+Note: if you are using `simplePaginate` instead of `paginate`, you can type hint on the `Illuminate\Pagination\Paginator` class.
+
+```php
+class MyController
+{
+ /**
+ * @return Product[]
+ */
+ #[Query]
+ public function products(): Illuminate\Pagination\Paginator
+ {
+ return Product::simplePaginate(15);
+ }
+}
+```
+
+The behaviour will be exactly the same except you will be missing the `totalCount` and `lastPage` fields.
+
+## Using GraphQLite with Eloquent efficiently
+
+In GraphQLite, you are supposed to put a `#[Field]` attribute on each getter.
+
+Eloquent uses PHP magic properties to expose your database records.
+Because Eloquent relies on magic properties, it is quite rare for an Eloquent model to have proper getters and setters.
+
+So we need to find a workaround. GraphQLite comes with a `#[MagicField]` attribute to help you
+working with magic properties.
+
+```php
+#[Type]
+#[MagicField(name: "id", outputType: "ID!")]
+#[MagicField(name: "name", phpType: "string")]
+#[MagicField(name: "categories", phpType: "Category[]")]
+class Product extends Model
+{
+}
+```
+
+Please note that since the properties are "magic", they don't have a type. Therefore,
+you need to pass either the "outputType" attribute with the GraphQL type matching the property,
+or the "phpType" attribute with the PHP type matching the property.
+
+### Pitfalls to avoid with Eloquent
+
+When designing relationships in Eloquent, you write a method to expose that relationship this way:
+
+```php
+class User extends Model
+{
+ /**
+ * Get the phone record associated with the user.
+ */
+ public function phone()
+ {
+ return $this->hasOne('App\Phone');
+ }
+}
+```
+
+It would be tempting to put a `#[Field]` attribute on the `phone()` method, but this will not work. Indeed,
+the `phone()` method does not return a `App\Phone` object. It is the `phone` magic property that returns it.
+
+In short:
+
+
+ This does not work:
+
+```php
+class User extends Model
+{
+
+ #[Field]
+ public function phone()
+ {
+ return $this->hasOne('App\Phone');
+ }
+}
+```
+
+
+
+
+ This works:
+
+```php
+#[MagicField(name: "phone", phpType:"App\\Phone")]
+class User extends Model
+{
+ public function phone()
+ {
+ return $this->hasOne('App\Phone');
+ }
+}
+```
+
+
+
+## Export the schema from the CLI
+
+The extension comes with a special command: `graphqlite:export-schema`.
+
+Usage:
+
+```console
+$ ./artisan graphqlite:export-schema --output=schema.graphql
+```
+
+This will export your GraphQL schema in SDL format. You can use this exported schema to import it in other
+tools (like graphql-codegen).
\ No newline at end of file
diff --git a/website/versioned_docs/version-8.0.0/laravel-package.md b/website/versioned_docs/version-8.0.0/laravel-package.md
new file mode 100644
index 0000000000..d7014c2bcc
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/laravel-package.md
@@ -0,0 +1,153 @@
+---
+id: laravel-package
+title: Getting started with Laravel
+sidebar_label: Laravel package
+---
+
+
+
Be advised! This documentation will be removed in a future release. For current and up-to-date Laravel extension specific documentation, please see the
Github repository.
+
By default, the
/graphql route is placed under
web middleware group which requires a
+
CSRF token.
Heads up! If you are not using a framework with an autowiring container (like Symfony or Laravel), please be aware that the MyController class must exist in the container of your application. Furthermore, the identifier of the controller in the container MUST be the fully qualified class name of controller.
+
+## About attributes
+
+GraphQLite relies a lot on attributes.
+
+It supports the new PHP 8 attributes (`#[Query]`), the "Doctrine annotations" style (`#[Query]`) was dropped.
+
+## Testing the query
+
+The default GraphQL endpoint is `/graphql`.
+
+The easiest way to test a GraphQL endpoint is to use [GraphiQL](https://github.com/graphql/graphiql) or
+[Altair](https://altair.sirmuel.design/) clients (they are available as Chrome or Firefox plugins)
+
+
+ If you are using the Symfony bundle, GraphiQL is also directly embedded.
+ Simply head to http://[path-to-my-app]/graphiql
+
+
+Here a query using our simple *Hello World* example:
+
+
+
+## Query with a type
+
+So far, we simply declared a query. But we did not yet declare a type.
+
+Let's assume you want to return a product:
+
+```php
+namespace App\Controller;
+
+use TheCodingMachine\GraphQLite\Annotations\Query;
+
+class ProductController
+{
+ #[Query]
+ public function product(string $id): Product
+ {
+ // Some code that looks for a product and returns it.
+ }
+}
+```
+
+
+As the `Product` class is not a scalar type, you must tell GraphQLite how to handle it:
+
+```php
+namespace App\Entities;
+
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Type;
+
+#[Type]
+class Product
+{
+ // ...
+
+ #[Field]
+ public function getName(): string
+ {
+ return $this->name;
+ }
+
+ #[Field]
+ public function getPrice(): ?float
+ {
+ return $this->price;
+ }
+}
+```
+
+The `#[Type]` attribute is used to inform GraphQLite that the `Product` class is a GraphQL type.
+
+The `#[Field]` attribute is used to define the GraphQL fields. This attribute must be put on a **public method**.
+
+The `Product` class must be in one of the *types* namespaces. As for *controller* classes, you configured this namespace when you installed
+GraphQLite. By default, in Symfony, the allowed types namespaces are `App\Entity` and `App\Types`.
+
+This query is equivalent to the following [GraphQL type language](https://graphql.org/learn/schema/#type-language):
+
+```graphql
+Type Product {
+ name: String!
+ price: Float
+}
+```
+
+
+
If you are used to Domain driven design, you probably
+ realize that the Product class is part of your domain.
+
GraphQL attributes are adding some serialization logic that is out of scope of the domain.
+ These are just attributes and for most project, this is the fastest and easiest route.
+
If you feel that GraphQL attributes do not belong to the domain, or if you cannot modify the class
+ directly (maybe because it is part of a third party library), there is another way to create types without annotating
+ the domain class. We will explore that in the next chapter.
+
+ In the future, it may make sense to implement streaming servers directly into GraphQLite, especially
+ as PHP progresses with async and parallel processing. At this time, we might consider returning a
+ `Generator` (or `Fiber`) from the controller method.
+
diff --git a/website/versioned_docs/version-8.0.0/symfony-bundle-advanced.mdx b/website/versioned_docs/version-8.0.0/symfony-bundle-advanced.mdx
new file mode 100644
index 0000000000..c34c6d7628
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/symfony-bundle-advanced.mdx
@@ -0,0 +1,169 @@
+---
+id: symfony-bundle-advanced
+title: "Symfony bundle: advanced usage"
+sidebar_label: Symfony specific features
+---
+
+
+
Be advised! This documentation will be removed in a future release. For current and up-to-date Symfony bundle specific documentation, please see the
Github repository.
+
+
Be advised! This documentation will be removed in a future release. For current and up-to-date Symfony bundle specific documentation, please see the
Github repository.
+
App\Controller namespace Symfony applies a particular compiler pass to classes in the App\Controller namespace. This compiler pass will prevent you from using input types. Put your controllers in another namespace. We advise using App\GraphqlController.
+
+
+The Symfony bundle come with a set of advanced features that are not described in this install documentation (like providing a login/logout mutation out of the box). Jump to the ["Symfony specific features"](symfony-bundle-advanced.mdx) documentation of GraphQLite if you want to learn more.
diff --git a/website/versioned_docs/version-8.0.0/troubleshooting.md b/website/versioned_docs/version-8.0.0/troubleshooting.md
new file mode 100644
index 0000000000..862cf9b4e7
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/troubleshooting.md
@@ -0,0 +1,25 @@
+---
+id: troubleshooting
+title: Troubleshooting
+sidebar_label: Troubleshooting
+---
+
+**Error: Maximum function nesting level of '100' reached**
+
+Webonyx's GraphQL library tends to use a very deep stack.
+This error does not necessarily mean your code is going into an infinite loop.
+Simply try to increase the maximum allowed nesting level in your XDebug conf:
+
+```
+xdebug.max_nesting_level=500
+```
+
+
+**Cannot autowire service "_[some input type]_": argument "$..." of method "..." is type-hinted "...", you should configure its value explicitly.**
+
+The message says that Symfony is trying to instantiate an input type as a service. This can happen if you put your
+GraphQLite controllers in the Symfony controller namespace (`App\Controller` by default). Symfony will assume that any
+object type-hinted in a method of a controller is a service ([because all controllers are tagged with the "controller.service_arguments" tag](https://symfony.com/doc/current/service_container/3.3-di-changes.html#controllers-are-registered-as-services))
+
+To fix this issue, do not put your GraphQLite controller in the same namespace as the Symfony controllers and
+reconfigure your `config/graphqlite.yml` file to point to your new namespace.
diff --git a/website/versioned_docs/version-8.0.0/type-mapping.mdx b/website/versioned_docs/version-8.0.0/type-mapping.mdx
new file mode 100644
index 0000000000..d5b6c4dc29
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/type-mapping.mdx
@@ -0,0 +1,383 @@
+---
+id: type-mapping
+title: Type mapping
+sidebar_label: Type mapping
+---
+
+As explained in the [queries](queries.mdx) section, the job of GraphQLite is to create GraphQL types from PHP types.
+
+## Scalar mapping
+
+Scalar PHP types can be type-hinted to the corresponding GraphQL types:
+
+* `string`
+* `int`
+* `bool`
+* `float`
+
+For instance:
+
+```php
+namespace App\Controller;
+
+use TheCodingMachine\GraphQLite\Annotations\Query;
+
+class MyController
+{
+ #[Query]
+ public function hello(string $name): string
+ {
+ return 'Hello ' . $name;
+ }
+}
+```
+
+## Class mapping
+
+When returning a PHP class in a query, you must annotate this class using `#[Type]` and `#[Field]` attributes:
+
+```php
+namespace App\Entities;
+
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Type;
+
+#[Type]
+class Product
+{
+ // ...
+
+ #[Field]
+ public function getName(): string
+ {
+ return $this->name;
+ }
+
+ #[Field]
+ public function getPrice(): ?float
+ {
+ return $this->price;
+ }
+}
+```
+
+**Note:** The GraphQL output type name generated by GraphQLite is equal to the class name of the PHP class. So if your
+PHP class is `App\Entities\Product`, then the GraphQL type will be named "Product".
+
+In case you have several types with the same class name in different namespaces, you will face a naming collision.
+Hopefully, you can force the name of the GraphQL output type using the "name" attribute:
+
+```php
+#[Type(name: "MyProduct")]
+class Product { /* ... */ }
+```
+
+
+
+## Array mapping
+
+You can type-hint against arrays (or iterators) as long as you add a detailed `@return` statement in the PHPDoc.
+
+```php
+/**
+ * @return User[] <=== we specify that the array is an array of User objects.
+ */
+#[Query]
+public function users(int $limit, int $offset): array
+{
+ // Some code that returns an array of "users".
+}
+```
+
+## ID mapping
+
+GraphQL comes with a native `ID` type. PHP has no such type.
+
+There are two ways with GraphQLite to handle such type.
+
+### Force the outputType
+
+```php
+#[Field(outputType: "ID")]
+public function getId(): string
+{
+ // ...
+}
+```
+
+Using the `outputType` attribute of the `#[Field]` attribute, you can force the output type to `ID`.
+
+You can learn more about forcing output types in the [custom types section](custom-types.mdx).
+
+### ID class
+
+```php
+use TheCodingMachine\GraphQLite\Types\ID;
+
+#[Field]
+public function getId(): ID
+{
+ // ...
+}
+```
+
+Note that you can also use the `ID` class as an input type:
+
+```php
+use TheCodingMachine\GraphQLite\Types\ID;
+
+#[Mutation]
+public function save(ID $id, string $name): Product
+{
+ // ...
+}
+```
+
+## Date mapping
+
+Out of the box, GraphQL does not have a `DateTime` type, but we took the liberty to add one, with sensible defaults.
+
+When used as an output type, `DateTimeImmutable` or `DateTimeInterface` PHP classes are
+automatically mapped to this `DateTime` GraphQL type.
+
+```php
+#[Field]
+public function getDate(): \DateTimeInterface
+{
+ return $this->date;
+}
+```
+
+The `date` field will be of type `DateTime`. In the returned JSON response to a query, the date is formatted as a string
+in the **ISO8601** format (aka ATOM format).
+
+
+ PHP DateTime type is not supported.
+
+
+## Union types
+
+Union types for return are supported in GraphQLite as of version 6.0:
+
+```php
+#[Query]
+public function companyOrContact(int $id): Company|Contact
+{
+ // Some code that returns a company or a contact.
+}
+```
+
+## Enum types
+
+PHP 8.1 introduced native support for Enums. GraphQLite now also supports native enums as of version 5.1.
+
+```php
+#[Type]
+enum Status: string
+{
+ case ON = 'on';
+ case OFF = 'off';
+ case PENDING = 'pending';
+}
+```
+
+```php
+/**
+ * @return User[]
+ */
+#[Query]
+public function users(Status $status): array
+{
+ if ($status === Status::ON) {
+ // Your logic
+ }
+ // ...
+}
+```
+
+```graphql
+query users($status: Status!) {}
+ users(status: $status) {
+ id
+ }
+}
+```
+
+By default, the name of the GraphQL enum type will be the name of the class. If you have a naming conflict (two classes
+that live in different namespaces with the same class name), you can solve it using the `name` property on the `#[Type]` attribute:
+
+```php
+namespace Model\User;
+
+#[Type(name: "UserStatus")]
+enum Status: string
+{
+ // ...
+}
+```
+
+### Enum types with myclabs/php-enum
+
+
+ This implementation is now deprecated and will be removed in the future. You are advised to use native enums instead.
+
+
+*Prior to version 5.1, GraphQLite only supported Enums through the 3rd party library, [myclabs/php-enum](https://github.com/myclabs/php-enum). If you'd like to use this implementation you'll first need to add this library as a dependency to your application.*
+
+```bash
+$ composer require myclabs/php-enum
+```
+
+Now, any class extending the `MyCLabs\Enum\Enum` class will be mapped to a GraphQL enum:
+
+```php
+use MyCLabs\Enum\Enum;
+
+class StatusEnum extends Enum
+{
+ private const ON = 'on';
+ private const OFF = 'off';
+ private const PENDING = 'pending';
+}
+```
+
+```php
+/**
+ * @return User[]
+ */
+#[Query]
+public function users(StatusEnum $status): array
+{
+ if ($status == StatusEnum::ON()) {
+ // Note that the "magic" ON() method returns an instance of the StatusEnum class.
+ // Also, note that we are comparing this instance using "==" (using "===" would fail as we have 2 different instances here)
+ // ...
+ }
+ // ...
+}
+```
+
+```graphql
+query users($status: StatusEnum!) {}
+ users(status: $status) {
+ id
+ }
+}
+```
+
+By default, the name of the GraphQL enum type will be the name of the class. If you have a naming conflict (two classes
+that live in different namespaces with the same class name), you can solve it using the `#[EnumType]` attribute:
+
+```php
+use TheCodingMachine\GraphQLite\Annotations\EnumType;
+
+#[EnumType(name: "UserStatus")]
+class StatusEnum extends Enum
+{
+ // ...
+}
+```
+
+GraphQLite must be able to find all the classes extending the "MyCLabs\Enum" class
+in your project. By default, GraphQLite will look for "Enum" classes in the namespaces declared for the types. For this
+reason, your enum classes MUST be in one of the namespaces declared for the types in your GraphQLite
+configuration file.
+
+## Deprecation of fields
+
+You can mark a field as deprecated in your GraphQL Schema by just annotating it with the `@deprecated` PHPDoc annotation. Note that a description (reason) is required for the annotation to be rendered.
+
+```php
+namespace App\Entities;
+
+use TheCodingMachine\GraphQLite\Annotations\Field;
+use TheCodingMachine\GraphQLite\Annotations\Type;
+
+#[Type]
+class Product
+{
+ // ...
+
+ #[Field]
+ public function getName(): string
+ {
+ return $this->name;
+ }
+
+ /**
+ * @deprecated use field `name` instead
+ */
+ #[Field]
+ public function getProductName(): string
+ {
+ return $this->name;
+ }
+}
+```
+
+This will add the `@deprecated` directive to the field in the GraphQL Schema which sets the `isDeprecated` field to `true` and adds the reason to the `deprecationReason` field in an introspection query. Fields marked as deprecated can still be queried, but will be returned in an introspection query only if `includeDeprecated` is set to `true`.
+
+```graphql
+query {
+ __type(name: "Product") {
+ fields(includeDeprecated: true) {
+ name
+ isDeprecated
+ deprecationReason
+ }
+ }
+}
+```
+
+## Promise mapping
+
+GraphQL includes a native \GraphQL\Deferred type.
+You can map the return type by adding a detailed `@return` statement in the PHPDoc.
+An alternative to the `@return` statement is using `#[Field(outputType: SomeGQLType)]`.
+
+All the previously mentioned mappings work with Promises, except when a return type is explicitly declared
+in the method signature.
+
+This allows you to use \Overblog\DataLoader\DataLoader as an alternative
+for resolving N+1 query issues and caching intermediate results.
+
+```php
+#[Type]
+class Product
+{
+ // ...
+
+ /**
+ * @return string
+ */
+ #[Field]
+ public function getName(): Deferred
+ {
+ return new Deferred(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;
+ }
+}
+```
+
+## More scalar types
+
+Available in GraphQLite 4.0+
+
+GraphQL supports "custom" scalar types. GraphQLite supports adding more GraphQL scalar types.
+
+If you need more types, you can check the [GraphQLite Misc. Types library](https://github.com/thecodingmachine/graphqlite-misc-types).
+It adds support for more scalar types out of the box in GraphQLite.
+
+Or if you have some special needs, [you can develop your own scalar types](custom-types#registering-a-custom-scalar-type-advanced).
diff --git a/website/versioned_docs/version-8.0.0/universal-service-providers.md b/website/versioned_docs/version-8.0.0/universal-service-providers.md
new file mode 100644
index 0000000000..8375b0e1e4
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/universal-service-providers.md
@@ -0,0 +1,74 @@
+---
+id: universal-service-providers
+title: "Getting started with a framework compatible with container-interop/service-provider"
+sidebar_label: Universal service providers
+---
+
+[container-interop/service-provider](https://github.com/container-interop/service-provider/) is an experimental project
+aiming to bring interoperability between framework module systems.
+
+If your framework is compatible with [container-interop/service-provider](https://github.com/container-interop/service-provider/),
+GraphQLite comes with a service provider that you can leverage.
+
+## Installation
+
+Open a terminal in your current project directory and run:
+
+```console
+$ composer require thecodingmachine/graphqlite-universal-service-provider
+```
+
+## Requirements
+
+In order to bootstrap GraphQLite, you will need:
+
+- A PSR-16 cache
+
+Additionally, you will have to route the HTTP requests to the underlying GraphQL library.
+
+GraphQLite relies on the [webonyx/graphql-php](http://webonyx.github.io/graphql-php/) library internally.
+This library plays well with PSR-7 requests and we provide a [PSR-15 middleware](other-frameworks.mdx).
+
+## Integration
+
+Webonyx/graphql-php library requires a [Schema](https://webonyx.github.io/graphql-php/type-system/schema/) in order to resolve
+GraphQL queries. The service provider provides this `Schema` class.
+
+[Checkout the the service-provider documentation](https://github.com/thecodingmachine/graphqlite-universal-service-provider)
+
+## Sample usage
+
+```json title="composer.json"
+{
+ "require": {
+ "mnapoli/simplex": "^0.5",
+ "thecodingmachine/graphqlite-universal-service-provider": "^3",
+ "thecodingmachine/symfony-cache-universal-module": "^1"
+ },
+ "minimum-stability": "dev",
+ "prefer-stable": true
+}
+```
+
+```php title="index.php"
+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);
+```
diff --git a/website/versioned_docs/version-8.0.0/validation.mdx b/website/versioned_docs/version-8.0.0/validation.mdx
new file mode 100644
index 0000000000..dde8a9413a
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/validation.mdx
@@ -0,0 +1,188 @@
+---
+id: validation
+title: Validation
+sidebar_label: User input validation
+---
+
+GraphQLite does not handle user input validation by itself. It is out of its scope.
+
+However, it can integrate with your favorite framework validation mechanism. The way you validate user input will
+therefore depend on the framework you are using.
+
+## Validating user input with Laravel
+
+If you are using Laravel, jump directly to the [GraphQLite Laravel package advanced documentation](laravel-package-advanced.mdx#support-for-laravel-validation-rules)
+to learn how to use the Laravel validation with GraphQLite.
+
+## Validating user input with Symfony validator
+
+GraphQLite provides a bridge to use the [Symfony validator](https://symfony.com/doc/current/validation.html) directly in your application.
+
+- If you are using Symfony and the Symfony GraphQLite bundle, the bridge is available out of the box
+- If you are using another framework, the "Symfony validator" component can be used in standalone mode. If you want to
+ add it to your project, you can require the *thecodingmachine/graphqlite-symfony-validator-bridge* package:
+
+ ```bash
+ $ composer require thecodingmachine/graphqlite-symfony-validator-bridge
+ ```
+
+### Using the Symfony validator bridge
+
+Usually, when you use the Symfony validator component, you put attributes in your entities and you validate those entities
+using the `Validator` object.
+
+```php title="UserController.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
+ // ...
+ }
+}
+```
+
+Validation rules are added directly to the object in the domain model:
+
+```php title="User.php"
+use Symfony\Component\Validator\Constraints as Assert;
+
+class User
+{
+ #[Assert\Email(message: "The email '{{ value }}' is not a valid email.", checkMX: true)]
+ private $email;
+
+ /**
+ * The NotCompromisedPassword assertion asks the "HaveIBeenPawned" service if your password has already leaked or not.
+ */
+ #[Assert\NotCompromisedPassword]
+ private $password;
+
+ public function __construct(string $email, string $password)
+ {
+ $this->email = $email;
+ $this->password = $password;
+ }
+
+ // ...
+}
+```
+
+If a validation fails, GraphQLite will return the failed validations in the "errors" section of the JSON response:
+
+```json
+{
+ "errors": [
+ {
+ "message": "The email '\"foo@thisdomaindoesnotexistatall.com\"' is not a valid email.",
+ "extensions": {
+ "code": "bf447c1c-0266-4e10-9c6c-573df282e413",
+ "field": "email"
+ }
+ }
+ ]
+}
+```
+
+
+### Using the validator directly on a query / mutation / subscription / factory ...
+
+If the data entered by the user is mapped to an object, please use the "validator" instance directly as explained in
+the last chapter. It is a best practice to put your validation layer as close as possible to your domain model.
+
+If the data entered by the user is **not** mapped to an object, you can directly annotate your query, mutation, factory...
+
+
+ You generally don't want to do this. It is a best practice to put your validation constraints
+on your domain objects. Only use this technique if you want to validate user input and user input will not be stored
+in a domain object.
+
+
+Use the `#[Assertion]` attribute to validate directly the user input.
+
+```php
+use Symfony\Component\Validator\Constraints as Assert;
+use TheCodingMachine\GraphQLite\Validator\Annotations\Assertion;
+use TheCodingMachine\GraphQLite\Annotations\Query;
+
+#[Query]
+#[Assertion(for: "email", constraint: new Assert\Email())]
+public function findByMail(string $email): User
+{
+ // ...
+}
+```
+
+Notice that the "constraint" parameter contains an attribute (it is an attribute wrapped in an attribute).
+
+You can also pass an array to the `constraint` parameter:
+
+```php
+#[Assertion(for: "email", constraint: [new Assert\NotBlack(), new Assert\Email()])]
+```
+
+## Custom InputType Validation
+
+GraphQLite also supports a fully custom validation implementation for all input types defined with an `#[Input]` attribute. This offers a way to validate input types before they're available as a method parameter of your query and mutation controllers. This way, when you're using your query or mutation controllers, you can feel confident that your input type objects have already been validated.
+
+
+
It's important to note that this validation implementation does not validate input types created with a factory. If you are creating an input type with a factory, or using primitive parameters in your query/mutation controllers, you should be sure to validate these independently. This is strictly for input type objects.
+
+
You can use one of the framework validation libraries listed above or implement your own validation for these cases. If you're using input type objects for most all of your query and mutation controllers, then there is little additional validation concerns with regards to user input. There are many reasons why you should consider defaulting to an InputType object, as opposed to individual arguments, for your queries and mutations. This is just one additional perk.
+
+
+
+Each middleware is passed number of objects describing the parameter:
+
+- a PHP `ReflectionParameter` object representing the parameter being manipulated
+- a `phpDocumentor\Reflection\DocBlock` instance (useful to analyze the `@param` comment if any)
+- a `phpDocumentor\Reflection\Type` instance (useful to analyze the type if the argument)
+- a `TheCodingMachine\GraphQLite\Annotations\ParameterAnnotations` instance. This is a collection of all custom annotations that apply to this specific argument (more on that later)
+- a `$next` handler to pass the argument resolving to the next middleware.
+
+Parameter resolution is done in 2 passes.
+
+On the first pass, middlewares are traversed. They must return a `TheCodingMachine\GraphQLite\Parameters\ParameterInterface` (an object that does the actual resolving).
+
+```php
+interface ParameterMiddlewareInterface
+{
+ public function mapParameter(ReflectionParameter $parameter, DocBlock $docBlock, ?Type $paramTagType, ParameterAnnotations $parameterAnnotations, ParameterHandlerInterface $next): ParameterInterface;
+}
+```
+
+Then, resolution actually happen by executing the resolver (this is the second pass).
+
+## Attributes parsing
+
+If you plan to use attributes while resolving arguments, your attribute class should extend the [`ParameterAnnotationInterface`](https://github.com/thecodingmachine/graphqlite/blob/master/src/Annotations/ParameterAnnotationInterface.php)
+
+For instance, if we want GraphQLite to inject a service in an argument, we can use `#[Autowire]`.
+
+We only need to put declare the annotation can target parameters: `#[Attribute(Attribute::TARGET_PARAMETER)]`.
+
+The class looks like this:
+
+```php
+use Attribute;
+
+/**
+ * Use this attribute to autowire a service from the container into a given parameter of a field/query/mutation.
+ *
+ */
+#[Attribute(Attribute::TARGET_PARAMETER)]
+class Autowire implements ParameterAnnotationInterface
+{
+ /**
+ * @var string
+ */
+ public $for;
+
+ /**
+ * The getTarget method must return the name of the argument
+ */
+ public function getTarget(): string
+ {
+ return $this->for;
+ }
+}
+```
+
+## Writing the parameter middleware
+
+The middleware purpose is to analyze a parameter and decide whether or not it can handle it.
+
+```php title="Parameter middleware class"
+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 annotation implementing ParameterAnnotationInterface
+ $autowire = $parameterAnnotations->getAnnotationByType(Autowire::class);
+
+ if ($autowire === null) {
+ // If there are no annotation, 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 annotation, let's return a parameter resolver.
+ return new ContainerParameter($this->container, $parameter->getType());
+ }
+}
+```
+
+The last step is to write the actual parameter resolver.
+
+```php title="Parameter resolver class"
+/**
+ * A parameter filled from the container.
+ */
+class ContainerParameter implements ParameterInterface
+{
+ /** @var ContainerInterface */
+ private $container;
+ /** @var string */
+ private $identifier;
+
+ public function __construct(ContainerInterface $container, string $identifier)
+ {
+ $this->container = $container;
+ $this->identifier = $identifier;
+ }
+
+ /**
+ * The "resolver" returns the actual value that will be fed to the function.
+ */
+ public function resolve(?object $source, array $args, $context, ResolveInfo $info)
+ {
+ return $this->container->get($this->identifier);
+ }
+}
+```
+
+## Registering a parameter middleware
+
+The last step is to register the parameter middleware we just wrote:
+
+You can register your own parameter middlewares using the `SchemaFactory::addParameterMiddleware()` method.
+
+```php
+$schemaFactory->addParameterMiddleware(new ContainerParameterHandler($container));
+```
+
+If you are using the Symfony bundle, you can tag the service as "graphql.parameter_middleware".
diff --git a/website/versioned_docs/version-8.0.0/authentication-authorization.mdx b/website/versioned_docs/version-8.0.0/authentication-authorization.mdx
new file mode 100644
index 0000000000..9842e2a3d3
--- /dev/null
+++ b/website/versioned_docs/version-8.0.0/authentication-authorization.mdx
@@ -0,0 +1,159 @@
+---
+id: authentication-authorization
+title: Authentication and authorization
+sidebar_label: Authentication and authorization
+---
+
+You might not want to expose your GraphQL API to anyone. Or you might want to keep some
+queries/mutations/subscriptions or fields reserved to some users.
+
+GraphQLite offers some control over what a user can do with your API. You can restrict access to
+resources:
+
+- based on authentication using the [`#[Logged]` attribute](#logged-and-right-annotations) (restrict access to logged users)
+- based on authorization using the [`#[Right]` attribute](#logged-and-right-annotations) (restrict access to logged users with certain rights).
+- based on fine-grained authorization using the [`#[Security]` attribute](fine-grained-security.mdx) (restrict access for some given resources to some users).
+
+