zrb 1.0.0a16__py3-none-any.whl → 1.0.0a20__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/repository/factory.py

@@ -0,0 +1,13 @@
+from my_app_name.common.db_engine import 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,
+)
+from my_app_name.module.my_module.service.my_entity.repository.my_entity_repository import (
+    MyEntityRepository,
+)
+
+if APP_REPOSITORY_TYPE == "db":
+    my_entity_repository: MyEntityRepository = MyEntityDBRepository(engine)
+else:
+    my_entity_repository: MyEntityRepository = None

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

@@ -1,13 +1,13 @@
-from fastapp_template.common.base_db_repository import BaseDBRepository
-from fastapp_template.common.error import NotFoundError
-from fastapp_template.module.my_module.service.my_entity.repository.my_entity_repository import (
+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,
 )
-from fastapp_template.schema.my_entity import (
+from my_app_name.schema.my_entity import (
     MyEntity,
-    MyEntityCreate,
+    MyEntityCreateWithAudit,
     MyEntityResponse,
-    MyEntityUpdate,
+    MyEntityUpdateWithAudit,
 )
 from passlib.context import CryptContext
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -22,12 +22,17 @@ def hash_password(password: str) -> str:
 
 
 class MyEntityDBRepository(
-    BaseDBRepository[MyEntity, MyEntityResponse, MyEntityCreate, MyEntityUpdate],
+    BaseDBRepository[
+        MyEntity,
+        MyEntityResponse,
+        MyEntityCreateWithAudit,
+        MyEntityUpdateWithAudit,
+    ],
     MyEntityRepository,
 ):
     db_model = MyEntity
     response_model = MyEntityResponse
-    create_model = MyEntityCreate
-    update_model = MyEntityUpdate
+    create_model = MyEntityCreateWithAudit
+    update_model = MyEntityUpdateWithAudit
     entity_name = "my_entity"
     column_preprocessors = {}

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

@@ -1,17 +1,16 @@
 from abc import ABC, abstractmethod
 
-from fastapp_template.schema.my_entity import (
+from my_app_name.schema.my_entity import (
     MyEntity,
-    MyEntityCreate,
+    MyEntityCreateWithAudit,
     MyEntityResponse,
-    MyEntityUpdate,
+    MyEntityUpdateWithAudit,
 )
 
 
 class MyEntityRepository(ABC):
-
     @abstractmethod
-    async def create(self, my_entity_data: MyEntityCreate) -> MyEntityResponse:
+    async def create(self, my_entity_data: MyEntityCreateWithAudit) -> MyEntityResponse:
         pass
 
     @abstractmethod
@@ -24,7 +23,7 @@ class MyEntityRepository(ABC):
 
     @abstractmethod
     async def update(
-        self, my_entity_id: str, my_entity_data: MyEntityUpdate
+        self, my_entity_id: str, my_entity_data: MyEntityUpdateWithAudit
     ) -> MyEntity:
         pass
 
@@ -34,6 +33,6 @@ class MyEntityRepository(ABC):
 
     @abstractmethod
     async def create_bulk(
-        self, my_entity_data_list: list[MyEntityCreate]
+        self, my_entity_data_list: list[MyEntityCreateWithAudit]
     ) -> list[MyEntityResponse]:
         pass

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

@@ -12,10 +12,18 @@ class MyEntityCreate(MyEntityBase):
     pass
 
 
+class MyEntityCreateWithAudit(MyEntityCreate):
+    created_by: str
+
+
 class MyEntityUpdate(SQLModel):
     my_column: str | None = None
 
 
+class MyEntityUpdateWithAudit(MyEntityUpdate):
+    updated_by: str
+
+
 class MyEntityResponse(MyEntityBase):
     id: str
 

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

@@ -0,0 +1,17 @@
+from my_app_name._zrb.config import APP_DIR
+from my_app_name._zrb.group import app_group
+
+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",
+        cmd=[
+            "isort . --profile black --force-grid-wrap 0",
+            "black .",
+        ],
+        cwd=APP_DIR,
+    ),
+    alias="format",
+)

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

