local ids, coverage

Author: mahenzon

fastapi_jsonapi/atomic/atomic_handler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -13,7 +14,7 @@
 from starlette.requests import Request
 
 from fastapi_jsonapi import RoutersJSONAPI
-from fastapi_jsonapi.atomic.prepared_atomic_operation import OperationBase
+from fastapi_jsonapi.atomic.prepared_atomic_operation import LocalIdsType, OperationBase
 from fastapi_jsonapi.atomic.schemas import AtomicOperationRequest, AtomicResultResponse
 from fastapi_jsonapi.utils.dependency_helper import DependencyHelper
 from fastapi_jsonapi.views.utils import HTTPMethodConfig
@@ -79,21 +80,32 @@ async def handle(self) -> Union[AtomicResponseDict, AtomicResultResponse, None]:
 
         # TODO: try/except, catch schema ValidationError
 
+        only_empty_responses = True
+        local_ids_cache: LocalIdsType = defaultdict(dict)
         success = True
         previous_dl: Optional[BaseDataLayer] = None
         for operation in prepared_operations:
             dl: BaseDataLayer = await operation.get_data_layer()
             await dl.atomic_start(previous_dl=previous_dl)
             previous_dl = dl
+            operation.update_relationships_with_lid(local_ids=local_ids_cache)
             response = await operation.handle(dl=dl)
             # response.data.id
-            if response:
-                results.append({"data": response.data})
+            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
+            results.append({"data": response.data})
+            if operation.data.lid and response.data:
+                local_ids_cache[operation.data.type][operation.data.lid] = response.data.id
 
         if previous_dl:
             await previous_dl.atomic_end(success=success)
 
-        if results:
+        if not only_empty_responses:
             return {"atomic:results": results}
 
         """

fastapi_jsonapi/atomic/prepared_atomic_operation.py

@@ -14,6 +14,8 @@
     from fastapi_jsonapi.views.list_view import ListViewBase
     from fastapi_jsonapi.views.view_base import ViewBase
 
+LocalIdsType = Dict[str, Dict[str, str]]
+
 
 @dataclass
 class OperationBase:
@@ -62,6 +64,55 @@ async def get_data_layer(self) -> BaseDataLayer:
     async def handle(self, dl: BaseDataLayer):
         raise NotImplementedError
 
+    @classmethod
+    def upd_one_relationship_with_local_id(cls, relationship_info: dict, local_ids: LocalIdsType):
+        """
+        TODO: refactor
+
+        :param relationship_info:
+        :param local_ids:
+        :return:
+        """
+        missing = object()
+        lid = relationship_info.get("lid", missing)
+        if lid is missing:
+            return
+
+        resource_type = relationship_info["type"]
+        if resource_type not in local_ids:
+            msg = (
+                f"Resource {resource_type} not found in previous operations,"
+                f" no lid {lid} defined yet, cannot create {relationship_info}"
+            )
+            raise ValueError(
+                msg,
+            )
+
+        lids_for_resource = local_ids[resource_type]
+        if lid not in lids_for_resource:
+            msg = (
+                f"lid {lid} for {resource_type} not found in previous operations,"
+                f" cannot process {relationship_info}"
+            )
+            raise ValueError(msg)
+
+        relationship_info.pop("lid")
+        relationship_info["id"] = lids_for_resource[lid]
+
+    def update_relationships_with_lid(self, local_ids: LocalIdsType):
+        if not (self.data and self.data.relationships):
+            return
+        for relationship_name, relationship_value in self.data.relationships.items():
+            relationship_data = relationship_value["data"]
+            if isinstance(relationship_data, list):
+                for data in relationship_data:
+                    self.upd_one_relationship_with_local_id(data, local_ids=local_ids)
+            elif isinstance(relationship_data, dict):
+                self.upd_one_relationship_with_local_id(relationship_data, local_ids=local_ids)
+            else:
+                msg = "unexpected relationship data"
+                raise ValueError(msg)
+
 
 class ListOperationBase(OperationBase):
     view: ListViewBase
@@ -83,6 +134,10 @@ async def handle(self, dl: BaseDataLayer):
 
 class OperationUpdate(DetailOperationBase):
     async def handle(self, dl: BaseDataLayer):
+        if self.data is None:
+            # TODO: clear to-one relationships
+            pass
+        # TODO: handle relationship update requests (relationship resources)
         data_in = self.jsonapi.schema_in_patch(data=self.data)
         obj_id = self.ref and self.ref.id or self.data and self.data.id
         response = await self.view.process_update_object(

fastapi_jsonapi/atomic/schemas.py

@@ -19,6 +19,7 @@ class OperationItemInSchema(BaseModel):
 
     type: str = Field(default=..., description="Resource type")
     id: Optional[str] = Field(default=None, description="Resource object ID")
+    lid: Optional[str] = Field(default=None, description="Resource object local ID")
     attributes: Optional[dict] = Field(None, description="Resource object attributes")
     relationships: Optional[dict] = Field(None, description="Resource object relationships")
 

tests/models.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 from uuid import UUID
 
 from sqlalchemy import JSON, Column, ForeignKey, Index, Integer, String, Text
@@ -53,6 +53,8 @@ class User(AutoIdMixin, Base):
     )
     computers = relationship(
         "Computer",
+        # TODO: rename
+        # back_populates="owner",
         back_populates="user",
         uselist=True,
     )
@@ -61,6 +63,8 @@ class User(AutoIdMixin, Base):
         back_populates="user",
         uselist=False,
     )
+    if TYPE_CHECKING:
+        computers: list["Computer"]
 
     def __repr__(self):
         return f"{self.__class__.__name__}(id={self.id}, name={self.name!r})"
@@ -194,6 +198,8 @@ class Computer(AutoIdMixin, Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     name = Column(String, nullable=False)
     user_id = Column(Integer, ForeignKey("users.id"), nullable=True)
+    # TODO: rename
+    # owner = relationship("User", back_populates="computers")
     user = relationship("User", back_populates="computers")
 
     def __repr__(self):

tests/schemas.py

@@ -299,6 +299,14 @@ class Config:
 
     id: int
 
+    # TODO: rename
+    # owner: Optional["UserSchema"] = Field(
+    user: Optional["UserSchema"] = Field(
+        relationship=RelationshipInfo(
+            resource_type="user",
+        ),
+    )
+
 
 class WorkplaceBaseSchema(BaseModel):
     """Workplace base schema."""