feat: alias nested schemas added (#110)

Author: marcosschroh

dataclasses_avroschema/fields.py

@@ -103,6 +103,10 @@ class BaseField:
     type: typing.Any  # store the python primitive type
     default: typing.Any
     metadata: typing.Mapping = dataclasses.field(default_factory=dict)
+    model_metadata: typing.Optional[utils.SchemaMetadata] = None
+
+    def __post_init__(self) -> None:
+        self.model_metadata = self.model_metadata or utils.SchemaMetadata()
 
     @staticmethod
     def _get_self_reference_type(a_type: typing.Any) -> str:
@@ -296,10 +300,14 @@ def generate_items_type(self) -> typing.Any:
 
         if utils.is_union(items_type):
             self.items_type = UnionField(
-                name, items_type, default=self.default, default_factory=self.default_factory
+                name,
+                items_type,
+                default=self.default,
+                default_factory=self.default_factory,
+                model_metadata=self.model_metadata,
             ).get_avro_type()
         else:
-            self.internal_field = AvroField(name, items_type)
+            self.internal_field = AvroField(name, items_type, model_metadata=self.model_metadata)
             self.items_type = self.internal_field.get_avro_type()
 
     def fake(self) -> typing.List:
@@ -347,7 +355,7 @@ def generate_values_type(self) -> typing.Any:
         values_type = self.type.__args__[1]
 
         name = self.get_singular_name(self.name)
-        self.internal_field = AvroField(name, values_type)
+        self.internal_field = AvroField(name, values_type, model_metadata=self.model_metadata)
         self.values_type = self.internal_field.get_avro_type()
 
     def fake(self) -> typing.Dict[str, typing.Any]:
@@ -388,13 +396,15 @@ def generate_unions_type(self) -> typing.List:
             unions.insert(0, NULL)
         elif type(self.default) is not dataclasses._MISSING_TYPE:
             default_type = type(self.default)
-            default_field = AvroField(name, default_type)
+            default_field = AvroField(name, default_type, model_metadata=self.model_metadata)
             unions.append(default_field.get_avro_type())
             self.internal_fields.append(default_field)
 
         for element in elements:
+
+            print(self.model_metadata, "jjsjs")
             # create the field and get the avro type
-            field = AvroField(name, element)
+            field = AvroField(name, element, model_metadata=self.model_metadata)
 
             if field.get_avro_type() not in unions:
                 unions.append(field.get_avro_type())
@@ -646,20 +656,28 @@ def fake(self) -> uuid.UUID:
 class RecordField(BaseField):
     def get_avro_type(self) -> typing.Union[typing.List, typing.Dict]:
         record_type = self.type.avro_schema_to_python()
+        record_type["name"] = self.record_name
+
+        if self.default is None:
+            return [NULL, record_type]
+        return record_type
+
+    @property
+    def record_name(self) -> str:
+        alias = self.model_metadata.get_alias(self.name)  # type: ignore
+
+        if alias:
+            return alias
 
         # when there is a nested record replace its name
-        # to avoid name colisions
+        # to avoid name collisions
         record_name = self.type.__name__.lower()
         if record_name not in self.name:
             name = f"{self.name}_{record_name}_record"
         else:
             name = f"{self.name}_record"
 
-        record_type["name"] = name
-
-        if self.default is None:
-            return [NULL, record_type]
-        return record_type
+        return name
 
     def fake(self) -> typing.Any:
         return self.type.fake()
@@ -797,16 +815,21 @@ def field_factory(
     default: typing.Any = dataclasses.MISSING,
     default_factory: typing.Any = dataclasses.MISSING,
     metadata: typing.Mapping = dataclasses.field(default_factory=dict),
+    model_metadata: typing.Optional[utils.SchemaMetadata] = None,
 ) -> FieldType:
     if native_type in PYTHON_INMUTABLE_TYPES:
         klass = INMUTABLE_FIELDS_CLASSES[native_type]
-        return klass(name=name, type=native_type, default=default, metadata=metadata)
+        return klass(name=name, type=native_type, default=default, metadata=metadata, model_metadata=model_metadata)
     elif utils.is_self_referenced(native_type):
-        return SelfReferenceField(name=name, type=native_type, default=default, metadata=metadata)
+        return SelfReferenceField(
+            name=name, type=native_type, default=default, metadata=metadata, model_metadata=model_metadata
+        )
     elif native_type is types.Fixed:
-        return FixedField(name=name, type=native_type, default=default, metadata=metadata)
+        return FixedField(
+            name=name, type=native_type, default=default, metadata=metadata, model_metadata=model_metadata
+        )
     elif native_type is types.Enum:
-        return EnumField(name=name, type=native_type, default=default, metadata=metadata)
+        return EnumField(name=name, type=native_type, default=default, metadata=metadata, model_metadata=model_metadata)
     elif isinstance(native_type, GenericAlias):  # type: ignore
         origin = native_type.__origin__
 
@@ -833,12 +856,15 @@ def field_factory(
             default=default,
             metadata=metadata,
             default_factory=default_factory,
+            model_metadata=model_metadata,
         )
     elif native_type in PYTHON_LOGICAL_TYPES:
         klass = LOGICAL_TYPES_FIELDS_CLASSES[native_type]  # type: ignore
-        return klass(name=name, type=native_type, default=default, metadata=metadata)
+        return klass(name=name, type=native_type, default=default, metadata=metadata, model_metadata=model_metadata)
     elif inspect.isclass(native_type) and issubclass(native_type, schema_generator.AvroModel):
-        return RecordField(name=name, type=native_type, default=default, metadata=metadata)
+        return RecordField(
+            name=name, type=native_type, default=default, metadata=metadata, model_metadata=model_metadata
+        )
     else:
         msg = (
             f"Type {native_type} is unknown. Please check the valid types at "

dataclasses_avroschema/schema_definition.py

@@ -46,10 +46,8 @@ def is_faust_record(self) -> bool:
 
 @dataclasses.dataclass
 class AvroSchemaDefinition(BaseSchemaDefinition):
-    aliases: typing.List[str] = dataclasses.field(default_factory=list)
-    namespace: typing.Optional[str] = None
+    metadata: utils.SchemaMetadata
     fields: typing.List[FieldType] = dataclasses.field(default_factory=list)
-    metadata: utils.SchemaMetadata = dataclasses.field(default_factory=utils.SchemaMetadata)
 
     def __post_init__(self) -> None:
         self.fields = self.parse_dataclasses_fields()
@@ -67,6 +65,7 @@ def parse_fields(self) -> typing.List[FieldType]:
                 dataclass_field.default,
                 dataclass_field.default_factory,  # type: ignore  # TODO: resolve mypy
                 dataclass_field.metadata,
+                self.metadata,
             )
             for dataclass_field in dataclasses.fields(self.klass)
         ]
