Добавлена документация типов

Author: Вадим Козыревский

docs/javascripts/navigation.js

@@ -68,6 +68,17 @@
             { title: 'Dependency Injection', url: 'di/', path: 'di' },
             // Request Handler
             { title: 'Commands / Requests Handling', url: 'request_handler/', path: 'request_handler' },
+            // Request / Response Types
+            { title: 'Request / Response Types', url: 'request_response_types/', path: 'request_response_types/index' },
+            { title: 'Pydantic', url: 'request_response_types/pydantic/', path: 'request_response_types/pydantic' },
+            { title: 'Dataclasses', url: 'request_response_types/dataclasses/', path: 'request_response_types/dataclasses' },
+            { title: 'Standard Classes', url: 'request_response_types/standard_classes/', path: 'request_response_types/standard_classes' },
+            { title: 'NamedTuple', url: 'request_response_types/namedtuple/', path: 'request_response_types/namedtuple' },
+            { title: 'Attrs', url: 'request_response_types/attrs/', path: 'request_response_types/attrs' },
+            { title: 'Msgspec', url: 'request_response_types/msgspec/', path: 'request_response_types/msgspec' },
+            { title: 'TypedDict', url: 'request_response_types/typeddict/', path: 'request_response_types/typeddict' },
+            { title: 'Mixed Usage', url: 'request_response_types/mixed_usage/', path: 'request_response_types/mixed_usage' },
+            { title: 'Best Practices', url: 'request_response_types/best_practices/', path: 'request_response_types/best_practices' },
             // Stream Handling
             { title: 'Stream Handling', url: 'stream_handling/', path: 'stream_handling/index' },
             { title: 'Stream Configuration', url: 'stream_handling/configuration/', path: 'stream_handling/configuration' },

docs/request_handler.md

@@ -14,6 +14,7 @@ Request handlers process commands (write operations) and queries (read operation
     Before creating handlers, ensure you've configured [Bootstrap](bootstrap/index.md) and understand [Dependency Injection](di.md).
 
 !!! tip "Related Topics"
+    - [Request / Response Types](request_response_types/index.md) — Different types for requests and responses (Pydantic, Dataclasses, attrs, etc.)
     - [Stream Handling](stream_handling/index.md) — For incremental processing
     - [Chain of Responsibility](chain_of_responsibility/index.md) — For sequential handler chains
     - [Saga Pattern](saga/index.md) — For distributed transactions with compensation

docs/request_response_types/attrs.md

@@ -0,0 +1,154 @@
+# Attrs Request/Response
+
+**Advanced features** - Uses the `attrs` library for more features than standard dataclasses.
+
+## Best For
+
+- More features than standard dataclasses
+- Functional-style codebases
+- When you need more control than dataclasses
+- Complex validation scenarios
+
+!!! info "Installation"
+    ```bash
+    pip install attrs
+    ```
+
+## Usage
+
+```python
+import cqrs
+import attrs
+from typing import Self
+
+@attrs.define
+class AttrsRequest(cqrs.IRequest):
+    """Request using attrs."""
+    user_id: str = attrs.field(validator=attrs.validators.instance_of(str))
+    action: str = attrs.field(validator=attrs.validators.instance_of(str))
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return attrs.asdict(self)
+    
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """Create from dictionary."""
+        return cls(**kwargs)
+
+@attrs.define(frozen=True)
+class AttrsResponse(cqrs.IResponse):
+    """Immutable response using attrs."""
+    result: str = attrs.field()
+    status: str = attrs.field()
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return attrs.asdict(self)
+    
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """Create from dictionary."""
+        return cls(**kwargs)
+
+class AttrsHandler(cqrs.RequestHandler[AttrsRequest, AttrsResponse]):
+    @property
+    def events(self) -> list[cqrs.IEvent]:
+        return []
+    
+    async def handle(self, request: AttrsRequest) -> AttrsResponse:
+        return AttrsResponse(
+            result=f"Processed {request.action}",
+            status="success"
+        )
+```
+
+## Validation
+
+Attrs provides powerful validation capabilities:
+
+```python
+import attrs
+from typing import Self
+
+@attrs.define
+class ValidatedRequest(cqrs.IRequest):
+    email: str = attrs.field(
+        validator=attrs.validators.matches_re(r'^[\w\.-]+@[\w\.-]+\.\w+$')
+    )
+    age: int = attrs.field(
+        validator=attrs.validators.and_(
+            attrs.validators.ge(0),
+            attrs.validators.le(120)
+        )
+    )
+    
+    def to_dict(self) -> dict:
+        return attrs.asdict(self)
+    
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        return cls(**kwargs)
+```
+
+## Custom Converters
+
+You can use converters for automatic type conversion:
+
+```python
+@attrs.define
+class ConvertedRequest(cqrs.IRequest):
+    count: int = attrs.field(converter=int)
+    tags: list[str] = attrs.field(
+        converter=lambda x: x.split(",") if isinstance(x, str) else x
+    )
+    
+    def to_dict(self) -> dict:
+        return attrs.asdict(self)
+    
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        return cls(**kwargs)
+```
+
+## Factory Functions
+
+Attrs supports factory functions for default values:
+
+```python
+@attrs.define
+class RequestWithDefaults(cqrs.IRequest):
+    user_id: str
+    metadata: dict = attrs.field(factory=dict)
+    tags: list[str] = attrs.field(factory=list)
+    
+    def to_dict(self) -> dict:
+        return attrs.asdict(self)
+    
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        return cls(**kwargs)
+```
+
+## Immutable Classes
+
+Use `frozen=True` for immutability:
+
+```python
+@attrs.define(frozen=True)
+class ImmutableRequest(cqrs.IRequest):
+    user_id: str
+    action: str
+    
+    def to_dict(self) -> dict:
+        return attrs.asdict(self)
+    
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        return cls(**kwargs)
+```
+
+## See Also
+
+- [Dataclasses](dataclasses.md) - Standard library alternative
+- [Request Handlers](../request_handler.md) - Learn about handler implementation