nlbone 0.6.20__py3-none-any.whl → 0.7.0__py3-none-any.whl

nlbone/adapters/outbox/outbox_repo.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from sqlalchemy import (
+    delete,
+    select,
+    update,
+)
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+from nlbone.core.domain.models import Outbox, OutboxStatus
+from nlbone.core.ports.outbox import AsyncOutboxRepository, OutboxRepository
+
+
+class SQLAlchemyOutboxRepository(OutboxRepository):
+    def __init__(self, session: Session) -> None:
+        self.session = session
+
+    def _now(self) -> datetime:
+        return datetime.now(timezone.utc)
+
+    def enqueue(self, topic: str, payload: Dict[str, Any], *, headers=None, key=None, available_at=None) -> Outbox:
+        row = Outbox(
+            topic=topic,
+            payload=payload,
+            headers=headers or {},
+            key=key,
+            available_at=available_at or self._now(),
+        )
+        self.session.add(row)
+        # Do not commit here; caller's transaction should commit
+        self.session.flush()
+        return row
+
+    def enqueue_many(
+            self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
+    ) -> List[Outbox]:
+        rows = [
+            Outbox(topic=t, payload=p, headers=headers or {}, available_at=available_at or self._now())
+            for t, p in items
+        ]
+        self.session.add_all(rows)
+        self.session.flush()
+        return [r for r in rows]
+
+    def claim_batch(self, *, topics: list[str] = None, limit: int = 100, now: Optional[datetime] = None) -> List[
+        Outbox]:
+        now = now or self._now()
+        # Select candidates eligible to process
+        stmt = (
+            select(Outbox)
+            .where(
+                Outbox.topic.in_(topics),
+                Outbox.status.in_([OutboxStatus.PENDING, OutboxStatus.FAILED]),
+                Outbox.available_at <= now,
+                (Outbox.next_attempt_at.is_(None)) | (Outbox.next_attempt_at <= now),
+            )
+            .order_by(Outbox.id)
+            .limit(limit)
+            .with_for_update(skip_locked=True)
+        )
+        rows = self.session.execute(stmt).scalars().all()
+        if not rows:
+            return []
+        # Mark as PROCESSING and increment attempts
+        ids = [r.id for r in rows]
+        self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PROCESSING, attempts=Outbox.attempts + 1)
+        )
+        self.session.flush()
+        return [r for r in rows]
+
+    def mark_published(self, ids: Iterable[int]) -> None:
+        ids = list(ids)
+        if not ids:
+            return
+        self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PUBLISHED, last_error=None, next_attempt_at=None)
+        )
+
+    def mark_failed(self, id: int, error: str, *, backoff: timedelta = timedelta(seconds=30)) -> None:
+        self.session.execute(
+            update(Outbox)
+            .where(Outbox.id == id)
+            .values(
+                status=OutboxStatus.FAILED,
+                last_error=error,
+                next_attempt_at=self._now() + backoff,
+            )
+        )
+
+    def delete_older_than(self, *, before: datetime, status: Optional[OutboxStatus] = None) -> int:
+        conds = [Outbox.created_at < before]
+        if status is not None:
+            conds.append(Outbox.status == status)
+        stmt = delete(Outbox).where(*conds)
+        res = self.session.execute(stmt)
+        return res.rowcount or 0
+
+
+class SQLAlchemyAsyncOutboxRepository(AsyncOutboxRepository):
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    def _now(self) -> datetime:
+        return datetime.now(timezone.utc)
+
+    async def enqueue(
+            self, topic: str, payload: Dict[str, Any], *, headers=None, key=None, available_at=None
+    ) -> Outbox:
+        row = Outbox(
+            topic=topic,
+            payload=payload,
+            headers=headers or {},
+            key=key,
+            available_at=available_at or self._now(),
+        )
+        self.session.add(row)
+        await self.session.flush()
+        return row
+
+    async def enqueue_many(
+            self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
+    ) -> List[Outbox]:
+        rows = [
+            Outbox(topic=t, payload=p, headers=headers or {}, available_at=available_at or self._now())
+            for t, p in items
+        ]
+        self.session.add_all(rows)
+        await self.session.flush()
+        return [r for r in rows]
+
+    async def claim_batch(self, *, limit: int = 100, now: Optional[datetime] = None) -> List[Outbox]:
+        now = now or self._now()
+        stmt = (
+            select(Outbox)
+            .where(
+                Outbox.status.in_([OutboxStatus.PENDING, OutboxStatus.FAILED]),
+                Outbox.available_at <= now,
+                (Outbox.next_attempt_at.is_(None)) | (Outbox.next_attempt_at <= now),
+            )
+            .order_by(Outbox.id)
+            .limit(limit)
+            .with_for_update(skip_locked=True)
+        )
+        rows = (await self.session.execute(stmt)).scalars().all()
+        if not rows:
+            return []
+        ids = [r.id for r in rows]
+        await self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PROCESSING, attempts=Outbox.attempts + 1)
+        )
+        await self.session.flush()
+        return [r.to_domain() for r in rows]
+
+    async def mark_published(self, ids: Iterable[int]) -> None:
+        ids = list(ids)
+        if not ids:
+            return
+        await self.session.execute(
+            update(Outbox)
+            .where(Outbox.id.in_(ids))
+            .values(status=OutboxStatus.PUBLISHED, last_error=None, next_attempt_at=None)
+        )
+
+    async def mark_failed(self, id: int, error: str, *, backoff: timedelta = timedelta(seconds=30)) -> None:
+        await self.session.execute(
+            update(Outbox)
+            .where(Outbox.id == id)
+            .values(
+                status=OutboxStatus.FAILED,
+                last_error=error,
+                next_attempt_at=self._now() + backoff,
+            )
+        )
+
+    async def delete_older_than(self, *, before: datetime, status: Optional[OutboxStatus] = None) -> int:
+        conds = [Outbox.created_at < before]
+        if status is not None:
+            conds.append(Outbox.status == status)
+        res = await self.session.execute(delete(Outbox).where(*conds))
+        return res.rowcount or 0

