zrb 1.0.0a10__py3-none-any.whl → 1.0.0a14__py3-none-any.whl

zrb/builtin/__init__.py

@@ -12,14 +12,22 @@ from zrb.builtin.md5 import hash_md5, sum_md5
 from zrb.builtin.project.add.fastapp import add_fastapp_to_project
 from zrb.builtin.project.create.create import create_project
 from zrb.builtin.python import format_python_code
-from zrb.builtin.setup.dev.asdf import setup_asdf
-from zrb.builtin.setup.dev.tmux import setup_tmux
-from zrb.builtin.setup.system.latex.ubuntu import setup_latex_on_ubuntu
-from zrb.builtin.setup.system.ubuntu import setup_ubuntu
+from zrb.builtin.setup.asdf.asdf import setup_asdf
+from zrb.builtin.setup.latex.ubuntu import setup_latex_on_ubuntu
+from zrb.builtin.setup.tmux.tmux import setup_tmux
+from zrb.builtin.setup.ubuntu import setup_ubuntu
 from zrb.builtin.shell.autocomplete.bash import make_bash_autocomplete
 from zrb.builtin.shell.autocomplete.subcmd import get_shell_subcommands
 from zrb.builtin.shell.autocomplete.zsh import make_zsh_autocomplete
-from zrb.builtin.todo import add_todo, complete_todo, edit_todo, list_todo, log_todo
+from zrb.builtin.todo import (
+    add_todo,
+    archive_todo,
+    complete_todo,
+    edit_todo,
+    list_todo,
+    log_todo,
+    show_todo,
+)
 
 assert create_project
 assert add_fastapp_to_project
@@ -42,9 +50,11 @@ assert git_pull_subtree
 assert git_push_subtree
 assert list_todo
 assert add_todo
+assert archive_todo
 assert edit_todo
 assert complete_todo
 assert log_todo
+assert show_todo
 assert setup_ubuntu
 assert setup_latex_on_ubuntu
 assert setup_asdf

zrb/builtin/project/add/fastapp.py

@@ -6,7 +6,7 @@ from zrb.input.str_input import StrInput
 from zrb.task.make_task import make_task
 from zrb.task.scaffolder import Scaffolder
 from zrb.task.task import Task
-from zrb.util.string.conversion import double_quote
+from zrb.util.string.conversion import double_quote, to_snake_case
 from zrb.util.string.name import get_random_name
 
 _DIR = os.path.dirname(__file__)
@@ -22,25 +22,21 @@ scaffold_fastapp = Scaffolder(
             default_str=lambda _: os.getcwd(),
         ),
         StrInput(
-            name="app-name",
+            name="app",
             description="App name",
             prompt="App name",
-            default_str=lambda _: get_random_name(separator="_"),
         ),
     ],
     source_path=os.path.join(_DIR, "fastapp_template"),
     render_source_path=False,
-    destination_path=lambda ctx: os.path.join(
-        ctx.input["project-dir"], ctx.input["app-name"]
-    ),
+    destination_path=lambda ctx: os.path.join(ctx.input["project-dir"], ctx.input.app),
     transform_content={
-        "fastapp_template": "{to_snake_case(ctx.input['app-name'])}",
-        "App Name": "{ctx.input['app-name'].title()}",
-        "App name": "{ctx.input['app-name'].capitalize()}",
-        "app-name": "{to_kebab_case(ctx.input['app-name'])}",
-        "app_name": "{to_snake_case(ctx.input['app-name'])}",
-        "APP_NAME": "{to_snake_case(ctx.input['app-name']).upper()}",
-        "secure-password": lambda _: get_random_name(),
+        "fastapp_template": "{to_snake_case(ctx.input.app)}",
+        "My App Name": "{ctx.input.app.title()}",
+        "my-app-name": "{to_kebab_case(ctx.input.app)}",
+        "my_app_name": "{to_snake_case(ctx.input.app)}",
+        "MY_APP_NAME": "{to_snake_case(ctx.input.app).upper()}",
+        "my-secure-password": lambda _: get_random_name(),
     },
     retries=0,
 )
