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

fastapi_forge/templates/without_rbac/app/api/v1/users/service.py

@@ -0,0 +1,92 @@
+from uuid import UUID
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.v1.users.repository import UserRepository
+from app.api.v1.users.schema import UserCreate, UserResponse, UserUpdate
+from app.core.exceptions import ConflictException, NotFoundException
+from app.core.security import hash_password
+from app.db.models import User
+
+
+class UserService:
+    def __init__(self, session: AsyncSession):
+        self.repo = UserRepository(session)
+
+    async def list_users(self, page, page_size, pagination=True, **kwargs):
+        users, total = await self.repo.get_all(
+            page, page_size, pagination, **kwargs
+        )
+        return [self._to_response(user) for user in users], total
+
+    async def list_deleted_users(self, page, page_size, pagination=True, **kwargs):
+        users, total = await self.repo.get_deleted(
+            page=page,
+            page_size=page_size,
+            pagination=pagination,
+            search=kwargs.get("search"),
+            search_columns=[User.email, User.username, User.full_name],
+            sort_by=kwargs.get("sort_by"),
+            sort_order=kwargs.get("sort_order"),
+        )
+        return [self._to_response(user) for user in users], total
+
+    async def get_user(self, user_id: UUID) -> UserResponse:
+        user = await self.repo.get_active(user_id)
+        if not user:
+            raise NotFoundException("User", user_id)
+        return self._to_response(user)
+
+    async def create_user(self, data: UserCreate) -> UserResponse:
+        email, username = data.email.lower(), data.username.lower()
+        if await self.repo.exists("email", email):
+            raise ConflictException("An account with this email already exists")
+        if await self.repo.exists("username", username):
+            raise ConflictException("Username is already taken")
+        values = data.model_dump(exclude={"password"})
+        values.update(
+            email=email,
+            username=username,
+            hashed_password=hash_password(data.password),
+        )
+        return self._to_response(await self.repo.create(values))
+
+    async def update_user(self, user_id: UUID, data: UserUpdate) -> UserResponse:
+        user = await self.repo.get_by_id(user_id)
+        if not user:
+            raise NotFoundException("User", user_id)
+        values = data.model_dump(exclude_unset=True)
+        for field in ("email", "username"):
+            if field in values:
+                values[field] = values[field].lower()
+                if await self.repo.exists_for_other_user(field, values[field], user_id):
+                    raise ConflictException(f"{field.title()} is already taken")
+        return self._to_response(await self.repo.update(user, values))
+
+    async def soft_delete_user(self, user_id: UUID, note: str) -> None:
+        user = await self.repo.get_by_id(user_id)
+        if not user:
+            raise NotFoundException("User", user_id)
+        await self.repo.soft_delete(user, note)
+
+    async def hard_delete_user(self, user_id: UUID, note: str) -> None:
+        user = await self.repo.get_by_id(user_id, include_deleted=True)
+        if not user:
+            raise NotFoundException("User", user_id)
+        await self.repo.hard_delete(user, note)
+
+    @staticmethod
+    def _to_response(user: User) -> UserResponse:
+        return UserResponse(
+            id=str(user.id),
+            email=user.email,
+            username=user.username,
+            full_name=user.full_name,
+            is_active=user.is_active,
+            is_superuser=user.is_superuser,
+            is_verified=user.is_verified,
+            last_login_at=user.last_login_at.isoformat() if user.last_login_at else None,
+            is_deleted=user.is_deleted,
+            deleted_at=user.deleted_at.isoformat() if user.deleted_at else None,
+            deletion_note=user.deletion_note,
+        )

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

@@ -0,0 +1 @@
+

fastapi_forge/templates/without_rbac/app/core/config.py

