zrb 1.0.0a15__py3-none-any.whl → 1.0.0a17__py3-none-any.whl

zrb/builtin/project/add/{fastapp_template/_zrb/module/create_module_task.py → fastapp/fastapp_template/_zrb/module/task.py}

@@ -2,10 +2,11 @@ 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
 from fastapp_template._zrb.input import new_module_input
+from fastapp_template._zrb.util import get_existing_module_names
 
 from zrb import AnyContext, Scaffolder, Task, make_task
+from zrb.util.file import read_file, write_file
 from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
 
 
@@ -22,7 +23,7 @@ async def validate_create_my_app_name_module(ctx: AnyContext):
 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__), "module_template"),
+    source_path=os.path.join(os.path.dirname(__file__), "template", "module_template"),
     render_source_path=False,
     destination_path=lambda ctx: os.path.join(
         APP_DIR,
@@ -31,7 +32,8 @@ scaffold_my_app_name_module = Scaffolder(
     ),
     transform_content={
         "module_template": "{to_snake_case(ctx.input.module)}",
-        "MY_MODULE_NAME": "{to_snake_case(ctx.input.module).upper()}",
+        "MY_MODULE": "{to_snake_case(ctx.input.module).upper()}",
+        "my_module": "{to_snake_case(ctx.input.module)}",
     },
     retries=0,
     upstream=validate_create_my_app_name_module,
@@ -60,8 +62,13 @@ async def register_my_app_name_module_config(ctx: AnyContext):
     config_name = f"APP_{upper_module_name}_BASE_URL"
     env_name = f"MY_APP_NAME_{upper_module_name}_BASE_URL"
     # TODO: check before write
-    with open(config_file_name, "a") as f:
-        f.write(f'{config_name} = os.getenv("{env_name}", "{module_base_url}")\n')
+    write_file(
+        config_file_name,
+        [
+            read_file(config_file_name),
+            f'{config_name} = os.getenv("{env_name}", "{module_base_url}")\n',
+        ],
+    )
 
 
 @make_task(
@@ -76,23 +83,24 @@ async def register_my_app_name_module(ctx: AnyContext):
     module_name = to_snake_case(ctx.input.module)
     import_code = f"from fastapp_template.module.{module_name} import route as {module_name}_route"  # noqa
     assert_code = f"assert {module_name}_route"
-    with open(app_main_file_name, "r") as f:
-        code = f.read()
+    code = read_file(app_main_file_name)
     new_code = "\n".join([import_code, code.strip(), assert_code, ""])
     # TODO: check before write
-    with open(app_main_file_name, "w") as f:
-        f.write(new_code)
+    write_file(app_main_file_name, new_code)
+
+
+# TODO: Register to zrb's config
 
 
 @make_task(
-    name="register-my-app-name-module-runner",
+    name="add-my-app-name-module-task-to-zrb-init",
     input=new_module_input,
     upstream=validate_create_my_app_name_module,
     retries=0,
 )
-async def register_my_app_name_module_runner(ctx: AnyContext):
-    """Registering module to _zrb's main.py"""
-    task_main_file_name = os.path.join(APP_DIR, "_zrb", "main.py")
+async def add_my_app_name_module_task_to_zrb_init(ctx: AnyContext):
+    """Registering module to _zrb's task.py"""
+    task_main_file_name = os.path.join(APP_DIR, "_zrb", "task.py")
     existing_module_names = get_existing_module_names()
     module_port = 3001 + len(
         [
@@ -104,33 +112,32 @@ async def register_my_app_name_module_runner(ctx: AnyContext):
     module_snake_name = to_snake_case(ctx.input.module)
     module_kebab_name = to_kebab_case(ctx.input.module)
     module_pascal_name = to_pascal_case(ctx.input.module)
-    with open(os.path.join(os.path.dirname(__file__), "run_module.template.py")) as f:
-        module_runner_code = (
-            f.read()
-            .replace("my_module", module_snake_name)
-            .replace("my-module", module_kebab_name)
-            .replace("My Module", module_pascal_name)
-            .replace("3000", f"{module_port}")
-        )
-    with open(task_main_file_name, "r") as f:
-        code = f.read()
+    module_runner_code = read_file(
+        os.path.join(os.path.dirname(__file__), "template", "task_definition.py"),
+        {
+            "my_module": module_snake_name,
+            "my-module": module_kebab_name,
+            "My Module": module_pascal_name,
+            "3000": f"{module_port}",
+        },
+    )
+    code = read_file(task_main_file_name)
     new_code = "\n".join([code.strip(), "", module_runner_code, ""])
     # TODO: check before write
-    with open(task_main_file_name, "w") as f:
-        f.write(new_code)
+    write_file(task_main_file_name, new_code)
 
 
 create_my_app_name_module = app_create_group.add_task(
     Task(
         name="create-my-app-name-module",
         description="🧩 Create new module on My App Name",
+        upstream=[
+            scaffold_my_app_name_module,
+            register_my_app_name_module,
+            register_my_app_name_module_config,
+            add_my_app_name_module_task_to_zrb_init,
+        ],
         retries=0,
     ),
     alias="module",
 )
-create_my_app_name_module << [
-    scaffold_my_app_name_module,
-    register_my_app_name_module,
-    register_my_app_name_module_config,
-    register_my_app_name_module_runner,
-]

zrb/builtin/project/add/fastapp/fastapp_template/_zrb/module/template/module_template/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/_zrb/module/template/module_template/client/api_client.py

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

zrb/builtin/project/add/{fastapp_template/_zrb/module → fastapp/fastapp_template/_zrb/module/template}/module_template/client/direct_client.py

@@ -1,6 +1,6 @@
-from fastapp_template.module.module_template.client.any_client import BaseClient
+from fastapp_template.module.module_template.client.any_client import AnyClient
 from fastapp_template.module.module_template.service.user.usecase import user_usecase
 
 
-class DirectClient(BaseClient):
+class DirectClient(AnyClient):
     pass

zrb/builtin/project/add/{fastapp_template/_zrb/module → fastapp/fastapp_template/_zrb/module/template}/module_template/client/factory.py

@@ -1,9 +1,9 @@
 from fastapp_template.config import APP_COMMUNICATION
-from fastapp_template.module.module_template.client.any_client import BaseClient
+from fastapp_template.module.module_template.client.any_client import AnyClient
 from fastapp_template.module.module_template.client.api_client import APIClient
 from fastapp_template.module.module_template.client.direct_client import DirectClient
 
 if APP_COMMUNICATION == "direct":
-    client: BaseClient = DirectClient()
+    client: AnyClient = DirectClient()
 elif APP_COMMUNICATION == "api":
-    client: BaseClient = APIClient()
+    client: AnyClient = APIClient()

zrb/builtin/project/add/fastapp/fastapp_template/_zrb/module/template/module_template/route.py

@@ -0,0 +1,33 @@
+from fastapi import FastAPI
+from fastapp_template.common.app import app
+from fastapp_template.common.schema import BasicResponse
+from fastapp_template.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/_zrb/task.py}

@@ -2,18 +2,18 @@ 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.entity.task import create_my_app_name_entity
 from fastapp_template._zrb.group import (
     app_create_migration_group,
     app_migrate_group,
     app_run_group,
 )
-from fastapp_template._zrb.helper import (
+from fastapp_template._zrb.module.task import create_my_app_name_module
+from fastapp_template._zrb.util 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 zrb import CmdTask, Env, EnvFile, Task

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/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}/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_template → fastapp/fastapp_template}/module/auth/client/any_client.py

@@ -1,9 +1,13 @@
 from abc import ABC, abstractmethod
 
-from fastapp_template.schema.user import UserCreate, UserResponse, UserUpdate
+from fastapp_template.schema.user import (
+    UserCreateWithAudit,
+    UserResponse,
+    UserUpdateWithAudit,
+)
 
 
-class BaseClient(ABC):
+class AnyClient(ABC):
     @abstractmethod
     async def get_user_by_id(self, user_id: str) -> UserResponse:
         pass
@@ -14,12 +18,14 @@ class BaseClient(ABC):
 
     @abstractmethod
     async def create_user(
-        self, data: UserCreate | list[UserCreate]
+        self, data: UserCreateWithAudit | list[UserCreateWithAudit]
     ) -> UserResponse | list[UserResponse]:
         pass
 
     @abstractmethod
-    async def update_user(self, user_id: str, data: UserUpdate) -> UserResponse:
+    async def update_user(
+        self, user_id: str, data: UserUpdateWithAudit
+    ) -> UserResponse:
         pass
 
     @abstractmethod

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/module/auth/client/api_client.py

@@ -1,7 +1,7 @@
 from fastapp_template.config import APP_AUTH_BASE_URL
-from fastapp_template.module.auth.client.any_client import BaseClient
+from fastapp_template.module.auth.client.any_client import AnyClient
 from fastapp_template.module.auth.service.user.user_usecase import user_usecase
 
 
-class APIClient(user_usecase.as_api_client(base_url=APP_AUTH_BASE_URL), BaseClient):
+class APIClient(user_usecase.as_api_client(base_url=APP_AUTH_BASE_URL), AnyClient):
     pass

zrb/builtin/project/add/fastapp/fastapp_template/module/auth/client/direct_client.py

@@ -0,0 +1,6 @@
+from fastapp_template.module.auth.client.any_client import AnyClient
+from fastapp_template.module.auth.service.user.user_usecase import user_usecase
+
+
+class DirectClient(user_usecase.as_direct_client(), AnyClient):
+    pass

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/module/auth/client/factory.py

@@ -1,9 +1,9 @@
 from fastapp_template.config import APP_COMMUNICATION
-from fastapp_template.module.auth.client.any_client import BaseClient
+from fastapp_template.module.auth.client.any_client import AnyClient
 from fastapp_template.module.auth.client.api_client import APIClient
 from fastapp_template.module.auth.client.direct_client import DirectClient
 
 if APP_COMMUNICATION == "direct":
-    client: BaseClient = DirectClient()
+    client: AnyClient = DirectClient()
 elif APP_COMMUNICATION == "api":
-    client: BaseClient = APIClient()
+    client: AnyClient = APIClient()

zrb/builtin/project/add/fastapp/fastapp_template/module/auth/route.py

@@ -0,0 +1,37 @@
+from fastapi import FastAPI
+from fastapp_template.common.app import app
+from fastapp_template.common.schema import BasicResponse
+from fastapp_template.config import APP_MAIN_MODULE, APP_MODE, APP_MODULES
+from fastapp_template.module.auth.service.user.user_usecase import user_usecase
+
+
+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 "auth" not in APP_MODULES:
+        return
+    if APP_MAIN_MODULE == "auth":
+        serve_health_check(app)
+        serve_readiness_check(app)
+
+    # Serve user endpoints for APIClient
+    user_usecase.serve_route(app)
+
+
+serve_route(app)

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/module/auth/service/user/repository/user_db_repository.py

@@ -3,7 +3,12 @@ from fastapp_template.common.error import NotFoundError
 from fastapp_template.module.auth.service.user.repository.user_repository import (
     UserRepository,
 )
-from fastapp_template.schema.user import User, UserCreate, UserResponse, UserUpdate
+from fastapp_template.schema.user import (
+    User,
+    UserCreateWithAudit,
+    UserResponse,
+    UserUpdateWithAudit,
+)
 from passlib.context import CryptContext
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import Session, select
@@ -17,12 +22,13 @@ def hash_password(password: str) -> str:
 
 
 class UserDBRepository(
-    BaseDBRepository[User, UserResponse, UserCreate, UserUpdate], UserRepository
+    BaseDBRepository[User, UserResponse, UserCreateWithAudit, UserUpdateWithAudit],
+    UserRepository,
 ):
     db_model = User
     response_model = UserResponse
-    create_model = UserCreate
-    update_model = UserUpdate
+    create_model = UserCreateWithAudit
+    update_model = UserUpdateWithAudit
     entity_name = "user"
     column_preprocessors = {"password": hash_password}
 

zrb/builtin/project/add/fastapp/fastapp_template/module/auth/service/user/repository/user_repository.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+
+from fastapp_template.schema.user import (
+    User,
+    UserCreateWithAudit,
+    UserResponse,
+    UserUpdateWithAudit,
+)
+
+
+class UserRepository(ABC):
+
+    @abstractmethod
+    async def create(self, user_data: UserCreateWithAudit) -> UserResponse:
+        pass
+
+    @abstractmethod
+    async def get_by_id(self, user_id: str) -> UserResponse:
+        pass
+
+    @abstractmethod
+    async def get_all(self) -> list[User]:
+        pass
+
+    @abstractmethod
+    async def update(
+        self, user_id: str, user_data: UserUpdateWithAudit
+    ) -> UserResponse:
+        pass
+
+    @abstractmethod
+    async def delete(self, user_id: str) -> UserResponse:
+        pass
+
+    @abstractmethod
+    async def create_bulk(
+        self, user_data_list: list[UserCreateWithAudit]
+    ) -> list[UserResponse]:
+        pass
+
+    @abstractmethod
+    async def get_by_credentials(self, username: str, password: str) -> UserResponse:
+        pass

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/module/auth/service/user/user_usecase.py

@@ -3,7 +3,11 @@ from fastapp_template.module.auth.service.user.repository.factory import user_re
 from fastapp_template.module.auth.service.user.repository.user_repository import (
     UserRepository,
 )
-from fastapp_template.schema.user import UserCreate, UserResponse, UserUpdate
+from fastapp_template.schema.user import (
+    UserCreateWithAudit,
+    UserResponse,
+    UserUpdateWithAudit,
+)
 
 
 class UserUsecase(BaseUsecase):
@@ -30,16 +34,18 @@ class UserUsecase(BaseUsecase):
         response_model=UserResponse | list[UserResponse],
     )
     async def create_user(
-        self, data: UserCreate | list[UserCreate]
+        self, data: UserCreateWithAudit | list[UserCreateWithAudit]
     ) -> UserResponse | list[UserResponse]:
-        if isinstance(data, UserCreate):
+        if isinstance(data, UserCreateWithAudit):
             return await self.user_repository.create(data)
         return await self.user_repository.create_bulk(data)
 
     @BaseUsecase.route(
         "/api/v1/users/{user_id}", methods=["put"], response_model=UserResponse
     )
-    async def update_user(self, user_id: str, data: UserUpdate) -> UserResponse:
+    async def update_user(
+        self, user_id: str, data: UserUpdateWithAudit
+    ) -> UserResponse:
         return await self.user_repository.update(user_id, data)
 
     @BaseUsecase.route(

zrb/builtin/project/add/fastapp/fastapp_template/module/gateway/route.py

@@ -0,0 +1,43 @@
+from fastapi import FastAPI
+from fastapp_template.common.app import app
+from fastapp_template.common.schema import BasicResponse
+from fastapp_template.config import APP_MAIN_MODULE, APP_MODE, APP_MODULES
+from fastapp_template.module.auth.client.factory import client as auth_client
+from fastapp_template.schema.user import UserCreate, UserResponse
+
+
+def serve_health_check(app: FastAPI):
+    @app.api_route("/health", methods=["GET", "HEAD"], response_model=BasicResponse)
+    async def health():
+        """
+        My App Name'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():
+        """
+        My App Name's readiness check
+        """
+        return BasicResponse(message="ok")
+
+
+def serve_route(app: FastAPI):
+    if APP_MODE != "monolith" and "gateway" not in APP_MODULES:
+        return
+    if APP_MODE == "monolith" or APP_MAIN_MODULE == "gateway":
+        serve_health_check(app)
+        serve_readiness_check(app)
+
+    @app.get("/api/v1/users", response_model=list[UserResponse])
+    async def auth_get_all_users() -> UserResponse:
+        return await auth_client.get_all_users()
+
+    @app.post("/api/v1/users", response_model=UserResponse | list[UserResponse])
+    async def auth_create_user(data: UserCreate | list[UserCreate]):
+        return await auth_client.create_user(data)
+
+
+serve_route(app)

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/requirements.txt

@@ -1,4 +1,4 @@
-fastapi[standard]~=0.115.5
+fastapi[standard]~=0.115.6
 alembic~=1.14.0
 sqlmodel~=0.0.22
 ulid-py~=1.1.0

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/schema/permission.py

@@ -12,11 +12,19 @@ class PermissionCreate(PermissionBase):
     description: str
 
 
+class PermissionCreateWithAudit(PermissionCreate):
+    created_by: str
+
+
 class PermissionUpdate(SQLModel):
     name: str | None = None
     description: str | None = None
 
 
+class PermissionUpdateWithAudit(PermissionUpdate):
+    updated_by: str
+
+
 class PermissionResponse(PermissionBase):
     id: str
 

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/schema/role.py

@@ -12,11 +12,19 @@ class RoleCreate(RoleBase):
     description: str
 
 
+class RoleCreateWithAudit(RoleCreate):
+    created_by: str
+
+
 class RoleUpdate(SQLModel):
     name: str | None = None
     description: str | None = None
 
 
+class RoleUpdateWithAudit(RoleUpdate):
+    updated_by: str
+
+
 class RoleResponse(RoleBase):
     id: str
 

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/schema/user.py

@@ -12,11 +12,19 @@ class UserCreate(UserBase):
     password: str
 
 
+class UserCreateWithAudit(UserCreate):
+    created_by: str
+
+
 class UserUpdate(SQLModel):
     username: str | None = None
     password: str | None = None
 
 
+class UserUpdateWithAudit(UserUpdate):
+    updated_by: str
+
+
 class UserResponse(UserBase):
     id: str
 

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

@@ -0,0 +1,22 @@
+from zrb.util.string.conversion import double_quote, to_snake_case
+
+
+def get_zrb_init_import_code(old_code: str) -> str | None:
+    code = "from zrb import load_file"
+    if code in old_code:
+        return None
+    return code
+
+
+def get_zrb_init_load_app_name_task(app: str) -> str:
+    snake_app_name = to_snake_case(app)
+    load_file_param = ", ".join(
+        [double_quote(part) for part in [snake_app_name, "_zrb", "task.py"]]
+    )
+    return "\n".join(
+        [
+            f"# Load {app} automation",
+            f"{snake_app_name} = load_file(os.path.join(_DIR, {load_file_param}))",
+            f"assert {snake_app_name}",
+        ]
+    )

zrb/builtin/project/create/{create.py → project_task.py}

@@ -21,7 +21,7 @@ scaffold_project = Scaffolder(
             name="project",
             description="Project name",
             prompt="Project name",
-            default_str=lambda ctx: os.path.basename(ctx.input["project-dir"]),
+            default_str=lambda ctx: os.path.basename(ctx.input.project_dir),
         ),
     ],
     source_path=os.path.join(_DIR, "project-template"),