zrb 1.0.0a2__py3-none-any.whl → 1.0.0a3__py3-none-any.whl

zrb/builtin/project/add/fastapp_template/_zrb/config.py

@@ -0,0 +1,17 @@
+import os
+import platform
+
+DIR = os.path.dirname(__file__)
+APP_DIR = os.path.dirname(DIR)
+APP_MODULE_NAME = os.path.basename(APP_DIR)
+
+MICROSERVICES_ENV_VARS = {
+    "APP_NAME_MODE": "microservices",
+    "APP_NAME_AUTH_BASE_URL": "http://localhost:3002",
+}
+MONOLITH_ENV_VARS = {"APP_NAME_MODE": "monolith"}
+
+if platform.system() == "Windows":
+    ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\Scripts\Activate"  # noqa
+else:
+    ACTIVATE_VENV_SCRIPT = "source .venv/bin/activate"

zrb/builtin/project/add/fastapp_template/_zrb/group.py

@@ -0,0 +1,16 @@
+from zrb import Group
+from zrb.builtin import project_group
+
+app_group = project_group.add_group(
+    Group(name="app-name", description="🚀 Managing App Name")
+)
+
+app_run_group = app_group.add_group(Group(name="run", description="🟢 Run App Name"))
+
+app_migrate_group = app_group.add_group(
+    Group(name="migrate", description="📦 Run App Name DB migration")
+)
+
+app_create_group = app_group.add_group(
+    Group(name="create", description="✨ Create resources for App Name")
+)

zrb/builtin/project/add/fastapp_template/_zrb/helper.py

@@ -0,0 +1,97 @@
+import os
+
+from fastapp_template._zrb.config import (
+    ACTIVATE_VENV_SCRIPT,
+    APP_DIR,
+    MICROSERVICES_ENV_VARS,
+    MONOLITH_ENV_VARS,
+)
+
+from zrb import Cmd, CmdTask, EnvFile, EnvMap, StrInput, Task
+
+
+def create_migration(name: str, module: str) -> Task:
+    return CmdTask(
+        name=f"create-app-name-{name}-migration",
+        description=f"🧩 Create App Name {name.capitalize()} DB migration",
+        input=StrInput(
+            name="message",
+            description="Migration message",
+            prompt="Migration message",
+            allow_empty=False,
+        ),
+        env=[
+            EnvFile(path=os.path.join(APP_DIR, "template.env")),
+            EnvMap(
+                vars={
+                    "APP_DB_URL": f"sqlite:///{APP_DIR}/.migration.{module}.db",
+                    "APP_NAME_MODULES": f"{module}",
+                }
+            ),
+        ],
+        cwd=APP_DIR,
+        cmd=[
+            ACTIVATE_VENV_SCRIPT,
+            f"cd {os.path.join(APP_DIR, 'module', module)}",
+            "alembic upgrade head",
+            Cmd(
+                "alembic revision --autogenerate -m {double_quote(ctx.input.message)}",
+                auto_render=True,
+            ),
+        ],
+        auto_render_cmd=False,
+        retries=2,
+    )
+
+
+def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
+    env_vars = MICROSERVICES_ENV_VARS if as_microservices else MONOLITH_ENV_VARS
+    return CmdTask(
+        name=(
+            f"migrate-app-name-{name}"
+            if as_microservices
+            else f"migrate-{name}-on-monolith"
+        ),
+        description=f"🧩 Run App Name {name.capitalize()} DB migration",
+        env=[
+            EnvFile(path=os.path.join(APP_DIR, "template.env")),
+            EnvMap(
+                vars={
+                    **env_vars,
+                    "APP_NAME_MODULES": f"{module}",
+                }
+            ),
+        ],
+        cwd=APP_DIR,
+        cmd=[
+            ACTIVATE_VENV_SCRIPT,
+            f"cd {os.path.join(APP_DIR, 'module', module)}",
+            "alembic upgrade head",
+        ],
+        auto_render_cmd=False,
+        retries=2,
+    )
+
+
+def run_microservice(name: str, port: int, module: str) -> Task:
+    return CmdTask(
+        name=f"run-app-name-{name}",
+        description=f"🧩 Run App Name {name.capitalize()}",
+        env=[
+            EnvFile(path=os.path.join(APP_DIR, "template.env")),
+            EnvMap(
+                vars={
+                    **MICROSERVICES_ENV_VARS,
+                    "APP_NAME_PORT": f"{port}",
+                    "APP_NAME_MODULES": f"{module}",
+                }
+            ),
+        ],
+        cwd=APP_DIR,
+        cmd=[
+            ACTIVATE_VENV_SCRIPT,
+            'fastapi dev main.py --port "${APP_NAME_PORT}"',
+        ],
+        auto_render_cmd=False,
+        retries=2,
+    )

