10xgraph-api 0.7.0__py3-none-any.whl

tenxgraph_api/src/app/core/config/setup_middleware.py

@@ -0,0 +1,483 @@
+import uuid
+from datetime import datetime
+
+from fastapi import FastAPI
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+from fastapi.responses import JSONResponse
+from injectq import InjectQ
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from tenxgraph_api.src.app.core.middleware.rate_limit import RateLimitMiddleware, build_backend
+from tenxgraph_api.src.app.core.middleware.request_limits import RequestSizeLimitMiddleware
+from tenxgraph_api.src.app.core.middleware.security_headers import SecurityHeadersMiddleware
+
+from .graph_config import GraphConfig
+from .sentry_config import init_sentry
+from .settings import get_settings, logger
+
+
+class HealthCheckAwareTrustedHostMiddleware(TrustedHostMiddleware):
+    """``TrustedHostMiddleware`` that lets the health check through from any Host.
+
+    Docker and Kubernetes probes call ``/ping`` on ``localhost`` or the pod IP, which are
+    never in ``ALLOWED_HOST``, so the probe would fail and the container would be restarted.
+    ``/ping`` returns a constant and reads nothing, so skipping the Host check there is safe.
+    """
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "http" and _is_health_check(scope):
+            await self.app(scope, receive, send)
+            return
+        await super().__call__(scope, receive, send)
+
+
+# Multipart framing (boundaries, part headers, the filename field) on top of the file bytes.
+UPLOAD_MULTIPART_OVERHEAD_BYTES = 64 * 1024
+
+
+def _upload_path_limits(max_request_size: int) -> dict[str, int]:
+    """A body limit for the upload route that fits ``MEDIA_MAX_SIZE_MB``, if that is larger."""
+    from tenxgraph_api.src.app.core.config.media_settings import get_media_settings
+
+    media_bytes = int(get_media_settings().MEDIA_MAX_SIZE_MB * 1024 * 1024)
+    upload_limit = media_bytes + UPLOAD_MULTIPART_OVERHEAD_BYTES
+    if upload_limit <= max_request_size:
+        return {}
+    return {"/v1/files/upload": upload_limit}
+
+
+def _is_health_check(scope: Scope) -> bool:
+    path = scope.get("path", "")
+    root_path = (scope.get("root_path") or "").rstrip("/")
+    return path in ("/ping", f"{root_path}/ping")
+
+
+# Paths that should be excluded from GZip compression (streaming endpoints)
+GZIP_EXCLUDED_PATHS = frozenset({"/v1/graph/stream"})
+
+# StaleStateError is raised by checkpointers that do optimistic concurrency
+# control on state writes. It was added in a later core release, and this package
+# supports 10xgraph>=0.7.0, so treat it as optional: when the installed
+# core does not expose it, we simply do not register the 409 handler.
+try:
+    from tenxgraph.core.exceptions import StaleStateError
+except ImportError:  # pragma: no cover - depends on installed core version
+    StaleStateError = None  # type: ignore[assignment]
+
+
+class InsecureCorsConfigError(RuntimeError):
+    """Raised when production is configured with wildcard CORS + credentials."""
+
+
+def _resolve_cors_policy(settings) -> tuple[list[str], bool]:
+    """Decide the CORS origins/credentials policy, failing closed in production.
+
+    ``ORIGINS="*"`` on its own is a legitimate choice for a public, token-less
+    API, and a permissive default is normal in development. The dangerous case is
+    wildcard origins *combined with credentials*: Starlette reflects the caller's
+    Origin header back alongside ``Access-Control-Allow-Credentials: true``, which
+    turns every origin into a trusted, credentialed one. Warning about it (the old
+    behaviour) still served it.
+
+    In production that combination is refused outright, with two ways forward:
+    set explicit ``ORIGINS``, or set ``CORS_ALLOW_CREDENTIALS=false``.
+    """
+    origins = [o.strip() for o in settings.ORIGINS.split(",") if o.strip()]
+    allow_credentials = bool(getattr(settings, "CORS_ALLOW_CREDENTIALS", True))
+    is_wildcard = "*" in origins
+    is_production = str(getattr(settings, "MODE", "development")).lower() == "production"
+
+    if is_wildcard and allow_credentials:
+        if is_production:
+            raise InsecureCorsConfigError(
+                "Refusing to start: CORS is configured with ORIGINS='*' and "
+                "credentials enabled while MODE=production. This reflects any "
+                "caller's Origin back with Access-Control-Allow-Credentials: true, "
+                "making every origin a trusted one. Fix by either:\n"
+                "  1. setting ORIGINS to an explicit comma-separated list, or\n"
+                "  2. setting CORS_ALLOW_CREDENTIALS=false for a public, "
+                "non-credentialed API."
+            )
+        logger.warning(
+            "CORS is wildcard ('*') with credentials enabled. This is accepted in "
+            "development but will refuse to start when MODE=production."
+        )
+
+    return origins, allow_credentials
+
+
+async def _stale_state_handler(request: Request, exc: Exception) -> JSONResponse:
+    """Return 409 Conflict when a run loses the checkpointer's version check.
+
+    A ``StaleStateError`` means another execution committed a newer state for the
+    same thread while this one was running, so persisting would silently discard
+    that work. This is a genuine conflict, not a server fault: surface it as 409
+    so the client can reload the thread and retry instead of seeing a 500.
+    """
+    logger.warning("State conflict on concurrent run: %s", exc)
+    context = getattr(exc, "context", {}) or {}
+    return JSONResponse(
+        status_code=409,
+        content={
+            "error": "state_conflict",
+            "detail": (
+                "This thread was updated by another run while yours was in flight. "
+                "Reload the thread and retry."
+            ),
+            "thread_id": context.get("thread_id"),
+        },
+    )
+
+
+class SelectiveGZipMiddleware:
+    """
+    GZip middleware that excludes certain paths from compression.
+
+    This is necessary because streaming endpoints need to send data
+    immediately without buffering, but GZipMiddleware buffers the
+    entire response before compressing.
+    """
+
+    def __init__(self, app: ASGIApp, minimum_size: int = 1000):
+        self.app = app
+        self.gzip_app = GZipMiddleware(app, minimum_size=minimum_size)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "http" and scope["path"] in GZIP_EXCLUDED_PATHS:
+            # Skip GZip for excluded paths - pass through directly
+            await self.app(scope, receive, send)
+        else:
+            # Apply GZip for all other paths
+            await self.gzip_app(scope, receive, send)
+
+
+class RequestIDMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware to add a unique request ID and timestamp to each request and response.
+
+    This middleware generates a unique request ID and a timestamp when a request is received.
+    It adds these values to the request state and includes them in the response headers.
+
+
+    Methods:
+        dispatch(request: Request, call_next):
+            Generates a unique request ID and timestamp, adds them to the request state,
+            and includes them in the response headers.
+
+    Returns:
+        Response: The HTTP response with added request ID and timestamp headers.
+    """
+
+    async def dispatch(self, request: Request, call_next):
+        """
+        Middleware dispatch method to handle incoming requests.
+
+        This method generates a unique request ID and a timestamp for each incoming request,
+        adds them to the request state, and includes them in the response headers for
+        logging purposes.
+
+        Args:
+            request (Request): The incoming HTTP request.
+            call_next (Callable): The next middleware or route handler to be called.
+
+        Returns:
+            Response: The HTTP response with added headers for request ID and timestamp.
+        """
+        # Generate request ID and timestamp
+        request_id = str(uuid.uuid4())
+        timestamp = datetime.now().isoformat()
+
+        # Add request ID and timestamp to request headers
+        request.state.request_id = request_id
+        request.state.timestamp = timestamp
+        logger.debug(f"Requesting: Request ID: {request_id}, Timestamp: {timestamp}")
+
+        # Proceed with the request
+        response = await call_next(request)
+
+        # Add request ID and timestamp to response headers for logging
+        response.headers["X-Request-ID"] = request_id
+        response.headers["X-Timestamp"] = timestamp
+        logger.debug(f"Response: Request ID: {request_id}, Timestamp: {timestamp}")
+
+        return response
+
+
+def _attach_otel_publisher(container: InjectQ, settings) -> None:
+    """Wire OtelPublisher into the container when OTEL_ENABLED=true.
+
+    Merges with any publisher already bound in the container:
+      - None bound         → bind OtelPublisher directly
+      - CompositePublisher → add OtelPublisher to it
+      - Single publisher   → wrap both in a new CompositePublisher
+    """
+    try:
+        from tenxgraph.runtime.publisher.base_publisher import BasePublisher
+        from tenxgraph.runtime.publisher.composite_publisher import CompositePublisher
+        from tenxgraph.runtime.publisher.otel_publisher import ObservabilityLevel, OtelPublisher
+    except ImportError:
+        logger.warning(
+            "OTEL_ENABLED=true but opentelemetry packages are not installed. "
+            "Install with: pip install '10xgraph[otel]'"
+        )
+        return
+
+    try:
+        level = ObservabilityLevel(settings.OTEL_LEVEL.lower())
+    except ValueError:
+        logger.warning(
+            "Invalid OTEL_LEVEL=%r, falling back to 'standard'. Valid: spans, standard, full",
+            settings.OTEL_LEVEL,
+        )
+        level = ObservabilityLevel.STANDARD
+
+    otel_publisher = OtelPublisher(level=level)
+    existing = container.try_get(BasePublisher)
+
+    if existing is None:
+        container.bind_instance(BasePublisher, otel_publisher)
+        logger.info("OTEL: OtelPublisher bound (level=%s)", level)
+    elif isinstance(existing, CompositePublisher):
+        existing.add_publisher(otel_publisher)
+        logger.info("OTEL: OtelPublisher added to existing CompositePublisher (level=%s)", level)
+    else:
+        container.bind_instance(BasePublisher, CompositePublisher([existing, otel_publisher]))
+        logger.info(
+            "OTEL: wrapped %s + OtelPublisher in CompositePublisher (level=%s)",
+            type(existing).__name__,
+            level,
+        )
+
+
+def _setup_observability(container: InjectQ | None, graph_config: GraphConfig | None) -> None:
+    """Wire Logfire/LangSmith from the ``observability`` block of ``10xgraph.json``.
+
+    Configures the tracer provider(s)/exporters and binds an ``OtelPublisher``
+    into the DI container. This runs at app-construction time, before the graph
+    is loaded and compiled — the only reliable attach point, because InjectQ
+    freezes the ``BasePublisher`` binding at ``container.compile()`` (which runs
+    inside ``StateGraph.compile()``). The core ``StateGraph.compile()`` guard
+    preserves a publisher already present in the container instead of clobbering
+    it with ``None``.
+
+    Secrets stay in the environment (``LOGFIRE_TOKEN``, ``LANGSMITH_API_KEY``);
+    only non-secret settings live in ``10xgraph.json``.
+    """
+    if container is None or graph_config is None:
+        return
+
+    obs_cfg = graph_config.observability
+    if not obs_cfg:
+        return
+
+    logfire_on = bool((obs_cfg.get("logfire") or {}).get("enabled", False))
+    langsmith_on = bool((obs_cfg.get("langsmith") or {}).get("enabled", False))
+    if not logfire_on and not langsmith_on:
+        return
+
+    try:
+        from tenxgraph.runtime.publisher.base_publisher import BasePublisher
+        from tenxgraph.runtime.publisher.composite_publisher import CompositePublisher
+        from tenxgraph.runtime.publisher.exporters import setup_observability
+        from tenxgraph.runtime.publisher.otel_publisher import ObservabilityLevel, OtelPublisher
+    except ImportError:
+        logger.warning(
+            "observability is configured but required packages are not installed. "
+            "Install with: pip install '10xgraph[observability]'"
+        )
+        return
+
+    # Configure the provider(s)/exporter(s) only. graph=None means no publisher
+    # is attached here; we bind it into the container ourselves below so it is
+    # in place before the graph compiles.
+    try:
+        setup_observability(None, obs_cfg)
+    except (ImportError, ValueError) as exc:
+        logger.warning("Observability setup skipped: %s", exc)
+        return
+
+    try:
+        level = ObservabilityLevel(str(obs_cfg.get("level", "standard")).lower())
+    except ValueError:
+        logger.warning(
+            "Invalid observability level=%r, falling back to 'standard'.",
+            obs_cfg.get("level"),
+        )
+        level = ObservabilityLevel.STANDARD
+
+    otel_publisher = OtelPublisher(level=level)
+    existing = container.try_get(BasePublisher)
+
+    if existing is None:
+        container.bind_instance(BasePublisher, otel_publisher)
+    elif isinstance(existing, CompositePublisher):
+        existing.add_publisher(otel_publisher)
+    else:
+        container.bind_instance(BasePublisher, CompositePublisher([existing, otel_publisher]))
+
+    logger.info(
+        "Observability enabled (logfire=%s, langsmith=%s, level=%s)",
+        logfire_on,
+        langsmith_on,
+        level,
+    )
+
+
+def _setup_otel(app: FastAPI, settings) -> None:
+    """Configure OpenTelemetry tracing and instrument the FastAPI app.
+
+    Reads OTEL_EXPORTER_OTLP_ENDPOINT from settings. If unset, falls back to
+    the standard OTEL_EXPORTER_OTLP_ENDPOINT env var (honoured automatically
+    by the OTLP exporter). A ConsoleSpanExporter is used when no endpoint is
+    configured and the app is not in production, so traces are visible locally
+    without any collector.
+    """
+    try:
+        from opentelemetry import trace
+        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+        from opentelemetry.sdk.resources import Resource
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import BatchSpanProcessor
+    except ImportError:
+        logger.warning(
+            "OTEL_ENABLED=true but opentelemetry packages are not installed. "
+            "Install with: pip install '10xgraph-api[otel]'"
+        )
+        return
+
+    resource = Resource.create({"service.name": settings.OTEL_SERVICE_NAME})
+    provider = TracerProvider(resource=resource)
+
+    endpoint = settings.OTEL_EXPORTER_OTLP_ENDPOINT
+    if endpoint:
+        try:
+            from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+            provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint=endpoint)))
+            logger.info("OTEL: exporting traces to %s", endpoint)
+        except ImportError:
+            logger.warning(
+                "OTEL_EXPORTER_OTLP_ENDPOINT is set but opentelemetry-exporter-otlp "
+                "is not installed. Install with: pip install '10xgraph-api[otel]'"
+            )
+            return
+    else:
+        from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
+
+        provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
+        logger.info("OTEL: no endpoint configured, printing spans to console")
+
+    trace.set_tracer_provider(provider)
+    FastAPIInstrumentor.instrument_app(app)
+    logger.info("OTEL: FastAPI instrumentation active (service=%s)", settings.OTEL_SERVICE_NAME)
+
+
+def setup_middleware(
+    app: FastAPI,
+    graph_config: GraphConfig | None = None,
+    container: InjectQ | None = None,
+):
+    """
+    Set up middleware for the FastAPI application.
+
+    Args:
+        app (FastAPI): The FastAPI application instance.
+        graph_config (GraphConfig | None): Optional graph configuration used to
+            enable dynamic rate limiting from ``10xgraph.json``.
+
+    Middleware:
+        - CORS: Configured based on settings.ORIGINS.
+        - TrustedHost: Configured with allowed hosts from settings.ALLOWED_HOST.
+        - GZip: Applied with a minimum size of 1000 bytes (excludes streaming endpoints).
+        - RateLimit: Applied when ``rate_limit`` is configured in ``10xgraph.json``.
+    """
+    settings = get_settings()
+
+    # A concurrent run on the same thread is a conflict (409), not a 500.
+    if StaleStateError is not None:
+        app.add_exception_handler(StaleStateError, _stale_state_handler)
+
+    if settings.OTEL_ENABLED:
+        _setup_otel(app, settings)
+        if container is not None:
+            _attach_otel_publisher(container, settings)
+
+    # Declarative Logfire/LangSmith wiring from 10xgraph.json (before compile).
+    _setup_observability(container, graph_config)
+
+    # init cors
+    origins, allow_credentials = _resolve_cors_policy(settings)
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=origins,
+        allow_credentials=allow_credentials,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.add_middleware(
+        HealthCheckAwareTrustedHostMiddleware,
+        allowed_hosts=settings.ALLOWED_HOST.split(","),
+    )
+
+    # Add request size limit middleware (protects against DoS via large payloads). The upload
+    # route gets room for MEDIA_MAX_SIZE_MB, which the route itself enforces on the file.
+    app.add_middleware(
+        RequestSizeLimitMiddleware,
+        max_size=settings.MAX_REQUEST_SIZE,
+        path_limits=_upload_path_limits(settings.MAX_REQUEST_SIZE),
+    )
+
+    # Add security headers middleware (if enabled)
+    if settings.SECURITY_HEADERS_ENABLED:
+        app.add_middleware(
+            SecurityHeadersMiddleware,
+            enable_hsts=settings.HSTS_ENABLED,
+            hsts_max_age=settings.HSTS_MAX_AGE,
+            hsts_include_subdomains=settings.HSTS_INCLUDE_SUBDOMAINS,
+            hsts_preload=settings.HSTS_PRELOAD,
+            frame_options=settings.FRAME_OPTIONS,
+            content_type_options=settings.CONTENT_TYPE_OPTIONS,
+            xss_protection=settings.XSS_PROTECTION,
+            referrer_policy=settings.REFERRER_POLICY,
+            permissions_policy=settings.PERMISSIONS_POLICY,
+            csp_policy=settings.CSP_POLICY,
+        )
+
+    app.add_middleware(RequestIDMiddleware)
+
+    # Use SelectiveGZipMiddleware to exclude streaming endpoints from compression
+    # Streaming endpoints need immediate data transmission without buffering
+    app.add_middleware(SelectiveGZipMiddleware, minimum_size=1000)
+
+    # Apply rate limiting only when configured in 10xgraph.json
+    if graph_config is not None:
+        rate_limit_config = graph_config.rate_limit
+        if rate_limit_config is not None:
+            backend = build_backend(rate_limit_config, container=container)
+            # Store on app.state so lifespan can close it cleanly
+            app.state.rate_limit_backend = backend
+            app.add_middleware(
+                RateLimitMiddleware,
+                config=rate_limit_config,
+                backend=backend,
+            )
+            logger.info(
+                "Rate limiting enabled: backend=%s, %d req/%ds, by=%s, "
+                "exclude_paths=%s, trusted_proxy_headers=%s",
+                rate_limit_config.backend,
+                rate_limit_config.requests,
+                rate_limit_config.window,
+                rate_limit_config.by,
+                rate_limit_config.exclude_paths or "(none)",
+                rate_limit_config.trusted_proxy_headers,
+            )
+
+    logger.debug("Middleware set up")
+
+    # Initialize Sentry
+    init_sentry(settings)

tenxgraph_api/src/app/core/config/worker_middleware.py

@@ -0,0 +1,99 @@
+# from typing import Any
+
+# from taskiq import TaskiqMessage, TaskiqMiddleware, TaskiqResult
+
+# from tenxgraph_api.src.app.core import logger
+
+
+# class MonitoringMiddleware(TaskiqMiddleware):
+#     """
+#     Middleware for monitoring task execution in Taskiq.
+
+#     This middleware logs various stages of task execution, including startup,
+#     shutdown, pre-execution, post-save, and error handling.
+
+#     Methods:
+#         startup: Logs a debug message when the middleware starts up.
+#         shutdown: Logs a debug message when the middleware shuts down.
+#         pre_execute: Logs an info message before a task is executed.
+#         post_save: Logs info and debug messages after a task is saved.
+#         on_error: Logs error messages when an exception occurs during task execution.
+#     """
+
+#     def startup(self) -> None:
+#         """
+#         Perform startup operations.
+
+#         This method logs a debug message indicating that the startup process is running.
+
+#         Returns:
+#             None
+#         """
+#         logger.debug("RUNNING STARTUP")
+
+#     def shutdown(self) -> None:
+#         """
+#         Perform shutdown operations.
+
+#         This method logs a debug message indicating that the shutdown process is running.
+
+#         Returns:
+#             None
+#         """
+#         logger.debug("RUNNING SHUTDOWN")
+
+#     def pre_execute(self, message: "TaskiqMessage") -> TaskiqMessage:
+#         """
+#         Pre-execution hook for processing a TaskiqMessage.
+
+#         This method is called before the task execution begins. It logs the task ID
+#         of the incoming message and returns the message unchanged.
+
+#         Args:
+#             message (TaskiqMessage): The message to be processed.
+
+#         Returns:
+#             TaskiqMessage: The same message that was passed in.
+#         """
+#         logger.info(f"PRE EXECUTE: {message.task_id}")
+#         return message
+
+#     def post_save(self, message: "TaskiqMessage", result: "TaskiqResult[Any]") -> None:
+#         """
+#         Handles post-save operations for a task.
+
+#         This method is called after a task is saved. It logs the task ID and the result of the
+#           task.
+
+#         Args:
+#             message (TaskiqMessage): The message object containing task details.
+#             result (TaskiqResult[Any]): The result object containing the outcome of the task.
+
+#         Returns:
+#             None
+#         """
+#         logger.info(f"Saved Task: {message.task_id}")
+#         logger.debug(f"Result: {result.return_value}")
+
+#     def on_error(
+#         self,
+#         message: "TaskiqMessage",
+#         result: "TaskiqResult[Any]",
+#         exception: BaseException,
+#     ) -> None:
+#         """
+#         Handles errors that occur during task execution.
+
+#         Args:
+#             message (TaskiqMessage): The message associated with the task.
+#             result (TaskiqResult[Any]): The result of the task execution.
+#             exception (BaseException): The exception that was raised.
+
+#         Returns:
+#             None
+#         """
+#         logger.error(f"Exception on task: {message.task_id}", exc_info=exception)
+#         logger.error(
+#             f"Exception on task {message.task_id} Result: {result.return_value if result
+#               else None}"
+#         )

