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/_zrb/module/template/module_task_definition.py

@@ -1,7 +1,7 @@
 # 🔐 Run/Migrate My Module ==========================================================
 
 run_my_module = app_run_group.add_task(
-    run_microservice("my-module", 3000, "my_module"), alias="microservices-my_module"
+    run_microservice("my-module", 3000, "my_module"), alias="svc-my_module"
 )
 prepare_venv >> run_my_module >> run_microservices
 
@@ -17,7 +17,7 @@ prepare_venv >> migrate_monolith_my_module >> [migrate_monolith, run_monolith]
 
 migrate_microservices_my_module = app_migrate_group.add_task(
     migrate_module("my-module", "my_module", as_microservices=True),
-    alias="microservices-my-module",
+    alias="svc-my-module",
 )
 (
     prepare_venv

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/task.py

@@ -1,7 +1,7 @@
 import os
 
-from my_app_name._zrb.column.create_column_task import add_my_app_name_column
-from my_app_name._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR
+from my_app_name._zrb.column.add_column_task import add_my_app_name_column
+from my_app_name._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR, MONOLITH_ENV_VARS
 from my_app_name._zrb.entity.add_entity_task import add_my_app_name_entity
 from my_app_name._zrb.format_task import format_my_app_name_code
 from my_app_name._zrb.group import (
@@ -13,7 +13,7 @@ from my_app_name._zrb.module.add_module_task import add_my_app_name_module
 from my_app_name._zrb.util import create_migration, migrate_module, run_microservice
 from my_app_name._zrb.venv_task import prepare_venv
 
-from zrb import CmdTask, Env, EnvFile, Task
+from zrb import CmdTask, EnvFile, EnvMap, Task
 
 assert add_my_app_name_entity
 assert add_my_app_name_module
@@ -54,7 +54,7 @@ run_monolith = app_run_group.add_task(
         description="🗿 Run My App Name as a monolith",
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
-            Env(name="MY_APP_NAME_MODE", default="monolith"),
+            EnvMap(vars=MONOLITH_ENV_VARS),
         ],
         cwd=APP_DIR,
         cmd=[
@@ -100,7 +100,7 @@ migrate_microservices >> migrate_all
 # 📡 Run/Migrate Gateway =======================================================
 
 run_gateway = app_run_group.add_task(
-    run_microservice("gateway", 3001, "gateway"), alias="microservices-gateway"
+    run_microservice("gateway", 3001, "gateway"), alias="svc-gateway"
 )
 prepare_venv >> run_gateway >> run_microservices
 
@@ -114,14 +114,14 @@ 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",
+    alias="svc-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"
+    run_microservice("auth", 3002, "auth"), alias="svc-auth"
 )
 prepare_venv >> run_auth >> run_microservices
 
@@ -134,6 +134,6 @@ 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"
+    migrate_module("auth", "auth", as_microservices=True), alias="svc-auth"
 )
 prepare_venv >> migrate_microservices_auth >> [migrate_microservices, run_auth]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/util.py

@@ -1,4 +1,5 @@
 import os
+import platform
 
 from my_app_name._zrb.config import (
     ACTIVATE_VENV_SCRIPT,
@@ -8,6 +9,7 @@ from my_app_name._zrb.config import (
 )
 
 from zrb import Cmd, CmdTask, EnvFile, EnvMap, StrInput, Task
+from zrb.util.string.conversion import double_quote, to_snake_case
 
 
 def create_migration(name: str, module: str) -> Task:
@@ -20,19 +22,13 @@ def create_migration(name: str, module: str) -> Task:
             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",
-                    "MY_APP_NAME_MODULES": f"{module}",
-                }
-            ),
-        ],
+        env=EnvFile(path=os.path.join(APP_DIR, "template.env")),
         cwd=APP_DIR,
         cmd=[
             ACTIVATE_VENV_SCRIPT,
-            f"cd {os.path.join(APP_DIR, 'module', module)}",
+            set_create_migration_db_url_env(module),
+            set_module_env(module),
+            cd_module_script(module),
             "alembic upgrade head",
             Cmd(
                 "alembic revision --autogenerate -m {double_quote(ctx.input.message)}",
@@ -45,7 +41,11 @@ def create_migration(name: str, module: str) -> Task:
 
 
 def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
-    env_vars = MICROSERVICES_ENV_VARS if as_microservices else MONOLITH_ENV_VARS
+    env_vars = (
+        dict(MICROSERVICES_ENV_VARS) if as_microservices else dict(MONOLITH_ENV_VARS)
+    )
+    if as_microservices:
+        env_vars["MY_APP_NAME_MODULES"] = to_snake_case(module)
     return CmdTask(
         name=(
             f"migrate-my-app-name-{name}"
@@ -55,17 +55,12 @@ def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
         description=f"🧩 Run My App Name {name.capitalize()} DB migration",
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
-            EnvMap(
-                vars={
-                    **env_vars,
-                    "MY_APP_NAME_MODULES": f"{module}",
-                }
-            ),
+            EnvMap(vars=env_vars),
         ],
         cwd=APP_DIR,
         cmd=[
             ACTIVATE_VENV_SCRIPT,
-            f"cd {os.path.join(APP_DIR, 'module', module)}",
+            cd_module_script(module),
             "alembic upgrade head",
         ],
         render_cmd=False,
@@ -82,14 +77,14 @@ def run_microservice(name: str, port: int, module: str) -> Task:
             EnvMap(
                 vars={
                     **MICROSERVICES_ENV_VARS,
-                    "MY_APP_NAME_PORT": f"{port}",
-                    "MY_APP_NAME_MODULES": f"{module}",
                 }
             ),
         ],
         cwd=APP_DIR,
         cmd=[
             ACTIVATE_VENV_SCRIPT,
+            set_env("MY_APP_NAME_MODULES", module),
+            set_env("MY_APP_NAME_PORT", f"{port}"),
             'fastapi dev main.py --port "${MY_APP_NAME_PORT}"',
         ],
         render_cmd=False,
@@ -109,3 +104,35 @@ def get_existing_schema_names() -> list[str]:
         for entry in os.scandir(module_dir_path)
         if entry.is_file() and entry.name.endswith(".py")
     ]
+
+
+def set_create_migration_db_url_env(module_name: str) -> str:
+    return set_env(
+        "MY_APP_NAME_DB_URL",
+        f"sqlite:///{APP_DIR}/.migration.{to_snake_case(module_name)}.db",
+    )
+
+
+def set_module_env(module_name: str) -> str:
+    return (set_env("MY_APP_NAME_MODULES", to_snake_case(module_name)),)
+
+
+def cd_module_script(module_name: str) -> str:
+    module_dir_path = os.path.join(APP_DIR, "module", to_snake_case(module_name))
+    return f"cd {module_dir_path}"
+
+
+def set_env(var_name: str, var_value: str) -> str:
+    """
+    Generates a script to set an environment variable depending on the OS.
+    :param var_name: Name of the environment variable.
+    :param var_value: Value of the environment variable.
+    :return: A string containing the appropriate script.
+    """
+    if platform.system() == "Windows":
+        # PowerShell script for Windows
+        script = f'[Environment]::SetEnvironmentVariable({double_quote(var_name)}, {double_quote(var_value)}, "User")'  # noqa
+    else:
+        # Bash script for Unix-like systems
+        script = f"export {var_name}={double_quote(var_value)}"
+    return script

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

@@ -0,0 +1,29 @@
+import os
+
+from fastapi import FastAPI
+from my_app_name.common.db_engine_factory import db_engine
+from my_app_name.common.util.app import (
+    create_default_app_lifespan,
+    get_default_app_title,
+    serve_docs,
+    serve_static_dir,
+)
+from my_app_name.config import (
+    APP_GATEWAY_FAVICON_PATH,
+    APP_GATEWAY_TITLE,
+    APP_GATEWAY_VIEW_PATH,
+    APP_MODE,
+    APP_MODULES,
+    APP_VERSION,
+)
+
+app_title = get_default_app_title(APP_GATEWAY_TITLE, mode=APP_MODE, modules=APP_MODULES)
+app = FastAPI(
+    title=app_title,
+    version=APP_VERSION,
+    lifespan=create_default_app_lifespan(db_engine),
+    docs_url=None,
+)
+
+serve_static_dir(app, os.path.join(APP_GATEWAY_VIEW_PATH, "static"))
+serve_docs(app, app_title=app_title, favicon_url=APP_GATEWAY_FAVICON_PATH)

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

@@ -1,12 +1,17 @@
+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, 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 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)
 
