zrb 1.0.0b6__tar.gz → 1.0.0b8__tar.gz

{zrb-1.0.0b6 → zrb-1.0.0b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0b6
+Version: 1.0.0b8
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-1.0.0b6 → zrb-1.0.0b8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0b6"
+version = "1.0.0b8"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/__init__.py

@@ -17,6 +17,7 @@ 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.setup.zsh.zsh import setup_zsh
 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
@@ -62,3 +63,4 @@ assert setup_ubuntu
 assert setup_latex_on_ubuntu
 assert setup_asdf
 assert setup_tmux
+assert setup_zsh

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/git.py

@@ -57,9 +57,9 @@ from zrb.util.git import (
 )
 async def get_git_diff(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     diff = await get_diff(
-        repo_dir, ctx.input.source, ctx.input.current, log_method=ctx.print
+        repo_dir, ctx.input.source, ctx.input.current, print_method=ctx.print
     )
     result = []
     decorated = []
@@ -88,17 +88,17 @@ async def get_git_diff(ctx: AnyContext):
 )
 async def prune_local_branches(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get existing branches"))
-    branches = await get_branches(repo_dir, log_method=ctx.print)
+    branches = await get_branches(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
     for branch in branches:
         if branch == current_branch or branch == "main" or branch == "master":
             continue
         ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:
-            await delete_branch(repo_dir, branch, log_method=ctx.print)
+            await delete_branch(repo_dir, branch, print_method=ctx.print)
         except Exception as e:
             ctx.log_error(e)
 
@@ -117,11 +117,11 @@ async def prune_local_branches(ctx: AnyContext):
 )
 async def git_commit(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Add changes to staging"))
-    await add(repo_dir, log_method=ctx.print)
+    await add(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Commit changes"))
-    await commit(repo_dir, ctx.input.message, log_method=ctx.print)
+    await commit(repo_dir, ctx.input.message, print_method=ctx.print)
 
 
 @make_task(
@@ -139,12 +139,12 @@ async def git_commit(ctx: AnyContext):
 )
 async def git_pull(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
     remote = ctx.input.remote
     ctx.print(stylize_faint(f"Pulling from {remote}/{current_branch}"))
-    await pull(repo_dir, remote, current_branch, log_method=ctx.print)
+    await pull(repo_dir, remote, current_branch, print_method=ctx.print)
 
 
 @make_task(
@@ -161,9 +161,9 @@ async def git_pull(ctx: AnyContext):
     alias="push",
 )
 async def git_push(ctx: AnyContext):
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
     remote = ctx.input.remote
     ctx.print(stylize_faint(f"Pushing to {remote}/{current_branch}"))
-    await push(repo_dir, remote, current_branch, log_method=ctx.print)
+    await push(repo_dir, remote, current_branch, print_method=ctx.print)

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/git_subtree.py

@@ -35,7 +35,7 @@ from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_su
 )
 async def git_add_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Add subtree"))
     await add_subtree(
         repo_dir=repo_dir,
@@ -43,7 +43,7 @@ async def git_add_subtree(ctx: AnyContext):
         repo_url=ctx.input["repo-url"],
         branch=ctx.input["repo-branch"],
         prefix=ctx.input["repo-prefix"],
-        log_method=ctx.print,
+        print_method=ctx.print,
     )
 
 
@@ -56,7 +56,7 @@ async def git_add_subtree(ctx: AnyContext):
 )
 async def git_pull_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -69,7 +69,7 @@ async def git_pull_subtree(ctx: AnyContext):
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
-                log_method=ctx.print,
+                print_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:
@@ -88,7 +88,7 @@ async def git_pull_subtree(ctx: AnyContext):
 )
 async def git_push_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -101,7 +101,7 @@ async def git_push_subtree(ctx: AnyContext):
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
-                log_method=ctx.print,
+                print_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/project/add/fastapp/fastapp_task.py

@@ -20,11 +20,11 @@ from zrb.util.string.name import get_random_name
 
 
 @make_task(
-    name="validate-create-fastapp",
+    name="validate-add-fastapp",
     input=[project_dir_input, app_name_input],
     retries=0,
 )
-async def validate_create_fastapp(ctx: AnyContext):
+async def validate_add_fastapp(ctx: AnyContext):
     project_dir = ctx.input.project_dir
     if not os.path.isdir(project_dir):
         raise ValueError(f"Project directory not exists: {project_dir}")
@@ -39,7 +39,7 @@ scaffold_fastapp = Scaffolder(
         project_dir_input,
         app_name_input,
     ],
-    upstream=validate_create_fastapp,
+    upstream=validate_add_fastapp,
     source_path=os.path.join(os.path.dirname(__file__), "fastapp_template"),
     render_source_path=False,
     destination_path="{ctx.input.project_dir}",

zrb-1.0.0b8/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/column/add_column_task.py

@@ -0,0 +1,93 @@
+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 (
+    existing_entity_input,
+    new_column_input,
+    new_column_type_input,
+)
+from my_app_name._zrb.util import get_existing_schema_names
+
+from zrb import AnyContext, Task, make_task
+from zrb.util.codemod.prepend_property_to_class import prepend_property_to_class
+from zrb.util.file import read_file, write_file
+from zrb.util.string.conversion import to_pascal_case, to_snake_case
+
+
+@make_task(
+    name="validate-add-my-app-name-column",
+    input=existing_entity_input,
+    retries=0,
+)
+async def validate_add_my_app_name_column(ctx: AnyContext):
+    schema_name = ctx.input.entity
+    if schema_name not in get_existing_schema_names():
+        raise ValueError(f"Schema not exist: {schema_name}")
+
+
+@make_task(
+    name="update-my-app-name-schema",
+    input=[
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    retries=0,
+    upstream=validate_add_my_app_name_column,
+)
+def update_my_app_name_schema(ctx: AnyContext):
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    schema_file_path = os.path.join(APP_DIR, "schema", f"{snake_entity_name}.py")
+    existing_code = read_file(schema_file_path)
+    snake_column_name = to_snake_case(ctx.input.column)
+    column_type = ctx.input.type
+    # Base
+    new_code = prepend_property_to_class(
+        original_code=existing_code,
+        class_name=f"{pascal_entity_name}Base",
+        property_name=snake_column_name,
+        annotation=column_type,
+        default_value=_get_default_value(column_type),
+    )
+    # Update
+    new_code = prepend_property_to_class(
+        original_code=new_code,
+        class_name=f"{pascal_entity_name}Update",
+        property_name=snake_column_name,
+        annotation=f"{column_type} | None",
+        default_value="None",
+    )
+    # Table
+    new_code = prepend_property_to_class(
+        original_code=new_code,
+        class_name=f"{pascal_entity_name}",
+        property_name=snake_column_name,
+        annotation=f"{column_type} | None",
+        default_value="Field(index=False)",
+    )
+    write_file(schema_file_path, new_code)
+
+
+add_my_app_name_column = app_create_group.add_task(
+    Task(
+        name="add-my-app-name-column",
+        description="📊 Create new column on an entity",
+        upstream=update_my_app_name_schema,
+        successor=format_my_app_name_code,
+        retries=0,
+    ),
+    alias="column",
+)
+
+
+def _get_default_value(data_type: str) -> str:
+    if data_type == "str":
+        return '""'
+    if data_type in ("int", "float"):
+        return "0"
+    if data_type == "bool":
+        return "True"
+    return "None"

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_task.py

@@ -48,7 +48,7 @@ from zrb.util.string.conversion import to_snake_case
 
 
 @make_task(
-    name="validate-create-my-app-name-entity",
+    name="validate-add-my-app-name-entity",
     input=[
         existing_module_input,
         new_entity_input,
@@ -57,7 +57,7 @@ from zrb.util.string.conversion import to_snake_case
     ],
     retries=0,
 )
-async def validate_create_my_app_name_entity(ctx: AnyContext):
+async def validate_add_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}")
@@ -147,7 +147,7 @@ scaffold_my_app_name_entity = Scaffolder(
         ),
     ],
     retries=0,
-    upstream=validate_create_my_app_name_entity,
+    upstream=validate_add_my_app_name_entity,
 )
 
 create_my_app_name_entity_migration = CmdTask(

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/my_entity_service.py

@@ -72,10 +72,8 @@ class MyEntityService(BaseService):
     async def update_my_entity_bulk(
         self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
     ) -> MyEntityResponse:
-        my_entities = await self.my_entity_repository.update_bulk(my_entity_ids, data)
-        return await self.my_entity_repository.get_by_ids(
-            [my_entity.id for my_entity in my_entities]
-        )
+        await self.my_entity_repository.update_bulk(my_entity_ids, data)
+        return await self.my_entity_repository.get_by_ids(my_entity_ids)
 
     @BaseService.route(
         "/api/v1/my-entities/{my_entity_id}",
@@ -85,21 +83,20 @@ class MyEntityService(BaseService):
     async def update_my_entity(
         self, my_entity_id: str, data: MyEntityUpdateWithAudit
     ) -> MyEntityResponse:
-        my_entity = await self.my_entity_repository.update(my_entity_id, data)
-        return await self.my_entity_repository.get_by_id(my_entity.id)
+        await self.my_entity_repository.update(my_entity_id, data)
+        return await self.my_entity_repository.get_by_id(my_entity_id)
 
     @BaseService.route(
-        "/api/v1/my-entities/{my_entity_id}",
+        "/api/v1/my-entities/bulk",
         methods=["delete"],
         response_model=MyEntityResponse,
     )
     async def delete_my_entity_bulk(
         self, my_entity_ids: list[str], deleted_by: str
     ) -> MyEntityResponse:
-        my_entities = await self.my_entity_repository.delete_bulk(my_entity_ids)
-        return await self.my_entity_repository.get_by_ids(
-            [my_entity.id for my_entity in my_entities]
-        )
+        my_entities = await self.my_entity_repository.get_by_ids(my_entity_ids)
+        await self.my_entity_repository.delete_bulk(my_entity_ids)
+        return my_entities
 
     @BaseService.route(
         "/api/v1/my-entities/{my_entity_id}",
@@ -109,5 +106,6 @@ class MyEntityService(BaseService):
     async def delete_my_entity(
         self, my_entity_id: str, deleted_by: str
     ) -> MyEntityResponse:
-        my_entity = await self.my_entity_repository.delete(my_entity_id)
-        return await self.my_entity_repository.get_by_id(my_entity.id)
+        my_entity = await self.my_entity_repository.get_by_id(my_entity.id)
+        await self.my_entity_repository.delete(my_entity_id)
+        return my_entity

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/add_module_task.py

@@ -24,11 +24,11 @@ from zrb import AnyContext, ContentTransformer, Scaffolder, Task, make_task
 
 
 @make_task(
-    name="validate-create-my-app-name-module",
+    name="validate-add-my-app-name-module",
     input=new_module_input,
     retries=0,
 )
-async def validate_create_my_app_name_module(ctx: AnyContext):
+async def validate_add_my_app_name_module(ctx: AnyContext):
     if ctx.input.module in get_existing_module_names():
         raise ValueError(f"Module already exists: {ctx.input.module}")
 
@@ -93,7 +93,7 @@ scaffold_my_app_name_module = Scaffolder(
         ),
     ],
     retries=0,
-    upstream=validate_create_my_app_name_module,
+    upstream=validate_add_my_app_name_module,
 )
 
 add_my_app_name_module = app_create_group.add_task(

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/permission_service.py

@@ -76,10 +76,8 @@ class PermissionService(BaseService):
     async def update_permission_bulk(
         self, permission_ids: list[str], data: PermissionUpdateWithAudit
     ) -> PermissionResponse:
-        permissions = await self.permission_repository.update_bulk(permission_ids, data)
-        return await self.permission_repository.get_by_ids(
-            [permission.id for permission in permissions]
-        )
+        await self.permission_repository.update_bulk(permission_ids, data)
+        return await self.permission_repository.get_by_ids(permission_ids)
 
     @BaseService.route(
         "/api/v1/permissions/{permission_id}",
@@ -89,21 +87,20 @@ class PermissionService(BaseService):
     async def update_permission(
         self, permission_id: str, data: PermissionUpdateWithAudit
     ) -> PermissionResponse:
-        permission = await self.permission_repository.update(permission_id, data)
-        return await self.permission_repository.get_by_id(permission.id)
+        await self.permission_repository.update(permission_id, data)
+        return await self.permission_repository.get_by_id(permission_id)
 
     @BaseService.route(
-        "/api/v1/permissions/{permission_id}",
+        "/api/v1/permissions/bulk",
         methods=["delete"],
         response_model=PermissionResponse,
     )
     async def delete_permission_bulk(
         self, permission_ids: list[str], deleted_by: str
     ) -> PermissionResponse:
-        permissions = await self.permission_repository.delete_bulk(permission_ids)
-        return await self.permission_repository.get_by_ids(
-            [permission.id for permission in permissions]
-        )
+        permissions = await self.permission_repository.get_by_ids(permission_ids)
+        await self.permission_repository.delete_bulk(permission_ids)
+        return permissions
 
     @BaseService.route(
         "/api/v1/permissions/{permission_id}",
@@ -113,5 +110,6 @@ class PermissionService(BaseService):
     async def delete_permission(
         self, permission_id: str, deleted_by: str
     ) -> PermissionResponse:
-        permission = await self.permission_repository.delete(permission_id)
-        return await self.permission_repository.get_by_id(permission.id)
+        permission = await self.permission_repository.get_by_id(permission_id)
+        await self.permission_repository.delete(permission_id)
+        return permission

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/role_service.py

@@ -87,17 +87,15 @@ class RoleService(BaseService):
     ) -> RoleResponse:
         permission_ids = [row.get_permission_ids() for row in data]
         data = [row.get_role_update_with_audit() for row in data]
-        roles = await self.role_repository.update_bulk(role_ids, data)
-        if len(roles) > 0:
-            updated_by = roles[0].updated_by
-            await self.role_repository.remove_all_permissions(
-                [role.id for role in roles]
-            )
+        await self.role_repository.update_bulk(role_ids, data)
+        if len(role_ids) > 0:
+            updated_by = data[0].updated_by
+            await self.role_repository.remove_all_permissions(role_ids)
             await self.role_repository.add_permissions(
-                data={role.id: permission_ids[i] for i, role in enumerate(roles)},
+                data={role_id: permission_ids[i] for i, role_id in enumerate(role_ids)},
                 created_by=updated_by,
             )
-        return await self.role_repository.get_by_ids([role.id for role in roles])
+        return await self.role_repository.get_by_ids(role_ids)
 
     @BaseService.route(
         "/api/v1/roles/{role_id}",
@@ -108,24 +106,26 @@ class RoleService(BaseService):
         self, role_id: str, data: RoleUpdateWithPermissionsAndAudit
     ) -> RoleResponse:
         permission_ids = data.get_permission_ids()
-        data = data.get_role_update_with_audit()
-        role = await self.role_repository.update(role_id, data)
-        await self.role_repository.remove_all_permissions([role.id])
+        role_data = data.get_role_update_with_audit()
+        await self.role_repository.update(role_id, role_data)
+        await self.role_repository.remove_all_permissions([role_id])
         await self.role_repository.add_permissions(
-            data={role.id: permission_ids}, created_by=role.updated_by
+            data={role_id: permission_ids}, created_by=role_data.updated_by
         )
-        return await self.role_repository.get_by_id(role.id)
+        return await self.role_repository.get_by_id(role_id)
 
     @BaseService.route(
-        "/api/v1/roles/{role_id}",
+        "/api/v1/roles/bulk",
         methods=["delete"],
         response_model=RoleResponse,
     )
     async def delete_role_bulk(
         self, role_ids: list[str], deleted_by: str
     ) -> RoleResponse:
-        roles = await self.role_repository.delete_bulk(role_ids)
-        return await self.role_repository.get_by_ids([role.id for role in roles])
+        roles = await self.role_repository.get_by_ids(role_ids)
+        await self.role_repository.delete_bulk(role_ids)
+        await self.role_repository.remove_all_permissions(role_ids)
+        return roles
 
     @BaseService.route(
         "/api/v1/roles/{role_id}",
@@ -133,5 +133,7 @@ class RoleService(BaseService):
         response_model=RoleResponse,
     )
     async def delete_role(self, role_id: str, deleted_by: str) -> RoleResponse:
-        role = await self.role_repository.delete(role_id)
-        return await self.role_repository.get_by_id(role.id)
+        role = await self.role_repository.get_by_id(role_id)
+        await self.role_repository.delete(role_id)
+        await self.role_repository.remove_all_permissions([role_id])
+        return role

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/user_service.py

@@ -84,16 +84,16 @@ class UserService(BaseService):
         self, user_ids: list[str], data: UserUpdateWithRolesAndAudit
     ) -> UserResponse:
         role_ids = [row.get_role_ids() for row in data]
-        data = [row.get_user_create_with_audit() for row in data]
-        users = await self.user_repository.update_bulk(user_ids, data)
-        if len(users) > 0:
-            updated_by = users[0].updated_by
-            await self.user_repository.remove_all_roles([user.id for user in users])
+        user_data = [row.get_user_create_with_audit() for row in data]
+        await self.user_repository.update_bulk(user_ids, user_data)
+        if len(user_ids) > 0:
+            updated_by = user_data[0].updated_by
+            await self.user_repository.remove_all_roles(user_ids)
             await self.user_repository.add_roles(
-                data={user.id: role_ids[i] for i, user in enumerate(data)},
+                data={user_id: role_ids[i] for i, user_id in enumerate(user_ids)},
                 updated_by=updated_by,
             )
-        return await self.user_repository.get_by_ids([user.id for user in users])
+        return await self.user_repository.get_by_ids(user_ids)
 
     @BaseService.route(
         "/api/v1/users/{user_id}",
@@ -103,19 +103,27 @@ class UserService(BaseService):
     async def update_user(
         self, user_id: str, data: UserUpdateWithRolesAndAudit
     ) -> UserResponse:
-        user = await self.user_repository.update(user_id, data)
-        return await self.user_repository.get_by_id(user.id)
+        role_ids = data.get_role_ids()
+        user_data = data.get_user_update_with_audit()
+        await self.user_repository.update(user_id, user_data)
+        await self.user_repository.remove_all_roles([user_id])
+        await self.user_repository.add_roles(
+            data={user_id: role_ids}, created_by=user_data.updated_by
+        )
+        return await self.user_repository.get_by_id(user_id)
 
     @BaseService.route(
-        "/api/v1/users/{user_id}",
+        "/api/v1/users/bulk",
         methods=["delete"],
         response_model=UserResponse,
     )
     async def delete_user_bulk(
         self, user_ids: list[str], deleted_by: str
     ) -> UserResponse:
-        users = await self.user_repository.delete_bulk(user_ids)
-        return await self.user_repository.get_by_ids([user.id for user in users])
+        roles = await self.user_repository.get_by_ids(user_ids)
+        await self.user_repository.delete_bulk(user_ids)
+        await self.user_repository.remove_all_roles(user_ids)
+        return roles
 
     @BaseService.route(
         "/api/v1/users/{user_id}",
@@ -123,5 +131,7 @@ class UserService(BaseService):
         response_model=UserResponse,
     )
     async def delete_user(self, user_id: str, deleted_by: str) -> UserResponse:
-        user = await self.user_repository.delete(user_id)
-        return await self.user_repository.get_by_id(user.id)
+        user = await self.user_repository.get_by_id(user_id)
+        await self.user_repository.delete(user_id)
+        await self.user_repository.remove_all_roles([user_id])
+        return user

{zrb-1.0.0b6 → zrb-1.0.0b8}/src/zrb/builtin/setup/tmux/tmux.py

@@ -24,7 +24,7 @@ install_tmux = CmdTask(
         prompt="Tmux config file",
         default_str="~/.tmux.conf",
     ),
-    description="🖥️ Setup `tmux`.",
+    description="📺 Setup `tmux`.",
     group=setup_group,
     alias="tmux",
 )

zrb-1.0.0b8/src/zrb/builtin/setup/zsh/zsh.py

@@ -0,0 +1,55 @@
+import os
+
+from zrb.builtin.group import setup_group
+from zrb.builtin.setup.common_input import package_manager_input, use_sudo_input
+from zrb.builtin.setup.zsh.zsh_helper import get_install_zsh_cmd
+from zrb.context.any_context import AnyContext
+from zrb.input.str_input import StrInput
+from zrb.task.cmd_task import CmdTask
+from zrb.task.make_task import make_task
+from zrb.util.file import read_file, write_file
+
+install_zsh = CmdTask(
+    name="install-zsh",
+    input=[package_manager_input, use_sudo_input],
+    cmd=get_install_zsh_cmd,
+)
+
+install_omz = CmdTask(
+    name="install-omz",
+    cmd='sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"',  # noqa
+    upstream=install_zsh,
+)
+
+install_zinit = CmdTask(
+    name="install-zinit",
+    cmd='bash -c "$(curl --fail --show-error --silent --location https://raw.githubusercontent.com/zdharma-continuum/zinit/HEAD/scripts/install.sh)"',  # noqa
+    upstream=install_zsh,
+)
+
+
+@make_task(
+    name="setup-zsh",
+    input=StrInput(
+        name="zsh-config",
+        description="zsh config file",
+        prompt="zsh config file",
+        default_str="~/.zshrc",
+    ),
+    upstream=[install_omz, install_zinit],
+    description="💻 Setup `zsh`.",
+    group=setup_group,
+    alias="zsh",
+)
+def setup_zsh(ctx: AnyContext):
+    zsh_config = read_file(os.path.join(os.path.dirname(__file__), "zsh_config.sh"))
+    zsh_config_file = os.path.expanduser(ctx.input["zsh-config"])
+    # Make sure config file exists
+    if not os.path.isfile(zsh_config_file):
+        write_file(zsh_config_file, "")
+    content = read_file(zsh_config_file)
+    if zsh_config in content:
+        return
+    # Write config
+    write_file(zsh_config_file, [content, zsh_config, ""])
+    ctx.print("Setup complete, restart your terminal to continue")