Require attributes for property morphable and cast before passing to …

…morph
bentleyo · Jan 29, 2025 · 2f70f17 · 2f70f17
1 parent 3129237
commit 2f70f17
Show file tree

Hide file tree

Showing 9 changed files with 112 additions and 47 deletions.
diff --git a/src/Resolvers/DataFromSomethingResolver.php b/src/Resolvers/DataFromSomethingResolver.php
@@ -3,6 +3,7 @@
 namespace Spatie\LaravelData\Resolvers;
 
 use Illuminate\Http\Request;
+use Illuminate\Support\Arr;
 use Spatie\LaravelData\Contracts\BaseData;
 use Spatie\LaravelData\Contracts\PropertyMorphableData;
 use Spatie\LaravelData\Enums\CustomCreationMethodType;
@@ -130,7 +131,7 @@ protected function dataFromArray(
             /**
              * @var class-string<PropertyMorphableData> $class
              */
-            if ($morph = $class::morph($properties)) {
+            if ($morph = $class::morph(Arr::only($properties, $dataClass->propertyMorphablePropertyNames))) {
                 return $this->execute($morph, $creationContext, ...$payloads);
             }
         }

diff --git a/src/Resolvers/DataValidationRulesResolver.php b/src/Resolvers/DataValidationRulesResolver.php
@@ -8,7 +8,9 @@
 use Spatie\LaravelData\Attributes\MergeValidationRules;
 use Spatie\LaravelData\Attributes\Validation\ArrayType;
 use Spatie\LaravelData\Attributes\Validation\Present;
+use Spatie\LaravelData\Contracts\BaseData;
 use Spatie\LaravelData\Contracts\PropertyMorphableData;
+use Spatie\LaravelData\Support\Creation\CreationContextFactory;
 use Spatie\LaravelData\Support\DataClass;
 use Spatie\LaravelData\Support\DataConfig;
 use Spatie\LaravelData\Support\DataProperty;
@@ -36,17 +38,11 @@ public function execute(
         DataRules $dataRules
     ): array {
         $dataClass = $this->dataConfig->getDataClass($class);
-
-        if ($this->isPropertyMorphable($dataClass)) {
-            /**
-             * @var class-string<PropertyMorphableData> $class
-             */
-            $morphedClass = $class::morph(
-                $path->isRoot() ? $fullPayload : Arr::get($fullPayload, $path->get(), [])
-            );
-
-            $dataClass = $this->dataConfig->getDataClass($morphedClass ?? $class);
-        }
+        $dataClass = $this->propertyMorphableDataClass(
+            $dataClass,
+            $fullPayload,
+            $path
+        ) ?? $dataClass;
 
         $withoutValidationProperties = [];
 
@@ -96,6 +92,44 @@ public function execute(
         return $dataRules->rules;
     }
 
+    protected function propertyMorphableDataClass(
+        DataClass $dataClass,
+        array $fullPayload,
+        ValidationPath $path
+    ): ?DataClass {
+        if (! $dataClass->propertyMorphable) {
+            return null;
+        }
+
+        /**
+         * @var class-string<PropertyMorphableData&BaseData> $class
+         */
+        $class = $dataClass->name;
+        $creationContext = CreationContextFactory::createFromConfig($class)->get();
+        $pipeline = $this->dataConfig->getResolvedDataPipeline($class);
+
+        try {
+            $properties = Arr::only($pipeline->execute(
+                $path->isRoot() ? $fullPayload : Arr::get($fullPayload, $path->get(), []),
+                $creationContext
+            ), $dataClass->propertyMorphablePropertyNames);
+        } catch (\Throwable $exception) {
+            return null;
+        }
+
+        // Only morph if all properties are present
+        if (count($properties) !== count($dataClass->propertyMorphablePropertyNames)) {
+            return null;
+        }
+
+        $morphedClass = $class::morph($properties);
+        if ($morphedClass === null) {
+            return null;
+        }
+
+        return $this->dataConfig->getDataClass($morphedClass);
+    }
+
     protected function shouldSkipPropertyValidation(
         DataProperty $dataProperty,
         array $fullPayload,

diff --git a/src/Support/DataClass.php b/src/Support/DataClass.php
@@ -35,7 +35,8 @@ public function __construct(
         public DataStructureProperty $allowedRequestOnly,
         public DataStructureProperty $allowedRequestExcept,
         public DataStructureProperty $outputMappedProperties,
-        public DataStructureProperty $transformationFields
+        public DataStructureProperty $transformationFields,
+        public readonly array $propertyMorphablePropertyNames
     ) {
     }
 

diff --git a/src/Support/Factories/DataClassFactory.php b/src/Support/Factories/DataClassFactory.php
@@ -104,6 +104,10 @@ public function build(ReflectionClass $reflectionClass): DataClass
             allowedRequestExcept: new LazyDataStructureProperty(fn (): ?array => $responsable ? $name::allowedRequestExcept() : null),
             outputMappedProperties: $outputMappedProperties,
             transformationFields: static::resolveTransformationFields($properties),
+            propertyMorphablePropertyNames: $properties->filter(fn (DataProperty $property) => $property->isForMorph)
+                ->map(fn (DataProperty $property) => $property->name)
+                ->values()
+                ->all(),
         );
     }
 

diff --git a/src/Support/Validation/RequiresPropertyMorphableClassRule.php b/src/Support/Validation/RequiresPropertyMorphableClassRule.php
@@ -3,6 +3,7 @@
 namespace Spatie\LaravelData\Support\Validation;
 
 use Closure;
+use Exception;
 use Illuminate\Contracts\Validation\ValidationRule;
 use Spatie\LaravelData\Attributes\Validation\ObjectValidationAttribute;
 use Spatie\LaravelData\Support\DataClass;
@@ -25,7 +26,7 @@ public static function keyword(): string
 
     public static function create(string ...$parameters): static
     {
-        return new static(...$parameters);
+        throw new Exception('Cannot create a requires property morphable class rule');
     }
 
     public function validate(string $attribute, mixed $value, Closure $fail): void

diff --git a/tests/CreationTest.php b/tests/CreationTest.php
@@ -1455,17 +1455,25 @@ class TestAutoLazyClassAttributeData extends Data
 });
 
 describe('property-morphable creation tests', function () {
+    enum TestPropertyMorphableEnum: string
+    {
+        case A = 'a';
+        case B = 'b';
+    };
+
     abstract class TestAbstractPropertyMorphableData extends Data implements PropertyMorphableData
     {
-        public function __construct(public string $variant)
-        {
+        public function __construct(
+            #[\Spatie\LaravelData\Attributes\PropertyForMorph]
+            public TestPropertyMorphableEnum $variant
+        ) {
         }
 
         public static function morph(array $properties): ?string
         {
             return match ($properties['variant'] ?? null) {
-                'a' => TestPropertyMorphableDataA::class,
-                'b' => TestPropertyMorphableDataB::class,
+                TestPropertyMorphableEnum::A => TestPropertyMorphableDataA::class,
+                TestPropertyMorphableEnum::B => TestPropertyMorphableDataB::class,
                 default => null,
             };
         }
@@ -1475,15 +1483,15 @@ class TestPropertyMorphableDataA extends TestAbstractPropertyMorphableData
     {
         public function __construct(public string $a, public DummyBackedEnum $enum)
         {
-            parent::__construct('a');
+            parent::__construct(TestPropertyMorphableEnum::A);
         }
     }
 
     class TestPropertyMorphableDataB extends TestAbstractPropertyMorphableData
     {
         public function __construct(public string $b)
         {
-            parent::__construct('b');
+            parent::__construct(TestPropertyMorphableEnum::B);
         }
     }
 
@@ -1496,7 +1504,7 @@ public function __construct(public string $b)
 
         expect($dataA)
             ->toBeInstanceOf(TestPropertyMorphableDataA::class)
-            ->variant->toEqual('a')
+            ->variant->toEqual(TestPropertyMorphableEnum::A)
             ->a->toEqual('foo')
             ->enum->toEqual(DummyBackedEnum::FOO);
 
@@ -1507,7 +1515,7 @@ public function __construct(public string $b)
 
         expect($dataB)
             ->toBeInstanceOf(TestPropertyMorphableDataB::class)
-            ->variant->toEqual('b')
+            ->variant->toEqual(TestPropertyMorphableEnum::B)
             ->b->toEqual('bar');
     });
 
@@ -1519,7 +1527,7 @@ public function __construct(public string $b)
 
         expect($dataA)
             ->toBeInstanceOf(TestPropertyMorphableDataA::class)
-            ->variant->toEqual('a')
+            ->variant->toEqual(TestPropertyMorphableEnum::A)
             ->a->toEqual('foo')
             ->enum->toEqual(DummyBackedEnum::FOO);
     });
