added test case and base logic

Author: CosmoV

fastapi_jsonapi/querystring.py

@@ -1,4 +1,5 @@
 """Helper to deal with querystring parameters according to jsonapi specification."""
+from collections import defaultdict
 from functools import cached_property
 from typing import (
     TYPE_CHECKING,
@@ -22,17 +23,16 @@
 )
 from starlette.datastructures import QueryParams
 
+from fastapi_jsonapi.api import RoutersJSONAPI
 from fastapi_jsonapi.exceptions import (
     BadRequest,
-    InvalidField,
     InvalidFilters,
     InvalidInclude,
     InvalidSort,
 )
 from fastapi_jsonapi.schema import (
     get_model_field,
     get_relationships,
-    get_schema_from_type,
 )
 from fastapi_jsonapi.splitter import SPLIT_REL
 
@@ -97,7 +97,7 @@ def _get_key_values(self, name: str) -> Dict[str, Union[List[str], str]]:
         :return: a dict of key / values items
         :raises BadRequest: if an error occurred while parsing the querystring.
         """
-        results: Dict[str, Union[List[str], str]] = {}
+        results = defaultdict(set)
 
         for raw_key, value in self.qs.multi_items():
             key = unquote(raw_key)
@@ -109,10 +109,7 @@ def _get_key_values(self, name: str) -> Dict[str, Union[List[str], str]]:
                 key_end = key.index("]")
                 item_key = key[key_start:key_end]
 
-                if "," in value:
-                    results.update({item_key: value.split(",")})
-                else:
-                    results.update({item_key: value})
+                results[item_key].update(value.split(","))
             except Exception:
                 msg = "Parse error"
                 raise BadRequest(msg, parameter=key)
@@ -216,27 +213,28 @@ def fields(self) -> Dict[str, List[str]]:
 
         :raises InvalidField: if result field not in schema.
         """
-        if self.request.method != "GET":
-            msg = "attribute 'fields' allowed only for GET-method"
-            raise InvalidField(msg)
         fields = self._get_key_values("fields")
-        for key, value in fields.items():
-            if not isinstance(value, list):
-                value = [value]  # noqa: PLW2901
-                fields[key] = value
+        for resource_type, field_names in fields.items():
             # TODO: we have registry for models (BaseModel)
             # TODO: create `type to schemas` registry
-            schema: Type[BaseModel] = get_schema_from_type(key, self.app)
-            for field in value:
-                if field not in schema.__fields__:
-                    msg = "{schema} has no attribute {field}".format(
-                        schema=schema.__name__,
-                        field=field,
-                    )
-                    raise InvalidField(msg)
+
+            # schema: Type[BaseModel] = get_schema_from_type(key, self.app)
+            self._get_schema(resource_type)
+
+            # for field_name in field_names:
+            #     if field_name not in schema.__fields__:
+            #         msg = "{schema} has no attribute {field}".format(
+            #             schema=schema.__name__,
+            #             field=field_name,
+            #         )
+            #         raise InvalidField(msg)
 
         return fields
 
