Update to Nextras 4 compatibility

- Update PHP requirement to >=8.1 (required by nette/di 3.x)
- Fix deprecated TAG_INJECT constant (now TagInject)
- Update PHPStan configuration for proper analysis
- Add comprehensive test coverage for QueryObject, ExecutableQueryObject,
  QueryObjectContextAwareManager, TRepositoryQueryable, and exceptions

Closes #9

Author: claude

composer.json

@@ -11,7 +11,7 @@
     }
   ],
   "require": {
-    "php": ">=7.2",
+    "php": ">=8.1",
     "nextras/dbal": "^4.0.0"
   },
   "require-dev": {

phpstan.neon

@@ -6,5 +6,11 @@ includes:
 
 parameters:
 	level: 9
-	phpVersion: 70200
+	phpVersion: 80100
+	paths:
+		- src
+	scanDirectories:
+		- vendor/nette/di/src
+		- vendor/nextras/orm/src
+		- vendor/nextras/dbal/src
 

src/DI/NextrasQueryObjectExtension.php

@@ -32,11 +32,11 @@ public function beforeCompile(): void
 		$builder = $this->getContainerBuilder();
 
 		foreach ($builder->findByType(Repository::class) as $name => $def) {
-			$def->addTag(InjectExtension::TAG_INJECT);
+			$def->addTag(InjectExtension::TagInject);
 		}
 
 		foreach ($builder->findByType(Mapper::class) as $name => $def) {
-			$def->addTag(InjectExtension::TAG_INJECT);
+			$def->addTag(InjectExtension::TagInject);
 		}
 	}
 

tests/Cases/Exceptions.phpt

@@ -0,0 +1,37 @@
+<?php declare(strict_types = 1);
+
+use Contributte\Nextras\Orm\QueryObject\Exception\InvalidHydrationModeException;
+use Contributte\Nextras\Orm\QueryObject\Exception\InvalidObjectCreationException;
+use Tester\Assert;
+
+require_once __DIR__ . '/../bootstrap.php';
+
+// Test: InvalidHydrationModeException extends LogicException
+test(function (): void {
+	$exception = new InvalidHydrationModeException('Test message');
+
+	Assert::type(LogicException::class, $exception);
+	Assert::same('Test message', $exception->getMessage());
+});
+
+// Test: InvalidObjectCreationException extends LogicException
+test(function (): void {
+	$exception = new InvalidObjectCreationException('Creation failed');
+
+	Assert::type(LogicException::class, $exception);
+	Assert::same('Creation failed', $exception->getMessage());
+});
+
+// Test: InvalidHydrationModeException can be thrown and caught
+test(function (): void {
+	Assert::exception(function (): void {
+		throw new InvalidHydrationModeException('Invalid hydration mode "99"');
+	}, InvalidHydrationModeException::class, 'Invalid hydration mode "99"');
+});
+
+// Test: InvalidObjectCreationException can be thrown and caught
+test(function (): void {
+	Assert::exception(function (): void {
+		throw new InvalidObjectCreationException('Created object must be typed of QueryObject');
+	}, InvalidObjectCreationException::class, 'Created object must be typed of QueryObject');
+});

tests/Cases/ExecutableQueryObject.phpt

@@ -0,0 +1,112 @@
+<?php declare(strict_types = 1);
+
+use Contributte\Nextras\Orm\QueryObject\ExecutableQueryObject;
+use Nextras\Dbal\Connection;
+use Nextras\Dbal\QueryBuilder\QueryBuilder;
+use Nextras\Dbal\Result\Result;
+use Tester\Assert;
+
+require_once __DIR__ . '/../bootstrap.php';
+
+/**
+ * Test ExecutableQueryObject
+ */
+class TestExecutableQueryObject extends ExecutableQueryObject
+{
+
+	public function doQuery(QueryBuilder $builder): QueryBuilder
+	{
+		return $builder->select('[*]')->from('[test_table]');
+	}
+
+}
+
+/**
+ * Test ExecutableQueryObject with custom postResult
+ */
+class TestExecutableQueryObjectWithPostResult extends ExecutableQueryObject
+{
+
+	private bool $postResultCalled = false;
+
+	public function doQuery(QueryBuilder $builder): QueryBuilder
+	{
+		return $builder->select('[id]')->from('[users]');
+	}
+
+	public function postResult(Result $result): Result
+	{
+		$this->postResultCalled = true;
+		return parent::postResult($result);
+	}
+
+	public function wasPostResultCalled(): bool
+	{
+		return $this->postResultCalled;
+	}
+
+}
+
+// Test: ExecutableQueryObject builds query via fetch method
+test(function (): void {
+	$connection = Mockery::mock(Connection::class);
+	$queryBuilder = Mockery::mock(QueryBuilder::class);
+
+	$queryBuilder->shouldReceive('select')
+		->with('[*]')
+		->once()
+		->andReturnSelf();
+
+	$queryBuilder->shouldReceive('from')
+		->with('[test_table]')
+		->once()
+		->andReturnSelf();
+
+	$qo = new TestExecutableQueryObject($connection);
+	$result = $qo->fetch($queryBuilder);
+
+	Assert::type(QueryBuilder::class, $result);
+
+	Mockery::close();
+});
+
+// Test: ExecutableQueryObject execute method uses connection
+test(function (): void {
+	$connection = Mockery::mock(Connection::class);
+	$queryBuilder = Mockery::mock(QueryBuilder::class);
+	$result = Mockery::mock(Result::class);
+
+	$queryBuilder->shouldReceive('select')
+		->with('[*]')
+		->once()
+		->andReturnSelf();
+
+	$queryBuilder->shouldReceive('from')
+		->with('[test_table]')
+		->once()
+		->andReturnSelf();
+
+	$queryBuilder->shouldReceive('getQuerySql')
+		->once()
+		->andReturn('SELECT * FROM test_table');
+
+	$queryBuilder->shouldReceive('getQueryParameters')
+		->once()
+		->andReturn([]);
+
+	$connection->shouldReceive('createQueryBuilder')
+		->once()
+		->andReturn($queryBuilder);
+
+	$connection->shouldReceive('queryArgs')
+		->with('SELECT * FROM test_table', [])
+		->once()
+		->andReturn($result);
+
+	$qo = new TestExecutableQueryObject($connection);
+	$executeResult = $qo->execute();
+
+	Assert::type(Result::class, $executeResult);
+
+	Mockery::close();
+});

