fastapi-forge-cli 0.1.0__py3-none-any.whl

fastapi_forge/templates/with_rbac/app/api/v1/health/router.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, Response, status
+
+from app.api.v1.health.service import HealthService
+
+router = APIRouter()
+
+
+@router.get("/health")
+async def health_check():
+    return await HealthService().status()
+
+
+@router.get("/health/live")
+async def liveness_check():
+    return HealthService().liveness()
+
+
+@router.get("/health/ready")
+async def readiness_check(response: Response):
+    result = await HealthService().readiness()
+    if result["status"] != "healthy":
+        response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
+    return result

fastapi_forge/templates/with_rbac/app/api/v1/health/schema.py

@@ -0,0 +1,5 @@
+from app.utils.casing import CamelModel
+
+
+class HealthResponse(CamelModel):
+    status: str

fastapi_forge/templates/with_rbac/app/api/v1/health/service.py

@@ -0,0 +1,25 @@
+from app.core.config import settings
+from app.db.session import check_db_health
+
+
+class HealthService:
+    @staticmethod
+    def liveness() -> dict:
+        return {"status": "healthy"}
+
+    async def readiness(self) -> dict:
+        database = await check_db_health()
+        return {
+            "status": "healthy" if database["status"] == "healthy" else "unhealthy",
+            "database": database,
+        }
+
+    async def status(self) -> dict:
+        database = await check_db_health()
+        return {
+            "status": "healthy" if database["status"] == "healthy" else "degraded",
+            "app": settings.APP_NAME,
+            "version": settings.APP_VERSION,
+            "environment": settings.APP_ENV,
+            "database": database,
+        }

fastapi_forge/templates/with_rbac/app/api/v1/permissions/repository.py

