zrb 1.0.0a21__py3-none-any.whl → 1.0.0b5__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_db_repository.py

@@ -1,12 +1,22 @@
+import datetime
+from contextlib import asynccontextmanager
 from typing import Any, Callable, Generic, Type, TypeVar
 
-from my_app_name.common.error import NotFoundError
-from sqlalchemy import Engine
+import ulid
+from my_app_name.common.error import InvalidValueError, NotFoundError
+from my_app_name.common.parser_factory import (
+    parse_filter_param as default_parse_filter_param,
+)
+from my_app_name.common.parser_factory import (
+    parse_sort_param as default_parse_sort_param,
+)
+from sqlalchemy import Engine, delete, func, insert, select, update
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
-from sqlmodel import Session, SQLModel, select
+from sqlalchemy.sql import ClauseElement, ColumnElement, Select
+from sqlmodel import Session, SQLModel
 
 DBModel = TypeVar("DBModel", bound=SQLModel)
-ResponseModel = TypeVar("Model", bound=SQLModel)
+ResponseModel = TypeVar("ResponseModel", bound=SQLModel)
 CreateModel = TypeVar("CreateModel", bound=SQLModel)
 UpdateModel = TypeVar("UpdateModel", bound=SQLModel)
 
@@ -19,116 +29,234 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
     entity_name: str = "entity"
     column_preprocessors: dict[str, Callable[[Any], Any]] = {}
 
-    def __init__(self, engine: Engine | AsyncEngine):
+    def __init__(
+        self,
+        engine: Engine | AsyncEngine,
+        filter_param_parser: (
+            Callable[[SQLModel, str], list[ClauseElement]] | None
+        ) = None,
+        sort_param_parser: Callable[[SQLModel, str], list[ColumnElement]] | None = None,
+    ):
         self.engine = engine
-        self.is_async = isinstance(engine, AsyncEngine)
+        self._is_async = isinstance(engine, AsyncEngine)
+        self._parse_filter_param = (
+            filter_param_parser if filter_param_parser else default_parse_filter_param
+        )
+        self._parse_sort_param = (
+            sort_param_parser if sort_param_parser else default_parse_sort_param
+        )
 
-    def _to_response(self, db_instance: DBModel) -> ResponseModel:
-        return self.response_model(**db_instance.model_dump())
+    @property
+    def is_async(self) -> bool:
+        return self._is_async
 
-    async def create(self, data: CreateModel) -> ResponseModel:
+    def _select(self) -> Select:
+        """
+        This method is used to contruct select statement for get, get_by_id and get_by_ids.
+        To parse the result of the statement, make sure you override _rows_to_response as well.
+        """
+        return select(self.db_model)
+
+    def _rows_to_responses(self, rows: list[tuple[Any, ...]]) -> list[ResponseModel]:
+        """
+        This method is used to parse the result of select statement generated by _select.
+        """
+        return [self.response_model.model_validate(row[0]) for row in rows]
+
+    async def _select_to_response(
+        self, query_modifier: Callable[[Select], Any]
+    ) -> list[ResponseModel]:
+        statement = query_modifier(self._select())
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            return self._rows_to_responses(result.all())
+
+    def _ensure_one(self, responses: list[ResponseModel]) -> ResponseModel:
+        if not responses:
+            raise NotFoundError(f"{self.entity_name} not found")
+        if len(responses) > 1:
+            raise InvalidValueError(f"Duplicate {self.entity_name}")
+        return responses[0]
+
+    def _model_to_data_dict(
+        self, data: SQLModel, **additional_data: Any
+    ) -> dict[str, Any]:
+        """
+        This method transform SQLModel into dictionary for insert/update operation.
+        """
         data_dict = data.model_dump(exclude_unset=True)
+        data_dict.update(additional_data)
         for key, preprocessor in self.column_preprocessors.items():
-            if key in data_dict:
-                data_dict[key] = preprocessor(data_dict[key])
-        db_instance = self.db_model(**data_dict)
-        if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                session.add(db_instance)
-                await session.commit()
-                await session.refresh(db_instance)
-        else:
-            with Session(self.engine) as session:
-                session.add(db_instance)
-                session.commit()
-                session.refresh(db_instance)
-        return self._to_response(db_instance)
+            if key not in data_dict:
+                continue
+            if not hasattr(self.db_model, key):
+                raise InvalidValueError(f"Invalid {self.entity_name} property: {key}")
+            data_dict[key] = preprocessor(data_dict[key])
+        return data_dict
 
