SiteAccessAwareEntityManager.php

<?php

/**
 * @copyright Copyright (C) Ibexa AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
declare(strict_types=1);

namespace Ibexa\Core\Persistence\Doctrine;

use Doctrine\DBAL\Connection;
use Doctrine\ORM\Cache;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Internal\Hydration\AbstractHydrator;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\NativeQuery;
use Doctrine\ORM\Proxy\ProxyFactory;
use Doctrine\ORM\Query;
use Doctrine\ORM\Query\Expr;
use Doctrine\ORM\Query\FilterCollection;
use Doctrine\ORM\Query\ResultSetMapping;
use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\UnitOfWork;
use Ibexa\Bundle\Core\Entity\EntityManagerFactory;
use Ibexa\Contracts\Core\MVC\EventSubscriber\ConfigScopeChangeSubscriber;
use Ibexa\Core\MVC\Symfony\Event\ScopeChangeEvent;
use Symfony\Contracts\Service\ResetInterface;

/**
 * @internal
 *
 * SiteAccessAwareEntityManager is a cross-compatible class supporting doctrine/persistence v2 and v3.
 */
final class SiteAccessAwareEntityManager implements EntityManagerInterface, ConfigScopeChangeSubscriber, ResetInterface
{
    private EntityManagerFactory $entityManagerFactory;

    private ?EntityManagerInterface $resolvedEntityManager = null;

    public function __construct(EntityManagerFactory $entityManagerFactory)
    {
        $this->entityManagerFactory = $entityManagerFactory;
    }

    public function onConfigScopeChange(ScopeChangeEvent $event): void
    {
        $this->resolvedEntityManager = null;
    }

    public function reset(): void
    {
        $this->resolvedEntityManager = null;
    }

    private function getWrapped(): EntityManagerInterface
    {
        return $this->resolvedEntityManager ??= $this->entityManagerFactory->getEntityManager();
    }

    public function getConnection(): Connection
    {
        return $this->getWrapped()->getConnection();
    }

    public function getExpressionBuilder(): Expr
    {
        return $this->getWrapped()->getExpressionBuilder();
    }

    public function beginTransaction(): void
    {
        $this->getWrapped()->beginTransaction();
    }

    public function transactional($func)
    {
        return $this->getWrapped()->transactional($func);
    }

    /**
     * @return mixed
     */
    public function wrapInTransaction(callable $func)
    {
        return $this->getWrapped()->wrapInTransaction($func);
    }

    public function commit(): void
    {
        $this->getWrapped()->commit();
    }

    public function rollback(): void
    {
        $this->getWrapped()->rollback();
    }

    public function createQuery($dql = ''): Query
    {
        return $this->getWrapped()->createQuery($dql);
    }

    public function createNamedQuery($name): Query
    {
        return $this->getWrapped()->createNamedQuery($name);
    }

    public function createNativeQuery($sql, ResultSetMapping $rsm): NativeQuery
    {
        return $this->getWrapped()->createNativeQuery($sql, $rsm);
    }

    public function createNamedNativeQuery($name): NativeQuery
    {
        return $this->getWrapped()->createNamedNativeQuery($name);
    }

    public function createQueryBuilder(): QueryBuilder
    {
        return $this->getWrapped()->createQueryBuilder();
    }

    /**
     * @template T of object
     *
     * @param class-string<T> $entityName
     *
     * @return T|null
     */
    public function getReference($entityName, $id): ?object
    {
        return $this->getWrapped()->getReference($entityName, $id);
    }

    /**
     * @template T of object
     *
     * @param class-string<T> $entityName
     *
     * @return T|null
     */
    public function getPartialReference($entityName, $identifier): ?object
    {
        return $this->getWrapped()->getPartialReference($entityName, $identifier);
    }

    public function close(): void
    {
        $this->getWrapped()->close();
    }

    /**
     * @template T of object
     *
     * @param T $entity
     * @param bool $deep
     *
     * @return T
     */
    public function copy($entity, $deep = false): object
    {
        /** @var T */
        return $this->getWrapped()->copy($entity, $deep);
    }