+    def _get_schema(self, resource_type: str) -> Type[BaseModel]:
+        target_router = RoutersJSONAPI.all_jsonapi_routers[resource_type]
+        return target_router.detail_response_schema
+
     def get_sorts(self, schema: Type["TypeSchema"]) -> List[Dict[str, str]]:
         """
         Return fields to sort by including sort name for SQLAlchemy and row sort parameter for other ORMs.

fastapi_jsonapi/schema_builder.py

@@ -484,6 +484,7 @@ def create_jsonapi_object_schemas(
         base_name: str = "",
         compute_included_schemas: bool = False,
         use_schema_cache: bool = True,
+        exclude_attributes: Optional[List[str]] = None,
     ) -> JSONAPIObjectSchemas:
         if use_schema_cache and schema in self.object_schemas_cache and includes is not_passed:
             return self.object_schemas_cache[schema]

fastapi_jsonapi/views/list_view.py

@@ -6,6 +6,7 @@
     JSONAPIResultDetailSchema,
     JSONAPIResultListSchema,
 )
+from fastapi_jsonapi.views.utils import get_includes_indexes_by_type
 from fastapi_jsonapi.views.view_base import ViewBase
 
 if TYPE_CHECKING:
@@ -14,6 +15,31 @@
 logger = logging.getLogger(__name__)
 
 
+def calculate_include_fields(response, query_params, jsonapi) -> Dict:
+    included = "included" in response.__fields__ and response.included or []
+
+    include_params = {
+        field_name: {*response.__fields__[field_name].type_.__fields__.keys()}
+        for field_name in response.__fields__
+        if field_name
+    }
+    include_params["included"] = {}
+
+    includes_indexes_by_type = get_includes_indexes_by_type(included)
+
+    for resource_type, field_names in query_params.fields.items():
+        if resource_type == jsonapi.type_:
+            include_params["data"] = {"__all__": {"attributes": field_names, "id": {"id"}, "type": {"type"}}}
+            continue
+
+        target_type_indexes = includes_indexes_by_type.get(resource_type)
+
+        if resource_type in includes_indexes_by_type and target_type_indexes:
+            include_params["included"].update((idx, field_names) for idx in target_type_indexes)
+
+    return include_params
+
+
 class ListViewBase(ViewBase):
     def _calculate_total_pages(self, db_items_count: int) -> int:
         total_pages = 1
@@ -40,7 +66,17 @@ async def handle_get_resource_list(self, **extra_view_deps) -> JSONAPIResultList
         count, items_from_db = await dl.get_collection(qs=query_params)
         total_pages = self._calculate_total_pages(count)
 
-        return self._build_list_response(items_from_db, count, total_pages)
+        response = self._build_list_response(items_from_db, count, total_pages)
+
+        if not query_params.fields:
+            return response
+
+        include_params = calculate_include_fields(response, query_params, self.jsonapi)
+
+        if include_params:
+            return response.dict(include=include_params)
+
+        return response
 
     async def handle_post_resource_list(
         self,

fastapi_jsonapi/views/utils.py

@@ -1,6 +1,7 @@
+from collections import defaultdict
 from enum import Enum
 from functools import cache
-from typing import Callable, Coroutine, Optional, Set, Type, Union
+from typing import Callable, Coroutine, Dict, List, Optional, Set, Type, Union
 
 from pydantic import BaseModel
 
@@ -27,3 +28,12 @@ class Config:
     @property
     def handler(self) -> Optional[Union[Callable, Coroutine]]:
         return self.prepare_data_layer_kwargs
+
+
+def get_includes_indexes_by_type(included: List[Dict]) -> Dict[str, List[int]]:
+    result = defaultdict(list)
+
+    for idx, item in enumerate(included, 1):
+        result[item["type"]].append(idx)
+
+    return result

fastapi_jsonapi/views/view_base.py

@@ -30,6 +30,7 @@
 from fastapi_jsonapi.schema import (
     JSONAPIObjectSchema,
     JSONAPIResultListMetaSchema,
+    JSONAPIResultListSchema,
     get_related_schema,
 )
 from fastapi_jsonapi.schema_base import BaseModel, RelationshipInfo
@@ -185,7 +186,12 @@ def _build_detail_response(self, db_item: TypeModel):
 
         return detail_jsonapi_schema(data=result_object, **extras)
 
-    def _build_list_response(self, items_from_db: List[TypeModel], count: int, total_pages: int):
+    def _build_list_response(
+        self,
+        items_from_db: List[TypeModel],
+        count: int,
+        total_pages: int,
+    ) -> JSONAPIResultListSchema:
         result_objects, object_schemas, extras = self._build_response(items_from_db, self.jsonapi.schema_list)
 
         # we need to build a new schema here

tests/test_api/test_api_sqla_with_includes.py

@@ -4,7 +4,7 @@
 from datetime import datetime, timezone
 from itertools import chain, zip_longest
 from json import dumps, loads
-from typing import Dict, List, Literal
+from typing import Dict, List, Literal, Set, Tuple
 from uuid import UUID, uuid4
 
 import pytest
@@ -16,6 +16,7 @@
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import InstrumentedAttribute
+from starlette.datastructures import QueryParams
 
 from fastapi_jsonapi.views.view_base import ViewBase
 from tests.common import is_postgres_tests
@@ -151,6 +152,59 @@ async def test_get_users_paginated(
             "meta": {"count": 2, "totalPages": 2},
         }
 
+    @mark.parametrize(
+        "fields, expected_include",
+        [
+            param(
+                [
+                    ("fields[user]", "name,age"),
+                ],
+                {"name", "age"},
+            ),
+            param(
+                [
+                    ("fields[user]", "name,age"),
+                    ("fields[user]", "email"),
+                ],
+                {"name", "age", "email"},
+            ),
+        ],
+    )
+    async def test_select_custom_fields(
+        self,
+        app: FastAPI,
+        client: AsyncClient,
+        user_1: User,
+        user_2: User,
+        fields: List[Tuple[str, str]],
+        expected_include: Set[str],
+    ):
+        url = app.url_path_for("get_user_list")
+        user_1, user_2 = sorted((user_1, user_2), key=lambda x: x.id)
+
+        params = QueryParams(fields)
+        response = await client.get(url, params=str(params))
+
+        assert response.status_code == status.HTTP_200_OK, response.text
+        response_data = response.json()
+
+        assert response_data == {
+            "data": [
+                {
+                    "attributes": UserAttributesBaseSchema.from_orm(user_1).dict(include=expected_include),
+                    "id": str(user_1.id),
+                    "type": "user",
+                },
+                {
+                    "attributes": UserAttributesBaseSchema.from_orm(user_2).dict(include=expected_include),
+                    "id": str(user_2.id),
+                    "type": "user",
+                },
+            ],
+            "jsonapi": {"version": "1.0"},
+            "meta": {"count": 2, "total_pages": 1},
+        }
+
 
 class TestCreatePostAndComments:
     async def test_get_posts_with_users(