As it is now, the classes need to follow strict naming conventions in order to be mapped. A nice feature would be to be able to change this behaviour via the Options, making the mapper instead guess the source property name.

For example, when looking for the property firstName, the mapper would match the first occurrence of either [firstName, first_name, FirstName, ...].

Credit

This is a young library, meaning there is lots of room for improvements, bugfixes and new features. Contributions of any kind are very much appreciated!

Some things that need work & general ideas:

• While the documentation is pretty thorough, I feel there are some things that can be explained better. There are bound to be spelling mistakes as well.
• The tests definitely need a look. They don't follow best practices. A nudge in the right direction would be very nice.
• The open issues need to be looked at, as well as the features on the roadmap.
• Submitting feature requests and bug reports is encouraged!

I'm trying to map a nested property (using mapTo) where the source property name and the target property name are different but I can't seem to find a way.

I tried mapTo and fromProperty combined:

 ->forMember('address', Operation::fromProperty('adres'))
 ->forMember('address', Operation::mapTo(Address::class))

I tried a mapTo combined with a name resolver:

->forMember('address', Operation::mapTo(Address::class))
->withNameResolver(new CallbackNameResolver(function ($targetProperty) {
    if ($targetProperty == 'address') {
        return 'adres';
    }
    return $targetProperty;
}))

None of them seem to work.

I suspect that MapFromWithMapper would do the trick but that change has not been published to packagist it seems. Am I missing something here?

The InvalidPropertyException is thrown when the provided propertyname doesn't exist on the source object. This should take into account the provided naming conventions (and the FromProperty operation).

For example registering a mapping from snake_case to camelCase and then calling forMember with a camelCase propertname will throw an error when it shouldn't

PHPStan has configuration for something it calls "object crates". These are classes that are like stdClass, that just accept whatever you read and write to them by way of __get() and __set().

I'd lile to suggest that the best way to support mapping to stdClass would be a generic system such as this, where you configure a destination class as an object crate, and everything is just written as-is. This makes it easy to extend when integrating it into frameworks and other dynamic code.

Hi,

I'm trying to use automapper-plus in the latest version (1.2.1) with Entity classes used in doctrine ORM. Doctrine ORM creates Proxy-Classes that inherit from the Entity class for adding additional stuff (e.g. loading assosiations).

My problem is, that automapper-plus seems not to work in this case. When trying to map from the proxy class to the target object, it says:

No mapping registered for converting an instance of class Proxies\__CG__\App\Entity\UserAddress into one of App\FormModel\UserAddressFormModel

I think this should be working, because every child class is an instance of the base class and should provide the same interface (Liscov Substitution Principle). The mapping should therefore apply to all sub classes.

Best Regards
mschop

When mapping to an object, MapTo::getSourceValue should also use mapToObject instead of creating an new one with map()

Maybe I miss something, but I try to implement a custom constructor that grabs entities from a Doctrine repository.

But it doesn't seem to be possible because the constructor callback doesn't get $destinationClass as parameter to retrieve which class to instanciate.

I think $destinationClass should be passed as a parameter to the constructor callable.

I've a parent class and its child

EntityA {
   private $name;
   private $entityB;
}

EntityB {
   private $name;
}

With doctrine, when I "findAll" entityA, it returns:

[
EntityA {
    name: Foo
    entityB: {
        name: Bar
        entitiesA: {
            ........
        }
    }
}
]

Then I want to map the response Doctrine to this Model

ModelA {
    private $name;
    private $modelB;
}

ModelB {
    private $name;
}

When I want to map the doctrine response to the ModelA I've this result:

ModelA {
    name: Foo
    modelB: {
        name: bar
        entitiesA: {
           ........
        }
    }
}

while the expected result should be :

ModelA {
    name: Foo
    modelB: {
        name: bar
    }
}

The mapper copy "entitiesA" property (come from doctrine) in the class ModelB, while my class ModelB hasn't a property named "entitiesA"

