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

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,
+        )

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

@@ -0,0 +1,105 @@
+import re
+from typing import Callable
+
+from sqlalchemy import asc, desc
+from sqlalchemy.sql import ClauseElement, ColumnElement
+from sqlmodel import SQLModel
+
+
+def create_default_sort_param_parser() -> (
+    Callable[[SQLModel, str], list[ColumnElement]]
+):
+    def parse_sort_param(model: SQLModel, query: str) -> list[ColumnElement]:
+        """
+        Parse the sort parameter and return a list of SQLAlchemy ColumnElement objects.
+
+        Args:
+            model (Type[SQLModel]): The SQLModel class to be queried.
+            query (str): A comma-separated string of fields to sort by.
+                        Prefix a field with '-' for descending order.
+
+        Returns:
+            list[ColumnElement]: A list of SQLAlchemy ColumnElement objects representing the sort order.
+
+        Example:
+            parse_sort_param(UserModel, "name,-age")
+            # Returns [asc(UserModel.name), desc(UserModel.age)]
+        """
+        sorts: list[ColumnElement] = []
+        sort_parts = query.split(",")
+        for part in sort_parts:
+            if part.startswith("-"):
+                key = part[1:]
+                order = desc
+            else:
+                key = part
+                order = asc
+            if hasattr(model, key):
+                sorts.append(order(getattr(model, key)))
+        return sorts
+
+    return parse_sort_param
+
+
+def create_default_filter_param_parser() -> (
+    Callable[[SQLModel, str], list[ClauseElement]]
+):
+    def parse_filter_param(model: SQLModel, query: str) -> list[ClauseElement]:
+        """
+        Parse the filter parameter and return a list of SQLAlchemy ClauseElement objects.
+
+        Args:
+            model (Type[SQLModel]): The SQLModel class to be queried.
+            query (str): A comma-separated string of filters.
+                        Each filter should be in the format "field:operator:value".
+                        Use '\,' to escape commas within values.
+
+        Returns:
+            list[ClauseElement]: A list of SQLAlchemy ClauseElement objects representing the filters.
+
+        Supported operators:
+            eq: Equal to
+            ne: Not equal to
+            gt: Greater than
+            gte: Greater than or equal to
+            lt: Less than
+            lte: Less than or equal to
+            like: SQL LIKE (use % for wildcards)
+            in: In a list of values (semicolon-separated)
+
+        Example:
+            parse_filter_param(UserModel, "age:gte:18,name:like:John%,role:in:admin;user,address:eq:123\, Main St.")
+            # Returns [UserModel.age >= 18, UserModel.name.like("John%"), UserModel.role.in_(["admin", "user"]), UserModel.address == "123, Main St."]
+        """
+        filters: list[ClauseElement] = []
+        filter_parts = split_by_comma(query)
+        for part in filter_parts:
+            match = re.match(r"(.+):(.+):(.+)", part)
+            if match:
+                key, op, value = match.groups()
+                value = value.replace(r"\,", ",")  # Unescape commas in the value
+                if hasattr(model, key):
+                    column = getattr(model, key)
+                    if op == "eq":
+                        filters.append(column == value)
+                    elif op == "ne":
+                        filters.append(column != value)
+                    elif op == "gt":
+                        filters.append(column > value)
+                    elif op == "gte":
+                        filters.append(column >= value)
+                    elif op == "lt":
+                        filters.append(column < value)
+                    elif op == "lte":
+                        filters.append(column <= value)
+                    elif op == "like":
+                        filters.append(column.like(value))
+                    elif op == "in":
+                        filters.append(column.in_(value.split(";")))
+        return filters
+
+    return parse_filter_param
+
+
+def split_by_comma(s: str, delimiter: str = ",") -> list[str]:
+    return re.split(r"(?<!\\)" + re.escape(delimiter), s)

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

@@ -0,0 +1,58 @@
+import re
+
+
+def get_os_from_user_agent(user_agent: str) -> str:
+    os_patterns = [
+        (r"Windows NT (\d+\.\d+)", "Windows"),
+        (r"Mac OS X (\d+[_\.]\d+)", "MacOS"),
+        (r"Android (\d+[\.\d]*)", "Android"),
+        (r"iPhone OS (\d+[_\.]\d+)", "iOS"),
+        (r"iPad.*OS (\d+[_\.]\d+)", "iPadOS"),
+        (r"Linux", "Linux"),
+    ]
+    os = "Unknown OS"
+    # Match OS
+    for pattern, name in os_patterns:
+        match = re.search(pattern, user_agent)
+        if match:
+            os = (
+                f"{name} {match.group(1).replace('_', '.')}" if match.groups() else name
+            )
+            break
+    return os
+
+
+def get_browser_from_user_agent(user_agent: str) -> str:
+    browser_patterns = [
+        (r"Chrome/([\d\.]+)", "Chrome"),
+        (r"Firefox/([\d\.]+)", "Firefox"),
+        (r"Edg/([\d\.]+)", "Edge"),
+        (r"Safari/([\d\.]+)", "Safari"),
+    ]
+    browser = "Unknown Browser"
+    # Match Browser
+    for pattern, name in browser_patterns:
+        match = re.search(pattern, user_agent)
+        if match:
+            browser = f"{name} {match.group(1)}"
+            break
+    return browser
+
+
+def get_device_from_user_agent(user_agent: str):
+    device_patterns = [
+        (r"iPhone", "iPhone"),
+        (r"iPad", "iPad"),
+        (r"Android.*Mobile", "Android Phone"),
+        (r"Android", "Android Tablet"),
+        (r"Macintosh", "Mac"),
+        (r"Windows NT", "Windows PC"),
+        (r"Linux", "Linux Device"),
+    ]
+    device = "Unknown Device"
+    # Match Device
+    for pattern, name in device_patterns:
+        if re.search(pattern, user_agent):
+            device = name
+            break
+    return device

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

