django-ninja-aio-crud 2.1.0__tar.gz → 2.2.0__tar.gz

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/.github/workflows/docs.yml

@@ -96,7 +96,7 @@ jobs:
           if [ "$MAKE_LATEST" = "true" ]; then
             echo "Deploying $VERSION as latest and default"
             mike deploy --push --update-aliases "$VERSION" latest --ignore-remote-status
-            mike set-default "$VERSION"
+            mike set-default --push latest
           else
             echo "Deploying $VERSION (non-latest)"
             mike deploy --push "$VERSION" --ignore-remote-status

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 2.1.0
+Version: 2.2.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
-Requires-Python: >=3.10
+Requires-Python: >=3.10, <=3.14
 Description-Content-Type: text/markdown
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/docs/api/authentication.md

@@ -614,188 +614,11 @@ Support both JWT and API Key:
 class ArticleViewSet(APIViewSet):
     model = Article
     api = api
-    auth = [JWTAuth() | APIKeyAuth()]  # Either JWT or API Key
+    auth = [JWTAuth(), APIKeyAuth()]  # Either JWT or API Key
 ```
 
 Django Ninja will try both methods; if either succeeds, the request is authenticated.
 
-## Token Validation
-
-### Expiration Validation
-
-JWT tokens include `exp` claim (expiration timestamp):
-
-```python
-# Token payload
-{
-  "sub": "123",
-  "exp": 1704067200,  # Unix timestamp
-  "iat": 1704063600
-}
-```
-
-AsyncJwtBearer automatically validates expiration:
-
-```python
-class JWTAuth(AsyncJwtBearer):
-    jwt_public = jwk.RSAKey.import_key(PUBLIC_KEY)
-    # Expiration checked automatically
-```
-
-**Error Response:**
-
-```json
-{
-  "detail": "Token has expired"
-}
-```
-
-### Not Before Validation
-
-Use `nbf` claim for tokens that become valid in the future:
-
-```python
-# Token payload
-{
-  "sub": "123",
-  "nbf": 1704063600,  # Not valid before this time
-  "exp": 1704067200
-}
-```
-
-Automatically validated by AsyncJwtBearer.
-
-### Custom Validation
-
-```python
-class StrictAuth(AsyncJwtBearer):
-    jwt_public = jwk.RSAKey.import_key(PUBLIC_KEY)
-
-    async def auth_handler(self, request):
-        # Check token type
-        token_type = self.dcd.claims.get("typ")
-        if token_type != "access":
-            return False
-
-        # Check IP whitelist
-        allowed_ips = self.dcd.claims.get("allowed_ips", [])
-        client_ip = request.META.get('REMOTE_ADDR')
-        if allowed_ips and client_ip not in allowed_ips:
-            return False
-
-        # Continue with normal auth
-        user_id = self.dcd.claims.get("sub")
-        return await User.objects.aget(id=user_id)
-```
-
-## Testing Authentication
-
-### Unit Tests
-
-```python
-import pytest
-from ninja.testing import TestAsyncClient
-from myapp.views import api
-from myapp.auth import JWTAuth
-import jwt
-from datetime import datetime, timedelta
-
-
-def create_token(user_id: int, **claims) -> str:
-    payload = {
-        "sub": str(user_id),
-        "exp": datetime.utcnow() + timedelta(hours=1),
-        "iat": datetime.utcnow(),
-        **claims
-    }
-    return jwt.encode(payload, PRIVATE_KEY, algorithm="RS256")
-
-
-@pytest.mark.asyncio
-async def test_authenticated_request():
-    client = TestAsyncClient(api)
-
-    # Create user
-    user = await User.objects.acreate(username="testuser")
-
-    # Create token
-    token = create_token(user.id)
-
-    # Make authenticated request
-    response = await client.get(
-        "/article/",
-        headers={"Authorization": f"Bearer {token}"}
-    )
-
-    assert response.status_code == 200
-
-
-@pytest.mark.asyncio
-async def test_missing_token():
-    client = TestAsyncClient(api)
-
-    response = await client.get("/article/")
-    assert response.status_code == 401
-    assert "detail" in response.json()
-
-
-@pytest.mark.asyncio
-async def test_expired_token():
-    client = TestAsyncClient(api)
-
-    # Create expired token
-    payload = {
-        "sub": "123",
-        "exp": datetime.utcnow() - timedelta(hours=1),  # Expired
-        "iat": datetime.utcnow() - timedelta(hours=2)
-    }
-    token = jwt.encode(payload, PRIVATE_KEY, algorithm="RS256")
-
-    response = await client.get(
-        "/article/",
-        headers={"Authorization": f"Bearer {token}"}
-    )
-
-    assert response.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_invalid_signature():
-    client = TestAsyncClient(api)
-
-    # Create token with wrong key
-    payload = {"sub": "123", "exp": datetime.utcnow() + timedelta(hours=1)}
-    token = jwt.encode(payload, "wrong-secret", algorithm="HS256")
-
-    response = await client.get(
-        "/article/",
-        headers={"Authorization": f"Bearer {token}"}
-    )
-
-    assert response.status_code == 401
-```
-
-### Mock Authentication
-
-For testing without real tokens:
-
-```python
-from unittest.mock import AsyncMock, patch
-
-
-@pytest.mark.asyncio
-@patch('myapp.auth.JWTAuth.auth_handler')
-async def test_with_mock_auth(mock_auth):
-    # Mock auth to return test user
-    user = await User.objects.acreate(username="testuser")
-    mock_auth.return_value = user
-
-    client = TestAsyncClient(api)
-    response = await client.get("/article/")
-
-    assert response.status_code == 200
-```
-
 ## Best Practices
 
 1. **Use RSA (asymmetric) keys for production:**

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/docs/api/views/api_view.md

@@ -81,15 +81,12 @@ Registers all defined views to the API instance.
 
 **Returns:** The router instance
 
-**Usage:**
-
-```python
-view = UserAPIView()
-view.add_views_to_route()
-```
+**Note:** When using `@api.view(prefix="/path", tags=[...])`, manual registration via `add_views_to_route()` is not required; the router is mounted automatically.
 
 ## Complete Example
 
+**Recommended:**
+
 ```python
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIView
@@ -101,6 +98,23 @@ class StatsSchema(Schema):
     total: int
     active: int
 
