rewired the conneciton logic

Author: transistive

src/Bolt/BoltConnection.php

@@ -28,12 +28,11 @@
 use Laudis\Neo4j\Enum\ConnectionProtocol;
 use Laudis\Neo4j\Types\CypherList;
 use Psr\Http\Message\UriInterface;
-use RuntimeException;
 use function str_starts_with;
 use WeakReference;
 
 /**
- * @implements ConnectionInterface<array{0: V3, 1: IConnection}>
+ * @implements ConnectionInterface<array{0: V3, 1: Connection}>
  *
  * @psalm-import-type BoltMeta from FormatterInterface
  */
@@ -59,44 +58,30 @@ final class BoltConnection implements ConnectionInterface
      */
     private array $subscribedResults = [];
     private AuthenticateInterface $auth;
-    private IConnection $connection;
-    private string $encryptionLevel;
+    private Connection $connection;
     private string $userAgent;
 
+    public function getImplementation()
+    {
+        return [$this->boltProtocol, $this->connection];
+    }
+
     /**
      * @psalm-mutation-free
      */
-    public function __construct(V3 $protocol, IConnection $connection, ConnectionConfiguration $config, AuthenticateInterface $auth, string $encryptionLevel, string $userAgent)
+    public function __construct(V3 $protocol, Connection $connection, AuthenticateInterface $auth, string $userAgent, ConnectionConfiguration $config)
     {
         $this->boltProtocol = $protocol;
-        $this->config = $config;
         $this->serverState = 'READY';
         $this->auth = $auth;
         $this->connection = $connection;
-        $this->encryptionLevel = $encryptionLevel;
         $this->userAgent = $userAgent;
+        $this->config = $config;
     }
 
-    /**
-     * @psalm-mutation-free
-     *
-     * @return array{0: V3, 1: IConnection}
-     */
-    public function getImplementation(): array
-    {
-        if (!$this->isOpen()) {
-            throw new RuntimeException('Connection is closed');
-        }
-
-        return [$this->boltProtocol, $this->connection];
-    }
-
-    /**
-     * Encryption level can be either '', 's' or 'ssc', which stand for 'no encryption', 'full encryption' and 'self-signed encryption' respectively.
-     */
     public function getEncryptionLevel(): string
     {
-        return $this->encryptionLevel;
+        return $this->connection->getEncryptionLevel();
     }
 
     /**
@@ -338,7 +323,7 @@ public function rollback(): void
 
     public function protocol(): V3
     {
-        return $this->getImplementation()[0];
+        return $this->boltProtocol;
     }
 
     /**

src/Bolt/Connection.php

@@ -14,15 +14,16 @@
 namespace Laudis\Neo4j\Bolt;
 
 use Bolt\connection\IConnection;
+use Bolt\protocol\AProtocol;
 
 class Connection
 {
     private IConnection $connection;
-    /** ''|'s'|'ssc' */
+    /** @var ''|'s'|'ssc' */
     private string $ssl;
+    private ?AProtocol $protocol = null;
 
     /**
-     * @param IConnection $connection
      * @param ''|'s'|'ssc' $ssl
      */
     public function __construct(IConnection $connection, string $ssl)
@@ -31,9 +32,9 @@ public function __construct(IConnection $connection, string $ssl)
         $this->ssl = $ssl;
     }
 
-    public function connect(): bool
+    public function getIConnection(): IConnection
     {
-        return $this->connection->connect();
+        return $this->connection;
     }
 
     public function write(string $buffer): void

src/Bolt/ConnectionPool.php

@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /*
  * This file is part of the Neo4j PHP Client and Driver package.
  *
@@ -17,8 +19,11 @@
 use Laudis\Neo4j\Contracts\ConnectionInterface;
 use Laudis\Neo4j\Contracts\ConnectionPoolInterface;
 use Laudis\Neo4j\Contracts\SemaphoreInterface;
+use Laudis\Neo4j\Databags\ConnectionRequestData;
 use Laudis\Neo4j\Databags\SessionConfiguration;
 use Laudis\Neo4j\Databags\SslConfiguration;
+use Psr\Http\Message\UriInterface;
+
 use function method_exists;
 use function microtime;
 use function shuffle;
@@ -27,28 +32,24 @@
  * @template T
  * @implements ConnectionPoolInterface<T>
  */