zrb/builtin/project/add/fastapp_template/_zrb/main.py

@@ -0,0 +1,132 @@
+import os
+
+from fastapp_template._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR
+from fastapp_template._zrb.group import (
+    app_create_group,
+    app_migrate_group,
+    app_run_group,
+)
+from fastapp_template._zrb.helper import (
+    create_migration,
+    migrate_module,
+    run_microservice,
+)
+from fastapp_template._zrb.venv_task import prepare_venv
+
+from zrb import CmdTask, Env, EnvFile, Task
+
+# 🚀 Run/Migrate All ===========================================================
+
+run_all = app_run_group.add_task(
+    Task(
+        name="run-app-name", description="🟢 Run App Name as monolith and microservices"
+    ),
+    alias="all",
+)
+
+migrate_all = app_migrate_group.add_task(
+    Task(
+        name="migrate-app-name",
+        description="📦 Run App Name DB migration for monolith and microservices",
+    ),
+    alias="all",
+)
+
+create_all_migration = app_create_group.add_task(
+    Task(
+        name="create-app-name-migration", description="📦 Create App Name DB migration"
+    ),
+    alias="migration",
+)
+
+# 🗿 Run/Migrate Monolith =====================================================
+
+run_monolith = app_run_group.add_task(
+    CmdTask(
+        name="run-monolith-app-name",
+        description="🗿 Run App Name as a monolith",
+        env=[
+            EnvFile(path=os.path.join(APP_DIR, "template.env")),
+            Env(name="APP_NAME_MODE", default="monolith"),
+        ],
+        cwd=APP_DIR,
+        cmd=[
+            ACTIVATE_VENV_SCRIPT,
+            'fastapi dev main.py --port "${APP_NAME_PORT}"',
+        ],
+        auto_render_cmd=False,
+        retries=2,
+    ),
+    alias="monolith",
+)
+prepare_venv >> run_monolith >> run_all
+
+migrate_monolith = app_migrate_group.add_task(
+    Task(
+        name="migrate-monolith-app-name",
+        description="🗿 Run App Name DB migration for monolith",
+    ),
+    alias="monolith",
+)
+migrate_monolith >> migrate_all
+
+# 🌐 Run/Migrate Microsevices ==================================================
+
+run_microservices = app_run_group.add_task(
+    Task(
+        name="run-microservices-app-name",
+        description="🌐 Run App Name as microservices",
+    ),
+    alias="microservices",
+)
+run_microservices >> run_all
+
+migrate_microservices = app_migrate_group.add_task(
+    Task(
+        name="migrate-microservices-app-name",
+        description="🌐 Run App Name DB migration for microservices",
+    ),
+    alias="microservices",
+)
+migrate_microservices >> migrate_all
+
+# 📡 Run/Migrate Gateway =======================================================
+
+run_gateway = app_run_group.add_task(
+    run_microservice("gateway", 3001, "gateway"), alias="microservices-gateway"
+)
+prepare_venv >> run_gateway >> run_microservices
+
+create_gateway_migration = app_create_group.add_task(
+    create_migration("gateway", "gateway"), alias="gateway-migration"
+)
+prepare_venv >> create_gateway_migration >> create_all_migration
+
+migrate_monolith_gateway = migrate_module("gateway", "gateway", as_microservices=False)
+prepare_venv >> migrate_monolith_gateway >> [migrate_monolith, run_monolith]
+
+migrate_microservices_gateway = app_migrate_group.add_task(
+    migrate_module("gateway", "gateway", as_microservices=True),
+    alias="microservices-gateway",
+)
+prepare_venv >> migrate_microservices_gateway >> [migrate_microservices, run_gateway]
+
+# 🔐 Run/Migrate Auth ==========================================================
+
+run_auth = app_run_group.add_task(
+    run_microservice("auth", 3002, "auth"), alias="microservices-auth"
+)
+prepare_venv >> run_auth >> run_microservices
+
+create_auth_migration = app_create_group.add_task(
+    create_migration("auth", "auth"), alias="auth-migration"
+)
+prepare_venv >> create_auth_migration >> create_all_migration
+
+migrate_monolith_auth = migrate_module("auth", "auth", as_microservices=False)
+prepare_venv >> migrate_monolith_auth >> [migrate_monolith, run_monolith]
+
+migrate_microservices_auth = app_migrate_group.add_task(
+    migrate_module("auth", "auth", as_microservices=True), alias="microservices-auth"
+)
+prepare_venv >> migrate_microservices_auth >> [migrate_microservices, run_auth]

