zrb 1.0.0b2__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

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

@@ -4,10 +4,15 @@ from typing import Any, Callable, Generic, Type, TypeVar
 
 import ulid
 from my_app_name.common.error import InvalidValueError, NotFoundError
-from my_app_name.common.parser_factory import parse_filter_param, parse_sort_param
+from my_app_name.common.parser_factory import (
+    parse_filter_param as default_parse_filter_param,
+)
+from my_app_name.common.parser_factory import (
+    parse_sort_param as default_parse_sort_param,
+)
 from sqlalchemy import Engine, delete, func, insert, select, update
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
-from sqlalchemy.sql import Select
+from sqlalchemy.sql import ClauseElement, ColumnElement, Select
 from sqlmodel import Session, SQLModel
 
 DBModel = TypeVar("DBModel", bound=SQLModel)
@@ -24,16 +29,48 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
     entity_name: str = "entity"
     column_preprocessors: dict[str, Callable[[Any], Any]] = {}
 
-    def __init__(self, engine: Engine | AsyncEngine):
+    def __init__(
+        self,
+        engine: Engine | AsyncEngine,
+        filter_param_parser: (
+            Callable[[SQLModel, str], list[ClauseElement]] | None
+        ) = None,
+        sort_param_parser: Callable[[SQLModel, str], list[ColumnElement]] | None = None,
+    ):
         self.engine = engine
-        self.is_async = isinstance(engine, AsyncEngine)
+        self._is_async = isinstance(engine, AsyncEngine)
+        self._parse_filter_param = (
+            filter_param_parser if filter_param_parser else default_parse_filter_param
+        )
+        self._parse_sort_param = (
+            sort_param_parser if sort_param_parser else default_parse_sort_param
+        )
+
+    @property
+    def is_async(self) -> bool:
+        return self._is_async
 
     def _select(self) -> Select:
+        """
+        This method is used to contruct select statement for get, get_by_id and get_by_ids.
+        To parse the result of the statement, make sure you override _rows_to_response as well.
+        """
         return select(self.db_model)
 
-    def _rows_to_responses(self, rows: list[tuple[Any]]) -> list[ResponseModel]:
+    def _rows_to_responses(self, rows: list[tuple[Any, ...]]) -> list[ResponseModel]:
+        """
+        This method is used to parse the result of select statement generated by _select.
+        """
         return [self.response_model.model_validate(row[0]) for row in rows]
 
+    async def _select_to_response(
+        self, query_modifier: Callable[[Select], Any]
+    ) -> list[ResponseModel]:
+        statement = query_modifier(self._select())
+        async with self._session_scope() as session:
+            result = await self._execute_statement(session, statement)
+            return self._rows_to_responses(result.all())
+
     def _ensure_one(self, responses: list[ResponseModel]) -> ResponseModel:
         if not responses:
             raise NotFoundError(f"{self.entity_name} not found")
@@ -41,6 +78,22 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             raise InvalidValueError(f"Duplicate {self.entity_name}")
         return responses[0]
 
+    def _model_to_data_dict(
+        self, data: SQLModel, **additional_data: Any
+    ) -> dict[str, Any]:
+        """
+        This method transform SQLModel into dictionary for insert/update operation.
+        """
+        data_dict = data.model_dump(exclude_unset=True)
+        data_dict.update(additional_data)
+        for key, preprocessor in self.column_preprocessors.items():
+            if key not in data_dict:
+                continue
+            if not hasattr(self.db_model, key):
+                raise InvalidValueError(f"Invalid {self.entity_name} property: {key}")
+            data_dict[key] = preprocessor(data_dict[key])
+        return data_dict
+
     @asynccontextmanager
     async def _session_scope(self):
         if self.is_async:
@@ -65,25 +118,18 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             return session.execute(statement)
 
     async def get_by_id(self, id: str) -> ResponseModel:
-        statement = self._select().where(self.db_model.id == id)
-        async with self._session_scope() as session:
-            result = await self._execute_statement(session, statement)
-            responses = self._rows_to_responses(result.all())
-            return self._ensure_one(responses)
+        rows = await self._select_to_response(lambda q: q.where(self.db_model.id == id))
+        return self._ensure_one(rows)
 
     async def get_by_ids(self, id_list: list[str]) -> list[ResponseModel]:
-        statement = self._select().where(self.db_model.id.in_(id_list))
-        async with self._session_scope() as session:
-            result = await self._execute_statement(session, statement)
-            return [
-                self.db_model(**entity.model_dump())
-                for entity in result.scalars().all()
-            ]
+        return await self._select_to_response(
+            lambda q: q.where(self.db_model.id.in_(id_list))
+        )
 
     async def count(self, filter: str | None = None) -> int:
         count_statement = select(func.count(1)).select_from(self.db_model)
         if filter:
-            filter_param = parse_filter_param(self.db_model, filter)
+            filter_param = self._parse_filter_param(self.db_model, filter)
             count_statement = count_statement.where(*filter_param)
         async with self._session_scope() as session:
             result = await self._execute_statement(session, count_statement)
@@ -96,33 +142,31 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
         filter: str | None = None,
         sort: str | None = None,
     ) -> list[ResponseModel]:
-        offset = (page - 1) * page_size
-        statement = self._select().offset(offset).limit(page_size)
-        if filter:
-            filter_param = parse_filter_param(self.db_model, filter)
-            statement = statement.where(*filter_param)
-        if sort:
-            sort_param = parse_sort_param(self.db_model, sort)
-            statement = statement.order_by(*sort_param)
-        async with self._session_scope() as session:
-            result = await self._execute_statement(session, statement)
-            return [
-                self.db_model(**entity.model_dump())
-                for entity in result.scalars().all()
-            ]
+        return await self._select_to_response(
+            self._get_pagination_query_modifier(
+                page=page, page_size=page_size, filter=filter, sort=sort
+            )
+        )
 
-    def _model_to_data_dict(
-        self, data: SQLModel, **additional_data: Any
-    ) -> dict[str, Any]:
-        data_dict = data.model_dump(exclude_unset=True)
-        data_dict.update(additional_data)
-        for key, preprocessor in self.column_preprocessors.items():
-            if key not in data_dict:
-                continue
-            if not hasattr(self.db_model, key):
-                raise InvalidValueError(f"Invalid {self.entity_name} property: {key}")
-            data_dict[key] = preprocessor(data_dict[key])
-        return data_dict
+    def _get_pagination_query_modifier(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> Callable[[Select], Any]:
+        def pagination_query_modifier(statement: Select) -> Any:
+            offset = (page - 1) * page_size
+            statement = statement.offset(offset).limit(page_size)
+            if filter:
+                filter_param = self._parse_filter_param(self.db_model, filter)
+                statement = statement.where(*filter_param)
+            if sort:
+                sort_param = self._parse_sort_param(self.db_model, sort)
+                statement = statement.order_by(*sort_param)
+            return statement
+
+        return pagination_query_modifier
 
     async def create(self, data: CreateModel) -> DBModel:
         now = datetime.datetime.now(datetime.timezone.utc)

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

@@ -50,5 +50,17 @@ APP_AUTH_SUPER_USER = os.getenv("MY_APP_NAME_AUTH_SUPER_USER", "admin")
 APP_AUTH_SUPER_USER_PASSWORD = os.getenv(
     "MY_APP_NAME_AUTH_SUPER_USER_PASSWORD", "my-secure-password"
 )
+APP_AUTH_GUEST_USER = os.getenv("MY_APP_NAME_AUTH_GUEST_USER", "user")
+APP_AUTH_GUEST_USER_PERMISSIONS = (
+    permission_name.strip()
+    for permission_name in os.getenv(
+        "MY_APP_NAME_AUTH_GUEST_USER_PERMISSIONS", ""
+    ).split(",")
+    if permission_name.strip() != ""
+)
+APP_MAX_PARALLEL_SESSION = int(os.getenv("MY_APP_NAME_MAX_PARALLEL_SESSION", "1"))
+APP_SESSION_EXPIRE_MINUTES = int(
+    os.getenv("MY_APP_NAME_SESSION_EXPIRE_MINUTES", "1440")
+)
 
 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/client/auth_client.py

@@ -8,15 +8,15 @@ from my_app_name.schema.permission import (
 )
 from my_app_name.schema.role import (
     MultipleRoleResponse,
-    RoleCreateWithAudit,
+    RoleCreateWithPermissionsAndAudit,
     RoleResponse,
-    RoleUpdateWithAudit,
+    RoleUpdateWithPermissionsAndAudit,
 )
 from my_app_name.schema.user import (
     MultipleUserResponse,
-    UserCreateWithAudit,
+    UserCreateWithRolesAndAudit,
     UserResponse,
-    UserUpdateWithAudit,
+    UserUpdateWithRolesAndAudit,
 )
 
 
@@ -38,18 +38,18 @@ class AuthClient(ABC):
     ) -> MultiplePermissionResponse:
         """Get permissions by filter and sort"""
 