Why the mapper create properties which not exists in the class ?

code example :

$config->registerMapping(EntityA::class, ModelA::class);
$mapperResponse = $mapper->mapMultiple($doctrineResultWithEntityAList, ModelA::class);

How do I copy values from a source object to an existing destination object rather than create a new one?

maybe like..
$mapper->map($sourceObject, $destinationObject) ??

Is there any easy way to map polymorph property?

The polymorph property can be class A or B or C. Both classes extends the same abstract classes.
Unfortunately I can not make a mapper for the abstract class itself.

I need to avoid a N+1 problem uses DataLoader or similar solution.

I have collection of Entities and each model load from DB or from REST some data.

->forMember('path', function (Category $category, AutoMapperInterface $mapper) {

    $paths = $this->pathProvider->findByPath($category->path);

    return $mapper->mapMultiple($paths, CategoryPathDTO::class);
})

I want to collect all paths, load in batch and then resolve for each object. Do you have any suggestions how I can do this?

Is there a way to limit the level of the mapping?

Basically the same as the .Net AutoMapper.MaxDepth()
https://github.com/AutoMapper/AutoMapper/blob/835261c00c072f3e08232f0cd86d40750e109690/src/AutoMapper/Configuration/MappingExpression.cs#L86

Hi, in this case:
$dto = $mapper->map($john, EmployeeDto::class);

if $john is null, the mapper throws an exception:

"No mapping registered for converting an instance of class AutoMapperPlus\AutoMapper into one of App\DTOs\EmployeeDTO"

Shouldn't it just set $dto to NULL as well?

Hello! I updated from 1.2.1 to 1.2.2 and found a bug, example code:

final class FooDTO {
	/** @var int */
	private $foo_another_id = 2;
	/** @var int */
	private $id = 1;
}

final class BarDTO {
	/** @var int */
	private $id;
	/** @var int */
	private $bar_another_id;
}

$config = (new \AutoMapperPlus\Configuration\AutoMapperConfig());
$config
	->registerMapping(FooDTO::class, BarDTO::class)
	->forMember('id', \AutoMapperPlus\MappingOperation\Operation::fromProperty('id'))
	->forMember('bar_another_id', \AutoMapperPlus\MappingOperation\Operation::fromProperty('foo_another_id'))
	->withDefaultOperation(\AutoMapperPlus\MappingOperation\Operation::ignore());
$mapper = new \AutoMapperPlus\AutoMapper($config);
var_dump($mapper->map((new FooDTO()), BarDTO::class));

Output:

object(BarDTO)[539]
  private 'id' => int 2
  private 'bar_another_id' => int 2

Problem in \AutoMapperPlus\PropertyAccessor\PropertyAccessor::getPrivate

In following example, we didn't find a way how to replicate following in Automapper. We don't think it's possible without very custom things.

$answerSetDTO = ...
$duplicatedAnswerSetDTO = $this->autoMapper->map($answerSetDTO, AnswerSetDTO::class);

$optionsDTO = [];
foreach ($answerSetDTO->options as $optionDTO) {
    $optionDTO = $this->autoMapper->map($optionDTO, AnswerSetOptionDTO::class);
    $optionDTO->answerSet = $duplicatedAnswerSetDTO; // <- here is a complication
    $optionsDTO[] = $optionDTO;
}

$duplicatedAnswerSetDTO->options = new ArrayCollection($optionsDTO);

Using Operation::mapTo like following is close, but $optionsDTO#answerSet will be null, or it will just copy same object over:

// cloning
$autoMapperConfig->registerMapping(AnswerSetDTO::class, AnswerSetDTO::class)
    ->forMember('id', Operation::ignore())
    ->forMember('options', Operation::mapTo(AnswerSetOptionDTO::class))
    ->forMember('questions', Operation::ignore());

$autoMapperConfig->registerMapping(AnswerSetOptionDTO::class, AnswerSetOptionDTO::class)
    ->forMember('id', Operation::ignore())
