Refactor packages:update command

Signed-off-by: Tim Goudriaan <tim@codedmonkey.com>

Author: codedmonkey

src/Command/PackagesUpdateCommand.php

@@ -4,6 +4,7 @@
 
 use CodedMonkey\Dirigent\Doctrine\Repository\PackageRepository;
 use CodedMonkey\Dirigent\Message\SchedulePackageUpdate;
+use CodedMonkey\Dirigent\Message\UpdatePackage;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputArgument;
@@ -29,48 +30,92 @@ public function __construct(
     protected function configure(): void
     {
         $this
-            ->addArgument('package', InputArgument::OPTIONAL, 'Package to update')
-            ->addOption('force', null, InputOption::VALUE_NONE, 'Forces a re-crawl of all packages');
+            ->addArgument('package', InputArgument::IS_ARRAY, 'Package to update')
+            ->addOption('all', null, InputOption::VALUE_NONE, 'Update all packages')
+            ->addOption('sync', null, InputOption::VALUE_NONE, 'Update packages synchronously')
+            ->setHelp(<<<'TXT'
+                The <info>%command.name%</info> command schedules packages in the registry for update:
+
+                  <info>%command.full_name%</info>
+
+                By default, only packages that have passed the periodic update interval will be scheduled for update.
+
+                Use the <comment>--all</comment> option to schedule all packages for update instead:
+
+                  <info>%command.full_name% --all</info>
+
+                It's possible to update specific packages by passing their name as arguments:
+
+                  <info>%command.full_name% psr/cache psr/log</info>
+
+                Use the <comment>--sync</comment> option to update packages synchronously:
+
+                  <info>%command.full_name% psr/cache psr/log --sync</info>
+            TXT);
     }
 
     protected function execute(InputInterface $input, OutputInterface $output): int
     {
         $io = new SymfonyStyle($input, $output);
 
-        $force = $input->getOption('force');
-        $packageName = $input->getArgument('package');
+        $all = $input->getOption('all');
+        $packageNames = $input->getArgument('package');
+        $sync = $input->getOption('sync');
+
+        if ($sync && !count($packageNames)) {
+            $io->error('Specify a package to update when using the --sync option.');
 
+            return Command::FAILURE;
+        }
+
+        // Force refresh updates even if alread
+        $forceRefresh = false;
+        // Randomize time of updates
         $randomTimes = true;
+        // Schedule update even if already scheduled
         $reschedule = false;
 
-        if ($packageName) {
-            if (null === $package = $this->packageRepository->findOneByName($packageName)) {
-                $io->error("Package $packageName not found");
+        if (count($packageNames)) {
+            $packageIds = [];
+            foreach ($packageNames as $packageName) {
+                if (null === $package = $this->packageRepository->findOneByName($packageName)) {
+                    $io->error("Package $packageName not found");
 
-                return Command::FAILURE;
-            }
+                    return Command::FAILURE;
+                }
 
-            $io->writeln("Scheduling package $packageName for update...");
-
-            $packages = [['id' => $package->getId()]];
+                $io->writeln("Scheduling package $packageName for update...");
+                $packageIds[] = $package->getId();
+            }
 
+            $forceRefresh = true;
             $randomTimes = false;
             $reschedule = true;
-        } elseif ($force) {
+        } elseif ($all) {
             $io->writeln('Scheduling all packages for update...');
-            $packages = $this->packageRepository->getAllPackageIds();
+            $packageIds = $this->packageRepository->getAllPackageIds();
 
+            $forceRefresh = true;
             $reschedule = true;
         } else {
             $io->writeln('Scheduling stale packages for update...');
-            $packages = $this->packageRepository->getStalePackageIds();
+            $packageIds = $this->packageRepository->getStalePackageIds();
+        }
+
+        if ($sync) {
+            foreach ($packageIds as $packageId) {
+                $this->messenger->dispatch(new UpdatePackage($packageId, forceRefresh: $forceRefresh));
+            }
+
+            $packageCount = count($packageIds);
+            $io->success("Updated $packageCount package(s).");
         }
 
-        foreach ($packages as $package) {
-            $this->messenger->dispatch(new SchedulePackageUpdate($package['id'], randomTime: $randomTimes, reschedule: $reschedule, forceRefresh: $force));
+        foreach ($packageIds as $packageId) {
+            $this->messenger->dispatch(new SchedulePackageUpdate($packageId, randomTime: $randomTimes, reschedule: $reschedule, forceRefresh: $forceRefresh));
         }
 
-        $packageCount = count($packages);
+        $packageCount = count($packageIds);
         $io->success("Scheduled $packageCount package(s) for update.");
 
         return Command::SUCCESS;

src/Doctrine/Entity/Package.php

@@ -333,6 +333,11 @@ public function setUpdateScheduledAt(?\DateTimeInterface $updateScheduledAt): vo
         $this->updateScheduledAt = $updateScheduledAt;
     }
 
+    public function isUpdateScheduled(): bool
+    {
+        return null !== $this->updateScheduledAt;
+    }
+
     public function getDumpedAt(): ?\DateTimeInterface
     {
         return $this->dumpedAt;

src/Doctrine/Repository/PackageRepository.php

@@ -55,17 +55,17 @@ public function findOneByName(string $name): ?Package
     }
 
     /**
-     * @return list<array{id: int}>
+     * @return int[]
      */
     public function getAllPackageIds(): array
     {
         $connection = $this->getEntityManager()->getConnection();
 
-        return $connection->fetchAllAssociative('SELECT id FROM package ORDER BY id');
+        return $connection->fetchFirstColumn('SELECT id FROM package ORDER BY id');
     }
 
     /**
-     * @return list<array{id: int}>
+     * @return int[]
      */
     public function getStalePackageIds(): array
     {
@@ -74,12 +74,13 @@ public function getStalePackageIds(): array
         $now = (new \DateTimeImmutable())->setTimezone(new \DateTimeZone('UTC'));
         $before = $now->sub($this->updateInterval);
 
-        return $connection->fetchAllAssociative(
-            'SELECT p.id FROM package p
-            WHERE p.update_scheduled_at IS NULL
-                AND (p.updated_at IS NULL OR p.updated_at < :crawled)
-            ORDER BY p.id',
-            [
+        return $connection->fetchFirstColumn(
+            <<<'SQL'
+                SELECT p.id FROM package p
+                WHERE p.update_scheduled_at IS NULL
+                    AND (p.updated_at IS NULL OR p.updated_at < :crawled)
+                ORDER BY p.id
+            SQL, [
                 'crawled' => $before->format('Y-m-d H:i:s'),
             ]
         );

src/Message/SchedulePackageUpdateHandler.php

@@ -22,26 +22,22 @@ public function __invoke(SchedulePackageUpdate $message): void
     {
         $package = $this->packageRepository->find($message->packageId);
 
-        if (!$message->reschedule && null !== $package->getUpdateScheduledAt()) {
+        if (!$message->reschedule && $package->isUpdateScheduled()) {
             return;
         }
 
-        $updateMessage = new UpdatePackage($message->packageId, scheduled: true, forceRefresh: $message->forceRefresh);
-        $updateEnvelope = new Envelope($updateMessage, [
-            new TransportNamesStamp('async'),
-        ]);
+        $updateMessage = Envelope::wrap(new UpdatePackage($message->packageId, scheduled: true, forceRefresh: $message->forceRefresh))
+            ->with(new TransportNamesStamp('async'));
 
         if ($message->randomTime) {
             // Delay message up to 12 minutes
-            $updateEnvelope = $updateEnvelope->with(
-                new DelayStamp(random_int(1, 720) * 1000),
-            );
+            $updateMessage = $updateMessage->with(new DelayStamp(random_int(1, 720) * 1000));
         }
 
         $package->setUpdateScheduledAt(new \DateTime());
 
         $this->packageRepository->save($package, true);
 
-        $this->messenger->dispatch($updateEnvelope);
+        $this->messenger->dispatch($updateMessage);
     }
 }