zrb 1.0.0a20__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

zrb/__init__.py

@@ -34,7 +34,8 @@ from zrb.input.password_input import PasswordInput
 from zrb.input.str_input import StrInput
 from zrb.input.text_input import TextInput
 from zrb.runner.cli import cli
-from zrb.runner.web_config import User, web_config
+from zrb.runner.web_config.config_factory import web_config
+from zrb.runner.web_schema.user import User
 from zrb.session.session import Session
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask

zrb/builtin/llm/llm_chat.py

@@ -1,6 +1,6 @@
 from zrb.builtin.group import llm_group
 from zrb.builtin.llm.tool.cli import run_shell_command
-from zrb.builtin.llm.tool.web import open_web_page, query_internet
+from zrb.builtin.llm.tool.web import open_web_route, query_internet
 from zrb.config import (
     LLM_ALLOW_ACCESS_SHELL,
     LLM_ALLOW_ACCESS_WEB,
@@ -43,5 +43,5 @@ if LLM_ALLOW_ACCESS_SHELL:
     llm_chat.add_tool(run_shell_command)
 
 if LLM_ALLOW_ACCESS_WEB:
-    llm_chat.add_tool(open_web_page)
+    llm_chat.add_tool(open_web_route)
     llm_chat.add_tool(query_internet)

zrb/builtin/llm/tool/web.py

@@ -2,7 +2,7 @@ import json
 from typing import Annotated
 
 
-def open_web_page(url: str) -> str:
+def open_web_route(url: str) -> str:
     """Get content from a web page."""
     import requests
 

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

@@ -49,6 +49,7 @@ scaffold_fastapp = Scaffolder(
     transform_content=[
         # Common transformation (project_dir/app_dir/**/*)
         ContentTransformer(
+            name="transform-app-dir",
             match=is_in_project_app_dir,
             transform={
                 "My App Name": "{ctx.input.app.title()}",
@@ -60,6 +61,7 @@ scaffold_fastapp = Scaffolder(
         ),
         # Register fastapp's tasks to project's zrb_init (project_dir/zrb_init.py)
         ContentTransformer(
+            name="trasnform-zrb-init",
             match=is_project_zrb_init_file,
             transform=update_project_zrb_init_file,
         ),

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

@@ -9,7 +9,10 @@ MICROSERVICES_ENV_VARS = {
     "MY_APP_NAME_MODE": "microservices",
     "MY_APP_NAME_AUTH_BASE_URL": "http://localhost:3002",
 }
-MONOLITH_ENV_VARS = {"MY_APP_NAME_MODE": "monolith"}
+MONOLITH_ENV_VARS = {
+    "MY_APP_NAME_MODE": "monolith",
+    "MY_APP_NAME_MODULES": "",
+}
 
 if platform.system() == "Windows":
     ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\\Scripts\\Activate"  # noqa

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

@@ -7,11 +7,13 @@ from my_app_name._zrb.entity.add_entity_util import (
     is_module_any_client_file,
     is_module_api_client_file,
     is_module_direct_client_file,
+    is_module_gateway_subroute_file,
     is_module_migration_metadata_file,
     is_module_route_file,
     update_any_client,
     update_api_client,
     update_direct_client,
+    update_gateway_subroute,
     update_migration_metadata,
     update_route,
 )
@@ -66,6 +68,7 @@ scaffold_my_app_name_entity = Scaffolder(
     transform_content=[
         # Schema tranformation (my_app_name/schema/snake_entity_name)
         ContentTransformer(
+            name="transform-schema-file",
             match=is_in_app_schema_dir,
             transform={
                 "MyEntity": "{to_pascal_case(ctx.input.entity)}",
@@ -75,6 +78,7 @@ scaffold_my_app_name_entity = Scaffolder(
         # Common module's entity transformation
         # (my_app_name/module/snake_module_name/service/snake_entity_name)
         ContentTransformer(
+            name="transform-module-entity-dir",
             match=is_in_module_entity_dir,
             transform={
                 "my_module": "{to_snake_case(ctx.input.module)}",
@@ -87,30 +91,41 @@ scaffold_my_app_name_entity = Scaffolder(
         # Add entity to migration metadata
         # (my_app_name/module/snake_module_name/migration_metadata.py)
         ContentTransformer(
+            name="transform-module-migration-metadata",
             match=is_module_migration_metadata_file,
             transform=update_migration_metadata,
         ),
         # Update API Client (my_app_name/module/snake_module_name/client/api_client.py)
         ContentTransformer(
+            name="transform-module-api-client",
             match=is_module_api_client_file,
             transform=update_api_client,
         ),
         # Update Direct Client (my_app_name/module/snake_module_name/client/direct_client.py)
         ContentTransformer(
+            name="transform-module-direct-client",
             match=is_module_direct_client_file,
             transform=update_direct_client,
         ),
         # Update Any Client (my_app_name/module/snake_module_name/client/any_client.py)
         ContentTransformer(
+            name="transform-module-any-client",
             match=is_module_any_client_file,
             transform=update_any_client,
         ),
         # Update module route (my_app_name/module/route.py)
         ContentTransformer(
+            name="transform-module-route",
             match=is_module_route_file,
             transform=update_route,
         ),
-        # TODO: Register gateway route
+        # Update module gateway subroute
+        # (my_app_name/module/gateway/subroute/snake_module_name.py)
+        ContentTransformer(
+            name="transform-module-gateway-subroute",
+            match=is_module_gateway_subroute_file,
+            transform=update_gateway_subroute,
+        ),
     ],
     retries=0,
     upstream=validate_create_my_app_name_entity,

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

@@ -82,6 +82,17 @@ def is_module_direct_client_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == module_direct_client_file
 
 
+def is_module_gateway_subroute_file(ctx: AnyContext, file_path: str) -> bool:
+    module_gateway_subroute_file = os.path.join(
+        APP_DIR,
+        "module",
+        "gateway",
+        "subroute",
+        f"{to_snake_case(ctx.input.module)}.py",
+    )
+    return file_path == module_gateway_subroute_file
+
+
 def update_migration_metadata(ctx: AnyContext, migration_metadata_file_path: str):
     app_name = os.path.basename(APP_DIR)
     existing_migration_metadata_code = read_file(migration_metadata_file_path)
@@ -148,7 +159,7 @@ def update_any_client(ctx: AnyContext, any_client_file_path: str):
     write_file(
         file_path=any_client_file_path,
         content=[
-            f"from {app_name}.schema.{snake_entity_name}.{snake_entity_name} import (",
+            f"from {app_name}.schema.{snake_entity_name} import (",
             f"    {pascal_entity_name}CreateWithAudit, {pascal_entity_name}Response, {pascal_entity_name}UpdateWithAudit",  # noqa
             ")",
             new_code.strip(),
@@ -165,12 +176,14 @@ def update_api_client(ctx: AnyContext, api_client_file_path: str):
     write_file(
         file_path=api_client_file_path,
         content=[
-            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_usecase import {snake_entity_name}_usecase",  # noqa
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_service_factory import {snake_entity_name}_service",  # noqa
             prepend_code_to_module(
                 prepend_parent_class(
-                    existing_api_client_code, "APIClient", "user_api_client"
+                    original_code=existing_api_client_code,
+                    class_name="APIClient",
+                    parent_class_name=f"{snake_entity_name}_api_client",
                 ),
-                f"user_api_client = user_usecase.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
+                f"{snake_entity_name}_api_client = {snake_entity_name}_service.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
             ),
         ],
     )
@@ -184,12 +197,14 @@ def update_direct_client(ctx: AnyContext, direct_client_file_path: str):
     write_file(
         file_path=direct_client_file_path,
         content=[
-            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_usecase import {snake_entity_name}_usecase",  # noqa
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_service_factory import {snake_entity_name}_service",  # noqa
             prepend_code_to_module(
                 prepend_parent_class(
-                    existing_direct_client_code, "DirectClient", "user_direct_client"
+                    original_code=existing_direct_client_code,
+                    class_name="DirectClient",
+                    parent_class_name=f"{snake_entity_name}_direct_client",
                 ),
-                "user_direct_client = user_usecase.as_direct_client()",
+                f"{snake_entity_name}_direct_client = {snake_entity_name}_service.as_direct_client()",  # noqa
             ).strip(),
         ],
     )
@@ -203,11 +218,78 @@ def update_route(ctx: AnyContext, route_file_path: str):
     write_file(
         file_path=route_file_path,
         content=[
-            f"from {app_name}.module.{module_name}.service.{entity_name}.{entity_name}_usecase import {entity_name}_usecase",  # noqa
+            f"from {app_name}.module.{module_name}.service.{entity_name}.{entity_name}_service_factory import {entity_name}_service",  # noqa
             append_code_to_function(
                 existing_route_code,
                 "serve_route",
-                f"{entity_name}_usecase.serve_route(app)",
+                f"{entity_name}_service.serve_route(app)",
             ),
         ],
     )
+
+
+def update_gateway_subroute(ctx: AnyContext, module_gateway_subroute_path: str):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    snake_plural_entity_name = to_snake_case(ctx.input.plural)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    existing_gateway_subroute_code = read_file(module_gateway_subroute_path)
+    write_file(
+        file_path=module_gateway_subroute_path,
+        content=[
+            _get_import_client_for_gateway_subroute_code(
+                existing_gateway_subroute_code, module_name=ctx.input.module
+            ),
+            _get_import_schema_for_gateway_subroute_code(
+                existing_gateway_subroute_code, entity_name=ctx.input.entity
+            ),
+            append_code_to_function(
+                original_code=existing_gateway_subroute_code,
+                function_name=f"serve_{snake_module_name}_route",
+                new_code=read_file(
+                    file_path=os.path.join(
+                        os.path.dirname(__file__), "template", "gateway_subroute.py"
+                    ),
+                    replace_map={
+                        "my_module": snake_module_name,
+                        "my_entity": snake_entity_name,
+                        "my_entities": snake_plural_entity_name,
+                        "MyEntity": pascal_entity_name,
+                    },
+                ),
+            ),
+        ],
+    )
+
+
+def _get_import_client_for_gateway_subroute_code(
+    existing_code: str, module_name: str
+) -> str | None:
+    snake_module_name = to_snake_case(module_name)
+    client_import_path = f"my_app_name.module.{snake_module_name}.client.factory"
+    new_code = f"from {client_import_path} import client as {snake_module_name}_client"
+    if new_code in existing_code:
+        return None
+    return new_code
+
+
+def _get_import_schema_for_gateway_subroute_code(
+    existing_code: str, entity_name: str
+) -> str | None:
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    schema_import_path = f"my_app_name.schema.{snake_entity_name}"
+    new_code = "\n".join(
+        [
+            f"from {schema_import_path} import (",
+            f"   {pascal_entity_name}Create,",
+            f"   {pascal_entity_name}CreateWithAudit,",
+            f"   {pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Update,",
+            f"   {pascal_entity_name}UpdateWithAudit,",
+            ")",
+        ]
+    )
+    if new_code in existing_code:
+        return None
+    return new_code

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

@@ -1,7 +1,4 @@
-from my_app_name.common.base_usecase import BaseUsecase
-from my_app_name.module.my_module.service.my_entity.repository.factory import (
-    my_entity_repository,
-)
+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,
 )
@@ -12,12 +9,12 @@ from my_app_name.schema.my_entity import (
 )
 
 
-class MyEntityUsecase(BaseUsecase):
+class MyEntityService(BaseService):
     def __init__(self, my_entity_repository: MyEntityRepository):
         super().__init__()
         self.my_entity_repository = my_entity_repository
 
-    @BaseUsecase.route(
+    @BaseService.route(
         "/api/v1/my-entities/{my_entity_id}",
         methods=["get"],
         response_model=MyEntityResponse,
@@ -25,13 +22,13 @@ class MyEntityUsecase(BaseUsecase):
     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)
 
-    @BaseUsecase.route(
+    @BaseService.route(
         "/api/v1/my-entities", methods=["get"], response_model=list[MyEntityResponse]
     )
     async def get_all_my_entities(self) -> list[MyEntityResponse]:
         return await self.my_entity_repository.get_all()
 
-    @BaseUsecase.route(
+    @BaseService.route(
         "/api/v1/my-entities",
         methods=["post"],
         response_model=MyEntityResponse | list[MyEntityResponse],
@@ -43,7 +40,7 @@ class MyEntityUsecase(BaseUsecase):
             return await self.my_entity_repository.create(data)
         return await self.my_entity_repository.create_bulk(data)
 
-    @BaseUsecase.route(
+    @BaseService.route(
         "/api/v1/my-entities/{my_entity_id}",
         methods=["put"],
         response_model=MyEntityResponse,
@@ -53,13 +50,10 @@ class MyEntityUsecase(BaseUsecase):
     ) -> MyEntityResponse:
         return await self.my_entity_repository.update(my_entity_id, data)
 
-    @BaseUsecase.route(
+    @BaseService.route(
         "/api/v1/my-entities/{my_entity_id}",
         methods=["delete"],
         response_model=MyEntityResponse,
     )
     async def delete_my_entity(self, my_entity_id: str) -> MyEntityResponse:
         return await self.my_entity_repository.delete(my_entity_id)
-
-
-my_entity_usecase = MyEntityUsecase(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/my_entity_service_factory.py

@@ -0,0 +1,8 @@
+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(my_entity_repository=my_entity_repository)

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

@@ -0,0 +1,37 @@
+@app.get("/api/v1/my_entities", response_model=list[MyEntityResponse])
+async def get_all_my_entities() -> MyEntityResponse:
+    return await my_module_client.get_all_my_entities()
+
+
+@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", response_model=MyEntityResponse | list[MyEntityResponse]
+)
+async def create_my_entity(data: MyEntityCreate | list[MyEntityCreate]):
+    if isinstance(data, MyEntityCreate):
+        data_dict = data.model_dump(exclude_unset=True)
+        audited_data = MyEntityCreateWithAudit(**data_dict, created_by="system")
+        return await my_module_client.create_my_entity(audited_data)
+    audited_data = [
+        MyEntityCreateWithAudit(
+            **row.model_dump(exclude_unset=True), created_by="system"
+        )
+        for row in data
+    ]
+    return await my_module_client.create_my_entity(audited_data)
+
+
+@app.put("/api/v1/my_entities/{my_entity_id}", response_model=MyEntityResponse)
+async def update_my_entity(my_entity_id: str, data: MyEntityUpdate) -> MyEntityResponse:
+    data_dict = data.model_dump(exclude_unset=True)
+    audited_data = MyEntityUpdateWithAudit(**data_dict, updated_by="system")
+    return await my_module_client.update_my_entity(my_entity_id, audited_data)
+
+
+@app.delete("/api/v1/my_entities/{my_entity_id}", response_model=MyEntityResponse)
+async def delete_my_entity(my_entity_id: str) -> MyEntityResponse:
+    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,51 @@ 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)}",
             },
         ),
+        # 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/api_client.py

@@ -1,5 +1,5 @@
 from my_app_name.config import APP_MY_MODULE_BASE_URL
-from my_app_name.module.module_template.client.any_client import AnyClient
+from my_app_name.module.my_module.client.any_client import AnyClient
 
 
 class APIClient(AnyClient):

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

@@ -1,5 +1,4 @@
-from my_app_name.module.module_template.client.any_client import AnyClient
-from my_app_name.module.module_template.service.user.usecase import user_usecase
+from my_app_name.module.my_module.client.any_client import AnyClient
 
 
 class DirectClient(AnyClient):

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

@@ -1,7 +1,7 @@
 from my_app_name.config import APP_COMMUNICATION
-from my_app_name.module.module_template.client.any_client import AnyClient
-from my_app_name.module.module_template.client.api_client import APIClient
-from my_app_name.module.module_template.client.direct_client import DirectClient
+from my_app_name.module.my_module.client.any_client import AnyClient
+from my_app_name.module.my_module.client.api_client import APIClient
+from my_app_name.module.my_module.client.direct_client import DirectClient
 
 if APP_COMMUNICATION == "direct":
     client: AnyClient = DirectClient()

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

@@ -4,7 +4,15 @@ 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)

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=[