used transition states

Author: transistive

src/Bolt/ServerStateRepository.php

@@ -13,24 +13,17 @@
 
 namespace Laudis\Neo4j\Bolt;
 
+use function array_filter;
+use function array_map;
 use function in_array;
 
 /**
  * @see https://7687.org/bolt/bolt-protocol-server-state-specification-4.html#version-43
+ *
+ * @psalm-immutable
  */
 final class ServerStateRepository
 {
-    private const KEYS = ['State' => 0, 'Request Message' => 1, 'Triggers Signal' => 2, 'Server Response' => 3, 'New State' => 4];
-    public function canSendMessage(string $state, string $message): bool
-    {
-        return in_array($message, $this->getMessagesForState($state), true);
-    }
-
-    public function isValidState(string $state): bool
-    {
-        return in_array($state, $this->getStates(), true);
-    }
-
     private const TRANSITIONS = [
         ['CONNECTED', 'HELLO', null, 'SUCCESS', 'READY'],
         ['CONNECTED', 'HELLO', null, 'FAILURE', 'DEFUNCT'],
@@ -89,27 +82,95 @@ public function isValidState(string $state): bool
         ['INTERRUPTED', 'GOODBYE', 'DISCONNECT', null, 'DEFUNCT'],
     ];
 
+    /** @var list<StateTransition> */
+    private array $transitions;
+
+    public function __construct()
+    {
+        $this->transitions = array_map(static fn ($x) => StateTransition::fromArray($x), self::TRANSITIONS);
+    }
+
     /**
-     * @return list<string>
+     * @return array<string, string|null>
      */
-    public function getMessagesForState(string $state): array
+    public function expectedStates(string $state, string $message): array
+    {
+        $tbr = [];
+        foreach ($this->getAvailableTransitionsForState($state) as $transition) {
+            $tbr[$transition->getServerResponse() ?? ''] = $transition->getNewState();
+        }
+
+        return $tbr;
+    }
+
+    /**
+     * Returns the expected state for the response.
+     */
+    public function expectedStateForResponse(string $state, string $message, string $response): ?string
+    {
+        return $this->expectedStates($state, $message)[$response] ?? null;
+    }
+
+    /**
+     * Returns the signal if the state transition response triggers one, null otherwise.
+     */
+    public function expectedSignalForResponse(string $state, string $message, string $response): ?string
     {
-        $messages = [];
-        foreach (self::TRANSITIONS as $transition) {
-            if ($transition[self::KEYS['State']] === $state) {
-                $messages[] = $transition[self::KEYS['Request Message']];
+        foreach ($this->getAvailableTransitionsForStateAndMessage($state, $message) as $transition) {
+            if ($transition->getTriggersSignal()) {
+                return $transition->getTriggersSignal();
             }
         }
 
-        return $messages;
+        return null;
+    }
+
+    /**
+     * @return list<StateTransition>
+     */
+    public function getAvailableTransitionsForStateAndMessage(string $state, string $message): array
+    {
+        return array_values(array_filter(
+            $this->getAvailableTransitionsForState($state),
+            static fn ($x) => $x->getMessage() === $message
+        ));
+    }
+
+    /**
+     * Returns the available transitions for the state.
+     *
+     * @return list<StateTransition>
+     */
+    private function getAvailableTransitionsForState(string $state): array
+    {
+        return array_values(
+            array_filter($this->transitions, static fn ($x) => $x->getOriginalState() === $state)
+        );
+    }
+
+    public function canSendMessage(string $state, string $message): bool
+    {
+        return in_array($message, $this->getMessagesForState($state), true);
+    }
+
+    public function isValidState(string $state): bool
+    {
+        return in_array($state, $this->getStates(), true);
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getMessagesForState(string $state): array
+    {
+        return array_map(static fn ($x) => $x->getMessage(), $this->getAvailableTransitionsForState($state));
     }
 
     /**
      * @return list<string>
      */
     public function getStates(): array
     {
-        /** @var list<string> */
-        return array_unique(array_map(static fn (array $x) => $x[self::KEYS['State']], self::TRANSITIONS));
+        return array_values(array_unique(array_map(static fn ($x) => $x->getOriginalState(), $this->transitions)));
     }
 }

src/Bolt/StateTransition.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the Laudis Neo4j package.
+ *
+ * (c) Laudis technologies <http://laudis.tech>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Laudis\Neo4j\Bolt;
+
+/**
+ * @psalm-immutable
+ */
+final class StateTransition
+{
+    public function __construct(
+        private string $originalState,
+        private string $message,
+        private ?string $triggersSignal,
+        private ?string $serverResponse,
+        private ?string $newState
+    ) {
+    }
+
+    public function getOriginalState(): string
+    {
+        return $this->originalState;
+    }
+
+    public function getMessage(): string
+    {
+        return $this->message;
+    }
+
+    public function getTriggersSignal(): ?string
+    {
+        return $this->triggersSignal;
+    }
+
+    public function getServerResponse(): ?string
+    {
+        return $this->serverResponse;
+    }
+
+    public function getNewState(): ?string
+    {
+        return $this->newState;
+    }
+
+    /**
+     * @param array{0: string, 1: string, 2: string|null, 3: string|null, 4: string|null} $params
+     *
+     * @pure
+     */
+    public static function fromArray(array $params): self
+    {
+        return new self($params[0], $params[1], $params[2], $params[3], $params[4]);
+    }
+}