#27517

pending completion

Build # #27517

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/9f99c4522d48c648463626e48748b45c316c0dd3">9f99c4522<a href="https://github.com/api-platform/core/commit/9f99c4522d48c648463626e48748b45c316c0dd3">">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/69e2826deadab0786300e66e9f5338f3e527d41a">69e2826de</a>">69e2826de</a><a href="https://github.com/api-platform/core/commit/9f99c4522d48c648463626e48748b45c316c0dd3"> into 9f7f1e117">9f7f1e117</a>

Run Details

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

7642 of 12655 relevant lines covered (60.39%)

85.81 hits per line

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

78.69

/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;
use Symfony\Component\Uid\Ulid;
use Symfony\Component\Uid\Uuid;

/**
 * {@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 = method_exists(Type::class, 'getCollectionKeyTypes') ? ($type->getCollectionKeyTypes()[0] ?? null) : $type->getCollectionKeyType();
            $subType = (method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $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) || is_a($className, Uuid::class, true)) {
            return [
                'type' => 'string',
                'format' => 'uuid',
            ];
        }
        if (is_a($className, Ulid::class, true)) {
            return [
                'type' => 'string',
                'format' => 'ulid',
            ];
        }

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

        if (true !== $readableLink && $this->isResourceClass($className)) {
            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, false);

        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()) {
            return $jsonSchema;
        }

        if (!$type->isNullable()) {
            return $jsonSchema;
        }

        if (\array_key_exists('$ref', $jsonSchema)) {
            if ($schema && Schema::VERSION_JSON_SCHEMA === $schema->getVersion()) {
                return [
                    'anyOf' => [
                        $jsonSchema,
                        ['type' => 'null'],
                    ],
                ];
            }

            return [
                'nullable' => true,
                'anyOf' => [$jsonSchema],
            ];
        }

        if ($schema && Schema::VERSION_JSON_SCHEMA === $schema->getVersion()) {
            return array_merge(
                $jsonSchema,
                [
                    'type' => \is_array($jsonSchema['type'])
                        ? array_merge($jsonSchema['type'], ['null'])
                        : [$jsonSchema['type'], 'null'],
                ]
            );
        }

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

api-platform / core / #27517

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