@@ -1543,13 +1551,13 @@ public function __construct(
 
         expect($data->nestedCollection[0])
             ->toBeInstanceOf(TestPropertyMorphableDataA::class)
-            ->variant->toEqual('a')
+            ->variant->toEqual(TestPropertyMorphableEnum::A)
             ->a->toEqual('foo')
             ->enum->toEqual(DummyBackedEnum::FOO);
 
         expect($data->nestedCollection[1])
             ->toBeInstanceOf(TestPropertyMorphableDataB::class)
-            ->variant->toEqual('b')
+            ->variant->toEqual(TestPropertyMorphableEnum::B)
             ->b->toEqual('bar');
     });
 
@@ -1562,13 +1570,13 @@ public function __construct(
 
         expect($collection[0])
             ->toBeInstanceOf(TestPropertyMorphableDataA::class)
-            ->variant->toEqual('a')
+            ->variant->toEqual(TestPropertyMorphableEnum::A)
             ->a->toEqual('foo')
             ->enum->toEqual(DummyBackedEnum::FOO);
 
         expect($collection[1])
             ->toBeInstanceOf(TestPropertyMorphableDataB::class)
-            ->variant->toEqual('b')
+            ->variant->toEqual(TestPropertyMorphableEnum::B)
             ->b->toEqual('bar');
     });
 });