@@ -87,7 +86,11 @@ def parse_faust_record_fields(self) -> typing.List[FieldType]:
                     default_factory = default.default_factory  # type: ignore  # TODO: resolve mypy
                     default = dataclasses.MISSING
 
-            schema_fields.append(AvroField(dataclass_field.name, dataclass_field.type, default, default_factory))
+            schema_fields.append(
+                AvroField(
+                    dataclass_field.name, dataclass_field.type, default, default_factory, model_metadata=self.metadata
+                )
+            )
 
         return schema_fields
 

dataclasses_avroschema/schema_generator.py

@@ -33,8 +33,6 @@ def generate_dataclass(cls: typing.Any) -> typing.Any:
     def generate_metadata(cls: typing.Any) -> SchemaMetadata:
         meta = getattr(cls.klass, "Meta", None)
 
-        if meta is None:
-            return SchemaMetadata()
         return SchemaMetadata.create(meta)
 
     @classmethod

dataclasses_avroschema/utils.py

@@ -1,5 +1,5 @@
 import typing
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime
 
 from pytz import utc
@@ -56,6 +56,7 @@ class SchemaMetadata:
     schema_doc: bool = True
     namespace: typing.Optional[typing.List[str]] = None
     aliases: typing.Optional[typing.List[str]] = None
+    alias_nested_items: typing.Dict[str, str] = field(default_factory=dict)
 
     @classmethod
     def create(cls, klass: typing.Any) -> typing.Any:
@@ -64,8 +65,12 @@ def create(cls, klass: typing.Any) -> typing.Any:
             schema_doc=getattr(klass, "schema_doc", True),
             namespace=getattr(klass, "namespace", None),
             aliases=getattr(klass, "aliases", None),
+            alias_nested_items=getattr(klass, "alias_nested_items", {}),
         )
 
+    def get_alias(self, name: str) -> typing.Optional[str]:
+        return self.alias_nested_items.get(name)
+
 
 epoch: datetime = datetime(1970, 1, 1, tzinfo=utc)
 epoch_naive: datetime = datetime(1970, 1, 1)

docs/complex_types.md

@@ -401,16 +401,18 @@ User.avro_schema()
 
 #### Class Meta
 
