25700642152

Committed 11 May 2026 10:16PM UTC coverage: 98.554% (+0.003%) from 98.551%

Build Type

github

Committed by Enno Woortmann

Commit Message

Add content validator registry for contentMediaType/contentEncoding (Draft 7 Phase 5)

Introduces an opt-in registry on GeneratorConfiguration that lets users register
ContentValidatorInterface implementations keyed by media type and/or encoding.
At generation time the most specific matching validator is embedded into the
generated model; at runtime it is called against the raw string before the
MediaString wrapper is applied. Validator failures throw a ContentException whose
getPrevious() carries the original error for programmatic inspection.

addContentValidator() accepts null (wildcard), string, or string[] for each
dimension; arrays expand via Cartesian product so a single call can cover
multiple media types or encodings at once.

Pull Request Pull Request #126: Json schema draft7

Coverage Stats

244 of 252 new or added lines in 13 files covered. (96.83%)

4 existing lines in 4 files now uncovered.

4770 of 4840 relevant lines covered (98.55%)

643.67 hits per line

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

99.38

/src/SchemaProcessor/PostProcessor/Internal/SerializationPostProcessor.php

<?php

declare(strict_types=1);

namespace PHPModelGenerator\SchemaProcessor\PostProcessor\Internal;

use JsonSerializable;
use PHPModelGenerator\Filter\TransformingFilterInterface;
use PHPModelGenerator\Interfaces\SerializationInterface;
use PHPModelGenerator\Model\GeneratorConfiguration;
use PHPModelGenerator\Model\Property\Property;
use PHPModelGenerator\Model\Property\PropertyInterface;
use PHPModelGenerator\Model\Property\PropertyType;
use PHPModelGenerator\Model\Schema;
use PHPModelGenerator\Model\SchemaDefinition\JsonSchema;
use PHPModelGenerator\Model\Validator\AdditionalPropertiesValidator;
use PHPModelGenerator\Model\Validator\FilterValidator;
use PHPModelGenerator\Model\Validator\PatternPropertiesValidator;
use PHPModelGenerator\SchemaProcessor\Hook\SchemaHookResolver;
use PHPModelGenerator\SchemaProcessor\Hook\SerializationHookInterface;
use PHPModelGenerator\SchemaProcessor\PostProcessor\PostProcessor;
use PHPModelGenerator\SchemaProcessor\PostProcessor\RenderedMethod;
use PHPModelGenerator\Traits\SerializableTrait;

/**
 * Class SerializationPostProcessor
 *
 * @package PHPModelGenerator\SchemaProcessor\PostProcessor
 */
class SerializationPostProcessor extends PostProcessor
{
    /**
     * Add serialization support to the provided schema
     */
    public function process(Schema $schema, GeneratorConfiguration $generatorConfiguration): void
    {
        $schema
            ->addTrait(SerializableTrait::class)
            ->addInterface(JsonSerializable::class)
            ->addInterface(SerializationInterface::class);

        $this->addSerializeFunctionsForTransformingFilters($schema, $generatorConfiguration);
        $this->addSerializationHookMethod($schema, $generatorConfiguration);
        $this->addSkipNotProvidedPropertiesMap($schema, $generatorConfiguration);
        $this->addWriteOnlyExclusion($schema, $generatorConfiguration);

        $this->addPatternPropertiesSerialization($schema, $generatorConfiguration);

        $json = $schema->getJsonSchema()->getJson();
        if (isset($json['additionalProperties']) && $json['additionalProperties'] !== false) {
            $this->addAdditionalPropertiesSerialization($schema, $generatorConfiguration);
        }
    }

