nlbone 0.3.3__tar.gz → 0.4.1__tar.gz

{nlbone-0.3.3 → nlbone-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.3.3
+Version: 0.4.1
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
@@ -17,14 +17,6 @@ Requires-Dist: python-keycloak==5.8.1
 Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: starlette>=0.47
 Requires-Dist: uvicorn>=0.35
-Provides-Extra: dev
-Requires-Dist: mypy>=1.10; extra == 'dev'
-Requires-Dist: pre-commit>=3.7; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Requires-Dist: ruff>=0.5; extra == 'dev'
-Requires-Dist: tomli; extra == 'dev'
-Requires-Dist: twine; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # nlbone

{nlbone-0.3.3 → nlbone-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.3.3"
+version = "0.4.1"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -25,20 +25,17 @@ dependencies = [
     "dependency-injector>=4.48.1"
 ]
 
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0",
-    "pytest-asyncio>=0.23",
-    "ruff>=0.5",
-    "mypy>=1.10",
-    "pre-commit>=3.7",
-    "twine",
-    "tomli"
-]
-
 [tool.ruff]
-line-length = 100
-target-version = "py310"
+line-length = 120
+target-version = "py312"
+exclude = ["tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+preview = true
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
@@ -48,7 +45,14 @@ packages = ["src/nlbone"]
 
 [tool.hatch.build.targets.sdist]
 include = [
-  "src/nlbone",
-  "README.md",
-  "LICENSE",
+    "src/nlbone",
+    "README.md",
+    "LICENSE",
+]
+
+[dependency-groups]
+dev = [
+    "pre-commit>=4.3.0",
+    "pytest>=8.4.2",
+    "ruff>=0.12.12",
 ]

nlbone-0.4.1/src/nlbone/adapters/auth/__init__.py

@@ -0,0 +1 @@
+from .keycloak import KeycloakAuthService

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/adapters/auth/keycloak.py

@@ -1,7 +1,8 @@
 from keycloak import KeycloakOpenID
 from keycloak.exceptions import KeycloakAuthenticationError
-from nlbone.core.ports.auth import AuthService
+
 from nlbone.config.settings import Settings, get_settings
+from nlbone.core.ports.auth import AuthService
 
 
 class KeycloakAuthService(AuthService):
@@ -70,4 +71,4 @@ class KeycloakAuthService(AuthService):
     def client_has_access(self, token: str, permissions: list[str], allowed_clients: set[str] | None = None) -> bool:
         if not self.is_client_token(token, allowed_clients):
             return False
-        return self.has_access(token, permissions)
+        return self.has_access(token, permissions)

nlbone-0.4.1/src/nlbone/adapters/db/__init__.py

@@ -0,0 +1,3 @@
+from .sqlalchemy import apply_pagination, get_paginated_response
+from .sqlalchemy.base import Base
+from .sqlalchemy.engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session

nlbone-0.4.1/src/nlbone/adapters/db/sqlalchemy/__init__.py

@@ -0,0 +1,4 @@
+from .engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session
+from .query_builder import apply_pagination, get_paginated_response
+from .repository import AsyncSqlAlchemyRepository, SqlAlchemyRepository
+from .uow import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/adapters/db/sqlalchemy/base.py

@@ -1,5 +1,3 @@
 from sqlalchemy.orm import declarative_base
 
 Base = declarative_base()
-
-

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/adapters/db/sqlalchemy/engine.py

@@ -1,16 +1,15 @@
 from contextlib import asynccontextmanager, contextmanager
-from typing import Generator, Optional, Any, AsyncGenerator
+from typing import Any, AsyncGenerator, Generator, Optional
 
 from sqlalchemy import create_engine, text
 from sqlalchemy.engine import Engine
-from sqlalchemy.orm import Session, sessionmaker
-
 from sqlalchemy.ext.asyncio import (
     AsyncEngine,
     AsyncSession,
     async_sessionmaker,
     create_async_engine,
 )
+from sqlalchemy.orm import Session, sessionmaker
 
 from nlbone.config.settings import get_settings
 
@@ -117,3 +116,16 @@ def sync_ping() -> None:
     with eng.connect() as conn:
         conn.execute(text("SELECT 1"))
 
+
+def get_async_session_factory() -> async_sessionmaker[AsyncSession]:
+    if _async_session_factory is None:
+        init_async_engine()
+    assert _async_session_factory is not None
+    return _async_session_factory
+
+
+def get_sync_session_factory() -> sessionmaker[Session]:
+    if _sync_session_factory is None:
+        init_sync_engine()
+    assert _sync_session_factory is not None
+    return _sync_session_factory

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/adapters/db/sqlalchemy/query_builder.py

@@ -1,12 +1,22 @@
-from typing import Union, Callable, Any, Optional, Type, Sequence
+from typing import Any, Callable, Optional, Sequence, Type, Union
 
 from sqlalchemy import asc, desc, or_
+from sqlalchemy.dialects.postgresql import ENUM as PGEnum
+from sqlalchemy.orm import Query, Session
 from sqlalchemy.orm.interfaces import LoaderOption
 from sqlalchemy.sql.sqltypes import (
-    String, Text, Integer, BigInteger, SmallInteger, Numeric, Float, Boolean, Enum as SAEnum
+    BigInteger,
+    Boolean,
+    Float,
+    Integer,
+    Numeric,
+    SmallInteger,
+    String,
+    Text,
+)
+from sqlalchemy.sql.sqltypes import (
+    Enum as SAEnum,
 )
-from sqlalchemy.orm import Session, Query
-from sqlalchemy.dialects.postgresql import ENUM as PGEnum
 
 from nlbone.interfaces.api.exceptions import UnprocessableEntityException
 from nlbone.interfaces.api.pagination import PaginateRequest, PaginateResponse
@@ -122,12 +132,16 @@ def _apply_filters(pagination, entity, query):
                 return float(v)
             # Booleans
             if isinstance(coltype, Boolean):
-                if isinstance(v, bool): return v
-                if isinstance(v, (int, float)): return bool(v)
+                if isinstance(v, bool):
+                    return v
+                if isinstance(v, (int, float)):
+                    return bool(v)
                 if isinstance(v, str):
                     vl = v.strip().lower()
-                    if vl in {"true", "1", "yes", "y", "t"}: return True
-                    if vl in {"false", "0", "no", "n", "f"}: return False
+                    if vl in {"true", "1", "yes", "y", "t"}:
+                        return True
+                    if vl in {"false", "0", "no", "n", "f"}:
+                        return False
                 return None
             # fallback
             return v
@@ -215,7 +229,8 @@ def _serialize_item(item: Any, output_cls: OutputType) -> Any:
     try:
         obj = output_cls(item)  # type: ignore[call-arg]
         try:
-            from dataclasses import is_dataclass, asdict
+            from dataclasses import asdict, is_dataclass
+
             if is_dataclass(obj):
                 return asdict(obj)
         except Exception:
@@ -252,5 +267,6 @@ def get_paginated_response(
         data = [output_cls.model_validate(r, from_attributes=True).model_dump() for r in rows]
     else:
         data = rows
-    return PaginateResponse(total_count=total_count, data=data, limit=pagination.limit,
-                            offset=pagination.offset).to_dict()
+    return PaginateResponse(
+        total_count=total_count, data=data, limit=pagination.limit, offset=pagination.offset
+    ).to_dict()

nlbone-0.4.1/src/nlbone/adapters/db/sqlalchemy/repository.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Generic, Iterable, List, Optional, Type, TypeVar
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+from nlbone.core.ports.repo import AsyncRepository, Repository
+
+T = TypeVar("T")
+
+
+class SqlAlchemyRepository(Repository[T], Generic[T]):
+    def __init__(self, session: Session, model: Type[T]) -> None:
+        self.session = session
+        self.model = model
+
+    def get(self, id) -> Optional[T]:
+        return self.session.get(self.model, id)
+
+    def add(self, obj: T) -> None:
+        self.session.add(obj)
+
+    def remove(self, obj: T) -> None:
+        self.session.delete(obj)
+
+    def list(self, *, limit: int | None = None, offset: int = 0) -> Iterable[T]:
+        q = self.session.query(self.model).offset(offset)
+        if limit is not None:
+            q = q.limit(limit)
+        return q.all()
+
+
+class AsyncSqlAlchemyRepository(AsyncRepository, Generic[T]):
+    def __init__(self, session: AsyncSession, model: Type[T]) -> None:
+        self.session = session
+        self.model = model
+
+    async def get(self, id) -> Optional[T]:
+        return await self.session.get(self.model, id)
+
+    def add(self, obj: T) -> None:
+        self.session.add(obj)
+
+    async def remove(self, obj: T) -> None:
+        await self.session.delete(obj)
+
+    async def list(self, *, limit: int | None = None, offset: int = 0) -> List[T]:
+        stmt = select(self.model).offset(offset)
+        if limit is not None:
+            stmt = stmt.limit(limit)
+        res = await self.session.execute(stmt)
+        return list(res.scalars().all())

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/adapters/db/sqlalchemy/schema.py

@@ -1,18 +1,17 @@
-
 import importlib
 from typing import Sequence
 
 from nlbone.adapters.db.sqlalchemy.base import Base
 from nlbone.adapters.db.sqlalchemy.engine import init_async_engine, init_sync_engine
 
+DEFAULT_MODEL_MODULES: Sequence[str] = ()
 
-DEFAULT_MODEL_MODULES: Sequence[str] = (
-)
 
 def import_model_modules(modules: Sequence[str] | None = None) -> None:
-    for m in (modules or DEFAULT_MODEL_MODULES):
+    for m in modules or DEFAULT_MODEL_MODULES:
         importlib.import_module(m)
 
+
 # --------- Async (SQLAlchemy 2.x) ----------
 async def init_db_async(model_modules: Sequence[str] | None = None) -> None:
     """Create tables using AsyncEngine (dev/test). Prefer Alembic in prod."""
@@ -21,9 +20,10 @@ async def init_db_async(model_modules: Sequence[str] | None = None) -> None:
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
 
+
 # --------- Sync ----------
 def init_db_sync(model_modules: Sequence[str] | None = None) -> None:
     """Create tables using Sync Engine (dev/test). Prefer Alembic in prod."""
     import_model_modules(model_modules)
     engine = init_sync_engine()
-    Base.metadata.create_all(bind=engine)
+    Base.metadata.create_all(bind=engine)

nlbone-0.4.1/src/nlbone/adapters/db/sqlalchemy/uow.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sqlalchemy.orm import Session, sessionmaker
+
+from nlbone.core.ports.uow import AsyncUnitOfWork as AsyncUnitOfWorkPort
+from nlbone.core.ports.uow import UnitOfWork
+
+
+class SqlAlchemyUnitOfWork(UnitOfWork):
+    """sync UoW for SQLAlchemy."""
+
+    def __init__(self, session_factory: sessionmaker) -> None:
+        self._session_factory = session_factory
+        self.session: Session | None = None
+
+    def __enter__(self) -> "SqlAlchemyUnitOfWork":
+        self.session = self._session_factory()
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        try:
+            if exc_type is None:
+                self.commit()
+            else:
+                self.rollback()
+        finally:
+            if self.session is not None:
+                self.session.close()
+                self.session = None
+
+    def commit(self) -> None:
+        if self.session:
+            self.session.commit()
+
+    def rollback(self) -> None:
+        if self.session:
+            self.session.rollback()
+
+
+class AsyncSqlAlchemyUnitOfWork(AsyncUnitOfWorkPort):
+    """Transactional boundary for async SQLAlchemy."""
+
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._sf = session_factory
+        self.session: Optional[AsyncSession] = None
+
+    async def __aenter__(self) -> "AsyncSqlAlchemyUnitOfWork":
+        self.session = self._sf()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        try:
+            if exc_type is None:
+                await self.commit()
+            else:
+                await self.rollback()
+        finally:
+            if self.session is not None:
+                await self.session.close()
+                self.session = None
+
+    async def commit(self) -> None:
+        if self.session:
+            await self.session.commit()
+
+    async def rollback(self) -> None:
+        if self.session:
+            await self.session.rollback()

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/adapters/http_clients/uploadchi.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import json
 from typing import Any, Optional
 from urllib.parse import urlparse, urlunparse
@@ -6,8 +7,8 @@ from urllib.parse import urlparse, urlunparse
 import httpx
 import requests
 
-from nlbone.core.ports.files import FileServicePort
 from nlbone.config.settings import get_settings
+from nlbone.core.ports.files import FileServicePort
 
 
 class UploadchiError(RuntimeError):
@@ -28,8 +29,9 @@ def _auth_headers(token: str | None) -> dict[str, str]:
     return {"Authorization": f"Bearer {token}"} if token else {}
 
 
-def _build_list_query(limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None) -> \
-        dict[str, Any]:
+def _build_list_query(
+    limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None
+) -> dict[str, Any]:
     q: dict[str, Any] = {"limit": limit, "offset": offset}
     if filters:
         q["filters"] = json.dumps(filters)
@@ -55,8 +57,12 @@ def _normalize_https_base(url: str) -> str:
 
 
 class UploadchiClient(FileServicePort):
-    def __init__(self, base_url: Optional[str] = None, timeout_seconds: Optional[float] = None,
-                 client: httpx.Client | None = None) -> None:
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        client: httpx.Client | None = None,
+    ) -> None:
         s = get_settings()
         self._base_url = _normalize_https_base(base_url or str(s.UPLOADCHI_BASE_URL))
         self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
@@ -65,8 +71,9 @@ class UploadchiClient(FileServicePort):
     def close(self) -> None:
         self._client.close()
 
-    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:
         tok = _resolve_token(token)
         files = {"file": (filename, file_bytes)}
         data = (params or {}).copy()
@@ -77,13 +84,22 @@ class UploadchiClient(FileServicePort):
 
     def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = self._client.post(f"{self._base_url}/{file_id}/commit", headers=_auth_headers(tok),
-                              params={"client_id": client_id} if client_id else None)
+        r = self._client.post(
+            f"{self._base_url}/{file_id}/commit",
+            headers=_auth_headers(tok),
+            params={"client_id": client_id} if client_id else None,
+        )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)
 
-    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:
         tok = _resolve_token(token)
         q = _build_list_query(limit, offset, filters, sort)
         r = self._client.get(self._base_url, params=q, headers=_auth_headers(tok))

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/adapters/http_clients/uploadchi_async.py

@@ -1,22 +1,35 @@
 from __future__ import annotations
-from typing import Any, Optional, AsyncIterator
+
+from typing import Any, AsyncIterator, Optional
+
 import httpx
 
-from nlbone.core.ports.files import AsyncFileServicePort
 from nlbone.config.settings import get_settings
+from nlbone.core.ports.files import AsyncFileServicePort
+
 from .uploadchi import UploadchiError, _auth_headers, _build_list_query, _filename_from_cd, _resolve_token
 
+
 class UploadchiAsyncClient(AsyncFileServicePort):
-    def __init__(self, base_url: Optional[str] = None, timeout_seconds: Optional[float] = None, client: httpx.AsyncClient | None = None) -> None:
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
         s = get_settings()
         self._base_url = base_url or str(s.UPLOADCHI_BASE_URL)
         self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
-        self._client = client or httpx.AsyncClient(base_url=self._base_url, timeout=self._timeout, follow_redirects=True)
+        self._client = client or httpx.AsyncClient(
+            base_url=self._base_url, timeout=self._timeout, follow_redirects=True
+        )
 
     async def aclose(self) -> None:
         await self._client.aclose()
 
-    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:
         tok = _resolve_token(token)
         files = {"file": (filename, file_bytes)}
         data = (params or {}).copy()
@@ -27,11 +40,20 @@ class UploadchiAsyncClient(AsyncFileServicePort):
 
     async def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = await self._client.post(f"/{file_id}/commit", headers=_auth_headers(tok), params={"client_id": client_id} if client_id else None)
+        r = await self._client.post(
+            f"/{file_id}/commit", headers=_auth_headers(tok), params={"client_id": client_id} if client_id else None
+        )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, await r.aread())
 
