fastapi-basekit 0.1.24__tar.gz → 0.1.25__tar.gz

{fastapi_basekit-0.1.24 → fastapi_basekit-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.1.24
+Version: 0.1.25
 Summary: Utilities and base classes for FastAPI async projects (Beanie or SQLAlchemy)
 Author-email: Jerson Moreno <jerson.ml820@hotmail.com>
 License: MIT

{fastapi_basekit-0.1.24 → fastapi_basekit-0.1.25}/fastapi_basekit/aio/sqlalchemy/controller/base.py

@@ -53,7 +53,6 @@ class SQLAlchemyBaseController(BaseController):
             **params,
             "use_or": use_or,
             "joins": joins,
-            "order_by": order_by,
         }
         items, total = await self.service.list(**service_params)
         count = params.get("count") or 0

{fastapi_basekit-0.1.24 → fastapi_basekit-0.1.25}/fastapi_basekit/aio/sqlalchemy/repository/base.py

@@ -16,10 +16,12 @@ class BaseRepository:
     """
 
     model: Type[Any]
+    service: Optional[Any] = None
 
     def __init__(self, db: AsyncSession):
         """Inicializa el repositorio con la sesión a reutilizar."""
         self._session = db
+        self.service = None
 
     @property
     def session(self) -> AsyncSession:
@@ -50,6 +52,51 @@ class BaseRepository:
                         query = query.options(joinedload(relationship_attr))
         return query
 
+    def _resolve_field_path(
+        self, path: str
+    ) -> Tuple[Optional[Any], Dict[str, Any]]:
+        """
+        Resuelve una ruta de campo (ej. 'user__role__name') a su atributo
+        de SQLAlchemy y el conjunto de JOINs necesarios para el filtrado.
+
+        Args:
+            path: Ruta del campo con sintaxis '__'
+
+        Returns:
+            Tuple con:
+            - attr: Atributo final (columna o relación) o None si no existe
+            - joins_to_apply: Dict con las relaciones intermedias (name: attr)
+        """
+        parts = path.split("__")
+        current_model = self.model
+        attr = getattr(current_model, parts[0], None)
+        joins_to_apply = {}
+
+        if attr is None:
+            return None, {}
+
+        # Recorrer la cadena de relaciones intermedias
+        for part in parts[1:]:
+            # Chequear si el atributo actual es una relación ORM
+            if hasattr(attr.property, "entity") and isinstance(
+                attr.property, Relationship
+            ):
+                # Es una relación: Añadir al diccionario de JOINs
+                relation_name = attr.key
+                joins_to_apply[relation_name] = attr
+
+                # Mover al modelo relacionado y obtener el siguiente atributo
+                current_model = attr.property.mapper.class_
+                attr = getattr(current_model, part, None)
+
+                if attr is None:
+                    return None, {}
+            else:
+                # No es una relación o es el final del path
+                break
+
+        return attr, joins_to_apply
+
     def _resolve_attribute(
         self, filters: Dict[str, Any]
     ) -> Tuple[Dict[str, Tuple[Any, Any]], Dict[str, Any]]:
@@ -84,17 +131,13 @@ class BaseRepository:
         joins_to_apply = {}
 
         for filter_path, value in filters.items():
-            parts = filter_path.split("__")
-
-            # Inicialización
-            current_model = self.model
-            attr = getattr(current_model, parts[0], None)
+            attr, field_joins = self._resolve_field_path(filter_path)
 
             if attr is None:
-                # Si no existe el campo base, omitir silenciosamente
-                # (mantiene compatibilidad con código existente)
                 continue
 
+            joins_to_apply.update(field_joins)
+
             # Procesar valor (manejo de Enum a su valor/lista de valores)
             processed_value = value
             if (
@@ -106,47 +149,14 @@ class BaseRepository:
             elif hasattr(value, "value"):
                 processed_value = value.value
 
-            # 1. Recorrer la cadena de relaciones intermedias
-            for part in parts[1:]:
-                # Chequear si el atributo actual es una relación ORM
-                if hasattr(attr.property, "entity") and isinstance(
-                    attr.property, Relationship
-                ):
-                    # Es una relación: Añadir al diccionario de JOINs si no
-                    # está ya
-                    relation_name = (
-                        attr.key
-                    )  # Nombre del atributo en el modelo
-                    # (e.g., 'user_roles')
-                    joins_to_apply[relation_name] = attr
-
-                    # Mover al modelo relacionado y obtener el siguiente
-                    # atributo
-                    current_model = attr.property.mapper.class_
-                    attr = getattr(current_model, part, None)
-
-                    if attr is None:
-                        break  # El siguiente campo no existe
-                else:
-                    # No es una relación (parte final del path), romper el
-                    # bucle
-                    break
-
-            # 2. Si el atributo final es válido, añadir a las condiciones
-            # resueltas
-            # Verificamos si es una Columna (o un campo scalar)
-            # Para columnas simples, attr.property.columns existe
-            # Para relaciones, attr.property es Relationship
-            if attr is not None:
-                # Verificar que no sea una relación (solo queremos columnas)
-                is_relationship = isinstance(attr.property, Relationship)
-                # Verificar que sea una columna o atributo válido
-                is_column = hasattr(attr.property, "columns") or hasattr(
-                    attr, "comparator"
-                )
-
-                if not is_relationship and is_column:
-                    resolved_filters[filter_path] = (attr, processed_value)
+            # Verificar que no sea una relación (solo queremos columnas para filtrar)
+            is_relationship = isinstance(attr.property, Relationship)
+            is_column = hasattr(attr.property, "columns") or hasattr(
+                attr, "comparator"
+            )
+
+            if not is_relationship and is_column:
+                resolved_filters[filter_path] = (attr, processed_value)
 
         return resolved_filters, joins_to_apply
 
@@ -233,53 +243,21 @@ class BaseRepository:
             order_expression = attr.desc() if should_descend else attr.asc()
             return order_expression, {}
 
-        # 2. Si no es un campo especial, procesar como campo normal o relación
-        # Dividir la ruta en partes (puede ser simple o con relaciones)
-        parts = field_path.split("__")
-
-        # Inicialización: empezar con el modelo base
-        current_model = self.model
-        attr = getattr(current_model, parts[0], None)
+        # 2. Si no es un campo especial, procesar con el helper
+        attr, field_joins = self._resolve_field_path(field_path)
 
         if attr is None:
-            # Campo base no existe, retornar None
             return None, {}
 
-        # 3. Recorrer la cadena de relaciones intermedias
-        for part in parts[1:]:
-            # Chequear si el atributo actual es una relación ORM
-            if hasattr(attr.property, "entity") and isinstance(
-                attr.property, Relationship
-            ):
-                # Es una relación: Añadir al diccionario de JOINs si no está ya
-                relation_name = attr.key  # Nombre del atributo en el modelo
-                joins_to_apply[relation_name] = attr
-
-                # Mover al modelo relacionado y obtener el siguiente atributo
-                current_model = attr.property.mapper.class_
-                attr = getattr(current_model, part, None)
-
-                if attr is None:
-                    # El siguiente campo no existe
-                    return None, {}
-            else:
-                # No es una relación (parte final del path), romper el bucle
-                break
+        joins_to_apply.update(field_joins)
 
         # 4. Verificar que el atributo final es válido para ordenar
-        # Solo queremos columnas, no relaciones
-        if attr is None:
-            return None, {}
-
-        # Verificar que no sea una relación (solo queremos columnas)
         is_relationship = isinstance(attr.property, Relationship)
-        # Verificar que sea una columna o atributo válido
         is_column = hasattr(attr.property, "columns") or hasattr(
             attr, "comparator"
         )
 
         if is_relationship or not is_column:
-            # No es una columna válida para ordenar
             return None, {}
 
         # 5. Determinar la dirección del ordenamiento
@@ -337,25 +315,44 @@ class BaseRepository:
 
     def _build_search_condition(
         self, search: Optional[str], search_fields: Optional[List[str]]
-    ) -> Optional[Any]:
+    ) -> Tuple[Optional[Any], Dict[str, Any]]:
         """Construye una condición OR para búsqueda textual en múltiples campos
 
         Usa ilike (insensible a mayúsculas) si hay término y campos válidos.