nlbone/adapters/ticketing/client.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel
+
+from nlbone.adapters.messaging.rabbitmq import RabbitMQEventBus
+from nlbone.config.settings import get_settings
+
+
+class CreateTicketIn(BaseModel):
+    assignee_id: str
+    category_id: int
+    channel: str
+    direction: str
+    entity_id: str
+    entity_type: str
+    message: str
+    priority: str
+    product_id: int
+    status: str
+    title: str
+    user_id: int
+
+
+class TicketingClient:
+    def __init__(self):
+        settings = get_settings()
+        self._bus = RabbitMQEventBus(settings.RABBITMQ_URL)
+        self._exchange = settings.RABBITMQ_TICKETING_EXCHANGE
+        self._rk_create_v1 = settings.RABBITMQ_TICKETING_ROUTING_KEY_CREATE_V1
+
+    async def create_ticket(self, payload: CreateTicketIn, created_by_id: int, *,
+                            override_exchange: Optional[str] = None,
+                            override_routing_key: Optional[str] = None) -> None:
+        exchange = override_exchange or self._exchange
+        routing_key = override_routing_key or self._rk_create_v1
+        payload = payload.model_dump()
+        payload.update({'created_by_id': created_by_id})
+        print(payload)
+        await self._bus.publish(exchange=exchange, routing_key=routing_key, payload=payload)

nlbone/config/settings.py

@@ -26,11 +26,11 @@ def _guess_env_file() -> str | None:
         raise Exception("Failed to guess env file path!") from e
 
 
-def is_production_env() -> bool:
+def read_from_env_fild() -> bool:
     raw = os.getenv("NLBONE_ENV") or os.getenv("ENV") or os.getenv("ENVIRONMENT")
     if not raw:
         return False
-    return raw.strip().lower() in {"prod", "production"}
+    return raw.strip().lower() not in {"prod", "production", "stage", "staging"}
 
 
 class Settings(BaseSettings):
@@ -101,6 +101,10 @@ class Settings(BaseSettings):
     # ---------------------------
     FERNET_KEY: str = Field(default="")
 