+    @abstractmethod
+    async def create_permission_bulk(
+        self, data: list[PermissionCreateWithAudit]
+    ) -> list[PermissionResponse]:
+        """Create new permissions"""
+
     @abstractmethod
     async def create_permission(
         self, data: PermissionCreateWithAudit
     ) -> PermissionResponse:
         """Create a new permission"""
 
-    @abstractmethod
-    async def create_permission(
-        self, data: list[PermissionCreateWithAudit]
-    ) -> list[PermissionResponse]:
-        """Create new permissions"""
-
     @abstractmethod
     async def update_permission_bulk(
         self, permission_ids: list[str], data: PermissionUpdateWithAudit
@@ -91,22 +91,26 @@ class AuthClient(ABC):
         """Get roles by filter and sort"""
 
     @abstractmethod
-    async def create_role(self, data: RoleCreateWithAudit) -> RoleResponse:
-        """Create a new role"""
+    async def create_role_bulk(
+        self, data: list[RoleCreateWithPermissionsAndAudit]
+    ) -> list[RoleResponse]:
+        """Create new roles"""
 
     @abstractmethod
-    async def create_role(self, data: list[RoleCreateWithAudit]) -> list[RoleResponse]:
-        """Create new roles"""
+    async def create_role(
+        self, data: RoleCreateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        """Create a new role"""
 
     @abstractmethod
     async def update_role_bulk(
-        self, role_ids: list[str], data: RoleUpdateWithAudit
+        self, role_ids: list[str], data: RoleUpdateWithPermissionsAndAudit
     ) -> RoleResponse:
         """Update some roles"""
 
     @abstractmethod
     async def update_role(
-        self, role_id: str, data: RoleUpdateWithAudit
+        self, role_id: str, data: RoleUpdateWithPermissionsAndAudit
     ) -> RoleResponse:
         """Update a role"""
 
@@ -135,22 +139,24 @@ class AuthClient(ABC):
         """Get users by filter and sort"""
 
     @abstractmethod
-    async def create_user(self, data: UserCreateWithAudit) -> UserResponse:
-        """Create a new user"""
+    async def create_user_bulk(
+        self, data: list[UserCreateWithRolesAndAudit]
+    ) -> list[UserResponse]:
+        """Create new users"""
 
     @abstractmethod
-    async def create_user(self, data: list[UserCreateWithAudit]) -> list[UserResponse]:
-        """Create new users"""
+    async def create_user(self, data: UserCreateWithRolesAndAudit) -> UserResponse:
+        """Create a new user"""
 
     @abstractmethod
     async def update_user_bulk(
-        self, user_ids: list[str], data: UserUpdateWithAudit
+        self, user_ids: list[str], data: UserUpdateWithRolesAndAudit
     ) -> UserResponse:
         """Update some users"""
 
     @abstractmethod
     async def update_user(
-        self, user_id: str, data: UserUpdateWithAudit
+        self, user_id: str, data: UserUpdateWithRolesAndAudit
     ) -> UserResponse:
         """Update a user"""
 

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

@@ -32,7 +32,7 @@ def upgrade() -> None:
         sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
         sa.PrimaryKeyConstraint("id"),
     )
-    op.create_index(op.f("ix_permission_name"), "permission", ["name"], unique=False)
+    op.create_index(op.f("ix_permission_name"), "permission", ["name"], unique=True)
     op.create_index(
         op.f("ix_permission_created_at"), "permission", ["created_at"], unique=False
     )
@@ -57,7 +57,7 @@ def upgrade() -> None:
         sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
         sa.PrimaryKeyConstraint("id"),
     )
-    op.create_index(op.f("ix_role_name"), "role", ["name"], unique=False)
+    op.create_index(op.f("ix_role_name"), "role", ["name"], unique=True)
     op.create_index(op.f("ix_role_created_at"), "role", ["created_at"], unique=False)
     op.create_index(op.f("ix_role_created_by"), "role", ["created_by"], unique=False)
     op.create_index(op.f("ix_role_updated_at"), "role", ["updated_at"], unique=False)
