feat: observable tasks timeout iterator

composer.json

@@ -60,7 +60,8 @@
     },
     "require-dev": {
         "phpunit/phpunit": "^11.0",
-        "swoole/ide-helper": "^5.1"
+        "swoole/ide-helper": "^5.1",
+        "symfony/var-dumper": "^7.0"
     },
     "suggest": {
         "ext-ds": "For better memory management",

psalm.xml

@@ -11,6 +11,10 @@
     xmlns="https://getpsalm.org/schema/config"
     xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
 >
+    <forbiddenFunctions>
+        <function name="dump"/>
+    </forbiddenFunctions>
+
     <projectFiles>
         <directory name="src" />
         <file name="constants.php" />

src/Attribute/BuildsPDOPoolConnection.php

-<?php
-
-declare(strict_types=1);
-
-namespace Distantmagic\Resonance\Attribute;
-
-use Attribute;
-use Distantmagic\Resonance\Attribute as BaseAttribute;
-
-#[Attribute(Attribute::TARGET_CLASS)]
-readonly class BuildsPDOPoolConnection extends BaseAttribute
-{
-    /**
-     * @param non-empty-string $name
-     */
-    public function __construct(
-        public string $name,
-    ) {}
-}

src/CurlErrorMessage.php

+<?php
+
+declare(strict_types=1);
+
+namespace Distantmagic\Resonance;
+
+use CurlHandle;
+use Stringable;
+
+readonly class CurlErrorMessage implements Stringable
+{
+    public function __construct(private CurlHandle $curlHandle) {}
+
+    public function __toString(): string
+    {
+        return sprintf(
+            'curl request failed because of error: (%d)"%s"',
+            curl_errno($this->curlHandle),
+            curl_error($this->curlHandle),
+        );
+    }
+}

src/CurlException.php

@@ -11,10 +11,6 @@ class CurlException extends RuntimeException
 {
     public function __construct(CurlHandle $ch)
     {
-        parent::__construct(sprintf(
-            'curl request failed because of error: (%d)"%s"',
-            curl_errno($ch),
-            curl_error($ch),
-        ));
+        parent::__construct((string) new CurlErrorMessage($ch));
     }
 }

src/DatabaseConnectionPoolRepository.php

@@ -8,6 +8,7 @@ use Ds\Map;
 use OutOfBoundsException;
 use PDO;
 use RuntimeException;
+use Swoole\Database\PDOPool;
 use Swoole\Database\PDOProxy;
 
 readonly class DatabaseConnectionPoolRepository

src/LlamaCppClient.php

@@ -9,7 +9,9 @@ use Distantmagic\Resonance\Attribute\RequiresPhpExtension;
 use Distantmagic\Resonance\Attribute\Singleton;
 use Generator;
 use JsonSerializable;
+use Psr\Log\LoggerInterface;
 use RuntimeException;
+use Swoole\Coroutine;
 use Swoole\Coroutine\Channel;
 
 #[RequiresPhpExtension('curl')]
@@ -20,6 +22,7 @@ readonly class LlamaCppClient
         private JsonSerializer $jsonSerializer,
         private LlamaCppConfiguration $llamaCppConfiguration,
         private LlamaCppLinkBuilder $llamaCppLinkBuilder,
+        private LoggerInterface $logger,
     ) {}
 
     public function generateCompletion(LlamaCppCompletionRequest $request): LlamaCppCompletionIterator
