Use string array of excludeFilters in metadata

src/Filter/FilterFactory.php

@@ -18,6 +18,7 @@
 use function array_filter;
 use function array_keys;
 use function array_merge;
+use function array_udiff;
 use function array_unique;
 use function count;
 use function in_array;
@@ -68,15 +69,10 @@ public function get(
             SORT_REGULAR,
         );
 
-        // Get a diff of the allowed filters and the excluded filters
-        // array_diff does not work on enum
-        foreach (Filters::cases() as $filter) {
-            if (in_array($filter, $excludedFilters)) {
-                continue;
-            }
-
-            $allowedFilters[] = $filter;
-        }
+        // Get the allowed filters
+        $allowedFilters = array_udiff(Filters::cases(), $excludedFilters, static function ($a, $b) {
+            return $a->value <=> $b->value;
+        });
 
         // Limit association filters
         if ($associationName) {

src/Filter/Filters.php

@@ -96,4 +96,21 @@ static function ($filter) {
 
         return $filters;
     }
+
+    /**
+     * Covert an array of enum values to an array of strings
+     *
+     * @param Filters[] $filters
+     *
+     * @return string[]
+     */
+    public static function toStringArray(array $filters): array
+    {
+        return array_map(
+            static function (Filters $filter) {
+                return $filter->value;
+            },
+            $filters,
+        );
+    }
 }

src/Metadata/MetadataFactory.php

@@ -7,6 +7,7 @@
 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 ArrayObject;
 use Doctrine\ORM\EntityManager;
@@ -108,7 +109,7 @@ private function buildMetadataForEntity(ReflectionClass $reflectionClass): void
                 'hydratorNamingStrategy' => $instance->getHydratorNamingStrategy(),
                 'fields' => [],
                 'hydratorFilters' => $instance->getHydratorFilters(),
-                'excludeFilters' => $instance->getExcludeFilters(),
+                'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
                 'description' => $instance->getDescription(),
                 'typeName' => $instance->getTypeName()
                     ? $this->appendGroupSuffix($instance->getTypeName()) :
@@ -149,7 +150,7 @@ private function buildMetadataForFields(
                     'type' => $instance->getType() ?? $entityClassMetadata->getTypeOfField($fieldName),
                     'hydratorStrategy' => $instance->getHydratorStrategy() ??
                         $this->getDefaultStrategy($entityClassMetadata->getTypeOfField($fieldName)),
-                    'excludeFilters' => $instance->getExcludeFilters(),
+                    'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
                 ];
 
                 $this->metadata[$reflectionClass->getName()]['fields'][$fieldName] = $fieldMetadata;
