zrb 1.0.0b9__py3-none-any.whl → 1.0.0b10__py3-none-any.whl

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

@@ -4,8 +4,8 @@ from my_app_name._zrb.config import APP_DIR
 from my_app_name._zrb.util import get_existing_module_names
 
 from zrb.context.any_context import AnyContext
-from zrb.util.codemod.append_code_to_function import append_code_to_function
-from zrb.util.codemod.append_key_to_dict import append_key_to_dict
+from zrb.util.codemod.modify_dict import append_key_to_dict
+from zrb.util.codemod.modify_function import append_code_to_function
 from zrb.util.file import read_file, write_file
 from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
 

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

@@ -1,4 +1,9 @@
-from fastapi import FastAPI
+from typing import Annotated
+
+from fastapi import Depends, FastAPI
+from my_app_name.common.error import ForbiddenError
+from my_app_name.module.gateway.util.auth import get_current_user
+from my_app_name.schema.user import AuthUserResponse
 
 
 def serve_my_module_route(app: FastAPI):

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

@@ -1,26 +1,30 @@
 # 🔐 Run/Migrate My Module ==========================================================
 
 run_my_module = app_run_group.add_task(
-    run_microservice("my-module", 3000, "my_module"), alias="svc-my_module"
+    run_microservice("my_module", 3000), alias="svc-my-module"
 )
 prepare_venv >> run_my_module >> run_microservices
 
 create_my_module_migration = app_create_migration_group.add_task(
-    create_migration("my-module", "my_module"), alias="my_module"
+    create_migration("my_module"), alias="my_module"
 )
 prepare_venv >> create_my_module_migration >> create_all_migration
 
-migrate_monolith_my_module = migrate_module(
-    "my_module", "my_module", as_microservices=False
-)
+migrate_monolith_my_module = migrate_module("my_module", as_microservices=False)
 prepare_venv >> migrate_monolith_my_module >> [migrate_monolith, run_monolith]
 
 migrate_microservices_my_module = app_migrate_group.add_task(
-    migrate_module("my-module", "my_module", as_microservices=True),
+    migrate_module("my_module", as_microservices=True),
     alias="svc-my-module",
 )
+
 (
     prepare_venv
     >> migrate_microservices_my_module
     >> [migrate_microservices, run_my_module]
 )
+
+migrate_test_my_module = migrate_module(
+    "my_module", as_microservices=False, additional_env_vars=TEST_ENV_VARS
+)
+prepare_venv >> migrate_test_my_module >> migrate_test

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

@@ -1,11 +1,17 @@
 import os
 
 from my_app_name._zrb.column.add_column_task import add_my_app_name_column
-from my_app_name._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR, MONOLITH_ENV_VARS
+from my_app_name._zrb.config import (
+    ACTIVATE_VENV_SCRIPT,
+    APP_DIR,
+    MONOLITH_ENV_VARS,
+    TEST_ENV_VARS,
+)
 from my_app_name._zrb.entity.add_entity_task import add_my_app_name_entity
 from my_app_name._zrb.format_task import format_my_app_name_code
 from my_app_name._zrb.group import (
     app_create_migration_group,
+    app_group,
     app_migrate_group,
     app_run_group,
 )
@@ -19,13 +25,42 @@ from my_app_name._zrb.task_util import (
 )
 from my_app_name._zrb.venv_task import prepare_venv
 
-from zrb import CmdTask, EnvFile, EnvMap, Task
+from zrb import AnyContext, CmdPath, CmdTask, EnvFile, EnvMap, Task, make_task
 
 assert add_my_app_name_entity
 assert add_my_app_name_module
 assert add_my_app_name_column
 assert format_my_app_name_code
 