-        Ignora campos inexistentes silenciosamente.
+        Soporta rutas anidadas con '__'.
+
+        Returns:
+            Tuple con:
+            - search_condition: Condición OR de SQLAlchemy o None
+            - search_joins: Dict con JOINs necesarios para la búsqueda
         """
         if not search or not search_fields:
-            return None
+            return None, {}
+        
         exprs: List[Any] = []
-        for field_name in search_fields:
-            try:
-                field = self._get_field(field_name)
-            except AttributeError:
-                # Si el campo no existe en el modelo, lo omitimos
+        search_joins: Dict[str, Any] = {}
+
+        for field_path in search_fields:
+            attr, field_joins = self._resolve_field_path(field_path)
+            
+            if attr is None:
                 continue
-            exprs.append(field.ilike(f"%{search}%"))
+
+            search_joins.update(field_joins)
+
+            # Verificar que sea una columna válida para ILIKE
+            is_column = hasattr(attr.property, "columns") or hasattr(
+                attr, "comparator"
+            )
+            is_relationship = isinstance(attr.property, Relationship)
+
+            if not is_relationship and is_column:
+                exprs.append(attr.ilike(f"%{search}%"))
+
         if not exprs:
-            return None
-        return or_(*exprs)
+            return None, {}
+
+        return or_(*exprs), search_joins
 
     async def create(self, obj_in: Any | Dict) -> Any:
         """Crea un nuevo registro en la base de datos."""
@@ -578,9 +575,17 @@ class BaseRepository:
         )
 
         # 4. Aplicar búsqueda textual (search)
-        search_condition = self._build_search_condition(search, search_fields)
+        search_condition, search_joins = self._build_search_condition(
+            search, search_fields
+        )
+
+        # 5. Aplicar JOINs de búsqueda
+        for relation_name, relation_attr in search_joins.items():
+            # Evitar unir dos veces la misma relación si ya se hizo por filtros
+            # NOTA: join() en SQLAlchemy es idempotente si es la misma entidad/atributo
+            queryset = queryset.join(relation_attr)
 
-        # 5. Combina todos los filtros
+        # 6. Combina todos los filtros
         if combined_filters is not None and search_condition is not None:
             queryset = queryset.where(
                 and_(combined_filters, search_condition)
@@ -625,12 +630,11 @@ class BaseRepository:
         order_by: Optional[Any] = None,
         search: Optional[str] = None,
         search_fields: Optional[List[str]] = None,
-        base_query: Optional[Select[Tuple[Any]]] = None,
         **kwargs: Any,
     ) -> tuple[List[Any], int]:
         
-        # 1. Construir query personalizado
-        kwargs = {
+        # 1. Construir query base
+        query_kwargs = {
             "filters": filters,
             "use_or": use_or,
             "joins": joins,
@@ -638,13 +642,12 @@ class BaseRepository:
             "search": search,
             "search_fields": search_fields,
         }
-
         try:
-             # Try with arguments (Modern subclasses)
-             queryset = self.build_list_queryset(**kwargs)
+            # Intentar con argumentos (subclases modernas)
+            queryset = self.build_list_queryset(**query_kwargs)
         except TypeError:
-             # Fallback to no arguments (Legacy subclasses)
-             queryset = self.build_list_queryset()
+            # Fallback sin argumentos (subclases legacy)
+            queryset = self.build_list_queryset()
 
         # 2. Aplicar filtros estándar
         queryset = self.apply_list_filters(

{fastapi_basekit-0.1.24 → fastapi_basekit-0.1.25}/fastapi_basekit/aio/sqlalchemy/service/base.py

@@ -23,14 +23,37 @@ class BaseService:
         self,
         repository: BaseRepository,
         request: Optional[Request] = None,
+        **kwargs,
     ):
         self.repository = repository
         self.request = request
+
+        # Vincular el servicio al repositorio principal
+        if self.repository:
+            self.repository.service = self
+
+        # Procesar kwargs adicionales para vincular otros repositorios
+        for name, value in kwargs.items():
+            if isinstance(value, BaseRepository):
+                value.service = self
+            setattr(self, name, value)
         endpoint_func = (
             self.request.scope.get("endpoint") if self.request else None
         )
         self.action = endpoint_func.__name__ if endpoint_func else None
 
+        # Parámetros compartidos para consultas (especialmente list)
+        self.params: Dict[str, Any] = {
+            "search": None,
+            "page": 1,
+            "count": 25,
+            "filters": {},
+            "use_or": False,
+            "joins": None,
+            "order_by": None,
+            "meta": {}
+        }
+
     def get_filters(
         self, filters: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
@@ -51,27 +74,6 @@ class BaseService:
         """
         return self.kwargs_query or {}
 