@@ -0,0 +1,131 @@
+import json
+from functools import lru_cache
+from typing import List
+
+from pydantic import field_validator, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from sqlalchemy.engine import URL
+
+
+class Settings(BaseSettings):
+    APP_NAME: str = "__PROJECT_NAME__"
+    APP_VERSION: str = "1.0.0"
+    APP_ENV: str = "development"
+    APP_DEBUG: bool = False
+    SECRET_KEY: str = "change-me-in-production"
+    ALLOWED_HOSTS: List[str] = ["*"]
+    ALLOWED_ORIGINS: List[str] = ["*"]
+    log_dir: str = "logs"
+    log_to_files: bool = False
+
+    pg_host: str = "localhost"
+    pg_port: int = 5432
+    pg_database: str = "project_name"
+    pg_user: str = "postgres"
+    pg_password: str = "postgres"
+    pg_sslmode: str = "prefer"
+    database_pool_size: int = 10
+    database_max_overflow: int = 20
+    database_pool_timeout: int = 30
+    database_debug: bool = False
+
+    access_token_expire_minutes: int = 30
+    refresh_token_expire_days: int = 7
+    algorithm: str = "HS256"
+    password_reset_token_expire_minutes: int = 15
+
+    use_redis: bool = False
+    redis_url: str = ""
+    rate_limit_per_minute: int = 60
+
+    mail_username: str = ""
+    mail_password: str = ""
+    mail_from: str = "noreply@example.com"
+    mail_port: int = 587
+    mail_server: str = "smtp.example.com"
+    mail_starttls: bool = True
+    mail_ssl_tls: bool = False
+    mail_from_name: str = "__PROJECT_NAME__"
+    frontend_url: str = "http://localhost:3000"
+
+    default_page_size: int = 20
+    max_page_size: int = 100
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    @field_validator("ALLOWED_HOSTS", "ALLOWED_ORIGINS", mode="before")
+    @classmethod
+    def parse_json_or_csv_list(cls, value):
+        if isinstance(value, str):
+            value = value.strip()
+            if not value:
+                return []
+            if value.startswith("["):
+                return json.loads(value)
+            return [item.strip() for item in value.split(",") if item.strip()]
+        return value
+
+    @model_validator(mode="after")
+    def validate_production_settings(self):
+        if not self.is_production:
+            return self
+        default_secrets = {
+            "change-me-in-production",
+            "replace-with-a-long-random-secret",
+        }
+        if self.SECRET_KEY in default_secrets or len(self.SECRET_KEY) < 32:
+            raise ValueError(
+                "Production SECRET_KEY must be a unique value of at least 32 characters"
+            )
+        if not self.ALLOWED_HOSTS or "*" in self.ALLOWED_HOSTS:
+            raise ValueError("Production ALLOWED_HOSTS must contain explicit hostnames")
+        if not self.ALLOWED_ORIGINS or "*" in self.ALLOWED_ORIGINS:
+            raise ValueError("Production ALLOWED_ORIGINS must contain explicit origins")
+        if self.pg_sslmode in {"disable", "allow", "prefer"}:
+            raise ValueError("Production PG_SSLMODE must verify or require TLS")
+        return self
+
+    @property
+    def postgres_url(self) -> str:
+        return URL.create(
+            "postgresql+psycopg",
+            username=self.pg_user,
+            password=self.pg_password,
+            host=self.pg_host,
+            port=self.pg_port,
+            database=self.pg_database,
+            query={"sslmode": self.pg_sslmode},
+        ).render_as_string(hide_password=False)
+
+    @property
+    def postgres_async_url(self) -> str:
+        return URL.create(
+            "postgresql+asyncpg",
+            username=self.pg_user,
+            password=self.pg_password,
+            host=self.pg_host,
+            port=self.pg_port,
+            database=self.pg_database,
+            query={"ssl": self.pg_sslmode},
+        ).render_as_string(hide_password=False)
+
+    @property
+    def is_production(self) -> bool:
+        return self.APP_ENV.lower() in {"production", "prod"}
+
+    @property
+    def is_development(self) -> bool:
+        return self.APP_ENV.lower() in {"development", "dev"}
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+
+
+settings = get_settings()

fastapi_forge/templates/without_rbac/app/core/dependencies.py

