fastapi-rtk 0.2.27__py3-none-any.whl → 1.0.13__py3-none-any.whl

fastapi_rtk/backends/sqla/db.py

@@ -1,8 +1,8 @@
 import collections
 import typing
 
+import fastapi
 import sqlalchemy
-from fastapi import HTTPException
 from sqlalchemy import (
     Column,
     Select,
@@ -18,8 +18,10 @@ from sqlalchemy.orm.strategy_options import _AbstractLoad
 
 from ...bases.db import AbstractQueryBuilder
 from ...const import logger
+from ...exceptions import HTTPWithValidationException
+from ...lang import translate
 from ...utils import T, deep_merge, prettify_dict, safe_call, smart_run
-from .filters import BaseFilter
+from .filters import BaseFilter, BaseOprFilter
 
 __all__ = ["SQLAQueryBuilder"]
 
@@ -32,6 +34,7 @@ LOAD_TYPE_MAPPING = {
 
 class LoadColumn(typing.TypedDict):
     statement: Select[tuple[T]] | _AbstractLoad
+    statement_type: typing.Literal["select", "joinedload", "selectinload"] | None
     type: typing.Literal["defer", "some", "all"]
     columns: list[str]
     related_columns: collections.defaultdict[str, "LoadColumn"]
@@ -40,6 +43,7 @@ class LoadColumn(typing.TypedDict):
 def create_load_column(statement: Select[tuple[T]] | _AbstractLoad | None = None):
     return LoadColumn(
         statement=statement,
+        statement_type=None,
         type="defer",
         columns=[],
         related_columns=collections.defaultdict(create_load_column),
@@ -102,7 +106,7 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
                     statement = statement.options(cache_option)
             return statement
 
-        load_column = self._load_columns_recursively(statement, list_columns)
+        load_column = self._load_columns_recursively(statement, "select", list_columns)
         logger.debug(f"Load Column:\n{prettify_dict(load_column)}")
         return self._load_columns_from_dictionary(statement, load_column, list_columns)
 
@@ -153,8 +157,13 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
                 filter_class = f
                 break
         if not filter_class:
-            raise HTTPException(
-                status_code=400, detail=f"Invalid filter opr: {filter.opr}"
+            raise HTTPWithValidationException(
+                fastapi.status.HTTP_400_BAD_REQUEST,
+                "invalid_key",
+                "query",
+                "filters",
+                translate("Invalid filter operator: {operator}", operator=filter.opr),
+                filter.model_dump(mode="json"),
             )
 
         if "." in filter.col:
@@ -171,6 +180,29 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
 
         return await self._filter(filter_class, statement, col, value)
 
+    async def apply_opr_filter(self, statement, filter):
+        filter_class = None
+        for f in self.datamodel.opr_filters:
+            if f.arg_name == filter.opr:
+                filter_class = f
+                break
+        if not filter_class:
+            raise HTTPWithValidationException(
+                fastapi.status.HTTP_400_BAD_REQUEST,
+                "invalid_key",
+                "query",
+                "opr_filters",
+                translate(
+                    "Invalid opr_filter operator: {operator}", operator=filter.opr
+                ),
+                filter.model_dump(mode="json"),
+            )
+
+        return await self._filter(filter_class, statement, None, filter.value)
+
+    async def apply_opr_filter_class(self, statement, filter_class, value):
+        return await self._filter(filter_class, statement, None, value)
+
     async def apply_global_filter(self, statement, columns, global_filter):
         return await self.apply_filter_class(
             statement,
@@ -255,27 +287,32 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
 
     async def _filter(
         self,
-        cls: BaseFilter,
+        cls: BaseFilter | BaseOprFilter,
         statement: Select[tuple[T]],
-        col: str,
+        col: str | None,
         value: typing.Any,
     ):
         """
         Helper method to apply a filter class.
 
         Args:
-            cls (BaseFilter): The filter class to apply.
+            cls (BaseFilter | BaseOprFilter): The filter class to apply.
             statement (Select[tuple[T]]): The SQLAlchemy Select statement to which the filter will be applied.
-            col (str): The column name to apply the filter on.
+            col (str | None): The column name to apply the filter on. None if the filter is an OprFilter.
             value (typing.Any): The value to filter by.
 
         Returns:
             Select[tuple[T]]: The SQLAlchemy Select statement with the filter applied.
         """
+        params = [statement]
+        if isinstance(cls, BaseOprFilter):
+            params.append(value)
+        else:
+            params.extend([col, value])
         if cls.is_heavy:
-            return await smart_run(cls.apply, statement, col, value)
+            return await smart_run(cls.apply, *params)
 
-        return await safe_call(cls.apply(statement, col, value))
+        return await safe_call(cls.apply(*params))
 
     def _load_columns_from_dictionary(
         self,
@@ -330,27 +367,32 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
         return statement
 
     def _load_columns_recursively(
-        self, statement: Select[tuple[T]] | _AbstractLoad, columns: list[str]
+        self,
+        statement: Select[tuple[T]] | _AbstractLoad,
+        statement_type: typing.Literal["select", "joinedload", "selectinload"],
+        columns: list[str],
     ):
         """
         Load specified columns into the given SQLAlchemy statement. This returns a dictionary that can be used with the `load_columns_from_dictionary` method.
 
         Args:
             statement (Select[tuple[T]] | _AbstractLoad): The SQLAlchemy statement to which the columns will be loaded.
+            statement_type (typing.Literal["select", "joinedload", "selectinload"]): The type of statement to use for loading.
             columns (list[str]): A list of column names to be loaded.
 
         Returns:
             dict: A dictionary that can be used with the `load_columns_from_dictionary` method.
         """
         load_column = create_load_column(statement)
+        load_column["statement_type"] = statement_type
         for col in columns:
             sub_col = ""
             if "." in col:
                 col, sub_col = col.split(".", 1)
 
-            # If it is not a relation, load only the column if it is in the user column list, else skip
+            # If it is not a relation, load only the column if it is in the column list, else skip
             if not self.datamodel.is_relation(col):
-                if col in self.datamodel.get_user_column_list():
+                if col in self.datamodel.get_column_list():
                     load_column["columns"].append(col)
                     load_column["type"] = "some"
                 continue
@@ -358,10 +400,18 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
             if self.datamodel.is_relation_one_to_one(
                 col
             ) or self.datamodel.is_relation_many_to_one(col):
+                load_column["related_columns"][col]["statement_type"] = (
+                    load_column["related_columns"][col]["statement_type"]
+                    or "joinedload"
+                )
                 load_column["related_columns"][col]["statement"] = load_column[
                     "related_columns"
                 ][col]["statement"] or joinedload(self.datamodel.obj.load_options(col))
             else:
+                load_column["related_columns"][col]["statement_type"] = (
+                    load_column["related_columns"][col]["statement_type"]
+                    or "selectinload"
+                )
                 load_column["related_columns"][col]["statement"] = load_column[
                     "related_columns"
                 ][col]["statement"] or selectinload(
@@ -375,7 +425,9 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
                 load_column["related_columns"][col] = deep_merge(
                     load_column["related_columns"][col],
                     interface.query._load_columns_recursively(
-                        load_column["related_columns"][col]["statement"], [sub_col]
+                        load_column["related_columns"][col]["statement"],
+                        load_column["related_columns"][col]["statement_type"],
+                        [sub_col],
                     ),
                     rules={
                         "type": lambda x1, x2: LOAD_TYPE_MAPPING[x2]
@@ -392,8 +444,8 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
                 load_column["related_columns"][col]["type"] = "all"
                 continue
 
-            # Skip if the sub column is not in the user column list or if it is a relation
-            if sub_col not in interface.get_user_column_list() or interface.is_relation(
+            # Skip if the sub column is not in the column list or if it is a relation
+            if sub_col not in interface.get_column_list() or interface.is_relation(
                 sub_col
             ):
                 continue
@@ -402,3 +454,11 @@ class SQLAQueryBuilder(AbstractQueryBuilder[Select[tuple[T]]]):
             load_column["related_columns"][col]["type"] = "some"
 
         return load_column
+
+    def _convert_id_into_dict(self, id):
+        # Cast the id into the right type based on the pk column type
+        pk_dict = super()._convert_id_into_dict(id)
+        for pk in pk_dict:
+            col_type = self.datamodel.list_columns[pk].type.python_type
+            pk_dict[pk] = col_type(pk_dict[pk])
+        return pk_dict