+    RABBITMQ_URL: str = Field(default="", description="amqp(s)://user:pass@host:5672/vhost")
+    RABBITMQ_TICKETING_EXCHANGE: str = "crm_stage.ticket"
+    RABBITMQ_TICKETING_ROUTING_KEY_CREATE_V1: str = "crm_stage.ticket.create.v1"
+
     model_config = SettingsConfigDict(
         env_prefix="",
         env_file=None,
@@ -110,9 +114,9 @@ class Settings(BaseSettings):
 
     @classmethod
     def load(cls, env_file: str | None = None) -> "Settings":
-        if is_production_env():
-            return cls()
-        return cls(_env_file=env_file or _guess_env_file())
+        if read_from_env_fild():
+            return cls(_env_file=env_file or _guess_env_file())
+        return cls()
 
 
 @lru_cache(maxsize=4)

nlbone/container.py

@@ -10,13 +10,10 @@ from nlbone.adapters.auth.token_provider import ClientTokenProvider
 from nlbone.adapters.cache.async_redis import AsyncRedisCache
 from nlbone.adapters.cache.memory import InMemoryCache
 from nlbone.adapters.cache.redis import RedisCache
-from nlbone.adapters.db.postgres import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork
 from nlbone.adapters.db.postgres.engine import get_async_session_factory, get_sync_session_factory
 from nlbone.adapters.http_clients import PricingService
 from nlbone.adapters.http_clients.uploadchi import UploadchiClient
 from nlbone.adapters.http_clients.uploadchi.uploadchi_async import UploadchiAsyncClient
-from nlbone.adapters.messaging import InMemoryEventBus
-from nlbone.core.ports import EventBusPort
 from nlbone.core.ports.cache import AsyncCachePort, CachePort
 from nlbone.core.ports.files import AsyncFileServicePort, FileServicePort
 
@@ -27,12 +24,8 @@ class Container(containers.DeclarativeContainer):
     sync_session_factory = providers.Singleton(get_sync_session_factory)
     async_session_factory = providers.Singleton(get_async_session_factory)
 
-    # --- UoW ---
-    uow = providers.Factory(SqlAlchemyUnitOfWork, session_factory=sync_session_factory)
-    async_uow = providers.Factory(AsyncSqlAlchemyUnitOfWork, session_factory=async_session_factory)
-
     # --- Event bus ---
-    event_bus: providers.Singleton[EventBusPort] = providers.Singleton(InMemoryEventBus)
+    # event_bus: providers.Singleton[EventBusPort] = providers.Singleton(InMemoryEventBus)
 
     # --- Services ---
     auth: providers.Singleton[KeycloakAuthService] = providers.Singleton(KeycloakAuthService)

nlbone/core/application/bus.py

@@ -1,10 +1,10 @@
 import traceback
-from typing import Optional, List, Callable, Coroutine, Any, Protocol
+from typing import Any, Callable, Coroutine, List, Optional, Protocol
 
-from nlbone.core.application.registry import HandlerRegistry, AsyncHandlerRegistry
-from nlbone.core.domain.base import Command, DomainEvent
-from nlbone.core.ports import UnitOfWork, AsyncUnitOfWork
-from nlbone.core.ports.event_bus import OutboxPublisher, Message, AsyncOutboxPublisher
+from nlbone.core.application.registry import AsyncHandlerRegistry, HandlerRegistry
+from nlbone.core.domain.base import Command, DomainEvent, Message
+from nlbone.core.ports import AsyncUnitOfWork, UnitOfWork
+from nlbone.core.ports.event_bus import AsyncOutboxPublisher, OutboxPublisher
 from nlbone.interfaces.api.middleware.access_log import logger
 
 
@@ -149,7 +149,7 @@ class AsyncMessageBus:
                 produced = await handler(event)
                 if produced:
                     self._queue.extend(produced)
-                self._queue.extend(self.uow.collect_new_events())
+                self._queue.extend(await self.uow.collect_new_events())
             except Exception:  # noqa: BLE001
                 logger.exception("Exception handling event %s\n%s", event, traceback.format_exc())
                 continue
@@ -161,7 +161,7 @@ class AsyncMessageBus:
             produced = await handler(command)
             if produced:
                 self._queue.extend(produced)
-            self._queue.extend(self.uow.collect_new_events())
+            self._queue.extend(await self.uow.collect_new_events())
             if self.outbox:
                 await self.outbox.publish(self._queue)
         except Exception:  # noqa: BLE001

nlbone/core/application/di.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
+
 import inspect
-from typing import Any, Callable, Dict, Optional, Type, get_type_hints, get_origin, get_args
+import sys
+from typing import Any, Callable, Dict, Optional, Type, get_args, get_origin, get_type_hints
+
 
 class TypeContainer:
     """Tiny type-based DI: register_instance(T, obj) / register_factory(T, () -> obj)."""
+
     def __init__(self) -> None:
         self._instances: Dict[Type[Any], Any] = {}
         self._factories: Dict[Type[Any], Callable[[], Any]] = {}
@@ -62,6 +66,7 @@ class TypeContainer:
             return None
         raise LookupError(f"No provider for {types}")
 
+
 def _mro_distance(sub: Type[Any], sup: Type[Any]) -> int:
     try:
         return sub.mro().index(sup)
@@ -69,31 +74,55 @@ def _mro_distance(sub: Type[Any], sup: Type[Any]) -> int:
         return 10**6
 
 
+def _type_hints(obj):
+    mod = sys.modules.get(getattr(obj, "__module__", "__name__"))
+    return get_type_hints(obj, globalns=vars(mod) if mod else None)
+
+
+def _build_kwargs(
+    sig: inspect.Signature,
+    hints: Dict[str, Any],
+    container: TypeContainer,
+    *,
+    skip_params: int = 0,
+) -> Dict[str, Any]:
+    kwargs: Dict[str, Any] = {}
+    for name, param in list(sig.parameters.items())[skip_params:]:
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            continue
+        ann = hints.get(name, param.annotation)
+        if param.default is not inspect._empty:
+            kwargs[name] = param.default
+        else:
+            kwargs[name] = container.resolve(ann)
+    return kwargs
+
+
 def bind_callable(fn: Callable[..., Any], c: TypeContainer) -> Callable[..., Any]:
     sig = inspect.signature(fn)
-    hints = get_type_hints(fn)
+    hints = _type_hints(fn)
+
     def wrapper(message: Any):
-        kwargs = {}
-        for name, param in list(sig.parameters.items())[1:]:
-            ann = hints.get(name, param.annotation)
-            kwargs[name] = c.resolve(ann)
+        kwargs = _build_kwargs(sig, hints, c, skip_params=1)
         return fn(message, **kwargs)
+
     return wrapper
 
 
 def bind_handler(handler: Any, c: TypeContainer) -> Callable[..., Any]:
     if inspect.isclass(handler):
-        init = handler.__init__  # type: ignore[attr-defined]
+        init = handler.__init__
         sig = inspect.signature(init)
-        hints = get_type_hints(init)
-        kwargs = {}
-        for name, param in list(sig.parameters.items())[1:]:
-            ann = hints.get(name, param.annotation)
-            kwargs[name] = c.resolve(ann)
-        instance = handler(**kwargs)  # type: ignore
+        hints = _type_hints(init)
+
+        kwargs = _build_kwargs(sig, hints, c, skip_params=1)
+
+        instance = handler(**kwargs)  # type: ignore[arg-type]
         if not callable(instance):
             raise TypeError(f"{handler!r} must implement __call__")
         return instance
-    elif callable(handler):
+
+    if callable(handler):
         return bind_callable(handler, c)
+
     raise TypeError(f"Unsupported handler: {handler!r}")

nlbone/core/application/registry.py

@@ -1,8 +1,7 @@
-from typing import Dict, Type, List, Callable, TypeVar, Optional, Iterable, Coroutine, Any
+from typing import Any, Callable, Coroutine, Dict, Iterable, List, Optional, Type, TypeVar
 
 from nlbone.core.application.di import TypeContainer, bind_handler
-from nlbone.core.domain.base import DomainEvent, Command
-from nlbone.core.ports.event_bus import Message
+from nlbone.core.domain.base import Command, DomainEvent, Message
 
 TMsg = TypeVar("TMsg", bound=Message)
 SyncHandler = Callable[[TMsg], Optional[Iterable[Message]]]
@@ -88,9 +87,16 @@ def handles_command_async(cmd_type: Type[Command], registry: AsyncHandlerRegistr
 
 
 def make_sync_decorators(registry: HandlerRegistry, container: TypeContainer):
-    def handles_command(cmd_type: Type[Any]):
-        def deco(h: Any):
-            registry.register_command(cmd_type, bind_handler(h, container))
+    def handles_command(cmd_type):
+        def deco(h):
+            instance_ref = {"inst": None}
+
+            def lazy_handler(message):
+                if instance_ref["inst"] is None:
+                    instance_ref["inst"] = bind_handler(h, container)
+                return instance_ref["inst"](message)
+
+            registry.register_command(cmd_type, lazy_handler)
             return h
 
         return deco

nlbone/core/domain/base.py

@@ -2,7 +2,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from datetime import datetime, timezone
+from enum import Enum
 from typing import Any, Generic, List, TypeVar
+from uuid import uuid4
+
+from pydantic import BaseModel
 
 TId = TypeVar("TId")
 
@@ -11,17 +15,28 @@ class DomainError(Exception):
     """Base domain exception."""
 
 
-@dataclass(frozen=True)
-class DomainEvent:
+
+class Message(BaseModel):
+    pass
+
+
+
+class DomainEvent(Message):
     """Immutable domain event."""
 
     occurred_at: datetime = datetime.now(timezone.utc)
+    event_id: str = uuid4()
 
     @property
     def name(self):
         return self.__class__.__name__
 
 
+@dataclass(frozen=True)
+class Command:
+    pass
+
+
 class ValueObject:
     """Base for value objects (immutable in practice)."""
 
@@ -39,13 +54,19 @@ class Entity(Generic[TId]):
 class AggregateRoot(Entity[TId]):
     """Aggregate root with domain event collection."""
 
-    def __init__(self, *args, **kwargs) -> None:
-        self._domain_events: List[DomainEvent] = []
+    def __init__(self) -> None:
+        self._events: List[DomainEvent] = []
+
+    @property
+    def events(self) -> List[DomainEvent]:
+        return self._events
 
     def _raise(self, event: DomainEvent) -> None:
-        self._domain_events.append(event)
+        self._events.append(event)
+
+    def clear_events(self) -> None:
+        self._events.clear()
+
 
-    def pull_events(self) -> List[DomainEvent]:
-        events = list(self._domain_events)
-        self._domain_events.clear()
-        return events
+class BaseEnum(Enum):
+    pass

nlbone/core/domain/models.py

@@ -1,12 +1,16 @@
+import enum
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone, timedelta
+from typing import Any, Dict, Optional
 
+from sqlalchemy import JSON, DateTime, Index, Integer, String, Text
 from sqlalchemy import JSON as SA_JSON
-from sqlalchemy import DateTime, Index, String, Text
+from sqlalchemy import Enum as SA_Enum
 from sqlalchemy.orm import Mapped, mapped_column
 from sqlalchemy.sql import func
 
-from nlbone.adapters.db import Base
+from nlbone.adapters.db.postgres.base import Base
+from nlbone.utils.time import now
 
 try:
     from sqlalchemy.dialects.postgresql import JSONB, UUID
@@ -38,3 +42,42 @@ class AuditLog(Base):
         Index("ix_audit_entity_entityid", "entity", "entity_id"),
         Index("ix_audit_created_at", "created_at"),
     )
+
+
+class OutboxStatus(str, enum.Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    PUBLISHED = "published"
+    FAILED = "failed"
+
+
+class Outbox(Base):
+    __tablename__ = "outbox"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    topic: Mapped[str] = mapped_column(String(200), nullable=False, index=True)
+    payload: Mapped[Dict[str, Any]] = mapped_column(JSON, nullable=False)
+    headers: Mapped[Dict[str, Any]] = mapped_column(JSON, default=dict)
+    key: Mapped[Optional[str]] = mapped_column(String(200), nullable=True, index=True)
+
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
+    available_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), index=True
+    )
+
+    status: Mapped[OutboxStatus] = mapped_column(SA_Enum(OutboxStatus), default=OutboxStatus.PENDING, index=True)
+    attempts: Mapped[int] = mapped_column(Integer, default=0)
+    last_error: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    next_attempt_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True, index=True)
+
+    def mark_failed(self, error: str, *, backoff: timedelta = timedelta(seconds=30)):
+        self.status = OutboxStatus.FAILED
+        self.last_error = error
+        self.next_attempt_at = now() + backoff
+
+    def mark_published(self):
+        self.status = OutboxStatus.PUBLISHED
+        self.next_attempt_at = None
+
+def to_outbox_row(evt) -> Outbox:
+    return Outbox(topic=evt.topic, payload=evt.__dict__)

