Feature: property-morphable abstract data

src/Contracts/PropertyMorphableData.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Spatie\LaravelData\Contracts;
+
+interface PropertyMorphableData
+{
+    public static function morph(array $properties): ?string;
+}

src/Resolvers/DataFromSomethingResolver.php

@@ -4,6 +4,7 @@
 
 use Illuminate\Http\Request;
 use Spatie\LaravelData\Contracts\BaseData;
+use Spatie\LaravelData\Contracts\PropertyMorphableData;
 use Spatie\LaravelData\Enums\CustomCreationMethodType;
 use Spatie\LaravelData\Optional;
 use Spatie\LaravelData\Support\Creation\CreationContext;
@@ -39,10 +40,9 @@ public function execute(
         $payloadCount = count($payloads);
 
         if ($payloadCount === 0 || $payloadCount === 1) {
-            return $this->dataFromArrayResolver->execute(
-                $class,
-                $pipeline->execute($payloads[0] ?? [], $creationContext)
-            );
+            $properties = $pipeline->execute($payloads[0] ?? [], $creationContext);
+
+            return $this->dataFromArray($class, $creationContext, $payloads, $properties);
         }
 
         $properties = [];
@@ -57,7 +57,7 @@ public function execute(
             }
         }
 
-        return $this->dataFromArrayResolver->execute($class, $properties);
+        return $this->dataFromArray($class, $creationContext, $payloads, $properties);
     }
 
     protected function createFromCustomCreationMethod(
@@ -117,4 +117,24 @@ protected function createFromCustomCreationMethod(
 
         return $class::$methodName(...$payloads);
     }
+
+    protected function dataFromArray(
+        string $class,
+        CreationContext $creationContext,
+        array $payloads,
+        array $properties,
+    ): BaseData {
+        $dataClass = $this->dataConfig->getDataClass($class);
+
+        if ($dataClass->isAbstract && $dataClass->propertyMorphable) {
+            /**
+             * @var class-string<PropertyMorphableData> $class
+             */
+            if ($morph = $class::morph($properties)) {
+                return $this->execute($morph, $creationContext, ...$payloads);
+            }
+        }
+
+        return $this->dataFromArrayResolver->execute($class, $properties);
+    }
 }

src/Resolvers/DataValidationRulesResolver.php

@@ -8,6 +8,7 @@
 use Spatie\LaravelData\Attributes\MergeValidationRules;
 use Spatie\LaravelData\Attributes\Validation\ArrayType;
 use Spatie\LaravelData\Attributes\Validation\Present;
+use Spatie\LaravelData\Contracts\PropertyMorphableData;
 use Spatie\LaravelData\Support\DataClass;
 use Spatie\LaravelData\Support\DataConfig;
 use Spatie\LaravelData\Support\DataProperty;
@@ -35,6 +36,17 @@ public function execute(
     ): 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);
+        }
+
         $withoutValidationProperties = [];
 
         foreach ($dataClass->properties as $dataProperty) {
@@ -283,4 +295,9 @@ protected function inferRulesForDataProperty(
             $path
         );
     }
+
+    protected function isPropertyMorphable(DataClass $dataClass): bool
+    {
+        return $dataClass->isAbstract && $dataClass->propertyMorphable;
+    }
 }

src/Support/DataClass.php

