Add support for datetime in strict mode

Author: djairhogeuens

src/JsonMapper.php

@@ -301,6 +301,8 @@ public function map($json, $object)
                 // but only a flat type (i.e. string, int)
                 if ($this->bStrictObjectTypeChecking
                     && !is_subclass_of($type, \BackedEnum::class)
+                    && (!is_subclass_of($type, \DateTimeInterface::class)
+                    || !$this->isSafeDateTime($jvalue))
                 ) {
                     throw new JsonMapper_Exception(
                         'JSON property "' . $key . '" must be an object, '
@@ -343,7 +345,7 @@ public function map($json, $object)
      * @param $type  Type name (simple type or class name)
      * @param $strNs Base namespace that gets prepended to the type name
      *
-     * @return Fully-qualified type name with namespace
+     * @return ?string Fully-qualified type name with namespace
      */
     protected function getFullNamespace(?string $type, string $strNs): ?string
     {
@@ -455,6 +457,8 @@ public function mapArray(
                         $array[$key] = $jvalue;
                     } else if ($this->bStrictObjectTypeChecking
                         && !is_subclass_of($class, \BackedEnum::class)
+                        && (!is_subclass_of($class, \DateTimeInterface::class)
+                        || !$this->isSafeDateTime($jvalue))
                     ) {
                         throw new JsonMapper_Exception(
                             'JSON property'
@@ -708,6 +712,29 @@ protected function createInstance(
         }
     }
 
+    /**
+     * Checks if the given JSON value is a strict ISO 8601 / RFC 3339 date string.
+     *
+     * @param mixed $jvalue JSON value being mapped
+     *
+     * @return bool
+     */
+    protected function isSafeDateTime(mixed $jvalue): bool
+    {
+        $pattern = '/^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})?)?$/';
+        if (!preg_match($pattern, $jvalue)) {
+            return false;
+        }
+        try {
+            new \DateTimeImmutable($jvalue);
+        } catch (\Exception $e) {
+            return false;
+        }
+        $errors = \DateTimeImmutable::getLastErrors();
+        return !is_array($errors)
+            || (empty($errors['warnings']) && empty($errors['errors']));
+    }
+
     /**
      * Get the mapped class/type name for this class.
      * Returns the incoming classname if not mapped.
@@ -746,7 +773,7 @@ protected function getMappedType(?string $type, mixed $jvalue = null): ?string
      *
      * @param $type type name from gettype()
      *
-     * @return boole True if it is a simple PHP type
+     * @return bool True if it is a simple PHP type
      *
      * @see isFlatType()
      */

tests/DateTime_Strict_Test.php

@@ -0,0 +1,86 @@
+<?php
+/**
+ * Unit tests for JsonMapper's DateTime handling under strict object type checking.
+ *
+ * @category Tests
+ * @package  JsonMapper
+ * @license  OSL-3.0 http://opensource.org/licenses/osl-3.0
+ * @link     https://github.com/cweiske/jsonmapper
+ */
+class DateTime_Strict_Test extends \PHPUnit\Framework\TestCase
+{
+    public static function validFormatData()
+    {
+        return [
+            'date only'              => ['2024-01-15'],
+            'space separator'        => ['2024-01-15 12:30:45'],
+            'iso with colon offset'  => ['2024-01-15T12:30:45+00:00'],
+            'rfc 3339 fractional Z'  => ['2024-01-15T12:30:45.123Z'],
+            'compact offset'         => ['2024-01-15T12:30:45+0100'],
+        ];
+    }
+
+    /**
+     * @dataProvider validFormatData
+     */
+    public function testMapValidFormat($value)
+    {
+        $jm = new JsonMapper();
+        $jm->bStrictObjectTypeChecking = true;
+        $sn = $jm->map(
+            json_decode("{\"datetime\":\"$value\"}"),
+            new JsonMapperTest_Object()
+        );
+        $this->assertInstanceOf(DateTime::class, $sn->datetime);
+    }
+
+    public static function invalidFormatData()
+    {
+        return [
+            'relative string' => ['now'],
+            'wrong format'    => ['2024/01/15'],
+            'overflow date'   => ['2024-02-30'],
+        ];
+    }
+
+    /**
+     * @dataProvider invalidFormatData
+     */
+    public function testMapInvalidFormat($value)
+    {
+        $jm = new JsonMapper();
+        $jm->bStrictObjectTypeChecking = true;
+        $this->expectException(JsonMapper_Exception::class);
+        $this->expectExceptionMessage('JSON property "datetime" must be an object, string given');
+        $sn = $jm->map(
+            json_decode("{\"datetime\":\"$value\"}"),
+            new JsonMapperTest_Object()
+        );
+    }
+
+    public function testMapArrayValidFormat()
+    {
+        $jm = new JsonMapper();
+        $jm->bStrictObjectTypeChecking = true;
+        $sn = $jm->map(
+            json_decode("{\"typedSimpleArray\":[\"{$this->validFormatData()['date only'][0]}\",\"{$this->validFormatData()['space separator'][0]}\"]}"),
+            new JsonMapperTest_Array()
+        );
+        $this->assertIsArray($sn->typedSimpleArray);
+        $this->assertCount(2, $sn->typedSimpleArray);
+        $this->assertInstanceOf(DateTime::class, $sn->typedSimpleArray[0]);
+        $this->assertInstanceOf(DateTime::class, $sn->typedSimpleArray[1]);
+    }
+
+    public function testMapArrayInvalidFormat()
+    {
+        $jm = new JsonMapper();
+        $jm->bStrictObjectTypeChecking = true;
+        $this->expectException(JsonMapper_Exception::class);
+        $this->expectExceptionMessage('JSON property "typedSimpleArray[1]" must be an object, string given');
+        $sn = $jm->map(
+            json_decode("{\"typedSimpleArray\":[\"{$this->validFormatData()['date only'][0]}\",\"{$this->invalidFormatData()['relative string'][0]}\"]}"),
+            new JsonMapperTest_Array()
+        );
+    }
+}