Fix JSON Schema generation for non-resource class

teohhanhui · teohhanhui · commit 320c48cdc94c · 2019-12-23T16:35:11.000+01:00
diff --git a/SchemaFactory.php b/SchemaFactory.php
@@ -14,12 +14,14 @@
 namespace ApiPlatform\Core\JsonSchema;
 
 use ApiPlatform\Core\Api\OperationType;
+use ApiPlatform\Core\Api\ResourceClassResolverInterface;
 use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
 use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
 use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
 use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
 use ApiPlatform\Core\Metadata\Resource\ResourceMetadata;
 use ApiPlatform\Core\Swagger\Serializer\DocumentationNormalizer;
+use ApiPlatform\Core\Util\ResourceClassInfoTrait;
 use Symfony\Component\PropertyInfo\Type;
 use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
 use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
@@ -33,20 +35,22 @@
  */
 final class SchemaFactory implements SchemaFactoryInterface
 {
-    private $resourceMetadataFactory;
+    use ResourceClassInfoTrait;
+
+    private $typeFactory;
     private $propertyNameCollectionFactory;
     private $propertyMetadataFactory;
-    private $typeFactory;
     private $nameConverter;
     private $distinctFormats = [];
 
-    public function __construct(TypeFactoryInterface $typeFactory, ResourceMetadataFactoryInterface $resourceMetadataFactory, PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, NameConverterInterface $nameConverter = null)
+    public function __construct(TypeFactoryInterface $typeFactory, ResourceMetadataFactoryInterface $resourceMetadataFactory, PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, NameConverterInterface $nameConverter = null, ResourceClassResolverInterface $resourceClassResolver = null)
     {
+        $this->typeFactory = $typeFactory;
         $this->resourceMetadataFactory = $resourceMetadataFactory;
         $this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
         $this->propertyMetadataFactory = $propertyMetadataFactory;
         $this->nameConverter = $nameConverter;
-        $this->typeFactory = $typeFactory;
+        $this->resourceClassResolver = $resourceClassResolver;
     }
 
     /**
@@ -62,16 +66,20 @@ public function addDistinctFormat(string $format): void
     /**
      * {@inheritdoc}
      */
-    public function buildSchema(string $resourceClass, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?Schema $schema = null, ?array $serializerContext = null, bool $forceCollection = false): Schema
+    public function buildSchema(string $className, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?Schema $schema = null, ?array $serializerContext = null, bool $forceCollection = false): Schema
     {
         $schema = $schema ?? new Schema();
-        if (null === $metadata = $this->getMetadata($resourceClass, $type, $operationType, $operationName, $serializerContext)) {
+        if (null === $metadata = $this->getMetadata($className, $type, $operationType, $operationName, $serializerContext)) {
             return $schema;
         }
         [$resourceMetadata, $serializerContext, $inputOrOutputClass] = $metadata;
 
+        if (null === $resourceMetadata && (null !== $operationType || null !== $operationName)) {
+            throw new \LogicException('The $operationType and $operationName arguments must be null for non-resource class.');
+        }
+
         $version = $schema->getVersion();
-        $definitionName = $this->buildDefinitionName($resourceClass, $format, $type, $operationType, $operationName, $serializerContext);
+        $definitionName = $this->buildDefinitionName($className, $format, $type, $operationType, $operationName, $serializerContext);
 
         if (null === $operationType || null === $operationName) {
             $method = Schema::TYPE_INPUT === $type ? 'POST' : 'GET';
@@ -103,12 +111,13 @@ public function buildSchema(string $resourceClass, string $format = 'json', stri
 
         $definition = new \ArrayObject(['type' => 'object']);
         $definitions[$definitionName] = $definition;
-        if (null !== $description = $resourceMetadata->getDescription()) {
+        if (null !== $resourceMetadata && null !== $description = $resourceMetadata->getDescription()) {
             $definition['description'] = $description;
         }
         // see https://github.com/json-schema-org/json-schema-spec/pull/737
         if (
             Schema::VERSION_SWAGGER !== $version &&
+            null !== $resourceMetadata &&
             (
                 (null !== $operationType && null !== $operationName && null !== $resourceMetadata->getTypedOperationAttribute($operationType, $operationName, 'deprecation_reason', null, true)) ||
                 null !== $resourceMetadata->getAttribute('deprecation_reason', null)
@@ -118,7 +127,7 @@ public function buildSchema(string $resourceClass, string $format = 'json', stri
         }
         // externalDocs is an OpenAPI specific extension, but JSON Schema allows additional keys, so we always add it
         // See https://json-schema.org/latest/json-schema-core.html#rfc.section.6.4
-        if (null !== $iri = $resourceMetadata->getIri()) {
+        if (null !== $resourceMetadata && null !== $iri = $resourceMetadata->getIri()) {
             $definition['externalDocs'] = ['url' => $iri];
         }
 
@@ -200,12 +209,12 @@ private function buildPropertySchema(Schema $schema, string $definitionName, str
         $schema->getDefinitions()[$definitionName]['properties'][$normalizedPropertyName] = $propertySchema;
     }
 
-    private function buildDefinitionName(string $resourceClass, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?array $serializerContext = null): string
+    private function buildDefinitionName(string $className, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?array $serializerContext = null): string
     {
-        [$resourceMetadata, $serializerContext, $inputOrOutputClass] = $this->getMetadata($resourceClass, $type, $operationType, $operationName, $serializerContext);
+        [$resourceMetadata, $serializerContext, $inputOrOutputClass] = $this->getMetadata($className, $type, $operationType, $operationName, $serializerContext);
 
-        $prefix = $resourceMetadata->getShortName();
-        if (null !== $inputOrOutputClass && $resourceClass !== $inputOrOutputClass) {
+        $prefix = $resourceMetadata ? $resourceMetadata->getShortName() : (new \ReflectionClass($className))->getShortName();
+        if (null !== $inputOrOutputClass && $className !== $inputOrOutputClass) {
             $prefix .= ':'.md5($inputOrOutputClass);
         }
 
@@ -224,14 +233,22 @@ private function buildDefinitionName(string $resourceClass, string $format = 'js
         return $name;
     }
 
-    private function getMetadata(string $resourceClass, string $type = Schema::TYPE_OUTPUT, ?string $operationType, ?string $operationName, ?array $serializerContext): ?array
+    private function getMetadata(string $className, string $type = Schema::TYPE_OUTPUT, ?string $operationType, ?string $operationName, ?array $serializerContext): ?array
     {
-        $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
+        if (!$this->isResourceClass($className)) {
+            return [
+                null,
+                $serializerContext,
+                $className,
+            ];
+        }
+
+        $resourceMetadata = $this->resourceMetadataFactory->create($className);
         $attribute = Schema::TYPE_OUTPUT === $type ? 'output' : 'input';
         if (null === $operationType || null === $operationName) {
-            $inputOrOutput = $resourceMetadata->getAttribute($attribute, ['class' => $resourceClass]);
+            $inputOrOutput = $resourceMetadata->getAttribute($attribute, ['class' => $className]);
         } else {
-            $inputOrOutput = $resourceMetadata->getTypedOperationAttribute($operationType, $operationName, $attribute, ['class' => $resourceClass], true);
+            $inputOrOutput = $resourceMetadata->getTypedOperationAttribute($operationType, $operationName, $attribute, ['class' => $className], true);
         }
 
         if (null === ($inputOrOutput['class'] ?? null)) {
diff --git a/SchemaFactoryInterface.php b/SchemaFactoryInterface.php
@@ -13,10 +13,8 @@
 
 namespace ApiPlatform\Core\JsonSchema;
 
-use ApiPlatform\Core\Exception\ResourceClassNotFoundException;
-
 /**
- * Builds a JSON Schema from an API Platform resource definition.
+ * Factory for creating the JSON Schema document corresponding to a PHP class.
  *
  * @experimental
  *
@@ -25,7 +23,7 @@
 interface SchemaFactoryInterface
 {
     /**
-     * @throws ResourceClassNotFoundException
+     * Builds the JSON Schema document corresponding to the given PHP class.
      */
-    public function buildSchema(string $resourceClass, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?Schema $schema = null, ?array $serializerContext = null, bool $forceCollection = false): Schema;
+    public function buildSchema(string $className, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?Schema $schema = null, ?array $serializerContext = null, bool $forceCollection = false): Schema;
 }
diff --git a/TypeFactory.php b/TypeFactory.php
@@ -13,6 +13,9 @@
 
 namespace ApiPlatform\Core\JsonSchema;
 
+use ApiPlatform\Core\Api\ResourceClassResolverInterface;
+use ApiPlatform\Core\Util\ResourceClassInfoTrait;
+use Ramsey\Uuid\UuidInterface;
 use Symfony\Component\PropertyInfo\Type;
 
 /**
@@ -24,21 +27,25 @@
  */
 final class TypeFactory implements TypeFactoryInterface
 {
+    use ResourceClassInfoTrait;
+
     /**
      * @var SchemaFactoryInterface|null
      */
     private $schemaFactory;
 
-    /**
-     * Injects the JSON Schema factory to use.
-     */
+    public function __construct(ResourceClassResolverInterface $resourceClassResolver = null)
+    {
+        $this->resourceClassResolver = $resourceClassResolver;
+    }
+
     public function setSchemaFactory(SchemaFactoryInterface $schemaFactory): void
     {
         $this->schemaFactory = $schemaFactory;
     }
 
     /**
-     * Gets the OpenAPI type corresponding to the given PHP type, and recursively adds needed new schema to the current schema if provided.
+     * {@inheritdoc}
      */
     public function getType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array
     {
@@ -66,7 +73,7 @@ public function getType(Type $type, string $format = 'json', ?bool $readableLink
     }
 
     /**
-     * Gets the OpenAPI type corresponding to the given PHP class, and recursively adds needed new schema to the current schema if provided.
+     * Gets the JSON Schema document which specifies the data type corresponding to the given PHP class, and recursively adds needed new schema to the current schema if provided.
      */
     private function getClassType(?string $className, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, ?Schema $schema = null): array
     {
@@ -75,20 +82,41 @@ private function getClassType(?string $className, string $format = 'json', ?bool
         }
 
         if (is_a($className, \DateTimeInterface::class, true)) {
-            return ['type' => 'string', 'format' => 'date-time'];
+            return [
+                'type' => 'string',
+                'format' => 'date-time',
+            ];
+        }
+        if (is_a($className, UuidInterface::class, true)) {
+            return [
+                'type' => 'string',
+                'format' => 'uuid',
+            ];
         }
 
-        if (null !== $this->schemaFactory && true === $readableLink && null !== $schema) { // Skip if $baseSchema is null (filters only support basic types)
-            $version = $schema->getVersion();
+        // Skip if $schema is null (filters only support basic types)
+        if (null === $schema) {
+            return ['type' => 'string'];
+        }
 
-            $subSchema = new Schema($version);
-            $subSchema->setDefinitions($schema->getDefinitions()); // Populate definitions of the main schema
+        if ($this->isResourceClass($className) && true !== $readableLink) {
+            return [
+                'type' => 'string',
+                'format' => 'iri-reference',
+            ];
+        }
 
-            $this->schemaFactory->buildSchema($className, $format, Schema::TYPE_OUTPUT, null, null, $subSchema, $serializerContext);
+        $version = $schema->getVersion();
 
-            return ['$ref' => $subSchema['$ref']];
+        $subSchema = new Schema($version);
+        $subSchema->setDefinitions($schema->getDefinitions()); // Populate definitions of the main schema
+
+        if (null === $this->schemaFactory) {
+            throw new \LogicException('The schema factory must be injected by calling the "setSchemaFactory" method.');
         }
 
-        return ['type' => 'string'];
+        $subSchema = $this->schemaFactory->buildSchema($className, $format, Schema::TYPE_OUTPUT, null, null, $subSchema, $serializerContext);
+
+        return ['$ref' => $subSchema['$ref']];
     }
 }
diff --git a/TypeFactoryInterface.php b/TypeFactoryInterface.php
@@ -16,11 +16,16 @@
 use Symfony\Component\PropertyInfo\Type;
 
 /**
- * Gets the OpenAPI type corresponding to the given PHP type, and recursively adds needed new schema to the current schema if provided.
+ * Factory for creating the JSON Schema document which specifies the data type corresponding to a PHP type.
+ *
+ * @experimental
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
  */
 interface TypeFactoryInterface
 {
+    /**
+     * Gets the JSON Schema document which specifies the data type corresponding to the given PHP type, and recursively adds needed new schema to the current schema if provided.
+     */
     public function getType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array;
 }

Original file line number	Diff line number	Diff line change
`@@ -13,10 +13,8 @@`
`13`	`13`
`14`	`14`	`namespace ApiPlatform\Core\JsonSchema;`
`15`	`15`
`16`		`-use ApiPlatform\Core\Exception\ResourceClassNotFoundException;`
`17`		`-`
`18`	`16`	`/**`
`19`		`- * Builds a JSON Schema from an API Platform resource definition.`
	`17`	`+ * Factory for creating the JSON Schema document corresponding to a PHP class.`
`20`	`18`	`*`
`21`	`19`	`* @experimental`
`22`	`20`	`*`
`@@ -25,7 +23,7 @@`
`25`	`23`	`interface SchemaFactoryInterface`
`26`	`24`	`{`
`27`	`25`	`/**`
`28`		`- * @throws ResourceClassNotFoundException`
	`26`	`+ * Builds the JSON Schema document corresponding to the given PHP class.`
`29`	`27`	`*/`
`30`		`- public function buildSchema(string $resourceClass, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?Schema $schema = null, ?array $serializerContext = null, bool $forceCollection = false): Schema;`
	`28`	`+ public function buildSchema(string $className, string $format = 'json', string $type = Schema::TYPE_OUTPUT, ?string $operationType = null, ?string $operationName = null, ?Schema $schema = null, ?array $serializerContext = null, bool $forceCollection = false): Schema;`
`31`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,16 @@`
`16`	`16`	`use Symfony\Component\PropertyInfo\Type;`
`17`	`17`
`18`	`18`	`/**`
`19`		`- * Gets the OpenAPI type corresponding to the given PHP type, and recursively adds needed new schema to the current schema if provided.`
	`19`	`+ * Factory for creating the JSON Schema document which specifies the data type corresponding to a PHP type.`
	`20`	`+ *`
	`21`	`+ * @experimental`
`20`	`22`	`*`
`21`	`23`	`* @author Kévin Dunglas <[email protected]>`
`22`	`24`	`*/`
`23`	`25`	`interface TypeFactoryInterface`
`24`	`26`	`{`
	`27`	`+ /**`
	`28`	`+ * Gets the JSON Schema document which specifies the data type corresponding to the given PHP type, and recursively adds needed new schema to the current schema if provided.`
	`29`	`+ */`
`25`	`30`	`public function getType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array;`
`26`	`31`	`}`