zrb 1.0.0b8__py3-none-any.whl → 1.0.0b10__py3-none-any.whl

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

@@ -3,18 +3,26 @@
 
 @app.get("/api/v1/my-entities", response_model=MultipleMyEntityResponse)
 async def get_my_entities(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
     page: int = 1,
     page_size: int = 10,
     sort: str | None = None,
     filter: str | None = None,
 ) -> MultipleMyEntityResponse:
+    if not current_user.has_permission("my-entity:read"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.get_my_entities(
         page=page, page_size=page_size, sort=sort, filter=filter
     )
 
 
 @app.get("/api/v1/my-entities/{my_entity_id}", response_model=MyEntityResponse)
-async def get_my_entity_by_id(my_entity_id: str) -> MyEntityResponse:
+async def get_my_entity_by_id(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_id: str,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:read"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.get_my_entity_by_id(my_entity_id)
 
 
@@ -22,9 +30,14 @@ async def get_my_entity_by_id(my_entity_id: str) -> MyEntityResponse:
     "/api/v1/my-entities/bulk",
     response_model=list[MyEntityResponse],
 )
-async def create_my_entity_bulk(data: list[MyEntityCreate]):
+async def create_my_entity_bulk(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    data: list[MyEntityCreate],
+) -> list[MyEntityResponse]:
+    if not current_user.has_permission("my-entity:create"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.create_my_entity_bulk(
-        [row.with_audit(created_by="system") for row in data]
+        [row.with_audit(created_by=current_user.id) for row in data]
     )
 
 
@@ -32,17 +45,30 @@ async def create_my_entity_bulk(data: list[MyEntityCreate]):
     "/api/v1/my-entities",
     response_model=MyEntityResponse,
 )
-async def create_my_entity(data: MyEntityCreate):
-    return await my_module_client.create_my_entity(data.with_audit(created_by="system"))
+async def create_my_entity(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    data: MyEntityCreate,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:create"):
+        raise ForbiddenError("Access denied")
+    return await my_module_client.create_my_entity(
+        data.with_audit(created_by=current_user.id)
+    )
 
 
 @app.put(
     "/api/v1/my-entities/bulk",
     response_model=list[MyEntityResponse],
 )
-async def update_my_entity_bulk(my_entity_ids: list[str], data: MyEntityUpdate):
+async def update_my_entity_bulk(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_ids: list[str],
+    data: MyEntityUpdate,
+) -> list[MyEntityResponse]:
+    if not current_user.has_permission("my-entity:update"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.update_my_entity_bulk(
-        my_entity_ids, data.with_audit(updated_by="system")
+        my_entity_ids, data.with_audit(updated_by=current_user.id)
     )
 
 
@@ -50,9 +76,15 @@ async def update_my_entity_bulk(my_entity_ids: list[str], data: MyEntityUpdate):
     "/api/v1/my-entities/{my_entity_id}",
     response_model=MyEntityResponse,
 )
-async def update_my_entity(my_entity_id: str, data: MyEntityUpdate):
+async def update_my_entity(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_id: str,
+    data: MyEntityUpdate,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:update"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.update_my_entity(
-        my_entity_id, data.with_audit(updated_by="system")
+        my_entity_id, data.with_audit(updated_by=current_user.id)
     )
 
 
@@ -60,9 +92,14 @@ async def update_my_entity(my_entity_id: str, data: MyEntityUpdate):
     "/api/v1/my-entities/bulk",
     response_model=list[MyEntityResponse],
 )
-async def delete_my_entity_bulk(my_entity_ids: list[str]):
+async def delete_my_entity_bulk(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_ids: list[str],
+) -> list[MyEntityResponse]:
+    if not current_user.has_permission("my-entity:delete"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.delete_my_entity_bulk(
-        my_entity_ids, deleted_by="system"
+        my_entity_ids, deleted_by=current_user.id
     )
 
 
@@ -70,5 +107,12 @@ async def delete_my_entity_bulk(my_entity_ids: list[str]):
     "/api/v1/my-entities/{my_entity_id}",
     response_model=MyEntityResponse,
 )
-async def delete_my_entity(my_entity_id: str):
-    return await my_module_client.delete_my_entity(my_entity_id, deleted_by="system")
+async def delete_my_entity(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_id: str,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:delete"):
+        raise ForbiddenError("Access denied")
+    return await my_module_client.delete_my_entity(
+        my_entity_id, deleted_by=current_user.id
+    )

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/module/add_module_util.py

@@ -4,8 +4,8 @@ from my_app_name._zrb.config import APP_DIR
 from my_app_name._zrb.util import get_existing_module_names
 
 from zrb.context.any_context import AnyContext
-from zrb.util.codemod.append_code_to_function import append_code_to_function
-from zrb.util.codemod.append_key_to_dict import append_key_to_dict
+from zrb.util.codemod.modify_dict import append_key_to_dict
+from zrb.util.codemod.modify_function import append_code_to_function
 from zrb.util.file import read_file, write_file
 from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/gateway/subroute/my_module.py

@@ -1,4 +1,9 @@
-from fastapi import FastAPI
+from typing import Annotated
+
+from fastapi import Depends, FastAPI
+from my_app_name.common.error import ForbiddenError
+from my_app_name.module.gateway.util.auth import get_current_user
+from my_app_name.schema.user import AuthUserResponse
 
 
 def serve_my_module_route(app: FastAPI):

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/module_task_definition.py

@@ -1,26 +1,30 @@
 # 🔐 Run/Migrate My Module ==========================================================
 
 run_my_module = app_run_group.add_task(
-    run_microservice("my-module", 3000, "my_module"), alias="svc-my_module"
+    run_microservice("my_module", 3000), alias="svc-my-module"
 )
 prepare_venv >> run_my_module >> run_microservices
 
 create_my_module_migration = app_create_migration_group.add_task(
-    create_migration("my-module", "my_module"), alias="my_module"
+    create_migration("my_module"), alias="my_module"
 )
 prepare_venv >> create_my_module_migration >> create_all_migration
 
-migrate_monolith_my_module = migrate_module(
-    "my_module", "my_module", as_microservices=False
-)
+migrate_monolith_my_module = migrate_module("my_module", as_microservices=False)
 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),
+    migrate_module("my_module", as_microservices=True),
     alias="svc-my-module",
 )