@@ -0,0 +1,37 @@
+import os
+from typing import Any
+
+from fastapi.responses import HTMLResponse
+from jinja2 import Environment, FileSystemLoader
+
+
+def render_str(template_path: str, **data: Any) -> str:
+    """
+    Renders a Jinja2 template with the given data.
+
+    :param template_path: The absolute or relative file path of the template.
+    :param data: A dictionary of data to pass to the template (default is None).
+    :return: Rendered template as a string.
+    """
+    if data is None:
+        data = {}
+    # Get the directory and file name
+    directory, template_name = os.path.split(template_path)
+    # Set up Jinja2 environment with the specific directory
+    env = Environment(loader=FileSystemLoader(directory))
+    # Render the template
+    template = env.get_template(template_name)
+    return template.render(data)
+
+
+def render_page(
+    template_path: str,
+    status_code: int = 200,
+    headers: dict[str, str] = None,
+    media_type: str | None = None,
+    **data: Any
+) -> HTMLResponse:
+    content = render_str(template_path, **data)
+    return HTMLResponse(
+        content=content, status_code=status_code, headers=headers, media_type=media_type
+    )

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/config.py

@@ -1,6 +1,30 @@
 import os
 
 APP_PATH = os.path.dirname(__file__)
+APP_VERSION = "0.1.0"
+
+APP_GATEWAY_VIEW_PATH = os.path.join(APP_PATH, "module", "gateway", "view")
+APP_GATEWAY_VIEW_DEFAULT_TEMPLATE_PATH = os.getenv(
+    "MY_APP_GATEWAY_VIEW_DEFAULT_TEMPLATE_PATH",
+    os.path.join("template", "default.html"),
+)
+_DEFAULT_CSS_PATH = "/static/pico-css/pico.min.css"
+APP_GATEWAY_CSS_PATH_LIST = [
+    path
+    for path in os.getenv("MY_APP_GATEWAY_CSS_PATH", _DEFAULT_CSS_PATH).split(":")
+    if path != ""
+]
+APP_GATEWAY_JS_PATH_LIST = [
+    path for path in os.getenv("MY_APP_GATEWAY_JS_PATH", "").split(":") if path != ""
+]
+APP_GATEWAY_TITLE = os.getenv("MY_APP_GATEWAY_TITLE", "My App Name")
+APP_GATEWAY_SUBTITLE = os.getenv("MY_APP_GATEWAY_SUBTITLE", "Just Another App")
+APP_GATEWAY_LOGO_PATH = os.getenv(
+    "MY_APP_GATEWAY_LOGO", "/static/images/android-chrome-192x192.png"
+)
+APP_GATEWAY_FAVICON_PATH = os.getenv(
+    "MY_APP_GATEWAY_FAVICON", "/static/images/favicon-32x32.png"
+)
 
 APP_MODE = os.getenv("MY_APP_NAME_MODE", "monolith")
 APP_MODULES = [
@@ -15,7 +39,7 @@ APP_COMMUNICATION = os.getenv(
 )
 APP_REPOSITORY_TYPE = os.getenv("APP_REPOSITORY_TYPE", "db")
 APP_DB_URL = os.getenv(
-    "APP_DB_URL",
+    "MY_APP_NAME_DB_URL",
     (
         f"sqlite:///{APP_PATH}/monolith.db"
         if APP_MODE == "monolith" or len(APP_MODULES) == 0

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/main.py

@@ -1,4 +1,4 @@
-from my_app_name.common.app import app
+from my_app_name.common.app_factory import app
 from my_app_name.module.auth import route as auth_route
 from my_app_name.module.gateway import route as gateway_route
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/auth_api_client.py

@@ -0,0 +1,16 @@
+from my_app_name.config import APP_AUTH_BASE_URL
+from my_app_name.module.auth.client.auth_client import AuthClient
+from my_app_name.module.auth.service.permission.permission_service_factory import (
+    permission_service,
+)
+from my_app_name.module.auth.service.role.role_service_factory import role_service
+from my_app_name.module.auth.service.user.user_service_factory import user_service
+
+
+class AuthAPIClient(
+    permission_service.as_api_client(base_url=APP_AUTH_BASE_URL),
+    role_service.as_api_client(base_url=APP_AUTH_BASE_URL),
+    user_service.as_api_client(base_url=APP_AUTH_BASE_URL),
+    AuthClient,
+):
+    pass