fixes #24 (#25)

* added ssl context options

Author: transistive

src/Databags/StatementStatistics.php

@@ -13,11 +13,17 @@
 
 namespace Laudis\Neo4j\Databags;
 
+use ArrayIterator;
+use IteratorAggregate;
+
 /**
  * @psalm-immutable
- * @codeCoverageIgnore Not used yet
+ *
+ * @implements IteratorAggregate<string, int|bool>
+ *
+ * @codeCoverageIgnore
  */
-final class StatementStatistics
+final class StatementStatistics implements IteratorAggregate
 {
     private int $nodesCreated;
 
@@ -149,7 +155,7 @@ public function systemUpdates(): int
         return $this->systemUpdates;
     }
 
-    public function mergeStats(StatementStatistics $resultStats): StatementStatistics
+    public function merge(StatementStatistics $resultStats): StatementStatistics
     {
         return new StatementStatistics(
             $this->nodesCreated + $resultStats->nodesCreated,
@@ -168,4 +174,24 @@ public function mergeStats(StatementStatistics $resultStats): StatementStatistic
             $this->systemUpdates + $resultStats->systemUpdates
         );
     }
+
+    public function getIterator(): ArrayIterator
+    {
+        return new ArrayIterator([
+            'nodesCreated' => $this->nodesCreated,
+            'nodesDeleted' => $this->nodesDeleted,
+            'relationshipsCreated' => $this->relationshipsCreated,
+            'relationshipsDeleted' => $this->relationshipsDeleted,
+            'propertiesSet' => $this->propertiesSet,
+            'labelsAdded' => $this->labelsAdded,
+            'labelsRemoved' => $this->labelsRemoved,
+            'indexesAdded' => $this->indexesAdded,
+            'indexesRemoved' => $this->indexesRemoved,
+            'constraintsAdded' => $this->constraintsAdded,
+            'constraintsRemoved' => $this->constraintsRemoved,
+            'containsUpdates' => $this->containsUpdates,
+            'containsSystemUpdates' => $this->containsSystemUpdates,
+            'systemUpdates' => $this->systemUpdates,
+        ]);
+    }
 }

src/Network/Bolt/BoltDriver.php

@@ -65,11 +65,16 @@ public function aquireSession(): SessionInterface
         $this->parsedUrl['host'] = $ip;
         try {
             $sock = new StreamSocket($this->parsedUrl['host'], $this->parsedUrl['port'] ?? self::DEFAULT_TCP_PORT);
+            $options = $this->injections->sslContextOptions();
+            if ($options) {
+                $sock->setSslContextOptions($options);
+            }
             $bolt = new Bolt($sock);
             $bolt->init('LaudisNeo4j/'.ClientInterface::VERSION, $this->parsedUrl['user'], $this->parsedUrl['pass']);
         } catch (Exception $e) {
             throw new Neo4jException(new Vector([new Neo4jError($e->getMessage(), '')]), $e);
         }
+
         $this->session = new BoltSession($this->parsedUrl, $bolt, new BoltCypherFormatter(), $this->injections);
 
         return $this->session;

src/Network/Bolt/BoltInjections.php

@@ -13,24 +13,56 @@
 
 namespace Laudis\Neo4j\Network\Bolt;
 
+/**
+ * @psalm-type SSLContextOptions = null|array{
+ *     peer_name?: string,
+ *     verify_peer?: bool,
+ *     verify_peer_name?: bool,
+ *     allow_self_signed?: bool,
+ *     cafile?: string,
+ *     capath?: string,
+ *     local_cert?: string,
+ *     local_pk?: string,
+ *     passphrase?: string,
+ *     verify_depth?: int,
+ *     ciphers?: string,
+ *     capture_peer_cert?: bool,
+ *     capture_peer_cert_chain?: bool,
+ *     SNI_enabled?: bool,
+ *     disable_compression?: bool,
+ *     peer_fingerprint?: string|array,
+ *     security_level?: int
+ * }
+ *
+ * @psalm-type LazySSLContextOptions = callable():SSLContextOptions|SSLContextOptions
+ */
 final class BoltInjections
 {
     /** @var callable():string|string */
     private $database;
+    /** @var LazySSLContextOptions */
+    private $sslContextOptions;
 
     /**
-     * BoltInjections constructor.
-     *
-     * @param callable():string|string|null $database
+     * @param callable():string|?string $database
+     * @param LazySSLContextOptions     $sslContextOptions
      */
-    public function __construct($database = null)
+    public function __construct($database = null, $sslContextOptions = null)
     {
         $this->database = $database ?? static function (): string { return 'neo4j'; };
+        $this->sslContextOptions = $sslContextOptions;
     }
 
-    public static function create(?string $database = null): self
+    /**
+     * @param SSLContextOptions|null $sslContextOptions
+     *
+     * @see https://www.php.net/manual/en/context.ssl.php for ssl connections
+     *
+     * @return static
+     */
+    public static function create(?string $database = null, ?array $sslContextOptions = null): self
     {
-        return new self($database);
+        return new self($database, $sslContextOptions);
     }
 
     /**
@@ -41,6 +73,14 @@ public function withDatabase($database): self
         return new self($database);
     }
 
+    /**
+     * @param LazySSLContextOptions $options
+     */
+    public function withSslContextOptions($options): self
+    {
+        return new self($this->database, $options);
+    }
+
     public function database(): string
     {
         if (is_callable($this->database)) {
@@ -49,4 +89,17 @@ public function database(): string
 
         return $this->database;
     }
+
+    /**
+     * @return SSLContextOptions
+     */
+    public function sslContextOptions(): ?array
+    {
+        if (is_callable($this->sslContextOptions)) {
+            /** @psalm-suppress PossiblyInvalidFunctionCall */
+            $this->sslContextOptions = call_user_func($this->sslContextOptions);
+        }
+
+        return $this->sslContextOptions;
+    }
 }

tests/Unit/BoltInjectionsTest.php

@@ -31,4 +31,17 @@ public function testWithDatabase(): void
         $injections = new BoltInjections('abc');
         self::assertEquals('test', $injections->withDatabase('test')->database());
     }
+
+    public function testWithSslContext(): void
+    {
+        $injections = new BoltInjections('abc', ['passphrase' => 'test']);
+        self::assertEquals(['passphrase' => 'test'], $injections->sslContextOptions());
+        self::assertNull(BoltInjections::create()->sslContextOptions());
+
+        self::assertEquals(['passphrase' => 'x'], $injections->withSslContextOptions(['passphrase' => 'x'])->sslContextOptions());
+        self::assertEquals(
+            ['passphrase' => 'y'],
+            $injections->withSslContextOptions(static fn () => ['passphrase' => 'y'])->sslContextOptions()
+        );
+    }
 }