zrb 1.0.0b7__py3-none-any.whl → 1.0.0b9__py3-none-any.whl

zrb/__main__.py

@@ -16,8 +16,11 @@ def serve_cli():
         cli.run(sys.argv[1:])
     except KeyboardInterrupt:
         print(stylize_warning("\nStopped"), file=sys.stderr)
+        sys.exit(1)
     except RuntimeError as e:
         if f"{e}".lower() != "event loop is closed":
             raise e
+        sys.exit(1)
     except NodeNotFoundError as e:
         print(stylize_error(f"{e}"), file=sys.stderr)
+        sys.exit(1)

zrb/builtin/git.py

@@ -57,9 +57,9 @@ from zrb.util.git import (
 )
 async def get_git_diff(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     diff = await get_diff(
-        repo_dir, ctx.input.source, ctx.input.current, log_method=ctx.print
+        repo_dir, ctx.input.source, ctx.input.current, print_method=ctx.print
     )
     result = []
     decorated = []
@@ -88,17 +88,17 @@ async def get_git_diff(ctx: AnyContext):
 )
 async def prune_local_branches(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get existing branches"))
-    branches = await get_branches(repo_dir, log_method=ctx.print)
+    branches = await get_branches(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
     for branch in branches:
         if branch == current_branch or branch == "main" or branch == "master":
             continue
         ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:
-            await delete_branch(repo_dir, branch, log_method=ctx.print)
+            await delete_branch(repo_dir, branch, print_method=ctx.print)
         except Exception as e:
             ctx.log_error(e)
 
@@ -117,11 +117,11 @@ async def prune_local_branches(ctx: AnyContext):
 )
 async def git_commit(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Add changes to staging"))
-    await add(repo_dir, log_method=ctx.print)
+    await add(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Commit changes"))
-    await commit(repo_dir, ctx.input.message, log_method=ctx.print)
+    await commit(repo_dir, ctx.input.message, print_method=ctx.print)
 
 
 @make_task(
@@ -139,12 +139,12 @@ async def git_commit(ctx: AnyContext):
 )
 async def git_pull(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
     remote = ctx.input.remote
     ctx.print(stylize_faint(f"Pulling from {remote}/{current_branch}"))
-    await pull(repo_dir, remote, current_branch, log_method=ctx.print)
+    await pull(repo_dir, remote, current_branch, print_method=ctx.print)
 
 
 @make_task(
@@ -161,9 +161,9 @@ async def git_pull(ctx: AnyContext):
     alias="push",
 )
 async def git_push(ctx: AnyContext):
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
     remote = ctx.input.remote
     ctx.print(stylize_faint(f"Pushing to {remote}/{current_branch}"))
-    await push(repo_dir, remote, current_branch, log_method=ctx.print)
+    await push(repo_dir, remote, current_branch, print_method=ctx.print)

zrb/builtin/git_subtree.py

@@ -35,7 +35,7 @@ from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_su
 )
 async def git_add_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Add subtree"))
     await add_subtree(
         repo_dir=repo_dir,
@@ -43,7 +43,7 @@ async def git_add_subtree(ctx: AnyContext):
         repo_url=ctx.input["repo-url"],
         branch=ctx.input["repo-branch"],
         prefix=ctx.input["repo-prefix"],
-        log_method=ctx.print,
+        print_method=ctx.print,
     )
 
 
@@ -56,7 +56,7 @@ async def git_add_subtree(ctx: AnyContext):
 )
 async def git_pull_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -69,7 +69,7 @@ async def git_pull_subtree(ctx: AnyContext):
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
-                log_method=ctx.print,
+                print_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:
@@ -88,7 +88,7 @@ async def git_pull_subtree(ctx: AnyContext):
 )
 async def git_push_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -101,7 +101,7 @@ async def git_push_subtree(ctx: AnyContext):
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
-                log_method=ctx.print,
+                print_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:

zrb/builtin/project/add/fastapp/fastapp_task.py

@@ -57,6 +57,7 @@ scaffold_fastapp = Scaffolder(
                 "my_app_name": "{to_snake_case(ctx.input.app)}",
                 "MY_APP_NAME": "{to_snake_case(ctx.input.app).upper()}",
                 "my-secure-password": lambda _: get_random_name(),
+                "my-secret-key": lambda _: get_random_name(),
             },
         ),
         # Register fastapp's tasks to project's zrb_init (project_dir/zrb_init.py)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_task.py

