allow to free result after stream closed

Makefile

@@ -36,6 +36,10 @@ phpunit: vendor phpunit-unit phpunit-integration                              	#
 phpunit-integration: vendor                                                    	## run phpunit integration tests
 	vendor/bin/phpunit --testsuite=integration
 
+.PHONY: phpunit-integration-postgres
+phpunit-integration-postgres: vendor                                            ## run phpunit integration tests on postgres
+	DB_URL="pdo-pgsql://postgres:postgres@localhost:5432/eventstore?charset=utf8" vendor/bin/phpunit --testsuite=integration
+
 .PHONY: phpunit-unit
 phpunit-unit: vendor                                             				## run phpunit unit tests
 	XDEBUG_MODE=coverage vendor/bin/phpunit --testsuite=unit

docker-compose.yaml

@@ -0,0 +1,8 @@
+services:
+  postgres:
+    image: postgres:alpine
+    environment:
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=eventstore
+    expose:
+      - 5432

src/Store/DoctrineDbalStoreStream.php

@@ -18,8 +18,10 @@
 /** @implements IteratorAggregate<Message> */
 final class DoctrineDbalStoreStream implements Stream, IteratorAggregate
 {
+    private Result|null $result;
+
     /** @var Generator<Message> */
-    private readonly Generator $generator;
+    private Generator|null $generator;
 
     /** @var positive-int|0|null */
     private int|null $position;
@@ -28,39 +30,59 @@ final class DoctrineDbalStoreStream implements Stream, IteratorAggregate
     private int|null $index;
 
     public function __construct(
-        private readonly Result $result,
+        Result $result,
         EventSerializer $eventSerializer,
         HeadersSerializer $headersSerializer,
         AbstractPlatform $platform,
     ) {
+        $this->result = $result;
         $this->generator = $this->buildGenerator($result, $eventSerializer, $headersSerializer, $platform);
         $this->position = null;
         $this->index = null;
     }
 
     public function close(): void
     {
-        $this->result->free();
+        $this->result?->free();
+
+        $this->result = null;
+        $this->generator = null;
     }
 
     public function next(): void
     {
+        if ($this->result === null || $this->generator === null) {
+            throw new StreamClosed();
+        }
+
         $this->generator->next();
     }
 
     public function end(): bool
     {
+        if ($this->result === null || $this->generator === null) {
+            throw new StreamClosed();
+        }
+
         return !$this->generator->valid();
     }
 
     public function current(): Message|null
     {
+        if ($this->result === null || $this->generator === null) {
+            throw new StreamClosed();
+        }
+
         return $this->generator->current() ?: null;
     }
 
     /** @return positive-int|0|null */
     public function position(): int|null
     {
+        if ($this->result === null || $this->generator === null) {
+            throw new StreamClosed();
+        }
+
         if ($this->position === null) {
             $this->generator->key();
         }
@@ -71,6 +93,10 @@ public function position(): int|null
     /** @return positive-int|null */
     public function index(): int|null
     {
+        if ($this->result === null || $this->generator === null) {
+            throw new StreamClosed();
+        }
+
         if ($this->index === null) {
             $this->generator->key();
         }
@@ -81,6 +107,10 @@ public function index(): int|null
     /** @return Traversable<Message> */
     public function getIterator(): Traversable
     {
+        if ($this->result === null || $this->generator === null) {
+            throw new StreamClosed();
+        }
+
         return $this->generator;
     }
 

src/Store/Stream.php

@@ -12,15 +12,26 @@ interface Stream extends Traversable
 {
     public function close(): void;
 
+    /** @throws StreamClosed */
     public function next(): void;
 
+    /** @throws StreamClosed */
     public function current(): Message|null;
 
+    /** @throws StreamClosed */
     public function end(): bool;
 
-    /** @return positive-int|0|null */
+    /**
+     * @return positive-int|0|null
+     *
+     * @throws StreamClosed
+     */
     public function position(): int|null;
 
-    /** @return positive-int|null */
+    /**
+     * @return positive-int|null
+     *
+     * @throws StreamClosed
+     */
     public function index(): int|null;
 }

src/Store/StreamClosed.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\Store;
+
+use RuntimeException;
+
+final class StreamClosed extends RuntimeException
+{
+    public function __construct()
+    {
+        parent::__construct('Stream is already closed.');
+    }
+}

tests/Integration/Store/StoreTest.php

@@ -126,19 +126,25 @@ public function testLoad(): void
 
         $this->store->save($message);
 
-        $stream = $this->store->load();
+        $stream = null;
 
-        self::assertSame(1, $stream->index());
-        self::assertSame(0, $stream->position());
+        try {
+            $stream = $this->store->load();
 
-        $loadedMessage = $stream->current();
+            self::assertSame(1, $stream->index());
+            self::assertSame(0, $stream->position());
 
-        self::assertInstanceOf(Message::class, $loadedMessage);
-        self::assertNotSame($message, $loadedMessage);
-        self::assertEquals($message->event(), $loadedMessage->event());
-        self::assertEquals($message->header(AggregateHeader::class)->aggregateId, $loadedMessage->header(AggregateHeader::class)->aggregateId);
-        self::assertEquals($message->header(AggregateHeader::class)->aggregateName, $loadedMessage->header(AggregateHeader::class)->aggregateName);
-        self::assertEquals($message->header(AggregateHeader::class)->playhead, $loadedMessage->header(AggregateHeader::class)->playhead);
-        self::assertEquals($message->header(AggregateHeader::class)->recordedOn, $loadedMessage->header(AggregateHeader::class)->recordedOn);
+            $loadedMessage = $stream->current();
+
+            self::assertInstanceOf(Message::class, $loadedMessage);
+            self::assertNotSame($message, $loadedMessage);
+            self::assertEquals($message->event(), $loadedMessage->event());
+            self::assertEquals($message->header(AggregateHeader::class)->aggregateId, $loadedMessage->header(AggregateHeader::class)->aggregateId);
+            self::assertEquals($message->header(AggregateHeader::class)->aggregateName, $loadedMessage->header(AggregateHeader::class)->aggregateName);
+            self::assertEquals($message->header(AggregateHeader::class)->playhead, $loadedMessage->header(AggregateHeader::class)->playhead);
+            self::assertEquals($message->header(AggregateHeader::class)->recordedOn, $loadedMessage->header(AggregateHeader::class)->recordedOn);
+        } finally {
+            $stream?->close();
+        }
     }
 }