Synchronize frequently bought together products in batches

config/services/synchronizer.xml

@@ -13,6 +13,7 @@
             <argument type="service" id="CommerceWeavers\SyliusAlsoBoughtPlugin\Provider\PlacedOrdersProviderInterface" />
             <argument type="service" id="CommerceWeavers\SyliusAlsoBoughtPlugin\Mapper\BoughtTogetherProductsMapperInterface" />
             <argument type="service" id="CommerceWeavers\SyliusAlsoBoughtPlugin\Saver\BoughtTogetherProductsInfoSaverInterface" />
+            <argument>%commerce_weavers_sylius_also_bought.batch_size_limit%</argument>
         </service>
     </services>
 </container>

docs/installation.md

@@ -24,6 +24,7 @@ imports:
 
 commerce_weavers_sylius_also_bought:
     number_of_products_to_associate: 10 # default value
+    batch_size_limit: 1000 # default value
 ```
 
 ### 4. Add trait to enhance Sylius Product model

src/DependencyInjection/CommerceWeaversSyliusAlsoBoughtExtension.php

@@ -42,6 +42,11 @@ public function prepend(ContainerBuilder $container): void
             $config['number_of_products_to_associate'],
         );
 
+        $container->setParameter(
+            'commerce_weavers_sylius_also_bought.batch_size_limit',
+            $config['batch_size_limit'],
+        );
+
         $this->prependDoctrineMigrations($container);
         $this->prependDoctrineMapping($container);
     }

src/DependencyInjection/Configuration.php

@@ -32,6 +32,7 @@ private function addConfiguration(ArrayNodeDefinition $node): void
         $node
             ->children()
                 ->integerNode('number_of_products_to_associate')->defaultValue(10)->end()
+                ->integerNode('batch_size_limit')->defaultValue(1000)->end()
             ->end()
         ;
     }

src/Provider/PlacedOrdersProvider.php

@@ -13,13 +13,15 @@ public function __construct(private OrderRepositoryInterface $orderRepository)
     {
     }
 
-    public function getSince(\DateTimeInterface $since): array
+    public function getSince(\DateTimeInterface $since, int $limit, int $offset): array
     {
         /** @var OrderInterface[] $result */
         $result = $this->orderRepository
             ->createListQueryBuilder()
             ->andWhere('o.checkoutCompletedAt >= :date')
             ->setParameter('date', $since)
+            ->setMaxResults($limit)
+            ->setFirstResult($offset)
             ->getQuery()
             ->getResult()
         ;

src/Provider/PlacedOrdersProviderInterface.php

@@ -9,5 +9,5 @@
 interface PlacedOrdersProviderInterface
 {
     /** @return OrderInterface[] */
-    public function getSince(\DateTimeInterface $since): array;
+    public function getSince(\DateTimeInterface $since, int $limit, int $offset): array;
 }

src/Synchronizer/FrequentlyBoughtTogetherProductsSynchronizer.php

@@ -8,20 +8,46 @@
 use CommerceWeavers\SyliusAlsoBoughtPlugin\Model\SynchronizationResult;
 use CommerceWeavers\SyliusAlsoBoughtPlugin\Provider\PlacedOrdersProviderInterface;
 use CommerceWeavers\SyliusAlsoBoughtPlugin\Saver\BoughtTogetherProductsInfoSaverInterface;
+use Sylius\Component\Core\Model\OrderInterface;
 
 final class FrequentlyBoughtTogetherProductsSynchronizer implements FrequentlyBoughtTogetherProductsSynchronizerInterface
 {
     public function __construct(
         private PlacedOrdersProviderInterface $placedOrdersProvider,
         private BoughtTogetherProductsMapperInterface $boughtTogetherProductsMapper,
         private BoughtTogetherProductsInfoSaverInterface $boughtTogetherProductsInfoSaver,
+        private int $batchSize = 1000,
     ) {
     }
 
     public function synchronize(\DateTimeInterface $since): SynchronizationResult
     {
-        $orders = $this->placedOrdersProvider->getSince($since);
+        $offset = 0;
 
+        $numberOfOrders = 0;
+        $affectedProducts = [];
+
+        while (($orders = $this->placedOrdersProvider->getSince($since, $this->batchSize, $offset)) !== []) {
+            $affectedProducts = array_merge($affectedProducts, $this->getAffectedProducts($orders));
+            $numberOfOrders += count($orders);
+
+            $offset += $this->batchSize;
+        }
+
+        foreach ($affectedProducts as $productCode => $products) {
+            $this->boughtTogetherProductsInfoSaver->save($productCode, $products);
+        }
+
+        return new SynchronizationResult($numberOfOrders, array_keys($affectedProducts));
+    }
+
+    /**
+     * @param OrderInterface[] $orders
+     *
+     * @return array<string, array<string>>
+     */
+    private function getAffectedProducts(array $orders): array
+    {
         $affectedProducts = [];
 
         foreach ($orders as $order) {
@@ -32,10 +58,6 @@ public function synchronize(\DateTimeInterface $since): SynchronizationResult
             }
         }
 
-        foreach ($affectedProducts as $productCode => $products) {
-            $this->boughtTogetherProductsInfoSaver->save($productCode, $products);
-        }
-
-        return new SynchronizationResult(count($orders), array_keys($affectedProducts));
+        return $affectedProducts;
     }
 }

tests/Unit/DependencyInjection/ConfigurationTest.php

@@ -31,6 +31,25 @@ public function it_allows_to_define_number_of_products_to_associate(): void
             'number_of_products_to_associate'
         );
     }
+    /** @test */
+    public function it_defines_batch_size_limit_by_default(): void
+    {
+        $this->assertProcessedConfigurationEquals(
+            [],
+            ['batch_size_limit' => 1000],
+            'batch_size_limit'
+        );
+    }
+
+    /** @test */
+    public function it_allows_to_define_batch_size_limit(): void
+    {
+        $this->assertProcessedConfigurationEquals(
+            [['batch_size_limit' => 5]],
+            ['batch_size_limit' => 5],
+            'batch_size_limit'
+        );
+    }
 
     protected function getConfiguration(): Configuration
     {

tests/Unit/Provider/PlacedOrdersProviderTest.php

@@ -29,13 +29,15 @@ public function testItProvidesOrdersPlacedSinceSpecificDate(): void
 
         $orderRepository->createListQueryBuilder()->willReturn($queryBuilder->reveal())->shouldBeCalled();
         $queryBuilder->andWhere('o.checkoutCompletedAt >= :date')->willReturn($queryBuilder->reveal())->shouldBeCalled();
+        $queryBuilder->setMaxResults(10)->willReturn($queryBuilder->reveal())->shouldBeCalled();
+        $queryBuilder->setFirstResult(0)->willReturn($queryBuilder->reveal())->shouldBeCalled();
         $queryBuilder->setParameter('date', $since)->willReturn($queryBuilder->reveal())->shouldBeCalled();
         $queryBuilder->getQuery()->willReturn($query->reveal())->shouldBeCalled();
         $query->getResult()->willReturn([$firstOrder, $secondOrder]);
 
         self::assertSame(
             [$firstOrder, $secondOrder],
-            (new PlacedOrdersProvider($orderRepository->reveal()))->getSince($since)
+            (new PlacedOrdersProvider($orderRepository->reveal()))->getSince($since, 10, 0)
         );
     }
 }

tests/Unit/Synchronizer/FrequentlyBoughtTogetherProductsSynchronizerTest.php

@@ -25,27 +25,41 @@ public function testProductsSynchronization(): void
 
         $firstOrder = new Order();
         $secondOrder = new Order();
+        $thirdOrder = new Order();
 
         $synchronizer = new FrequentlyBoughtTogetherProductsSynchronizer(
             $placedOrdersProvider->reveal(),
             $productsMapper->reveal(),
             $boughtTogetherProductsInfoSaver->reveal(),
+            2,
         );
 
         $placedOrdersProvider
-            ->getSince(new \DateTimeImmutable('2020-01-01'))
+            ->getSince(new \DateTimeImmutable('2020-01-01'), 2, 0)
             ->willReturn([$firstOrder, $secondOrder])
         ;
 
+        $placedOrdersProvider
+            ->getSince(new \DateTimeImmutable('2020-01-01'), 2, 2)
+            ->willReturn([$thirdOrder])
+        ;
+
+        $placedOrdersProvider
+            ->getSince(new \DateTimeImmutable('2020-01-01'), 2, 4)
+            ->willReturn([])
+        ;
+
         $productsMapper->map($firstOrder)->willReturn(['P10273' => ['P12182', 'P12183'], 'P12182' => ['P10273', 'P12183'], 'P12183' => ['P10273', 'P12182']]);
         $productsMapper->map($secondOrder)->willReturn(['P12182' => ['P10273'], 'P10273' => ['P12182']]);
+        $productsMapper->map($thirdOrder)->willReturn(['P13757' => ['P10273']]);
 
         $boughtTogetherProductsInfoSaver->save('P10273', ['P12182', 'P12183', 'P12182'])->shouldBeCalled();
         $boughtTogetherProductsInfoSaver->save('P12182', ['P10273', 'P12183', 'P10273'])->shouldBeCalled();
         $boughtTogetherProductsInfoSaver->save('P12183', ['P10273', 'P12182'])->shouldBeCalled();
+        $boughtTogetherProductsInfoSaver->save('P13757', ['P10273'])->shouldBeCalled();
 
         self::assertEquals(
-            new SynchronizationResult(2, ['P10273', 'P12182', 'P12183']),
+            new SynchronizationResult(3, ['P10273', 'P12182', 'P12183', 'P13757']),
             $synchronizer->synchronize(new \DateTimeImmutable('2020-01-01')),
         );
     }