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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-basekit
-Version: 0.1.23
+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.25/fastapi_basekit/aio/beanie/repository/base.py

@@ -0,0 +1,360 @@
+from typing import Any, Dict, List, Optional, Type, Union
+from typing import get_args, get_origin
+import re
+
+from bson import ObjectId, Link
+from pydantic import BaseModel
+from beanie import Document
+from beanie.odm.queries.find import FindMany
+from beanie.operators import Or, RegEx
+
+
+class BaseRepository:
+    model: Type[Document]
+    
+    def _parse_order_field(self, order_by: str) -> tuple[str, int, bool]:
+        """Parse order_by string into components.
+        
+        Args:
+            order_by: Order string, e.g., "-created_at" or "tool__name"
+            
+        Returns:
+            tuple: (field_path, direction, is_nested)
+            - field_path: "tool.name" or "created_at"
+            - direction: 1 (asc) or -1 (desc)
+            - is_nested: True if contains "__"
+        """
+        # Check for descending prefix
+        direction = -1 if order_by.startswith("-") else 1
+        field = order_by.lstrip("-")
+        
+        # Check if nested (contains __ or .)
+        is_nested = "__" in field or "." in field
+        
+        # Convert __ to . for MongoDB field path (normalize)
+        field_path = field.replace("__", ".")
+        
+        return field_path, direction, is_nested
+    
+    def _get_collection_name_from_field(self, field_name: str) -> Optional[str]:
+        """Get the collection name for a Link field.
+        
+        Args:
+            field_name: Name of the field in the model
+            
+        Returns:
+            Collection name or None if not a Link field
+        """
+        if not hasattr(self.model, "model_fields"):
+            return None
+            
+        model_fields = self.model.model_fields
+        field_info = model_fields.get(field_name)
+        
+        if not field_info:
+            return None
+        
+        field_type = field_info.annotation
+        origin = get_origin(field_type)
+        
+        # Handle Link[Model]
+        if origin is Link:
+            args = get_args(field_type)
+            if args:
+                linked_model = args[0]
+                if hasattr(linked_model, "Settings") and hasattr(linked_model.Settings, "name"):
+                    return linked_model.Settings.name
+        
+        # Handle Optional[Link[Model]]
+        if origin is Union:
+            args = get_args(field_type)
+            for arg in args:
+                arg_origin = get_origin(arg)
+                if arg_origin is Link:
+                    link_args = get_args(arg)
+                    if link_args:
+                        linked_model = link_args[0]
+                        if hasattr(linked_model, "Settings") and hasattr(linked_model.Settings, "name"):
+                            return linked_model.Settings.name
+        
+        return None
+
+    def _get_query_kwargs(
+        self,
+        fetch_links: bool = False,
+        nesting_depths_per_field: Optional[Dict[str, int]] = None,
+        projection: Optional[Union[List[str], Type[BaseModel]]] = None,
+    ):
+        kwargs = {
+            "fetch_links": fetch_links,
+            "nesting_depths_per_field": (
+                nesting_depths_per_field if fetch_links else None
+            ),
+        }
+        if projection is not None:
+            kwargs["projection"] = projection
+        return kwargs
+
+    def build_filter_query(
+        self,
+        search: Optional[str],
+        search_fields: List[str],
+        filters: dict = None,
+        order_by: Optional[List[tuple]] = None,
+        **kwargs,
+    ) -> FindMany[Document]:
+        """Versión personalizada que soporta campos Link."""
+        exprs = []
+
+        if search and search_fields:
+            exprs.append(
+                Or(
+                    *[
+                        RegEx(
+                            getattr(self.model, f),
+                            f".*{search}.*",
+                            options="i",
+                        )
+                        for f in search_fields
+                    ]
+                )
+            )
+
+        # Obtener campos del modelo
+        model_fields = (
+            self.model.model_fields
+            if hasattr(self.model, "model_fields")
+            else {}
+        )
+
+        def _is_link_field(field_name: str) -> bool:
+            """Verifica si un campo es de tipo Link."""
+            field_info = model_fields.get(field_name)
+            if not field_info:
+                return False
+
+            field_type = field_info.annotation
+            origin = get_origin(field_type)
+
+            # Caso directo: Link[Model]
+            if origin is Link:
+                return True
+
+            # Caso Optional[Link[Model]] = Union[Link[Model], None]
+            # O cualquier Union que contenga Link
+            if origin is not None:
+                args = get_args(field_type)
+                for arg in args:
+                    # Verificar si el argumento es Link
+                    arg_origin = get_origin(arg)
+                    if arg_origin is Link:
+                        return True
+
+            return False
+
+        for k, v in (filters or {}).items():
+            if hasattr(self.model, k):
+                field_attr = getattr(self.model, k)
+
+                if _is_link_field(k):
+                    exprs.append(field_attr.id == v)
+                else:
+                    exprs.append(field_attr == v)
+
+        query = self.model.find(*exprs, **self._get_query_kwargs(**kwargs))
+        
+        # Apply ordering if provided
+        if order_by:
+            query = query.sort(order_by)
+        
+        return query
+
+    async def paginate(
+        self, query: FindMany[Document], page: int, count: int, order_by: Optional[List[tuple]] = None
+    ) -> tuple[List[Document], int]:
+        # Apply ordering if provided and not already applied
+        if order_by:
+            query = query.sort(order_by)
+        
+        total = await query.count()
+        items = await query.skip(count * (page - 1)).limit(count).to_list()
+        return items, total
+    
+    async def list_with_aggregation(
+        self,
+        search: Optional[str],
+        search_fields: List[str],
+        filters: dict,
+        order_by: str,
+        page: int,
+        count: int,
+        **kwargs
+    ) -> tuple[List[Document], int]:
+        """List with support for nested ordering using aggregation ($facet optimized)."""
+        field_path, direction, is_nested = self._parse_order_field(order_by)
+        pipeline = []
+        
+        # 1. Match stage (same as before)
+        match_conditions = {}
+        if filters:
+            for key, value in filters.items():
+                if isinstance(value, ObjectId):
+                    match_conditions[key] = value
+                elif hasattr(value, "id"):
+                    match_conditions[f"{key}.$id"] = value.id
+                else:
+                    match_conditions[key] = value
+        
+        if search and search_fields:
+            search_conditions = [
+                {field: {"$regex": f".*{search}.*", "$options": "i"}}
+                for field in search_fields
+            ]
+            if search_conditions:
+                if match_conditions:
+                    match_conditions = {"$and": [match_conditions, {"$or": search_conditions}]}
+                else:
+                    match_conditions = {"$or": search_conditions}
+        
+        if match_conditions:
+            pipeline.append({"$match": match_conditions})
+        
+        # 2. Lookup & Sort (same as before)
+        collection_name = None
+        first_field = None
+        
+        if is_nested:
+            parts = field_path.split(".")
+            first_field = parts[0]
+            collection_name = self._get_collection_name_from_field(first_field)
+            
+            if collection_name:
+                pipeline.extend([
+                    {
+                        "$lookup": {
+                            "from": collection_name,
+                            "localField": f"{first_field}.$id",
+                            "foreignField": "_id",
+                            "as": f"{first_field}_data"
+                        }
+                    },
+                    {
+                        "$unwind": {
+                            "path": f"${first_field}_data",
+                            "preserveNullAndEmptyArrays": True
+                        }
+                    }
+                ])
+                remaining_path = ".".join(parts[1:]) if len(parts) > 1 else ""
+                sort_field = f"{first_field}_data.{remaining_path}" if remaining_path else f"{first_field}_data"
+            else:
+                sort_field = field_path
+        else:
+            sort_field = field_path
+            
+        pipeline.append({"$sort": {sort_field: direction}})
+        
+        # 3. Facet for Single Query Pagination
+        project_exclusion = {f"{first_field}_data": 0} if (is_nested and collection_name) else None
+        
+        facet_stage = {
+            "$facet": {
+                "metadata": [{"$count": "total"}],
+                "data": [
+                    {"$skip": count * (page - 1)},
+                    {"$limit": count}
+                ]
+            }
+        }
+        
+        # Add projection to remove join artifacts if needed
+        if project_exclusion:
+             facet_stage["$facet"]["data"].append({"$project": project_exclusion})
+             
+        pipeline.append(facet_stage)
+        
+        # Execute Pipeline
+        results = await self.model.aggregate(pipeline).to_list()
+        
+        # Process Results
+        if not results or not results[0].get("metadata"):
+            return [], 0
+            
+        data = results[0]
+        total = data["metadata"][0]["total"] if data["metadata"] else 0
+        items_raw = data["data"]
+        
+        # Efficient Validation
+        items = []
+        for raw_item in items_raw:
+            try:
+                items.append(self.model.model_validate(raw_item))
+            except Exception:
+                continue
+                
+        return items, total
+
+    async def get_by_id(
+        self,
+        obj_id: Union[str, ObjectId],
+        **kwargs,
+    ) -> Optional[Document]:
+        if not isinstance(obj_id, ObjectId):
+            obj_id = ObjectId(obj_id)
+        return await self.model.find_one(
+            self.model.id == obj_id,
+            **self._get_query_kwargs(**kwargs),
+        )
+
+    async def get_by_field(
+        self,
+        field_name: str,
+        value: Any,
+        **kwargs,
+    ) -> Optional[Document]:
+        if not hasattr(self.model, field_name):
+            raise AttributeError(
+                f"{self.model.__name__} no tiene el campo '{field_name}'"
+            )
+        return await self.model.find_one(
+            getattr(self.model, field_name) == value,
+            **self._get_query_kwargs(**kwargs),
+        )
+
+    async def get_by_fields(
+        self,
+        filters: Dict[str, Any],
+        **kwargs,
+    ) -> Optional[Document]:
+        exprs = [
+            getattr(self.model, f) == v
+            for f, v in filters.items()
+            if hasattr(self.model, f)
+        ]
+        if not exprs:
+            return None
+        return await self.model.find_one(
+            *exprs, **self._get_query_kwargs(**kwargs)
+        )
+
+    async def list_all(
+        self,
+        **kwargs,
+    ) -> List[Document]:
+        query = self.model.find_all(**self._get_query_kwargs(**kwargs))
+        return await query.to_list()
+
+    async def create(self, obj: Union[Document, Dict[str, Any]]) -> Document:
+        if isinstance(obj, dict):
+            obj = self.model(**obj)
+        await obj.insert()
+        return obj
+
+    async def update(self, obj: Document, data: Dict[str, Any]) -> Document:
+        for key, value in data.items():
+            setattr(obj, key, value)
+        await obj.save()
+        return obj
+
+    async def delete(self, obj: Document) -> None:
+        await obj.delete()

