MetadataFactory::__invoke() - Code Metrics - API-Skeletons/doctrine-orm-graphql - Measure and Improve Code Quality continuously with Scrutinizer

MetadataFactory::__invoke() A
last analyzed 2024-08-18 08:07 UTC

↳ Parent: MetadataFactory

Complexity

Conditions	5
Paths	7

Size

Total Lines	38
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	19
nc	7
nop	0
dl	0
loc	38
rs	9.3222
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace ApiSkeletons\Doctrine\ORM\GraphQL\Metadata;

use ApiSkeletons\Doctrine\ORM\GraphQL\Attribute;
use ApiSkeletons\Doctrine\ORM\GraphQL\Config;
use ApiSkeletons\Doctrine\ORM\GraphQL\Event\Metadata;
use ApiSkeletons\Doctrine\ORM\GraphQL\Filter\Filters;
use ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy;
use ApiSkeletons\Doctrine\ORM\GraphQL\Metadata\Common\MetadataFactory as CommonMetadataFactory;
use ArrayObject;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Mapping\ClassMetadata;
use League\Event\EventDispatcher;
use ReflectionClass;

use function assert;
use function count;

/**
 * Build metadata for entities
 */
class MetadataFactory extends CommonMetadataFactory
{
    public function __construct(
        protected ArrayObject $metadata,
        protected readonly EntityManager $entityManager,
        protected readonly Config $config,
        protected readonly GlobalEnable $globalEnable,
        protected readonly EventDispatcher $eventDispatcher,
    ) {
    }

    /**
     * Build metadata for all entities and return it
     */
    public function __invoke(): ArrayObject
    {
        if (count($this->metadata)) {
            return $this->metadata;
        }

        // Fetch all entity classes from the entity manager
        $entityClasses = [];
        foreach ($this->entityManager->getMetadataFactory()->getAllMetadata() as $metadata) {
            $entityClasses[] = $metadata->getName();
        }

        // If global enable is set, use the GlobalEnable class to build metadata
        if ($this->config->getGlobalEnable()) {
            $this->metadata = ($this->globalEnable)($entityClasses);

            return $this->metadata;
        }

        // Build metadata for each entity class
        foreach ($entityClasses as $entityClass) {
            $reflectionClass = new ReflectionClass($entityClass);

            $entityClassMetadata = $this->entityManager
                ->getMetadataFactory()
                ->getMetadataFor($reflectionClass->getName());

            $this->buildMetadataForEntity($reflectionClass);
            $this->buildMetadataForFields($entityClassMetadata, $reflectionClass);
            $this->buildMetadataForAssociations($reflectionClass);
        }

        // Fire the metadata.build event
        $this->eventDispatcher->dispatch(
            new Metadata($this->metadata, 'metadata.build'),
        );

        return $this->metadata;
    }

    /**
     * Using the entity class attributes, generate the metadata.
     * The buildmetadata* functions exist to simplify the buildMetadata
     * function.
     */
    private function buildMetadataForEntity(ReflectionClass $reflectionClass): void
    {
        $entityInstance = null;

        // Fetch attributes for the entity class filterd by Attribute\Entity
        foreach ($reflectionClass->getAttributes(Attribute\Entity::class) as $attribute) {
            $instance = $attribute->newInstance();

            // Only process attributes for the Config group
            if ($instance->getGroup() !== $this->config->getGroup()) {
                continue;
            }

            // Only one matching instance per group is allowed
            assert(
                ! $entityInstance,
                'Duplicate attribute found for entity '
                . $reflectionClass->getName() . ', group ' . $instance->getGroup(),
            );
            $entityInstance = $instance;

            // Save entity-level metadata
            $this->metadata[$reflectionClass->getName()] = [
                'entityClass' => $reflectionClass->getName(),
                'byValue' => $this->config->getGlobalByValue() ?? $instance->getByValue(),
                'limit' => $instance->getLimit(),
                'fields' => [],
                'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
                'description' => $instance->getDescription(),
                'typeName' => $instance->getTypeName()
                    ? $this->appendGroupSuffix($instance->getTypeName()) :
                    $this->getTypeName($reflectionClass->getName()),
            ];
        }
    }

