From 46cfbebcfbe4bd6b628ba9d92db84863b8b6bebc Mon Sep 17 00:00:00 2001 From: Dylan van der Hout Date: Thu, 1 Oct 2026 14:37:13 +0200 Subject: [PATCH 1/4] feat(serializer): support resource polymorphism through DiscriminatorMap --- src/JsonApi/JsonSchema/SchemaFactory.php | 84 ++- .../Tests/JsonSchema/SchemaFactoryTest.php | 3 + src/JsonSchema/SchemaFactory.php | 130 ++++- .../Discriminator/DiscriminatedAnimal.php | 22 + .../Discriminator/DiscriminatedCat.php | 19 + .../Discriminator/DiscriminatedDog.php | 19 + .../Discriminator/DiscriminatedGadget.php | 22 + .../Discriminator/DiscriminatedPhone.php | 19 + src/JsonSchema/Tests/SchemaFactoryTest.php | 104 ++++ src/Laravel/ApiPlatformProvider.php | 8 + .../Tests/Fixtures/Discriminator/Car.php | 24 + .../Fixtures/Discriminator/Hatchback.php | 21 + .../Fixtures/Discriminator/SportsCar.php | 18 + .../Tests/Fixtures/Discriminator/Truck.php | 18 + .../Tests/Fixtures/Discriminator/Vehicle.php | 21 + .../Util/ClassDiscriminatorHelperTest.php | 84 +++ .../Util/ClassDiscriminatorHelper.php | 132 +++++ src/Serializer/AbstractItemNormalizer.php | 111 +++- .../Bundle/Resources/config/json_schema.php | 1 + .../Bundle/Resources/config/jsonapi.php | 1 + .../DiscriminatedBook.php | 81 +++ .../DiscriminatedBookStore.php | 22 + .../DiscriminatedCar.php | 29 + .../DiscriminatedFictionBook.php | 26 + .../DiscriminatedGadget.php | 70 +++ .../DiscriminatedGadgetStore.php | 22 + .../DiscriminatedPersianCat.php | 19 + .../DiscriminatedPet.php | 71 +++ .../DiscriminatedPetCat.php | 25 + .../DiscriminatedPetDog.php | 19 + .../DiscriminatedPetStore.php | 22 + .../DiscriminatedPhone.php | 19 + .../DiscriminatedSiameseCat.php | 19 + .../DiscriminatedSignedFictionBook.php | 22 + .../DiscriminatedSportsCar.php | 27 + .../DiscriminatedTechnicalBook.php | 24 + .../DiscriminatedTruck.php | 49 ++ .../DiscriminatedVehicle.php | 101 ++++ .../DiscriminatedVehicleStore.php | 20 + .../UndiscriminatedBook.php | 43 ++ .../UndiscriminatedSecretBook.php | 19 + .../DiscriminatedNestedResourceTest.php | 231 ++++++++ .../DiscriminatedResourceOverrideTest.php | 279 ++++++++++ .../Functional/DiscriminatedResourceTest.php | 497 ++++++++++++++++++ .../DiscriminatedSelfMappedResourceTest.php | 193 +++++++ 45 files changed, 2794 insertions(+), 16 deletions(-) create mode 100644 src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedAnimal.php create mode 100644 src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedCat.php create mode 100644 src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedDog.php create mode 100644 src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedGadget.php create mode 100644 src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedPhone.php create mode 100644 src/Metadata/Tests/Fixtures/Discriminator/Car.php create mode 100644 src/Metadata/Tests/Fixtures/Discriminator/Hatchback.php create mode 100644 src/Metadata/Tests/Fixtures/Discriminator/SportsCar.php create mode 100644 src/Metadata/Tests/Fixtures/Discriminator/Truck.php create mode 100644 src/Metadata/Tests/Fixtures/Discriminator/Vehicle.php create mode 100644 src/Metadata/Tests/Util/ClassDiscriminatorHelperTest.php create mode 100644 src/Metadata/Util/ClassDiscriminatorHelper.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedCar.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetCat.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSiameseCat.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSportsCar.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicleStore.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php create mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php create mode 100644 tests/Functional/DiscriminatedNestedResourceTest.php create mode 100644 tests/Functional/DiscriminatedResourceOverrideTest.php create mode 100644 tests/Functional/DiscriminatedResourceTest.php create mode 100644 tests/Functional/DiscriminatedSelfMappedResourceTest.php diff --git a/src/JsonApi/JsonSchema/SchemaFactory.php b/src/JsonApi/JsonSchema/SchemaFactory.php index 717a5b39723..f13711510c8 100644 --- a/src/JsonApi/JsonSchema/SchemaFactory.php +++ b/src/JsonApi/JsonSchema/SchemaFactory.php @@ -27,7 +27,9 @@ use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface; use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface; use ApiPlatform\Metadata\ResourceClassResolverInterface; +use ApiPlatform\Metadata\Util\ClassDiscriminatorHelper; use ApiPlatform\State\ApiResource\Error; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; /** * Decorator factory which adds JSON:API properties to the JSON Schema document. @@ -81,7 +83,7 @@ final class SchemaFactory implements SchemaFactoryInterface, SchemaFactoryAwareI private readonly ResourceLinkageResolver $resourceLinkageResolver; - public function __construct(private readonly SchemaFactoryInterface $schemaFactory, private readonly PropertyMetadataFactoryInterface $propertyMetadataFactory, ResourceClassResolverInterface $resourceClassResolver, ?ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory = null, private ?DefinitionNameFactoryInterface $definitionNameFactory = null, ?ResourceLinkageResolver $resourceLinkageResolver = null, private readonly bool $strictMemberNames = false) + public function __construct(private readonly SchemaFactoryInterface $schemaFactory, private readonly PropertyMetadataFactoryInterface $propertyMetadataFactory, ResourceClassResolverInterface $resourceClassResolver, ?ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory = null, private ?DefinitionNameFactoryInterface $definitionNameFactory = null, ?ResourceLinkageResolver $resourceLinkageResolver = null, private readonly bool $strictMemberNames = false, private readonly ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null) { if (!$definitionNameFactory) { $this->definitionNameFactory = new DefinitionNameFactory(); @@ -383,18 +385,92 @@ private function buildDefinitionPropertiesSchema(string $key, string $documentDe // Only relax the requirement on the input schema; responses still always carry an `id`. $required = Schema::TYPE_INPUT === $type && $resourceOperation instanceof HttpOperation && 'POST' === $resourceOperation->getMethod() ? ['type'] : ['type', 'id']; - $resourceDefinitionName = $documentDefinitionName.'.resource'; - $definitions[$resourceDefinitionName] = [ + $data = [ 'type' => 'object', 'properties' => $replacement, 'required' => $required, ]; + // Subtypes declared in a serializer discriminator map: the type property lives in "attributes" so an OpenAPI discriminator cannot be used + $typeProperty = null; + foreach ($this->getDiscriminatedSubtypes($key, $propertyClass, $definitions, $schema->getVersion()) as [$subKey, $subClass, $typeProperty]) { + $subDocumentDefinitionName = $documentDefinitionName.'.'.(new \ReflectionClass($subClass))->getShortName(); + $subSchema = $this->buildDefinitionPropertiesSchema($subKey, $subDocumentDefinitionName, $subClass, $format, $type, $resourceOperation, $schema, $serializerContext); + if (\in_array($typeProperty, $definitions[$subKey]['required'] ?? [], true)) { + $definitions[$subDocumentDefinitionName.'.resource']['properties']['attributes']['required'] = [ReservedAttributeNameConverter::getReservedAttributes($this->strictMemberNames)[$typeProperty] ?? $typeProperty]; + } + $data['oneOf'][] = $subSchema['data']; + + foreach ($subSchema['included']['items']['anyOf'] ?? [] as $relatedDefinition) { + $relatedDefinitions[$relatedDefinition['$ref']] = $relatedDefinition; + } + } + + // The inline "oneOf" branch of a class declared in its own discriminator map describes the instances of the class itself + foreach (null !== $typeProperty ? $definitions[$key]['oneOf'] : [] as $branch) { + if (isset($branch['$ref']) || !isset($branch['properties'][$typeProperty])) { + continue; + } + + $attributeName = ReservedAttributeNameConverter::getReservedAttributes($this->strictMemberNames)[$typeProperty] ?? $typeProperty; + $ownData = $data; + unset($ownData['oneOf']); + $ownData['properties']['attributes']['properties'][$attributeName] = $branch['properties'][$typeProperty]; + if (\in_array($typeProperty, $branch['required'] ?? [], true)) { + $ownData['properties']['attributes']['required'] = [$attributeName]; + } + array_unshift($data['oneOf'], $ownData); + } + + if ($relatedDefinitions && !$included) { + $included = [ + 'included' => [ + 'description' => 'Related resources requested via the "include" query parameter.', + 'type' => 'array', + 'items' => [], + 'readOnly' => true, + 'externalDocs' => [ + 'url' => 'https://jsonapi.org/format/#fetching-includes', + ], + ], + ]; + } + + if ($included) { + $included['included']['items'] = ['anyOf' => array_values($relatedDefinitions)]; + } + + $resourceDefinitionName = $documentDefinitionName.'.resource'; + $definitions[$resourceDefinitionName] = $data; + return [ 'data' => ['$ref' => $this->getSchemaUriPrefix($schema->getVersion()).$resourceDefinitionName], ] + $included; } + /** + * @return iterable + */ + private function getDiscriminatedSubtypes(string $key, string $className, \ArrayObject $definitions, string $version): iterable + { + $discriminator = $definitions[$key]['discriminator'] ?? null; + if (null === $this->classDiscriminatorResolver || !isset($definitions[$key]['oneOf'], $discriminator['mapping']) || null === $mapping = $this->classDiscriminatorResolver->getMappingForClass($className)) { + return; + } + + $prefix = $this->getSchemaUriPrefix($version); + foreach (ClassDiscriminatorHelper::getDirectSubtypes($mapping, $className) as $typeValue => $subClass) { + if (null === $ref = $discriminator['mapping'][$typeValue] ?? null) { + continue; + } + + $subKey = substr($ref, \strlen($prefix)); + if (isset($definitions[$subKey])) { + yield [$subKey, $subClass, $mapping->getTypeProperty()]; + } + } + } + private function getRelationship(string $resourceClass, string $property, ?array $serializerContext): ?array { $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $property, $serializerContext ?? []); @@ -409,6 +485,8 @@ private function getRelationship(string $resourceClass, string $property, ?array $relatedClasses = []; foreach ($relationships as [$className, $isCollection]) { $isOne = $isOne || !$isCollection; + // A relation narrowed to a subtype of a resource (e.g. declared in a discriminator map) targets the resource itself + $className = $this->resourceClassResolver->getResourceClass(null, $className); $relatedClasses[$className] = $className; } diff --git a/src/JsonApi/Tests/JsonSchema/SchemaFactoryTest.php b/src/JsonApi/Tests/JsonSchema/SchemaFactoryTest.php index 64f46013138..fbc01c69b3f 100644 --- a/src/JsonApi/Tests/JsonSchema/SchemaFactoryTest.php +++ b/src/JsonApi/Tests/JsonSchema/SchemaFactoryTest.php @@ -80,6 +80,7 @@ protected function setUp(): void ); $resourceClassResolver = $this->prophesize(ResourceClassResolverInterface::class); + $resourceClassResolver->getResourceClass(null, Argument::type('string'))->willReturnArgument(1); $resourceClassResolver->isResourceClass(Dummy::class)->willReturn(true); $resourceClassResolver->isResourceClass(Error::class)->willReturn(true); @@ -368,6 +369,7 @@ private function buildSchemaFactoryWithPolymorphicRelation(?Operation $relatedOp ); $resourceClassResolver = $this->prophesize(ResourceClassResolverInterface::class); + $resourceClassResolver->getResourceClass(null, Argument::type('string'))->willReturnArgument(1); $resourceClassResolver->isResourceClass(Dummy::class)->willReturn(true); $resourceClassResolver->isResourceClass(RelatedDummy::class)->willReturn(true); $resourceClassResolver->isResourceClass(OtherRelatedDummy::class)->willReturn(true); @@ -430,6 +432,7 @@ private function buildSchemaFactoryWithRelation(?Operation $relatedOperation = n ); $resourceClassResolver = $this->prophesize(ResourceClassResolverInterface::class); + $resourceClassResolver->getResourceClass(null, Argument::type('string'))->willReturnArgument(1); $resourceClassResolver->isResourceClass(Dummy::class)->willReturn(true); $resourceClassResolver->isResourceClass(RelatedDummy::class)->willReturn(true); diff --git a/src/JsonSchema/SchemaFactory.php b/src/JsonSchema/SchemaFactory.php index 6593e985870..596a81d59f6 100644 --- a/src/JsonSchema/SchemaFactory.php +++ b/src/JsonSchema/SchemaFactory.php @@ -22,7 +22,9 @@ use ApiPlatform\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface; use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface; use ApiPlatform\Metadata\ResourceClassResolverInterface; +use ApiPlatform\Metadata\Util\ClassDiscriminatorHelper; use ApiPlatform\Metadata\Util\TypeHelper; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; use Symfony\Component\Serializer\NameConverter\NameConverterInterface; use Symfony\Component\Serializer\Normalizer\AbstractNormalizer; use Symfony\Component\TypeInfo\Type\BuiltinType; @@ -49,7 +51,7 @@ final class SchemaFactory implements SchemaFactoryInterface, SchemaFactoryAwareI public const OPENAPI_DEFINITION_NAME = 'openapi_definition_name'; public const PARTIAL_UPDATE = 'partial_update'; - public function __construct(ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory, private readonly PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, private readonly PropertyMetadataFactoryInterface $propertyMetadataFactory, private readonly ?NameConverterInterface $nameConverter = null, ?ResourceClassResolverInterface $resourceClassResolver = null, private ?DefinitionNameFactoryInterface $definitionNameFactory = null) + public function __construct(ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory, private readonly PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, private readonly PropertyMetadataFactoryInterface $propertyMetadataFactory, private readonly ?NameConverterInterface $nameConverter = null, ?ResourceClassResolverInterface $resourceClassResolver = null, private ?DefinitionNameFactoryInterface $definitionNameFactory = null, private readonly ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null) { if (!$definitionNameFactory) { $this->definitionNameFactory = new DefinitionNameFactory(); @@ -155,22 +157,140 @@ public function buildSchema(string $className, string $format = 'json', string $ } $options = ['schema_type' => $type] + $this->getFactoryOptions($serializerContext, $validationGroups); - foreach ($this->propertyNameCollectionFactory->create($inputOrOutputClass, $options) as $propertyName) { - $propertyMetadata = $this->propertyMetadataFactory->create($inputOrOutputClass, $propertyName, $options); + $this->buildDefinitionProperties($schema, $definition, $definitionName, $inputOrOutputClass, $options, $serializerContext, $format, $type, $isPartialUpdate); + + // Subtypes explicitly declared in a serializer discriminator map are documented using "oneOf" and an OpenAPI "discriminator" + $this->buildDiscriminatedDefinitions($schema, $definition, $className, $inputOrOutputClass, $definitionFormat, $operation, $options, $serializerContext, $serializerContext + [ + 'schema_type' => $type, + self::PARTIAL_UPDATE => $isPartialUpdate && !$isJsonMergePatch, + ], $format, $type, $isPartialUpdate); + + return $schema; + } + + /** + * @param \ArrayObject $definition + */ + private function buildDefinitionProperties(Schema $schema, \ArrayObject $definition, string $definitionName, string $class, array $options, array $serializerContext, string $format, string $type, bool $isPartialUpdate): void + { + foreach ($this->propertyNameCollectionFactory->create($class, $options) as $propertyName) { + $propertyMetadata = $this->propertyMetadataFactory->create($class, $propertyName, $options); if (false === $propertyMetadata->isReadable() && false === $propertyMetadata->isWritable()) { continue; } - $normalizedPropertyName = $this->nameConverter ? $this->nameConverter->normalize($propertyName, $inputOrOutputClass, $format, $serializerContext) : $propertyName; + $normalizedPropertyName = $this->nameConverter ? $this->nameConverter->normalize($propertyName, $class, $format, $serializerContext) : $propertyName; if ($propertyMetadata->isRequired() && !$isPartialUpdate) { $definition['required'][] = $normalizedPropertyName; } $this->buildPropertySchema($schema, $definitionName, $normalizedPropertyName, $propertyMetadata, $serializerContext, $format, $type); } + } - return $schema; + /** + * @param \ArrayObject $definition + * @param array> $parentTypeProperties type properties of the outer discriminator maps the class belongs to + */ + private function buildDiscriminatedDefinitions(Schema $schema, \ArrayObject $definition, string $className, string $class, string $definitionFormat, ?Operation $operation, array $options, array $serializerContext, array $definitionNameContext, string $format, string $type, bool $isPartialUpdate, array $parentTypeProperties = []): void + { + if (null === $this->classDiscriminatorResolver || null === $mapping = $this->classDiscriminatorResolver->getMappingForClass($class)) { + return; + } + + $typeProperty = $mapping->getTypeProperty(); + $definitions = $schema->getDefinitions(); + $prefix = $this->getSchemaUriPrefix($schema->getVersion()); + $discriminatorMapping = []; + $oneOf = []; + + foreach (ClassDiscriminatorHelper::getDirectSubtypes($mapping, $class) as $typeValue => $subClass) { + $subDefinitionName = $this->definitionNameFactory->create($className, $definitionFormat, $subClass, $operation, $definitionNameContext); + $discriminatorMapping[$typeValue] = $oneOf[]['$ref'] = $prefix.$subDefinitionName; + + if (isset($definitions[$subDefinitionName])) { + continue; + } + + /** @var \ArrayObject $subDefinition */ + $subDefinition = new \ArrayObject(['type' => 'object']); + $definitions[$subDefinitionName] = $subDefinition; + if (isset($definition['additionalProperties'])) { + $subDefinition['additionalProperties'] = $definition['additionalProperties']; + } + + $this->buildDefinitionProperties($schema, $subDefinition, $subDefinitionName, $subClass, $options, $serializerContext, $format, $type, $isPartialUpdate); + + // The type properties of the outer maps are part of the payload of a nested subtype too + $typeProperties = $parentTypeProperties + [$typeProperty => ['type' => 'string', 'enum' => [(string) $typeValue]]]; + $this->addTypeProperties($subDefinition, $typeProperties, $isPartialUpdate); + + $this->buildDiscriminatedDefinitions($schema, $subDefinition, $className, $subClass, $definitionFormat, $operation, $options, $serializerContext, $definitionNameContext, $format, $type, $isPartialUpdate, $typeProperties); + } + + $ownTypeValues = ClassDiscriminatorHelper::getOwnTypes($mapping, $class); + foreach ($ownTypeValues as $typeValue) { + $discriminatorMapping[$typeValue] = $prefix.$this->definitionNameFactory->create($className, $definitionFormat, $class, $operation, $definitionNameContext); + } + + if (!$discriminatorMapping) { + return; + } + + if ($oneOf) { + // An instance of the class itself is described by its own branch: it carries its own type and none of the subtype properties + if ($ownTypeValues) { + $ownBranch = new \ArrayObject(['type' => 'object']); + foreach (['properties', 'required', 'additionalProperties'] as $keyword) { + if (isset($definition[$keyword])) { + $ownBranch[$keyword] = $definition[$keyword]; + } + } + + $this->addTypeProperties($ownBranch, [$typeProperty => ['type' => 'string', 'enum' => $ownTypeValues]], $isPartialUpdate || \in_array($mapping->getDefaultType(), $ownTypeValues, true)); + array_unshift($oneOf, $ownBranch->getArrayCopy()); + } + + $definition['oneOf'] = $oneOf; + + // "additionalProperties" ignores the properties declared in the "oneOf" branches, they are restricted by the branches instead + unset($definition['additionalProperties']); + } + + // An instance of the class itself carries its own type + if ($ownTypeValues && !isset($definition['properties'][$typeProperty])) { + if ($oneOf) { + $properties = $definition['properties'] ?? []; + $properties[$typeProperty] = ['type' => 'string', 'enum' => array_map('strval', array_keys($discriminatorMapping))]; + $definition['properties'] = $properties; + } else { + $this->addTypeProperties($definition, [$typeProperty => ['type' => 'string', 'enum' => $ownTypeValues]], $isPartialUpdate || \in_array($mapping->getDefaultType(), $ownTypeValues, true)); + } + } + + $definition['discriminator'] = ['propertyName' => $typeProperty, 'mapping' => $discriminatorMapping]; + } + + /** + * @param \ArrayObject $definition + * @param array> $typeProperties + */ + private function addTypeProperties(\ArrayObject $definition, array $typeProperties, bool $optional): void + { + $properties = $definition['properties'] ?? []; + $required = $definition['required'] ?? []; + foreach ($typeProperties as $name => $typePropertySchema) { + $properties[$name] = $typePropertySchema; + if (!$optional && !\in_array($name, $required, true)) { + $required[] = $name; + } + } + + $definition['properties'] = $properties; + if ($required) { + $definition['required'] = $required; + } } private function buildPropertySchema(Schema $schema, string $definitionName, string $normalizedPropertyName, ApiProperty $propertyMetadata, array $serializerContext, string $format, string $parentType): void diff --git a/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedAnimal.php b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedAnimal.php new file mode 100644 index 00000000000..783c723cef1 --- /dev/null +++ b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedAnimal.php @@ -0,0 +1,22 @@ + + * + * 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\JsonSchema\Tests\Fixtures\Discriminator; + +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +#[DiscriminatorMap(typeProperty: 'species', mapping: ['cat' => DiscriminatedCat::class, 'dog' => DiscriminatedDog::class])] +abstract class DiscriminatedAnimal +{ + public string $name = ''; +} diff --git a/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedCat.php b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedCat.php new file mode 100644 index 00000000000..ef4d9a91c41 --- /dev/null +++ b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedCat.php @@ -0,0 +1,19 @@ + + * + * 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\JsonSchema\Tests\Fixtures\Discriminator; + +final class DiscriminatedCat extends DiscriminatedAnimal +{ + public int $lives = 9; +} diff --git a/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedDog.php b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedDog.php new file mode 100644 index 00000000000..547421bf54b --- /dev/null +++ b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedDog.php @@ -0,0 +1,19 @@ + + * + * 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\JsonSchema\Tests\Fixtures\Discriminator; + +final class DiscriminatedDog extends DiscriminatedAnimal +{ + public bool $goodBoy = true; +} diff --git a/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedGadget.php b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedGadget.php new file mode 100644 index 00000000000..038e31cf59c --- /dev/null +++ b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedGadget.php @@ -0,0 +1,22 @@ + + * + * 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\JsonSchema\Tests\Fixtures\Discriminator; + +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +#[DiscriminatorMap(typeProperty: 'kind', mapping: ['gadget' => DiscriminatedGadget::class, 'phone' => DiscriminatedPhone::class])] +class DiscriminatedGadget +{ + public string $name = ''; +} diff --git a/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedPhone.php b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedPhone.php new file mode 100644 index 00000000000..e5325c6f9b6 --- /dev/null +++ b/src/JsonSchema/Tests/Fixtures/Discriminator/DiscriminatedPhone.php @@ -0,0 +1,19 @@ + + * + * 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\JsonSchema\Tests\Fixtures\Discriminator; + +final class DiscriminatedPhone extends DiscriminatedGadget +{ + public string $number = ''; +} diff --git a/src/JsonSchema/Tests/SchemaFactoryTest.php b/src/JsonSchema/Tests/SchemaFactoryTest.php index 56093795b2c..fd23c2f5d6a 100644 --- a/src/JsonSchema/Tests/SchemaFactoryTest.php +++ b/src/JsonSchema/Tests/SchemaFactoryTest.php @@ -19,6 +19,11 @@ use ApiPlatform\JsonSchema\Tests\Fixtures\ApiResource\ChildAttributeDummy; use ApiPlatform\JsonSchema\Tests\Fixtures\ApiResource\OverriddenOperationDummy; use ApiPlatform\JsonSchema\Tests\Fixtures\ApiResource\ParentAttributeDummy; +use ApiPlatform\JsonSchema\Tests\Fixtures\Discriminator\DiscriminatedAnimal; +use ApiPlatform\JsonSchema\Tests\Fixtures\Discriminator\DiscriminatedCat; +use ApiPlatform\JsonSchema\Tests\Fixtures\Discriminator\DiscriminatedDog; +use ApiPlatform\JsonSchema\Tests\Fixtures\Discriminator\DiscriminatedGadget; +use ApiPlatform\JsonSchema\Tests\Fixtures\Discriminator\DiscriminatedPhone; use ApiPlatform\JsonSchema\Tests\Fixtures\DummyResourceInterface; use ApiPlatform\JsonSchema\Tests\Fixtures\Enum\GenderTypeEnum; use ApiPlatform\JsonSchema\Tests\Fixtures\GenericChild; @@ -42,6 +47,9 @@ use PHPUnit\Framework\TestCase; use Prophecy\Argument; use Prophecy\PhpUnit\ProphecyTrait; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata; +use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory; +use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader; use Symfony\Component\Serializer\Normalizer\AbstractNormalizer; use Symfony\Component\TypeInfo\Type; @@ -484,6 +492,102 @@ public function testBuildSchemaForAssociativeArray(): void $this->assertSame('string', $definitions[$rootDefinitionKey]['properties']['bar']['additionalProperties']); } + public function testBuildSchemaDocumentsDiscriminatorMapSubtypes(): void + { + $schemaFactory = $this->createDiscriminatorSchemaFactory(); + $schema = $schemaFactory->buildSchema(DiscriminatedAnimal::class, 'json', Schema::TYPE_OUTPUT, null, new Schema(Schema::VERSION_OPENAPI)); + $definitions = $schema->getDefinitions(); + + $base = $definitions['DiscriminatedAnimal']; + $this->assertSame(['name'], array_keys($base['properties'])); + $this->assertSame([ + ['$ref' => '#/components/schemas/DiscriminatedAnimal.DiscriminatedCat'], + ['$ref' => '#/components/schemas/DiscriminatedAnimal.DiscriminatedDog'], + ], $base['oneOf']); + $this->assertSame([ + 'propertyName' => 'species', + 'mapping' => [ + 'cat' => '#/components/schemas/DiscriminatedAnimal.DiscriminatedCat', + 'dog' => '#/components/schemas/DiscriminatedAnimal.DiscriminatedDog', + ], + ], $base['discriminator']); + + $cat = $definitions['DiscriminatedAnimal.DiscriminatedCat']; + $this->assertSame(['lives', 'name', 'species'], array_keys($cat['properties'])); + $this->assertSame(['type' => 'string', 'enum' => ['cat']], $cat['properties']['species']); + $this->assertSame(['species'], $cat['required']); + $this->assertArrayNotHasKey('allOf', $cat); + + $dog = $definitions['DiscriminatedAnimal.DiscriminatedDog']; + $this->assertSame(['goodBoy', 'name', 'species'], array_keys($dog['properties'])); + $this->assertSame(['type' => 'string', 'enum' => ['dog']], $dog['properties']['species']); + } + + public function testBuildSchemaDocumentsClassDeclaredInItsOwnDiscriminatorMap(): void + { + $schemaFactory = $this->createDiscriminatorSchemaFactory(); + $schema = $schemaFactory->buildSchema(DiscriminatedGadget::class, 'json', Schema::TYPE_INPUT, null, new Schema(Schema::VERSION_OPENAPI), [AbstractNormalizer::ALLOW_EXTRA_ATTRIBUTES => false]); + $definitions = $schema->getDefinitions(); + $rootDefinitionKey = $schema->getRootDefinitionKey(); + + $base = $definitions[$rootDefinitionKey]; + $this->assertSame(['type' => 'string', 'enum' => ['phone', 'gadget']], $base['properties']['kind']); + $this->assertArrayNotHasKey('additionalProperties', $base); + $this->assertSame([ + 'type' => 'object', + 'properties' => [ + 'name' => ['type' => 'string'], + 'kind' => ['type' => 'string', 'enum' => ['gadget']], + ], + 'additionalProperties' => false, + 'required' => ['kind'], + ], json_decode(json_encode($base['oneOf'][0]), true)); + $this->assertSame(['$ref' => '#/components/schemas/'.$rootDefinitionKey.'.DiscriminatedPhone'], $base['oneOf'][1]); + $this->assertSame('#/components/schemas/'.$rootDefinitionKey, $base['discriminator']['mapping']['gadget']); + + $phone = $definitions[$rootDefinitionKey.'.DiscriminatedPhone']; + $this->assertSame(['type' => 'string', 'enum' => ['phone']], $phone['properties']['kind']); + $this->assertFalse($phone['additionalProperties']); + } + + public function testBuildSchemaWithoutClassDiscriminatorResolverIgnoresDiscriminatorMap(): void + { + $schemaFactory = $this->createDiscriminatorSchemaFactory(false); + $definitions = $schemaFactory->buildSchema(DiscriminatedAnimal::class)->getDefinitions(); + + $this->assertSame(['DiscriminatedAnimal'], array_keys($definitions->getArrayCopy())); + $this->assertArrayNotHasKey('oneOf', $definitions['DiscriminatedAnimal']); + $this->assertArrayNotHasKey('discriminator', $definitions['DiscriminatedAnimal']); + } + + private function createDiscriminatorSchemaFactory(bool $withClassDiscriminatorResolver = true): SchemaFactory + { + $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class); + $propertyNameCollectionFactoryProphecy->create(DiscriminatedAnimal::class, Argument::cetera())->willReturn(new PropertyNameCollection(['name'])); + $propertyNameCollectionFactoryProphecy->create(DiscriminatedCat::class, Argument::cetera())->willReturn(new PropertyNameCollection(['lives', 'name'])); + $propertyNameCollectionFactoryProphecy->create(DiscriminatedDog::class, Argument::cetera())->willReturn(new PropertyNameCollection(['goodBoy', 'name'])); + $propertyNameCollectionFactoryProphecy->create(DiscriminatedGadget::class, Argument::cetera())->willReturn(new PropertyNameCollection(['name'])); + $propertyNameCollectionFactoryProphecy->create(DiscriminatedPhone::class, Argument::cetera())->willReturn(new PropertyNameCollection(['name', 'number'])); + + $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class); + $propertyMetadataFactoryProphecy->create(Argument::any(), 'name', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::string())->withReadable(true)->withWritable(true)->withSchema(['type' => 'string'])); + $propertyMetadataFactoryProphecy->create(DiscriminatedCat::class, 'lives', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::int())->withReadable(true)->withWritable(true)->withSchema(['type' => 'integer'])); + $propertyMetadataFactoryProphecy->create(DiscriminatedPhone::class, 'number', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::string())->withReadable(true)->withWritable(true)->withSchema(['type' => 'string'])); + $propertyMetadataFactoryProphecy->create(DiscriminatedDog::class, 'goodBoy', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::bool())->withReadable(true)->withWritable(true)->withSchema(['type' => 'boolean'])); + + $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class); + $resourceClassResolverProphecy->isResourceClass(Argument::any())->willReturn(false); + + return new SchemaFactory( + resourceMetadataFactory: $this->prophesize(ResourceMetadataCollectionFactoryInterface::class)->reveal(), + propertyNameCollectionFactory: $propertyNameCollectionFactoryProphecy->reveal(), + propertyMetadataFactory: $propertyMetadataFactoryProphecy->reveal(), + resourceClassResolver: $resourceClassResolverProphecy->reveal(), + definitionNameFactory: new DefinitionNameFactory(), + classDiscriminatorResolver: $withClassDiscriminatorResolver ? new ClassDiscriminatorFromClassMetadata(new ClassMetadataFactory(new AttributeLoader())) : null, + ); + } + public function testPartialUpdateRequiredPropertiesUseDistinctDefinitions(): void { $resourceMetadataFactoryProphecy = $this->prophesize(ResourceMetadataCollectionFactoryInterface::class); diff --git a/src/Laravel/ApiPlatformProvider.php b/src/Laravel/ApiPlatformProvider.php index bf55f8c4ed0..c2e659f56fc 100644 --- a/src/Laravel/ApiPlatformProvider.php +++ b/src/Laravel/ApiPlatformProvider.php @@ -217,6 +217,8 @@ use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface; use Symfony\Component\Routing\RequestContext; use Symfony\Component\Serializer\Encoder\CsvEncoder; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory; use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface; use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader; @@ -312,6 +314,10 @@ public function register(): void ); }); + $this->app->singleton(ClassDiscriminatorResolverInterface::class, static function (Application $app) { + return new ClassDiscriminatorFromClassMetadata($app->make(ClassMetadataFactoryInterface::class)); + }); + $this->app->singleton(SerializerClassMetadataFactory::class, static function (Application $app) { return new SerializerClassMetadataFactory($app->make(ClassMetadataFactoryInterface::class)); }); @@ -970,6 +976,7 @@ public function register(): void $app->make(NameConverterInterface::class), $app->make(ResourceClassResolverInterface::class), $app->make(DefinitionNameFactoryInterface::class), + $app->make(ClassDiscriminatorResolverInterface::class), ); }); $this->app->singleton(JsonApiSchemaFactory::class, static function (Application $app) { @@ -980,6 +987,7 @@ public function register(): void $app->make(ResourceMetadataCollectionFactoryInterface::class), $app->make(DefinitionNameFactoryInterface::class), strictMemberNames: (bool) $app['config']->get('api-platform.jsonapi.strict_member_names', false), + classDiscriminatorResolver: $app->make(ClassDiscriminatorResolverInterface::class), ); }); $this->app->singleton(HydraSchemaFactory::class, static function (Application $app) { diff --git a/src/Metadata/Tests/Fixtures/Discriminator/Car.php b/src/Metadata/Tests/Fixtures/Discriminator/Car.php new file mode 100644 index 00000000000..c42265beb53 --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Discriminator/Car.php @@ -0,0 +1,24 @@ + + * + * 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\Discriminator; + +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +/** + * Concrete class declaring itself in its own map, which also (wrongly) lists an ancestor. + */ +#[DiscriminatorMap(typeProperty: 'body', mapping: ['car' => Car::class, 'sports' => SportsCar::class, 'vehicle' => Vehicle::class])] +class Car extends Vehicle +{ +} diff --git a/src/Metadata/Tests/Fixtures/Discriminator/Hatchback.php b/src/Metadata/Tests/Fixtures/Discriminator/Hatchback.php new file mode 100644 index 00000000000..c4a02cb5c79 --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Discriminator/Hatchback.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\Metadata\Tests\Fixtures\Discriminator; + +/** + * Not declared in any discriminator map. + */ +final class Hatchback extends Car +{ +} diff --git a/src/Metadata/Tests/Fixtures/Discriminator/SportsCar.php b/src/Metadata/Tests/Fixtures/Discriminator/SportsCar.php new file mode 100644 index 00000000000..db0fc4b4744 --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Discriminator/SportsCar.php @@ -0,0 +1,18 @@ + + * + * 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\Discriminator; + +final class SportsCar extends Car +{ +} diff --git a/src/Metadata/Tests/Fixtures/Discriminator/Truck.php b/src/Metadata/Tests/Fixtures/Discriminator/Truck.php new file mode 100644 index 00000000000..5cee8478ed1 --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Discriminator/Truck.php @@ -0,0 +1,18 @@ + + * + * 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\Discriminator; + +final class Truck extends Vehicle +{ +} diff --git a/src/Metadata/Tests/Fixtures/Discriminator/Vehicle.php b/src/Metadata/Tests/Fixtures/Discriminator/Vehicle.php new file mode 100644 index 00000000000..4e81d33eddf --- /dev/null +++ b/src/Metadata/Tests/Fixtures/Discriminator/Vehicle.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\Metadata\Tests\Fixtures\Discriminator; + +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +#[DiscriminatorMap(typeProperty: 'kind', mapping: ['car' => Car::class, 'truck' => Truck::class])] +abstract class Vehicle +{ +} diff --git a/src/Metadata/Tests/Util/ClassDiscriminatorHelperTest.php b/src/Metadata/Tests/Util/ClassDiscriminatorHelperTest.php new file mode 100644 index 00000000000..5fb18cfa262 --- /dev/null +++ b/src/Metadata/Tests/Util/ClassDiscriminatorHelperTest.php @@ -0,0 +1,84 @@ + + * + * 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\Util; + +use ApiPlatform\Metadata\Tests\Fixtures\Discriminator\Car; +use ApiPlatform\Metadata\Tests\Fixtures\Discriminator\Hatchback; +use ApiPlatform\Metadata\Tests\Fixtures\Discriminator\SportsCar; +use ApiPlatform\Metadata\Tests\Fixtures\Discriminator\Truck; +use ApiPlatform\Metadata\Tests\Fixtures\Discriminator\Vehicle; +use ApiPlatform\Metadata\Util\ClassDiscriminatorHelper; +use PHPUnit\Framework\TestCase; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; +use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory; +use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader; + +final class ClassDiscriminatorHelperTest extends TestCase +{ + private ClassDiscriminatorFromClassMetadata $resolver; + + protected function setUp(): void + { + $this->resolver = new ClassDiscriminatorFromClassMetadata(new ClassMetadataFactory(new AttributeLoader())); + } + + public function testGetDirectSubtypesOnlyReturnsStrictSubclasses(): void + { + $mapping = new ClassDiscriminatorMapping('body', ['car' => Car::class, 'sports' => SportsCar::class, 'vehicle' => Vehicle::class, 'truck' => Truck::class]); + + $this->assertSame(['sports' => SportsCar::class], ClassDiscriminatorHelper::getDirectSubtypes($mapping, Car::class)); + $this->assertSame(['car'], ClassDiscriminatorHelper::getOwnTypes($mapping, Car::class)); + } + + public function testGetSubtypesWalksNestedMaps(): void + { + $this->assertEqualsCanonicalizing([Car::class, SportsCar::class, Truck::class], ClassDiscriminatorHelper::getSubtypes($this->resolver, Vehicle::class)); + $this->assertSame([SportsCar::class], ClassDiscriminatorHelper::getSubtypes($this->resolver, Car::class)); + } + + public function testResolveTerminatesWhenANestedMapListsAnAncestor(): void + { + $resolved = ClassDiscriminatorHelper::resolve($this->resolver, Vehicle::class, Hatchback::class); + + $this->assertNotNull($resolved); + $this->assertSame(Car::class, $resolved['class']); + $this->assertSame(['kind', 'body'], $resolved['type_properties']); + } + + public function testResolveMostSpecificNestedSubtype(): void + { + $resolved = ClassDiscriminatorHelper::resolve($this->resolver, Vehicle::class, SportsCar::class); + + $this->assertNotNull($resolved); + $this->assertSame(SportsCar::class, $resolved['class']); + $this->assertSame(['kind', 'body'], $resolved['type_properties']); + } + + public function testResolveClassDeclaredInItsOwnMap(): void + { + $resolved = ClassDiscriminatorHelper::resolve($this->resolver, Car::class, Car::class); + + $this->assertNotNull($resolved); + $this->assertSame(Car::class, $resolved['class']); + $this->assertSame(['body'], $resolved['type_properties']); + } + + public function testResolveReturnsNullForAClassOutsideOfTheMaps(): void + { + $this->assertNull(ClassDiscriminatorHelper::resolve($this->resolver, Vehicle::class, Vehicle::class)); + $this->assertNull(ClassDiscriminatorHelper::resolve($this->resolver, Truck::class, Vehicle::class)); + $this->assertNull(ClassDiscriminatorHelper::resolve($this->resolver, \stdClass::class, \stdClass::class)); + } +} diff --git a/src/Metadata/Util/ClassDiscriminatorHelper.php b/src/Metadata/Util/ClassDiscriminatorHelper.php new file mode 100644 index 00000000000..b7eac611b8c --- /dev/null +++ b/src/Metadata/Util/ClassDiscriminatorHelper.php @@ -0,0 +1,132 @@ + + * + * 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\Util; + +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; + +/** + * Walks the (possibly nested) serializer discriminator maps of a class. + * + * Only strict subclasses declared in a map are considered as subtypes: walking down nested maps + * always descends the class hierarchy, which guarantees termination even with misconfigured maps. + * + * @internal + */ +final class ClassDiscriminatorHelper +{ + /** + * Returns the subtypes declared in the given map of a class, indexed by their type value. + * + * @return array + */ + public static function getDirectSubtypes(ClassDiscriminatorMapping $mapping, string $class): array + { + $subtypes = []; + foreach ($mapping->getTypesMapping() as $typeValue => $typeClass) { + if ($typeClass !== $class && is_a($typeClass, $class, true)) { + $subtypes[(string) $typeValue] = $typeClass; + } + } + + return $subtypes; + } + + /** + * Returns the type values the given map assigns to the class itself. + * + * @return list + */ + public static function getOwnTypes(ClassDiscriminatorMapping $mapping, string $class): array + { + $types = []; + foreach ($mapping->getTypesMapping() as $typeValue => $typeClass) { + if ($typeClass === $class) { + $types[] = (string) $typeValue; + } + } + + return $types; + } + + /** + * Lists the subtypes declared, possibly through nested maps, in the discriminator map of a class. + * + * @return list + */ + public static function getSubtypes(ClassDiscriminatorResolverInterface $resolver, string $class): array + { + if (null === $mapping = $resolver->getMappingForClass($class)) { + return []; + } + + $subtypes = []; + foreach (self::getDirectSubtypes($mapping, $class) as $subtype) { + $subtypes[] = $subtype; + foreach (self::getSubtypes($resolver, $subtype) as $nestedSubtype) { + $subtypes[] = $nestedSubtype; + } + } + + return array_values(array_unique($subtypes)); + } + + /** + * Resolves the most specific class declared in the discriminator maps of a resource for the given class. + * + * Classes that are not part of a discriminator map resolve to their closest mapped parent. + * A class declaring itself in its own map carries the type property of that map too. + * + * @param class-string $resourceClass + * @param class-string $class + * + * @return array{class: class-string, type_properties: list, mappings: list}|null + */ + public static function resolve(ClassDiscriminatorResolverInterface $resolver, string $resourceClass, string $class): ?array + { + if (!is_a($class, $resourceClass, true)) { + return null; + } + + $mappedClass = $resourceClass; + $typeProperties = []; + $mappings = []; + while (null !== $mapping = $resolver->getMappingForClass($mappedClass)) { + $candidate = null; + foreach (self::getDirectSubtypes($mapping, $mappedClass) as $typeClass) { + if (is_a($class, $typeClass, true) && (null === $candidate || is_a($typeClass, $candidate, true))) { + $candidate = $typeClass; + } + } + + if (null === $candidate && !self::getOwnTypes($mapping, $mappedClass)) { + break; + } + + $typeProperties[] = $mapping->getTypeProperty(); + $mappings[] = $mapping; + if (null === $candidate) { + break; + } + + $mappedClass = $candidate; + } + + if (!$mappings) { + return null; + } + + return ['class' => $mappedClass, 'type_properties' => array_values(array_unique($typeProperties)), 'mappings' => $mappings]; + } +} diff --git a/src/Serializer/AbstractItemNormalizer.php b/src/Serializer/AbstractItemNormalizer.php index c08a967ad45..e2c658dfbce 100644 --- a/src/Serializer/AbstractItemNormalizer.php +++ b/src/Serializer/AbstractItemNormalizer.php @@ -26,6 +26,7 @@ use ApiPlatform\Metadata\ResourceAccessCheckerInterface; use ApiPlatform\Metadata\ResourceClassResolverInterface; use ApiPlatform\Metadata\UrlGeneratorInterface; +use ApiPlatform\Metadata\Util\ClassDiscriminatorHelper; use ApiPlatform\Metadata\Util\ClassInfoTrait; use ApiPlatform\Metadata\Util\CloneTrait; use Symfony\Component\PropertyAccess\Exception\InvalidArgumentException as PropertyAccessInvalidArgumentException; @@ -41,6 +42,7 @@ use Symfony\Component\Serializer\Exception\NotNormalizableValueException; use Symfony\Component\Serializer\Exception\RuntimeException; use Symfony\Component\Serializer\Exception\UnexpectedValueException; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface; use Symfony\Component\Serializer\NameConverter\NameConverterInterface; use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer; @@ -269,7 +271,12 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a // An IRI references an existing resource, its type is resolved when it is retrieved if (null === ($objectToPopulate = $this->extractObjectToPopulate($resourceClass, $context, static::OBJECT_TO_POPULATE)) && !\is_string($data)) { $normalizedData = \is_scalar($data) ? [$data] : $this->prepareForDenormalization($data); - $type = $this->getClassDiscriminatorResolvedClass($normalizedData, $type, $context); + // Nested discriminator maps are resolved down to the most specific class + $resolvedTypes = []; + do { + $resolvedTypes[$type] = true; + $type = $this->getClassDiscriminatorResolvedClass($normalizedData, $type, $context); + } while (!isset($resolvedTypes[$type])); } $context['api_denormalize'] = true; @@ -277,6 +284,13 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a if ($this->resourceClassResolver->isResourceClass($type)) { $resourceClass = $this->resourceClassResolver->getResourceClass($objectToPopulate, $type); $context['resource_class'] = $resourceClass; + + // A subtype declared in the serializer discriminator map of the resource is described by its own + // metadata: pin the resource class to it so its properties can be written. + if (\is_array($data) && null !== $discriminatorMapping = $this->getDiscriminatorMapping($resourceClass, null !== $objectToPopulate ? $this->getObjectClass($objectToPopulate) : $type)) { + $data = $this->prepareDiscriminatedData($data, $discriminatorMapping, $objectToPopulate, $type, $context); + $resourceClass = $context['resource_class'] = $discriminatorMapping['class']; + } } elseif (($context['api_platform_input'] ?? false) && isset($context['resource_class'])) { // A discriminated input DTO base (not itself a resource) resolves to a concrete // subclass here: pin the resource class to that concrete class so constructor and @@ -510,6 +524,57 @@ protected function getClassDiscriminatorResolvedClass(array $data, string $class return $mappedClass; } + /** + * @return array{class: class-string, type_properties: list, mappings: list}|null + */ + private function getDiscriminatorMapping(string $resourceClass, string $class): ?array + { + return null === $this->classDiscriminatorResolver ? null : ClassDiscriminatorHelper::resolve($this->classDiscriminatorResolver, $resourceClass, $class); + } + + /** + * @param array{class: class-string, type_properties: list, mappings: list} $discriminatorMapping + */ + private function prepareDiscriminatedData(array $data, array $discriminatorMapping, ?object $objectToPopulate, string $type, array $context): array + { + // A class declaring its own map is resolved again by the Symfony serializer, which reads the type property of that map + $resolvedTypeProperty = null === $objectToPopulate ? $this->classDiscriminatorResolver?->getMappingForClass($type)?->getTypeProperty() : null; + foreach ($discriminatorMapping['mappings'] as $mapping) { + $typeProperty = $mapping->getTypeProperty(); + if (!\array_key_exists($typeProperty, $data)) { + continue; + } + + // The type of an existing object cannot be changed + if (null !== $objectToPopulate && (!\is_string($data[$typeProperty]) || null === ($typeClass = $mapping->getClassForType($data[$typeProperty])) || !$objectToPopulate instanceof $typeClass)) { + throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type "%s" does not match the type of the object being updated.', \is_scalar($data[$typeProperty]) ? $data[$typeProperty] : get_debug_type($data[$typeProperty])), $data[$typeProperty], ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$typeProperty : $typeProperty, true); + } + + // The type property is computed from the discriminator map, it is not a writable property of the object + if ($typeProperty !== $resolvedTypeProperty && !property_exists($discriminatorMapping['class'], $typeProperty)) { + unset($data[$typeProperty]); + } + } + + return $data; + } + + private function getDiscriminatorTypeValue(object $object, string $attribute, string $resourceClass): ?string + { + if (null === $this->classDiscriminatorResolver?->getMappingForMappedObject($object) || !$this->resourceClassResolver->isResourceClass($resourceClass)) { + return null; + } + + $discriminatorMapping = $this->getDiscriminatorMapping($this->resourceClassResolver->getResourceClass(null, $resourceClass), $this->getObjectClass($object)); + foreach ($discriminatorMapping['mappings'] ?? [] as $mapping) { + if ($attribute === $mapping->getTypeProperty()) { + return $mapping->getMappedObjectType($object); + } + } + + return null; + } + protected function createConstructorArgument(mixed $parameterData, string $key, \ReflectionParameter $constructorParameter, array $context, ?string $format = null): mixed { return $this->createAndValidateAttributeValue($constructorParameter->name, $parameterData, $format, $context); @@ -537,6 +602,12 @@ protected function getAllowedAttributes(string|object $classOrObject, array $con } $resourceClass = $this->resourceClassResolver->getResourceClass(null, $context['resource_class']); // fix for abstract classes and interfaces + // Subtypes are only exposed when they are explicitly declared in the serializer discriminator map of the resource + $discriminatorMapping = $this->getDiscriminatorMapping($resourceClass, $context['resource_class']); + if (null !== $discriminatorMapping) { + $resourceClass = $discriminatorMapping['class']; + } + $options = $this->getFactoryOptions($context); $propertyNames = $this->propertyNameCollectionFactory->create($resourceClass, $options); @@ -554,6 +625,20 @@ protected function getAllowedAttributes(string|object $classOrObject, array $con } } + // The type property is always part of a discriminated output, its value is computed from the discriminator map + if (null !== $discriminatorMapping && isset($context['api_normalize'])) { + foreach ($discriminatorMapping['type_properties'] as $typeProperty) { + if (!\in_array($typeProperty, $allowedAttributes, true) && $this->isAllowedAttribute($classOrObject, $typeProperty, null, $context)) { + array_unshift($allowedAttributes, $typeProperty); + } + } + } + + // The type property of the map declared by the class being created is read by the serializer to resolve the class + if (isset($context['api_denormalize']) && \is_string($classOrObject) && null !== ($typeProperty = $this->classDiscriminatorResolver?->getMappingForClass($classOrObject)?->getTypeProperty()) && !\in_array($typeProperty, $allowedAttributes, true)) { + $allowedAttributes[] = $typeProperty; + } + return $allowedAttributes; } @@ -636,14 +721,14 @@ protected function isCacheKeySafe(array $context): bool return $this->safeCacheKeysCache[$cacheKey]; } - $propertyNames = $this->propertyNameCollectionFactory->create($resourceClass, $options); - $this->safeCacheKeysCache[$cacheKey] = true; - foreach ($propertyNames as $propertyName) { - $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName, $options); - if (null !== ($propertyMetadata->getSecurity() ?? $propertyMetadata->getPolicy())) { - $this->safeCacheKeysCache[$cacheKey] = false; - break; + // Subtypes declared in the discriminator map of the resource are exposed too, their properties must be checked as well + foreach ([$resourceClass, ...(null === $this->classDiscriminatorResolver ? [] : ClassDiscriminatorHelper::getSubtypes($this->classDiscriminatorResolver, $resourceClass))] as $class) { + foreach ($this->propertyNameCollectionFactory->create($class, $options) as $propertyName) { + $propertyMetadata = $this->propertyMetadataFactory->create($class, $propertyName, $options); + if (null !== ($propertyMetadata->getSecurity() ?? $propertyMetadata->getPolicy())) { + return $this->safeCacheKeysCache[$cacheKey] = false; + } } } @@ -674,6 +759,11 @@ protected function canAccessAttributePostDenormalize(?object $object, ?object $p */ protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []): void { + // The type property is computed from the discriminator map, it is not a writable property of the object + if ($attribute === $this->classDiscriminatorResolver?->getMappingForMappedObject($object)?->getTypeProperty() && !property_exists($object, $attribute)) { + return; + } + // symfony/serializer only reads the current value of typed attributes (https://github.com/symfony/symfony/pull/67883), and it can't type them here if (!isset($context[static::OBJECT_TO_POPULATE]) && ($context[static::DEEP_OBJECT_TO_POPULATE] ?? $this->defaultContext[static::DEEP_OBJECT_TO_POPULATE] ?? false) @@ -883,6 +973,11 @@ protected function getFactoryOptions(array $context): array */ protected function getAttributeValue(object $object, string $attribute, ?string $format = null, array $context = []): mixed { + // Symfony only computes the type property of the innermost discriminator map, compute those of the outer ones + if (!($context['api_denormalize'] ?? false) && isset($context['resource_class']) && null !== $typeValue = $this->getDiscriminatorTypeValue($object, $attribute, $context['resource_class'])) { + return $typeValue; + } + $context['api_attribute'] = $attribute; $context['property_metadata'] = $propertyMetadata = $this->propertyMetadataFactory->create($context['resource_class'], $attribute, $this->getFactoryOptions($context)); diff --git a/src/Symfony/Bundle/Resources/config/json_schema.php b/src/Symfony/Bundle/Resources/config/json_schema.php index b1a21cf8c1f..6a091d684b7 100644 --- a/src/Symfony/Bundle/Resources/config/json_schema.php +++ b/src/Symfony/Bundle/Resources/config/json_schema.php @@ -31,6 +31,7 @@ service('api_platform.name_converter')->ignoreOnInvalid(), service('api_platform.resource_class_resolver'), service('api_platform.json_schema.definition_name_factory')->ignoreOnInvalid(), + service('serializer.mapping.class_discriminator_resolver')->ignoreOnInvalid(), ]); $services->alias(SchemaFactoryInterface::class, 'api_platform.json_schema.schema_factory'); diff --git a/src/Symfony/Bundle/Resources/config/jsonapi.php b/src/Symfony/Bundle/Resources/config/jsonapi.php index 0b2d4b1c760..e7d6b0d312f 100644 --- a/src/Symfony/Bundle/Resources/config/jsonapi.php +++ b/src/Symfony/Bundle/Resources/config/jsonapi.php @@ -43,6 +43,7 @@ service('api_platform.json_schema.definition_name_factory')->ignoreOnInvalid(), service('api_platform.jsonapi.resource_linkage_resolver'), false, + service('serializer.mapping.class_discriminator_resolver')->ignoreOnInvalid(), ]); $services->set('api_platform.jsonapi.encoder', JsonEncoder::class) diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.php new file mode 100644 index 00000000000..4eadb1a0cea --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.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\Fixtures\TestBundle\ApiResource\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Delete; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Operation; +use ApiPlatform\Metadata\Patch; +use ApiPlatform\Metadata\Post; +use ApiPlatform\Metadata\Put; +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; +use Symfony\Component\Validator\Constraints as Assert; + +/** + * Abstract resource exposing its subtypes through a serializer discriminator map. + * Subtypes are not resources themselves: the discriminator map is the contract declaring them. + */ +#[ApiResource( + operations: [ + new Get(), + new GetCollection(), + new Post(), + new Put(), + new Patch(), + new Delete(), + ], + provider: [self::class, 'provide'], + processor: [self::class, 'process'], +)] +#[DiscriminatorMap(typeProperty: 'kind', mapping: [ + 'fiction' => DiscriminatedFictionBook::class, + 'technical' => DiscriminatedTechnicalBook::class, +])] +abstract class DiscriminatedBook +{ + #[ApiProperty(identifier: true, writable: false)] + public ?int $id = null; + + #[Assert\NotBlank] + public string $title = ''; + + public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null + { + if ($operation instanceof GetCollection) { + return array_values(DiscriminatedBookStore::$books); + } + + return DiscriminatedBookStore::$books[(int) $uriVariables['id']] ?? null; + } + + public static function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): ?self + { + if ($operation instanceof Delete) { + unset(DiscriminatedBookStore::$books[(int) $uriVariables['id']]); + + return null; + } + + if (isset($uriVariables['id'])) { + $data->id = (int) $uriVariables['id']; + } + + $data->id ??= (DiscriminatedBookStore::$books ? max(array_keys(DiscriminatedBookStore::$books)) : 0) + 1; + + return DiscriminatedBookStore::$books[$data->id] = $data; + } +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php new file mode 100644 index 00000000000..fcd81038291 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php @@ -0,0 +1,22 @@ + + * + * 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\DiscriminatedResource; + +final class DiscriminatedBookStore +{ + /** + * @var array + */ + public static array $books = []; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedCar.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedCar.php new file mode 100644 index 00000000000..9190cc55db2 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedCar.php @@ -0,0 +1,29 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; + +class DiscriminatedCar extends DiscriminatedVehicle +{ + /** + * Native property types are invariant in PHP: the narrowing is declared through PHPDoc. + * + * @var DiscriminatedCar|null + */ + public ?DiscriminatedVehicle $tows = null; + + #[ApiProperty(writable: false)] + public ?string $plate = null; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php new file mode 100644 index 00000000000..cf62be4b3a6 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php @@ -0,0 +1,26 @@ + + * + * 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\DiscriminatedResource; + +use Symfony\Component\Validator\Constraints as Assert; + +class DiscriminatedFictionBook extends DiscriminatedBook +{ + public ?string $genre = null; + + #[Assert\Positive] + public ?int $pageCount = null; + + public ?DiscriminatedBook $sequelOf = null; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php new file mode 100644 index 00000000000..85ee25c1fef --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php @@ -0,0 +1,70 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Operation; +use ApiPlatform\Metadata\Patch; +use ApiPlatform\Metadata\Post; +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +/** + * Concrete resource declaring itself in its own discriminator map. + */ +#[ApiResource( + operations: [ + new Get(), + new GetCollection(), + new Post(), + new Patch(), + ], + normalizationContext: ['allow_extra_attributes' => false], + denormalizationContext: ['allow_extra_attributes' => false], + provider: [self::class, 'provide'], + processor: [self::class, 'process'], +)] +#[DiscriminatorMap(typeProperty: 'kind', mapping: [ + 'gadget' => DiscriminatedGadget::class, + 'phone' => DiscriminatedPhone::class, +])] +class DiscriminatedGadget +{ + #[ApiProperty(identifier: true, writable: false)] + public ?int $id = null; + + public string $name = ''; + + public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null + { + if ($operation instanceof GetCollection) { + return array_values(DiscriminatedGadgetStore::$gadgets); + } + + return DiscriminatedGadgetStore::$gadgets[(int) $uriVariables['id']] ?? null; + } + + public static function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): self + { + if (isset($uriVariables['id'])) { + $data->id = (int) $uriVariables['id']; + } + + $data->id ??= (DiscriminatedGadgetStore::$gadgets ? max(array_keys(DiscriminatedGadgetStore::$gadgets)) : 0) + 1; + + return DiscriminatedGadgetStore::$gadgets[$data->id] = $data; + } +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php new file mode 100644 index 00000000000..162e99786ae --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php @@ -0,0 +1,22 @@ + + * + * 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\DiscriminatedResource; + +final class DiscriminatedGadgetStore +{ + /** + * @var array + */ + public static array $gadgets = []; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php new file mode 100644 index 00000000000..33bd41f71f7 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php @@ -0,0 +1,19 @@ + + * + * 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\DiscriminatedResource; + +final class DiscriminatedPersianCat extends DiscriminatedPetCat +{ + public ?string $furLength = null; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php new file mode 100644 index 00000000000..3390bcbe020 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php @@ -0,0 +1,71 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Operation; +use ApiPlatform\Metadata\Patch; +use ApiPlatform\Metadata\Post; +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +/** + * Resource whose discriminator map contains a subtype declaring its own (nested) discriminator map. + */ +#[ApiResource( + operations: [ + new Get(), + new GetCollection(), + new Post(), + new Patch(), + ], + // input and output share their definitions: the flag is set on both so the JSON Schema restricts additional properties + normalizationContext: ['allow_extra_attributes' => false], + denormalizationContext: ['allow_extra_attributes' => false], + provider: [self::class, 'provide'], + processor: [self::class, 'process'], +)] +#[DiscriminatorMap(typeProperty: 'kind', mapping: [ + 'cat' => DiscriminatedPetCat::class, + 'dog' => DiscriminatedPetDog::class, +])] +abstract class DiscriminatedPet +{ + #[ApiProperty(identifier: true, writable: false)] + public ?int $id = null; + + public string $name = ''; + + public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null + { + if ($operation instanceof GetCollection) { + return array_values(DiscriminatedPetStore::$pets); + } + + return DiscriminatedPetStore::$pets[(int) $uriVariables['id']] ?? null; + } + + public static function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): self + { + if (isset($uriVariables['id'])) { + $data->id = (int) $uriVariables['id']; + } + + $data->id ??= (DiscriminatedPetStore::$pets ? max(array_keys(DiscriminatedPetStore::$pets)) : 0) + 1; + + return DiscriminatedPetStore::$pets[$data->id] = $data; + } +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetCat.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetCat.php new file mode 100644 index 00000000000..eee06293fa6 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetCat.php @@ -0,0 +1,25 @@ + + * + * 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\DiscriminatedResource; + +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +#[DiscriminatorMap(typeProperty: 'breed', mapping: [ + 'persian' => DiscriminatedPersianCat::class, + 'siamese' => DiscriminatedSiameseCat::class, +])] +abstract class DiscriminatedPetCat extends DiscriminatedPet +{ + public int $lives = 9; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php new file mode 100644 index 00000000000..0410a23a7fb --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php @@ -0,0 +1,19 @@ + + * + * 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\DiscriminatedResource; + +final class DiscriminatedPetDog extends DiscriminatedPet +{ + public bool $goodBoy = true; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php new file mode 100644 index 00000000000..1fec718d9ca --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php @@ -0,0 +1,22 @@ + + * + * 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\DiscriminatedResource; + +final class DiscriminatedPetStore +{ + /** + * @var array + */ + public static array $pets = []; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php new file mode 100644 index 00000000000..cda6fe5b28f --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php @@ -0,0 +1,19 @@ + + * + * 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\DiscriminatedResource; + +class DiscriminatedPhone extends DiscriminatedGadget +{ + public string $number = ''; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSiameseCat.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSiameseCat.php new file mode 100644 index 00000000000..7d704224546 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSiameseCat.php @@ -0,0 +1,19 @@ + + * + * 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\DiscriminatedResource; + +final class DiscriminatedSiameseCat extends DiscriminatedPetCat +{ + public ?string $eyeColor = null; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php new file mode 100644 index 00000000000..94c470e15de --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php @@ -0,0 +1,22 @@ + + * + * 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\DiscriminatedResource; + +/** + * Extends a mapped subtype without being declared in the discriminator map: its own properties must never be exposed. + */ +final class DiscriminatedSignedFictionBook extends DiscriminatedFictionBook +{ + public ?string $signature = null; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSportsCar.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSportsCar.php new file mode 100644 index 00000000000..ea4eeb63ffa --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSportsCar.php @@ -0,0 +1,27 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; + +/** + * Not declared in the discriminator map: it must be exposed exactly as a DiscriminatedCar. + */ +final class DiscriminatedSportsCar extends DiscriminatedCar +{ + #[ApiProperty(readable: false)] + public string $name = ''; + + public ?string $topSpeed = null; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php new file mode 100644 index 00000000000..45c71310936 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php @@ -0,0 +1,24 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; + +final class DiscriminatedTechnicalBook extends DiscriminatedBook +{ + public ?string $programmingLanguage = null; + + #[ApiProperty(security: "is_granted('ROLE_ADMIN')")] + public ?string $internalNote = null; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php new file mode 100644 index 00000000000..5411a0f8499 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php @@ -0,0 +1,49 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; +use Symfony\Component\Validator\Constraints as Assert; + +final class DiscriminatedTruck extends DiscriminatedVehicle +{ + #[Assert\Length(min: 5)] + public string $name = ''; + + #[ApiProperty(security: "is_granted('ROLE_ADMIN')")] + public ?string $plate = null; + + public ?int $payload = null; + + /** + * The setter cannot narrow its parameter (contravariance): writes are narrowed through validation. + */ + #[Assert\Type(self::class)] + protected ?DiscriminatedVehicle $trailer = null; + + /** + * Covariant return type: a truck only tows trucks. + */ + public function getTrailer(): ?self + { + \assert(null === $this->trailer || $this->trailer instanceof self); + + return $this->trailer; + } + + public function getRating(): int + { + return 4; + } +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php new file mode 100644 index 00000000000..172dcddd8c4 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php @@ -0,0 +1,101 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Delete; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Operation; +use ApiPlatform\Metadata\Patch; +use ApiPlatform\Metadata\Post; +use ApiPlatform\Metadata\Put; +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; +use Symfony\Component\Validator\Constraints as Assert; + +/** + * Discriminated resource whose subtypes override inherited properties (narrowed types, metadata, constraints). + */ +#[ApiResource( + operations: [ + new Get(), + new GetCollection(), + new Post(), + new Put(), + new Patch(), + new Delete(), + ], + provider: [self::class, 'provide'], + processor: [self::class, 'process'], +)] +#[DiscriminatorMap(typeProperty: 'kind', mapping: [ + 'car' => DiscriminatedCar::class, + 'truck' => DiscriminatedTruck::class, +])] +abstract class DiscriminatedVehicle +{ + #[ApiProperty(identifier: true, writable: false)] + public ?int $id = null; + + #[Assert\NotBlank] + public string $name = ''; + + public ?string $plate = null; + + public ?DiscriminatedVehicle $tows = null; + + protected ?DiscriminatedVehicle $trailer = null; + + public function getTrailer(): ?self + { + return $this->trailer; + } + + public function setTrailer(?self $trailer): void + { + $this->trailer = $trailer; + } + + public function getRating(): int|float + { + return 4.5; + } + + public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null + { + if ($operation instanceof GetCollection) { + return array_values(DiscriminatedVehicleStore::$vehicles); + } + + return DiscriminatedVehicleStore::$vehicles[(int) $uriVariables['id']] ?? null; + } + + public static function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): ?self + { + if ($operation instanceof Delete) { + unset(DiscriminatedVehicleStore::$vehicles[(int) $uriVariables['id']]); + + return null; + } + + if (isset($uriVariables['id'])) { + $data->id = (int) $uriVariables['id']; + } + + $data->id ??= (DiscriminatedVehicleStore::$vehicles ? max(array_keys(DiscriminatedVehicleStore::$vehicles)) : 0) + 1; + + return DiscriminatedVehicleStore::$vehicles[$data->id] = $data; + } +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicleStore.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicleStore.php new file mode 100644 index 00000000000..78a4337799a --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicleStore.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\DiscriminatedResource; + +final class DiscriminatedVehicleStore +{ + /** @var array */ + public static array $vehicles = []; +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php new file mode 100644 index 00000000000..dedfd50a9f5 --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php @@ -0,0 +1,43 @@ + + * + * 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\DiscriminatedResource; + +use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\Operation; + +/** + * Abstract resource without a serializer discriminator map: subclass properties must stay hidden. + * + * @see https://github.com/api-platform/core/issues/2931 + */ +#[ApiResource(operations: [new Get(provider: [self::class, 'provide'])])] +abstract class UndiscriminatedBook +{ + #[ApiProperty(identifier: true)] + public ?int $id = null; + + public string $title = ''; + + public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self + { + $book = new UndiscriminatedSecretBook(); + $book->id = (int) $uriVariables['id']; + $book->title = 'Hidden'; + $book->secret = 'must not leak'; + + return $book; + } +} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php new file mode 100644 index 00000000000..c8abc8e9e1e --- /dev/null +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php @@ -0,0 +1,19 @@ + + * + * 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\DiscriminatedResource; + +final class UndiscriminatedSecretBook extends UndiscriminatedBook +{ + public ?string $secret = null; +} diff --git a/tests/Functional/DiscriminatedNestedResourceTest.php b/tests/Functional/DiscriminatedNestedResourceTest.php new file mode 100644 index 00000000000..4ba1835513a --- /dev/null +++ b/tests/Functional/DiscriminatedNestedResourceTest.php @@ -0,0 +1,231 @@ + + * + * 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; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPersianCat; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPet; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPetDog; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPetStore; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedSiameseCat; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use JsonSchema\Validator; +use PHPUnit\Framework\Attributes\DataProvider; + +/** + * Polymorphic resources whose discriminator map contains a subtype declaring its own discriminator map. + */ +final class DiscriminatedNestedResourceTest extends ApiTestCase +{ + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [DiscriminatedPet::class]; + } + + protected function setUp(): void + { + $persian = new DiscriminatedPersianCat(); + $persian->id = 1; + $persian->name = 'Garfield'; + $persian->lives = 7; + $persian->furLength = 'long'; + + $dog = new DiscriminatedPetDog(); + $dog->id = 2; + $dog->name = 'Odie'; + + DiscriminatedPetStore::$pets = [1 => $persian, 2 => $dog]; + } + + protected function tearDown(): void + { + DiscriminatedPetStore::$pets = []; + + parent::tearDown(); + } + + public function testGetItemExposesTheTypeOfEveryMap(): void + { + $response = self::createClient()->request('GET', '/discriminated_pets/1'); + + $this->assertResponseIsSuccessful(); + $this->assertEquals([ + '@context' => '/contexts/DiscriminatedPet', + '@id' => '/discriminated_pets/1', + '@type' => 'DiscriminatedPet', + 'kind' => 'cat', + 'breed' => 'persian', + 'id' => 1, + 'name' => 'Garfield', + 'lives' => 7, + 'furLength' => 'long', + ], $response->toArray()); + } + + /** + * @return iterable + */ + public static function formatProvider(): iterable + { + yield 'json' => ['application/json']; + yield 'jsonapi' => ['application/vnd.api+json']; + yield 'hal' => ['application/hal+json']; + } + + #[DataProvider('formatProvider')] + public function testGetItemInOtherFormats(string $accept): void + { + $json = self::createClient()->request('GET', '/discriminated_pets/1', ['headers' => ['Accept' => $accept]])->toArray(); + + $this->assertResponseIsSuccessful(); + $attributes = $json['data']['attributes'] ?? $json; + $this->assertSame('cat', $attributes['kind']); + $this->assertSame('persian', $attributes['breed']); + $this->assertSame('long', $attributes['furLength']); + } + + public function testGetCollection(): void + { + $members = self::createClient()->request('GET', '/discriminated_pets')->toArray()['hydra:member']; + + $this->assertResponseIsSuccessful(); + $this->assertSame(['cat', 'dog'], array_column($members, 'kind')); + $this->assertSame('persian', $members[0]['breed']); + $this->assertArrayNotHasKey('breed', $members[1]); + $this->assertTrue($members[1]['goodBoy']); + } + + public function testPostCreatesTheMostSpecificSubtype(): void + { + self::createClient()->request('POST', '/discriminated_pets', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'cat', 'breed' => 'siamese', 'name' => 'Tom', 'lives' => 3, 'eyeColor' => 'blue'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['kind' => 'cat', 'breed' => 'siamese', 'name' => 'Tom', 'lives' => 3, 'eyeColor' => 'blue']); + $this->assertInstanceOf(DiscriminatedSiameseCat::class, DiscriminatedPetStore::$pets[3]); + $this->assertSame('blue', DiscriminatedPetStore::$pets[3]->eyeColor); + } + + public function testPostWithoutNestedTypeIsRejected(): void + { + self::createClient()->request('POST', '/discriminated_pets', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'cat', 'name' => 'Tom'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertArrayNotHasKey(3, DiscriminatedPetStore::$pets); + } + + public function testPostRejectsPropertiesOfAnotherSubtype(): void + { + self::createClient()->request('POST', '/discriminated_pets', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'cat', 'breed' => 'siamese', 'name' => 'Tom', 'furLength' => 'short'], + ]); + + $this->assertResponseStatusCodeSame(400); + } + + public function testPatchUpdatesNestedSubtypeProperties(): void + { + self::createClient()->request('PATCH', '/discriminated_pets/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['kind' => 'cat', 'breed' => 'persian', 'furLength' => 'short'], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['kind' => 'cat', 'breed' => 'persian', 'furLength' => 'short']); + $this->assertInstanceOf(DiscriminatedPersianCat::class, DiscriminatedPetStore::$pets[1]); + } + + public function testPatchCannotChangeTheNestedType(): void + { + self::createClient()->request('PATCH', '/discriminated_pets/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['breed' => 'siamese'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertInstanceOf(DiscriminatedPersianCat::class, DiscriminatedPetStore::$pets[1]); + } + + public function testOpenApiDocumentsNestedSubtypes(): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + $schemas = $json['components']['schemas']; + + $cat = $schemas['DiscriminatedPet.DiscriminatedPetCat']; + $this->assertSame('breed', $cat['discriminator']['propertyName']); + $this->assertCount(2, $cat['oneOf']); + + // A nested subtype documents the type properties of every map it belongs to. + $persian = $schemas['DiscriminatedPet.DiscriminatedPersianCat']; + $this->assertSame(['type' => 'string', 'enum' => ['cat']], $persian['properties']['kind']); + $this->assertSame(['type' => 'string', 'enum' => ['persian']], $persian['properties']['breed']); + $this->assertContains('kind', $persian['required']); + $this->assertContains('breed', $persian['required']); + $this->assertFalse($persian['additionalProperties']); + + // "additionalProperties" ignores "oneOf" branches: it must only restrict the leaf definitions. + $this->assertArrayNotHasKey('additionalProperties', $schemas['DiscriminatedPet']); + $this->assertArrayNotHasKey('additionalProperties', $cat); + $this->assertFalse($schemas['DiscriminatedPet.DiscriminatedPetDog']['additionalProperties']); + } + + /** + * @return iterable, bool}> + */ + public static function inputPayloadProvider(): iterable + { + yield 'dog' => [['kind' => 'dog', 'name' => 'Odie', 'goodBoy' => true], true]; + yield 'nested cat' => [['kind' => 'cat', 'breed' => 'persian', 'name' => 'Garfield', 'lives' => 7, 'furLength' => 'long'], true]; + yield 'property of a sibling subtype' => [['kind' => 'cat', 'breed' => 'persian', 'name' => 'Garfield', 'eyeColor' => 'blue'], false]; + yield 'unknown property' => [['kind' => 'dog', 'name' => 'Odie', 'unknown' => true], false]; + yield 'missing nested type' => [['kind' => 'cat', 'name' => 'Garfield'], false]; + } + + /** + * @param array $payload + */ + #[DataProvider('inputPayloadProvider')] + public function testInputSchemaValidatesPayloadsWhenExtraAttributesAreNotAllowed(array $payload, bool $valid): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + + $schema = json_decode(json_encode([ + '$ref' => $json['paths']['/discriminated_pets']['post']['requestBody']['content']['application/ld+json']['schema']['$ref'], + 'components' => ['schemas' => $json['components']['schemas']], + ])); + $data = json_decode(json_encode($payload)); + + $validator = new Validator(); + $validator->validate($data, $schema); + + $this->assertSame($valid, $validator->isValid(), json_encode($validator->getErrors())); + } +} diff --git a/tests/Functional/DiscriminatedResourceOverrideTest.php b/tests/Functional/DiscriminatedResourceOverrideTest.php new file mode 100644 index 00000000000..000c6877320 --- /dev/null +++ b/tests/Functional/DiscriminatedResourceOverrideTest.php @@ -0,0 +1,279 @@ + + * + * 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; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedCar; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedSportsCar; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedTruck; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedVehicle; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedVehicleStore; +use ApiPlatform\Tests\SetupClassResourcesTrait; + +/** + * Subtypes of a discriminated resource overriding inherited properties. + */ +final class DiscriminatedResourceOverrideTest extends ApiTestCase +{ + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [DiscriminatedVehicle::class]; + } + + protected function setUp(): void + { + $car = new DiscriminatedCar(); + $car->id = 1; + $car->name = 'Beetle'; + $car->plate = 'AB-123'; + + $truck = new DiscriminatedTruck(); + $truck->id = 2; + $truck->name = 'Actros'; + $truck->plate = 'TR-999'; + $truck->payload = 18000; + + $sportsCar = new DiscriminatedSportsCar(); + $sportsCar->id = 3; + $sportsCar->name = 'Carrera'; + $sportsCar->plate = 'SP-911'; + $sportsCar->topSpeed = '300'; + + DiscriminatedVehicleStore::$vehicles = [1 => $car, 2 => $truck, 3 => $sportsCar]; + } + + protected function tearDown(): void + { + DiscriminatedVehicleStore::$vehicles = []; + + parent::tearDown(); + } + + public function testOverriddenPropertyMetadataIsReadFromTheSubtype(): void + { + $client = self::createClient(); + + $car = $client->request('GET', '/discriminated_vehicles/1')->toArray(); + $this->assertSame('AB-123', $car['plate']); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); + + // The truck overrides "plate" with a security expression. + $truck = $client->request('GET', '/discriminated_vehicles/2')->toArray(); + $this->assertSame('truck', $truck['kind']); + $this->assertSame(18000, $truck['payload']); + $this->assertArrayNotHasKey('plate', $truck); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); + } + + public function testUnmappedSubclassIsExposedThroughItsMappedParentContract(): void + { + $response = self::createClient()->request('GET', '/discriminated_vehicles/3'); + + $this->assertResponseIsSuccessful(); + $json = $response->toArray(); + $this->assertSame('car', $json['kind']); + // Overrides declared on an unmapped subclass are not part of the documented contract. + $this->assertSame('Carrera', $json['name']); + $this->assertArrayNotHasKey('topSpeed', $json); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); + } + + public function testOverriddenWritabilityIsEnforced(): void + { + self::createClient()->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'car', 'name' => 'Golf', 'plate' => 'not writable on cars'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertNull(DiscriminatedVehicleStore::$vehicles[4]->plate); + } + + public function testOverriddenSecurityIsEnforcedOnWrite(): void + { + self::createClient()->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Scania', 'plate' => 'admins only'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertNull(DiscriminatedVehicleStore::$vehicles[4]->plate); + } + + public function testOverriddenConstraintsAreValidated(): void + { + $client = self::createClient(); + + $client->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'MAN'], + ]); + $this->assertResponseStatusCodeSame(422); + $this->assertJsonContains(['violations' => [['propertyPath' => 'name']]]); + + $client->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'car', 'name' => 'Kia'], + ]); + $this->assertResponseStatusCodeSame(201); + } + + public function testNarrowedRelationAcceptsTheNarrowedType(): void + { + self::createClient()->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'car', 'name' => 'Polo', 'tows' => '/discriminated_vehicles/1'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['tows' => '/discriminated_vehicles/1']); + $this->assertSame(DiscriminatedVehicleStore::$vehicles[1], DiscriminatedVehicleStore::$vehicles[4]->tows); + } + + public function testNarrowedRelationRejectsAnIriOfAnotherSubtype(): void + { + self::createClient()->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'car', 'name' => 'Polo', 'tows' => '/discriminated_vehicles/2'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertCount(3, DiscriminatedVehicleStore::$vehicles); + } + + public function testNarrowedRelationRejectsAnIriOfAnotherSubtypeOnPatch(): void + { + self::createClient()->request('PATCH', '/discriminated_vehicles/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['tows' => '/discriminated_vehicles/2'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertNull(DiscriminatedVehicleStore::$vehicles[1]->tows); + } + + public function testInheritedRelationAcceptsAnySubtype(): void + { + self::createClient()->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Volvo FH', 'tows' => '/discriminated_vehicles/1'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertSame(DiscriminatedVehicleStore::$vehicles[1], DiscriminatedVehicleStore::$vehicles[4]->tows); + } + + public function testCovariantGetterNarrowsTheReadType(): void + { + $trailer = new DiscriminatedTruck(); + $trailer->id = 5; + $trailer->name = 'Trailer truck'; + DiscriminatedVehicleStore::$vehicles[5] = $trailer; + DiscriminatedVehicleStore::$vehicles[2]->setTrailer($trailer); + $client = self::createClient(); + + $json = $client->request('GET', '/discriminated_vehicles/2')->toArray(); + $this->assertSame(4, $json['rating']); + $this->assertSame('/discriminated_vehicles/5', $json['trailer']); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); + + $json = $client->request('GET', '/discriminated_vehicles/1')->toArray(); + $this->assertSame(4.5, $json['rating']); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); + } + + public function testCovariantGetterAcceptsTheNarrowedTypeOnWrite(): void + { + $truck = new DiscriminatedTruck(); + $truck->id = 5; + $truck->name = 'Trailer truck'; + DiscriminatedVehicleStore::$vehicles[5] = $truck; + + self::createClient()->request('PATCH', '/discriminated_vehicles/2', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['trailer' => '/discriminated_vehicles/5'], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['trailer' => '/discriminated_vehicles/5']); + $this->assertSame($truck, DiscriminatedVehicleStore::$vehicles[2]->getTrailer()); + } + + /** + * A setter parameter cannot be narrowed (contravariance), so the write type is the inherited one: + * the narrowing of the covariant getter is enforced by validation. + */ + public function testCovariantGetterIsEnforcedOnWriteThroughValidation(): void + { + self::createClient()->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Volvo FH', 'trailer' => '/discriminated_vehicles/1'], + ]); + + $this->assertResponseStatusCodeSame(422); + $this->assertJsonContains(['violations' => [['propertyPath' => 'trailer']]]); + $this->assertCount(3, DiscriminatedVehicleStore::$vehicles); + } + + public function testInheritedGetterAcceptsAnySubtypeOnWrite(): void + { + self::createClient()->request('PATCH', '/discriminated_vehicles/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['trailer' => '/discriminated_vehicles/2'], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertSame(DiscriminatedVehicleStore::$vehicles[2], DiscriminatedVehicleStore::$vehicles[1]->getTrailer()); + } + + public function testSchemaDocumentsCovariantReturnTypes(): void + { + $schemas = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray()['components']['schemas']; + + $this->assertSame('integer', $schemas['DiscriminatedVehicle.DiscriminatedTruck.jsonld']['properties']['rating']['type']); + $this->assertSame([['type' => 'number'], ['type' => 'integer']], $schemas['DiscriminatedVehicle.DiscriminatedCar.jsonld']['properties']['rating']['anyOf']); + $this->assertSame([['type' => 'number'], ['type' => 'integer']], $schemas['DiscriminatedVehicle.jsonld']['allOf'][1]['properties']['rating']['anyOf']); + } + + public function testSchemaDocumentsOverriddenProperties(): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + $schemas = $json['components']['schemas']; + + // Overridden writability: "plate" is read-only on cars, but still writable on trucks. + $this->assertTrue($schemas['DiscriminatedVehicle.DiscriminatedCar']['properties']['plate']['readOnly']); + $this->assertArrayNotHasKey('readOnly', $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']['plate']); + $this->assertArrayNotHasKey('readOnly', $schemas['DiscriminatedVehicle']['properties']['plate']); + $this->assertArrayHasKey('payload', $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']); + + // Overridden constraints are documented on the subtype only. + $this->assertSame(5, $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']['name']['minLength']); + $this->assertArrayNotHasKey('minLength', $schemas['DiscriminatedVehicle.DiscriminatedCar']['properties']['name']); + + // Unmapped subclasses are never documented. + $this->assertArrayNotHasKey('DiscriminatedVehicle.DiscriminatedSportsCar', $schemas); + $this->assertArrayNotHasKey('DiscriminatedVehicle.DiscriminatedSportsCar.jsonld', $schemas); + } +} diff --git a/tests/Functional/DiscriminatedResourceTest.php b/tests/Functional/DiscriminatedResourceTest.php new file mode 100644 index 00000000000..083a497b436 --- /dev/null +++ b/tests/Functional/DiscriminatedResourceTest.php @@ -0,0 +1,497 @@ + + * + * 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; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedBook; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedBookStore; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedFictionBook; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedSignedFictionBook; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedTechnicalBook; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\UndiscriminatedBook; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use PHPUnit\Framework\Attributes\DataProvider; +use Symfony\Component\Security\Core\User\InMemoryUser; + +/** + * Polymorphic resources declared through a serializer discriminator map. + */ +final class DiscriminatedResourceTest extends ApiTestCase +{ + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [DiscriminatedBook::class, UndiscriminatedBook::class]; + } + + protected function setUp(): void + { + $fiction = new DiscriminatedFictionBook(); + $fiction->id = 1; + $fiction->title = 'The Hobbit'; + $fiction->genre = 'Fantasy'; + $fiction->pageCount = 310; + + $technical = new DiscriminatedTechnicalBook(); + $technical->id = 2; + $technical->title = 'Design Patterns'; + $technical->programmingLanguage = 'C++'; + $technical->internalNote = 'secret'; + + $signed = new DiscriminatedSignedFictionBook(); + $signed->id = 3; + $signed->title = 'Signed copy'; + $signed->genre = 'Fantasy'; + $signed->signature = 'must not leak'; + + DiscriminatedBookStore::$books = [1 => $fiction, 2 => $technical, 3 => $signed]; + } + + protected function tearDown(): void + { + DiscriminatedBookStore::$books = []; + + parent::tearDown(); + } + + public function testGetItemExposesSubtypeProperties(): void + { + $response = self::createClient()->request('GET', '/discriminated_books/1'); + + $this->assertResponseIsSuccessful(); + $this->assertEquals([ + '@context' => '/contexts/DiscriminatedBook', + '@id' => '/discriminated_books/1', + '@type' => 'DiscriminatedBook', + 'kind' => 'fiction', + 'id' => 1, + 'title' => 'The Hobbit', + 'genre' => 'Fantasy', + 'pageCount' => 310, + 'sequelOf' => null, + ], $response->toArray()); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class); + } + + public function testGetItemAppliesSubtypePropertySecurity(): void + { + $response = self::createClient()->request('GET', '/discriminated_books/2'); + + $this->assertResponseIsSuccessful(); + $json = $response->toArray(); + $this->assertSame('technical', $json['kind']); + $this->assertSame('C++', $json['programmingLanguage']); + $this->assertArrayNotHasKey('internalNote', $json); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class); + } + + /** + * The allowed attributes are cached per cache key, subtype property security must make that key unsafe + * or the attributes allowed for a user leak to the next ones in long-running processes. + */ + #[DataProvider('userSequenceProvider')] + public function testSubtypePropertySecurityIsNotCachedAcrossUsers(bool $adminFirst): void + { + $client = self::createClient(); + $client->disableReboot(); + + $requestAs = static function (bool $admin) use ($client): array { + $client->getCookieJar()->clear(); + if ($admin) { + $client->loginUser(new InMemoryUser('admin', 'password', ['ROLE_ADMIN'])); + } + + return $client->request('GET', '/discriminated_books/2', ['headers' => ['Accept' => 'application/json']])->toArray(); + }; + + foreach ([$adminFirst, !$adminFirst, $adminFirst] as $admin) { + $json = $requestAs($admin); + if ($admin) { + $this->assertSame('secret', $json['internalNote'] ?? null); + } else { + $this->assertArrayNotHasKey('internalNote', $json); + } + } + } + + /** + * @return iterable + */ + public static function userSequenceProvider(): iterable + { + yield 'admin first' => [true]; + yield 'anonymous first' => [false]; + } + + public function testGetItemDoesNotExposePropertiesOfUnmappedSubclass(): void + { + $response = self::createClient()->request('GET', '/discriminated_books/3'); + + $this->assertResponseIsSuccessful(); + $json = $response->toArray(); + $this->assertSame('fiction', $json['kind']); + $this->assertSame('Fantasy', $json['genre']); + $this->assertArrayNotHasKey('signature', $json); + } + + public function testGetItemWithoutDiscriminatorMapDoesNotExposeSubclassProperties(): void + { + $response = self::createClient()->request('GET', '/undiscriminated_books/1'); + + $this->assertResponseIsSuccessful(); + $json = $response->toArray(); + $this->assertSame('Hidden', $json['title']); + $this->assertArrayNotHasKey('secret', $json); + } + + public function testGetCollectionExposesEachSubtype(): void + { + unset(DiscriminatedBookStore::$books[3]); + + $response = self::createClient()->request('GET', '/discriminated_books'); + + $this->assertResponseIsSuccessful(); + $members = $response->toArray()['hydra:member']; + $this->assertCount(2, $members); + $this->assertSame('fiction', $members[0]['kind']); + $this->assertSame('Fantasy', $members[0]['genre']); + $this->assertArrayNotHasKey('programmingLanguage', $members[0]); + $this->assertSame('technical', $members[1]['kind']); + $this->assertSame('C++', $members[1]['programmingLanguage']); + $this->assertArrayNotHasKey('genre', $members[1]); + $this->assertMatchesResourceCollectionJsonSchema(DiscriminatedBook::class); + } + + public function testGetItemInJson(): void + { + $response = self::createClient()->request('GET', '/discriminated_books/1', ['headers' => ['Accept' => 'application/json']]); + + $this->assertResponseIsSuccessful(); + $this->assertEquals([ + 'kind' => 'fiction', + 'id' => 1, + 'title' => 'The Hobbit', + 'genre' => 'Fantasy', + 'pageCount' => 310, + 'sequelOf' => null, + ], $response->toArray()); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class, format: 'json'); + } + + public function testGetItemInJsonApi(): void + { + $response = self::createClient()->request('GET', '/discriminated_books/2', ['headers' => ['Accept' => 'application/vnd.api+json']]); + + $this->assertResponseIsSuccessful(); + $attributes = $response->toArray()['data']['attributes']; + $this->assertSame('technical', $attributes['kind']); + $this->assertSame('C++', $attributes['programmingLanguage']); + $this->assertArrayNotHasKey('internalNote', $attributes); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class, format: 'jsonapi'); + } + + public function testGetItemInHal(): void + { + $response = self::createClient()->request('GET', '/discriminated_books/1', ['headers' => ['Accept' => 'application/hal+json']]); + + $this->assertResponseIsSuccessful(); + $json = $response->toArray(); + $this->assertSame('fiction', $json['kind']); + $this->assertSame('Fantasy', $json['genre']); + $this->assertSame(310, $json['pageCount']); + } + + public function testPostCreatesTheMappedSubtype(): void + { + $response = self::createClient()->request('POST', '/discriminated_books', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => [ + 'kind' => 'technical', + 'title' => 'Refactoring', + 'programmingLanguage' => 'Java', + 'internalNote' => 'cannot be written anonymously', + ], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertEquals([ + '@context' => '/contexts/DiscriminatedBook', + '@id' => '/discriminated_books/4', + '@type' => 'DiscriminatedBook', + 'kind' => 'technical', + 'id' => 4, + 'title' => 'Refactoring', + 'programmingLanguage' => 'Java', + ], $response->toArray()); + $this->assertInstanceOf(DiscriminatedTechnicalBook::class, DiscriminatedBookStore::$books[4]); + $this->assertNull(DiscriminatedBookStore::$books[4]->internalNote); + } + + public function testPostDenormalizesSubtypeRelation(): void + { + $response = self::createClient()->request('POST', '/discriminated_books', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => [ + 'kind' => 'fiction', + 'title' => 'The Lord of the Rings', + 'genre' => 'Fantasy', + 'sequelOf' => '/discriminated_books/1', + ], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains([ + 'kind' => 'fiction', + 'sequelOf' => '/discriminated_books/1', + ]); + $book = DiscriminatedBookStore::$books[4]; + $this->assertInstanceOf(DiscriminatedFictionBook::class, $book); + $this->assertSame(DiscriminatedBookStore::$books[1], $book->sequelOf); + } + + public function testPostInJson(): void + { + self::createClient()->request('POST', '/discriminated_books', [ + 'headers' => ['Content-Type' => 'application/json', 'Accept' => 'application/json'], + 'json' => [ + 'kind' => 'fiction', + 'title' => 'Dune', + 'genre' => 'Science fiction', + 'pageCount' => 412, + ], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonEquals([ + 'kind' => 'fiction', + 'id' => 4, + 'title' => 'Dune', + 'genre' => 'Science fiction', + 'pageCount' => 412, + 'sequelOf' => null, + ]); + } + + public function testPostValidatesSubtypeConstraints(): void + { + self::createClient()->request('POST', '/discriminated_books', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => [ + 'kind' => 'fiction', + 'title' => 'Dune', + 'pageCount' => -1, + ], + ]); + + $this->assertResponseStatusCodeSame(422); + $this->assertJsonContains(['violations' => [['propertyPath' => 'pageCount']]]); + } + + public function testPostWithoutTypeIsRejected(): void + { + self::createClient()->request('POST', '/discriminated_books', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['title' => 'Untyped'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertCount(3, DiscriminatedBookStore::$books); + } + + public function testPostWithUnknownTypeIsRejected(): void + { + self::createClient()->request('POST', '/discriminated_books', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'poetry', 'title' => 'Unknown'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertCount(3, DiscriminatedBookStore::$books); + } + + public function testPatchUpdatesSubtypeProperties(): void + { + self::createClient()->request('PATCH', '/discriminated_books/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['genre' => 'High fantasy', 'pageCount' => 320], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonContains([ + 'kind' => 'fiction', + 'title' => 'The Hobbit', + 'genre' => 'High fantasy', + 'pageCount' => 320, + ]); + $book = DiscriminatedBookStore::$books[1]; + $this->assertInstanceOf(DiscriminatedFictionBook::class, $book); + $this->assertSame('High fantasy', $book->genre); + } + + public function testPatchAcceptsMatchingType(): void + { + self::createClient()->request('PATCH', '/discriminated_books/2', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['kind' => 'technical', 'programmingLanguage' => 'Rust'], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['kind' => 'technical', 'programmingLanguage' => 'Rust']); + } + + public function testPatchCannotChangeTheType(): void + { + self::createClient()->request('PATCH', '/discriminated_books/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['kind' => 'technical', 'programmingLanguage' => 'Rust'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertInstanceOf(DiscriminatedFictionBook::class, DiscriminatedBookStore::$books[1]); + $this->assertSame('Fantasy', DiscriminatedBookStore::$books[1]->genre); + } + + public function testPatchValidatesSubtypeConstraints(): void + { + self::createClient()->request('PATCH', '/discriminated_books/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['pageCount' => 0], + ]); + + $this->assertResponseStatusCodeSame(422); + $this->assertJsonContains(['violations' => [['propertyPath' => 'pageCount']]]); + } + + public function testPutReplacesTheResourceWithTheGivenSubtype(): void + { + self::createClient()->request('PUT', '/discriminated_books/1', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => [ + 'kind' => 'technical', + 'title' => 'Clean Code', + 'programmingLanguage' => 'Java', + ], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonEquals([ + '@context' => '/contexts/DiscriminatedBook', + '@id' => '/discriminated_books/1', + '@type' => 'DiscriminatedBook', + 'kind' => 'technical', + 'id' => 1, + 'title' => 'Clean Code', + 'programmingLanguage' => 'Java', + ]); + $this->assertInstanceOf(DiscriminatedTechnicalBook::class, DiscriminatedBookStore::$books[1]); + } + + public function testDelete(): void + { + self::createClient()->request('DELETE', '/discriminated_books/2'); + + $this->assertResponseStatusCodeSame(204); + $this->assertArrayNotHasKey(2, DiscriminatedBookStore::$books); + } + + public function testOpenApiDocumentsSubtypes(): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + $schemas = $json['components']['schemas']; + + // Output (JSON-LD): the base definition keeps its own properties and lists its subtypes. + $output = $this->findDefinition($schemas, $json['paths']['/discriminated_books/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); + $this->assertSame([ + 'propertyName' => 'kind', + 'mapping' => [ + 'fiction' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook.jsonld', + 'technical' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook.jsonld', + ], + ], $output['discriminator']); + $this->assertSame([ + ['$ref' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook.jsonld'], + ['$ref' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook.jsonld'], + ], $output['oneOf']); + $this->assertArrayHasKey('title', $output['properties']); + $this->assertArrayNotHasKey('genre', $output['properties']); + + $fiction = $schemas['DiscriminatedBook.DiscriminatedFictionBook.jsonld']; + $this->assertSame(['type' => 'string', 'enum' => ['fiction']], $fiction['properties']['kind']); + $this->assertContains('kind', $fiction['required']); + $this->assertArrayHasKey('genre', $fiction['properties']); + $this->assertArrayHasKey('pageCount', $fiction['properties']); + $this->assertArrayNotHasKey('signature', $fiction['properties']); + $this->assertArrayNotHasKey('allOf', $fiction, 'Subtype schemas must not reference the base schema back (circular reference).'); + + $technical = $schemas['DiscriminatedBook.DiscriminatedTechnicalBook.jsonld']; + $this->assertSame(['type' => 'string', 'enum' => ['technical']], $technical['properties']['kind']); + $this->assertArrayHasKey('programmingLanguage', $technical['properties']); + $this->assertArrayNotHasKey('genre', $technical['properties']); + + // Required properties of a subtype must not leak into the base nor into siblings. + $this->assertNotContains('kind', $output['required'] ?? []); + $this->assertNotContains('kind', $schemas['DiscriminatedBook.jsonld']['allOf'][1]['required'] ?? []); + + // Input (POST) + $postInput = $this->findDefinition($schemas, $json['paths']['/discriminated_books']['post']['requestBody']['content']['application/ld+json']['schema']['$ref']); + $this->assertSame('kind', $postInput['discriminator']['propertyName']); + $this->assertSame([ + 'fiction' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook', + 'technical' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook', + ], $postInput['discriminator']['mapping']); + $this->assertContains('kind', $schemas['DiscriminatedBook.DiscriminatedFictionBook']['required']); + $this->assertArrayHasKey('genre', $schemas['DiscriminatedBook.DiscriminatedFictionBook']['properties']); + + // Input (PATCH): a merge-patch document does not require any property, not even the type. + $patchInput = $this->findDefinition($schemas, $json['paths']['/discriminated_books/{id}']['patch']['requestBody']['content']['application/merge-patch+json']['schema']['$ref']); + $this->assertSame([ + 'fiction' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook.jsonMergePatch', + 'technical' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook.jsonMergePatch', + ], $patchInput['discriminator']['mapping']); + $this->assertArrayNotHasKey('required', $schemas['DiscriminatedBook.DiscriminatedFictionBook.jsonMergePatch']); + $this->assertArrayNotHasKey('required', $schemas['DiscriminatedBook.DiscriminatedTechnicalBook.jsonMergePatch']); + + // JSON:API: the type property is an attribute, each subtype is a variant of the "data" object. + $jsonApiData = $this->findDefinition($schemas, $schemas['DiscriminatedBook.jsonapi']['properties']['data']['$ref']); + $this->assertCount(2, $jsonApiData['oneOf']); + $fiction = $this->findDefinition($schemas, $jsonApiData['oneOf'][0]['$ref']); + $technical = $this->findDefinition($schemas, $jsonApiData['oneOf'][1]['$ref']); + $this->assertSame(['type' => 'string', 'enum' => ['fiction']], $fiction['properties']['attributes']['properties']['kind']); + $this->assertSame(['kind'], $fiction['properties']['attributes']['required']); + $this->assertArrayHasKey('sequelOf', $fiction['properties']['relationships']['properties']); + $this->assertArrayHasKey('programmingLanguage', $technical['properties']['attributes']['properties']); + + // Resources without a discriminator map are untouched. + $this->assertArrayNotHasKey('discriminator', $schemas['UndiscriminatedBook.jsonld']['allOf'][1]); + $this->assertArrayNotHasKey('oneOf', $schemas['UndiscriminatedBook.jsonld']['allOf'][1]); + } + + /** + * Resolves a definition, unwrapping the Hydra item decoration if any. + */ + private function findDefinition(array $schemas, string $ref): array + { + $definition = $schemas[substr($ref, \strlen('#/components/schemas/'))]; + + return $definition['allOf'][1] ?? $definition; + } +} diff --git a/tests/Functional/DiscriminatedSelfMappedResourceTest.php b/tests/Functional/DiscriminatedSelfMappedResourceTest.php new file mode 100644 index 00000000000..c30d3e71564 --- /dev/null +++ b/tests/Functional/DiscriminatedSelfMappedResourceTest.php @@ -0,0 +1,193 @@ + + * + * 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; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedGadget; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedGadgetStore; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPhone; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use JsonSchema\Validator; +use PHPUnit\Framework\Attributes\DataProvider; + +/** + * Concrete polymorphic resource declaring itself in its own discriminator map. + */ +final class DiscriminatedSelfMappedResourceTest extends ApiTestCase +{ + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [DiscriminatedGadget::class]; + } + + protected function setUp(): void + { + $gadget = new DiscriminatedGadget(); + $gadget->id = 1; + $gadget->name = 'Spinner'; + + $phone = new DiscriminatedPhone(); + $phone->id = 2; + $phone->name = 'Pocket'; + $phone->number = '555-0100'; + + DiscriminatedGadgetStore::$gadgets = [1 => $gadget, 2 => $phone]; + } + + protected function tearDown(): void + { + DiscriminatedGadgetStore::$gadgets = []; + + parent::tearDown(); + } + + public function testGetBaseItemExposesItsOwnType(): void + { + $response = self::createClient()->request('GET', '/discriminated_gadgets/1'); + + $this->assertResponseIsSuccessful(); + $this->assertEquals([ + '@context' => '/contexts/DiscriminatedGadget', + '@id' => '/discriminated_gadgets/1', + '@type' => 'DiscriminatedGadget', + 'kind' => 'gadget', + 'id' => 1, + 'name' => 'Spinner', + ], $response->toArray()); + } + + /** + * @return iterable + */ + public static function jsonApiItemProvider(): iterable + { + yield 'base type' => [1, 'gadget']; + yield 'subtype' => [2, 'phone']; + } + + #[DataProvider('jsonApiItemProvider')] + public function testGetItemInJsonApiMatchesItsJsonSchema(int $id, string $kind): void + { + $json = self::createClient()->request('GET', '/discriminated_gadgets/'.$id, ['headers' => ['Accept' => 'application/vnd.api+json']])->toArray(); + + $this->assertResponseIsSuccessful(); + $this->assertSame($kind, $json['data']['attributes']['kind']); + $this->assertMatchesResourceItemJsonSchema(DiscriminatedGadget::class, format: 'jsonapi'); + } + + public function testGetCollectionExposesTheTypeOfEveryMember(): void + { + $members = self::createClient()->request('GET', '/discriminated_gadgets')->toArray()['hydra:member']; + + $this->assertResponseIsSuccessful(); + $this->assertSame(['gadget', 'phone'], array_column($members, 'kind')); + $this->assertArrayNotHasKey('number', $members[0]); + $this->assertSame('555-0100', $members[1]['number']); + } + + public function testPostBaseTypeWithTypeProperty(): void + { + self::createClient()->request('POST', '/discriminated_gadgets', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'gadget', 'name' => 'Yo-yo'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['kind' => 'gadget', 'name' => 'Yo-yo']); + $this->assertSame(DiscriminatedGadget::class, DiscriminatedGadgetStore::$gadgets[3]::class); + } + + public function testPostSubtype(): void + { + self::createClient()->request('POST', '/discriminated_gadgets', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'phone', 'name' => 'Brick', 'number' => '555-0199'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['kind' => 'phone', 'number' => '555-0199']); + $this->assertInstanceOf(DiscriminatedPhone::class, DiscriminatedGadgetStore::$gadgets[3]); + } + + public function testPostBaseTypeRejectsSubtypeProperties(): void + { + self::createClient()->request('POST', '/discriminated_gadgets', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'gadget', 'name' => 'Yo-yo', 'number' => '555-0199'], + ]); + + $this->assertResponseStatusCodeSame(400); + } + + public function testPatchBaseItemWithItsType(): void + { + self::createClient()->request('PATCH', '/discriminated_gadgets/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['kind' => 'gadget', 'name' => 'Fidget'], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['kind' => 'gadget', 'name' => 'Fidget']); + } + + public function testPatchCannotChangeTheBaseItemType(): void + { + self::createClient()->request('PATCH', '/discriminated_gadgets/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['kind' => 'phone'], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertSame(DiscriminatedGadget::class, DiscriminatedGadgetStore::$gadgets[1]::class); + } + + /** + * @return iterable, bool}> + */ + public static function inputPayloadProvider(): iterable + { + yield 'base type' => [['kind' => 'gadget', 'name' => 'Yo-yo'], true]; + yield 'subtype' => [['kind' => 'phone', 'name' => 'Brick', 'number' => '555-0199'], true]; + yield 'unknown property' => [['kind' => 'gadget', 'name' => 'Yo-yo', 'unknown' => true], false]; + } + + /** + * @param array $payload + */ + #[DataProvider('inputPayloadProvider')] + public function testInputSchemaMatchesTheAcceptedPayloads(array $payload, bool $valid): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + + $schema = json_decode(json_encode([ + '$ref' => $json['paths']['/discriminated_gadgets']['post']['requestBody']['content']['application/ld+json']['schema']['$ref'], + 'components' => ['schemas' => $json['components']['schemas']], + ])); + $data = json_decode(json_encode($payload)); + + $validator = new Validator(); + $validator->validate($data, $schema); + + $this->assertSame($valid, $validator->isValid(), json_encode($validator->getErrors())); + } +} From 141f0a83e560b597ea7ccf09771b51e6f8ad7e14 Mon Sep 17 00:00:00 2001 From: Dylan van der Hout Date: Thu, 1 Oct 2026 15:48:33 +0200 Subject: [PATCH 2/4] feat(doctrine): derive resource polymorphism from Doctrine discriminator maps Expose the ORM and MongoDB ODM inheritance discriminator map of an API resource hierarchy as a serializer discriminator map, so subtypes are read, written and documented without declaring them twice. An explicit serializer DiscriminatorMap in the hierarchy takes precedence. Every non-leaf class gets a map of itself and its subclasses, so resources declared mid-hierarchy resolve their own subtypes. Disabled by default; enable with api_platform.doctrine.discriminator_map or api_platform.doctrine_mongodb_odm.discriminator_map. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../DoctrineDiscriminatorMappingLoader.php | 138 ++++++ ...DoctrineDiscriminatorMappingLoaderTest.php | 227 +++++++++ src/Doctrine/Common/composer.json | 4 +- .../ApiPlatformExtension.php | 8 + .../Compiler/SerializerMappingLoaderPass.php | 10 + .../DependencyInjection/Configuration.php | 12 + .../Resources/config/doctrine_mongodb_odm.php | 7 + .../Bundle/Resources/config/doctrine_orm.php | 7 + .../ApiPlatformExtensionTest.php | 24 + .../DoctrineDiscriminatedCar.php | 34 ++ .../DoctrineDiscriminatedSportsCar.php | 23 + .../DoctrineDiscriminatedTruck.php | 26 + .../DoctrineDiscriminatedVehicle.php | 46 ++ .../DoctrineDiscriminatedAnimal.php | 41 ++ .../DoctrineDiscriminatedCar.php | 37 ++ .../DoctrineDiscriminatedCat.php | 23 + .../DoctrineDiscriminatedCircle.php | 23 + .../DoctrineDiscriminatedDog.php | 23 + .../DoctrineDiscriminatedShape.php | 40 ++ .../DoctrineDiscriminatedSportsCar.php | 23 + .../DoctrineDiscriminatedSquare.php | 23 + .../DoctrineDiscriminatedTruck.php | 26 + .../DoctrineDiscriminatedVehicle.php | 48 ++ .../DoctrineDiscriminatedDocumentTest.php | 173 +++++++ .../DoctrineDiscriminatedResourceTest.php | 468 ++++++++++++++++++ .../DoctrineDiscriminatorMapAppKernel.php | 45 ++ .../SerializerMappingLoaderPassTest.php | 64 +++ .../DependencyInjection/ConfigurationTest.php | 2 + 28 files changed, 1624 insertions(+), 1 deletion(-) create mode 100644 src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php create mode 100644 src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php create mode 100644 tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedCar.php create mode 100644 tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php create mode 100644 tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php create mode 100644 tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedAnimal.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCar.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCat.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCircle.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedDog.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedShape.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSquare.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php create mode 100644 tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php create mode 100644 tests/Functional/DoctrineDiscriminatedDocumentTest.php create mode 100644 tests/Functional/DoctrineDiscriminatedResourceTest.php create mode 100644 tests/Functional/DoctrineDiscriminatorMapAppKernel.php create mode 100644 tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php diff --git a/src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php b/src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php new file mode 100644 index 00000000000..f8391289790 --- /dev/null +++ b/src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php @@ -0,0 +1,138 @@ + + * + * 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\Doctrine\Common\Serializer\Mapping\Loader; + +use ApiPlatform\Metadata\ResourceClassResolverInterface; +use Doctrine\Persistence\ManagerRegistry; +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; +use Symfony\Component\Serializer\Mapping\ClassMetadataInterface; +use Symfony\Component\Serializer\Mapping\Loader\LoaderInterface; + +/** + * Exposes the Doctrine inheritance discriminator map (ORM and MongoDB ODM) of an API resource as a serializer + * discriminator map, so the subtypes of a Doctrine hierarchy are read, written and documented as such. + * + * A serializer discriminator map declared in the hierarchy always takes precedence. + * + * The serializer does not inherit discriminator maps: every class having subclasses in the Doctrine map gets + * its own map, restricted to itself and its subclasses, so a resource declared in the middle of a hierarchy + * resolves its own subtypes too. + * + * @internal + */ +final class DoctrineDiscriminatorMappingLoader implements LoaderInterface +{ + public function __construct( + private readonly ManagerRegistry $managerRegistry, + private readonly ResourceClassResolverInterface $resourceClassResolver, + ) { + } + + public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool + { + if (null !== $classMetadata->getClassDiscriminatorMapping()) { + return false; + } + + $class = $classMetadata->getName(); + if (!class_exists($class) || null === $manager = $this->managerRegistry->getManagerForClass($class)) { + return false; + } + + $doctrineMetadata = $manager->getClassMetadata($class); + $discriminatorMap = property_exists($doctrineMetadata, 'discriminatorMap') ? $doctrineMetadata->discriminatorMap : null; + if (!\is_array($discriminatorMap) || !$discriminatorMap || null === $typeProperty = $this->getTypeProperty($doctrineMetadata)) { + return false; + } + + $typesMapping = []; + $hasSubtypes = false; + foreach ($discriminatorMap as $typeValue => $typeClass) { + if (!\is_string($typeClass) || !is_a($typeClass, $class, true)) { + continue; + } + + $typesMapping[(string) $typeValue] = $typeClass; + $hasSubtypes = $hasSubtypes || $typeClass !== $class; + } + + // Leaves do not need a map: their type is resolved from the maps of their parents + if (!$hasSubtypes) { + return false; + } + + // The root of a hierarchy (e.g. an abstract class) is not necessarily part of the Doctrine map + $hierarchy = array_filter($discriminatorMap, 'is_string'); + for ($hierarchyClass = $class; false !== $hierarchyClass; $hierarchyClass = get_parent_class($hierarchyClass)) { + $hierarchy[] = $hierarchyClass; + } + $hierarchy = array_unique($hierarchy); + + if (!$this->isResourceHierarchy($hierarchy) || $this->hasSerializerDiscriminatorMap($hierarchy)) { + return false; + } + + $classMetadata->setClassDiscriminatorMapping(new ClassDiscriminatorMapping($typeProperty, $typesMapping)); + + return true; + } + + private function getTypeProperty(object $doctrineMetadata): ?string + { + // ORM: a DiscriminatorColumnMapping object (ORM 3) or an array (ORM 2) + if (property_exists($doctrineMetadata, 'discriminatorColumn') && null !== $column = $doctrineMetadata->discriminatorColumn) { + $name = \is_array($column) ? ($column['name'] ?? null) : ($column->name ?? null); + + return \is_string($name) && '' !== $name ? $name : null; + } + + // MongoDB ODM + if (property_exists($doctrineMetadata, 'discriminatorField') && \is_string($doctrineMetadata->discriminatorField) && '' !== $doctrineMetadata->discriminatorField) { + return $doctrineMetadata->discriminatorField; + } + + return null; + } + + /** + * @param list $hierarchy + */ + private function isResourceHierarchy(array $hierarchy): bool + { + foreach ($hierarchy as $class) { + if ($this->resourceClassResolver->isResourceClass($class)) { + return true; + } + } + + return false; + } + + /** + * A serializer map declared anywhere in the hierarchy is the explicit API contract: the Doctrine one is ignored. + * + * @param list $hierarchy + */ + private function hasSerializerDiscriminatorMap(array $hierarchy): bool + { + foreach ($hierarchy as $class) { + if (class_exists($class) && (new \ReflectionClass($class))->getAttributes(DiscriminatorMap::class, \ReflectionAttribute::IS_INSTANCEOF)) { + return true; + } + } + + return false; + } +} diff --git a/src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php b/src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php new file mode 100644 index 00000000000..61bc58ac81f --- /dev/null +++ b/src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php @@ -0,0 +1,227 @@ + + * + * 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\Doctrine\Common\Tests\Serializer\Mapping\Loader; + +use ApiPlatform\Doctrine\Common\Serializer\Mapping\Loader\DoctrineDiscriminatorMappingLoader; +use ApiPlatform\Metadata\ResourceClassResolverInterface; +use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as OdmClassMetadata; +use Doctrine\ORM\Mapping\ClassMetadata as OrmClassMetadata; +use Doctrine\ORM\Mapping\DiscriminatorColumnMapping; +use Doctrine\Persistence\ManagerRegistry; +use Doctrine\Persistence\ObjectManager; +use PHPUnit\Framework\TestCase; +use Prophecy\Argument; +use Prophecy\PhpUnit\ProphecyTrait; +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; +use Symfony\Component\Serializer\Mapping\ClassMetadata; + +final class DoctrineDiscriminatorMappingLoaderTest extends TestCase +{ + use ProphecyTrait; + + private const ORM_MAP = [ + 'vehicle' => LoaderVehicle::class, + 'car' => LoaderCar::class, + 'sportsCar' => LoaderSportsCar::class, + 'truck' => LoaderTruck::class, + ]; + + public function testRootGetsTheWholeDoctrineMap(): void + { + $metadata = new ClassMetadata(LoaderVehicle::class); + + $this->assertTrue($this->createOrmLoader()->loadClassMetadata($metadata)); + $this->assertEquals(new ClassDiscriminatorMapping('kind', self::ORM_MAP), $metadata->getClassDiscriminatorMapping()); + } + + public function testIntermediateClassGetsItselfAndItsSubclasses(): void + { + $metadata = new ClassMetadata(LoaderCar::class); + + $this->assertTrue($this->createOrmLoader()->loadClassMetadata($metadata)); + $this->assertEquals( + new ClassDiscriminatorMapping('kind', ['car' => LoaderCar::class, 'sportsCar' => LoaderSportsCar::class]), + $metadata->getClassDiscriminatorMapping(), + ); + } + + public function testLeavesAreLeftAlone(): void + { + $loader = $this->createOrmLoader(); + + foreach ([LoaderSportsCar::class, LoaderTruck::class] as $class) { + $metadata = new ClassMetadata($class); + $this->assertFalse($loader->loadClassMetadata($metadata)); + $this->assertNull($metadata->getClassDiscriminatorMapping()); + } + } + + public function testExistingSerializerMappingWins(): void + { + $mapping = new ClassDiscriminatorMapping('type', ['car' => LoaderCar::class]); + $metadata = new ClassMetadata(LoaderVehicle::class, $mapping); + + $this->assertFalse($this->createOrmLoader()->loadClassMetadata($metadata)); + $this->assertSame($mapping, $metadata->getClassDiscriminatorMapping()); + } + + public function testSerializerDiscriminatorMapDeclaredInTheHierarchyWins(): void + { + $doctrineMetadata = $this->createOrmMetadata(LoaderSerializerMappedChild::class, [ + 'base' => LoaderSerializerMappedBase::class, + 'child' => LoaderSerializerMappedChild::class, + 'grandChild' => LoaderSerializerMappedGrandChild::class, + ]); + $metadata = new ClassMetadata(LoaderSerializerMappedChild::class); + + $this->assertFalse($this->createLoader([LoaderSerializerMappedChild::class => $doctrineMetadata])->loadClassMetadata($metadata)); + $this->assertNull($metadata->getClassDiscriminatorMapping()); + } + + public function testNonResourceHierarchiesAreLeftAlone(): void + { + $metadata = new ClassMetadata(LoaderVehicle::class); + $loader = $this->createLoader([LoaderVehicle::class => $this->createOrmMetadata(LoaderVehicle::class, self::ORM_MAP)], []); + + $this->assertFalse($loader->loadClassMetadata($metadata)); + $this->assertNull($metadata->getClassDiscriminatorMapping()); + } + + public function testHierarchyIsExposedWhenOnlyASubclassIsAResource(): void + { + $metadata = new ClassMetadata(LoaderVehicle::class); + $loader = $this->createLoader([LoaderVehicle::class => $this->createOrmMetadata(LoaderVehicle::class, self::ORM_MAP)], [LoaderTruck::class]); + + $this->assertTrue($loader->loadClassMetadata($metadata)); + $this->assertEqualsCanonicalizing(self::ORM_MAP, $metadata->getClassDiscriminatorMapping()?->getTypesMapping()); + } + + public function testUnmanagedClassesAreLeftAlone(): void + { + $metadata = new ClassMetadata(LoaderVehicle::class); + + $this->assertFalse($this->createLoader([])->loadClassMetadata($metadata)); + $this->assertNull($metadata->getClassDiscriminatorMapping()); + } + + public function testClassesWithoutInheritanceAreLeftAlone(): void + { + $metadata = new ClassMetadata(LoaderVehicle::class); + $doctrineMetadata = new OrmClassMetadata(LoaderVehicle::class); + + $this->assertFalse($this->createLoader([LoaderVehicle::class => $doctrineMetadata])->loadClassMetadata($metadata)); + $this->assertNull($metadata->getClassDiscriminatorMapping()); + } + + public function testIntegerDiscriminatorValuesAreCastToStrings(): void + { + $metadata = new ClassMetadata(LoaderVehicle::class); + $loader = $this->createLoader([LoaderVehicle::class => $this->createOrmMetadata(LoaderVehicle::class, [1 => LoaderCar::class, 2 => LoaderTruck::class])]); + + $this->assertTrue($loader->loadClassMetadata($metadata)); + $this->assertEqualsCanonicalizing(['1' => LoaderCar::class, '2' => LoaderTruck::class], $metadata->getClassDiscriminatorMapping()?->getTypesMapping()); + $this->assertSame(LoaderCar::class, $metadata->getClassDiscriminatorMapping()->getClassForType('1')); + } + + public function testMongoDbOdmDiscriminatorField(): void + { + $doctrineMetadata = new OdmClassMetadata(LoaderVehicle::class); + $doctrineMetadata->discriminatorField = 'kind'; + $doctrineMetadata->discriminatorMap = ['car' => LoaderCar::class, 'truck' => LoaderTruck::class]; + $metadata = new ClassMetadata(LoaderVehicle::class); + + $this->assertTrue($this->createLoader([LoaderVehicle::class => $doctrineMetadata])->loadClassMetadata($metadata)); + $this->assertEquals( + new ClassDiscriminatorMapping('kind', ['car' => LoaderCar::class, 'truck' => LoaderTruck::class]), + $metadata->getClassDiscriminatorMapping(), + ); + } + + private function createOrmLoader(): DoctrineDiscriminatorMappingLoader + { + $metadata = []; + foreach (self::ORM_MAP as $class) { + $metadata[$class] = $this->createOrmMetadata($class, self::ORM_MAP); + } + + return $this->createLoader($metadata); + } + + /** + * @param array $discriminatorMap + */ + private function createOrmMetadata(string $class, array $discriminatorMap): OrmClassMetadata + { + $metadata = new OrmClassMetadata($class); + // ORM 2 stores the discriminator column as an array + $metadata->discriminatorColumn = class_exists(DiscriminatorColumnMapping::class) + ? new DiscriminatorColumnMapping('string', 'kind', 'kind') + : ['type' => 'string', 'fieldName' => 'kind', 'name' => 'kind']; + $metadata->discriminatorMap = $discriminatorMap; + + return $metadata; + } + + /** + * @param array $doctrineMetadata + * @param class-string[]|null $resourceClasses defaults to the root of every hierarchy + */ + private function createLoader(array $doctrineMetadata, ?array $resourceClasses = null): DoctrineDiscriminatorMappingLoader + { + $resourceClasses ??= [LoaderVehicle::class, LoaderSerializerMappedBase::class]; + + $managerRegistry = $this->prophesize(ManagerRegistry::class); + $managerRegistry->getManagerForClass(Argument::type('string'))->willReturn(null); + foreach ($doctrineMetadata as $class => $metadata) { + $manager = $this->prophesize(ObjectManager::class); + $manager->getClassMetadata($class)->willReturn($metadata); + $managerRegistry->getManagerForClass($class)->willReturn($manager->reveal()); + } + + $resourceClassResolver = $this->prophesize(ResourceClassResolverInterface::class); + $resourceClassResolver->isResourceClass(Argument::type('string'))->will(static fn (array $args): bool => \in_array($args[0], $resourceClasses, true)); + + return new DoctrineDiscriminatorMappingLoader($managerRegistry->reveal(), $resourceClassResolver->reveal()); + } +} + +class LoaderVehicle +{ +} + +class LoaderCar extends LoaderVehicle +{ +} + +class LoaderSportsCar extends LoaderCar +{ +} + +class LoaderTruck extends LoaderVehicle +{ +} + +#[DiscriminatorMap(typeProperty: 'type', mapping: ['child' => LoaderSerializerMappedChild::class])] +class LoaderSerializerMappedBase +{ +} + +class LoaderSerializerMappedChild extends LoaderSerializerMappedBase +{ +} + +class LoaderSerializerMappedGrandChild extends LoaderSerializerMappedChild +{ +} diff --git a/src/Doctrine/Common/composer.json b/src/Doctrine/Common/composer.json index 2661c2e6469..7154e8e05b8 100644 --- a/src/Doctrine/Common/composer.json +++ b/src/Doctrine/Common/composer.json @@ -35,6 +35,7 @@ "doctrine/orm": "^2.17 || ^3.0", "phpspec/prophecy-phpunit": "^2.2", "phpunit/phpunit": "^11.5 || ^12.2 || ^13.0", + "symfony/serializer": "^7.4 || ^8.0", "symfony/type-info": "^7.4 || ^8.0" }, "conflict": { @@ -46,7 +47,8 @@ "symfony/config": "For XML resource configuration.", "api-platform/http-cache": "For HTTP cache invalidation.", "api-platform/graphql": "For GraphQl mercure subscriptions.", - "symfony/mercure-bundle": "For mercure updates publisher." + "symfony/mercure-bundle": "For mercure updates publisher.", + "symfony/serializer": "To expose Doctrine discriminator maps as polymorphic resources." }, "autoload": { "psr-4": { diff --git a/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php b/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php index 52531dfb23f..0d66dc5ed04 100644 --- a/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php +++ b/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php @@ -864,6 +864,10 @@ private function registerDoctrineOrmConfiguration(ContainerBuilder $container, a $loader->load('graphql/doctrine_orm.php'); } + if (!$config['doctrine']['discriminator_map']) { + $container->removeDefinition('api_platform.doctrine.orm.serializer.discriminator_mapping_loader'); + } + if ($this->isConfigEnabled($container, $config['eager_loading'])) { return; } @@ -898,6 +902,10 @@ private function registerDoctrineMongoDbOdmConfiguration(ContainerBuilder $conta if ($this->isConfigEnabled($container, $config['graphql'])) { $loader->load('graphql/doctrine_mongodb_odm.php'); } + + if (!$config['doctrine_mongodb_odm']['discriminator_map']) { + $container->removeDefinition('api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader'); + } } private function registerHttpCacheConfiguration(ContainerBuilder $container, array $config, PhpFileLoader $loader): void diff --git a/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php b/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php index 7a9cc0d5c1d..61546662208 100644 --- a/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php +++ b/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php @@ -23,6 +23,16 @@ public function process(ContainerBuilder $container): void $chainLoader = $container->getDefinition('serializer.mapping.chain_loader'); $loaders = $chainLoader->getArgument(0); $loaders[] = $container->getDefinition('api_platform.serializer.property_metadata_loader'); + + // Doctrine discriminator maps are loaded last so explicit serializer maps take precedence + foreach (['api_platform.doctrine.orm.serializer.discriminator_mapping_loader', 'api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader'] as $id) { + if ($container->hasDefinition($id)) { + $loader = $container->getDefinition($id); + $loaders[] = $loader; + $chainLoader->replaceArgument(0, [...$chainLoader->getArgument(0), $loader]); + } + } + $container->getDefinition('serializer.mapping.cache_warmer')->replaceArgument(0, $loaders); } } diff --git a/src/Symfony/Bundle/DependencyInjection/Configuration.php b/src/Symfony/Bundle/DependencyInjection/Configuration.php index a65e60f9d10..a559c9aa86f 100644 --- a/src/Symfony/Bundle/DependencyInjection/Configuration.php +++ b/src/Symfony/Bundle/DependencyInjection/Configuration.php @@ -236,6 +236,12 @@ private function addDoctrineOrmSection(ArrayNodeDefinition $rootNode): void ->children() ->arrayNode('doctrine') ->{class_exists(DoctrineBundle::class) && interface_exists(EntityManagerInterface::class) ? 'canBeDisabled' : 'canBeEnabled'}() + ->children() + ->booleanNode('discriminator_map') + ->defaultFalse() + ->info('Expose the subtypes declared in the Doctrine ORM discriminator map of a resource as a serializer discriminator map (polymorphic resources): mapped subclass properties are exposed and writable. An explicit serializer discriminator map always takes precedence.') + ->end() + ->end() ->end() ->end(); } @@ -246,6 +252,12 @@ private function addDoctrineMongoDbOdmSection(ArrayNodeDefinition $rootNode): vo ->children() ->arrayNode('doctrine_mongodb_odm') ->{class_exists(DoctrineMongoDBBundle::class) ? 'canBeDisabled' : 'canBeEnabled'}() + ->children() + ->booleanNode('discriminator_map') + ->defaultFalse() + ->info('Expose the subtypes declared in the Doctrine MongoDB ODM discriminator map of a resource as a serializer discriminator map (polymorphic resources): mapped subclass properties are exposed and writable. An explicit serializer discriminator map always takes precedence.') + ->end() + ->end() ->end() ->end(); } diff --git a/src/Symfony/Bundle/Resources/config/doctrine_mongodb_odm.php b/src/Symfony/Bundle/Resources/config/doctrine_mongodb_odm.php index 8e7625bf4af..e38210c8550 100644 --- a/src/Symfony/Bundle/Resources/config/doctrine_mongodb_odm.php +++ b/src/Symfony/Bundle/Resources/config/doctrine_mongodb_odm.php @@ -14,6 +14,7 @@ namespace Symfony\Component\DependencyInjection\Loader\Configurator; use ApiPlatform\Doctrine\Common\Metadata\Property\DoctrineDiscriminatorSerializerPropertyMetadataFactory; +use ApiPlatform\Doctrine\Common\Serializer\Mapping\Loader\DoctrineDiscriminatorMappingLoader; use ApiPlatform\Doctrine\Common\State\PersistProcessor; use ApiPlatform\Doctrine\Common\State\RemoveProcessor; use ApiPlatform\Doctrine\Odm\Extension\FilterExtension; @@ -196,6 +197,12 @@ service('api_platform.doctrine_mongodb.odm.metadata.property.metadata_factory.inner'), ]); + $services->set('api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader', DoctrineDiscriminatorMappingLoader::class) + ->args([ + service('doctrine_mongodb'), + service('api_platform.resource_class_resolver'), + ]); + $services->set('api_platform.doctrine_mongodb.odm.metadata.property.metadata_factory.discriminator_serializer', DoctrineDiscriminatorSerializerPropertyMetadataFactory::class) ->decorate('api_platform.metadata.property.metadata_factory', null, 31) ->args([ diff --git a/src/Symfony/Bundle/Resources/config/doctrine_orm.php b/src/Symfony/Bundle/Resources/config/doctrine_orm.php index 13806ccf0fb..a3f6f8bf1a6 100644 --- a/src/Symfony/Bundle/Resources/config/doctrine_orm.php +++ b/src/Symfony/Bundle/Resources/config/doctrine_orm.php @@ -14,6 +14,7 @@ namespace Symfony\Component\DependencyInjection\Loader\Configurator; use ApiPlatform\Doctrine\Common\Metadata\Property\DoctrineDiscriminatorSerializerPropertyMetadataFactory; +use ApiPlatform\Doctrine\Common\Serializer\Mapping\Loader\DoctrineDiscriminatorMappingLoader; use ApiPlatform\Doctrine\Common\State\PersistProcessor; use ApiPlatform\Doctrine\Common\State\RemoveProcessor; use ApiPlatform\Doctrine\Orm\Extension\EagerLoadingExtension; @@ -214,6 +215,12 @@ service('api_platform.doctrine.orm.metadata.property.metadata_factory.inner'), ]); + $services->set('api_platform.doctrine.orm.serializer.discriminator_mapping_loader', DoctrineDiscriminatorMappingLoader::class) + ->args([ + service('doctrine'), + service('api_platform.resource_class_resolver'), + ]); + $services->set('api_platform.doctrine.orm.metadata.property.metadata_factory.discriminator_serializer', DoctrineDiscriminatorSerializerPropertyMetadataFactory::class) ->decorate('api_platform.metadata.property.metadata_factory', null, 31) ->args([ diff --git a/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php b/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php index 8f80ae8e788..5c0268deaab 100644 --- a/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php +++ b/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php @@ -643,4 +643,28 @@ public function testHttpCachePurgeListenerRegisteredForMongoDbOdmWhenInvalidatio $tags = $this->container->getDefinition('api_platform.doctrine_mongodb.odm.listener.http_cache.purge')->getTags(); $this->assertSame([['event' => 'onFlush'], ['event' => 'postFlush']], $tags['doctrine_mongodb.odm.event_listener']); } + + public function testDoctrineDiscriminatorMappingLoadersAreNotRegisteredByDefault(): void + { + $config = self::DEFAULT_CONFIG; + $config['api_platform']['doctrine']['enabled'] = true; + $config['api_platform']['doctrine_mongodb_odm']['enabled'] = true; + (new ApiPlatformExtension())->load($config, $this->container); + + $this->assertContainerHasService('api_platform.doctrine.orm.state.item_provider'); + $this->assertNotContainerHasService('api_platform.doctrine.orm.serializer.discriminator_mapping_loader'); + $this->assertContainerHasService('api_platform.doctrine_mongodb.odm.state.item_provider'); + $this->assertNotContainerHasService('api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader'); + } + + public function testDoctrineDiscriminatorMappingLoadersCanBeEnabled(): void + { + $config = self::DEFAULT_CONFIG; + $config['api_platform']['doctrine'] = ['enabled' => true, 'discriminator_map' => true]; + $config['api_platform']['doctrine_mongodb_odm'] = ['enabled' => true, 'discriminator_map' => true]; + (new ApiPlatformExtension())->load($config, $this->container); + + $this->assertContainerHasService('api_platform.doctrine.orm.serializer.discriminator_mapping_loader'); + $this->assertContainerHasService('api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader'); + } } diff --git a/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedCar.php b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedCar.php new file mode 100644 index 00000000000..4e6ed7df270 --- /dev/null +++ b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedCar.php @@ -0,0 +1,34 @@ + + * + * 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\DoctrineDiscriminated; + +use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\Post; +use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM; +use Symfony\Component\Validator\Constraints as Assert; + +#[ApiResource(operations: [new Get(), new Post()])] +#[ODM\Document] +class DoctrineDiscriminatedCar extends DoctrineDiscriminatedVehicle +{ + #[ODM\Field(type: 'int')] + #[Assert\Positive] + public int $seats = 4; + + #[ODM\Field(nullable: true)] + #[ApiProperty(security: "is_granted('ROLE_ADMIN')")] + public ?string $vin = null; +} diff --git a/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php new file mode 100644 index 00000000000..23fddd176dc --- /dev/null +++ b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php @@ -0,0 +1,23 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM; + +#[ODM\Document] +class DoctrineDiscriminatedSportsCar extends DoctrineDiscriminatedCar +{ + #[ODM\Field(type: 'int')] + public int $topSpeed = 0; +} diff --git a/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php new file mode 100644 index 00000000000..ec3a076caad --- /dev/null +++ b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php @@ -0,0 +1,26 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM; + +/** + * Not an API resource: exposed as a subtype of the vehicle resource. + */ +#[ODM\Document] +class DoctrineDiscriminatedTruck extends DoctrineDiscriminatedVehicle +{ + #[ODM\Field(type: 'int')] + public int $payload = 0; +} diff --git a/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php new file mode 100644 index 00000000000..49b0552b8dd --- /dev/null +++ b/tests/Fixtures/TestBundle/Document/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php @@ -0,0 +1,46 @@ + + * + * 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\DoctrineDiscriminated; + +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Delete; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Patch; +use ApiPlatform\Metadata\Post; +use ApiPlatform\Metadata\Put; +use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM; +use Symfony\Component\Validator\Constraints as Assert; + +/** + * Single collection inheritance: the subtypes are only declared in the Doctrine discriminator map. + */ +#[ApiResource(operations: [new Get(), new GetCollection(), new Post(), new Put(), new Patch(), new Delete()])] +#[ODM\Document] +#[ODM\InheritanceType('SINGLE_COLLECTION')] +#[ODM\DiscriminatorField('kind')] +#[ODM\DiscriminatorMap([ + 'car' => DoctrineDiscriminatedCar::class, + 'sportsCar' => DoctrineDiscriminatedSportsCar::class, + 'truck' => DoctrineDiscriminatedTruck::class, +])] +abstract class DoctrineDiscriminatedVehicle +{ + #[ODM\Id(strategy: 'INCREMENT', type: 'int')] + public ?int $id = null; + + #[ODM\Field] + #[Assert\NotBlank] + public string $name = ''; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedAnimal.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedAnimal.php new file mode 100644 index 00000000000..b06b49ad510 --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedAnimal.php @@ -0,0 +1,41 @@ + + * + * 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\DoctrineDiscriminated; + +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Post; +use Doctrine\ORM\Mapping as ORM; +use Symfony\Component\Serializer\Attribute\DiscriminatorMap; + +/** + * The serializer discriminator map is the API contract: it takes precedence over the Doctrine one. + */ +#[ApiResource(operations: [new Get(), new GetCollection(), new Post()])] +#[ORM\Entity] +#[ORM\InheritanceType('SINGLE_TABLE')] +#[ORM\DiscriminatorColumn(name: 'discr', type: 'string')] +#[ORM\DiscriminatorMap(['dog' => DoctrineDiscriminatedDog::class, 'cat' => DoctrineDiscriminatedCat::class])] +#[DiscriminatorMap(typeProperty: 'species', mapping: ['canine' => DoctrineDiscriminatedDog::class])] +abstract class DoctrineDiscriminatedAnimal +{ + #[ORM\Id] + #[ORM\GeneratedValue] + #[ORM\Column(type: 'integer')] + public ?int $id = null; + + #[ORM\Column] + public string $name = ''; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCar.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCar.php new file mode 100644 index 00000000000..3f80e948131 --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCar.php @@ -0,0 +1,37 @@ + + * + * 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\DoctrineDiscriminated; + +use ApiPlatform\Metadata\ApiProperty; +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\Post; +use Doctrine\ORM\Mapping as ORM; +use Symfony\Component\Validator\Constraints as Assert; + +/** + * A resource in the middle of the hierarchy: it resolves its own subtypes from the Doctrine map. + */ +#[ApiResource(operations: [new Get(), new Post()])] +#[ORM\Entity] +class DoctrineDiscriminatedCar extends DoctrineDiscriminatedVehicle +{ + #[ORM\Column(type: 'integer')] + #[Assert\Positive] + public int $seats = 4; + + #[ORM\Column(nullable: true)] + #[ApiProperty(security: "is_granted('ROLE_ADMIN')")] + public ?string $vin = null; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCat.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCat.php new file mode 100644 index 00000000000..5d05aaf174d --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCat.php @@ -0,0 +1,23 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ORM\Mapping as ORM; + +#[ORM\Entity] +class DoctrineDiscriminatedCat extends DoctrineDiscriminatedAnimal +{ + #[ORM\Column(type: 'integer')] + public int $lives = 9; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCircle.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCircle.php new file mode 100644 index 00000000000..6061585f4a1 --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedCircle.php @@ -0,0 +1,23 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ORM\Mapping as ORM; + +#[ORM\Entity] +class DoctrineDiscriminatedCircle extends DoctrineDiscriminatedShape +{ + #[ORM\Column(type: 'float')] + public float $radius = 0.0; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedDog.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedDog.php new file mode 100644 index 00000000000..e23f23d240e --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedDog.php @@ -0,0 +1,23 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ORM\Mapping as ORM; + +#[ORM\Entity] +class DoctrineDiscriminatedDog extends DoctrineDiscriminatedAnimal +{ + #[ORM\Column(type: 'boolean')] + public bool $goodBoy = true; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedShape.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedShape.php new file mode 100644 index 00000000000..3197e984d69 --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedShape.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 ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated; + +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Patch; +use ApiPlatform\Metadata\Post; +use Doctrine\ORM\Mapping as ORM; + +/** + * Class table inheritance with integer discriminator values. + */ +#[ApiResource(operations: [new Get(), new GetCollection(), new Post(), new Patch()])] +#[ORM\Entity] +#[ORM\InheritanceType('JOINED')] +#[ORM\DiscriminatorColumn(name: 'shapeType', type: 'integer')] +#[ORM\DiscriminatorMap([1 => DoctrineDiscriminatedCircle::class, 2 => DoctrineDiscriminatedSquare::class])] +abstract class DoctrineDiscriminatedShape +{ + #[ORM\Id] + #[ORM\GeneratedValue] + #[ORM\Column(type: 'integer')] + public ?int $id = null; + + #[ORM\Column] + public string $color = ''; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php new file mode 100644 index 00000000000..df93ec9801a --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSportsCar.php @@ -0,0 +1,23 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ORM\Mapping as ORM; + +#[ORM\Entity] +class DoctrineDiscriminatedSportsCar extends DoctrineDiscriminatedCar +{ + #[ORM\Column(type: 'integer')] + public int $topSpeed = 0; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSquare.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSquare.php new file mode 100644 index 00000000000..5c5546be455 --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedSquare.php @@ -0,0 +1,23 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ORM\Mapping as ORM; + +#[ORM\Entity] +class DoctrineDiscriminatedSquare extends DoctrineDiscriminatedShape +{ + #[ORM\Column(type: 'float')] + public float $side = 0.0; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php new file mode 100644 index 00000000000..4a4ed70b69b --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedTruck.php @@ -0,0 +1,26 @@ + + * + * 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\DoctrineDiscriminated; + +use Doctrine\ORM\Mapping as ORM; + +/** + * Not an API resource: exposed as a subtype of the vehicle resource. + */ +#[ORM\Entity] +class DoctrineDiscriminatedTruck extends DoctrineDiscriminatedVehicle +{ + #[ORM\Column(type: 'integer')] + public int $payload = 0; +} diff --git a/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php new file mode 100644 index 00000000000..172ac1a88ad --- /dev/null +++ b/tests/Fixtures/TestBundle/Entity/DoctrineDiscriminated/DoctrineDiscriminatedVehicle.php @@ -0,0 +1,48 @@ + + * + * 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\DoctrineDiscriminated; + +use ApiPlatform\Metadata\ApiResource; +use ApiPlatform\Metadata\Delete; +use ApiPlatform\Metadata\Get; +use ApiPlatform\Metadata\GetCollection; +use ApiPlatform\Metadata\Patch; +use ApiPlatform\Metadata\Post; +use ApiPlatform\Metadata\Put; +use Doctrine\ORM\Mapping as ORM; +use Symfony\Component\Validator\Constraints as Assert; + +/** + * Single table inheritance: the subtypes are only declared in the Doctrine discriminator map. + */ +#[ApiResource(operations: [new Get(), new GetCollection(), new Post(), new Put(), new Patch(), new Delete()])] +#[ORM\Entity] +#[ORM\InheritanceType('SINGLE_TABLE')] +#[ORM\DiscriminatorColumn(name: 'kind', type: 'string')] +#[ORM\DiscriminatorMap([ + 'car' => DoctrineDiscriminatedCar::class, + 'sportsCar' => DoctrineDiscriminatedSportsCar::class, + 'truck' => DoctrineDiscriminatedTruck::class, +])] +abstract class DoctrineDiscriminatedVehicle +{ + #[ORM\Id] + #[ORM\GeneratedValue] + #[ORM\Column(type: 'integer')] + public ?int $id = null; + + #[ORM\Column] + #[Assert\NotBlank] + public string $name = ''; +} diff --git a/tests/Functional/DoctrineDiscriminatedDocumentTest.php b/tests/Functional/DoctrineDiscriminatedDocumentTest.php new file mode 100644 index 00000000000..a0cb229c978 --- /dev/null +++ b/tests/Functional/DoctrineDiscriminatedDocumentTest.php @@ -0,0 +1,173 @@ + + * + * 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; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\Document\DoctrineDiscriminated\DoctrineDiscriminatedCar; +use ApiPlatform\Tests\Fixtures\TestBundle\Document\DoctrineDiscriminated\DoctrineDiscriminatedSportsCar; +use ApiPlatform\Tests\Fixtures\TestBundle\Document\DoctrineDiscriminated\DoctrineDiscriminatedTruck; +use ApiPlatform\Tests\Fixtures\TestBundle\Document\DoctrineDiscriminated\DoctrineDiscriminatedVehicle; +use ApiPlatform\Tests\RecreateSchemaTrait; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use Symfony\Component\Security\Core\User\InMemoryUser; + +/** + * Polymorphic resources declared through the Doctrine MongoDB ODM discriminator map only. + */ +final class DoctrineDiscriminatedDocumentTest extends ApiTestCase +{ + use RecreateSchemaTrait; + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + protected static function getKernelClass(): string + { + return DoctrineDiscriminatorMapAppKernel::class; + } + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [DoctrineDiscriminatedVehicle::class, DoctrineDiscriminatedCar::class]; + } + + protected function setUp(): void + { + if (!$this->isMongoDB()) { + $this->markTestSkipped('MongoDB ODM only, see DoctrineDiscriminatedResourceTest.'); + } + + $this->recreateSchema([ + DoctrineDiscriminatedVehicle::class, + DoctrineDiscriminatedCar::class, + DoctrineDiscriminatedSportsCar::class, + DoctrineDiscriminatedTruck::class, + ]); + + $car = new DoctrineDiscriminatedCar(); + $car->name = 'Family car'; + $car->seats = 5; + $car->vin = 'secret-vin'; + + $truck = new DoctrineDiscriminatedTruck(); + $truck->name = 'Big truck'; + $truck->payload = 20000; + + $manager = $this->getManager(); + $manager->persist($car); + $manager->persist($truck); + $manager->flush(); + $manager->clear(); + } + + public function testGetItemOfANonResourceSubtypeExposesItsProperties(): void + { + self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2'); + + $this->assertResponseIsSuccessful(); + $this->assertJsonEquals([ + '@context' => '/contexts/DoctrineDiscriminatedVehicle', + '@id' => '/doctrine_discriminated_vehicles/2', + '@type' => 'DoctrineDiscriminatedVehicle', + 'kind' => 'truck', + 'id' => 2, + 'name' => 'Big truck', + 'payload' => 20000, + ]); + } + + public function testGetItemAppliesSubtypePropertySecurity(): void + { + $client = self::createClient(); + $client->disableReboot(); + + $json = $client->request('GET', '/doctrine_discriminated_vehicles')->toArray(); + $this->assertSame('car', $json['hydra:member'][0]['kind']); + $this->assertSame(5, $json['hydra:member'][0]['seats']); + $this->assertArrayNotHasKey('vin', $json['hydra:member'][0]); + + $client->loginUser(new InMemoryUser('admin', 'password', ['ROLE_ADMIN'])); + $client->request('GET', '/doctrine_discriminated_cars/1'); + $this->assertJsonContains(['vin' => 'secret-vin']); + } + + public function testPostCreatesTheMappedSubtypes(): void + { + $client = self::createClient(); + + $client->request('POST', '/doctrine_discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Small truck', 'payload' => 3500], + ]); + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['@id' => '/doctrine_discriminated_vehicles/3', 'kind' => 'truck', 'payload' => 3500]); + + $client->request('POST', '/doctrine_discriminated_cars', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'sportsCar', 'name' => 'Roadster', 'seats' => 2, 'topSpeed' => 250], + ]); + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['@id' => '/doctrine_discriminated_cars/4', 'kind' => 'sportsCar', 'topSpeed' => 250]); + + $manager = $this->getManager(); + $manager->clear(); + $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $manager->find(DoctrineDiscriminatedVehicle::class, 3)); + $this->assertInstanceOf(DoctrineDiscriminatedSportsCar::class, $manager->find(DoctrineDiscriminatedVehicle::class, 4)); + } + + public function testPostWithoutTypeIsRejected(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['name' => 'Unknown'], + ]); + + $this->assertResponseStatusCodeSame(400); + } + + public function testPatchUpdatesSubtypeProperties(): void + { + $client = self::createClient(); + + $client->request('PATCH', '/doctrine_discriminated_vehicles/2', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['payload' => 25000], + ]); + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['kind' => 'truck', 'payload' => 25000]); + + $client->request('PATCH', '/doctrine_discriminated_vehicles/2', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['kind' => 'car', 'seats' => 3], + ]); + $this->assertResponseStatusCodeSame(400); + } + + public function testOpenApiDocumentsDoctrineSubtypes(): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + + $ref = $json['paths']['/doctrine_discriminated_vehicles/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']; + $definition = $json['components']['schemas'][substr($ref, \strlen('#/components/schemas/'))]; + $output = $definition['allOf'][1] ?? $definition; + + $this->assertSame('kind', $output['discriminator']['propertyName']); + $this->assertEqualsCanonicalizing(['car', 'sportsCar', 'truck'], array_keys($output['discriminator']['mapping'])); + } +} diff --git a/tests/Functional/DoctrineDiscriminatedResourceTest.php b/tests/Functional/DoctrineDiscriminatedResourceTest.php new file mode 100644 index 00000000000..f6b2d719def --- /dev/null +++ b/tests/Functional/DoctrineDiscriminatedResourceTest.php @@ -0,0 +1,468 @@ + + * + * 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; + +use ApiPlatform\Test\ApiTestCase; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedAnimal; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedCar; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedCat; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedCircle; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedDog; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedShape; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedSportsCar; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedSquare; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedTruck; +use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedVehicle; +use ApiPlatform\Tests\RecreateSchemaTrait; +use ApiPlatform\Tests\SetupClassResourcesTrait; +use Symfony\Component\Security\Core\User\InMemoryUser; + +/** + * Polymorphic resources declared through the Doctrine ORM discriminator map only. + */ +final class DoctrineDiscriminatedResourceTest extends ApiTestCase +{ + use RecreateSchemaTrait; + use SetupClassResourcesTrait; + + protected static ?bool $alwaysBootKernel = false; + + protected static function getKernelClass(): string + { + return DoctrineDiscriminatorMapAppKernel::class; + } + + /** + * @return class-string[] + */ + public static function getResources(): array + { + return [ + DoctrineDiscriminatedVehicle::class, + DoctrineDiscriminatedCar::class, + DoctrineDiscriminatedShape::class, + DoctrineDiscriminatedAnimal::class, + ]; + } + + protected function setUp(): void + { + if ($this->isMongoDB()) { + $this->markTestSkipped('ORM only, see DoctrineDiscriminatedDocumentTest.'); + } + + $this->recreateSchema([ + DoctrineDiscriminatedVehicle::class, + DoctrineDiscriminatedCar::class, + DoctrineDiscriminatedSportsCar::class, + DoctrineDiscriminatedTruck::class, + DoctrineDiscriminatedShape::class, + DoctrineDiscriminatedCircle::class, + DoctrineDiscriminatedSquare::class, + DoctrineDiscriminatedAnimal::class, + DoctrineDiscriminatedDog::class, + DoctrineDiscriminatedCat::class, + ]); + + $car = new DoctrineDiscriminatedCar(); + $car->name = 'Family car'; + $car->seats = 5; + $car->vin = 'secret-vin'; + + $truck = new DoctrineDiscriminatedTruck(); + $truck->name = 'Big truck'; + $truck->payload = 20000; + + $sportsCar = new DoctrineDiscriminatedSportsCar(); + $sportsCar->name = 'Fast car'; + $sportsCar->seats = 2; + $sportsCar->topSpeed = 320; + + $circle = new DoctrineDiscriminatedCircle(); + $circle->color = 'red'; + $circle->radius = 2.5; + + $dog = new DoctrineDiscriminatedDog(); + $dog->name = 'Rex'; + + $manager = $this->getManager(); + foreach ([$car, $truck, $sportsCar, $circle, $dog] as $entity) { + $manager->persist($entity); + } + $manager->flush(); + $manager->clear(); + } + + public function testGetItemOfANonResourceSubtypeExposesItsProperties(): void + { + self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2'); + + $this->assertResponseIsSuccessful(); + $this->assertJsonEquals([ + '@context' => '/contexts/DoctrineDiscriminatedVehicle', + '@id' => '/doctrine_discriminated_vehicles/2', + '@type' => 'DoctrineDiscriminatedVehicle', + 'kind' => 'truck', + 'id' => 2, + 'name' => 'Big truck', + 'payload' => 20000, + ]); + } + + public function testGetItemOfAResourceSubtypeUsesItsOwnResource(): void + { + self::createClient()->request('GET', '/doctrine_discriminated_cars/3'); + + $this->assertResponseIsSuccessful(); + $this->assertJsonEquals([ + '@context' => '/contexts/DoctrineDiscriminatedCar', + '@id' => '/doctrine_discriminated_cars/3', + '@type' => 'DoctrineDiscriminatedCar', + 'kind' => 'sportsCar', + 'id' => 3, + 'name' => 'Fast car', + 'seats' => 2, + 'topSpeed' => 320, + ]); + } + + public function testGetItemAppliesSubtypePropertySecurity(): void + { + $client = self::createClient(); + $client->disableReboot(); + + $client->request('GET', '/doctrine_discriminated_cars/1'); + $this->assertResponseIsSuccessful(); + $this->assertJsonEquals([ + '@context' => '/contexts/DoctrineDiscriminatedCar', + '@id' => '/doctrine_discriminated_cars/1', + '@type' => 'DoctrineDiscriminatedCar', + 'kind' => 'car', + 'id' => 1, + 'name' => 'Family car', + 'seats' => 5, + ]); + + $client->loginUser(new InMemoryUser('admin', 'password', ['ROLE_ADMIN'])); + $client->request('GET', '/doctrine_discriminated_cars/1'); + $this->assertJsonContains(['vin' => 'secret-vin']); + } + + public function testGetCollectionExposesEachSubtype(): void + { + $response = self::createClient()->request('GET', '/doctrine_discriminated_vehicles'); + + $this->assertResponseIsSuccessful(); + $members = $response->toArray()['hydra:member']; + $this->assertCount(3, $members); + + $this->assertSame('/doctrine_discriminated_cars/1', $members[0]['@id']); + $this->assertSame('car', $members[0]['kind']); + $this->assertSame(5, $members[0]['seats']); + $this->assertArrayNotHasKey('vin', $members[0]); + + $this->assertSame('/doctrine_discriminated_vehicles/2', $members[1]['@id']); + $this->assertSame('truck', $members[1]['kind']); + $this->assertSame(20000, $members[1]['payload']); + $this->assertArrayNotHasKey('seats', $members[1]); + + $this->assertSame('/doctrine_discriminated_cars/3', $members[2]['@id']); + $this->assertSame('sportsCar', $members[2]['kind']); + $this->assertSame(320, $members[2]['topSpeed']); + } + + public function testGetItemInJsonApi(): void + { + $response = self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2', ['headers' => ['Accept' => 'application/vnd.api+json']]); + + $this->assertResponseIsSuccessful(); + $attributes = $response->toArray()['data']['attributes']; + $this->assertSame('truck', $attributes['kind']); + $this->assertSame(20000, $attributes['payload']); + } + + public function testGetItemInHal(): void + { + $response = self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2', ['headers' => ['Accept' => 'application/hal+json']]); + + $this->assertResponseIsSuccessful(); + $data = $response->toArray(); + $this->assertSame('/doctrine_discriminated_vehicles/2', $data['_links']['self']['href']); + $this->assertSame('truck', $data['kind']); + $this->assertSame(20000, $data['payload']); + } + + public function testPostCreatesANonResourceSubtype(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Small truck', 'payload' => 3500], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonEquals([ + '@context' => '/contexts/DoctrineDiscriminatedVehicle', + '@id' => '/doctrine_discriminated_vehicles/4', + '@type' => 'DoctrineDiscriminatedVehicle', + 'kind' => 'truck', + 'id' => 4, + 'name' => 'Small truck', + 'payload' => 3500, + ]); + + $truck = $this->findVehicle(4); + $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $truck); + $this->assertSame(3500, $truck->payload); + } + + public function testPostCreatesAResourceSubtypeThroughTheParentResource(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'car', 'name' => 'Van', 'seats' => 8, 'vin' => 'cannot be written anonymously'], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['@id' => '/doctrine_discriminated_cars/4', 'kind' => 'car', 'seats' => 8]); + + $car = $this->findVehicle(4); + $this->assertInstanceOf(DoctrineDiscriminatedCar::class, $car); + $this->assertNotInstanceOf(DoctrineDiscriminatedSportsCar::class, $car); + $this->assertNull($car->vin); + } + + public function testPostCreatesAGrandchildThroughAnIntermediateResource(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_cars', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'sportsCar', 'name' => 'Roadster', 'seats' => 2, 'topSpeed' => 250], + ]); + + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['@id' => '/doctrine_discriminated_cars/4', 'kind' => 'sportsCar', 'topSpeed' => 250]); + $this->assertInstanceOf(DoctrineDiscriminatedSportsCar::class, $this->findVehicle(4)); + } + + public function testPostOnAConcreteIntermediateResourceDefaultsToItself(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_cars', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'car', 'name' => 'Hatchback', 'seats' => 4], + ]); + + $this->assertResponseStatusCodeSame(201); + $car = $this->findVehicle(4); + $this->assertInstanceOf(DoctrineDiscriminatedCar::class, $car); + $this->assertNotInstanceOf(DoctrineDiscriminatedSportsCar::class, $car); + } + + public function testPostOnAnIntermediateResourceRejectsSiblingTypes(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_cars', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Not a car', 'payload' => 1], + ]); + + $this->assertResponseStatusCodeSame(400); + } + + public function testPostWithoutTypeIsRejected(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['name' => 'Unknown'], + ]); + + $this->assertResponseStatusCodeSame(400); + } + + public function testPostValidatesSubtypeConstraints(): void + { + self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'car', 'name' => 'Broken', 'seats' => 0], + ]); + + $this->assertResponseStatusCodeSame(422); + $this->assertJsonContains(['violations' => [['propertyPath' => 'seats']]]); + } + + public function testPatchUpdatesSubtypeProperties(): void + { + self::createClient()->request('PATCH', '/doctrine_discriminated_vehicles/2', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['payload' => 25000], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['kind' => 'truck', 'name' => 'Big truck', 'payload' => 25000]); + $truck = $this->findVehicle(2); + $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $truck); + $this->assertSame(25000, $truck->payload); + } + + public function testPatchCannotChangeTheType(): void + { + self::createClient()->request('PATCH', '/doctrine_discriminated_vehicles/2', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['kind' => 'car', 'seats' => 3], + ]); + + $this->assertResponseStatusCodeSame(400); + $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $this->findVehicle(2)); + } + + public function testPutReplacesSubtypeProperties(): void + { + self::createClient()->request('PUT', '/doctrine_discriminated_vehicles/2', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Renamed truck', 'payload' => 1000], + ]); + + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['kind' => 'truck', 'name' => 'Renamed truck', 'payload' => 1000]); + + $truck = $this->findVehicle(2); + $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $truck); + $this->assertSame('Renamed truck', $truck->name); + } + + public function testDelete(): void + { + self::createClient()->request('DELETE', '/doctrine_discriminated_vehicles/2'); + + $this->assertResponseStatusCodeSame(204); + $this->assertNull($this->findVehicle(2)); + } + + public function testJoinedInheritanceWithIntegerDiscriminatorValues(): void + { + $client = self::createClient(); + + $client->request('GET', '/doctrine_discriminated_shapes/1'); + $this->assertResponseIsSuccessful(); + $this->assertJsonEquals([ + '@context' => '/contexts/DoctrineDiscriminatedShape', + '@id' => '/doctrine_discriminated_shapes/1', + '@type' => 'DoctrineDiscriminatedShape', + 'shapeType' => '1', + 'id' => 1, + 'color' => 'red', + 'radius' => 2.5, + ]); + + $client->request('POST', '/doctrine_discriminated_shapes', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['shapeType' => '2', 'color' => 'blue', 'side' => 3], + ]); + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['shapeType' => '2', 'side' => 3]); + $this->assertInstanceOf(DoctrineDiscriminatedSquare::class, $this->getManager()->find(DoctrineDiscriminatedShape::class, 2)); + + $client->request('PATCH', '/doctrine_discriminated_shapes/1', [ + 'headers' => ['Content-Type' => 'application/merge-patch+json'], + 'json' => ['radius' => 4], + ]); + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['shapeType' => '1', 'radius' => 4]); + } + + public function testSerializerDiscriminatorMapTakesPrecedence(): void + { + $client = self::createClient(); + + $client->request('GET', '/doctrine_discriminated_animals/1'); + $this->assertResponseIsSuccessful(); + $this->assertJsonEquals([ + '@context' => '/contexts/DoctrineDiscriminatedAnimal', + '@id' => '/doctrine_discriminated_animals/1', + '@type' => 'DoctrineDiscriminatedAnimal', + 'species' => 'canine', + 'id' => 1, + 'name' => 'Rex', + 'goodBoy' => true, + ]); + + // Only the subtypes of the serializer map can be created. + $client->request('POST', '/doctrine_discriminated_animals', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['species' => 'cat', 'name' => 'Tom', 'lives' => 7], + ]); + $this->assertResponseStatusCodeSame(400); + $client->request('POST', '/doctrine_discriminated_animals', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['discr' => 'cat', 'name' => 'Tom', 'lives' => 7], + ]); + $this->assertResponseStatusCodeSame(400); + } + + public function testOpenApiDocumentsDoctrineSubtypes(): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + $schemas = $json['components']['schemas']; + + $output = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_vehicles/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); + $this->assertSame('kind', $output['discriminator']['propertyName']); + $this->assertEqualsCanonicalizing([ + 'car' => '#/components/schemas/DoctrineDiscriminatedVehicle.DoctrineDiscriminatedCar.jsonld', + 'sportsCar' => '#/components/schemas/DoctrineDiscriminatedVehicle.DoctrineDiscriminatedSportsCar.jsonld', + 'truck' => '#/components/schemas/DoctrineDiscriminatedVehicle.DoctrineDiscriminatedTruck.jsonld', + ], $output['discriminator']['mapping']); + $this->assertSame(['type' => 'string', 'enum' => ['truck']], $schemas['DoctrineDiscriminatedVehicle.DoctrineDiscriminatedTruck.jsonld']['properties']['kind']); + $this->assertArrayHasKey('payload', $schemas['DoctrineDiscriminatedVehicle.DoctrineDiscriminatedTruck.jsonld']['properties']); + + $input = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_vehicles']['post']['requestBody']['content']['application/ld+json']['schema']['$ref']); + $this->assertSame('kind', $input['discriminator']['propertyName']); + $this->assertArrayHasKey('truck', $input['discriminator']['mapping']); + + $shape = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_shapes/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); + $this->assertSame('shapeType', $shape['discriminator']['propertyName']); + $this->assertEqualsCanonicalizing(['1', '2'], array_map('strval', array_keys($shape['discriminator']['mapping']))); + + $animal = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_animals/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); + $this->assertSame([ + 'propertyName' => 'species', + 'mapping' => ['canine' => '#/components/schemas/DoctrineDiscriminatedAnimal.DoctrineDiscriminatedDog.jsonld'], + ], $animal['discriminator']); + } + + private function findVehicle(int $id): ?DoctrineDiscriminatedVehicle + { + $manager = $this->getManager(); + $manager->clear(); + + return $manager->find(DoctrineDiscriminatedVehicle::class, $id); + } + + /** + * @param array> $schemas + * + * @return array + */ + private function findDefinition(array $schemas, string $ref): array + { + $definition = $schemas[substr($ref, \strlen('#/components/schemas/'))]; + + // JSON-LD output wraps the definition in an allOf with the hydra base schema. + foreach ($definition['allOf'] ?? [] as $part) { + if (isset($part['discriminator'])) { + return $part; + } + } + + return $definition; + } +} diff --git a/tests/Functional/DoctrineDiscriminatorMapAppKernel.php b/tests/Functional/DoctrineDiscriminatorMapAppKernel.php new file mode 100644 index 00000000000..e7d1315c029 --- /dev/null +++ b/tests/Functional/DoctrineDiscriminatorMapAppKernel.php @@ -0,0 +1,45 @@ + + * + * 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; + +use Symfony\Component\Config\Loader\LoaderInterface; +use Symfony\Component\DependencyInjection\ContainerBuilder; + +/** + * Enables the (opt-in) Doctrine discriminator maps of the active Doctrine integration. + */ +class DoctrineDiscriminatorMapAppKernel extends \AppKernel +{ + public function getCacheDir(): string + { + return parent::getCacheDir().'/doctrine_discriminator_map'; + } + + public function getLogDir(): string + { + return parent::getLogDir().'/doctrine_discriminator_map'; + } + + protected function configureContainer(ContainerBuilder $c, LoaderInterface $loader): void + { + parent::configureContainer($c, $loader); + + $integration = 'mongodb' === $this->environment ? 'doctrine_mongodb_odm' : 'doctrine'; + $loader->load(static function (ContainerBuilder $container) use ($integration): void { + $container->loadFromExtension('api_platform', [ + $integration => ['discriminator_map' => true], + ]); + }); + } +} diff --git a/tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php b/tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php new file mode 100644 index 00000000000..efa01c72a23 --- /dev/null +++ b/tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php @@ -0,0 +1,64 @@ + + * + * 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\Symfony\Bundle\DependencyInjection\Compiler; + +use ApiPlatform\Doctrine\Common\Serializer\Mapping\Loader\DoctrineDiscriminatorMappingLoader; +use ApiPlatform\Serializer\Mapping\Loader\PropertyMetadataLoader; +use ApiPlatform\Symfony\Bundle\DependencyInjection\Compiler\SerializerMappingLoaderPass; +use PHPUnit\Framework\TestCase; +use Symfony\Component\DependencyInjection\ContainerBuilder; +use Symfony\Component\DependencyInjection\Definition; +use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader; + +final class SerializerMappingLoaderPassTest extends TestCase +{ + public function testDoctrineDiscriminatorMappingLoadersAreAppendedAfterTheOtherLoaders(): void + { + $container = $this->createContainer(); + $orm = $container->register('api_platform.doctrine.orm.serializer.discriminator_mapping_loader', DoctrineDiscriminatorMappingLoader::class); + $odm = $container->register('api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader', DoctrineDiscriminatorMappingLoader::class); + + (new SerializerMappingLoaderPass())->process($container); + + $chainLoaders = $container->getDefinition('serializer.mapping.chain_loader')->getArgument(0); + $this->assertCount(3, $chainLoaders); + $this->assertSame([$orm, $odm], \array_slice($chainLoaders, 1)); + + $warmerLoaders = $container->getDefinition('serializer.mapping.cache_warmer')->getArgument(0); + $this->assertCount(4, $warmerLoaders); + $this->assertSame(PropertyMetadataLoader::class, $warmerLoaders[1]->getClass()); + $this->assertSame([$orm, $odm], \array_slice($warmerLoaders, 2)); + } + + public function testChainLoaderIsUntouchedWithoutDoctrineDiscriminatorMappingLoader(): void + { + $container = $this->createContainer(); + + (new SerializerMappingLoaderPass())->process($container); + + $this->assertCount(1, $container->getDefinition('serializer.mapping.chain_loader')->getArgument(0)); + $this->assertCount(2, $container->getDefinition('serializer.mapping.cache_warmer')->getArgument(0)); + } + + private function createContainer(): ContainerBuilder + { + $container = new ContainerBuilder(); + $attributeLoader = new Definition(AttributeLoader::class); + $container->register('serializer.mapping.chain_loader')->setArguments([[$attributeLoader]]); + $container->register('serializer.mapping.cache_warmer')->setArguments([[], '%kernel.cache_dir%/serializer.php']); + $container->register('api_platform.serializer.property_metadata_loader', PropertyMetadataLoader::class); + + return $container; + } +} diff --git a/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php b/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php index 8da7010b910..6f34daef554 100644 --- a/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php +++ b/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php @@ -200,9 +200,11 @@ private function runDefaultConfigTests(array $doctrineIntegrationsToLoad = ['orm ], 'doctrine' => [ 'enabled' => \in_array('orm', $doctrineIntegrationsToLoad, true), + 'discriminator_map' => false, ], 'doctrine_mongodb_odm' => [ 'enabled' => \in_array('odm', $doctrineIntegrationsToLoad, true), + 'discriminator_map' => false, ], 'messenger' => [ 'enabled' => true, From e210d79f01cad54e3738455d6e00fb69d18726d6 Mon Sep 17 00:00:00 2001 From: Dylan van der Hout Date: Thu, 29 Oct 2026 17:14:43 +0100 Subject: [PATCH 3/4] fix(jsonschema): only list subtypes in the oneOf of a discriminated parent schema Every oneOf branch already carries the common properties, repeating them next to oneOf made Swagger UI display them twice. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/JsonApi/JsonSchema/SchemaFactory.php | 43 ++++++++++-------- src/JsonSchema/SchemaFactory.php | 13 ++---- src/JsonSchema/Tests/SchemaFactoryTest.php | 4 +- .../DiscriminatedResourceOverrideTest.php | 2 - .../Functional/DiscriminatedResourceTest.php | 45 +++++++++++++++++-- 5 files changed, 73 insertions(+), 34 deletions(-) diff --git a/src/JsonApi/JsonSchema/SchemaFactory.php b/src/JsonApi/JsonSchema/SchemaFactory.php index f13711510c8..eca9c9ecd87 100644 --- a/src/JsonApi/JsonSchema/SchemaFactory.php +++ b/src/JsonApi/JsonSchema/SchemaFactory.php @@ -293,7 +293,15 @@ private function buildDefinitionPropertiesSchema(string $key, string $documentDe // Capture the resource's operation up front; the relationship loop below reassigns $operation. $resourceOperation = $operation; $definitions = $schema->getDefinitions(); - $properties = $definitions[$key]['properties'] ?? []; + // A definition listing its subtypes in "oneOf" carries no properties: an instance of the class itself is described by its inline branch + $ownBranch = null; + foreach (isset($definitions[$key]['discriminator']) ? $definitions[$key]['oneOf'] ?? [] : [] as $branch) { + if (!isset($branch['$ref'])) { + $ownBranch = $branch; + break; + } + } + $properties = $ownBranch['properties'] ?? $definitions[$key]['properties'] ?? []; $attributes = []; $relationships = []; @@ -392,34 +400,33 @@ private function buildDefinitionPropertiesSchema(string $key, string $documentDe ]; // Subtypes declared in a serializer discriminator map: the type property lives in "attributes" so an OpenAPI discriminator cannot be used - $typeProperty = null; + $oneOf = []; foreach ($this->getDiscriminatedSubtypes($key, $propertyClass, $definitions, $schema->getVersion()) as [$subKey, $subClass, $typeProperty]) { + $attributeName = ReservedAttributeNameConverter::getReservedAttributes($this->strictMemberNames)[$typeProperty] ?? $typeProperty; + + // The inline branch of a class declared in its own discriminator map describes the instances of the class itself + if (!$oneOf && null !== $ownBranch) { + if (\in_array($typeProperty, $ownBranch['required'] ?? [], true)) { + $data['properties']['attributes']['required'] = [$attributeName]; + } + $oneOf[] = $data; + } + $subDocumentDefinitionName = $documentDefinitionName.'.'.(new \ReflectionClass($subClass))->getShortName(); $subSchema = $this->buildDefinitionPropertiesSchema($subKey, $subDocumentDefinitionName, $subClass, $format, $type, $resourceOperation, $schema, $serializerContext); if (\in_array($typeProperty, $definitions[$subKey]['required'] ?? [], true)) { - $definitions[$subDocumentDefinitionName.'.resource']['properties']['attributes']['required'] = [ReservedAttributeNameConverter::getReservedAttributes($this->strictMemberNames)[$typeProperty] ?? $typeProperty]; + $definitions[$subDocumentDefinitionName.'.resource']['properties']['attributes']['required'] = [$attributeName]; } - $data['oneOf'][] = $subSchema['data']; + $oneOf[] = $subSchema['data']; foreach ($subSchema['included']['items']['anyOf'] ?? [] as $relatedDefinition) { $relatedDefinitions[$relatedDefinition['$ref']] = $relatedDefinition; } } - // The inline "oneOf" branch of a class declared in its own discriminator map describes the instances of the class itself - foreach (null !== $typeProperty ? $definitions[$key]['oneOf'] : [] as $branch) { - if (isset($branch['$ref']) || !isset($branch['properties'][$typeProperty])) { - continue; - } - - $attributeName = ReservedAttributeNameConverter::getReservedAttributes($this->strictMemberNames)[$typeProperty] ?? $typeProperty; - $ownData = $data; - unset($ownData['oneOf']); - $ownData['properties']['attributes']['properties'][$attributeName] = $branch['properties'][$typeProperty]; - if (\in_array($typeProperty, $branch['required'] ?? [], true)) { - $ownData['properties']['attributes']['required'] = [$attributeName]; - } - array_unshift($data['oneOf'], $ownData); + // Every branch carries the common members: they are not repeated next to "oneOf" + if ($oneOf) { + $data = ['type' => 'object', 'oneOf' => $oneOf]; } if ($relatedDefinitions && !$included) { diff --git a/src/JsonSchema/SchemaFactory.php b/src/JsonSchema/SchemaFactory.php index 596a81d59f6..359cee07c39 100644 --- a/src/JsonSchema/SchemaFactory.php +++ b/src/JsonSchema/SchemaFactory.php @@ -254,19 +254,14 @@ private function buildDiscriminatedDefinitions(Schema $schema, \ArrayObject $def $definition['oneOf'] = $oneOf; + // Every branch carries the common properties: they are not repeated next to "oneOf" // "additionalProperties" ignores the properties declared in the "oneOf" branches, they are restricted by the branches instead - unset($definition['additionalProperties']); + unset($definition['properties'], $definition['required'], $definition['additionalProperties']); } // An instance of the class itself carries its own type - if ($ownTypeValues && !isset($definition['properties'][$typeProperty])) { - if ($oneOf) { - $properties = $definition['properties'] ?? []; - $properties[$typeProperty] = ['type' => 'string', 'enum' => array_map('strval', array_keys($discriminatorMapping))]; - $definition['properties'] = $properties; - } else { - $this->addTypeProperties($definition, [$typeProperty => ['type' => 'string', 'enum' => $ownTypeValues]], $isPartialUpdate || \in_array($mapping->getDefaultType(), $ownTypeValues, true)); - } + if ($ownTypeValues && !$oneOf && !isset($definition['properties'][$typeProperty])) { + $this->addTypeProperties($definition, [$typeProperty => ['type' => 'string', 'enum' => $ownTypeValues]], $isPartialUpdate || \in_array($mapping->getDefaultType(), $ownTypeValues, true)); } $definition['discriminator'] = ['propertyName' => $typeProperty, 'mapping' => $discriminatorMapping]; diff --git a/src/JsonSchema/Tests/SchemaFactoryTest.php b/src/JsonSchema/Tests/SchemaFactoryTest.php index fd23c2f5d6a..7cba5c919e1 100644 --- a/src/JsonSchema/Tests/SchemaFactoryTest.php +++ b/src/JsonSchema/Tests/SchemaFactoryTest.php @@ -499,7 +499,7 @@ public function testBuildSchemaDocumentsDiscriminatorMapSubtypes(): void $definitions = $schema->getDefinitions(); $base = $definitions['DiscriminatedAnimal']; - $this->assertSame(['name'], array_keys($base['properties'])); + $this->assertArrayNotHasKey('properties', $base); $this->assertSame([ ['$ref' => '#/components/schemas/DiscriminatedAnimal.DiscriminatedCat'], ['$ref' => '#/components/schemas/DiscriminatedAnimal.DiscriminatedDog'], @@ -531,7 +531,7 @@ public function testBuildSchemaDocumentsClassDeclaredInItsOwnDiscriminatorMap(): $rootDefinitionKey = $schema->getRootDefinitionKey(); $base = $definitions[$rootDefinitionKey]; - $this->assertSame(['type' => 'string', 'enum' => ['phone', 'gadget']], $base['properties']['kind']); + $this->assertArrayNotHasKey('properties', $base); $this->assertArrayNotHasKey('additionalProperties', $base); $this->assertSame([ 'type' => 'object', diff --git a/tests/Functional/DiscriminatedResourceOverrideTest.php b/tests/Functional/DiscriminatedResourceOverrideTest.php index 000c6877320..e5b026af82f 100644 --- a/tests/Functional/DiscriminatedResourceOverrideTest.php +++ b/tests/Functional/DiscriminatedResourceOverrideTest.php @@ -252,7 +252,6 @@ public function testSchemaDocumentsCovariantReturnTypes(): void $this->assertSame('integer', $schemas['DiscriminatedVehicle.DiscriminatedTruck.jsonld']['properties']['rating']['type']); $this->assertSame([['type' => 'number'], ['type' => 'integer']], $schemas['DiscriminatedVehicle.DiscriminatedCar.jsonld']['properties']['rating']['anyOf']); - $this->assertSame([['type' => 'number'], ['type' => 'integer']], $schemas['DiscriminatedVehicle.jsonld']['allOf'][1]['properties']['rating']['anyOf']); } public function testSchemaDocumentsOverriddenProperties(): void @@ -265,7 +264,6 @@ public function testSchemaDocumentsOverriddenProperties(): void // Overridden writability: "plate" is read-only on cars, but still writable on trucks. $this->assertTrue($schemas['DiscriminatedVehicle.DiscriminatedCar']['properties']['plate']['readOnly']); $this->assertArrayNotHasKey('readOnly', $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']['plate']); - $this->assertArrayNotHasKey('readOnly', $schemas['DiscriminatedVehicle']['properties']['plate']); $this->assertArrayHasKey('payload', $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']); // Overridden constraints are documented on the subtype only. diff --git a/tests/Functional/DiscriminatedResourceTest.php b/tests/Functional/DiscriminatedResourceTest.php index 083a497b436..73358d79779 100644 --- a/tests/Functional/DiscriminatedResourceTest.php +++ b/tests/Functional/DiscriminatedResourceTest.php @@ -418,7 +418,7 @@ public function testOpenApiDocumentsSubtypes(): void ])->toArray(); $schemas = $json['components']['schemas']; - // Output (JSON-LD): the base definition keeps its own properties and lists its subtypes. + // Output (JSON-LD): the base definition only lists its subtypes, each of them carrying the common properties. $output = $this->findDefinition($schemas, $json['paths']['/discriminated_books/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); $this->assertSame([ 'propertyName' => 'kind', @@ -431,8 +431,7 @@ public function testOpenApiDocumentsSubtypes(): void ['$ref' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook.jsonld'], ['$ref' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook.jsonld'], ], $output['oneOf']); - $this->assertArrayHasKey('title', $output['properties']); - $this->assertArrayNotHasKey('genre', $output['properties']); + $this->assertArrayNotHasKey('properties', $output); $fiction = $schemas['DiscriminatedBook.DiscriminatedFictionBook.jsonld']; $this->assertSame(['type' => 'string', 'enum' => ['fiction']], $fiction['properties']['kind']); @@ -488,6 +487,46 @@ public function testOpenApiDocumentsSubtypes(): void /** * Resolves a definition, unwrapping the Hydra item decoration if any. */ + public static function parentSchemaProvider(): iterable + { + yield 'output json' => ['/discriminated_books/{id}', 'get', 'application/json']; + yield 'output jsonld' => ['/discriminated_books/{id}', 'get', 'application/ld+json']; + yield 'input json' => ['/discriminated_books', 'post', 'application/json']; + yield 'input jsonld' => ['/discriminated_books', 'post', 'application/ld+json']; + yield 'input merge-patch' => ['/discriminated_books/{id}', 'patch', 'application/merge-patch+json']; + yield 'output jsonapi' => ['/discriminated_books/{id}', 'get', 'application/vnd.api+json']; + } + + /** + * Every "oneOf" branch is a complete description of a subtype: repeating the common properties + * next to "oneOf" makes Swagger UI display them twice. + */ + #[DataProvider('parentSchemaProvider')] + public function testOpenApiParentSchemaOnlyListsItsSubtypes(string $path, string $method, string $mimeType): void + { + $json = self::createClient()->request('GET', '/docs', [ + 'headers' => ['Accept' => 'application/vnd.openapi+json'], + ])->toArray(); + $schemas = $json['components']['schemas']; + + $operation = $json['paths'][$path][$method]; + $ref = 'get' === $method ? $operation['responses']['200']['content'][$mimeType]['schema']['$ref'] : $operation['requestBody']['content'][$mimeType]['schema']['$ref']; + $parent = $this->findDefinition($schemas, $ref); + if ('application/vnd.api+json' === $mimeType) { + $parent = $this->findDefinition($schemas, $parent['properties']['data']['$ref']); + } + + $this->assertCount(2, $parent['oneOf']); + $this->assertArrayNotHasKey('properties', $parent); + $this->assertArrayNotHasKey('required', $parent); + + foreach ($parent['oneOf'] as $branch) { + $branch = $this->findDefinition($schemas, $branch['$ref']); + $properties = 'application/vnd.api+json' === $mimeType ? $branch['properties']['attributes']['properties'] : $branch['properties']; + $this->assertArrayHasKey('title', $properties); + } + } + private function findDefinition(array $schemas, string $ref): array { $definition = $schemas[substr($ref, \strlen('#/components/schemas/'))]; From 0bbdbfe6909e7d025791a668ed3ba7edef53f21e Mon Sep 17 00:00:00 2001 From: Dylan van der Hout Date: Mon, 9 Nov 2026 15:13:18 +0100 Subject: [PATCH 4/4] feat(serializer): gate resource polymorphism behind serializer.discriminator_map - add the opt-in `serializer.discriminator_map` flag (Laravel: `api-platform.serializer.discriminator_map`), implied by the Doctrine flags - expose subtypes in Hydra/JSON-LD: most specific `@type`, subtype terms in the context, `subClassOf` classes in /docs.jsonld - only emit the `discriminator` keyword in OpenAPI schemas - let serializer maps declared with any loader take precedence over Doctrine maps - memoize the discriminator resolution in AbstractItemNormalizer - reject type changes on nested maps listing their own class - replace Prophecy with PHPUnit stubs, consolidate fixtures and functional tests Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- CHANGELOG.md | 1 + .../DoctrineDiscriminatorMappingLoader.php | 25 +- ...DoctrineDiscriminatorMappingLoaderTest.php | 43 +- .../Serializer/DocumentationNormalizer.php | 94 ++- .../DocumentationNormalizerTest.php | 79 +++ src/JsonApi/JsonSchema/SchemaFactory.php | 58 +- src/JsonLd/ContextBuilder.php | 71 ++- src/JsonLd/Serializer/ItemNormalizer.php | 10 +- src/JsonSchema/SchemaFactory.php | 7 +- src/JsonSchema/Tests/SchemaFactoryTest.php | 47 +- src/Laravel/ApiPlatformProvider.php | 18 +- src/Laravel/config/api-platform.php | 2 + .../Util/ClassDiscriminatorHelper.php | 8 + src/Serializer/AbstractItemNormalizer.php | 104 +++- .../ApiPlatformExtension.php | 16 +- .../Compiler/SerializerMappingLoaderPass.php | 11 +- .../DependencyInjection/Configuration.php | 1 + src/Symfony/Bundle/Resources/config/api.php | 4 +- src/Symfony/Bundle/Resources/config/hal.php | 2 +- src/Symfony/Bundle/Resources/config/hydra.php | 1 + .../Bundle/Resources/config/json_schema.php | 2 +- .../Bundle/Resources/config/jsonapi.php | 6 +- .../Bundle/Resources/config/jsonld.php | 1 + .../ApiPlatformExtensionTest.php | 21 + ...inatedPetCat.php => DiscriminatedBike.php} | 10 +- .../DiscriminatedBook.php | 81 --- .../DiscriminatedBookStore.php | 22 - .../DiscriminatedFictionBook.php | 26 - .../DiscriminatedGadget.php | 70 --- .../DiscriminatedGadgetStore.php | 22 - ...eCat.php => DiscriminatedMountainBike.php} | 4 +- .../DiscriminatedPersianCat.php | 19 - .../DiscriminatedPet.php | 71 --- .../DiscriminatedPetDog.php | 19 - .../DiscriminatedPetStore.php | 22 - .../DiscriminatedPhone.php | 19 - .../DiscriminatedSignedFictionBook.php | 22 - .../DiscriminatedTechnicalBook.php | 24 - .../DiscriminatedTruck.php | 5 - .../DiscriminatedVehicle.php | 9 +- .../UndiscriminatedBook.php | 43 -- .../UndiscriminatedSecretBook.php | 19 - tests/Fixtures/app/config/config_common.yml | 2 + .../DiscriminatedNestedResourceTest.php | 231 ------- .../DiscriminatedResourceOverrideTest.php | 277 --------- .../Functional/DiscriminatedResourceTest.php | 583 ++++++------------ .../DiscriminatedSelfMappedResourceTest.php | 193 ------ .../DoctrineDiscriminatedDocumentTest.php | 78 +-- .../DoctrineDiscriminatedResourceTest.php | 299 +-------- .../SerializerMappingLoaderPassTest.php | 12 +- .../DependencyInjection/ConfigurationTest.php | 1 + 51 files changed, 764 insertions(+), 2051 deletions(-) rename tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/{DiscriminatedPetCat.php => DiscriminatedBike.php} (63%) delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php rename tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/{DiscriminatedSiameseCat.php => DiscriminatedMountainBike.php} (77%) delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php delete mode 100644 tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php delete mode 100644 tests/Functional/DiscriminatedNestedResourceTest.php delete mode 100644 tests/Functional/DiscriminatedResourceOverrideTest.php delete mode 100644 tests/Functional/DiscriminatedSelfMappedResourceTest.php diff --git a/CHANGELOG.md b/CHANGELOG.md index 4debc273dda..1dc96afd6a8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ API Platform 5.1 contains every change shipped in the v5.0.x releases, plus the * JSON:API: a `PATCH` or `PUT` whose `data.id` does not match the endpoint now returns `409 Conflict`, as the specification requires; it used to be applied to the endpoint's resource ([#8752](https://github.com/api-platform/core/pull/8752)). With `jsonapi.strict_resource_type` enabled, a mismatched `data.type` also returns `409` on `PATCH` and `PUT`, not only on `POST`. * JSON:API: `jsonapi.strict_member_names` (off by default) exposes the `id` and `type` properties as `resourceId` and `resourceType` attributes instead of `_id` and `_type`, which are not valid member names, and stops renaming `links`, `relationships` and `included` ([#8752](https://github.com/api-platform/core/pull/8752)). +* Resource polymorphism: resources whose class declares a serializer `#[DiscriminatorMap]` (or a Doctrine discriminator map with `doctrine.discriminator_map` / `doctrine_mongodb_odm.discriminator_map`) expose, validate and document their subtypes when `serializer.discriminator_map` is enabled (Laravel: `api-platform.serializer.discriminator_map`). It is off by default, as it changes the JSON-LD `@type`, the JSON Schemas and the denormalization of these resources ([#8620](https://github.com/api-platform/core/pull/8620)). ### Breaking changes diff --git a/src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php b/src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php index f8391289790..b7b0a95a0ad 100644 --- a/src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php +++ b/src/Doctrine/Common/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoader.php @@ -17,6 +17,7 @@ use Doctrine\Persistence\ManagerRegistry; use Symfony\Component\Serializer\Attribute\DiscriminatorMap; use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; +use Symfony\Component\Serializer\Mapping\ClassMetadata; use Symfony\Component\Serializer\Mapping\ClassMetadataInterface; use Symfony\Component\Serializer\Mapping\Loader\LoaderInterface; @@ -24,7 +25,8 @@ * Exposes the Doctrine inheritance discriminator map (ORM and MongoDB ODM) of an API resource as a serializer * discriminator map, so the subtypes of a Doctrine hierarchy are read, written and documented as such. * - * A serializer discriminator map declared in the hierarchy always takes precedence. + * A serializer discriminator map declared in the hierarchy always takes precedence. It is detected using the + * explicit serializer loaders (attributes, XML, YAML) when they are given, attributes only otherwise. * * The serializer does not inherit discriminator maps: every class having subclasses in the Doctrine map gets * its own map, restricted to itself and its subclasses, so a resource declared in the middle of a hierarchy @@ -34,9 +36,13 @@ */ final class DoctrineDiscriminatorMappingLoader implements LoaderInterface { + /** @var array */ + private array $serializerDiscriminatorMaps = []; + public function __construct( private readonly ManagerRegistry $managerRegistry, private readonly ResourceClassResolverInterface $resourceClassResolver, + private readonly ?LoaderInterface $serializerLoader = null, ) { } @@ -128,11 +134,26 @@ private function isResourceHierarchy(array $hierarchy): bool private function hasSerializerDiscriminatorMap(array $hierarchy): bool { foreach ($hierarchy as $class) { - if (class_exists($class) && (new \ReflectionClass($class))->getAttributes(DiscriminatorMap::class, \ReflectionAttribute::IS_INSTANCEOF)) { + if (class_exists($class) && ($this->serializerDiscriminatorMaps[$class] ??= $this->declaresSerializerDiscriminatorMap($class))) { return true; } } return false; } + + /** + * @param class-string $class + */ + private function declaresSerializerDiscriminatorMap(string $class): bool + { + if (null === $this->serializerLoader) { + return (bool) (new \ReflectionClass($class))->getAttributes(DiscriminatorMap::class, \ReflectionAttribute::IS_INSTANCEOF); + } + + $classMetadata = new ClassMetadata($class); + $this->serializerLoader->loadClassMetadata($classMetadata); + + return null !== $classMetadata->getClassDiscriminatorMapping(); + } } diff --git a/src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php b/src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php index 61bc58ac81f..50764bfd72f 100644 --- a/src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php +++ b/src/Doctrine/Common/Tests/Serializer/Mapping/Loader/DoctrineDiscriminatorMappingLoaderTest.php @@ -21,16 +21,14 @@ use Doctrine\Persistence\ManagerRegistry; use Doctrine\Persistence\ObjectManager; use PHPUnit\Framework\TestCase; -use Prophecy\Argument; -use Prophecy\PhpUnit\ProphecyTrait; use Symfony\Component\Serializer\Attribute\DiscriminatorMap; use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; use Symfony\Component\Serializer\Mapping\ClassMetadata; +use Symfony\Component\Serializer\Mapping\ClassMetadataInterface; +use Symfony\Component\Serializer\Mapping\Loader\LoaderInterface; final class DoctrineDiscriminatorMappingLoaderTest extends TestCase { - use ProphecyTrait; - private const ORM_MAP = [ 'vehicle' => LoaderVehicle::class, 'car' => LoaderCar::class, @@ -90,6 +88,24 @@ public function testSerializerDiscriminatorMapDeclaredInTheHierarchyWins(): void $this->assertNull($metadata->getClassDiscriminatorMapping()); } + public function testSerializerDiscriminatorMapDeclaredWithAnotherLoaderWins(): void + { + $serializerLoader = $this->createStub(LoaderInterface::class); + $serializerLoader->method('loadClassMetadata')->willReturnCallback(static function (ClassMetadataInterface $metadata): bool { + if (LoaderVehicle::class !== $metadata->getName()) { + return false; + } + + $metadata->setClassDiscriminatorMapping(new ClassDiscriminatorMapping('type', ['car' => LoaderCar::class])); + + return true; + }); + $metadata = new ClassMetadata(LoaderCar::class); + + $this->assertFalse($this->createLoader([LoaderCar::class => $this->createOrmMetadata(LoaderCar::class, self::ORM_MAP)], serializerLoader: $serializerLoader)->loadClassMetadata($metadata)); + $this->assertNull($metadata->getClassDiscriminatorMapping()); + } + public function testNonResourceHierarchiesAreLeftAlone(): void { $metadata = new ClassMetadata(LoaderVehicle::class); @@ -178,22 +194,23 @@ private function createOrmMetadata(string $class, array $discriminatorMap): OrmC * @param array $doctrineMetadata * @param class-string[]|null $resourceClasses defaults to the root of every hierarchy */ - private function createLoader(array $doctrineMetadata, ?array $resourceClasses = null): DoctrineDiscriminatorMappingLoader + private function createLoader(array $doctrineMetadata, ?array $resourceClasses = null, ?LoaderInterface $serializerLoader = null): DoctrineDiscriminatorMappingLoader { $resourceClasses ??= [LoaderVehicle::class, LoaderSerializerMappedBase::class]; - $managerRegistry = $this->prophesize(ManagerRegistry::class); - $managerRegistry->getManagerForClass(Argument::type('string'))->willReturn(null); + $managers = []; foreach ($doctrineMetadata as $class => $metadata) { - $manager = $this->prophesize(ObjectManager::class); - $manager->getClassMetadata($class)->willReturn($metadata); - $managerRegistry->getManagerForClass($class)->willReturn($manager->reveal()); + $managers[$class] = $this->createStub(ObjectManager::class); + $managers[$class]->method('getClassMetadata')->willReturn($metadata); } - $resourceClassResolver = $this->prophesize(ResourceClassResolverInterface::class); - $resourceClassResolver->isResourceClass(Argument::type('string'))->will(static fn (array $args): bool => \in_array($args[0], $resourceClasses, true)); + $managerRegistry = $this->createStub(ManagerRegistry::class); + $managerRegistry->method('getManagerForClass')->willReturnCallback(static fn (string $class): ?ObjectManager => $managers[$class] ?? null); + + $resourceClassResolver = $this->createStub(ResourceClassResolverInterface::class); + $resourceClassResolver->method('isResourceClass')->willReturnCallback(static fn (string $class): bool => \in_array($class, $resourceClasses, true)); - return new DoctrineDiscriminatorMappingLoader($managerRegistry->reveal(), $resourceClassResolver->reveal()); + return new DoctrineDiscriminatorMappingLoader($managerRegistry, $resourceClassResolver, $serializerLoader); } } diff --git a/src/Hydra/Serializer/DocumentationNormalizer.php b/src/Hydra/Serializer/DocumentationNormalizer.php index 3492403a94d..85f6b0acc2c 100644 --- a/src/Hydra/Serializer/DocumentationNormalizer.php +++ b/src/Hydra/Serializer/DocumentationNormalizer.php @@ -29,7 +29,9 @@ use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface; use ApiPlatform\Metadata\ResourceClassResolverInterface; use ApiPlatform\Metadata\UrlGeneratorInterface; +use ApiPlatform\Metadata\Util\ClassDiscriminatorHelper; use ApiPlatform\Metadata\Util\TypeHelper; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; use Symfony\Component\Serializer\NameConverter\NameConverterInterface; use Symfony\Component\Serializer\Normalizer\AbstractNormalizer; use Symfony\Component\Serializer\Normalizer\NormalizerInterface; @@ -59,6 +61,7 @@ public function __construct( private readonly ?NameConverterInterface $nameConverter = null, private readonly ?array $defaultContext = [], private readonly ?bool $entrypointEnabled = true, + private readonly ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null, ) { } @@ -68,8 +71,11 @@ public function __construct( public function normalize(mixed $data, ?string $format = null, array $context = []): array { $classes = []; + $subtypeClasses = []; $entrypointProperties = []; $hydraPrefix = $this->getHydraPrefix($context + $this->defaultContext); + $resourceClasses = iterator_to_array($data->getResourceNameCollection(), false); + $resourceShortNames = null === $this->classDiscriminatorResolver ? [] : $this->getResourceShortNames($resourceClasses); foreach ($data->getResourceNameCollection() as $resourceClass) { $resourceMetadataCollection = $this->resourceMetadataFactory->create($resourceClass); @@ -84,10 +90,96 @@ public function normalize(mixed $data, ?string $format = null, array $context = $this->populateEntrypointProperties($resourceMetadata, $shortName, $prefixedShortName, $entrypointProperties, $hydraPrefix); $classes[] = $this->getClass($resourceClass, $resourceMetadata, $shortName, $prefixedShortName, $context, $hydraPrefix); + + if (null !== $this->classDiscriminatorResolver) { + [$propertyNameContext] = $this->getPropertyMetadataFactoryContext($resourceMetadata); + $propertyNames = array_fill_keys(iterator_to_array($this->propertyNameCollectionFactory->create($resourceClass, $propertyNameContext), false), true); + $this->addSubtypeClasses($subtypeClasses, $resourceClasses, $resourceShortNames, $resourceClass, $prefixedShortName, $propertyNames, $resourceMetadata, $context, $hydraPrefix); + } + } + } + + return $this->computeDoc($data, $this->getClasses($entrypointProperties, [...$classes, ...array_values($subtypeClasses)], $hydraPrefix), $hydraPrefix); + } + + /** + * Documents the subtypes declared in the discriminator map of a resource as subclasses of their parent, + * supporting the properties their parent does not expose. + * + * @param array> $subtypeClasses + * @param list $resourceClasses + * @param array $resourceShortNames + * @param array $propertyNames the properties exposed by the parent class + */ + private function addSubtypeClasses(array &$subtypeClasses, array $resourceClasses, array $resourceShortNames, string $class, string $prefixedShortName, array $propertyNames, ApiResource $resourceMetadata, array $context, string $hydraPrefix): void + { + if (null === $mapping = $this->classDiscriminatorResolver?->getMappingForClass($class)) { + return; + } + + [$propertyNameContext, $propertyContext] = $this->getPropertyMetadataFactoryContext($resourceMetadata); + foreach (ClassDiscriminatorHelper::getDirectSubtypes($mapping, $class) as $subtype) { + // A subtype being a resource is documented by its own class + if (\in_array($subtype, $resourceClasses, true)) { + continue; + } + + $subtypeShortName = ClassDiscriminatorHelper::getShortName($subtype); + // The short name already identifies a resource: its class must not be redefined, the subtypes of the subtype extend the parent + if (isset($resourceShortNames[$subtypeShortName])) { + $this->addSubtypeClasses($subtypeClasses, $resourceClasses, $resourceShortNames, $subtype, $prefixedShortName, $propertyNames, $resourceMetadata, $context, $hydraPrefix); + + continue; + } + + $subtypePrefixedShortName = "#$subtypeShortName"; + $subtypePropertyNames = $propertyNames; + $properties = []; + foreach ($this->propertyNameCollectionFactory->create($subtype, $propertyNameContext) as $propertyName) { + if (isset($subtypePropertyNames[$propertyName])) { + continue; + } + + $subtypePropertyNames[$propertyName] = true; + $propertyMetadata = $this->propertyMetadataFactory->create($subtype, $propertyName, $propertyContext); + if ((true === $propertyMetadata->isIdentifier() && false === $propertyMetadata->isWritable()) || false === $propertyMetadata->getHydra()) { + continue; + } + + $normalizedPropertyName = $this->nameConverter ? $this->nameConverter->normalize($propertyName, $subtype, self::FORMAT, $context) : $propertyName; + $properties[] = $this->getProperty($propertyMetadata, $normalizedPropertyName, $subtypePrefixedShortName, $subtypeShortName, $hydraPrefix); + } + + $subtypeClasses[$subtypePrefixedShortName] ??= [ + '@id' => $subtypePrefixedShortName, + '@type' => $hydraPrefix.'Class', + $hydraPrefix.'title' => $subtypeShortName, + 'subClassOf' => $prefixedShortName, + $hydraPrefix.'supportedProperty' => $properties, + $hydraPrefix.'supportedOperation' => [], + ]; + + $this->addSubtypeClasses($subtypeClasses, $resourceClasses, $resourceShortNames, $subtype, $subtypePrefixedShortName, $subtypePropertyNames, $resourceMetadata, $context, $hydraPrefix); + } + } + + /** + * @param list $resourceClasses + * + * @return array + */ + private function getResourceShortNames(array $resourceClasses): array + { + $shortNames = []; + foreach ($resourceClasses as $resourceClass) { + foreach ($this->resourceMetadataFactory->create($resourceClass) as $resourceMetadata) { + if (true !== $resourceMetadata->getHideHydraOperation()) { + $shortNames[$resourceMetadata->getShortName()] = true; + } } } - return $this->computeDoc($data, $this->getClasses($entrypointProperties, $classes, $hydraPrefix), $hydraPrefix); + return $shortNames; } /** diff --git a/src/Hydra/Tests/Serializer/DocumentationNormalizerTest.php b/src/Hydra/Tests/Serializer/DocumentationNormalizerTest.php index b83dbdcd8e2..680250f8758 100644 --- a/src/Hydra/Tests/Serializer/DocumentationNormalizerTest.php +++ b/src/Hydra/Tests/Serializer/DocumentationNormalizerTest.php @@ -36,6 +36,8 @@ use PHPUnit\Framework\TestCase; use Prophecy\Argument; use Prophecy\PhpUnit\ProphecyTrait; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; use Symfony\Component\TypeInfo\Type; use const ApiPlatform\JsonLd\HYDRA_CONTEXT; @@ -1212,4 +1214,81 @@ public function testNormalizeWithStringGroups(): void $this->assertSame('#dummy', $doc['hydra:supportedClass'][0]['@id']); $this->assertNotEmpty($doc['hydra:supportedClass'][0]['hydra:supportedProperty']); } + + public function testSubtypeDoesNotRedefineTheClassOfAResourceWithTheSameShortName(): void + { + $documentation = new Documentation(new ResourceNameCollection([HydraDiscriminatedVehicle::class, HydraDiscriminatedOther::class]), 'Test Api', 'test', '0.0.0'); + + $propertyNames = [ + HydraDiscriminatedVehicle::class => ['name'], + HydraDiscriminatedCar::class => ['name', 'doors'], + HydraDiscriminatedTruck::class => ['name', 'payload'], + HydraDiscriminatedHeavyTruck::class => ['name', 'payload', 'axles'], + HydraDiscriminatedOther::class => ['title'], + ]; + $propertyNameCollectionFactory = $this->createStub(PropertyNameCollectionFactoryInterface::class); + $propertyNameCollectionFactory->method('create')->willReturnCallback(static fn (string $class): PropertyNameCollection => new PropertyNameCollection($propertyNames[$class])); + + $propertyMetadataFactory = $this->createStub(PropertyMetadataFactoryInterface::class); + $propertyMetadataFactory->method('create')->willReturn((new ApiProperty())->withNativeType(Type::string())->withReadable(true)->withWritable(true)); + + $resourceMetadataFactory = $this->createStub(ResourceMetadataCollectionFactoryInterface::class); + $resourceMetadataFactory->method('create')->willReturnCallback(static function (string $class): ResourceMetadataCollection { + // An unrelated resource is named after a subtype of the discriminated resource + $shortName = HydraDiscriminatedOther::class === $class ? 'HydraDiscriminatedTruck' : 'HydraDiscriminatedVehicle'; + + return new ResourceMetadataCollection($class, [(new ApiResource())->withShortName($shortName)->withOperations(new Operations(['get' => (new Get())->withShortName($shortName)]))]); + }); + + $resourceClassResolver = $this->createStub(ResourceClassResolverInterface::class); + $resourceClassResolver->method('isResourceClass')->willReturn(false); + + $urlGenerator = $this->createStub(UrlGeneratorInterface::class); + $urlGenerator->method('generate')->willReturn('/doc'); + + $mappings = [ + HydraDiscriminatedVehicle::class => new ClassDiscriminatorMapping('kind', ['car' => HydraDiscriminatedCar::class, 'truck' => HydraDiscriminatedTruck::class]), + HydraDiscriminatedTruck::class => new ClassDiscriminatorMapping('size', ['heavy' => HydraDiscriminatedHeavyTruck::class]), + ]; + $classDiscriminatorResolver = $this->createStub(ClassDiscriminatorResolverInterface::class); + $classDiscriminatorResolver->method('getMappingForClass')->willReturnCallback(static fn (string $class): ?ClassDiscriminatorMapping => $mappings[$class] ?? null); + + $documentationNormalizer = new DocumentationNormalizer($resourceMetadataFactory, $propertyNameCollectionFactory, $propertyMetadataFactory, $resourceClassResolver, $urlGenerator, null, [], true, $classDiscriminatorResolver); + + $classes = array_values(array_filter($documentationNormalizer->normalize($documentation)['hydra:supportedClass'], static fn (array $class): bool => str_starts_with($class['@id'], '#HydraDiscriminated'))); + $properties = static fn (array $class): array => array_column(array_column($class['hydra:supportedProperty'], 'hydra:property'), '@id'); + + $this->assertSame(['#HydraDiscriminatedVehicle', '#HydraDiscriminatedTruck', '#HydraDiscriminatedCar', '#HydraDiscriminatedHeavyTruck'], array_column($classes, '@id')); + + // The class of the resource is left untouched + $this->assertArrayNotHasKey('subClassOf', $classes[1]); + $this->assertSame(['#HydraDiscriminatedTruck/title'], $properties($classes[1])); + + $this->assertSame('#HydraDiscriminatedVehicle', $classes[2]['subClassOf']); + $this->assertSame(['#HydraDiscriminatedCar/doors'], $properties($classes[2])); + + // The subtypes of the undocumented subtype extend the resource and support its properties + $this->assertSame('#HydraDiscriminatedVehicle', $classes[3]['subClassOf']); + $this->assertSame(['#HydraDiscriminatedHeavyTruck/payload', '#HydraDiscriminatedHeavyTruck/axles'], $properties($classes[3])); + } +} + +class HydraDiscriminatedVehicle +{ +} + +class HydraDiscriminatedCar extends HydraDiscriminatedVehicle +{ +} + +class HydraDiscriminatedTruck extends HydraDiscriminatedVehicle +{ +} + +class HydraDiscriminatedHeavyTruck extends HydraDiscriminatedTruck +{ +} + +class HydraDiscriminatedOther +{ } diff --git a/src/JsonApi/JsonSchema/SchemaFactory.php b/src/JsonApi/JsonSchema/SchemaFactory.php index eca9c9ecd87..8ddbd023756 100644 --- a/src/JsonApi/JsonSchema/SchemaFactory.php +++ b/src/JsonApi/JsonSchema/SchemaFactory.php @@ -19,6 +19,7 @@ use ApiPlatform\JsonSchema\DefinitionNameFactoryInterface; use ApiPlatform\JsonSchema\ResourceMetadataTrait; use ApiPlatform\JsonSchema\Schema; +use ApiPlatform\JsonSchema\SchemaFactory as BaseSchemaFactory; use ApiPlatform\JsonSchema\SchemaFactoryAwareInterface; use ApiPlatform\JsonSchema\SchemaFactoryInterface; use ApiPlatform\JsonSchema\SchemaUriPrefixTrait; @@ -135,6 +136,7 @@ public function buildSchema(string $className, string $format = 'jsonapi', strin $prefix = $this->getSchemaUriPrefix($schema->getVersion()); $definitions = $schema->getDefinitions(); $collectionKey = $schema->getItemsDefinitionKey(); + $subtypeDefinitionName = $this->getSubtypeDefinitionNameFactory($className, $type, $operation, $jsonApiSerializerContext); // Already computed if (!$collectionKey && isset($definitions[$definitionName])) { @@ -167,7 +169,7 @@ public function buildSchema(string $className, string $format = 'jsonapi', strin if (!$collectionKey) { $definitions[$definitionName]['type'] = 'object'; - $definitions[$definitionName]['properties'] = $this->buildDefinitionPropertiesSchema($key, $definitionName, $inputOrOutputClass, $format, $type, $operation, $schema, []); + $definitions[$definitionName]['properties'] = $this->buildDefinitionPropertiesSchema($key, $definitionName, $inputOrOutputClass, $format, $type, $operation, $schema, [], $subtypeDefinitionName); $schema['$ref'] = $prefix.$definitionName; return $schema; @@ -265,7 +267,7 @@ public function buildSchema(string $className, string $format = 'jsonapi', strin unset($schema['items']); unset($schema['type']); - $properties = $this->buildDefinitionPropertiesSchema($key, $definitionName, $inputOrOutputClass, $format, $type, $operation, $schema, []); + $properties = $this->buildDefinitionPropertiesSchema($key, $definitionName, $inputOrOutputClass, $format, $type, $operation, $schema, [], $subtypeDefinitionName); $properties['data'] = [ 'type' => 'array', @@ -288,14 +290,17 @@ public function setSchemaFactory(SchemaFactoryInterface $schemaFactory): void } } - private function buildDefinitionPropertiesSchema(string $key, string $documentDefinitionName, string $propertyClass, string $format, string $type, ?Operation $operation, Schema $schema, ?array $serializerContext): array + /** + * @param (\Closure(class-string): string)|null $subtypeDefinitionName + */ + private function buildDefinitionPropertiesSchema(string $key, string $documentDefinitionName, string $propertyClass, string $format, string $type, ?Operation $operation, Schema $schema, ?array $serializerContext, ?\Closure $subtypeDefinitionName = null): array { // Capture the resource's operation up front; the relationship loop below reassigns $operation. $resourceOperation = $operation; $definitions = $schema->getDefinitions(); // A definition listing its subtypes in "oneOf" carries no properties: an instance of the class itself is described by its inline branch $ownBranch = null; - foreach (isset($definitions[$key]['discriminator']) ? $definitions[$key]['oneOf'] ?? [] : [] as $branch) { + foreach (null !== $this->classDiscriminatorResolver?->getMappingForClass($propertyClass) ? $definitions[$key]['oneOf'] ?? [] : [] as $branch) { if (!isset($branch['$ref'])) { $ownBranch = $branch; break; @@ -401,7 +406,7 @@ private function buildDefinitionPropertiesSchema(string $key, string $documentDe // Subtypes declared in a serializer discriminator map: the type property lives in "attributes" so an OpenAPI discriminator cannot be used $oneOf = []; - foreach ($this->getDiscriminatedSubtypes($key, $propertyClass, $definitions, $schema->getVersion()) as [$subKey, $subClass, $typeProperty]) { + foreach ($this->getDiscriminatedSubtypes($key, $propertyClass, $definitions, $schema->getVersion(), $subtypeDefinitionName) as [$subKey, $subClass, $typeProperty]) { $attributeName = ReservedAttributeNameConverter::getReservedAttributes($this->strictMemberNames)[$typeProperty] ?? $typeProperty; // The inline branch of a class declared in its own discriminator map describes the instances of the class itself @@ -413,7 +418,7 @@ private function buildDefinitionPropertiesSchema(string $key, string $documentDe } $subDocumentDefinitionName = $documentDefinitionName.'.'.(new \ReflectionClass($subClass))->getShortName(); - $subSchema = $this->buildDefinitionPropertiesSchema($subKey, $subDocumentDefinitionName, $subClass, $format, $type, $resourceOperation, $schema, $serializerContext); + $subSchema = $this->buildDefinitionPropertiesSchema($subKey, $subDocumentDefinitionName, $subClass, $format, $type, $resourceOperation, $schema, $serializerContext, $subtypeDefinitionName); if (\in_array($typeProperty, $definitions[$subKey]['required'] ?? [], true)) { $definitions[$subDocumentDefinitionName.'.resource']['properties']['attributes']['required'] = [$attributeName]; } @@ -456,23 +461,44 @@ private function buildDefinitionPropertiesSchema(string $key, string $documentDe } /** + * Mirrors the name the decorated factory gives to the definition of a subtype declared in a discriminator map. + * + * @return (\Closure(class-string): string)|null + */ + private function getSubtypeDefinitionNameFactory(string $className, string $type, ?Operation $operation, array $serializerContext): ?\Closure + { + if (null === $this->classDiscriminatorResolver) { + return null; + } + + $method = $operation instanceof HttpOperation ? $operation->getMethod() : 'GET'; + $isInput = Schema::TYPE_INPUT === $type; + $definitionFormat = $isInput && 'PATCH' === $method ? 'merge-patch+json' : 'json'; + $serializerContext += ($operation ? $this->getSerializerContext($operation, $type) : []) + [ + 'schema_type' => $type, + BaseSchemaFactory::PARTIAL_UPDATE => $isInput && 'PUT' === $method && !($operation?->getExtraProperties()['standard_put'] ?? true), + ]; + + return fn (string $subClass): string => $this->definitionNameFactory->create($className, $definitionFormat, $subClass, $operation, $serializerContext); + } + + /** + * @param (\Closure(class-string): string)|null $subtypeDefinitionName + * * @return iterable */ - private function getDiscriminatedSubtypes(string $key, string $className, \ArrayObject $definitions, string $version): iterable + private function getDiscriminatedSubtypes(string $key, string $className, \ArrayObject $definitions, string $version, ?\Closure $subtypeDefinitionName): iterable { - $discriminator = $definitions[$key]['discriminator'] ?? null; - if (null === $this->classDiscriminatorResolver || !isset($definitions[$key]['oneOf'], $discriminator['mapping']) || null === $mapping = $this->classDiscriminatorResolver->getMappingForClass($className)) { + if (null === $subtypeDefinitionName || !isset($definitions[$key]['oneOf']) || null === $mapping = $this->classDiscriminatorResolver?->getMappingForClass($className)) { return; } + // The "$ref" branches of "oneOf" reference the definitions of the direct subtypes + $refs = array_flip(array_column($definitions[$key]['oneOf'], '$ref')); $prefix = $this->getSchemaUriPrefix($version); - foreach (ClassDiscriminatorHelper::getDirectSubtypes($mapping, $className) as $typeValue => $subClass) { - if (null === $ref = $discriminator['mapping'][$typeValue] ?? null) { - continue; - } - - $subKey = substr($ref, \strlen($prefix)); - if (isset($definitions[$subKey])) { + foreach (ClassDiscriminatorHelper::getDirectSubtypes($mapping, $className) as $subClass) { + $subKey = $subtypeDefinitionName($subClass); + if (isset($refs[$prefix.$subKey], $definitions[$subKey])) { yield [$subKey, $subClass, $mapping->getTypeProperty()]; } } diff --git a/src/JsonLd/ContextBuilder.php b/src/JsonLd/ContextBuilder.php index 82f90e6f21b..057a34c0b91 100644 --- a/src/JsonLd/ContextBuilder.php +++ b/src/JsonLd/ContextBuilder.php @@ -23,7 +23,9 @@ use ApiPlatform\Metadata\Resource\Factory\ResourceNameCollectionFactoryInterface; use ApiPlatform\Metadata\Resource\ResourceMetadataCollection; use ApiPlatform\Metadata\UrlGeneratorInterface; +use ApiPlatform\Metadata\Util\ClassDiscriminatorHelper; use ApiPlatform\Metadata\Util\ClassInfoTrait; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; use Symfony\Component\Serializer\NameConverter\NameConverterInterface; /** @@ -40,7 +42,7 @@ final class ContextBuilder implements AnonymousContextBuilderInterface, Operatio public const HYDRA_PREFIX = 'hydra:'; public const HYDRA_CONTEXT_HAS_PREFIX = 'hydra_prefix'; - public function __construct(private readonly ResourceNameCollectionFactoryInterface $resourceNameCollectionFactory, private readonly ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory, private readonly PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, private readonly PropertyMetadataFactoryInterface $propertyMetadataFactory, private readonly UrlGeneratorInterface $urlGenerator, private readonly ?IriConverterInterface $iriConverter = null, private readonly ?NameConverterInterface $nameConverter = null, private array $defaultContext = []) + public function __construct(private readonly ResourceNameCollectionFactoryInterface $resourceNameCollectionFactory, private readonly ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory, private readonly PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, private readonly PropertyMetadataFactoryInterface $propertyMetadataFactory, private readonly UrlGeneratorInterface $urlGenerator, private readonly ?IriConverterInterface $iriConverter = null, private readonly ?NameConverterInterface $nameConverter = null, private array $defaultContext = [], private readonly ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null) { } @@ -234,40 +236,57 @@ private function getResourceContextWithShortname(string $resourceClass, int $ref $propertyNameCollectionContext = $serializerGroups ? ['serializer_groups' => $serializerGroups] : []; } + $propertyNames = []; foreach ($this->propertyNameCollectionFactory->create($resourceClass, $propertyNameCollectionContext) as $propertyName) { - $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName, $propertyContext); + $propertyNames[$propertyName] = true; + $this->addPropertyContext($context, $resourceClass, $propertyName, $shortName, $propertyContext); + } - if ($propertyMetadata->isIdentifier() && true !== $propertyMetadata->isWritable()) { - continue; + // The properties of the subtypes declared in the discriminator map of the resource are defined by their own class + foreach (null === $this->classDiscriminatorResolver ? [] : ClassDiscriminatorHelper::getSubtypes($this->classDiscriminatorResolver, $resourceClass) as $subtype) { + foreach ($this->propertyNameCollectionFactory->create($subtype, $propertyNameCollectionContext) as $propertyName) { + if (!isset($propertyNames[$propertyName])) { + $propertyNames[$propertyName] = true; + $this->addPropertyContext($context, $subtype, $propertyName, ClassDiscriminatorHelper::getShortName($subtype), $propertyContext); + } } + } - $convertedName = $this->nameConverter ? $this->nameConverter->normalize($propertyName, $resourceClass, self::FORMAT) : $propertyName; - $jsonldContext = $propertyMetadata->getJsonldContext() ?? []; + return $context; + } - if ($id = $propertyMetadata->getIris()) { - $id = 1 === (is_countable($id) ? \count($id) : 0) ? $id[0] : $id; - } + private function addPropertyContext(array &$context, string $resourceClass, string $propertyName, string $shortName, array $propertyContext): void + { + $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName, $propertyContext); - if (!$id) { - $id = \sprintf('%s/%s', $shortName, $convertedName); - } + if ($propertyMetadata->isIdentifier() && true !== $propertyMetadata->isWritable()) { + return; + } - if (false === $propertyMetadata->isReadableLink()) { - $jsonldContext += [ - '@id' => $id, - '@type' => '@id', - ]; - } + $convertedName = $this->nameConverter ? $this->nameConverter->normalize($propertyName, $resourceClass, self::FORMAT) : $propertyName; + $jsonldContext = $propertyMetadata->getJsonldContext() ?? []; - if (empty($jsonldContext)) { - $context[$convertedName] = $id; - } else { - $context[$convertedName] = $jsonldContext + [ - '@id' => $id, - ]; - } + if ($id = $propertyMetadata->getIris()) { + $id = 1 === (is_countable($id) ? \count($id) : 0) ? $id[0] : $id; } - return $context; + if (!$id) { + $id = \sprintf('%s/%s', $shortName, $convertedName); + } + + if (false === $propertyMetadata->isReadableLink()) { + $jsonldContext += [ + '@id' => $id, + '@type' => '@id', + ]; + } + + if (empty($jsonldContext)) { + $context[$convertedName] = $id; + } else { + $context[$convertedName] = $jsonldContext + [ + '@id' => $id, + ]; + } } } diff --git a/src/JsonLd/Serializer/ItemNormalizer.php b/src/JsonLd/Serializer/ItemNormalizer.php index e63202613f6..e512011aa45 100644 --- a/src/JsonLd/Serializer/ItemNormalizer.php +++ b/src/JsonLd/Serializer/ItemNormalizer.php @@ -24,6 +24,7 @@ use ApiPlatform\Metadata\ResourceAccessCheckerInterface; use ApiPlatform\Metadata\ResourceClassResolverInterface; use ApiPlatform\Metadata\UrlGeneratorInterface; +use ApiPlatform\Metadata\Util\ClassDiscriminatorHelper; use ApiPlatform\Metadata\Util\ClassInfoTrait; use ApiPlatform\Serializer\AbstractItemNormalizer; use ApiPlatform\Serializer\ContextTrait; @@ -130,7 +131,7 @@ public function normalize(mixed $data, ?string $format = null, array $context = return $normalizedData; } - if (!isset($metadata['@type']) && null !== ($type = $this->resolveType($resourceClass, $isResourceClass, $context))) { + if (!isset($metadata['@type']) && null !== ($type = $this->resolveType($data, $resourceClass, $isResourceClass, $context))) { $metadata['@type'] = $type; } @@ -140,7 +141,7 @@ public function normalize(mixed $data, ?string $format = null, array $context = /** * @return string|array|null */ - private function resolveType(string $resourceClass, bool $isResourceClass, array $context): string|array|null + private function resolveType(object $data, string $resourceClass, bool $isResourceClass, array $context): string|array|null { $operation = $context['operation'] ?? null; @@ -157,6 +158,11 @@ private function resolveType(string $resourceClass, bool $isResourceClass, array } $types = $operation instanceof HttpOperation ? $operation->getTypes() : null; + // A subtype declared in the discriminator map of the resource is typed by its own class, documented as a subclass of the resource + if (null === $types && $isResourceClass && null !== $discriminatedClass = $this->getDiscriminatedClass($data, $resourceClass)) { + return ClassDiscriminatorHelper::getShortName($discriminatedClass); + } + if (null === $types) { $typeClass = $isResourceClass ? $resourceClass : ($operation->getClass() ?? $resourceClass); if (isset($context['item_uri_template']) || $operation->getClass() === $typeClass) { diff --git a/src/JsonSchema/SchemaFactory.php b/src/JsonSchema/SchemaFactory.php index 359cee07c39..fca5eb53bf1 100644 --- a/src/JsonSchema/SchemaFactory.php +++ b/src/JsonSchema/SchemaFactory.php @@ -159,7 +159,7 @@ public function buildSchema(string $className, string $format = 'json', string $ $options = ['schema_type' => $type] + $this->getFactoryOptions($serializerContext, $validationGroups); $this->buildDefinitionProperties($schema, $definition, $definitionName, $inputOrOutputClass, $options, $serializerContext, $format, $type, $isPartialUpdate); - // Subtypes explicitly declared in a serializer discriminator map are documented using "oneOf" and an OpenAPI "discriminator" + // Subtypes explicitly declared in a serializer discriminator map are documented using "oneOf" (and a "discriminator" in OpenAPI) $this->buildDiscriminatedDefinitions($schema, $definition, $className, $inputOrOutputClass, $definitionFormat, $operation, $options, $serializerContext, $serializerContext + [ 'schema_type' => $type, self::PARTIAL_UPDATE => $isPartialUpdate && !$isJsonMergePatch, @@ -264,7 +264,10 @@ private function buildDiscriminatedDefinitions(Schema $schema, \ArrayObject $def $this->addTypeProperties($definition, [$typeProperty => ['type' => 'string', 'enum' => $ownTypeValues]], $isPartialUpdate || \in_array($mapping->getDefaultType(), $ownTypeValues, true)); } - $definition['discriminator'] = ['propertyName' => $typeProperty, 'mapping' => $discriminatorMapping]; + // "discriminator" is an OpenAPI keyword, plain JSON Schema relies on the "enum" of the type property in every branch + if (Schema::VERSION_OPENAPI === $schema->getVersion()) { + $definition['discriminator'] = ['propertyName' => $typeProperty, 'mapping' => $discriminatorMapping]; + } } /** diff --git a/src/JsonSchema/Tests/SchemaFactoryTest.php b/src/JsonSchema/Tests/SchemaFactoryTest.php index 7cba5c919e1..1aba5bce81d 100644 --- a/src/JsonSchema/Tests/SchemaFactoryTest.php +++ b/src/JsonSchema/Tests/SchemaFactoryTest.php @@ -523,6 +523,18 @@ public function testBuildSchemaDocumentsDiscriminatorMapSubtypes(): void $this->assertSame(['type' => 'string', 'enum' => ['dog']], $dog['properties']['species']); } + public function testBuildJsonSchemaDocumentsDiscriminatorMapSubtypesWithoutOpenApiDiscriminator(): void + { + $definitions = $this->createDiscriminatorSchemaFactory()->buildSchema(DiscriminatedAnimal::class)->getDefinitions(); + + $this->assertSame([ + ['$ref' => '#/definitions/DiscriminatedAnimal.DiscriminatedCat'], + ['$ref' => '#/definitions/DiscriminatedAnimal.DiscriminatedDog'], + ], $definitions['DiscriminatedAnimal']['oneOf']); + $this->assertArrayNotHasKey('discriminator', $definitions['DiscriminatedAnimal']); + $this->assertSame(['type' => 'string', 'enum' => ['cat']], $definitions['DiscriminatedAnimal.DiscriminatedCat']['properties']['species']); + } + public function testBuildSchemaDocumentsClassDeclaredInItsOwnDiscriminatorMap(): void { $schemaFactory = $this->createDiscriminatorSchemaFactory(); @@ -562,27 +574,28 @@ public function testBuildSchemaWithoutClassDiscriminatorResolverIgnoresDiscrimin private function createDiscriminatorSchemaFactory(bool $withClassDiscriminatorResolver = true): SchemaFactory { - $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class); - $propertyNameCollectionFactoryProphecy->create(DiscriminatedAnimal::class, Argument::cetera())->willReturn(new PropertyNameCollection(['name'])); - $propertyNameCollectionFactoryProphecy->create(DiscriminatedCat::class, Argument::cetera())->willReturn(new PropertyNameCollection(['lives', 'name'])); - $propertyNameCollectionFactoryProphecy->create(DiscriminatedDog::class, Argument::cetera())->willReturn(new PropertyNameCollection(['goodBoy', 'name'])); - $propertyNameCollectionFactoryProphecy->create(DiscriminatedGadget::class, Argument::cetera())->willReturn(new PropertyNameCollection(['name'])); - $propertyNameCollectionFactoryProphecy->create(DiscriminatedPhone::class, Argument::cetera())->willReturn(new PropertyNameCollection(['name', 'number'])); + $propertyNames = [ + DiscriminatedAnimal::class => ['name'], + DiscriminatedCat::class => ['lives', 'name'], + DiscriminatedDog::class => ['goodBoy', 'name'], + DiscriminatedGadget::class => ['name'], + DiscriminatedPhone::class => ['name', 'number'], + ]; + $propertyNameCollectionFactory = $this->createStub(PropertyNameCollectionFactoryInterface::class); + $propertyNameCollectionFactory->method('create')->willReturnCallback(static fn (string $class): PropertyNameCollection => new PropertyNameCollection($propertyNames[$class])); - $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class); - $propertyMetadataFactoryProphecy->create(Argument::any(), 'name', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::string())->withReadable(true)->withWritable(true)->withSchema(['type' => 'string'])); - $propertyMetadataFactoryProphecy->create(DiscriminatedCat::class, 'lives', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::int())->withReadable(true)->withWritable(true)->withSchema(['type' => 'integer'])); - $propertyMetadataFactoryProphecy->create(DiscriminatedPhone::class, 'number', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::string())->withReadable(true)->withWritable(true)->withSchema(['type' => 'string'])); - $propertyMetadataFactoryProphecy->create(DiscriminatedDog::class, 'goodBoy', Argument::cetera())->willReturn((new ApiProperty())->withNativeType(Type::bool())->withReadable(true)->withWritable(true)->withSchema(['type' => 'boolean'])); + $schemas = ['name' => [Type::string(), 'string'], 'lives' => [Type::int(), 'integer'], 'number' => [Type::string(), 'string'], 'goodBoy' => [Type::bool(), 'boolean']]; + $propertyMetadataFactory = $this->createStub(PropertyMetadataFactoryInterface::class); + $propertyMetadataFactory->method('create')->willReturnCallback(static fn (string $class, string $property): ApiProperty => (new ApiProperty())->withNativeType($schemas[$property][0])->withReadable(true)->withWritable(true)->withSchema(['type' => $schemas[$property][1]])); - $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class); - $resourceClassResolverProphecy->isResourceClass(Argument::any())->willReturn(false); + $resourceClassResolver = $this->createStub(ResourceClassResolverInterface::class); + $resourceClassResolver->method('isResourceClass')->willReturn(false); return new SchemaFactory( - resourceMetadataFactory: $this->prophesize(ResourceMetadataCollectionFactoryInterface::class)->reveal(), - propertyNameCollectionFactory: $propertyNameCollectionFactoryProphecy->reveal(), - propertyMetadataFactory: $propertyMetadataFactoryProphecy->reveal(), - resourceClassResolver: $resourceClassResolverProphecy->reveal(), + resourceMetadataFactory: $this->createStub(ResourceMetadataCollectionFactoryInterface::class), + propertyNameCollectionFactory: $propertyNameCollectionFactory, + propertyMetadataFactory: $propertyMetadataFactory, + resourceClassResolver: $resourceClassResolver, definitionNameFactory: new DefinitionNameFactory(), classDiscriminatorResolver: $withClassDiscriminatorResolver ? new ClassDiscriminatorFromClassMetadata(new ClassMetadataFactory(new AttributeLoader())) : null, ); diff --git a/src/Laravel/ApiPlatformProvider.php b/src/Laravel/ApiPlatformProvider.php index c2e659f56fc..2b152be6b36 100644 --- a/src/Laravel/ApiPlatformProvider.php +++ b/src/Laravel/ApiPlatformProvider.php @@ -719,7 +719,8 @@ public function register(): void $app->make(UrlGeneratorInterface::class), $app->make(IriConverterInterface::class), $app->make(NameConverterInterface::class), - $defaultContext + $defaultContext, + self::getResourceClassDiscriminatorResolver($app), ); }); @@ -976,7 +977,7 @@ public function register(): void $app->make(NameConverterInterface::class), $app->make(ResourceClassResolverInterface::class), $app->make(DefinitionNameFactoryInterface::class), - $app->make(ClassDiscriminatorResolverInterface::class), + self::getResourceClassDiscriminatorResolver($app), ); }); $this->app->singleton(JsonApiSchemaFactory::class, static function (Application $app) { @@ -987,7 +988,7 @@ public function register(): void $app->make(ResourceMetadataCollectionFactoryInterface::class), $app->make(DefinitionNameFactoryInterface::class), strictMemberNames: (bool) $app['config']->get('api-platform.jsonapi.strict_member_names', false), - classDiscriminatorResolver: $app->make(ClassDiscriminatorResolverInterface::class), + classDiscriminatorResolver: self::getResourceClassDiscriminatorResolver($app), ); }); $this->app->singleton(HydraSchemaFactory::class, static function (Application $app) { @@ -1021,7 +1022,8 @@ classDiscriminatorResolver: $app->make(ClassDiscriminatorResolverInterface::clas $app->make(UrlGeneratorInterface::class), $app->make(NameConverterInterface::class), $defaultContext, - $entrypointEnabled + $entrypointEnabled, + self::getResourceClassDiscriminatorResolver($app), ); }); @@ -1698,4 +1700,12 @@ public function boot(): void $this->loadRoutesFrom(__DIR__.'/routes/api.php'); } + + /** + * Resource polymorphism through serializer discriminator maps is opt-in (api-platform.serializer.discriminator_map). + */ + private static function getResourceClassDiscriminatorResolver(Application $app): ?ClassDiscriminatorResolverInterface + { + return $app['config']->get('api-platform.serializer.discriminator_map', false) ? $app->make(ClassDiscriminatorResolverInterface::class) : null; + } } diff --git a/src/Laravel/config/api-platform.php b/src/Laravel/config/api-platform.php index 0f1ff2c4d75..d283788b1b3 100644 --- a/src/Laravel/config/api-platform.php +++ b/src/Laravel/config/api-platform.php @@ -192,6 +192,8 @@ 'serializer' => [ 'hydra_prefix' => false, + // Read, write and document the subtypes declared in the serializer discriminator map of a resource + 'discriminator_map' => false, // 'datetime_format' => \DateTimeInterface::RFC3339, ], diff --git a/src/Metadata/Util/ClassDiscriminatorHelper.php b/src/Metadata/Util/ClassDiscriminatorHelper.php index b7eac611b8c..5f7ec84a2c1 100644 --- a/src/Metadata/Util/ClassDiscriminatorHelper.php +++ b/src/Metadata/Util/ClassDiscriminatorHelper.php @@ -26,6 +26,14 @@ */ final class ClassDiscriminatorHelper { + /** + * Returns the name identifying a subtype in JSON-LD (its type) and in the Hydra documentation. + */ + public static function getShortName(string $class): string + { + return false === ($position = strrpos($class, '\\')) ? $class : substr($class, $position + 1); + } + /** * Returns the subtypes declared in the given map of a class, indexed by their type value. * diff --git a/src/Serializer/AbstractItemNormalizer.php b/src/Serializer/AbstractItemNormalizer.php index e2c658dfbce..f388eeab686 100644 --- a/src/Serializer/AbstractItemNormalizer.php +++ b/src/Serializer/AbstractItemNormalizer.php @@ -43,6 +43,7 @@ use Symfony\Component\Serializer\Exception\RuntimeException; use Symfony\Component\Serializer\Exception\UnexpectedValueException; use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping; +use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface; use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface; use Symfony\Component\Serializer\NameConverter\NameConverterInterface; use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer; @@ -78,6 +79,12 @@ abstract class AbstractItemNormalizer extends AbstractObjectNormalizer implement */ public const SKIP_NULL_TO_ONE_RELATIONS = 'skip_null_to_one_relations'; + /** + * Default context flag exposing the subtypes declared in the serializer discriminator map of a resource + * (polymorphic resources): their properties are read and written. + */ + public const DISCRIMINATOR_MAP = 'discriminator_map'; + protected PropertyAccessorInterface $propertyAccessor; protected array $localCache = []; protected array $localFactoryOptionsCache = []; @@ -85,6 +92,20 @@ abstract class AbstractItemNormalizer extends AbstractObjectNormalizer implement protected array $attributesCache = []; protected ?ResourceAccessCheckerInterface $resourceAccessChecker; + /** + * The class discriminator resolver, only set when resource polymorphism is enabled. + */ + private ?ClassDiscriminatorResolverInterface $resourceDiscriminatorResolver = null; + + /** @var array, mappings: list}|null> */ + private array $discriminatorMappingCache = []; + + /** @var array> */ + private array $discriminatorTypeMappingsCache = []; + + /** @var array */ + private array $discriminatorTypePropertyCache = []; + public function __construct(protected PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, protected PropertyMetadataFactoryInterface $propertyMetadataFactory, protected IriConverterInterface $iriConverter, protected ResourceClassResolverInterface $resourceClassResolver, ?PropertyAccessorInterface $propertyAccessor = null, ?NameConverterInterface $nameConverter = null, ?ClassMetadataFactoryInterface $classMetadataFactory = null, array $defaultContext = [], ?ResourceMetadataCollectionFactoryInterface $resourceMetadataCollectionFactory = null, ?ResourceAccessCheckerInterface $resourceAccessChecker = null, protected ?TagCollectorInterface $tagCollector = null, protected ?OperationResourceClassResolverInterface $operationResourceResolver = null) { if (!isset($defaultContext['circular_reference_handler'])) { @@ -95,6 +116,9 @@ public function __construct(protected PropertyNameCollectionFactoryInterface $pr $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor(); $this->resourceAccessChecker = $resourceAccessChecker; $this->resourceMetadataCollectionFactory = $resourceMetadataCollectionFactory; + if ($defaultContext[self::DISCRIMINATOR_MAP] ?? false) { + $this->resourceDiscriminatorResolver = $this->classDiscriminatorResolver; + } } /** @@ -271,12 +295,12 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a // An IRI references an existing resource, its type is resolved when it is retrieved if (null === ($objectToPopulate = $this->extractObjectToPopulate($resourceClass, $context, static::OBJECT_TO_POPULATE)) && !\is_string($data)) { $normalizedData = \is_scalar($data) ? [$data] : $this->prepareForDenormalization($data); - // Nested discriminator maps are resolved down to the most specific class + // With resource polymorphism, nested discriminator maps are resolved down to the most specific class $resolvedTypes = []; do { $resolvedTypes[$type] = true; $type = $this->getClassDiscriminatorResolvedClass($normalizedData, $type, $context); - } while (!isset($resolvedTypes[$type])); + } while (null !== $this->resourceDiscriminatorResolver && !isset($resolvedTypes[$type])); } $context['api_denormalize'] = true; @@ -529,7 +553,29 @@ protected function getClassDiscriminatorResolvedClass(array $data, string $class */ private function getDiscriminatorMapping(string $resourceClass, string $class): ?array { - return null === $this->classDiscriminatorResolver ? null : ClassDiscriminatorHelper::resolve($this->classDiscriminatorResolver, $resourceClass, $class); + if (null === $this->resourceDiscriminatorResolver) { + return null; + } + + $cacheKey = $resourceClass.'|'.$class; + if (!\array_key_exists($cacheKey, $this->discriminatorMappingCache)) { + $this->discriminatorMappingCache[$cacheKey] = ClassDiscriminatorHelper::resolve($this->resourceDiscriminatorResolver, $resourceClass, $class); + } + + return $this->discriminatorMappingCache[$cacheKey]; + } + + /** + * Returns the most specific class declared in the discriminator maps of the resource for the given object, + * when it differs from the resource class. + * + * @internal + */ + protected function getDiscriminatedClass(object $object, string $resourceClass): ?string + { + $class = $this->getDiscriminatorMapping($resourceClass, $this->getObjectClass($object))['class'] ?? null; + + return $class !== $resourceClass ? $class : null; } /** @@ -538,7 +584,7 @@ private function getDiscriminatorMapping(string $resourceClass, string $class): private function prepareDiscriminatedData(array $data, array $discriminatorMapping, ?object $objectToPopulate, string $type, array $context): array { // A class declaring its own map is resolved again by the Symfony serializer, which reads the type property of that map - $resolvedTypeProperty = null === $objectToPopulate ? $this->classDiscriminatorResolver?->getMappingForClass($type)?->getTypeProperty() : null; + $resolvedTypeProperty = null === $objectToPopulate ? $this->resourceDiscriminatorResolver?->getMappingForClass($type)?->getTypeProperty() : null; foreach ($discriminatorMapping['mappings'] as $mapping) { $typeProperty = $mapping->getTypeProperty(); if (!\array_key_exists($typeProperty, $data)) { @@ -546,7 +592,7 @@ private function prepareDiscriminatedData(array $data, array $discriminatorMappi } // The type of an existing object cannot be changed - if (null !== $objectToPopulate && (!\is_string($data[$typeProperty]) || null === ($typeClass = $mapping->getClassForType($data[$typeProperty])) || !$objectToPopulate instanceof $typeClass)) { + if (null !== $objectToPopulate && (!\is_string($data[$typeProperty]) || null === ($typeClass = $mapping->getClassForType($data[$typeProperty])) || $typeClass !== $this->getMostSpecificMappedClass($mapping, $objectToPopulate))) { throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type "%s" does not match the type of the object being updated.', \is_scalar($data[$typeProperty]) ? $data[$typeProperty] : get_debug_type($data[$typeProperty])), $data[$typeProperty], ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$typeProperty : $typeProperty, true); } @@ -559,20 +605,48 @@ private function prepareDiscriminatedData(array $data, array $discriminatorMappi return $data; } + /** + * A map can list a class along with its own subclasses: the object is only of the most specific one. + */ + private function getMostSpecificMappedClass(ClassDiscriminatorMapping $mapping, object $object): ?string + { + $mostSpecificClass = null; + foreach ($mapping->getTypesMapping() as $class) { + if ($object instanceof $class && (null === $mostSpecificClass || is_a($class, $mostSpecificClass, true))) { + $mostSpecificClass = $class; + } + } + + return $mostSpecificClass; + } + private function getDiscriminatorTypeValue(object $object, string $attribute, string $resourceClass): ?string { - if (null === $this->classDiscriminatorResolver?->getMappingForMappedObject($object) || !$this->resourceClassResolver->isResourceClass($resourceClass)) { + if (null === $this->resourceDiscriminatorResolver) { return null; } - $discriminatorMapping = $this->getDiscriminatorMapping($this->resourceClassResolver->getResourceClass(null, $resourceClass), $this->getObjectClass($object)); - foreach ($discriminatorMapping['mappings'] ?? [] as $mapping) { - if ($attribute === $mapping->getTypeProperty()) { - return $mapping->getMappedObjectType($object); - } + $class = $this->getObjectClass($object); + $typeMappings = $this->discriminatorTypeMappingsCache[$resourceClass.'|'.$class] ??= $this->getDiscriminatorTypeMappings($resourceClass, $class); + + return isset($typeMappings[$attribute]) ? $typeMappings[$attribute]->getMappedObjectType($object) : null; + } + + /** + * @return array the discriminator maps of the resource the class belongs to, indexed by type property + */ + private function getDiscriminatorTypeMappings(string $resourceClass, string $class): array + { + if (!$this->resourceClassResolver->isResourceClass($resourceClass)) { + return []; + } + + $typeMappings = []; + foreach ($this->getDiscriminatorMapping($this->resourceClassResolver->getResourceClass(null, $resourceClass), $class)['mappings'] ?? [] as $mapping) { + $typeMappings[$mapping->getTypeProperty()] ??= $mapping; } - return null; + return $typeMappings; } protected function createConstructorArgument(mixed $parameterData, string $key, \ReflectionParameter $constructorParameter, array $context, ?string $format = null): mixed @@ -635,7 +709,7 @@ protected function getAllowedAttributes(string|object $classOrObject, array $con } // The type property of the map declared by the class being created is read by the serializer to resolve the class - if (isset($context['api_denormalize']) && \is_string($classOrObject) && null !== ($typeProperty = $this->classDiscriminatorResolver?->getMappingForClass($classOrObject)?->getTypeProperty()) && !\in_array($typeProperty, $allowedAttributes, true)) { + if (isset($context['api_denormalize']) && \is_string($classOrObject) && null !== ($typeProperty = $this->resourceDiscriminatorResolver?->getMappingForClass($classOrObject)?->getTypeProperty()) && !\in_array($typeProperty, $allowedAttributes, true)) { $allowedAttributes[] = $typeProperty; } @@ -723,7 +797,7 @@ protected function isCacheKeySafe(array $context): bool $this->safeCacheKeysCache[$cacheKey] = true; // Subtypes declared in the discriminator map of the resource are exposed too, their properties must be checked as well - foreach ([$resourceClass, ...(null === $this->classDiscriminatorResolver ? [] : ClassDiscriminatorHelper::getSubtypes($this->classDiscriminatorResolver, $resourceClass))] as $class) { + foreach ([$resourceClass, ...(null === $this->resourceDiscriminatorResolver ? [] : ClassDiscriminatorHelper::getSubtypes($this->resourceDiscriminatorResolver, $resourceClass))] as $class) { foreach ($this->propertyNameCollectionFactory->create($class, $options) as $propertyName) { $propertyMetadata = $this->propertyMetadataFactory->create($class, $propertyName, $options); if (null !== ($propertyMetadata->getSecurity() ?? $propertyMetadata->getPolicy())) { @@ -760,7 +834,7 @@ protected function canAccessAttributePostDenormalize(?object $object, ?object $p protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []): void { // The type property is computed from the discriminator map, it is not a writable property of the object - if ($attribute === $this->classDiscriminatorResolver?->getMappingForMappedObject($object)?->getTypeProperty() && !property_exists($object, $attribute)) { + if (null !== $this->resourceDiscriminatorResolver && $attribute === ($this->discriminatorTypePropertyCache[$this->getObjectClass($object)] ??= $this->resourceDiscriminatorResolver->getMappingForMappedObject($object)?->getTypeProperty() ?? false) && !property_exists($object, $attribute)) { return; } diff --git a/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php b/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php index 0d66dc5ed04..2976d25e0a9 100644 --- a/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php +++ b/src/Symfony/Bundle/DependencyInjection/ApiPlatformExtension.php @@ -59,6 +59,7 @@ use ApiPlatform\Metadata\UrlGeneratorInterface; use ApiPlatform\OpenApi\Model\Tag; use ApiPlatform\RamseyUuid\Serializer\UuidDenormalizer; +use ApiPlatform\Serializer\AbstractItemNormalizer; use ApiPlatform\State\ApiResource\Error; use ApiPlatform\State\ParameterProviderInterface; use ApiPlatform\State\ProcessorInterface; @@ -346,7 +347,16 @@ private function registerCommonConfiguration(ContainerBuilder $container, array $container->setDefinition('serializer.normalizer.number', $numberNormalizerDefinition); } - $defaultContext = ['hydra_prefix' => $config['serializer']['hydra_prefix']] + ($container->hasParameter('serializer.default_context') ? $container->getParameter('serializer.default_context') : []); + // Doctrine discriminator maps are exposed as serializer discriminator maps: they need resource polymorphism + $discriminatorMap = $config['serializer']['discriminator_map'] + || ($this->isConfigEnabled($container, $config['doctrine']) && $config['doctrine']['discriminator_map']) + || ($this->isConfigEnabled($container, $config['doctrine_mongodb_odm']) && $config['doctrine_mongodb_odm']['discriminator_map']); + $container->setParameter('api_platform.serializer.discriminator_map', $discriminatorMap); + if ($discriminatorMap) { + $container->setAlias('api_platform.serializer.class_discriminator_resolver', 'serializer.mapping.class_discriminator_resolver'); + } + + $defaultContext = ['hydra_prefix' => $config['serializer']['hydra_prefix'], AbstractItemNormalizer::DISCRIMINATOR_MAP => $discriminatorMap] + ($container->hasParameter('serializer.default_context') ? $container->getParameter('serializer.default_context') : []); $container->setParameter('api_platform.serializer.default_context', $defaultContext); if (!$container->hasParameter('serializer.default_context')) { @@ -725,7 +735,7 @@ private function registerJsonApiConfiguration(ContainerBuilder $container, array $itemNormalizer->replaceArgument(7, [ JsonApiItemNormalizer::ALLOW_CLIENT_GENERATED_ID => $config['jsonapi']['allow_client_generated_id'] ?? false, JsonApiItemNormalizer::STRICT_RESOURCE_TYPE => $config['jsonapi']['strict_resource_type'] ?? false, - ]); + ] + $itemNormalizer->getArgument(7)); $itemNormalizer->addArgument($useIriAsId); $itemNormalizer->addArgument(new Reference('api_platform.jsonapi.resource_linkage_resolver')); @@ -733,7 +743,7 @@ private function registerJsonApiConfiguration(ContainerBuilder $container, array $itemDenormalizer->replaceArgument(7, [ JsonApiItemNormalizer::ALLOW_CLIENT_GENERATED_ID => $config['jsonapi']['allow_client_generated_id'] ?? false, JsonApiItemNormalizer::STRICT_RESOURCE_TYPE => $config['jsonapi']['strict_resource_type'] ?? false, - ]); + ] + $itemDenormalizer->getArgument(7)); $itemDenormalizer->addArgument($useIriAsId); } diff --git a/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php b/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php index 61546662208..0ba7267ada4 100644 --- a/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php +++ b/src/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPass.php @@ -15,6 +15,8 @@ use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; +use Symfony\Component\DependencyInjection\Definition; +use Symfony\Component\Serializer\Mapping\Loader\LoaderChain; final class SerializerMappingLoaderPass implements CompilerPassInterface { @@ -22,17 +24,20 @@ public function process(ContainerBuilder $container): void { $chainLoader = $container->getDefinition('serializer.mapping.chain_loader'); $loaders = $chainLoader->getArgument(0); - $loaders[] = $container->getDefinition('api_platform.serializer.property_metadata_loader'); + $warmerLoaders = [...$loaders, $container->getDefinition('api_platform.serializer.property_metadata_loader')]; // Doctrine discriminator maps are loaded last so explicit serializer maps take precedence foreach (['api_platform.doctrine.orm.serializer.discriminator_mapping_loader', 'api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader'] as $id) { if ($container->hasDefinition($id)) { $loader = $container->getDefinition($id); - $loaders[] = $loader; + // The explicit serializer loaders (attributes, XML, YAML) tell whether a class of the hierarchy declares its own map + $loader->setArgument('$serializerLoader', new Definition(LoaderChain::class, [$loaders])); $chainLoader->replaceArgument(0, [...$chainLoader->getArgument(0), $loader]); + // The warmer builds the final metadata of the classes mapped by the other loaders: without the Doctrine map they would lose their subtypes + $warmerLoaders[] = $loader; } } - $container->getDefinition('serializer.mapping.cache_warmer')->replaceArgument(0, $loaders); + $container->getDefinition('serializer.mapping.cache_warmer')->replaceArgument(0, $warmerLoaders); } } diff --git a/src/Symfony/Bundle/DependencyInjection/Configuration.php b/src/Symfony/Bundle/DependencyInjection/Configuration.php index a559c9aa86f..1a151c7993d 100644 --- a/src/Symfony/Bundle/DependencyInjection/Configuration.php +++ b/src/Symfony/Bundle/DependencyInjection/Configuration.php @@ -173,6 +173,7 @@ public function getConfigTreeBuilder(): TreeBuilder ->addDefaultsIfNotSet() ->children() ->booleanNode('hydra_prefix')->defaultFalse()->info('Use the "hydra:" prefix.')->end() + ->booleanNode('discriminator_map')->defaultFalse()->info('Expose the subtypes declared in the serializer discriminator map of a resource (polymorphic resources): subtype properties are readable, writable and documented. Always enabled when "doctrine.discriminator_map" or "doctrine_mongodb_odm.discriminator_map" is.')->end() ->end() ->end() ->end(); diff --git a/src/Symfony/Bundle/Resources/config/api.php b/src/Symfony/Bundle/Resources/config/api.php index 65bfb38c5f1..30a49d3a651 100644 --- a/src/Symfony/Bundle/Resources/config/api.php +++ b/src/Symfony/Bundle/Resources/config/api.php @@ -172,7 +172,7 @@ null, service('api_platform.metadata.resource.metadata_collection_factory')->ignoreOnInvalid(), service('api_platform.security.resource_access_checker')->ignoreOnInvalid(), - [], + ['discriminator_map' => '%api_platform.serializer.discriminator_map%'], service('api_platform.http_cache.tag_collector')->ignoreOnInvalid(), service('api_platform.serializer.operation_resource_resolver'), ]) @@ -191,7 +191,7 @@ null, service('api_platform.metadata.resource.metadata_collection_factory')->ignoreOnInvalid(), service('api_platform.security.resource_access_checker')->ignoreOnInvalid(), - [], + ['discriminator_map' => '%api_platform.serializer.discriminator_map%'], service('api_platform.http_cache.tag_collector')->ignoreOnInvalid(), service('api_platform.serializer.operation_resource_resolver'), ]) diff --git a/src/Symfony/Bundle/Resources/config/hal.php b/src/Symfony/Bundle/Resources/config/hal.php index b94f88b30a1..ae5b1ff8b4c 100644 --- a/src/Symfony/Bundle/Resources/config/hal.php +++ b/src/Symfony/Bundle/Resources/config/hal.php @@ -60,7 +60,7 @@ service('api_platform.property_accessor'), service('api_platform.name_converter')->ignoreOnInvalid(), service('serializer.mapping.class_metadata_factory')->ignoreOnInvalid(), - [], + ['discriminator_map' => '%api_platform.serializer.discriminator_map%'], service('api_platform.metadata.resource.metadata_collection_factory')->ignoreOnInvalid(), service('api_platform.security.resource_access_checker')->ignoreOnInvalid(), service('api_platform.http_cache.tag_collector')->ignoreOnInvalid(), diff --git a/src/Symfony/Bundle/Resources/config/hydra.php b/src/Symfony/Bundle/Resources/config/hydra.php index 1ce0d98c9d5..acec80bf1bf 100644 --- a/src/Symfony/Bundle/Resources/config/hydra.php +++ b/src/Symfony/Bundle/Resources/config/hydra.php @@ -45,6 +45,7 @@ service('api_platform.name_converter')->ignoreOnInvalid(), '%api_platform.serializer.default_context%', '%api_platform.enable_entrypoint%', + service('api_platform.serializer.class_discriminator_resolver')->ignoreOnInvalid(), ]) ->tag('serializer.normalizer', ['priority' => -800]); diff --git a/src/Symfony/Bundle/Resources/config/json_schema.php b/src/Symfony/Bundle/Resources/config/json_schema.php index 6a091d684b7..d2228da3db4 100644 --- a/src/Symfony/Bundle/Resources/config/json_schema.php +++ b/src/Symfony/Bundle/Resources/config/json_schema.php @@ -31,7 +31,7 @@ service('api_platform.name_converter')->ignoreOnInvalid(), service('api_platform.resource_class_resolver'), service('api_platform.json_schema.definition_name_factory')->ignoreOnInvalid(), - service('serializer.mapping.class_discriminator_resolver')->ignoreOnInvalid(), + service('api_platform.serializer.class_discriminator_resolver')->ignoreOnInvalid(), ]); $services->alias(SchemaFactoryInterface::class, 'api_platform.json_schema.schema_factory'); diff --git a/src/Symfony/Bundle/Resources/config/jsonapi.php b/src/Symfony/Bundle/Resources/config/jsonapi.php index e7d6b0d312f..be103d16f90 100644 --- a/src/Symfony/Bundle/Resources/config/jsonapi.php +++ b/src/Symfony/Bundle/Resources/config/jsonapi.php @@ -43,7 +43,7 @@ service('api_platform.json_schema.definition_name_factory')->ignoreOnInvalid(), service('api_platform.jsonapi.resource_linkage_resolver'), false, - service('serializer.mapping.class_discriminator_resolver')->ignoreOnInvalid(), + service('api_platform.serializer.class_discriminator_resolver')->ignoreOnInvalid(), ]); $services->set('api_platform.jsonapi.encoder', JsonEncoder::class) @@ -78,7 +78,7 @@ service('api_platform.property_accessor'), service('api_platform.jsonapi.name_converter.reserved_attribute_name'), service('serializer.mapping.class_metadata_factory')->ignoreOnInvalid(), - [], + ['discriminator_map' => '%api_platform.serializer.discriminator_map%'], service('api_platform.metadata.resource.metadata_collection_factory'), service('api_platform.security.resource_access_checker')->ignoreOnInvalid(), service('api_platform.http_cache.tag_collector')->ignoreOnInvalid(), @@ -97,7 +97,7 @@ service('api_platform.property_accessor'), service('api_platform.jsonapi.name_converter.reserved_attribute_name'), service('serializer.mapping.class_metadata_factory')->ignoreOnInvalid(), - [], + ['discriminator_map' => '%api_platform.serializer.discriminator_map%'], service('api_platform.metadata.resource.metadata_collection_factory'), service('api_platform.security.resource_access_checker')->ignoreOnInvalid(), service('api_platform.http_cache.tag_collector')->ignoreOnInvalid(), diff --git a/src/Symfony/Bundle/Resources/config/jsonld.php b/src/Symfony/Bundle/Resources/config/jsonld.php index 368295f0ea8..8162fb565e6 100644 --- a/src/Symfony/Bundle/Resources/config/jsonld.php +++ b/src/Symfony/Bundle/Resources/config/jsonld.php @@ -34,6 +34,7 @@ service('api_platform.symfony.iri_converter.skolem'), service('api_platform.name_converter'), '%api_platform.serializer.default_context%', + service('api_platform.serializer.class_discriminator_resolver')->ignoreOnInvalid(), ]); $services->set('api_platform.jsonld.normalizer.item', ItemNormalizer::class) diff --git a/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php b/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php index 5c0268deaab..52179869e13 100644 --- a/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php +++ b/src/Symfony/Tests/Bundle/DependencyInjection/ApiPlatformExtensionTest.php @@ -666,5 +666,26 @@ public function testDoctrineDiscriminatorMappingLoadersCanBeEnabled(): void $this->assertContainerHasService('api_platform.doctrine.orm.serializer.discriminator_mapping_loader'); $this->assertContainerHasService('api_platform.doctrine_mongodb.odm.serializer.discriminator_mapping_loader'); + // Doctrine discriminator maps need resource polymorphism + $this->assertTrue($this->container->getParameter('api_platform.serializer.discriminator_map')); + } + + public function testResourcePolymorphismIsDisabledByDefault(): void + { + (new ApiPlatformExtension())->load(self::DEFAULT_CONFIG, $this->container); + + $this->assertFalse($this->container->getParameter('api_platform.serializer.discriminator_map')); + $this->assertFalse($this->container->getParameter('api_platform.serializer.default_context')['discriminator_map']); + $this->assertFalse($this->container->hasAlias('api_platform.serializer.class_discriminator_resolver')); + } + + public function testResourcePolymorphismCanBeEnabled(): void + { + $config = self::DEFAULT_CONFIG; + $config['api_platform']['serializer']['discriminator_map'] = true; + (new ApiPlatformExtension())->load($config, $this->container); + + $this->assertTrue($this->container->getParameter('api_platform.serializer.default_context')['discriminator_map']); + $this->assertSame('serializer.mapping.class_discriminator_resolver', (string) $this->container->getAlias('api_platform.serializer.class_discriminator_resolver')); } } diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetCat.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBike.php similarity index 63% rename from tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetCat.php rename to tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBike.php index eee06293fa6..717c7597fde 100644 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetCat.php +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBike.php @@ -15,11 +15,11 @@ use Symfony\Component\Serializer\Attribute\DiscriminatorMap; -#[DiscriminatorMap(typeProperty: 'breed', mapping: [ - 'persian' => DiscriminatedPersianCat::class, - 'siamese' => DiscriminatedSiameseCat::class, +#[DiscriminatorMap(typeProperty: 'frame', mapping: [ + 'bike' => DiscriminatedBike::class, + 'mountain' => DiscriminatedMountainBike::class, ])] -abstract class DiscriminatedPetCat extends DiscriminatedPet +class DiscriminatedBike extends DiscriminatedVehicle { - public int $lives = 9; + public int $gears = 1; } diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.php deleted file mode 100644 index 4eadb1a0cea..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBook.php +++ /dev/null @@ -1,81 +0,0 @@ - - * - * 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\DiscriminatedResource; - -use ApiPlatform\Metadata\ApiProperty; -use ApiPlatform\Metadata\ApiResource; -use ApiPlatform\Metadata\Delete; -use ApiPlatform\Metadata\Get; -use ApiPlatform\Metadata\GetCollection; -use ApiPlatform\Metadata\Operation; -use ApiPlatform\Metadata\Patch; -use ApiPlatform\Metadata\Post; -use ApiPlatform\Metadata\Put; -use Symfony\Component\Serializer\Attribute\DiscriminatorMap; -use Symfony\Component\Validator\Constraints as Assert; - -/** - * Abstract resource exposing its subtypes through a serializer discriminator map. - * Subtypes are not resources themselves: the discriminator map is the contract declaring them. - */ -#[ApiResource( - operations: [ - new Get(), - new GetCollection(), - new Post(), - new Put(), - new Patch(), - new Delete(), - ], - provider: [self::class, 'provide'], - processor: [self::class, 'process'], -)] -#[DiscriminatorMap(typeProperty: 'kind', mapping: [ - 'fiction' => DiscriminatedFictionBook::class, - 'technical' => DiscriminatedTechnicalBook::class, -])] -abstract class DiscriminatedBook -{ - #[ApiProperty(identifier: true, writable: false)] - public ?int $id = null; - - #[Assert\NotBlank] - public string $title = ''; - - public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null - { - if ($operation instanceof GetCollection) { - return array_values(DiscriminatedBookStore::$books); - } - - return DiscriminatedBookStore::$books[(int) $uriVariables['id']] ?? null; - } - - public static function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): ?self - { - if ($operation instanceof Delete) { - unset(DiscriminatedBookStore::$books[(int) $uriVariables['id']]); - - return null; - } - - if (isset($uriVariables['id'])) { - $data->id = (int) $uriVariables['id']; - } - - $data->id ??= (DiscriminatedBookStore::$books ? max(array_keys(DiscriminatedBookStore::$books)) : 0) + 1; - - return DiscriminatedBookStore::$books[$data->id] = $data; - } -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php deleted file mode 100644 index fcd81038291..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedBookStore.php +++ /dev/null @@ -1,22 +0,0 @@ - - * - * 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\DiscriminatedResource; - -final class DiscriminatedBookStore -{ - /** - * @var array - */ - public static array $books = []; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php deleted file mode 100644 index cf62be4b3a6..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedFictionBook.php +++ /dev/null @@ -1,26 +0,0 @@ - - * - * 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\DiscriminatedResource; - -use Symfony\Component\Validator\Constraints as Assert; - -class DiscriminatedFictionBook extends DiscriminatedBook -{ - public ?string $genre = null; - - #[Assert\Positive] - public ?int $pageCount = null; - - public ?DiscriminatedBook $sequelOf = null; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php deleted file mode 100644 index 85ee25c1fef..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadget.php +++ /dev/null @@ -1,70 +0,0 @@ - - * - * 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\DiscriminatedResource; - -use ApiPlatform\Metadata\ApiProperty; -use ApiPlatform\Metadata\ApiResource; -use ApiPlatform\Metadata\Get; -use ApiPlatform\Metadata\GetCollection; -use ApiPlatform\Metadata\Operation; -use ApiPlatform\Metadata\Patch; -use ApiPlatform\Metadata\Post; -use Symfony\Component\Serializer\Attribute\DiscriminatorMap; - -/** - * Concrete resource declaring itself in its own discriminator map. - */ -#[ApiResource( - operations: [ - new Get(), - new GetCollection(), - new Post(), - new Patch(), - ], - normalizationContext: ['allow_extra_attributes' => false], - denormalizationContext: ['allow_extra_attributes' => false], - provider: [self::class, 'provide'], - processor: [self::class, 'process'], -)] -#[DiscriminatorMap(typeProperty: 'kind', mapping: [ - 'gadget' => DiscriminatedGadget::class, - 'phone' => DiscriminatedPhone::class, -])] -class DiscriminatedGadget -{ - #[ApiProperty(identifier: true, writable: false)] - public ?int $id = null; - - public string $name = ''; - - public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null - { - if ($operation instanceof GetCollection) { - return array_values(DiscriminatedGadgetStore::$gadgets); - } - - return DiscriminatedGadgetStore::$gadgets[(int) $uriVariables['id']] ?? null; - } - - public static function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): self - { - if (isset($uriVariables['id'])) { - $data->id = (int) $uriVariables['id']; - } - - $data->id ??= (DiscriminatedGadgetStore::$gadgets ? max(array_keys(DiscriminatedGadgetStore::$gadgets)) : 0) + 1; - - return DiscriminatedGadgetStore::$gadgets[$data->id] = $data; - } -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php deleted file mode 100644 index 162e99786ae..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedGadgetStore.php +++ /dev/null @@ -1,22 +0,0 @@ - - * - * 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\DiscriminatedResource; - -final class DiscriminatedGadgetStore -{ - /** - * @var array - */ - public static array $gadgets = []; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSiameseCat.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedMountainBike.php similarity index 77% rename from tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSiameseCat.php rename to tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedMountainBike.php index 7d704224546..5a06c6ba11d 100644 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSiameseCat.php +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedMountainBike.php @@ -13,7 +13,7 @@ namespace ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource; -final class DiscriminatedSiameseCat extends DiscriminatedPetCat +final class DiscriminatedMountainBike extends DiscriminatedBike { - public ?string $eyeColor = null; + public ?string $suspension = null; } diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php deleted file mode 100644 index 33bd41f71f7..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPersianCat.php +++ /dev/null @@ -1,19 +0,0 @@ - - * - * 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\DiscriminatedResource; - -final class DiscriminatedPersianCat extends DiscriminatedPetCat -{ - public ?string $furLength = null; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php deleted file mode 100644 index 3390bcbe020..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPet.php +++ /dev/null @@ -1,71 +0,0 @@ - - * - * 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\DiscriminatedResource; - -use ApiPlatform\Metadata\ApiProperty; -use ApiPlatform\Metadata\ApiResource; -use ApiPlatform\Metadata\Get; -use ApiPlatform\Metadata\GetCollection; -use ApiPlatform\Metadata\Operation; -use ApiPlatform\Metadata\Patch; -use ApiPlatform\Metadata\Post; -use Symfony\Component\Serializer\Attribute\DiscriminatorMap; - -/** - * Resource whose discriminator map contains a subtype declaring its own (nested) discriminator map. - */ -#[ApiResource( - operations: [ - new Get(), - new GetCollection(), - new Post(), - new Patch(), - ], - // input and output share their definitions: the flag is set on both so the JSON Schema restricts additional properties - normalizationContext: ['allow_extra_attributes' => false], - denormalizationContext: ['allow_extra_attributes' => false], - provider: [self::class, 'provide'], - processor: [self::class, 'process'], -)] -#[DiscriminatorMap(typeProperty: 'kind', mapping: [ - 'cat' => DiscriminatedPetCat::class, - 'dog' => DiscriminatedPetDog::class, -])] -abstract class DiscriminatedPet -{ - #[ApiProperty(identifier: true, writable: false)] - public ?int $id = null; - - public string $name = ''; - - public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null - { - if ($operation instanceof GetCollection) { - return array_values(DiscriminatedPetStore::$pets); - } - - return DiscriminatedPetStore::$pets[(int) $uriVariables['id']] ?? null; - } - - public static function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): self - { - if (isset($uriVariables['id'])) { - $data->id = (int) $uriVariables['id']; - } - - $data->id ??= (DiscriminatedPetStore::$pets ? max(array_keys(DiscriminatedPetStore::$pets)) : 0) + 1; - - return DiscriminatedPetStore::$pets[$data->id] = $data; - } -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php deleted file mode 100644 index 0410a23a7fb..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetDog.php +++ /dev/null @@ -1,19 +0,0 @@ - - * - * 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\DiscriminatedResource; - -final class DiscriminatedPetDog extends DiscriminatedPet -{ - public bool $goodBoy = true; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php deleted file mode 100644 index 1fec718d9ca..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPetStore.php +++ /dev/null @@ -1,22 +0,0 @@ - - * - * 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\DiscriminatedResource; - -final class DiscriminatedPetStore -{ - /** - * @var array - */ - public static array $pets = []; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php deleted file mode 100644 index cda6fe5b28f..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedPhone.php +++ /dev/null @@ -1,19 +0,0 @@ - - * - * 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\DiscriminatedResource; - -class DiscriminatedPhone extends DiscriminatedGadget -{ - public string $number = ''; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php deleted file mode 100644 index 94c470e15de..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedSignedFictionBook.php +++ /dev/null @@ -1,22 +0,0 @@ - - * - * 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\DiscriminatedResource; - -/** - * Extends a mapped subtype without being declared in the discriminator map: its own properties must never be exposed. - */ -final class DiscriminatedSignedFictionBook extends DiscriminatedFictionBook -{ - public ?string $signature = null; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php deleted file mode 100644 index 45c71310936..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTechnicalBook.php +++ /dev/null @@ -1,24 +0,0 @@ - - * - * 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\DiscriminatedResource; - -use ApiPlatform\Metadata\ApiProperty; - -final class DiscriminatedTechnicalBook extends DiscriminatedBook -{ - public ?string $programmingLanguage = null; - - #[ApiProperty(security: "is_granted('ROLE_ADMIN')")] - public ?string $internalNote = null; -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php index 5411a0f8499..20e92a8338e 100644 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedTruck.php @@ -41,9 +41,4 @@ public function getTrailer(): ?self return $this->trailer; } - - public function getRating(): int - { - return 4; - } } diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php index 172dcddd8c4..ca80987a2cd 100644 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php +++ b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/DiscriminatedVehicle.php @@ -26,7 +26,8 @@ use Symfony\Component\Validator\Constraints as Assert; /** - * Discriminated resource whose subtypes override inherited properties (narrowed types, metadata, constraints). + * Polymorphic resource: its subtypes override inherited properties (narrowed types, metadata, constraints), + * bikes are discriminated by a nested map listing the bike itself. */ #[ApiResource( operations: [ @@ -43,6 +44,7 @@ #[DiscriminatorMap(typeProperty: 'kind', mapping: [ 'car' => DiscriminatedCar::class, 'truck' => DiscriminatedTruck::class, + 'bike' => DiscriminatedBike::class, ])] abstract class DiscriminatedVehicle { @@ -68,11 +70,6 @@ public function setTrailer(?self $trailer): void $this->trailer = $trailer; } - public function getRating(): int|float - { - return 4.5; - } - public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self|array|null { if ($operation instanceof GetCollection) { diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php deleted file mode 100644 index dedfd50a9f5..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedBook.php +++ /dev/null @@ -1,43 +0,0 @@ - - * - * 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\DiscriminatedResource; - -use ApiPlatform\Metadata\ApiProperty; -use ApiPlatform\Metadata\ApiResource; -use ApiPlatform\Metadata\Get; -use ApiPlatform\Metadata\Operation; - -/** - * Abstract resource without a serializer discriminator map: subclass properties must stay hidden. - * - * @see https://github.com/api-platform/core/issues/2931 - */ -#[ApiResource(operations: [new Get(provider: [self::class, 'provide'])])] -abstract class UndiscriminatedBook -{ - #[ApiProperty(identifier: true)] - public ?int $id = null; - - public string $title = ''; - - public static function provide(Operation $operation, array $uriVariables = [], array $context = []): self - { - $book = new UndiscriminatedSecretBook(); - $book->id = (int) $uriVariables['id']; - $book->title = 'Hidden'; - $book->secret = 'must not leak'; - - return $book; - } -} diff --git a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php b/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php deleted file mode 100644 index c8abc8e9e1e..00000000000 --- a/tests/Fixtures/TestBundle/ApiResource/DiscriminatedResource/UndiscriminatedSecretBook.php +++ /dev/null @@ -1,19 +0,0 @@ - - * - * 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\DiscriminatedResource; - -final class UndiscriminatedSecretBook extends UndiscriminatedBook -{ - public ?string $secret = null; -} diff --git a/tests/Fixtures/app/config/config_common.yml b/tests/Fixtures/app/config/config_common.yml index b1d280c406f..606c7bbc028 100644 --- a/tests/Fixtures/app/config/config_common.yml +++ b/tests/Fixtures/app/config/config_common.yml @@ -46,6 +46,8 @@ api_platform: Made with love enable_swagger: true enable_swagger_ui: true + serializer: + discriminator_map: true formats: jsonld: ['application/ld+json'] jsonhal: ['application/hal+json'] diff --git a/tests/Functional/DiscriminatedNestedResourceTest.php b/tests/Functional/DiscriminatedNestedResourceTest.php deleted file mode 100644 index 4ba1835513a..00000000000 --- a/tests/Functional/DiscriminatedNestedResourceTest.php +++ /dev/null @@ -1,231 +0,0 @@ - - * - * 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; - -use ApiPlatform\Test\ApiTestCase; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPersianCat; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPet; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPetDog; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPetStore; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedSiameseCat; -use ApiPlatform\Tests\SetupClassResourcesTrait; -use JsonSchema\Validator; -use PHPUnit\Framework\Attributes\DataProvider; - -/** - * Polymorphic resources whose discriminator map contains a subtype declaring its own discriminator map. - */ -final class DiscriminatedNestedResourceTest extends ApiTestCase -{ - use SetupClassResourcesTrait; - - protected static ?bool $alwaysBootKernel = false; - - /** - * @return class-string[] - */ - public static function getResources(): array - { - return [DiscriminatedPet::class]; - } - - protected function setUp(): void - { - $persian = new DiscriminatedPersianCat(); - $persian->id = 1; - $persian->name = 'Garfield'; - $persian->lives = 7; - $persian->furLength = 'long'; - - $dog = new DiscriminatedPetDog(); - $dog->id = 2; - $dog->name = 'Odie'; - - DiscriminatedPetStore::$pets = [1 => $persian, 2 => $dog]; - } - - protected function tearDown(): void - { - DiscriminatedPetStore::$pets = []; - - parent::tearDown(); - } - - public function testGetItemExposesTheTypeOfEveryMap(): void - { - $response = self::createClient()->request('GET', '/discriminated_pets/1'); - - $this->assertResponseIsSuccessful(); - $this->assertEquals([ - '@context' => '/contexts/DiscriminatedPet', - '@id' => '/discriminated_pets/1', - '@type' => 'DiscriminatedPet', - 'kind' => 'cat', - 'breed' => 'persian', - 'id' => 1, - 'name' => 'Garfield', - 'lives' => 7, - 'furLength' => 'long', - ], $response->toArray()); - } - - /** - * @return iterable - */ - public static function formatProvider(): iterable - { - yield 'json' => ['application/json']; - yield 'jsonapi' => ['application/vnd.api+json']; - yield 'hal' => ['application/hal+json']; - } - - #[DataProvider('formatProvider')] - public function testGetItemInOtherFormats(string $accept): void - { - $json = self::createClient()->request('GET', '/discriminated_pets/1', ['headers' => ['Accept' => $accept]])->toArray(); - - $this->assertResponseIsSuccessful(); - $attributes = $json['data']['attributes'] ?? $json; - $this->assertSame('cat', $attributes['kind']); - $this->assertSame('persian', $attributes['breed']); - $this->assertSame('long', $attributes['furLength']); - } - - public function testGetCollection(): void - { - $members = self::createClient()->request('GET', '/discriminated_pets')->toArray()['hydra:member']; - - $this->assertResponseIsSuccessful(); - $this->assertSame(['cat', 'dog'], array_column($members, 'kind')); - $this->assertSame('persian', $members[0]['breed']); - $this->assertArrayNotHasKey('breed', $members[1]); - $this->assertTrue($members[1]['goodBoy']); - } - - public function testPostCreatesTheMostSpecificSubtype(): void - { - self::createClient()->request('POST', '/discriminated_pets', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'cat', 'breed' => 'siamese', 'name' => 'Tom', 'lives' => 3, 'eyeColor' => 'blue'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains(['kind' => 'cat', 'breed' => 'siamese', 'name' => 'Tom', 'lives' => 3, 'eyeColor' => 'blue']); - $this->assertInstanceOf(DiscriminatedSiameseCat::class, DiscriminatedPetStore::$pets[3]); - $this->assertSame('blue', DiscriminatedPetStore::$pets[3]->eyeColor); - } - - public function testPostWithoutNestedTypeIsRejected(): void - { - self::createClient()->request('POST', '/discriminated_pets', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'cat', 'name' => 'Tom'], - ]); - - $this->assertResponseStatusCodeSame(400); - $this->assertArrayNotHasKey(3, DiscriminatedPetStore::$pets); - } - - public function testPostRejectsPropertiesOfAnotherSubtype(): void - { - self::createClient()->request('POST', '/discriminated_pets', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'cat', 'breed' => 'siamese', 'name' => 'Tom', 'furLength' => 'short'], - ]); - - $this->assertResponseStatusCodeSame(400); - } - - public function testPatchUpdatesNestedSubtypeProperties(): void - { - self::createClient()->request('PATCH', '/discriminated_pets/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['kind' => 'cat', 'breed' => 'persian', 'furLength' => 'short'], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['kind' => 'cat', 'breed' => 'persian', 'furLength' => 'short']); - $this->assertInstanceOf(DiscriminatedPersianCat::class, DiscriminatedPetStore::$pets[1]); - } - - public function testPatchCannotChangeTheNestedType(): void - { - self::createClient()->request('PATCH', '/discriminated_pets/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['breed' => 'siamese'], - ]); - - $this->assertResponseStatusCodeSame(400); - $this->assertInstanceOf(DiscriminatedPersianCat::class, DiscriminatedPetStore::$pets[1]); - } - - public function testOpenApiDocumentsNestedSubtypes(): void - { - $json = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray(); - $schemas = $json['components']['schemas']; - - $cat = $schemas['DiscriminatedPet.DiscriminatedPetCat']; - $this->assertSame('breed', $cat['discriminator']['propertyName']); - $this->assertCount(2, $cat['oneOf']); - - // A nested subtype documents the type properties of every map it belongs to. - $persian = $schemas['DiscriminatedPet.DiscriminatedPersianCat']; - $this->assertSame(['type' => 'string', 'enum' => ['cat']], $persian['properties']['kind']); - $this->assertSame(['type' => 'string', 'enum' => ['persian']], $persian['properties']['breed']); - $this->assertContains('kind', $persian['required']); - $this->assertContains('breed', $persian['required']); - $this->assertFalse($persian['additionalProperties']); - - // "additionalProperties" ignores "oneOf" branches: it must only restrict the leaf definitions. - $this->assertArrayNotHasKey('additionalProperties', $schemas['DiscriminatedPet']); - $this->assertArrayNotHasKey('additionalProperties', $cat); - $this->assertFalse($schemas['DiscriminatedPet.DiscriminatedPetDog']['additionalProperties']); - } - - /** - * @return iterable, bool}> - */ - public static function inputPayloadProvider(): iterable - { - yield 'dog' => [['kind' => 'dog', 'name' => 'Odie', 'goodBoy' => true], true]; - yield 'nested cat' => [['kind' => 'cat', 'breed' => 'persian', 'name' => 'Garfield', 'lives' => 7, 'furLength' => 'long'], true]; - yield 'property of a sibling subtype' => [['kind' => 'cat', 'breed' => 'persian', 'name' => 'Garfield', 'eyeColor' => 'blue'], false]; - yield 'unknown property' => [['kind' => 'dog', 'name' => 'Odie', 'unknown' => true], false]; - yield 'missing nested type' => [['kind' => 'cat', 'name' => 'Garfield'], false]; - } - - /** - * @param array $payload - */ - #[DataProvider('inputPayloadProvider')] - public function testInputSchemaValidatesPayloadsWhenExtraAttributesAreNotAllowed(array $payload, bool $valid): void - { - $json = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray(); - - $schema = json_decode(json_encode([ - '$ref' => $json['paths']['/discriminated_pets']['post']['requestBody']['content']['application/ld+json']['schema']['$ref'], - 'components' => ['schemas' => $json['components']['schemas']], - ])); - $data = json_decode(json_encode($payload)); - - $validator = new Validator(); - $validator->validate($data, $schema); - - $this->assertSame($valid, $validator->isValid(), json_encode($validator->getErrors())); - } -} diff --git a/tests/Functional/DiscriminatedResourceOverrideTest.php b/tests/Functional/DiscriminatedResourceOverrideTest.php deleted file mode 100644 index e5b026af82f..00000000000 --- a/tests/Functional/DiscriminatedResourceOverrideTest.php +++ /dev/null @@ -1,277 +0,0 @@ - - * - * 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; - -use ApiPlatform\Test\ApiTestCase; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedCar; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedSportsCar; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedTruck; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedVehicle; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedVehicleStore; -use ApiPlatform\Tests\SetupClassResourcesTrait; - -/** - * Subtypes of a discriminated resource overriding inherited properties. - */ -final class DiscriminatedResourceOverrideTest extends ApiTestCase -{ - use SetupClassResourcesTrait; - - protected static ?bool $alwaysBootKernel = false; - - /** - * @return class-string[] - */ - public static function getResources(): array - { - return [DiscriminatedVehicle::class]; - } - - protected function setUp(): void - { - $car = new DiscriminatedCar(); - $car->id = 1; - $car->name = 'Beetle'; - $car->plate = 'AB-123'; - - $truck = new DiscriminatedTruck(); - $truck->id = 2; - $truck->name = 'Actros'; - $truck->plate = 'TR-999'; - $truck->payload = 18000; - - $sportsCar = new DiscriminatedSportsCar(); - $sportsCar->id = 3; - $sportsCar->name = 'Carrera'; - $sportsCar->plate = 'SP-911'; - $sportsCar->topSpeed = '300'; - - DiscriminatedVehicleStore::$vehicles = [1 => $car, 2 => $truck, 3 => $sportsCar]; - } - - protected function tearDown(): void - { - DiscriminatedVehicleStore::$vehicles = []; - - parent::tearDown(); - } - - public function testOverriddenPropertyMetadataIsReadFromTheSubtype(): void - { - $client = self::createClient(); - - $car = $client->request('GET', '/discriminated_vehicles/1')->toArray(); - $this->assertSame('AB-123', $car['plate']); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); - - // The truck overrides "plate" with a security expression. - $truck = $client->request('GET', '/discriminated_vehicles/2')->toArray(); - $this->assertSame('truck', $truck['kind']); - $this->assertSame(18000, $truck['payload']); - $this->assertArrayNotHasKey('plate', $truck); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); - } - - public function testUnmappedSubclassIsExposedThroughItsMappedParentContract(): void - { - $response = self::createClient()->request('GET', '/discriminated_vehicles/3'); - - $this->assertResponseIsSuccessful(); - $json = $response->toArray(); - $this->assertSame('car', $json['kind']); - // Overrides declared on an unmapped subclass are not part of the documented contract. - $this->assertSame('Carrera', $json['name']); - $this->assertArrayNotHasKey('topSpeed', $json); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); - } - - public function testOverriddenWritabilityIsEnforced(): void - { - self::createClient()->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'car', 'name' => 'Golf', 'plate' => 'not writable on cars'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertNull(DiscriminatedVehicleStore::$vehicles[4]->plate); - } - - public function testOverriddenSecurityIsEnforcedOnWrite(): void - { - self::createClient()->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'truck', 'name' => 'Scania', 'plate' => 'admins only'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertNull(DiscriminatedVehicleStore::$vehicles[4]->plate); - } - - public function testOverriddenConstraintsAreValidated(): void - { - $client = self::createClient(); - - $client->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'truck', 'name' => 'MAN'], - ]); - $this->assertResponseStatusCodeSame(422); - $this->assertJsonContains(['violations' => [['propertyPath' => 'name']]]); - - $client->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'car', 'name' => 'Kia'], - ]); - $this->assertResponseStatusCodeSame(201); - } - - public function testNarrowedRelationAcceptsTheNarrowedType(): void - { - self::createClient()->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'car', 'name' => 'Polo', 'tows' => '/discriminated_vehicles/1'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains(['tows' => '/discriminated_vehicles/1']); - $this->assertSame(DiscriminatedVehicleStore::$vehicles[1], DiscriminatedVehicleStore::$vehicles[4]->tows); - } - - public function testNarrowedRelationRejectsAnIriOfAnotherSubtype(): void - { - self::createClient()->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'car', 'name' => 'Polo', 'tows' => '/discriminated_vehicles/2'], - ]); - - $this->assertResponseStatusCodeSame(400); - $this->assertCount(3, DiscriminatedVehicleStore::$vehicles); - } - - public function testNarrowedRelationRejectsAnIriOfAnotherSubtypeOnPatch(): void - { - self::createClient()->request('PATCH', '/discriminated_vehicles/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['tows' => '/discriminated_vehicles/2'], - ]); - - $this->assertResponseStatusCodeSame(400); - $this->assertNull(DiscriminatedVehicleStore::$vehicles[1]->tows); - } - - public function testInheritedRelationAcceptsAnySubtype(): void - { - self::createClient()->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'truck', 'name' => 'Volvo FH', 'tows' => '/discriminated_vehicles/1'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertSame(DiscriminatedVehicleStore::$vehicles[1], DiscriminatedVehicleStore::$vehicles[4]->tows); - } - - public function testCovariantGetterNarrowsTheReadType(): void - { - $trailer = new DiscriminatedTruck(); - $trailer->id = 5; - $trailer->name = 'Trailer truck'; - DiscriminatedVehicleStore::$vehicles[5] = $trailer; - DiscriminatedVehicleStore::$vehicles[2]->setTrailer($trailer); - $client = self::createClient(); - - $json = $client->request('GET', '/discriminated_vehicles/2')->toArray(); - $this->assertSame(4, $json['rating']); - $this->assertSame('/discriminated_vehicles/5', $json['trailer']); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); - - $json = $client->request('GET', '/discriminated_vehicles/1')->toArray(); - $this->assertSame(4.5, $json['rating']); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); - } - - public function testCovariantGetterAcceptsTheNarrowedTypeOnWrite(): void - { - $truck = new DiscriminatedTruck(); - $truck->id = 5; - $truck->name = 'Trailer truck'; - DiscriminatedVehicleStore::$vehicles[5] = $truck; - - self::createClient()->request('PATCH', '/discriminated_vehicles/2', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['trailer' => '/discriminated_vehicles/5'], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['trailer' => '/discriminated_vehicles/5']); - $this->assertSame($truck, DiscriminatedVehicleStore::$vehicles[2]->getTrailer()); - } - - /** - * A setter parameter cannot be narrowed (contravariance), so the write type is the inherited one: - * the narrowing of the covariant getter is enforced by validation. - */ - public function testCovariantGetterIsEnforcedOnWriteThroughValidation(): void - { - self::createClient()->request('POST', '/discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'truck', 'name' => 'Volvo FH', 'trailer' => '/discriminated_vehicles/1'], - ]); - - $this->assertResponseStatusCodeSame(422); - $this->assertJsonContains(['violations' => [['propertyPath' => 'trailer']]]); - $this->assertCount(3, DiscriminatedVehicleStore::$vehicles); - } - - public function testInheritedGetterAcceptsAnySubtypeOnWrite(): void - { - self::createClient()->request('PATCH', '/discriminated_vehicles/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['trailer' => '/discriminated_vehicles/2'], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertSame(DiscriminatedVehicleStore::$vehicles[2], DiscriminatedVehicleStore::$vehicles[1]->getTrailer()); - } - - public function testSchemaDocumentsCovariantReturnTypes(): void - { - $schemas = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray()['components']['schemas']; - - $this->assertSame('integer', $schemas['DiscriminatedVehicle.DiscriminatedTruck.jsonld']['properties']['rating']['type']); - $this->assertSame([['type' => 'number'], ['type' => 'integer']], $schemas['DiscriminatedVehicle.DiscriminatedCar.jsonld']['properties']['rating']['anyOf']); - } - - public function testSchemaDocumentsOverriddenProperties(): void - { - $json = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray(); - $schemas = $json['components']['schemas']; - - // Overridden writability: "plate" is read-only on cars, but still writable on trucks. - $this->assertTrue($schemas['DiscriminatedVehicle.DiscriminatedCar']['properties']['plate']['readOnly']); - $this->assertArrayNotHasKey('readOnly', $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']['plate']); - $this->assertArrayHasKey('payload', $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']); - - // Overridden constraints are documented on the subtype only. - $this->assertSame(5, $schemas['DiscriminatedVehicle.DiscriminatedTruck']['properties']['name']['minLength']); - $this->assertArrayNotHasKey('minLength', $schemas['DiscriminatedVehicle.DiscriminatedCar']['properties']['name']); - - // Unmapped subclasses are never documented. - $this->assertArrayNotHasKey('DiscriminatedVehicle.DiscriminatedSportsCar', $schemas); - $this->assertArrayNotHasKey('DiscriminatedVehicle.DiscriminatedSportsCar.jsonld', $schemas); - } -} diff --git a/tests/Functional/DiscriminatedResourceTest.php b/tests/Functional/DiscriminatedResourceTest.php index 73358d79779..0cd1e2bed07 100644 --- a/tests/Functional/DiscriminatedResourceTest.php +++ b/tests/Functional/DiscriminatedResourceTest.php @@ -14,12 +14,13 @@ namespace ApiPlatform\Tests\Functional; use ApiPlatform\Test\ApiTestCase; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedBook; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedBookStore; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedFictionBook; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedSignedFictionBook; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedTechnicalBook; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\UndiscriminatedBook; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedBike; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedCar; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedMountainBike; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedSportsCar; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedTruck; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedVehicle; +use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedVehicleStore; use ApiPlatform\Tests\SetupClassResourcesTrait; use PHPUnit\Framework\Attributes\DataProvider; use Symfony\Component\Security\Core\User\InMemoryUser; @@ -38,377 +39,260 @@ final class DiscriminatedResourceTest extends ApiTestCase */ public static function getResources(): array { - return [DiscriminatedBook::class, UndiscriminatedBook::class]; + return [DiscriminatedVehicle::class]; } protected function setUp(): void { - $fiction = new DiscriminatedFictionBook(); - $fiction->id = 1; - $fiction->title = 'The Hobbit'; - $fiction->genre = 'Fantasy'; - $fiction->pageCount = 310; - - $technical = new DiscriminatedTechnicalBook(); - $technical->id = 2; - $technical->title = 'Design Patterns'; - $technical->programmingLanguage = 'C++'; - $technical->internalNote = 'secret'; - - $signed = new DiscriminatedSignedFictionBook(); - $signed->id = 3; - $signed->title = 'Signed copy'; - $signed->genre = 'Fantasy'; - $signed->signature = 'must not leak'; - - DiscriminatedBookStore::$books = [1 => $fiction, 2 => $technical, 3 => $signed]; + $car = new DiscriminatedCar(); + $car->id = 1; + $car->name = 'Beetle'; + $car->plate = 'AB-123'; + + $truck = new DiscriminatedTruck(); + $truck->id = 2; + $truck->name = 'Actros'; + $truck->plate = 'TR-999'; + $truck->payload = 18000; + + $sportsCar = new DiscriminatedSportsCar(); + $sportsCar->id = 3; + $sportsCar->name = 'Carrera'; + $sportsCar->topSpeed = '300'; + + $mountainBike = new DiscriminatedMountainBike(); + $mountainBike->id = 4; + $mountainBike->name = 'Rocky'; + $mountainBike->gears = 21; + $mountainBike->suspension = 'full'; + + $bike = new DiscriminatedBike(); + $bike->id = 5; + $bike->name = 'Fixie'; + + DiscriminatedVehicleStore::$vehicles = [1 => $car, 2 => $truck, 3 => $sportsCar, 4 => $mountainBike, 5 => $bike]; } protected function tearDown(): void { - DiscriminatedBookStore::$books = []; + DiscriminatedVehicleStore::$vehicles = []; parent::tearDown(); } - public function testGetItemExposesSubtypeProperties(): void + /** + * @return iterable + */ + public static function formatProvider(): iterable + { + yield 'jsonld' => ['application/ld+json', 'jsonld']; + yield 'json' => ['application/json', 'json']; + yield 'jsonapi' => ['application/vnd.api+json', 'jsonapi']; + yield 'hal' => ['application/hal+json', 'jsonhal']; + } + + #[DataProvider('formatProvider')] + public function testGetItemExposesSubtypeProperties(string $accept, string $format): void { - $response = self::createClient()->request('GET', '/discriminated_books/1'); + $json = self::createClient()->request('GET', '/discriminated_vehicles/2', ['headers' => ['Accept' => $accept]])->toArray(); $this->assertResponseIsSuccessful(); - $this->assertEquals([ - '@context' => '/contexts/DiscriminatedBook', - '@id' => '/discriminated_books/1', - '@type' => 'DiscriminatedBook', - 'kind' => 'fiction', - 'id' => 1, - 'title' => 'The Hobbit', - 'genre' => 'Fantasy', - 'pageCount' => 310, - 'sequelOf' => null, - ], $response->toArray()); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class); + $attributes = $json['data']['attributes'] ?? $json; + $this->assertSame('truck', $attributes['kind']); + $this->assertSame('Actros', $attributes['name']); + $this->assertSame(18000, $attributes['payload']); + // Subtype property security + $this->assertArrayNotHasKey('plate', $attributes); + if ('jsonhal' !== $format) { + $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class, format: $format); + } + } + + /** + * @return iterable, list}> + */ + public static function typeProvider(): iterable + { + yield 'nested map' => [4, ['@type' => 'DiscriminatedMountainBike', 'kind' => 'bike', 'frame' => 'mountain', 'gears' => 21, 'suspension' => 'full'], []]; + yield 'class declared in its own nested map' => [5, ['@type' => 'DiscriminatedBike', 'kind' => 'bike', 'frame' => 'bike', 'gears' => 1], ['suspension']]; + yield 'unmapped subclass exposed as its mapped parent' => [3, ['@type' => 'DiscriminatedCar', 'kind' => 'car', 'name' => 'Carrera'], ['topSpeed']]; } - public function testGetItemAppliesSubtypePropertySecurity(): void + /** + * @param array $expected + * @param list $absent + */ + #[DataProvider('typeProvider')] + public function testGetItemExposesTheTypeOfEveryMap(int $id, array $expected, array $absent): void { - $response = self::createClient()->request('GET', '/discriminated_books/2'); + $json = self::createClient()->request('GET', '/discriminated_vehicles/'.$id)->toArray(); $this->assertResponseIsSuccessful(); - $json = $response->toArray(); - $this->assertSame('technical', $json['kind']); - $this->assertSame('C++', $json['programmingLanguage']); - $this->assertArrayNotHasKey('internalNote', $json); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class); + $this->assertJsonContains($expected); + foreach ($absent as $property) { + $this->assertArrayNotHasKey($property, $json); + } + $this->assertMatchesResourceItemJsonSchema(DiscriminatedVehicle::class); } /** * The allowed attributes are cached per cache key, subtype property security must make that key unsafe * or the attributes allowed for a user leak to the next ones in long-running processes. */ - #[DataProvider('userSequenceProvider')] - public function testSubtypePropertySecurityIsNotCachedAcrossUsers(bool $adminFirst): void + public function testSubtypePropertySecurityIsNotCachedAcrossUsers(): void { $client = self::createClient(); $client->disableReboot(); - $requestAs = static function (bool $admin) use ($client): array { + foreach ([true, false, true] as $admin) { $client->getCookieJar()->clear(); if ($admin) { $client->loginUser(new InMemoryUser('admin', 'password', ['ROLE_ADMIN'])); } - return $client->request('GET', '/discriminated_books/2', ['headers' => ['Accept' => 'application/json']])->toArray(); - }; - - foreach ([$adminFirst, !$adminFirst, $adminFirst] as $admin) { - $json = $requestAs($admin); - if ($admin) { - $this->assertSame('secret', $json['internalNote'] ?? null); - } else { - $this->assertArrayNotHasKey('internalNote', $json); - } + $json = $client->request('GET', '/discriminated_vehicles/2', ['headers' => ['Accept' => 'application/json']])->toArray(); + $this->assertSame($admin ? 'TR-999' : null, $json['plate'] ?? null); } } - /** - * @return iterable - */ - public static function userSequenceProvider(): iterable - { - yield 'admin first' => [true]; - yield 'anonymous first' => [false]; - } - - public function testGetItemDoesNotExposePropertiesOfUnmappedSubclass(): void - { - $response = self::createClient()->request('GET', '/discriminated_books/3'); - - $this->assertResponseIsSuccessful(); - $json = $response->toArray(); - $this->assertSame('fiction', $json['kind']); - $this->assertSame('Fantasy', $json['genre']); - $this->assertArrayNotHasKey('signature', $json); - } - - public function testGetItemWithoutDiscriminatorMapDoesNotExposeSubclassProperties(): void - { - $response = self::createClient()->request('GET', '/undiscriminated_books/1'); - - $this->assertResponseIsSuccessful(); - $json = $response->toArray(); - $this->assertSame('Hidden', $json['title']); - $this->assertArrayNotHasKey('secret', $json); - } - public function testGetCollectionExposesEachSubtype(): void { - unset(DiscriminatedBookStore::$books[3]); - - $response = self::createClient()->request('GET', '/discriminated_books'); - - $this->assertResponseIsSuccessful(); - $members = $response->toArray()['hydra:member']; - $this->assertCount(2, $members); - $this->assertSame('fiction', $members[0]['kind']); - $this->assertSame('Fantasy', $members[0]['genre']); - $this->assertArrayNotHasKey('programmingLanguage', $members[0]); - $this->assertSame('technical', $members[1]['kind']); - $this->assertSame('C++', $members[1]['programmingLanguage']); - $this->assertArrayNotHasKey('genre', $members[1]); - $this->assertMatchesResourceCollectionJsonSchema(DiscriminatedBook::class); - } - - public function testGetItemInJson(): void - { - $response = self::createClient()->request('GET', '/discriminated_books/1', ['headers' => ['Accept' => 'application/json']]); - - $this->assertResponseIsSuccessful(); - $this->assertEquals([ - 'kind' => 'fiction', - 'id' => 1, - 'title' => 'The Hobbit', - 'genre' => 'Fantasy', - 'pageCount' => 310, - 'sequelOf' => null, - ], $response->toArray()); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class, format: 'json'); - } - - public function testGetItemInJsonApi(): void - { - $response = self::createClient()->request('GET', '/discriminated_books/2', ['headers' => ['Accept' => 'application/vnd.api+json']]); + $members = self::createClient()->request('GET', '/discriminated_vehicles')->toArray()['hydra:member']; $this->assertResponseIsSuccessful(); - $attributes = $response->toArray()['data']['attributes']; - $this->assertSame('technical', $attributes['kind']); - $this->assertSame('C++', $attributes['programmingLanguage']); - $this->assertArrayNotHasKey('internalNote', $attributes); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedBook::class, format: 'jsonapi'); + $this->assertSame(['car', 'truck', 'car', 'bike', 'bike'], array_column($members, 'kind')); + $this->assertSame(['DiscriminatedCar', 'DiscriminatedTruck', 'DiscriminatedCar', 'DiscriminatedMountainBike', 'DiscriminatedBike'], array_column($members, '@type')); + $this->assertSame(18000, $members[1]['payload']); + $this->assertArrayNotHasKey('payload', $members[0]); + $this->assertMatchesResourceCollectionJsonSchema(DiscriminatedVehicle::class); } - public function testGetItemInHal(): void + /** + * @return iterable, class-string}> + */ + public static function postProvider(): iterable { - $response = self::createClient()->request('GET', '/discriminated_books/1', ['headers' => ['Accept' => 'application/hal+json']]); - - $this->assertResponseIsSuccessful(); - $json = $response->toArray(); - $this->assertSame('fiction', $json['kind']); - $this->assertSame('Fantasy', $json['genre']); - $this->assertSame(310, $json['pageCount']); + yield 'subtype' => [['kind' => 'truck', 'name' => 'Scania', 'payload' => 12000], DiscriminatedTruck::class]; + yield 'nested subtype' => [['kind' => 'bike', 'frame' => 'mountain', 'name' => 'Trek', 'suspension' => 'hardtail'], DiscriminatedMountainBike::class]; + yield 'class declared in its own nested map' => [['kind' => 'bike', 'frame' => 'bike', 'name' => 'Brompton', 'gears' => 3], DiscriminatedBike::class]; } - public function testPostCreatesTheMappedSubtype(): void + /** + * @param array $payload + * @param class-string $class + */ + #[DataProvider('postProvider')] + public function testPostCreatesTheMostSpecificSubtype(array $payload, string $class): void { - $response = self::createClient()->request('POST', '/discriminated_books', [ + self::createClient()->request('POST', '/discriminated_vehicles', [ 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => [ - 'kind' => 'technical', - 'title' => 'Refactoring', - 'programmingLanguage' => 'Java', - 'internalNote' => 'cannot be written anonymously', - ], + 'json' => $payload, ]); $this->assertResponseStatusCodeSame(201); - $this->assertEquals([ - '@context' => '/contexts/DiscriminatedBook', - '@id' => '/discriminated_books/4', - '@type' => 'DiscriminatedBook', - 'kind' => 'technical', - 'id' => 4, - 'title' => 'Refactoring', - 'programmingLanguage' => 'Java', - ], $response->toArray()); - $this->assertInstanceOf(DiscriminatedTechnicalBook::class, DiscriminatedBookStore::$books[4]); - $this->assertNull(DiscriminatedBookStore::$books[4]->internalNote); + $this->assertJsonContains(['@id' => '/discriminated_vehicles/6', '@type' => substr($class, strrpos($class, '\\') + 1)] + $payload); + $this->assertSame($class, DiscriminatedVehicleStore::$vehicles[6]::class); } - public function testPostDenormalizesSubtypeRelation(): void + public function testOverriddenPropertyMetadataIsEnforcedOnWrite(): void { - $response = self::createClient()->request('POST', '/discriminated_books', [ + $client = self::createClient(); + + // "plate" is not writable on cars + $client->request('POST', '/discriminated_vehicles', [ 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => [ - 'kind' => 'fiction', - 'title' => 'The Lord of the Rings', - 'genre' => 'Fantasy', - 'sequelOf' => '/discriminated_books/1', - ], + 'json' => ['kind' => 'car', 'name' => 'Golf', 'plate' => 'not writable'], ]); - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains([ - 'kind' => 'fiction', - 'sequelOf' => '/discriminated_books/1', - ]); - $book = DiscriminatedBookStore::$books[4]; - $this->assertInstanceOf(DiscriminatedFictionBook::class, $book); - $this->assertSame(DiscriminatedBookStore::$books[1], $book->sequelOf); - } + $this->assertNull(DiscriminatedVehicleStore::$vehicles[6]->plate); - public function testPostInJson(): void - { - self::createClient()->request('POST', '/discriminated_books', [ - 'headers' => ['Content-Type' => 'application/json', 'Accept' => 'application/json'], - 'json' => [ - 'kind' => 'fiction', - 'title' => 'Dune', - 'genre' => 'Science fiction', - 'pageCount' => 412, - ], + // "plate" is restricted to admins on trucks + $client->request('POST', '/discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Scania', 'plate' => 'admins only'], ]); - $this->assertResponseStatusCodeSame(201); - $this->assertJsonEquals([ - 'kind' => 'fiction', - 'id' => 4, - 'title' => 'Dune', - 'genre' => 'Science fiction', - 'pageCount' => 412, - 'sequelOf' => null, - ]); + $this->assertNull(DiscriminatedVehicleStore::$vehicles[7]->plate); } - public function testPostValidatesSubtypeConstraints(): void + /** + * @return iterable}> + */ + public static function invalidPayloadProvider(): iterable { - self::createClient()->request('POST', '/discriminated_books', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => [ - 'kind' => 'fiction', - 'title' => 'Dune', - 'pageCount' => -1, - ], - ]); - - $this->assertResponseStatusCodeSame(422); - $this->assertJsonContains(['violations' => [['propertyPath' => 'pageCount']]]); + yield 'no type' => ['POST', '/discriminated_vehicles', ['name' => 'Untyped']]; + yield 'unknown type' => ['POST', '/discriminated_vehicles', ['kind' => 'plane', 'name' => 'Unknown']]; + yield 'no nested type' => ['POST', '/discriminated_vehicles', ['kind' => 'bike', 'name' => 'Untyped bike']]; + yield 'relation narrowed by the subtype' => ['POST', '/discriminated_vehicles', ['kind' => 'car', 'name' => 'Polo', 'tows' => '/discriminated_vehicles/2']]; + yield 'type change' => ['PATCH', '/discriminated_vehicles/1', ['kind' => 'truck', 'payload' => 1]]; + yield 'nested type change' => ['PATCH', '/discriminated_vehicles/4', ['frame' => 'bike']]; } - public function testPostWithoutTypeIsRejected(): void + /** + * @param array $payload + */ + #[DataProvider('invalidPayloadProvider')] + public function testInvalidPayloadIsRejected(string $method, string $uri, array $payload): void { - self::createClient()->request('POST', '/discriminated_books', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['title' => 'Untyped'], - ]); + $classes = array_map(static fn (DiscriminatedVehicle $vehicle): string => $vehicle::class, DiscriminatedVehicleStore::$vehicles); - $this->assertResponseStatusCodeSame(400); - $this->assertCount(3, DiscriminatedBookStore::$books); - } - - public function testPostWithUnknownTypeIsRejected(): void - { - self::createClient()->request('POST', '/discriminated_books', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'poetry', 'title' => 'Unknown'], + self::createClient()->request($method, $uri, [ + 'headers' => ['Content-Type' => 'PATCH' === $method ? 'application/merge-patch+json' : 'application/ld+json'], + 'json' => $payload, ]); $this->assertResponseStatusCodeSame(400); - $this->assertCount(3, DiscriminatedBookStore::$books); - } - - public function testPatchUpdatesSubtypeProperties(): void - { - self::createClient()->request('PATCH', '/discriminated_books/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['genre' => 'High fantasy', 'pageCount' => 320], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertJsonContains([ - 'kind' => 'fiction', - 'title' => 'The Hobbit', - 'genre' => 'High fantasy', - 'pageCount' => 320, - ]); - $book = DiscriminatedBookStore::$books[1]; - $this->assertInstanceOf(DiscriminatedFictionBook::class, $book); - $this->assertSame('High fantasy', $book->genre); + $this->assertSame($classes, array_map(static fn (DiscriminatedVehicle $vehicle): string => $vehicle::class, DiscriminatedVehicleStore::$vehicles)); } - public function testPatchAcceptsMatchingType(): void + /** + * @return iterable, string}> + */ + public static function constraintViolationProvider(): iterable { - self::createClient()->request('PATCH', '/discriminated_books/2', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['kind' => 'technical', 'programmingLanguage' => 'Rust'], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['kind' => 'technical', 'programmingLanguage' => 'Rust']); + yield 'subtype constraint on POST' => ['POST', '/discriminated_vehicles', ['kind' => 'truck', 'name' => 'MAN'], 'name']; + yield 'subtype constraint on PATCH' => ['PATCH', '/discriminated_vehicles/2', ['name' => 'MAN'], 'name']; + // A setter parameter cannot be narrowed (contravariance): the covariant getter is enforced by validation + yield 'covariant getter' => ['POST', '/discriminated_vehicles', ['kind' => 'truck', 'name' => 'Volvo FH', 'trailer' => '/discriminated_vehicles/1'], 'trailer']; } - public function testPatchCannotChangeTheType(): void + /** + * @param array $payload + */ + #[DataProvider('constraintViolationProvider')] + public function testSubtypeConstraintsAreValidated(string $method, string $uri, array $payload, string $propertyPath): void { - self::createClient()->request('PATCH', '/discriminated_books/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['kind' => 'technical', 'programmingLanguage' => 'Rust'], + self::createClient()->request($method, $uri, [ + 'headers' => ['Content-Type' => 'PATCH' === $method ? 'application/merge-patch+json' : 'application/ld+json'], + 'json' => $payload, ]); - $this->assertResponseStatusCodeSame(400); - $this->assertInstanceOf(DiscriminatedFictionBook::class, DiscriminatedBookStore::$books[1]); - $this->assertSame('Fantasy', DiscriminatedBookStore::$books[1]->genre); + $this->assertResponseStatusCodeSame(422); + $this->assertJsonContains(['violations' => [['propertyPath' => $propertyPath]]]); } - public function testPatchValidatesSubtypeConstraints(): void + public function testPatchUpdatesSubtypeProperties(): void { - self::createClient()->request('PATCH', '/discriminated_books/1', [ + self::createClient()->request('PATCH', '/discriminated_vehicles/2', [ 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['pageCount' => 0], + 'json' => ['kind' => 'truck', 'payload' => 20000], ]); - $this->assertResponseStatusCodeSame(422); - $this->assertJsonContains(['violations' => [['propertyPath' => 'pageCount']]]); + $this->assertResponseIsSuccessful(); + $this->assertJsonContains(['kind' => 'truck', 'name' => 'Actros', 'payload' => 20000]); + $this->assertInstanceOf(DiscriminatedTruck::class, DiscriminatedVehicleStore::$vehicles[2]); } public function testPutReplacesTheResourceWithTheGivenSubtype(): void { - self::createClient()->request('PUT', '/discriminated_books/1', [ + self::createClient()->request('PUT', '/discriminated_vehicles/1', [ 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => [ - 'kind' => 'technical', - 'title' => 'Clean Code', - 'programmingLanguage' => 'Java', - ], + 'json' => ['kind' => 'truck', 'name' => 'Unimog', 'payload' => 5000], ]); $this->assertResponseIsSuccessful(); - $this->assertJsonEquals([ - '@context' => '/contexts/DiscriminatedBook', - '@id' => '/discriminated_books/1', - '@type' => 'DiscriminatedBook', - 'kind' => 'technical', - 'id' => 1, - 'title' => 'Clean Code', - 'programmingLanguage' => 'Java', - ]); - $this->assertInstanceOf(DiscriminatedTechnicalBook::class, DiscriminatedBookStore::$books[1]); - } - - public function testDelete(): void - { - self::createClient()->request('DELETE', '/discriminated_books/2'); - - $this->assertResponseStatusCodeSame(204); - $this->assertArrayNotHasKey(2, DiscriminatedBookStore::$books); + $this->assertJsonContains(['@id' => '/discriminated_vehicles/1', '@type' => 'DiscriminatedTruck', 'kind' => 'truck', 'payload' => 5000]); + $this->assertInstanceOf(DiscriminatedTruck::class, DiscriminatedVehicleStore::$vehicles[1]); } public function testOpenApiDocumentsSubtypes(): void @@ -418,119 +302,48 @@ public function testOpenApiDocumentsSubtypes(): void ])->toArray(); $schemas = $json['components']['schemas']; - // Output (JSON-LD): the base definition only lists its subtypes, each of them carrying the common properties. - $output = $this->findDefinition($schemas, $json['paths']['/discriminated_books/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); + $output = $schemas['DiscriminatedVehicle.jsonld']['allOf'][1] ?? $schemas['DiscriminatedVehicle.jsonld']; $this->assertSame([ 'propertyName' => 'kind', 'mapping' => [ - 'fiction' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook.jsonld', - 'technical' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook.jsonld', + 'car' => '#/components/schemas/DiscriminatedVehicle.DiscriminatedCar.jsonld', + 'truck' => '#/components/schemas/DiscriminatedVehicle.DiscriminatedTruck.jsonld', + 'bike' => '#/components/schemas/DiscriminatedVehicle.DiscriminatedBike.jsonld', ], ], $output['discriminator']); - $this->assertSame([ - ['$ref' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook.jsonld'], - ['$ref' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook.jsonld'], - ], $output['oneOf']); + $this->assertCount(3, $output['oneOf']); $this->assertArrayNotHasKey('properties', $output); - $fiction = $schemas['DiscriminatedBook.DiscriminatedFictionBook.jsonld']; - $this->assertSame(['type' => 'string', 'enum' => ['fiction']], $fiction['properties']['kind']); - $this->assertContains('kind', $fiction['required']); - $this->assertArrayHasKey('genre', $fiction['properties']); - $this->assertArrayHasKey('pageCount', $fiction['properties']); - $this->assertArrayNotHasKey('signature', $fiction['properties']); - $this->assertArrayNotHasKey('allOf', $fiction, 'Subtype schemas must not reference the base schema back (circular reference).'); - - $technical = $schemas['DiscriminatedBook.DiscriminatedTechnicalBook.jsonld']; - $this->assertSame(['type' => 'string', 'enum' => ['technical']], $technical['properties']['kind']); - $this->assertArrayHasKey('programmingLanguage', $technical['properties']); - $this->assertArrayNotHasKey('genre', $technical['properties']); - - // Required properties of a subtype must not leak into the base nor into siblings. - $this->assertNotContains('kind', $output['required'] ?? []); - $this->assertNotContains('kind', $schemas['DiscriminatedBook.jsonld']['allOf'][1]['required'] ?? []); - - // Input (POST) - $postInput = $this->findDefinition($schemas, $json['paths']['/discriminated_books']['post']['requestBody']['content']['application/ld+json']['schema']['$ref']); - $this->assertSame('kind', $postInput['discriminator']['propertyName']); - $this->assertSame([ - 'fiction' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook', - 'technical' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook', - ], $postInput['discriminator']['mapping']); - $this->assertContains('kind', $schemas['DiscriminatedBook.DiscriminatedFictionBook']['required']); - $this->assertArrayHasKey('genre', $schemas['DiscriminatedBook.DiscriminatedFictionBook']['properties']); - - // Input (PATCH): a merge-patch document does not require any property, not even the type. - $patchInput = $this->findDefinition($schemas, $json['paths']['/discriminated_books/{id}']['patch']['requestBody']['content']['application/merge-patch+json']['schema']['$ref']); - $this->assertSame([ - 'fiction' => '#/components/schemas/DiscriminatedBook.DiscriminatedFictionBook.jsonMergePatch', - 'technical' => '#/components/schemas/DiscriminatedBook.DiscriminatedTechnicalBook.jsonMergePatch', - ], $patchInput['discriminator']['mapping']); - $this->assertArrayNotHasKey('required', $schemas['DiscriminatedBook.DiscriminatedFictionBook.jsonMergePatch']); - $this->assertArrayNotHasKey('required', $schemas['DiscriminatedBook.DiscriminatedTechnicalBook.jsonMergePatch']); - - // JSON:API: the type property is an attribute, each subtype is a variant of the "data" object. - $jsonApiData = $this->findDefinition($schemas, $schemas['DiscriminatedBook.jsonapi']['properties']['data']['$ref']); - $this->assertCount(2, $jsonApiData['oneOf']); - $fiction = $this->findDefinition($schemas, $jsonApiData['oneOf'][0]['$ref']); - $technical = $this->findDefinition($schemas, $jsonApiData['oneOf'][1]['$ref']); - $this->assertSame(['type' => 'string', 'enum' => ['fiction']], $fiction['properties']['attributes']['properties']['kind']); - $this->assertSame(['kind'], $fiction['properties']['attributes']['required']); - $this->assertArrayHasKey('sequelOf', $fiction['properties']['relationships']['properties']); - $this->assertArrayHasKey('programmingLanguage', $technical['properties']['attributes']['properties']); - - // Resources without a discriminator map are untouched. - $this->assertArrayNotHasKey('discriminator', $schemas['UndiscriminatedBook.jsonld']['allOf'][1]); - $this->assertArrayNotHasKey('oneOf', $schemas['UndiscriminatedBook.jsonld']['allOf'][1]); - } + $truck = $schemas['DiscriminatedVehicle.DiscriminatedTruck.jsonld']; + $this->assertSame(['type' => 'string', 'enum' => ['truck']], $truck['properties']['kind']); + $this->assertArrayHasKey('payload', $truck['properties']); + $this->assertSame(5, $truck['properties']['name']['minLength']); + $this->assertArrayNotHasKey('minLength', $schemas['DiscriminatedVehicle.DiscriminatedCar.jsonld']['properties']['name']); - /** - * Resolves a definition, unwrapping the Hydra item decoration if any. - */ - public static function parentSchemaProvider(): iterable - { - yield 'output json' => ['/discriminated_books/{id}', 'get', 'application/json']; - yield 'output jsonld' => ['/discriminated_books/{id}', 'get', 'application/ld+json']; - yield 'input json' => ['/discriminated_books', 'post', 'application/json']; - yield 'input jsonld' => ['/discriminated_books', 'post', 'application/ld+json']; - yield 'input merge-patch' => ['/discriminated_books/{id}', 'patch', 'application/merge-patch+json']; - yield 'output jsonapi' => ['/discriminated_books/{id}', 'get', 'application/vnd.api+json']; - } + // The nested map lists the bike itself: an instance of the bike is described by an inline branch + $bike = $schemas['DiscriminatedVehicle.DiscriminatedBike.jsonld']; + $this->assertSame('frame', $bike['discriminator']['propertyName']); + $this->assertSame(['type' => 'string', 'enum' => ['bike']], $bike['oneOf'][0]['properties']['frame']); + $this->assertSame(['$ref' => '#/components/schemas/DiscriminatedVehicle.DiscriminatedMountainBike.jsonld'], $bike['oneOf'][1]); - /** - * Every "oneOf" branch is a complete description of a subtype: repeating the common properties - * next to "oneOf" makes Swagger UI display them twice. - */ - #[DataProvider('parentSchemaProvider')] - public function testOpenApiParentSchemaOnlyListsItsSubtypes(string $path, string $method, string $mimeType): void - { - $json = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray(); - $schemas = $json['components']['schemas']; - - $operation = $json['paths'][$path][$method]; - $ref = 'get' === $method ? $operation['responses']['200']['content'][$mimeType]['schema']['$ref'] : $operation['requestBody']['content'][$mimeType]['schema']['$ref']; - $parent = $this->findDefinition($schemas, $ref); - if ('application/vnd.api+json' === $mimeType) { - $parent = $this->findDefinition($schemas, $parent['properties']['data']['$ref']); - } - - $this->assertCount(2, $parent['oneOf']); - $this->assertArrayNotHasKey('properties', $parent); - $this->assertArrayNotHasKey('required', $parent); - - foreach ($parent['oneOf'] as $branch) { - $branch = $this->findDefinition($schemas, $branch['$ref']); - $properties = 'application/vnd.api+json' === $mimeType ? $branch['properties']['attributes']['properties'] : $branch['properties']; - $this->assertArrayHasKey('title', $properties); - } + // Unmapped subclasses are never documented + $this->assertArrayNotHasKey('DiscriminatedVehicle.DiscriminatedSportsCar.jsonld', $schemas); } - private function findDefinition(array $schemas, string $ref): array + public function testHydraDocumentsSubtypesAsSubclasses(): void { - $definition = $schemas[substr($ref, \strlen('#/components/schemas/'))]; + $client = self::createClient(); - return $definition['allOf'][1] ?? $definition; + $classes = array_column($client->request('GET', '/docs.jsonld')->toArray()['hydra:supportedClass'], null, '@id'); + $truck = $classes['#DiscriminatedTruck']; + $this->assertSame('#DiscriminatedVehicle', $truck['subClassOf']); + $this->assertSame(['#DiscriminatedTruck/payload'], array_column(array_column($truck['hydra:supportedProperty'], 'hydra:property'), '@id')); + $this->assertSame('#DiscriminatedBike', $classes['#DiscriminatedMountainBike']['subClassOf']); + $this->assertArrayNotHasKey('#DiscriminatedSportsCar', $classes); + + $context = $client->request('GET', '/contexts/DiscriminatedVehicle')->toArray()['@context']; + $this->assertSame('DiscriminatedVehicle/name', $context['name']); + $this->assertSame('DiscriminatedTruck/payload', $context['payload']); + $this->assertSame('DiscriminatedMountainBike/suspension', $context['suspension']); } } diff --git a/tests/Functional/DiscriminatedSelfMappedResourceTest.php b/tests/Functional/DiscriminatedSelfMappedResourceTest.php deleted file mode 100644 index c30d3e71564..00000000000 --- a/tests/Functional/DiscriminatedSelfMappedResourceTest.php +++ /dev/null @@ -1,193 +0,0 @@ - - * - * 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; - -use ApiPlatform\Test\ApiTestCase; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedGadget; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedGadgetStore; -use ApiPlatform\Tests\Fixtures\TestBundle\ApiResource\DiscriminatedResource\DiscriminatedPhone; -use ApiPlatform\Tests\SetupClassResourcesTrait; -use JsonSchema\Validator; -use PHPUnit\Framework\Attributes\DataProvider; - -/** - * Concrete polymorphic resource declaring itself in its own discriminator map. - */ -final class DiscriminatedSelfMappedResourceTest extends ApiTestCase -{ - use SetupClassResourcesTrait; - - protected static ?bool $alwaysBootKernel = false; - - /** - * @return class-string[] - */ - public static function getResources(): array - { - return [DiscriminatedGadget::class]; - } - - protected function setUp(): void - { - $gadget = new DiscriminatedGadget(); - $gadget->id = 1; - $gadget->name = 'Spinner'; - - $phone = new DiscriminatedPhone(); - $phone->id = 2; - $phone->name = 'Pocket'; - $phone->number = '555-0100'; - - DiscriminatedGadgetStore::$gadgets = [1 => $gadget, 2 => $phone]; - } - - protected function tearDown(): void - { - DiscriminatedGadgetStore::$gadgets = []; - - parent::tearDown(); - } - - public function testGetBaseItemExposesItsOwnType(): void - { - $response = self::createClient()->request('GET', '/discriminated_gadgets/1'); - - $this->assertResponseIsSuccessful(); - $this->assertEquals([ - '@context' => '/contexts/DiscriminatedGadget', - '@id' => '/discriminated_gadgets/1', - '@type' => 'DiscriminatedGadget', - 'kind' => 'gadget', - 'id' => 1, - 'name' => 'Spinner', - ], $response->toArray()); - } - - /** - * @return iterable - */ - public static function jsonApiItemProvider(): iterable - { - yield 'base type' => [1, 'gadget']; - yield 'subtype' => [2, 'phone']; - } - - #[DataProvider('jsonApiItemProvider')] - public function testGetItemInJsonApiMatchesItsJsonSchema(int $id, string $kind): void - { - $json = self::createClient()->request('GET', '/discriminated_gadgets/'.$id, ['headers' => ['Accept' => 'application/vnd.api+json']])->toArray(); - - $this->assertResponseIsSuccessful(); - $this->assertSame($kind, $json['data']['attributes']['kind']); - $this->assertMatchesResourceItemJsonSchema(DiscriminatedGadget::class, format: 'jsonapi'); - } - - public function testGetCollectionExposesTheTypeOfEveryMember(): void - { - $members = self::createClient()->request('GET', '/discriminated_gadgets')->toArray()['hydra:member']; - - $this->assertResponseIsSuccessful(); - $this->assertSame(['gadget', 'phone'], array_column($members, 'kind')); - $this->assertArrayNotHasKey('number', $members[0]); - $this->assertSame('555-0100', $members[1]['number']); - } - - public function testPostBaseTypeWithTypeProperty(): void - { - self::createClient()->request('POST', '/discriminated_gadgets', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'gadget', 'name' => 'Yo-yo'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains(['kind' => 'gadget', 'name' => 'Yo-yo']); - $this->assertSame(DiscriminatedGadget::class, DiscriminatedGadgetStore::$gadgets[3]::class); - } - - public function testPostSubtype(): void - { - self::createClient()->request('POST', '/discriminated_gadgets', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'phone', 'name' => 'Brick', 'number' => '555-0199'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains(['kind' => 'phone', 'number' => '555-0199']); - $this->assertInstanceOf(DiscriminatedPhone::class, DiscriminatedGadgetStore::$gadgets[3]); - } - - public function testPostBaseTypeRejectsSubtypeProperties(): void - { - self::createClient()->request('POST', '/discriminated_gadgets', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'gadget', 'name' => 'Yo-yo', 'number' => '555-0199'], - ]); - - $this->assertResponseStatusCodeSame(400); - } - - public function testPatchBaseItemWithItsType(): void - { - self::createClient()->request('PATCH', '/discriminated_gadgets/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['kind' => 'gadget', 'name' => 'Fidget'], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['kind' => 'gadget', 'name' => 'Fidget']); - } - - public function testPatchCannotChangeTheBaseItemType(): void - { - self::createClient()->request('PATCH', '/discriminated_gadgets/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['kind' => 'phone'], - ]); - - $this->assertResponseStatusCodeSame(400); - $this->assertSame(DiscriminatedGadget::class, DiscriminatedGadgetStore::$gadgets[1]::class); - } - - /** - * @return iterable, bool}> - */ - public static function inputPayloadProvider(): iterable - { - yield 'base type' => [['kind' => 'gadget', 'name' => 'Yo-yo'], true]; - yield 'subtype' => [['kind' => 'phone', 'name' => 'Brick', 'number' => '555-0199'], true]; - yield 'unknown property' => [['kind' => 'gadget', 'name' => 'Yo-yo', 'unknown' => true], false]; - } - - /** - * @param array $payload - */ - #[DataProvider('inputPayloadProvider')] - public function testInputSchemaMatchesTheAcceptedPayloads(array $payload, bool $valid): void - { - $json = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray(); - - $schema = json_decode(json_encode([ - '$ref' => $json['paths']['/discriminated_gadgets']['post']['requestBody']['content']['application/ld+json']['schema']['$ref'], - 'components' => ['schemas' => $json['components']['schemas']], - ])); - $data = json_decode(json_encode($payload)); - - $validator = new Validator(); - $validator->validate($data, $schema); - - $this->assertSame($valid, $validator->isValid(), json_encode($validator->getErrors())); - } -} diff --git a/tests/Functional/DoctrineDiscriminatedDocumentTest.php b/tests/Functional/DoctrineDiscriminatedDocumentTest.php index a0cb229c978..ec87799a015 100644 --- a/tests/Functional/DoctrineDiscriminatedDocumentTest.php +++ b/tests/Functional/DoctrineDiscriminatedDocumentTest.php @@ -20,7 +20,6 @@ use ApiPlatform\Tests\Fixtures\TestBundle\Document\DoctrineDiscriminated\DoctrineDiscriminatedVehicle; use ApiPlatform\Tests\RecreateSchemaTrait; use ApiPlatform\Tests\SetupClassResourcesTrait; -use Symfony\Component\Security\Core\User\InMemoryUser; /** * Polymorphic resources declared through the Doctrine MongoDB ODM discriminator map only. @@ -74,40 +73,21 @@ protected function setUp(): void $manager->clear(); } - public function testGetItemOfANonResourceSubtypeExposesItsProperties(): void + public function testGetAndPostANonResourceSubtype(): void { - self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2'); + $client = self::createClient(); + $client->request('GET', '/doctrine_discriminated_vehicles/2'); $this->assertResponseIsSuccessful(); $this->assertJsonEquals([ '@context' => '/contexts/DoctrineDiscriminatedVehicle', '@id' => '/doctrine_discriminated_vehicles/2', - '@type' => 'DoctrineDiscriminatedVehicle', + '@type' => 'DoctrineDiscriminatedTruck', 'kind' => 'truck', 'id' => 2, 'name' => 'Big truck', 'payload' => 20000, ]); - } - - public function testGetItemAppliesSubtypePropertySecurity(): void - { - $client = self::createClient(); - $client->disableReboot(); - - $json = $client->request('GET', '/doctrine_discriminated_vehicles')->toArray(); - $this->assertSame('car', $json['hydra:member'][0]['kind']); - $this->assertSame(5, $json['hydra:member'][0]['seats']); - $this->assertArrayNotHasKey('vin', $json['hydra:member'][0]); - - $client->loginUser(new InMemoryUser('admin', 'password', ['ROLE_ADMIN'])); - $client->request('GET', '/doctrine_discriminated_cars/1'); - $this->assertJsonContains(['vin' => 'secret-vin']); - } - - public function testPostCreatesTheMappedSubtypes(): void - { - $client = self::createClient(); $client->request('POST', '/doctrine_discriminated_vehicles', [ 'headers' => ['Content-Type' => 'application/ld+json'], @@ -116,58 +96,8 @@ public function testPostCreatesTheMappedSubtypes(): void $this->assertResponseStatusCodeSame(201); $this->assertJsonContains(['@id' => '/doctrine_discriminated_vehicles/3', 'kind' => 'truck', 'payload' => 3500]); - $client->request('POST', '/doctrine_discriminated_cars', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'sportsCar', 'name' => 'Roadster', 'seats' => 2, 'topSpeed' => 250], - ]); - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains(['@id' => '/doctrine_discriminated_cars/4', 'kind' => 'sportsCar', 'topSpeed' => 250]); - $manager = $this->getManager(); $manager->clear(); $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $manager->find(DoctrineDiscriminatedVehicle::class, 3)); - $this->assertInstanceOf(DoctrineDiscriminatedSportsCar::class, $manager->find(DoctrineDiscriminatedVehicle::class, 4)); - } - - public function testPostWithoutTypeIsRejected(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['name' => 'Unknown'], - ]); - - $this->assertResponseStatusCodeSame(400); - } - - public function testPatchUpdatesSubtypeProperties(): void - { - $client = self::createClient(); - - $client->request('PATCH', '/doctrine_discriminated_vehicles/2', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['payload' => 25000], - ]); - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['kind' => 'truck', 'payload' => 25000]); - - $client->request('PATCH', '/doctrine_discriminated_vehicles/2', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['kind' => 'car', 'seats' => 3], - ]); - $this->assertResponseStatusCodeSame(400); - } - - public function testOpenApiDocumentsDoctrineSubtypes(): void - { - $json = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray(); - - $ref = $json['paths']['/doctrine_discriminated_vehicles/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']; - $definition = $json['components']['schemas'][substr($ref, \strlen('#/components/schemas/'))]; - $output = $definition['allOf'][1] ?? $definition; - - $this->assertSame('kind', $output['discriminator']['propertyName']); - $this->assertEqualsCanonicalizing(['car', 'sportsCar', 'truck'], array_keys($output['discriminator']['mapping'])); } } diff --git a/tests/Functional/DoctrineDiscriminatedResourceTest.php b/tests/Functional/DoctrineDiscriminatedResourceTest.php index f6b2d719def..97d352e843c 100644 --- a/tests/Functional/DoctrineDiscriminatedResourceTest.php +++ b/tests/Functional/DoctrineDiscriminatedResourceTest.php @@ -26,7 +26,6 @@ use ApiPlatform\Tests\Fixtures\TestBundle\Entity\DoctrineDiscriminated\DoctrineDiscriminatedVehicle; use ApiPlatform\Tests\RecreateSchemaTrait; use ApiPlatform\Tests\SetupClassResourcesTrait; -use Symfony\Component\Security\Core\User\InMemoryUser; /** * Polymorphic resources declared through the Doctrine ORM discriminator map only. @@ -104,20 +103,32 @@ protected function setUp(): void $manager->clear(); } - public function testGetItemOfANonResourceSubtypeExposesItsProperties(): void + public function testGetAndPostANonResourceSubtype(): void { - self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2'); + $client = self::createClient(); + $client->request('GET', '/doctrine_discriminated_vehicles/2'); $this->assertResponseIsSuccessful(); $this->assertJsonEquals([ '@context' => '/contexts/DoctrineDiscriminatedVehicle', '@id' => '/doctrine_discriminated_vehicles/2', - '@type' => 'DoctrineDiscriminatedVehicle', + '@type' => 'DoctrineDiscriminatedTruck', 'kind' => 'truck', 'id' => 2, 'name' => 'Big truck', 'payload' => 20000, ]); + + $client->request('POST', '/doctrine_discriminated_vehicles', [ + 'headers' => ['Content-Type' => 'application/ld+json'], + 'json' => ['kind' => 'truck', 'name' => 'Small truck', 'payload' => 3500], + ]); + $this->assertResponseStatusCodeSame(201); + $this->assertJsonContains(['@id' => '/doctrine_discriminated_vehicles/4', '@type' => 'DoctrineDiscriminatedTruck', 'kind' => 'truck', 'payload' => 3500]); + + $truck = $this->findVehicle(4); + $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $truck); + $this->assertSame(3500, $truck->payload); } public function testGetItemOfAResourceSubtypeUsesItsOwnResource(): void @@ -128,7 +139,7 @@ public function testGetItemOfAResourceSubtypeUsesItsOwnResource(): void $this->assertJsonEquals([ '@context' => '/contexts/DoctrineDiscriminatedCar', '@id' => '/doctrine_discriminated_cars/3', - '@type' => 'DoctrineDiscriminatedCar', + '@type' => 'DoctrineDiscriminatedSportsCar', 'kind' => 'sportsCar', 'id' => 3, 'name' => 'Fast car', @@ -137,215 +148,6 @@ public function testGetItemOfAResourceSubtypeUsesItsOwnResource(): void ]); } - public function testGetItemAppliesSubtypePropertySecurity(): void - { - $client = self::createClient(); - $client->disableReboot(); - - $client->request('GET', '/doctrine_discriminated_cars/1'); - $this->assertResponseIsSuccessful(); - $this->assertJsonEquals([ - '@context' => '/contexts/DoctrineDiscriminatedCar', - '@id' => '/doctrine_discriminated_cars/1', - '@type' => 'DoctrineDiscriminatedCar', - 'kind' => 'car', - 'id' => 1, - 'name' => 'Family car', - 'seats' => 5, - ]); - - $client->loginUser(new InMemoryUser('admin', 'password', ['ROLE_ADMIN'])); - $client->request('GET', '/doctrine_discriminated_cars/1'); - $this->assertJsonContains(['vin' => 'secret-vin']); - } - - public function testGetCollectionExposesEachSubtype(): void - { - $response = self::createClient()->request('GET', '/doctrine_discriminated_vehicles'); - - $this->assertResponseIsSuccessful(); - $members = $response->toArray()['hydra:member']; - $this->assertCount(3, $members); - - $this->assertSame('/doctrine_discriminated_cars/1', $members[0]['@id']); - $this->assertSame('car', $members[0]['kind']); - $this->assertSame(5, $members[0]['seats']); - $this->assertArrayNotHasKey('vin', $members[0]); - - $this->assertSame('/doctrine_discriminated_vehicles/2', $members[1]['@id']); - $this->assertSame('truck', $members[1]['kind']); - $this->assertSame(20000, $members[1]['payload']); - $this->assertArrayNotHasKey('seats', $members[1]); - - $this->assertSame('/doctrine_discriminated_cars/3', $members[2]['@id']); - $this->assertSame('sportsCar', $members[2]['kind']); - $this->assertSame(320, $members[2]['topSpeed']); - } - - public function testGetItemInJsonApi(): void - { - $response = self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2', ['headers' => ['Accept' => 'application/vnd.api+json']]); - - $this->assertResponseIsSuccessful(); - $attributes = $response->toArray()['data']['attributes']; - $this->assertSame('truck', $attributes['kind']); - $this->assertSame(20000, $attributes['payload']); - } - - public function testGetItemInHal(): void - { - $response = self::createClient()->request('GET', '/doctrine_discriminated_vehicles/2', ['headers' => ['Accept' => 'application/hal+json']]); - - $this->assertResponseIsSuccessful(); - $data = $response->toArray(); - $this->assertSame('/doctrine_discriminated_vehicles/2', $data['_links']['self']['href']); - $this->assertSame('truck', $data['kind']); - $this->assertSame(20000, $data['payload']); - } - - public function testPostCreatesANonResourceSubtype(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'truck', 'name' => 'Small truck', 'payload' => 3500], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertJsonEquals([ - '@context' => '/contexts/DoctrineDiscriminatedVehicle', - '@id' => '/doctrine_discriminated_vehicles/4', - '@type' => 'DoctrineDiscriminatedVehicle', - 'kind' => 'truck', - 'id' => 4, - 'name' => 'Small truck', - 'payload' => 3500, - ]); - - $truck = $this->findVehicle(4); - $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $truck); - $this->assertSame(3500, $truck->payload); - } - - public function testPostCreatesAResourceSubtypeThroughTheParentResource(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'car', 'name' => 'Van', 'seats' => 8, 'vin' => 'cannot be written anonymously'], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains(['@id' => '/doctrine_discriminated_cars/4', 'kind' => 'car', 'seats' => 8]); - - $car = $this->findVehicle(4); - $this->assertInstanceOf(DoctrineDiscriminatedCar::class, $car); - $this->assertNotInstanceOf(DoctrineDiscriminatedSportsCar::class, $car); - $this->assertNull($car->vin); - } - - public function testPostCreatesAGrandchildThroughAnIntermediateResource(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_cars', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'sportsCar', 'name' => 'Roadster', 'seats' => 2, 'topSpeed' => 250], - ]); - - $this->assertResponseStatusCodeSame(201); - $this->assertJsonContains(['@id' => '/doctrine_discriminated_cars/4', 'kind' => 'sportsCar', 'topSpeed' => 250]); - $this->assertInstanceOf(DoctrineDiscriminatedSportsCar::class, $this->findVehicle(4)); - } - - public function testPostOnAConcreteIntermediateResourceDefaultsToItself(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_cars', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'car', 'name' => 'Hatchback', 'seats' => 4], - ]); - - $this->assertResponseStatusCodeSame(201); - $car = $this->findVehicle(4); - $this->assertInstanceOf(DoctrineDiscriminatedCar::class, $car); - $this->assertNotInstanceOf(DoctrineDiscriminatedSportsCar::class, $car); - } - - public function testPostOnAnIntermediateResourceRejectsSiblingTypes(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_cars', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'truck', 'name' => 'Not a car', 'payload' => 1], - ]); - - $this->assertResponseStatusCodeSame(400); - } - - public function testPostWithoutTypeIsRejected(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['name' => 'Unknown'], - ]); - - $this->assertResponseStatusCodeSame(400); - } - - public function testPostValidatesSubtypeConstraints(): void - { - self::createClient()->request('POST', '/doctrine_discriminated_vehicles', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'car', 'name' => 'Broken', 'seats' => 0], - ]); - - $this->assertResponseStatusCodeSame(422); - $this->assertJsonContains(['violations' => [['propertyPath' => 'seats']]]); - } - - public function testPatchUpdatesSubtypeProperties(): void - { - self::createClient()->request('PATCH', '/doctrine_discriminated_vehicles/2', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['payload' => 25000], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['kind' => 'truck', 'name' => 'Big truck', 'payload' => 25000]); - $truck = $this->findVehicle(2); - $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $truck); - $this->assertSame(25000, $truck->payload); - } - - public function testPatchCannotChangeTheType(): void - { - self::createClient()->request('PATCH', '/doctrine_discriminated_vehicles/2', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['kind' => 'car', 'seats' => 3], - ]); - - $this->assertResponseStatusCodeSame(400); - $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $this->findVehicle(2)); - } - - public function testPutReplacesSubtypeProperties(): void - { - self::createClient()->request('PUT', '/doctrine_discriminated_vehicles/2', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['kind' => 'truck', 'name' => 'Renamed truck', 'payload' => 1000], - ]); - - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['kind' => 'truck', 'name' => 'Renamed truck', 'payload' => 1000]); - - $truck = $this->findVehicle(2); - $this->assertInstanceOf(DoctrineDiscriminatedTruck::class, $truck); - $this->assertSame('Renamed truck', $truck->name); - } - - public function testDelete(): void - { - self::createClient()->request('DELETE', '/doctrine_discriminated_vehicles/2'); - - $this->assertResponseStatusCodeSame(204); - $this->assertNull($this->findVehicle(2)); - } - public function testJoinedInheritanceWithIntegerDiscriminatorValues(): void { $client = self::createClient(); @@ -355,7 +157,7 @@ public function testJoinedInheritanceWithIntegerDiscriminatorValues(): void $this->assertJsonEquals([ '@context' => '/contexts/DoctrineDiscriminatedShape', '@id' => '/doctrine_discriminated_shapes/1', - '@type' => 'DoctrineDiscriminatedShape', + '@type' => 'DoctrineDiscriminatedCircle', 'shapeType' => '1', 'id' => 1, 'color' => 'red', @@ -369,13 +171,6 @@ public function testJoinedInheritanceWithIntegerDiscriminatorValues(): void $this->assertResponseStatusCodeSame(201); $this->assertJsonContains(['shapeType' => '2', 'side' => 3]); $this->assertInstanceOf(DoctrineDiscriminatedSquare::class, $this->getManager()->find(DoctrineDiscriminatedShape::class, 2)); - - $client->request('PATCH', '/doctrine_discriminated_shapes/1', [ - 'headers' => ['Content-Type' => 'application/merge-patch+json'], - 'json' => ['radius' => 4], - ]); - $this->assertResponseIsSuccessful(); - $this->assertJsonContains(['shapeType' => '1', 'radius' => 4]); } public function testSerializerDiscriminatorMapTakesPrecedence(): void @@ -387,19 +182,14 @@ public function testSerializerDiscriminatorMapTakesPrecedence(): void $this->assertJsonEquals([ '@context' => '/contexts/DoctrineDiscriminatedAnimal', '@id' => '/doctrine_discriminated_animals/1', - '@type' => 'DoctrineDiscriminatedAnimal', + '@type' => 'DoctrineDiscriminatedDog', 'species' => 'canine', 'id' => 1, 'name' => 'Rex', 'goodBoy' => true, ]); - // Only the subtypes of the serializer map can be created. - $client->request('POST', '/doctrine_discriminated_animals', [ - 'headers' => ['Content-Type' => 'application/ld+json'], - 'json' => ['species' => 'cat', 'name' => 'Tom', 'lives' => 7], - ]); - $this->assertResponseStatusCodeSame(400); + // Only the subtypes of the serializer map can be created, using its type property $client->request('POST', '/doctrine_discriminated_animals', [ 'headers' => ['Content-Type' => 'application/ld+json'], 'json' => ['discr' => 'cat', 'name' => 'Tom', 'lives' => 7], @@ -407,38 +197,6 @@ public function testSerializerDiscriminatorMapTakesPrecedence(): void $this->assertResponseStatusCodeSame(400); } - public function testOpenApiDocumentsDoctrineSubtypes(): void - { - $json = self::createClient()->request('GET', '/docs', [ - 'headers' => ['Accept' => 'application/vnd.openapi+json'], - ])->toArray(); - $schemas = $json['components']['schemas']; - - $output = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_vehicles/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); - $this->assertSame('kind', $output['discriminator']['propertyName']); - $this->assertEqualsCanonicalizing([ - 'car' => '#/components/schemas/DoctrineDiscriminatedVehicle.DoctrineDiscriminatedCar.jsonld', - 'sportsCar' => '#/components/schemas/DoctrineDiscriminatedVehicle.DoctrineDiscriminatedSportsCar.jsonld', - 'truck' => '#/components/schemas/DoctrineDiscriminatedVehicle.DoctrineDiscriminatedTruck.jsonld', - ], $output['discriminator']['mapping']); - $this->assertSame(['type' => 'string', 'enum' => ['truck']], $schemas['DoctrineDiscriminatedVehicle.DoctrineDiscriminatedTruck.jsonld']['properties']['kind']); - $this->assertArrayHasKey('payload', $schemas['DoctrineDiscriminatedVehicle.DoctrineDiscriminatedTruck.jsonld']['properties']); - - $input = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_vehicles']['post']['requestBody']['content']['application/ld+json']['schema']['$ref']); - $this->assertSame('kind', $input['discriminator']['propertyName']); - $this->assertArrayHasKey('truck', $input['discriminator']['mapping']); - - $shape = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_shapes/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); - $this->assertSame('shapeType', $shape['discriminator']['propertyName']); - $this->assertEqualsCanonicalizing(['1', '2'], array_map('strval', array_keys($shape['discriminator']['mapping']))); - - $animal = $this->findDefinition($schemas, $json['paths']['/doctrine_discriminated_animals/{id}']['get']['responses']['200']['content']['application/ld+json']['schema']['$ref']); - $this->assertSame([ - 'propertyName' => 'species', - 'mapping' => ['canine' => '#/components/schemas/DoctrineDiscriminatedAnimal.DoctrineDiscriminatedDog.jsonld'], - ], $animal['discriminator']); - } - private function findVehicle(int $id): ?DoctrineDiscriminatedVehicle { $manager = $this->getManager(); @@ -446,23 +204,4 @@ private function findVehicle(int $id): ?DoctrineDiscriminatedVehicle return $manager->find(DoctrineDiscriminatedVehicle::class, $id); } - - /** - * @param array> $schemas - * - * @return array - */ - private function findDefinition(array $schemas, string $ref): array - { - $definition = $schemas[substr($ref, \strlen('#/components/schemas/'))]; - - // JSON-LD output wraps the definition in an allOf with the hydra base schema. - foreach ($definition['allOf'] ?? [] as $part) { - if (isset($part['discriminator'])) { - return $part; - } - } - - return $definition; - } } diff --git a/tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php b/tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php index efa01c72a23..4f6c5ca9c68 100644 --- a/tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php +++ b/tests/Symfony/Bundle/DependencyInjection/Compiler/SerializerMappingLoaderPassTest.php @@ -20,6 +20,7 @@ use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Definition; use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader; +use Symfony\Component\Serializer\Mapping\Loader\LoaderChain; final class SerializerMappingLoaderPassTest extends TestCase { @@ -35,10 +36,15 @@ public function testDoctrineDiscriminatorMappingLoadersAreAppendedAfterTheOtherL $this->assertCount(3, $chainLoaders); $this->assertSame([$orm, $odm], \array_slice($chainLoaders, 1)); + foreach ([$orm, $odm] as $loader) { + $serializerLoader = $loader->getArgument('$serializerLoader'); + $this->assertSame(LoaderChain::class, $serializerLoader->getClass()); + $this->assertSame([$chainLoaders[0]], $serializerLoader->getArgument(0)); + } + + // The cache warmer builds the metadata of the classes mapped by the other loaders: they must get their Doctrine map too $warmerLoaders = $container->getDefinition('serializer.mapping.cache_warmer')->getArgument(0); - $this->assertCount(4, $warmerLoaders); - $this->assertSame(PropertyMetadataLoader::class, $warmerLoaders[1]->getClass()); - $this->assertSame([$orm, $odm], \array_slice($warmerLoaders, 2)); + $this->assertSame([$chainLoaders[0], $container->getDefinition('api_platform.serializer.property_metadata_loader'), $orm, $odm], $warmerLoaders); } public function testChainLoaderIsUntouchedWithoutDoctrineDiscriminatorMappingLoader(): void diff --git a/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php b/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php index 6f34daef554..cb8bceb5715 100644 --- a/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php +++ b/tests/Symfony/Bundle/DependencyInjection/ConfigurationTest.php @@ -242,6 +242,7 @@ private function runDefaultConfigTests(array $doctrineIntegrationsToLoad = ['orm 'handle_symfony_errors' => false, 'serializer' => [ 'hydra_prefix' => null, + 'discriminator_map' => false, ], 'enable_phpdoc_parser' => true, 'mcp' => [