fastapi-mongo-base 0.8.30__py3-none-any.whl

fastapi_mongo_base/models.py

@@ -0,0 +1,384 @@
+import uuid
+from datetime import date, datetime
+from decimal import Decimal
+
+from beanie import Document, Insert, Replace, Save, SaveChanges, Update, before_event
+from beanie.odm.queries.find import FindMany
+from pydantic import ConfigDict
+from pymongo import ASCENDING, IndexModel
+
+try:
+    from server.config import Settings
+except ImportError:
+    from .core.config import Settings
+
+from .schemas import (
+    BaseEntitySchema,
+    BusinessEntitySchema,
+    BusinessOwnedEntitySchema,
+    OwnedEntitySchema,
+)
+from .tasks import TaskMixin
+
+
+class BaseEntity(BaseEntitySchema, Document):
+    class Settings:
+        __abstract__ = True
+
+        keep_nulls = False
+        validate_on_save = True
+
+        indexes = [
+            IndexModel([("uid", ASCENDING)], unique=True),
+        ]
+
+        @classmethod
+        def is_abstract(cls):
+            # Use `__dict__` to check if `__abstract__` is defined in the class itself
+            return "__abstract__" in cls.__dict__ and cls.__dict__["__abstract__"]
+
+    @before_event([Insert, Replace, Save, SaveChanges, Update])
+    async def pre_save(self):
+        self.updated_at = datetime.now()
+
+    @classmethod
+    def get_queryset(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        uid: uuid.UUID = None,
+        *args,
+        **kwargs,
+    ) -> list[dict]:
+        """Build a MongoDB query filter based on provided parameters.
+
+        Args:
+            user_id: Filter by user ID if the model has user_id field
+            business_name: Filter by business name if the model has business_name field
+            is_deleted: Filter by deletion status
+            uid: Filter by unique identifier
+            **kwargs: Additional filters that can include range queries with _from/_to suffixes
+
+        Returns:
+            List of MongoDB query conditions
+        """
+        # Start with basic filters
+        base_query = []
+
+        # Add standard filters if applicable
+        base_query.append({"is_deleted": is_deleted})
+
+        if hasattr(cls, "user_id") and user_id:
+            base_query.append({"user_id": user_id})
+
+        if hasattr(cls, "business_name"):
+            base_query.append({"business_name": business_name})
+
+        if uid:
+            base_query.append({"uid": uid})
+
+        # Process additional filters from kwargs
+        for key, value in kwargs.items():
+            if value is None:
+                continue
+
+            # Extract base field name without _from/_to suffix
+            base_field = cls._get_base_field_name(key)
+
+            # Validate field is allowed for searching
+            if cls.search_field_set() and base_field not in cls.search_field_set():
+                continue
+            if cls.search_exclude_set() and base_field in cls.search_exclude_set():
+                continue
+            if not hasattr(cls, base_field):
+                continue
+
+            # Handle range queries and normal filters
+            if (
+                key.endswith("_from") or key.endswith("_to")
+            ) and cls._is_valid_range_value(value):
+                if key.endswith("_from"):
+                    base_query.append({base_field: {"$gte": value}})
+                elif key.endswith("_to"):
+                    base_query.append({base_field: {"$lte": value}})
+            else:
+                base_query.append({key: value})
+
+        return base_query
+
+    @classmethod
+    def _get_base_field_name(cls, field: str) -> str:
+        """Extract the base field name by removing _from/_to suffixes."""
+        if field.endswith("_from"):
+            return field[:-5]
+        elif field.endswith("_to"):
+            return field[:-3]
+        return field
+
+    @classmethod
+    def _is_valid_range_value(cls, value) -> bool:
+        """Check if value is valid for range comparison."""
+        return isinstance(value, (int, float, Decimal, datetime, date, str))
+
+    @classmethod
+    def get_query(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        uid: uuid.UUID = None,
+        created_at_from: datetime = None,
+        created_at_to: datetime = None,
+        *args,
+        **kwargs,
+    ) -> FindMany:
+        base_query = cls.get_queryset(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            uid=uid,
+            created_at_from=created_at_from,
+            created_at_to=created_at_to,
+            *args,
+            **kwargs,
+        )
+        query = cls.find(*base_query)
+        return query
+
+    @classmethod
+    async def get_item(
+        cls,
+        uid: uuid.UUID,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ) -> "BaseEntity":
+        query = cls.get_query(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            uid=uid,
+            *args,
+            **kwargs,
+        )
+        items = await query.to_list()
+        if not items:
+            return None
+        if len(items) > 1:
+            raise ValueError("Multiple items found")
+        return items[0]
+
+    @classmethod
+    def adjust_pagination(cls, offset: int, limit: int):
+        from fastapi import params
+
+        if isinstance(offset, params.Query):
+            offset = offset.default
+        if isinstance(limit, params.Query):
+            limit = limit.default
+
+        offset = max(offset or 0, 0)
+        limit = max(1, min(limit or 10, Settings.page_max_limit))
+        return offset, limit
+
+    @classmethod
+    async def list_items(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        offset: int = 0,
+        limit: int = 10,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ):
+        offset, limit = cls.adjust_pagination(offset, limit)
+
+        query = cls.get_query(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            *args,
+            **kwargs,
+        )
+
+        items_query = query.sort("-created_at").skip(offset).limit(limit)
+        items = await items_query.to_list()
+        return items
+
+    @classmethod
+    async def total_count(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ):
+        query = cls.get_query(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            *args,
+            **kwargs,
+        )
+        return await query.count()
+
+    @classmethod
+    async def list_total_combined(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        offset: int = 0,
+        limit: int = 10,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ) -> tuple[list["BaseEntity"], int]:
+        items = await cls.list_items(
+            user_id=user_id,
+            business_name=business_name,
+            offset=offset,
+            limit=limit,
+            is_deleted=is_deleted,
+            **kwargs,
+        )
+        total = await cls.total_count(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            **kwargs,
+        )
+
+        return items, total
+
+    @classmethod
+    async def create_item(cls, data: dict):
+        # for key in data.keys():
+        #     if cls.create_exclude_set() and key not in cls.create_field_set():
+        #         data.pop(key, None)
+        #     elif cls.create_exclude_set() and key in cls.create_exclude_set():
+        #         data.pop(key, None)
+
+        item = cls(**data)
+        await item.save()
+        return item
+
+    @classmethod
+    async def update_item(cls, item: "BaseEntity", data: dict):
+        for key, value in data.items():
+            if cls.update_field_set() and key not in cls.update_field_set():
+                continue
+            if cls.update_exclude_set() and key in cls.update_exclude_set():
+                continue
+
+            if hasattr(item, key):
+                setattr(item, key, value)
+
+        await item.save()
+        return item
+
+    @classmethod
+    async def delete_item(cls, item: "BaseEntity"):
+        item.is_deleted = True
+        await item.save()
+        return item
+
+
+class OwnedEntity(OwnedEntitySchema, BaseEntity):
+
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+        indexes = BaseEntity.Settings.indexes + [IndexModel([("user_id", ASCENDING)])]
+
+    @classmethod
+    async def get_item(cls, uid, user_id, *args, **kwargs) -> "OwnedEntity":
+        if user_id == None and kwargs.get("ignore_user_id") != True:
+            raise ValueError("user_id is required")
+        return await super().get_item(uid, user_id=user_id, *args, **kwargs)
+
+
+class BusinessEntity(BusinessEntitySchema, BaseEntity):
+
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+        indexes = BaseEntity.Settings.indexes + [
+            IndexModel([("business_name", ASCENDING)])
+        ]
+
+    @classmethod
+    async def get_item(cls, uid, business_name, *args, **kwargs) -> "BusinessEntity":
+        if business_name == None:
+            raise ValueError("business_name is required")
+        return await super().get_item(uid, business_name=business_name, *args, **kwargs)
+
+    async def get_business(self):
+        raise NotImplementedError
+        from apps.business_mongo.models import Business
+
+        return await Business.get_by_name(self.business_name)
+
+
+class BusinessOwnedEntity(BusinessOwnedEntitySchema, BaseEntity):
+
+    class Settings(BusinessEntity.Settings):
+        __abstract__ = True
+
+        indexes = BusinessEntity.Settings.indexes + [
+            IndexModel([("user_id", ASCENDING)])
+        ]
+
+    @classmethod
+    async def get_item(
+        cls, uid, business_name, user_id, *args, **kwargs
+    ) -> "BusinessOwnedEntity":
+        if business_name == None:
+            raise ValueError("business_name is required")
+        # if user_id == None:
+        #     raise ValueError("user_id is required")
+        return await super().get_item(
+            uid, business_name=business_name, user_id=user_id, *args, **kwargs
+        )
+
+
+class BaseEntityTaskMixin(BaseEntity, TaskMixin):
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+
+class ImmutableBase(BaseEntity):
+    model_config = ConfigDict(frozen=True)
+
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+    @classmethod
+    async def update_item(cls, item: "BaseEntity", data: dict):
+        raise ValueError("Immutable items cannot be updated")
+
+    @classmethod
+    async def delete_item(cls, item: "BaseEntity"):
+        raise ValueError("Immutable items cannot be deleted")
+
+
+class ImmutableOwnedEntity(ImmutableBase, OwnedEntity):
+
+    class Settings(OwnedEntity.Settings):
+        __abstract__ = True
+
+
+class ImmutableBusinessEntity(ImmutableBase, BusinessEntity):
+
+    class Settings(BusinessEntity.Settings):
+        __abstract__ = True
+
+
+class ImmutableBusinessOwnedEntity(ImmutableBase, BusinessOwnedEntity):
+
+    class Settings(BusinessOwnedEntity.Settings):
+        __abstract__ = True