zrb/builtin/project/add/fastapp_template/_zrb/venv_task.py

@@ -0,0 +1,22 @@
+import os
+
+from fastapp_template._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR
+from fastapp_template._zrb.group import app_group
+
+from zrb import CmdTask
+
+create_venv = CmdTask(
+    name="create-app-name-venv",
+    cwd=APP_DIR,
+    cmd="python -m venv .venv",
+    execute_condition=lambda _: not os.path.isdir(os.path.join(APP_DIR, ".venv")),
+)
+
+prepare_venv = CmdTask(
+    name="prepare-app-name-venv",
+    cmd=[ACTIVATE_VENV_SCRIPT, "pip install -r requirements.txt"],
+    cwd=APP_DIR,
+)
+create_venv >> prepare_venv
+
+app_group.add_task(create_venv, alias="prepare")

zrb/builtin/project/add/fastapp_template/common/app.py

@@ -0,0 +1,18 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapp_template.common.db_engine import engine
+from fastapp_template.config import APP_MODE, APP_MODULES
+from sqlmodel import SQLModel
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    SQLModel.metadata.create_all(engine)
+    yield
+
+
+app_title = (
+    "App Name" if APP_MODE == "monolith" else f"App Name - {', '.join(APP_MODULES)}"
+)
+app = FastAPI(title=app_title, lifespan=lifespan)

zrb/builtin/project/add/fastapp_template/common/db_engine.py

@@ -0,0 +1,5 @@
+from fastapp_template.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)

zrb/builtin/project/add/fastapp_template/common/db_repository.py

@@ -0,0 +1,134 @@
+from typing import Any, Callable, Generic, Type, TypeVar
+
+from fastapp_template.common.error import NotFoundError
+from sqlalchemy import Engine
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+from sqlmodel import Session, SQLModel, select
+
+DBModel = TypeVar("DBModel", bound=SQLModel)
+ResponseModel = TypeVar("Model", bound=SQLModel)
+CreateModel = TypeVar("CreateModel", bound=SQLModel)
+UpdateModel = TypeVar("UpdateModel", bound=SQLModel)
+
+
+class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]):
+    db_model: Type[DBModel]
+    response_model: Type[ResponseModel]
+    create_model: Type[CreateModel]
+    update_model: Type[UpdateModel]
+    entity_name: str = "entity"
+    column_preprocessors: dict[str, Callable[[Any], Any]] = {}
+
+    def __init__(self, engine: Engine | AsyncEngine):
+        self.engine = engine
+        self.is_async = isinstance(engine, AsyncEngine)
+
+    def _to_response(self, db_instance: DBModel) -> ResponseModel:
+        return self.response_model(**db_instance.model_dump())
+
+    async def create(self, data: CreateModel) -> ResponseModel:
+        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_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)
+
+    async def get_by_id(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)
+        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)
+
+    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)
+        if self.is_async:
+            async with AsyncSession(self.engine) as session:
+                result = await session.execute(statement)
+                results = result.scalars().all()
+        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))
+        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)
+        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]

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

@@ -0,0 +1,8 @@
+from typing import Dict
+
+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)

zrb/builtin/project/add/fastapp_template/common/schema.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class BasicResponse(BaseModel):
+    message: str