#24768

pending completion

Build # #24768

Build Type

push

github

Committed by

web-flow

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/43d18a7783b8cdefb07a0202ac0c284a880387fc">43d18a778<a href="https://github.com/api-platform/core/commit/43d18a7783b8cdefb07a0202ac0c284a880387fc">">Merge </a><a class="double-link" href="https://github.com/api-platform/core/commit/<a class="double-link" href="https://github.com/api-platform/core/commit/82ba090add06bffd9e1919f2667a470ce54e3eb2">82ba090ad</a>">82ba090ad</a><a href="https://github.com/api-platform/core/commit/43d18a7783b8cdefb07a0202ac0c284a880387fc"> into f52a17ef8">f52a17ef8</a>

Run Details

2 of 2 new or added lines in 2 files covered. (100.0%)

9267 of 10169 relevant lines covered (91.13%)

16.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.75

/src/JsonSchema/TypeFactory.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * 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\Core\JsonSchema;

use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Util\ResourceClassInfoTrait;
use Ramsey\Uuid\UuidInterface;
use Symfony\Component\PropertyInfo\Type;

/**
 * {@inheritdoc}
 *
 * @experimental
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
final class TypeFactory implements TypeFactoryInterface
{
    use ResourceClassInfoTrait;

    /**
     * @var SchemaFactoryInterface|null
     */
    private $schemaFactory;

    public function __construct(ResourceClassResolverInterface $resourceClassResolver = null)
    {
        $this->resourceClassResolver = $resourceClassResolver;
    }

    public function setSchemaFactory(SchemaFactoryInterface $schemaFactory): void
    {
        $this->schemaFactory = $schemaFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function getType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array
    {
        if ($type->isCollection()) {
            $keyType = $type->getCollectionKeyType();
            $subType = $type->getCollectionValueType() ?? new Type($type->getBuiltinType(), false, $type->getClassName(), false);

            if (null !== $keyType && Type::BUILTIN_TYPE_STRING === $keyType->getBuiltinType()) {
                return $this->addNullabilityToTypeDefinition([
                    'type' => 'object',
                    'additionalProperties' => $this->getType($subType, $format, $readableLink, $serializerContext, $schema),
                ], $type, $schema);
            }

            return $this->addNullabilityToTypeDefinition([
                'type' => 'array',
                'items' => $this->getType($subType, $format, $readableLink, $serializerContext, $schema),
            ], $type, $schema);
        }

        return $this->addNullabilityToTypeDefinition($this->makeBasicType($type, $format, $readableLink, $serializerContext, $schema), $type, $schema);
    }

    private function makeBasicType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array
    {
        switch ($type->getBuiltinType()) {
            case Type::BUILTIN_TYPE_INT:
                return ['type' => 'integer'];
            case Type::BUILTIN_TYPE_FLOAT:
                return ['type' => 'number'];
            case Type::BUILTIN_TYPE_BOOL:
                return ['type' => 'boolean'];
            case Type::BUILTIN_TYPE_OBJECT:
                return $this->getClassType($type->getClassName(), $format, $readableLink, $serializerContext, $schema);
            default:
                return ['type' => 'string'];
        }
    }

    /**
     * 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, ?bool $readableLink, ?array $serializerContext, ?Schema $schema): array
    {
        if (null === $className) {
            return ['type' => 'string'];
        }

        if (is_a($className, \DateTimeInterface::class, true)) {
            return [
                'type' => 'string',
                'format' => 'date-time',
            ];
        }
        if (is_a($className, \DateInterval::class, true)) {
            return [
                'type' => 'string',
                'format' => 'duration',
            ];
        }
        if (is_a($className, UuidInterface::class, true)) {
            return [
                'type' => 'string',
                'format' => 'uuid',
            ];
        }

        // Skip if $schema is null (filters only support basic types)
        if (null === $schema) {
            return ['type' => 'string'];
        }

        if ($this->isResourceClass($className) && true !== $readableLink) {
            return [
                'type' => 'string',
                'format' => 'iri-reference',
            ];
        }

        $version = $schema->getVersion();

        $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.');
        }

        $subSchema = $this->schemaFactory->buildSchema($className, $format, Schema::TYPE_OUTPUT, null, null, $subSchema, $serializerContext);

        return ['$ref' => $subSchema['$ref']];
    }

    /**
     * @param array<string, mixed> $jsonSchema
     *
     * @return array<string, mixed>
     */
    private function addNullabilityToTypeDefinition(array $jsonSchema, Type $type, ?Schema $schema): array
    {
        if (($schema && Schema::VERSION_SWAGGER === $schema->getVersion()) || !$type->isNullable()) {
            return $jsonSchema;
        }

        if (\array_key_exists('$ref', $jsonSchema)) {
            return [
                'nullable' => true,
                'anyOf' => [$jsonSchema],
            ];
        }

        return array_merge($jsonSchema, ['nullable' => true]);
    }
}

