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/entity/template/app_template/module/my_module/service/my_entity/my_entity_service.py

@@ -0,0 +1,113 @@
+from logging import Logger
+
+from my_app_name.common.base_service import BaseService
+from my_app_name.module.my_module.service.my_entity.repository.my_entity_repository import (
+    MyEntityRepository,
+)
+from my_app_name.schema.my_entity import (
+    MultipleMyEntityResponse,
+    MyEntityCreateWithAudit,
+    MyEntityResponse,
+    MyEntityUpdateWithAudit,
+)
+
+
+class MyEntityService(BaseService):
+
+    def __init__(self, logger: Logger, my_entity_repository: MyEntityRepository):
+        super().__init__(logger)
+        self.my_entity_repository = my_entity_repository
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["get"],
+        response_model=MyEntityResponse,
+    )
+    async def get_my_entity_by_id(self, my_entity_id: str) -> MyEntityResponse:
+        return await self.my_entity_repository.get_by_id(my_entity_id)
+
+    @BaseService.route(
+        "/api/v1/my-entities",
+        methods=["get"],
+        response_model=MultipleMyEntityResponse,
+    )
+    async def get_my_entities(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleMyEntityResponse:
+        my_entities = await self.my_entity_repository.get(page, page_size, filter, sort)
+        count = await self.my_entity_repository.count(filter)
+        return MultipleMyEntityResponse(data=my_entities, count=count)
+
+    @BaseService.route(
+        "/api/v1/my-entities/bulk",
+        methods=["post"],
+        response_model=list[MyEntityResponse],
+    )
+    async def create_my_entity_bulk(
+        self, data: list[MyEntityCreateWithAudit]
+    ) -> list[MyEntityResponse]:
+        my_entities = await self.my_entity_repository.create_bulk(data)
+        return await self.my_entity_repository.get_by_ids(
+            [my_entity.id for my_entity in my_entities]
+        )
+
+    @BaseService.route(
+        "/api/v1/my-entities",
+        methods=["post"],
+        response_model=MyEntityResponse,
+    )
+    async def create_my_entity(self, data: MyEntityCreateWithAudit) -> MyEntityResponse:
+        my_entity = await self.my_entity_repository.create(data)
+        return await self.my_entity_repository.get_by_id(my_entity.id)
+
+    @BaseService.route(
+        "/api/v1/my-entities/bulk",
+        methods=["put"],
+        response_model=MyEntityResponse,
+    )
+    async def update_my_entity_bulk(
+        self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
+    ) -> MyEntityResponse:
+        my_entities = await self.my_entity_repository.update_bulk(my_entity_ids, data)
+        return await self.my_entity_repository.get_by_ids(
+            [my_entity.id for my_entity in my_entities]
+        )
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["put"],
+        response_model=MyEntityResponse,
+    )
+    async def update_my_entity(
+        self, my_entity_id: str, data: MyEntityUpdateWithAudit
+    ) -> MyEntityResponse:
+        my_entity = await self.my_entity_repository.update(my_entity_id, data)
+        return await self.my_entity_repository.get_by_id(my_entity.id)
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["delete"],
+        response_model=MyEntityResponse,
+    )
+    async def delete_my_entity_bulk(
+        self, my_entity_ids: list[str], deleted_by: str
+    ) -> MyEntityResponse:
+        my_entities = await self.my_entity_repository.delete_bulk(my_entity_ids)
+        return await self.my_entity_repository.get_by_ids(
+            [my_entity.id for my_entity in my_entities]
+        )
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["delete"],
+        response_model=MyEntityResponse,
+    )
+    async def delete_my_entity(
+        self, my_entity_id: str, deleted_by: str
+    ) -> MyEntityResponse:
+        my_entity = await self.my_entity_repository.delete(my_entity_id)
+        return await self.my_entity_repository.get_by_id(my_entity.id)

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

@@ -0,0 +1,9 @@
+from my_app_name.common.logger_factory import logger
+from my_app_name.module.my_module.service.my_entity.my_entity_service import (
+    MyEntityService,
+)
+from my_app_name.module.my_module.service.my_entity.repository.my_entity_repository_factory import (
+    my_entity_repository,
+)
+
+my_entity_service = MyEntityService(logger, my_entity_repository=my_entity_repository)

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

@@ -1,5 +1,4 @@
 from my_app_name.common.base_db_repository import BaseDBRepository