@@ -0,0 +1,71 @@
+from collections.abc import AsyncGenerator, Generator
+from typing import Optional
+
+from fastapi import Depends
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+from app.api.v1.auth.repository import RevokedTokenRepository
+from app.core.exceptions import ForbiddenException, UnauthorizedException
+from app.core.security import decode_token
+from app.db.session import AsyncSessionLocal, SyncSessionLocal
+
+bearer_scheme = HTTPBearer(auto_error=False)
+
+
+async def get_async_db() -> AsyncGenerator[AsyncSession, None]:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+
+
+def get_sync_db() -> Generator[Session, None, None]:
+    db = SyncSessionLocal()
+    try:
+        yield db
+        db.commit()
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
+def get_db() -> Generator[Session, None, None]:
+    yield from get_sync_db()
+
+
+async def get_current_user_payload(
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(bearer_scheme),
+    db: AsyncSession = Depends(get_async_db),
+) -> dict:
+    if not credentials:
+        raise UnauthorizedException("Bearer token missing")
+    payload = decode_token(credentials.credentials, expected_type="access")
+    jti = payload.get("jti")
+    if not jti or await RevokedTokenRepository(db).is_revoked(jti):
+        raise UnauthorizedException("Token is invalid or revoked")
+    return payload
+
+
+async def get_current_user_id(
+    payload: dict = Depends(get_current_user_payload),
+) -> str:
+    user_id = payload.get("sub")
+    if not user_id:
+        raise UnauthorizedException("Invalid token payload")
+    return user_id
+
+
+async def require_superuser(
+    payload: dict = Depends(get_current_user_payload),
+) -> dict:
+    if not payload.get("is_superuser"):
+        raise ForbiddenException("Superuser access required")
+    return payload
+

fastapi_forge/templates/without_rbac/app/core/exceptions.py

@@ -0,0 +1,162 @@
+from typing import Any, Optional
+from fastapi import Request, status
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from app.core.logging import get_logger
+from app.core.responses import error_response
+
+logger = get_logger(__name__)
+
+
+# ── Custom Exception Base ────────────────────────────────────────
+class AppException(Exception):
+    def __init__(
+        self,
+        message: str,
+        status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR,
+        error_code: Optional[str] = None,
+        details: Optional[Any] = None,
+    ):
+        self.message = message
+        self.status_code = status_code
+        self.error_code = error_code or f"ERR_{status_code}"
+        self.details = details
+        super().__init__(message)
+
+
+# ── Domain-specific Exceptions ───────────────────────────────────
+class NotFoundException(AppException):
+    def __init__(self, resource: str = "Resource", resource_id: Any = None):
+        msg = f"{resource} not found"
+        if resource_id:
+            msg = f"{resource} with id '{resource_id}' not found"
+        super().__init__(msg, status.HTTP_404_NOT_FOUND, "NOT_FOUND")
+
+
+class UnauthorizedException(AppException):
+    def __init__(self, message: str = "Authentication required"):
+        super().__init__(message, status.HTTP_401_UNAUTHORIZED, "UNAUTHORIZED")
+
+
+class ForbiddenException(AppException):
+    def __init__(self, message: str = "Permission denied"):
+        super().__init__(message, status.HTTP_403_FORBIDDEN, "FORBIDDEN")
+
+
+class ConflictException(AppException):
+    def __init__(self, message: str = "Resource already exists"):
+        super().__init__(message, status.HTTP_409_CONFLICT, "CONFLICT")
+
+
+class ValidationException(AppException):
+    def __init__(self, message: str = "Validation failed", details: Any = None):
+        super().__init__(
+            message, status.HTTP_422_UNPROCESSABLE_ENTITY, "VALIDATION_ERROR", details
+        )
+
+
+class RateLimitException(AppException):
+    def __init__(self, message: str = "Too many requests"):
+        super().__init__(
+            message, status.HTTP_429_TOO_MANY_REQUESTS, "RATE_LIMIT_EXCEEDED"
+        )
+
+
+class ServiceUnavailableException(AppException):
+    def __init__(self, message: str = "Service temporarily unavailable"):
+        super().__init__(
+            message, status.HTTP_503_SERVICE_UNAVAILABLE, "SERVICE_UNAVAILABLE"
+        )
+
+
+# ── Exception Handlers ───────────────────────────────────────────
+async def app_exception_handler(request: Request, exc: AppException) -> JSONResponse:
+    logger.error(
+        "Application exception",
+        error_code=exc.error_code,
+        message=exc.message,
+        status_code=exc.status_code,
+        path=str(request.url),
+    )
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=error_response(
+            message=exc.message,
+            error_code=exc.error_code,
+            details=exc.details,
+            request_id=getattr(request.state, "request_id", None),
+        ).model_dump(by_alias=True),
+    )
+
+
+async def http_exception_handler(
+    request: Request, exc: StarletteHTTPException
+) -> JSONResponse:
+    logger.warning(
+        "HTTP exception",
+        status_code=exc.status_code,
+        detail=exc.detail,
+        path=str(request.url),
+    )
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=error_response(
+            message=str(exc.detail),
+            error_code=f"HTTP_{exc.status_code}",
+            request_id=getattr(request.state, "request_id", None),
+        ).model_dump(by_alias=True),
+    )
+
+
+async def validation_exception_handler(
+    request: Request, exc: RequestValidationError
+) -> JSONResponse:
+    errors = []
+    for error in exc.errors():
+        errors.append(
+            {
+                "field": " -> ".join(str(loc) for loc in error["loc"]),
+                "message": error["msg"],
+                "type": error["type"],
+            }
+        )
+
+    logger.warning(
+        "Request validation failed",
+        errors=errors,
+        path=str(request.url),
+    )
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content=error_response(
+            message="Request validation failed",
+            error_code="VALIDATION_ERROR",
+            details=errors,
+            request_id=getattr(request.state, "request_id", None),
+        ).model_dump(by_alias=True),
+    )
+
+
+async def unhandled_exception_handler(request: Request, exc: Exception) -> JSONResponse:
+    logger.exception(
+        "Unhandled exception",
+        exc_info=exc,
+        path=str(request.url),
+    )
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content=error_response(
+            message="An unexpected error occurred",
+            error_code="INTERNAL_SERVER_ERROR",
+            request_id=getattr(request.state, "request_id", None),
+        ).model_dump(by_alias=True),
+    )
+
+
+def register_exception_handlers(app) -> None:
+    app.add_exception_handler(AppException, app_exception_handler)
+    app.add_exception_handler(StarletteHTTPException, http_exception_handler)
+    app.add_exception_handler(RequestValidationError, validation_exception_handler)
+    app.add_exception_handler(Exception, unhandled_exception_handler)