-    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:
         tok = _resolve_token(token)
         q = _build_list_query(limit, offset, filters, sort)
         r = await self._client.get("", params=q, headers=_auth_headers(tok))

nlbone-0.4.1/src/nlbone/adapters/messaging/__init__.py

@@ -0,0 +1 @@
+from .event_bus import InMemoryEventBus

nlbone-0.4.1/src/nlbone/adapters/messaging/event_bus.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Callable, Dict, Iterable, List
+
+from nlbone.core.domain.base import DomainEvent
+from nlbone.core.ports.event_bus import EventBusPort
+
+
+class InMemoryEventBus(EventBusPort):
+    def __init__(self) -> None:
+        self._handlers: Dict[str, List[Callable[[DomainEvent], None]]] = defaultdict(list)
+
+    def publish(self, events: Iterable[DomainEvent]) -> None:
+        for evt in events:
+            for h in self._handlers.get(evt.name, []):
+                try:
+                    h(evt)
+                except Exception:
+                    pass
+
+    def subscribe(self, event_name: str, handler: Callable[[DomainEvent], None]) -> None:
+        self._handlers[event_name].append(handler)

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/config/logging.py

@@ -1,19 +1,16 @@
 from __future__ import annotations
 
+import contextvars
 import json
 import logging
 import sys
 from datetime import datetime, timezone
 from typing import Any, MutableMapping, Optional
 