@@ -0,0 +1,80 @@
+from uuid import UUID
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.db.models.permission import Permission, Role
+from app.db.models.user import User
+from app.repositories.base import BaseRepository
+
+
+class PermissionRepository(BaseRepository[Permission]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(Permission, session)
+
+    async def get_active(
+        self,
+        page: int,
+        page_size: int,
+        pagination: bool = True,
+        search: str | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+        active_only: bool = True,
+    ) -> tuple[list[Permission], int]:
+        filters = []
+        if active_only:
+            filters.append(Permission.is_active == True)
+        return await self.get_all(
+            page=page,
+            page_size=page_size,
+            pagination=pagination,
+            filters=filters,
+            search=search,
+            search_columns=[Permission.code, Permission.name, Permission.description],
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+
+    async def get_active_by_id(self, permission_id: UUID) -> Permission | None:
+        q = select(Permission).where(
+            Permission.id == permission_id,
+            Permission.is_deleted == False,
+            Permission.is_active == True,
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    async def exists_for_other_permission(
+        self,
+        field: str,
+        value: str,
+        permission_id: UUID,
+    ) -> bool:
+        q = (
+            select(func.count())
+            .select_from(Permission)
+            .where(
+                getattr(Permission, field) == value,
+                Permission.id != permission_id,
+            )
+        )
+        return (await self.session.execute(q)).scalar_one() > 0
+
+
+class UserAssignmentRepository(BaseRepository[User]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(User, session)
+
+    async def get_user(self, user_id: UUID) -> User | None:
+        q = (
+            select(User)
+            .where(User.id == user_id, User.is_deleted == False)
+            .options(
+                selectinload(User.roles).selectinload(Role.permissions),
+                selectinload(User.extra_permissions),
+            )
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()

fastapi_forge/templates/with_rbac/app/api/v1/permissions/router.py

@@ -0,0 +1,151 @@
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.v1.permissions.schema import (
+    AssignPermissionRequest,
+    PermissionCreate,
+    PermissionUpdate,
+)
+from app.api.v1.schema import DeleteNoteRequest
+from app.api.v1.permissions.service import PermissionService
+from app.core.dependencies import get_async_db, require_any_permission
+from app.helper.pagination_helper import PaginationParams
+from app.core.responses import paginated_response, success_response
+
+router = APIRouter()
+
+_permission_read = Depends(require_any_permission("admin:write", "permissions:read"))
+_permission_create = Depends(require_any_permission("admin:write", "permissions:create"))
+_permission_update = Depends(require_any_permission("admin:write", "permissions:update"))
+_permission_soft_delete = Depends(
+    require_any_permission("admin:write", "permissions:soft_delete")
+)
+_permission_hard_delete = Depends(
+    require_any_permission("admin:write", "permissions:hard_delete")
+)
+
+
+@router.get("", dependencies=[_permission_read])
+async def list_permissions(
+    pagination: PaginationParams = Depends(),
+    active_only: bool = Query(False, alias="activeOnly"),
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = PermissionService(db)
+    data, total = await svc.list_permissions(
+        pagination.page,
+        pagination.page_size,
+        pagination.pagination,
+        pagination.search,
+        pagination.sort_by,
+        pagination.sort_order,
+        active_only,
+    )
+    items = [item.model_dump() for item in data]
+    if not pagination.pagination:
+        return success_response(data=items)
+    return paginated_response(
+        items,
+        total,
+        pagination.page,
+        pagination.page_size,
+    )
+
+
+@router.get(
+    "/deleted",
+    dependencies=[_permission_read],
+    summary="List soft-deleted permissions",
+)
+async def list_deleted_permissions(
+    pagination: PaginationParams = Depends(),
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = PermissionService(db)
+    data, total = await svc.list_deleted_permissions(
+        pagination.page,
+        pagination.page_size,
+        pagination.pagination,
+        pagination.search,
+        pagination.sort_by,
+        pagination.sort_order,
+    )
+    items = [item.model_dump() for item in data]
+    if not pagination.pagination:
+        return success_response(data=items)
+    return paginated_response(items, total, pagination.page, pagination.page_size)
+
+
+@router.post("", dependencies=[_permission_create])
+async def create_permission(
+    body: PermissionCreate, db: AsyncSession = Depends(get_async_db)
+):
+    svc = PermissionService(db)
+    permission = await svc.create_permission(body)
+    return success_response(data=permission.model_dump(), message="Permission created")
+
+
+@router.post(
+    "/assign-permission",
+    dependencies=[_permission_update],
+    summary="Assign extra permission to a user",
+)
+async def assign_permission(
+    body: AssignPermissionRequest, db: AsyncSession = Depends(get_async_db)
+):
+    svc = PermissionService(db)
+    await svc.assign_permission(body.user_id, body.permission_id)
+    return success_response(message="Permission assigned to user")
+
+
+@router.get("/{permission_id}", dependencies=[_permission_read])
+async def get_permission(
+    permission_id: UUID,
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = PermissionService(db)
+    permission = await svc.get_permission(permission_id)
+    return success_response(data=permission.model_dump())
+
+
+@router.patch("/{permission_id}", dependencies=[_permission_update])
+async def update_permission(
+    permission_id: UUID,
+    body: PermissionUpdate,
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = PermissionService(db)
+    permission = await svc.update_permission(permission_id, body)
+    return success_response(data=permission.model_dump(), message="Permission updated")
+
+
+@router.delete(
+    "/{permission_id}",
+    dependencies=[_permission_soft_delete],
+    summary="Soft delete a permission",
+)
+async def soft_delete_permission(
+    permission_id: UUID,
+    body: DeleteNoteRequest,
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = PermissionService(db)
+    await svc.soft_delete_permission(permission_id, body.note)
+    return success_response(message="Permission soft deleted")
+
+
+@router.delete(
+    "/{permission_id}/hard",
+    dependencies=[_permission_hard_delete],
+    summary="Hard delete a permission",
+)
+async def hard_delete_permission(
+    permission_id: UUID,
+    body: DeleteNoteRequest,
+    db: AsyncSession = Depends(get_async_db),
+):
+    svc = PermissionService(db)
+    await svc.hard_delete_permission(permission_id, body.note)
+    return success_response(message="Permission hard deleted")

fastapi_forge/templates/with_rbac/app/api/v1/permissions/schema.py

@@ -0,0 +1,40 @@
+from typing import Optional
+from uuid import UUID
+
+from pydantic import Field
+
+from app.utils.casing import CamelModel
+
+
+class PermissionCreate(CamelModel):
+    code: str = Field(..., pattern=r"^[a-z_*]+:[a-z_*]+$", examples=["users:read"])
+    name: str
+    description: Optional[str] = None
+    is_active: bool = True
+
+
+class PermissionUpdate(CamelModel):
+    code: Optional[str] = Field(
+        default=None,
+        pattern=r"^[a-z_*]+:[a-z_*]+$",
+        examples=["users:read"],
+    )
+    name: Optional[str] = None
+    description: Optional[str] = None
+    is_active: Optional[bool] = None
+
+
+class PermissionResponse(CamelModel):
+    id: str
+    code: str
+    name: str
+    description: Optional[str] = None
+    is_active: bool
+    is_deleted: bool = False
+    deleted_at: Optional[str] = None
+    deletion_note: Optional[str] = None
+
+
+class AssignPermissionRequest(CamelModel):
+    user_id: UUID
+    permission_id: UUID

fastapi_forge/templates/with_rbac/app/api/v1/permissions/service.py

@@ -0,0 +1,156 @@
+from uuid import UUID
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.v1.permissions.repository import (
+    PermissionRepository,
+    UserAssignmentRepository,
+)
+from app.api.v1.permissions.schema import (
+    PermissionCreate,
+    PermissionResponse,
+    PermissionUpdate,
+)
+from app.core.exceptions import (
+    ConflictException,
+    NotFoundException,
+    ValidationException,
+)
+from app.db.models.permission import Permission
+
+
+class PermissionService:
+    def __init__(self, session: AsyncSession):
+        self.session = session
+        self.permissions = PermissionRepository(session)
+        self.assignments = UserAssignmentRepository(session)
+
+    async def list_permissions(
+        self,
+        page: int,
+        page_size: int,
+        pagination: bool = True,
+        search: str | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+        active_only: bool = True,
+    ) -> tuple[list[PermissionResponse], int]:
+        items, total = await self.permissions.get_active(
+            page,
+            page_size,
+            pagination,
+            search,
+            sort_by,
+            sort_order,
+            active_only,
+        )
+        return [self._permission_response(item) for item in items], total
+
+    async def list_deleted_permissions(
+        self,
+        page: int,
+        page_size: int,
+        pagination: bool = True,
+        search: str | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> tuple[list[PermissionResponse], int]:
+        items, total = await self.permissions.get_deleted(
+            page=page,
+            page_size=page_size,
+            pagination=pagination,
+            search=search,
+            search_columns=[Permission.code, Permission.name, Permission.description],
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+        return [self._permission_response(item) for item in items], total
+
+    async def create_permission(self, data: PermissionCreate) -> PermissionResponse:
+        if await self.permissions.exists("code", data.code):
+            raise ConflictException(f"Permission '{data.code}' already exists")
+        permission = await self.permissions.create(data.model_dump())
+        return self._permission_response(permission)
+
+    async def get_permission(self, permission_id: UUID) -> PermissionResponse:
+        permission = await self.permissions.get_by_id(permission_id)
+        if not permission:
+            raise NotFoundException("Permission", permission_id)
+        return self._permission_response(permission)
+
+    async def update_permission(
+        self,
+        permission_id: UUID,
+        data: PermissionUpdate,
+    ) -> PermissionResponse:
+        permission = await self.permissions.get_by_id(permission_id)
+        if not permission:
+            raise NotFoundException("Permission", permission_id)
+
+        values = data.model_dump(exclude_unset=True)
+        if "code" in values and await self.permissions.exists_for_other_permission(
+            "code",
+            values["code"],
+            permission_id,
+        ):
+            raise ConflictException(f"Permission '{values['code']}' already exists")
+
+        permission = await self.permissions.update(permission, values)
+        return self._permission_response(permission)
+
+    async def assign_permission(self, user_id: UUID, permission_id: UUID) -> None:
+        user = await self.assignments.get_user(user_id)
+        if not user:
+            raise NotFoundException("User", user_id)
+        permission = await self.permissions.get_active_by_id(permission_id)
+        if not permission:
+            raise NotFoundException("Permission", permission_id)
+        if self._permission_exists_in_user_role(user, permission):
+            raise ValidationException(
+                f"Permission '{permission.code}' is already assigned to role"
+            )
+        if permission not in user.extra_permissions:
+            user.extra_permissions.append(permission)
+            await self.session.flush()
+
+    async def soft_delete_permission(self, permission_id: UUID, note: str) -> None:
+        permission = await self.permissions.get_by_id(permission_id)
+        if not permission:
+            raise NotFoundException("Permission", permission_id)
+        await self.permissions.soft_delete(permission, note)
+
+    async def hard_delete_permission(self, permission_id: UUID, note: str) -> None:
+        permission = await self.permissions.get_by_id(
+            permission_id,
+            include_deleted=True,
+        )
+        if not permission:
+            raise NotFoundException("Permission", permission_id)
+        await self.permissions.hard_delete(permission, note)
+
+    def _permission_response(self, permission) -> PermissionResponse:
+        return PermissionResponse(
+            id=str(permission.id),
+            code=permission.code,
+            name=permission.name,
+            description=permission.description,
+            is_active=permission.is_active,
+            is_deleted=permission.is_deleted,
+            deleted_at=(
+                permission.deleted_at.isoformat() if permission.deleted_at else None
+            ),
+            deletion_note=permission.deletion_note,
+        )
+
+    def _permission_exists_in_user_role(self, user, permission) -> bool:
+        for role in user.roles:
+            if role.is_deleted or not role.is_active:
+                continue
+            if any(
+                role_permission.id == permission.id
+                and not role_permission.is_deleted
+                and role_permission.is_active
+                for role_permission in role.permissions
+            ):
+                return True
+        return False

fastapi_forge/templates/with_rbac/app/api/v1/roles/__init__.py

@@ -0,0 +1 @@
+

fastapi_forge/templates/with_rbac/app/api/v1/roles/repository.py

@@ -0,0 +1,161 @@
+from uuid import UUID
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.db.models.permission import Role
+from app.db.models.user import User
+from app.repositories.base import BaseRepository
+
+
+class RoleRepository(BaseRepository[Role]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(Role, session)
+
+    async def get_active(
+        self,
+        page: int,
+        page_size: int,
+        pagination: bool = True,
+        search: str | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+        active_only: bool = True,
+    ) -> tuple[list[Role], int]:
+        filters = []
+        if active_only:
+            filters.append(Role.is_active == True)
+        return await self.get_all(
+            page=page,
+            page_size=page_size,
+            pagination=pagination,
+            filters=filters,
+            search=search,
+            search_columns=[Role.name, Role.description],
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+
+    async def get_with_permissions(self, role_id: UUID) -> Role | None:
+        q = (
+            select(Role)
+            .where(Role.id == role_id, Role.is_deleted == False)
+            .options(selectinload(Role.permissions))
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    async def get_by_name_with_permissions(self, name: str) -> Role | None:
+        q = (
+            select(Role)
+            .where(
+                Role.name == name,
+                Role.is_deleted == False,
+                Role.is_active == True,
+            )
+            .options(selectinload(Role.permissions))
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    async def list_active_with_permissions(self) -> list[Role]:
+        q = (
+            select(Role)
+            .where(Role.is_deleted == False, Role.is_active == True)
+            .options(selectinload(Role.permissions))
+            .order_by(Role.name)
+        )
+        result = await self.session.execute(q)
+        return list(result.scalars().all())
+
+    async def is_descendant(self, role_id: UUID, ancestor_role_id: UUID) -> bool:
+        if role_id == ancestor_role_id:
+            return False
+        roles = await self.list_active_with_permissions()
+        by_id = {role.id: role for role in roles}
+        current = by_id.get(role_id)
+        visited = set()
+        while current and current.parent_role_id:
+            if current.parent_role_id == ancestor_role_id:
+                return True
+            if current.parent_role_id in visited:
+                return False
+            visited.add(current.parent_role_id)
+            current = by_id.get(current.parent_role_id)
+        return False
+
+    async def would_create_cycle(
+        self,
+        role_id: UUID,
+        parent_role_id: UUID | None,
+    ) -> bool:
+        if parent_role_id is None:
+            return False
+        if role_id == parent_role_id:
+            return True
+        return await self.is_descendant(parent_role_id, role_id)
+
+    async def has_active_children(self, role_id: UUID) -> bool:
+        q = (
+            select(func.count())
+            .select_from(Role)
+            .where(
+                Role.parent_role_id == role_id,
+                Role.is_deleted == False,
+                Role.is_active == True,
+            )
+        )
+        return (await self.session.execute(q)).scalar_one() > 0
+
+    async def exists_for_other_role(
+        self,
+        field: str,
+        value: str,
+        role_id: UUID,
+    ) -> bool:
+        q = (
+            select(func.count())
+            .select_from(Role)
+            .where(
+                getattr(Role, field) == value,
+                Role.id != role_id,
+            )
+        )
+        return (await self.session.execute(q)).scalar_one() > 0
+
+
+class RoleAssignmentRepository(BaseRepository[User]):
+    def __init__(self, session: AsyncSession):
+        super().__init__(User, session)
+
+    async def get_user(self, user_id: UUID) -> User | None:
+        q = (
+            select(User)
+            .where(User.id == user_id, User.is_deleted == False)
+            .options(
+                selectinload(User.roles).selectinload(Role.permissions),
+                selectinload(User.extra_permissions),
+            )
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    async def get_role(self, role_id: UUID) -> Role | None:
+        q = (
+            select(Role)
+            .where(
+                Role.id == role_id,
+                Role.is_deleted == False,
+                Role.is_active == True,
+            )
+            .options(selectinload(Role.permissions))
+        )
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    def get_role_from_user(self, user: User) -> Role | None:
+        for role in user.roles:
+            if not role.is_deleted and role.is_active:
+                return role
+        return None