nlbone 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

nlbone/core/domain/base.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Generic, List, TypeVar
+
+TId = TypeVar("TId")
+
+
+class DomainError(Exception):
+    """Base domain exception."""
+
+
+@dataclass(frozen=True)
+class DomainEvent:
+    """Immutable domain event."""
+
+    occurred_at: datetime = datetime.now(timezone.utc)
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+
+class ValueObject:
+    """Base for value objects (immutable in practice)."""
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+    def __hash__(self) -> int:  # allow in sets/dicts
+        return hash(tuple(sorted(self.__dict__.items())))
+
+
+class Entity(Generic[TId]):
+    id: TId
+
+
+class AggregateRoot(Entity[TId]):
+    """Aggregate root with domain event collection."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        self._domain_events: List[DomainEvent] = []
+
+    def _raise(self, event: DomainEvent) -> None:
+        self._domain_events.append(event)
+
+    def pull_events(self) -> List[DomainEvent]:
+        events = list(self._domain_events)
+        self._domain_events.clear()
+        return events

nlbone/core/ports/__init__.py

@@ -1 +1,5 @@
-from .auth import AuthService
+from .auth import AuthService
+from .event_bus import EventBusPort
+from .files import AsyncFileServicePort, FileServicePort
+from .repo import AsyncRepository, Repository
+from .uow import AsyncUnitOfWork, UnitOfWork

nlbone/core/ports/auth.py

@@ -1,5 +1,6 @@
 from typing import Protocol, runtime_checkable
 
+
 @runtime_checkable
 class AuthService(Protocol):
     def has_access(self, token: str, permissions: list[str]) -> bool: ...

nlbone/core/ports/event_bus.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Callable, Iterable, Protocol
+
+from nlbone.core.domain.base import DomainEvent
+
+
+class EventBusPort(Protocol):
+    def publish(self, events: Iterable[DomainEvent]) -> None: ...
+    def subscribe(self, event_name: str, handler: Callable[[DomainEvent], None]) -> None: ...

nlbone/core/ports/files.py

@@ -1,20 +1,41 @@
 from __future__ import annotations
-from typing import Protocol, runtime_checkable, AsyncIterator, Any
+
+from typing import Any, AsyncIterator, Protocol, runtime_checkable
+
 
 @runtime_checkable
 class FileServicePort(Protocol):
-    def upload_file(self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None) -> dict: ...
+    def upload_file(
+        self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None
+    ) -> dict: ...
     def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None: ...
-    def list_files(self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None, sort: list[tuple[str, str]] | None = None, token: str | None = None) -> dict: ...
+    def list_files(
+        self,
+        limit: int = 10,
+        offset: int = 0,
+        filters: dict[str, Any] | None = None,
+        sort: list[tuple[str, str]] | None = None,
+        token: str | None = None,
+    ) -> dict: ...
     def get_file(self, file_id: int, token: str | None = None) -> dict: ...
     def download_file(self, file_id: int, token: str | None = None) -> tuple[bytes, str, str]: ...
     def delete_file(self, file_id: int, token: str | None = None) -> None: ...
 
+
 @runtime_checkable
 class AsyncFileServicePort(Protocol):
-    async def upload_file(self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None) -> dict: ...
+    async def upload_file(
+        self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None
+    ) -> dict: ...
     async def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None: ...
-    async def list_files(self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None, sort: list[tuple[str, str]] | None = None, token: str | None = None) -> dict: ...
+    async def list_files(
+        self,
+        limit: int = 10,
+        offset: int = 0,
+        filters: dict[str, Any] | None = None,
+        sort: list[tuple[str, str]] | None = None,
+        token: str | None = None,
+    ) -> dict: ...
     async def get_file(self, file_id: int, token: str | None = None) -> dict: ...
     async def download_file(self, file_id: int, token: str | None = None) -> tuple[AsyncIterator[bytes], str, str]: ...
     async def delete_file(self, file_id: int, token: str | None = None) -> None: ...

nlbone/core/ports/repo.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Iterable, List, Optional, Protocol, TypeVar
+
+T = TypeVar("T")
+
+
+class Repository(Protocol[T]):  # ← نه Protocol, Generic[T]
+    def get(self, id) -> Optional[T]: ...
+    def add(self, obj: T) -> None: ...
+    def remove(self, obj: T) -> None: ...
+    def list(self, *, limit: int | None = None, offset: int = 0) -> Iterable[T]: ...
+
+
+class AsyncRepository(Protocol[T]):
+    async def get(self, id) -> Optional[T]: ...
+    def add(self, obj: T) -> None: ...
+    async def remove(self, obj: T) -> None: ...
+    async def list(self, *, limit: int | None = None, offset: int = 0) -> List[T]: ...

nlbone/core/ports/uow.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class UnitOfWork(Protocol):
+    def __enter__(self) -> "UnitOfWork": ...
+    def __exit__(self, exc_type, exc, tb) -> None: ...
+    def commit(self) -> None: ...
+    def rollback(self) -> None: ...
+
+
+@runtime_checkable
+class AsyncUnitOfWork(Protocol):
+    async def __aenter__(self) -> "AsyncUnitOfWork": ...
+    async def __aexit__(self, exc_type, exc, tb) -> None: ...
+    async def commit(self) -> None: ...
+    async def rollback(self) -> None: ...

nlbone/interfaces/api/dependencies/__init__.py

@@ -1,2 +1,11 @@
-from .db import get_session, get_async_session
-from .auth import has_access, client_has_access, current_client_id, current_user_id, current_request, user_authenticated
+from .async_auth import client_has_access, current_request, current_user_id, has_access, user_authenticated
+from .auth import (  # noqa: F811
+    client_has_access,
+    current_client_id,
+    current_request,
+    current_user_id,
+    has_access,
+    user_authenticated,
+)
+from .db import get_async_session, get_session
+from .uow import get_async_uow, get_uow

nlbone/interfaces/api/dependencies/async_auth.py

@@ -0,0 +1,61 @@
+import functools
+
+from nlbone.adapters.auth import KeycloakAuthService
+from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
+from nlbone.utils.context import current_request
+
+
+async def current_user_id() -> int:
+    user_id = current_request().state.user_id
+    if user_id is not None:
+        return int(user_id)
+    raise UnauthorizedException()
+
+
+async def current_client_id() -> str:
+    request = current_request()
+    if client_id := KeycloakAuthService().get_client_id(request.state.token):
+        return str(client_id)
+    raise UnauthorizedException()
+
+
+def client_has_access(*, permissions=None):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            request = current_request()
+            if not KeycloakAuthService().client_has_access(request.state.token, permissions=permissions):
+                raise ForbiddenException(f"Forbidden {permissions}")
+
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def user_authenticated(func):
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        if not await current_user_id():
+            raise UnauthorizedException()
+        return await func(*args, **kwargs)
+
+    return wrapper
+
+
+def has_access(*, permissions=None):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            request = current_request()
+            if not await current_user_id():
+                raise UnauthorizedException()
+            if not KeycloakAuthService().has_access(request.state.token, permissions=permissions):
+                raise ForbiddenException(f"Forbidden {permissions}")
+
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

nlbone/interfaces/api/dependencies/auth.py

@@ -30,15 +30,16 @@ def client_has_access(*, permissions=None):
             return func(*args, **kwargs)
 
         return wrapper
+
     return decorator
 
 
 def user_authenticated(func):
     @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
+    def wrapper(*args, **kwargs):
         if not current_user_id():
             raise UnauthorizedException()
-        return await func(*args, **kwargs)
+        return func(*args, **kwargs)
 
     return wrapper
 
@@ -56,4 +57,5 @@ def has_access(*, permissions=None):
             return func(*args, **kwargs)
 
         return wrapper
-    return decorator
+
+    return decorator

nlbone/interfaces/api/dependencies/db.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 from typing import AsyncGenerator, Generator
 
-from sqlalchemy.orm import Session
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
 
 from nlbone.adapters.db.sqlalchemy.engine import async_session, sync_session
 
@@ -11,6 +12,7 @@ async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
     async with async_session() as s:
         yield s
 
+
 def get_session() -> Generator[Session, None, None]:
     with sync_session() as s:
-        yield s
+        yield s

nlbone/interfaces/api/dependencies/uow.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import AsyncIterator
+
+from fastapi import Request
+
+from nlbone.adapters.db.sqlalchemy import AsyncSqlAlchemyUnitOfWork
+from nlbone.core.ports.uow import AsyncUnitOfWork, UnitOfWork
+
+
+def get_uow(request: Request) -> Iterator[UnitOfWork]:
+    """
+    Uses DI container mounted at app.state.container to create a UoW per request.
+    Assumes container.uow is a provider returning SqlAlchemyUnitOfWork(session_factory).
+    """
+    container = getattr(request.app.state, "container", None)
+    if container is None or not hasattr(container, "uow"):
+        raise RuntimeError("Container with 'uow' provider not configured on app.state.container")
+
+    uow = container.uow()
+    with uow as _uow:
+        yield _uow
+
+
+async def get_async_uow(request: Request) -> AsyncIterator[AsyncUnitOfWork]:
+    container = getattr(request.app.state, "container", None)
+    if container is None or not hasattr(container, "async_uow"):
+        raise RuntimeError("Container.async_uow provider not configured")
+    uow: AsyncSqlAlchemyUnitOfWork = container.async_uow()
+    async with uow as _uow:
+        yield _uow

nlbone/interfaces/api/exception_handlers.py

@@ -1,32 +1,33 @@
 from __future__ import annotations
-from typing import Any, Optional, Mapping
+
+from typing import Any, Mapping, Optional
 from uuid import uuid4
 
 from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
+from fastapi import HTTPException as FastAPIHTTPException
 from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
 from pydantic import ValidationError
-from fastapi import HTTPException as FastAPIHTTPException
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from .exceptions import BaseHttpException
 
-
 # ---- Helpers ---------------------------------------------------------------
 
+
 def _ensure_trace_id(request: Request) -> str:
     rid = request.headers.get("X-Request-Id") or request.headers.get("X-Trace-Id")
     return rid or str(uuid4())
 
 
 def _json_response(
-        request: Request,
-        status_code: int,
-        *,
-        detail: Any,
-        headers: Optional[Mapping[str, str]] = None,
-        trace_id: Optional[str] = None,
-        extra: Optional[Mapping[str, Any]] = None,
+    request: Request,
+    status_code: int,
+    *,
+    detail: Any,
+    headers: Optional[Mapping[str, str]] = None,
+    trace_id: Optional[str] = None,
+    extra: Optional[Mapping[str, Any]] = None,
 ) -> JSONResponse:
     payload: dict[str, Any] = {"detail": detail}
     if extra:
@@ -44,11 +45,12 @@ def _json_response(
 
 # ---- Public Installer ------------------------------------------------------
 
+
 def install_exception_handlers(
-        app: FastAPI,
-        *,
-        logger: Any = None,
-        expose_server_errors: bool = False,
+    app: FastAPI,
+    *,
+    logger: Any = None,
+    expose_server_errors: bool = False,
 ) -> None:
     @app.exception_handler(BaseHttpException)
     async def _handle_base_http_exception(request: Request, exc: BaseHttpException):

nlbone/interfaces/api/exceptions.py

@@ -1,4 +1,5 @@
 from typing import Any, Iterable
+
 from fastapi import HTTPException, status
 
 
@@ -77,5 +78,3 @@ class UnprocessableEntityException(BaseHttpException):
 class LogicalValidationException(UnprocessableEntityException):
     def __init__(self, detail: str, loc: Iterable[Any] | None = None, type_: str = "logical_error"):
         super().__init__(detail=detail, loc=loc, type_=type_)
-
-

nlbone/interfaces/api/middleware/__init__.py

@@ -1,3 +1,3 @@
-from .authentication import AuthenticationMiddleware
+from .access_log import AccessLogMiddleware
 from .add_request_context import AddRequestContextMiddleware
-from .access_log import AccessLogMiddleware
+from .authentication import AuthenticationMiddleware

nlbone/interfaces/api/middleware/access_log.py

@@ -1,5 +1,6 @@
 import time
 from typing import Callable
+
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
@@ -7,6 +8,7 @@ from nlbone.config.logging import get_logger
 
 logger = get_logger(__name__)
 
+
 class AccessLogMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next: Callable):
         start = time.perf_counter()
@@ -20,11 +22,13 @@ class AccessLogMiddleware(BaseHTTPMiddleware):
             raise
         finally:
             dur_ms = int((time.perf_counter() - start) * 1000)
-            logger.info({
-                "event": "access",
-                "method": request.method,
-                "path": request.url.path,
-                "status": status_code,
-                "duration_ms": dur_ms,
-                "query": request.url.query,
-            })
+            logger.info(
+                {
+                    "event": "access",
+                    "method": request.method,
+                    "path": request.url.path,
+                    "status": status_code,
+                    "duration_ms": dur_ms,
+                    "query": request.url.query,
+                }
+            )

nlbone/interfaces/api/middleware/add_request_context.py

@@ -1,52 +1,55 @@
-from __future__ import annotations
-from typing import Optional
-from uuid import uuid4
-
-from starlette.datastructures import Headers
-from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from starlette.requests import Request
-
-from nlbone import config
-from nlbone.utils.context import request_ctx, request_id_ctx, bind_context, reset_context
-
-
-def mock_request(user=None, token: Optional[str] = None):
-    request = Request({
-        "type": "http",
-        "headers": Headers({"User-Agent": "Testing-Agent"}).raw,
-        "client": {"host": "192.168.1.1", "port": 80},
-        "method": "GET",
-        "path": "/__test__",
-    })
-    request.state.user = user
-    request.state.token = token
-    return request
-
-
-def current_request() -> Optional[Request]:
-    req = request_ctx.get()
-    if config.ENV == 'test' and req is None:
-        return mock_request()
-    return req
-
-
-def current_request_id() -> Optional[str]:
-    return request_id_ctx.get()
-
-
-class AddRequestContextMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
-        incoming_req_id = request.headers.get("X-Request-ID")
-        req_id = incoming_req_id or str(uuid4())
-
-        user_id = getattr(getattr(request, "state", None), "user_id", None) or request.headers.get("X-User-Id")
-        ip = request.client.host if request.client else None
-        ua = request.headers.get("user-agent")
-
-        tokens = bind_context(request=request, request_id=req_id, user_id=user_id, ip=ip, user_agent=ua)
-        try:
-            response = await call_next(request)
-            response.headers.setdefault("X-Request-ID", req_id)
-            return response
-        finally:
-            reset_context(tokens)
+from __future__ import annotations
+
+from typing import Optional
+from uuid import uuid4
+
+from starlette.datastructures import Headers
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+
+from nlbone.config.settings import get_settings
+from nlbone.utils.context import bind_context, request_ctx, request_id_ctx, reset_context
+
+
+def mock_request(user=None, token: Optional[str] = None):
+    request = Request(
+        {
+            "type": "http",
+            "headers": Headers({"User-Agent": "Testing-Agent"}).raw,
+            "client": {"host": "192.168.1.1", "port": 80},
+            "method": "GET",
+            "path": "/__test__",
+        }
+    )
+    request.state.user = user
+    request.state.token = token
+    return request
+
+
+def current_request() -> Optional[Request]:
+    req = request_ctx.get()
+    if get_settings().ENV == "local" and req is None:
+        return mock_request()
+    return req
+
+
+def current_request_id() -> Optional[str]:
+    return request_id_ctx.get()
+
+
+class AddRequestContextMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
+        incoming_req_id = request.headers.get("X-Request-ID")
+        req_id = incoming_req_id or str(uuid4())
+
+        user_id = getattr(getattr(request, "state", None), "user_id", None) or request.headers.get("X-User-Id")
+        ip = request.client.host if request.client else None
+        ua = request.headers.get("user-agent")
+
+        tokens = bind_context(request=request, request_id=req_id, user_id=user_id, ip=ip, user_agent=ua)
+        try:
+            response = await call_next(request)
+            response.headers.setdefault("X-Request-ID", req_id)
+            return response
+        finally:
+            reset_context(tokens)

nlbone/interfaces/api/middleware/authentication.py

@@ -1,9 +1,11 @@
-from typing import Optional, Callable, Union
+from typing import Callable, Optional, Union
+
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
 try:
     from dependency_injector import providers
+
     ProviderType = providers.Provider  # type: ignore
 except Exception:
     ProviderType = object
@@ -14,6 +16,7 @@ from nlbone.core.ports.auth import AuthService
 def _to_factory(auth: Union[AuthService, Callable[[], AuthService], ProviderType]):
     try:
         from dependency_injector import providers as _p  # type: ignore
+
         if isinstance(auth, _p.Provider):
             return auth
     except Exception:

nlbone/interfaces/api/pagination/__init__.py

@@ -1,13 +1,12 @@
 from typing import Generic, List, Optional, TypeVar
-from pydantic import BaseModel
+
 from fastapi import Depends
+from pydantic import BaseModel
 
-from .offset_base import PaginateResponse, PaginateRequest
+from .offset_base import PaginateRequest, PaginateResponse
 
 
-def get_pagination(
-        req: PaginateRequest = Depends(PaginateRequest)
-) -> PaginateRequest:
+def get_pagination(req: PaginateRequest = Depends(PaginateRequest)) -> PaginateRequest:
     return req
 
 

nlbone/interfaces/api/pagination/offset_base.py

@@ -3,7 +3,6 @@ from math import ceil
 from typing import Any, Optional
 
 from fastapi import Query
-from sqlalchemy import asc, desc
 
 
 class PaginateRequest:
@@ -76,7 +75,6 @@ class PaginateRequest:
         return filters_dict
 
 
-
 class PaginateResponse:
     """
     Lightweight response shaper. If total_count is None → returns just items.

nlbone/interfaces/cli/init_db.py

@@ -1,8 +1,10 @@
 import argparse
+
 import anyio
 
 from nlbone.adapters.db.sqlalchemy.schema import init_db_async, init_db_sync
 
+
 def main() -> None:
     parser = argparse.ArgumentParser(description="Initialize database schema (create_all).")
     parser.add_argument("--async", dest="use_async", action="store_true", help="Use AsyncEngine")
@@ -13,5 +15,6 @@ def main() -> None:
     else:
         init_db_sync()
 
+
 if __name__ == "__main__":
     main()