sera-2 1.9.1__py3-none-any.whl → 1.11.2__py3-none-any.whl

sera/libs/api_helper.py

@@ -1,10 +1,22 @@
 from __future__ import annotations
 
 import re
+from typing import Collection, Generic, cast
 
 from litestar import Request, status_codes
+from litestar.connection import ASGIConnection
+from litestar.dto import MsgspecDTO
+from litestar.dto._backend import DTOBackend
+from litestar.dto._codegen_backend import DTOCodegenBackend
+from litestar.enums import RequestEncodingType
 from litestar.exceptions import HTTPException
+from litestar.serialization import decode_json, decode_msgpack
+from litestar.typing import FieldDefinition
+from msgspec import Struct
+
 from sera.libs.base_service import Query, QueryOp
+from sera.libs.middlewares.uscp import STATE_SYSTEM_CONTROLLED_PROP_KEY
+from sera.typing import T
 
 # for parsing field names and operations from query string
 FIELD_REG = re.compile(r"(?P<name>[a-zA-Z_0-9]+)(?:\[(?P<op>[a-zA-Z0-9]+)\])?")
@@ -64,3 +76,72 @@ def parse_query(request: Request, fields: set[str], debug: bool) -> Query:
             continue
 
     return query
+
+
+class SingleAutoUSCP(MsgspecDTO[T], Generic[T]):
+    """Auto Update System Controlled Property DTO"""
+
+    @classmethod
+    def create_for_field_definition(
+        cls,
+        field_definition: FieldDefinition,
+        handler_id: str,
+        backend_cls: type[DTOBackend] | None = None,
+    ) -> None:
+        assert backend_cls is None, "Custom backend not supported"
+        super().create_for_field_definition(
+            field_definition, handler_id, FixedDTOBackend
+        )
+
+    def decode_bytes(self, value: bytes):
+        """Decode a byte string into an object"""
+        backend = self._dto_backends[self.asgi_connection.route_handler.handler_id][
+            "data_backend"
+        ]  # pyright: ignore
+        obj = backend.populate_data_from_raw(value, self.asgi_connection)
+        obj.update_system_controlled_props(
+            self.asgi_connection.scope["state"][STATE_SYSTEM_CONTROLLED_PROP_KEY]
+        )
+        return obj
+
+
+class FixedDTOBackend(DTOCodegenBackend):
+    def parse_raw(
+        self, raw: bytes, asgi_connection: ASGIConnection
+    ) -> Struct | Collection[Struct]:
+        """Parse raw bytes into transfer model type.
+
+        Note: instead of decoding into self.annotation, which I encounter this error: https://github.com/litestar-org/litestar/issues/4181; we have to use self.model_type, which is the original type.
+
+        Args:
+            raw: bytes
+            asgi_connection: The current ASGI Connection
+
+        Returns:
+            The raw bytes parsed into transfer model type.
+        """
+        request_encoding = RequestEncodingType.JSON
+
+        if (content_type := getattr(asgi_connection, "content_type", None)) and (
+            media_type := content_type[0]
+        ):
+            request_encoding = media_type
+
+        type_decoders = asgi_connection.route_handler.resolve_type_decoders()
+
+        if request_encoding == RequestEncodingType.MESSAGEPACK:
+            result = decode_msgpack(
+                value=raw,
+                target_type=self.model_type,
+                type_decoders=type_decoders,
+                strict=False,
+            )
+        else:
+            result = decode_json(
+                value=raw,
+                target_type=self.model_type,
+                type_decoders=type_decoders,
+                strict=False,
+            )
+
+        return cast("Struct | Collection[Struct]", result)

sera/libs/base_service.py

@@ -4,12 +4,13 @@ from enum import Enum
 from math import dist
 from typing import Annotated, Any, Generic, NamedTuple, Optional, Sequence, TypeVar
 
+from sqlalchemy import Result, Select, exists, func, select
+from sqlalchemy.orm import Session, load_only
+
 from sera.libs.base_orm import BaseORM
 from sera.misc import assert_not_null
 from sera.models import Class
 from sera.typing import FieldName, T, doc
-from sqlalchemy import Result, Select, exists, func, select
-from sqlalchemy.orm import Session, load_only
 
 
 class QueryOp(str, Enum):
@@ -42,12 +43,24 @@ class QueryResult(NamedTuple, Generic[R]):
 
 class BaseService(Generic[ID, R]):
 
+    instance = None
+
     def __init__(self, cls: Class, orm_cls: type[R]):
         self.cls = cls
         self.orm_cls = orm_cls
         self.id_prop = assert_not_null(cls.get_id_property())
 
         self._cls_id_prop = getattr(self.orm_cls, self.id_prop.name)