@@ -20,6 +20,7 @@ public function __construct(
         public readonly ?DataMethod $constructorMethod,
         public readonly bool $isReadonly,
         public readonly bool $isAbstract,
+        public readonly bool $propertyMorphable,
         public readonly bool $appendable,
         public readonly bool $includeable,
         public readonly bool $responsable,

src/Support/EloquentCasts/DataCollectionEloquentCast.php

@@ -40,10 +40,10 @@ public function get($model, string $key, $value, array $attributes): ?DataCollec
 
         $data = json_decode($value, true, flags: JSON_THROW_ON_ERROR);
 
-        $dataClass = $this->dataConfig->getDataClass($this->dataClass);
+        $isAbstractClassCast = $this->isAbstractClassCast();
 
-        $data = array_map(function (array $item) use ($dataClass) {
-            if ($dataClass->isAbstract && $dataClass->transformable) {
+        $data = array_map(function (array $item) use ($isAbstractClassCast) {
+            if ($isAbstractClassCast) {
                 $morphedClass = $this->dataConfig->morphMap->getMorphedDataClass($item['type']) ?? $item['type'];
 
                 return $morphedClass::from($item['data']);
@@ -73,10 +73,10 @@ public function set($model, string $key, $value, array $attributes): ?string
             throw CannotCastData::shouldBeArray($model::class, $key);
         }
 
-        $dataClass = $this->dataConfig->getDataClass($this->dataClass);
+        $isAbstractClassCast = $this->isAbstractClassCast();
 
-        $data = array_map(function (array|BaseData $item) use ($dataClass) {
-            if ($dataClass->isAbstract && $item instanceof TransformableData) {
+        $data = array_map(function (array|BaseData $item) use ($isAbstractClassCast) {
+            if ($isAbstractClassCast && $item instanceof TransformableData) {
                 $class = get_class($item);
 
                 return [
@@ -90,7 +90,7 @@ public function set($model, string $key, $value, array $attributes): ?string
                 : $item;
         }, $value);
 
-        if ($dataClass->isAbstract) {
+        if ($isAbstractClassCast) {
             return json_encode($data);
         }
 
@@ -107,6 +107,8 @@ public function set($model, string $key, $value, array $attributes): ?string
 
     protected function isAbstractClassCast(): bool
     {
-        return $this->dataConfig->getDataClass($this->dataClass)->isAbstract;
+        $dataClass = $this->dataConfig->getDataClass($this->dataClass);
+
+        return $dataClass->isAbstract && $dataClass->transformable && ! $dataClass->propertyMorphable;
     }
 }

src/Support/EloquentCasts/DataEloquentCast.php

@@ -84,6 +84,8 @@ public function set($model, string $key, $value, array $attributes): ?string
 
     protected function isAbstractClassCast(): bool
     {
-        return $this->dataConfig->getDataClass($this->dataClass)->isAbstract;
+        $dataClass = $this->dataConfig->getDataClass($this->dataClass);
+
+        return $dataClass->isAbstract && ! $dataClass->propertyMorphable;
     }
 }

src/Support/Factories/DataClassFactory.php

@@ -12,6 +12,7 @@
 use Spatie\LaravelData\Contracts\AppendableData;
 use Spatie\LaravelData\Contracts\EmptyData;
 use Spatie\LaravelData\Contracts\IncludeableData;
+use Spatie\LaravelData\Contracts\PropertyMorphableData;
 use Spatie\LaravelData\Contracts\ResponsableData;
 use Spatie\LaravelData\Contracts\TransformableData;
 use Spatie\LaravelData\Contracts\ValidateableData;
@@ -87,6 +88,7 @@ public function build(ReflectionClass $reflectionClass): DataClass
             constructorMethod: $constructor,
             isReadonly: method_exists($reflectionClass, 'isReadOnly') && $reflectionClass->isReadOnly(),
             isAbstract: $reflectionClass->isAbstract(),
+            propertyMorphable: $reflectionClass->implementsInterface(PropertyMorphableData::class),
             appendable: $reflectionClass->implementsInterface(AppendableData::class),
             includeable: $reflectionClass->implementsInterface(IncludeableData::class),
             responsable: $responsable,

tests/CreationTest.php

@@ -27,6 +27,7 @@
 use Spatie\LaravelData\Casts\Uncastable;
 use Spatie\LaravelData\Concerns\WithDeprecatedCollectionMethod;
 use Spatie\LaravelData\Contracts\DeprecatedData as DeprecatedDataContract;
+use Spatie\LaravelData\Contracts\PropertyMorphableData;
 use Spatie\LaravelData\Data;
 use Spatie\LaravelData\DataCollection;
 use Spatie\LaravelData\DataPipeline;
@@ -1452,3 +1453,122 @@ class TestAutoLazyClassAttributeData extends Data
         ->toHaveCount(2)
         ->each()->toBeInstanceOf(FakeNestedModelData::class);
 });
+
+describe('property-morphable creation tests', function () {
+    abstract class TestAbstractPropertyMorphableData extends Data implements PropertyMorphableData
+    {
+        public function __construct(public string $variant)
+        {
+        }
+
+        public static function morph(array $properties): ?string
+        {
+            return match ($properties['variant'] ?? null) {
+                'a' => TestPropertyMorphableDataA::class,
+                'b' => TestPropertyMorphableDataB::class,
+                default => null,
+            };
+        }
+    }
+
+    class TestPropertyMorphableDataA extends TestAbstractPropertyMorphableData
+    {
+        public function __construct(public string $a, public DummyBackedEnum $enum)
+        {
+            parent::__construct('a');
+        }
+    }
+
+    class TestPropertyMorphableDataB extends TestAbstractPropertyMorphableData
+    {
+        public function __construct(public string $b)
+        {
+            parent::__construct('b');
+        }
+    }
+
+    it('will allow property-morphable data to be created', function () {
+        $dataA = TestAbstractPropertyMorphableData::from([
+            'variant' => 'a',
+            'a' => 'foo',
+            'enum' => 'foo',
+        ]);
+
+        expect($dataA)
+            ->toBeInstanceOf(TestPropertyMorphableDataA::class)
+            ->variant->toEqual('a')
+            ->a->toEqual('foo')
+            ->enum->toEqual(DummyBackedEnum::FOO);
+
+        $dataB = TestAbstractPropertyMorphableData::from([
+            'variant' => 'b',
+            'b' => 'bar',
+        ]);
+
+        expect($dataB)
+            ->toBeInstanceOf(TestPropertyMorphableDataB::class)
+            ->variant->toEqual('b')
+            ->b->toEqual('bar');
+    });
+
+    it('will allow property-morphable data to be created from concrete', function () {
+        $dataA = TestPropertyMorphableDataA::from([
+            'a' => 'foo',
+            'enum' => 'foo',
+        ]);
+
+        expect($dataA)
+            ->toBeInstanceOf(TestPropertyMorphableDataA::class)
+            ->variant->toEqual('a')
+            ->a->toEqual('foo')
+            ->enum->toEqual(DummyBackedEnum::FOO);
+    });
+
+    it('will allow property-morphable data to be created from a nested collection', function () {
+        class NestedPropertyMorphableData extends Data
+        {
+            public function __construct(
+                /** @var TestAbstractPropertyMorphableData[] */
+                public ?DataCollection $nestedCollection,
+            ) {
+            }
+        }
+
+        $data = NestedPropertyMorphableData::from([
+            'nestedCollection' => [
+                ['variant' => 'a', 'a' => 'foo', 'enum' => 'foo'],
+                ['variant' => 'b', 'b' => 'bar'],
+            ],
+        ]);
+
+        expect($data->nestedCollection[0])
+            ->toBeInstanceOf(TestPropertyMorphableDataA::class)
+            ->variant->toEqual('a')
+            ->a->toEqual('foo')
+            ->enum->toEqual(DummyBackedEnum::FOO);
+
+        expect($data->nestedCollection[1])
+            ->toBeInstanceOf(TestPropertyMorphableDataB::class)
+            ->variant->toEqual('b')
+            ->b->toEqual('bar');
+    });
+
+
+    it('will allow property-morphable data to be created as a collection', function () {
+        $collection = TestAbstractPropertyMorphableData::collect([
+            ['variant' => 'a', 'a' => 'foo', 'enum' => DummyBackedEnum::FOO->value],
+            ['variant' => 'b', 'b' => 'bar'],
+        ]);
+
+        expect($collection[0])
+            ->toBeInstanceOf(TestPropertyMorphableDataA::class)
+            ->variant->toEqual('a')
+            ->a->toEqual('foo')
+            ->enum->toEqual(DummyBackedEnum::FOO);
+
+        expect($collection[1])
+            ->toBeInstanceOf(TestPropertyMorphableDataB::class)
+            ->variant->toEqual('b')
+            ->b->toEqual('bar');
+    });
+});