Codebase improvements with php 8.1 features (#548)

* psr/container v2

* Implement replacement for Picotainer

* Replace Picotainer with LazyContainer in tests and documentation for version >=6

* Fix tests for phpdocumentor/type-resolver minor update

* run cs-fix script

* Fix some cs-fixer errors manually

* fix return type

* abandon psr/container ^1

* Test for LazyContainer

* Normalize RootTypeMapperInterface

* end-to-end test with enums in mutation and as single-returned field

* Bump ecodev/graphql-upload and webonyx/graphql-php"

* Fix some tests for webonyx ^15.0

* clearer types to fix tests

* clearer types to fix failing tests for webonyx 15

* clearer types to fix failing tests for webonyx 15

* fix failing tests for webonyx 15.
Make clearer types.

* fix failing tests for webonyx 15.
Make clearer types.

* fix some breaking changes for webonyx 15

* fix breaking changes for webonyx 15

* Update continuous_integration.yml

Remove support for PHP 8.0 test matrix

* Specify PHP 8.1 minimum support

* Add 'final' keyword to all classes marked with @internal phpdoc

* Improve code with php 8.1 features: 'readonly' keyword, native intersection types (OutputType&Type), new functions (str_starts_with,str_ends_with)

* Improve code with php 8.1 features: 'readonly' keyword, native intersection types (OutputType&Type)

* Improve code with php 8.1 features: 'readonly' keyword, native intersection types (e.g. OutputType&Type), match(){} syntax

* Improve code with php 8.1 features: str_starts_with

* Improve code with php 8.1 features: readonly modifier

* Improve code with php 8.1 features: intersection types

* Improve code with php 8.1 features: intersection types and readonly modifier

* Improve code with php 8.1 features: intersection types and readonly modifier

* Bump phpstan to minimum version 1.9. Fixes failed tests with --prefer-lowest
phpstan/phpstan#5906

---------

Co-authored-by: Jacob Thomason <jacob@thomason.xxx>

Author: l-you

composer.json

@@ -36,7 +36,7 @@
         "myclabs/php-enum": "^1.6.6",
         "php-coveralls/php-coveralls": "^2.1",
         "phpstan/extension-installer": "^1.1",
-        "phpstan/phpstan": "^1.0",
+        "phpstan/phpstan": "^1.9",
         "phpunit/phpunit": "^8.5.19 || ^9.5.8",
         "symfony/var-dumper": "^5.4 || ^6.0",
         "thecodingmachine/phpstan-strict-rules": "^1.0"

src/AggregateControllerQueryProvider.php

@@ -29,7 +29,7 @@ class AggregateControllerQueryProvider implements QueryProviderInterface
      * @param iterable<string>   $controllers          A list of controllers name in the container.
      * @param ContainerInterface $controllersContainer The container we will fetch controllers from.
      */
-    public function __construct(private iterable $controllers, private FieldsBuilder $fieldsBuilder, private ContainerInterface $controllersContainer)
+    public function __construct(private readonly iterable $controllers, private readonly FieldsBuilder $fieldsBuilder, private readonly ContainerInterface $controllersContainer)
     {
     }
 

src/AggregateControllerQueryProviderFactory.php

@@ -15,7 +15,7 @@ class AggregateControllerQueryProviderFactory implements QueryProviderFactoryInt
      * @param iterable<string> $controllers A list of controllers name in the container.
      * @param ContainerInterface $controllersContainer The container we will fetch controllers from.
      */
-    public function __construct(private iterable $controllers, private ContainerInterface $controllersContainer)
+    public function __construct(private readonly iterable $controllers, private readonly ContainerInterface $controllersContainer)
     {
     }
 

src/AnnotationReader.php

@@ -67,7 +67,7 @@ class AnnotationReader
      * @param string $mode One of self::LAX_MODE or self::STRICT_MODE. If true, no exceptions will be thrown for incorrect annotations in code coming from the "vendor/" directory.
      * @param array<int,string> $strictNamespaces Classes in those namespaces MUST have valid annotations (otherwise, an error is thrown).
      */
-    public function __construct(private Reader $reader, private string $mode = self::STRICT_MODE, private array $strictNamespaces = [])
+    public function __construct(private readonly Reader $reader, private readonly string $mode = self::STRICT_MODE, private readonly array $strictNamespaces = [])
     {
         if (! in_array($mode, [self::LAX_MODE, self::STRICT_MODE], true)) {
             throw new InvalidArgumentException('The mode passed must be one of AnnotationReader::LAX_MODE, AnnotationReader::STRICT_MODE');
@@ -100,20 +100,11 @@ private function getClassAnnotation(ReflectionClass $refClass, string $annotatio
             assert($type === null || $type instanceof $annotationClass);
             return $type;
         } catch (AnnotationException $e) {
-            switch ($this->mode) {
-                case self::STRICT_MODE:
-                    throw $e;
-
-                case self::LAX_MODE:
-                    if ($this->isErrorImportant($annotationClass, $refClass->getDocComment() ?: '', $refClass->getName())) {
-                        throw $e;
-                    }
-
-                    return null;
-
-                default:
-                    throw new RuntimeException("Unexpected mode '" . $this->mode . "'."); // @codeCoverageIgnore
-            }
+            return match ($this->mode) {
+                self::STRICT_MODE=> throw $e,
+                self::LAX_MODE=>$this->isErrorImportant($annotationClass, $refClass->getDocComment() ?: '', $refClass->getName()) ? throw $e : null,
+                default=>throw new RuntimeException("Unexpected mode '" . $this->mode . "'.") // @codeCoverageIgnore
+            };
         }
     }
 
@@ -139,20 +130,11 @@ private function getMethodAnnotation(ReflectionMethod $refMethod, string $annota
 
             return $this->methodAnnotationCache[$cacheKey] = $this->reader->getMethodAnnotation($refMethod, $annotationClass);
         } catch (AnnotationException $e) {
-            switch ($this->mode) {
-                case self::STRICT_MODE:
-                    throw $e;
-
-                case self::LAX_MODE:
-                    if ($this->isErrorImportant($annotationClass, $refMethod->getDocComment() ?: '', $refMethod->getDeclaringClass()->getName())) {
-                        throw $e;
-                    }
-
-                    return null;
-
-                default:
-                    throw new RuntimeException("Unexpected mode '" . $this->mode . "'."); // @codeCoverageIgnore
-            }
+            return match ($this->mode) {
+                self::STRICT_MODE=> throw $e,
+                self::LAX_MODE=>$this->isErrorImportant($annotationClass, $refMethod->getDocComment() ?: '', $refMethod->getName()) ? throw $e : null,
+                default=>throw new RuntimeException("Unexpected mode '" . $this->mode . "'.") // @codeCoverageIgnore
+            };
         }
     }
 

src/FactoryContext.php

@@ -18,19 +18,19 @@
 final class FactoryContext
 {
     public function __construct(
-        private AnnotationReader $annotationReader,
-        private TypeResolver $typeResolver,
-        private NamingStrategyInterface $namingStrategy,
-        private TypeRegistry $typeRegistry,
-        private FieldsBuilder $fieldsBuilder,
-        private TypeGenerator $typeGenerator,
-        private InputTypeGenerator $inputTypeGenerator,
-        private RecursiveTypeMapperInterface $recursiveTypeMapper,
-        private ContainerInterface $container,
-        private CacheInterface $cache,
-        private InputTypeValidatorInterface|null $inputTypeValidator,
-        private int|null $globTTL,
-        private int|null $mapTTL = null,
+        private readonly AnnotationReader $annotationReader,
+        private readonly TypeResolver $typeResolver,
+        private readonly NamingStrategyInterface $namingStrategy,
+        private readonly TypeRegistry $typeRegistry,
+        private readonly FieldsBuilder $fieldsBuilder,
+        private readonly TypeGenerator $typeGenerator,
+        private readonly InputTypeGenerator $inputTypeGenerator,
+        private readonly RecursiveTypeMapperInterface $recursiveTypeMapper,
+        private readonly ContainerInterface $container,
+        private readonly CacheInterface $cache,
+        private readonly InputTypeValidatorInterface|null $inputTypeValidator,
+        private readonly int|null $globTTL,
+        private readonly int|null $mapTTL = null,
     ) {
     }
 

src/FieldsBuilder.php

@@ -62,7 +62,7 @@
 use function key;
 use function reset;
 use function rtrim;
-use function strpos;
+use function str_starts_with;
 use function trim;
 
 use const PHP_EOL;
@@ -75,16 +75,16 @@ class FieldsBuilder
     private TypeHandler $typeMapper;
 
     public function __construct(
-        private AnnotationReader $annotationReader,
-        private RecursiveTypeMapperInterface $recursiveTypeMapper,
-        private ArgumentResolver $argumentResolver,
-        private TypeResolver $typeResolver,
-        private CachedDocBlockFactory $cachedDocBlockFactory,
-        private NamingStrategyInterface $namingStrategy,
-        private RootTypeMapperInterface $rootTypeMapper,
-        private ParameterMiddlewareInterface $parameterMapper,
-        private FieldMiddlewareInterface $fieldMiddleware,
-        private InputFieldMiddlewareInterface $inputFieldMiddleware,
+        private readonly AnnotationReader $annotationReader,
+        private readonly RecursiveTypeMapperInterface $recursiveTypeMapper,
+        private readonly ArgumentResolver $argumentResolver,
+        private readonly TypeResolver $typeResolver,
+        private readonly CachedDocBlockFactory $cachedDocBlockFactory,
+        private readonly NamingStrategyInterface $namingStrategy,
+        private readonly RootTypeMapperInterface $rootTypeMapper,
+        private readonly ParameterMiddlewareInterface $parameterMapper,
+        private readonly FieldMiddlewareInterface $fieldMiddleware,
+        private readonly InputFieldMiddlewareInterface $inputFieldMiddleware,
     )
     {
         $this->typeMapper = new TypeHandler($this->argumentResolver, $this->rootTypeMapper, $this->typeResolver);
@@ -342,7 +342,7 @@ private function getFieldsByMethodAnnotations(string|object $controller, Reflect
             $methodName = $refMethod->getName();
 
             if ($queryAnnotation instanceof Field) {
-                if (strpos($methodName, 'set') === 0) {
+                if (str_starts_with($methodName, 'set')) {
                     continue;
                 }
                 $for = $queryAnnotation->getFor();
@@ -673,12 +673,8 @@ private function getMagicGetMethodFromSourceClassOrProxy(ReflectionClass $proxyR
         return $sourceRefClass->getMethod($magicGet);
     }
 
-    /**
-     * @param ReflectionClass<object> $refClass
-     *
-     * @return OutputType&Type
-     */
-    private function resolveOutputType(string $outputType, ReflectionClass $refClass, SourceFieldInterface $sourceField): OutputType
+    /** @param ReflectionClass<object> $refClass */
+    private function resolveOutputType(string $outputType, ReflectionClass $refClass, SourceFieldInterface $sourceField): OutputType&Type
     {
         try {
             return $this->typeResolver->mapNameToOutputType($outputType);
@@ -688,12 +684,8 @@ private function resolveOutputType(string $outputType, ReflectionClass $refClass
         }
     }
 
-    /**
-     * @param ReflectionClass<object> $refClass
-     *
-     * @return OutputType&Type
-     */
-    private function resolvePhpType(string $phpTypeStr, ReflectionClass $refClass, ReflectionMethod $refMethod): OutputType
+    /** @param ReflectionClass<object> $refClass */
+    private function resolvePhpType(string $phpTypeStr, ReflectionClass $refClass, ReflectionMethod $refMethod): OutputType&Type
     {
         $typeResolver = new \phpDocumentor\Reflection\TypeResolver();
 
@@ -850,7 +842,7 @@ private function getInputFieldsByMethodAnnotations(string|object $controller, Re
 
             $docBlockObj = $this->cachedDocBlockFactory->getDocBlock($refMethod);
             $methodName = $refMethod->getName();
-            if (strpos($methodName, 'set') !== 0) {
+            if (! str_starts_with($methodName, 'set')) {
                 continue;
             }
             $name = $fieldAnnotations->getName() ?: $this->namingStrategy->getInputFieldNameFromMethodName($methodName);

src/Http/WebonyxGraphqlMiddleware.php

@@ -42,11 +42,11 @@ final class WebonyxGraphqlMiddleware implements MiddlewareInterface
     ];
 
     public function __construct(
-        private ServerConfig $config,
-        private ResponseFactoryInterface $responseFactory,
-        private StreamFactoryInterface $streamFactory,
-        private HttpCodeDeciderInterface $httpCodeDecider,
-        private string $graphqlUri = '/graphql',
+        private readonly ServerConfig $config,
+        private readonly ResponseFactoryInterface $responseFactory,
+        private readonly StreamFactoryInterface $streamFactory,
+        private readonly HttpCodeDeciderInterface $httpCodeDecider,
+        private readonly string $graphqlUri = '/graphql',
         StandardServer|null $handler = null,
     )
     {

src/InputField.php

@@ -29,7 +29,7 @@
  * @phpstan-import-type InputObjectFieldConfig from InputObjectField
  * @phpstan-import-type ArgumentType from InputObjectField
  */
-class InputField extends InputObjectField
+final class InputField extends InputObjectField
 {
     /** @var callable */
     private $resolve;

src/InputFieldDescriptor.php

@@ -27,7 +27,7 @@ class InputFieldDescriptor
 {
     private string $name;
     /** @var (InputType&Type)|(InputType&Type&NullableType) */
-    private InputType $type;
+    private InputType&Type $type;
     /** @var array<string, ParameterInterface> */
     private array $parameters = [];
     /** @var callable|null */
@@ -96,13 +96,12 @@ public function setName(string $name): void
     }
 
     /** @return ((InputType&Type)|(InputType&Type&NullableType))  */
-    public function getType(): InputType
+    public function getType(): InputType&Type
     {
         return $this->type;
     }
 
-    /** @param (InputType&Type)  $type */
-    public function setType(InputType $type): void
+    public function setType(InputType&Type $type): void
     {
         $this->type = $type;
     }

src/InputTypeUtils.php

@@ -33,8 +33,8 @@
 class InputTypeUtils
 {
     public function __construct(
-        private AnnotationReader $annotationReader,
-        private NamingStrategyInterface $namingStrategy,
+        private readonly AnnotationReader $annotationReader,
+        private readonly NamingStrategyInterface $namingStrategy,
     )
     {
     }