-import contextvars
-
 from nlbone.config.settings import get_settings
 
 # Context variable for request/correlation id
-_request_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
-    "request_id", default=None
-)
+_request_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("request_id", default=None)
 
 
 def set_request_id(request_id: Optional[str]) -> None:
@@ -97,9 +94,7 @@ def _build_stream_handler(json_enabled: bool, level: int) -> logging.Handler:
         handler.setFormatter(JsonFormatter())
     else:
         # human-friendly text format
-        fmt = (
-            "%(asctime)s | %(levelname)s | %(name)s | rid=%(request_id)s | %(message)s"
-        )
+        fmt = "%(asctime)s | %(levelname)s | %(name)s | rid=%(request_id)s | %(message)s"
         datefmt = "%Y-%m-%dT%H:%M:%S%z"
         handler.setFormatter(logging.Formatter(fmt=fmt, datefmt=datefmt))
     return handler

{nlbone-0.3.3 → nlbone-0.4.1}/src/nlbone/config/settings.py

@@ -2,7 +2,8 @@ import os
 from functools import lru_cache
 from pathlib import Path
 from typing import Literal
-from pydantic import AnyHttpUrl, Field, SecretStr, AliasChoices
+
+from pydantic import AnyHttpUrl, Field, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -34,9 +35,7 @@ class Settings(BaseSettings):
     # App
     # ---------------------------
     PORT: int = 8000
