How to avoid the N+1 problem?

[gebekov]

Hi! Thanks for the great library 🙂!

I have a question:
Is there a way to avoid N+1 problems when mapping collections from DTO using transformers/providers (e.g. I keep identifiers in the DTOs and I want them to be loaded from the DB)? Unfortunately I couldn't find a clear answer to my question in the documentation.

The most obvious solution is to retrieve the required objects from the database in advance, before mapping, and pass them to the context. And then pass those objects from the context, but it seems to me that this is not a good solution. Is there another way to map collections?

Thanks in advance!

[damienalexandre]

Doctrine EntityManager is capable of that, so it could be possible to:

• craft a query to fetch all necessary entities at once
• use find(ID) in the transformer, and let the EntityManager returns the already known objects

Anyway, the question is, should we expect the automapper to deal with that?

[gebekov]

Hi @damienalexandre. Thank you for your reply!

Your comment seems to be correct: indeed, your trick can be used to achieve the desired result. But what about if the ORM Doctrine is not used, or if, for example, the objects are stored in another service's API?

Perhaps it's not Automapper's area of responsibility to solve these kinds of problems, but I think it could be a very handy feature

[joelwurtz]

For your use case i think you could use a provider https://automapper.jolicode.com/latest/mapping/provider/

With the following schema :

#[Entity]
class Book {
    public string $id;
}

#[Entity]
#[MapProvider(provider: LibraryProvider::class, source: 'array')]
class Library {
    public string $id;

    public Collection $books;
}

You could write a provider like this :

class LibraryProvider implements ProviderInterface
{
    public function __construct(private LibraryRepository $repository)
    {
    }

    public function provide(string $targetType, mixed $source, array $context): object|null
    {
        // fetch library with all it's book
        $library = $this->repository->findLibraryWithBooks($source['id']);

        return $library;
    }
}

[joelwurtz]

But i think we can provide a better solution in terms of DX, maybe we could provide a specific attribute which will do what you want like this :

// simple case on a inner joins
#[MapDoctrineProvider(joins: ['books'])]
// could be nested ?
#[MapDoctrineProvider(joins: ['b' => 'books' => 'b', 'r' => 'b.reviews'])]
// provide a custom query builder ?
#[MapDoctrineProvider(queryBuilder: QueryBuilderService::class)]
class Library {

}

[bitpetr]

Anything akin to api-platform's EagerLoadingExtension would be super cool - that is, if we do know beforehand if we would need to map that particular collection or not.

[joelwurtz]

I'm closing this, finally i think we don't really want to go there.

I think AutoMapper should be focus on mapping from/to existing object graph. That's what we have done in #260 by example by having a better support of mapping to an existing collection inside an object.

Supporting this object graph correctly allow to handle this logic before automapper (you fetch what you need to map or where you need to map correctly just before calling the map method).