-    async def get_by_id(self, item_id: str) -> ResponseModel:
+    @asynccontextmanager
+    async def _session_scope(self):
         if self.is_async:
             async with AsyncSession(self.engine) as session:
-                db_instance = await session.get(self.db_model, item_id)
+                async with session.begin():
+                    yield session
         else:
             with Session(self.engine) as session:
-                db_instance = session.get(self.db_model, item_id)
-        if not db_instance:
-            raise NotFoundError(f"{self.entity_name} not found")
-        return self._to_response(db_instance)
+                with session.begin():
+                    yield session
 
-    async def get_all(self, page: int = 1, page_size: int = 10) -> list[ResponseModel]:
-        offset = (page - 1) * page_size
-        statement = select(self.db_model).offset(offset).limit(page_size)
+    async def _commit(self, session: Session | AsyncSession):
         if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                result = await session.execute(statement)
-                results = result.scalars().all()
+            await session.commit()
         else:
-            with Session(self.engine) as session:
-                results = session.exec(statement).all()
-        return [self._to_response(instance) for instance in results]
-
-    async def update(self, item_id: str, data: UpdateModel) -> ResponseModel:
-        update_data = data.model_dump(exclude_unset=True)
-        for key, value in update_data.items():
-            if key in self.column_preprocessors:
-                update_data[key] = self.column_preprocessors[key](value)
-        if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                db_instance = await session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                for key, value in update_data.items():
-                    setattr(db_instance, key, value)
-                session.add(db_instance)
-                await session.commit()
-                await session.refresh(db_instance)
-        else:
-            with Session(self.engine) as session:
-                db_instance = session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                for key, value in update_data.items():
-                    setattr(db_instance, key, value)
-                session.add(db_instance)
-                session.commit()
-                session.refresh(db_instance)
-        return self._to_response(db_instance)
-
-    async def delete(self, item_id: str) -> ResponseModel:
-        if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                db_instance = await session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                await session.delete(db_instance)
-                await session.commit()
-        else:
-            with Session(self.engine) as session:
-                db_instance = session.get(self.db_model, item_id)
-                if not db_instance:
-                    raise NotFoundError(f"{self.entity_name} not found")
-                session.delete(db_instance)
-                session.commit()
-        return self._to_response(db_instance)
-
-    async def create_bulk(self, data_list: list[CreateModel]) -> list[ResponseModel]:
-        db_instances = []
-        for data in data_list:
-            data_dict = data.model_dump(exclude_unset=True)
-            for key, preprocessor in self.column_preprocessors.items():
-                if key in data_dict:
-                    data_dict[key] = preprocessor(data_dict[key])
-            db_instances.append(self.db_model(**data_dict))
+            session.commit()
+
+    async def _execute_statement(self, session, statement: Any) -> Any:
         if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                session.add_all(db_instances)
-                await session.commit()
-                for instance in db_instances:
-                    await session.refresh(instance)
+            return await session.execute(statement)
         else:
