fix: always allow to write private props in constructor (#137)

fixes problem raised
[here](#129 (comment))

Author: joelwurtz

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 - [GH#158](https://github.com/jolicode/automapper/pull/158) Actually read reload_strategy from bundle configuration
+- [GH#137](https://github.com/jolicode/automapper/pull/137) Always allow to write private props in constructor
 
 ## [9.0.2] - 2024-05-23
 ### Deprecated

src/Extractor/MappingExtractor.php

@@ -30,13 +30,44 @@ public function __construct(
     /**
      * @return list<string>
      */
-    public function getProperties(string $class): iterable
+    public function getProperties(string $class, bool $withConstructorParameters = false): iterable
     {
         if ($class === 'array' || $class === \stdClass::class) {
             return [];
         }
 
-        return $this->propertyInfoExtractor->getProperties($class) ?? [];
+        $properties = $this->propertyInfoExtractor->getProperties($class) ?? [];
+
+        if ($withConstructorParameters) {
+            $properties = array_values(
+                array_unique(
+                    [...$properties, ...$this->getConstructorParameters($class)]
+                )
+            );
+        }
+
+        return $properties;
+    }
+
+    /**
+     * @param class-string|'array' $class
+     *
+     * @return list<string>
+     */
+    private function getConstructorParameters(string $class): iterable
+    {
+        if ($class === 'array' || $class === \stdClass::class) {
+            return [];
+        }
+
+        try {
+            return array_map(
+                static fn (\ReflectionParameter $parameter) => $parameter->getName(),
+                (new \ReflectionClass($class))->getMethod('__construct')->getParameters()
+            );
+        } catch (\ReflectionException) {
+            return [];
+        }
     }
 
     public function getReadAccessor(string $class, string $property): ?ReadAccessor

src/Extractor/MappingExtractorInterface.php

@@ -21,6 +21,8 @@ interface MappingExtractorInterface
     /**
      * Extracts properties mapped for a given source and target.
      *
+     * @param class-string|'array' $class
+     *
      * @return list<string>
      */
     public function getProperties(string $class): iterable;

src/Metadata/MetadataFactory.php

@@ -194,7 +194,7 @@ private function createGeneratorMetadata(MapperMetadata $mapperMetadata): Genera
             $propertyEvents[$propertyEvent->target->property] = $propertyEvent;
         }
 
-        foreach ($extractor->getProperties($mapperMetadata->target) as $property) {
+        foreach ($extractor->getProperties($mapperMetadata->target, withConstructorParameters: true) as $property) {
             if (isset($propertyEvents[$property])) {
                 continue;
             }

tests/AutoMapperTest.php

@@ -48,6 +48,8 @@
 use AutoMapper\Tests\Fixtures\ObjectWithDateTime;
 use AutoMapper\Tests\Fixtures\Order;
 use AutoMapper\Tests\Fixtures\PetOwner;
+use AutoMapper\Tests\Fixtures\PrivatePropertyInConstructors\ChildClass;
+use AutoMapper\Tests\Fixtures\PrivatePropertyInConstructors\OtherClass;
 use AutoMapper\Tests\Fixtures\Provider\CustomProvider;
 use AutoMapper\Tests\Fixtures\SourceForConstructorWithDefaultValues;
 use AutoMapper\Tests\Fixtures\Transformer\MoneyTransformerFactory;
@@ -1523,4 +1525,29 @@ public function testIssue111(): void
         self::assertInstanceOf(Fixtures\Issue111\Foo::class, $foo);
         self::assertEquals([new Colour('red'), new Colour('green'), new Colour('blue')], $foo->getColours());
     }
+
+    public function testItCanMapFromArrayToClassesWithPrivatePropertiesInConstructor(): void
+    {
+        self::assertEquals(
+            new ChildClass(parentProp: 'foo', childProp: 'bar'),
+            $this->autoMapper->map(
+                [
+                    'parentProp' => 'foo',
+                    'childProp' => 'bar',
+                ],
+                ChildClass::class
+            )
+        );
+    }
+
+    public function testItCanMapToClassesWithPrivatePropertiesInConstructor(): void
+    {
+        self::assertEquals(
+            new ChildClass(parentProp: 'foo', childProp: 'bar'),
+            $this->autoMapper->map(
+                new OtherClass(parentProp: 'foo', childProp: 'bar'),
+                ChildClass::class
+            )
+        );
+    }
 }

tests/Fixtures/PrivatePropertyInConstructors/AbstractClass.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Tests\Fixtures\PrivatePropertyInConstructors;
+
+/**
+ * @author Nicolas PHILIPPE <[email protected]>
+ */
+abstract class AbstractClass
+{
+    public function __construct(
+        private string $parentProp,
+    ) {
+    }
+}

tests/Fixtures/PrivatePropertyInConstructors/ChildClass.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Tests\Fixtures\PrivatePropertyInConstructors;
+
+/**
+ * @author Nicolas PHILIPPE <[email protected]>
+ */
+final class ChildClass extends AbstractClass
+{
+    public function __construct(
+        string $parentProp,
+        private string $childProp,
+    ) {
+        parent::__construct($parentProp);
+    }
+}

tests/Fixtures/PrivatePropertyInConstructors/OtherClass.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Tests\Fixtures\PrivatePropertyInConstructors;
+
+/**
+ * @author Nicolas PHILIPPE <[email protected]>
+ */
+final readonly class OtherClass
+{
+    public function __construct(
+        public string $parentProp,
+        public string $childProp,
+    ) {
+    }
+}