+@api.view(prefix="/analytics", tags=["Analytics"])
+class AnalyticsView(APIView):
+    def views(self):
+        @self.router.get("/dashboard", response=StatsSchema)
+        async def dashboard(request):
+            return {"total": 1000, "active": 750}
+
+        @self.router.post("/track")
+        async def track_event(request, event: str):
+            return {"tracked": event}
+```
+
+**Alternative implementation:**
+
+```python
+api = NinjaAIO(title="My API")
+
 class AnalyticsView(APIView):
     api = api
     router_tag = "Analytics"
@@ -109,26 +123,21 @@ class AnalyticsView(APIView):
     def views(self):
         @self.router.get("/dashboard", response=StatsSchema)
         async def dashboard(request):
-            return {
-                "total": 1000,
-                "active": 750
-            }
+            return {"total": 1000, "active": 750}
 
         @self.router.post("/track")
         async def track_event(request, event: str):
-            # tracking logic
             return {"tracked": event}
 
-# Register views
 AnalyticsView().add_views_to_route()
 ```
 
 ## Notes
 
 - Use `APIView` for simple, non-CRUD endpoints
-- For CRUD operations, use [`APIViewSet`](api_view_set.md) instead
-- All views are automatically async-compatible
-- Error codes `{400, 401, 404, 428}` are available via `self.error_codes`
+- For CRUD operations, use [`APIViewSet`](api_view_set.md)
+- All views are async-compatible
+- Standard error codes are available via `self.error_codes`
 
 Note:
 

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/docs/api/views/api_view_set.md

@@ -16,7 +16,7 @@ Notes:
 
 - Retrieve path has no trailing slash; update/delete include a trailing slash.
 - `{base}` auto-resolves from model verbose name plural (lowercase) unless `api_route_path` is provided.
-- Error responses may use a unified generic schema for codes: 400, 401, 404, 428.
+- Error responses may use a unified generic schema for codes: 400, 401, 404.
 
 ## Core Attributes
 
@@ -317,7 +317,7 @@ All generated handlers are decorated with `@unique_view(...)` to ensure stable u
 
 ## Error Handling
 
-All CRUD and M2M endpoints may respond with `GenericMessageSchema` for error codes: 400 (validation), 401 (auth), 404 (not found), 428 (precondition required).
+All CRUD and M2M endpoints may respond with `GenericMessageSchema` for error codes: 400 (validation), 401 (auth), 404 (not found).
 
 ## Performance Tips
 
@@ -329,7 +329,31 @@ All CRUD and M2M endpoints may respond with `GenericMessageSchema` for error cod
 
 ## Minimal Usage
 
+Recommended:
+
+```python
+from ninja_aio import NinjaAIO
+from ninja_aio.views import APIViewSet
+from .models import User
+
+api = NinjaAIO(title="My API")
+
+@api.viewset(model=User)
+class UserViewSet(APIViewSet):
+    pass
+```
+
+Note: prefix and tags are optional. If omitted, the base path is inferred from the model verbose name plural and tags default to the model verbose name.
+
+Alternative implementation:
+
 ```python