@@ -48,16 +44,34 @@ scaffold_fastapp = Scaffolder(
 
 @make_task(
     name="register-fastapp-automation",
+    retries=0,
 )
 def register_fastapp_automation(ctx: AnyContext):
     project_dir_path = ctx.input["project-dir"]
     zrb_init_path = os.path.join(project_dir_path, "zrb_init.py")
-    app_dir_path = ctx.input["app-name"]
-    app_automation_file_part = ", ".join(
+    app_dir_path = ctx.input.app
+    app_name = to_snake_case(ctx.input.app)
+    with open(zrb_init_path, "r") as f:
+        file_content = f.read().strip()
+    # Assemble new content
+    new_content_list = [file_content]
+    # Check if import load_file is exists, if not exists, add
+    import_load_file_script = "from zrb import load_file"
+    if import_load_file_script not in file_content:
+        new_content_list = [import_load_file_script] + new_content_list
+    # Add fastapp-automation script
+    automation_file_part = ", ".join(
         [double_quote(part) for part in [app_dir_path, "_zrb", "main.py"]]
     )
-    with open(zrb_init_path, "+a") as f:
-        f.write(f"load_file(os.path.join(_DIR, {app_automation_file_part}))\n")
+    new_content_list = new_content_list + [
+        f"{app_name} = load_file(os.path.join(_DIR, {automation_file_part}))",
+        f"assert {app_name}",
+        "",
+    ]
+    new_content = "\n".join(new_content_list)
+    # Write new content
+    with open(zrb_init_path, "w") as f:
+        f.write(new_content)
 
 
 scaffold_fastapp >> register_fastapp_automation
@@ -66,6 +80,7 @@ add_fastapp_to_project = add_to_project_group.add_task(
     Task(
         name="add-fastapp",
         description="🚀 Add FastApp to project",
+        retries=0,
     ),
     alias="fastapp",
 )

zrb/builtin/project/add/fastapp_template/_zrb/column/create_column_task.py

@@ -0,0 +1,11 @@
+from fastapp_template._zrb.group import app_create_group
+
+from zrb import Task
+
+create_my_app_name_column = app_create_group.add_task(
+    Task(
+        name="create-my-app-name-column",
+        description="📊 Create new column on an entity",
+    ),
+    alias="column",
+)

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

@@ -6,12 +6,12 @@ APP_DIR = os.path.dirname(DIR)
 APP_MODULE_NAME = os.path.basename(APP_DIR)
 
 MICROSERVICES_ENV_VARS = {
-    "APP_NAME_MODE": "microservices",
-    "APP_NAME_AUTH_BASE_URL": "http://localhost:3002",
+    "MY_APP_NAME_MODE": "microservices",
+    "MY_APP_NAME_AUTH_BASE_URL": "http://localhost:3002",
 }
-MONOLITH_ENV_VARS = {"APP_NAME_MODE": "monolith"}
+MONOLITH_ENV_VARS = {"MY_APP_NAME_MODE": "monolith"}
 
 if platform.system() == "Windows":
-    ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\Scripts\Activate"  # noqa
+    ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\\Scripts\\Activate"  # noqa
 else:
     ACTIVATE_VENV_SCRIPT = "source .venv/bin/activate"

zrb/builtin/project/add/fastapp_template/_zrb/entity/create_entity_task.py

@@ -0,0 +1,196 @@
+import os
+
+from fastapp_template._zrb.config import APP_DIR
+from fastapp_template._zrb.group import app_create_group
+from fastapp_template._zrb.helper import (
+    get_existing_module_names,
+    get_existing_schema_names,
+)
+from fastapp_template._zrb.input import (
+    existing_module_input,
+    new_entity_column_input,
+    new_entity_input,
+    plural_entity_input,
+)
+
+from zrb import AnyContext, Scaffolder, Task, make_task
+from zrb.util.codemod.add_code_to_module import add_code_to_module
+from zrb.util.codemod.add_parent_to_class import add_parent_to_class
+from zrb.util.string.conversion import to_pascal_case, to_snake_case
+
+
+@make_task(
+    name="validate-create-my-app-name-entity",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        plural_entity_input,
+        new_entity_column_input,
+    ],
+    retries=0,
+)
+async def validate_create_my_app_name_entity(ctx: AnyContext):
+    module_name = to_snake_case(ctx.input.module)
+    if module_name not in get_existing_module_names():
+        raise ValueError(f"Module not exist: {module_name}")
+    schema_name = to_snake_case(ctx.input.entity)
+    if schema_name in get_existing_schema_names():
+        raise ValueError(f"Schema already exists: {schema_name}")
+
+
+scaffold_my_app_name_schema = Scaffolder(
+    name="scaffold-my-app-name-schema",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        new_entity_column_input,
+    ],
+    source_path=os.path.join(os.path.dirname(__file__), "schema.template.py"),
+    render_source_path=False,
+    destination_path=lambda ctx: os.path.join(
+        APP_DIR,
+        "schema",
+        f"{to_snake_case(ctx.input.entity)}.py",
+    ),
+    transform_content={
+        "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+        "my_column": "{to_snake_case(ctx.input.column)}",
+    },
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+
+scaffold_my_app_name_module_entity = Scaffolder(
+    name="scaffold-my-app-name-schema",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        plural_entity_input,
+    ],
+    source_path=os.path.join(os.path.dirname(__file__), "module_template"),
+    render_source_path=False,
+    destination_path=lambda ctx: os.path.join(
+        APP_DIR,
+        "module",
+        f"{to_snake_case(ctx.input.module)}",
+    ),
+    transform_content={
+        "my_module": "{to_snake_case(ctx.input.module)}",
+        "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+        "my_entity": "{to_snake_case(ctx.input.entity)}",
+        "my_entities": "{to_snake_case(ctx.input.plural)}",
+        "my-entities": "{to_kebab_case(ctx.input.plural)}",
+    },
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+
+
+@make_task(
+    name="register-my-app-name-migration",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_migration(ctx: AnyContext):
+    migration_metadata_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "migration_metadata.py"
+    )
+    app_name = os.path.basename(APP_DIR)
+    with open(migration_metadata_file_path, "r") as f:
+        file_content = f.read()
+    entity_name = to_snake_case(ctx.input.entity)
+    entity_class = to_pascal_case(ctx.input.entity)
+    new_file_content_list = (
+        [f"from {app_name}.schema.{entity_name} import {entity_class}"]
+        + file_content.strip()
+        + [
+            f"{entity_class}.metadata = metadata",
+            f"{entity_class}.__table__.tometadata(metadata)",
+            "",
+        ]
+    )
+    with open(migration_metadata_file_path, "w") as f:
+        f.write("\n".join(new_file_content_list))
+
+
+@make_task(
+    name="register-my-app-name-api-client",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_api_client(ctx: AnyContext):
+    api_client_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "client", "api_client.py"
+    )
+    with open(api_client_file_path, "r") as f:
+        file_content = f.read()
+    module_config_name = to_snake_case(ctx.input.module).upper()
+    new_code = add_code_to_module(
+        file_content,
+        f"user_api_client = user_usecase.as_api_client(base_url=APP_{module_config_name}_BASE_URL)",  # noqa
+    )
+    new_code = add_parent_to_class(
+        original_code=new_code,
+        class_name="APIClient",
+        parent_class_name="user_api_client",
+    )
+    app_name = os.path.basename(APP_DIR)
+    entity_name = to_snake_case(ctx.input.entity)
+    module_name = to_snake_case(ctx.input.module)
+    new_file_content_list = [
+        f"from {app_name}.module.{module_name}.service.{entity_name} import {entity_name}_usecase",  # noqa
+        new_code.strip(),
+        "",
+    ]
+    with open(api_client_file_path, "w") as f:
+        f.write("\n".join(new_file_content_list))
+
+
+@make_task(
+    name="register-my-app-name-direct-client",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_direct_client(ctx: AnyContext):
+    direct_client_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "client", "direct_client.py"
+    )
+    with open(direct_client_file_path, "r") as f:
+        file_content = f.read()
+    new_code = add_code_to_module(
+        file_content, "user_direct_client = user_usecase.as_direct_client()"
+    )
+    new_code = add_parent_to_class(
+        original_code=new_code,
+        class_name="DirectClient",
+        parent_class_name="user_direct_client",
+    )
+    app_name = os.path.basename(APP_DIR)
+    entity_name = to_snake_case(ctx.input.entity)
+    module_name = to_snake_case(ctx.input.module)
+    new_file_content_list = [
+        f"from {app_name}.module.{module_name}.service.{entity_name} import {entity_name}_usecase",  # noqa
+        new_code.strip(),
+        "",
+    ]
+    with open(direct_client_file_path, "w") as f:
+        f.write("\n".join(new_file_content_list))
+
+
+create_my_app_name_entity = app_create_group.add_task(
+    Task(
+        name="create-my-app-name-entity",
+        description="🏗️ Create new entity on a module",
+        successor="",
+    ),
+    alias="entity",
+)
+create_my_app_name_entity << [
+    scaffold_my_app_name_schema,
+    scaffold_my_app_name_module_entity,
+    register_my_app_name_api_client,
+    register_my_app_name_direct_client,
+]

zrb/builtin/project/add/fastapp_template/_zrb/entity/module_template/service/my_entity/my_entity_usecase.py

@@ -0,0 +1,66 @@
+from fastapp_template.common.base_usecase import BaseUsecase
+from fastapp_template.module.my_module.service.my_entity.repository.factory import (
+    my_entity_repository,
+)
+from fastapp_template.module.my_module.service.my_entity.repository.repository import (
+    MyEntityRepository,
+)
+from fastapp_template.schema.my_entity import (
+    MyEntityCreate,
+    MyEntityResponse,
+    MyEntityUpdate,
+)
+
+
+class MyEntityUsecase(BaseUsecase):
+
+    def __init__(self, my_entity_repository: MyEntityRepository):
+        super().__init__()
+        self.my_entity_repository = my_entity_repository
+
+    @BaseUsecase.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)
+
+    @BaseUsecase.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(
+        "/api/v1/my-entities",
+        methods=["post"],
+        response_model=MyEntityResponse | list[MyEntityResponse],
+    )
+    async def create_my_entity(
+        self, data: MyEntityCreate | list[MyEntityCreate]
+    ) -> MyEntityResponse | list[MyEntityResponse]:
+        if isinstance(data, MyEntityCreate):
+            return await self.my_entity_repository.create(data)
+        return await self.my_entity_repository.create_bulk(data)
+
+    @BaseUsecase.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["put"],
+        response_model=MyEntityResponse,
+    )
+    async def update_my_entity(
+        self, my_entity_id: str, data: MyEntityUpdate
+    ) -> MyEntityResponse:
+        return await self.my_entity_repository.update(my_entity_id, data)
+
+    @BaseUsecase.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_template/_zrb/entity/module_template/service/my_entity/repository/factory.py

