Entity::addAssociations() - Code Metrics - Inspection of "Merge pull request #124 from TomHAnderson/hotfix/i..." - API-Skeletons/doctrine-graphql - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 3e26d7...787f8a )

by Tom

created 2023-02-01 20:20 UTC

Entity::addAssociations() B

↳ Parent: Entity

Complexity

Conditions	9
Paths	9

Size

Total Lines	53
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	9
eloc	38
c	1
b	0
f	0
nc	9
nop	1
dl	0
loc	53
rs	7.7564

How to fix Long Method

<?php

declare(strict_types=1);

namespace ApiSkeletons\Doctrine\GraphQL\Type;

use ApiSkeletons\Doctrine\GraphQL\Criteria\CriteriaFactory;
use ApiSkeletons\Doctrine\GraphQL\Event\EntityDefinition;
use ApiSkeletons\Doctrine\GraphQL\Hydrator\HydratorFactory;
use ApiSkeletons\Doctrine\GraphQL\Metadata\Metadata;
use ApiSkeletons\Doctrine\GraphQL\Resolve\FieldResolver;
use ApiSkeletons\Doctrine\GraphQL\Resolve\ResolveCollectionFactory;
use ArrayObject;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Doctrine\ORM\Mapping\MappingException;
use GraphQL\Type\Definition\ObjectType;
use Laminas\Hydrator\HydratorInterface;
use League\Event\EventDispatcher;
use Psr\Container\ContainerInterface;

use function array_keys;
use function in_array;

class Entity
{
//    protected Driver $driver;
    protected CriteriaFactory $criteriaFactory;

    protected EntityManager $entityManager;

    protected EventDispatcher $eventDispatcher;

    protected FieldResolver $fieldResolver;

    protected HydratorFactory $hydratorFactory;

    protected Metadata $metadata;

    protected ResolveCollectionFactory $collectionFactory;

    protected TypeManager $typeManager;

    /** @param mixed[] $metadataConfig */
    public function __construct(ContainerInterface $container, protected array $metadataConfig)
    {
        $this->collectionFactory = $container->get(ResolveCollectionFactory::class);
        $this->criteriaFactory   = $container->get(CriteriaFactory::class);
        $this->entityManager     = $container->get(EntityManager::class);
        $this->eventDispatcher   = $container->get(EventDispatcher::class);
        $this->fieldResolver     = $container->get(FieldResolver::class);
        $this->hydratorFactory   = $container->get(HydratorFactory::class);
        $this->metadata          = $container->get(Metadata::class);
        $this->typeManager       = $container->get(TypeManager::class);
    }

    public function getHydrator(): HydratorInterface
    {
        return $this->hydratorFactory->get($this->getEntityClass());
    }

    public function getTypeName(): string
    {
        return $this->metadataConfig['typeName'];
    }

    public function getDescription(): string|null
    {
        return $this->metadataConfig['description'];
    }

    /** @return mixed[] */
    public function getMetadataConfig(): array
    {
        return $this->metadataConfig;
    }

    public function getEntityClass(): string
    {
        return $this->metadataConfig['entityClass'];
    }

    /**
     * Build the type for the current entity
     *
     * @throws MappingException
     */
    public function getGraphQLType(): ObjectType
    {
        if ($this->typeManager->has($this->getTypeName())) {
            return $this->typeManager->get($this->getTypeName());
        }

        $fields = [];

        $this->addFields($fields);
        $this->addAssociations($fields);

        $arrayObject = new ArrayObject([
            'name' => $this->getTypeName(),
            'description' => $this->getDescription(),
            'fields' => static fn () => $fields,
            'resolveField' => $this->fieldResolver,
        ]);

        /**
         * Dispatch event to allow modifications to the ObjectType definition
         */
        $this->eventDispatcher->dispatch(
            new EntityDefinition($arrayObject, $this->getEntityClass() . '.definition'),
        );

        $objectType = new ObjectType($arrayObject->getArrayCopy());
        $this->typeManager->set($this->getTypeName(), $objectType);

        return $objectType;
    }

    /** @param array<int, mixed[]> $fields */
    protected function addFields(array &$fields): void
    {
        $classMetadata = $this->entityManager->getClassMetadata($this->getEntityClass());

        foreach ($classMetadata->getFieldNames() as $fieldName) {
            if (! in_array($fieldName, array_keys($this->metadataConfig['fields']))) {
                continue;
            }

            $fields[$fieldName] = [
                'type' => $this->typeManager
                    ->get($this->getMetadataConfig()['fields'][$fieldName]['type']),
                'description' => $this->metadataConfig['fields'][$fieldName]['description'],
            ];
        }
    }

