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

fastapi_forge/templates/without_rbac/app/repositories/base.py

@@ -0,0 +1,347 @@
+from typing import Any, Dict, Generic, List, Optional, Tuple, Type, TypeVar
+from uuid import UUID
+
+from sqlalchemy import Select, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+from app.db.base import Base
+from app.helper.search import text_search_filter
+from app.helper.pagination_helper import apply_pagination
+from app.helper.sorting import sort_expressions
+
+ModelT = TypeVar("ModelT", bound=Base)
+
+
+class BaseRepository(Generic[ModelT]):
+    def __init__(self, model: Type[ModelT], session: AsyncSession):
+        self.model = model
+        self.session = session
+
+    def _active_query(self) -> Select:
+        q = select(self.model)
+        if hasattr(self.model, "is_deleted"):
+            q = q.where(self.model.is_deleted == False)
+        return q
+
+    async def create(self, data: Dict[str, Any]) -> ModelT:
+        instance = self.model(**data)
+        self.session.add(instance)
+        await self.session.flush()
+        await self.session.refresh(instance)
+        return instance
+
+    async def get_by_id(
+        self, id: UUID, include_deleted: bool = False
+    ) -> Optional[ModelT]:
+        q = select(self.model).where(self.model.id == id)
+        if not include_deleted and hasattr(self.model, "is_deleted"):
+            q = q.where(self.model.is_deleted == False)
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    async def get_by_field(self, field: str, value: Any) -> Optional[ModelT]:
+        q = self._active_query().where(getattr(self.model, field) == value)
+        result = await self.session.execute(q)
+        return result.scalar_one_or_none()
+
+    async def get_all(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        pagination: bool = True,
+        filters: Optional[List] = None,
+        search: str | None = None,
+        search_columns: Optional[List] = None,
+        order_by=None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> Tuple[List[ModelT], int]:
+        q = self._active_query()
+        if filters:
+            q = q.where(*filters)
+        search_filter = text_search_filter(self.model, search, search_columns)
+        if search_filter is not None:
+            q = q.where(search_filter)
+        if isinstance(order_by, (list, tuple)):
+            default_order = tuple(order_by)
+        else:
+            default_order = (order_by,) if order_by is not None else ()
+        if not default_order and hasattr(self.model, "created_at"):
+            default_order = (self.model.created_at.desc(),)
+        order = sort_expressions(self.model, sort_by, sort_order, default_order)
+        if order:
+            q = q.order_by(*order)
+
+        count_q = select(func.count()).select_from(q.subquery())
+        total = (await self.session.execute(count_q)).scalar_one()
+
+        q = apply_pagination(q, page, page_size, pagination)
+
+        result = await self.session.execute(q)
+        return list(result.scalars().all()), total
+
+    async def get_deleted(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        pagination: bool = True,
+        filters: Optional[List] = None,
+        search: str | None = None,
+        search_columns: Optional[List] = None,
+        order_by=None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> Tuple[List[ModelT], int]:
+        if not hasattr(self.model, "is_deleted"):
+            return [], 0
+
+        q = select(self.model).where(self.model.is_deleted == True)
+        if filters:
+            q = q.where(*filters)
+        search_filter = text_search_filter(self.model, search, search_columns)
+        if search_filter is not None:
+            q = q.where(search_filter)
+        if isinstance(order_by, (list, tuple)):
+            default_order = tuple(order_by)
+        else:
+            default_order = (order_by,) if order_by is not None else ()
+        if not default_order and hasattr(self.model, "deleted_at"):
+            default_order = (self.model.deleted_at.desc(),)
+        order = sort_expressions(self.model, sort_by, sort_order, default_order)
+        if order:
+            q = q.order_by(*order)
+
+        count_q = select(func.count()).select_from(q.subquery())
+        total = (await self.session.execute(count_q)).scalar_one()
+
+        q = apply_pagination(q, page, page_size, pagination)
+
+        result = await self.session.execute(q)
+        return list(result.scalars().all()), total
+
+    async def update(self, instance: ModelT, data: Dict[str, Any]) -> ModelT:
+        for key, value in data.items():
+            if hasattr(instance, key):
+                setattr(instance, key, value)
+        self.session.add(instance)
+        await self.session.flush()
+        await self.session.refresh(instance)
+        return instance
+
+    async def soft_delete(self, instance: ModelT, note: str) -> ModelT:
+        if not hasattr(instance, "soft_delete"):
+            raise AttributeError(f"{self.model.__name__} does not support soft delete")
+        instance.soft_delete(note)
+        self.session.add(instance)
+        await self.session.flush()
+        return instance
+
+    async def restore(self, instance: ModelT) -> ModelT:
+        if not hasattr(instance, "restore"):
+            raise AttributeError(f"{self.model.__name__} does not support restore")
+        instance.restore()
+        self.session.add(instance)
+        await self.session.flush()
+        return instance
+
+    async def hard_delete(self, instance: ModelT, note: str) -> None:
+        if hasattr(instance, "deletion_note"):
+            instance.deletion_note = note
+            self.session.add(instance)
+            await self.session.flush()
+        await self.session.delete(instance)
+        await self.session.flush()
+
+    async def exists(self, field: str, value: Any) -> bool:
+        q = (
+            select(func.count())
+            .select_from(self.model)
+            .where(getattr(self.model, field) == value)
+        )
+        count = (await self.session.execute(q)).scalar_one()
+        return count > 0
+
+
+class SyncBaseRepository(Generic[ModelT]):
+    def __init__(self, model: Type[ModelT], session: Session):
+        self.model = model
+        self.session = session
+
+    def _active_query(self) -> Select:
+        q = select(self.model)
+        if hasattr(self.model, "is_deleted"):
+            q = q.where(self.model.is_deleted == False)
+        return q
+
+    def create(self, data: Dict[str, Any]) -> ModelT:
+        instance = self.model(**data)
+        self.session.add(instance)
+        self.session.flush()
+        self.session.refresh(instance)
+        return instance
+
+    def get_by_id(self, id: UUID, include_deleted: bool = False) -> Optional[ModelT]:
+        q = select(self.model).where(self.model.id == id)
+        if not include_deleted and hasattr(self.model, "is_deleted"):
+            q = q.where(self.model.is_deleted == False)
+        return self.session.execute(q).scalar_one_or_none()
+
+    def get_by_field(self, field: str, value: Any) -> Optional[ModelT]:
+        q = self._active_query().where(getattr(self.model, field) == value)
+        return self.session.execute(q).scalar_one_or_none()
+
+    def get_all(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        pagination: bool = True,
+        filters: Optional[List] = None,
+        search: str | None = None,
+        search_columns: Optional[List] = None,
+        order_by=None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> Tuple[List[ModelT], int]:
+        q = self._active_query()
+        if filters:
+            q = q.where(*filters)
+        search_filter = text_search_filter(self.model, search, search_columns)
+        if search_filter is not None:
+            q = q.where(search_filter)
+        if isinstance(order_by, (list, tuple)):
+            default_order = tuple(order_by)
+        else:
+            default_order = (order_by,) if order_by is not None else ()
+        if not default_order and hasattr(self.model, "created_at"):
+            default_order = (self.model.created_at.desc(),)
+        order = sort_expressions(self.model, sort_by, sort_order, default_order)
+        if order:
+            q = q.order_by(*order)
+
+        total = self.session.execute(
+            select(func.count()).select_from(q.subquery())
+        ).scalar_one()
+
+        q = apply_pagination(q, page, page_size, pagination)
+
+        return list(self.session.execute(q).scalars().all()), total
+
+    def get_all_for_model(
+        self,
+        model: Type[ModelT],
+        page: int = 1,
+        page_size: int = 20,
+        pagination: bool = True,
+        filters: Optional[List] = None,
+        search: str | None = None,
+        search_columns: Optional[List] = None,
+        order_by=None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> Tuple[List[ModelT], int]:
+        q = select(model)
+        if hasattr(model, "is_deleted"):
+            q = q.where(model.is_deleted == False)
+        if filters:
+            q = q.where(*filters)
+        search_filter = text_search_filter(model, search, search_columns)
+        if search_filter is not None:
+            q = q.where(search_filter)
+        if isinstance(order_by, (list, tuple)):
+            default_order = tuple(order_by)
+        else:
+            default_order = (order_by,) if order_by is not None else ()
+        if not default_order and hasattr(model, "created_at"):
+            default_order = (model.created_at.desc(),)
+        order = sort_expressions(model, sort_by, sort_order, default_order)
+        if order:
+            q = q.order_by(*order)
+
+        total = self.session.execute(
+            select(func.count()).select_from(q.subquery())
+        ).scalar_one()
+
+        q = apply_pagination(q, page, page_size, pagination)
+
+        return list(self.session.execute(q).scalars().all()), total
+
+    def get_deleted(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        pagination: bool = True,
+        filters: Optional[List] = None,
+        search: str | None = None,
+        search_columns: Optional[List] = None,
+        order_by=None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> Tuple[List[ModelT], int]:
+        if not hasattr(self.model, "is_deleted"):
+            return [], 0
+
+        q = select(self.model).where(self.model.is_deleted == True)
+        if filters:
+            q = q.where(*filters)
+        search_filter = text_search_filter(self.model, search, search_columns)
+        if search_filter is not None:
+            q = q.where(search_filter)
+        if isinstance(order_by, (list, tuple)):
+            default_order = tuple(order_by)
+        else:
+            default_order = (order_by,) if order_by is not None else ()
+        if not default_order and hasattr(self.model, "deleted_at"):
+            default_order = (self.model.deleted_at.desc(),)
+        order = sort_expressions(self.model, sort_by, sort_order, default_order)
+        if order:
+            q = q.order_by(*order)
+
+        total = self.session.execute(
+            select(func.count()).select_from(q.subquery())
+        ).scalar_one()
+
+        q = apply_pagination(q, page, page_size, pagination)
+
+        return list(self.session.execute(q).scalars().all()), total
+
+    def update(self, instance: ModelT, data: Dict[str, Any]) -> ModelT:
+        for key, value in data.items():
+            if hasattr(instance, key):
+                setattr(instance, key, value)
+        self.session.add(instance)
+        self.session.flush()
+        self.session.refresh(instance)
+        return instance
+
+    def soft_delete(self, instance: ModelT, note: str) -> ModelT:
+        if not hasattr(instance, "soft_delete"):
+            raise AttributeError(f"{self.model.__name__} does not support soft delete")
+        instance.soft_delete(note)
+        self.session.add(instance)
+        self.session.flush()
+        return instance
+
+    def restore(self, instance: ModelT) -> ModelT:
+        if not hasattr(instance, "restore"):
+            raise AttributeError(f"{self.model.__name__} does not support restore")
+        instance.restore()
+        self.session.add(instance)
+        self.session.flush()
+        return instance
+
+    def hard_delete(self, instance: ModelT, note: str) -> None:
+        if hasattr(instance, "deletion_note"):
+            instance.deletion_note = note
+            self.session.add(instance)
+            self.session.flush()
+        self.session.delete(instance)
+        self.session.flush()
+
+    def exists(self, field: str, value: Any) -> bool:
+        count = self.session.execute(
+            select(func.count())
+            .select_from(self.model)
+            .where(getattr(self.model, field) == value)
+        ).scalar_one()
+        return count > 0

fastapi_forge/templates/without_rbac/app/services/__init__.py

@@ -0,0 +1 @@
+

fastapi_forge/templates/without_rbac/app/services/audit.py

@@ -0,0 +1,58 @@
+from typing import Optional
+from uuid import UUID
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.logging import get_logger
+from app.db.models.audit_log import AuditLog
+
+logger = get_logger(__name__)
+
+
+class AuditService:
+    def __init__(self, session: AsyncSession):
+        self.session = session
+
+    async def log(
+        self,
+        action: str,
+        resource: str,
+        resource_id: Optional[str] = None,
+        user_id: Optional[str | UUID] = None,
+        user_email: Optional[str] = None,
+        old_values: Optional[dict] = None,
+        new_values: Optional[dict] = None,
+        metadata: Optional[dict] = None,
+        ip_address: Optional[str] = None,
+        user_agent: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> AuditLog:
+        """
+        Append a single audit log entry. All arguments are optional except
+        action and resource so callers can provide as much or as little
+        context as they have.
+        """
+        entry = AuditLog(
+            action=action,
+            resource=resource,
+            resource_id=resource_id,
+            user_id=UUID(str(user_id)) if user_id else None,
+            user_email=user_email,
+            old_values=old_values,
+            new_values=new_values,
+            log_metadata=metadata,
+            ip_address=ip_address,
+            user_agent=user_agent,
+            request_id=request_id,
+        )
+        self.session.add(entry)
+        await self.session.flush()
+
+        logger.debug(
+            "Audit log written",
+            action=action,
+            resource=resource,
+            resource_id=resource_id,
+            user_id=str(user_id) if user_id else None,
+        )
+        return entry

fastapi_forge/templates/without_rbac/app/services/email.py

@@ -0,0 +1,118 @@
+from pathlib import Path
+from typing import Any, Dict, List
+from uuid import UUID
+
+from fastapi_mail import ConnectionConfig, FastMail, MessageSchema, MessageType
+from pydantic import EmailStr
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.config import settings
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+# ── FastMail configuration ───────────────────────────────────────
+_mail_config = ConnectionConfig(
+    MAIL_USERNAME=settings.mail_username,
+    MAIL_PASSWORD=settings.mail_password,
+    MAIL_FROM=settings.mail_from,
+    MAIL_PORT=settings.mail_port,
+    MAIL_SERVER=settings.mail_server,
+    MAIL_STARTTLS=settings.mail_starttls,
+    MAIL_SSL_TLS=settings.mail_ssl_tls,
+    MAIL_FROM_NAME=settings.mail_from_name,
+    TEMPLATE_FOLDER=Path(__file__).parent.parent / "templates" / "email",
+    USE_CREDENTIALS=True,
+    VALIDATE_CERTS=True,
+)
+
+_fast_mail = FastMail(_mail_config)
+
+
+class EmailService:
+    async def _send(
+        self,
+        recipients: List[EmailStr],
+        subject: str,
+        template_name: str,
+        template_body: Dict[str, Any],
+    ) -> None:
+        message = MessageSchema(
+            subject=subject,
+            recipients=recipients,
+            template_body=template_body,
+            subtype=MessageType.html,
+        )
+        try:
+            await _fast_mail.send_message(message, template_name=template_name)
+            logger.info("Email sent", subject=subject, recipients=recipients)
+        except Exception as exc:
+            logger.error("Email send failed", subject=subject, error=str(exc))
+            raise
+
+    # ── Public send helpers ──────────────────────────────────────
+    async def send_welcome_email(self, to_email: str, full_name: str) -> None:
+        await self._send(
+            recipients=[to_email],
+            subject=f"Welcome to {settings.APP_NAME}!",
+            template_name="welcome.html",
+            template_body={"full_name": full_name, "app_name": settings.APP_NAME},
+        )
+
+    async def send_password_reset_email(self, to_email: str, reset_link: str) -> None:
+        await self._send(
+            recipients=[to_email],
+            subject="Reset your password",
+            template_name="password_reset.html",
+            template_body={"reset_link": reset_link, "app_name": settings.APP_NAME},
+        )
+
+    async def send_email_verification(self, to_email: str, verify_link: str) -> None:
+        await self._send(
+            recipients=[to_email],
+            subject="Verify your email address",
+            template_name="verify_email.html",
+            template_body={"verify_link": verify_link, "app_name": settings.APP_NAME},
+        )
+
+    async def send_notification_email(
+        self,
+        to_user_id: UUID,
+        subject: str,
+        body: str,
+        session: AsyncSession,
+    ) -> None:
+        from app.db.models.user import User
+
+        user = await session.get(User, to_user_id)
+        if not user:
+            logger.warning(
+                "Cannot send notification email — user not found",
+                user_id=str(to_user_id),
+            )
+            return
+        await self._send(
+            recipients=[user.email],
+            subject=subject,
+            template_name="notification.html",
+            template_body={
+                "full_name": user.full_name,
+                "body": body,
+                "app_name": settings.APP_NAME,
+            },
+        )
+
+    async def send_generic(
+        self,
+        to_email: str,
+        subject: str,
+        body_html: str,
+    ) -> None:
+        """Send a one-off HTML email without a template file."""
+        message = MessageSchema(
+            subject=subject,
+            recipients=[to_email],
+            body=body_html,
+            subtype=MessageType.html,
+        )
+        await _fast_mail.send_message(message)

fastapi_forge/templates/without_rbac/app/services/notification.py

@@ -0,0 +1,82 @@
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from sqlalchemy import update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.logging import get_logger
+from app.db.models.notification import Notification
+
+logger = get_logger(__name__)
+
+
+class NotificationService:
+    def __init__(self, session: AsyncSession):
+        self.session = session
+
+    async def send(
+        self,
+        user_id: UUID,
+        title: str,
+        body: str,
+        notification_type: str = "info",
+        channel: str = "in_app",
+        payload: Optional[Dict[str, Any]] = None,
+    ) -> Notification:
+        notification = Notification(
+            user_id=user_id,
+            title=title,
+            body=body,
+            notification_type=notification_type,
+            channel=channel,
+            payload=payload,
+        )
+        self.session.add(notification)
+        await self.session.flush()
+
+        logger.debug(
+            "Notification created",
+            user_id=str(user_id),
+            type=notification_type,
+            channel=channel,
+        )
+
+        # ── Channel-specific dispatch ──────────────────────────
+        if channel == "email":
+            # Lazy import to avoid circular dependency
+            from app.services.email import EmailService
+
+            email_svc = EmailService()
+            # Fire-and-forget; failures are logged, not raised
+            try:
+                await email_svc.send_notification_email(
+                    to_user_id=user_id,
+                    subject=title,
+                    body=body,
+                    session=self.session,
+                )
+            except Exception as exc:
+                logger.warning("Email dispatch failed", error=str(exc))
+
+        return notification
+
+    async def bulk_send(self, user_ids: List[UUID], **kwargs) -> List[Notification]:
+        """Send the same notification to multiple users."""
+        results = []
+        for uid in user_ids:
+            n = await self.send(user_id=uid, **kwargs)
+            results.append(n)
+        return results
+
+    async def mark_all_read(self, user_id: UUID) -> int:
+        result = await self.session.execute(
+            update(Notification)
+            .where(
+                Notification.user_id == user_id,
+                Notification.is_read == False,
+                Notification.is_deleted == False,
+            )
+            .values(is_read=True, read_at=datetime.now(timezone.utc))
+        )
+        return result.rowcount

fastapi_forge/templates/without_rbac/app/templates/email/notification.html

@@ -0,0 +1,7 @@
+<!doctype html>
+<html>
+  <body>
+    <p>Hello {{ full_name }},</p>
+    <div>{{ body }}</div>
+  </body>
+</html>

fastapi_forge/templates/without_rbac/app/templates/email/password_reset.html

@@ -0,0 +1,7 @@
+<!doctype html>
+<html>
+  <body>
+    <p>Use the link below to reset your {{ app_name }} password:</p>
+    <p><a href="{{ reset_link }}">Reset password</a></p>
+  </body>
+</html>

fastapi_forge/templates/without_rbac/app/templates/email/verify_email.html

@@ -0,0 +1,7 @@
+<!doctype html>
+<html>
+  <body>
+    <p>Use the link below to verify your {{ app_name }} email address:</p>
+    <p><a href="{{ verify_link }}">Verify email</a></p>
+  </body>
+</html>

fastapi_forge/templates/without_rbac/app/templates/email/welcome.html

@@ -0,0 +1,6 @@
+<!doctype html>
+<html>
+  <body>
+    <p>Welcome {{ full_name }} to {{ app_name }}.</p>
+  </body>
+</html>

fastapi_forge/templates/without_rbac/app/utils/casing.py

@@ -0,0 +1,31 @@
+from collections.abc import Mapping
+from typing import Any
+
+from fastapi.encoders import jsonable_encoder
+from pydantic.alias_generators import to_camel
+from pydantic import BaseModel, ConfigDict
+
+
+class CamelModel(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+def keys_to_camel(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, BaseModel):
+        return value.model_dump(by_alias=True)
+    if isinstance(value, Mapping):
+        return {to_camel(str(key)): keys_to_camel(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [keys_to_camel(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(keys_to_camel(item) for item in value)
+    encoded = jsonable_encoder(value)
+    if encoded is not value:
+        return keys_to_camel(encoded)
+    return value