@@ -0,0 +1,13 @@
+from fastapp_template.common.db_engine import engine
+from fastapp_template.config import APP_REPOSITORY_TYPE
+from fastapp_template.module.my_module.service.my_entity.repository.my_entity_db_repository import (
+    MyEntityDBRepository,
+)
+from fastapp_template.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/service/my_entity/repository/my_entity_db_repository.py

@@ -0,0 +1,33 @@
+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 (
+    MyEntityRepository,
+)
+from fastapp_template.schema.my_entity import (
+    MyEntity,
+    MyEntityCreate,
+    MyEntityResponse,
+    MyEntityUpdate,
+)
+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(
+    BaseDBRepository[MyEntity, MyEntityResponse, MyEntityCreate, MyEntityUpdate],
+    MyEntityRepository,
+):
+    db_model = MyEntity
+    response_model = MyEntityResponse
+    create_model = MyEntityCreate
+    update_model = MyEntityUpdate
+    entity_name = "my_entity"
+    column_preprocessors = {}

zrb/builtin/project/add/fastapp_template/_zrb/entity/module_template/service/my_entity/repository/my_entity_repository.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+from fastapp_template.schema.my_entity import (
+    MyEntity,
+    MyEntityCreate,
+    MyEntityResponse,
+    MyEntityUpdate,
+)
+
+
+class MyEntityRepository(ABC):
+
+    @abstractmethod
+    async def create(self, my_entity_data: MyEntityCreate) -> MyEntityResponse:
+        pass
+
+    @abstractmethod
+    async def get_by_id(self, my_entity_id: str) -> MyEntity:
+        pass
+
+    @abstractmethod
+    async def get_all(self) -> list[MyEntity]:
+        pass
+
+    @abstractmethod
+    async def update(
+        self, my_entity_id: str, my_entity_data: MyEntityUpdate
+    ) -> MyEntity:
+        pass
+
+    @abstractmethod
+    async def delete(self, my_entity_id: str) -> MyEntity:
+        pass
+
+    @abstractmethod
+    async def create_bulk(
+        self, my_entity_data_list: list[MyEntityCreate]
+    ) -> list[MyEntityResponse]:
+        pass