fastapi_mongo_base/routes.py

@@ -0,0 +1,293 @@
+import asyncio
+import uuid
+from datetime import datetime
+from typing import Any, Generic, Type, TypeVar
+
+import singleton
+from fastapi import APIRouter, BackgroundTasks, Query, Request
+
+try:
+    from core.exceptions import BaseHTTPException
+except ImportError:
+    from .core.exceptions import BaseHTTPException
+
+try:
+    from server.config import Settings
+except ImportError:
+    from .core.config import Settings
+
+from .handlers import create_dto
+from .models import BaseEntity, BaseEntityTaskMixin
+from .schemas import BaseEntitySchema, PaginatedResponse
+
+# Define a type variable
+T = TypeVar("T", bound=BaseEntity)
+TE = TypeVar("TE", bound=BaseEntityTaskMixin)
+TS = TypeVar("TS", bound=BaseEntitySchema)
+
+
+class AbstractBaseRouter(Generic[T, TS], metaclass=singleton.Singleton):
+
+    def __init__(
+        self,
+        model: Type[T],
+        user_dependency: Any,
+        *args,
+        prefix: str = None,
+        tags: list[str] = None,
+        schema: Type[TS] = None,
+        **kwargs,
+    ):
+        self.model = model
+        if schema is None:
+            schema = self.model
+        self.schema = schema
+        self.user_dependency = user_dependency
+        if prefix is None:
+            prefix = f"/{self.model.__name__.lower()}s"
+        if tags is None:
+            tags = [self.model.__name__]
+        self.router = APIRouter(prefix=prefix, tags=tags, **kwargs)
+
+        self.config_schemas(self.schema, **kwargs)
+        self.config_routes(**kwargs)
+
+    def config_schemas(self, schema, **kwargs):
+        self.schema = schema
+        self.list_response_schema = PaginatedResponse[schema]
+        self.list_item_schema = schema
+        self.retrieve_response_schema = schema
+        self.create_response_schema = schema
+        self.update_response_schema = schema
+        self.delete_response_schema = schema
+
+        self.create_request_schema = schema
+        self.update_request_schema = schema
+
+    def config_routes(self, **kwargs):
+        prefix: str = kwargs.get("prefix", "")
+        prefix = prefix.strip("/")
+        prefix = f"/{prefix}" if prefix else ""
+
+        if kwargs.get("list_route", True):
+            self.router.add_api_route(
+                f"{prefix}/",
+                self.list_items,
+                methods=["GET"],
+                response_model=self.list_response_schema,
+                status_code=200,
+            )
+
+        if kwargs.get("retrieve_route", True):
+            self.router.add_api_route(
+                f"{prefix}/{{uid:uuid}}",
+                self.retrieve_item,
+                methods=["GET"],
+                response_model=self.retrieve_response_schema,
+                status_code=200,
+            )
+
+        if kwargs.get("create_route", True):
+            self.router.add_api_route(
+                f"{prefix}/",
+                self.create_item,
+                methods=["POST"],
+                response_model=self.create_response_schema,
+                status_code=201,
+            )
+
+        if kwargs.get("update_route", True):
+            self.router.add_api_route(
+                f"{prefix}/{{uid:uuid}}",
+                self.update_item,
+                methods=["PATCH"],
+                response_model=self.update_response_schema,
+                status_code=200,
+            )
+
+        if kwargs.get("delete_route", True):
+            self.router.add_api_route(
+                f"{prefix}/{{uid:uuid}}",
+                self.delete_item,
+                methods=["DELETE"],
+                response_model=self.delete_response_schema,
+                # status_code=204,
+            )
+
+    async def get_item(
+        self,
+        uid: uuid.UUID,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        **kwargs,
+    ):
+        item = await self.model.get_item(
+            uid, user_id=user_id, business_name=business_name, **kwargs
+        )
+        if item is None:
+            raise BaseHTTPException(
+                status_code=404,
+                error="item_not_found",
+                message=f"{self.model.__name__.capitalize()} not found",
+            )
+        return item
+
+    async def get_user(self, request: Request, *args, **kwargs):
+        if self.user_dependency is None:
+            return None
+        if asyncio.iscoroutinefunction(self.user_dependency):
+            return await self.user_dependency(request)
+        return self.user_dependency(request)
+
+    async def get_user_id(self, request: Request, *args, **kwargs):
+        user = await self.get_user(request)
+        user_id = user.uid if user else None
+        return user_id
+
+    async def list_items(
+        self,
+        request: Request,
+        offset: int = Query(0, ge=0),
+        limit: int = Query(10, ge=1, le=Settings.page_max_limit),
+        created_at_from: datetime | None = None,
+        created_at_to: datetime | None = None,
+    ):
+        user_id = await self.get_user_id(request)
+        limit = max(1, min(limit, Settings.page_max_limit))
+
+        items, total = await self.model.list_total_combined(
+            user_id=user_id,
+            offset=offset,
+            limit=limit,
+            created_at_from=created_at_from,
+            created_at_to=created_at_to,
+        )
+        items_in_schema = [self.list_item_schema(**item.model_dump()) for item in items]
+
+        return PaginatedResponse(
+            items=items_in_schema,
+            total=total,
+            offset=offset,
+            limit=limit,
+        )
+
+    async def retrieve_item(
+        self,
+        request: Request,
+        uid: uuid.UUID,
+    ):
+        user_id = await self.get_user_id(request)
+        item = await self.get_item(uid, user_id=user_id)
+        return item
+
+    async def create_item(
+        self,
+        request: Request,
+        data: dict,
+    ):
+        user_id = await self.get_user_id(request)
+        item_data: TS = await create_dto(self.create_response_schema)(
+            request, user_id=user_id
+        )
+        item = await self.model.create_item(item_data.model_dump())
+        # item: T = await create_dto(self.create_request_schema)(request, user)
+        await item.save()
+        return item
+
+    async def update_item(
+        self,
+        request: Request,
+        uid: uuid.UUID,
+        data: dict,
+    ):
+        user_id = await self.get_user_id(request)
+        item = await self.get_item(uid, user_id=user_id)
+        # item = await update_dto(self.model)(request, user)
+        item = await self.model.update_item(item, data)
+        return item
+
+    async def delete_item(
+        self,
+        request: Request,
+        uid: uuid.UUID,
+    ):
+        user_id = await self.get_user_id(request)
+        item = await self.get_item(uid, user_id=user_id)
+
+        item = await self.model.delete_item(item)
+        return item
+
+
+class AbstractTaskRouter(AbstractBaseRouter[TE, TS]):
+    def __init__(
+        self,
+        model: Type[TE],
+        user_dependency: Any,
+        schema: TS,
+        draftable: bool = True,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(model, user_dependency, schema=schema, *args, **kwargs)
+        self.draftable = draftable
+
+    def config_routes(self, **kwargs):
+        super().config_routes(**kwargs)
+
+        self.router.add_api_route(
+            "/{uid:uuid}/start",
+            self.start_item,
+            methods=["POST"],
+            response_model=self.retrieve_response_schema,
+        )
+
+    async def create_item(
+        self, request: Request, data: dict, background_tasks: BackgroundTasks
+    ):
+        if not self.draftable:
+            data["task_status"] = "init"
+
+        item: TE = await super().create_item(request, data)
+
+        if item.task_status == "init" or not self.draftable:
+            background_tasks.add_task(item.start_processing)
+        return item
+
+    async def start_item(
+        self, request: Request, uid: uuid.UUID, background_tasks: BackgroundTasks
+    ):
+        user_id = await self.get_user_id(request)
+        item: TE = await self.get_item(uid, user_id=user_id)
+        background_tasks.add_task(item.start_processing)
+        return item.model_dump()
+
+
+def copy_router(router: APIRouter, new_prefix: str):
+    new_router = APIRouter(prefix=new_prefix)
+    for route in router.routes:
+        new_router.add_api_route(
+            route.path.replace(router.prefix, ""),
+            route.endpoint,
+            methods=[
+                method
+                for method in route.methods
+                if method in ["GET", "POST", "PUT", "DELETE", "PATCH"]
+            ],
+            name=route.name,
+            response_class=route.response_class,
+            status_code=route.status_code,
+            tags=route.tags,
+            dependencies=route.dependencies,
+            summary=route.summary,
+            description=route.description,
+            response_description=route.response_description,
+            responses=route.responses,
+            deprecated=route.deprecated,
+            include_in_schema=route.include_in_schema,
+            response_model=route.response_model,
+            response_model_include=route.response_model_include,
+            response_model_exclude=route.response_model_exclude,
+            response_model_by_alias=route.response_model_by_alias,
+        )
+
+    return new_router