nlbone/core/ports/__init__.py

@@ -1,5 +1,3 @@
 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/event_bus.py

@@ -1,10 +1,27 @@
-from __future__ import annotations
+from typing import Any, Awaitable, Callable, Iterable, Protocol, Type, runtime_checkable
 
-from typing import Callable, Iterable, Protocol
+from nlbone.core.domain.base import DomainEvent, Message
 
-from nlbone.core.domain.base import DomainEvent
+EventHandler = Callable[[DomainEvent], Any] | Callable[[DomainEvent], Awaitable[Any]]
 
 
-class EventBusPort(Protocol):
-    def publish(self, events: Iterable[DomainEvent]) -> None: ...
-    def subscribe(self, event_name: str, handler: Callable[[DomainEvent], None]) -> None: ...
+class EventBus(Protocol):
+    def subscribe(self, event_type: Type[DomainEvent] | str, handler: EventHandler) -> None: ...
+
+    def publish(self, event: DomainEvent) -> None: ...
+
+
+class EventPublisher(Protocol):
+    def publish(self, event: DomainEvent) -> None: ...
+
+
+@runtime_checkable
+class OutboxPublisher(Protocol):
+    """Optional: publish integration messages reliably after commit."""
+
+    def publish(self, messages: Iterable[Message]) -> None: ...
+
+
+@runtime_checkable
+class AsyncOutboxPublisher(Protocol):
+    async def publish(self, messages: Iterable[Message]) -> None: ...