thecodingmachine · oojacoboo · Apr 7, 2022 · Nov 25, 2021 · Feb 14, 2022 · Feb 14, 2022
diff --git a/.github/workflows/continuous_integration.yml b/.github/workflows/continuous_integration.yml
@@ -18,7 +18,7 @@ jobs:
     strategy:
       matrix:
         install-args: ['', '--prefer-lowest']
-        php-version: ['7.4', '8.0']
+        php-version: ['7.4', '8.0', '8.1']
       fail-fast: false
 
     steps:

diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,4 @@
+/build/
 /vendor/
 /composer.lock
 /src/Tests/

diff --git a/composer.json b/composer.json
@@ -40,7 +40,8 @@
         "phpstan/extension-installer": "^1.1",
         "phpstan/phpstan": "^1.0",
         "phpstan/phpstan-webmozart-assert": "^1.0",
-        "phpunit/phpunit": "^8.5.19||^9.5.8",
+        "phpunit/phpunit": "^8.5.19 || ^9.5.8",
+        "symfony/var-dumper": "^5.4 || ^6.0",
         "thecodingmachine/phpstan-strict-rules": "^1.0"
     },
     "suggest": {

diff --git a/phpcs.xml.dist b/phpcs.xml.dist
@@ -28,6 +28,7 @@
         <exclude name="SlevomatCodingStandard.ControlStructures.RequireNullCoalesceEqualOperator"/>
         <exclude name="Squiz.Commenting.FunctionComment.InvalidNoReturn" />
         <exclude name="Generic.Formatting.MultipleStatementAlignment" />
+        <exclude name="Squiz.Functions.MultiLineFunctionDeclaration.NewlineBeforeOpenBrace" />
     </rule>
 
     <!-- Do not align assignments -->

diff --git a/phpstan.neon b/phpstan.neon
@@ -4,6 +4,10 @@ parameters:
     tmpDir: .phpstan-cache
     paths:
         - src
+    excludePaths:
+         # TODO: exlude only for PHP < 8.1
+        - src/Mappers/Root/EnumTypeMapper.php
+        - src/Types/EnumType.php
     level: 8
     checkGenericClassInNonGenericObjectType: false
     reportUnmatchedIgnoredErrors: false

diff --git a/src/AnnotationReader.php b/src/AnnotationReader.php
@@ -7,7 +7,6 @@
 use Doctrine\Common\Annotations\AnnotationException;
 use Doctrine\Common\Annotations\Reader;
 use InvalidArgumentException;
-use MyCLabs\Enum\Enum;
 use ReflectionClass;
 use ReflectionMethod;
 use ReflectionParameter;
@@ -568,9 +567,6 @@ static function ($attribute) {
         return $toAddAnnotations;
     }
 
-    /**
-     * @param ReflectionClass<Enum> $refClass
-     */
     public function getEnumTypeAnnotation(ReflectionClass $refClass): ?EnumType
     {
         return $this->getClassAnnotation($refClass, EnumType::class);

diff --git a/src/Annotations/EnumType.php b/src/Annotations/EnumType.php
@@ -9,6 +9,8 @@
 /**
  * The EnumType annotation is useful to change the name of the generated "enum" type.
  *
+ * @deprecated Use @Type on a native PHP 8.1 Enum instead. Support will be removed in future release.
+ *
  * @Annotation
  * @Target({"CLASS"})
  * @Attributes({
@@ -21,12 +23,16 @@ class EnumType
     /** @var string|null */
     private $name;
 
+    /** @var bool */
+    private $useValues;
+
     /**
      * @param mixed[] $attributes
      */
-    public function __construct(array $attributes = [], ?string $name = null)
+    public function __construct(array $attributes = [], ?string $name = null, ?bool $useValues = null)
     {
         $this->name = $name ?? $attributes['name'] ?? null;
+        $this->useValues = $useValues ?? $attributes['useValues'] ?? false;
     }
 
     /**
@@ -36,4 +42,12 @@ public function getName(): ?string
     {
         return $this->name;
     }
+
+    /**
+     * Returns true if the enum type should expose backed values instead of case names.
+     */
+    public function useValues(): bool
+    {
+        return $this->useValues;
+    }
 }
diff --git a/src/Annotations/Type.php b/src/Annotations/Type.php
@@ -45,12 +45,21 @@ class Type
      */
     private $selfType = false;
 
+    /** @var bool */
+    private $useEnumValues = false;
+
     /**
      * @param mixed[] $attributes
      * @param class-string<object>|null $class
      */
-    public function __construct(array $attributes = [], ?string $class = null, ?string $name = null, ?bool $default = null, ?bool $external = null)
-    {
+    public function __construct(
+        array $attributes = [],
+        ?string $class = null,
+        ?string $name = null,
+        ?bool $default = null,
+        ?bool $external = null,
+        ?bool $useEnumValues = null
+    ) {
         $external = $external ?? $attributes['external'] ?? null;
         $class = $class ?? $attributes['class'] ?? null;
         if ($class !== null) {
@@ -63,6 +72,7 @@ public function __construct(array $attributes = [], ?string $class = null, ?stri
 
         // If no value is passed for default, "default" = true
         $this->default = $default ?? $attributes['default'] ?? true;
+        $this->useEnumValues = $useEnumValues ?? $attributes['useEnumValues'] ?? false;
 
         if ($external === null) {
             return;
@@ -123,4 +133,12 @@ public function isDefault(): bool
     {
         return $this->default;
     }
+
+    /**
+     * Returns true if this enum type
+     */
+    public function useEnumValues(): bool
+    {
+        return $this->useEnumValues;
+    }
 }
diff --git a/src/Mappers/CompositeTypeMapper.php b/src/Mappers/CompositeTypeMapper.php
@@ -65,6 +65,7 @@ public function mapClassToType(string $className, ?OutputType $subType): Mutable
                 return $typeMapper->mapClassToType($className, $subType);
             }
         }
+
         throw CannotMapTypeException::createForType($className);
     }
 

diff --git a/src/Mappers/RecursiveTypeMapper.php b/src/Mappers/RecursiveTypeMapper.php
@@ -114,6 +114,7 @@ public function mapClassToType(string $className, ?OutputType $subType): Mutable
         if ($closestClassName === null) {
             throw CannotMapTypeException::createForType($className);
         }
+
         $type = $this->typeMapper->mapClassToType($closestClassName, $subType);
 
         // In the event this type was already part of cache, let's not extend it.
@@ -452,8 +453,10 @@ public function getOutputTypes(): array
         $types     = [];
         $typeNames = [];
         foreach ($this->typeMapper->getSupportedClasses() as $supportedClass) {
-            $type                   = $this->mapClassToType($supportedClass, null);
+            $type = $this->mapClassToType($supportedClass, null);
+
             $types[$supportedClass] = $type;
+
             if (isset($typeNames[$type->name])) {
                 throw DuplicateMappingException::createForTypeName($type->name, $typeNames[$type->name], $supportedClass);
             }

diff --git a/src/Mappers/Root/EnumTypeMapper.php b/src/Mappers/Root/EnumTypeMapper.php
@@ -0,0 +1,214 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\GraphQLite\Mappers\Root;
+
+use GraphQL\Type\Definition\InputType;
+use GraphQL\Type\Definition\NamedType;
+use GraphQL\Type\Definition\OutputType;
+use GraphQL\Type\Definition\Type as GraphQLType;
+use phpDocumentor\Reflection\DocBlock;
+use phpDocumentor\Reflection\Type;
+use phpDocumentor\Reflection\Types\Object_;
+use ReflectionClass;
+use ReflectionEnum;
+use ReflectionMethod;
+use ReflectionProperty;
+use Symfony\Contracts\Cache\CacheInterface;
+use TheCodingMachine\GraphQLite\AnnotationReader;
+use TheCodingMachine\GraphQLite\Types\EnumType;
+use TheCodingMachine\GraphQLite\Utils\Namespaces\NS;
+use UnitEnum;
+
+use function assert;
+use function enum_exists;
+
+/**
+ * Maps an enum class to a GraphQL type (only available in PHP>=8.1)
+ */
+class EnumTypeMapper implements RootTypeMapperInterface
+{
+    /** @var array<class-string<UnitEnum>, EnumType> */
+    private $cache = [];
+    /** @var array<string, EnumType> */
+    private $cacheByName = [];
+    /** @var array<string, class-string<UnitEnum>> */
+    private $nameToClassMapping;
+    /** @var RootTypeMapperInterface */
+    private $next;
+    /** @var AnnotationReader */
+    private $annotationReader;
+    /** @var array|NS[] */
+    private $namespaces;
+    /** @var CacheInterface */
+    private $cacheService;
+
+    /**
+     * @param NS[] $namespaces List of namespaces containing enums. Used when searching an enum by name.
+     */
+    public function __construct(
+        RootTypeMapperInterface $next,
+        AnnotationReader $annotationReader,
+        CacheInterface $cacheService,
+        array $namespaces
+    ) {
+        $this->next = $next;
+        $this->annotationReader = $annotationReader;
+        $this->cacheService = $cacheService;
+        $this->namespaces = $namespaces;
+    }
+
+    /**
+     * @param (OutputType&GraphQLType)|null $subType
+     * @param ReflectionMethod|ReflectionProperty $reflector
+     *
+     * @return OutputType&GraphQLType
+     */
+    public function toGraphQLOutputType(
+        Type $type,
+        ?OutputType $subType,
+        $reflector,
+        DocBlock $docBlockObj
+    ): OutputType {
+        $result = $this->map($type);
+        if ($result === null) {
+            return $this->next->toGraphQLOutputType($type, $subType, $reflector, $docBlockObj);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Maps into the appropriate InputType
+     *
+     * @param InputType|GraphQLType|null $subType
+     * @param ReflectionMethod|ReflectionProperty $reflector
+     *
+     * @return InputType|GraphQLType
+     */
+    public function toGraphQLInputType(
+        Type $type,
+        ?InputType $subType,
+        string $argumentName,
+        $reflector,
+        DocBlock $docBlockObj
+    ): InputType
+    {
+        $result = $this->map($type);
+        if ($result === null) {
+            return $this->next->toGraphQLInputType($type, $subType, $argumentName, $reflector, $docBlockObj);
+        }
+
+        return $result;
+    }
+
+    private function map(Type $type): ?EnumType
+    {
+        if (! $type instanceof Object_) {
+            return null;
+        }
+        $fqsen = $type->getFqsen();
+        if ($fqsen === null) {
+            return null;
+        }
+
+        /** @var class-string<object> $enumClass */
+        $enumClass = (string) $fqsen;
+
+        return $this->mapByClassName($enumClass);
+    }
+
+    /**
+     * @param class-string $enumClass
+     */
+    private function mapByClassName(string $enumClass): ?EnumType
+    {
+        if (isset($this->cache[$enumClass])) {
+            return $this->cache[$enumClass];
+        }
+
+        if (! enum_exists($enumClass)) {
+            return null;
+        }
+
+        // phpcs:disable SlevomatCodingStandard.Commenting.InlineDocCommentDeclaration.MissingVariable
+        /** @var class-string<UnitEnum> $enumClass */
+        // phpcs:enable SlevomatCodingStandard.Commenting.InlineDocCommentDeclaration.MissingVariable
+
+        $reflectionEnum = new ReflectionEnum($enumClass);
+
+        $typeAnnotation = $this->annotationReader->getTypeAnnotation($reflectionEnum);
+        $typeName = ($typeAnnotation !== null ? $typeAnnotation->getName() : null) ?? $reflectionEnum->getShortName();
+
+        // Expose values instead of names if specifically configured to and if enum is string-backed
+        $useValues = $typeAnnotation !== null &&
+            $typeAnnotation->useEnumValues() &&
+            $reflectionEnum->isBacked() &&
+            (string) $reflectionEnum->getBackingType() === 'string';
+
+        $type = new EnumType($enumClass, $typeName, $useValues);
+
+        return $this->cacheByName[$typeName] = $this->cache[$enumClass] = $type;
+    }
+
+    private function getTypeName(ReflectionClass $reflectionClass): string
+    {
+        $typeAnnotation = $this->annotationReader->getTypeAnnotation($reflectionClass);
+
+        return ($typeAnnotation !== null ? $typeAnnotation->getName() : null) ?? $reflectionClass->getShortName();
+    }
+
+    /**
+     * 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
+     */
+    public function mapNameToType(string $typeName): NamedType
+    {
+        // This is a hack to make sure "$schema->assertValid()" returns true.
+        // The mapNameToType will fail if the mapByClassName method was not called before.
+        // This is actually not an issue in real life scenarios where enum types are never queried by type name.
+        if (isset($this->cacheByName[$typeName])) {
+            return $this->cacheByName[$typeName];
+        }
+
+        $nameToClassMapping = $this->getNameToClassMapping();
+        if (isset($this->nameToClassMapping[$typeName])) {
+            $className = $nameToClassMapping[$typeName];
+            $type = $this->mapByClassName($className);
+            assert($type !== null);
+            return $type;
+        }
+
+        return $this->next->mapNameToType($typeName);
+    }
+
+    /**
+     * Go through all classes in the defined namespaces and loads the cache.
+     *
+     * @return array<string, class-string<UnitEnum>>
+     */
+    private function getNameToClassMapping(): array
+    {
+        if ($this->nameToClassMapping === null) {
+            $this->nameToClassMapping = $this->cacheService->get('enum_name_to_class', function () {
+                $nameToClassMapping = [];
+                foreach ($this->namespaces as $ns) {
+                    foreach ($ns->getClassList() as $className => $classRef) {
+                        if (! enum_exists($className)) {
+                            continue;
+                        }
+
+                        $nameToClassMapping[$this->getTypeName($classRef)] = $className;
+                    }
+                }
+                return $nameToClassMapping;
+            });
+        }
+
+        return $this->nameToClassMapping;
+    }
+}
-Original file line number
+Diff line change
@@ Expand Up @@
                     return $typeMapper->mapClassToType($className, $subType);
                 }
             }
             throw CannotMapTypeException::createForType($className);
         }
@@ Expand Down @@