Allow referencing previously defined named types

src/Objects/Schema.php

@@ -19,6 +19,7 @@
 use FlixTech\AvroSerializer\Objects\Schema\LocalTimestampMillisType;
 use FlixTech\AvroSerializer\Objects\Schema\LongType;
 use FlixTech\AvroSerializer\Objects\Schema\MapType;
+use FlixTech\AvroSerializer\Objects\Schema\NamedType;
 use FlixTech\AvroSerializer\Objects\Schema\NullType;
 use FlixTech\AvroSerializer\Objects\Schema\RecordType;
 use FlixTech\AvroSerializer\Objects\Schema\StringType;
@@ -71,6 +72,11 @@ public static function string(): StringType
         return new StringType();
     }
 
+    public static function named(string $name): NamedType
+    {
+        return new NamedType($name);
+    }
+
     public static function record(): RecordType
     {
         return new RecordType();

src/Objects/Schema/Generation/SchemaGenerator.php

@@ -18,9 +18,15 @@ class SchemaGenerator
      */
     private $reader;
 
+    /**
+     * @var TypeMapper
+     */
+    private $typeMapper;
+
     public function __construct(SchemaAttributeReader $reader)
     {
         $this->reader = $reader;
+        $this->typeMapper = new TypeMapper($this);
     }
 
     /**
@@ -39,7 +45,7 @@ public function generate(string $className): Schema
      */
     private function generateFromClass(ReflectionClass $class, Type $type): Schema
     {
-        $schema = $this->schemaFromTypes($type);
+        $schema = $this->schemaFromType($type);
 
         if (!$schema instanceof Schema\RecordType) {
             return $schema;
@@ -56,75 +62,20 @@ private function generateFromClass(ReflectionClass $class, Type $type): Schema
     private function schemaFromTypes(Type ...$types): Schema
     {
         if (\count($types) > 1) {
-            $unionSchemas = \array_map(function (Type $type) {
-                return $this->schemaFromTypes($type);
-            }, $types);
+            $unionSchemas = \array_map([$this, 'schemaFromType'], $types);
 
             return Schema::union(...$unionSchemas);
         }
 
-        $type = $types[0];
-        $attributes = $type->getAttributes();
-
-        switch ($type->getTypeName()) {
-            case TypeName::RECORD:
-                if ($attributes->has(AttributeName::TARGET_CLASS)) {
-                    return $this->generate($attributes->get(AttributeName::TARGET_CLASS));
-                }
-                $schema = Schema::record();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::NULL:
-                $schema = Schema::null();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::BOOLEAN:
-                $schema = Schema::boolean();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::INT:
-                $schema = Schema::int();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::LONG:
-                $schema = Schema::long();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::FLOAT:
-                $schema = Schema::float();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::DOUBLE:
-                $schema = Schema::double();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::BYTES:
-                $schema = Schema::bytes();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::STRING:
-                $schema = Schema::string();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::ARRAY:
-                $schema = Schema::array();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::MAP:
-                $schema = Schema::map();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::ENUM:
-                $schema = Schema::enum();
-
-                return $this->applyAttributes($schema, $attributes);
-            case TypeName::FIXED:
-                $schema = Schema::fixed();
+        return $this->schemaFromType($types[0]);
+    }
 
-                return $this->applyAttributes($schema, $attributes);
-            default:
-                throw new \InvalidArgumentException('$type is not a valid avro type');
-        }
+    private function schemaFromType(Type $type): Schema
+    {
+        return $this->applyAttributes(
+            $this->typeMapper->toSchema($type),
+            $type->getAttributes()
+        );
     }
 
     private function parseField(ReflectionProperty $property, Schema\RecordType $rootSchema): Schema

src/Objects/Schema/Generation/TypeMapper.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FlixTech\AvroSerializer\Objects\Schema\Generation;
+
+use FlixTech\AvroSerializer\Objects\Schema;
+use FlixTech\AvroSerializer\Objects\Schema\AttributeName;
+use FlixTech\AvroSerializer\Objects\Schema\TypeName;
+
+final class TypeMapper
+{
+    /**
+     * @var array<string, callable>
+     */
+    private $mappers;
+
+    public function __construct(SchemaGenerator $generator)
+    {
+        $this->mappers = [
+            TypeName::RECORD => $this->recordType($generator),
+            TypeName::NULL => $this->simpleType(Schema::null()),
+            TypeName::BOOLEAN => $this->simpleType(Schema::boolean()),
+            TypeName::INT => $this->simpleType(Schema::int()),
+            TypeName::LONG => $this->simpleType(Schema::long()),
+            TypeName::FLOAT => $this->simpleType(Schema::float()),
+            TypeName::DOUBLE => $this->simpleType(Schema::double()),
+            TypeName::BYTES => $this->simpleType(Schema::bytes()),
+            TypeName::STRING => $this->simpleType(Schema::string()),
+            TypeName::ARRAY => $this->simpleType(Schema::array()),
+            TypeName::MAP => $this->simpleType(Schema::map()),
+            TypeName::ENUM => $this->simpleType(Schema::enum()),
+            TypeName::FIXED => $this->simpleType(Schema::fixed()),
+        ];
+    }
+
+    public function toSchema(Type $type): Schema
+    {
+        $mapper = $this->mappers[$type->getTypeName()] ?? $this->namedType();
+
+        return $mapper($type);
+    }
+
+    private function simpleType(Schema $schema): callable
+    {
+        return function () use ($schema): Schema {
+            return $schema;
+        };
+    }
+
+    private function recordType(SchemaGenerator $generator): callable
+    {
+        return function (Type $type) use ($generator): Schema {
+            $attributes = $type->getAttributes();
+
+            if ($attributes->has(AttributeName::TARGET_CLASS)) {
+                return $generator->generate($attributes->get(AttributeName::TARGET_CLASS));
+            }
+
+            return Schema::record();
+        };
+    }
+
+    private function namedType(): callable
+    {
+        return function (Type $type): Schema {
+            return Schema::named($type->getTypeName());
+        };
+    }
+}

src/Objects/Schema/NamedType.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FlixTech\AvroSerializer\Objects\Schema;
+
+use FlixTech\AvroSerializer\Objects\Schema;
+
+class NamedType extends Schema
+{
+    /**
+     * @var string
+     */
+    private $name;
+
+    public function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+
+    public function serialize(): string
+    {
+        return $this->name;
+    }
+}

test/Objects/Schema/Generation/Fixture/RecordWithRecordType.php

@@ -13,10 +13,18 @@
 class RecordWithRecordType
 {
     /**
-     * @SerDe\AvroName("simple")
+     * @SerDe\AvroName("simpleField")
      * @SerDe\AvroType("record", attributes={
-     *     @SerDe\AvroTargetClass("\FlixTech\AvroSerializer\Test\Objects\Schema\Generation\Fixture\SimpleRecord")
+     *     @SerDe\AvroTargetClass("\FlixTech\AvroSerializer\Test\Objects\Schema\Generation\Fixture\SimpleRecord"),
+     *     @SerDe\AvroDoc("This a simple record for testing purposes")
      * })
      */
     private $simpleRecord;
+
+    /**
+     * @SerDe\AvroName("unionField")
+     * @SerDe\AvroType("null")
+     * @SerDe\AvroType("org.acme.SimpleRecord")
+     */
+    private $unionRecord;
 }

test/Objects/Schema/Generation/SchemaGeneratorTest.php

@@ -151,11 +151,23 @@ public function it_should_generate_records_containing_records()
         $expected = Schema::record()
             ->name('RecordWithRecordType')
             ->field(
-                'simple',
+                'simpleField',
                 Schema::record()
                     ->name('SimpleRecord')
                     ->namespace('org.acme')
-                    ->field('intType', Schema::int(), Schema\Record\FieldOption::default(42))
+                    ->doc('This a simple record for testing purposes')
+                    ->field(
+                        'intType',
+                        Schema::int(),
+                        Schema\Record\FieldOption::default(42)
+                    ),
+            )
+            ->field(
+                'unionField',
+                Schema::union(
+                    Schema::null(),
+                    Schema::named('org.acme.SimpleRecord')
+                )
             );
 
         $this->assertEquals($expected, $schema);