-The `class Meta` is used to specify schema attributes that are not represented by the class fields like `namespace`, `aliases` and whether to include the `schema documentation`. One can also provide a custom schema name (the default is the class' name) via `schema_name` attribute.
+The `class Meta` is used to specify schema attributes that are not represented by the class fields like `namespace`, `aliases` and whether to include the `schema documentation`. One can also provide a custom schema name (the default is the class' name) via `schema_name` attribute and `alias_nested_items` when you have nested items and you want to use custom naming for them.
 
 ```python
 class Meta:
     schema_name = "Name other than the class name"
     schema_doc = False
     namespace = "test.com.ar/user/v1"
     aliases = ["User", "My favorite User"]
+    alias_nested_items = {"address": "Address"}
 ```
 
 `schema_doc (boolean)`: Whether include the `schema documentation` generated from `docstrings`. Default `True`
 `namespace (optional[str])`: Schema namespace. Default `None`
 `aliases (optional[List[str]])`: Schema aliases. Default `None`
+`alias_nested_items (optional[Dict[str, str]])`: Nested items names

docs/schema_relationships.md

@@ -261,10 +261,10 @@ User.avro_schema()
 }'
 ```
 
-## Avoid name colision in multiple relationships
+## Avoid name collision in multiple relationships
 
 Sometimes we have relationships where a class is related more than once with a particular class,
-and the name for the nested schemas must be diferent, otherwise we will generate an invalid `avro schema`.
+and the name for the nested schemas must be different, otherwise we will generate an invalid `avro schema`.
 
 For example:
 
@@ -290,7 +290,7 @@ class Trip(AvroModel):
     finish_location: Location  # second relationship
 ```
 
-In order to avoid name colisions, the nested name is generated in the following way:
+In order to avoid name collision, the nested name is generated in the following way:
 
 1. Get the lower name of the related class
 2. Get the field name
@@ -361,3 +361,62 @@ Example for start_location:
   "doc": "Trip(start_time: datetime.datetime, start_location: __main__.Location, finish_time: datetime.datetime, finish_location: __main__.Location)"
 }'
 ```
+
+If you want, also you can use custom name for nested items (`nested records`, `arrays` or `maps`) using the property `alias_nested_items` in `class Meta`:
+
+```python
+from dataclasses_avroschema import AvroModel
+
+
+class Address(AvroModel):
+    "An Address"
+    street: str
+    street_number: int
+
+class User(AvroModel):
+    "An User with Address"
+    name: str
+    age: int
+    address: Address  # default name address_record
+
+    class Meta:
+        alias_nested_items = {"address": "MySuperAddress"}
+```
+
+`User.avro_schema()` will generate:
+
+```json
+{
+    "type": "record",
+    "name": "User",
+    "fields": [
+        {
+            "name": "name",
+            "type": "string"
+        },
+        {
+            "name": "age",
+            "type": "long"
+        },
+        {
+            "name": "address",
+            "type": {
+                "type": "record",
+                "name": "MySuperAddress",  // renamed it using alias_nested_items
+                "fields": [
+                    {
+                        "name": "street",
+                        "type": "string"
+                    },
+                    {
+                        "name": "street_number",
+                        "type": "long"
+                    }
+                ],
+                "doc": "An Address"
+            }
+        } 
+    ],
+    "doc": "An User with Address"
+}
+```

tests/schemas/avro/user_many_address_map_alias_item.avsc

@@ -0,0 +1,37 @@
+{
+    "type": "record",
+    "name": "User",
+    "fields": [
+        {
+            "name": "name",
+            "type": "string"
+        },
+        {
+            "name": "age",
+            "type": "long"
+        },
+        {
+            "name": "addresses",
+            "type": {
+                "type": "map",
+                "values": {
+                    "type": "record",
+                    "name": "Address",
+                    "fields": [
+                        {
+                            "name": "street",
+                            "type": "string"
+                        },
+                        {
+                            "name": "street_number",
+                            "type": "long"
+                        }
+                    ],
+                    "doc": "An Address"
+                },
+                "name": "address"
+            }
+        } 
+    ],
+    "doc": "User with multiple Address"
+}

tests/schemas/avro/user_one_address_alias_item.avsc

@@ -0,0 +1,33 @@
+{
+    "type": "record",
+    "name": "User",
+    "fields": [
+        {
+            "name": "name",
+            "type": "string"
+        },
+        {
+            "name": "age",
+            "type": "long"
+        },
+        {
+            "name": "address",
+            "type": {
+                "type": "record",
+                "name": "Address",
+                "fields": [
+                    {
+                        "name": "street",
+                        "type": "string"
+                    },
+                    {
+                        "name": "street_number",
+                        "type": "long"
+                    }
+                ],
+                "doc": "An Address"
+            }
+        } 
+    ],
+    "doc": "An User with Address"
+}