    public function lock($entity, $lockMode, $lockVersion = null): void
    {
        $this->getWrapped()->lock($entity, $lockMode, $lockVersion);
    }

    public function getEventManager(): \Doctrine\Common\EventManager
    {
        return $this->getWrapped()->getEventManager();
    }

    public function getConfiguration(): Configuration
    {
        return $this->getWrapped()->getConfiguration();
    }

    public function isOpen(): bool
    {
        return $this->getWrapped()->isOpen();
    }

    public function getUnitOfWork(): UnitOfWork
    {
        return $this->getWrapped()->getUnitOfWork();
    }

    public function getHydrator($hydrationMode): AbstractHydrator
    {
        return $this->getWrapped()->getHydrator($hydrationMode);
    }

    public function newHydrator($hydrationMode): AbstractHydrator
    {
        return $this->getWrapped()->newHydrator($hydrationMode);
    }

    public function getProxyFactory(): ProxyFactory
    {
        return $this->getWrapped()->getProxyFactory();
    }

    public function getFilters(): FilterCollection
    {
        return $this->getWrapped()->getFilters();
    }

    public function isFiltersStateClean(): bool
    {
        return $this->getWrapped()->isFiltersStateClean();
    }

    public function hasFilters(): bool
    {
        return $this->getWrapped()->hasFilters();
    }

    public function getCache(): ?Cache
    {
        return $this->getWrapped()->getCache();
    }

    /**
     * @template T of object
     *
     * @phpstan-param class-string<T> $className
     * @phpstan-param \Doctrine\DBAL\LockMode::*|null $lockMode
     *
     * @param string $className
     * @param mixed $id
     * @param int|null $lockMode
     * @param int|null $lockVersion
     *
     * @return T|null
     */
    public function find($className, $id, ?int $lockMode = null, ?int $lockVersion = null): ?object
    {
        return $this->getWrapped()->find($className, $id, $lockMode, $lockVersion);
    }

    /**
     * @param object $object
     */
    public function persist($object): void
    {
        $this->getWrapped()->persist($object);
    }

    public function remove($object): void
    {
        $this->getWrapped()->remove($object);
    }

    /**
     * @param string|null $objectName
     */
    public function clear($objectName = null): void
    {
        $this->getWrapped()->clear($objectName);
    }

    /**
     * @param object $object
     */
    public function detach($object): void
    {
        $this->getWrapped()->detach($object);
    }

    public function refresh($object, ?int $lockMode = null): void
    {
        $this->getWrapped()->refresh($object, $lockMode);
    }

    public function flush(): void
    {
        $this->getWrapped()->flush();
    }

    public function getRepository($className): EntityRepository
    {
        return $this->getWrapped()->getRepository($className);
    }

    public function getClassMetadata($className): ClassMetadata
    {
        return $this->getWrapped()->getClassMetadata($className);
    }

    public function getMetadataFactory(): ClassMetadataFactory
    {
        return $this->getWrapped()->getMetadataFactory();
    }

    /**
     * @param object $obj
     */
    public function initializeObject($obj): void
    {
        $this->getWrapped()->initializeObject($obj);
    }

    /**
     * @param mixed $value
     */
    public function isUninitializedObject($value): bool
    {
        $entityManager = $this->getWrapped();

        // workaround for doctrine/persistence v2 and v3 cross-compatibility
        return method_exists($entityManager, 'isUninitializedObject')
            ? $entityManager->isUninitializedObject($value)
            : false;
    }

    /**
     * @param object $object
     */
    public function contains($object): bool
    {
        return $this->getWrapped()->contains($object);
    }

    /**
     * @param object $object
     *
     * @return object|null
     */
    public function merge($object)
    {
        $entityManager = $this->getWrapped();

        // workaround for doctrine/persistence v2 and v3 cross-compatibility
        return method_exists($entityManager, 'merge')
            ? $entityManager->merge($object)
            : null;
    }
}