@@ -193,7 +194,7 @@ private function buildMetadataForAssociations(
                 $associationMetadata = [
                     'limit' => $instance->getLimit(),
                     'description' => $instance->getDescription(),
-                    'excludeFilters' => $instance->getExcludeFilters(),
+                    'excludeFilters' => Filters::toStringArray($instance->getExcludeFilters()),
                     'criteriaEventName' => $instance->getCriteriaEventName(),
                     'hydratorStrategy' => $instance->getHydratorStrategy() ??
                         Strategy\AssociationDefault::class,

test/Entity/User.php

@@ -5,6 +5,7 @@
 namespace ApiSkeletonsTest\Doctrine\ORM\GraphQL\Entity;
 
 use ApiSkeletons\Doctrine\ORM\GraphQL\Attribute as GraphQL;
+use ApiSkeletons\Doctrine\ORM\GraphQL\Filter\Filters;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Filter\Password;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\AssociationDefault;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\ToBoolean;
@@ -22,6 +23,7 @@
 #[GraphQL\Entity(group: 'NamingStrategyTest', hydratorNamingStrategy: CustomNamingStrategy::class)]
 #[GraphQL\Entity(group: 'CustomFieldStrategyTest')]
 #[GraphQL\Entity(group: 'InputFactoryTest')]
+#[GraphQL\Entity(group: 'StaticMetadata')]
 #[ORM\Entity]
 class User
 {
@@ -31,6 +33,7 @@ class User
     #[GraphQL\Field(group: 'NamingStrategyTest')]
     #[GraphQL\Field(group: 'CustomFieldStrategyTest', hydratorStrategy: ToBoolean::class)]
     #[GraphQL\Field(group: 'InputFactoryTest')]
+    #[GraphQL\Field(group: 'StaticMetadata')]
     #[ORM\Column(type: 'string', nullable: false)]
     private string $name;
 
@@ -57,6 +60,7 @@ class User
     /** @var Collection<id, Recording> */
     #[GraphQL\Association(description: 'Recordings')]
     #[GraphQL\Association(group: 'CustomFieldStrategyTest', hydratorStrategy: AssociationDefault::class)]
+    #[GraphQL\Association(group: 'StaticMetadata', excludeFilters: [Filters::EQ])]
     #[ORM\ManyToMany(targetEntity: 'ApiSkeletonsTest\Doctrine\ORM\GraphQL\Entity\Recording', inversedBy: 'users')]
     #[ORM\JoinTable(name: 'RecordingToUser')]
     #[ORM\JoinColumn(name: 'user_id', referencedColumnName: 'id', nullable: false)]

test/Feature/Metadata/CachingTest.php

@@ -4,6 +4,7 @@
 
 namespace ApiSkeletonsTest\Doctrine\ORM\GraphQL\Feature\Metadata;
 
+use ApiSkeletons\Doctrine\ORM\GraphQL\Config;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Driver;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Type\Entity;
 use ApiSkeletons\Doctrine\ORM\GraphQL\Type\TypeManager;
@@ -28,36 +29,42 @@ public function testCacheMetadata(): void
 
     public function testStaticMetadata(): void
     {
+        $driver            = new Driver($this->getEntityManager(), new Config(['group' => 'StaticMetadata']));
+        $generatedMetadata = $driver->get('metadata')->getArrayCopy();
+
         $metadata = [
             'ApiSkeletonsTest\Doctrine\ORM\GraphQL\Entity\User' => [
                 'entityClass' => 'ApiSkeletonsTest\Doctrine\ORM\GraphQL\Entity\User',
-                'documentation' => '',
-                'byValue' => 1,
-                'namingStrategy' => null,
+                'byValue' => true,
+                'limit' => 0,
+                'description' => '',
+                'hydratorNamingStrategy' => null,
+                'hydratorFilters' => [],
+                'excludeFilters' => [],
+                'typeName' => 'ApiSkeletonsTest_Doctrine_ORM_GraphQL_Entity_User_StaticMetadata',
                 'fields' => [
                     'name' => [
-                        'strategy' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\FieldDefault',
-                        'documentation' => '',
+                        'description' => null,
+                        'type' => 'string',
+                        'hydratorStrategy' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\FieldDefault',
+                        'excludeFilters' => [],
                     ],
                     'recordings' => [
-                        'strategy' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\AssociationDefault',
-                        'excludeCriteria' => ['eq'],
-                        'documentation' => '',
+                        'limit' => null,
+                        'description' => null,
+                        'criteriaEventName' => null,
+                        'hydratorStrategy' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\AssociationDefault',
+                        'excludeFilters' => ['eq'],
                     ],
                 ],
-
-                'strategies' => [
-                    'name' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\FieldDefault',
-                    'email' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\FieldDefault',
-                    'id' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\ToInteger',
-                    'recordings' => 'ApiSkeletons\Doctrine\ORM\GraphQL\Hydrator\Strategy\AssociationDefault',
-                ],
-                'filters' => [],
-                'typeName' => 'User',
             ],
         ];
 
-        $driver = new Driver($this->getEntityManager(), null, $metadata);
+        $driver = new Driver($this->getEntityManager(), new Config(['group' => 'StaticMetadata']), $metadata);
+
+        $this->assertEquals($generatedMetadata, $metadata);
+        $this->assertEquals($generatedMetadata, $driver->get('metadata')->getArrayCopy());
+
         $this->assertInstanceOf(Entity::class, $driver->get(TypeManager::class)->build(Entity::class, User::class));
 
         $this->expectException(Error::class);