fastapi_forge/templates/without_rbac/app/core/logging.py

@@ -0,0 +1,231 @@
+import logging
+import logging.handlers
+import sys
+import uuid
+from contextvars import ContextVar
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+import structlog
+from app.core.config import settings
+
+# ── Context var to carry request-id across async tasks ──────────
+request_id_ctx: ContextVar[Optional[str]] = ContextVar("request_id", default=None)
+
+
+def get_request_id() -> str:
+    return request_id_ctx.get() or str(uuid.uuid4())
+
+
+def set_request_id(request_id: str) -> None:
+    request_id_ctx.set(request_id)
+
+
+# ── Add request_id to every log record automatically ────────────
+def add_request_id(logger, method, event_dict):
+    event_dict["request_id"] = get_request_id()
+    return event_dict
+
+
+def add_app_info(logger, method, event_dict):
+    event_dict["app"] = settings.APP_NAME
+    event_dict["env"] = settings.APP_ENV
+    return event_dict
+
+
+# ── Log level filter ───────────────────────────────────────────
+def level_filter(levels: list[int]):
+    """Return a logging filter function that passes only specified log levels."""
+    allowed_levels = set(levels)
+
+    def filter_record(record: logging.LogRecord) -> bool:
+        return record.levelno in allowed_levels
+
+    return filter_record
+
+
+# ── Build daily rotating file handler ─────────────────────────
+def _build_file_handler(
+    log_dir: str, level: int, label: str, formatter: logging.Formatter
+) -> logging.Handler:
+    """
+    TimedRotatingFileHandler that writes to  <log_dir>/YYYY-MM-DD_<label>.log.
+    The date prefix is embedded in the *base* filename so every day's file
+    carries the date as a prefix rather than a suffix.
+    """
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+    # Create date-wise log directory.
+    date_dir = Path(log_dir) / today
+    date_dir.mkdir(parents=True, exist_ok=True)
+
+    # Example:
+    # logs/2026-07-29/error.log
+    path = date_dir / f"{label}.log"
+
+    handler = logging.handlers.TimedRotatingFileHandler(
+        filename=str(path),
+        when="midnight",
+        interval=1,
+        backupCount=30,
+        utc=True,
+        encoding="utf-8",
+    )
+
+    handler.suffix = "%Y-%m-%d"
+    handler.setLevel(level)
+    handler.setFormatter(formatter)
+    return handler
+
+
+# ── Configure per-level file logging ──────────────────────────
+def _setup_file_logging(
+    log_dir: str, root_level: int, formatter: logging.Formatter
+) -> None:
+    """Attach per-level file handlers to the root stdlib logger."""
+
+    Path(log_dir).mkdir(parents=True, exist_ok=True)
+
+    root = logging.getLogger()
+
+    # Remove previously configured application file handlers.
+    # This prevents duplicate logs when configure_logging() is
+    # called more than once, which can happen with reloaders.
+    for handler in root.handlers[:]:
+        if getattr(handler, "_app_file_handler", False):
+            root.removeHandler(handler)
+            handler.close()
+
+    level_map = [
+        (logging.DEBUG, [logging.DEBUG], "debug"),
+        (logging.INFO, [logging.INFO], "info"),
+        (logging.WARNING, [logging.WARNING], "warn"),
+        (logging.ERROR, [logging.ERROR, logging.CRITICAL], "error"),
+    ]
+
+    for min_level, filter_levels, label in level_map:
+        # Do not create files below the configured log level.
+        if min_level < root_level:
+            continue
+
+        handler = _build_file_handler(
+            log_dir=log_dir, level=min_level, label=label, formatter=formatter
+        )
+
+        # Mark handler so it can be identified and removed later.
+        handler._app_file_handler = True
+
+        # Only allow the exact levels assigned to this file.
+        handler.addFilter(level_filter(filter_levels))
+        root.addHandler(handler)
+
+
+# ── Logging configuration ─────────────────────────────────────
+def configure_logging() -> None:
+    """
+    Configure Structlog, console logging, file logging,
+    and third-party library logging.
+    """
+
+    log_level = logging.DEBUG if settings.APP_DEBUG else logging.INFO
+
+    common_shared_processors = [
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+    ]
+
+    shared_processors = common_shared_processors + [
+        structlog.contextvars.merge_contextvars,
+        add_request_id,
+        add_app_info,
+    ]
+
+    # ── Console formatter ──────────────────────────────────────
+    # Pretty console output for development.
+    # Colors are disabled automatically outside development.
+    console_formatter = structlog.stdlib.ProcessorFormatter(
+        processor=structlog.dev.ConsoleRenderer(
+            colors=settings.is_development,
+            exception_formatter=structlog.dev.plain_traceback,
+        ),
+        foreign_pre_chain=shared_processors,
+    )
+
+    # ── JSON file formatter ────────────────────────────────────
+    # Structured JSON output for log aggregators and production
+    # log analysis.
+    json_formatter = structlog.stdlib.ProcessorFormatter(
+        processor=structlog.processors.JSONRenderer(),
+        foreign_pre_chain=shared_processors,
+    )
+
+    # ── Configure Structlog ────────────────────────────────────
+
+    structlog.configure(
+        processors=common_shared_processors
+        + [
+            structlog.stdlib.filter_by_level,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    # ── Root logger ────────────────────────────────────────────
+
+    root = logging.getLogger()
+    root.setLevel(log_level)
+
+    # Remove existing handlers to avoid:
+    for handler in root.handlers[:]:
+        root.removeHandler(handler)
+        handler.close()
+
+    # ── Console handler ────────────────────────────────────────
+
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(log_level)
+    console_handler.setFormatter(console_formatter)
+
+    root.addHandler(console_handler)
+
+    # ── File handlers ──────────────────────────────────────────
+    if settings.log_to_files:
+        _setup_file_logging(
+            log_dir=settings.log_dir,
+            root_level=log_level,
+            formatter=json_formatter,
+        )
+
+    # ── Third-party libraries ──────────────────────────────────
+
+    # FastAPI application logs.
+    logging.getLogger("fastapi").setLevel(log_level)
+
+    # Uvicorn access logs
+    logging.getLogger("uvicorn.access").setLevel(logging.INFO)
+
+    # Uvicorn server errors.
+    logging.getLogger("uvicorn.error").setLevel(logging.ERROR)
+
+    # APScheduler:
+    logging.getLogger("apscheduler").setLevel(logging.WARNING)
+
+    # SQLAlchemy SQL logging:
+    #
+    # Keep disabled unless explicitly debugging SQL.
+    logging.getLogger("sqlalchemy.engine").setLevel(logging.WARNING)
+
+    # SQLAlchemy connection pool logging.
+    logging.getLogger("sqlalchemy.pool").setLevel(logging.WARNING)
+
+
+# ── Logger factory ─────────────────────────────────────────────
+def get_logger(name: str = __name__):
+    return structlog.get_logger(name)