add Normalizer

Author: astral-data

src/Casts/Normalizer/ArrayNormalizerCast.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Astral\Serialize\Casts\Normalizer;
+
+use Astral\Serialize\Contracts\Normalizer\NormalizerCastInterface;
+
+class ArrayNormalizerCast implements NormalizerCastInterface
+{
+    public function match(mixed $values): bool
+    {
+       return is_object($values) && method_exists($values, 'toArray');
+    }
+
+    public function resolve(mixed $values): mixed
+    {
+        if($this->match($values)){
+            return $values->toArray();
+        }
+
+        return $values;
+    }
+}

src/Casts/Normalizer/JsonNormalizerCast.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Astral\Serialize\Casts\Normalizer;
+
+use Astral\Serialize\Contracts\Normalizer\NormalizerCastInterface;
+use JsonException;
+
+class JsonNormalizerCast implements NormalizerCastInterface
+{
+    public function match(mixed $values): bool
+    {
+        return is_string($values);
+    }
+
+    public function resolve(mixed $values): array
+    {
+        if($this->match($values)){
+            try {
+                $decoded = json_decode($values, true, 512, JSON_THROW_ON_ERROR);
+                return is_array($decoded) ? $decoded : $values;
+            } catch (JsonException $e) {
+
+            }
+        }
+
+        return $values;
+    }
+}

src/Contracts/Normalizer/NormalizerCastInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Astral\Serialize\Contracts\Normalizer;
+
+interface NormalizerCastInterface
+{
+    public function match(mixed $values): bool;
+
+    public function resolve(mixed $values): mixed;
+}

src/Resolvers/Casts/NormalizerCastResolver.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Astral\Serialize\Resolvers\Casts;
+
+use Astral\Serialize\Support\Collections\DataCollection;
+use Astral\Serialize\Support\Config\ConfigManager;
+use Astral\Serialize\Support\Context\InputValueContext;
+
+class NormalizerCastResolver
+{
+    public function __construct(
+        private readonly ConfigManager $configManager
+    ) {
+
+    }
+
+    public function resolve(mixed $values): mixed
+    {
+        foreach ($this->configManager->getNormalizerCasts() as $cast) {
+            $values =  $cast->resolve($values);
+        }
+
+        return $values;
+    }
+}

src/SerializeContainer.php

@@ -8,6 +8,7 @@
 use Astral\Serialize\Faker\Rule\FakerDefaultRules;
 use Astral\Serialize\Resolvers\Casts\DataCollectionCastResolver;
 use Astral\Serialize\Resolvers\Casts\InputValueCastResolver;
+use Astral\Serialize\Resolvers\Casts\NormalizerCastResolver;
 use Astral\Serialize\Resolvers\Casts\OutputCastResolver;
 use Astral\Serialize\Resolvers\GroupResolver;
 use Astral\Serialize\Resolvers\InputResolver;
@@ -41,6 +42,7 @@ class SerializeContainer
     protected ?GroupResolver $groupResolver                                                 = null;
     protected ?ReflectionClassInstanceManager $reflectionClassInstanceManager               = null;
     protected ?SerializeInstanceManager $serializeInstanceManager                           = null;
+    protected ?NormalizerCastResolver $normalizerCastResolver                               = null;
     protected ?DataCollectionCastResolver $attributePropertyResolver                        = null;
     protected ?InputResolver $propertyInputValueResolver                                    = null;
     protected ?OutputResolver $propertyToArrayResolver                                      = null;
@@ -119,6 +121,11 @@ public function propertyInputValueResolver(): InputResolver
         );
     }
 
+    public function normalizerCastResolver(): NormalizerCastResolver
+    {
+        return $this->normalizerCastResolver ??= new NormalizerCastResolver(ConfigManager::getInstance());
+    }
+
     public function inputValueCastResolver(): InputValueCastResolver
     {
         return $this->inputValueCastResolver ??= new InputValueCastResolver(ConfigManager::getInstance());

src/Support/Config/ConfigManager.php

@@ -7,12 +7,15 @@
 use Astral\Serialize\Casts\InputValue\InputObjectBestMatchChildCast;
 use Astral\Serialize\Casts\InputValue\InputValueEnumCast;
 use Astral\Serialize\Casts\InputValue\InputValueNullCast;
+use Astral\Serialize\Casts\Normalizer\ArrayNormalizerCast;
+use Astral\Serialize\Casts\Normalizer\JsonNormalizerCast;
 use Astral\Serialize\Casts\OutValue\OutArrayChildCast;
 use Astral\Serialize\Casts\OutValue\OutValueEnumCast;
 use Astral\Serialize\Casts\OutValue\OutValueGetterCast;
 use Astral\Serialize\Contracts\Attribute\DataCollectionCastInterface;
 use Astral\Serialize\Contracts\Attribute\InputValueCastInterface;
 use Astral\Serialize\Contracts\Attribute\OutValueCastInterface;
+use Astral\Serialize\Contracts\Normalizer\NormalizerCastInterface;
 use Astral\Serialize\Enums\CacheDriverEnum;
 use Astral\Serialize\Exceptions\NotFoundAttributePropertyResolver;
 use Astral\Serialize\Support\Caching\MemoryCache;
@@ -40,6 +43,12 @@ class ConfigManager
         OutValueGetterCast::class,
     ];
 
+    /** @var (NormalizerCastInterface|string)[] $normalizerCasts */
+    private array $normalizerCasts = [
+//        JsonNormalizerCast::class,
+        ArrayNormalizerCast::class,
+    ];
+
     /** @var CacheDriverEnum|class-string $cacheDriver */
     private string|CacheDriverEnum $cacheDriver = MemoryCache::class;
 
