updated fields requests logic

Author: CosmoV

fastapi_jsonapi/api.py

@@ -77,6 +77,7 @@ def __init__(
         pagination_default_limit: Optional[int] = None,
         methods: Iterable[str] = (),
         ending_slash: bool = True,
+        model_id_field_name: str = "id",
     ) -> None:
         """
         Initialize router items.
@@ -122,7 +123,7 @@ def __init__(
             msg = f"Resource type {self.type_!r} already registered"
             raise ValueError(msg)
         self.all_jsonapi_routers[self.type_] = self
-        models_storage.add_model(resource_type, model)
+        models_storage.add_model(resource_type, model, model_id_field_name)
 
         self.pagination_default_size: Optional[int] = pagination_default_size
         self.pagination_default_number: Optional[int] = pagination_default_number

fastapi_jsonapi/data_layers/base.py

@@ -26,7 +26,6 @@ def __init__(
         model: Type[TypeModel],
         resource_type: str,
         url_id_field: str,
-        id_name_field: Optional[str] = None,
         disable_collection_count: bool = False,
         default_collection_count: int = -1,
         **kwargs,
@@ -38,7 +37,6 @@ def __init__(
         :param schema:
         :param model:
         :param url_id_field:
-        :param id_name_field:
         :param disable_collection_count:
         :param default_collection_count:
         :param resource_type: resource type
@@ -49,7 +47,6 @@ def __init__(
         self.model = model
         self.resource_type = resource_type
         self.url_id_field = url_id_field
-        self.id_name_field = id_name_field
         self.disable_collection_count: bool = disable_collection_count
         self.default_collection_count: int = default_collection_count
         self.is_atomic = False
@@ -94,26 +91,6 @@ async def create_object(self, data_create: BaseJSONAPIItemInSchema, view_kwargs:
         """
         raise NotImplementedError
 
-    def get_object_id_field_name(self):
-        """
-        compound key may cause errors
-
-        :return:
-        """
-        return self.id_name_field
-
-    def get_object_id_field(self):
-        id_name_field = self.get_object_id_field_name()
-        try:
-            return getattr(self.model, id_name_field)
-        except AttributeError:
-            msg = f"{self.model.__name__} has no attribute {id_name_field}"
-            # TODO: any custom exception type?
-            raise Exception(msg)
-
-    def get_object_id(self, obj: TypeModel):
-        return getattr(obj, self.get_object_id_field_name())
-
     async def get_object(self, view_kwargs: dict, qs: Optional[QueryStringManager] = None) -> TypeModel:
         """
         Retrieve an object

fastapi_jsonapi/data_layers/sqla/base_model.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Literal, Optional, Type, Union
+from typing import Any, Iterable, Literal, Optional, Type, Union
 
 from sqlalchemy import and_, delete, func, select
 from sqlalchemy.exc import IntegrityError
@@ -165,22 +165,21 @@ async def one_or_raise(
         return result
 
     @classmethod
-    async def query(
+    def query(
         cls,
         model: TypeModel,
         distinct_: bool = False,
-        fields: Optional[list] = None,
         filters: Optional[list[Union[BinaryExpression, bool]]] = None,
         for_update: Optional[dict] = None,
         join: Optional[list[RelationshipInfo]] = None,
         number: Optional[int] = None,
-        options: set = (),
+        options: Iterable = (),
         order: Optional[Union[str, UnaryExpression]] = None,
         size: Optional[int] = None,
         stmt: Optional[Select] = None,
     ) -> Select:
         if stmt is None:
-            stmt = select(model) if fields is None else select(*fields)
+            stmt = select(model)
 
         if filters is not None:
             stmt = stmt.where(*filters)

fastapi_jsonapi/data_layers/sqla/orm.py

@@ -8,8 +8,7 @@
 from pydantic import BaseModel
 from sqlalchemy.exc import MissingGreenlet
 from sqlalchemy.ext.asyncio import AsyncSession, AsyncSessionTransaction
-from sqlalchemy.inspection import inspect
-from sqlalchemy.orm import joinedload, selectinload
+from sqlalchemy.orm import joinedload, load_only, selectinload
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.orm.collections import InstrumentedList
 from sqlalchemy.sql import Select
@@ -246,13 +245,45 @@ async def create_object(
         await self.after_create_object(obj, model_kwargs, view_kwargs)
         return obj
 
-    def get_object_id_field_name(self):
-        """
-        compound key may cause errors
+    def get_fields_options(
+        self,
+        resource_type: str,
+        qs: QueryStringManager,
+        required_to_load: Optional[set] = None,
+    ) -> set:
+        required_to_load = required_to_load or set()
 
