Merge pull request #81 from mts-ai/fix-cascade-changes

mahenzon · web-flow · commit 39d995b52491 · 2024-04-02T18:03:58.000+03:00
Fix cascade changes
diff --git a/fastapi_jsonapi/data_layers/sqla_orm.py b/fastapi_jsonapi/data_layers/sqla_orm.py
@@ -3,7 +3,7 @@
 from typing import TYPE_CHECKING, Any, Iterable, List, Optional, Tuple, Type
 
 from sqlalchemy import delete, func, select
-from sqlalchemy.exc import DBAPIError, IntegrityError, NoResultFound
+from sqlalchemy.exc import DBAPIError, IntegrityError, MissingGreenlet, NoResultFound
 from sqlalchemy.ext.asyncio import AsyncSession, AsyncSessionTransaction
 from sqlalchemy.inspection import inspect
 from sqlalchemy.orm import joinedload, selectinload
@@ -185,6 +185,18 @@ async def apply_relationships(self, obj: TypeModel, data_create: BaseJSONAPIItem
                     related_id_field=relationship_info.id_field_name,
                     id_value=relationship_in.data.id,
                 )
+
+            try:
+                hasattr(obj, relation_name)
+            except MissingGreenlet:
+                raise InternalServerError(
+                    detail=(
+                        f"Error of loading the {relation_name!r} relationship. "
+                        f"Please add this relationship to include query parameter explicitly."
+                    ),
+                    parameter="include",
+                )
+
             # todo: relation name may be different?
             setattr(obj, relation_name, related_data)
 
