django-ninja-aio-crud 2.6.1__tar.gz → 2.7.0__tar.gz

{django_ninja_aio_crud-2.6.1 → django_ninja_aio_crud-2.7.0}/.github/workflows/docs.yml

@@ -18,6 +18,7 @@ on:
           - "2.4"
           - "2.5"
           - "2.6"
+          - "2.6.1"
       make_latest:
         description: 'Set as "latest" and default?'
         type: boolean
@@ -39,6 +40,7 @@ on:
           - "2.4"
           - "2.5"
           - "2.6"
+          - "2.6.1"
       delete_confirm:
         description: 'Confirm deletion of the selected version'
         type: boolean

{django_ninja_aio_crud-2.6.1 → django_ninja_aio_crud-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 2.6.1
+Version: 2.7.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10, <3.15

{django_ninja_aio_crud-2.6.1 → django_ninja_aio_crud-2.7.0}/docs/api/models/serializers.md

@@ -20,7 +20,7 @@ While both `ModelSerializer` and `Serializer` provide schema generation and CRUD
 | Schema generation        | On-demand via generate_*() methods  | On-demand via generate_*() methods            |
 | Usage                    | Inherit from ModelSerializer        | Separate serializer class                     |
 | Query optimization       | QuerySet nested class               | QuerySet nested class (inherited)             |
-| Relation serializers     | Auto-resolved                       | Explicit via relations_serializers (supports string refs) |
+| Relation serializers     | Auto-resolved                       | Explicit via relations_serializers (supports string refs & Union) |
 
 ## Key points
 
@@ -28,6 +28,7 @@ While both `ModelSerializer` and `Serializer` provide schema generation and CRUD
 - Generates read/create/update/related schemas on demand via ninja.orm.create_schema.
 - Supports explicit relation serializers for forward and reverse relations.
 - **Supports string references in `relations_serializers` for forward/circular dependencies**.
+- **Supports Union types for polymorphic relations** (e.g., generic foreign keys, content types).
 - Plays nicely with APIViewSet to auto-wire schemas and queryset handling.
 
 ## Configuration
@@ -38,7 +39,7 @@ Define a Serializer subclass with a nested Meta:
 - **schema_in**: SchemaModelConfig for create inputs
 - **schema_out**: SchemaModelConfig for read outputs
 - **schema_update**: SchemaModelConfig for patch/update inputs
-- **relations_serializers**: Mapping of relation field name -> Serializer class **or string reference** (for forward/circular dependencies)
+- **relations_serializers**: Mapping of relation field name -> Serializer class, **string reference**, or **Union of serializers** (supports forward/circular dependencies and polymorphic relations)
 
 SchemaModelConfig fields:
 
@@ -180,16 +181,191 @@ class ArticleSerializer(serializers.Serializer):
         }
 ```
 
+**String Reference Formats:**
+
+1. **Class name in the same module:**
+   ```python
+   relations_serializers = {
+       "articles": "ArticleSerializer",  # Resolved in current module
+   }
+   ```
+
+2. **Absolute import path:**
+   ```python
+   relations_serializers = {
+       "articles": "myapp.serializers.ArticleSerializer",  # Full import path
+   }
+   ```
+
 **String Reference Requirements:**
-- String must be the class name of a serializer in the same module
+- String can be the class name of a serializer in the same module, or an absolute import path
+- Absolute paths use dot notation: `"package.module.ClassName"`
 - References are resolved lazily when schemas are generated
 - Both forward and circular references are supported
 
+**Example: Cross-Module References with Absolute Paths**
+
+```python
+# myapp/serializers.py
+from ninja_aio.models import serializers
+from . import models
+
+class ArticleSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Article
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "title", "author"]
+        )
+        relations_serializers = {
+            # Reference a serializer from another module
+            "author": "users.serializers.UserSerializer",
+        }
+
+# users/serializers.py
+from ninja_aio.models import serializers
+from . import models
+
+class UserSerializer(serializers.Serializer):
+    class Meta:
+        model = models.User
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "username", "email", "articles"]
+        )
+        relations_serializers = {
+            # Reference back to the article serializer
+            "articles": "myapp.serializers.ArticleSerializer",
+        }
+```
+
+## Union Types for Polymorphic Relations
+
+You can use `Union` types in `relations_serializers` to handle polymorphic relationships where a field can reference multiple possible serializer types. This is particularly useful for generic foreign keys, content types, or any scenario where a relation can point to different model types.
+
+```python
+from typing import Union
+from ninja_aio.models import serializers
+from . import models
+
+class VideoSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Video
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "title", "duration", "url"]
+        )
+
+class ImageSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Image
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "title", "width", "height", "url"]
+        )
+
+class CommentSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Comment
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "text", "content_object"]
+        )
+        relations_serializers = {
+            # content_object can be a Video or Image
+            "content_object": Union[VideoSerializer, ImageSerializer],
+        }
+```
+
+**Union Type Formats:**
+
+1. **Direct class references:**
+   ```python
+   relations_serializers = {
+       "field": Union[SerializerA, SerializerB],
+   }
+   ```
+
+2. **String references:**
+   ```python
+   relations_serializers = {
+       "field": Union["SerializerA", "SerializerB"],
+   }
+   ```
+
+3. **Mixed class and string references:**
+   ```python
+   relations_serializers = {
+       "field": Union[SerializerA, "SerializerB"],
+   }
+   ```
+
+4. **Absolute import paths:**
+   ```python
+   relations_serializers = {
+       "field": Union["myapp.serializers.SerializerA", SerializerB],
+   }
+   ```
+
+**Use Cases for Union Types:**
+
+- **Polymorphic relations:** Generic foreign keys or Django ContentType relations
+- **Flexible APIs:** Different response formats for the same field based on runtime type
+- **Gradual migrations:** Transitioning between different serializer implementations
+- **Multi-tenant systems:** Different serialization requirements per tenant
+
+**Complete Polymorphic Example:**
+
+```python
+from typing import Union
+from django.contrib.contenttypes.fields import GenericForeignKey
+from ninja_aio.models import serializers
+
+# Models
+class Comment(models.Model):
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.PositiveIntegerField()
+    content_object = GenericForeignKey('content_type', 'object_id')
+    text = models.TextField()
+
+# Serializers for different content types
+class BlogPostSerializer(serializers.Serializer):
+    class Meta:
+        model = models.BlogPost
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "title", "body", "published_at"]
+        )
+
+class ProductSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Product
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name", "price", "stock"]
+        )
+
+class EventSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Event
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name", "date", "location"]
+        )
+
+# Comment serializer with Union support
+class CommentSerializer(serializers.Serializer):
+    class Meta:
+        model = Comment
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "text", "created_at", "content_object"]
+        )
+        relations_serializers = {
+            # Comments can be on blog posts, products, or events
+            "content_object": Union[BlogPostSerializer, ProductSerializer, EventSerializer],
+        }
+```
+
 Notes:
 
 - Forward relations are included as plain fields unless a related ModelSerializer/Serializer is declared.
 - Reverse relations require an entry in relations_serializers when using vanilla Django models.
 - When the related model is a ModelSerializer, related schemas can be auto-resolved.
+- Absolute import paths are useful for cross-module references and avoiding circular import issues at module load time.
+- Union types are resolved lazily, so forward and circular references work seamlessly.
+- The schema generator will create a union of all possible schemas from the serializers in the Union.
 
 ## Using with APIViewSet
 

{django_ninja_aio_crud-2.6.1 → django_ninja_aio_crud-2.7.0}/ninja_aio/__init__.py

@@ -1,6 +1,6 @@
 """Django Ninja AIO CRUD - Rest Framework"""
 
-__version__ = "2.6.1"
+__version__ = "2.7.0"
 
 from .api import NinjaAIO
 

{django_ninja_aio_crud-2.6.1 → django_ninja_aio_crud-2.7.0}/ninja_aio/models/serializers.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Union, get_args, get_origin, ForwardRef
 import warnings
 import sys
 
@@ -69,19 +69,14 @@ class BaseSerializer:
         raise NotImplementedError
 
     @classmethod
-    def _resolve_serializer_reference(cls, serializer_ref: str | type) -> type:
+    def _resolve_string_reference(cls, string_ref: str) -> type:
         """
-        Resolve a serializer reference that may be a string or a class.
-
-        This method performs lazy resolution, meaning it will attempt to resolve
-        string references only when called, allowing for forward references and
-        circular dependencies between serializers in the same module.
+        Resolve a string serializer reference to an actual class.
 
         Parameters
         ----------
-        serializer_ref : str | type
-            Either a string reference to a serializer class name in the same module,
-            or an actual serializer class.
+        string_ref : str
+            String reference (local class name or absolute import path).
 
         Returns
         -------
@@ -93,35 +88,152 @@ class BaseSerializer:
         ValueError
             If the string reference cannot be resolved.
         """
-        # If it's already a class, return it directly
-        if not isinstance(serializer_ref, str):
-            return serializer_ref
+        # Check if it's an absolute import path (contains dots)
+        if "." in string_ref:
+            # Absolute import path: "myapp.serializers.UserSerializer"
+            module_path, class_name = string_ref.rsplit(".", 1)
 
-        # Get the module where the current serializer class is defined
+            try:
+                # Try to get or import the module
+                module = sys.modules.get(module_path)
+                if module is None:
+                    import importlib
+                    module = importlib.import_module(module_path)
+
+                # Get the serializer class from the module
+                serializer_class = getattr(module, class_name, None)
+
+                if serializer_class is None:
+                    raise ValueError(
+                        f"Cannot resolve serializer reference '{string_ref}': "
+                        f"class '{class_name}' not found in module '{module_path}'."
+                    )
+
+                return serializer_class
+            except ImportError as e:
+                raise ValueError(
+                    f"Cannot resolve serializer reference '{string_ref}': "
+                    f"failed to import module '{module_path}': {e}"
+                )
+
+        # Local reference: simple class name in the same module
         module = sys.modules.get(cls.__module__)
 
         if module is None:
             raise ValueError(
-                f"Cannot resolve serializer reference '{serializer_ref}': "
+                f"Cannot resolve serializer reference '{string_ref}': "
                 f"module '{cls.__module__}' not found in sys.modules."
             )
 
-        # Try to get the serializer class from the module
-        serializer_class = getattr(module, serializer_ref, None)
+        serializer_class = getattr(module, string_ref, None)
 
         if serializer_class is None:
             raise ValueError(
-                f"Cannot resolve serializer reference '{serializer_ref}' in module '{cls.__module__}'. "
-                f"Make sure the serializer class '{serializer_ref}' is defined in the same module as {cls.__name__}."
+                f"Cannot resolve serializer reference '{string_ref}' in module '{cls.__module__}'. "
+                f"Make sure the serializer class '{string_ref}' is defined in the same module as {cls.__name__}."
             )
 
         return serializer_class
 
+    @classmethod
+    def _resolve_serializer_reference(cls, serializer_ref: str | type | Any) -> type | Any:
+        """
+        Resolve a serializer reference that may be a string, a class, or a Union of serializers.
+
+        This method performs lazy resolution, meaning it will attempt to resolve
+        string references only when called, allowing for forward references and
+        circular dependencies between serializers in the same module.
+
+        Parameters
+        ----------
+        serializer_ref : str | type | Union
+            Either a string reference to a serializer class, an actual serializer class,
+            or a Union of serializer references. String references can be:
+            - A class name in the same module (e.g., "UserSerializer")
+            - An absolute import path (e.g., "myapp.serializers.UserSerializer")
+
+        Returns
+        -------
+        type | Union
+            The resolved serializer class or Union of serializer classes.
+
+        Raises
+        ------
+        ValueError
+            If the string reference cannot be resolved.
+
+        Examples
+        --------
+        >>> # Single reference
+        >>> cls._resolve_serializer_reference("UserSerializer")
+        >>> cls._resolve_serializer_reference(UserSerializer)
+        >>>
+        >>> # Union reference
+        >>> from typing import Union
+        >>> cls._resolve_serializer_reference(Union[UserSerializer, AdminSerializer])
+        >>> cls._resolve_serializer_reference(Union["UserSerializer", "AdminSerializer"])
+        """
+        # Handle Union types
+        origin = get_origin(serializer_ref)
+        if origin is Union:
+            resolved_types = tuple(
+                cls._resolve_serializer_reference(arg)
+                for arg in get_args(serializer_ref)
+            )
+            # Optimize single-type unions
+            if len(resolved_types) == 1:
+                return resolved_types[0]
+            # Create Union using indexing syntax for Python 3.10+ compatibility
+            return Union[resolved_types]
+
+        # Handle ForwardRef (created when using Union["StringType"])
+        if isinstance(serializer_ref, ForwardRef):
+            return cls._resolve_serializer_reference(serializer_ref.__forward_arg__)
+
+        # Handle string references
+        if isinstance(serializer_ref, str):
+            return cls._resolve_string_reference(serializer_ref)
+
+        # Already a class, return as-is
+        return serializer_ref
+
     @classmethod
     def _get_relations_serializers(cls) -> dict[str, "Serializer"]:
         # Optional in subclasses. Default to no explicit relation serializers.
         return {}
 
+    @classmethod
+    def _generate_union_schema(cls, resolved_union: Any) -> Any:
+        """
+        Generate a Union schema from multiple resolved serializers.
+
+        Parameters
+        ----------
+        resolved_union : Union
+            A Union type containing resolved serializer classes.
+
+        Returns
+        -------
+        Schema | Union[Schema, ...] | None
+            Union of generated schemas or None if all schemas are None.
+        """
+        # Generate schemas for each serializer in the Union
+        schemas = tuple(
+            serializer_type.generate_related_s()
+            for serializer_type in get_args(resolved_union)
+            if serializer_type.generate_related_s() is not None
+        )
+
+        if not schemas:
+            return None
+
+        # Optimize single-schema unions
+        if len(schemas) == 1:
+            return schemas[0]
+
+        # Create Union of schemas using indexing syntax for Python 3.10+ compatibility
+        return Union[schemas]
+
     @classmethod
     def _resolve_relation_schema(cls, field_name: str, rel_model: models.Model):
         """
@@ -136,23 +248,30 @@ class BaseSerializer:
 
         Returns
         -------
-        Schema | None
-            Generated schema or None if cannot be resolved.
+        Schema | Union[Schema, ...] | None
+            Generated schema, Union of schemas, or None if cannot be resolved.
         """
-        # Check if related model is a ModelSerializer with readable fields
+        # Auto-resolve ModelSerializer with readable fields
         if isinstance(rel_model, ModelSerializerMeta):
             if rel_model.get_fields("read") or rel_model.get_custom_fields("read"):
                 return rel_model.generate_related_s()
             return None
 
-        # Fall back to explicit serializer mapping
+        # Resolve from explicit serializer mapping
         rel_serializers = cls._get_relations_serializers() or {}
         serializer_ref = rel_serializers.get(field_name)
-        if serializer_ref:
-            serializer = cls._resolve_serializer_reference(serializer_ref)
-            return serializer.generate_related_s()
 
-        return None
+        if not serializer_ref:
+            return None
+
+        resolved = cls._resolve_serializer_reference(serializer_ref)
+
+        # Handle Union of serializers
+        if get_origin(resolved) is Union:
+            return cls._generate_union_schema(resolved)
+
+        # Handle single serializer
+        return resolved.generate_related_s()
 
     @classmethod
     def _is_special_field(

django_ninja_aio_crud-2.7.0/tests/test_serializers.py

@@ -0,0 +1,291 @@
+import warnings
+from typing import Union
+from django.test import TestCase, tag
+
+from tests.test_app.models import TestModelForeignKey, TestModelReverseForeignKey
+from ninja_aio.models import serializers
+
+
+class TestModelForeignKeySerializer(serializers.Serializer):
+    class Meta:
+        model = TestModelForeignKey
+        schema_in = serializers.SchemaModelConfig(
+            fields=["name", "description", "test_model"]
+        )
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name", "description", "test_model"]
+        )
+
+
+class TestModelReverseForeignKeySerializer(serializers.Serializer):
+    class Meta:
+        model = TestModelReverseForeignKey
+        schema_in = serializers.SchemaModelConfig(fields=["name", "description"])
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name", "description", "test_model_foreign_keys"]
+        )
+        relations_serializers = {
+            "test_model_foreign_keys": TestModelForeignKeySerializer,
+        }
+
+
+# Test serializers for Union tests - defined at module level so they can be resolved
+class AltSerializer(serializers.Serializer):
+    class Meta:
+        model = TestModelForeignKey
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name"]
+        )
+
+
+class AltStringSerializer(serializers.Serializer):
+    class Meta:
+        model = TestModelForeignKey
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "description"]
+        )
+
+
+class MixedAltSerializer(serializers.Serializer):
+    class Meta:
+        model = TestModelForeignKey
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name", "description"]
+        )
+
+
+class LocalTestSerializer(serializers.Serializer):
+    class Meta:
+        model = TestModelForeignKey
+        schema_out = serializers.SchemaModelConfig(fields=["id"])
+
+
+@tag("serializers")
+class SerializersTestCase(TestCase):
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.serializer_fk = TestModelForeignKeySerializer
+        cls.serializer_rfk = TestModelReverseForeignKeySerializer
+        warnings.simplefilter("ignore", UserWarning)  # Ignora tutti i UserWarning
+
+    def test_generate_schema_out(self):
+        schema_out_fk = self.serializer_fk.generate_read_s()
+        for f in ["id", "name", "description", "test_model"]:
+            self.assertIn(f, schema_out_fk.model_fields)
+
+        schema_out_rfk = self.serializer_rfk.generate_read_s()
+        for f in ["id", "name", "description", "test_model_foreign_keys"]:
+            self.assertIn(f, schema_out_rfk.model_fields)
+
+    def test_generate_schema_in(self):
+        schema_in_fk = self.serializer_fk.generate_create_s()
+        # In schema should include declared input fields
+        for f in ["name", "description", "test_model"]:
+            self.assertIn(f, schema_in_fk.model_fields)
+        self.assertNotIn("id", schema_in_fk.model_fields)
+
+        schema_in_rfk = self.serializer_rfk.generate_create_s()
+        for f in ["name", "description"]:
+            self.assertIn(f, schema_in_rfk.model_fields)
+
+    def test_generate_schema_update(self):
+        # If no fields provided for update, optional fields should be honored when declared
+        # Here no explicit update config exists, so update schema may be None or empty depending on implementation
+        schema_patch_fk = self.serializer_fk.generate_update_s()
+        # Implementation returns a schema when fields/customs/excludes exist; otherwise may fallback to optionals.
+        # Our Meta doesn't define update, so ensure function doesn't crash and returns a Schema or None
+        self.assertTrue(
+            schema_patch_fk is None or hasattr(schema_patch_fk, "model_fields")
+        )
+
+        schema_patch_rfk = self.serializer_rfk.generate_update_s()
+        self.assertTrue(
+            schema_patch_rfk is None or hasattr(schema_patch_rfk, "model_fields")
+        )
+
+    def test_generate_related_schema(self):
+        related_fk = self.serializer_fk.generate_related_s()
+        # Related schema should include non-relational read fields only
+        for f in ["id", "name", "description"]:
+            self.assertIn(f, related_fk.model_fields)
+        # Forward relation declared on fk read fields should still be present as plain field in read, but not in related
+        self.assertNotIn("test_model", related_fk.model_fields)
+
+        related_rfk = self.serializer_rfk.generate_related_s()
+        for f in ["id", "name", "description"]:
+            self.assertIn(f, related_rfk.model_fields)
+        # Reverse relation should be excluded from related schema
+        self.assertNotIn("test_model_foreign_keys", related_rfk.model_fields)
+
+    def test_relation_serializer_required_when_mapping_provided(self):
+        # When relations_serializers mapping exists, any relation field listed in read fields must have a mapping
+        class BadSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelReverseForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", "description", "test_model_foreign_keys"]
+                )
+                relations_serializers = {}
+
+    def test_relation_serializer_inclusion(self):
+        # Ensure that providing relations_serializers yields nested related schema in read
+        schema_out_rfk = self.serializer_rfk.generate_read_s()
+        # The reverse relation should be represented as a field; the nested schema type comes from ninja's create_schema.
+        self.assertIn("test_model_foreign_keys", schema_out_rfk.model_fields)
+        # Also ensure base fields present
+        for f in ["id", "name", "description"]:
+            self.assertIn(f, schema_out_rfk.model_fields)
+
+
+@tag("serializers", "union")
+class UnionSerializerTestCase(TestCase):
+    """Test cases for Union serializer references support."""
+
+    def setUp(self):
+        warnings.simplefilter("ignore", UserWarning)
+
+    def test_union_with_direct_class_references(self):
+        """Test Union with direct class references."""
+
+        class UnionTestSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelReverseForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", "test_model_foreign_keys"]
+                )
+                relations_serializers = {
+                    "test_model_foreign_keys": Union[TestModelForeignKeySerializer, AltSerializer],
+                }
+
+        # Should resolve without errors
+        schema = UnionTestSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("test_model_foreign_keys", schema.model_fields)
+
+    def test_union_with_string_references(self):
+        """Test Union with string references."""
+
+        class UnionStringTestSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelReverseForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", "test_model_foreign_keys"]
+                )
+                relations_serializers = {
+                    "test_model_foreign_keys": Union["TestModelForeignKeySerializer", "AltStringSerializer"],
+                }
+
+        # Should resolve without errors
+        schema = UnionStringTestSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("test_model_foreign_keys", schema.model_fields)
+
+    def test_union_with_mixed_references(self):
+        """Test Union with mixed class and string references."""
+
+        class UnionMixedTestSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelReverseForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", "test_model_foreign_keys"]
+                )
+                relations_serializers = {
+                    "test_model_foreign_keys": Union[MixedAltSerializer, "TestModelForeignKeySerializer"],
+                }
+
+        # Should resolve without errors
+        schema = UnionMixedTestSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("test_model_foreign_keys", schema.model_fields)
+
+    def test_union_with_absolute_import_path(self):
+        """Test Union with absolute import path string references."""
+
+        class UnionAbsolutePathSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelReverseForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", "test_model_foreign_keys"]
+                )
+                relations_serializers = {
+                    "test_model_foreign_keys": Union[
+                        "tests.test_serializers.TestModelForeignKeySerializer",
+                        TestModelForeignKeySerializer,
+                    ],
+                }
+
+        # Should resolve without errors
+        schema = UnionAbsolutePathSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("test_model_foreign_keys", schema.model_fields)
+
+    def test_resolve_serializer_reference_with_union(self):
+        """Test _resolve_serializer_reference directly with Union types."""
+        from typing import get_args, get_origin
+
+        # Test with Union of DIFFERENT classes (Union of same type gets optimized away by Python)
+        union_ref = Union[TestModelForeignKeySerializer, AltSerializer]
+        resolved = TestModelForeignKeySerializer._resolve_serializer_reference(union_ref)
+
+        # Check that it returns a Union (using reduce with or_ creates a union-like structure)
+        # The resolved type should be a union of the two serializers
+        self.assertEqual(get_origin(resolved), Union)
+        resolved_args = get_args(resolved)
+        self.assertEqual(len(resolved_args), 2)
+        # Should contain both serializer classes
+        self.assertIn(TestModelForeignKeySerializer, resolved_args)
+        self.assertIn(AltSerializer, resolved_args)
+
+    def test_resolve_serializer_reference_with_string_union(self):
+        """Test _resolve_serializer_reference with Union of strings."""
+        from typing import get_args, get_origin
+
+        # Test with Union of string references
+        union_ref = Union["TestModelForeignKeySerializer", "LocalTestSerializer"]
+        resolved = LocalTestSerializer._resolve_serializer_reference(union_ref)
+
+        # Check that it returns a Union
+        self.assertEqual(get_origin(resolved), Union)
+        resolved_types = get_args(resolved)
+        self.assertEqual(len(resolved_types), 2)
+
+        # Verify that both serializers are resolved correctly
+        self.assertIn(TestModelForeignKeySerializer, resolved_types)
+        self.assertIn(LocalTestSerializer, resolved_types)
+
+    def test_single_serializer_still_works(self):
+        """Ensure single serializer references still work as before."""
+
+        class SingleRefSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelReverseForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", "test_model_foreign_keys"]
+                )
+                relations_serializers = {
+                    "test_model_foreign_keys": TestModelForeignKeySerializer,
+                }
+
+        # Should work exactly as before
+        schema = SingleRefSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("test_model_foreign_keys", schema.model_fields)
+
+    def test_single_string_serializer_still_works(self):
+        """Ensure single string serializer references still work as before."""
+
+        class SingleStringRefSerializer(serializers.Serializer):
+            class Meta:
+                model = TestModelReverseForeignKey
+                schema_out = serializers.SchemaModelConfig(
+                    fields=["id", "name", "test_model_foreign_keys"]
+                )
+                relations_serializers = {
+                    "test_model_foreign_keys": "TestModelForeignKeySerializer",
+                }
+
+        # Should work exactly as before
+        schema = SingleStringRefSerializer.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("test_model_foreign_keys", schema.model_fields)

django_ninja_aio_crud-2.6.1/tests/test_serializers.py

@@ -1,106 +0,0 @@
-import warnings
-from django.test import TestCase, tag
-
-from tests.test_app.models import TestModelForeignKey, TestModelReverseForeignKey
-from ninja_aio.models import serializers
-
-
-class TestModelForeignKeySerializer(serializers.Serializer):
-    class Meta:
-        model = TestModelForeignKey
-        schema_in = serializers.SchemaModelConfig(
-            fields=["name", "description", "test_model"]
-        )
-        schema_out = serializers.SchemaModelConfig(
-            fields=["id", "name", "description", "test_model"]
-        )
-
-
-class TestModelReverseForeignKeySerializer(serializers.Serializer):
-    class Meta:
-        model = TestModelReverseForeignKey
-        schema_in = serializers.SchemaModelConfig(fields=["name", "description"])
-        schema_out = serializers.SchemaModelConfig(
-            fields=["id", "name", "description", "test_model_foreign_keys"]
-        )
-        relations_serializers = {
-            "test_model_foreign_keys": TestModelForeignKeySerializer,
-        }
-
-
-@tag("serializers")
-class SerializersTestCase(TestCase):
-
-    @classmethod
-    def setUpTestData(cls):
-        cls.serializer_fk = TestModelForeignKeySerializer
-        cls.serializer_rfk = TestModelReverseForeignKeySerializer
-        warnings.simplefilter("ignore", UserWarning)  # Ignora tutti i UserWarning
-
-    def test_generate_schema_out(self):
-        schema_out_fk = self.serializer_fk.generate_read_s()
-        for f in ["id", "name", "description", "test_model"]:
-            self.assertIn(f, schema_out_fk.model_fields)
-
-        schema_out_rfk = self.serializer_rfk.generate_read_s()
-        for f in ["id", "name", "description", "test_model_foreign_keys"]:
-            self.assertIn(f, schema_out_rfk.model_fields)
-
-    def test_generate_schema_in(self):
-        schema_in_fk = self.serializer_fk.generate_create_s()
-        # In schema should include declared input fields
-        for f in ["name", "description", "test_model"]:
-            self.assertIn(f, schema_in_fk.model_fields)
-        self.assertNotIn("id", schema_in_fk.model_fields)
-
-        schema_in_rfk = self.serializer_rfk.generate_create_s()
-        for f in ["name", "description"]:
-            self.assertIn(f, schema_in_rfk.model_fields)
-
-    def test_generate_schema_update(self):
-        # If no fields provided for update, optional fields should be honored when declared
-        # Here no explicit update config exists, so update schema may be None or empty depending on implementation
-        schema_patch_fk = self.serializer_fk.generate_update_s()
-        # Implementation returns a schema when fields/customs/excludes exist; otherwise may fallback to optionals.
-        # Our Meta doesn't define update, so ensure function doesn't crash and returns a Schema or None
-        self.assertTrue(
-            schema_patch_fk is None or hasattr(schema_patch_fk, "model_fields")
-        )
-
-        schema_patch_rfk = self.serializer_rfk.generate_update_s()
-        self.assertTrue(
-            schema_patch_rfk is None or hasattr(schema_patch_rfk, "model_fields")
-        )
-
-    def test_generate_related_schema(self):
-        related_fk = self.serializer_fk.generate_related_s()
-        # Related schema should include non-relational read fields only
-        for f in ["id", "name", "description"]:
-            self.assertIn(f, related_fk.model_fields)
-        # Forward relation declared on fk read fields should still be present as plain field in read, but not in related
-        self.assertNotIn("test_model", related_fk.model_fields)
-
-        related_rfk = self.serializer_rfk.generate_related_s()
-        for f in ["id", "name", "description"]:
-            self.assertIn(f, related_rfk.model_fields)
-        # Reverse relation should be excluded from related schema
-        self.assertNotIn("test_model_foreign_keys", related_rfk.model_fields)
-
-    def test_relation_serializer_required_when_mapping_provided(self):
-        # When relations_serializers mapping exists, any relation field listed in read fields must have a mapping
-        class BadSerializer(serializers.Serializer):
-            class Meta:
-                model = TestModelReverseForeignKey
-                schema_out = serializers.SchemaModelConfig(
-                    fields=["id", "name", "description", "test_model_foreign_keys"]
-                )
-                relations_serializers = {}
-
-    def test_relation_serializer_inclusion(self):
-        # Ensure that providing relations_serializers yields nested related schema in read
-        schema_out_rfk = self.serializer_rfk.generate_read_s()
-        # The reverse relation should be represented as a field; the nested schema type comes from ninja's create_schema.
-        self.assertIn("test_model_foreign_keys", schema_out_rfk.model_fields)
-        # Also ensure base fields present
-        for f in ["id", "name", "description"]:
-            self.assertIn(f, schema_out_rfk.model_fields)