-        :return:
-        """
-        return self.id_name_field or inspect(self.model).primary_key[0].key
+        if resource_type not in qs.fields:
+            return set()
+
+        # empty str means skip all attributes
+        if "" not in qs.fields[resource_type]:
+            required_to_load.update(field_name for field_name in qs.fields[resource_type])
+
+        return self.get_load_only_options(
+            resource_type=resource_type,
+            field_names=required_to_load,
+        )
+
+    @staticmethod
+    def get_load_only_options(
+        resource_type: str,
+        field_names: Iterable[str],
+    ) -> set:
+        model = models_storage.get_model(resource_type)
+        options = {
+            load_only(
+                getattr(
+                    model,
+                    models_storage.get_model_id_field_name(resource_type),
+                ),
+            ),
+        }
+
+        for field_name in field_names:
+            options.add(load_only(getattr(model, field_name)))
+
+        return options
 
     async def get_object(
         self,
@@ -268,17 +299,24 @@ async def get_object(
         """
         await self.before_get_object(view_kwargs)
 
-        filter_field = self.get_object_id_field()
+        filter_field = models_storage.get_object_id_field(self.resource_type)
         filter_value = self.prepare_id_value(filter_field, view_kwargs[self.url_id_field])
 
-        relation_join_objects: list = []
+        options = set()
         if qs is not None:
-            relation_join_objects = self.eagerload_includes(qs)
+            options.update(self.eagerload_includes(qs))
+            options.update(
+                self.get_fields_options(
+                    resource_type=self.resource_type,
+                    qs=qs,
+                    required_to_load=set(view_kwargs.get("required_to_load", set())),
+                ),
+            )
 