1	<?php
2
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	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Core\JsonSchema;
15
16	use ApiPlatform\Core\Api\ResourceClassResolverInterface;
17	use ApiPlatform\Core\Util\ResourceClassInfoTrait;
18	use Ramsey\Uuid\UuidInterface;
19	use Symfony\Component\PropertyInfo\Type;
20
21	/**
22	* {@inheritdoc}
23	*
24	* @experimental
25	*
26	* @author Kévin Dunglas <dunglas@gmail.com>
27	*/
28	final class TypeFactory implements TypeFactoryInterface
29	{
30	use ResourceClassInfoTrait;
31
32	/**
33	* @var SchemaFactoryInterface\|null
34	*/
35	private $schemaFactory;
36
37	public function __construct(ResourceClassResolverInterface $resourceClassResolver = null)
38	{
39	$this->resourceClassResolver = $resourceClassResolver;	135✔
40	}	135✔
41
42	public function setSchemaFactory(SchemaFactoryInterface $schemaFactory): void
43	{
44	$this->schemaFactory = $schemaFactory;	89✔
45	}	89✔
46
47	/**
48	* {@inheritdoc}
49	*/
50	public function getType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array
51	{
52	if ($type->isCollection()) {	105✔
53	$keyType = $type->getCollectionKeyType();	35✔
54	$subType = $type->getCollectionValueType() ?? new Type($type->getBuiltinType(), false, $type->getClassName(), false);	35✔
55
56	if (null !== $keyType && Type::BUILTIN_TYPE_STRING === $keyType->getBuiltinType()) {	35✔
57	return $this->addNullabilityToTypeDefinition([	10✔
58	'type' => 'object',	10✔
59	'additionalProperties' => $this->getType($subType, $format, $readableLink, $serializerContext, $schema),	10✔
60	], $type, $schema);
61	}
62
63	return $this->addNullabilityToTypeDefinition([	25✔
64	'type' => 'array',	25✔
65	'items' => $this->getType($subType, $format, $readableLink, $serializerContext, $schema),	25✔
66	], $type, $schema);
67	}
68
69	return $this->addNullabilityToTypeDefinition($this->makeBasicType($type, $format, $readableLink, $serializerContext, $schema), $type, $schema);	105✔
70	}
71
72	private function makeBasicType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array
73	{
74	switch ($type->getBuiltinType()) {	105✔
75	case Type::BUILTIN_TYPE_INT:
76	return ['type' => 'integer'];	42✔
77	case Type::BUILTIN_TYPE_FLOAT:
78	return ['type' => 'number'];	15✔
79	case Type::BUILTIN_TYPE_BOOL:
80	return ['type' => 'boolean'];	15✔
81	case Type::BUILTIN_TYPE_OBJECT:
82	return $this->getClassType($type->getClassName(), $format, $readableLink, $serializerContext, $schema);	37✔
83	default:
84	return ['type' => 'string'];	65✔
85	}
86	}
87
88	/**
89	* 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.
90	*/
91	private function getClassType(?string $className, string $format, ?bool $readableLink, ?array $serializerContext, ?Schema $schema): array
92	{
93	if (null === $className) {	37✔
94	return ['type' => 'string'];	4✔
95	}
96
97	if (is_a($className, \DateTimeInterface::class, true)) {	33✔
98	return [
99	'type' => 'string',	19✔
100	'format' => 'date-time',
101	];
102	}
103	if (is_a($className, \DateInterval::class, true)) {	25✔
104	return [
105	'type' => 'string',	2✔
106	'format' => 'duration',
107	];
108	}
109	if (is_a($className, UuidInterface::class, true)) {	23✔
110	return [
111	'type' => 'string',	×
112	'format' => 'uuid',
113	];
114	}
115
116	// Skip if $schema is null (filters only support basic types)
117	if (null === $schema) {	23✔
118	return ['type' => 'string'];	×
119	}
120
121	if ($this->isResourceClass($className) && true !== $readableLink) {	23✔
122	return [
123	'type' => 'string',	15✔
124	'format' => 'iri-reference',
125	];
126	}
127
128	$version = $schema->getVersion();	15✔
129
130	$subSchema = new Schema($version);	15✔
131	$subSchema->setDefinitions($schema->getDefinitions()); // Populate definitions of the main schema	15✔
132
133	if (null === $this->schemaFactory) {	15✔
134	throw new \LogicException('The schema factory must be injected by calling the "setSchemaFactory" method.');	×
135	}
136
137	$subSchema = $this->schemaFactory->buildSchema($className, $format, Schema::TYPE_OUTPUT, null, null, $subSchema, $serializerContext);	15✔
138
139	return ['$ref' => $subSchema['$ref']];	15✔
140	}
141
142	/**
143	* @param array<string, mixed> $jsonSchema
144	*
145	* @return array<string, mixed>
146	*/
147	private function addNullabilityToTypeDefinition(array $jsonSchema, Type $type, ?Schema $schema): array
148	{
149	if (($schema && Schema::VERSION_SWAGGER === $schema->getVersion()) \|\| !$type->isNullable()) {	105✔
150	return $jsonSchema;	52✔
151	}
152
153	if (\array_key_exists('$ref', $jsonSchema)) {	60✔
154	return [	33✔
155	'nullable' => true,
156	'anyOf' => [$jsonSchema],
157	];	41✔
158	}
159		4✔
160	return array_merge($jsonSchema, ['nullable' => true]);	4✔
161	}
162	}

api-platform / core / #24768

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous