fix(database): loading database relations or other objects (#884)

Author: brendt

composer.json

@@ -43,6 +43,7 @@
         "illuminate/view": "~11.7.0",
         "jenssegers/blade": "^2.0",
         "mikey179/vfsstream": "^2.0@dev",
+        "nesbot/carbon": "^3.8",
         "nyholm/psr7": "^1.8",
         "phpat/phpat": "^0.11.0",
         "phpbench/phpbench": "84.x-dev",

src/Tempest/Database/src/Builder/FieldName.php

@@ -5,6 +5,7 @@
 namespace Tempest\Database\Builder;
 
 use Stringable;
+use Tempest\Database\DatabaseModel;
 use Tempest\Mapper\Casters\CasterFactory;
 use Tempest\Reflection\ClassReflector;
 
@@ -25,6 +26,11 @@ public static function make(ClassReflector $class, ?TableName $tableName = null)
         $tableName ??= $class->callStatic('table');
 
         foreach ($class->getPublicProperties() as $property) {
+            // Don't include the field if it's a relation
+            if ($property->getType()->matches(DatabaseModel::class)) {
+                continue;
+            }
+
             $caster = $casterFactory->forProperty($property);
 
             if ($caster !== null) {

src/Tempest/Database/src/Casters/RelationCaster.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Database\Casters;
+
+use Tempest\Mapper\Caster;
+
+final class RelationCaster implements Caster
+{
+    public function cast(mixed $input): mixed
+    {
+        return $input;
+    }
+}

src/Tempest/Database/src/DatabaseModel.php

@@ -6,7 +6,10 @@
 
 use Tempest\Database\Builder\ModelQueryBuilder;
 use Tempest\Database\Builder\TableName;
+use Tempest\Database\Casters\RelationCaster;
+use Tempest\Mapper\CastWith;
 
+#[CastWith(RelationCaster::class)]
 interface DatabaseModel
 {
     public static function table(): TableName;

src/Tempest/Database/src/Mappers/QueryToModelMapper.php

@@ -122,7 +122,9 @@ private function parse(ClassReflector $class, DatabaseModel $model, array $row):
 
     private function parseProperty(PropertyReflector $property, DatabaseModel $model, mixed $value): DatabaseModel
     {
-        if ($value && ($caster = $this->casterFactory->forProperty($property)) !== null) {
+        $caster = $this->casterFactory->forProperty($property);
+
+        if ($value && $caster !== null) {
             $value = $caster->cast($value);
         }
 

src/Tempest/Mapper/src/Casters/CasterFactory.php

@@ -18,37 +18,51 @@
 {
     public function forProperty(PropertyReflector $property): ?Caster
     {
+        $type = $property->getType();
+
         // Get CastWith from the property
         $castWith = $property->getAttribute(CastWith::class);
 
-        $type = $property->getType();
-
-        // Get CastWith from the property's type
+        // Get CastWith from the property's type if there's no property-defined CastWith
         if ($castWith === null) {
             try {
-                $castWith = $type->asClass()->getAttribute(CastWith::class);
+                $castWith = $type->asClass()->getAttribute(CastWith::class, recursive: true);
             } catch (ReflectionException) {
                 // Could not resolve CastWith from the type
             }
         }
 
+        // Return the caster if defined with CastWith
         if ($castWith !== null) {
             // Resolve the caster from the container
             return get($castWith->className);
         }
 
+        $typeName = $type->getName();
+
         // Check if backed enum
         if ($type->matches(BackedEnum::class)) {
-            return new EnumCaster($type->getName());
+            return new EnumCaster($typeName);
         }
 
-        // Get Caster from built-in casters
-        return match ($type->getName()) {
+        // Try a built-in caster
+        $builtInCaster = match ($type->getName()) {
             'int' => new IntegerCaster(),
             'float' => new FloatCaster(),
             'bool' => new BooleanCaster(),
             DateTimeImmutable::class, DateTimeInterface::class, DateTime::class => DateTimeCaster::fromProperty($property),
             default => null,
         };
+
+        if ($builtInCaster !== null) {
+            return $builtInCaster;
+        }
+
+        // If the type's a class, we'll cast it with the generic object caster
+        if ($type->isClass()) {
+            return new ObjectCaster($type);
+        }
+
+        return null;
     }
 }

src/Tempest/Mapper/src/Casters/ObjectCaster.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Mapper\Casters;
+
+use Tempest\Mapper\Caster;
+use Tempest\Reflection\TypeReflector;
+use Throwable;
+
+final readonly class ObjectCaster implements Caster
+{
+    public function __construct(
+        private TypeReflector $type,
+    ) {
+    }
+
+    public function cast(mixed $input): mixed
+    {
+        try {
+            return $this->type->asClass()->newInstanceArgs([$input]);
+        } catch (Throwable) {
+            return $input;
+        }
+    }
+}

src/Tempest/Reflection/src/ClassReflector.php

@@ -37,6 +37,23 @@ public function getReflection(): PHPReflectionClass
         return $this->reflectionClass;
     }
 
+    public function getParent(): ?ClassReflector
+    {
+        if ($parentClass = $this->reflectionClass->getParentClass()) {
+            return new ClassReflector($parentClass);
+        }
+
+        return null;
+    }
+
+    /** @return Generator<\Tempest\Reflection\TypeReflector> */
+    public function getInterfaces(): Generator
+    {
+        foreach ($this->reflectionClass->getInterfaces() as $interface) {
+            yield new TypeReflector($interface);
+        }
+    }
+
     /** @return Generator<PropertyReflector> */
     public function getPublicProperties(): Generator
     {

src/Tempest/Reflection/src/HasAttributes.php

@@ -24,11 +24,31 @@ public function hasAttribute(string $name): bool
      * @param class-string<TAttributeClass> $attributeClass
      * @return TAttributeClass|null
      */
-    public function getAttribute(string $attributeClass): object|null
+    public function getAttribute(string $attributeClass, bool $recursive = false): object|null
     {
         $attribute = $this->getReflection()->getAttributes($attributeClass, PHPReflectionAttribute::IS_INSTANCEOF)[0] ?? null;
 
-        return $attribute?->newInstance();
+        $attributeInstance = $attribute?->newInstance();
+
+        if (! $recursive) {
+            return $attributeInstance;
+        }
+
+        if ($this instanceof ClassReflector) {
+            foreach ($this->getInterfaces() as $interface) {
+                $attributeInstance = $interface->asClass()->getAttribute($attributeClass);
+
+                if ($attributeInstance !== null) {
+                    break;
+                }
+            }
+
+            if ($attributeInstance === null && $parent = $this->getParent()) {
+                $attributeInstance = $parent->getAttribute($attributeClass, true);
+            }
+        }
+
+        return $attributeInstance;
     }
 
     /**

src/Tempest/Reflection/tests/ClassReflectorTest.php

@@ -7,6 +7,9 @@
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 use Tempest\Reflection\ClassReflector;
+use Tempest\Reflection\Tests\Fixtures\ChildWithRecursiveAttribute;
+use Tempest\Reflection\Tests\Fixtures\ClassWithInterfaceWithRecursiveAttribute;
+use Tempest\Reflection\Tests\Fixtures\RecursiveAttribute;
 use Tempest\Reflection\Tests\Fixtures\TestClassA;
 use Tempest\Reflection\Tests\Fixtures\TestClassB;
 
@@ -43,4 +46,18 @@ public function test_nullable_property_type(): void
         $reflector = new ClassReflector(TestClassB::class);
         $this->assertTrue($reflector->getProperty('name')->isNullable());
     }
+
+    public function test_recursive_attribute_from_interface(): void
+    {
+        $reflector = new ClassReflector(ClassWithInterfaceWithRecursiveAttribute::class);
+        $this->assertNull($reflector->getAttribute(RecursiveAttribute::class));
+        $this->assertNotNull($reflector->getAttribute(RecursiveAttribute::class, recursive: true));
+    }
+
+    public function test_recursive_attribute_from_parent(): void
+    {
+        $reflector = new ClassReflector(ChildWithRecursiveAttribute::class);
+        $this->assertNull($reflector->getAttribute(RecursiveAttribute::class));
+        $this->assertNotNull($reflector->getAttribute(RecursiveAttribute::class, recursive: true));
+    }
 }