@@ -1,7 +1,4 @@
-from fastapp_template._zrb.helper import (
-    get_existing_module_names,
-    get_existing_schema_names,
-)
+from my_app_name._zrb.util import get_existing_module_names, get_existing_schema_names
 
 from zrb import OptionInput, StrInput
 from zrb.util.string.conversion import pluralize

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

@@ -0,0 +1,85 @@
+import os
+
+from my_app_name._zrb.config import APP_DIR
+from my_app_name._zrb.format_task import format_my_app_name_code
+from my_app_name._zrb.group import app_create_group
+from my_app_name._zrb.input import new_module_input
+from my_app_name._zrb.module.add_module_util import (
+    is_app_config_file,
+    is_app_main_file,
+    is_app_zrb_config_file,
+    is_app_zrb_task_file,
+    is_in_module_dir,
+    update_app_config_file,
+    update_app_main_file,
+    update_app_zrb_config_file,
+    update_app_zrb_task_file,
+)
+from my_app_name._zrb.util import get_existing_module_names
+
+from zrb import AnyContext, ContentTransformer, Scaffolder, Task, make_task
+
+
+@make_task(
+    name="validate-create-my-app-name-module",
+    input=new_module_input,
+    retries=0,
+)
+async def validate_create_my_app_name_module(ctx: AnyContext):
+    if ctx.input.module in get_existing_module_names():
+        raise ValueError(f"Module already exists: {ctx.input.module}")
+
+
+scaffold_my_app_name_module = Scaffolder(
+    name="scaffold-my-app-name-module",
+    input=new_module_input,
+    source_path=os.path.join(os.path.dirname(__file__), "template", "app_template"),
+    render_source_path=False,
+    destination_path=APP_DIR,
+    transform_path={
+        "my_module": "{to_snake_case(ctx.input.module)}",
+    },
+    transform_content=[
+        # Common transformation (my_app_name/module/snake_module_name)
+        ContentTransformer(
+            match=is_in_module_dir,
+            transform={
+                "MY_MODULE": "{to_snake_case(ctx.input.module).upper()}",
+                "my_module": "{to_snake_case(ctx.input.module)}",
+            },
+        ),
+        # Register module config to my_app_name/config.py
+        ContentTransformer(
+            match=is_app_config_file,
+            transform=update_app_config_file,
+        ),
+        # Register module route to my_app_name/main.py
+        ContentTransformer(
+            match=is_app_main_file,
+            transform=update_app_main_file,
+        ),
+        # Register module's tasks to my_app_name/_zrb/task.py
+        ContentTransformer(
+            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(
+            match=is_app_zrb_config_file,
+            transform=update_app_zrb_config_file,
+        ),
+    ],
+    retries=0,
+    upstream=validate_create_my_app_name_module,
+)
+
+add_my_app_name_module = app_create_group.add_task(
+    Task(
+        name="add-my-app-name-module",
+        description="🧩 Create new module on My App Name",
+        upstream=scaffold_my_app_name_module,
+        successor=format_my_app_name_code,
+        retries=0,
+    ),
+    alias="module",
+)

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

@@ -0,0 +1,154 @@
+import os
+
+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_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
+
+
+def is_app_config_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(APP_DIR, "config.py")
+
+
+def is_app_main_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(APP_DIR, "main.py")
+
+
+def is_app_zrb_task_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(APP_DIR, "_zrb", "task.py")
+
+
+def is_app_zrb_config_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(APP_DIR, "_zrb", "config.py")
+
+
+def is_in_module_dir(ctx: AnyContext, file_path: str) -> bool:
+    return file_path.startswith(
+        os.path.join(APP_DIR, "module", to_snake_case(ctx.input.module))
+    )
+
+
+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
+    upper_snake_module_name = to_snake_case(module_name).upper()
+    existing_module_names = get_existing_module_names()
+    module_port = 3001 + len(
+        [
+            existing_module_name
+            for existing_module_name in existing_module_names
+            if existing_module_name != to_snake_case(module_name)
+        ]
+    )
+    write_file(
+        file_path=zrb_config_file_path,
+        content=append_key_to_dict(
+            original_code=existing_zrb_config_code,
+            dictionary_name="MICROSERVICES_ENV_VARS",
+            new_key=f"MY_APP_NAME_{upper_snake_module_name}_BASE_URL",
+            new_value=f"http://localhost:{module_port}",
+        ),
+    )
+
+
+def update_app_zrb_task_file(ctx: AnyContext, zrb_task_file_path: str):
+    existing_zrb_task_code = read_file(zrb_task_file_path)
+    write_file(
+        file_path=zrb_task_file_path,
+        content=[
+            existing_zrb_task_code.strip(),
+            "",
+            _get_task_definition_code(existing_zrb_task_code, ctx.input.module),
+        ],
+    )
+
+
+def _get_task_definition_code(existing_code: str, module_name: str) -> str | None:
+    existing_module_names = get_existing_module_names()
+    module_port = 3001 + len(
+        [
+            existing_module_name
+            for existing_module_name in existing_module_names
+            if existing_module_name != to_snake_case(module_name)
+        ]
+    )
+    snake_module_name = to_snake_case(module_name)
+    kebab_module_name = to_kebab_case(module_name)
+    pascal_module_name = to_pascal_case(module_name)
+    task_definition_code = read_file(
+        file_path=os.path.join(
+            os.path.dirname(__file__), "template", "module_task_definition.py"
+        ),
+        replace_map={
+            "my_module": snake_module_name,
+            "my-module": kebab_module_name,
+            "My Module": pascal_module_name,
+            "3000": f"{module_port}",
+        },
+    ).strip()
+    if task_definition_code in existing_code:
+        return None
+    return task_definition_code
+
+
+def update_app_main_file(ctx: AnyContext, app_main_file_path: str):
+    existing_app_main_code = read_file(app_main_file_path)
+    write_file(
+        file_path=app_main_file_path,
+        content=[
+            _get_import_module_route_code(existing_app_main_code, ctx.input.module),
+            existing_app_main_code,
+            "",
+            _get_assert_module_route_code(existing_app_main_code, ctx.input.module),
+        ],
+    )
+
+
+def _get_import_module_route_code(existing_code: str, module_name: str) -> str | None:
+    snake_module_name = to_snake_case(module_name)
+    import_module_path = f"my_app_name.module.{snake_module_name}"
+    import_route_code = (
+        f"from {import_module_path} import route as {snake_module_name}_route"
+    )
+    if import_route_code in existing_code:
+        return None
+    return import_route_code
+
+
+def _get_assert_module_route_code(existing_code: str, module_name: str) -> str | None:
+    snake_module_name = to_snake_case(module_name)
+    assert_route_code = f"assert {snake_module_name}_route"
+    return assert_route_code if assert_route_code not in existing_code else None
+
+
+def update_app_config_file(ctx: AnyContext, module_config_path: str):
+    existing_config_code = read_file(module_config_path)
+    write_file(
+        module_config_path,
+        [
+            existing_config_code.strip(),
+            _get_new_module_config_code(existing_config_code, ctx.input.module),
+        ],
+    )
+
+
+def _get_new_module_config_code(existing_code: str, module_name: str) -> str | None:
+    existing_module_names = get_existing_module_names()
+    module_port = 3000 + len(
+        [
+            existing_module_name
+            for existing_module_name in existing_module_names
+            if existing_module_name != to_snake_case(module_name)
+        ]
+    )
+    module_base_url = f"http://localhost:{module_port}"
+    upper_snake_module_name = to_snake_case(module_name).upper()
+    config_name = f"APP_{upper_snake_module_name}_BASE_URL"
+    env_name = f"MY_APP_NAME_{upper_snake_module_name}_BASE_URL"
+    config_code = f'{config_name} = os.getenv("{env_name}", "{module_base_url}")'
+    if config_code in existing_code:
+        return None
+    return config_code

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

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

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

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

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

@@ -0,0 +1,6 @@
+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
+
+
+class DirectClient(AnyClient):
+    pass

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

@@ -0,0 +1,9 @@
+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
+
+if APP_COMMUNICATION == "direct":
+    client: AnyClient = DirectClient()
+elif APP_COMMUNICATION == "api":
+    client: AnyClient = APIClient()

zrb/builtin/project/add/{fastapp_template/_zrb/module/module_template → fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/my_module}/migration/env.py

@@ -1,8 +1,8 @@
 from logging.config import fileConfig
 
 from alembic import context
-from fastapp_template.config import APP_DB_URL
-from fastapp_template.module.my_module.migration_metadata import metadata
+from my_app_name.config import APP_DB_URL
+from my_app_name.module.my_module.migration_metadata import metadata
 from sqlalchemy import engine_from_config, pool
 
 # this is the Alembic Config object, which provides
@@ -68,7 +68,6 @@ def run_migrations_offline() -> None:
         target_metadata=target_metadata,
         literal_binds=True,
         dialect_opts={"paramstyle": "named"},
-        imports=["import sqlmodel"],  # 🔥 FastApp Modification
         version_table=MIGRATION_TABLE,  # 🔥 FastApp Modification
         include_object=include_object,  # 🔥 FastApp Modification
     )
