django-ninja-jsonapi 0.2.0__py3-none-any.whl

django_ninja_jsonapi/VERSION

@@ -0,0 +1 @@
+0.1.0

django_ninja_jsonapi/__init__.py

@@ -0,0 +1,34 @@
+"""JSON API utils package."""
+
+from pathlib import Path
+from typing import Any
+
+from django_ninja_jsonapi.exceptions import BadRequest
+from django_ninja_jsonapi.exceptions.json_api import HTTPException
+from django_ninja_jsonapi.querystring import QueryStringManager
+from django_ninja_jsonapi.renderers import JSONAPIRenderer
+
+__version__ = Path(__file__).parent.joinpath("VERSION").read_text().strip()
+
+__all__ = [
+    "ApplicationBuilder",
+    "BadRequest",
+    "HTTPException",
+    "JSONAPIRenderer",
+    "QueryStringManager",
+    "ViewBaseGeneric",
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "ApplicationBuilder":
+        from django_ninja_jsonapi.api.application_builder import ApplicationBuilder
+
+        return ApplicationBuilder
+
+    if name == "ViewBaseGeneric":
+        from django_ninja_jsonapi.generics import ViewBaseGeneric
+
+        return ViewBaseGeneric
+
+    raise AttributeError(name)

django_ninja_jsonapi/api/application_builder.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, Callable, Iterable, Optional, Type
+
+from ninja import NinjaAPI, Router
+from pydantic import BaseModel
+
+from django_ninja_jsonapi.api.endpoint_builder import EndpointsBuilder
+from django_ninja_jsonapi.api.schemas import ResourceData
+from django_ninja_jsonapi.atomic.atomic import AtomicOperations
+from django_ninja_jsonapi.data_typing import TypeModel
+from django_ninja_jsonapi.exceptions import HTTPException
+from django_ninja_jsonapi.exceptions.handlers import base_exception_handler
+from django_ninja_jsonapi.renderers import JSONAPIRenderer
+from django_ninja_jsonapi.schema_builder import SchemaBuilder
+from django_ninja_jsonapi.storages.models_storage import models_storage
+from django_ninja_jsonapi.storages.schemas_storage import schemas_storage
+from django_ninja_jsonapi.storages.views_storage import views_storage
+from django_ninja_jsonapi.views.enums import Operation
+
+
+class ApplicationBuilderError(Exception):
+    pass
+
+
+class ApplicationBuilder:
+    def __init__(
+        self,
+        api: NinjaAPI,
+        base_router: Optional[Router] = None,
+        exception_handler: Optional[Callable] = None,
+        **base_router_include_kwargs,
+    ):
+        self._api = api
+        self._base_router = base_router or Router()
+        self._base_router_include_kwargs = base_router_include_kwargs
+        self._routers: dict[str, Router] = {}
+        self._router_include_kwargs: dict[str, dict[str, Any]] = {}
+        self._resource_data: dict[str, ResourceData] = {}
+        self._exception_handler: Callable = exception_handler or base_exception_handler
+        self._initialized = False
+        self._api.renderer = JSONAPIRenderer()
+
+    def add_resource(
+        self,
+        path: str,
+        tags: Iterable[str],
+        resource_type: str,
+        view: Type[Any],
+        model: Type[TypeModel],
+        schema: Type[BaseModel],
+        router: Optional[Router] = None,
+        schema_in_post: Optional[Type[BaseModel]] = None,
+        schema_in_patch: Optional[Type[BaseModel]] = None,
+        pagination_default_size: Optional[int] = 25,
+        pagination_default_number: Optional[int] = 1,
+        pagination_default_offset: Optional[int] = None,
+        pagination_default_limit: Optional[int] = None,
+        operations: Iterable[Operation] = (),
+        ending_slash: bool = True,
+        model_id_field_name: str = "id",
+        include_router_kwargs: Optional[dict] = None,
+    ):
+        if self._initialized:
+            raise ApplicationBuilderError("Can't add resource after app initialization")
+
+        if resource_type in self._resource_data:
+            raise ApplicationBuilderError(f"Resource {resource_type!r} already registered")
+
+        if include_router_kwargs is not None and router is None:
+            raise ApplicationBuilderError(
+                "The argument 'include_router_kwargs' is not allowed when 'router' is missing"
+            )
+
+        models_storage.add_model(resource_type, model, model_id_field_name, path)
+        views_storage.add_view(resource_type, view)
+
+        dto = SchemaBuilder(resource_type).create_schemas(
+            schema=schema,
+            schema_in_post=schema_in_post,
+            schema_in_patch=schema_in_patch,
+        )
+
+        resource_operations = list(operations) or Operation.real_operations()
+        if Operation.ALL in resource_operations:
+            resource_operations = Operation.real_operations()
+
+        self._resource_data[resource_type] = ResourceData(
+            path=path,
+            tags=list(tags),
+            view=view,
+            model=model,
+            source_schema=schema,
+            schema_in_post=schema_in_post,
+            schema_in_post_data=dto.schema_in_post_data,
+            schema_in_patch=schema_in_patch,
+            schema_in_patch_data=dto.schema_in_patch_data,
+            detail_response_schema=dto.detail_response_schema,
+            list_response_schema=dto.list_response_schema,
+            pagination_default_size=pagination_default_size,
+            pagination_default_number=pagination_default_number,
+            pagination_default_offset=pagination_default_offset,
+            pagination_default_limit=pagination_default_limit,
+            operations=resource_operations,
+            ending_slash=ending_slash,
+        )
+
+        resolved_router = router or self._base_router
+        self._routers[resource_type] = resolved_router
+        self._router_include_kwargs[resource_type] = include_router_kwargs or {}
+
+    def initialize(self) -> NinjaAPI:
+        if self._initialized:
+            raise ApplicationBuilderError("Application already initialized")
+
+        self._initialized = True
+        self._register_exception_handler()
+
+        for resource_type, data in self._resource_data.items():
+            builder = EndpointsBuilder(resource_type, data)
+            router = self._routers[resource_type]
+
+            for operation in data.operations:
+                name, endpoint = builder.create_common_ninja_endpoint(operation)
+                method = operation.http_method().lower()
+                path = self._create_path(
+                    path=data.path,
+                    include_object_id=operation in {Operation.GET, Operation.UPDATE, Operation.DELETE},
+                    ending_slash=data.ending_slash,
+                )
+
+                response_schema = self._response_for(data, operation)
+                route = getattr(router, method)
+                route(
+                    path,
+                    response=response_schema,
+                    tags=data.tags,
+                    operation_id=name,
+                )(endpoint)
+
+            relationships_info = schemas_storage.get_relationships_info(
+                resource_type=resource_type,
+                operation_type="get",
+            )
+            for relationship_name, info in relationships_info.items():
+                if not views_storage.has_view(info.resource_type):
+                    continue
+
+                operation = Operation.GET_LIST if info.many else Operation.GET
+                relationship_name_id, relationship_endpoint = builder.create_relationship_endpoint(
+                    parent_resource_type=resource_type,
+                    relationship_name=relationship_name,
+                    operation=operation,
+                )
+                relationship_path = self._create_relationship_path(
+                    resource_path=data.path,
+                    relationship_name=relationship_name,
+                    ending_slash=data.ending_slash,
+                )
+
+                related_data = self._resource_data.get(info.resource_type, data)
+                relationship_response = (
+                    related_data.list_response_schema if info.many else related_data.detail_response_schema
+                )
+                getattr(router, operation.http_method().lower())(
+                    relationship_path,
+                    response=relationship_response,
+                    tags=data.tags,
+                    operation_id=relationship_name_id,
+                )(relationship_endpoint)
+
+        registered_routers = set()
+        for resource_type, router in self._routers.items():
+            if id(router) in registered_routers:
+                continue
+
+            include_kwargs = self._router_include_kwargs.get(resource_type, {})
+            if router is self._base_router:
+                include_kwargs = self._base_router_include_kwargs
+
+            self._api.add_router("", router, **include_kwargs)
+            registered_routers.add(id(router))
+
+        atomic = AtomicOperations()
+        self._api.add_router("", atomic.router)
+
+        return self._api
+
+    def _register_exception_handler(self):
+        add_handler = getattr(self._api, "add_exception_handler", None)
+        if callable(add_handler):
+            add_handler(HTTPException, self._exception_handler)
+
+    @staticmethod
+    def _response_for(data: ResourceData, operation: Operation):
+        if operation == Operation.DELETE:
+            return {HTTPStatus.NO_CONTENT: None}
+        if operation == Operation.GET_LIST:
+            return data.list_response_schema
+        return data.detail_response_schema
+
+    @staticmethod
+    def _create_path(path: str, include_object_id: bool, ending_slash: bool) -> str:
+        base_path = path.rstrip("/")
+        if include_object_id:
+            base_path = f"{base_path}/{{obj_id}}"
+        if ending_slash:
+            return f"{base_path}/"
+        return base_path
+
+    @staticmethod
+    def _create_relationship_path(resource_path: str, relationship_name: str, ending_slash: bool) -> str:
+        base_path = resource_path.rstrip("/")
+        path = f"{base_path}/{{obj_id}}/relationships/{relationship_name}"
+        if ending_slash:
+            return f"{path}/"
+        return path

django_ninja_jsonapi/api/endpoint_builder.py

@@ -0,0 +1,117 @@
+import json
+from typing import Any, Awaitable, Callable
+
+from django.http import HttpRequest
+
+from django_ninja_jsonapi.api.schemas import ResourceData
+from django_ninja_jsonapi.views.enums import Operation
+
+
+class EndpointsBuilder:
+    def __init__(self, resource_type: str, data: ResourceData):
+        self.resource_type = resource_type
+        self.data = data
+
+    def _build_view(self, request: HttpRequest, operation: Operation):
+        return self.data.view(
+            request=request,
+            resource_type=self.resource_type,
+            operation=operation,
+            model=self.data.model,
+            schema=self.data.source_schema,
+        )
+
+    @staticmethod
+    def _parse_json_body(request: HttpRequest) -> dict[str, Any]:
+        raw = request.body.decode() if request.body else "{}"
+        return json.loads(raw)
+
+    def create_common_ninja_endpoint(self, operation: Operation) -> tuple[str, Callable[..., Awaitable[Any]]]:
+        if operation == Operation.GET:
+            return self._create_get_detail()
+        if operation == Operation.GET_LIST:
+            return self._create_get_list()
+        if operation == Operation.CREATE:
+            return self._create_create()
+        if operation == Operation.UPDATE:
+            return self._create_update()
+        if operation == Operation.DELETE:
+            return self._create_delete()
+        if operation == Operation.DELETE_LIST:
+            return self._create_delete_list()
+
+        raise ValueError(f"Unsupported operation {operation!r}")
+
+    def create_relationship_endpoint(
+        self,
+        *,
+        parent_resource_type: str,
+        relationship_name: str,
+        operation: Operation,
+    ) -> tuple[str, Callable[..., Awaitable[Any]]]:
+        if operation == Operation.GET_LIST:
+
+            async def endpoint(request: HttpRequest, obj_id: str):
+                view = self._build_view(request, operation)
+                return await view.handle_get_resource_relationship_list(
+                    obj_id=obj_id,
+                    relationship_name=relationship_name,
+                    parent_resource_type=parent_resource_type,
+                )
+
+            return f"{parent_resource_type}_{relationship_name}_get_list", endpoint
+
+        async def endpoint(request: HttpRequest, obj_id: str):
+            view = self._build_view(request, operation)
+            return await view.handle_get_resource_relationship(
+                obj_id=obj_id,
+                relationship_name=relationship_name,
+                parent_resource_type=parent_resource_type,
+            )
+
+        return f"{parent_resource_type}_{relationship_name}_get", endpoint
+
+    def _create_get_detail(self):
+        async def endpoint(request: HttpRequest, obj_id: str):
+            view = self._build_view(request, Operation.GET)
+            return await view.handle_get_resource_detail(obj_id=obj_id)
+
+        return f"{self.resource_type}_get", endpoint
+
+    def _create_get_list(self):
+        async def endpoint(request: HttpRequest):
+            view = self._build_view(request, Operation.GET_LIST)
+            return await view.handle_get_resource_list()
+
+        return f"{self.resource_type}_get_list", endpoint
+
+    def _create_create(self):
+        async def endpoint(request: HttpRequest):
+            view = self._build_view(request, Operation.CREATE)
+            payload = self.data.schema_in_post_data.model_validate(self._parse_json_body(request))
+            return await view.handle_post_resource_list(data_create=payload.data)
+
+        return f"{self.resource_type}_create", endpoint
+
+    def _create_update(self):
+        async def endpoint(request: HttpRequest, obj_id: str):
+            view = self._build_view(request, Operation.UPDATE)
+            payload = self.data.schema_in_patch_data.model_validate(self._parse_json_body(request))
+            return await view.handle_update_resource(obj_id=obj_id, data_update=payload.data)
+
+        return f"{self.resource_type}_update", endpoint
+
+    def _create_delete(self):
+        async def endpoint(request: HttpRequest, obj_id: str):
+            view = self._build_view(request, Operation.DELETE)
+            await view.handle_delete_resource(obj_id=obj_id)
+            return 204, None
+
+        return f"{self.resource_type}_delete", endpoint
+
+    def _create_delete_list(self):
+        async def endpoint(request: HttpRequest):
+            view = self._build_view(request, Operation.DELETE_LIST)
+            return await view.handle_delete_resource_list()
+
+        return f"{self.resource_type}_delete_list", endpoint

django_ninja_jsonapi/api/schemas.py

@@ -0,0 +1,26 @@
+from typing import Any, Iterable, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from django_ninja_jsonapi.data_typing import TypeModel, TypeSchema
+from django_ninja_jsonapi.views.enums import Operation
+
+
+class ResourceData(BaseModel):
+    path: Union[str, list[str]]
+    tags: list[str]
+    view: Type[Any]
+    model: Type[TypeModel]
+    source_schema: Type[TypeSchema]
+    schema_in_post: Optional[Type[BaseModel]]
+    schema_in_post_data: Type[BaseModel]
+    schema_in_patch: Optional[Type[BaseModel]]
+    schema_in_patch_data: Type[BaseModel]
+    detail_response_schema: Type[BaseModel]
+    list_response_schema: Type[BaseModel]
+    pagination_default_size: Optional[int] = 25
+    pagination_default_number: Optional[int] = 1
+    pagination_default_offset: Optional[int] = None
+    pagination_default_limit: Optional[int] = None
+    operations: Iterable[Operation] = ()
+    ending_slash: bool = True

django_ninja_jsonapi/atomic/__init__.py

@@ -0,0 +1,7 @@
+from .atomic import AtomicOperations
+from .atomic_handler import current_atomic_operation
+
+__all__ = (
+    "AtomicOperations",
+    "current_atomic_operation",
+)

django_ninja_jsonapi/atomic/atomic.py

@@ -0,0 +1,49 @@
+from http import HTTPStatus
+from typing import Optional, Type
+
+from django.http import HttpRequest, HttpResponse
+from ninja import Router
+
+from django_ninja_jsonapi.atomic.atomic_handler import AtomicViewHandler
+from django_ninja_jsonapi.atomic.schemas import AtomicOperationRequest, AtomicResultResponse
+
+
+class AtomicOperations:
+    atomic_handler: Type[AtomicViewHandler] = AtomicViewHandler
+
+    def __init__(
+        self,
+        url_path: str = "/operations",
+        router: Optional[Router] = None,
+    ):
+        self.router = router or Router(tags=["Atomic Operations"])
+        self.url_path = url_path
+        self._register_view()
+
+    async def view_atomic(
+        self,
+        request: HttpRequest,
+        operations_request: AtomicOperationRequest,
+    ):
+        atomic_handler = self.atomic_handler(
+            request=request,
+            operations_request=operations_request,
+        )
+        result = await atomic_handler.handle()
+        if result:
+            return result
+        return HttpResponse(status=HTTPStatus.NO_CONTENT)
+
+    def _register_view(self) -> None:
+        async def endpoint(request: HttpRequest, operations_request: AtomicOperationRequest):
+            return await self.view_atomic(
+                request=request,
+                operations_request=operations_request,
+            )
+
+        self.router.post(
+            self.url_path,
+            response=AtomicResultResponse,
+            summary="Atomic operations",
+            description="""[https://jsonapi.org/ext/atomic/](https://jsonapi.org/ext/atomic/)""",
+        )(endpoint)

django_ninja_jsonapi/atomic/atomic_handler.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from contextvars import ContextVar
+from functools import wraps
+from http import HTTPStatus
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional, TypedDict, Union
+
+from django.http import HttpRequest
+from pydantic import ValidationError
+
+from django_ninja_jsonapi.atomic.prepared_atomic_operation import LocalIdsType, OperationBase
+from django_ninja_jsonapi.atomic.schemas import (
+    AtomicOperation,
+    AtomicOperationRequest,
+    AtomicResultResponse,
+    OperationItemInSchema,
+)
+from django_ninja_jsonapi.exceptions import HTTPException
+from django_ninja_jsonapi.storages.schemas_storage import schemas_storage
+
+if TYPE_CHECKING:
+    from django_ninja_jsonapi.data_layers.base import BaseDataLayer
+    from django_ninja_jsonapi.data_typing import TypeSchema
+
+log = logging.getLogger(__name__)
+AtomicResponseDict = TypedDict("AtomicResponseDict", {"atomic:results": list[Any]})
+current_atomic_operation: ContextVar[OperationBase] = ContextVar("current_atomic_operation")
+
+
+def catch_exc_on_operation_handle(func: Callable[..., Awaitable]):
+    @wraps(func)
+    async def wrapper(*a, operation: OperationBase, **kw):
+        try:
+            return await func(*a, operation=operation, **kw)
+        except (ValidationError, ValueError) as ex:
+            log.exception(
+                "Validation error on atomic action ref=%s, data=%s",
+                operation.ref,
+                operation.data,
+            )
+            errors_details = {
+                "message": f"Validation error on operation {operation.op_type}",
+                "ref": operation.ref,
+                "data": operation.data.model_dump() if hasattr(operation.data, "model_dump") else operation.data,
+            }
+            if isinstance(ex, ValidationError):
+                errors_details.update(errors=ex.errors())
+            elif isinstance(ex, ValueError):
+                errors_details.update(error=f"{ex}")
+            else:
+                raise
+            # TODO: json:api exception
+            raise HTTPException(
+                status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                detail=errors_details,
+            ) from ex
+
+    return wrapper
+
+
+class AtomicViewHandler:
+    def __init__(
+        self,
+        request: HttpRequest,
+        operations_request: AtomicOperationRequest,
+    ):
+        self.request = request
+        self.operations_request = operations_request
+        self.local_ids_cache: LocalIdsType = defaultdict(dict)
+
+    async def prepare_one_operation(self, operation: AtomicOperation):
+        """
+        Prepare one atomic operation
+
+        :param operation:
+        :return:
+        """
+        resource_type = (operation.ref and operation.ref.type) or (operation.data and operation.data.type)
+        if not schemas_storage.has_resource(resource_type):
+            msg = f"Unknown resource type {resource_type!r}."
+            raise ValueError(msg)
+
+        return OperationBase.prepare(
+            action=operation.op,
+            request=self.request,
+            resource_type=resource_type,
+            ref=operation.ref,
+            data=operation.data,
+        )
+
+    async def prepare_operations(self) -> list[OperationBase]:
+        prepared_operations: list[OperationBase] = []
+
+        for operation in self.operations_request.operations:
+            one_operation = await self.prepare_one_operation(operation)
+            prepared_operations.append(one_operation)
+
+        return prepared_operations
+
+    @catch_exc_on_operation_handle
+    async def process_one_operation(
+        self,
+        dl: BaseDataLayer,
+        operation: OperationBase,
+    ):
+        operation.update_relationships_with_lid(local_ids=self.local_ids_cache)
+        return await operation.handle(dl=dl)
+
+    async def process_next_operation(
+        self,
+        operation: OperationBase,
+        previous_dl: Optional[BaseDataLayer],
+    ) -> tuple[Optional[TypeSchema], BaseDataLayer]:
+        dl = await operation.get_data_layer()
+        await dl.atomic_start(
+            previous_dl=previous_dl,
+        )
+        try:
+            response = await self.process_one_operation(
+                dl=dl,
+                operation=operation,
+            )
+        except HTTPException as ex:
+            await dl.atomic_end(
+                success=False,
+                exception=ex,
+            )
+            raise ex
+
+        return response, dl
+
+    async def handle(self) -> Union[AtomicResponseDict, AtomicResultResponse, None]:
+        prepared_operations = await self.prepare_operations()
+        results = []
+        only_empty_responses = True
+        success = True
+        previous_dl: Optional[BaseDataLayer] = None
+        for operation in prepared_operations:
+            # set context var
+            ctx_var_token = current_atomic_operation.set(operation)
+            try:
+                response, dl = await self.process_next_operation(operation, previous_dl)
+                previous_dl = dl
+
+                # response.data.id
+                if not response:
+                    # https://jsonapi.org/ext/atomic/#result-objects
+                    # An empty result object ({}) is acceptable
+                    # for operations that are not required to return data.
+                    results.append({})
+                    continue
+                only_empty_responses = False
+
+                data = response["data"]
+                results.append(
+                    {"data": data},
+                )
+
+                if isinstance(operation.data, OperationItemInSchema) and operation.data.lid and data and "id" in data:
+                    self.local_ids_cache[operation.data.type][operation.data.lid] = data["id"]
+            finally:
+                # reset context var even when operation fails
+                current_atomic_operation.reset(ctx_var_token)
+
+        if previous_dl:
+            await previous_dl.atomic_end(success=success)
+
+        if not only_empty_responses:
+            return {"atomic:results": results}
+
+        """
+        if all results are empty,
+        the server MAY respond with 204 No Content and no document.
+        """