{fastapi_basekit-0.1.23 → fastapi_basekit-0.1.25}/fastapi_basekit/aio/beanie/service/base.py

@@ -19,6 +19,7 @@ class BaseService:
     duplicate_check_fields: List[str] = []
     kwargs_query: Dict[str, Union[str, int]] = {}
     action: str = ""
+    order_by: Optional[List[tuple]] = None
 
     def __init__(
         self, repository: BaseRepository, request: Optional[Request] = None
@@ -45,6 +46,15 @@ class BaseService:
     def get_kwargs_query(self) -> Dict[str, Any]:
         return self.kwargs_query
 
+    def get_order(self) -> Optional[List[tuple]]:
+        """Override this method to define custom ordering.
+        
+        Returns:
+            List of tuples with (field_name, direction) where direction is 1 for ascending or -1 for descending.
+            Example: [("created_at", -1)] for newest first
+        """
+        return self.order_by
+
     def get_filters(
         self,
         filters: Optional[Dict[str, Any]] = None,
@@ -65,16 +75,55 @@ class BaseService:
         page: int = 1,
         count: int = 25,
         filters: Optional[Dict[str, Any]] = None,
+        order_by: Optional[str] = None,  # NEW: Dynamic ordering (e.g., "-created_at" or "tool__name")
     ):
         kwargs = self.get_kwargs_query()
         applied_filters = self.get_filters(filters)
-        query = self.repository.build_filter_query(
-            search=search,
-            search_fields=self.search_fields,
-            filters=applied_filters,
-            **kwargs,
-        )
-        return await self.repository.paginate(query, page, count)
+        
+        # Determine which ordering to use
+        if order_by:
+            # Dynamic ordering from parameter (takes precedence)
+            order_str = order_by
+        else:
+            # Fall back to service-level ordering
+            default_order = self.get_order()
+            if default_order:
+                # Convert list of tuples to string format
+                # e.g., [("created_at", -1)] -> "-created_at"
+                field, direction = default_order[0]
+                order_str = f"{'-' if direction == -1 else ''}{field}"
+            else:
+                order_str = None
+        
+        # Check if we need aggregation (nested field with __ or .)
+        if order_str and ("__" in order_str or "." in order_str):
+            # Use aggregation pipeline for nested ordering
+            return await self.repository.list_with_aggregation(
+                search=search,
+                search_fields=self.search_fields,
+                filters=applied_filters,
+                order_by=order_str,
+                page=page,
+                count=count,
+                **kwargs,
+            )
+        else:
+            # Use standard query for simple ordering
+            order_list = None
+            if order_str:
+                # Parse the order string
+                direction = -1 if order_str.startswith("-") else 1
+                field = order_str.lstrip("-")
+                order_list = [(field, direction)]
+            
+            query = self.repository.build_filter_query(
+                search=search,
+                search_fields=self.search_fields,
+                filters=applied_filters,
+                order_by=order_list,
+                **kwargs,
+            )
+            return await self.repository.paginate(query, page, count, order_by=order_list)
 
     async def create(
         self, payload: BaseModel, check_fields: Optional[List[str]] = None

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

@@ -21,6 +21,7 @@ class BaseController:
         "page",
         "count",
         "search",
+        "order_by",
         "__class__",
         "args",
         "kwargs",
@@ -142,12 +143,13 @@ class BaseController:
         query_params = self.request.query_params if self.request else {}
 
         # Parámetros especiales de paginación y búsqueda
-        standard_params = {"page", "count", "search"}
+        standard_params = {"page", "count", "search", "order_by"}
 
         # Valores por defecto
         page = 1
         count = 10
         search = None
+        order_by = None
         filters = {}
 
         # Intentar obtener valores validados del frame local
@@ -191,6 +193,8 @@ class BaseController:
                 )
             elif param_name == "search":
                 search = final_value
+            elif param_name == "order_by":
+                order_by = final_value
             elif param_name not in standard_params:
                 # Es un filtro
                 filters[param_name] = final_value
@@ -199,6 +203,7 @@ class BaseController:
             "page": page,
             "count": count,
             "search": search,
+            "order_by": order_by,
             "filters": filters,
         }
 