@@ -52,13 +61,30 @@ public function __construct()
         foreach ($this->outputValueCasts as $key => $cast) {
             $this->outputValueCasts[$key] = new $cast();
         }
+
+        foreach ($this->normalizerCasts as $key => $cast) {
+            $this->normalizerCasts[$key] = new $cast();
+        }
     }
 
     public static function getInstance(): ConfigManager
     {
         return self::$instance ??= new self();
     }
 
+    /**
+     * @throws NotFoundAttributePropertyResolver
+     */
+    public function addNormalizerCasts(NormalizerCastInterface|string $resolverClass): static
+    {
+        if (is_string($resolverClass) && !is_subclass_of($resolverClass, NormalizerCastInterface::class)) {
+            throw new NotFoundAttributePropertyResolver('Resolver class must be an instance of NormalizerCastInterface');
+        }
+        $this->attributePropertyResolver[] = (is_string($resolverClass) ? new $resolverClass() : $resolverClass);
+
+        return $this;
+    }
+
     /**
      * @throws NotFoundAttributePropertyResolver
      */
@@ -113,6 +139,11 @@ public function getOutValueCasts(): array
         return $this->outputValueCasts;
     }
 
+    public function getNormalizerCasts(): array
+    {
+        return $this->normalizerCasts;
+    }
+
     public function getCacheDriver(): string
     {
         if ($this->cacheDriver instanceof CacheDriverEnum) {

src/Support/Context/SerializeContext.php

@@ -5,6 +5,7 @@
 use Astral\Serialize\Exceptions\NotFoundGroupException;
 use Astral\Serialize\Faker\FakerResolver;
 use Astral\Serialize\Resolvers\Casts\DataCollectionCastResolver;
+use Astral\Serialize\Resolvers\Casts\NormalizerCastResolver;
 use Astral\Serialize\Resolvers\GroupResolver;
 use Astral\Serialize\Resolvers\InputResolver;
 use Astral\Serialize\Resolvers\OutputResolver;
@@ -38,6 +39,7 @@ public function __construct(
         private readonly InputResolver                  $propertyInputValueResolver,
         private readonly OutputResolver                 $propertyToArrayResolver,
         private readonly FakerResolver                  $fakerResolver,
+        private readonly NormalizerCastResolver         $normalizerCastResolver,
     ) {
 
     }
@@ -187,8 +189,10 @@ className: $type->className,
      */
     public function from(mixed ...$payload): object
     {
+
         $payloads = [];
         foreach ($payload as $field => $itemPayload) {
+            $itemPayload = $this->normalizerCastResolver->resolve($itemPayload);
             $values   = is_numeric($field) && is_array($itemPayload) ? $itemPayload : [$field => $itemPayload];
             $payloads = [...$payloads, ...$values];
         }

src/Support/Factories/ContextFactory.php

@@ -28,6 +28,7 @@ public static function build(string $className): SerializeContext
             propertyInputValueResolver: SerializeContainer::get()->propertyInputValueResolver(),
             propertyToArrayResolver:  SerializeContainer::get()->propertyToArrayResolver(),
             fakerResolver: SerializeContainer::get()->fakerResolver(),
+            normalizerCastResolver: SerializeContainer::get()->normalizerCastResolver(),
         ));
     }
 }

tests/Serialize/From/NormalizerFromSerializeTest.php

@@ -0,0 +1,55 @@
+<?php
+
+use Astral\Serialize\Serialize;
+
+beforeAll(function () {
+    class NormalizerOne extends Serialize
+    {
+        public string $name_one;
+        public int $id_one;
+    }
+
+    class NormalizerTwo extends Serialize
+    {
+        public string $name_two;
+        public int $id_two;
+    }
+
+    class NormalizerClass extends Serialize
+    {
+        public NormalizerOne $one;
+        public NormalizerTwo $two;
+
+        public mixed $three;
+    }
+
+});
+
+it('test normalizer Serialize class', function () {
+
+    $normalizerOne = new NormalizerOne();
+    $normalizerOne->name_one = 'one name';
+    $normalizerOne->id_one = 1;
+
+    $normalizerTwo = new NormalizerTwo();
+    $normalizerTwo->name_two = 'two name';
+    $normalizerTwo->id_two = 2;
+
+    $res = NormalizerClass::from(one: $normalizerOne, two: $normalizerTwo, three: $normalizerOne);
+
+    expect($res->one)->toBeInstanceOf(NormalizerOne::class)
+        ->and($res->one->name_one)->toBe('one name')
+        ->and($res->one->id_one)->toBe(1)
+        ->and($res->two)->toBeInstanceOf(NormalizerTwo::class)
+        ->and($res->two->name_two)->toBe('two name')
+        ->and($res->two->id_two)->toBe(2)
+        ->and($res->three)->toBeArray()
+        ->and($res->three)->toMatchArray([
+            'name_one' => 'one name',
+            'id_one' => 1
+        ]);
+
+    $resJson = json_encode($res);
+    expect($resJson)->toBe('{"code":200,"message":"\u64cd\u4f5c\u6210\u529f","data":{"one":{"code":200,"message":"\u64cd\u4f5c\u6210\u529f","data":{"name_one":"one name","id_one":1}},"two":{"code":200,"message":"\u64cd\u4f5c\u6210\u529f","data":{"name_two":"two name","id_two":2}},"three":{"name_one":"one name","id_one":1}}}');
+});
+