Merge branch 'main' into vite-configuration

Author: ewingd

CHANGELOG.md

@@ -2,7 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
-## [1.2.2](https://github.com/tempestphp/tempest-framework/compare/v1.2.1..1.2.2)  —  2025-07-08
+## [1.2.3](https://github.com/tempestphp/tempest-framework/compare/v1.2.2..1.2.3)  —  2025-07-08
+
+### 🐛 Bug fixes
+
+- **database**: fix datetime serialization for mysql database (#1383) ([dde0e84](https://github.com/tempestphp/tempest-framework/commit/dde0e84a6bba614c4fa3932914ffaee2dd4916e7))
+
+
+## [1.2.2](https://github.com/tempestphp/tempest-framework/compare/v1.2.1..v1.2.2)  —  2025-07-08
 
 ### 🚀 Features
 

packages/core/src/Kernel.php

@@ -8,7 +8,7 @@
 
 interface Kernel
 {
-    public const string VERSION = '1.2.2';
+    public const string VERSION = '1.2.3';
 
     public string $root {
         get;

packages/database/src/Casters/IdCaster.php

@@ -6,7 +6,6 @@
 
 use Tempest\Database\Id;
 use Tempest\Mapper\Caster;
-use Tempest\Mapper\Exceptions\ValueCouldNotBeSerialized;
 
 final readonly class IdCaster implements Caster
 {
@@ -18,13 +17,4 @@ public function cast(mixed $input): Id
 
         return new Id($input);
     }
-
-    public function serialize(mixed $input): string
-    {
-        if (! ($input instanceof Id)) {
-            throw new ValueCouldNotBeSerialized(Id::class);
-        }
-
-        return (string) $input->id;
-    }
 }

packages/database/src/DatabaseInitializer.php

@@ -11,6 +11,7 @@
 use Tempest\Database\Connection\Connection;
 use Tempest\Database\Connection\PDOConnection;
 use Tempest\Database\Transactions\GenericTransactionManager;
+use Tempest\Mapper\SerializerFactory;
 use Tempest\Reflection\ClassReflector;
 use UnitEnum;
 
@@ -42,6 +43,7 @@ className: Connection::class,
         return new GenericDatabase(
             $connection,
             new GenericTransactionManager($connection),
+            $container->get(SerializerFactory::class),
         );
     }
 }

packages/database/src/GenericDatabase.php

@@ -4,8 +4,6 @@
 
 namespace Tempest\Database;
 
-use BackedEnum;
-use DateTimeInterface;
 use PDO;
 use PDOException;
 use PDOStatement;
@@ -14,6 +12,7 @@
 use Tempest\Database\Connection\Connection;
 use Tempest\Database\Exceptions\QueryWasInvalid;
 use Tempest\Database\Transactions\TransactionManager;
+use Tempest\Mapper\SerializerFactory;
 use Throwable;
 use UnitEnum;
 
@@ -33,6 +32,7 @@ final class GenericDatabase implements Database
     public function __construct(
         private(set) readonly Connection $connection,
         private(set) readonly TransactionManager $transactionManager,
+        private(set) readonly SerializerFactory $serializerFactory,
     ) {}
 
     public function execute(BuildsQuery|Query $query): void