// here is second culprit. Causes answerSet to be null, 
// or same object instead of parent one if Operation::ignore() is removed
// how to assign parent object id instead?
    ->forMember('answerSet', Operation::ignore()); 

So, if $answerSetDTO#options[0]#answerSet#id = 1 and $duplicateAnswerSetDTO#id = 2, we want $duplicateAnswerSetDTO#options[0]#answerSet#id = 2. Currently, we can achieve it to be null or 1 only.

Description of this operation says: "Always sets the property to the given value" but actually its not true - it will only set property to the given value in the target class if the source class has the same property name defined.. It doesnt make sense to me. I would like my mapper to always set given property to a given value, but I cant do it using setTo operation. Solution to this problem would be to always allow mappings for this operation \AutoMapperPlus\MappingOperation\Implementations\SetTo::canMapProperty:

/**
 * @inheritdoc
 */
protected function canMapProperty(string $propertyName, $source): bool
{
    return true;
}

Given $object1 and $object2 with same type.
How can I update $object1 attributes with the not null values of $object2. Is it possible?

Checking how to create nested DTO mappings, I came across the section in the README file Dealing with nested Mappings. I was confused for some time with the line that reads

$config->createMapping(Child::class, ChildDto::class);

As far as I am aware, there doesn't seem to be a method name createMapping, but rather registerMapping. Everywhere else in the README file has the method registerMapping, so I tried that in my code and it works great.

I know it's small thing, but if it could be fixed, then hopefully it'll cause less confusion for people reading the docs for the library xD

To encode a password in symfony, we have to use UserPasswordEncoderInterface to encode the password. It will need to pass the User entity as first parameter for the method encodePassword().

It will be cool if we could do something like

$config->registerMapping(UserDto::class, User::class)
    ->forMember("password", function($source, $destination) use ($passwordEncoder) {
         return $passwordEncoder->encodePassword($destination, $source->password);  
   });

Hi,
Example : the array
$array =

array (2) {
  [0]=> 
    object(App\Foo) {
      id => 1
    }
  [1]=>
    object(App\Foo) {
      id => 2
    }
}

Is automapper able to convert this array to an object like this ?

object(FooList) (2) {
  [0]=> 
    object(App\Foo) {
      id => 1
    }
  [1]=>
    object(App\Foo) {
      id => 2
    }
}

Please, change this comment to real exception

Hello! I have the following code:

$order = new Order();
$item = new Item();
$item->setName('Item Name');
$item->setPrice(1000);
$order->setItems([$item]);

dump($order);

// DTO haven't price property*
$dto = $mapper->map($order, OrderDTO::class);

dump($dto);

$order = $mapper->mapToObject($dto, $order);

dump($order);

Output:

App\Model\Order {#23
  -items: array:1 [
    0 => App\Model\Item {#24
      -name: "Item Name"
      -price: 1000
    }
  ]
}
App\DTO\OrderDTO {#33
  +items: array:1 [
    0 => App\DTO\ItemDTO {#28
      +name: "Item Name"
    }
  ]
}
App\Model\Order {#23
  -items: array:1 [
    0 => App\Model\Item {#31
      -name: "Item Name"
      -price: null
    }
  ]
}

Expected output:

App\Model\Order {#23
  -items: array:1 [
    0 => App\Model\Item {#24
      -name: "Item Name"
      -price: 1000
    }
  ]
}
App\DTO\OrderDTO {#33
  +items: array:1 [
    0 => App\DTO\ItemDTO {#28
      +name: "Item Name"
    }
  ]
}
App\Model\Order {#23
  -items: array:1 [
    0 => App\Model\Item {#31
      -name: "Item Name"
      -price: 1000
    }
  ]
}

Reproducer: https://github.com/BoShurik/automapper-plus-issue