    /**
     * Each transforming filter must provide a method to serialize the value. Add a method to the schema to call the
     * serialization for each property with a transforming filter
     */
    private function addSerializeFunctionsForTransformingFilters(
        Schema $schema,
        GeneratorConfiguration $generatorConfiguration,
    ): void {
        foreach ($schema->getProperties() as $property) {
            foreach ($property->getValidators() as $validator) {
                $validator = $validator->getValidator();

                if (
                    $validator instanceof FilterValidator &&
                    $validator->getFilter() instanceof TransformingFilterInterface
                ) {
                    [$serializerClass, $serializerMethod] = $validator->getFilter()->getSerializer();

                    $schema->addMethod(
                        "serialize{$property->getAttribute()}",
                        new RenderedMethod(
                            $schema,
                            $generatorConfiguration,
                            join(
                                DIRECTORY_SEPARATOR,
                                ['Serialization', 'TransformingFilterSerializer.phptpl'],
                            ),
                            [
                                'property' => $property,
                                'serializerClass' => $serializerClass,
                                'serializerMethod' => $serializerMethod,
                                'serializerOptions' => var_export($validator->getFilterOptions(), true),
                            ],
                        )
                    );
                }
            }
        }

        foreach ($schema->getBaseValidators() as $validator) {
            if ($validator instanceof PatternPropertiesValidator) {
                foreach ($validator->getValidationProperty()->getValidators() as $patternPropertyValidator) {
                    $filterValidator = $patternPropertyValidator->getValidator();

                    if (
                        $filterValidator instanceof FilterValidator &&
                        $filterValidator->getFilter() instanceof TransformingFilterInterface
                    ) {
                        [$serializerClass, $serializerMethod] = $filterValidator->getFilter()->getSerializer();

                        $schema->addMethod(
                            "serialize{$validator->getKey()}",
                            new RenderedMethod(
                                $schema,
                                $generatorConfiguration,
                                join(
                                    DIRECTORY_SEPARATOR,
                                    ['Serialization', 'PatternPropertyTransformingFilterSerializer.phptpl'],
                                ),
                                [
                                    'key' => $validator->getKey(),
                                    'serializerClass' => $serializerClass,
                                    'serializerMethod' => $serializerMethod,
                                    'serializerOptions' => var_export($filterValidator->getFilterOptions(), true),
                                ],
                            )
                        );
                    }
                }
            }
        }
    }

    private function addSerializationHookMethod(Schema $schema, GeneratorConfiguration $generatorConfiguration): void
    {
        $schema->addMethod(
            'resolveSerializationHook',
            new RenderedMethod(
                $schema,
                $generatorConfiguration,
                join(DIRECTORY_SEPARATOR, ['Serialization', 'SerializationHook.phptpl']),
                [
                    'schemaHookResolver' => new SchemaHookResolver($schema),
                ],
            )
        );
    }

    /**
     * Adds code to merge serialized pattern properties into the serialization result
     */
    private function addPatternPropertiesSerialization(
        Schema $schema,
        GeneratorConfiguration $generatorConfiguration,
    ): void {
        if (!isset($schema->getJsonSchema()->getJson()['patternProperties'])) {
            return;
        }

        $schema->addMethod(
            'serializePatternProperties',
            new RenderedMethod($schema, $generatorConfiguration, 'Serialization/PatternPropertiesSerializer.phptpl'),
        );

        $schema->addSchemaHook(
            new class () implements SerializationHookInterface {
                public function getCode(): string
                {
                    return '$data += $this->serializePatternProperties($depth, $except);';
                }
            },
        );
    }

    /**
     * Adds a custom serialization function to the schema to merge all additional properties into the serialization
     * result on serializations
     */
    public function addAdditionalPropertiesSerialization(
        Schema $schema,
        GeneratorConfiguration $generatorConfiguration,
    ): void {
        $validationProperty = null;
        foreach ($schema->getBaseValidators() as $validator) {
            if (is_a($validator, AdditionalPropertiesValidator::class)) {
                $validationProperty = $validator->getValidationProperty();
            }
        }

        $transformingFilterValidator = null;

        if ($validationProperty) {
            foreach ($validationProperty->getValidators() as $validator) {
                $validator = $validator->getValidator();

                if (
                    $validator instanceof FilterValidator &&
                    $validator->getFilter() instanceof TransformingFilterInterface
                ) {
                    $transformingFilterValidator = $validator;
                    [$serializerClass, $serializerMethod] = $validator->getFilter()->getSerializer();
                }
            }
        }

        $schema->addMethod(
            'serializeAdditionalProperties',
            new RenderedMethod(
                $schema,
                $generatorConfiguration,
                'Serialization/AdditionalPropertiesSerializer.phptpl',
                [
                    'serializerClass' => $serializerClass ?? null,
                    'serializerMethod' => $serializerMethod ?? null,
                    'serializerOptions' => $transformingFilterValidator
                        ? var_export($transformingFilterValidator->getFilterOptions(), true)
                        : [],
                ],
            )
        );

        $schema->addSchemaHook(
            new class () implements SerializationHookInterface {
                public function getCode(): string
                {
                    return '$data = array_merge($this->serializeAdditionalProperties($depth, $except), $data);';
                }
            },
        );
    }