    /**
     * Build the metadata for each field in an entity based on the Attribute\Field
     */
    private function buildMetadataForFields(
        ClassMetadata $entityClassMetadata,
        ReflectionClass $reflectionClass,
    ): void {
        foreach ($entityClassMetadata->getFieldNames() as $fieldName) {
            $fieldInstance   = null;
            $reflectionField = $reflectionClass->getProperty($fieldName);

            foreach ($reflectionField->getAttributes(Attribute\Field::class) as $attribute) {
                $instance = $attribute->newInstance();

                // Only process attributes for the same group
                if ($instance->getGroup() !== $this->config->getGroup()) {
                    continue;
                }

                // Only one matching instance per group is allowed
                assert(
                    ! $fieldInstance,
                    'Duplicate attribute found for field '
                    . $fieldName . ', group ' . $instance->getGroup(),
                );
                $fieldInstance = $instance;

                $fieldMetadata = [
                    'alias' => $instance->getAlias(),
                    'description' => $instance->getDescription(),
                    'type' => $instance->getType() ?? $entityClassMetadata->getTypeOfField($fieldName),
                    'hydratorStrategy' => $instance->getHydratorStrategy() ??
                        $this->getDefaultStrategy($entityClassMetadata->getTypeOfField($fieldName)),
                    'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
                ];

                $this->metadata[$reflectionClass->getName()]['fields'][$fieldName] = $fieldMetadata;
            }
        }
    }