zrb/builtin/project/add/fastapp_template/_zrb/entity/schema.template.py

@@ -0,0 +1,29 @@
+import datetime
+
+import ulid
+from sqlmodel import Field, SQLModel
+
+
+class MyEntityBase(SQLModel):
+    my_column: str
+
+
+class MyEntityCreate(MyEntityBase):
+    pass
+
+
+class MyEntityUpdate(SQLModel):
+    my_column: str | None = None
+
+
+class MyEntityResponse(MyEntityBase):
+    id: str
+
+
+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

zrb/builtin/project/add/fastapp_template/_zrb/group.py

@@ -1,16 +1,20 @@
 from zrb import Group
-from zrb.builtin import project_group
+from zrb.builtin.group import project_group
 
 app_group = project_group.add_group(
-    Group(name="app-name", description="🚀 Managing App Name")
+    Group(name="my-app-name", description="🚀 Managing My App Name")
 )
 
-app_run_group = app_group.add_group(Group(name="run", description="🟢 Run App Name"))
+app_run_group = app_group.add_group(Group(name="run", description="🟢 Run My App Name"))
 
 app_migrate_group = app_group.add_group(
-    Group(name="migrate", description="📦 Run App Name DB migration")
+    Group(name="migrate", description="📦 Run My App Name DB migration")
 )
 
 app_create_group = app_group.add_group(
-    Group(name="create", description="✨ Create resources for App Name")
+    Group(name="create", description="✨ Create resources for My App Name")
+)
+
+app_create_migration_group = app_create_group.add_group(
+    Group(name="migration", description="📦 Create My App Name DB migration")
 )

