From 65c1303395be5ad79dd4bae92269e65e0638ce85 Mon Sep 17 00:00:00 2001 From: Valentin Date: Mon, 16 Nov 2026 23:24:38 +0100 Subject: [PATCH 1/3] feat(metadata): enumClass on parameters A parameter can name a PHP backed enum as the source of its allowed values. The enum fills the schema "type" and "enum", which OpenAPI and the parameter validation already read. Closes #8686 Co-Authored-By: Claude Fable 5.2 --- src/Metadata/Parameter.php | 21 ++++ ...meterResourceMetadataCollectionFactory.php | 30 +++++ .../ApiResource/WithEnumParameter.php | 36 ++++++ .../Tests/Fixtures/Enum/IntBackedPriority.php | 20 ++++ .../Fixtures/Enum/StringBackedStatus.php | 20 ++++ src/Metadata/Tests/Fixtures/Enum/UnitSuit.php | 20 ++++ ...rResourceMetadataCollectionFactoryTest.php | 107 ++++++++++++++++++ .../EnumClassParameter/EnumClassParameter.php | 39 +++++++ .../EnumClassParameter/Priority.php | 20 ++++ .../ApiResource/EnumClassParameter/Status.php | 20 ++++ .../Parameters/EnumClassParameterTest.php | 81 +++++++++++++ 11 files changed, 414 insertions(+) create mode 100644 src/Metadata/Tests/Fixtures/ApiResource/WithEnumParameter.php create mode 100644 src/Metadata/Tests/Fixtures/Enum/IntBackedPriority.php create mode 100644 src/Metadata/Tests/Fixtures/Enum/StringBackedStatus.php create mode 100644 src/Metadata/Tests/Fixtures/Enum/UnitSuit.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/EnumClassParameter.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Priority.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Status.php create mode 100644 tests/Functional/Parameters/EnumClassParameterTest.php diff --git a/src/Metadata/Parameter.php b/src/Metadata/Parameter.php index 715e09b1e88..60fb6bde010 100644 --- a/src/Metadata/Parameter.php +++ b/src/Metadata/Parameter.php @@ -43,6 +43,7 @@ abstract class Parameter * @param ?callable(mixed): mixed $castFn the closure used to cast your parameter, this gets called only when $castToNativeType is set * @param ?string $filterClass the class to use when resolving filter properties (from stateOptions) * @param list>|null $operations a list of operations (instances or class names) this parameter applies to (if null, applies to all operations) + * @param class-string<\BackedEnum>|null $enumClass a backed enum whose case values are the allowed values (fills the schema "enum" and "type") * * @phpstan-param array|null $schema * @@ -72,6 +73,7 @@ public function __construct( protected mixed $default = null, protected ?string $filterClass = null, protected ?array $operations = null, + protected ?string $enumClass = null, ) { } @@ -439,4 +441,23 @@ public function withOperations(?array $operations): self return $self; } + + /** + * @return class-string<\BackedEnum>|null + */ + public function getEnumClass(): ?string + { + return $this->enumClass; + } + + /** + * @param class-string<\BackedEnum>|null $enumClass + */ + public function withEnumClass(?string $enumClass): static + { + $self = clone $this; + $self->enumClass = $enumClass; + + return $self; + } } diff --git a/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php b/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php index fe1391b5978..eedb7e090f8 100644 --- a/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php +++ b/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php @@ -16,6 +16,7 @@ use ApiPlatform\Doctrine\Common\Filter\ManagerRegistryAwareInterface; use ApiPlatform\Doctrine\Common\Filter\PropertyAwareFilterInterface; use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\Exception\InvalidArgumentException; use ApiPlatform\Metadata\Exception\RuntimeException; use ApiPlatform\Metadata\FilterInterface; use ApiPlatform\Metadata\JsonSchemaFilterInterface; @@ -324,6 +325,7 @@ private function getDefaultParameters(Operation $operation, string $resourceClas $parameter = $parameter->withProperties($propertyNames); } + $parameter = $this->resolveEnumClass($parameter); $parameter = $this->setDefaults($key, $parameter, $filter, $properties, $operation); // We don't do any type cast yet, a query parameter or an header is always a string or a list of strings if (null === $parameter->getNativeType()) { @@ -478,6 +480,34 @@ private function setDefaults(string $key, Parameter $parameter, ?object $filter, return $parameter; } + /** + * Fills the schema "type" and "enum" from the backed enum, keeping the keys declared explicitly in the schema. + * + * The resulting schema behaves like an explicit one: it is resolved before the filter metadata, so a schema + * provided by the filter is not merged into it. + */ + private function resolveEnumClass(Parameter $parameter): Parameter + { + if (null === $enumClass = $parameter->getEnumClass()) { + return $parameter; + } + + if (!enum_exists($enumClass) || !is_subclass_of($enumClass, \BackedEnum::class)) { + throw new InvalidArgumentException(\sprintf('The "enumClass" of the parameter "%s" must be a backed enum, "%s" given.', $parameter->getKey(), $enumClass)); + } + + $type = 'int' === (new \ReflectionEnum($enumClass))->getBackingType()?->getName() ? 'integer' : 'string'; + $schema = ($parameter->getSchema() ?? []) + ['type' => $type, 'enum' => array_column($enumClass::cases(), 'value')]; + $parameter = $parameter->withSchema($schema); + + // Query and header values arrive as strings: cast them so they strictly match the int case values. + if ('integer' === $schema['type'] && null === $parameter->getCastToNativeType()) { + $parameter = $parameter->withCastToNativeType(true); + } + + return $parameter; + } + private function getLegacyFilterMetadata(Parameter $parameter, Operation $operation, FilterInterface $filter): Parameter { $description = $filter->getDescription($this->getStateOptionsClass($operation, $operation->getClass())); diff --git a/src/Metadata/Tests/Fixtures/ApiResource/WithEnumParameter.php b/src/Metadata/Tests/Fixtures/ApiResource/WithEnumParameter.php new file mode 100644 index 00000000000..ea2c1334ad3 --- /dev/null +++ b/src/Metadata/Tests/Fixtures/ApiResource/WithEnumParameter.php @@ -0,0 +1,36 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Metadata\Tests\Fixtures\ApiResource; + +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\HeaderParameter; +use ApiPlatform\Metadata\QueryParameter; +use ApiPlatform\Metadata\Tests\Fixtures\Enum\IntBackedPriority; +use ApiPlatform\Metadata\Tests\Fixtures\Enum\StringBackedStatus; + +#[ApiResource(operations: [ + new GetCollection(name: 'collection', parameters: [ + 'status' => new QueryParameter(enumClass: StringBackedStatus::class), + 'priority' => new QueryParameter(enumClass: IntBackedPriority::class), + 'priorityNoCast' => new QueryParameter(enumClass: IntBackedPriority::class, castToNativeType: false), + 'narrowed' => new QueryParameter(schema: ['enum' => ['draft']], enumClass: StringBackedStatus::class), + 'typed' => new QueryParameter(schema: ['type' => 'string'], enumClass: IntBackedPriority::class), + 'X-Status' => new HeaderParameter(enumClass: StringBackedStatus::class), + ]), +])] +class WithEnumParameter +{ + public $id; +} diff --git a/src/Metadata/Tests/Fixtures/Enum/IntBackedPriority.php b/src/Metadata/Tests/Fixtures/Enum/IntBackedPriority.php new file mode 100644 index 00000000000..9abc7fafb61 --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Enum/IntBackedPriority.php @@ -0,0 +1,20 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Metadata\Tests\Fixtures\Enum; + +enum IntBackedPriority: int +{ + case Low = 1; + case High = 2; +} diff --git a/src/Metadata/Tests/Fixtures/Enum/StringBackedStatus.php b/src/Metadata/Tests/Fixtures/Enum/StringBackedStatus.php new file mode 100644 index 00000000000..ea526fb605c --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Enum/StringBackedStatus.php @@ -0,0 +1,20 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Metadata\Tests\Fixtures\Enum; + +enum StringBackedStatus: string +{ + case Draft = 'draft'; + case Published = 'published'; +} diff --git a/src/Metadata/Tests/Fixtures/Enum/UnitSuit.php b/src/Metadata/Tests/Fixtures/Enum/UnitSuit.php new file mode 100644 index 00000000000..8ca18b9be9f --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Enum/UnitSuit.php @@ -0,0 +1,20 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Metadata\Tests\Fixtures\Enum; + +enum UnitSuit +{ + case Hearts; + case Spades; +} diff --git a/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php b/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php index 561a433de53..9453d600981 100644 --- a/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php +++ b/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php @@ -16,6 +16,7 @@ use ApiPlatform\Metadata\ApiProperty; use ApiPlatform\Metadata\ApiResource; use ApiPlatform\Metadata\Delete; +use ApiPlatform\Metadata\Exception\InvalidArgumentException; use ApiPlatform\Metadata\Exception\RuntimeException; use ApiPlatform\Metadata\FilterInterface; use ApiPlatform\Metadata\Get; @@ -23,6 +24,8 @@ use ApiPlatform\Metadata\GraphQl\Mutation; use ApiPlatform\Metadata\GraphQl\QueryCollection; use ApiPlatform\Metadata\HeaderParameter; +use ApiPlatform\Metadata\JsonSchemaFilterInterface; +use ApiPlatform\Metadata\Parameter as MetadataParameter; use ApiPlatform\Metadata\ParameterProviderFilterInterface; use ApiPlatform\Metadata\Parameters; use ApiPlatform\Metadata\Patch; @@ -33,9 +36,16 @@ use ApiPlatform\Metadata\QueryParameter; use ApiPlatform\Metadata\Resource\Factory\AttributesResourceMetadataCollectionFactory; use ApiPlatform\Metadata\Resource\Factory\ParameterResourceMetadataCollectionFactory; +use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface; +use ApiPlatform\Metadata\Resource\ResourceMetadataCollection; +use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\WithEnumParameter; use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\WithLimitedPropertyParameter; use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\WithParameter; +use ApiPlatform\Metadata\Tests\Fixtures\Enum\IntBackedPriority; +use ApiPlatform\Metadata\Tests\Fixtures\Enum\UnitSuit; use ApiPlatform\OpenApi\Model\Parameter; +use ApiPlatform\State\Parameter\ValueCaster; +use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\TestCase; use Psr\Container\ContainerInterface; use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter; @@ -1313,6 +1323,90 @@ public function testProviderAttachedForClassStringFilterNotRegisteredAsFilterInt $this->assertNotNull($param); $this->assertSame(ClassStringParameterProviderFilter::getParameterProvider(), $param->getProvider()); } + + public function testEnumClassIsResolvedToSchema(): void + { + $parameterFactory = $this->createEnumClassParameterFactory(new AttributesResourceMetadataCollectionFactory()); + $parameters = $parameterFactory->create(WithEnumParameter::class)->getOperation('collection')->getParameters(); + + $status = $parameters->get('status', QueryParameter::class); + $this->assertSame(['type' => 'string', 'enum' => ['draft', 'published']], $status->getSchema()); + $this->assertEquals(Type::string(), $status->getNativeType()); + + $priority = $parameters->get('priority', QueryParameter::class); + $this->assertSame(['type' => 'integer', 'enum' => [1, 2]], $priority->getSchema()); + $this->assertTrue($priority->getCastToNativeType()); + $this->assertSame([ValueCaster::class, 'toInt'], $priority->getCastFn()); + + $this->assertFalse($parameters->get('priorityNoCast', QueryParameter::class)->getCastToNativeType()); + + $this->assertEquals(['enum' => ['draft'], 'type' => 'string'], $parameters->get('narrowed', QueryParameter::class)->getSchema()); + + $typed = $parameters->get('typed', QueryParameter::class); + $this->assertSame(['type' => 'string', 'enum' => [1, 2]], $typed->getSchema()); + $this->assertNull($typed->getCastToNativeType()); + + $this->assertSame(['draft', 'published'], $parameters->get('X-Status', HeaderParameter::class)->getSchema()['enum']); + } + + #[DataProvider('provideInvalidEnumClasses')] + public function testEnumClassMustBeABackedEnum(string $enumClass): void + { + $decorated = $this->createStub(ResourceMetadataCollectionFactoryInterface::class); + $decorated->method('create')->willReturn(new ResourceMetadataCollection('Dummy', [ + new ApiResource(operations: [ + new GetCollection(name: 'collection', parameters: ['status' => new QueryParameter(enumClass: $enumClass)]), + ]), + ])); + + $this->expectException(InvalidArgumentException::class); + $this->expectExceptionMessage(\sprintf('The "enumClass" of the parameter "status" must be a backed enum, "%s" given.', $enumClass)); + + $this->createEnumClassParameterFactory($decorated)->create('Dummy'); + } + + public function testEnumClassWinsOverFilterSchema(): void + { + $decorated = $this->createStub(ResourceMetadataCollectionFactoryInterface::class); + $decorated->method('create')->willReturn(new ResourceMetadataCollection(\stdClass::class, [ + new ApiResource(operations: [ + // A class is needed for the filter description (legacy filter metadata). + new GetCollection(name: 'collection', class: \stdClass::class, parameters: [ + 'priority' => new QueryParameter(filter: new NumberSchemaFilter(), enumClass: IntBackedPriority::class), + ]), + ]), + ])); + + $priority = $this->createEnumClassParameterFactory($decorated)->create(\stdClass::class)->getOperation('collection')->getParameters()->get('priority', QueryParameter::class); + + $this->assertSame(['type' => 'integer', 'enum' => [1, 2]], $priority->getSchema()); + $this->assertTrue($priority->getCastToNativeType()); + $this->assertSame([ValueCaster::class, 'toInt'], $priority->getCastFn()); + } + + public static function provideInvalidEnumClasses(): iterable + { + yield 'non-backed enum' => [UnitSuit::class]; + yield 'not an enum' => [\stdClass::class]; + yield 'missing class' => ['App\\DoesNotExist']; + } + + private function createEnumClassParameterFactory(ResourceMetadataCollectionFactoryInterface $decorated): ParameterResourceMetadataCollectionFactory + { + $nameCollection = $this->createStub(PropertyNameCollectionFactoryInterface::class); + $nameCollection->method('create')->willReturn(new PropertyNameCollection(['id'])); + $propertyMetadata = $this->createStub(PropertyMetadataFactoryInterface::class); + $propertyMetadata->method('create')->willReturn(new ApiProperty(identifier: true)); + $filterLocator = $this->createStub(ContainerInterface::class); + $filterLocator->method('has')->willReturn(false); + + return new ParameterResourceMetadataCollectionFactory( + $nameCollection, + $propertyMetadata, + $decorated, + $filterLocator + ); + } } class ClassStringParameterProviderFilter implements ParameterProviderFilterInterface @@ -1323,6 +1417,19 @@ public static function getParameterProvider(): string } } +class NumberSchemaFilter implements FilterInterface, JsonSchemaFilterInterface +{ + public function getDescription(string $resourceClass): array + { + return []; + } + + public function getSchema(MetadataParameter $parameter): array + { + return ['type' => 'number']; + } +} + class ParameterProviderFilter implements FilterInterface, ParameterProviderFilterInterface { public function getDescription(string $resourceClass): array diff --git a/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/EnumClassParameter.php b/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/EnumClassParameter.php new file mode 100644 index 00000000000..1631e8770c0 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/EnumClassParameter.php @@ -0,0 +1,39 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\EnumClassParameter; + +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Operation; +use ApiPlatform\Metadata\QueryParameter; + +#[ApiResource( + operations: [ + new GetCollection( + uriTemplate: '/enum_class_parameters', + parameters: [ + 'status' => new QueryParameter(enumClass: Status::class), + 'priority' => new QueryParameter(enumClass: Priority::class), + ], + provider: [self::class, 'provide'], + ), + ] +)] +class EnumClassParameter +{ + public static function provide(Operation $operation): array + { + return []; + } +} diff --git a/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Priority.php b/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Priority.php new file mode 100644 index 00000000000..7e64379629b --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Priority.php @@ -0,0 +1,20 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\EnumClassParameter; + +enum Priority: int +{ + case Low = 1; + case High = 2; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Status.php b/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Status.php new file mode 100644 index 00000000000..c8a20f50621 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/EnumClassParameter/Status.php @@ -0,0 +1,20 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\EnumClassParameter; + +enum Status: string +{ + case Draft = 'draft'; + case Published = 'published'; +} diff --git a/tests/Functional/Parameters/EnumClassParameterTest.php b/tests/Functional/Parameters/EnumClassParameterTest.php new file mode 100644 index 00000000000..a7c715d02c3 --- /dev/null +++ b/tests/Functional/Parameters/EnumClassParameterTest.php @@ -0,0 +1,81 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Functional\Parameters; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\EnumClassParameter\EnumClassParameter; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use PHPUnit\Framework\Attributes\DataProvider; + +final class EnumClassParameterTest extends ApiTestCase +{ + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [EnumClassParameter::class]; + } + + #[DataProvider('provideValidValues')] + public function testValidValueIsAccepted(string $query): void + { + self::createClient()->request('GET', '/enum_class_parameters?'.$query); + + $this->assertResponseIsSuccessful(); + } + + public static function provideValidValues(): \Generator + { + yield 'string backed enum' => ['status=draft']; + yield 'int backed enum' => ['priority=2']; + } + + #[DataProvider('provideInvalidValues')] + public function testInvalidValueIsRejected(string $parameter, string $value): void + { + $response = self::createClient()->request('GET', '/enum_class_parameters?'.$parameter.'='.$value); + + $this->assertResponseStatusCodeSame(422); + $this->assertArraySubset([ + 'violations' => [ + ['propertyPath' => $parameter, 'message' => 'The value you selected is not a valid choice.'], + ], + ], $response->toArray(false)); + } + + public static function provideInvalidValues(): \Generator + { + yield 'unknown string case' => ['status', 'foo']; + yield 'unknown int case' => ['priority', '3']; + yield 'non numeric int value' => ['priority', 'foo']; + } + + public function testOpenApiSchema(): void + { + $response = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ]); + $this->assertResponseIsSuccessful(); + + $parameters = array_column($response->toArray()['paths']['/enum_class_parameters']['get']['parameters'], null, 'name'); + + $this->assertSame(['type' => 'string', 'enum' => ['draft', 'published']], $parameters['status']['schema']); + $this->assertSame(['type' => 'integer', 'enum' => [1, 2]], $parameters['priority']['schema']); + } +} From b0d0467dfaf055fac11363ae2ad7d75d5b8f669f Mon Sep 17 00:00:00 2001 From: Valentin Date: Tue, 17 Nov 2026 09:57:43 +0100 Subject: [PATCH 2/3] fix(metadata): enumClass parameters take a list of values with a filter A filter such as ExactFilter takes a value or a list of values. With "enumClass", the scalar schema type narrowed the parameter to a single value, so "?type[]=a&type[]=b" was rejected while still documented. The enum now constrains the values a filter receives, not their shape. The scalar type constraint is applied to each value of a list. Closes #8816 Co-Authored-By: Claude Fable 5.2 --- ...meterResourceMetadataCollectionFactory.php | 9 +- .../Util/ParameterValidationConstraints.php | 25 ++-- .../Entity/Issue8816/ActivityLevel.php | 21 ++++ .../Entity/Issue8816/ActivityType.php | 21 ++++ .../Entity/Issue8816/EnumFilteredActivity.php | 62 ++++++++++ .../Parameters/EnumClassExactFilterTest.php | 110 ++++++++++++++++++ 6 files changed, 235 insertions(+), 13 deletions(-) create mode 100644 tests/Fixtures/TestBundle/Entity/Issue8816/ActivityLevel.php create mode 100644 tests/Fixtures/TestBundle/Entity/Issue8816/ActivityType.php create mode 100644 tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php create mode 100644 tests/Functional/Parameters/EnumClassExactFilterTest.php diff --git a/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php b/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php index eedb7e090f8..38aa40b06b6 100644 --- a/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php +++ b/src/Metadata/Resource/Factory/ParameterResourceMetadataCollectionFactory.php @@ -497,9 +497,16 @@ private function resolveEnumClass(Parameter $parameter): Parameter } $type = 'int' === (new \ReflectionEnum($enumClass))->getBackingType()?->getName() ? 'integer' : 'string'; - $schema = ($parameter->getSchema() ?? []) + ['type' => $type, 'enum' => array_column($enumClass::cases(), 'value')]; + $declaredSchema = $parameter->getSchema() ?? []; + $schema = $declaredSchema + ['type' => $type, 'enum' => array_column($enumClass::cases(), 'value')]; $parameter = $parameter->withSchema($schema); + // The enum constrains the values a filter receives, not their shape: as without an enum, a filter takes a value or a list of values. + if (null !== $parameter->getFilter() && null === $parameter->getNativeType() && !isset($declaredSchema['type']) && false !== $parameter->getCastToArray() && !$parameter instanceof ScalarHeaderParameter) { + $valueType = 'integer' === $type ? Type::int() : Type::string(); + $parameter = $parameter->withNativeType(Type::union($valueType, Type::list($valueType))); + } + // Query and header values arrive as strings: cast them so they strictly match the int case values. if ('integer' === $schema['type'] && null === $parameter->getCastToNativeType()) { $parameter = $parameter->withCastToNativeType(true); diff --git a/src/Validator/Util/ParameterValidationConstraints.php b/src/Validator/Util/ParameterValidationConstraints.php index dda03359be5..fc1fb798bf3 100644 --- a/src/Validator/Util/ParameterValidationConstraints.php +++ b/src/Validator/Util/ParameterValidationConstraints.php @@ -102,6 +102,19 @@ public static function getParameterValidationConstraints(Parameter $parameter, ? $assertions[] = new Choice(choices: $schema['enum']); } + // The scalar type applies to each value: it is declared before the collection wrapping below. + if (isset($schema['type']) && $parameter->getCastToNativeType()) { + $assertion = match ($schema['type']) { + 'boolean', 'integer' => new Type(type: $schema['type']), + 'number' => new Type(type: 'float'), + default => null, + }; + + if ($assertion) { + $assertions[] = $assertion; + } + } + $isCollectionType = static fn ($t) => $t instanceof CollectionType; $isCollection = $parameter->getNativeType()?->isSatisfiedBy($isCollectionType) ?? false; @@ -138,18 +151,6 @@ public static function getParameterValidationConstraints(Parameter $parameter, ? $assertions[] = new Type(type: 'array'); } - if (isset($schema['type']) && $parameter->getCastToNativeType()) { - $assertion = match ($schema['type']) { - 'boolean', 'integer' => new Type(type: $schema['type']), - 'number' => new Type(type: 'float'), - default => null, - }; - - if ($assertion) { - $assertions[] = $assertion; - } - } - if (isset($schema['type'], $schema['format']) && 'string' === $schema['type'] && 'uuid' === $schema['format']) { $assertions[] = new Uuid(); } diff --git a/tests/Fixtures/TestBundle/Entity/Issue8816/ActivityLevel.php b/tests/Fixtures/TestBundle/Entity/Issue8816/ActivityLevel.php new file mode 100644 index 00000000000..0933128280a --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/Issue8816/ActivityLevel.php @@ -0,0 +1,21 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816; + +enum ActivityLevel: int +{ + case Beginner = 1; + case Advanced = 2; + case Expert = 3; +} diff --git a/tests/Fixtures/TestBundle/Entity/Issue8816/ActivityType.php b/tests/Fixtures/TestBundle/Entity/Issue8816/ActivityType.php new file mode 100644 index 00000000000..cb7af938e9f --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/Issue8816/ActivityType.php @@ -0,0 +1,21 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816; + +enum ActivityType: string +{ + case Meeting = 'meeting'; + case Workshop = 'workshop'; + case Webinar = 'webinar'; +} diff --git a/tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php b/tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php new file mode 100644 index 00000000000..6b5249ff53b --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php @@ -0,0 +1,62 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816; + +use ApiPlatform\Doctrine\Orm\Filter\ExactFilter; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\QueryParameter; +use Doctrine\ORM\Mapping as ORM; + +#[GetCollection( + uriTemplate: 'enum_filtered_activities{._format}', + parameters: [ + 'type' => new QueryParameter(filter: new ExactFilter(), property: 'type', enumClass: ActivityType::class), + 'level' => new QueryParameter(filter: new ExactFilter(), property: 'level', enumClass: ActivityLevel::class), + ], +)] +#[ORM\Entity] +class EnumFilteredActivity +{ + #[ORM\Column(type: 'integer')] + #[ORM\Id] + #[ORM\GeneratedValue(strategy: 'AUTO')] + private ?int $id = null; + + #[ORM\Column(enumType: ActivityType::class)] + private ActivityType $type; + + #[ORM\Column(enumType: ActivityLevel::class)] + private ActivityLevel $level; + + public function __construct(ActivityType $type = ActivityType::Meeting, ActivityLevel $level = ActivityLevel::Beginner) + { + $this->type = $type; + $this->level = $level; + } + + public function getId(): ?int + { + return $this->id; + } + + public function getType(): ActivityType + { + return $this->type; + } + + public function getLevel(): ActivityLevel + { + return $this->level; + } +} diff --git a/tests/Functional/Parameters/EnumClassExactFilterTest.php b/tests/Functional/Parameters/EnumClassExactFilterTest.php new file mode 100644 index 00000000000..0062e46a85e --- /dev/null +++ b/tests/Functional/Parameters/EnumClassExactFilterTest.php @@ -0,0 +1,110 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Functional\Parameters; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityLevel; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityType; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\EnumFilteredActivity; +use ApiPlatform\Tests\RecreateSchemaTrait; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use PHPUnit\Framework\Attributes\DataProvider; + +/** + * An "enumClass" parameter combined with a filter accepting both a value and a list of values. + * + * @see https://github.com/api-platform/core/issues/8816 + */ +final class EnumClassExactFilterTest extends ApiTestCase +{ + use RecreateSchemaTrait; + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [EnumFilteredActivity::class]; + } + + protected function setUp(): void + { + if ($this->isMongoDB()) { + $this->markTestSkipped('The fixture uses the Doctrine ORM ExactFilter.'); + } + + $this->recreateSchema(self::getResources()); + + $manager = static::getContainer()->get('doctrine')->getManager(); + $manager->persist(new EnumFilteredActivity(ActivityType::Meeting, ActivityLevel::Beginner)); + $manager->persist(new EnumFilteredActivity(ActivityType::Workshop, ActivityLevel::Advanced)); + $manager->persist(new EnumFilteredActivity(ActivityType::Webinar, ActivityLevel::Expert)); + $manager->flush(); + } + + /** + * @param list $expectedTypes + */ + #[DataProvider('provideValidQueries')] + public function testFiltersOnEnumValues(string $query, array $expectedTypes): void + { + $response = self::createClient()->request('GET', '/enum_filtered_activities?'.$query); + + $this->assertResponseIsSuccessful(); + $this->assertSame($expectedTypes, array_column($response->toArray()['hydra:member'], 'type')); + } + + public static function provideValidQueries(): \Generator + { + yield 'string backed enum, single value' => ['type=workshop', ['workshop']]; + yield 'string backed enum, list of values' => ['type[]=meeting&type[]=webinar', ['meeting', 'webinar']]; + yield 'int backed enum, single value' => ['level=2', ['workshop']]; + yield 'int backed enum, list of values' => ['level[]=1&level[]=3', ['meeting', 'webinar']]; + } + + #[DataProvider('provideInvalidQueries')] + public function testRejectsValuesOutsideTheEnum(string $query): void + { + self::createClient()->request('GET', '/enum_filtered_activities?'.$query); + + $this->assertResponseStatusCodeSame(422); + } + + public static function provideInvalidQueries(): \Generator + { + yield 'string backed enum, single value' => ['type=party']; + yield 'string backed enum, list with an unknown value' => ['type[]=meeting&type[]=party']; + yield 'int backed enum, single value' => ['level=4']; + yield 'int backed enum, list with an unknown value' => ['level[]=1&level[]=4']; + yield 'int backed enum, non numeric value' => ['level=foo']; + } + + public function testOpenApiDocumentsTheEnumOnBothForms(): void + { + $response = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ]); + $this->assertResponseIsSuccessful(); + + $parameters = array_column($response->toArray()['paths']['/enum_filtered_activities']['get']['parameters'], null, 'name'); + + $this->assertSame(['type' => 'string', 'enum' => ['meeting', 'workshop', 'webinar']], $parameters['type']['schema']); + $this->assertSame(['type' => 'array', 'items' => ['type' => 'string', 'enum' => ['meeting', 'workshop', 'webinar']]], $parameters['type[]']['schema']); + $this->assertSame(['type' => 'integer', 'enum' => [1, 2, 3]], $parameters['level']['schema']); + $this->assertSame(['type' => 'array', 'items' => ['type' => 'integer', 'enum' => [1, 2, 3]]], $parameters['level[]']['schema']); + } +} From 735bc50e593adbe7aea651411dc34d262319f5c1 Mon Sep 17 00:00:00 2001 From: Valentin Date: Tue, 17 Nov 2026 10:31:53 +0100 Subject: [PATCH 3/3] test(metadata): cover enumClass with MongoDB, GraphQL and Laravel Unit tests for the shape of an enumClass parameter (value or list of values with a filter) and for the scalar type constraint applied to each value of a list. The ExactFilter functional test now runs with the MongoDB ODM, and enumClass is tested as a GraphQL collection argument and in the Laravel workbench. Co-Authored-By: Claude Fable 5.2 --- src/Laravel/Tests/EnumClassParameterTest.php | 65 +++++++++++++ .../ApiResource/WithEnumClassParameter.php | 40 ++++++++ .../workbench/app/Enums/TicketPriority.php | 20 ++++ .../workbench/app/Enums/TicketStatus.php | 20 ++++ ...rResourceMetadataCollectionFactoryTest.php | 44 +++++++++ .../ParameterValidationConstraintsTest.php | 32 +++++++ .../Issue8816/EnumFilteredActivity.php | 80 ++++++++++++++++ .../Entity/Issue8816/EnumFilteredActivity.php | 28 +++++- .../GraphQl/EnumClassParameterTest.php | 95 +++++++++++++++++++ .../Parameters/EnumClassExactFilterTest.php | 14 ++- 10 files changed, 425 insertions(+), 13 deletions(-) create mode 100644 src/Laravel/Tests/EnumClassParameterTest.php create mode 100644 src/Laravel/workbench/app/ApiResource/WithEnumClassParameter.php create mode 100644 src/Laravel/workbench/app/Enums/TicketPriority.php create mode 100644 src/Laravel/workbench/app/Enums/TicketStatus.php create mode 100644 tests/Fixtures/TestBundle/Document/Issue8816/EnumFilteredActivity.php create mode 100644 tests/Functional/GraphQl/EnumClassParameterTest.php diff --git a/src/Laravel/Tests/EnumClassParameterTest.php b/src/Laravel/Tests/EnumClassParameterTest.php new file mode 100644 index 00000000000..a5c294bf925 --- /dev/null +++ b/src/Laravel/Tests/EnumClassParameterTest.php @@ -0,0 +1,65 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Laravel\Tests; + +use ApiPlatform\Laravel\Test\ApiTestAssertionsTrait; +use Orchestra\Testbench\Concerns\WithWorkbench; +use Orchestra\Testbench\TestCase; +use PHPUnit\Framework\Attributes\DataProvider; + +class EnumClassParameterTest extends TestCase +{ + use ApiTestAssertionsTrait; + use WithWorkbench; + + #[DataProvider('provideValidValues')] + public function testValidValueIsAccepted(string $query): void + { + $response = $this->get('/api/with_enum_class_parameters?'.$query, ['Accept' => 'application/ld+json']); + + $response->assertStatus(200); + } + + public static function provideValidValues(): \Generator + { + yield 'string backed enum' => ['status=open']; + yield 'int backed enum' => ['priority=2']; + } + + #[DataProvider('provideInvalidValues')] + public function testInvalidValueIsRejected(string $query): void + { + $response = $this->get('/api/with_enum_class_parameters?'.$query, ['Accept' => 'application/ld+json']); + + $response->assertStatus(422); + } + + public static function provideInvalidValues(): \Generator + { + yield 'unknown string case' => ['status=foo']; + yield 'unknown int case' => ['priority=3']; + yield 'non numeric int value' => ['priority=foo']; + } + + public function testOpenApiSchema(): void + { + $response = $this->get('/api/docs', ['Accept' => 'application/vnd.openapi+json']); + $response->assertStatus(200); + + $parameters = array_column($response->json('paths')['/api/with_enum_class_parameters']['get']['parameters'], null, 'name'); + + $this->assertSame(['type' => 'string', 'enum' => ['open', 'closed']], $parameters['status']['schema']); + $this->assertSame(['type' => 'integer', 'enum' => [1, 2]], $parameters['priority']['schema']); + } +} diff --git a/src/Laravel/workbench/app/ApiResource/WithEnumClassParameter.php b/src/Laravel/workbench/app/ApiResource/WithEnumClassParameter.php new file mode 100644 index 00000000000..2364a447d6d --- /dev/null +++ b/src/Laravel/workbench/app/ApiResource/WithEnumClassParameter.php @@ -0,0 +1,40 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace Workbench\App\ApiResource; + +use ApiPlatform\Laravel\workbench\app\Enums\TicketPriority; +use ApiPlatform\Laravel\workbench\app\Enums\TicketStatus; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\QueryParameter; + +#[GetCollection( + uriTemplate: '/with_enum_class_parameters', + parameters: [ + 'status' => new QueryParameter(enumClass: TicketStatus::class), + 'priority' => new QueryParameter(enumClass: TicketPriority::class), + ], + provider: [self::class, 'provide'], +)] +class WithEnumClassParameter +{ + public int $id = 1; + + /** + * @return list + */ + public static function provide(): array + { + return []; + } +} diff --git a/src/Laravel/workbench/app/Enums/TicketPriority.php b/src/Laravel/workbench/app/Enums/TicketPriority.php new file mode 100644 index 00000000000..66fadfab809 --- /dev/null +++ b/src/Laravel/workbench/app/Enums/TicketPriority.php @@ -0,0 +1,20 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Laravel\workbench\app\Enums; + +enum TicketPriority: int +{ + case Low = 1; + case High = 2; +} diff --git a/src/Laravel/workbench/app/Enums/TicketStatus.php b/src/Laravel/workbench/app/Enums/TicketStatus.php new file mode 100644 index 00000000000..a703a096bb7 --- /dev/null +++ b/src/Laravel/workbench/app/Enums/TicketStatus.php @@ -0,0 +1,20 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Laravel\workbench\app\Enums; + +enum TicketStatus: string +{ + case Open = 'open'; + case Closed = 'closed'; +} diff --git a/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php b/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php index 9453d600981..b1288cb03f2 100644 --- a/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php +++ b/src/Metadata/Tests/Resource/Factory/ParameterResourceMetadataCollectionFactoryTest.php @@ -42,6 +42,7 @@ use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\WithLimitedPropertyParameter; use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\WithParameter; use ApiPlatform\Metadata\Tests\Fixtures\Enum\IntBackedPriority; +use ApiPlatform\Metadata\Tests\Fixtures\Enum\StringBackedStatus; use ApiPlatform\Metadata\Tests\Fixtures\Enum\UnitSuit; use ApiPlatform\OpenApi\Model\Parameter; use ApiPlatform\State\Parameter\ValueCaster; @@ -1384,6 +1385,49 @@ public function testEnumClassWinsOverFilterSchema(): void $this->assertSame([ValueCaster::class, 'toInt'], $priority->getCastFn()); } + #[DataProvider('provideEnumClassShapes')] + public function testEnumClassKeepsTheShapeAFilterTakes(QueryParameter $parameter, Type $expectedNativeType): void + { + $decorated = $this->createStub(ResourceMetadataCollectionFactoryInterface::class); + $decorated->method('create')->willReturn(new ResourceMetadataCollection(\stdClass::class, [ + new ApiResource(operations: [ + new GetCollection(name: 'collection', class: \stdClass::class, parameters: ['enum' => $parameter]), + ]), + ])); + + $resolved = $this->createEnumClassParameterFactory($decorated)->create(\stdClass::class)->getOperation('collection')->getParameters()->get('enum', QueryParameter::class); + + $this->assertEquals($expectedNativeType, $resolved->getNativeType()); + } + + public static function provideEnumClassShapes(): iterable + { + yield 'string backed enum with a filter takes a value or a list' => [ + new QueryParameter(filter: new NumberSchemaFilter(), enumClass: StringBackedStatus::class), + Type::union(Type::string(), Type::list(Type::string())), + ]; + yield 'int backed enum with a filter takes a value or a list' => [ + new QueryParameter(filter: new NumberSchemaFilter(), enumClass: IntBackedPriority::class), + Type::union(Type::int(), Type::list(Type::int())), + ]; + yield 'without a filter it is a single value' => [ + new QueryParameter(enumClass: IntBackedPriority::class), + Type::int(), + ]; + yield 'castToArray false narrows a filtered parameter to a single value' => [ + new QueryParameter(filter: new NumberSchemaFilter(), enumClass: StringBackedStatus::class, castToArray: false), + Type::string(), + ]; + yield 'a declared schema type decides the shape' => [ + new QueryParameter(filter: new NumberSchemaFilter(), enumClass: StringBackedStatus::class, schema: ['type' => 'string']), + Type::string(), + ]; + yield 'a declared native type is kept' => [ + new QueryParameter(filter: new NumberSchemaFilter(), enumClass: StringBackedStatus::class, nativeType: Type::list(Type::string())), + Type::list(Type::string()), + ]; + } + public static function provideInvalidEnumClasses(): iterable { yield 'non-backed enum' => [UnitSuit::class]; diff --git a/src/Validator/Tests/Util/ParameterValidationConstraintsTest.php b/src/Validator/Tests/Util/ParameterValidationConstraintsTest.php index d48bb55ad2c..593f4a71a62 100644 --- a/src/Validator/Tests/Util/ParameterValidationConstraintsTest.php +++ b/src/Validator/Tests/Util/ParameterValidationConstraintsTest.php @@ -17,12 +17,14 @@ use ApiPlatform\Validator\Util\ParameterValidationConstraints; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\TestCase; +use Symfony\Component\TypeInfo\Type; use Symfony\Component\Validator\Constraint; use Symfony\Component\Validator\Constraints\GreaterThan; use Symfony\Component\Validator\Constraints\GreaterThanOrEqual; use Symfony\Component\Validator\Constraints\LessThan; use Symfony\Component\Validator\Constraints\LessThanOrEqual; use Symfony\Component\Validator\Constraints\Range; +use Symfony\Component\Validator\Validation; final class ParameterValidationConstraintsTest extends TestCase { @@ -36,6 +38,36 @@ public function testZeroBounds(array $schema, Constraint $expected): void $this->assertContainsEquals($expected, $validation::getParameterValidationConstraints(new QueryParameter(schema: $schema))); } + /** + * The scalar type of a parameter taking a value or a list of values is checked on each value, not on the list. + */ + #[DataProvider('provideTypedValues')] + public function testScalarTypeAppliesToEachValueOfAList(mixed $value, int $expectedViolations): void + { + $validation = new class { + use ParameterValidationConstraints; + }; + + $parameter = new QueryParameter( + schema: ['type' => 'integer', 'enum' => [1, 2, 3]], + nativeType: Type::union(Type::int(), Type::list(Type::int())), + castToNativeType: true, + ); + + $violations = Validation::createValidator()->validate($value, $validation::getParameterValidationConstraints($parameter)); + + $this->assertCount($expectedViolations, $violations, (string) $violations); + } + + public static function provideTypedValues(): iterable + { + yield 'single value' => [1, 0]; + yield 'list of values' => [[1, 3], 0]; + yield 'single value outside the enum' => [4, 1]; + yield 'list with a value outside the enum' => [[1, 4], 1]; + yield 'list with a value of another type' => [[1, 'foo'], 1]; + } + public static function provideZeroBounds(): iterable { yield 'minimum and maximum' => [['type' => 'integer', 'minimum' => 0, 'maximum' => 100], new Range(min: 0, max: 100)]; diff --git a/tests/Fixtures/TestBundle/Document/Issue8816/EnumFilteredActivity.php b/tests/Fixtures/TestBundle/Document/Issue8816/EnumFilteredActivity.php new file mode 100644 index 00000000000..e3dc5dad6e5 --- /dev/null +++ b/tests/Fixtures/TestBundle/Document/Issue8816/EnumFilteredActivity.php @@ -0,0 +1,80 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Fixtures\TestBundle\Document\Issue8816; + +use ApiPlatform\Doctrine\Odm\Filter\ExactFilter; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\GraphQl\Query; +use ApiPlatform\Metadata\GraphQl\QueryCollection; +use ApiPlatform\Metadata\QueryParameter; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityLevel; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityType; +use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM; + +#[ApiResource( + operations: [ + new Get(uriTemplate: 'enum_filtered_activities/{id}{._format}'), + new GetCollection( + uriTemplate: 'enum_filtered_activities{._format}', + parameters: [ + 'type' => new QueryParameter(filter: new ExactFilter(), property: 'type', enumClass: ActivityType::class), + 'level' => new QueryParameter(filter: new ExactFilter(), property: 'level', enumClass: ActivityLevel::class), + ], + ), + ], + graphQlOperations: [ + new Query(), + new QueryCollection( + parameters: [ + 'type' => new QueryParameter(filter: new ExactFilter(), property: 'type', enumClass: ActivityType::class), + 'level' => new QueryParameter(filter: new ExactFilter(), property: 'level', enumClass: ActivityLevel::class), + ], + ), + ], +)] +#[ODM\Document] +class EnumFilteredActivity +{ + #[ODM\Id(type: 'int', strategy: 'INCREMENT')] + private ?int $id = null; + + #[ODM\Field(type: 'string', enumType: ActivityType::class)] + private ActivityType $type; + + #[ODM\Field(type: 'int', enumType: ActivityLevel::class)] + private ActivityLevel $level; + + public function __construct(ActivityType $type = ActivityType::Meeting, ActivityLevel $level = ActivityLevel::Beginner) + { + $this->type = $type; + $this->level = $level; + } + + public function getId(): ?int + { + return $this->id; + } + + public function getType(): ActivityType + { + return $this->type; + } + + public function getLevel(): ActivityLevel + { + return $this->level; + } +} diff --git a/tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php b/tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php index 6b5249ff53b..ce5dffa08cf 100644 --- a/tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php +++ b/tests/Fixtures/TestBundle/Entity/Issue8816/EnumFilteredActivity.php @@ -14,15 +14,33 @@ namespace ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816; use ApiPlatform\Doctrine\Orm\Filter\ExactFilter; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\GraphQl\Query; +use ApiPlatform\Metadata\GraphQl\QueryCollection; use ApiPlatform\Metadata\QueryParameter; use Doctrine\ORM\Mapping as ORM; -#[GetCollection( - uriTemplate: 'enum_filtered_activities{._format}', - parameters: [ - 'type' => new QueryParameter(filter: new ExactFilter(), property: 'type', enumClass: ActivityType::class), - 'level' => new QueryParameter(filter: new ExactFilter(), property: 'level', enumClass: ActivityLevel::class), +#[ApiResource( + operations: [ + new Get(uriTemplate: 'enum_filtered_activities/{id}{._format}'), + new GetCollection( + uriTemplate: 'enum_filtered_activities{._format}', + parameters: [ + 'type' => new QueryParameter(filter: new ExactFilter(), property: 'type', enumClass: ActivityType::class), + 'level' => new QueryParameter(filter: new ExactFilter(), property: 'level', enumClass: ActivityLevel::class), + ], + ), + ], + graphQlOperations: [ + new Query(), + new QueryCollection( + parameters: [ + 'type' => new QueryParameter(filter: new ExactFilter(), property: 'type', enumClass: ActivityType::class), + 'level' => new QueryParameter(filter: new ExactFilter(), property: 'level', enumClass: ActivityLevel::class), + ], + ), ], )] #[ORM\Entity] diff --git a/tests/Functional/GraphQl/EnumClassParameterTest.php b/tests/Functional/GraphQl/EnumClassParameterTest.php new file mode 100644 index 00000000000..3d96cfcd1a3 --- /dev/null +++ b/tests/Functional/GraphQl/EnumClassParameterTest.php @@ -0,0 +1,95 @@ + + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace ApiPlatform\Tests\Functional\GraphQl; + +use ApiPlatform\GraphQl\Test\GraphQlTestTrait; +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\Document\Issue8816\EnumFilteredActivity as DocumentEnumFilteredActivity; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityLevel; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityType; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\EnumFilteredActivity; +use ApiPlatform\Tests\RecreateSchemaTrait; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use PHPUnit\Framework\Attributes\DataProvider; + +/** + * An "enumClass" parameter exposed as a GraphQL collection argument. + */ +final class EnumClassParameterTest extends ApiTestCase +{ + use GraphQlTestTrait; + use RecreateSchemaTrait; + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [EnumFilteredActivity::class]; + } + + protected function setUp(): void + { + $this->recreateSchema(self::getResources()); + + $class = $this->isMongoDB() ? DocumentEnumFilteredActivity::class : EnumFilteredActivity::class; + $manager = $this->getManager(); + $manager->persist(new $class(ActivityType::Meeting, ActivityLevel::Beginner)); + $manager->persist(new $class(ActivityType::Workshop, ActivityLevel::Advanced)); + $manager->persist(new $class(ActivityType::Webinar, ActivityLevel::Expert)); + $manager->flush(); + } + + public function testArgumentsUseTheScalarTypeOfTheEnum(): void + { + $response = $this->executeGraphQl(<<<'QUERY' + { + __type(name: "Query") { + fields { name args { name type { kind name ofType { name } } } } + } + } + QUERY); + + $json = $response->toArray(false); + $this->assertArrayNotHasKey('errors', $json, json_encode($json['errors'] ?? null)); + + $fields = array_column($json['data']['__type']['fields'], null, 'name'); + $args = array_column($fields['enumFilteredActivities']['args'], null, 'name'); + + $this->assertSame(['kind' => 'SCALAR', 'name' => 'String', 'ofType' => null], $args['type']['type']); + $this->assertSame(['kind' => 'SCALAR', 'name' => 'Int', 'ofType' => null], $args['level']['type']); + } + + /** + * @param list $expectedIds + */ + #[DataProvider('provideValidArguments')] + public function testFiltersOnEnumValues(string $arguments, array $expectedIds): void + { + $response = $this->executeGraphQl(\sprintf('{ enumFilteredActivities(%s) { edges { node { id } } } }', $arguments)); + + $json = $response->toArray(false); + $this->assertArrayNotHasKey('errors', $json, json_encode($json['errors'] ?? null)); + $this->assertSame($expectedIds, array_column(array_column($json['data']['enumFilteredActivities']['edges'], 'node'), 'id')); + } + + public static function provideValidArguments(): \Generator + { + yield 'string backed enum' => ['type: "workshop"', ['/enum_filtered_activities/2']]; + yield 'int backed enum' => ['level: 3', ['/enum_filtered_activities/3']]; + } +} diff --git a/tests/Functional/Parameters/EnumClassExactFilterTest.php b/tests/Functional/Parameters/EnumClassExactFilterTest.php index 0062e46a85e..49a2a111f38 100644 --- a/tests/Functional/Parameters/EnumClassExactFilterTest.php +++ b/tests/Functional/Parameters/EnumClassExactFilterTest.php @@ -14,6 +14,7 @@ namespace ApiPlatform\Tests\Functional\Parameters; use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\Document\Issue8816\EnumFilteredActivity as DocumentEnumFilteredActivity; use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityLevel; use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\ActivityType; use ApiPlatform\Tests\Fixtures\TestBundle\Entity\Issue8816\EnumFilteredActivity; @@ -43,16 +44,13 @@ public static function getResources(): array protected function setUp(): void { - if ($this->isMongoDB()) { - $this->markTestSkipped('The fixture uses the Doctrine ORM ExactFilter.'); - } - $this->recreateSchema(self::getResources()); - $manager = static::getContainer()->get('doctrine')->getManager(); - $manager->persist(new EnumFilteredActivity(ActivityType::Meeting, ActivityLevel::Beginner)); - $manager->persist(new EnumFilteredActivity(ActivityType::Workshop, ActivityLevel::Advanced)); - $manager->persist(new EnumFilteredActivity(ActivityType::Webinar, ActivityLevel::Expert)); + $class = $this->isMongoDB() ? DocumentEnumFilteredActivity::class : EnumFilteredActivity::class; + $manager = $this->getManager(); + $manager->persist(new $class(ActivityType::Meeting, ActivityLevel::Beginner)); + $manager->persist(new $class(ActivityType::Workshop, ActivityLevel::Advanced)); + $manager->persist(new $class(ActivityType::Webinar, ActivityLevel::Expert)); $manager->flush(); }