-        query = await self._base_sql.query(
+        query = self._base_sql.query(
             model=self.model,
             filters=[filter_field == filter_value],
-            options=set(relation_join_objects),
+            options=options,
             stmt=self._query,
         )
         obj = await self._base_sql.one_or_raise(
@@ -317,16 +355,16 @@ async def get_collection(
             for relationship_path in relationship_paths
         ]
 
-        relation_join_objects: list = []
+        options = self.get_fields_options(self.resource_type, qs)
         if self.eagerload_includes_:
-            relation_join_objects = self.eagerload_includes(qs)
+            options.update(self.eagerload_includes(qs))
 
-        query = await self._base_sql.query(
+        query = self._base_sql.query(
             model=self.model,
             filters=self.get_filter_expressions(qs),
             join=relationships_info,
             number=qs.pagination.number,
-            options=set(relation_join_objects),
+            options=options,
             order=self.get_sort_expressions(qs),
             size=qs.pagination.size,
             stmt=self._query,
@@ -535,7 +573,7 @@ async def get_related_objects(
         id_field = getattr(related_model, related_id_field)
         id_values = [self.prepare_id_value(id_field, id_) for id_ in ids]
 
-        query = await self._base_sql.query(
+        query = self._base_sql.query(
             model=related_model,
             filters=[id_field.in_(id_values)],
         )
@@ -622,6 +660,13 @@ def eagerload_includes(
                 current_resource_type = relationship_info.resource_type
                 current_model = models_storage.get_model(current_resource_type)
 
+                relation_join_object = relation_join_object.options(
+                    *self.get_fields_options(
+                        resource_type=current_resource_type,
+                        qs=qs,
+                    ),
+                )
+
             relation_join_objects.append(relation_join_object)
 
         return relation_join_objects
@@ -638,7 +683,7 @@ async def before_create_object(
         :param view_kwargs: kwargs from the resource view.
         """
         if (id_value := model_kwargs.get("id")) and self.auto_convert_id_to_column_type:
-            model_field = self.get_object_id_field()
+            model_field = models_storage.get_object_id_field(resource_type=self.resource_type)
             model_kwargs.update(id=self.prepare_id_value(model_field, id_value))
 
     async def after_create_object(

fastapi_jsonapi/models_storage.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Callable, Type
+from typing import Any, Callable, Type
 
 from fastapi_jsonapi.data_typing import TypeModel
 from fastapi_jsonapi.exceptions import BadRequest, InternalServerError
@@ -11,17 +11,51 @@ class ModelsStorage:
     relationship_search_handlers: dict[str, Callable[[str, Type[TypeModel], str], Type[TypeModel]]]
 
     def __init__(self):
-        self._data: dict[str, TypeModel] = {}
+        self._models: dict[str, Type[TypeModel]] = {}
+        self._id_field_names: dict[str, str] = {}
         self.relationship_search_handlers = {}
 
-    def add_model(self, resource_type: str, model: Type[TypeModel]):
-        self._data[resource_type] = model
+    def add_model(self, resource_type: str, model: Type[TypeModel], id_field_name: str):
+        self._models[resource_type] = model
+        self._id_field_names[resource_type] = id_field_name
 
     def get_model(self, resource_type: str) -> Type[TypeModel]:
         try:
-            return self._data[resource_type]
+            return self._models[resource_type]
         except KeyError:
-            raise InternalServerError(detail=f"Not found model for resource_type {resource_type!r}.")
+            raise InternalServerError(
+                detail=f"Not found model for resource_type {resource_type!r}.",
+            )
+
+    def get_model_id_field_name(self, resource_type: str) -> str:
+        try:
+            return self._id_field_names[resource_type]
+        except KeyError:
+            raise InternalServerError(
+                detail=f"Not found model id field name for resource_type {resource_type!r}.",
+            )
+
+    def get_object_id_field(self, resource_type: str) -> Any:
+        model = self.get_model(resource_type)
+        id_field_name = self.get_model_id_field_name(resource_type)
+
+        try:
+            return getattr(model, id_field_name)
+        except AttributeError:
+            raise InternalServerError(
+                detail=f"Can't get object id field. The model {model.__name__!r} has no attribute {id_field_name!r}",
+            )
+
+    def get_object_id(self, db_object: TypeModel, resource_type: str) -> Any:
+        id_field_name = self.get_model_id_field_name(resource_type)
+
+        try:
+            return getattr(db_object, id_field_name)
+        except AttributeError:
+            model = self.get_model(resource_type)
+            raise InternalServerError(
+                detail=f"Can't get object id. The model {model.__name__!r} has no attribute {id_field_name!r}.",
+            )
 
     def register_search_handler(self, orm_mode: str, handler: Callable[[str, Type[TypeModel], str], Type[TypeModel]]):
         self.relationship_search_handlers[orm_mode] = handler
@@ -40,7 +74,7 @@ def search_relationship_model(
         except KeyError:
             raise InternalServerError(
                 detail=f"Not found orm handler for {self._orm_mode!r}. "
-                f"Please register this with SchemasStorage.register_search_handler",
+                f"Please register this with SchemasStorage.register_search_handler.",
             )
 
         return orm_handler(resource_type, model, field_name)

fastapi_jsonapi/schema.py

@@ -182,6 +182,10 @@ class SchemasInfoDTO:
 
     relationships_info: dict[str, tuple[RelationshipInfo, Any]]
 
+    field_schemas: dict[str, Type[BaseModel]]
+
+    model_validators: dict
+
 
 def get_model_field(schema: Type["TypeSchema"], field: str) -> str:
     """

fastapi_jsonapi/schema_builder.py

@@ -132,7 +132,9 @@ def build_schema_in(
             source_schema=schema,
             data_schema=object_jsonapi_schema,
             attributes_schema=dto.attributes_schema,
+            field_schemas=dto.field_schemas,
             relationships_info=dto.relationships_info,
+            model_validators=dto.model_validators,
         )
 
         wrapped_object_jsonapi_schema = create_model(
@@ -230,7 +232,7 @@ def _get_info_from_schema_for_building(
                 if related_schema := get_schema_from_field_annotation(field):
                     included_schemas.append((name, related_schema, relationship_info.resource_type))
             elif name == "id":
-                id_validators = extract_validators(
+                id_validators, _ = extract_validators(
                     model=schema,
                     include_for_field_names={"id"},
                 )
@@ -245,13 +247,27 @@ def _get_info_from_schema_for_building(
             from_attributes=True,
         )
 
+        field_validators, model_validators = extract_validators(schema, exclude_for_field_names={"id"})
         attributes_schema = create_model(
             f"{base_name}AttributesJSONAPI",
             **attributes_schema_fields,
             __config__=model_config,
-            __validators__=extract_validators(schema, exclude_for_field_names={"id"}),
+            __validators__={**field_validators, **model_validators},
         )
 
+        field_schemas = {}
+        for field_name, field in attributes_schema_fields.items():
+            field_validators, _ = extract_validators(
+                schema,
+                include_for_field_names={field_name},
+            )
+            field_schemas[field_name] = create_model(
+                f"{base_name}{field_name.title()}AttributeJSONAPI",
+                **{field_name: field},
+                __config__=model_config,
+                __validators__=field_validators,
+            )
+
         relationships_schema = create_model(
             f"{base_name}RelationshipsJSONAPI",
             **relationships_schema_fields,
@@ -265,6 +281,8 @@ def _get_info_from_schema_for_building(
             relationships_info=relationships_info,
             has_required_relationship=has_required_relationship,
             included_schemas=included_schemas,
+            field_schemas=field_schemas,
+            model_validators=model_validators,
         )
 
     @classmethod
@@ -440,7 +458,9 @@ def create_jsonapi_object_schemas(
             source_schema=schema,
             data_schema=relationship_less_object_jsonapi_schema,
             attributes_schema=dto.attributes_schema,
+            field_schemas=dto.field_schemas,
             relationships_info=dto.relationships_info,
+            model_validators=dto.model_validators,
         )
 
         can_be_included_schemas = {}