zrb/builtin/project/add/fastapp_template/_zrb/helper.py

@@ -12,8 +12,8 @@ from zrb import Cmd, CmdTask, EnvFile, EnvMap, StrInput, Task
 
 def create_migration(name: str, module: str) -> Task:
     return CmdTask(
-        name=f"create-app-name-{name}-migration",
-        description=f"🧩 Create App Name {name.capitalize()} DB migration",
+        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",
@@ -25,7 +25,7 @@ def create_migration(name: str, module: str) -> Task:
             EnvMap(
                 vars={
                     "APP_DB_URL": f"sqlite:///{APP_DIR}/.migration.{module}.db",
-                    "APP_NAME_MODULES": f"{module}",
+                    "MY_APP_NAME_MODULES": f"{module}",
                 }
             ),
         ],
@@ -48,17 +48,17 @@ def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
     env_vars = MICROSERVICES_ENV_VARS if as_microservices else MONOLITH_ENV_VARS
     return CmdTask(
         name=(
-            f"migrate-app-name-{name}"
+            f"migrate-my-app-name-{name}"
             if as_microservices
             else f"migrate-{name}-on-monolith"
         ),
-        description=f"🧩 Run App Name {name.capitalize()} DB migration",
+        description=f"🧩 Run My App Name {name.capitalize()} DB migration",
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
             EnvMap(
                 vars={
                     **env_vars,
-                    "APP_NAME_MODULES": f"{module}",
+                    "MY_APP_NAME_MODULES": f"{module}",
                 }
             ),
         ],
@@ -75,23 +75,37 @@ def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
 
 def run_microservice(name: str, port: int, module: str) -> Task:
     return CmdTask(
-        name=f"run-app-name-{name}",
-        description=f"🧩 Run App Name {name.capitalize()}",
+        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,
-                    "APP_NAME_PORT": f"{port}",
-                    "APP_NAME_MODULES": f"{module}",
+                    "MY_APP_NAME_PORT": f"{port}",
+                    "MY_APP_NAME_MODULES": f"{module}",
                 }
             ),
         ],
         cwd=APP_DIR,
         cmd=[
             ACTIVATE_VENV_SCRIPT,
-            'fastapi dev main.py --port "${APP_NAME_PORT}"',
+            'fastapi dev main.py --port "${MY_APP_NAME_PORT}"',
         ],
         render_cmd=False,
         retries=2,
     )
+
+
+def get_existing_module_names() -> list[str]:
+    module_dir_path = os.path.join(APP_DIR, "module")
+    return [entry.name for entry in os.scandir(module_dir_path) if entry.is_dir()]
+
+
+def get_existing_schema_names() -> list[str]:
+    module_dir_path = os.path.join(APP_DIR, "schema")
+    return [
+        os.path.splitext(entry.name)[0]
+        for entry in os.scandir(module_dir_path)
+        if entry.is_file() and entry.name.endswith(".py")
+    ]