core-framework 0.3.0__py3-none-any.whl

core_framework/core/exception_handlers/comment.py

@@ -0,0 +1,99 @@
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+from core_framework.core.exception_handlers.common import GENERIC_INTERNAL_SERVER_ERROR_DETAIL
+from core_framework.domains.comment import (
+    BaseCommentException,
+    CommentEditLimitReachedException,
+    CommentNotFoundException,
+    CommentUpdateNotFoundException,
+    MaxReplyDepthException,
+    ParentCommentNotFoundException,
+)
+
+
+async def parent_comment_not_found_exception_handler(
+    request: Request,
+    exc: ParentCommentNotFoundException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_404_NOT_FOUND,
+        content={"detail": exc.message},
+    )
+
+
+async def comment_not_found_exception_handler(
+    request: Request,
+    exc: CommentNotFoundException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_404_NOT_FOUND,
+        content={"detail": exc.message},
+    )
+
+
+async def max_reply_depth_exception_handler(
+    request: Request,
+    exc: MaxReplyDepthException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def comment_update_not_found_exception_handler(
+    request: Request,
+    exc: CommentUpdateNotFoundException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def comment_edit_limit_reached_exception_handler(
+    request: Request,
+    exc: CommentEditLimitReachedException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_409_CONFLICT,
+        content={"detail": exc.message},
+    )
+
+
+async def base_comment_exception_handler(
+    request: Request,
+    exc: BaseCommentException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": GENERIC_INTERNAL_SERVER_ERROR_DETAIL},
+    )
+
+
+def add_comment_exception_handlers(app: FastAPI) -> None:
+    app.add_exception_handler(
+        CommentNotFoundException,
+        comment_not_found_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+    app.add_exception_handler(
+        ParentCommentNotFoundException,
+        parent_comment_not_found_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+    app.add_exception_handler(
+        MaxReplyDepthException,
+        max_reply_depth_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+    app.add_exception_handler(
+        CommentUpdateNotFoundException,
+        comment_update_not_found_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+    app.add_exception_handler(
+        CommentEditLimitReachedException,
+        comment_edit_limit_reached_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+    app.add_exception_handler(
+        BaseCommentException,
+        base_comment_exception_handler,  # ty: ignore[invalid-argument-type]
+    )

core_framework/core/exception_handlers/common.py

@@ -0,0 +1,5 @@
+from typing import Final
+
+GENERIC_INTERNAL_SERVER_ERROR_DETAIL: Final[str] = (
+    "Something went wrong while processing your request. Please try again later."
+)

core_framework/core/exception_handlers/moderation.py

@@ -0,0 +1,104 @@
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+from core_framework.core.exception_handlers.common import GENERIC_INTERNAL_SERVER_ERROR_DETAIL
+from core_framework.domains.moderation import (
+    AppealAlreadyDecidedException,
+    AppealNotFoundException,
+    AppealRequirementException,
+    BaseModerationException,
+    ExistingPendingAppealException,
+    SelfReportException,
+)
+
+
+async def self_report_exception_handler(
+    request: Request,
+    exc: SelfReportException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def appeal_requirement_exception_handler(
+    request: Request,
+    exc: AppealRequirementException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def existing_pending_appeal_exception_handler(
+    request: Request,
+    exc: ExistingPendingAppealException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def appeal_not_found_exception_handler(
+    request: Request,
+    exc: AppealNotFoundException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_404_NOT_FOUND,
+        content={"detail": exc.message},
+    )
+
+
+async def appeal_already_decided_exception_handler(
+    request: Request,
+    exc: AppealAlreadyDecidedException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def base_moderation_exception_handler(
+    request: Request,
+    exc: BaseModerationException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": GENERIC_INTERNAL_SERVER_ERROR_DETAIL},
+    )
+
+
+def add_moderation_exception_handlers(app: FastAPI) -> None:
+    app.add_exception_handler(
+        SelfReportException,
+        self_report_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        AppealRequirementException,
+        appeal_requirement_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        ExistingPendingAppealException,
+        existing_pending_appeal_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        AppealNotFoundException,
+        appeal_not_found_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        AppealAlreadyDecidedException,
+        appeal_already_decided_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        BaseModerationException,
+        base_moderation_exception_handler,  # ty: ignore[invalid-argument-type]
+    )

core_framework/core/exception_handlers/post.py

@@ -0,0 +1,54 @@
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+from core_framework.core.exception_handlers.common import GENERIC_INTERNAL_SERVER_ERROR_DETAIL
+from core_framework.domains.post import (
+    BasePostException,
+    EditLimitReachedException,
+    PostUpdateNotFoundException,
+)
+
+
+async def post_update_not_found_exception_handler(
+    request: Request,
+    exc: PostUpdateNotFoundException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def edit_limit_reached_exception_handler(
+    request: Request,
+    exc: EditLimitReachedException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_409_CONFLICT,
+        content={"detail": exc.message},
+    )
+
+
+async def base_post_exception_handler(
+    request: Request,
+    exc: BasePostException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": GENERIC_INTERNAL_SERVER_ERROR_DETAIL},
+    )
+
+
+def add_post_exception_handlers(app: FastAPI) -> None:
+    app.add_exception_handler(
+        PostUpdateNotFoundException,
+        post_update_not_found_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+    app.add_exception_handler(
+        EditLimitReachedException,
+        edit_limit_reached_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+    app.add_exception_handler(
+        BasePostException,
+        base_post_exception_handler,  # ty: ignore[invalid-argument-type]
+    )

core_framework/core/exception_handlers/setup.py

@@ -0,0 +1,80 @@
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+from core_framework.application.shared.exceptions import (
+    ForbiddenException,
+    UnauthorizedException,
+    UserNotFoundException,
+)
+from core_framework.core.exception_handlers.comment import add_comment_exception_handlers
+from core_framework.core.exception_handlers.moderation import add_moderation_exception_handlers
+from core_framework.core.exception_handlers.post import add_post_exception_handlers
+from core_framework.core.exception_handlers.user import add_user_exception_handlers
+from core_framework.domains.post import PostNotFoundException
+
+
+async def unauthorized_exception_handler(
+    request: Request,
+    exc: UnauthorizedException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        content={"detail": exc.message},
+    )
+
+
+async def forbidden_exception_handler(
+    request: Request,
+    exc: ForbiddenException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_403_FORBIDDEN,
+        content={"detail": exc.message},
+    )
+
+
+async def user_not_found_exception_handler(
+    request: Request,
+    exc: UserNotFoundException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_404_NOT_FOUND,
+        content={"detail": exc.message},
+    )
+
+
+async def post_not_found_exception_handler(
+    request: Request,
+    exc: PostNotFoundException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_404_NOT_FOUND,
+        content={"detail": exc.message},
+    )
+
+
+def setup_exception_handlers(app: FastAPI) -> None:
+    app.add_exception_handler(
+        UnauthorizedException,
+        unauthorized_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        ForbiddenException,
+        forbidden_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        UserNotFoundException,
+        user_not_found_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        PostNotFoundException,
+        post_not_found_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    add_user_exception_handlers(app)
+    add_comment_exception_handlers(app)
+    add_moderation_exception_handlers(app)
+    add_post_exception_handlers(app)

core_framework/core/exception_handlers/user.py

@@ -0,0 +1,72 @@
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+
+from core_framework.core.exception_handlers.common import GENERIC_INTERNAL_SERVER_ERROR_DETAIL
+from core_framework.domains.user import (
+    BaseUserException,
+    SelfBlockException,
+    UserIdConflictException,
+    UsernameConflictException,
+)
+
+
+async def username_conflict_exception_handler(
+    request: Request,
+    exc: UsernameConflictException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_409_CONFLICT,
+        content={"detail": exc.message},
+    )
+
+
+async def user_id_conflict_exception_handler(
+    request: Request,
+    exc: UserIdConflictException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_409_CONFLICT,
+        content={"detail": exc.message},
+    )
+
+
+async def self_block_exception_handler(
+    request: Request,
+    exc: SelfBlockException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": exc.message},
+    )
+
+
+async def base_user_exception_handler(
+    request: Request,
+    exc: BaseUserException,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": GENERIC_INTERNAL_SERVER_ERROR_DETAIL},
+    )
+
+
+def add_user_exception_handlers(app: FastAPI) -> None:
+    app.add_exception_handler(
+        UsernameConflictException,
+        username_conflict_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        UserIdConflictException,
+        user_id_conflict_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        SelfBlockException,
+        self_block_exception_handler,  # ty: ignore[invalid-argument-type]
+    )
+
+    app.add_exception_handler(
+        BaseUserException,
+        base_user_exception_handler,  # ty: ignore[invalid-argument-type]
+    )

core_framework/core/http_client.py

@@ -0,0 +1,64 @@
+from types import TracebackType
+from typing import Any, Final, Self
+
+from httpx import AsyncClient, Limits, Timeout
+
+HTTP_CLIENT_NOT_CONNECTED_MSG: Final[str] = "HTTP client is not connected"
+HTTP_CLIENT_ALREADY_CONNECTED_MSG: Final[str] = "HTTP client is already connected"
+
+
+class HttpClient:
+    __slots__ = ("_client", "_limits", "_timeout", "_event_hooks", "_headers")
+
+    def __init__(
+        self,
+        timeout: Timeout,
+        limits: Limits,
+        event_hooks: dict[str, Any] | None = None,
+        headers: dict[str, Any] | None = None,
+    ) -> None:
+        self._client: AsyncClient | None = None
+        self._timeout = timeout
+        self._limits = limits
+        self._event_hooks = event_hooks
+        self._headers = headers
+
+    async def __aenter__(self) -> Self:
+        return await self.connect()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.disconnect()
+
+    async def connect(self) -> Self:
+        if self._client is not None:
+            raise RuntimeError(HTTP_CLIENT_ALREADY_CONNECTED_MSG)
+
+        self._client = AsyncClient(
+            http2=True,
+            timeout=self._timeout,
+            limits=self._limits,
+            event_hooks=self._event_hooks,
+            headers=self._headers,
+        )
+        return self
+
+    async def disconnect(self) -> None:
+        if self._client is None:
+            return
+
+        try:
+            await self._client.aclose()
+        finally:
+            self._client = None
+
+    @property
+    def client(self) -> AsyncClient:
+        if self._client is None:
+            raise RuntimeError(HTTP_CLIENT_NOT_CONNECTED_MSG)
+
+        return self._client

core_framework/core/logging.py

@@ -0,0 +1,99 @@
+import logging
+
+import loguru
+import orjson
+from loguru import logger
+
+from core_framework.core.context import client_ip, request_id, user_id, user_ip
+from core_framework.core.settings import Settings
+
+
+class InterceptHandler(logging.Handler):
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            level: str | int = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+
+        frame = logging.currentframe()
+        depth = 2
+        while frame and frame.f_code.co_filename == logging.__file__:
+            frame = frame.f_back
+            depth += 1
+
+        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
+def _configure_uvicorn_logging() -> None:
+    logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)
+
+    for name in logging.root.manager.loggerDict.keys():
+        if name.startswith("uvicorn"):
+            logging.getLogger(name).handlers = [InterceptHandler()]
+            logging.getLogger(name).propagate = False
+
+
+def _custom_serializer(record: loguru.Record) -> str:
+    subset = {
+        "time": record["time"].isoformat(),
+        "level": record["level"].name,
+        "message": record["message"],
+    }
+
+    if record["extra"].get("context"):
+        subset.update(record["extra"]["context"])
+
+    return orjson.dumps(subset).decode()
+
+
+def _add_context_to_record(record: loguru.Record) -> None:
+    if "context" not in record["extra"]:
+        record["extra"]["context"] = {}
+
+    if (user_id_value := user_id.get()) is not None:
+        record["extra"]["context"]["user_id"] = user_id_value
+    if (user_ip_value := user_ip.get()) is not None:
+        record["extra"]["context"]["user_ip"] = user_ip_value
+    if (client_ip_value := client_ip.get()) is not None:
+        record["extra"]["context"]["client_ip"] = client_ip_value
+    if (request_id_value := request_id.get()) is not None:
+        record["extra"]["context"]["request_id"] = request_id_value
+
+
+def _patch_serializer(record: loguru.Record) -> None:
+    _add_context_to_record(record)
+    record["extra"]["json_output"] = _custom_serializer(record)
+
+
+def setup_logging(settings: Settings) -> None:
+    if settings.app.environment == "local":
+        return
+
+    if settings.observability.enabled:
+        patched_logger = logger.patch(_add_context_to_record)
+
+        loguru.logger = patched_logger
+        globals()["logger"] = patched_logger
+
+        _configure_uvicorn_logging()
+        return
+
+    logger.remove()
+    patched_logger = logger.patch(_patch_serializer)
+
+    loguru.logger = patched_logger
+    globals()["logger"] = patched_logger
+
+    patched_logger.add(
+        settings.logging.sink,
+        format="{extra[json_output]}",
+        level=settings.logging.level,
+        rotation="10 MB",
+        retention="7 days",
+        compression="gz",
+        enqueue=True,
+        backtrace=True,
+        diagnose=False,
+    )
+
+    _configure_uvicorn_logging()

core_framework/core/middleware.py

@@ -0,0 +1,64 @@
+from brotli_asgi import BrotliMiddleware
+from fastapi import FastAPI, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+from fastapi.responses import JSONResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+from ulid import ULID
+from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
+
+from core_framework.core.context import REQUEST_CONTEXTVARS, client_ip, request_id
+from core_framework.core.settings import Settings
+
+
+class ContextMiddleware:
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        try:
+            if scope.get("path", "") not in {"/health", "/readiness"}:
+                client = scope["client"]
+                if client is None:
+                    response = JSONResponse(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        content={"detail": "Client IP could not be determined"},
+                    )
+                    await response(scope, receive, send)
+                    return
+                client_ip.set(client[0])
+                request_id.set(str(ULID()))
+            await self.app(scope, receive, send)
+        finally:
+            for contextvar in REQUEST_CONTEXTVARS:
+                contextvar.set(None)
+
+
+def setup_middleware(app: FastAPI, settings: Settings) -> None:
+    app.add_middleware(ContextMiddleware)  # ty: ignore[invalid-argument-type]
+
+    app.add_middleware(
+        BrotliMiddleware,  # ty: ignore[invalid-argument-type]
+        minimum_size=102_400,  # Decrease this if no longer using cloudflare
+    )
+
+    app.add_middleware(
+        CORSMiddleware,  # ty: ignore[invalid-argument-type]
+        allow_credentials=settings.cors.allow_credentials,
+        allow_origins=settings.cors.allowed_origins,
+        allow_methods=settings.cors.allowed_methods,
+        allow_headers=settings.cors.allowed_headers,
+    )
+
+    app.add_middleware(
+        TrustedHostMiddleware,  # ty: ignore[invalid-argument-type]
+        allowed_hosts=settings.app.allowed_hosts,
+    )
+
+    app.add_middleware(
+        ProxyHeadersMiddleware,  # ty: ignore[invalid-argument-type]
+        trusted_hosts=["*"],
+    )

core_framework/core/observability.py

@@ -0,0 +1,36 @@
+import logfire
+import loguru
+from fastapi import FastAPI
+
+from core_framework.core.settings import Settings
+
+
+def setup_observability(app: FastAPI, settings: Settings) -> None:
+    if settings.app.environment == "local":
+        return
+
+    if not settings.observability.enabled:
+        return
+
+    logfire.configure(
+        service_name="core_framework-api",
+        token=settings.observability.logfire_token,
+        min_level=settings.logging.level,
+    )
+
+    loguru.logger.configure(handlers=[logfire.loguru_handler()])
+
+    logfire.instrument_httpx()
+
+    logfire.instrument_asyncpg()
+
+    logfire.instrument_redis()
+
+    logfire.instrument_fastapi(
+        app=app,
+        excluded_urls=[
+            "/health",
+            "/readiness",
+        ],
+        capture_headers=False,
+    )