+        self.is_id_auto_increment = self.id_prop.db.is_auto_increment
+
+    @classmethod
+    def get_instance(cls):
+        """Get the singleton instance of the service."""
+        if cls.instance is None:
+            # assume that the subclass overrides the __init__ method
+            # so that we don't need to pass the class and orm_cls
+            cls.instance = cls()
+        return cls.instance
 
     def get(
         self,
@@ -90,7 +103,7 @@ class BaseService(Generic[ID, R]):
 
         cq = select(func.count()).select_from(q.subquery())
         rq = q.limit(limit).offset(offset)
-        records = self._process_result(session.execute(q)).scalars().all()
+        records = self._process_result(session.execute(rq)).scalars().all()
         total = session.execute(cq).scalar_one()
         return QueryResult(records, total)
 
@@ -108,6 +121,9 @@ class BaseService(Generic[ID, R]):
 
     def create(self, record: R, session: Session) -> R:
         """Create a new record."""
+        if self.is_id_auto_increment:
+            setattr(record, self.id_prop.name, None)
+
         session.add(record)
         session.commit()
         return record

sera/libs/middlewares/auth.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Callable, Generator, Generic, Optional, Sequence, Type
+
+from litestar import Request
+from litestar.connection import ASGIConnection
+from litestar.exceptions import NotAuthorizedException
+from litestar.middleware import AbstractAuthenticationMiddleware, AuthenticationResult
+from litestar.types import ASGIApp, Method, Scopes
+from litestar.types.composite_types import Dependencies
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from sera.typing import T
+
+
+class AuthMiddleware(AbstractAuthenticationMiddleware, Generic[T]):
+    """
+    Middleware to handle authentication for the API.
+
+    This middleware checks if the user is authenticated to access
+    the requested resource. If not, it raises an HTTPException with a 401 status code.
+    """
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        user_handler: Callable[[str], T],
+        exclude: str | list[str] | None = None,
+        exclude_from_auth_key: str = "exclude_from_auth",
+        exclude_http_methods: Sequence[Method] | None = None,
+        scopes: Scopes | None = None,
+    ) -> None:
+        super().__init__(
+            app=app,
+            exclude=exclude,
+            exclude_from_auth_key=exclude_from_auth_key,
+            exclude_http_methods=exclude_http_methods,
+            scopes=scopes,
+        )
+        self.user_handler = user_handler
+
+    async def authenticate_request(
+        self, connection: ASGIConnection
+    ) -> AuthenticationResult:
+        # do something here.
+        if "userid" not in connection.session:
+            raise NotAuthorizedException(
+                detail="Invalid credentials",
+            )
+
+        userid: str = connection.session["userid"]
+        expired_at = datetime.fromtimestamp(
+            connection.session.get("exp", 0), timezone.utc
+        )
+        if expired_at < datetime.now(timezone.utc):
+            raise NotAuthorizedException(
+                detail="Credentials expired",
+            )
+
+        user = self.user_handler(userid)
+        if user is None:
+            raise NotAuthorizedException(
+                detail="User not found",
+            )
+
+        return AuthenticationResult(user, None)
+
+    @staticmethod
+    def save(req: Request, user: T, expired_at: datetime) -> None:
+        req.session["userid"] = user.id
+        req.session["exp"] = expired_at.timestamp()

sera/libs/middlewares/uscp.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from litestar.connection.base import UserT
+from litestar.middleware import AbstractMiddleware
+from litestar.types import ASGIApp, Message, Receive, Scope, Scopes, Send
+
+STATE_SYSTEM_CONTROLLED_PROP_KEY = "system_controlled_properties"
+
+
+class USCPMiddleware(AbstractMiddleware):
+    """
+    Middleware to update system-controlled properties in the request.
+
+    This middleware updates the `created_at`, `updated_at`, and `deleted_at` properties
+    of the request with the current timestamp. It is intended to be used in a Litestar
+    application.
+    """
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        get_system_controlled_props: Callable[[UserT], dict],
+        skip_update_system_controlled_props: Callable[[UserT], bool],
+        exclude: str | list[str] | None = None,
+        exclude_opt_key: str | None = None,
+        scopes: Scopes | None = None,
+    ) -> None:
+        """Initialize the middleware.
+
+        Args:
+            app: The ``next`` ASGI app to call.
+            exclude: A pattern or list of patterns to match against a request's path.
+                If a match is found, the middleware will be skipped.
+            exclude_opt_key: An identifier that is set in the route handler
+                ``opt`` key which allows skipping the middleware.
+            scopes: ASGI scope types, should be a set including
+                either or both 'ScopeType.HTTP' and 'ScopeType.WEBSOCKET'.
+        """
+        super().__init__(app, exclude, exclude_opt_key, scopes)
+        self.get_system_controlled_props = get_system_controlled_props
+        self.skip_update_system_controlled_props = skip_update_system_controlled_props
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        user = scope["user"]
+        if self.skip_update_system_controlled_props(user):
+            scope["state"][STATE_SYSTEM_CONTROLLED_PROP_KEY] = None
+        else:
+            scope["state"][STATE_SYSTEM_CONTROLLED_PROP_KEY] = (
+                self.get_system_controlled_props(user)
+            )
+        await self.app(scope, receive, send)
+
+
+def get_scp_from_user(user: UserT, fields: dict[str, str]) -> dict:
+    """Get system-controlled properties from the user.
+
+    Args:
+        user: The user object.
+        fields: A list of fields to include in the system-controlled properties.
+
+    Returns:
+        A dictionary containing the system-controlled properties.
+    """
+    return {
+        data_field: getattr(user, db_field) for data_field, db_field in fields.items()
+    }