    /**
     * Build the metadata for each field in an entity based on the Attribute\Association
     */
    private function buildMetadataForAssociations(
        ReflectionClass $reflectionClass,
    ): void {
        // Fetch attributes for associations
        $associationNames = $this->entityManager->getMetadataFactory()
            ->getMetadataFor($reflectionClass->getName())
            ->getAssociationNames();

        foreach ($associationNames as $associationName) {
            $associationInstance   = null;
            $reflectionAssociation = $reflectionClass->getProperty($associationName);

            foreach ($reflectionAssociation->getAttributes(Attribute\Association::class) as $attribute) {
                $instance = $attribute->newInstance();

                // Only process attributes for the same group
                if ($instance->getGroup() !== $this->config->getGroup()) {
                    continue;
                }

                // Only one matching instance per group is allowed
                assert(
                    ! $associationInstance,
                    'Duplicate attribute found for association '
                    . $associationName . ', group ' . $instance->getGroup(),
                );

                $associationInstance = $instance;

                $associationMetadata = [
                    'alias' => $instance->getAlias(),
                    'limit' => $instance->getLimit(),
                    'description' => $instance->getDescription(),
                    'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
                    'criteriaEventName' => $instance->getCriteriaEventName(),
                    'hydratorStrategy' => $instance->getHydratorStrategy() ??
                        Strategy\AssociationDefault::class,
                ];

                $this->metadata[$reflectionClass->getName()]['fields'][$associationName] = $associationMetadata;
            }
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ApiSkeletons\Doctrine\ORM\GraphQL\Metadata;
6
7			use ApiSkeletons\Doctrine\ORM\GraphQL\Attribute;
8			use ApiSkeletons\Doctrine\ORM\GraphQL\Config;
9			use ApiSkeletons\Doctrine\ORM\GraphQL\Event\Metadata;
10			use ApiSkeletons\Doctrine\ORM\GraphQL\Filter\Filters;
11			use ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy;
12			use ApiSkeletons\Doctrine\ORM\GraphQL\Metadata\Common\MetadataFactory as CommonMetadataFactory;
13			use ArrayObject;
14			use Doctrine\ORM\EntityManager;
15			use Doctrine\ORM\Mapping\ClassMetadata;
16			use League\Event\EventDispatcher;
17			use ReflectionClass;
18
19			use function assert;
20			use function count;
21
22			/**
23			* Build metadata for entities
24			*/
25			class MetadataFactory extends CommonMetadataFactory
26			{
27			public function __construct(
28			protected ArrayObject $metadata,
29			protected readonly EntityManager $entityManager,
30			protected readonly Config $config,
31			protected readonly GlobalEnable $globalEnable,
32			protected readonly EventDispatcher $eventDispatcher,
33			) {
34			}
35
36			/**
37			* Build metadata for all entities and return it
38			*/
39			public function __invoke(): ArrayObject
40			{
41			if (count($this->metadata)) {
42			return $this->metadata;
43			}
44
45			// Fetch all entity classes from the entity manager
46			$entityClasses = [];
47			foreach ($this->entityManager->getMetadataFactory()->getAllMetadata() as $metadata) {
48			$entityClasses[] = $metadata->getName();
49			}
50
51			// If global enable is set, use the GlobalEnable class to build metadata
52			if ($this->config->getGlobalEnable()) {
53			$this->metadata = ($this->globalEnable)($entityClasses);
54
55			return $this->metadata;
56			}
57
58			// Build metadata for each entity class
59			foreach ($entityClasses as $entityClass) {
60			$reflectionClass = new ReflectionClass($entityClass);
61
62			$entityClassMetadata = $this->entityManager
63			->getMetadataFactory()
64			->getMetadataFor($reflectionClass->getName());
65
66			$this->buildMetadataForEntity($reflectionClass);
67			$this->buildMetadataForFields($entityClassMetadata, $reflectionClass);
68			$this->buildMetadataForAssociations($reflectionClass);
69			}
70
71			// Fire the metadata.build event
72			$this->eventDispatcher->dispatch(
73			new Metadata($this->metadata, 'metadata.build'),
74			);
75
76			return $this->metadata;
77			}
78
79			/**
80			* Using the entity class attributes, generate the metadata.
81			* The buildmetadata* functions exist to simplify the buildMetadata
82			* function.
83			*/
84			private function buildMetadataForEntity(ReflectionClass $reflectionClass): void
85			{
86			$entityInstance = null;
87
88			// Fetch attributes for the entity class filterd by Attribute\Entity
89			foreach ($reflectionClass->getAttributes(Attribute\Entity::class) as $attribute) {
90			$instance = $attribute->newInstance();
91
92			// Only process attributes for the Config group
93			if ($instance->getGroup() !== $this->config->getGroup()) {
94			continue;
95			}
96
97			// Only one matching instance per group is allowed
98			assert(
99			! $entityInstance,
100			'Duplicate attribute found for entity '
101			. $reflectionClass->getName() . ', group ' . $instance->getGroup(),
102			);
103			$entityInstance = $instance;
104
105			// Save entity-level metadata
106			$this->metadata[$reflectionClass->getName()] = [
107			'entityClass' => $reflectionClass->getName(),
108			'byValue' => $this->config->getGlobalByValue() ?? $instance->getByValue(),
109			'limit' => $instance->getLimit(),
110			'fields' => [],
111			'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
112			'description' => $instance->getDescription(),
113			'typeName' => $instance->getTypeName()
114			? $this->appendGroupSuffix($instance->getTypeName()) :
115			$this->getTypeName($reflectionClass->getName()),
116			];
117			}
118			}
119
120			/**
121			* Build the metadata for each field in an entity based on the Attribute\Field
122			*/
123			private function buildMetadataForFields(
124			ClassMetadata $entityClassMetadata,
125			ReflectionClass $reflectionClass,
126			): void {
127			foreach ($entityClassMetadata->getFieldNames() as $fieldName) {
128			$fieldInstance = null;
129			$reflectionField = $reflectionClass->getProperty($fieldName);
130
131			foreach ($reflectionField->getAttributes(Attribute\Field::class) as $attribute) {
132			$instance = $attribute->newInstance();
133
134			// Only process attributes for the same group
135			if ($instance->getGroup() !== $this->config->getGroup()) {
136			continue;
137			}
138
139			// Only one matching instance per group is allowed
140			assert(
141			! $fieldInstance,
142			'Duplicate attribute found for field '
143			. $fieldName . ', group ' . $instance->getGroup(),
144			);
145			$fieldInstance = $instance;
146
147			$fieldMetadata = [
148			'alias' => $instance->getAlias(),
149			'description' => $instance->getDescription(),
150			'type' => $instance->getType() ?? $entityClassMetadata->getTypeOfField($fieldName),
151			'hydratorStrategy' => $instance->getHydratorStrategy() ??
152			$this->getDefaultStrategy($entityClassMetadata->getTypeOfField($fieldName)),
153			'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
154			];
155
156			$this->metadata[$reflectionClass->getName()]['fields'][$fieldName] = $fieldMetadata;
157			}
158			}
159			}
160
161			/**
162			* Build the metadata for each field in an entity based on the Attribute\Association
163			*/
164			private function buildMetadataForAssociations(
165			ReflectionClass $reflectionClass,
166			): void {
167			// Fetch attributes for associations
168			$associationNames = $this->entityManager->getMetadataFactory()
169			->getMetadataFor($reflectionClass->getName())
170			->getAssociationNames();
171
172			foreach ($associationNames as $associationName) {
173			$associationInstance = null;
174			$reflectionAssociation = $reflectionClass->getProperty($associationName);
175
176			foreach ($reflectionAssociation->getAttributes(Attribute\Association::class) as $attribute) {
177			$instance = $attribute->newInstance();
178
179			// Only process attributes for the same group
180			if ($instance->getGroup() !== $this->config->getGroup()) {
181			continue;
182			}
183
184			// Only one matching instance per group is allowed
185			assert(
186			! $associationInstance,
187			'Duplicate attribute found for association '
188			. $associationName . ', group ' . $instance->getGroup(),
189			);
190
191			$associationInstance = $instance;
192
193			$associationMetadata = [
194			'alias' => $instance->getAlias(),
195			'limit' => $instance->getLimit(),
196			'description' => $instance->getDescription(),
197			'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
198			'criteriaEventName' => $instance->getCriteriaEventName(),
199			'hydratorStrategy' => $instance->getHydratorStrategy() ??
200			Strategy\AssociationDefault::class,
201			];
202
203			$this->metadata[$reflectionClass->getName()]['fields'][$associationName] = $associationMetadata;
204			}
205			}
206			}
207			}
208

API-Skeletons / doctrine-orm-graphql

MetadataFactory::__invoke() A last analyzed 2024-08-18 08:07 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MetadataFactory::__invoke() A
last analyzed 2024-08-18 08:07 UTC