vendor/overblog/graphql-bundle/src/EventListener/TypeDecoratorListener.php line 41

  1. <?php
  3. declare(strict_types=1);
  5. namespace Overblog\GraphQLBundle\EventListener;
  7. use GraphQL\Type\Definition\EnumType;
  8. use GraphQL\Type\Definition\InterfaceType;
  9. use GraphQL\Type\Definition\ObjectType;
  10. use GraphQL\Type\Definition\Type;
  11. use GraphQL\Type\Definition\UnionType;
  12. use InvalidArgumentException;
  13. use Overblog\GraphQLBundle\Definition\ArgumentFactory;
  14. use Overblog\GraphQLBundle\Definition\Type\CustomScalarType;
  15. use Overblog\GraphQLBundle\Event\TypeLoadedEvent;
  16. use Overblog\GraphQLBundle\Resolver\ResolverMapInterface;
  17. use Overblog\GraphQLBundle\Resolver\ResolverMaps;
  18. use function array_diff;
  19. use function count;
  20. use function current;
  21. use function implode;
  22. use function is_callable;
  23. use function sprintf;
  24. use function substr;
  26. final class TypeDecoratorListener
  27. {
  28.     private ArgumentFactory $argumentFactory;
  29.     private array $schemaResolverMaps = [];
  31.     public function __construct(ArgumentFactory $argumentFactory)
  32.     {
  33.         $this->argumentFactory = $argumentFactory;
  34.     }
  36.     public function addSchemaResolverMaps(string $schemaName, array $resolverMaps): void
  37.     {
  38.         $this->schemaResolverMaps[$schemaName] = 1 === count($resolverMaps) ? current($resolverMaps) : new ResolverMaps($resolverMaps);
  39.     }
  41.     public function onTypeLoaded(TypeLoadedEvent $event): void
  42.     {
  43.         if (!empty($this->schemaResolverMaps[$event->getSchemaName()])) {
  44.             $this->decorateType($event->getType(), $this->schemaResolverMaps[$event->getSchemaName()]);
  45.         }
  46.     }
  48.     public function decorateType(Type $type, ResolverMapInterface $resolverMap): void
  49.     {
  50.         if ($type instanceof ObjectType) {
  51.             $this->decorateObjectType($type, $resolverMap);
  52.         } elseif ($type instanceof InterfaceType || $type instanceof UnionType) {
  53.             $this->decorateInterfaceOrUnionType($type, $resolverMap);
  54.         } elseif ($type instanceof EnumType) {
  55.             $this->decorateEnumType($type, $resolverMap);
  56.         } elseif ($type instanceof CustomScalarType) {
  57.             $this->decorateCustomScalarType($type, $resolverMap);
  58.         } else {
  59.             $covered = $resolverMap->covered($type->name);
  60.             if (!empty($covered)) {
  61.                 throw new InvalidArgumentException(
  62.                     sprintf(
  63.                         '"%s".{"%s"} defined in resolverMap, but type is not managed by TypeDecorator.',
  64.                         $type->name,
  65.                         implode('", "', $covered)
  66.                     )
  67.                 );
  68.             }
  69.         }
  70.     }
  72.     private function decorateObjectType(ObjectType $type, ResolverMapInterface $resolverMap): void
  73.     {
  74.         $fieldsResolved = [];
  75.         foreach ($resolverMap->covered($type->name) as $fieldName) {
  76.             if (ResolverMapInterface::IS_TYPEOF === $fieldName) {
  77.                 $this->configTypeMapping($type, ResolverMapInterface::IS_TYPEOF, $resolverMap);
  78.             } elseif (ResolverMapInterface::RESOLVE_FIELD === $fieldName) {
  79.                 $resolveFieldFn = $this->argumentFactory->wrapResolverArgs($resolverMap->resolve($type->name, ResolverMapInterface::RESOLVE_FIELD));
  80.                 $type->config[substr(ResolverMapInterface::RESOLVE_FIELD, 2)] = $resolveFieldFn;
  81.                 $type->resolveFieldFn = $resolveFieldFn;
  82.             } else {
  83.                 $fieldsResolved[] = $fieldName;
  84.             }
  85.         }
  86.         $this->decorateObjectTypeFields($type, $fieldsResolved, $resolverMap);
  87.     }
  89.     /**
  90.      * @param InterfaceType|UnionType $type
  91.      */
  92.     private function decorateInterfaceOrUnionType($type, ResolverMapInterface $resolverMap): void
  93.     {
  94.         $this->configTypeMapping($type, ResolverMapInterface::RESOLVE_TYPE, $resolverMap);
  95.         $covered = $resolverMap->covered($type->name);
  96.         if (!empty($covered)) {
  97.             $unknownFields = array_diff($covered, [ResolverMapInterface::RESOLVE_TYPE]);
  98.             if (!empty($unknownFields)) {
  99.                 throw new InvalidArgumentException(
  100.                     sprintf(
  101.                         '"%s".{"%s"} defined in resolverMap, but only "%s::RESOLVE_TYPE" is allowed.',
  102.                         $type->name,
  103.                         implode('", "', $unknownFields),
  104.                         ResolverMapInterface::class
  105.                     )
  106.                 );
  107.             }
  108.         }
  109.     }
  111.     private function decorateCustomScalarType(CustomScalarType $type, ResolverMapInterface $resolverMap): void
  112.     {
  113.         static $allowedFields = [
  114.             ResolverMapInterface::SCALAR_TYPE,
  115.             ResolverMapInterface::SERIALIZE,
  116.             ResolverMapInterface::PARSE_VALUE,
  117.             ResolverMapInterface::PARSE_LITERAL,
  118.         ];
  120.         foreach ($allowedFields as $fieldName) {
  121.             $this->configTypeMapping($type, $fieldName, $resolverMap);
  122.         }
  124.         $unknownFields = array_diff($resolverMap->covered($type->name), $allowedFields);
  125.         if (!empty($unknownFields)) {
  126.             throw new InvalidArgumentException(
  127.                 sprintf(
  128.                     '"%s".{"%s"} defined in resolverMap, but only "%s::{%s}" is allowed.',
  129.                     $type->name,
  130.                     implode('", "', $unknownFields),
  131.                     ResolverMapInterface::class,
  132.                     implode(', ', ['SCALAR_TYPE', 'SERIALIZE', 'PARSE_VALUE', 'PARSE_LITERAL'])
  133.                 )
  134.             );
  135.         }
  136.     }
  138.     private function decorateEnumType(EnumType $type, ResolverMapInterface $resolverMap): void
  139.     {
  140.         $fieldNames = [];
  141.         foreach ($type->config['values'] as $key => &$value) {
  142.             $fieldName = $value['name'] ?? $key;
  143.             if ($resolverMap->isResolvable($type->name, $fieldName)) {
  144.                 $value['value'] = $resolverMap->resolve($type->name, $fieldName);
  145.             }
  146.             $fieldNames[] = $fieldName;
  147.         }
  148.         $unknownFields = array_diff($resolverMap->covered($type->name), $fieldNames);
  149.         if (!empty($unknownFields)) {
  150.             throw new InvalidArgumentException(
  151.                 sprintf(
  152.                     '"%s".{"%s"} defined in resolverMap, was defined in resolvers, but enum is not in schema.',
  153.                     $type->name,
  154.                     implode('", "', $unknownFields)
  155.                 )
  156.             );
  157.         }
  158.     }
  160.     private function decorateObjectTypeFields(ObjectType $type, array $fieldsResolved, ResolverMapInterface $resolverMap): void
  161.     {
  162.         $fields = $type->config['fields'];
  164.         $decoratedFields = function () use ($fields, $type, $fieldsResolved, $resolverMap) {
  165.             if (is_callable($fields)) {
  166.                 $fields = $fields();
  167.             }
  169.             $fieldNames = [];
  170.             foreach ($fields as $key => &$field) {
  171.                 $fieldName = $field['name'] ?? $key;
  173.                 if ($resolverMap->isResolvable($type->name, $fieldName)) {
  174.                     $field['resolve'] = $this->argumentFactory->wrapResolverArgs($resolverMap->resolve($type->name, $fieldName));
  175.                 }
  177.                 $fieldNames[] = $fieldName;
  178.             }
  180.             $unknownFields = array_diff($fieldsResolved, $fieldNames);
  181.             if (!empty($unknownFields)) {
  182.                 throw new InvalidArgumentException(
  183.                     sprintf('"%s".{"%s"} defined in resolverMap, but not in schema.', $type->name, implode('", "', $unknownFields))
  184.                 );
  185.             }
  187.             return $fields;
  188.         };
  190.         $type->config['fields'] = is_callable($fields) ? $decoratedFields : $decoratedFields();
  191.     }
  193.     private function configTypeMapping(Type $type, string $fieldName, ResolverMapInterface $resolverMap): void
  194.     {
  195.         if ($resolverMap->isResolvable($type->name, $fieldName)) {
  196.             $type->config[substr($fieldName, 2)] = $resolverMap->resolve($type->name, $fieldName);
  197.         }
  198.     }
  199. }