-            with Session(self.engine) as session:
-                session.add_all(db_instances)
-                session.commit()
-                for instance in db_instances:
-                    session.refresh(instance)
-        return [self._to_response(instance) for instance in db_instances]
+            return session.execute(statement)
+
+    async def get_by_id(self, id: str) -> ResponseModel:
+        rows = await self._select_to_response(lambda q: q.where(self.db_model.id == id))
+        return self._ensure_one(rows)
+
+    async def get_by_ids(self, id_list: list[str]) -> list[ResponseModel]:
+        return await self._select_to_response(
+            lambda q: q.where(self.db_model.id.in_(id_list))
+        )
+
+    async def count(self, filter: str | None = None) -> int:
+        count_statement = select(func.count(1)).select_from(self.db_model)
+        if filter:
+            filter_param = self._parse_filter_param(self.db_model, filter)
+            count_statement = count_statement.where(*filter_param)
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, count_statement)
+            return result.scalar_one()
+
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[ResponseModel]:
+        return await self._select_to_response(
+            self._get_pagination_query_modifier(
+                page=page, page_size=page_size, filter=filter, sort=sort
+            )
+        )
+
+    def _get_pagination_query_modifier(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> Callable[[Select], Any]:
+        def pagination_query_modifier(statement: Select) -> Any:
+            offset = (page - 1) * page_size
+            statement = statement.offset(offset).limit(page_size)
+            if filter:
+                filter_param = self._parse_filter_param(self.db_model, filter)
+                statement = statement.where(*filter_param)
+            if sort:
+                sort_param = self._parse_sort_param(self.db_model, sort)
+                statement = statement.order_by(*sort_param)
+            return statement
+
+        return pagination_query_modifier
+
+    async def create(self, data: CreateModel) -> DBModel:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data_dict = self._model_to_data_dict(data, created_at=now, id=ulid.new().str)
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session, insert(self.db_model).values(**data_dict)
+            )
+            statement = select(self.db_model).where(self.db_model.id == data_dict["id"])
+            result = await self._execute_statement(session, statement)
+            created_entity = result.scalar_one_or_none()
+            if created_entity is None:
+                raise NotFoundError(f"{self.entity_name} not found after creation")
+            return self.db_model(**created_entity.model_dump())
+
+    async def create_bulk(self, data_list: list[CreateModel]) -> list[DBModel]:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data_dicts = [
+            self._model_to_data_dict(data, created_at=now, id=ulid.new().str)
+            for data in data_list
+        ]
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session, insert(self.db_model).values(data_dicts)
+            )
+            id_list = [d["id"] for d in data_dicts]
+            statement = select(self.db_model).where(self.db_model.id.in_(id_list))
+            result = await self._execute_statement(session, statement)
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]
+
+    async def delete(self, id: str) -> DBModel:
+        async with self._session_scope() as session:
+            statement = select(self.db_model).where(self.db_model.id == id)
+            result = await self._execute_statement(session, statement)
+            entity = result.scalar_one_or_none()
+            if not entity:
+                raise NotFoundError(f"{self.entity_name} not found")
+            await self._execute_statement(
+                session, delete(self.db_model).where(self.db_model.id == id)
+            )
+            return self.db_model(**entity.model_dump())
+
+    async def delete_bulk(self, id_list: list[str]) -> list[DBModel]:
+        async with self._session_scope() as session:
+            statement = select(self.db_model).where(self.db_model.id.in_(id_list))
+            result = await self._execute_statement(session, statement)
+            entities = result.scalars().all()
+            await self._execute_statement(
+                session, delete(self.db_model).where(self.db_model.id.in_(id_list))
+            )
+            return [self.db_model(**entity.model_dump()) for entity in entities]
+
+    async def update(self, id: str, data: UpdateModel) -> DBModel:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        update_data = self._model_to_data_dict(data, updated_at=now)
+        async with self._session_scope() as session:
+            statement = (
+                update(self.db_model)
+                .where(self.db_model.id == id)
+                .values(**update_data)
+            )
+            await self._execute_statement(session, statement)
+            result = await self._execute_statement(
+                session, select(self.db_model).where(self.db_model.id == id)
+            )
+            updated_instance = result.scalar_one_or_none()
+            if not updated_instance:
+                raise NotFoundError(f"{self.entity_name} not found")
+            return self.db_model(**updated_instance.model_dump())
+
+    async def update_bulk(self, id_list: list[str], data: UpdateModel) -> list[DBModel]:
+        now = datetime.datetime.now(datetime.timezone.utc)
+        update_data = self._model_to_data_dict(data, updated_at=now)
+        update_data = {k: v for k, v in update_data.items() if v is not None}
+        if not update_data:
+            raise InvalidValueError("No valid update data provided")
+        async with self._session_scope() as session:
+            statement = (
+                update(self.db_model)
+                .where(self.db_model.id.in_(id_list))
+                .values(**update_data)
+            )
+            await self._execute_statement(session, statement)
+            result = await self._execute_statement(
+                session, select(self.db_model).where(self.db_model.id.in_(id_list))
+            )
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_service.py