tenxgraph_api/src/app/core/exceptions/__init__.py

@@ -0,0 +1,17 @@
+from .general_exception import GeneralException
+from .resources_exceptions import (
+    InvalidOperationError,
+    ResourceDuplicationError,
+    ResourceNotFoundError,
+)
+from .user_exception import UserAccountError, UserPermissionError
+
+
+__all__ = [
+    "GeneralException",
+    "InvalidOperationError",
+    "ResourceDuplicationError",
+    "ResourceNotFoundError",
+    "UserAccountError",
+    "UserPermissionError",
+]

tenxgraph_api/src/app/core/exceptions/general_exception.py

@@ -0,0 +1,58 @@
+from tenxgraph_api.src.app.utils.schemas import ErrorSchemas
+
+
+class GeneralException(Exception):
+    """
+    A custom exception class to handle general application errors.
+
+    Attributes:
+        message (str): Description of the error.
+        status_code (int): HTTP status code associated with the error.
+        error_code (str): Application-specific error code.
+        details (list[ErrorSchemas]): Optional list of detailed error schemas.
+
+    Methods:
+        __str__(): Returns a string representation of the exception.
+    """
+
+    def __init__(
+        self,
+        message="An error occurred",
+        status_code=400,
+        error_code="APP_ERROR",
+        details: list[ErrorSchemas] | None = None,
+    ):
+        """
+        Initializes a GeneralException instance.
+
+        Args:
+            message (str, optional):
+                Description of the error. Defaults to "An error occurred".
+            status_code (int, optional):
+                HTTP status code associated with the error. Defaults to 400.
+            error_code (str, optional):
+                Application-specific error code. Defaults to "APP_ERROR".
+            details (list[ErrorSchemas], optional):
+                Optional list of detailed error schemas.
+        """
+        self.message = message
+        self.status_code = status_code
+        self.error_code = error_code
+        self.details = details
+        super().__init__(self.message)
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the GeneralException instance.
+
+        Returns:
+            str: A string containing the message, status code, and error code.
+        """
+        return (
+            "message: "
+            + self.message
+            + " status_code: "
+            + str(self.status_code)
+            + " error_code: "
+            + self.error_code
+        )