    /** @param array<int, mixed[]> $fields */
    protected function addAssociations(array &$fields): void
    {
        $classMetadata = $this->entityManager->getClassMetadata($this->getEntityClass());

        foreach ($classMetadata->getAssociationNames() as $associationName) {
            if (! in_array($associationName, array_keys($this->metadataConfig['fields']))) {
                continue;
            }

            $associationMetadata = $classMetadata->getAssociationMapping($associationName);

            switch ($associationMetadata['type']) {
                case ClassMetadataInfo::ONE_TO_ONE:
                case ClassMetadataInfo::MANY_TO_ONE:
                case ClassMetadataInfo::TO_ONE:
                    $targetEntity             = $associationMetadata['targetEntity'];
                    $fields[$associationName] = function () use ($targetEntity) {
                        $entity = $this->metadata->get($targetEntity);

                        return [
                            'type' => $entity->getGraphQLType(),
                            'description' => $entity->getDescription(),
                        ];
                    };
                    break;
                case ClassMetadataInfo::ONE_TO_MANY:
                case ClassMetadataInfo::MANY_TO_MANY:
                case ClassMetadataInfo::TO_MANY:
                    $targetEntity             = $associationMetadata['targetEntity'];
                    $fields[$associationName] = function () use ($targetEntity, $associationName) {
                        $entity    = $this->metadata->get($targetEntity);
                        $shortName = $this->getTypeName() . '_' . $associationName;

                        return [
                            'type' => $this->typeManager->build(
                                Connection::class,
                                $shortName . '_Connection',
                                $entity->getGraphQLType(),
                            ),
                            'args' => [
                                'filter' => $this->criteriaFactory->get(
                                    $entity,
                                    $this,
                                    $associationName,
                                    $this->metadataConfig['fields'][$associationName],
                                ),
                                'pagination' => $this->typeManager->get('pagination'),
                            ],
                            'description' => $this->metadataConfig['fields'][$associationName]['description'],
                            'resolve' => $this->collectionFactory->get($entity),
                        ];
                    };
                    break;
            }
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ApiSkeletons\Doctrine\GraphQL\Type;
6
7			use ApiSkeletons\Doctrine\GraphQL\Criteria\CriteriaFactory;
8			use ApiSkeletons\Doctrine\GraphQL\Event\EntityDefinition;
9			use ApiSkeletons\Doctrine\GraphQL\Hydrator\HydratorFactory;
10			use ApiSkeletons\Doctrine\GraphQL\Metadata\Metadata;
11			use ApiSkeletons\Doctrine\GraphQL\Resolve\FieldResolver;
12			use ApiSkeletons\Doctrine\GraphQL\Resolve\ResolveCollectionFactory;
13			use ArrayObject;
14			use Doctrine\ORM\EntityManager;
15			use Doctrine\ORM\Mapping\ClassMetadataInfo;
16			use Doctrine\ORM\Mapping\MappingException;
17			use GraphQL\Type\Definition\ObjectType;
18			use Laminas\Hydrator\HydratorInterface;
19			use League\Event\EventDispatcher;
20			use Psr\Container\ContainerInterface;
21
22			use function array_keys;
23			use function in_array;
24
25			class Entity
26			{
27			// protected Driver $driver;
28			protected CriteriaFactory $criteriaFactory;
29
30			protected EntityManager $entityManager;
31
32			protected EventDispatcher $eventDispatcher;
33
34			protected FieldResolver $fieldResolver;
35
36			protected HydratorFactory $hydratorFactory;
37
38			protected Metadata $metadata;
39
40			protected ResolveCollectionFactory $collectionFactory;
41
42			protected TypeManager $typeManager;
43
44			/** @param mixed[] $metadataConfig */
45			public function __construct(ContainerInterface $container, protected array $metadataConfig)
46			{
47			$this->collectionFactory = $container->get(ResolveCollectionFactory::class);
48			$this->criteriaFactory = $container->get(CriteriaFactory::class);
49			$this->entityManager = $container->get(EntityManager::class);
50			$this->eventDispatcher = $container->get(EventDispatcher::class);
51			$this->fieldResolver = $container->get(FieldResolver::class);
52			$this->hydratorFactory = $container->get(HydratorFactory::class);
53			$this->metadata = $container->get(Metadata::class);
54			$this->typeManager = $container->get(TypeManager::class);
55			}
56
57			public function getHydrator(): HydratorInterface
58			{
59			return $this->hydratorFactory->get($this->getEntityClass());
60			}
61
62			public function getTypeName(): string
63			{
64			return $this->metadataConfig['typeName'];
65			}
66
67			public function getDescription(): string\|null
68			{
69			return $this->metadataConfig['description'];
70			}
71
72			/** @return mixed[] */
73			public function getMetadataConfig(): array
74			{
75			return $this->metadataConfig;
76			}
77
78			public function getEntityClass(): string
79			{
80			return $this->metadataConfig['entityClass'];
81			}
82
83			/**
84			* Build the type for the current entity
85			*
86			* @throws MappingException
87			*/
88			public function getGraphQLType(): ObjectType
89			{
90			if ($this->typeManager->has($this->getTypeName())) {
91			return $this->typeManager->get($this->getTypeName());
92			}
93
94			$fields = [];
95
96			$this->addFields($fields);
97			$this->addAssociations($fields);
98
99			$arrayObject = new ArrayObject([
100			'name' => $this->getTypeName(),
101			'description' => $this->getDescription(),
102			'fields' => static fn () => $fields,
103			'resolveField' => $this->fieldResolver,
104			]);
105
106			/**
107			* Dispatch event to allow modifications to the ObjectType definition
108			*/
109			$this->eventDispatcher->dispatch(
110			new EntityDefinition($arrayObject, $this->getEntityClass() . '.definition'),
111			);
112
113			$objectType = new ObjectType($arrayObject->getArrayCopy());
114			$this->typeManager->set($this->getTypeName(), $objectType);
115
116			return $objectType;
117			}
118
119			/** @param array<int, mixed[]> $fields */
120			protected function addFields(array &$fields): void
121			{
122			$classMetadata = $this->entityManager->getClassMetadata($this->getEntityClass());
123
124			foreach ($classMetadata->getFieldNames() as $fieldName) {
125			if (! in_array($fieldName, array_keys($this->metadataConfig['fields']))) {
126			continue;
127			}
128
129			$fields[$fieldName] = [
130			'type' => $this->typeManager
131			->get($this->getMetadataConfig()['fields'][$fieldName]['type']),
132			'description' => $this->metadataConfig['fields'][$fieldName]['description'],
133			];
134			}
135			}
136
137			/** @param array<int, mixed[]> $fields */
138			protected function addAssociations(array &$fields): void
139			{
140			$classMetadata = $this->entityManager->getClassMetadata($this->getEntityClass());
141
142			foreach ($classMetadata->getAssociationNames() as $associationName) {
143			if (! in_array($associationName, array_keys($this->metadataConfig['fields']))) {
144			continue;
145			}
146
147			$associationMetadata = $classMetadata->getAssociationMapping($associationName);
148
149			switch ($associationMetadata['type']) {
150			case ClassMetadataInfo::ONE_TO_ONE:
151			case ClassMetadataInfo::MANY_TO_ONE:
152			case ClassMetadataInfo::TO_ONE:
153			$targetEntity = $associationMetadata['targetEntity'];
154			$fields[$associationName] = function () use ($targetEntity) {
155			$entity = $this->metadata->get($targetEntity);
156
157			return [
158			'type' => $entity->getGraphQLType(),
159			'description' => $entity->getDescription(),
160			];
161			};
162			break;
163			case ClassMetadataInfo::ONE_TO_MANY:
164			case ClassMetadataInfo::MANY_TO_MANY:
165			case ClassMetadataInfo::TO_MANY:
166			$targetEntity = $associationMetadata['targetEntity'];
167			$fields[$associationName] = function () use ($targetEntity, $associationName) {
168			$entity = $this->metadata->get($targetEntity);
169			$shortName = $this->getTypeName() . '_' . $associationName;
170
171			return [
172			'type' => $this->typeManager->build(
173			Connection::class,
174			$shortName . '_Connection',
175			$entity->getGraphQLType(),
176			),
177			'args' => [
178			'filter' => $this->criteriaFactory->get(
179			$entity,
180			$this,
181			$associationName,
182			$this->metadataConfig['fields'][$associationName],
183			),
184			'pagination' => $this->typeManager->get('pagination'),
185			],
186			'description' => $this->metadataConfig['fields'][$associationName]['description'],
187			'resolve' => $this->collectionFactory->get($entity),
188			];
189			};
190			break;
191			}
192			}
193			}
194			}
195

API-Skeletons / doctrine-graphql

Push — main ( 3e26d7...787f8a )

Entity::addAssociations() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like