-    ENV: Literal["local", "dev", "staging", "prod"] = Field(default="local",
-                                                            validation_alias=AliasChoices("NLBONE_ENV", "ENV",
-                                                                                          "ENVIRONMENT"))
+    ENV: Literal["local", "dev", "staging", "prod"] = Field(default="local")
     DEBUG: bool = Field(default=False)
     LOG_LEVEL: Literal["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"] = Field(default="INFO")
     LOG_JSON: bool = Field(default=True)
@@ -49,40 +48,37 @@ class Settings(BaseSettings):
     # ---------------------------
     # Keycloak / Auth
     # ---------------------------
-    KEYCLOAK_SERVER_URL: AnyHttpUrl = Field(default="https://keycloak.local/auth",
-                                            validation_alias=AliasChoices("NLBONE_KEYCLOAK_SERVER_URL",
-                                                                          "KEYCLOAK_SERVER_URL"))
-    KEYCLOAK_REALM_NAME: str = Field(default="numberland",
-                                     validation_alias=AliasChoices("NLBONE_KEYCLOAK_REALM_NAME", "KEYCLOAK_REALM_NAME"))
-    KEYCLOAK_CLIENT_ID: str = Field(default="nlbone",
-                                    validation_alias=AliasChoices("NLBONE_KEYCLOAK_CLIENT_ID", "KEYCLOAK_CLIENT_ID"))
-    KEYCLOAK_CLIENT_SECRET: SecretStr = Field(default=SecretStr("dev-secret"),
-                                              validation_alias=AliasChoices("NLBONE_KEYCLOAK_CLIENT_SECRET",
-                                                                            "KEYCLOAK_CLIENT_SECRET"))
+    KEYCLOAK_SERVER_URL: AnyHttpUrl = Field(default="https://keycloak.local/auth")
+    KEYCLOAK_REALM_NAME: str = Field(default="numberland")
+    KEYCLOAK_CLIENT_ID: str = Field(default="nlbone")
+    KEYCLOAK_CLIENT_SECRET: SecretStr = Field(default=SecretStr("dev-secret"))
 
     # ---------------------------
     # Database
     # ---------------------------