@@ -94,7 +93,6 @@ def run_migrations_online() -> None:
         context.configure(
             connection=connection,
             target_metadata=target_metadata,
-            imports=["import sqlmodel"],  # 🔥 FastApp Modification
             version_table=MIGRATION_TABLE,  # 🔥 FastApp Modification
             include_object=include_object,  # 🔥 FastApp Modification
         )

zrb/builtin/project/add/{fastapp_template/module/auth → fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/my_module}/migration/script.py.mako

@@ -9,6 +9,7 @@ from typing import Sequence, Union
 
 from alembic import op
 import sqlalchemy as sa
+import sqlmodel  # 🔥 FastApp Modification
 ${imports if imports else ""}
 
 # revision identifiers, used by Alembic.

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

@@ -0,0 +1,33 @@
+from fastapi import FastAPI
+from my_app_name.common.app 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):
+    @app.api_route("/health", methods=["GET", "HEAD"], response_model=BasicResponse)
+    async def health():
+        """
+        Microservice's health check
+        """
+        return BasicResponse(message="ok")
+
+
+def serve_readiness_check(app: FastAPI):
+    @app.api_route("/readiness", methods=["GET", "HEAD"], response_model=BasicResponse)
+    async def readiness():
+        """
+        Microservice's readiness check
+        """
+        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_template/_zrb/main.py → fastapp/fastapp_template/my_app_name/_zrb/task.py}

