Dtos, mapeo y profundidad máxima de las relaciones

Hi,

Using $entities = $this->collectionProvider->provide(...) causes an N+1 query problem: Doctrine lazily loads associations per entity, leading to many queries and slow performance.

So, Icheck if the repository implements EagerLoadingRepositoryInterface and, if so, fetch paginated entities with relations eager-loaded. Map them to DTOs and return via TraversablePaginator. Otherwise, fall back to the default provider.

        $resourceClass = $operation->getClass();
        $options = $operation->getStateOptions();
        assert($options instanceof Options);
        if ($operation instanceof CollectionOperationInterface) {
            $entityClass = $options->getEntityClass();
            $repository = $this->registry->getRepository($entityClass);
            if ($repository instanceof EagerLoadingRepositoryInterface) {
                $page = $context['filters']['page'] ?? 1;
                $limit = $operation->getPaginationItemsPerPage() ?? 12;
                $entities = $repository->findPaginatedWithRelations($page, $limit);
            } else {
                $entities = $this->collectionProvider->provide($operation, $uriVariables, $context);
            }
            assert($entities instanceof Paginator);
            $dtos = [];
            foreach ($entities as $entity) {
                $dtos[] = $this->microMapper->map($entity, $resourceClass);
            }
            return new TraversablePaginator(
                new \ArrayIterator($dtos),
                $entities->getCurrentPage(),
                $entities->getItemsPerPage(),
                $entities->getTotalItems()
            );
        }

Repository

namespace App\Repository;
use ApiPlatform\Doctrine\Orm\Paginator;
use Doctrine\ORM\Tools\Pagination\Paginator as DocrtinePaginator;
// ...
public function findPaginatedWithRelations(int $page, int $limit): Paginator
    {
        $qb = $this->createQueryBuilder('p')
            ->leftJoin('p.media', 'm')
            ->addSelect('m')
            ->leftJoin('p.subCategory', 'sc')
            ->addSelect('sc')
            ->leftJoin('sc.category', 'c')
            ->addSelect('c');
        $query = $qb->getQuery()
            ->setFirstResult(($page - 1) * $limit)
            ->setMaxResults($limit);
        return new Paginator( new DocrtinePaginator($query));
    }

Is this a good solution, or can it be optimized further?

Thnks

Hi,

Apologies, I'm relatively new to Symfony/API Platform, so my terminology maybe slightly off. But I have been following this tutorial and creating my own API, and I am having an issue whereby when using DTOs, a ManyToMany relationship is being returned as the fully hydrated model, not the IRIs as I would of expected.

Broadly, this is an example what I have put in place (I have removed the mapper from the provider etc to make this as stripped back as possible, so what is being done is minimal):

// BookDTO.php
#[ApiResource(
    shortName: 'Book',
    provider: TestProvider::class,
    stateOptions: new Options(
        entityClass: DoctrineBook::class
    )
)]
#[Get(uriTemplate: '/books/{id}.{_format}')]
#[GetCollection]
class BookDTO
{
    public function __construct(
        public ?int $id = null,
        public ?UserEntity $owner = null,
        /** @var UserEntity[] $authors */
        public array $authors = []
    )
    {}
}

The test provider just wraps the Doctrine Provider and maps the returned entity to the BookDTO.

<?php
// App/State/TestProvider

readonly final class TestProvider implements ProviderInterface
{
    public function __construct(
        #[Autowire(service: 'api_platform.doctrine.orm.state.item_provider')]
        private ProviderInterface $itemProvider,
        #[Autowire(service: CollectionProvider::class)]
        private ProviderInterface $collectionProvider,
    ) {
    }

    public function provide(Operation $operation, array $uriVariables = [], array $context = []): null|array|object
    {
        if ($operation instanceof CollectionOperationInterface) {
            return $this->provideCollection($operation, $uriVariables, $context);
        }

        // Handle single item...
    }

    private function provideCollection(Operation $operation, array $uriVariables, array $context): Traversable
    {
        $entities = $this->collectionProvider->provide($operation, $uriVariables, $context);

        $dtos = new \ArrayIterator();

        foreach ($entities as $entity) {
            $dto = new Book(id: $entity->getId());
            $dto->owner = $entity->getOwner();
            $dto->authors = $entity->getAuthors()->getValues();
            $dtos->append($dto);
        }

        return new TraversablePaginator(
            traversable:  $dtos,
            currentPage:  $entities->getCurrentPage(),
            itemsPerPage: $entities->getItemsPerPage(),
            totalItems:   $entities->getTotalItems()
        );
    }
}

The owner will come back as expected, but the authors will come back fully hydrated, and not be converted to IRIs. I'm not sure why it works fine for the owner but not authors:

"@id": "/books/1",
      "@type": "BookDTO",
      "id": 1,
      "owner": "/user-entities/4",
      "members": [
        {
          "@id": "/user-entities/4",
          "@type": "UserEntity",
          "id": 4,
          "roles": [
            "ROLE_USER"
          ],
          "userIdentifier": ""
        },

Note that if I tag the related Doctrine Entities with APIResource it all works perfectly. Also note that the OneToMany on the model seems to be working as expected as well.

I did originally have a UserDTO but have stripped it out to make the example simpler (and to try and get this working with the Doctrine entity first).

Any help would be greatly appreciated, I'm sure I'm doing something basic wrong.

Being in this chapter of the course, my already tired head tells me that if I want to add custom data that comes from business logic operations, I would have to do it here in the created Mapper, injecting the service that performs the logic I need and then assign it in populate() as it is done for example with $dto->isMine = $this->security->getUser() && $this->security->getUser() === $entity->getOwner();<br />

Am I right ? or better somewhere else ?

Hello, how can we ensure that in the following example we at least have the entire nested object?

I can't seem to get more than an array of URIs, even when increasing MAX_DEPTH to 2 or more.

$dto->dragonTreasures = array_map(function(DragonTreasure $dragonTreasure) {
    return $this->microMapper->map($dragonTreasure, DragonTreasureApi::class, [
        MicroMapperInterface::MAX_DEPTH => 1,
    ]);
}, $entity->getPublishedDragonTreasures()->getValues());

I would like to get the top level information for each dragon, including the road collection.