Make AsDatabaseType name optional, defaulting to the service id

When no name is provided, the FQCN (service id) is used as the type name,
allowing #[Column(type: MyType::class)] without declaring an explicit name.
This also works for YAML/PHP service configuration: any service tagged with
doctrine.dbal.type without a type attribute falls back to its service id.

Author: GromNaN

docs/en/custom-dbal-types.rst

@@ -60,13 +60,14 @@ connection:
     use Doctrine\DBAL\Platforms\AbstractPlatform;
     use Doctrine\DBAL\Types\Type;
 
-    #[AsDatabaseType(name: 'money')]
+    #[AsDatabaseType]
     final class MoneyType extends Type
     {
         // ...
     }
 
-You can now use the type by name in your entity mappings:
+When no ``name`` is given, the fully-qualified class name is used as the type
+name. You can then reference the type with ``::class`` in your entity mappings:
 
 .. code-block:: php
 
@@ -86,28 +87,18 @@ You can now use the type by name in your entity mappings:
         #[ORM\Column]
         private int $id;
 
-        #[ORM\Column(type: MoneyType::NAME)]
+        #[ORM\Column(type: MoneyType::class)]
         private Money $price;
     }
 
-It is recommended to define the type name as a constant on the type class to
-avoid duplicating the string:
+An explicit name can still be provided when the type needs to be referenced by
+a short string (e.g. from PHP or YAML mappings):
 
 .. code-block:: php
 
-    <?php
-
-    namespace App\Doctrine\Type;
-
-    use Doctrine\Bundle\DoctrineBundle\Attribute\AsDatabaseType;
-    use Doctrine\DBAL\Platforms\AbstractPlatform;
-    use Doctrine\DBAL\Types\Type;
-
-    #[AsDatabaseType(name: MoneyType::NAME)]
+    #[AsDatabaseType(name: 'money')]
     final class MoneyType extends Type
     {
-        public const string NAME = 'money';
-
         // ...
     }
 
@@ -127,8 +118,8 @@ subset of connections by repeating the attribute with a ``connection`` argument:
     use Doctrine\DBAL\Platforms\AbstractPlatform;
     use Doctrine\DBAL\Types\Type;
 
-    #[AsDatabaseType(name: 'money', connection: 'default')]
-    #[AsDatabaseType(name: 'money', connection: 'reporting')]
+    #[AsDatabaseType(connection: 'default')]
+    #[AsDatabaseType(connection: 'reporting')]
     final class MoneyType extends Type
     {
         // ...

src/Attribute/AsDatabaseType.php

@@ -6,11 +6,24 @@
 
 use Attribute;
 
+/**
+ * Registers a DBAL type as a service, with full dependency injection support.
+ *
+ * The type is registered in the TypeRegistry of the specified connection(s),
+ * replacing the global static type registry for that connection.
+ */
 #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
 class AsDatabaseType
 {
+    /**
+     * @param string|null $name       The DBAL type name used in column mappings (e.g. in #[Column(type: ...)]).
+     *                                Defaults to the fully-qualified class name of the type when omitted,
+     *                                so that #[Column(type: MyType::class)] works without declaring a name.
+     * @param string|null $connection Restrict the type to a specific named connection.
+     *                                When null (default), the type is registered for all connections.
+     */
     public function __construct(
-        public readonly string $name,
+        public readonly string|null $name = null,
         public readonly string|null $connection = null,
     ) {
     }

src/DependencyInjection/Compiler/DatabaseTypePass.php

@@ -58,15 +58,11 @@ public function process(ContainerBuilder $container): void
             // Service-tagged types: global (no connection restriction) or matching this connection
             foreach ($taggedServiceIds as $id => $tags) {
                 foreach ($tags as $tag) {
-                    if (! isset($tag['type'])) {
-                        continue;
-                    }
-
                     if ($name !== ($tag['connection'] ?? $name)) {
                         continue;
                     }
 
-                    $instances[$tag['type']] = new Reference($id);
+                    $instances[$tag['type'] ?? $id] = new Reference($id);
                 }
             }
 

tests/DependencyInjection/Compiler/DatabaseTypePassTest.php

@@ -82,6 +82,32 @@ public function testTypeRegisteredOnMultipleConnectionsViaRepeatedAttribute(): v
         $this->assertTypeRegistered($container, 'conn2', 'multi_alias', MultiConnectionType::class);
     }
 
+    public function testTypeWithNoNameDefaultsToServiceId(): void
+    {
+        $container = $this->createContainer(static function (ContainerBuilder $container): void {
+            $container->register(AutoconfiguredAnonymousType::class, AutoconfiguredAnonymousType::class)
+                ->setAutoconfigured(true);
+
+            $container->setAlias('registry_conn1', 'doctrine.dbal.conn1_connection.type_registry')->setPublic(true);
+            $container->setAlias('registry_conn2', 'doctrine.dbal.conn2_connection.type_registry')->setPublic(true);
+        });
+
+        $this->assertTypeRegistered($container, 'conn1', AutoconfiguredAnonymousType::class, AutoconfiguredAnonymousType::class);
+        $this->assertTypeRegistered($container, 'conn2', AutoconfiguredAnonymousType::class, AutoconfiguredAnonymousType::class);
+    }
+
+    public function testTaggedTypeWithNoTypeAttributeDefaultsToServiceId(): void
+    {
+        $container = $this->createContainer(static function (ContainerBuilder $container): void {
+            $container->register('my_type', MoneyType::class)
+                ->addTag('doctrine.dbal.type');
+
+            $container->setAlias('registry_conn1', 'doctrine.dbal.conn1_connection.type_registry')->setPublic(true);
+        });
+
+        $this->assertTypeRegistered($container, 'conn1', 'my_type', MoneyType::class);
+    }
+
     public function testAutoconfiguredTypeViaAttribute(): void
     {
         $container = $this->createContainer(static function (ContainerBuilder $container): void {
@@ -328,6 +354,15 @@ public function getSQLDeclaration(array $column, AbstractPlatform $platform): st
     }
 }
 
+#[AsDatabaseType]
+class AutoconfiguredAnonymousType extends Type
+{
+    public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
+    {
+        return 'VARCHAR(255)';
+    }
+}
+
 #[AsDatabaseType(name: 'multi', connection: 'conn1')]
 #[AsDatabaseType(name: 'multi_alias', connection: 'conn2')]
 class MultiConnectionType extends Type