fixed static analysis Neo4j namespace

Author: transistive

composer.json

@@ -49,7 +49,7 @@
         "nyholm/psr7": "^1.3",
         "nyholm/psr7-server": "^1.0",
         "kriswallsmith/buzz": "^1.2",
-        "vimeo/psalm": "4.26.0",
+        "vimeo/psalm": "^4.27",
         "friendsofphp/php-cs-fixer": "3.8.0",
         "psalm/plugin-phpunit": "^0.15.1",
         "monolog/monolog": "^2.2",

src/Basic/Driver.php

@@ -56,7 +56,6 @@ public function verifyConnectivity(): bool
 
     /**
      * @param string|UriInterface $uri
-     * @pure
      */
     public static function create($uri, ?DriverConfiguration $configuration = null, ?AuthenticateInterface $authenticate = null): self
     {

src/Bolt/BoltDriver.php

@@ -14,11 +14,10 @@
 namespace Laudis\Neo4j\Bolt;
 
 use Exception;
-use function extension_loaded;
 use function is_string;
 use Laudis\Neo4j\Authentication\Authenticate;
-use Laudis\Neo4j\Common\SingleThreadedSemaphore;
-use Laudis\Neo4j\Common\SysVSemaphore;
+use Laudis\Neo4j\BoltFactory;
+use Laudis\Neo4j\Common\SemaphoreFactory;
 use Laudis\Neo4j\Common\Uri;
 use Laudis\Neo4j\Contracts\AuthenticateInterface;
 use Laudis\Neo4j\Contracts\DriverInterface;
@@ -81,46 +80,11 @@ public static function create($uri, ?DriverConfiguration $configuration = null,
 
         $configuration ??= DriverConfiguration::default();
         $authenticate ??= Authenticate::fromUrl($uri);
-        $sslFactory = new SslConfigurationFactory();
-
-        // Because interprocess switching of connections between PHP sessions is impossible,
-        // we have to build a key to limit the amount of open connections, potentially between ALL sessions.
-        // because of this we have to settle on a configuration basis to limit the connection pool,
-        // not on an object basis.
-        // The combination is between the server and the user agent as it most closely resembles an "application"
-        // connecting to a server. The application thus supports multiple authentication methods, but they have
-        // to be shared between the same connection pool.
-        $key = $uri->getHost().':'.($uri->getPort() ?? '').':'.$configuration->getUserAgent();
-
-        if (extension_loaded('ext-sysvsem')) {
-            $semaphore = SysVSemaphore::create($key, $configuration->getMaxPoolSize());
-        } else {
-            $semaphore = SingleThreadedSemaphore::create($key, $configuration->getMaxPoolSize());
-        }
-
-        $pool = new ConnectionPool(
-            $semaphore,
-            SystemWideConnectionFactory::getInstance(),
-            new ConnectionRequestData(
-                $uri,
-                $authenticate,
-                $configuration->getUserAgent(),
-                $sslFactory->create($uri, $configuration->getSslConfiguration())
-            )
-        );
-
-        if ($formatter !== null) {
-            return new self(
-                $uri,
-                $pool,
-                $formatter
-            );
-        }
 
         return new self(
             $uri,
-            $pool,
-            OGMFormatter::create(),
+            ConnectionPool::create($uri, $authenticate, $configuration),
+            $formatter ?? OGMFormatter::create(),
         );
     }
 

src/Bolt/ConnectionPool.php

@@ -14,40 +14,54 @@
 namespace Laudis\Neo4j\Bolt;
 
 use Generator;
-use Laudis\Neo4j\Contracts\ConnectionFactoryInterface;
+use Laudis\Neo4j\BoltFactory;
+use Laudis\Neo4j\Common\SemaphoreFactory;
+use Laudis\Neo4j\Contracts\AuthenticateInterface;
 use Laudis\Neo4j\Contracts\ConnectionInterface;
 use Laudis\Neo4j\Contracts\ConnectionPoolInterface;
 use Laudis\Neo4j\Contracts\SemaphoreInterface;
 use Laudis\Neo4j\Databags\ConnectionRequestData;
+use Laudis\Neo4j\Databags\DriverConfiguration;
 use Laudis\Neo4j\Databags\SessionConfiguration;
-use Bolt\protocol\V3;
-use Laudis\Neo4j\Bolt\Connection;
 use function method_exists;
 use function microtime;
+use Psr\Http\Message\UriInterface;
 use function shuffle;
 
 /**
- * @implements ConnectionPoolInterface<array{0: V3, 1: Connection}>
+ * @implements ConnectionPoolInterface<BoltConnection>
  */
 final class ConnectionPool implements ConnectionPoolInterface
 {
     private SemaphoreInterface $semaphore;
-    /** @var list<ConnectionInterface<array{0: V3, 1: Connection}>> */
+    /** @var list<BoltConnection> */
     private array $activeConnections = [];
-    /** @var ConnectionFactoryInterface<array{0: V3, 1: Connection}> */
-    private ConnectionFactoryInterface $factory;
+    private BoltFactory $factory;
     private ConnectionRequestData $data;
 
-    /**
-     * @param ConnectionFactoryInterface<array{0: V3, 1: Connection}> $factory
-     */
-    public function __construct(SemaphoreInterface $semaphore, ConnectionFactoryInterface $factory, ConnectionRequestData $data)
+    public function __construct(SemaphoreInterface $semaphore, BoltFactory $factory, ConnectionRequestData $data)
     {
         $this->semaphore = $semaphore;
         $this->factory = $factory;
         $this->data = $data;
     }
 
+    public static function create(UriInterface $uri, AuthenticateInterface $auth, DriverConfiguration $conf): self
+    {
+        $semaphore = SemaphoreFactory::getInstance()->create($uri, $conf);
+
+        return new self(
+            $semaphore,
+            BoltFactory::create(),
+            new ConnectionRequestData(
+                $uri,
+                $auth,
+                $conf->getUserAgent(),
+                $conf->getSslConfiguration()
+            )
+        );
+    }
+
     public function acquire(SessionConfiguration $config): Generator
     {
         $generator = $this->semaphore->wait();
@@ -96,7 +110,7 @@ public function release(ConnectionInterface $connection): void
     }
 
     /**
-     * @return ConnectionInterface<array{0: V3, 1: Connection}>|null
+     * @return BoltConnection|null
      */
     private function returnAnyAvailableConnection(SessionConfiguration $config): ?ConnectionInterface
     {

src/Bolt/Session.php

@@ -15,8 +15,8 @@
 
 use Bolt\error\MessageException;
 use Exception;
+use Laudis\Neo4j\Common\GeneratorHelper;
 use Laudis\Neo4j\Common\TransactionHelper;
-use Laudis\Neo4j\Contracts\AuthenticateInterface;
 use Laudis\Neo4j\Contracts\ConnectionPoolInterface;
 use Laudis\Neo4j\Contracts\FormatterInterface;
 use Laudis\Neo4j\Contracts\SessionInterface;
@@ -31,7 +31,6 @@
 use Laudis\Neo4j\Exception\Neo4jException;
 use Laudis\Neo4j\Neo4j\Neo4jConnectionPool;
 use Laudis\Neo4j\Types\CypherList;
-use Psr\Http\Message\UriInterface;
 
 /**
  * A session using bolt connections.
@@ -156,13 +155,15 @@ private function beginInstantTransaction(
     private function acquireConnection(TransactionConfiguration $config, SessionConfiguration $sessionConfig): BoltConnection
     {
         $connection = $this->pool->acquire($sessionConfig);
+        /** @var BoltConnection $connection */
+        $connection = GeneratorHelper::getReturnFromGenerator($connection);
 
         // We try and let the server do the timeout management.
-        // Since the client should not run indefinitely, we just multiply the client side by two, just in case
+        // Since the client should not run indefinitely, we just add the client side by two, just in case
         $timeout = $config->getTimeout();
         if ($timeout) {
             $timeout = ($timeout < 30) ? 30 : $timeout;
-            $connection->setTimeout($timeout * 2);
+            $connection->setTimeout($timeout + 2);
         }
 
         return $connection;

src/Bolt/SystemWideConnectionFactory.php

@@ -14,11 +14,12 @@
 namespace Laudis\Neo4j\Bolt;
 
 use function extension_loaded;
+use Laudis\Neo4j\Contracts\BasicConnectionFactoryInterface;
 
 /**
  * Singleton connection factory based on the installed extensions.
  */
-class SystemWideConnectionFactory
+class SystemWideConnectionFactory implements BasicConnectionFactoryInterface
 {
     /**
      * @var SocketConnectionFactory|StreamConnectionFactory

src/Bolt/UriConfiguration.php

@@ -23,11 +23,7 @@ final class UriConfiguration
     private ?float $timeout;
 
     /**
-     * @param string $host
-     * @param int|null $port
      * @param ''|'s'|'ssc' $sslLevel
-     * @param array $sslConfiguration
-     * @param float|null $timeout
      */
     public function __construct(string $host, ?int $port, string $sslLevel, array $sslConfiguration, ?float $timeout)
     {

src/BoltFactory.php

@@ -14,16 +14,14 @@
 namespace Laudis\Neo4j;
 
 use Bolt\Bolt;
-use Bolt\protocol\V3;
+use Laudis\Neo4j\Bolt\SystemWideConnectionFactory;
 use function explode;
 use Laudis\Neo4j\Bolt\BoltConnection;
-use Laudis\Neo4j\Bolt\Connection;
 use Laudis\Neo4j\Bolt\ProtocolFactory;
 use Laudis\Neo4j\Bolt\SslConfigurationFactory;
 use Laudis\Neo4j\Bolt\UriConfiguration;
 use Laudis\Neo4j\Common\ConnectionConfiguration;
 use Laudis\Neo4j\Contracts\BasicConnectionFactoryInterface;
-use Laudis\Neo4j\Contracts\ConnectionFactoryInterface;
 use Laudis\Neo4j\Contracts\ConnectionInterface;
 use Laudis\Neo4j\Databags\ConnectionRequestData;
 use Laudis\Neo4j\Databags\DatabaseInfo;
@@ -33,10 +31,8 @@
 
 /**
  * Small wrapper around the bolt library to easily guarantee only bolt version 3 and up will be created and authenticated.
- *
- * @implements ConnectionFactoryInterface<array{0: V3, 1: Connection}>
  */
-final class BoltFactory implements ConnectionFactoryInterface
+final class BoltFactory
 {
     private BasicConnectionFactoryInterface $connectionFactory;
     private ProtocolFactory $protocolFactory;
@@ -52,7 +48,12 @@ public function __construct(BasicConnectionFactoryInterface $connectionFactory,
         $this->sslConfigurationFactory = $sslConfigurationFactory;
     }
 
-    public function createConnection(ConnectionRequestData $data, SessionConfiguration $sessionConfig): ConnectionInterface
+    public static function create(): self
+    {
+        return new self(SystemWideConnectionFactory::getInstance(), new ProtocolFactory(), new SslConfigurationFactory());
+    }
+
+    public function createConnection(ConnectionRequestData $data, SessionConfiguration $sessionConfig): BoltConnection
     {
         [$sslLevel, $sslConfig] = $this->sslConfigurationFactory->create($data->getUri(), $data->getSslConfig());
 
@@ -89,7 +90,7 @@ public function canReuseConnection(ConnectionInterface $connection, ConnectionRe
                $connection->getUserAgent() === $data->getUserAgent();
     }
 
-    public function reuseConnection(ConnectionInterface $connection, SessionConfiguration $sessionConfig): ConnectionInterface
+    public function reuseConnection(BoltConnection $connection, SessionConfiguration $sessionConfig): BoltConnection
     {
         [$protocol, $connectionImpl] = $connection->getImplementation();
 

src/Client.php

@@ -143,8 +143,6 @@ private function decideAlias(?string $alias): string
     }
 
     /**
-     * @psalm-mutation-free
-     *
      * @param array<string, DriverSetup>       $driverSetups
      * @param FormatterInterface<ResultFormat> $formatter
      *

src/Common/Cache.php

@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /*
  * This file is part of the Neo4j PHP Client and Driver package.
  *