@@ -1,26 +1,24 @@
 import os
 
-from fastapp_template._zrb.column.create_column_task import create_my_app_name_column
-from fastapp_template._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR
-from fastapp_template._zrb.entity.create_entity_task import create_my_app_name_entity
-from fastapp_template._zrb.group import (
+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.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_migrate_group,
     app_run_group,
 )
-from fastapp_template._zrb.helper import (
-    create_migration,
-    migrate_module,
-    run_microservice,
-)
-from fastapp_template._zrb.module.create_module_task import create_my_app_name_module
-from fastapp_template._zrb.venv_task import prepare_venv
+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
 
-assert create_my_app_name_entity
-assert create_my_app_name_module
-assert create_my_app_name_column
+assert add_my_app_name_entity
+assert add_my_app_name_module
+assert add_my_app_name_column
+assert format_my_app_name_code
 
 # 🚀 Run/Migrate All ===========================================================
 

zrb/builtin/project/add/{fastapp_template/_zrb/helper.py → fastapp/fastapp_template/my_app_name/_zrb/util.py}

@@ -1,6 +1,6 @@
 import os
 
-from fastapp_template._zrb.config import (
+from my_app_name._zrb.config import (
     ACTIVATE_VENV_SCRIPT,
     APP_DIR,
     MICROSERVICES_ENV_VARS,

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template/my_app_name}/_zrb/venv_task.py

@@ -1,6 +1,6 @@
 import os
 
-from fastapp_template._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR
+from my_app_name._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR
 
 from zrb import CmdTask
 

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template/my_app_name}/common/app.py

