hydrator/src/Normalizer/ArrayShapeNormalizer.php at 4b8f1007d56a47764057302c538241bc0b64b79f · patchlevel/hydrator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
<?php

declare(strict_types=1);

namespace Patchlevel\Hydrator\Normalizer;

use Attribute;
use Patchlevel\Hydrator\Hydrator;
use Symfony\Component\TypeInfo\Type;
use Symfony\Component\TypeInfo\Type\ArrayShapeType;
use Symfony\Component\TypeInfo\Type\NullableType;

use function is_array;

#[Attribute(Attribute::TARGET_PROPERTY)]
final readonly class ArrayShapeNormalizer implements NormalizerWithContext, TypeAwareNormalizer, HydratorAwareNormalizer
{
    /** @param array<array-key, Normalizer> $normalizerMap */
    public function __construct(
        private array $normalizerMap,
    ) {
    }

    /**
     * @param array<string, mixed> $context
     *
     * @return array<array-key, mixed>|null
     */
    public function normalize(mixed $value, array $context = []): array|null
    {
        if ($value === null) {
            return null;
        }

        if (!is_array($value)) {
            throw InvalidArgument::withWrongType('array|null', $value);
        }

        $result = [];

        foreach ($this->normalizerMap as $field => $normalizer) {
            if (!isset($value[$field])) {
                continue;
            }

            if ($normalizer instanceof NormalizerWithContext) {
                $result[$field] = $normalizer->normalize($value[$field], $context);
            } else {
                $result[$field] = $normalizer->normalize($value[$field]);
            }
        }

        return $result;
    }

    /**
     * @param array<string, mixed> $context
     *
     * @return array<array-key, mixed>|null
     */
    public function denormalize(mixed $value, array $context = []): array|null
    {
        if ($value === null) {
            return null;
        }

        if (!is_array($value)) {
            throw InvalidArgument::withWrongType('array|null', $value);
        }

        $result = [];

        foreach ($this->normalizerMap as $field => $normalizer) {
            if (!isset($value[$field])) {
                continue;
            }

            if ($normalizer instanceof NormalizerWithContext) {
                $result[$field] = $normalizer->denormalize($value[$field], $context);
            } else {
                $result[$field] = $normalizer->denormalize($value[$field]);
            }
        }

        return $result;
    }

    public function setHydrator(Hydrator $hydrator): void
    {
        foreach ($this->normalizerMap as $normalizer) {
            if (!$normalizer instanceof HydratorAwareNormalizer) {
                continue;
            }

            $normalizer->setHydrator($hydrator);
        }
    }

    public function handleType(Type|null $type): void
    {
        if ($type === null) {
            return;
        }

        if ($type instanceof NullableType) {
            $type = $type->getWrappedType();
        }

        if (!$type instanceof ArrayShapeType) {
            return;
        }

        $shape = $type->getShape();

        foreach ($this->normalizerMap as $field => $normalizer) {
            if (!$normalizer instanceof TypeAwareNormalizer) {
                continue;
            }

            $normalizer->handleType($shape[$field]['type']);
        }
    }

    /** @return array<array-key, Normalizer> */
    public function innerNormalizers(): array
    {
        return $this->normalizerMap;
    }
}