@@ -88,6 +88,7 @@ scaffold_my_app_name_entity = Scaffolder(
             match=is_in_app_schema_dir,
             transform={
                 "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+                "my_entities": "{to_snake_case(ctx.input.plural)}",
                 "my_column": "{to_snake_case(ctx.input.column)}",
             },
         ),

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/my_entity_service.py

@@ -67,11 +67,11 @@ class MyEntityService(BaseService):
     @BaseService.route(
         "/api/v1/my-entities/bulk",
         methods=["put"],
-        response_model=MyEntityResponse,
+        response_model=list[MyEntityResponse],
     )
     async def update_my_entity_bulk(
         self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
-    ) -> MyEntityResponse:
+    ) -> list[MyEntityResponse]:
         await self.my_entity_repository.update_bulk(my_entity_ids, data)
         return await self.my_entity_repository.get_by_ids(my_entity_ids)
 
@@ -89,11 +89,11 @@ class MyEntityService(BaseService):
     @BaseService.route(
         "/api/v1/my-entities/bulk",
         methods=["delete"],
-        response_model=MyEntityResponse,
+        response_model=list[MyEntityResponse],
     )
     async def delete_my_entity_bulk(
         self, my_entity_ids: list[str], deleted_by: str
-    ) -> MyEntityResponse:
+    ) -> list[MyEntityResponse]:
         my_entities = await self.my_entity_repository.get_by_ids(my_entity_ids)
         await self.my_entity_repository.delete_bulk(my_entity_ids)
         return my_entities
@@ -106,6 +106,6 @@ class MyEntityService(BaseService):
     async def delete_my_entity(
         self, my_entity_id: str, deleted_by: str
     ) -> MyEntityResponse:
-        my_entity = await self.my_entity_repository.get_by_id(my_entity.id)
+        my_entity = await self.my_entity_repository.get_by_id(my_entity_id)
         await self.my_entity_repository.delete(my_entity_id)
         return my_entity

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/schema/my_entity.py

@@ -39,6 +39,7 @@ class MultipleMyEntityResponse(BaseModel):
 
 
 class MyEntity(SQLModel, table=True):
+    __tablename__ = "my_entities"
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
     created_at: datetime.datetime = Field(index=True)
     created_by: str = Field(index=True)

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

@@ -3,6 +3,14 @@ from my_app_name._zrb.util import get_existing_module_names, get_existing_schema
 from zrb import OptionInput, StrInput
 from zrb.util.string.conversion import pluralize
 
+run_env_input = OptionInput(
+    name="env",
+    description="Running environment",
+    prompt="Running Environment",
+    options=["dev", "prod"],
+    default_str="prod",
+)
+
 new_module_input = StrInput(
     name="module", description="Module name", prompt="New module name"
 )

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

@@ -9,8 +9,14 @@ from my_app_name._zrb.group import (
     app_migrate_group,
     app_run_group,
 )
+from my_app_name._zrb.input import run_env_input
 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.task_util import (
+    create_migration,
+    migrate_module,
+    run_microservice,
+    run_my_app_name,
+)
 from my_app_name._zrb.venv_task import prepare_venv
 
 from zrb import CmdTask, EnvFile, EnvMap, Task