tests/Cases/QueryObjectContextAwareManager.phpt

@@ -0,0 +1,99 @@
+<?php declare(strict_types = 1);
+
+use Contributte\Nextras\Orm\QueryObject\Exception\InvalidObjectCreationException;
+use Contributte\Nextras\Orm\QueryObject\QueryObject;
+use Contributte\Nextras\Orm\QueryObject\QueryObjectContextAwareManager;
+use Nette\DI\Container;
+use Nextras\Dbal\Connection;
+use Nextras\Dbal\QueryBuilder\QueryBuilder;
+use Nextras\Dbal\Result\Result;
+use Tester\Assert;
+use Tests\Mocks\SimpleQueryObject;
+
+require_once __DIR__ . '/../bootstrap.php';
+
+// Test: QueryObjectContextAwareManager create returns QueryObject
+test(function (): void {
+	$queryObject = new SimpleQueryObject();
+
+	$container = Mockery::mock(Container::class);
+	$container->shouldReceive('getByType')
+		->with(SimpleQueryObject::class)
+		->once()
+		->andReturn($queryObject);
+
+	$manager = new QueryObjectContextAwareManager($container);
+	$result = $manager->create(SimpleQueryObject::class);
+
+	Assert::type(QueryObject::class, $result);
+	Assert::same($queryObject, $result);
+
+	Mockery::close();
+});
+
+// Test: QueryObjectContextAwareManager create throws InvalidObjectCreationException for non-QueryObject
+test(function (): void {
+	$nonQueryObject = new stdClass();
+
+	$container = Mockery::mock(Container::class);
+	$container->shouldReceive('getByType')
+		->with(stdClass::class)
+		->once()
+		->andReturn($nonQueryObject);
+
+	$manager = new QueryObjectContextAwareManager($container);
+
+	Assert::exception(function () use ($manager): void {
+		$manager->create(stdClass::class);
+	}, InvalidObjectCreationException::class);
+
+	Mockery::close();
+});
+
+// Test: QueryObjectContextAwareManager fetch returns Result
+test(function (): void {
+	$connection = Mockery::mock(Connection::class);
+	$queryBuilder = Mockery::mock(QueryBuilder::class);
+	$result = Mockery::mock(Result::class);
+
+	$queryBuilder->shouldReceive('select')
+		->with('[*]')
+		->once()
+		->andReturnSelf();
+
+	$queryBuilder->shouldReceive('from')
+		->with('[foobar]')
+		->once()
+		->andReturnSelf();
+
+	$queryBuilder->shouldReceive('getQuerySql')
+		->once()
+		->andReturn('SELECT * FROM foobar');
+
+	$queryBuilder->shouldReceive('getQueryParameters')
+		->once()
+		->andReturn([]);
+
+	$connection->shouldReceive('createQueryBuilder')
+		->once()
+		->andReturn($queryBuilder);
+
+	$connection->shouldReceive('queryArgs')
+		->with('SELECT * FROM foobar', [])
+		->once()
+		->andReturn($result);
+
+	$container = Mockery::mock(Container::class);
+	$container->shouldReceive('getByType')
+		->with(Connection::class)
+		->once()
+		->andReturn($connection);
+
+	$manager = new QueryObjectContextAwareManager($container);
+	$queryObject = new SimpleQueryObject();
+	$fetchResult = $manager->fetch($queryObject);
+
+	Assert::type(Result::class, $fetchResult);
+
+	Mockery::close();
+});

tests/Cases/Queryable.phpt

@@ -0,0 +1,16 @@
+<?php declare(strict_types = 1);
+
+use Contributte\Nextras\Orm\QueryObject\Queryable;
+use Tester\Assert;
+
+require_once __DIR__ . '/../bootstrap.php';
+
+// Test: Queryable interface defines HYDRATION_RESULTSET constant
+test(function (): void {
+	Assert::same(1, Queryable::HYDRATION_RESULTSET);
+});
+
+// Test: Queryable interface defines HYDRATION_ENTITY constant
+test(function (): void {
+	Assert::same(2, Queryable::HYDRATION_ENTITY);
+});