-    def build_queryset(self) -> Select[Tuple[Any]]:
-        """Construye el queryset base para las consultas de listado.
-
-        Este método puede ser sobrescrito por el usuario para personalizar
-        el queryset base (agregar joins, agregaciones, etc.) sin necesidad
-        de reescribir el método list().
-
-        Ejemplo de uso:
-            def build_queryset(self):
-                from sqlalchemy import func, select
-                from .models import User, Referral
-
-                return select(
-                    User,
-                    func.count(Referral.id).label('referidos_count')
-                ).outerjoin(Referral, User.id == Referral.user_id).group_by(User.id)
-
-        Returns:
-            Select: Query base de SQLAlchemy
-        """
-        return select(self.repository.model)
 
     async def retrieve(
         self, id: str, joins: Optional[List[str]] = None
@@ -91,33 +93,52 @@ class BaseService:
     async def list(
         self,
         search: Optional[str] = None,
-        page: int = 1,
-        count: int = 25,
+        page: Optional[int] = None,
+        count: Optional[int] = None,
         filters: Optional[Dict[str, Any]] = None,
-        use_or: bool = False,
+        use_or: Optional[bool] = None,
         joins: Optional[List[str]] = None,
         order_by: Optional[Any] = None,
     ) -> tuple[List[Any], int]:
-        # Construye el queryset base personalizado
-        base_query = self.build_queryset()
+        # Actualiza self.params con los argumentos proporcionados (si no son None)
+        if search is not None:
+            self.params["search"] = search
+        if page is not None:
+            self.params["page"] = page
+        if count is not None:
+            self.params["count"] = count
+        if filters is not None:
+            self.params["filters"] = filters
+        if use_or is not None:
+            self.params["use_or"] = use_or
+        if joins is not None:
+            self.params["joins"] = joins
+        if order_by is not None:
+            self.params["order_by"] = order_by
+
 
         # Aplica filtros y kwargs de consulta definidos por el servicio
-        applied = self.get_filters(filters)
+        applied_filters = self.get_filters(self.params["filters"])
         kwargs = self.get_kwargs_query()
-        if joins is None:
-            joins = kwargs.get("joins")
-        if order_by is None:
-            order_by = kwargs.get("order_by", self.order_by)
+
+        # Prioridad de joins: argumento explícito > kwargs del servicio (por acción)
+        final_joins = self.params["joins"]
+        if final_joins is None:
+            final_joins = kwargs.get("joins")
+
+        # Prioridad de order_by: argumento explícito > kwargs del servicio > default del servicio
+        final_order_by = self.params["order_by"]
+        if final_order_by is None:
+            final_order_by = kwargs.get("order_by", self.order_by)
 
         return await self.repository.list_paginated(
-            base_query=base_query,
-            page=page,
-            count=count,
-            filters=applied,
-            use_or=use_or,
-            joins=joins,
-            order_by=order_by,
-            search=search,
+            page=self.params["page"],
+            count=self.params["count"],
+            filters=applied_filters,
+            use_or=self.params["use_or"],
+            joins=final_joins,
+            order_by=final_order_by,
+            search=self.params["search"],
             search_fields=self.search_fields,
         )
 

{fastapi_basekit-0.1.24 → fastapi_basekit-0.1.25}/fastapi_basekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.1.24
+Version: 0.1.25
 Summary: Utilities and base classes for FastAPI async projects (Beanie or SQLAlchemy)
 Author-email: Jerson Moreno <jerson.ml820@hotmail.com>
 License: MIT

{fastapi_basekit-0.1.24 → fastapi_basekit-0.1.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastapi-basekit"
-version = "0.1.24"
+version = "0.1.25"
 description = "Utilities and base classes for FastAPI async projects (Beanie or SQLAlchemy)"
 readme = "README.md"
 requires-python = ">=3.11"