+from ninja_aio import NinjaAIO
+from ninja_aio.views import APIViewSet
+from .models import User
+
+api = NinjaAIO(title="My API")
+
 class UserViewSet(APIViewSet):
     model = User
     api = api
@@ -340,18 +364,16 @@ UserViewSet().add_views_to_route()
 ## Disable Selected Views
 
 ```python
+@api.viewset(model=User)
 class ReadOnlyUserViewSet(APIViewSet):
-    model = User
-    api = api
     disable = ["create", "update", "delete"]
 ```
 
 ## Authentication Example
 
 ```python
+@api.viewset(model=User)
 class UserViewSet(APIViewSet):
-    model = User
-    api = api
     auth = [JWTAuth()]      # global fallback
     get_auth = None         # list/retrieve public
     delete_auth = [AdminAuth()]  # delete restricted
@@ -359,7 +381,16 @@ class UserViewSet(APIViewSet):
 
 ## Complete M2M + Filters Example
 
+Recommended:
+
 ```python
+from ninja_aio import NinjaAIO
+from ninja_aio.views import APIViewSet
+from ninja_aio.models import ModelSerializer
+from django.db import models
+
+api = NinjaAIO(title="My API")
+
 class Tag(ModelSerializer):
     name = models.CharField(max_length=100)
     class ReadSerializer:
@@ -371,12 +402,9 @@ class User(ModelSerializer):
     class ReadSerializer:
         fields = ["id", "username", "tags"]
 
+@api.viewset(model=User)
 class UserViewSet(APIViewSet):
-    model = User
-    api = api
-    query_params = {
-        "search": (str, None)
-    }
+    query_params = {"search": (str, None)}
     m2m_relations = [
         M2MRelationSchema(
             model=Tag,
@@ -384,7 +412,7 @@ class UserViewSet(APIViewSet):
             filters={"name": (str, "")},
             add=True,
             remove=True,
-            get=True
+            get=True,
         )
     ]
 
@@ -402,57 +430,60 @@ class UserViewSet(APIViewSet):
         return queryset
 ```
 
----
+Alternative implementation:
 
-## ReadOnlyViewSet
+```python
+class UserViewSet(APIViewSet):
+    model = User
+    api = api
+    query_params = {"search": (str, None)}
+    m2m_relations = [
+        M2MRelationSchema(
+            model=Tag,
+            related_name="tags",
+            filters={"name": (str, "")},
+            add=True,
+            remove=True,
+            get=True,
+        )
+    ]
 