@@ -167,31 +170,34 @@ readonly class LlamaCppClient
         SwooleCoroutineHelper::mustGo(function () use ($channel, $path, $requestData): void {
             $curlHandle = $this->createCurlHandle();
 
-            try {
-                curl_setopt($curlHandle, CURLOPT_POST, true);
-                curl_setopt($curlHandle, CURLOPT_POSTFIELDS, $requestData);
-                curl_setopt($curlHandle, CURLOPT_RETURNTRANSFER, false);
-                curl_setopt($curlHandle, CURLOPT_URL, $this->llamaCppLinkBuilder->build($path));
-                curl_setopt($curlHandle, CURLOPT_WRITEFUNCTION, function (CurlHandle $curlHandle, string $data) use ($channel): int {
-                    if ($channel->push($data, $this->llamaCppConfiguration->completionTokenTimeout)) {
-                        return strlen($data);
-                    }
-
-                    return 0;
-                });
-                if (false === curl_exec($curlHandle)) {
-                    $curlErrno = curl_errno($curlHandle);
-
-                    if (CURLE_WRITE_ERROR !== $curlErrno) {
-                        throw new CurlException($curlHandle);
-                    }
-                } else {
-                    $this->assertStatusCode($curlHandle, 200);
-                }
-            } finally {
+            Coroutine::defer(static function () use ($channel) {
+                $channel->close();
+            });
+
+            Coroutine::defer(static function () use ($curlHandle) {
                 curl_close($curlHandle);
+            });
+
+            curl_setopt($curlHandle, CURLOPT_TIMEOUT, 180);
+            curl_setopt($curlHandle, CURLOPT_POST, true);
+            curl_setopt($curlHandle, CURLOPT_POSTFIELDS, $requestData);
+            curl_setopt($curlHandle, CURLOPT_RETURNTRANSFER, false);
+            curl_setopt($curlHandle, CURLOPT_URL, $this->llamaCppLinkBuilder->build($path));
+            curl_setopt($curlHandle, CURLOPT_WRITEFUNCTION, function (CurlHandle $curlHandle, string $data) use ($channel): int {
+                if ($channel->push($data, $this->llamaCppConfiguration->completionTokenTimeout)) {
+                    return strlen($data);
+                }
 
-                $channel->close();
+                return 0;
+            });
+            if (false === curl_exec($curlHandle)) {
+                $curlErrno = curl_errno($curlHandle);
+
+                if (CURLE_WRITE_ERROR !== $curlErrno) {
+                    $this->logger->error(new CurlErrorMessage($curlHandle));
+                }
+            } else {
+                $this->assertStatusCode($curlHandle, 200);
             }
         });
 

src/ObservableTask.php

@@ -6,21 +6,32 @@ namespace Distantmagic\Resonance;
 
 use Closure;
 use Generator;
+use Throwable;
 
-/**
- * @template TTaskStatus of ObservableTaskStatusUpdate
- *
- * @template-implements ObservableTaskInterface<TTaskStatus>
- */
 readonly class ObservableTask implements ObservableTaskInterface
 {
     /**
-     * @param Closure():Generator<TTaskStatus> $iterableTask
+     * @var Closure():iterable<ObservableTaskStatusUpdate>
      */
-    public function __construct(private Closure $iterableTask) {}
+    private Closure $iterableTask;
+
+    /**
+     * @param callable():iterable<ObservableTaskStatusUpdate> $iterableTask
+     */
+    public function __construct(callable $iterableTask)
+    {
+        $this->iterableTask = Closure::fromCallable($iterableTask);
+    }
 
     public function getIterator(): Generator
     {
-        yield from ($this->iterableTask)();
+        try {
+            yield from ($this->iterableTask)();
+        } catch (Throwable $throwable) {
+            yield new ObservableTaskStatusUpdate(
+                ObservableTaskStatus::Failed,
+                $throwable,
+            );
+        }
     }
 }

src/ObservableTaskInterface.php

@@ -7,8 +7,6 @@ namespace Distantmagic\Resonance;
 use IteratorAggregate;
 
 /**
- * @template TTaskStatus of ObservableTaskStatusUpdate
- *
- * @template-extends IteratorAggregate<TTaskStatus>
+ * @template-extends IteratorAggregate<ObservableTaskStatusUpdate>
  */
 interface ObservableTaskInterface extends IteratorAggregate {}

src/ObservableTaskTable.php

@@ -8,6 +8,8 @@ use Distantmagic\Resonance\Attribute\Singleton;
 use Ds\Set;
 use Generator;
 use IteratorAggregate;
+use RuntimeException;
+use Swoole\Coroutine;
 use Swoole\Coroutine\Channel;
 use Swoole\Table;
 
@@ -41,11 +43,6 @@ readonly class ObservableTaskTable implements IteratorAggregate
         $this->table->create();
     }
 
-    public function __destruct()
-    {
-        $this->table->destroy();
-    }
-
     /**
      * @return Generator<non-empty-string,?ObservableTaskStatusUpdate>
      */
