atomic operations fixes, coverage for many-to-many

Author: mahenzon

examples/api_for_sqlalchemy/models/schemas/user.py

@@ -45,7 +45,7 @@ class Enum:
         ),
     )
 
-    computers: Optional["ComputerSchema"] = Field(
+    computers: Optional[List["ComputerSchema"]] = Field(
         relationship=RelationshipInfo(
             resource_type="computer",
             many=True,

fastapi_jsonapi/atomic/atomic_handler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
@@ -11,6 +12,8 @@
     Union,
 )
 
+from fastapi import HTTPException, status
+from pydantic import ValidationError
 from starlette.requests import Request
 
 from fastapi_jsonapi import RoutersJSONAPI
@@ -22,6 +25,7 @@
 if TYPE_CHECKING:
     from fastapi_jsonapi.data_layers.base import BaseDataLayer
 
+log = logging.getLogger(__name__)
 AtomicResponseDict = TypedDict("AtomicResponseDict", {"atomic:results": List[Any]})
 
 
@@ -84,12 +88,35 @@ async def handle(self) -> Union[AtomicResponseDict, AtomicResultResponse, None]:
         local_ids_cache: LocalIdsType = defaultdict(dict)
         success = True
         previous_dl: Optional[BaseDataLayer] = None
-        for operation in prepared_operations:
+        for idx, operation in enumerate(prepared_operations, start=1):
             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)
+            try:
+                operation.update_relationships_with_lid(local_ids=local_ids_cache)
+                response = await operation.handle(dl=dl)
+            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 #{idx}",
+                    "ref": operation.ref,
+                    "data": operation.data.dict(),
+                }
+                if isinstance(ex, ValidationError):
+                    errors_details.update(errors=ex.errors())
+                elif isinstance(ex, ValueError):
+                    errors_details.update(error=str(ex))
+                else:
+                    raise
+                # TODO: json:api exception
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=errors_details,
+                )
             # response.data.id
             if not response:
                 # https://jsonapi.org/ext/atomic/#result-objects

fastapi_jsonapi/atomic/prepared_atomic_operation.py

@@ -81,17 +81,15 @@ def upd_one_relationship_with_local_id(cls, relationship_info: dict, local_ids:
         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,
+                f"Resource {resource_type!r} not found in previous operations,"
+                f" no lid {lid!r} 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"lid {lid!r} for {resource_type!r} not found in previous operations,"
                 f" cannot process {relationship_info}"
             )
             raise ValueError(msg)

fastapi_jsonapi/schema_builder.py

@@ -252,7 +252,11 @@ def _get_info_from_schema_for_building(
                     field=field,
                     relationship_info=relationship,
                 )
-                relationship_field = ... if (non_optional_relationships and field.required) else None
+                # TODO: xxx
+                #  is there a way to read that the field type is Optional? (r.n. it's ForwardRef)
+                # consider field is not required until is marked required explicitly (`default=...` means required)
+                field_marked_required = field.required is True
+                relationship_field = ... if (non_optional_relationships and field_marked_required) else None
                 if relationship_field is not None:
                     has_required_relationship = True
                 relationships_schema_fields[name] = (relationship_schema, relationship_field)

tests/fixtures/app.py

@@ -14,6 +14,7 @@
     Child,
     Computer,
     Parent,
+    ParentToChildAssociation,
     Post,
     PostComment,
     User,
@@ -28,6 +29,7 @@
     ComputerSchema,
     ParentPatchSchema,
     ParentSchema,
+    ParentToChildAssociationSchema,
     PostCommentSchema,
     PostInSchema,
     PostPatchSchema,
@@ -133,6 +135,17 @@ def add_routers(app_plain: FastAPI):
         model=Child,
     )
 
+    RoutersJSONAPI(
+        router=router,
+        path="/parent-to-child-association",
+        tags=["Parent To Child Association"],
+        class_detail=DetailViewBaseGeneric,
+        class_list=ListViewBaseGeneric,
+        schema=ParentToChildAssociationSchema,
+        resource_type="parent-to-child-association",
+        model=ParentToChildAssociation,
+    )
+
     RoutersJSONAPI(
         router=router,
         path="/computers",

tests/fixtures/db_connection.py

@@ -28,7 +28,11 @@ async def async_session_dependency():
 
 @async_fixture(scope="class")
 async def async_engine():
-    engine = create_async_engine(url=make_url(sqla_uri()))
+    engine = create_async_engine(
+        url=make_url(sqla_uri()),
+        echo=False,
+        # echo=True,
+    )
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.drop_all)
         await conn.run_sync(Base.metadata.create_all)

tests/schemas.py

@@ -176,9 +176,14 @@ class PostCommentSchema(PostCommentBaseSchema):
 # Association Schemas ⬇️
 
 
-class ParentToChildAssociationSchema(BaseModel):
-    id: int
+class ParentToChildAssociationAttributesSchema(BaseModel):
     extra_data: str
+
+    class Config:
+        orm_mode = True
+
+
+class ParentToChildAssociationSchema(ParentToChildAssociationAttributesSchema):
     parent: "ParentSchema" = Field(
         relationship=RelationshipInfo(
             resource_type="parent",
@@ -195,17 +200,20 @@ class ParentToChildAssociationSchema(BaseModel):
 # Parent Schemas ⬇️
 
 
-class ParentBaseSchema(BaseModel):
-    """Parent base schema."""
+class ParentAttributesSchema(BaseModel):
+    name: str
 
     class Config:
         """Pydantic schema config."""
 
         orm_mode = True
 
-    name: str
+
+class ParentBaseSchema(ParentAttributesSchema):
+    """Parent base schema."""
 
     children: List["ParentToChildAssociationSchema"] = Field(
+        default=None,
         relationship=RelationshipInfo(
             resource_type="parent_child_association",
             many=True,
@@ -230,17 +238,20 @@ class ParentSchema(ParentInSchema):
 # Child Schemas ⬇️
 
 
-class ChildBaseSchema(BaseModel):
-    """Child base schema."""
+class ChildAttributesSchema(BaseModel):
+    name: str
 
     class Config:
         """Pydantic schema config."""
 
         orm_mode = True
 
-    name: str
+
+class ChildBaseSchema(ChildAttributesSchema):
+    """Child base schema."""
 
     parents: List["ParentToChildAssociationSchema"] = Field(
+        default=None,
         relationship=RelationshipInfo(
             resource_type="parent_child_association",
             many=True,