-ReadOnlyViewSet is a convenience subclass of APIViewSet that enables only list and retrieve endpoints. It is equivalent to setting `disable = ["create", "update", "delete"]`.
+    async def query_params_handler(self, queryset, filters):
+        if filters.get("search"):
+            from django.db.models import Q
+            s = filters["search"]
+            return queryset.filter(Q(username__icontains=s))
+        return queryset
 
-Generated endpoints:
+    async def tags_query_params_handler(self, queryset, filters):
+        name_filter = filters.get("name")
+        if name_filter:
+            queryset = queryset.filter(name__icontains=name_filter)
+        return queryset
 
-- GET `/{base}/` -> List
-- GET `/{base}/{pk}` -> Retrieve
+UserViewSet().add_views_to_route()
+```
 
-Minimal usage:
+## ReadOnlyViewSet
+
+ReadOnlyViewSet enables only list and retrieve endpoints.
 
 ```python
+@api.viewset(model=MyModel)
 class MyModelReadOnlyViewSet(ReadOnlyViewSet):
-    model = MyModel
-    api = api
-
-MyModelReadOnlyViewSet().add_views_to_route()
+    pass
 ```
 
-Notes:
-
-- Supports all features of APIViewSet relevant to read operations (pagination, list filters, auth per verb, dynamic schema generation when using ModelSerializer).
-- M2M endpoints can still be added via `m2m_relations` if desired.
-
 ## WriteOnlyViewSet
 
-WriteOnlyViewSet is a convenience subclass of APIViewSet that enables only create, update, and delete endpoints. It is equivalent to setting `disable = ["list", "retrieve"]`.
-
-Generated endpoints:
-
-- POST `/{base}/` -> Create
-- PATCH `/{base}/{pk}/` -> Update
-- DELETE `/{base}/{pk}/` -> Delete
-
-Minimal usage:
+WriteOnlyViewSet enables only create, update, and delete endpoints.
 
 ```python
+@api.viewset(model=MyModel)
 class MyModelWriteOnlyViewSet(WriteOnlyViewSet):
-    model = MyModel
-    api = api
-
-MyModelWriteOnlyViewSet().add_views_to_route()
+    pass
 ```
 
-Notes:
-
-- Supports auth per verb and dynamic schema generation for write operations when using ModelSerializer.
-- M2M endpoints can still be added via `m2m_relations` if desired.
-
 ## See Also
 
 - [ModelSerializer](../models/model_serializer.md)

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/docs/index.md

@@ -34,31 +34,27 @@ Traditional Django REST development requires:
 
 === "Traditional Approach"
     ```python
-    # serializers.py
-    class UserSerializer(serializers.ModelSerializer):
+    # schema.py
+    class UserSchemaOut(ModelSchema)
         class Meta:
             model = User
             fields = ['id', 'username', 'email']
     
-    class UserCreateSerializer(serializers.ModelSerializer):
+    class UserSchemaIn(ModelSchema):
         class Meta:
             model = User
             fields = ['username', 'email', 'password']
     
     # views.py
-    class UserListView(APIView):
-        async def get(self, request):
-            users = await sync_to_async(list)(User.objects.all())
-            serializer = UserSerializer(users, many=True)
-            return Response(serializer.data)
+    @api.get("/users", response={200: list[UserSchemaOut]})
+    async def list_users(request):
+        return [user async for user in User.objects.select_related().all()]
     