@@ -0,0 +1,236 @@
+import inspect
+from enum import Enum
+from functools import partial
+from logging import Logger
+from typing import Any, Callable, Sequence
+
+import httpx
+from fastapi import APIRouter, Depends, params
+from my_app_name.common.error import ClientAPIError
+from pydantic import BaseModel
+
+
+class RouteParam:
+    def __init__(
+        self,
+        path: str,
+        response_model: Any,
+        status_code: int | None = None,
+        tags: list[str | Enum] | None = None,
+        summary: str | None = None,
+        description: str = "",
+        deprecated: bool | None = None,
+        methods: set[str] | list[str] | None = None,
+        func: Callable | None = None,
+    ):
+        self.path = path
+        self.response_model = response_model
+        self.status_code = status_code
+        self.tags = tags
+        self.summary = summary
+        self.description = description
+        self.deprecated = deprecated
+        self.methods = methods
+        self.func = func
+
+
+class BaseService:
+    _route_params: dict[str, RouteParam] = {}
+
+    def __init__(self, logger: Logger):
+        self._logger = logger
+        self._route_params: dict[str, RouteParam] = {}
+        for name, method in self.__class__.__dict__.items():
+            if hasattr(method, "__route_param__"):
+                self._route_params[name] = getattr(method, "__route_param__")
+
+    @property
+    def logger(self) -> Logger:
+        return self._logger
+
+    @classmethod
+    def route(
+        cls,
+        path: str,
+        *,
+        response_model: Any = None,
+        status_code: int | None = None,
+        tags: list[str | Enum] | None = None,
+        dependencies: Sequence[params.Depends] | None = None,
+        summary: str | None = None,
+        description: str = None,
+        deprecated: bool | None = None,
+        methods: set[str] | list[str] | None = None,
+    ):
+        """
+        Decorator to register a method with its HTTP details.
+        """
+
+        def decorator(func: Callable):
+            # Check for Depends in function parameters
+            sig = inspect.signature(func)
+            for param in sig.parameters.values():
+                if param.annotation is Depends or (
+                    hasattr(param.annotation, "__origin__")
+                    and param.annotation.__origin__ is Depends
+                ):
+                    raise ValueError(
+                        f"Depends is not allowed in function parameters. Found in {func.__name__}"  # noqa
+                    )
+            # Inject __route_param__ property to the method
+            # Method with __route_param__ property will automatically
+            # registered to self._route_param and will be automatically exposed
+            # into DirectClient and APIClient
+            func.__route_param__ = RouteParam(
+                path=path,
+                response_model=response_model,
+                status_code=status_code,
+                tags=tags,
+                summary=summary,
+                description=description,
+                deprecated=deprecated,
+                methods=methods,
+                func=func,
+            )
+            return func
+
+        return decorator
+
+    def as_direct_client(self):
+        """
+        Dynamically create a direct client class.
+        """
+        _methods = self._route_params
+        DirectClient = _create_client_class("DirectClient")
+        for name, details in _methods.items():
+            func = details.func
+            client_method = _create_direct_client_method(self._logger, func, self)
+            # Use __get__ to make a bounded method,
+            # ensuring that client_method use DirectClient as `self`
+            setattr(DirectClient, name, client_method.__get__(DirectClient))
+        return DirectClient
+
+    def as_api_client(self, base_url: str):
+        """
+        Dynamically create an API client class.
+        """
+        _methods = self._route_params
+        APIClient = _create_client_class("APIClient")
+        # Dynamically generate methods
+        for name, param in _methods.items():
+            client_method = _create_api_client_method(self._logger, param, base_url)
+            # Use __get__ to make a bounded method,
+            # ensuring that client_method use APIClient as `self`
+            setattr(APIClient, name, client_method.__get__(APIClient))
+        return APIClient
+
+    def serve_route(self, app: APIRouter):
+        """
+        Dynamically add routes to FastAPI.
+        """
+        for _, route_param in self._route_params.items():
+            bound_func = partial(route_param.func, self)
+            bound_func.__name__ = route_param.func.__name__
+            bound_func.__doc__ = route_param.func.__doc__
+            app.add_api_route(
+                path=route_param.path,
+                endpoint=bound_func,
+                response_model=route_param.response_model,
+                status_code=route_param.status_code,
+                tags=route_param.tags,
+                summary=route_param.summary,
+                description=route_param.description,
+                deprecated=route_param.deprecated,
+                methods=route_param.methods,
+            )
+
+
+def _create_client_class(name):
+    class Client:
+        pass
+
+    Client.__name__ = name
+    return Client
+
+
+def _create_direct_client_method(logger: Logger, func: Callable, service: BaseService):
+    async def client_method(self, *args, **kwargs):
+        return await func(service, *args, **kwargs)
+
+    return client_method
+
+
+def _create_api_client_method(logger: Logger, param: RouteParam, base_url: str):
+    async def client_method(*args, **kwargs):
+        url = base_url + param.path
+        method = (
+            param.methods[0].lower()
+            if isinstance(param.methods, list)
+            else param.methods.lower()
+        )
+        # Get the signature of the original function
+        sig = inspect.signature(param.func)
+        # Bind the arguments to the signature
+        bound_args = sig.bind(*args, **kwargs)
+        bound_args.apply_defaults()
+        # Analyze parameters
+        params = list(sig.parameters.values())
+        body_params = [
+            p
+            for p in params
+            if p.name != "self" and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+        ]
+        # Prepare the request
+        path_params = {}
+        query_params = {}
+        body = {}
+        for name, value in bound_args.arguments.items():
+            if name == "self":
+                continue
+            if f"{{{name}}}" in param.path:
+                path_params[name] = value
+            elif isinstance(value, BaseModel):
+                body = _parse_api_param(value)
+            elif method in ["get", "delete"]:
+                query_params[name] = _parse_api_param(value)
+            elif len(body_params) == 1 and name == body_params[0].name:
+                # If there's only one body parameter, use its value directly
+                body = _parse_api_param(value)
+            else:
+                body[name] = _parse_api_param(value)
+        # Format the URL with path parameters
+        url = url.format(**path_params)
+        logger.info(
+            f"Sending request to {url} with method {method}, json={body}, params={query_params}"  # noqa
+        )
+        async with httpx.AsyncClient() as client:
+            if method in ["get", "delete"]:
+                response = await getattr(client, method)(url, params=query_params)
+            else:
+                response = await getattr(client, method)(
+                    url, json=body, params=query_params
+                )
+            logger.info(
+                f"Received response: status={response.status_code}, content={response.content}"
+            )
+            if response.status_code >= 400:
+                error_detail = (
+                    response.json()
+                    if response.headers.get("content-type") == "application/json"
+                    else response.text
+                )
+                raise ClientAPIError(response.status_code, error_detail)
+            return response.json()
+
+    return client_method
+
+
+def _parse_api_param(data: Any) -> Any:
+    if isinstance(data, BaseModel):
+        return data.model_dump()
+    elif isinstance(data, list):
+        return [_parse_api_param(item) for item in data]
+    elif isinstance(data, dict):
+        return {key: _parse_api_param(value) for key, value in data.items()}
+    else:
+        return data

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/{db_engine.py → db_engine_factory.py}