@@ -23,112 +28,191 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
         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())
+    def _select(self) -> Select:
+        return select(self.db_model)
 
-    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)
+    def _rows_to_responses(self, rows: list[tuple[Any]]) -> list[ResponseModel]:
+        return [self.response_model.model_validate(row[0]) for row in rows]
 
-    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:
+    def _ensure_one(self, responses: list[ResponseModel]) -> ResponseModel:
+        if not responses:
             raise NotFoundError(f"{self.entity_name} not found")
-        return self._to_response(db_instance)
+        if len(responses) > 1:
+            raise InvalidValueError(f"Duplicate {self.entity_name}")
+        return responses[0]
 
-    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)
+    @asynccontextmanager
+    async def _session_scope(self):
         if self.is_async:
             async with AsyncSession(self.engine) as session:
-                result = await session.execute(statement)
-                results = result.scalars().all()
+                async with session.begin():
+                    yield session
         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:
+                with session.begin():
+                    yield session
+
+    async def _commit(self, session: Session | AsyncSession):
         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()
+            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:
+        statement = self._select().where(self.db_model.id == id)
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            responses = self._rows_to_responses(result.all())
+            return self._ensure_one(responses)
+
+    async def get_by_ids(self, id_list: list[str]) -> list[ResponseModel]:
+        statement = self._select().where(self.db_model.id.in_(id_list))
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]
+
+    async def count(self, filter: str | None = None) -> int:
+        count_statement = select(func.count(1)).select_from(self.db_model)
+        if filter:
+            filter_param = 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]:
+        offset = (page - 1) * page_size
+        statement = self._select().offset(offset).limit(page_size)
+        if filter:
+            filter_param = parse_filter_param(self.db_model, filter)
+            statement = statement.where(*filter_param)
+        if sort:
+            sort_param = parse_sort_param(self.db_model, sort)
+            statement = statement.order_by(*sort_param)
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            return [
+                self.db_model(**entity.model_dump())
+                for entity in result.scalars().all()
+            ]
+
+    def _model_to_data_dict(
+        self, data: SQLModel, **additional_data: Any
+    ) -> dict[str, Any]:
+        data_dict = data.model_dump(exclude_unset=True)
+        data_dict.update(additional_data)
+        for key, preprocessor in self.column_preprocessors.items():
+            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 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()
+            ]