vendor/nelmio/api-doc-bundle/src/ModelDescriber/ObjectModelDescriber.php line 51

Open in your IDE?
  1. <?php
  3. /*
  4. * This file is part of the NelmioApiDocBundle package.
  5. *
  6. * (c) Nelmio
  7. *
  8. * For the full copyright and license information, please view the LICENSE
  9. * file that was distributed with this source code.
  10. */
  12. namespace Nelmio\ApiDocBundle\ModelDescriber;
  14. use Doctrine\Common\Annotations\Reader;
  15. use Nelmio\ApiDocBundle\Describer\ModelRegistryAwareInterface;
  16. use Nelmio\ApiDocBundle\Describer\ModelRegistryAwareTrait;
  17. use Nelmio\ApiDocBundle\Model\Model;
  18. use Nelmio\ApiDocBundle\ModelDescriber\Annotations\AnnotationsReader;
  19. use Nelmio\ApiDocBundle\OpenApiPhp\Util;
  20. use Nelmio\ApiDocBundle\PropertyDescriber\PropertyDescriberInterface;
  21. use OpenApi\Annotations as OA;
  22. use OpenApi\Generator;
  23. use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface;
  24. use Symfony\Component\PropertyInfo\Type;
  25. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  26. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  28. class ObjectModelDescriber implements ModelDescriberInterface, ModelRegistryAwareInterface
  29. {
  30. use ModelRegistryAwareTrait;
  31. use ApplyOpenApiDiscriminatorTrait;
  33. /** @var PropertyInfoExtractorInterface */
  34. private $propertyInfo;
  35. /** @var ClassMetadataFactoryInterface|null */
  36. private $classMetadataFactory;
  37. /** @var Reader|null */
  38. private $doctrineReader;
  39. /** @var PropertyDescriberInterface|PropertyDescriberInterface[] */
  40. private $propertyDescriber;
  41. /** @var string[] */
  42. private $mediaTypes;
  43. /** @var NameConverterInterface|null */
  44. private $nameConverter;
  45. /** @var bool */
  46. private $useValidationGroups;
  48. /**
  49. * @param PropertyDescriberInterface|PropertyDescriberInterface[] $propertyDescribers
  50. */
  51. public function __construct(
  52. PropertyInfoExtractorInterface $propertyInfo,
  53. ?Reader $reader,
  54. $propertyDescribers,
  55. array $mediaTypes,
  56. NameConverterInterface $nameConverter = null,
  57. bool $useValidationGroups = false,
  58. ClassMetadataFactoryInterface $classMetadataFactory = null
  59. ) {
  60. if (is_iterable($propertyDescribers)) {
  61. trigger_deprecation('nelmio/api-doc-bundle', '4.17', 'Passing an array of PropertyDescriberInterface to %s() is deprecated. Pass a single PropertyDescriberInterface instead.', __METHOD__);
  62. } else {
  63. if (!$propertyDescribers instanceof PropertyDescriberInterface) {
  64. throw new \InvalidArgumentException(sprintf('Argument 3 passed to %s() must be an array of %s or a single %s.', __METHOD__, PropertyDescriberInterface::class, PropertyDescriberInterface::class));
  65. }
  66. }
  68. $this->propertyInfo = $propertyInfo;
  69. $this->doctrineReader = $reader;
  70. $this->propertyDescriber = $propertyDescribers;
  71. $this->mediaTypes = $mediaTypes;
  72. $this->nameConverter = $nameConverter;
  73. $this->useValidationGroups = $useValidationGroups;
  74. $this->classMetadataFactory = $classMetadataFactory;
  75. }
  77. public function describe(Model $model, OA\Schema $schema)
  78. {
  79. $class = $model->getType()->getClassName();
  80. $schema->_context->class = $class;
  82. $context = ['serializer_groups' => null];
  83. if (null !== $model->getGroups()) {
  84. $context['serializer_groups'] = array_filter($model->getGroups(), 'is_string');
  85. }
  87. $reflClass = new \ReflectionClass($class);
  88. $annotationsReader = new AnnotationsReader(
  89. $this->doctrineReader,
  90. $this->modelRegistry,
  91. $this->mediaTypes,
  92. $this->useValidationGroups
  93. );
  94. $classResult = $annotationsReader->updateDefinition($reflClass, $schema);
  96. if (!$classResult->shouldDescribeModelProperties()) {
  97. return;
  98. }
  100. $schema->type = 'object';
  102. $mapping = false;
  103. if (null !== $this->classMetadataFactory) {
  104. $mapping = $this->classMetadataFactory
  105. ->getMetadataFor($class)
  106. ->getClassDiscriminatorMapping();
  107. }
  109. if ($mapping && Generator::UNDEFINED === $schema->discriminator) {
  110. $this->applyOpenApiDiscriminator(
  111. $model,
  112. $schema,
  113. $this->modelRegistry,
  114. $mapping->getTypeProperty(),
  115. $mapping->getTypesMapping()
  116. );
  117. }
  119. $propertyInfoProperties = $this->propertyInfo->getProperties($class, $context);
  121. if (null === $propertyInfoProperties) {
  122. return;
  123. }
  125. // Fix for https://github.com/nelmio/NelmioApiDocBundle/issues/1756
  126. // The SerializerExtractor does expose private/protected properties for some reason, so we eliminate them here
  127. $propertyInfoProperties = array_intersect($propertyInfoProperties, $this->propertyInfo->getProperties($class, []) ?? []);
  129. $defaultValues = array_filter($reflClass->getDefaultProperties(), static function ($value) {
  130. return null !== $value;
  131. });
  133. foreach ($propertyInfoProperties as $propertyName) {
  134. $serializedName = null !== $this->nameConverter ? $this->nameConverter->normalize($propertyName, $class, null, $model->getSerializationContext()) : $propertyName;
  136. $reflections = $this->getReflections($reflClass, $propertyName);
  138. // Check if a custom name is set
  139. foreach ($reflections as $reflection) {
  140. $serializedName = $annotationsReader->getPropertyName($reflection, $serializedName);
  141. }
  143. $property = Util::getProperty($schema, $serializedName);
  145. // Interpret additional options
  146. $groups = $model->getGroups();
  147. if (isset($groups[$propertyName]) && is_array($groups[$propertyName])) {
  148. $groups = $model->getGroups()[$propertyName];
  149. }
  150. foreach ($reflections as $reflection) {
  151. $annotationsReader->updateProperty($reflection, $property, $groups);
  152. }
  154. // If type manually defined
  155. if (Generator::UNDEFINED !== $property->type || Generator::UNDEFINED !== $property->ref) {
  156. continue;
  157. }
  159. if (Generator::UNDEFINED === $property->default && array_key_exists($propertyName, $defaultValues)) {
  160. $property->default = $defaultValues[$propertyName];
  161. }
  163. $types = $this->propertyInfo->getTypes($class, $propertyName);
  164. if (null === $types || 0 === count($types)) {
  165. throw new \LogicException(sprintf('The PropertyInfo component was not able to guess the type of %s::$%s. You may need to add a `@var` annotation or use `@OA\Property(type="")` to make its type explicit.', $class, $propertyName));
  166. }
  168. $this->describeProperty($types, $model, $property, $propertyName, $schema);
  169. }
  170. }
  172. /**
  173. * @return \ReflectionProperty[]|\ReflectionMethod[]
  174. */
  175. private function getReflections(\ReflectionClass $reflClass, string $propertyName): array
  176. {
  177. $reflections = [];
  178. if ($reflClass->hasProperty($propertyName)) {
  179. $reflections[] = $reflClass->getProperty($propertyName);
  180. }
  182. $camelProp = $this->camelize($propertyName);
  183. foreach (['', 'get', 'is', 'has', 'can', 'add', 'remove', 'set'] as $prefix) {
  184. if ($reflClass->hasMethod($prefix.$camelProp)) {
  185. $reflections[] = $reflClass->getMethod($prefix.$camelProp);
  186. }
  187. }
  189. return $reflections;
  190. }
  192. /**
  193. * Camelizes a given string.
  194. */
  195. private function camelize(string $string): string
  196. {
  197. return str_replace(' ', '', ucwords(str_replace('_', ' ', $string)));
  198. }
  200. /**
  201. * @param Type[] $types
  202. */
  203. private function describeProperty(array $types, Model $model, OA\Schema $property, string $propertyName, OA\Schema $schema)
  204. {
  205. $propertyDescribers = is_iterable($this->propertyDescriber) ? $this->propertyDescriber : [$this->propertyDescriber];
  207. foreach ($propertyDescribers as $propertyDescriber) {
  208. if ($propertyDescriber instanceof ModelRegistryAwareInterface) {
  209. $propertyDescriber->setModelRegistry($this->modelRegistry);
  210. }
  211. if ($propertyDescriber->supports($types)) {
  212. $propertyDescriber->describe($types, $property, $model->getGroups(), $schema, $model->getSerializationContext());
  214. return;
  215. }
  216. }
  218. throw new \Exception(sprintf('Type "%s" is not supported in %s::$%s. You may use the `@OA\Property(type="")` annotation to specify it manually.', $types[0]->getBuiltinType(), $model->getType()->getClassName(), $propertyName));
  219. }
  221. public function supports(Model $model): bool
  222. {
  223. return Type::BUILTIN_TYPE_OBJECT === $model->getType()->getBuiltinType()
  224. && (class_exists($model->getType()->getClassName()) || interface_exists($model->getType()->getClassName()));
  225. }
  226. }