vendor/zenstruck/foundry/src/Persistence/ProxyRepositoryDecorator.php line 436

  1. <?php
  3. /*
  4.  * This file is part of the zenstruck/foundry package.
  5.  *
  6.  * (c) Kevin Bond <kevinbond@gmail.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Zenstruck\Foundry\Persistence;
  14. use Doctrine\ODM\MongoDB\DocumentManager;
  15. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as ODMClassMetadata;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use Doctrine\ORM\EntityRepository;
  18. use Doctrine\ORM\Mapping\ClassMetadata as ORMClassMetadata;
  19. use Doctrine\ORM\Mapping\MappingException as ORMMappingException;
  20. use Doctrine\Persistence\Mapping\MappingException;
  21. use Doctrine\Persistence\ObjectManager;
  22. use Doctrine\Persistence\ObjectRepository;
  23. use Symfony\Component\PropertyAccess\PropertyAccess;
  24. use Zenstruck\Foundry\Factory;
  25. use Zenstruck\Foundry\Proxy as ProxyObject;
  27. /**
  28.  * @mixin EntityRepository<TProxiedObject>
  29.  * @extends RepositoryDecorator<TProxiedObject>
  30.  * @template TProxiedObject of object
  31.  *
  32.  * @author Kevin Bond <kevinbond@gmail.com>
  33.  *
  34.  * @final
  35.  */
  36. class ProxyRepositoryDecorator extends RepositoryDecorator
  37. {
  38.     /**
  39.      * @return list<Proxy<TProxiedObject>>|Proxy<TProxiedObject>
  40.      */
  41.     public function __call(string $method, array $arguments)
  42.     {
  43.         return $this->proxyResult($this->inner()->{$method}(...$arguments));
  44.     }
  46.     public function getIterator(): \Traversable
  47.     {
  48.         // TODO: $this->inner() is set to ObjectRepository, which is not
  49.         //       iterable. Can this every be another RepositoryDecorator?
  50.         if (\is_iterable($this->inner())) {
  51.             return yield from $this->inner();
  52.         }
  54.         yield from $this->findAll();
  55.     }
  57.     /**
  58.      * @deprecated use RepositoryDecorator::count()
  59.      */
  60.     public function getCount(): int
  61.     {
  62.         trigger_deprecation('zenstruck\foundry', '1.5.0', 'Using RepositoryDecorator::getCount() is deprecated, use RepositoryDecorator::count() (it is now Countable).');
  64.         return $this->count();
  65.     }
  67.     /**
  68.      * @deprecated use RepositoryDecorator::assert()->empty()
  69.      */
  70.     public function assertEmpty(string $message = ''): self
  71.     {
  72.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertEmpty() is deprecated, use RepositoryDecorator::assert()->empty().');
  74.         $this->assert()->empty($message);
  76.         return $this;
  77.     }
  79.     /**
  80.      * @deprecated use RepositoryDecorator::assert()->count()
  81.      */
  82.     public function assertCount(int $expectedCount, string $message = ''): self
  83.     {
  84.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertCount() is deprecated, use RepositoryDecorator::assert()->count().');
  86.         $this->assert()->count($expectedCount, $message);
  88.         return $this;
  89.     }
  91.     /**
  92.      * @deprecated use RepositoryDecorator::assert()->countGreaterThan()
  93.      */
  94.     public function assertCountGreaterThan(int $expected, string $message = ''): self
  95.     {
  96.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertCountGreaterThan() is deprecated, use RepositoryDecorator::assert()->countGreaterThan().');
  98.         $this->assert()->countGreaterThan($expected, $message);
  100.         return $this;
  101.     }
  103.     /**
  104.      * @deprecated use RepositoryDecorator::assert()->countGreaterThanOrEqual()
  105.      */
  106.     public function assertCountGreaterThanOrEqual(int $expected, string $message = ''): self
  107.     {
  108.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertCountGreaterThanOrEqual() is deprecated, use RepositoryDecorator::assert()->countGreaterThanOrEqual().');
  110.         $this->assert()->countGreaterThanOrEqual($expected, $message);
  112.         return $this;
  113.     }
  115.     /**
  116.      * @deprecated use RepositoryDecorator::assert()->countLessThan()
  117.      */
  118.     public function assertCountLessThan(int $expected, string $message = ''): self
  119.     {
  120.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertCountLessThan() is deprecated, use RepositoryDecorator::assert()->countLessThan().');
  122.         $this->assert()->countLessThan($expected, $message);
  124.         return $this;
  125.     }
  127.     /**
  128.      * @deprecated use RepositoryDecorator::assert()->countLessThanOrEqual()
  129.      */
  130.     public function assertCountLessThanOrEqual(int $expected, string $message = ''): self
  131.     {
  132.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertCountLessThanOrEqual() is deprecated, use RepositoryDecorator::assert()->countLessThanOrEqual().');
  134.         $this->assert()->countLessThanOrEqual($expected, $message);
  136.         return $this;
  137.     }
  139.     /**
  140.      * @deprecated use RepositoryDecorator::assert()->exists()
  141.      * @phpstan-param Proxy<TProxiedObject>|array|mixed $criteria
  142.      */
  143.     public function assertExists($criteria, string $message = ''): self
  144.     {
  145.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertExists() is deprecated, use RepositoryDecorator::assert()->exists().');
  147.         $this->assert()->exists($criteria, $message);
  149.         return $this;
  150.     }
  152.     /**
  153.      * @deprecated use RepositoryDecorator::assert()->notExists()
  154.      * @phpstan-param Proxy<TProxiedObject>|array|mixed $criteria
  155.      */
  156.     public function assertNotExists($criteria, string $message = ''): self
  157.     {
  158.         trigger_deprecation('zenstruck\foundry', '1.8.0', 'Using RepositoryDecorator::assertNotExists() is deprecated, use RepositoryDecorator::assert()->notExists().');
  160.         $this->assert()->notExists($criteria, $message);
  162.         return $this;
  163.     }
  165.     /**
  166.      * @return (Proxy&TProxiedObject)|null
  167.      *
  168.      * @phpstan-return Proxy<TProxiedObject>|null
  169.      */
  170.     public function first(string $sortedField = 'id'): ?Proxy
  171.     {
  172.         return $this->findBy([], [$sortedField => 'ASC'], 1)[0] ?? null;
  173.     }
  175.     /**
  176.      * @return (Proxy&TProxiedObject)|null
  177.      *
  178.      * @phpstan-return Proxy<TProxiedObject>|null
  179.      */
  180.     public function last(string $sortedField = 'id'): ?Proxy
  181.     {
  182.         return $this->findBy([], [$sortedField => 'DESC'], 1)[0] ?? null;
  183.     }
  185.     /**
  186.      * Remove all rows.
  187.      */
  188.     public function truncate(): void
  189.     {
  190.         $om = $this->getObjectManager();
  192.         if ($om instanceof EntityManagerInterface) {
  193.             $om->createQuery("DELETE {$this->getClassName()} e")->execute();
  195.             return;
  196.         }
  198.         if ($om instanceof DocumentManager) {
  199.             $om->getDocumentCollection($this->getClassName())->deleteMany([]);
  200.         }
  201.     }
  203.     /**
  204.      * Fetch one random object.
  205.      *
  206.      * @param array $attributes The findBy criteria
  207.      *
  208.      * @return Proxy&TProxiedObject
  209.      *
  210.      * @throws \RuntimeException if no objects are persisted
  211.      *
  212.      * @phpstan-return Proxy<TProxiedObject>
  213.      */
  214.     public function random(array $attributes = []): Proxy
  215.     {
  216.         return $this->randomSet(1, $attributes)[0];
  217.     }
  219.     /**
  220.      * Fetch a random set of objects.
  221.      *
  222.      * @param int   $number     The number of objects to return
  223.      * @param array $attributes The findBy criteria
  224.      *
  225.      * @return list<Proxy<TProxiedObject>>
  226.      *
  227.      * @throws \RuntimeException         if not enough persisted objects to satisfy the number requested
  228.      * @throws \InvalidArgumentException if number is less than zero
  229.      */
  230.     public function randomSet(int $number, array $attributes = []): array
  231.     {
  232.         if ($number < 0) {
  233.             throw new \InvalidArgumentException(\sprintf('$number must be positive (%d given).', $number));
  234.         }
  236.         return $this->randomRange($number, $number, $attributes);
  237.     }
  239.     /**
  240.      * Fetch a random range of objects.
  241.      *
  242.      * @param int   $min        The minimum number of objects to return
  243.      * @param int   $max        The maximum number of objects to return
  244.      * @param array $attributes The findBy criteria
  245.      *
  246.      * @return list<Proxy<TProxiedObject>>
  247.      *
  248.      * @throws \RuntimeException         if not enough persisted objects to satisfy the max
  249.      * @throws \InvalidArgumentException if min is less than zero
  250.      * @throws \InvalidArgumentException if max is less than min
  251.      */
  252.     public function randomRange(int $min, int $max, array $attributes = []): array
  253.     {
  254.         if ($min < 0) {
  255.             throw new \InvalidArgumentException(\sprintf('$min must be positive (%d given).', $min));
  256.         }
  258.         if ($max < $min) {
  259.             throw new \InvalidArgumentException(\sprintf('$max (%d) cannot be less than $min (%d).', $max, $min));
  260.         }
  262.         $all = \array_values($this->findBy($attributes));
  264.         \shuffle($all);
  266.         if (\count($all) < $max) {
  267.             throw new \RuntimeException(\sprintf('At least %d "%s" object(s) must have been persisted (%d persisted).', $max, $this->getClassName(), \count($all)));
  268.         }
  270.         return \array_slice($all, 0, \random_int($min, $max)); // @phpstan-ignore-line
  271.     }
  273.     /**
  274.      * @param object|array|mixed $criteria
  275.      *
  276.      * @return (Proxy&TProxiedObject)|null
  277.      *
  278.      * @phpstan-param Proxy<TProxiedObject>|array|mixed $criteria
  279.      * @phpstan-return Proxy<TProxiedObject>|null
  280.      */
  281.     public function find($criteria): ?object
  282.     {
  283.         if ($criteria instanceof Proxy) {
  284.             $criteria = $criteria->_real();
  285.         }
  287.         if (!\is_array($criteria)) {
  288.             /** @var TProxiedObject|null $result */
  289.             $result = $this->inner()->find($criteria);
  291.             return $this->proxyResult($result);
  292.         }
  294.         $normalizedCriteria = [];
  295.         $propertyAccessor = PropertyAccess::createPropertyAccessor();
  296.         foreach ($criteria as $attributeName => $attributeValue) {
  297.             if (!\is_object($attributeValue)) {
  298.                 $normalizedCriteria[$attributeName] = $attributeValue;
  300.                 continue;
  301.             }
  303.             if ($attributeValue instanceof Factory) {
  304.                 $attributeValue = $attributeValue->withoutPersisting()->createAndUnproxify();
  305.             } elseif ($attributeValue instanceof Proxy) {
  306.                 $attributeValue = $attributeValue->_real();
  307.             }
  309.             try {
  310.                 $metadataForAttribute = $this->getObjectManager()->getClassMetadata($attributeValue::class);
  311.             } catch (MappingException|ORMMappingException) {
  312.                 $normalizedCriteria[$attributeName] = $attributeValue;
  314.                 continue;
  315.             }
  317.             $isEmbedded = match ($metadataForAttribute::class) {
  318.                 ORMClassMetadata::class => $metadataForAttribute->isEmbeddedClass,
  319.                 ODMClassMetadata::class => $metadataForAttribute->isEmbeddedDocument,
  320.                 default => throw new \LogicException(\sprintf('Metadata class %s is not supported.', $metadataForAttribute::class)),
  321.             };
  323.             // it's a regular entity
  324.             if (!$isEmbedded) {
  325.                 $normalizedCriteria[$attributeName] = $attributeValue;
  327.                 continue;
  328.             }
  330.             foreach ($metadataForAttribute->getFieldNames() as $field) {
  331.                 $embeddableFieldValue = $propertyAccessor->getValue($attributeValue, $field);
  332.                 if (\is_object($embeddableFieldValue)) {
  333.                     throw new \InvalidArgumentException('Nested embeddable objects are still not supported in "find()" method.');
  334.                 }
  336.                 $normalizedCriteria["{$attributeName}.{$field}"] = $embeddableFieldValue;
  337.             }
  338.         }
  340.         return $this->findOneBy($normalizedCriteria);
  341.     }
  343.     /**
  344.      * @return list<Proxy<TProxiedObject>>
  345.      */
  346.     public function findAll(): array
  347.     {
  348.         return $this->proxyResult($this->inner()->findAll());
  349.     }
  351.     /**
  352.      * @param int|null $limit
  353.      * @param int|null $offset
  354.      *
  355.      * @return list<Proxy<TProxiedObject>>
  356.      */
  357.     public function findBy(array $criteria, ?array $orderBy = null, $limit = null, $offset = null): array
  358.     {
  359.         return $this->proxyResult($this->inner()->findBy(self::normalizeCriteria($criteria), $orderBy, $limit, $offset));
  360.     }
  362.     /**
  363.      * @param array|null $orderBy Some ObjectRepository's (ie Doctrine\ORM\EntityRepository) add this optional parameter
  364.      *
  365.      * @return (Proxy&TProxiedObject)|null
  366.      *
  367.      * @throws \RuntimeException if the wrapped ObjectRepository does not have the $orderBy parameter
  368.      *
  369.      * @phpstan-return Proxy<TProxiedObject>|null
  370.      */
  371.     public function findOneBy(array $criteria, ?array $orderBy = null): ?Proxy
  372.     {
  373.         if (null !== $orderBy) {
  374.             trigger_deprecation('zenstruck\foundry', '1.38.0', 'Argument "$orderBy" of method "%s()" is deprecated and will be removed in Foundry 2.0. Use "%s::findBy()" instead if you need an order.', __METHOD__, __CLASS__);
  375.         }
  377.         if (\is_array($orderBy)) {
  378.             $wrappedParams = (new \ReflectionClass($this->inner()))->getMethod('findOneBy')->getParameters();
  380.             if (!isset($wrappedParams[1]) || 'orderBy' !== $wrappedParams[1]->getName() || !($type = $wrappedParams[1]->getType()) instanceof \ReflectionNamedType || 'array' !== $type->getName()) {
  381.                 throw new \RuntimeException(\sprintf('Wrapped repository\'s (%s) findOneBy method does not have an $orderBy parameter.', $this->inner()::class));
  382.             }
  383.         }
  385.         /** @var TProxiedObject|null $result */
  386.         $result = $this->inner()->findOneBy(self::normalizeCriteria($criteria), $orderBy); // @phpstan-ignore-line
  387.         if (null === $result) {
  388.             return null;
  389.         }
  391.         return $this->proxyResult($result);
  392.     }
  394.     /**
  395.      * @return class-string<TProxiedObject>
  396.      */
  397.     public function getClassName(): string
  398.     {
  399.         return $this->inner()->getClassName();
  400.     }
  402.     /**
  403.      * @param TProxiedObject|list<TProxiedObject>|null $result
  404.      *
  405.      * @return Proxy|Proxy[]|object|object[]|mixed
  406.      *
  407.      * @phpstan-return ($result is array ? list<Proxy<TProxiedObject>> : Proxy<TProxiedObject>)
  408.      */
  409.     private function proxyResult(mixed $result)
  410.     {
  411.         if (\is_array($result)) {
  412.             return \array_map(fn(mixed $o): mixed => $this->proxyResult($o), $result);
  413.         }
  415.         if ($result && \is_a($result, $this->getClassName())) {
  416.             return ProxyObject::createFromPersisted($result);
  417.         }
  419.         return $result;
  420.     }
  422.     private static function normalizeCriteria(array $criteria): array
  423.     {
  424.         return \array_map(
  425.             static fn($value) => $value instanceof Proxy ? $value->_real() : $value,
  426.             $criteria,
  427.         );
  428.     }
  430.     private function getObjectManager(): ObjectManager
  431.     {
  432.         return Factory::configuration()->objectManagerFor($this->getClassName());
  433.     }
  434. }
  436. \class_exists(\Zenstruck\Foundry\RepositoryProxy::class);