Added compiler extension DatabaseTypeProviderExtension

- added test
- updated README

README.md

@@ -90,6 +90,25 @@ final class MyExtension extends StringType implements ContainerAwareTypeInterfac
 }
 ```
 
+#### Registering Doctrine Types via bundled DatabaseTypeProviderExtension
+
+To register custom types, it is not necessary to create a custom extension, but the class `DatabaseTypeProviderExtension` can be used.
+
+```neon
+extensions:
+    68publishers.doctrine_bridge.database_type_provider: SixtyEightPublishers\DoctrineBridge\Bridge\Nette\DI\DatabaseTypeProviderExtension
+
+68publishers.doctrine_bridge.database_type_provider:
+    # inline notation:
+    my_type_1: App\DbalType\MyType1
+
+    # structured notation:
+    my_type_2:
+        class: App\DbalType\MyType2
+        mapping_type: text
+        context: []
+```
+
 ### Entity Mapping Provider
 
 ```php

src/Bridge/Nette/DI/Config/DatabaseTypeConfig.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\DoctrineBridge\Bridge\Nette\DI\Config;
+
+final class DatabaseTypeConfig
+{
+	/** @var class-string */
+	public string $class;
+
+	public ?string $mappingType = null;
+
+	/** @var array<string, mixed> */
+	public array $context = [];
+}

src/Bridge/Nette/DI/DatabaseTypeProviderExtension.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\DoctrineBridge\Bridge\Nette\DI;
+
+use Nette\Schema\Expect;
+use Nette\Schema\Schema;
+use Nette\DI\CompilerExtension;
+use SixtyEightPublishers\DoctrineBridge\Bridge\Nette\DI\Config\DatabaseTypeConfig;
+use function assert;
+use function is_array;
+use function is_string;
+
+final class DatabaseTypeProviderExtension extends CompilerExtension implements DatabaseTypeProviderInterface
+{
+	public function getConfigSchema(): Schema
+	{
+		return Expect::arrayOf(
+			Expect::anyOf(
+				Expect::string(),
+				Expect::structure([
+					'class' => Expect::string()->required(),
+					'mapping_type' => Expect::string()->nullable(),
+					'context' => Expect::arrayOf('mixed', 'string'),
+				]),
+			)->before(
+				static fn (string|array $databaseType): array => is_array($databaseType)
+				? $databaseType
+				: ['class' => $databaseType, 'mapping_type' => null, 'context' => []]
+			)->castTo(DatabaseTypeConfig::class),
+			'string',
+		);
+	}
+
+	public function getDatabaseTypes(): array
+	{
+		$databaseTypes = [];
+		$config = $this->getConfig();
+		assert(is_array($config));
+
+		foreach ($config as $databaseTypeName => $databaseTypeConfig) {
+			assert(is_string($databaseTypeName) && $databaseTypeConfig instanceof DatabaseTypeConfig);
+
+			$databaseTypes[] = new DatabaseType(
+				name: $databaseTypeName,
+				class: $databaseTypeConfig->class,
+				mappingType: $databaseTypeConfig->mappingType,
+				context: $databaseTypeConfig->context,
+			);
+		}
+
+		return $databaseTypes;
+	}
+}

tests/Bridge/Nette/DI/Nettrine/DatabaseType/config.withDatabaseTypeProviderExtension.neon

@@ -0,0 +1,15 @@
+includes:
+	- ../base.neon
+
+extensions:
+	database_type_provider: SixtyEightPublishers\DoctrineBridge\Bridge\Nette\DI\DatabaseTypeProviderExtension
+
+database_type_provider:
+    custom_type_inline: SixtyEightPublishers\DoctrineBridge\Tests\Fixtures\DatabaseType\CustomTypeWithContainer
+    custom_type_extended:
+        class: SixtyEightPublishers\DoctrineBridge\Tests\Fixtures\DatabaseType\CustomTypeWithContainer
+    custom_type_extended_2:
+        class: SixtyEightPublishers\DoctrineBridge\Tests\Fixtures\DatabaseType\CustomTypeWithContainer
+        mapping_type: integer
+        context:
+            default_value: 3

tests/Bridge/Nette/DI/NettrineDatabaseTypeDoctrineBridgeExtensionTest.phpt

@@ -12,6 +12,7 @@ use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\Types\Type;
 use Doctrine\DBAL\Types\Types;
 use Tester\CodeCoverage\Collector;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
 use SixtyEightPublishers\DoctrineBridge\Tests\Bridge\Nette\DI\ContainerFactory;
 use SixtyEightPublishers\DoctrineBridge\Tests\Fixtures\DatabaseType\CustomTypeWithContainer;
 use function assert;
@@ -68,6 +69,35 @@ final class NettrineDatabaseTypeDoctrineBridgeExtensionTest extends TestCase
 		Assert::false(Type::hasType('test_4'));
 	}
 
+	public function testDatabaseTypesShouldBeRegisteredViaDatabaseTypeProviderExtension(): void
+	{
+		$container = ContainerFactory::create(__DIR__ . '/Nettrine/DatabaseType/config.withDatabaseTypeProviderExtension.neon');
+		$connection = $container->getByType(Connection::class);
+		$platform = $connection->getDatabasePlatform();
+		assert($connection instanceof Connection && $platform instanceof AbstractPlatform);
+
+		Assert::true(Type::hasType('custom_type_inline'));
+		Assert::true(Type::hasType('custom_type_extended'));
+		Assert::true(Type::hasType('custom_type_extended_2'));
+
+		Assert::equal(
+			CustomTypeWithContainer::create($container, []),
+			Type::getType('custom_type_inline'),
+		);
+
+		Assert::equal(
+			CustomTypeWithContainer::create($container, []),
+			Type::getType('custom_type_extended'),
+		);
+
+		Assert::equal(
+			CustomTypeWithContainer::create($container, [
+				'default_value' => 3,
+			]),
+			Type::getType('custom_type_extended_2'),
+		);
+	}
+
 	protected function tearDown(): void
 	{
 		# save manually partial code coverage to free memory

tests/Fixtures/DatabaseType/CustomTypeWithContainer.php

@@ -19,4 +19,12 @@ public function setContainer(Container $container, array $context = []): void
 		$this->container = $container;
 		$this->context = $context;
 	}
+
+	public static function create(Container $container, array $context): self
+	{
+		$type = new self();
+		$type->setContainer($container, $context);
+
+		return $type;
+	}
 }