@@ -52,6 +58,7 @@ run_monolith = app_run_group.add_task(
     CmdTask(
         name="run-monolith-my-app-name",
         description="🗿 Run My App Name as a monolith",
+        input=run_env_input,
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
             EnvMap(vars=MONOLITH_ENV_VARS),
@@ -59,7 +66,7 @@ run_monolith = app_run_group.add_task(
         cwd=APP_DIR,
         cmd=[
             ACTIVATE_VENV_SCRIPT,
-            'fastapi dev main.py --port "${MY_APP_NAME_PORT}"',
+            run_my_app_name,
         ],
         render_cmd=False,
         retries=2,

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

@@ -0,0 +1,100 @@
+import os
+
+from my_app_name._zrb.config import (
+    ACTIVATE_VENV_SCRIPT,
+    APP_DIR,
+    MICROSERVICES_ENV_VARS,
+    MONOLITH_ENV_VARS,
+)
+from my_app_name._zrb.input import run_env_input
+from my_app_name._zrb.util import (
+    cd_module_script,
+    run_my_app_name,
+    set_create_migration_db_url_env,
+    set_env,
+    set_module_env,
+)
+
+from zrb import Cmd, CmdTask, EnvFile, EnvMap, StrInput, Task
+from zrb.util.string.conversion import to_snake_case
+
+
+def create_migration(name: str, module: str) -> Task:
+    return CmdTask(
+        name=f"create-my-app-name-{name}-migration",
+        description=f"🧩 Create My 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")),
+        cwd=APP_DIR,
+        cmd=[
+            ACTIVATE_VENV_SCRIPT,
+            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)}",
+                auto_render=True,
+            ),
+        ],
+        render_cmd=False,
+        retries=2,
+    )
+
+
+def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
+    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}"
+            if as_microservices
+            else f"migrate-{name}-on-monolith"
+        ),
+        description=f"🧩 Run My App Name {name.capitalize()} DB migration",
+        env=[
+            EnvFile(path=os.path.join(APP_DIR, "template.env")),
+            EnvMap(vars=env_vars),
+        ],
+        cwd=APP_DIR,
+        cmd=[
+            ACTIVATE_VENV_SCRIPT,
+            cd_module_script(module),
+            "alembic upgrade head",
+        ],
+        render_cmd=False,
+        retries=2,
+    )
+
+
+def run_microservice(name: str, port: int, module: str) -> Task:
+    return CmdTask(
+        name=f"run-my-app-name-{name}",
+        description=f"🧩 Run My App Name {name.capitalize()}",
+        input=run_env_input,
+        env=[
+            EnvFile(path=os.path.join(APP_DIR, "template.env")),
+            EnvMap(
+                vars={
+                    **MICROSERVICES_ENV_VARS,
+                }
+            ),
+        ],
+        cwd=APP_DIR,
+        cmd=[
+            ACTIVATE_VENV_SCRIPT,
+            set_env("MY_APP_NAME_MODULES", module),
+            set_env("MY_APP_NAME_PORT", f"{port}"),
+            run_my_app_name,
+        ],
+        render_cmd=False,
+        retries=2,
+    )

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

@@ -1,95 +1,15 @@
 import os
 import platform
 
-from my_app_name._zrb.config import (
-    ACTIVATE_VENV_SCRIPT,
-    APP_DIR,
-    MICROSERVICES_ENV_VARS,
-    MONOLITH_ENV_VARS,
-)
-
-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:
-    return CmdTask(
-        name=f"create-my-app-name-{name}-migration",
-        description=f"🧩 Create My 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")),
-        cwd=APP_DIR,
-        cmd=[
-            ACTIVATE_VENV_SCRIPT,
-            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)}",
-                auto_render=True,
-            ),
-        ],
-        render_cmd=False,
-        retries=2,
-    )
-
+from my_app_name._zrb.config import APP_DIR
 
-def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
-    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}"
-            if as_microservices
-            else f"migrate-{name}-on-monolith"
-        ),
-        description=f"🧩 Run My App Name {name.capitalize()} DB migration",
-        env=[
-            EnvFile(path=os.path.join(APP_DIR, "template.env")),
-            EnvMap(vars=env_vars),
-        ],
-        cwd=APP_DIR,
-        cmd=[
-            ACTIVATE_VENV_SCRIPT,
-            cd_module_script(module),
-            "alembic upgrade head",
-        ],
-        render_cmd=False,
-        retries=2,
-    )
+from zrb import AnyContext
+from zrb.util.string.conversion import double_quote, to_snake_case
 
 
-def run_microservice(name: str, port: int, module: str) -> Task:
-    return CmdTask(
-        name=f"run-my-app-name-{name}",
-        description=f"🧩 Run My App Name {name.capitalize()}",
-        env=[
-            EnvFile(path=os.path.join(APP_DIR, "template.env")),
-            EnvMap(
-                vars={
-                    **MICROSERVICES_ENV_VARS,
-                }
-            ),
-        ],
-        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,
-        retries=2,
-    )
+def run_my_app_name(ctx: AnyContext) -> str:
+    subcommand = "dev" if ctx.input.env == "dev" else "run"
+    return f'fastapi {subcommand}  main.py --port "${{MY_APP_NAME_PORT}}"'
 
 
 def get_existing_module_names() -> list[str]:

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

@@ -122,9 +122,19 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
         return self._ensure_one(rows)
 
     async def get_by_ids(self, id_list: list[str]) -> list[ResponseModel]:
-        return await self._select_to_response(
+        rows = await self._select_to_response(
             lambda q: q.where(self.db_model.id.in_(id_list))
         )
+        # raise error if any id not in id_list
+        existing_id_list = [row.id for row in rows]
+        inexist_id_list = [id for id in id_list if id not in existing_id_list]
+        if len(inexist_id_list) > 0:
+            raise NotFoundError(
+                f"{self.entity_name} not found, inexist ids: {', '.join(inexist_id_list)}"
+            )
+        # sort rows
+        row_dict = {row.id: row for row in rows}
+        return [row_dict[id] for id in id_list]
 
     async def count(self, filter: str | None = None) -> int:
         count_statement = select(func.count(1)).select_from(self.db_model)
@@ -184,21 +194,22 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
 
     async def create_bulk(self, data_list: list[CreateModel]) -> list[DBModel]:
         now = datetime.datetime.now(datetime.timezone.utc)
-        data_dicts = [
+        data_dict_list = [
             self._model_to_data_dict(data, created_at=now, id=ulid.new().str)
             for data in data_list
         ]
+        id_list = [data_dict["id"] for data_dict in data_dict_list]
         async with self._session_scope() as session:
             await self._execute_statement(
-                session, insert(self.db_model).values(data_dicts)
+                session, insert(self.db_model).values(data_dict_list)
             )
-            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())
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump())
                 for entity in result.scalars().all()
-            ]
+            }
+            return [row_dict[id] for id in id_list]
 
     async def delete(self, id: str) -> DBModel:
         async with self._session_scope() as session:
@@ -220,11 +231,15 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             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]
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump()) for entity in entities
+            }
+            return [row_dict[id] for id in id_list]
 
     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)
+        update_data = {k: v for k, v in update_data.items() if v is not None}
         async with self._session_scope() as session:
             statement = (
                 update(self.db_model)
@@ -256,7 +271,8 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             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())
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump())
                 for entity in result.scalars().all()
-            ]
+            }
+            return [row_dict[id] for id in id_list]

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

@@ -56,7 +56,6 @@ class BaseService:
         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,
@@ -160,56 +159,62 @@ def _create_direct_client_method(logger: Logger, func: Callable, service: BaseSe
     return client_method
 
 
-def _create_api_client_method(logger: Logger, param: RouteParam, base_url: str):
+def _create_api_client_method(logger: Logger, route_param: RouteParam, base_url: str):
     async def client_method(*args, **kwargs):
-        url = base_url + param.path
+        url = base_url + route_param.path
         method = (
-            param.methods[0].lower()
-            if isinstance(param.methods, list)
-            else param.methods.lower()
+            route_param.methods[0].lower()
+            if isinstance(route_param.methods, list)
+            else route_param.methods.lower()
         )
         # Get the signature of the original function
-        sig = inspect.signature(param.func)
+        sig = inspect.signature(route_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
+        function_params = list(sig.parameters.values())
+        body_param_names = [
+            p.name
+            for p in function_params
+            if (
+                p.name != "self"
+                and f"{{{p.name}}}" not in route_param.path
+                and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+                and (
+                    method not in ["get", "delete"]
+                    or (method == "delete" and p.annotation not in [str, float, bool])
+                )
+            )
         ]
         # Prepare the request
         path_params = {}
         query_params = {}
-        body = {}
+        body_params = {}
         for name, value in bound_args.arguments.items():
             if name == "self":
                 continue
-            if f"{{{name}}}" in param.path:
+            if f"{{{name}}}" in route_param.path:
                 path_params[name] = value
-            elif isinstance(value, BaseModel):
-                body = _parse_api_param(value)
-            elif method in ["get", "delete"]:
+            elif name not in body_param_names:
                 query_params[name] = _parse_api_param(value)
-            elif len(body_params) == 1 and name == body_params[0].name:
+            elif len(body_param_names) == 1 and name == body_param_names[0]:
                 # If there's only one body parameter, use its value directly
-                body = _parse_api_param(value)
+                body_params = _parse_api_param(value)
             else:
-                body[name] = _parse_api_param(value)
+                body_params[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
+            f"Sending request to {url} with method {method}, json={body_params}, 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
-                )
+            response = await client.request(
+                method=method,
+                url=url,
+                params=query_params,
+                json=None if method == "get" else body_params,
+            )
             logger.info(
                 f"Received response: status={response.status_code}, content={response.content}"
             )

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

@@ -8,11 +8,26 @@ class NotFoundError(HTTPException):
         super().__init__(404, {"message": message}, headers)
 
 
+class ForbiddenError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(403, {"message": message}, headers)
+
+
+class UnauthorizedError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(401, {"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 InternalServerError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(500, {"message": message}, headers)
+
+
 class ClientAPIError(HTTPException):
     def __init__(
         self, status_code: int, message: str, headers: Dict[str, str] | None = None