-class ConnectionPool implements ConnectionPoolInterface
+final class ConnectionPool implements ConnectionPoolInterface
 {
     private SemaphoreInterface $semaphore;
 
     /** @var list<ConnectionInterface<T>> */
     private array $activeConnections = [];
-    private AuthenticateInterface $auth;
     /** @var ConnectionFactoryInterface<T> */
     private ConnectionFactoryInterface $factory;
-    private string $userAgent;
-    private SslConfiguration $sslConfiguration;
+    private ConnectionRequestData $data;
 
     /**
      * @param ConnectionFactoryInterface<T> $factory
      */
-    public function __construct(AuthenticateInterface $auth, string $userAgent, SslConfiguration $sslConfiguration, SemaphoreInterface $semaphore, ConnectionFactoryInterface $factory)
+    public function __construct(SemaphoreInterface $semaphore, ConnectionFactoryInterface $factory, ConnectionRequestData $data)
     {
         $this->semaphore = $semaphore;
-        $this->auth = $auth;
         $this->factory = $factory;
-        $this->userAgent = $userAgent;
-        $this->sslConfiguration = $sslConfiguration;
+        $this->data = $data;
     }
 
     public function acquire(SessionConfiguration $config): Generator
@@ -72,7 +73,7 @@ public function acquire(SessionConfiguration $config): Generator
         }
 
         return $this->returnAnyAvailableConnection($config) ??
-               $this->factory->createConnection($this->userAgent, $this->sslConfiguration, $config, $this->auth);
+               $this->factory->createConnection($this->data, $config);
     }
 
     public function release(ConnectionInterface $connection): void
@@ -101,7 +102,7 @@ private function returnAnyAvailableConnection(SessionConfiguration $config): ?Co
         foreach ($this->activeConnections as $activeConnection) {
             // We prefer a connection that is just ready
             if ($activeConnection->getServerState() === 'READY') {
-                if ($this->factory->canReuseConnection($activeConnection, $this->userAgent, $this->sslConfiguration, $this->auth)) {
+                if ($this->factory->canReuseConnection($activeConnection, $this->data)) {
                     return $this->factory->reuseConnection($activeConnection, $config);
                 } else {
                     $requiresReconnectConnection = $activeConnection;
@@ -116,7 +117,7 @@ private function returnAnyAvailableConnection(SessionConfiguration $config): ?Co
             // https://github.com/neo4j-php/neo4j-php-client/issues/146
             // NOTE: we cannot work with TX_STREAMING as we cannot force the transaction to implicitly close.
             if ($streamingConnection === null && $activeConnection->getServerState() === 'STREAMING') {
-                if ($this->factory->canReuseConnection($activeConnection, $this->userAgent, $this->sslConfiguration, $this->auth)) {
+                if ($this->factory->canReuseConnection($activeConnection, $this->data)) {
                     $streamingConnection = $activeConnection;
                     if (method_exists($streamingConnection, 'consumeResults')) {
                         $streamingConnection->consumeResults(); // State should now be ready
@@ -134,7 +135,7 @@ private function returnAnyAvailableConnection(SessionConfiguration $config): ?Co
         if ($requiresReconnectConnection) {
             $this->release($requiresReconnectConnection);
 
-            return $this->factory->createConnection($this->userAgent, $this->sslConfiguration, $config, $this->auth);
+            return $this->factory->createConnection($this->data, $config);
         }
 
         return null;

src/Bolt/UriConfiguration.php

@@ -7,12 +7,12 @@
 final class UriConfiguration
 {
     private string $host;
-    private int $port;
+    private ?int $port;
     private string $sslLevel;
     private array $sslConfiguration;
-    private int $timeout;
+    private ?float $timeout;
 
-    public function __construct(string $host, int $port, string $sslLevel, array $sslConfiguration, int $timeout)
+    public function __construct(string $host, ?int $port, string $sslLevel, array $sslConfiguration, ?float $timeout)
     {
         $this->host = $host;
         $this->port = $port;
@@ -21,42 +21,30 @@ public function __construct(string $host, int $port, string $sslLevel, array $ss
         $this->timeout = $timeout;
     }
 
-    /**
-     * @return string
-     */
     public function getHost(): string
     {
         return $this->host;
     }
 
-    /**
-     * @return int
-     */
-    public function getPort(): int
+    public function getPort(): ?int
     {
         return $this->port;
     }
 
     /**
-     * @return string
+     * @return 's'|'ssc'|''
      */
     public function getSslLevel(): string
     {
         return $this->sslLevel;
     }
 
-    /**
-     * @return array
-     */
     public function getSslConfiguration(): array
     {
         return $this->sslConfiguration;
     }
 
-    /**
-     * @return int
-     */
-    public function getTimeout(): int
+    public function getTimeout(): ?float
     {
         return $this->timeout;
     }