There is often a need to transform an object to associative array and I haven't found any good solutions for this. Even having some libraries they change a standard way to do such manipulations it in the project as we use the automapper-plus ;)
I've read somewhere that there is a plan to implement such a feature but in the next version because it has some breaking changes. Is it correct?
Anyway, I just wanted to ask whether this is a coming-soon feature and I can live with my hacks for now or should I better get some additional library for this only feature?
Kinds regards and thanks for the awesome library!

It would be nice to be able to map an entire object with a callable/closure, as an alternative to creating a custom mapper. E.g. the following:

$config->registerMapping(SomeClass::class, SomeOther::class)
            ->useCustomMapper(new class extends CustomMapper {
                public function mapToObject($source, $destination)
                {
                     // do stuff
                     return $destination;
                }
            });

Would become something like this:

$config->registerMapping(SomeClass::class, SomeOther::class)
            ->fromCallable(function ($source, $destination) {
                     // do stuff
                     return $destination;
                }});

Optionally the mapper can be passed as the third parameter. On a related note, the CustomMapper could maybe use a MapperAwareInterface as well.

Hi,

Since update 1.3.0, I perceive a mapping problem.

I have two objects represented as follows :

• UserDto
• User (model object)

UserDto {#705
    -id: 269
    -name: "Doe"
    -firstname: "John"
    -email: "[email protected]"
    -cellphone: "04"
    -phone: "05"
  }

/** -------------------------- */

User {#1163
  -id: 269
  -name: "DOE"
  -firstname: "John"
  -email: "[email protected]"
  -cellphone: "05"
  -phone: null
  -fax: "06"
}

/** Mapping */

$this->config->registerMapping(UserDto::class, User::class)

The above configuration is very simple. Despite this, the library has a rather strange behavior since, as we can see, the phone property is mapped in cellphone. The above configuration is however simple.

In another case, if I pass only the cellphone value, cellphone property in UserModel will then be null.

Can you help me to see things more clearly?

Thanks you.

Hello,

It would be nice registering mapping for an interface, making the code below possible for unknown types:

$config->registerMapping(ObjectInterface::class, MyDTO::class);


$dtos = [];
foreach ($objects as $object) {
    $dtos[] = $automapper->map($object, MyDTO::class);
}

AutoMapperConfig::getClassDistance should consider interfaces with class_implements if no result with class_parents

Config:

$config->registerMapping(Category::class, \stdClass::class);

Entity:

class Category
{
    private $id;

    private $name;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): self
    {
        $this->name = $name;

        return $this;
    }
}

Mapping:

$em = $this->getDoctrine()->getRepository(Category::class);
$category = $em->findOneBy([]);
$stdclass = $this->mapper->map($category, \stdClass::class);

Expected: stdClass with ID and name properties
Actual: Cannot access private property App\Entity\Category::$id

Is it possible to map to a typed list resp. an array of objects?

Imagine a class like this:

class MyObject{
    /**
     * @var Thing[]
     */
    private $things;

    /**
     * @return Thing[]
     */
    public function getThings(): array
    {
        return $this->things;
    }

    /**
     * @param Thing[] $things
     * @return MyObject
     */
    public function setThings(array $things): MyObject
    {
        $this->things = $things;

        return $this;
    }

}

When mapping from an array i did this:

$config->registerMapping(DataType::ARRAY, Thing::class);
$config->registerMapping(DataType::ARRAY, MyObject::class)
       ->forMember(
           'things',
           function (array $things, AutoMapperInterface $mapper) {
               $ret = [];
               foreach ($things['things'] as $thing) {
                   $ret[] = $mapper->map($thing, Thing::class);
               }
               return $ret;
           }
       );

I guess it would be convenient to have a operation for this custom callback to map to a list.
Like:
Operation::mapArrayToArray(Things::class);

Hello everyone,

This package looks amazing and I am currently trying to use it for a project. I was wondering if it was possible to use the method reverseMap() on a custom mapper if it only maps attributes to other attributes without any work on the values itself ?

Or doing a custom mapper for this isn't the best practice with this package ? I wanted to use a custom mapper since I will have a lot of mappers to create and it seemed cleaner to do it that way.