+# 🧪 Test ======================================================================
+
+
+@make_task(
+    name="prepare-my-app-name-test",
+)
+def prepare_test(ctx: AnyContext):
+    db_test_path = os.path.join(APP_DIR, "test.db")
+    if os.path.exists(db_test_path):
+        ctx.print(f"Removing test db: {db_test_path}")
+        os.remove(db_test_path)
+
+
+migrate_test = Task(name="migrate-test")
+
+test_app = app_group.add_task(
+    CmdTask(
+        name="test-my-app-name",
+        description="🧪 Test My App Name",
+        env=EnvMap(vars=TEST_ENV_VARS),
+        cwd=APP_DIR,
+        cmd=CmdPath(os.path.join(APP_DIR, "test.sh")),
+        retries=0,
+    ),
+    alias="test",
+)
+prepare_venv >> prepare_test >> migrate_test >> test_app
+
+
 # 🚀 Run/Migrate All ===========================================================
 
 run_all = app_run_group.add_task(
@@ -107,40 +142,49 @@ migrate_microservices >> migrate_all
 # 📡 Run/Migrate Gateway =======================================================
 
 run_gateway = app_run_group.add_task(
-    run_microservice("gateway", 3001, "gateway"), alias="svc-gateway"
+    run_microservice("gateway", 3001), alias="svc-gateway"
 )
 prepare_venv >> run_gateway >> run_microservices
 
 create_gateway_migration = app_create_migration_group.add_task(
-    create_migration("gateway", "gateway"), alias="gateway"
+    create_migration("gateway"), alias="gateway"
 )
 prepare_venv >> create_gateway_migration >> create_all_migration
 
-migrate_monolith_gateway = migrate_module("gateway", "gateway", as_microservices=False)
+migrate_monolith_gateway = migrate_module("gateway", as_microservices=False)
 prepare_venv >> migrate_monolith_gateway >> [migrate_monolith, run_monolith]
 
 migrate_microservices_gateway = app_migrate_group.add_task(
-    migrate_module("gateway", "gateway", as_microservices=True),
+    migrate_module("gateway", as_microservices=True),
     alias="svc-gateway",
 )
 prepare_venv >> migrate_microservices_gateway >> [migrate_microservices, run_gateway]
 
+migrate_test_gateway = migrate_module(
+    "gateway", as_microservices=False, additional_env_vars=TEST_ENV_VARS
+)
+prepare_venv >> migrate_test_gateway >> migrate_test
+
+
 # 🔐 Run/Migrate Auth ==========================================================
 
-run_auth = app_run_group.add_task(
-    run_microservice("auth", 3002, "auth"), alias="svc-auth"
-)
+run_auth = app_run_group.add_task(run_microservice("auth", 3002), alias="svc-auth")
 prepare_venv >> run_auth >> run_microservices
 
 create_auth_migration = app_create_migration_group.add_task(
-    create_migration("auth", "auth"), alias="auth"
+    create_migration("auth"), alias="auth"
 )
 prepare_venv >> create_auth_migration >> create_all_migration
 
-migrate_monolith_auth = migrate_module("auth", "auth", as_microservices=False)
+migrate_monolith_auth = migrate_module("auth", as_microservices=False)
 prepare_venv >> migrate_monolith_auth >> [migrate_monolith, run_monolith]
 
 migrate_microservices_auth = app_migrate_group.add_task(
-    migrate_module("auth", "auth", as_microservices=True), alias="svc-auth"
+    migrate_module("auth", as_microservices=True), alias="svc-auth"
 )
 prepare_venv >> migrate_microservices_auth >> [migrate_microservices, run_auth]
+
+migrate_test_auth = migrate_module(
+    "auth", as_microservices=False, additional_env_vars=TEST_ENV_VARS
+)
+prepare_venv >> migrate_test_auth >> migrate_test

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

@@ -16,10 +16,11 @@ from my_app_name._zrb.util import (
 )
 
 from zrb import Cmd, CmdTask, EnvFile, EnvMap, StrInput, Task
-from zrb.util.string.conversion import to_snake_case
+from zrb.util.string.conversion import to_kebab_case, to_snake_case
 
 
-def create_migration(name: str, module: str) -> Task:
+def create_migration(module: str) -> Task:
+    name = to_kebab_case(module)
     return CmdTask(
         name=f"create-my-app-name-{name}-migration",
         description=f"🧩 Create My App Name {name.capitalize()} DB migration",
@@ -47,10 +48,14 @@ def create_migration(name: str, module: str) -> Task:
     )
 
 
-def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
+def migrate_module(
+    module: str, as_microservices: bool, additional_env_vars: dict[str, str] = {}
+) -> Task:
+    name = to_kebab_case(module)
     env_vars = (
         dict(MICROSERVICES_ENV_VARS) if as_microservices else dict(MONOLITH_ENV_VARS)
     )
+    env_vars.update(additional_env_vars)
     if as_microservices:
         env_vars["MY_APP_NAME_MODULES"] = to_snake_case(module)
     return CmdTask(
@@ -75,7 +80,8 @@ def migrate_module(name: str, module: str, as_microservices: bool) -> Task:
     )
 
 
-def run_microservice(name: str, port: int, module: str) -> Task:
+def run_microservice(module: str, port: int) -> Task:
+    name = to_kebab_case(module)
     return CmdTask(
         name=f"run-my-app-name-{name}",
         description=f"🧩 Run My App Name {name.capitalize()}",

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_service.py

@@ -2,10 +2,10 @@ import inspect
 from enum import Enum
 from functools import partial
 from logging import Logger
-from typing import Any, Callable, Sequence
+from typing import Any, Callable, Union, get_args, get_origin
 
 import httpx
-from fastapi import APIRouter, Depends, params
+from fastapi import APIRouter, Depends
 from my_app_name.common.error import ClientAPIError
 from pydantic import BaseModel
 
@@ -162,58 +162,20 @@ def _create_direct_client_method(logger: Logger, func: Callable, service: BaseSe
 def _create_api_client_method(logger: Logger, route_param: RouteParam, base_url: str):
     async def client_method(*args, **kwargs):
         url = base_url + route_param.path
-        method = (
-            route_param.methods[0].lower()
-            if isinstance(route_param.methods, list)
-            else route_param.methods.lower()
+        method = _get_api_client_method(route_param)
+        body_param_names = _get_api_client_body_param_names(route_param, method)
+        path_params, query_params, body_params = _create_api_client_request_params(
+            route_param, body_param_names, args, kwargs
         )
-        # Get the signature of the original function
-        sig = inspect.signature(route_param.func)
-        # Bind the arguments to the signature
-        bound_args = sig.bind(*args, **kwargs)
-        bound_args.apply_defaults()
-        # Analyze parameters
-        function_params = list(sig.parameters.values())
-        body_param_names = [
-            p.name
-            for p in function_params
-            if (
-                p.name != "self"
-                and f"{{{p.name}}}" not in route_param.path
-                and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
-                and (
-                    method not in ["get", "delete"]
-                    or (method == "delete" and p.annotation not in [str, float, bool])
-                )
-            )
-        ]
-        # Prepare the request
-        path_params = {}
-        query_params = {}
-        body_params = {}
-        for name, value in bound_args.arguments.items():
-            if name == "self":
-                continue
-            if f"{{{name}}}" in route_param.path:
-                path_params[name] = value
-            elif name not in body_param_names:
-                query_params[name] = _parse_api_param(value)
-            elif len(body_param_names) == 1 and name == body_param_names[0]:
-                # If there's only one body parameter, use its value directly
-                body_params = _parse_api_param(value)
-            else:
-                body_params[name] = _parse_api_param(value)
         # Format the URL with path parameters
         url = url.format(**path_params)
+        json_body_params = None if method == "get" else body_params
         logger.info(
-            f"Sending request to {url} with method {method}, json={body_params}, params={query_params}"  # noqa
+            f"Sending request to {url} with method {method}, json={json_body_params}, params={query_params}"  # noqa
         )
         async with httpx.AsyncClient() as client:
             response = await client.request(
-                method=method,
-                url=url,
-                params=query_params,
-                json=None if method == "get" else body_params,
+                method=method, url=url, params=query_params, json=json_body_params
             )
             logger.info(
                 f"Received response: status={response.status_code}, content={response.content}"
@@ -225,17 +187,139 @@ def _create_api_client_method(logger: Logger, route_param: RouteParam, base_url:
                     else response.text
                 )
                 raise ClientAPIError(response.status_code, error_detail)
-            return response.json()
+            return _parse_api_client_response(logger, route_param, response)
 
     return client_method
 
 
-def _parse_api_param(data: Any) -> Any:
+def _parse_api_client_response(
+    logger: Logger, route_param: RouteParam, response: Any
+) -> Any:
+    sig = inspect.signature(route_param.func)
+    try:
+        response_data = response.json()
+    except Exception:
+        logger.warning("Failed to parse JSON")
+        return None
+    return_annotation = sig.return_annotation  # e.g., list[User]
+    if return_annotation is inspect.Signature.empty:
+        logger.warning("No return annotation detected, return value as is")
+        return response_data  # No return type specified, return raw JSON
+    origin = get_origin(return_annotation)  # e.g., list
+    args = get_args(return_annotation)  # e.g., (User,)
+    try:
+        if origin is None:  # Not a generic type, so check it directly
+            if inspect.isclass(return_annotation) and issubclass(
+                return_annotation, BaseModel
+            ):
+                if response_data:
+                    return return_annotation.model_validate(response_data)
+                return None
+        elif origin in {list, set, tuple} and args:
+            model_type = args[0]
+            if inspect.isclass(model_type) and issubclass(model_type, BaseModel):
+                if isinstance(response_data, list):
+                    return [model_type.model_validate(item) for item in response_data]
+                elif isinstance(response_data, tuple):
+                    return tuple(
+                        model_type.model_validate(item) for item in response_data
+                    )
+                elif isinstance(response_data, set):
+                    return {model_type.model_validate(item) for item in response_data}
+                return None
+        elif origin is Union and len(args) == 2 and type(None) in args:
+            model_type = next(
+                (
+                    arg
+                    for arg in args
+                    if inspect.isclass(arg) and issubclass(arg, BaseModel)
+                ),
+                None,
+            )
+            if response_data and model_type:
+                return model_type.model_validate(response_data)
+            return None
+        elif origin is dict and len(args) == 2:
+            key_type, value_type = args
+            if inspect.isclass(value_type) and issubclass(value_type, BaseModel):
+                if inspect(response_data, dict):
+                    return {
+                        k: value_type.model_validate(v)
+                        for k, v in response_data.items()
+                    }
+                return None
+        return response_data
+    except Exception:
+        logger.warning(
+            "Return annotation detected, but parsing error, return value as is"
+        )
+        return response_data
+
+
+def _create_api_client_request_params(
+    route_param: RouteParam,
+    body_param_names: list[str],
+    args: list[Any],
+    kwargs: dict[str, Any],
+) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]:
+    # Get the signature of the original function
+    sig = inspect.signature(route_param.func)
+    # Bind the arguments to the signature
+    bound_args = sig.bind(*args, **kwargs)
+    bound_args.apply_defaults()
+    # Prepare the request
+    path_params = {}
+    query_params = {}
+    body_params = {}
+    for name, value in bound_args.arguments.items():
+        if name == "self":
+            continue
+        if f"{{{name}}}" in route_param.path:
+            path_params[name] = value
+        elif name not in body_param_names:
+            query_params[name] = _parse_api_client_param(value)
+        elif len(body_param_names) == 1 and name == body_param_names[0]:
+            # If there's only one body parameter, use its value directly
+            body_params = _parse_api_client_param(value)
+        else:
+            body_params[name] = _parse_api_client_param(value)
+    return path_params, query_params, body_params
+
+
+def _parse_api_client_param(data: Any) -> Any:
     if isinstance(data, BaseModel):
         return data.model_dump()
-    elif isinstance(data, list):
-        return [_parse_api_param(item) for item in data]
     elif isinstance(data, dict):
-        return {key: _parse_api_param(value) for key, value in data.items()}
+        return {key: _parse_api_client_param(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [_parse_api_client_param(item) for item in data]
+    elif isinstance(data, tuple):
+        return tuple(_parse_api_client_param(item) for item in data)
+    elif isinstance(data, set):
+        return {_parse_api_client_param(item) for item in data}
     else:
         return data
+
+
+def _get_api_client_method(route_param: RouteParam) -> str:
+    if isinstance(route_param.methods, list):
+        return route_param.methods[0].lower()
+    return route_param.methods.lower()
+
+
+def _get_api_client_body_param_names(route_param: RouteParam, method: str):
+    sig = inspect.signature(route_param.func)
+    function_params = list(sig.parameters.values())
+    return [
+        p.name
+        for p in function_params
+        if (
+            p.name != "self"
+            and f"{{{p.name}}}" not in route_param.path
+            and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+            and (
+                method not in ["get", "delete"]
+                or (method == "delete" and p.annotation not in [str, float, bool])
+            )
+        )
+    ]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/util/parser.py

@@ -45,7 +45,7 @@ def create_default_filter_param_parser() -> (
     Callable[[SQLModel, str], list[ClauseElement]]
 ):
     def parse_filter_param(model: SQLModel, query: str) -> list[ClauseElement]:
-        """
+        r"""
         Parse the filter parameter and return a list of SQLAlchemy ClauseElement objects.
 
         Args:

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

@@ -80,4 +80,5 @@ APP_AUTH_SECRET_KEY = os.getenv("MY_APP_NAME_AUTH_SECRET_KEY", "my-secret-key")
 APP_AUTH_PRIORITIZE_NEW_SESSION = (
     os.getenv("MY_APP_NAME_AUTH_PRIORITIZE_NEW_SESSION", "1").lower() in TRUE_STRS
 )
+
 APP_AUTH_BASE_URL = os.getenv("MY_APP_NAME_AUTH_BASE_URL", "http://localhost:3001")

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/migration/versions/3093c7336477_add_auth_tables.py

@@ -32,18 +32,18 @@ def upgrade() -> None:
         sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
         sa.PrimaryKeyConstraint("id"),
     )
-    op.create_index(op.f("ix_permission_name"), "permissions", ["name"], unique=True)
+    op.create_index(op.f("ix_permissions_name"), "permissions", ["name"], unique=True)
     op.create_index(
-        op.f("ix_permission_created_at"), "permissions", ["created_at"], unique=False
+        op.f("ix_permissions_created_at"), "permissions", ["created_at"], unique=False
     )
     op.create_index(
-        op.f("ix_permission_created_by"), "permissions", ["created_by"], unique=False
+        op.f("ix_permissions_created_by"), "permissions", ["created_by"], unique=False
     )
     op.create_index(
-        op.f("ix_permission_updated_at"), "permissions", ["updated_at"], unique=False
+        op.f("ix_permissions_updated_at"), "permissions", ["updated_at"], unique=False
     )
     op.create_index(
-        op.f("ix_permission_updated_by"), "permissions", ["updated_by"], unique=False
+        op.f("ix_permissions_updated_by"), "permissions", ["updated_by"], unique=False
     )
 
     op.create_table(
@@ -57,11 +57,11 @@ def upgrade() -> None:
         sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
         sa.PrimaryKeyConstraint("id"),
     )
-    op.create_index(op.f("ix_role_name"), "roles", ["name"], unique=True)
-    op.create_index(op.f("ix_role_created_at"), "roles", ["created_at"], unique=False)
-    op.create_index(op.f("ix_role_created_by"), "roles", ["created_by"], unique=False)
-    op.create_index(op.f("ix_role_updated_at"), "roles", ["updated_at"], unique=False)
-    op.create_index(op.f("ix_role_updated_by"), "roles", ["updated_by"], unique=False)
+    op.create_index(op.f("ix_roles_name"), "roles", ["name"], unique=True)
+    op.create_index(op.f("ix_roles_created_at"), "roles", ["created_at"], unique=False)
+    op.create_index(op.f("ix_roles_created_by"), "roles", ["created_by"], unique=False)
+    op.create_index(op.f("ix_roles_updated_at"), "roles", ["updated_at"], unique=False)
+    op.create_index(op.f("ix_roles_updated_by"), "roles", ["updated_by"], unique=False)
 
     op.create_table(
         "role_permissions",
@@ -97,12 +97,12 @@ def upgrade() -> None:
         sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
         sa.PrimaryKeyConstraint("id"),
     )
-    op.create_index(op.f("ix_user_username"), "users", ["username"], unique=True)
-    op.create_index(op.f("ix_user_active"), "users", ["active"], unique=False)
-    op.create_index(op.f("ix_user_created_at"), "users", ["created_at"], unique=False)
-    op.create_index(op.f("ix_user_created_by"), "users", ["created_by"], unique=False)
-    op.create_index(op.f("ix_user_updated_at"), "users", ["updated_at"], unique=False)
-    op.create_index(op.f("ix_user_updated_by"), "users", ["updated_by"], unique=False)
+    op.create_index(op.f("ix_users_username"), "users", ["username"], unique=True)
+    op.create_index(op.f("ix_users_active"), "users", ["active"], unique=False)
+    op.create_index(op.f("ix_users_created_at"), "users", ["created_at"], unique=False)
+    op.create_index(op.f("ix_users_created_by"), "users", ["created_by"], unique=False)
+    op.create_index(op.f("ix_users_updated_at"), "users", ["updated_at"], unique=False)
+    op.create_index(op.f("ix_users_updated_by"), "users", ["updated_by"], unique=False)
 
     op.create_table(
         "user_roles",
@@ -131,24 +131,27 @@ def upgrade() -> None:
         sa.PrimaryKeyConstraint("id"),
     )
     op.create_index(
-        op.f("ix_user_session_user_id"), "user_sessions", ["user_id"], unique=False
+        op.f("ix_user_sessions_user_id"), "user_sessions", ["user_id"], unique=False
     )
     op.create_index(
-        op.f("ix_user_session_token"), "user_sessions", ["access_token"], unique=True
+        op.f("ix_user_sessions_access_token"),
+        "user_sessions",
+        ["access_token"],
+        unique=False,
     )
     op.create_index(
-        op.f("ix_user_session_refresh_token"),
+        op.f("ix_user_sessions_refresh_token"),
         "user_sessions",
         ["refresh_token"],
-        unique=True,
+        unique=False,
     )
     op.create_index(
-        op.f("ix_user_session_access_token_expired_at"),
+        op.f("ix_user_sessions_access_token_expired_at"),
         "user_sessions",
         ["access_token_expired_at"],
     )
     op.create_index(
-        op.f("ix_user_session_refresh_token_expired_at"),
+        op.f("ix_user_sessions_refresh_token_expired_at"),
         "user_sessions",
         ["refresh_token_expired_at"],
     )
@@ -157,14 +160,14 @@ def upgrade() -> None:
 
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f("ix_user_session_user_id"), table_name="user_sessions")
-    op.drop_index(op.f("ix_user_session_access_token"), table_name="user_sessions")
-    op.drop_index(op.f("ix_user_session_refresh_token"), table_name="user_sessions")
+    op.drop_index(op.f("ix_user_sessions_user_id"), table_name="user_sessions")
+    op.drop_index(op.f("ix_user_sessions_access_token"), table_name="user_sessions")
+    op.drop_index(op.f("ix_user_sessions_refresh_token"), table_name="user_sessions")
     op.drop_index(
-        op.f("ix_user_session_access_token_expired_at"), table_name="user_sessions"
+        op.f("ix_user_sessions_access_token_expired_at"), table_name="user_sessions"
     )
     op.drop_index(
-        op.f("ix_user_session_refresh_token_expired_at"), table_name="user_sessions"
+        op.f("ix_user_sessions_refresh_token_expired_at"), table_name="user_sessions"
     )
     op.drop_table("user_sessions")
 
@@ -172,12 +175,12 @@ def downgrade() -> None:
     op.drop_index(op.f("ix_user_roles_role_id"), table_name="user_roles")
     op.drop_table("user_roles")
 
-    op.drop_index(op.f("ix_user_username"), table_name="users")
-    op.drop_index(op.f("ix_user_active"), table_name="users")
-    op.drop_index(op.f("ix_user_updated_by"), table_name="users")
-    op.drop_index(op.f("ix_user_updated_at"), table_name="users")
-    op.drop_index(op.f("ix_user_created_by"), table_name="users")
-    op.drop_index(op.f("ix_user_created_at"), table_name="users")
+    op.drop_index(op.f("ix_users_username"), table_name="users")
+    op.drop_index(op.f("ix_users_active"), table_name="users")
+    op.drop_index(op.f("ix_users_updated_by"), table_name="users")
+    op.drop_index(op.f("ix_users_updated_at"), table_name="users")
+    op.drop_index(op.f("ix_users_created_by"), table_name="users")
+    op.drop_index(op.f("ix_users_created_at"), table_name="users")
     op.drop_table("users")
 
     op.drop_index(op.f("ix_role_permissions_role_id"), table_name="role_permissions")
@@ -186,17 +189,17 @@ def downgrade() -> None:
     )
     op.drop_table("role_permissions")
 
-    op.drop_index(op.f("ix_role_name"), table_name="roles")
-    op.drop_index(op.f("ix_role_updated_by"), table_name="roles")
-    op.drop_index(op.f("ix_role_updated_at"), table_name="roles")
-    op.drop_index(op.f("ix_role_created_by"), table_name="roles")
-    op.drop_index(op.f("ix_role_created_at"), table_name="roles")
+    op.drop_index(op.f("ix_roles_name"), table_name="roles")
+    op.drop_index(op.f("ix_roles_updated_by"), table_name="roles")
+    op.drop_index(op.f("ix_roles_updated_at"), table_name="roles")
+    op.drop_index(op.f("ix_roles_created_by"), table_name="roles")
+    op.drop_index(op.f("ix_roles_created_at"), table_name="roles")
     op.drop_table("roles")
 
-    op.drop_index(op.f("ix_permission_updated_by"), table_name="permissions")
-    op.drop_index(op.f("ix_permission_updated_at"), table_name="permissions")
-    op.drop_index(op.f("ix_permission_created_by"), table_name="permissions")
-    op.drop_index(op.f("ix_permission_created_at"), table_name="permissions")
-    op.drop_index(op.f("ix_permission_name"), table_name="permissions")
+    op.drop_index(op.f("ix_permissions_updated_by"), table_name="permissions")
+    op.drop_index(op.f("ix_permissions_updated_at"), table_name="permissions")
+    op.drop_index(op.f("ix_permissions_created_by"), table_name="permissions")
+    op.drop_index(op.f("ix_permissions_created_at"), table_name="permissions")
+    op.drop_index(op.f("ix_permissions_name"), table_name="permissions")
     op.drop_table("permissions")
     # ### end Alembic commands ###