-from my_app_name.common.error import NotFoundError
 from my_app_name.module.my_module.service.my_entity.repository.my_entity_repository import (
     MyEntityRepository,
 )
@@ -10,15 +9,6 @@ from my_app_name.schema.my_entity import (
     MyEntityUpdateWithAudit,
 )
 from passlib.context import CryptContext
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import Session, select
-
-# Password hashing context
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-
-def hash_password(password: str) -> str:
-    return pwd_context.hash(password)
 
 
 class MyEntityDBRepository(

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

@@ -9,30 +9,51 @@ from my_app_name.schema.my_entity import (
 
 
 class MyEntityRepository(ABC):
+
+    @abstractmethod
+    async def get_by_id(self, id: str) -> MyEntityResponse:
+        """Get my entity by id"""
+
+    @abstractmethod
+    async def get_by_ids(self, id_list: list[str]) -> MyEntityResponse:
+        """Get my entities by ids"""
+
+    @abstractmethod
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[MyEntity]:
+        """Get my entities by filter and sort"""
+
+    @abstractmethod
+    async def count(self, filter: str | None = None) -> int:
+        """Count my entities by filter"""
+
     @abstractmethod
-    async def create(self, my_entity_data: MyEntityCreateWithAudit) -> MyEntityResponse:
-        pass
+    async def create(self, data: MyEntityCreateWithAudit) -> MyEntity:
+        """Create a new my entity"""
 
     @abstractmethod
-    async def get_by_id(self, my_entity_id: str) -> MyEntity:
-        pass
+    async def create_bulk(self, data: list[MyEntityCreateWithAudit]) -> list[MyEntity]:
+        """Create some my entities"""
 
     @abstractmethod
-    async def get_all(self) -> list[MyEntity]:
-        pass
+    async def delete(self, id: str) -> MyEntity:
+        """Delete a my entity"""
 
     @abstractmethod
-    async def update(
-        self, my_entity_id: str, my_entity_data: MyEntityUpdateWithAudit
-    ) -> MyEntity:
-        pass
+    async def delete_bulk(self, id_list: list[str]) -> list[MyEntity]:
+        """Delete some my entities"""
 
     @abstractmethod
-    async def delete(self, my_entity_id: str) -> MyEntity:
-        pass
+    async def update(self, id: str, data: MyEntityUpdateWithAudit) -> MyEntity:
+        """Update a my entity"""
 
     @abstractmethod
-    async def create_bulk(
-        self, my_entity_data_list: list[MyEntityCreateWithAudit]
-    ) -> list[MyEntityResponse]:
-        pass
+    async def update_bulk(
+        self, id_list: list[str], data: MyEntityUpdateWithAudit
+    ) -> list[MyEntity]:
+        """Update some my entities"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/repository/{factory.py → my_entity_repository_factory.py}

@@ -1,4 +1,4 @@
-from my_app_name.common.db_engine import engine
+from my_app_name.common.db_engine_factory import db_engine
 from my_app_name.config import APP_REPOSITORY_TYPE
 from my_app_name.module.my_module.service.my_entity.repository.my_entity_db_repository import (
     MyEntityDBRepository,
@@ -8,6 +8,6 @@ from my_app_name.module.my_module.service.my_entity.repository.my_entity_reposit
 )
 
 if APP_REPOSITORY_TYPE == "db":
-    my_entity_repository: MyEntityRepository = MyEntityDBRepository(engine)
+    my_entity_repository: MyEntityRepository = MyEntityDBRepository(db_engine)
 else:
     my_entity_repository: MyEntityRepository = None

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

@@ -1,6 +1,7 @@
 import datetime
 
 import ulid
+from pydantic import BaseModel
 from sqlmodel import Field, SQLModel
 
 
@@ -9,7 +10,8 @@ class MyEntityBase(SQLModel):
 
 
 class MyEntityCreate(MyEntityBase):
-    pass
+    def with_audit(self, created_by: str) -> "MyEntityCreateWithAudit":
+        return MyEntityCreateWithAudit(**self.model_dump(), created_by=created_by)
 
 
 class MyEntityCreateWithAudit(MyEntityCreate):
@@ -19,6 +21,9 @@ class MyEntityCreateWithAudit(MyEntityCreate):
 class MyEntityUpdate(SQLModel):
     my_column: str | None = None
 
+    def with_audit(self, updated_by: str) -> "MyEntityUpdateWithAudit":
+        return MyEntityUpdateWithAudit(**self.model_dump(), updated_by=updated_by)
+
 
 class MyEntityUpdateWithAudit(MyEntityUpdate):
     updated_by: str
@@ -28,10 +33,15 @@ class MyEntityResponse(MyEntityBase):
     id: str
 
 
+class MultipleMyEntityResponse(BaseModel):
+    data: list[MyEntityResponse]
+    count: int
+
+
 class MyEntity(SQLModel, table=True):
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
-    created_at: datetime.datetime
-    created_by: str
-    updated_at: datetime.datetime
-    updated_by: str
-    my_column: str
+    created_at: datetime.datetime = Field(index=True)
+    created_by: str = Field(index=True)
+    updated_at: datetime.datetime | None = Field(index=True)
+    updated_by: str | None = Field(index=True)
+    my_column: str = Field(index=True)

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

@@ -0,0 +1,57 @@
+# MyEntity related methods
+
+
+@abstractmethod
+async def get_my_entity_by_id(self, my_entity_id: str) -> MyEntityResponse:
+    """Get my entity by id"""
+
+
+@abstractmethod
+async def get_my_entities(
+    self,
+    page: int = 1,
+    page_size: int = 10,
+    sort: str | None = None,
+    filter: str | None = None,
+) -> MultipleMyEntityResponse:
+    """Get my entities by filter and sort"""
+
+
+@abstractmethod
+async def create_my_entity(self, data: MyEntityCreateWithAudit) -> MyEntityResponse:
+    """Create a new my entities"""
+
+
+@abstractmethod
+async def create_my_entity(
+    self, data: list[MyEntityCreateWithAudit]
+) -> list[MyEntityResponse]:
+    """Create new my entities"""
+
+
+@abstractmethod
+async def update_my_entity_bulk(
+    self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
+) -> MyEntityResponse:
+    """Update some my entities"""
+
+
+@abstractmethod
+async def update_my_entity(
+    self, my_entity_id: str, data: MyEntityUpdateWithAudit
+) -> MyEntityResponse:
+    """Update a my entity"""
+
+
+@abstractmethod
+async def delete_my_entity_bulk(
+    self, my_entity_ids: str, deleted_by: str
+) -> MyEntityResponse:
+    """Delete some my entities"""
+
+
+@abstractmethod
+async def delete_my_entity(
+    self, my_entity_id: str, deleted_by: str
+) -> MyEntityResponse:
+    """Delete a my entity"""

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

@@ -0,0 +1,72 @@
+# MyEntity routes
+
+
+@app.get("/api/v1/my-entities", response_model=MultipleMyEntityResponse)
+async def get_my_entities(
+    page: int = 1,
+    page_size: int = 10,
+    sort: str | None = None,
+    filter: str | None = None,
+) -> MultipleMyEntityResponse:
+    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:
+    return await my_module_client.get_my_entity_by_id(my_entity_id)
+
+
+@app.post(
+    "/api/v1/my-entities/bulk",
+    response_model=list[MyEntityResponse],
+)
+async def create_my_entity_bulk(data: list[MyEntityCreate]):
+    return await my_module_client.create_my_entity_bulk(
+        [row.with_audit(created_by="system") for row in data]
+    )
+
+
+@app.post(
+    "/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"))
+
+
+@app.put(
+    "/api/v1/my-entities/bulk",
+    response_model=list[MyEntityResponse],
+)
+async def update_my_entity_bulk(my_entity_ids: list[str], data: MyEntityUpdate):
+    return await my_module_client.update_my_entity_bulk(
+        my_entity_ids, data.with_audit(updated_by="system")
+    )
+
+
+@app.put(
+    "/api/v1/my-entities/{my_entity_id}",
+    response_model=MyEntityResponse,
+)
+async def update_my_entity(my_entity_id: str, data: MyEntityUpdate):
+    return await my_module_client.update_my_entity(data.with_audit(updated_by="system"))
+
+
+@app.delete(
+    "/api/v1/my-entities/bulk",
+    response_model=list[MyEntityResponse],
+)
+async def delete_my_entity_bulk(my_entity_ids: list[str]):
+    return await my_module_client.delete_my_entity_bulk(
+        my_entity_ids, deleted_by="system"
+    )
+
+
+@app.delete(
+    "/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")

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

@@ -6,7 +6,7 @@ from zrb.task.cmd_task import CmdTask
 format_my_app_name_code = app_group.add_task(
     CmdTask(
         name="format-my-app-name-code",
-        description="✏️ Format Python code",
+        description="✨ Format Python code",
         cmd=[
             "isort . --profile black --force-grid-wrap 0",
             "black .",

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

@@ -38,3 +38,16 @@ new_entity_column_input = StrInput(
     prompt="New entity's column name",
     default_str="name",
 )
+
+new_column_input = StrInput(
+    name="column",
+    description="Column name",
+    prompt="New column name",
+)
+
+new_column_type_input = OptionInput(
+    name="type",
+    description="Column type",
+    prompt="Column type",
+    options=["str", "int", "float", "bool", "datetime", "date"],
+)

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

@@ -9,11 +9,14 @@ from my_app_name._zrb.module.add_module_util import (
     is_app_main_file,
     is_app_zrb_config_file,
     is_app_zrb_task_file,
+    is_gateway_module_subroute_file,
+    is_gateway_route_file,
     is_in_module_dir,
     update_app_config_file,
     update_app_main_file,
     update_app_zrb_config_file,
     update_app_zrb_task_file,
+    update_gateway_route_file,
 )
 from my_app_name._zrb.util import get_existing_module_names
 
@@ -42,32 +45,52 @@ scaffold_my_app_name_module = Scaffolder(
     transform_content=[
         # Common transformation (my_app_name/module/snake_module_name)
         ContentTransformer(
+            name="transform-module-dir",
             match=is_in_module_dir,
             transform={
                 "MY_MODULE": "{to_snake_case(ctx.input.module).upper()}",
                 "my_module": "{to_snake_case(ctx.input.module)}",
+                "MyModule": "{to_pascal_case(ctx.input.module)}",
+            },
+        ),
+        # Gateway's module subroute (my_app_name/module/gateway/subroute/snake_module_name.py)
+        ContentTransformer(
+            name="transform-gateway-subroute",
+            match=is_gateway_module_subroute_file,
+            transform={
+                "my_module": "{to_snake_case(ctx.input.module)}",
             },
         ),
         # Register module config to my_app_name/config.py
         ContentTransformer(
+            name="transform-app-config",
             match=is_app_config_file,
             transform=update_app_config_file,
         ),
         # Register module route to my_app_name/main.py
         ContentTransformer(
+            name="transform-app-main",
             match=is_app_main_file,
             transform=update_app_main_file,
         ),
         # Register module's tasks to my_app_name/_zrb/task.py
         ContentTransformer(
+            name="transform-zrb-task",
             match=is_app_zrb_task_file,
             transform=update_app_zrb_task_file,
         ),
         # Register module's base url to my_app_name/_zrb/config.py
         ContentTransformer(
+            name="transform-zrb-config",
             match=is_app_zrb_config_file,
             transform=update_app_zrb_config_file,
         ),
+        # Register module's subroute to my_app_name/gateway/route.py
+        ContentTransformer(
+            name="transform-gateway-route",
+            match=is_gateway_route_file,
+            transform=update_gateway_route_file,
+        ),
     ],
     retries=0,
     upstream=validate_create_my_app_name_module,

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

@@ -4,6 +4,7 @@ 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.file import read_file, write_file
 from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
@@ -17,6 +18,10 @@ def is_app_main_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == os.path.join(APP_DIR, "main.py")
 
 
+def is_gateway_route_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(APP_DIR, "module", "gateway", "route.py")
+
+
 def is_app_zrb_task_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == os.path.join(APP_DIR, "_zrb", "task.py")
 
@@ -31,6 +36,13 @@ def is_in_module_dir(ctx: AnyContext, file_path: str) -> bool:
     )
 
 
+def is_gateway_module_subroute_file(ctx: AnyContext, file_path: str) -> bool:
+    module_subroute_file_name = f"{to_snake_case(ctx.input.module)}.py"
+    return file_path == os.path.join(
+        APP_DIR, "module", "gateway", "subroute", module_subroute_file_name
+    )
+
+
 def update_app_zrb_config_file(ctx: AnyContext, zrb_config_file_path: str):
     existing_zrb_config_code = read_file(zrb_config_file_path)
     module_name = ctx.input.module
@@ -152,3 +164,33 @@ def _get_new_module_config_code(existing_code: str, module_name: str) -> str | N
     if config_code in existing_code:
         return None
     return config_code
+
+
+def update_gateway_route_file(ctx: AnyContext, gateway_route_file_path: str):
+    existing_gateway_route_code = read_file(gateway_route_file_path)
+    snake_module_name = to_snake_case(ctx.input.module)
+    write_file(
+        file_path=gateway_route_file_path,
+        content=[
+            _get_module_subroute_import(existing_gateway_route_code, ctx.input.module),
+            append_code_to_function(
+                original_code=existing_gateway_route_code,
+                function_name="serve_route",
+                new_code="\n".join(
+                    [
+                        f"# Serve {snake_module_name} route",
+                        f"serve_{snake_module_name}_route(app)",
+                    ]
+                ),
+            ),
+        ],
+    )
+
+
+def _get_module_subroute_import(existing_code: str, module_name: str) -> str | None:
+    snake_module_name = to_snake_case(module_name)
+    import_module_path = f"my_app_name.module.gateway.subroute.{snake_module_name}"
+    import_code = f"from {import_module_path} import serve_{snake_module_name}_route"
+    if import_code in existing_code:
+        return None
+    return import_code

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

@@ -0,0 +1,7 @@
+from fastapi import FastAPI
+
+
+def serve_my_module_route(app: FastAPI):
+    """
+    Serving routes for my_module
+    """

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/my_module/client/my_module_api_client.py

@@ -0,0 +1,6 @@
+from my_app_name.config import APP_MY_MODULE_BASE_URL
+from my_app_name.module.my_module.client.my_module_client import MyModuleClient
+
+
+class MyModuleAPIClient(MyModuleClient):
+    pass

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/my_module/client/{any_client.py → my_module_client.py}

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 
 
-class AnyClient(ABC):
+class MyModuleClient(ABC):
     """
     Defining client methods
     """

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/my_module/client/my_module_client_factory.py

@@ -0,0 +1,11 @@
+from my_app_name.config import APP_COMMUNICATION
+from my_app_name.module.my_module.client.my_module_api_client import MyModuleAPIClient
+from my_app_name.module.my_module.client.my_module_client import MyModuleClient
+from my_app_name.module.my_module.client.my_module_direct_client import (
+    MyModuleDirectClient,
+)
+
+if APP_COMMUNICATION == "direct":
+    my_module_client: MyModuleClient = MyModuleDirectClient()
+elif APP_COMMUNICATION == "api":
+    my_module_client: MyModuleClient = MyModuleAPIClient()

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/my_module/client/my_module_direct_client.py

@@ -0,0 +1,5 @@
+from my_app_name.module.my_module.client.my_module_client import MyModuleClient
+
+
+class MyModuleDirectClient(MyModuleClient):
+    pass

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

@@ -1,10 +1,18 @@
 from fastapi import FastAPI
-from my_app_name.common.app import app
+from my_app_name.common.app_factory import app
 from my_app_name.common.schema import BasicResponse
 from my_app_name.config import APP_MAIN_MODULE, APP_MODE, APP_MODULES
 
 
-def serve_health_check(app: FastAPI):
+def serve_route(app: FastAPI):
+    if APP_MODE != "microservices" or "my_module" not in APP_MODULES:
+        return
+    if APP_MAIN_MODULE == "my_module":
+        _serve_health_check(app)
+        _serve_readiness_check(app)
+
+
+def _serve_health_check(app: FastAPI):
     @app.api_route("/health", methods=["GET", "HEAD"], response_model=BasicResponse)
     async def health():
         """
@@ -13,7 +21,7 @@ def serve_health_check(app: FastAPI):
         return BasicResponse(message="ok")
 
 
-def serve_readiness_check(app: FastAPI):
+def _serve_readiness_check(app: FastAPI):
     @app.api_route("/readiness", methods=["GET", "HEAD"], response_model=BasicResponse)
     async def readiness():
         """
@@ -22,12 +30,4 @@ def serve_readiness_check(app: FastAPI):
         return BasicResponse(message="ok")
 
 
-def serve_route(app: FastAPI):
-    if APP_MODE != "microservices" or "my_module" not in APP_MODULES:
-        return
-    if APP_MAIN_MODULE == "my_module":
-        serve_health_check(app)
-        serve_readiness_check(app)
-
-
 serve_route(app)