@@ -93,7 +93,7 @@ def upgrade() -> None:
         sa.Column("updated_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
         sa.PrimaryKeyConstraint("id"),
     )
-    op.create_index(op.f("ix_user_username"), "user", ["username"], unique=False)
+    op.create_index(op.f("ix_user_username"), "user", ["username"], unique=True)
     op.create_index(op.f("ix_user_created_at"), "user", ["created_at"], unique=False)
     op.create_index(op.f("ix_user_created_by"), "user", ["created_by"], unique=False)
     op.create_index(op.f("ix_user_updated_at"), "user", ["updated_at"], unique=False)
@@ -115,17 +115,17 @@ def upgrade() -> None:
         "session",
         sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
         sa.Column("user_id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
-        sa.Column("device", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
-        sa.Column("os", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
-        sa.Column("browser", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("token", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
         sa.PrimaryKeyConstraint("id"),
     )
     op.create_index(op.f("ix_session_user_id"), "session", ["user_id"], unique=False)
+    op.create_index(op.f("ix_session_token"), "session", ["token"], unique=True)
     # ### end Alembic commands ###
 
 
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f("ix_session_token"), table_name="session")
     op.drop_index(op.f("ix_session_user_id"), table_name="session")
     op.drop_table("session")
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/repository/role_db_repository.py

@@ -1,5 +1,7 @@
+import datetime
 from typing import Any
 
+import ulid
 from my_app_name.common.base_db_repository import BaseDBRepository
 from my_app_name.module.auth.service.role.repository.role_repository import (
     RoleRepository,
@@ -13,7 +15,7 @@ from my_app_name.schema.role import (
     RoleUpdateWithAudit,
 )
 from sqlalchemy.sql import Select
-from sqlmodel import select
+from sqlmodel import delete, insert, select
 
 
 class RoleDBRepository(
@@ -35,41 +37,53 @@ class RoleDBRepository(
         return (
             select(Role, Permission)
             .join(RolePermission, RolePermission.role_id == Role.id, isouter=True)
-            .join(Permission, Permission.id == RolePermission.role_id, isouter=True)
+            .join(
+                Permission, Permission.id == RolePermission.permission_id, isouter=True
+            )
         )
 
-    def _rows_to_responses(self, rows: list[tuple[Role, Permission]]) -> RoleResponse:
+    def _rows_to_responses(self, rows: list[tuple[Any, ...]]) -> list[RoleResponse]:
         role_map: dict[str, dict[str, Any]] = {}
+        role_permission_map: dict[str, list[str]] = {}
         for role, permission in rows:
             if role.id not in role_map:
-                role_map[role.id] = {"role": role, "permissions": set()}
-            if permission:
-                role_map[role.id]["permissions"].add(permission)
+                role_map[role.id] = {"role": role, "permissions": []}
+                role_permission_map[role.id] = []
+            if (
+                permission is not None
+                and permission.id not in role_permission_map[role.id]
+            ):
+                role_permission_map[role.id].append(permission.id)
+                role_map[role.id]["permissions"].append(permission.model_dump())
         return [
-            RoleResponse(
-                **data["role"].model_dump(), permissions=list(data["permissions"])
-            )
+            RoleResponse(**data["role"].model_dump(), permissions=data["permissions"])
             for data in role_map.values()
         ]
 
-    async def add_permissions(self, role_id, permission_names: list[str]) -> Role:
-        # TODO: complete this
-        select_statement = self._select().where(self.db_model.id == role_id)
-        rows = await self._execute_select_statement(select_statement)
-        responses = self._rows_to_responses(rows)
-        return self._ensure_one(responses)
-
-    async def remove_permissions(self, role_id, permission_names: list[str]) -> Role:
-        # TODO: complete this
-        select_statement = self._select().where(self.db_model.id == role_id)
-        rows = await self._execute_select_statement(select_statement)
-        responses = self._rows_to_responses(rows)
-        return self._ensure_one(responses)
-
+    async def add_permissions(self, data: dict[str, list[str]], created_by: str):
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data_dict_list: list[dict[str, Any]] = []
+        for role_id, permission_ids in data.items():
+            for permission_id in permission_ids:
+                data_dict_list.append(
+                    self._model_to_data_dict(
+                        RolePermission(
+                            id=ulid.new().str,
+                            role_id=role_id,
+                            permission_id=permission_id,
+                            created_at=now,
+                            created_by=created_by,
+                        )
+                    )
+                )
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session, insert(RolePermission).values(data_dict_list)
+            )
 
-def _remove_create_model_additional_property(
-    data: RoleCreateWithAudit,
-) -> RoleCreateWithAudit:
-    return RoleCreateWithAudit(
-        **{key: val for key, val in data.model_dump().items() if key != "permissions"}
-    )
+    async def remove_all_permissions(self, role_ids: list[str] = []):
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session,
+                delete(RolePermission).where(RolePermission.role_id._in(role_ids)),
+            )

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/repository/role_repository.py

@@ -18,6 +18,14 @@ class RoleRepository(ABC):
     async def get_by_ids(self, id_list: list[str]) -> RoleResponse:
         """Get roles by ids"""
 
+    @abstractmethod
+    async def add_permissions(self, data: dict[str, list[str]], created_by: str):
+        """Adding permissions to roles"""
+
+    @abstractmethod
+    async def remove_all_permissions(self, role_ids: list[str] = []):
+        """Remove permissions from roles"""
+
     @abstractmethod
     async def get(
         self,

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/role_service.py

@@ -6,9 +6,9 @@ from my_app_name.module.auth.service.role.repository.role_repository import (
 )
 from my_app_name.schema.role import (
     MultipleRoleResponse,
-    RoleCreateWithAudit,
+    RoleCreateWithPermissionsAndAudit,
     RoleResponse,
-    RoleUpdateWithAudit,
+    RoleUpdateWithPermissionsAndAudit,
 )
 
 
@@ -42,35 +42,61 @@ class RoleService(BaseService):
         count = await self.role_repository.count(filter)
         return MultipleRoleResponse(data=roles, count=count)
 
-    @BaseService.route(
-        "/api/v1/roles",
-        methods=["post"],
-        response_model=RoleResponse,
-    )
-    async def create_role(self, data: RoleCreateWithAudit) -> RoleResponse:
-        role = await self.role_repository.create(data)
-        return await self.role_repository.get_by_id(role.id)
-
     @BaseService.route(
         "/api/v1/roles/bulk",
         methods=["post"],
         response_model=list[RoleResponse],
     )
     async def create_role_bulk(
-        self, data: list[RoleCreateWithAudit]
+        self, data: list[RoleCreateWithPermissionsAndAudit]
     ) -> list[RoleResponse]:
+        permission_ids = [row.get_permission_ids() for row in data]
+        data = [row.get_role_create_with_audit() for row in data]
         roles = await self.role_repository.create_bulk(data)
+        if len(roles) > 0:
+            created_by = roles[0].created_by
+            await self.role_repository.add_permissions(
+                data={role.id: permission_ids[i] for i, role in enumerate(roles)},
+                created_by=created_by,
+            )
         return await self.role_repository.get_by_ids([role.id for role in roles])
 
+    @BaseService.route(
+        "/api/v1/roles",
+        methods=["post"],
+        response_model=RoleResponse,
+    )
+    async def create_role(
+        self, data: RoleCreateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        permission_ids = data.get_permission_ids()
+        data = data.get_role_create_with_audit()
+        role = await self.role_repository.create(data)
+        await self.role_repository.add_permissions(
+            data={role.id: permission_ids}, created_by=role.created_by
+        )
+        return await self.role_repository.get_by_id(role.id)
+
     @BaseService.route(
         "/api/v1/roles/bulk",
         methods=["put"],
         response_model=RoleResponse,
     )
     async def update_role_bulk(
-        self, role_ids: list[str], data: RoleUpdateWithAudit
+        self, role_ids: list[str], data: RoleUpdateWithPermissionsAndAudit
     ) -> 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.add_permissions(
+                data={role.id: permission_ids[i] for i, role in enumerate(roles)},
+                created_by=updated_by,
+            )
         return await self.role_repository.get_by_ids([role.id for role in roles])
 
     @BaseService.route(
@@ -79,9 +105,15 @@ class RoleService(BaseService):
         response_model=RoleResponse,
     )
     async def update_role(
-        self, role_id: str, data: RoleUpdateWithAudit
+        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])
+        await self.role_repository.add_permissions(
+            data={role.id: permission_ids}, created_by=role.updated_by
+        )
         return await self.role_repository.get_by_id(role.id)
 
     @BaseService.route(