Thanks in advance,
Have a nice day !

Hi, I would like to add 2 operations and wanted to know if it is wanted or can't be done already with some other operations. I'll start with the easier one:

fromProperty

we have quite a few mappings like this

        $config->registerMapping(Hosting::class, HostingDto::class)
               ->forMember('isActive', static function (Hosting $hosting) {
                   return $hosting->canBeStarted();
               })
        ;

this could be quite easily done with something like

 $config->registerMapping(Hosting::class, HostingDto::class)
               ->forMember('isActive', Operation::fromMethod('canBeStarted')
 ;

mapToMultiple

the more complicated one - support polymorphism. Sometimes we have a collection of different objects (e.g. with single table inheritance) and we would like to map them to different set of objects. Currently we are doing it like this:

               ->forMember(
                   'supportedParameters',
                   static function (Package $package, AutoMapperInterface $mapper) {
                       // Automapper is not supporting polymorphism, so we have to do it like this
                       $supportedParameters = [];

                    foreach ($package->getSupportedParameters() as $hostingTypeParameters) {
                        switch (get_class($hostingTypeParameters)) {
                            case LinuxHostingParameters::class:
                                $supportedParameters[] = $mapper->map(
                                    $hostingTypeParameters,
                                    LinuxHostingParametersDto::class
                                );

                                break;
                            case WindowsHostingParameters::class:
                                $supportedParameters[] = $mapper->map(
                                    $hostingTypeParameters,
                                    WindowsHostingParametersDto::class
                                );

                                break;                                
                            default:
                                throw new \RuntimeException(
                                    sprintf('Unsupported hosting parameters "%s"', get_class($hostingTypeParameters))
                                );
                        }
                    }

                       return $supportedParameters;
                   }
               )

My idea is to create an operation which would look like this

 $config->registerMapping(Package::class, PackageDto::class)
               ->forMember('supportedParameters', Operation::mapToMultiple([
                   LinuxHostingParameters::class,
                   WindowsHostingParameters::class
               ])
 ;

When you do lazy loading sometimes the objects come back as a proxy class which breaks since there's no mapping config registered for the proxy classes.

Example of the error:
No mapping registered for converting an instance of class Proxies\CG\Bundle\Entity\ProductItem into one of \ProductItemDto

Hi, I have a question regarding flattening objects and reusability of mappings for child objects. Imagine having structure like this:

class Tyre
{
    /** @var string */
    public $name;

    /** @var int */
    public $size;
}

class Wheel
{
    /** @var Tyre */
    public $tyre;
}

class UniCycle
{
    /** @var Wheel */
    public $wheel;

}

class UniCycleDto implements Vehicle
{
    /** @var string */
    public $tyreName;
}

class CarWithOneWheelDto implements Vehicle
{
    /** @var string */
    public $tyreName;

    /** @var string */
    public $tyreSize;
}


$config->registerMapping(UniCycle::class, UniCycleDto::class)
       ->forMember(
           'tyreName',
           static function (UniCycle $uniCycle) {
               return $uniCycle->wheel->tyre->name;
           }
       );

This can result in a pretty big configuration, keeping me wondering, if this is not smaller/easier/faster (especially when I can't reuse my mapping, since I only have one unicycle in my system)

$uniCycleDto = new UniCycleDto();
$uniCycleDto->tyreName = $uniCycle->wheel->tyre->name;

Now first question is, is it possible to write it some compact way? e.g.

$config->registerMapping(UniCycle::class, UniCycleDto::class)
       ->forMember('tyreName', Operation::mapFrom('wheel.tyre.name'));

Second question is connected with my above example and this issue regarding reusability of those small value objects. I can have other objects, which have wheels and I'm interested in their tyre names (maybe some other properties). Is it possible to do something like this? I would like to have this kind of automatic, every time when I encounter Wheel, just do the mapping. However I'm not sure how to achieve that especially without recursive property accessor.

$config->registerMapping(Wheel::class, Vehicle::class)
       ->forMember('tyreName', Operation::mapFrom('tyre.name'))
       ->forMember('tyreSize', Operation::mapFrom('tyre.size'));

$config->registerMapping(UniCycle::class, UniCycleDto::class)
       ->useMapping(UniCycle::class, Vehicle::class);

$config->registerMapping(UniCycle::class, CarWithOneWheelDto::class)
       ->useMapping(UniCycle::class, Vehicle::class);

When for example an array is passed to map, get_class will trigger an error. It would be better to check the type and throw an InvalidArgumentException if needed. In the future, we could add mappings from scalars (such as arrays, #18)

I'm currently using this project and Psalm. Obviously static analysis has some issues to understand what this mapper does, but I think that with a couple of annotations it would be fairly easy to explain what's happening type-wise.

Would you be interested in a PR that adds annotations for improving static analysis?
Would you prefer replacing the current annotations or just adding @psalm-* ones beside the existing ones?

if classA entends classBase. All attributes lived in classBase. After mapping, will get an empty class A object.

In my case, I have classA extends classBase.
I want map classA to ClassADto. my class have a list of classA.
after mapping, I get a list of empty classADto.

I experience a problem after composer updated the minor version of the amazing library you develop.
As far as I understood it's because we don't use typed variables yet. We are still sticking to the annotations.
A very nice change but I'd suggest you consider implementing backwards capability or upgrade a major version of the library.
I can't achieve proper formatting of the stack trace so I will provide it using screenshots, hope it helps

Having a typed property (PHP 7.4+), such as:

class Employee
{
    public string $name;
    public int $age;
}

Causes mapping operations to fail when mapping to Employee::class. The same mapping operating works fine if the properties are declared without types.

There is a @TODO on AutoMapperPlus\Configuration\Mapping::shouldCheckForSourceProperty() method.

Indeed certain operations needs extra Interface to skip property existence check.

For instance, I don't want certain properties to be mapped into destination object. The way it works now is perfect (with Ignore operation) but there is one problem: when I specify this operation on virtual property (i.e. in Laravel there is a lot of magic happens on models) forMember method will try to ensure source property exist. But it has no sense due to meaning of Ignore operation.

Also you have great PropertyAccessorInterface object, please utilize it to check property can be reached instead of default PHP function within forMember method.

Thanks in advance, great Tool!

My target class has a property which the source class is lacking. To this target property I would like to be able to assign a particular value during the mapping. According to the documentation Operation::setTo seems to do the job, but at the moment it ignores target properties for which there are no equivalent source properties. Is there any reason behind this behaviour? I looked at the Options object too, but see no relevant setting. I know I could define a callback, but Operation::setTo is way more elegant in this case.

Is there any reason for $context parameter to be commented in interfaces ?

I'm using PHPStan and it raise an error when typing with AutoMapperInterface and trying to use context.

Hi !

When we use Doctrine wich returns proxies, the mapper could not map : it maps property to null.

Is there a solution ?

example dump doctrine result :

App\Entity\Company {#584
  -id: 81
  -secteur: Proxies\__CG__\App\Entity\Secteur {
    -id: 1
    -name: null
  }

dump($company->getSecteur->getName()) : returns a string

but the mapper found "null"

The mapper doesn't map to class typed properties. Can it be somehow configured or is it not supported?

First of all I am a big fan of the .NET AutoMapper and thank you so much for creating this for PHP!

Is there a way to blank out properties?
For example if my source object has a property like this:

[
    'description' => ''
]

the AutoMapper will ignore it. My goal is to ignore it if null, but to overwrite it if it's an empty string.

Basically if someone wants to delete an optional text field, they can't.
Maybe there is already a way to do that, if so, could you let me know?
Or otherwise can it be implemented?

Thanks!

I'm currently trying to use the automapper to solve this problem:

I have multiple objects to map, and I have multiple \DateTime properties in those; I would like to map all of those to the same format\DTO. I have set up everything correctly, but every time that a source object has a \DateTime property, I'm forced to call ->forMember('field', Operation::mapTo(DateTimeDto)).

Is there any way to map that just once and for all?

I have entities that are related:
building, house, properties

        $config
            ->registerMapping(DataCollectorBuilding::class, AggregateBuilding::class)
            ->forMember('houses', new MapTo(AggregateHouse::class));

        $config
            ->registerMapping(DataCollectorHouse::class, AggregateHouse::class)
            ->forMember('building', function(DataCollectorHouse $house) {
                return $house->getBuilding()->getId();
            })
            ->forMember('properties', new MapTo(AggregateProperty::class));

$config
            ->registerMapping(DataCollectorProperty::class, AggregateProperty::class)
            ->forMember('presetImage', function(DataCollectorProperty $property) {
                return !is_null($property->getPreset()) ? $property->getPreset()->getImage() : null;
            })
        ;

the property has a Preset and when I just ask for Building, the auto-mapper starts filling in related entities and the Preset fills in one by one

[2020-09-14 07:10:36] doctrine.DEBUG: SELECT t0.id AS id_1, t0.code AS code_2, t0.image AS image_3, t0.created_at AS created_at_4, t0.updated_at AS updated_at_5, t0.house_id AS house_id_6 FROM preset t0 WHERE t0.id = ? [1636] []
[2020-09-14 07:10:36] doctrine.DEBUG: SELECT t0.id AS id_1, t0.code AS code_2, t0.image AS image_3, t0.created_at AS created_at_4, t0.updated_at AS updated_at_5, t0.house_id AS house_id_6 FROM preset t0 WHERE t0.id = ? [1637] []
[2020-09-14 07:10:36] doctrine.DEBUG: SELECT t0.id AS id_1, t0.code AS code_2, t0.image AS image_3, t0.created_at AS created_at_4, t0.updated_at AS updated_at_5, t0.house_id AS house_id_6 FROM preset t0 WHERE t0.id = ? [1638] []
[2020-09-14 07:10:36] doctrine.DEBUG: SELECT t0.id AS id_1, t0.code AS code_2, t0.image AS image_3, t0.created_at AS created_at_4, t0.updated_at AS updated_at_5, t0.house_id AS house_id_6 FROM preset t0 WHERE t0.id = ? [1639] []
[2020-09-14 07:10:36] doctrine.DEBUG: SELECT t0.id AS id_1, t0.code AS code_2, t0.image AS image_3, t0.created_at AS created_at_4, t0.updated_at AS updated_at_5, t0.house_id AS house_id_6 FROM preset t0 WHERE t0.id = ? [1640] []

how can you get rid of this behavior?

Hello!

I have the following use case: https://gist.github.com/BoShurik/7aafc932e9dcf74be2196a09d6da15bd

To build children elements I need access to parent object

$config
    ->registerMapping(ItemDTO::class, Item::class)
    ->forMember('value', Operation::mapFrom(function (ItemDTO $dto) {
        return new Value(/*OrderDTO::$currency*/, $dto->value);
    }))
;

I suggest to use context:

$config
    ->registerMapping(OrderDTO::class, Order::class)
    ->forMember('value', Operation::mapFrom(function (OrderDTO $dto) {
        return new Value($dto->currency, $dto->value);
    }))
    ->forMember('items', Operation::mapFromWithMapper(function (OrderDTO $dto, AutoMapper $mapper) {
        $items = [];
        foreach ($dto->items as $item) {
            $items[] = $mapper->map($item, Item::class, [
               'currency' => $dto->currency,
            ]);
        }

        return $items;
    }))
;
$config
    ->registerMapping(ItemDTO::class, Item::class)
    ->forMember('value', Operation::mapFromWithContext(function (ItemDTO $dto, array $context) {
        return new Value($context['currency'] ?? 'EUR', $dto->value);
    }))
;

Not sure, but may be it solves problem described in #16

The problem is here: https://github.com/mark-gerarts/automapper-plus/blob/master/src/PropertyAccessor/PropertyAccessor.php#L95-L102

    protected function setPrivate($object, string $propertyName, $value): void
    {
        $setter = function($value) use ($propertyName) {
            $this->{$propertyName} = $value;
        };
        $boundSetter = \Closure::bind($setter, $object, get_class($object));
        $boundSetter($value);
    }

get_class($object) returns proxy class name. This scope does not have access to private properties. Sadly this code does not throw any exception.

This is probably a feature request:
Is it possible to use a property path with dot notation with Operation::fromProperty?

Operation::fromProperty('children[0].firstName')

Its possible with the symfony PropertyAccessor:
https://symfony.com/doc/current/components/property_access.html#accessing-public-properties

Of course this can be achieved by a callback, but its quite tedious to create the callback and also check for existance of the property path.
It would be quite handy if this could be done automatically within fromProperty().

Hi! I have a problem with nested object filling with array as a source. Is it possible with AutoMapper? Here is what I'd like to do, I attach a sample code. Could you have a look, please?

class Test
{
    public function test() {
        $mapper = $this->getParentClassMapper();

        $source = ["id" => 1, "name" => "Super name"];

        $parentObject = $mapper->map($source, ParentClass::class);
        var_dump($parentObject); die;
    }

    private function getParentClassMapper() {
        $config = new AutoMapperConfig();
        $config->registerMapping(DataType::ARRAY, ChildClass::class);
        $config->registerMapping(DataType::ARRAY, ParentClass::class)
            ->forMember('child', Operation::mapTo(ChildClass::class));
        return new AutoMapper($config);
    }
}


class ParentClass
{
    private $id;
    private $child;
}

class ChildClass
{
    private $name;
}

I know that the example looks strange and therefore give you some context. I have an address table in my database. It has fields like countryId and cityId. I don't want to get the city and country with separate queries and write an sql with joins to get all info. My sql looks like this (you can also see the tables and fields there):

SELECT address.id,
                       address.countryId,
                       address.stateId,
                       address.cityId,
                       address.street,
                       address.house,
                       address.zipCode,
                       address.longitude,
                       address.latitude,
                       address_country.nameEn as countryNameEn,
                       address_country.nameDe as countryNameDe,
                       address_country.region as countryRegion,
                       address_country.code as countryCode,
                       address_state.nameEn as stateNameEn,
                       address_state.nameDe as stateNameDe,
                       address_state.countryId as stateCountryId,
                       address_city.nameEn as cityNameEn,
                       address_city.nameDe as cityNameDe,
                       address_city.countryId as cityCountryId,
                       address_city.stateId as cityStateId
        
                FROM address
                JOIN address_country on (address_country.id = address.countryId)
                JOIN address_state on (address_state.id = address.stateId)
                JOIN address_city on (address_city.id = address.cityId)
                    
                WHERE address.id = ?;

My Address model is the following:

/**
     * @var $id int
     */
    private $id;

    /**
     * @var $country Country|null
     */
    private $country;

    /**
     * @var $state State|null
     */
    private $state;

    /**
     * @var $city City|null
     */
    private $city;

    /**
     * @var $street string|null
     */
    private $street;

    /**
     * @var $house string|null
     */
    private $house;

    /**
     * @var $zipCode string|null
     */
    private $zipCode;

    /**
     * @var $longitude string|null
     */
    private $longitude;

    /**
     * @var $latitude string|null
     */
    private $latitude;

    /**
     * @var $countryId int|null
     */
    private $countryId;

    /**
     * @var $stateId int|null
     */
    private $stateId;

    /**
     * @var $cityId int|null
     */
    private $cityId;

As you can see, I would like to have city and country fields that are City and Country types. I would like to map the fields like cityNameEn to field nameEn of child city. Is that possible?
Thanks a lot for your effort, the library is awesomely useful!