@@ -386,8 +398,10 @@ async def delete_object(self, obj: TypeModel, view_kwargs: dict):
         :param view_kwargs: kwargs from the resource view.
         """
         await self.before_delete_object(obj, view_kwargs)
+        stmt = delete(self.model).where(self.model.id == obj.id)
+
         try:
-            await self.session.delete(obj)
+            await self.session.execute(stmt)
             await self.save()
         except DBAPIError as e:
             await self.session.rollback()
diff --git a/tests/common.py b/tests/common.py
@@ -1,6 +1,9 @@
 from os import getenv
 from pathlib import Path
 
+from sqlalchemy import event
+from sqlalchemy.engine import Engine
+
 
 def sqla_uri():
     testing_db_url = getenv("TESTING_DB_URL")
@@ -12,3 +15,18 @@ def sqla_uri():
 
 def is_postgres_tests() -> bool:
     return "postgres" in sqla_uri()
+
+
+def is_sqlite_tests() -> bool:
+    return "sqlite" in sqla_uri()
+
+
+@event.listens_for(Engine, "connect")
+def set_sqlite_pragma(dbapi_connection, connection_record):
+    """
+    https://docs.sqlalchemy.org/en/14/dialects/sqlite.html#foreign-key-support
+    """
+    if is_sqlite_tests():
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()
diff --git a/tests/models.py b/tests/models.py
@@ -3,7 +3,7 @@
 
 from sqlalchemy import JSON, Column, DateTime, ForeignKey, Index, Integer, String, Text
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import declared_attr, relationship
+from sqlalchemy.orm import backref, declared_attr, relationship
 from sqlalchemy.types import CHAR, TypeDecorator
 
 from tests.common import is_postgres_tests, sqla_uri
@@ -390,3 +390,25 @@ class Delta(Base):
     name = Column(String)
     gammas: List["Gamma"] = relationship("Gamma", back_populates="delta", lazy="noload")
     betas: List["Beta"] = relationship("Beta", secondary="beta_delta_binding", back_populates="deltas", lazy="noload")
+
+
+class CascadeCase(Base):
+    __tablename__ = "cascade_case"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    parent_item_id = Column(
+        Integer,
+        ForeignKey(
+            "cascade_case.id",
+            onupdate="CASCADE",
+            ondelete="CASCADE",
+        ),
+        nullable=True,
+    )
+    sub_items = relationship(
+        "CascadeCase",
+        backref=backref("parent_item", remote_side=[id]),
+    )
+
+    if TYPE_CHECKING:
+        parent_item: Optional["CascadeCase"]
diff --git a/tests/schemas.py b/tests/schemas.py
@@ -409,6 +409,20 @@ class SelfRelationshipSchema(BaseModel):
     )
 
 
+class CascadeCaseSchema(BaseModel):
+    parent_item: Optional["CascadeCaseSchema"] = Field(
+        relationship=RelationshipInfo(
+            resource_type="cascade_case",
+        ),
+    )
+    sub_items: Optional[list["CascadeCaseSchema"]] = Field(
+        relationship=RelationshipInfo(
+            resource_type="cascade_case",
+            many=True,
+        ),
+    )
+
+
 class CustomUserAttributesSchema(UserBaseSchema):
     spam: str
     eggs: str
diff --git a/tests/test_api/test_api_sqla_with_includes.py b/tests/test_api/test_api_sqla_with_includes.py
@@ -1,6 +1,7 @@
 import json
 import logging
 from collections import defaultdict
+from contextlib import suppress
 from datetime import datetime, timezone
 from itertools import chain, zip_longest
 from json import dumps, loads
@@ -18,6 +19,7 @@
 from sqlalchemy.orm import InstrumentedAttribute
 from starlette.datastructures import QueryParams
 
+from fastapi_jsonapi.api import RoutersJSONAPI
 from fastapi_jsonapi.views.view_base import ViewBase
 from tests.common import is_postgres_tests
 from tests.fixtures.app import build_alphabet_app, build_app_custom
@@ -31,6 +33,7 @@
 from tests.models import (
     Alpha,
     Beta,
+    CascadeCase,
     Computer,
     ContainsTimestamp,
     CustomUUIDItem,
@@ -44,6 +47,7 @@
     Workplace,
 )
 from tests.schemas import (
+    CascadeCaseSchema,
     CustomUserAttributesSchema,
     CustomUUIDItemAttributesSchema,
     PostAttributesBaseSchema,
@@ -1744,6 +1748,87 @@ async def test_select_custom_fields(
             "meta": None,
         }
 
+    @mark.parametrize("check_type", ["ok", "fail"])
+    async def test_update_to_many_relationships(self, async_session: AsyncSession, check_type: Literal["ok", "fail"]):
+        resource_type = "cascade_case"
+        with suppress(KeyError):
+            RoutersJSONAPI.all_jsonapi_routers.pop(resource_type)
+
+        app = build_app_custom(
+            model=CascadeCase,
+            schema=CascadeCaseSchema,
+            resource_type=resource_type,
+        )
+
+        top_item = CascadeCase()
+        new_top_item = CascadeCase()
+        sub_item_1 = CascadeCase(parent_item=top_item)
+        sub_item_2 = CascadeCase(parent_item=top_item)
+        async_session.add_all(
+            [
+                top_item,
+                new_top_item,
+                sub_item_1,
+                sub_item_2,
+            ],
+        )
+        await async_session.commit()
+
+        assert sub_item_1.parent_item_id == top_item.id
+        assert sub_item_2.parent_item_id == top_item.id
+
+        async with AsyncClient(app=app, base_url="http://test") as client:
+            params = None
+            if check_type == "ok":
+                params = {"include": "sub_items"}
+
+            update_body = {
+                "type": resource_type,
+                "data": {
+                    "id": new_top_item.id,
+                    "attributes": {},
+                    "relationships": {
+                        "sub_items": {
+                            "data": [
+                                {
+                                    "type": resource_type,
+                                    "id": sub_item_1.id,
+                                },
+                                {
+                                    "type": resource_type,
+                                    "id": sub_item_2.id,
+                                },
+                            ],
+                        },
+                    },
+                },
+            }
+            url = app.url_path_for(f"update_{resource_type}_detail", obj_id=new_top_item.id)
+
+            res = await client.patch(url, params=params, json=update_body)
+
+            if check_type == "ok":
+                assert res.status_code == status.HTTP_200_OK, res.text
+
+                await async_session.refresh(sub_item_1)
+                await async_session.refresh(sub_item_2)
+                await async_session.refresh(top_item)
+                assert sub_item_1.parent_item_id == new_top_item.id
+                assert sub_item_1.parent_item_id == new_top_item.id
+            else:
+                assert res.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR, res.text
+                assert res.json() == {
+                    "errors": [
+                        {
+                            "detail": "Error of loading the 'sub_items' relationship. "
+                            "Please add this relationship to include query parameter explicitly.",
+                            "source": {"parameter": "include"},
+                            "status_code": status.HTTP_500_INTERNAL_SERVER_ERROR,
+                            "title": "Internal Server Error",
+                        },
+                    ],
+                }
+
 
 class TestPatchObjectRelationshipsToOne:
     async def test_ok_when_foreign_key_of_related_object_is_nullable(
@@ -2247,6 +2332,46 @@ async def test_select_custom_fields(
             "meta": {"count": 2, "totalPages": 1},
         }
 
+    async def test_cascade_delete(self, async_session: AsyncSession):
+        resource_type = "cascade_case"
+        with suppress(KeyError):
+            RoutersJSONAPI.all_jsonapi_routers.pop(resource_type)
+
+        app = build_app_custom(
+            model=CascadeCase,
+            schema=CascadeCaseSchema,
+            resource_type=resource_type,
+        )
+
+        top_item = CascadeCase()
+        sub_item_1 = CascadeCase(parent_item=top_item)
+        sub_item_2 = CascadeCase(parent_item=top_item)
+        async_session.add_all(
+            [
+                top_item,
+                sub_item_1,
+                sub_item_2,
+            ],
+        )
+        await async_session.commit()
+
+        assert sub_item_1.parent_item_id == top_item.id
+        assert sub_item_2.parent_item_id == top_item.id
+
+        async with AsyncClient(app=app, base_url="http://test") as client:
+            url = app.url_path_for(f"delete_{resource_type}_detail", obj_id=top_item.id)
+
+            res = await client.delete(url)
+            assert res.status_code == status.HTTP_204_NO_CONTENT, res.text
+
+            top_item_stmt = select(CascadeCase).where(CascadeCase.id == top_item.id)
+            top_item = (await async_session.execute(top_item_stmt)).one_or_none()
+            assert top_item is None
+
+            sub_items_stmt = select(CascadeCase).where(CascadeCase.id.in_([sub_item_1.id, sub_item_2.id]))
+            sub_items = (await async_session.execute(sub_items_stmt)).all()
+            assert sub_items == []
+
 
 class TestOpenApi:
     def test_openapi_method_ok(self, app: FastAPI):