@@ -76,30 +73,37 @@ readonly class ObservableTaskTable implements IteratorAggregate
         $slotId = $this->availableRowsPool->nextAvailableRow();
 
         SwooleCoroutineHelper::mustGo(function () use ($slotId, $observableTask) {
-            try {
-                $this->table->set($slotId, [
+            Coroutine::defer(function () use ($slotId) {
+                $this->availableRowsPool->freeAvailableRow($slotId);
+            });
+
+            if (
+                !$this->table->set($slotId, [
                     'status' => $this->serializedPendingStatus,
-                ]);
+                ])
+            ) {
+                throw new RuntimeException('Unable to set an initial slot status');
+            }
 
-                foreach ($observableTask as $statusUpdate) {
-                    $this->table->set($slotId, [
+            foreach ($observableTask as $statusUpdate) {
+                if (!$this->table->set($slotId, [
                         'status' => $this->serializer->serialize($statusUpdate),
-                    ]);
+                    ])
+                ) {
+                    throw new RuntimeException('Unable to update a slot status.');
+                }
 
-                    if (!$this->observableChannels->isEmpty()) {
-                        $slotStatusUpdate = new ObservableTaskSlotStatusUpdate($slotId, $statusUpdate);
+                if (!$this->observableChannels->isEmpty()) {
+                    $slotStatusUpdate = new ObservableTaskSlotStatusUpdate($slotId, $statusUpdate);
 
-                        foreach ($this->observableChannels as $observableChannel) {
-                            $observableChannel->push($slotStatusUpdate);
-                        }
+                    foreach ($this->observableChannels as $observableChannel) {
+                        $observableChannel->push($slotStatusUpdate);
                     }
+                }
 
-                    if (ObservableTaskStatus::Running !== $statusUpdate->status) {
-                        break;
-                    }
+                if (ObservableTaskStatus::Running !== $statusUpdate->status) {
+                    break;
                 }
-            } finally {
-                $this->availableRowsPool->freeAvailableRow($slotId);
             }
         });
 

src/ObservableTaskTableSlotStatusUpdateIteratorTest.php

@@ -7,6 +7,7 @@ namespace Distantmagic\Resonance;
 use Distantmagic\Resonance\Serializer\Vanilla;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\TestCase;
+use Swoole\Coroutine;
 use Swoole\Coroutine\WaitGroup;
 use Swoole\Event;
 
@@ -59,23 +60,23 @@ final class ObservableTaskTableSlotStatusUpdateIteratorTest extends TestCase
             SwooleCoroutineHelper::mustGo(function () use ($wg) {
                 self::assertNotNull($this->observableTaskTable);
 
-                try {
-                    $iterator = new ObservableTaskTableSlotStatusUpdateIterator($this->observableTaskTable);
+                Coroutine::defer(static function () use ($wg) {
+                    $wg->done();
+                });
 
-                    foreach ($iterator as $statusUpdate) {
-                        self::assertInstanceOf(ObservableTaskSlotStatusUpdate::class, $statusUpdate);
-                        self::assertEquals('0', $statusUpdate->slotId);
+                $iterator = new ObservableTaskTableSlotStatusUpdateIterator($this->observableTaskTable);
 
-                        if (ObservableTaskStatus::Finished === $statusUpdate->observableTaskStatusUpdate->status) {
-                            self::assertEquals('test2', $statusUpdate->observableTaskStatusUpdate->data);
+                foreach ($iterator as $statusUpdate) {
+                    self::assertInstanceOf(ObservableTaskSlotStatusUpdate::class, $statusUpdate);
+                    self::assertEquals('0', $statusUpdate->slotId);
 
-                            break;
-                        }
+                    if (ObservableTaskStatus::Finished === $statusUpdate->observableTaskStatusUpdate->status) {
+                        self::assertEquals('test2', $statusUpdate->observableTaskStatusUpdate->data);
 
-                        self::assertEquals('test1', $statusUpdate->observableTaskStatusUpdate->data);
+                        break;
                     }
-                } finally {
-                    $wg->done();
+
+                    self::assertEquals('test1', $statusUpdate->observableTaskStatusUpdate->data);
                 }
             });
 

src/ObservableTaskTableTest.php

@@ -7,6 +7,7 @@ namespace Distantmagic\Resonance;
 use Distantmagic\Resonance\Serializer\Vanilla;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\TestCase;
+use Swoole\Coroutine;
 use Swoole\Coroutine\Channel;
 use Swoole\Coroutine\WaitGroup;
 use Swoole\Event;
@@ -61,19 +62,19 @@ final class ObservableTaskTableTest extends TestCase
             $wg->add();
 
             SwooleCoroutineHelper::mustGo(static function () use ($channel, $wg) {
-                try {
-                    $status1 = $channel->pop();
+                Coroutine::defer(static function () use ($wg) {
+                    $wg->done();
+                });
 
-                    self::assertInstanceOf(ObservableTaskSlotStatusUpdate::class, $status1);
-                    self::assertSame(ObservableTaskStatus::Running, $status1->observableTaskStatusUpdate->status);
+                $status1 = $channel->pop();
 
-                    $status2 = $channel->pop();
+                self::assertInstanceOf(ObservableTaskSlotStatusUpdate::class, $status1);
+                self::assertSame(ObservableTaskStatus::Running, $status1->observableTaskStatusUpdate->status);
 
-                    self::assertInstanceOf(ObservableTaskSlotStatusUpdate::class, $status2);
-                    self::assertSame(ObservableTaskStatus::Finished, $status2->observableTaskStatusUpdate->status);
-                } finally {
-                    $wg->done();
-                }
+                $status2 = $channel->pop();
+
+                self::assertInstanceOf(ObservableTaskSlotStatusUpdate::class, $status2);
+                self::assertSame(ObservableTaskStatus::Finished, $status2->observableTaskStatusUpdate->status);
             });
 
             $this->observableTaskTable?->observe($observableTask);

src/ObservableTaskTimeoutIterator.php

+<?php
+
+declare(strict_types=1);
+
+namespace Distantmagic\Resonance;
+
+use Closure;
+use Generator;
+use IteratorAggregate;
+use Swoole\Coroutine;
+use Swoole\Coroutine\Channel;
+
+/**
+ * @template-implements IteratorAggregate<ObservableTaskStatusUpdate>
+ */
+readonly class ObservableTaskTimeoutIterator implements IteratorAggregate
+{
+    /**
+     * @var Closure():Generator<ObservableTaskStatusUpdate>
+     */
+    private Closure $iterableTask;
+
+    /**
+     * @param callable():Generator<ObservableTaskStatusUpdate> $iterableTask
+     */
+    public function __construct(
+        callable $iterableTask,
+        private float $inactivityTimeout,
+    ) {
+        $this->iterableTask = Closure::fromCallable($iterableTask);
+    }
+
+    /**
+     * @return SwooleChannelIterator<ObservableTaskStatusUpdate>
+     */
+    public function __invoke(): SwooleChannelIterator
+    {
+        return $this->getIterator();
+    }
+
+    /**
+     * @psalm-suppress UnusedVariable $generatorCoroutineId is used, just asynchronously
+     *
+     * @return SwooleChannelIterator<ObservableTaskStatusUpdate>
+     */
+    public function getIterator(): SwooleChannelIterator
+    {
+        /**
+         * @var null|int $generatorCoroutineId
+         */
+        $generatorCoroutineId = null;
+
+        $channel = new Channel(1);
+
+        $swooleTimeout = new SwooleTimeout(static function () use (&$generatorCoroutineId) {
+            if (is_int($generatorCoroutineId)) {
+                Coroutine::cancel($generatorCoroutineId);
+            }
+        });
+
+        $generatorCoroutineId = SwooleCoroutineHelper::mustGo(function () use ($channel, $swooleTimeout) {
+            $swooleTimeoutScheduled = $swooleTimeout->setTimeout($this->inactivityTimeout);
+
+            Coroutine::defer(static function () use ($channel) {
+                $channel->close();
+            });
+
+            Coroutine::defer(static function () use (&$swooleTimeoutScheduled) {
+                $swooleTimeoutScheduled->cancel();
+            });
+
+            foreach (($this->iterableTask)() as $observableTaskStatusUpdate) {
+                if (Coroutine::isCanceled()) {
+                    break;
+                }
+
+                $swooleTimeoutScheduled = $swooleTimeoutScheduled->reschedule($this->inactivityTimeout);
+
+                $channel->push($observableTaskStatusUpdate, $this->inactivityTimeout);
+            }
+        });
+
+        /**
+         * @var SwooleChannelIterator<ObservableTaskStatusUpdate>
+         */
+        return new SwooleChannelIterator(
+            channel: $channel,
+            timeout: $this->inactivityTimeout,
+        );
+    }
+}

src/PDOPool.php

-<?php
-
-declare(strict_types=1);
-
-namespace Distantmagic\Resonance;
-
-use Ds\Set;
-use PDO;
-use Swoole\ConnectionPool;
-use Swoole\Database\PDOConfig;
-use Swoole\Database\PDOProxy;
-
-/**
- * @psalm-suppress PropertyNotSetInConstructor swoole internals
- */
-class PDOPool extends ConnectionPool
-{
-    /**
-     * @param Set<PDOPoolConnectionBuilderInterface> $connectionBuilders
-     */
-    public function __construct(
-        private Set $connectionBuilders,
-        private PDOConfig $config,
-        int $size,
-    ) {
-        parent::__construct(
-            $this->createConnection(...),
-            $size,
-            PDOProxy::class,
-        );
-    }
-
-    public function get(float $timeout = -1): PDOProxy
-    {
-        /**
-         * @var PDOProxy $pdo
-         */
-        $pdo = parent::get($timeout);
-        $pdo->reset();
-
-        return $pdo;
-    }
-
-    private function createConnection(): PDO
-    {
-        $pdo = $this->createPDO();
-
-        foreach ($this->connectionBuilders as $connectionBuilder) {
-            $pdo = $connectionBuilder->buildPDOConnection($pdo);
-        }
-
-        return $pdo;
-    }
-
-    private function createDSN(string $driver): string
-    {
-        return match ($driver) {
-            'mariadb', 'mysql' => $this->config->hasUnixSocket()
-                ? sprintf(
-                    'mysql:unix_socket=%s;dbname=%s;charset=%s',
-                    (string) $this->config->getUnixSocket(),
-                    $this->config->getDbname(),
-                    $this->config->getCharset()
-                )
-                : sprintf(
-                    'mysql:host=%s;port=%d;dbname=%s;charset=%s',
-                    $this->config->getHost(),
-                    $this->config->getPort(),
-                    $this->config->getDbname(),
-                    $this->config->getCharset()
-                ),
-            'pgsql' => sprintf(
-                'pgsql:host=%s;port=%s;dbname=%s',
-                (string) ($this->config->hasUnixSocket() ? $this->config->getUnixSocket() : $this->config->getHost()),
-                $this->config->getPort(),
-                $this->config->getDbname(),
-            ),
-            'oci' => sprintf(
-                'oci:dbname=%s:%d/%s;charset=%s',
-                (string) ($this->config->hasUnixSocket() ? $this->config->getUnixSocket() : $this->config->getHost()),
-                $this->config->getPort(),
-                $this->config->getDbname(),
-                $this->config->getCharset()
-            ),
-        };
-    }
-
-    private function createPDO(): PDO
-    {
-        $driver = $this->config->getDriver();
-
-        if ('sqlite' !== $driver) {
-            return new PDO(
-                $this->createDSN($driver),
-                $this->config->getUsername(),
-                $this->config->getPassword(),
-                $this->config->getOptions()
-            );
-        }
-
-        return new PDO(sprintf(
-            'sqlite:%s',
-            $this->config->getDbname()
-        ));
-    }
-}

src/PDOPoolConnectionBuilder.php

-<?php
-
-declare(strict_types=1);
-
-namespace Distantmagic\Resonance;
-
-abstract readonly class PDOPoolConnectionBuilder implements PDOPoolConnectionBuilderInterface {}

src/PDOPoolConnectionBuilderCollection.php

-<?php
-
-declare(strict_types=1);
-
-namespace Distantmagic\Resonance;
-
-use Ds\Map;
-use Ds\Set;
-
-readonly class PDOPoolConnectionBuilderCollection
-{
-    /**
-     * @var Map<non-empty-string,Set<PDOPoolConnectionBuilderInterface>>
-     */
-    private Map $connectionBuilders;
-
-    public function __construct()
-    {
-        $this->connectionBuilders = new Map();
-    }
-
-    /**
-     * @param non-empty-string $name
-     */
-    public function addBuilder(
-        string $name,
-        PDOPoolConnectionBuilderInterface $pdoPoolConnectionBuilder,
-    ): void {
-        $this->getBuildersForConnection($name)->add($pdoPoolConnectionBuilder);
-    }
-
-    /**
-     * @param non-empty-string $name
-     *
-     * @return Set<PDOPoolConnectionBuilderInterface>
-     */
-    public function getBuildersForConnection(string $name): Set
-    {
-        if (!$this->connectionBuilders->hasKey($name)) {
-            $this->connectionBuilders->put($name, new Set());
-        }
-
-        return $this->connectionBuilders->get($name);
-    }
-}

src/PDOPoolConnectionBuilderInterface.php

-<?php
-
-declare(strict_types=1);
-
-namespace Distantmagic\Resonance;
-
-use PDO;
-
-interface PDOPoolConnectionBuilderInterface
-{
-    public function buildPDOConnection(PDO $pdo): PDO;
-}

src/SingletonProvider/DatabaseConnectionPoolRepositoryProvider.php

@@ -8,12 +8,11 @@ use Distantmagic\Resonance\Attribute\RequiresPhpExtension;
 use Distantmagic\Resonance\Attribute\Singleton;
 use Distantmagic\Resonance\DatabaseConfiguration;
 use Distantmagic\Resonance\DatabaseConnectionPoolRepository;
-use Distantmagic\Resonance\PDOPool;
-use Distantmagic\Resonance\PDOPoolConnectionBuilderCollection;
 use Distantmagic\Resonance\PHPProjectFiles;
 use Distantmagic\Resonance\SingletonContainer;
 use Distantmagic\Resonance\SingletonProvider;
 use Swoole\Database\PDOConfig;
+use Swoole\Database\PDOPool;
 
 /**
  * @template-extends SingletonProvider<DatabaseConnectionPoolRepository>
@@ -24,7 +23,6 @@ final readonly class DatabaseConnectionPoolRepositoryProvider extends SingletonP
 {
     public function __construct(
         private DatabaseConfiguration $databaseConfiguration,
-        private PDOPoolConnectionBuilderCollection $pdoPoolConnectionBuilderCollection,
     ) {}
 
     public function provide(SingletonContainer $singletons, PHPProjectFiles $phpProjectFiles): DatabaseConnectionPoolRepository
@@ -53,7 +51,6 @@ final readonly class DatabaseConnectionPoolRepositoryProvider extends SingletonP
             }
 
             $pdoPool = new PDOPool(
-                $this->pdoPoolConnectionBuilderCollection->getBuildersForConnection($name),
                 $pdoConfig,
                 $connectionPoolConfiguration->poolSize,
             );

src/SingletonProvider/PDOPoolConnectionBuilderCollectionProvider.php

-<?php
-
-declare(strict_types=1);
-
-namespace Distantmagic\Resonance\SingletonProvider;
-
-use Distantmagic\Resonance\Attribute\BuildsPDOPoolConnection;
-use Distantmagic\Resonance\Attribute\RequiresPhpExtension;
-use Distantmagic\Resonance\Attribute\RequiresSingletonCollection;
-use Distantmagic\Resonance\Attribute\Singleton;
-use Distantmagic\Resonance\HttpResponderCollection;
-use Distantmagic\Resonance\PDOPoolConnectionBuilderCollection;
-use Distantmagic\Resonance\PDOPoolConnectionBuilderInterface;
-use Distantmagic\Resonance\PHPProjectFiles;
-use Distantmagic\Resonance\SingletonAttribute;
-use Distantmagic\Resonance\SingletonCollection;
-use Distantmagic\Resonance\SingletonContainer;
-use Distantmagic\Resonance\SingletonProvider;
-
-/**
- * @template-extends SingletonProvider<HttpResponderCollection>
- */
-#[RequiresPhpExtension('pdo')]
-#[RequiresSingletonCollection(SingletonCollection::PDOPoolConnectionBuilder)]
-#[Singleton(provides: PDOPoolConnectionBuilderCollection::class)]
-final readonly class PDOPoolConnectionBuilderCollectionProvider extends SingletonProvider
-{
-    public function provide(SingletonContainer $singletons, PHPProjectFiles $phpProjectFiles): PDOPoolConnectionBuilderCollection
-    {
-        $pdoPoolConnectionBuilderCollection = new PDOPoolConnectionBuilderCollection();
-
-        foreach ($this->collectBuilders($singletons) as $builderAttribute) {
-            $pdoPoolConnectionBuilderCollection->addBuilder(
-                $builderAttribute->attribute->name,
-                $builderAttribute->singleton
-            );
-        }
-
-        return $pdoPoolConnectionBuilderCollection;
-    }
-
-    /**
-     * @return iterable<SingletonAttribute<PDOPoolConnectionBuilderInterface,BuildsPDOPoolConnection>>
-     */
-    private function collectBuilders(SingletonContainer $singletons): iterable
-    {
-        return $this->collectAttributes(
-            $singletons,
-            PDOPoolConnectionBuilderInterface::class,
-            BuildsPDOPoolConnection::class,
-        );
-    }
-}