@@ -124,21 +124,10 @@ private function resolveBindings(Query $query): array
         $bindings = [];
 
         foreach ($query->bindings as $key => $value) {
-            // TODO: this should be handled by serializers (except the Query)
-            if ($value instanceof Id) {
-                $value = $value->id;
-            }
-
             if ($value instanceof Query) {
                 $value = $value->execute();
-            }
-
-            if ($value instanceof BackedEnum) {
-                $value = $value->value;
-            }
-
-            if ($value instanceof DateTimeInterface) {
-                $value = $value->format('Y-m-d H:i:s');
+            } elseif ($serializer = $this->serializerFactory->forValue($value)) {
+                $value = $serializer->serialize($value);
             }
 
             $bindings[$key] = $value;

packages/database/src/Serializers/IdSerializer.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Tempest\Database\Serializers;
+
+use Tempest\Database\Id;
+use Tempest\Mapper\Exceptions\ValueCouldNotBeSerialized;
+use Tempest\Mapper\Serializer;
+
+final class IdSerializer implements Serializer
+{
+    public function serialize(mixed $input): array|string
+    {
+        if (! ($input instanceof Id)) {
+            throw new ValueCouldNotBeSerialized(Id::class);
+        }
+
+        return $input->id;
+    }
+}

packages/database/src/Serializers/IdSerializerProvider.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Tempest\Database\Serializers;
+
+use Tempest\Core\KernelEvent;
+use Tempest\Database\Id;
+use Tempest\EventBus\EventHandler;
+use Tempest\Mapper\SerializerFactory;
+
+final readonly class IdSerializerProvider
+{
+    public function __construct(
+        private SerializerFactory $serializerFactory,
+    ) {}
+
+    #[EventHandler(KernelEvent::BOOTED)]
+    public function __invoke(KernelEvent $_event): void
+    {
+        $this->serializerFactory->addSerializer(Id::class, IdSerializer::class);
+    }
+}

packages/database/tests/GenericDatabaseTest.php

@@ -10,6 +10,7 @@
 use Tempest\Database\Connection\Connection;
 use Tempest\Database\GenericDatabase;
 use Tempest\Database\Transactions\GenericTransactionManager;
+use Tempest\Mapper\SerializerFactory;
 
 /**
  * @internal
@@ -33,7 +34,7 @@ public function test_it_executes_transactions(): void
         $database = new GenericDatabase(
             $connection,
             new GenericTransactionManager($connection),
-            DatabaseDialect::SQLITE,
+            new SerializerFactory(),
         );
 
         $result = $database->withinTransaction(function () {
@@ -60,7 +61,7 @@ public function test_it_rolls_back_transactions_on_failure(): void
         $database = new GenericDatabase(
             $connection,
             new GenericTransactionManager($connection),
-            DatabaseDialect::SQLITE,
+            new SerializerFactory(),
         );
 
         $result = $database->withinTransaction(function (): never {

packages/mapper/src/Mappers/ObjectToArrayMapper.php

@@ -11,6 +11,8 @@
 use Tempest\Reflection\ClassReflector;
 use Tempest\Reflection\PropertyReflector;
 
+use function Tempest\map;
+
 final readonly class ObjectToArrayMapper implements Mapper
 {
     public function __construct(
@@ -22,20 +24,24 @@ public function canMap(mixed $from, mixed $to): bool
         return false;
     }
 
-    public function map(mixed $from, mixed $to): array
+    public function map(mixed $from, mixed $to): mixed
     {
         if ($from instanceof JsonSerializable) {
             return $from->jsonSerialize();
         }
 
-        $class = new ClassReflector($from);
+        if (is_object($from)) {
+            $class = new ClassReflector($from);
 
-        $mappedProperties = [];
+            $mappedProperties = [];
 
-        foreach ($class->getPublicProperties() as $property) {
-            $propertyName = $this->resolvePropertyName($property);
-            $propertyValue = $this->resolvePropertyValue($property, $from);
-            $mappedProperties[$propertyName] = $propertyValue;
+            foreach ($class->getPublicProperties() as $property) {
+                $propertyName = $this->resolvePropertyName($property);
+                $propertyValue = $this->resolvePropertyValue($property, $from);
+                $mappedProperties[$propertyName] = $propertyValue;
+            }
+        } else {
+            $mappedProperties = $from;
         }
 
         return $mappedProperties;
@@ -45,6 +51,16 @@ private function resolvePropertyValue(PropertyReflector $property, object $objec
     {
         $propertyValue = $property->getValue($object);
 
+        if ($property->getIterableType()?->isClass()) {
+            foreach ($propertyValue as $key => $value) {
+                if (is_object($value)) {
+                    $propertyValue[$key] = map($value)->toArray();
+                }
+            }
+
+            return $propertyValue;
+        }
+
         if ($propertyValue !== null && ($serializer = $this->serializerFactory->forProperty($property)) !== null) {
             return $serializer->serialize($propertyValue);
         }

packages/mapper/src/SerializerFactory.php

@@ -5,7 +5,10 @@
 namespace Tempest\Mapper;
 
 use Closure;
+use Tempest\Reflection\ClassReflector;
 use Tempest\Reflection\PropertyReflector;
+use Tempest\Reflection\TypeReflector;
+use TypeError;
 
 use function Tempest\get;
 
@@ -26,6 +29,40 @@ public function addSerializer(string|Closure $for, string|Closure $serializerCla
         return $this;
     }
 
+    private function serializerMatches(Closure|string $for, TypeReflector|string $input): bool
+    {
+        if (is_callable($for)) {
+            try {
+                return $for($input);
+            } catch (TypeError) { // @mago-expect best-practices/dont-catch-error
+                return false;
+            }
+        }
+
+        if ($for === $input) {
+            return true;
+        }
+
+        if ($input instanceof TypeReflector) {
+            return $input->getName() === $for || $input->matches($for);
+        }
+
+        return false;
+    }
+
+    private function resolveSerializer(Closure|string $serializerClass, PropertyReflector|TypeReflector|string $input): ?Serializer
+    {
+        if (is_string($serializerClass)) {
+            return get($serializerClass);
+        }
+
+        try {
+            return $serializerClass($input);
+        } catch (TypeError) { // @mago-expect best-practices/dont-catch-error
+            return null;
+        }
+    }
+
     public function forProperty(PropertyReflector $property): ?Serializer
     {
         $type = $property->getType();
@@ -46,10 +83,42 @@ public function forProperty(PropertyReflector $property): ?Serializer
 
         // Resolve serializer from manual additions
         foreach ($this->serializers as [$for, $serializerClass]) {
-            if (is_callable($for) && $for($property) || is_string($for) && $type->matches($for) || $type->getName() === $for) {
-                return is_callable($serializerClass)
-                    ? $serializerClass($property)
-                    : get($serializerClass);
+            if (! $this->serializerMatches($for, $type)) {
+                continue;
+            }
+
+            $serializer = $this->resolveSerializer($serializerClass, $property);
+
+            if ($serializer !== null) {
+                return $serializer;
+            }
+        }
+
+        return null;
+    }
+
+    public function forValue(mixed $value): ?Serializer
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if (is_object($value)) {
+            $input = new ClassReflector($value)->getType();
+        } else {
+            $input = gettype($value);
+        }
+
+        // Resolve serializer from manual additions
+        foreach ($this->serializers as [$for, $serializerClass]) {
+            if (! $this->serializerMatches($for, $input)) {
+                continue;
+            }
+
+            $serializer = $this->resolveSerializer($serializerClass, $input);
+
+            if ($serializer !== null) {
+                return $serializer;
             }
         }