diff --git a/tests/Support/EloquentCasts/DataCollectionEloquentCastTest.php b/tests/Support/EloquentCasts/DataCollectionEloquentCastTest.php
@@ -178,8 +178,10 @@
 it('can load and save an abstract property-morphable data collection', function () {
     abstract class TestCollectionCastAbstractPropertyMorphableData extends Data implements PropertyMorphableData
     {
-        public function __construct(public string $variant)
-        {
+        public function __construct(
+            #[\Spatie\LaravelData\Attributes\PropertyForMorph]
+            public string $variant
+        ) {
         }
 
         public static function morph(array $properties): ?string

diff --git a/tests/Support/EloquentCasts/DataEloquentCastTest.php b/tests/Support/EloquentCasts/DataEloquentCastTest.php
@@ -191,24 +191,26 @@
 it('can load and save an abstract property-morphable data object', function () {
     abstract class TestCastAbstractPropertyMorphableData extends Data implements PropertyMorphableData
     {
-        public function __construct(public string $variant)
-        {
+        public function __construct(
+            #[\Spatie\LaravelData\Attributes\PropertyForMorph]
+            public DummyBackedEnum $variant
+        ) {
         }
 
         public static function morph(array $properties): ?string
         {
             return match ($properties['variant'] ?? null) {
-                'a' => TestCastPropertyMorphableDataA::class,
+                DummyBackedEnum::FOO => TestCastPropertyMorphableDataFoo::class,
                 default => null,
             };
         }
     }
 
-    class TestCastPropertyMorphableDataA extends TestCastAbstractPropertyMorphableData
+    class TestCastPropertyMorphableDataFoo extends TestCastAbstractPropertyMorphableData
     {
-        public function __construct(public string $a, public DummyBackedEnum $enum)
+        public function __construct(public string $a)
         {
-            parent::__construct('a');
+            parent::__construct(DummyBackedEnum::FOO);
         }
     }
 
@@ -222,20 +224,20 @@ public function __construct(public string $a, public DummyBackedEnum $enum)
         public $timestamps = false;
     };
 
-    $abstractA = new TestCastPropertyMorphableDataA('foo', DummyBackedEnum::FOO);
+    $abstractA = new TestCastPropertyMorphableDataFoo('foo');
 
     $modelId = $modelClass::create([
         'data' => $abstractA,
     ])->id;
 
     assertDatabaseHas($modelClass::class, [
-        'data' => json_encode(['a' => 'foo', 'enum' => 'foo', 'variant' => 'a']),
+        'data' => json_encode(['a' => 'foo', 'variant' => 'foo']),
     ]);
 
     $model = $modelClass::find($modelId);
 
     expect($model->data)
-        ->toBeInstanceOf(TestCastPropertyMorphableDataA::class)
+        ->toBeInstanceOf(TestCastPropertyMorphableDataFoo::class)
         ->a->toBe('foo')
-        ->enum->toBe(DummyBackedEnum::FOO);
+        ->variant->toBe(DummyBackedEnum::FOO);
 });
diff --git a/tests/ValidationTest.php b/tests/ValidationTest.php
@@ -2609,19 +2609,25 @@ public static function rules(): array
 });
 
 describe('property-morphable validation tests', function () {
+    enum TestValidationPropertyMorphableEnum: string
+    {
+        case A = 'a';
+        case B = 'b';
+    };
+
     abstract class TestValidationAbstractPropertyMorphableData extends Data implements PropertyMorphableData
     {
         public function __construct(
             #[PropertyForMorph]
-            public string $variant,
+            public TestValidationPropertyMorphableEnum $variant,
         ) {
         }
 
         public static function morph(array $properties): ?string
         {
-            return match ($properties['variant'] ?? null) {
-                'a' => TestValidationPropertyMorphableDataA::class,
-                'b' => TestValidationPropertyMorphableDataB::class,
+            return match ($properties['variant']) {
+                TestValidationPropertyMorphableEnum::A => TestValidationPropertyMorphableDataA::class,
+                TestValidationPropertyMorphableEnum::B => TestValidationPropertyMorphableDataB::class,
                 default => null,
             };
         }
@@ -2631,15 +2637,15 @@ class TestValidationPropertyMorphableDataA extends TestValidationAbstractPropert
     {
         public function __construct(public string $a, public DummyBackedEnum $enum)
         {
-            parent::__construct('a');
+            parent::__construct(TestValidationPropertyMorphableEnum::A);
         }
     }
 
     class TestValidationPropertyMorphableDataB extends TestValidationAbstractPropertyMorphableData
     {
         public function __construct(public string $b)
         {
-            parent::__construct('b');
+            parent::__construct(TestValidationPropertyMorphableEnum::B);
         }
     }
 
@@ -2651,7 +2657,10 @@ public function __construct(public string $b)
             ->assertErrors([
                 'variant' => 'c',
             ], [
-                'variant' => ['The selected variant is invalid for morph.'],
+                'variant' => [
+                    'The selected variant is invalid.',
+                    'The selected variant is invalid for morph.',
+                ],
             ])
             ->assertErrors([
                 'variant' => 'a',
@@ -2701,7 +2710,10 @@ public function __construct(
             ->assertErrors([
                 'nestedCollection' => [['variant' => 'c']],
             ], [
-                'nestedCollection.0.variant' => ['The selected nested collection.0.variant is invalid for morph.'],
+                'nestedCollection.0.variant' => [
+                    'The selected nested collection.0.variant is invalid.',
+                    'The selected nested collection.0.variant is invalid for morph.',
+                ],
             ])
             ->assertErrors([
                 'nestedCollection' => [['variant' => 'a'], ['variant' => 'b']],