@@ -1,8 +1,8 @@
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
-from fastapp_template.common.db_engine import engine
-from fastapp_template.config import APP_MODE, APP_MODULES
+from my_app_name.common.db_engine import engine
+from my_app_name.config import APP_MODE, APP_MODULES
 from sqlmodel import SQLModel
 
 

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

@@ -1,6 +1,6 @@
 from typing import Any, Callable, Generic, Type, TypeVar
 
-from fastapp_template.common.error import NotFoundError
+from my_app_name.common.error import NotFoundError
 from sqlalchemy import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
 from sqlmodel import Session, SQLModel, select

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template/my_app_name}/common/base_usecase.py

@@ -67,6 +67,12 @@ class RouteParam:
 class BaseUsecase:
     _route_params: dict[str, RouteParam] = {}
 
+    def __init__(self):
+        self._route_params: dict[str, RouteParam] = {}
+        for name, method in self.__class__.__dict__.items():
+            if hasattr(method, "__route_param__"):
+                self._route_params[name] = getattr(method, "__route_param__")
+
     @classmethod
     def route(
         cls,
@@ -100,7 +106,15 @@ class BaseUsecase:
         """
 
         def decorator(func: Callable):
-            cls._route_params[func.__name__] = RouteParam(
+            @wraps(func)
+            async def wrapped(*args, **kwargs):
+                return await func(*args, **kwargs)
+
+            # Inject __route_param__ property to the method
+            # Method with __route_param__ property will automatically
+            # registered to self._route_param and will be automatically exposed
+            # into DirectClient and APIClient
+            wrapped.__route_param__ = RouteParam(
                 path=path,
                 response_model=response_model,
                 status_code=status_code,
@@ -126,11 +140,6 @@ class BaseUsecase:
                 generate_unique_id_function=generate_unique_id_function,
                 func=func,
             )
-
-            @wraps(func)
-            async def wrapped(*args, **kwargs):
-                return await func(*args, **kwargs)
-
             return wrapped
 
         return decorator
@@ -144,6 +153,8 @@ class BaseUsecase:
         for name, details in _methods.items():
             func = details.func
             client_method = create_direct_client_method(func, self)
+            # Use __get__ to make a bounded method,
+            # ensuring that client_method use DirectClient as `self`
             setattr(DirectClient, name, client_method.__get__(DirectClient))
         return DirectClient
 
@@ -156,6 +167,8 @@ class BaseUsecase:
         # Dynamically generate methods
         for name, param in _methods.items():
             client_method = create_api_client_method(param, base_url)
+            # Use __get__ to make a bounded method,
+            # ensuring that client_method use APIClient as `self`
             setattr(APIClient, name, client_method.__get__(APIClient))
         return APIClient
 

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template/my_app_name}/common/db_engine.py

@@ -1,4 +1,4 @@
-from fastapp_template.config import APP_DB_URL
+from my_app_name.config import APP_DB_URL
 from sqlmodel import create_engine
 
 connect_args = {"check_same_thread": False}

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template/my_app_name}/config.py

@@ -8,6 +8,7 @@ APP_MODULES = [
     for module in os.getenv("MY_APP_NAME_MODULES", "").split(",")
     if module.strip() != ""
 ]
+APP_MAIN_MODULE = APP_MODULES[0] if len(APP_MODULES) > 0 else None
 APP_PORT = int(os.getenv("MY_APP_NAME_PORT", "3000"))
 APP_COMMUNICATION = os.getenv(
     "MY_APP_NAME_COMMUNICATION", "direct" if APP_MODE == "monolith" else "api"

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/main.py

@@ -0,0 +1,7 @@
+from my_app_name.common.app import app
+from my_app_name.module.auth import route as auth_route
+from my_app_name.module.gateway import route as gateway_route
+
+assert app
+assert gateway_route
+assert auth_route

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/migrate.py

@@ -0,0 +1,3 @@
+from my_app_name.module.auth import migration as auth_migration
+
+assert auth_migration