{fastapi_basekit-0.1.23 → 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.23 → 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.23 → 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.23 → 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.23
+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.23 → fastapi_basekit-0.1.25}/pyproject.toml

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

fastapi_basekit-0.1.23/fastapi_basekit/aio/beanie/repository/base.py

@@ -1,168 +0,0 @@
-from typing import Any, Dict, List, Optional, Type, Union
-from typing import get_args, get_origin
-
-from bson import ObjectId, Link
-from pydantic import BaseModel
-from beanie import Document
-from beanie.odm.queries.find import FindMany
-from beanie.operators import Or, RegEx
-
-
-class BaseRepository:
-    model: Type[Document]
-
-    def _get_query_kwargs(
-        self,
-        fetch_links: bool = False,
-        nesting_depths_per_field: Optional[Dict[str, int]] = None,
-        projection: Optional[Union[List[str], Type[BaseModel]]] = None,
-    ):
-        kwargs = {
-            "fetch_links": fetch_links,
-            "nesting_depths_per_field": (
-                nesting_depths_per_field if fetch_links else None
-            ),
-        }
-        if projection is not None:
-            kwargs["projection"] = projection
-        return kwargs
-
-    def build_filter_query(
-        self,
-        search: Optional[str],
-        search_fields: List[str],
-        filters: dict = None,
-        **kwargs,
-    ) -> FindMany[Document]:
-        """Versión personalizada que soporta campos Link."""
-        exprs = []
-
-        if search and search_fields:
-            exprs.append(
-                Or(
-                    *[
-                        RegEx(
-                            getattr(self.model, f),
-                            f".*{search}.*",
-                            options="i",
-                        )
-                        for f in search_fields
-                    ]
-                )
-            )
-
-        # Obtener campos del modelo
-        model_fields = (
-            self.model.model_fields
-            if hasattr(self.model, "model_fields")
-            else {}
-        )
-
-        def _is_link_field(field_name: str) -> bool:
-            """Verifica si un campo es de tipo Link."""
-            field_info = model_fields.get(field_name)
-            if not field_info:
-                return False
-
-            field_type = field_info.annotation
-            origin = get_origin(field_type)
-
-            # Caso directo: Link[Model]
-            if origin is Link:
-                return True
-
-            # Caso Optional[Link[Model]] = Union[Link[Model], None]
-            # O cualquier Union que contenga Link
-            if origin is not None:
-                args = get_args(field_type)
-                for arg in args:
-                    # Verificar si el argumento es Link
-                    arg_origin = get_origin(arg)
-                    if arg_origin is Link:
-                        return True
-
-            return False
-
-        for k, v in (filters or {}).items():
-            if hasattr(self.model, k):
-                field_attr = getattr(self.model, k)
-
-                if _is_link_field(k):
-                    exprs.append(field_attr.id == v)
-                else:
-                    exprs.append(field_attr == v)
-
-        query = self.model.find(*exprs, **self._get_query_kwargs(**kwargs))
-        return query
-
-    async def paginate(
-        self, query: FindMany[Document], page: int, count: int
-    ) -> tuple[List[Document], int]:
-        total = await query.count()
-        items = await query.skip(count * (page - 1)).limit(count).to_list()
-        return items, total
-
-    async def get_by_id(
-        self,
-        obj_id: Union[str, ObjectId],
-        **kwargs,
-    ) -> Optional[Document]:
-        if not isinstance(obj_id, ObjectId):
-            obj_id = ObjectId(obj_id)
-        return await self.model.find_one(
-            self.model.id == obj_id,
-            **self._get_query_kwargs(**kwargs),
-        )
-
-    async def get_by_field(
-        self,
-        field_name: str,
-        value: Any,
-        **kwargs,
-    ) -> Optional[Document]:
-        if not hasattr(self.model, field_name):
-            raise AttributeError(
-                f"{self.model.__name__} no tiene el campo '{field_name}'"
-            )
-        return await self.model.find_one(
-            getattr(self.model, field_name) == value,
-            **self._get_query_kwargs(**kwargs),
-        )
-
-    async def get_by_fields(
-        self,
-        filters: Dict[str, Any],
-        **kwargs,
-    ) -> Optional[Document]:
-        exprs = [
-            getattr(self.model, f) == v
-            for f, v in filters.items()
-            if hasattr(self.model, f)
-        ]
-        if not exprs:
-            return None
-        return await self.model.find_one(
-            *exprs, **self._get_query_kwargs(**kwargs)
-        )
-
-    async def list_all(
-        self,
-        **kwargs,
-    ) -> List[Document]:
-        query = self.model.find_all(**self._get_query_kwargs(**kwargs))
-        return await query.to_list()
-
-    async def create(self, obj: Union[Document, Dict[str, Any]]) -> Document:
-        if isinstance(obj, dict):
-            obj = self.model(**obj)
-        await obj.insert()
-        return obj
-
-    async def update(self, obj: Document, data: Dict[str, Any]) -> Document:
-        for key, value in data.items():
-            setattr(obj, key, value)
-        await obj.save()
-        return obj
-
-    async def delete(self, obj: Document) -> None:
-        await obj.delete()