+
 (
     prepare_venv
     >> migrate_microservices_my_module
     >> [migrate_microservices, run_my_module]
 )
+
+migrate_test_my_module = migrate_module(
+    "my_module", as_microservices=False, additional_env_vars=TEST_ENV_VARS
+)
+prepare_venv >> migrate_test_my_module >> migrate_test

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

@@ -1,25 +1,66 @@
 import os
 
 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.config import (
+    ACTIVATE_VENV_SCRIPT,
+    APP_DIR,
+    MONOLITH_ENV_VARS,
+    TEST_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 (
     app_create_migration_group,
+    app_group,
     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
+from zrb import AnyContext, CmdPath, CmdTask, EnvFile, EnvMap, Task, make_task
 
 assert add_my_app_name_entity
 assert add_my_app_name_module
 assert add_my_app_name_column
 assert format_my_app_name_code
 
+# 🧪 Test ======================================================================
+
+
+@make_task(
+    name="prepare-my-app-name-test",
+)
+def prepare_test(ctx: AnyContext):
+    db_test_path = os.path.join(APP_DIR, "test.db")
+    if os.path.exists(db_test_path):
+        ctx.print(f"Removing test db: {db_test_path}")
+        os.remove(db_test_path)
+
+
+migrate_test = Task(name="migrate-test")
+
+test_app = app_group.add_task(
+    CmdTask(
+        name="test-my-app-name",
+        description="🧪 Test My App Name",
+        env=EnvMap(vars=TEST_ENV_VARS),
+        cwd=APP_DIR,
+        cmd=CmdPath(os.path.join(APP_DIR, "test.sh")),
+        retries=0,
+    ),
+    alias="test",
+)
+prepare_venv >> prepare_test >> migrate_test >> test_app
+
+
 # 🚀 Run/Migrate All ===========================================================
 
 run_all = app_run_group.add_task(
@@ -52,6 +93,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 +101,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,
@@ -100,40 +142,49 @@ migrate_microservices >> migrate_all
 # 📡 Run/Migrate Gateway =======================================================
 
 run_gateway = app_run_group.add_task(
-    run_microservice("gateway", 3001, "gateway"), alias="svc-gateway"
+    run_microservice("gateway", 3001), alias="svc-gateway"
 )
 prepare_venv >> run_gateway >> run_microservices
 
 create_gateway_migration = app_create_migration_group.add_task(
-    create_migration("gateway", "gateway"), alias="gateway"
+    create_migration("gateway"), alias="gateway"
 )
 prepare_venv >> create_gateway_migration >> create_all_migration
 
-migrate_monolith_gateway = migrate_module("gateway", "gateway", as_microservices=False)
+migrate_monolith_gateway = migrate_module("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),
+    migrate_module("gateway", as_microservices=True),
     alias="svc-gateway",
 )
 prepare_venv >> migrate_microservices_gateway >> [migrate_microservices, run_gateway]
 
+migrate_test_gateway = migrate_module(
+    "gateway", as_microservices=False, additional_env_vars=TEST_ENV_VARS
+)
+prepare_venv >> migrate_test_gateway >> migrate_test
+
+
 # 🔐 Run/Migrate Auth ==========================================================
 
-run_auth = app_run_group.add_task(
-    run_microservice("auth", 3002, "auth"), alias="svc-auth"
-)
+run_auth = app_run_group.add_task(run_microservice("auth", 3002), alias="svc-auth")
 prepare_venv >> run_auth >> run_microservices
 
 create_auth_migration = app_create_migration_group.add_task(
-    create_migration("auth", "auth"), alias="auth"
+    create_migration("auth"), alias="auth"
 )
 prepare_venv >> create_auth_migration >> create_all_migration
 
-migrate_monolith_auth = migrate_module("auth", "auth", as_microservices=False)
+migrate_monolith_auth = migrate_module("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="svc-auth"
+    migrate_module("auth", as_microservices=True), alias="svc-auth"
 )
 prepare_venv >> migrate_microservices_auth >> [migrate_microservices, run_auth]
+
+migrate_test_auth = migrate_module(
+    "auth", as_microservices=False, additional_env_vars=TEST_ENV_VARS
+)
+prepare_venv >> migrate_test_auth >> migrate_test

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

@@ -0,0 +1,106 @@
+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_kebab_case, to_snake_case
+
+
+def create_migration(module: str) -> Task:
+    name = to_kebab_case(module)
+    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(
+    module: str, as_microservices: bool, additional_env_vars: dict[str, str] = {}
+) -> Task:
+    name = to_kebab_case(module)
+    env_vars = (
+        dict(MICROSERVICES_ENV_VARS) if as_microservices else dict(MONOLITH_ENV_VARS)
+    )
+    env_vars.update(additional_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(module: str, port: int) -> Task:
+    name = to_kebab_case(module)
+    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]