-    POSTGRES_DB_DSN: str = Field(default="postgresql+asyncpg://user:pass@localhost:5432/nlbone",
-                                 validation_alias=AliasChoices("NLBONE_POSTGRES_DB_DSN",
-                                                               "POSTGRES_DB_DSN", "DATABASE_URL", "DB_DSN"))
+    POSTGRES_DB_DSN: str = Field(default="postgresql+asyncpg://user:pass@localhost:5432/nlbone")
+    DB_ECHO: bool = Field(default=False)
+    DB_POOL_SIZE: int = Field(default=5)
+    DB_MAX_OVERFLOW: int = Field(default=10)
 
     # ---------------------------
     # Messaging / Cache
     # ---------------------------
     REDIS_URL: str = Field(default="redis://localhost:6379/0")
 
+    # --- Event bus / Outbox ---
+    EVENT_BUS_BACKEND: Literal["inmemory"] = Field(default="inmemory")
+    OUTBOX_ENABLED: bool = Field(default=False)
+    OUTBOX_POLL_INTERVAL_MS: int = Field(default=500)
+
     # ---------------------------
     # UPLOADCHI
     # ---------------------------
     UPLOADCHI_BASE_URL: AnyHttpUrl = Field(default="https://uploadchi.numberland.ir/v1/files")
-    UPLOADCHI_TOKEN: SecretStr | None = Field(
-        default=None,
-        validation_alias=AliasChoices("NLBONE_UPLOADCHI_TOKEN", "UPLOADCHI_TOKEN"),
-    )
+    UPLOADCHI_TOKEN: SecretStr = Field(default="")
 
     model_config = SettingsConfigDict(
-        env_prefix="NLBONE_",
+        env_prefix="",
         env_file=None,
         env_file_encoding="utf-8",
         extra="ignore",