@@ -2,4 +2,4 @@ from my_app_name.config import APP_DB_URL
 from sqlmodel import create_engine
 
 connect_args = {"check_same_thread": False}
-engine = create_engine(APP_DB_URL, connect_args=connect_args)
+db_engine = create_engine(APP_DB_URL, connect_args=connect_args, echo=True)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/error.py

@@ -6,3 +6,15 @@ from fastapi import HTTPException
 class NotFoundError(HTTPException):
     def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
         super().__init__(404, {"message": message}, headers)
+
+
+class InvalidValueError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(422, {"message": message}, headers)
+
+
+class ClientAPIError(HTTPException):
+    def __init__(
+        self, status_code: int, message: str, headers: Dict[str, str] | None = None
+    ) -> None:
+        super().__init__(status_code, {"message": message}, headers)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/logger_factory.py

@@ -0,0 +1,10 @@
+import logging
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
+# Create a logger for your application
+logger: logging.Logger = logging.getLogger("fastapp")

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/parser_factory.py

@@ -0,0 +1,7 @@
+from my_app_name.common.util.parser import (
+    create_default_filter_param_parser,
+    create_default_sort_param_parser,
+)
+
+parse_filter_param = create_default_filter_param_parser()
+parse_sort_param = create_default_sort_param_parser()

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/util/app.py

@@ -0,0 +1,47 @@
+import os
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException
+from fastapi.openapi.docs import get_swagger_ui_html
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from sqlalchemy.engine import Engine
+from sqlmodel import SQLModel
+from starlette.types import Lifespan
+
+
+def get_default_app_title(app_title: str, mode: str, modules: list[str] = []) -> str:
+    if mode == "monolith":
+        return app_title
+    return f"{app_title} - {', '.join(modules)}"
+
+
+def create_default_app_lifespan(db_engine: Engine) -> Lifespan:
+    @asynccontextmanager
+    async def default_app_lifespan(app: FastAPI):
+        SQLModel.metadata.create_all(db_engine)
+        yield
+
+    return default_app_lifespan
+
+
+def serve_static_dir(app: FastAPI, static_dir: str):
+    app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+    # Serve static files
+    @app.get("/static/{file_path:path}", include_in_schema=False)
+    async def static_files(file_path: str):
+        full_path = os.path.join(static_dir, file_path)
+        if os.path.isfile(full_path):
+            return FileResponse(full_path)
+        raise HTTPException(status_code=404, detail="File not found")
+
+
+def serve_docs(app: FastAPI, app_title: str, favicon_url: str):
+    @app.get("/docs", include_in_schema=False)
+    async def swagger_ui_html():
+        return get_swagger_ui_html(
+            openapi_url="/openapi.json",
+            title=app_title,
+            swagger_favicon_url=favicon_url,
+        )