feat: Add transaction state

Author: exaby73

docker-compose.yml

@@ -1,5 +1,3 @@
-version: '3.8'
-
 x-definitions:
   x-shared-env:
     &common-env

src/Bolt/BoltUnmanagedTransaction.php

@@ -20,6 +20,8 @@
 use Laudis\Neo4j\Databags\SessionConfiguration;
 use Laudis\Neo4j\Databags\Statement;
 use Laudis\Neo4j\Databags\TransactionConfiguration;
+use Laudis\Neo4j\Enum\TransactionState;
+use Laudis\Neo4j\Exception\ClientException;
 use Laudis\Neo4j\Exception\Neo4jException;
 use Laudis\Neo4j\ParameterHelper;
 use Laudis\Neo4j\Types\AbstractCypherSequence;
@@ -40,9 +42,7 @@
  */
 final class BoltUnmanagedTransaction implements UnmanagedTransactionInterface
 {
-    private bool $isRolledBack = false;
-
-    private bool $isCommitted = false;
+    private TransactionState $state = TransactionState::ACTIVE;
 
     /**
      * @param FormatterInterface<T> $formatter
@@ -59,10 +59,26 @@ public function __construct(
         private readonly SessionConfiguration $config,
         private readonly TransactionConfiguration $tsxConfig,
         private readonly BookmarkHolder $bookmarkHolder
-    ) {}
+    ) {
+    }
 
+    /**
+     * @throws ClientException|Throwable
+     */
     public function commit(iterable $statements = []): CypherList
     {
+        if ($this->isFinished()) {
+            switch ($this->state) {
+                case TransactionState::TERMINATED:
+                    throw new ClientException("Can't commit, transaction has been terminated");
+                case TransactionState::COMMITTED:
+                    throw new ClientException("Can't commit, transaction has already been committed");
+                case TransactionState::ROLLED_BACK:
+                    throw new ClientException("Can't commit, transaction has already been rolled back");
+                default:
+            }
+        }
+
         // Force the results to pull all the results.
         // After a commit, the connection will be in the ready state, making it impossible to use PULL
         $tbr = $this->runStatements($statements)->each(static function ($list) {
@@ -72,15 +88,15 @@ public function commit(iterable $statements = []): CypherList
         });
 
         $this->connection->commit();
-        $this->isCommitted = true;
+        $this->state = TransactionState::COMMITTED;
 
         return $tbr;
     }
 
     public function rollback(): void
     {
         $this->connection->rollback();
-        $this->isRolledBack = true;
+        $this->state = TransactionState::ROLLED_BACK;
     }
 
     /**
@@ -109,7 +125,7 @@ public function runStatement(Statement $statement)
                 $this->config->getAccessMode()
             );
         } catch (Throwable $e) {
-            $this->isRolledBack = true;
+            $this->state = TransactionState::TERMINATED;
             throw $e;
         }
         $run = microtime(true);
@@ -140,35 +156,40 @@ public function runStatements(iterable $statements): CypherList
     }
 
     /**
-     * @throws Neo4jException
+     * @param Neo4jException $e
      *
      * @return never
+     * @throws Neo4jException
+     *
      */
-    private function handleMessageException(Neo4jException $e): void
+    private function handleMessageException(Neo4jException $e): never
     {
         $exception = $e->getErrors()[0];
         if (!($exception->getClassification() === 'ClientError' && $exception->getCategory() === 'Request')) {
             $this->connection->reset();
         }
-        if (!$this->isFinished() && in_array($exception->getClassification(), TransactionHelper::ROLLBACK_CLASSIFICATIONS)) {
-            $this->isRolledBack = true;
+        if (!$this->isFinished() && in_array(
+                $exception->getClassification(),
+                TransactionHelper::ROLLBACK_CLASSIFICATIONS
+            )) {
+            $this->state = TransactionState::ROLLED_BACK;
         }
 
         throw $e;
     }
 
     public function isRolledBack(): bool
     {
-        return $this->isRolledBack;
+        return $this->state == TransactionState::ROLLED_BACK;
     }
 
     public function isCommitted(): bool
     {
-        return $this->isCommitted;
+        return $this->state == TransactionState::COMMITTED;
     }
 
     public function isFinished(): bool
     {
-        return $this->isRolledBack() || $this->isCommitted();
+        return $this->state != TransactionState::ACTIVE;
     }
 }

src/Enum/TransactionEffect.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the Neo4j PHP Client and Driver package.
+ *
+ * (c) Nagels <https://nagels.tech>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Laudis\Neo4j\Enum;
+
+/**
+ * The state of a transaction.
+ */
+enum TransactionState {
+    /**
+     * The transaction is running with no explicit success or failure marked
+     */
+    case ACTIVE;
+
+    /**
+     * This transaction has been terminated because of a fatal connection error.
+     */
+    case TERMINATED;
+
+    /**
+     * This transaction has successfully committed
+     */
+    case COMMITTED;
+
+    /**
+     * This transaction has been rolled back
+     */
+    case ROLLED_BACK;
+}

src/Enum/TransactionState.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the Neo4j PHP Client and Driver package.
+ *
+ * (c) Nagels <https://nagels.tech>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Laudis\Neo4j\Exception;
+
+use RuntimeException;
+use Throwable;
+
+/**
+ * Exception when a Client Error occurs.
+ *
+ * @psalm-immutable
+ *
+ * @psalm-suppress MutableDependency
+ */
+final class ClientException extends RuntimeException
+{
+    /**
+     * @param string $message
+     * @param Throwable|null $previous
+     */
+    public function __construct(string $message, ?Throwable $previous = null)
+    {
+        parent::__construct($message, 0, $previous);
+    }
+}