    private function addWriteOnlyExclusion(
        Schema $schema,
        GeneratorConfiguration $generatorConfiguration,
    ): void {
        $writeOnlyAttributes = array_map(
            static fn(PropertyInterface $property): string => $property->getAttribute(true),
            array_filter(
                $schema->getProperties(),
                static fn(PropertyInterface $property): bool => $property->isWriteOnly(),
            ),
        );

        if (!$writeOnlyAttributes) {
            return;
        }

        $keysExport = var_export(array_values($writeOnlyAttributes), true);

        $schema->addSchemaHook(
            new class ($keysExport) implements SerializationHookInterface
            {
                public function __construct(private readonly string $keysExport)
                {}

                public function getCode(): string
                {
                    return sprintf(
                        'foreach (%s as $_writeOnlyKey) { unset($data[$_writeOnlyKey]); }',
                        $this->keysExport,
                    );
                }
            },
        );
    }

    private function addSkipNotProvidedPropertiesMap(
        Schema $schema,
        GeneratorConfiguration $generatorConfiguration,
    ): void {
        if ($generatorConfiguration->isImplicitNullAllowed()) {
            return;
        }

        $skipNotProvidedValues = array_map(
            static fn(PropertyInterface $property): string => $property->getName(),
            array_filter(
                $schema->getProperties(),
                static fn(PropertyInterface $property): bool =>
                    !$property->isRequired() && !$property->getDefaultValue(),
            )
        );

        $schema->addProperty(
            (new Property(
                'skipNotProvidedPropertiesMap',
                new PropertyType('array'),
                new JsonSchema(__FILE__, []),
                'Values which might be skipped for serialization if not provided',
            ))
                ->setDefaultValue($skipNotProvidedValues)
                ->setInternal(true),
        );
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace PHPModelGenerator\SchemaProcessor\PostProcessor\Internal;
6
7	use JsonSerializable;
8	use PHPModelGenerator\Filter\TransformingFilterInterface;
9	use PHPModelGenerator\Interfaces\SerializationInterface;
10	use PHPModelGenerator\Model\GeneratorConfiguration;
11	use PHPModelGenerator\Model\Property\Property;
12	use PHPModelGenerator\Model\Property\PropertyInterface;
13	use PHPModelGenerator\Model\Property\PropertyType;
14	use PHPModelGenerator\Model\Schema;
15	use PHPModelGenerator\Model\SchemaDefinition\JsonSchema;
16	use PHPModelGenerator\Model\Validator\AdditionalPropertiesValidator;
17	use PHPModelGenerator\Model\Validator\FilterValidator;
18	use PHPModelGenerator\Model\Validator\PatternPropertiesValidator;
19	use PHPModelGenerator\SchemaProcessor\Hook\SchemaHookResolver;
20	use PHPModelGenerator\SchemaProcessor\Hook\SerializationHookInterface;
21	use PHPModelGenerator\SchemaProcessor\PostProcessor\PostProcessor;
22	use PHPModelGenerator\SchemaProcessor\PostProcessor\RenderedMethod;
23	use PHPModelGenerator\Traits\SerializableTrait;
24
25	/**
26	* Class SerializationPostProcessor
27	*
28	* @package PHPModelGenerator\SchemaProcessor\PostProcessor
29	*/
30	class SerializationPostProcessor extends PostProcessor
31	{
32	/**
33	* Add serialization support to the provided schema
34	*/
35	public function process(Schema $schema, GeneratorConfiguration $generatorConfiguration): void	60 ✔
36	{
37	$schema	60 ✔
38	->addTrait(SerializableTrait::class)	60 ✔
39	->addInterface(JsonSerializable::class)	60 ✔
40	->addInterface(SerializationInterface::class);	60 ✔
41
42	$this->addSerializeFunctionsForTransformingFilters($schema, $generatorConfiguration);	60 ✔
43	$this->addSerializationHookMethod($schema, $generatorConfiguration);	60 ✔
44	$this->addSkipNotProvidedPropertiesMap($schema, $generatorConfiguration);	60 ✔
45	$this->addWriteOnlyExclusion($schema, $generatorConfiguration);	60 ✔
46
47	$this->addPatternPropertiesSerialization($schema, $generatorConfiguration);	60 ✔
48
49	$json = $schema->getJsonSchema()->getJson();	60 ✔
50	if (isset($json['additionalProperties']) && $json['additionalProperties'] !== false) {	60 ✔
51	$this->addAdditionalPropertiesSerialization($schema, $generatorConfiguration);	11 ✔
52	}
53	}
54
55	/**
56	* Each transforming filter must provide a method to serialize the value. Add a method to the schema to call the
57	* serialization for each property with a transforming filter
58	*/
59	private function addSerializeFunctionsForTransformingFilters(	60 ✔
60	Schema $schema,
61	GeneratorConfiguration $generatorConfiguration,
62	): void {
63	foreach ($schema->getProperties() as $property) {	60 ✔
64	foreach ($property->getValidators() as $validator) {	59 ✔
65	$validator = $validator->getValidator();	56 ✔
66
67	if (
68	$validator instanceof FilterValidator &&	56 ✔
69	$validator->getFilter() instanceof TransformingFilterInterface	56 ✔
70	) {
71	[$serializerClass, $serializerMethod] = $validator->getFilter()->getSerializer();	24 ✔
72
73	$schema->addMethod(	24 ✔
74	"serialize{$property->getAttribute()}",	24 ✔
75	new RenderedMethod(	24 ✔
76	$schema,	24 ✔
77	$generatorConfiguration,	24 ✔
78	join(	24 ✔
79	DIRECTORY_SEPARATOR,	24 ✔
80	['Serialization', 'TransformingFilterSerializer.phptpl'],	24 ✔
81	),	24 ✔
82	[	24 ✔
83	'property' => $property,	24 ✔
84	'serializerClass' => $serializerClass,	24 ✔
85	'serializerMethod' => $serializerMethod,	24 ✔
86	'serializerOptions' => var_export($validator->getFilterOptions(), true),	24 ✔
87	],	24 ✔
88	)	24 ✔
89	);	24 ✔
90	}
91	}
92	}
93
94	foreach ($schema->getBaseValidators() as $validator) {	60 ✔
95	if ($validator instanceof PatternPropertiesValidator) {	23 ✔
96	foreach ($validator->getValidationProperty()->getValidators() as $patternPropertyValidator) {	6 ✔
97	$filterValidator = $patternPropertyValidator->getValidator();	6 ✔
98
99	if (
100	$filterValidator instanceof FilterValidator &&	6 ✔
101	$filterValidator->getFilter() instanceof TransformingFilterInterface	6 ✔
102	) {
103	[$serializerClass, $serializerMethod] = $filterValidator->getFilter()->getSerializer();	2 ✔
104
105	$schema->addMethod(	2 ✔
106	"serialize{$validator->getKey()}",	2 ✔
107	new RenderedMethod(	2 ✔
108	$schema,	2 ✔
109	$generatorConfiguration,	2 ✔
110	join(	2 ✔
111	DIRECTORY_SEPARATOR,	2 ✔
112	['Serialization', 'PatternPropertyTransformingFilterSerializer.phptpl'],	2 ✔
113	),	2 ✔
114	[	2 ✔
115	'key' => $validator->getKey(),	2 ✔
116	'serializerClass' => $serializerClass,	2 ✔
117	'serializerMethod' => $serializerMethod,	2 ✔
118	'serializerOptions' => var_export($filterValidator->getFilterOptions(), true),	2 ✔
119	],	2 ✔
120	)	2 ✔
121	);	2 ✔
122	}
123	}
124	}
125	}
126	}
127
128	private function addSerializationHookMethod(Schema $schema, GeneratorConfiguration $generatorConfiguration): void	60 ✔
129	{
130	$schema->addMethod(	60 ✔
131	'resolveSerializationHook',	60 ✔
132	new RenderedMethod(	60 ✔
133	$schema,	60 ✔
134	$generatorConfiguration,	60 ✔
135	join(DIRECTORY_SEPARATOR, ['Serialization', 'SerializationHook.phptpl']),	60 ✔
136	[	60 ✔
137	'schemaHookResolver' => new SchemaHookResolver($schema),	60 ✔
138	],	60 ✔
139	)	60 ✔
140	);	60 ✔
141	}
142
143	/**
144	* Adds code to merge serialized pattern properties into the serialization result
145	*/
146	private function addPatternPropertiesSerialization(	60 ✔
147	Schema $schema,
148	GeneratorConfiguration $generatorConfiguration,
149	): void {
150	if (!isset($schema->getJsonSchema()->getJson()['patternProperties'])) {	60 ✔
151	return;	54 ✔
152	}
153
154	$schema->addMethod(	6 ✔
155	'serializePatternProperties',	6 ✔
156	new RenderedMethod($schema, $generatorConfiguration, 'Serialization/PatternPropertiesSerializer.phptpl'),	6 ✔
157	);	6 ✔
158
159	$schema->addSchemaHook(	6 ✔
160	new class () implements SerializationHookInterface {	6 ✔
161	public function getCode(): string
162	{
163	return '$data += $this->serializePatternProperties($depth, $except);';	6 ✔
164	}
165	},	6 ✔
166	);	6 ✔
167	}
168
169	/**
170	* Adds a custom serialization function to the schema to merge all additional properties into the serialization
171	* result on serializations
172	*/
173	public function addAdditionalPropertiesSerialization(	15 ✔
174	Schema $schema,
175	GeneratorConfiguration $generatorConfiguration,
176	): void {
177	$validationProperty = null;	15 ✔
178	foreach ($schema->getBaseValidators() as $validator) {	15 ✔
179	if (is_a($validator, AdditionalPropertiesValidator::class)) {	15 ✔
180	$validationProperty = $validator->getValidationProperty();	11 ✔
181	}
182	}
183
184	$transformingFilterValidator = null;	15 ✔
185
186	if ($validationProperty) {	15 ✔
187	foreach ($validationProperty->getValidators() as $validator) {	11 ✔
188	$validator = $validator->getValidator();	11 ✔
189
190	if (
191	$validator instanceof FilterValidator &&	11 ✔
192	$validator->getFilter() instanceof TransformingFilterInterface	11 ✔
193	) {
194	$transformingFilterValidator = $validator;	3 ✔
195	[$serializerClass, $serializerMethod] = $validator->getFilter()->getSerializer();	3 ✔
196	}
197	}
198	}
199
200	$schema->addMethod(	15 ✔
201	'serializeAdditionalProperties',	15 ✔
202	new RenderedMethod(	15 ✔
203	$schema,	15 ✔
204	$generatorConfiguration,	15 ✔
205	'Serialization/AdditionalPropertiesSerializer.phptpl',	15 ✔
206	[	15 ✔
207	'serializerClass' => $serializerClass ?? null,	15 ✔
208	'serializerMethod' => $serializerMethod ?? null,	15 ✔
209	'serializerOptions' => $transformingFilterValidator	15 ✔
210	? var_export($transformingFilterValidator->getFilterOptions(), true)	3 ✔
UNCOV 211	: [],	×
212	],	15 ✔
213	)	15 ✔
214	);	15 ✔
215
216	$schema->addSchemaHook(	15 ✔
217	new class () implements SerializationHookInterface {	15 ✔
218	public function getCode(): string
219	{
220	return '$data = array_merge($this->serializeAdditionalProperties($depth, $except), $data);';	15 ✔
221	}
222	},	15 ✔
223	);	15 ✔
224	}
225
226	private function addWriteOnlyExclusion(	60 ✔
227	Schema $schema,
228	GeneratorConfiguration $generatorConfiguration,
229	): void {
230	$writeOnlyAttributes = array_map(	60 ✔
231	static fn(PropertyInterface $property): string => $property->getAttribute(true),	60 ✔
232	array_filter(	60 ✔
233	$schema->getProperties(),	60 ✔
234	static fn(PropertyInterface $property): bool => $property->isWriteOnly(),	60 ✔
235	),	60 ✔
236	);	60 ✔
237
238	if (!$writeOnlyAttributes) {	60 ✔
239	return;	58 ✔
240	}
241
242	$keysExport = var_export(array_values($writeOnlyAttributes), true);	2 ✔
243
244	$schema->addSchemaHook(	2 ✔
245	new class ($keysExport) implements SerializationHookInterface	2 ✔
246	{	2 ✔
247	public function __construct(private readonly string $keysExport)
248	{}	2 ✔
249
250	public function getCode(): string
251	{
252	return sprintf(	2 ✔
253	'foreach (%s as $_writeOnlyKey) { unset($data[$_writeOnlyKey]); }',	2 ✔
254	$this->keysExport,	2 ✔
255	);	2 ✔
256	}
257	},	2 ✔
258	);	2 ✔
259	}
260
261	private function addSkipNotProvidedPropertiesMap(	60 ✔
262	Schema $schema,
263	GeneratorConfiguration $generatorConfiguration,
264	): void {
265	if ($generatorConfiguration->isImplicitNullAllowed()) {	60 ✔
266	return;	45 ✔
267	}
268
269	$skipNotProvidedValues = array_map(	15 ✔
270	static fn(PropertyInterface $property): string => $property->getName(),	15 ✔
271	array_filter(	15 ✔
272	$schema->getProperties(),	15 ✔
273	static fn(PropertyInterface $property): bool =>	15 ✔
274	!$property->isRequired() && !$property->getDefaultValue(),	15 ✔
275	)	15 ✔
276	);	15 ✔
277
278	$schema->addProperty(	15 ✔
279	(new Property(	15 ✔
280	'skipNotProvidedPropertiesMap',	15 ✔
281	new PropertyType('array'),	15 ✔
282	new JsonSchema(__FILE__, []),	15 ✔
283	'Values which might be skipped for serialization if not provided',	15 ✔
284	))	15 ✔
285	->setDefaultValue($skipNotProvidedValues)	15 ✔
286	->setInternal(true),	15 ✔
287	);	15 ✔
288	}
289	}

wol-soft / php-json-schema-model-generator / 25700642152

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