-    class UserCreateView(APIView):
-        async def post(self, request):
-            serializer = UserCreateSerializer(data=request.data)
-            if serializer.is_valid():
-                user = await sync_to_async(serializer.save)()
-                return Response(UserSerializer(user).data)
-            return Response(serializer.errors, status=400)
+    @api.post("/users/", response={201: UserSchemaOut})
+    async def create_user(request, data: UserSchemaIn):
+        user = await User.objects.select_related().acreate(**data.model_dump())
+        return 201, user
+
     
     # ... more views for retrieve, update, delete
     ```

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/mkdocs.yml

@@ -20,7 +20,7 @@ nav:
       - APIView: api/views/api_view.md
       - APIViewSet: api/views/api_view_set.md
       - Decorators: api/views/decorators.md
-      - Mixins: docs/mixins.md
+      - Mixins: api/views/mixins.md
     - Models:
       - ModelSerializer: api/models/model_serializer.md
       - ModelUtil: api/models/model_util.md
@@ -97,7 +97,6 @@ extra:
   version:
     provider: mike
     repo: caspel26/django-ninja-aio-crud
-    stable: true
     default: latest
 
 plugins:

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/ninja_aio/api.py

@@ -5,10 +5,13 @@ from ninja.throttling import BaseThrottle
 from ninja import NinjaAPI
 from ninja.openapi.docs import DocsBase, Swagger
 from ninja.constants import NOT_SET, NOT_SET_TYPE
+from django.db import models
 
 from .parsers import ORJSONParser
 from .renders import ORJSONRenderer
 from .exceptions import set_api_exception_handlers
+from .views import APIView, APIViewSet
+from .models import ModelSerializer
 
 
 class NinjaAIO(NinjaAPI):
@@ -49,3 +52,24 @@ class NinjaAIO(NinjaAPI):
     def set_default_exception_handlers(self):
         set_api_exception_handlers(self)
         super().set_default_exception_handlers()
+
+    def view(self, prefix: str, tags: list[str] = None) -> Any:
+        def wrapper(view: type[APIView]):
+            instance = view(api=self, prefix=prefix, tags=tags)
+            instance.add_views_to_route()
+            return instance
+
+        return wrapper
+
+    def viewset(
+        self,
+        model: models.Model | ModelSerializer,
+        prefix: str = None,
+        tags: list[str] = None,
+    ) -> None:
+        def wrapper(viewset: type[APIViewSet]):
+            instance = viewset(api=self, model=model, prefix=prefix, tags=tags)
+            instance.add_views_to_route()
+            return instance
+
+        return wrapper

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/ninja_aio/auth.py

@@ -124,7 +124,7 @@ def validate_key(key: Optional[JwtKeys], setting_name: str) -> JwtKeys:
         key = getattr(settings, setting_name, None)
     if key is None:
         raise ValueError(f"{setting_name} is required")
-    if not isinstance(key, (jwk.RSAKey, jwk.ECKey)):
+    if not isinstance(key, (jwk.RSAKey, jwk.ECKey, jwk.OctKey)):
         raise ValueError(
             f"{setting_name} must be an instance of jwk.RSAKey or jwk.ECKey"
         )
@@ -143,7 +143,7 @@ def validate_mandatory_claims(claims: dict) -> dict:
 
 
 def encode_jwt(
-    claims: dict, duration: int, private_key: jwk.RSAKey = None, algorithm: str = None
+    claims: dict, duration: int, private_key: JwtKeys = None, algorithm: str = None
 ) -> str:
     """
     Encode and sign a JWT.
@@ -192,7 +192,7 @@ def encode_jwt(
 
 def decode_jwt(
     token: str,
-    public_key: jwk.RSAKey | jwk.ECKey = None,
+    public_key: JwtKeys = None,
     algorithms: list[str] = None,
 ) -> jwt.Token:
     """

{django_ninja_aio_crud-2.1.0 → django_ninja_aio_crud-2.2.0}/ninja_aio/types.py

@@ -8,7 +8,7 @@ S_TYPES = Literal["read", "create", "update"]
 F_TYPES = Literal["fields", "customs", "optionals", "excludes"]
 SCHEMA_TYPES = Literal["In", "Out", "Patch", "Related"]
 VIEW_TYPES = Literal["list", "retrieve", "create", "update", "delete", "all"]
-JwtKeys: TypeAlias = jwk.RSAKey | jwk.ECKey
+JwtKeys: TypeAlias = jwk.RSAKey | jwk.ECKey | jwk.OctKey
 
 class ModelSerializerType(type):
     def __repr__(self):