vendor/api-platform/core/src/Hydra/Serializer/DocumentationNormalizer.php line 56

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the API Platform project.
  5.  *
  6.  * (c) Kévin Dunglas <dunglas@gmail.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. declare(strict_types=1);
  14. namespace ApiPlatform\Hydra\Serializer;
  16. use ApiPlatform\Api\ResourceClassResolverInterface as LegacyResourceClassResolverInterface;
  17. use ApiPlatform\Api\UrlGeneratorInterface as LegacyUrlGeneratorInterface;
  18. use ApiPlatform\Documentation\Documentation;
  19. use ApiPlatform\JsonLd\ContextBuilderInterface;
  20. use ApiPlatform\Metadata\ApiProperty;
  21. use ApiPlatform\Metadata\ApiResource;
  22. use ApiPlatform\Metadata\CollectionOperationInterface;
  23. use ApiPlatform\Metadata\ErrorResource;
  24. use ApiPlatform\Metadata\HttpOperation;
  25. use ApiPlatform\Metadata\Operation;
  26. use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
  27. use ApiPlatform\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
  28. use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
  29. use ApiPlatform\Metadata\Resource\ResourceMetadataCollection;
  30. use ApiPlatform\Metadata\ResourceClassResolverInterface;
  31. use ApiPlatform\Metadata\UrlGeneratorInterface;
  32. use ApiPlatform\Serializer\CacheableSupportsMethodInterface;
  33. use ApiPlatform\Symfony\Validator\Exception\ValidationException;
  34. use Symfony\Component\PropertyInfo\Type;
  35. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  36. use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
  37. use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
  38. use Symfony\Component\Serializer\Serializer;
  40. /**
  41.  * Creates a machine readable Hydra API documentation.
  42.  *
  43.  * @author Kévin Dunglas <dunglas@gmail.com>
  44.  */
  45. final class DocumentationNormalizer implements NormalizerInterface, CacheableSupportsMethodInterface
  46. {
  47.     public const FORMAT = 'jsonld';
  49.     public function __construct(private readonly ResourceMetadataCollectionFactoryInterface $resourceMetadataFactory, private readonly PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, private readonly PropertyMetadataFactoryInterface $propertyMetadataFactory, private readonly ResourceClassResolverInterface|LegacyResourceClassResolverInterface $resourceClassResolver, private readonly UrlGeneratorInterface|LegacyUrlGeneratorInterface $urlGenerator, private readonly ?NameConverterInterface $nameConverter = null)
  50.     {
  51.     }
  53.     /**
  54.      * {@inheritdoc}
  55.      */
  56.     public function normalize(mixed $object, ?string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
  57.     {
  58.         $classes = [];
  59.         $entrypointProperties = [];
  61.         foreach ($object->getResourceNameCollection() as $resourceClass) {
  62.             $resourceMetadataCollection = $this->resourceMetadataFactory->create($resourceClass);
  64.             $resourceMetadata = $resourceMetadataCollection[0];
  65.             if ($resourceMetadata instanceof ErrorResource && ValidationException::class === $resourceMetadata->getClass()) {
  66.                 continue;
  67.             }
  69.             $shortName = $resourceMetadata->getShortName();
  70.             $prefixedShortName = $resourceMetadata->getTypes()[0] ?? "#$shortName";
  71.             $this->populateEntrypointProperties($resourceMetadata, $shortName, $prefixedShortName, $entrypointProperties, $resourceMetadataCollection);
  72.             $classes[] = $this->getClass($resourceClass, $resourceMetadata, $shortName, $prefixedShortName, $context, $resourceMetadataCollection);
  73.         }
  75.         return $this->computeDoc($object, $this->getClasses($entrypointProperties, $classes));
  76.     }
  78.     /**
  79.      * Populates entrypoint properties.
  80.      */
  81.     private function populateEntrypointProperties(ApiResource $resourceMetadata, string $shortName, string $prefixedShortName, array &$entrypointProperties, ?ResourceMetadataCollection $resourceMetadataCollection = null): void
  82.     {
  83.         $hydraCollectionOperations = $this->getHydraOperations(true, $resourceMetadataCollection);
  84.         if (empty($hydraCollectionOperations)) {
  85.             return;
  86.         }
  88.         $entrypointProperty = [
  89.             '@type' => 'hydra:SupportedProperty',
  90.             'hydra:property' => [
  91.                 '@id' => sprintf('#Entrypoint/%s', lcfirst($shortName)),
  92.                 '@type' => 'hydra:Link',
  93.                 'domain' => '#Entrypoint',
  94.                 'rdfs:label' => "The collection of $shortName resources",
  95.                 'rdfs:range' => [
  96.                     ['@id' => 'hydra:Collection'],
  97.                     [
  98.                         'owl:equivalentClass' => [
  99.                             'owl:onProperty' => ['@id' => 'hydra:member'],
  100.                             'owl:allValuesFrom' => ['@id' => $prefixedShortName],
  101.                         ],
  102.                     ],
  103.                 ],
  104.                 'hydra:supportedOperation' => $hydraCollectionOperations,
  105.             ],
  106.             'hydra:title' => "The collection of $shortName resources",
  107.             'hydra:readable' => true,
  108.             'hydra:writeable' => false,
  109.         ];
  111.         if ($resourceMetadata->getDeprecationReason()) {
  112.             $entrypointProperty['owl:deprecated'] = true;
  113.         }
  115.         $entrypointProperties[] = $entrypointProperty;
  116.     }
  118.     /**
  119.      * Gets a Hydra class.
  120.      */
  121.     private function getClass(string $resourceClass, ApiResource $resourceMetadata, string $shortName, string $prefixedShortName, array $context, ?ResourceMetadataCollection $resourceMetadataCollection = null): array
  122.     {
  123.         $description = $resourceMetadata->getDescription();
  124.         $isDeprecated = $resourceMetadata->getDeprecationReason();
  126.         $class = [
  127.             '@id' => $prefixedShortName,
  128.             '@type' => 'hydra:Class',
  129.             'rdfs:label' => $shortName,
  130.             'hydra:title' => $shortName,
  131.             'hydra:supportedProperty' => $this->getHydraProperties($resourceClass, $resourceMetadata, $shortName, $prefixedShortName, $context),
  132.             'hydra:supportedOperation' => $this->getHydraOperations(false, $resourceMetadataCollection),
  133.         ];
  135.         if (null !== $description) {
  136.             $class['hydra:description'] = $description;
  137.         }
  139.         if ($isDeprecated) {
  140.             $class['owl:deprecated'] = true;
  141.         }
  143.         return $class;
  144.     }
  146.     /**
  147.      * Creates context for property metatata factories.
  148.      */
  149.     private function getPropertyMetadataFactoryContext(ApiResource $resourceMetadata): array
  150.     {
  151.         $normalizationGroups = $resourceMetadata->getNormalizationContext()[AbstractNormalizer::GROUPS] ?? null;
  152.         $denormalizationGroups = $resourceMetadata->getDenormalizationContext()[AbstractNormalizer::GROUPS] ?? null;
  153.         $propertyContext = [
  154.             'normalization_groups' => $normalizationGroups,
  155.             'denormalization_groups' => $denormalizationGroups,
  156.         ];
  157.         $propertyNameContext = [];
  159.         if ($normalizationGroups) {
  160.             $propertyNameContext['serializer_groups'] = $normalizationGroups;
  161.         }
  163.         if (!$denormalizationGroups) {
  164.             return [$propertyNameContext, $propertyContext];
  165.         }
  167.         if (!isset($propertyNameContext['serializer_groups'])) {
  168.             $propertyNameContext['serializer_groups'] = $denormalizationGroups;
  170.             return [$propertyNameContext, $propertyContext];
  171.         }
  173.         foreach ($denormalizationGroups as $group) {
  174.             $propertyNameContext['serializer_groups'][] = $group;
  175.         }
  177.         return [$propertyNameContext, $propertyContext];
  178.     }
  180.     /**
  181.      * Gets Hydra properties.
  182.      */
  183.     private function getHydraProperties(string $resourceClass, ApiResource $resourceMetadata, string $shortName, string $prefixedShortName, array $context): array
  184.     {
  185.         $classes = [];
  187.         $classes[$resourceClass] = true;
  188.         foreach ($resourceMetadata->getOperations() as $operation) {
  189.             /** @var Operation $operation */
  190.             if (!$operation instanceof CollectionOperationInterface) {
  191.                 continue;
  192.             }
  194.             $inputMetadata = $operation->getInput();
  195.             if (null !== $inputClass = $inputMetadata['class'] ?? null) {
  196.                 $classes[$inputClass] = true;
  197.             }
  199.             $outputMetadata = $operation->getOutput();
  200.             if (null !== $outputClass = $outputMetadata['class'] ?? null) {
  201.                 $classes[$outputClass] = true;
  202.             }
  203.         }
  205.         /** @var string[] $classes */
  206.         $classes = array_keys($classes);
  207.         $properties = [];
  208.         [$propertyNameContext, $propertyContext] = $this->getPropertyMetadataFactoryContext($resourceMetadata);
  210.         foreach ($classes as $class) {
  211.             foreach ($this->propertyNameCollectionFactory->create($class, $propertyNameContext) as $propertyName) {
  212.                 $propertyMetadata = $this->propertyMetadataFactory->create($class, $propertyName, $propertyContext);
  214.                 if (true === $propertyMetadata->isIdentifier() && false === $propertyMetadata->isWritable()) {
  215.                     continue;
  216.                 }
  218.                 if ($this->nameConverter) {
  219.                     $propertyName = $this->nameConverter->normalize($propertyName, $class, self::FORMAT, $context);
  220.                 }
  222.                 $properties[] = $this->getProperty($propertyMetadata, $propertyName, $prefixedShortName, $shortName);
  223.             }
  224.         }
  226.         return $properties;
  227.     }
  229.     /**
  230.      * Gets Hydra operations.
  231.      */
  232.     private function getHydraOperations(bool $collection, ?ResourceMetadataCollection $resourceMetadataCollection = null): array
  233.     {
  234.         $hydraOperations = [];
  235.         foreach ($resourceMetadataCollection as $resourceMetadata) {
  236.             foreach ($resourceMetadata->getOperations() as $operation) {
  237.                 if (('POST' === $operation->getMethod() || $operation instanceof CollectionOperationInterface) !== $collection) {
  238.                     continue;
  239.                 }
  241.                 $hydraOperations[] = $this->getHydraOperation($operation, $operation->getTypes()[0] ?? "#{$operation->getShortName()}");
  242.             }
  243.         }
  245.         return $hydraOperations;
  246.     }
  248.     /**
  249.      * Gets and populates if applicable a Hydra operation.
  250.      */
  251.     private function getHydraOperation(HttpOperation $operation, string $prefixedShortName): array
  252.     {
  253.         $method = $operation->getMethod() ?: 'GET';
  255.         $hydraOperation = $operation->getHydraContext() ?? [];
  256.         if ($operation->getDeprecationReason()) {
  257.             $hydraOperation['owl:deprecated'] = true;
  258.         }
  260.         $shortName = $operation->getShortName();
  261.         $inputMetadata = $operation->getInput() ?? [];
  262.         $outputMetadata = $operation->getOutput() ?? [];
  264.         $inputClass = \array_key_exists('class', $inputMetadata) ? $inputMetadata['class'] : false;
  265.         $outputClass = \array_key_exists('class', $outputMetadata) ? $outputMetadata['class'] : false;
  267.         if ('GET' === $method && $operation instanceof CollectionOperationInterface) {
  268.             $hydraOperation += [
  269.                 '@type' => ['hydra:Operation', 'schema:FindAction'],
  270.                 'hydra:title' => "Retrieves the collection of $shortName resources.",
  271.                 'returns' => null === $outputClass ? 'owl:Nothing' : 'hydra:Collection',
  272.             ];
  273.         } elseif ('GET' === $method) {
  274.             $hydraOperation += [
  275.                 '@type' => ['hydra:Operation', 'schema:FindAction'],
  276.                 'hydra:title' => "Retrieves a $shortName resource.",
  277.                 'returns' => null === $outputClass ? 'owl:Nothing' : $prefixedShortName,
  278.             ];
  279.         } elseif ('PATCH' === $method) {
  280.             $hydraOperation += [
  281.                 '@type' => 'hydra:Operation',
  282.                 'hydra:title' => "Updates the $shortName resource.",
  283.                 'returns' => null === $outputClass ? 'owl:Nothing' : $prefixedShortName,
  284.                 'expects' => null === $inputClass ? 'owl:Nothing' : $prefixedShortName,
  285.             ];
  286.         } elseif ('POST' === $method) {
  287.             $hydraOperation += [
  288.                 '@type' => ['hydra:Operation', 'schema:CreateAction'],
  289.                 'hydra:title' => "Creates a $shortName resource.",
  290.                 'returns' => null === $outputClass ? 'owl:Nothing' : $prefixedShortName,
  291.                 'expects' => null === $inputClass ? 'owl:Nothing' : $prefixedShortName,
  292.             ];
  293.         } elseif ('PUT' === $method) {
  294.             $hydraOperation += [
  295.                 '@type' => ['hydra:Operation', 'schema:ReplaceAction'],
  296.                 'hydra:title' => "Replaces the $shortName resource.",
  297.                 'returns' => null === $outputClass ? 'owl:Nothing' : $prefixedShortName,
  298.                 'expects' => null === $inputClass ? 'owl:Nothing' : $prefixedShortName,
  299.             ];
  300.         } elseif ('DELETE' === $method) {
  301.             $hydraOperation += [
  302.                 '@type' => ['hydra:Operation', 'schema:DeleteAction'],
  303.                 'hydra:title' => "Deletes the $shortName resource.",
  304.                 'returns' => 'owl:Nothing',
  305.             ];
  306.         }
  308.         $hydraOperation['hydra:method'] ?? $hydraOperation['hydra:method'] = $method;
  310.         if (!isset($hydraOperation['rdfs:label']) && isset($hydraOperation['hydra:title'])) {
  311.             $hydraOperation['rdfs:label'] = $hydraOperation['hydra:title'];
  312.         }
  314.         ksort($hydraOperation);
  316.         return $hydraOperation;
  317.     }
  319.     /**
  320.      * Gets the range of the property.
  321.      */
  322.     private function getRange(ApiProperty $propertyMetadata): array|string|null
  323.     {
  324.         $jsonldContext = $propertyMetadata->getJsonldContext();
  326.         if (isset($jsonldContext['@type'])) {
  327.             return $jsonldContext['@type'];
  328.         }
  330.         $builtInTypes = $propertyMetadata->getBuiltinTypes() ?? [];
  331.         $types = [];
  333.         foreach ($builtInTypes as $type) {
  334.             if ($type->isCollection() && null !== $collectionType = $type->getCollectionValueTypes()[0] ?? null) {
  335.                 $type = $collectionType;
  336.             }
  338.             switch ($type->getBuiltinType()) {
  339.                 case Type::BUILTIN_TYPE_STRING:
  340.                     if (!\in_array('xmls:string', $types, true)) {
  341.                         $types[] = 'xmls:string';
  342.                     }
  343.                     break;
  344.                 case Type::BUILTIN_TYPE_INT:
  345.                     if (!\in_array('xmls:integer', $types, true)) {
  346.                         $types[] = 'xmls:integer';
  347.                     }
  348.                     break;
  349.                 case Type::BUILTIN_TYPE_FLOAT:
  350.                     if (!\in_array('xmls:decimal', $types, true)) {
  351.                         $types[] = 'xmls:decimal';
  352.                     }
  353.                     break;
  354.                 case Type::BUILTIN_TYPE_BOOL:
  355.                     if (!\in_array('xmls:boolean', $types, true)) {
  356.                         $types[] = 'xmls:boolean';
  357.                     }
  358.                     break;
  359.                 case Type::BUILTIN_TYPE_OBJECT:
  360.                     if (null === $className = $type->getClassName()) {
  361.                         continue 2;
  362.                     }
  364.                     if (is_a($className, \DateTimeInterface::class, true)) {
  365.                         if (!\in_array('xmls:dateTime', $types, true)) {
  366.                             $types[] = 'xmls:dateTime';
  367.                         }
  368.                         break;
  369.                     }
  371.                     if ($this->resourceClassResolver->isResourceClass($className)) {
  372.                         $resourceMetadata = $this->resourceMetadataFactory->create($className);
  373.                         $operation = $resourceMetadata->getOperation();
  375.                         if (!$operation instanceof HttpOperation || !$operation->getTypes()) {
  376.                             if (!\in_array("#{$operation->getShortName()}", $types, true)) {
  377.                                 $types[] = "#{$operation->getShortName()}";
  378.                             }
  379.                             break;
  380.                         }
  382.                         $types = array_unique(array_merge($types, $operation->getTypes()));
  383.                         break;
  384.                     }
  385.             }
  386.         }
  388.         if ([] === $types) {
  389.             return null;
  390.         }
  392.         return 1 === \count($types) ? $types[0] : $types;
  393.     }
  395.     private function isSingleRelation(ApiProperty $propertyMetadata): bool
  396.     {
  397.         $builtInTypes = $propertyMetadata->getBuiltinTypes() ?? [];
  399.         foreach ($builtInTypes as $type) {
  400.             $className = $type->getClassName();
  401.             if (!$type->isCollection()
  402.                 && null !== $className
  403.                 && $this->resourceClassResolver->isResourceClass($className)
  404.             ) {
  405.                 return true;
  406.             }
  407.         }
  409.         return false;
  410.     }
  412.     /**
  413.      * Builds the classes array.
  414.      */
  415.     private function getClasses(array $entrypointProperties, array $classes): array
  416.     {
  417.         $classes[] = [
  418.             '@id' => '#Entrypoint',
  419.             '@type' => 'hydra:Class',
  420.             'hydra:title' => 'The API entrypoint',
  421.             'hydra:supportedProperty' => $entrypointProperties,
  422.             'hydra:supportedOperation' => [
  423.                 '@type' => 'hydra:Operation',
  424.                 'hydra:method' => 'GET',
  425.                 'rdfs:label' => 'The API entrypoint.',
  426.                 'returns' => '#EntryPoint',
  427.             ],
  428.         ];
  430.         // Constraint violation
  431.         $classes[] = [
  432.             '@id' => '#ConstraintViolation',
  433.             '@type' => 'hydra:Class',
  434.             'hydra:title' => 'A constraint violation',
  435.             'hydra:supportedProperty' => [
  436.                 [
  437.                     '@type' => 'hydra:SupportedProperty',
  438.                     'hydra:property' => [
  439.                         '@id' => '#ConstraintViolation/propertyPath',
  440.                         '@type' => 'rdf:Property',
  441.                         'rdfs:label' => 'propertyPath',
  442.                         'domain' => '#ConstraintViolation',
  443.                         'range' => 'xmls:string',
  444.                     ],
  445.                     'hydra:title' => 'propertyPath',
  446.                     'hydra:description' => 'The property path of the violation',
  447.                     'hydra:readable' => true,
  448.                     'hydra:writeable' => false,
  449.                 ],
  450.                 [
  451.                     '@type' => 'hydra:SupportedProperty',
  452.                     'hydra:property' => [
  453.                         '@id' => '#ConstraintViolation/message',
  454.                         '@type' => 'rdf:Property',
  455.                         'rdfs:label' => 'message',
  456.                         'domain' => '#ConstraintViolation',
  457.                         'range' => 'xmls:string',
  458.                     ],
  459.                     'hydra:title' => 'message',
  460.                     'hydra:description' => 'The message associated with the violation',
  461.                     'hydra:readable' => true,
  462.                     'hydra:writeable' => false,
  463.                 ],
  464.             ],
  465.         ];
  467.         // Constraint violation list
  468.         $classes[] = [
  469.             '@id' => '#ConstraintViolationList',
  470.             '@type' => 'hydra:Class',
  471.             'subClassOf' => 'hydra:Error',
  472.             'hydra:title' => 'A constraint violation list',
  473.             'hydra:supportedProperty' => [
  474.                 [
  475.                     '@type' => 'hydra:SupportedProperty',
  476.                     'hydra:property' => [
  477.                         '@id' => '#ConstraintViolationList/violations',
  478.                         '@type' => 'rdf:Property',
  479.                         'rdfs:label' => 'violations',
  480.                         'domain' => '#ConstraintViolationList',
  481.                         'range' => '#ConstraintViolation',
  482.                     ],
  483.                     'hydra:title' => 'violations',
  484.                     'hydra:description' => 'The violations',
  485.                     'hydra:readable' => true,
  486.                     'hydra:writeable' => false,
  487.                 ],
  488.             ],
  489.         ];
  491.         return $classes;
  492.     }
  494.     /**
  495.      * Gets a property definition.
  496.      */
  497.     private function getProperty(ApiProperty $propertyMetadata, string $propertyName, string $prefixedShortName, string $shortName): array
  498.     {
  499.         if ($iri = $propertyMetadata->getIris()) {
  500.             $iri = 1 === (is_countable($iri) ? \count($iri) : 0) ? $iri[0] : $iri;
  501.         }
  503.         if (!isset($iri)) {
  504.             $iri = "#$shortName/$propertyName";
  505.         }
  507.         $propertyData = [
  508.             '@id' => $iri,
  509.             '@type' => false === $propertyMetadata->isReadableLink() ? 'hydra:Link' : 'rdf:Property',
  510.             'rdfs:label' => $propertyName,
  511.             'domain' => $prefixedShortName,
  512.         ];
  514.         if ($propertyMetadata->getDeprecationReason()) {
  515.             $propertyData['owl:deprecated'] = true;
  516.         }
  518.         if ($this->isSingleRelation($propertyMetadata)) {
  519.             $propertyData['owl:maxCardinality'] = 1;
  520.         }
  522.         if (null !== $range = $this->getRange($propertyMetadata)) {
  523.             $propertyData['range'] = $range;
  524.         }
  526.         $property = [
  527.             '@type' => 'hydra:SupportedProperty',
  528.             'hydra:property' => $propertyData,
  529.             'hydra:title' => $propertyName,
  530.             'hydra:required' => $propertyMetadata->isRequired(),
  531.             'hydra:readable' => $propertyMetadata->isReadable(),
  532.             'hydra:writeable' => $propertyMetadata->isWritable() || $propertyMetadata->isInitializable(),
  533.         ];
  535.         if (null !== $description = $propertyMetadata->getDescription()) {
  536.             $property['hydra:description'] = $description;
  537.         }
  539.         return $property;
  540.     }
  542.     /**
  543.      * Computes the documentation.
  544.      */
  545.     private function computeDoc(Documentation $object, array $classes): array
  546.     {
  547.         $doc = ['@context' => $this->getContext(), '@id' => $this->urlGenerator->generate('api_doc', ['_format' => self::FORMAT]), '@type' => 'hydra:ApiDocumentation'];
  549.         if ('' !== $object->getTitle()) {
  550.             $doc['hydra:title'] = $object->getTitle();
  551.         }
  553.         if ('' !== $object->getDescription()) {
  554.             $doc['hydra:description'] = $object->getDescription();
  555.         }
  557.         $doc['hydra:entrypoint'] = $this->urlGenerator->generate('api_entrypoint');
  558.         $doc['hydra:supportedClass'] = $classes;
  560.         return $doc;
  561.     }
  563.     /**
  564.      * Builds the JSON-LD context for the API documentation.
  565.      */
  566.     private function getContext(): array
  567.     {
  568.         return [
  569.             '@vocab' => $this->urlGenerator->generate('api_doc', ['_format' => self::FORMAT], UrlGeneratorInterface::ABS_URL).'#',
  570.             'hydra' => ContextBuilderInterface::HYDRA_NS,
  571.             'rdf' => ContextBuilderInterface::RDF_NS,
  572.             'rdfs' => ContextBuilderInterface::RDFS_NS,
  573.             'xmls' => ContextBuilderInterface::XML_NS,
  574.             'owl' => ContextBuilderInterface::OWL_NS,
  575.             'schema' => ContextBuilderInterface::SCHEMA_ORG_NS,
  576.             'domain' => ['@id' => 'rdfs:domain', '@type' => '@id'],
  577.             'range' => ['@id' => 'rdfs:range', '@type' => '@id'],
  578.             'subClassOf' => ['@id' => 'rdfs:subClassOf', '@type' => '@id'],
  579.             'expects' => ['@id' => 'hydra:expects', '@type' => '@id'],
  580.             'returns' => ['@id' => 'hydra:returns', '@type' => '@id'],
  581.         ];
  582.     }
  584.     /**
  585.      * {@inheritdoc}
  586.      */
  587.     public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
  588.     {
  589.         return self::FORMAT === $format && $data instanceof Documentation;
  590.     }
  592.     public function getSupportedTypes($format): array
  593.     {
  594.         return self::FORMAT === $format ? [Documentation::class => true] : [];
  595.     }
  597.     public function hasCacheableSupportsMethod(): bool
  598.     {
  599.         if (method_exists(Serializer::class, 'getSupportedTypes')) {
  600.             trigger_deprecation(
  601.                 'api-platform/core',
  602.                 '3.1',
  603.                 'The "%s()" method is deprecated, use "getSupportedTypes()" instead.',
  604.                 __METHOD__
  605.             );
  606.         }
  608.         return true;
  609.     }
  610. }