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

nlbone/adapters/db/postgres/__init__.py

@@ -1,4 +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 .repository import SQLAlchemyAsyncRepository, SQLAlchemyRepository
 from .uow import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork

nlbone/adapters/db/postgres/base.py

@@ -1,3 +1,4 @@
-from sqlalchemy.orm import declarative_base
+from sqlalchemy.orm import declarative_base, registry
 
 Base = declarative_base()
+mapper_registry = registry(metadata=Base.metadata)

nlbone/adapters/db/postgres/repository.py

@@ -1,54 +1,279 @@
 from __future__ import annotations
 
-from typing import Generic, Iterable, List, Optional, Type, TypeVar
+from abc import ABC
+from typing import Any, Callable, Iterable, List, Optional, Sequence
 
-from sqlalchemy import select
+from sqlalchemy import delete as sqla_delete
+from sqlalchemy import desc as sa_desc
+from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from nlbone.core.ports.repo import AsyncRepository, Repository
+from nlbone.core.ports.repository import ID, AsyncRepository, Repository, T
+from nlbone.interfaces.api.exceptions import NotFoundException
 
-T = TypeVar("T")
 
+# -----------------------------
+# Helper utilities
+# -----------------------------
+def _apply_python_filters(
+    items: Sequence[T],
+    *,
+    where: Optional[Callable[[T], bool]] = None,
+    order_by: Optional[Callable[[T], object]] = None,
+    reverse: bool = False,
+    offset: int = 0,
+    limit: Optional[int] = None,
+) -> List[T]:
+    data = list(items)
+    if where:
+        data = [x for x in data if where(x)]
+    if order_by:
+        data.sort(key=order_by, reverse=reverse)
+    else:
+        if reverse:
+            data.reverse()
+    if offset:
+        data = data[offset:]
+    if limit is not None:
+        data = data[:limit]
+    return data
 
-class SqlAlchemyRepository(Repository[T], Generic[T]):
-    def __init__(self, session: Session, model: Type[T]) -> None:
+
+def _has_attr_id(entity: Any) -> bool:
+    return hasattr(entity, "id")
+
+
+# -----------------------------
+# SQLAlchemy (sync)
+# -----------------------------
+class SQLAlchemyRepository(Repository, ABC):
+    """
+    Concrete Repository[T, ID] backed by SQLAlchemy Session (sync).
+    Assumes entities have an `id` attribute and are mapped.
+    """
+
+    def __init__(self, session: Session, *, autocommit: bool = False):
         self.session = session
-        self.model = model
+        self.autocommit = autocommit
 
-    def get(self, id) -> Optional[T]:
+    def get(self, id: ID) -> Optional[T]:
         return self.session.get(self.model, id)
 
-    def add(self, obj: T) -> None:
-        self.session.add(obj)
+    def get_or_raise(self, id: ID) -> T:
+        entity = self.get(id)
+        if entity is None:
+            raise NotFoundException(f"Entity with id={id!r} not found")
+        return entity
+
+    def list(
+        self,
+        *,
+        offset: int = 0,
+        limit: Optional[int] = None,
+        where: Optional[Callable[[T], bool]] = None,
+        order_by: Optional[Callable[[T], object]] = None,
+        reverse: bool = False,
+    ) -> List[T]:
+        # If where/order_by look like SQLAlchemy expressions (not callables), push down to DB.
+        if where is None and (order_by is None or callable(order_by)):
+            stmt = select(self.model)
+        elif callable(where) or (order_by is not None and callable(order_by)):
+            # Fallback to Python-side filtering
+            stmt = select(self.model)
+        else:
+            stmt = select(self.model).where(where)  # type: ignore[arg-type]
+            if order_by is not None:
+                stmt = stmt.order_by(sa_desc(order_by) if reverse else order_by)  # type: ignore[arg-type]
+        if where is None and (order_by is None or not callable(order_by)):
+            if offset:
+                stmt = stmt.offset(offset)
+            if limit is not None:
+                stmt = stmt.limit(limit)
+            result = self.session.execute(stmt)
+            rows = result.scalars().all()
+            # If order_by was a Python callable, apply now
+            if order_by is not None and callable(order_by):
+                return _apply_python_filters(rows, order_by=order_by, reverse=reverse, offset=0, limit=None)
+            return rows
+        # Python-side filtering path
+        rows = self.session.execute(select(self.model)).scalars().all()
+        return _apply_python_filters(rows, where=where, order_by=order_by, reverse=reverse, offset=offset, limit=limit)
+
+    def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int:
+        if where is None:
+            stmt = select(func.count()).select_from(self.model)
+            return self.session.execute(stmt).scalar_one()
+        # Python-side when `where` is a callable
+        rows = self.session.execute(select(self.model)).scalars().all()
+        return sum(1 for x in rows if where(x))
+
+    def exists(self, id: ID) -> bool:
+        return self.get(id) is not None
+
+    # --- Write ---
+    def add(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        if self.exists(getattr(entity, "id")):
+            raise ValueError(f"Entity with id={getattr(entity, 'id')!r} already exists")
+        self.session.add(entity)
+        self.session.flush()
+        if self.autocommit:
+            self.session.commit()
+        return entity
+
+    def add_many(self, entities: Iterable[T]) -> List[T]:
+        data = list(entities)
+        for e in data:
+            if not _has_attr_id(e):
+                raise ValueError("All entities must have an `id` attribute.")
+        # Basic duplicate check in memory (best-effort)
+        ids = [getattr(e, "id") for e in data]
+        if len(ids) != len(set(ids)):
+            raise ValueError("Duplicate IDs in input batch.")
+        self.session.add_all(data)
+        if self.autocommit:
+            self.session.commit()
+        return data
 
-    def remove(self, obj: T) -> None:
+    def update(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        id_value = getattr(entity, "id")
+        if not self.exists(id_value):
+            raise NotFoundException(f"Entity with id={id_value!r} not found")
+        merged = self.session.merge(entity)
+        if self.autocommit:
+            self.session.commit()
+        return merged
+
+    def delete(self, id: ID) -> bool:
+        obj = self.get(id)
+        if not obj:
+            return False
         self.session.delete(obj)
+        if self.autocommit:
+            self.session.commit()
+        return True
+
+    def clear(self) -> None:
+        self.session.execute(sqla_delete(self.model))
+        if self.autocommit:
+            self.session.commit()
 
-    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()
 
+# -----------------------------
+# SQLAlchemy (async)
+# -----------------------------
+class SQLAlchemyAsyncRepository(AsyncRepository, ABC):
+    """
+    Concrete AsyncRepository[T, ID] backed by SQLAlchemy AsyncSession.
+    Assumes entities have an `id` attribute and are mapped.
+    """
 
-class AsyncSqlAlchemyRepository(AsyncRepository, Generic[T]):
-    def __init__(self, session: AsyncSession, model: Type[T]) -> None:
+    def __init__(self, session: AsyncSession, *, autocommit: bool = True):
         self.session = session
-        self.model = model
+        self.autocommit = autocommit
 
-    async def get(self, id) -> Optional[T]:
+    # --- Read ---
+    async def get(self, id: ID) -> Optional[T]:
         return await self.session.get(self.model, id)
 
-    def add(self, obj: T) -> None:
-        self.session.add(obj)
+    async def get_or_raise(self, id: ID) -> T:
+        entity = await self.get(id)
+        if entity is None:
+            raise NotFoundException(f"Entity with id={id!r} not found")
+        return entity
+
+    async def list(
+        self,
+        *,
+        offset: int = 0,
+        limit: Optional[int] = None,
+        where: Optional[Callable[[T], bool]] = None,
+        order_by: Optional[Callable[[T], object]] = None,
+        reverse: bool = False,
+    ) -> List[T]:
+        if where is None and (order_by is None or callable(order_by)):
+            stmt = select(self.model)
+        elif callable(where) or (order_by is not None and callable(order_by)):
+            stmt = select(self.model)
+        else:
+            stmt = select(self.model).where(where)  # type: ignore[arg-type]
+            if order_by is not None:
+                stmt = stmt.order_by(sa_desc(order_by) if reverse else order_by)  # type: ignore[arg-type]
+        if where is None and (order_by is None or not callable(order_by)):
+            if offset:
+                stmt = stmt.offset(offset)
+            if limit is not None:
+                stmt = stmt.limit(limit)
+            result = await self.session.execute(stmt)
+            rows = result.scalars().all()
+            if order_by is not None and callable(order_by):
+                return _apply_python_filters(rows, order_by=order_by, reverse=reverse, offset=0, limit=None)
+            return rows
+        result = await self.session.execute(select(self.model))
+        rows = result.scalars().all()
+        return _apply_python_filters(rows, where=where, order_by=order_by, reverse=reverse, offset=offset, limit=limit)
+
+    async def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int:
+        if where is None:
+            stmt = select(func.count()).select_from(self.model)
+            result = await self.session.execute(stmt)
+            return result.scalar_one()
+        result = await self.session.execute(select(self.model))
+        rows = result.scalars().all()
+        return sum(1 for x in rows if where(x))
+
+    async def exists(self, id: ID) -> bool:
+        return (await self.get(id)) is not None
+
+    # --- Write ---
+    async def add(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        if await self.exists(getattr(entity, "id")):
+            raise ValueError(f"Entity with id={getattr(entity, 'id')!r} already exists")
+        self.session.add(entity)
+        if self.autocommit:
+            await self.session.commit()
+        return entity
+
+    async def add_many(self, entities: Iterable[T]) -> List[T]:
+        data = list(entities)
+        for e in data:
+            if not _has_attr_id(e):
+                raise ValueError("All entities must have an `id` attribute.")
+        ids = [getattr(e, "id") for e in data]
+        if len(ids) != len(set(ids)):
+            raise ValueError("Duplicate IDs in input batch.")
+        self.session.add_all(data)
+        if self.autocommit:
+            await self.session.commit()
+        return data
+
+    async def update(self, entity: T) -> T:
+        if not _has_attr_id(entity):
+            raise ValueError("Entity must have an `id` attribute.")
+        id_value = getattr(entity, "id")
+        if not await self.exists(id_value):
+            raise NotFoundException(f"Entity with id={id_value!r} not found")
+        merged = await self.session.merge(entity)
+        if self.autocommit:
+            await self.session.commit()
+        return merged
 
-    async def remove(self, obj: T) -> None:
+    async def delete(self, id: ID) -> bool:
+        obj = await self.get(id)
+        if not obj:
+            return False
         await self.session.delete(obj)
+        if self.autocommit:
+            await self.session.commit()
+        return True
 
-    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())
+    async def clear(self) -> None:
+        await self.session.execute(sqla_delete(self.model))
+        if self.autocommit:
+            await self.session.commit()

nlbone/adapters/db/postgres/uow.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import AsyncIterator, Iterator, Optional
 
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from sqlalchemy.orm import Session, sessionmaker
 
+from nlbone.adapters.outbox.outbox_repo import SQLAlchemyAsyncOutboxRepository, SQLAlchemyOutboxRepository
+from nlbone.core.domain.base import DomainEvent
+from nlbone.core.ports.repository import AsyncRepository, Repository
 from nlbone.core.ports.uow import AsyncUnitOfWork as AsyncUnitOfWorkPort
 from nlbone.core.ports.uow import UnitOfWork
 
@@ -18,6 +21,7 @@ class SqlAlchemyUnitOfWork(UnitOfWork):
 
     def __enter__(self) -> "SqlAlchemyUnitOfWork":
         self.session = self._session_factory()
+        self.outbox_repo = SQLAlchemyOutboxRepository(self.session)
         return self
 
     def __exit__(self, exc_type, exc, tb) -> None:
@@ -34,11 +38,26 @@ class SqlAlchemyUnitOfWork(UnitOfWork):
     def commit(self) -> None:
         if self.session:
             self.session.commit()
+        # if self.event_bus:
+        #     for obj in self.session:
+        #         events = getattr(obj, "events", None)
+        #         if events:
+        #             for evt in list(events):
+        #                 self.event_bus.publish(evt)
+        #             obj.clear_events()
 
     def rollback(self) -> None:
         if self.session:
             self.session.rollback()
 
+    def collect_new_events(self) -> Iterator[DomainEvent]:
+        for name, type_ in self.__annotations__.items():
+            if isinstance(type_, type) and issubclass(type_, Repository):
+                repo = getattr(self, name)
+                for entity in repo.seen:
+                    for event in entity.events:
+                        yield event
+
 
 class AsyncSqlAlchemyUnitOfWork(AsyncUnitOfWorkPort):
     """Transactional boundary for async SQLAlchemy."""
@@ -49,6 +68,7 @@ class AsyncSqlAlchemyUnitOfWork(AsyncUnitOfWorkPort):
 
     async def __aenter__(self) -> "AsyncSqlAlchemyUnitOfWork":
         self.session = self._sf()
+        self.outbox_repo = SQLAlchemyAsyncOutboxRepository(self.session)
         return self
 
     async def __aexit__(self, exc_type, exc, tb) -> None:
@@ -65,7 +85,22 @@ class AsyncSqlAlchemyUnitOfWork(AsyncUnitOfWorkPort):
     async def commit(self) -> None:
         if self.session:
             await self.session.commit()
+        if self.event_bus:
+            for obj in self.session:
+                events = getattr(obj, "events", None)
+                if events:
+                    for evt in list(events):
+                        self.event_bus.publish(evt)
+                    obj.clear_events()
 
     async def rollback(self) -> None:
         if self.session:
             await self.session.rollback()
+
+    async def collect_new_events(self) -> AsyncIterator[DomainEvent]:
+        for name, type_ in self.__annotations__.items():
+            if isinstance(type_, type) and issubclass(type_, AsyncRepository):
+                repo = getattr(self, name)
+                for entity in repo.seen:
+                    for event in entity.events:
+                        yield event

nlbone/adapters/messaging/__init__.py

@@ -1 +1 @@
-from .event_bus import InMemoryEventBus
+from .event_bus import InProcessEventBus

nlbone/adapters/messaging/event_bus.py

@@ -1,23 +1,103 @@
-from __future__ import annotations
+import asyncio
+import json
+import time
+from typing import Callable, Dict, Iterable, List, Type
 
-from collections import defaultdict
-from typing import Callable, Dict, Iterable, List
+import redis
 
 from nlbone.core.domain.base import DomainEvent
-from nlbone.core.ports.event_bus import EventBusPort
+from nlbone.core.domain.models import Outbox
+from nlbone.core.ports.event_bus import EventBus, EventHandler
 
 
-class InMemoryEventBus(EventBusPort):
+class InProcessEventBus(EventBus):
     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)
+        self._handlers: Dict[Type[DomainEvent], List[EventHandler]] = {}
+
+    def subscribe(self, event_type: Type[DomainEvent], handler: EventHandler) -> None:
+        self._handlers.setdefault(event_type, []).append(handler)
+
+    def publish(self, event: DomainEvent) -> None:
+        handlers = list(self._handlers.get(type(event), []))
+        loop = None
+        for h in handlers:
+            res = h(event)
+            if asyncio.iscoroutine(res):
+                loop = loop or asyncio.get_event_loop()
+                loop.create_task(res)
+
+
+class OutboxDispatcher:
+    def __init__(self, session_factory, event_bus: EventBus, batch_size: int = 100):
+        self._sf = session_factory
+        self._bus = event_bus
+        self._batch = batch_size
+
+    def run_once(self) -> int:
+        sent = 0
+        with self._sf() as s:  # type: Session
+            rows: Iterable[Outbox] = (
+                s.query(Outbox).filter_by(published=False).order_by(Outbox.occurred_at).limit(self._batch).all()
+            )
+            for r in rows:
+                self._bus.publish(type("OutboxEvent", (), r.payload))
+                r.published = True
+                sent += 1
+            s.commit()
+        return sent
+
+
+class RedisStreamsEventBus(EventBus):
+    """Topic = stream name. routing_key = event.type"""
+
+    def __init__(self, client: redis.Redis, stream: str = "nlb:domain:events"):
+        self.client = client
+        self.stream = stream
+        self._local_handlers: dict[type[DomainEvent], list[EventHandler]] = {}
+
+    def subscribe(self, event_type: type[DomainEvent], handler: EventHandler) -> None:
+        self._local_handlers.setdefault(event_type, []).append(handler)
+
+    def publish(self, event: DomainEvent) -> None:
+        self.client.xadd(
+            self.stream,
+            {
+                "type": event.type,
+                "payload": json.dumps(event.__dict__, default=str),
+            },
+            maxlen=10_000,
+            approximate=True,
+        )
+        # optional: local handlers in same process (choreography ترکیبی)
+        for h in self._local_handlers.get(type(event), []):
+            h(event)
+
+
+class RedisStreamsConsumer:
+    def __init__(self, client: redis.Redis, stream: str, group: str, consumer: str, dlq: str | None = None):
+        self.client = client
+        self.stream = stream
+        self.group = group
+        self.consumer = consumer
+        self.dlq = dlq or f"{stream}:dlq"
+
+        try:
+            self.client.xgroup_create(name=self.stream, groupname=self.group, id="$", mkstream=True)
+        except redis.ResponseError:
+            pass  # group exists
+
+    def consume_forever(self, handler: Callable[[dict], None], block_ms: int = 2000, count: int = 32):
+        while True:
+            resp = self.client.xreadgroup(self.group, self.consumer, {self.stream: ">"}, count=count, block=block_ms)
+            if not resp:
+                continue
+            for _stream, messages in resp:
+                for msg_id, fields in messages:
+                    try:
+                        payload = json.loads(fields[b"payload"].decode())
+                        handler(payload)
+                        self.client.xack(self.stream, self.group, msg_id)
+                    except Exception:
+                        self.client.xack(self.stream, self.group, msg_id)
+                        self.client.xadd(self.dlq, fields)
+            time.sleep(0.05)

nlbone/adapters/messaging/rabbitmq.py

@@ -0,0 +1,45 @@
+import json
+from typing import Mapping, Any, Optional
+
+import aio_pika
+from aio_pika import ExchangeType, Message
+
+
+import json
+from typing import Mapping, Any, Optional
+import aio_pika
+from aio_pika import ExchangeType, Message
+from nlbone.core.ports.event_bus import EventBus
+
+class RabbitMQEventBus(EventBus):
+    def __init__(self, amqp_url: str, declare_passive: bool = True, exchange_type: ExchangeType = ExchangeType.DIRECT):
+        self._amqp_url = amqp_url
+        self._declare_passive = declare_passive
+        self._exchange_type = exchange_type
+        self._connection: Optional[aio_pika.RobustConnection] = None
+        self._channel: Optional[aio_pika.Channel] = None
+        self._exchange_cache: dict[str, aio_pika.Exchange] = {}
+
+    async def _ensure_channel(self) -> aio_pika.Channel:
+        if not self._connection or self._connection.is_closed:
+            self._connection = await aio_pika.connect_robust(self._amqp_url)
+        if not self._channel or self._channel.is_closed:
+            self._channel = await self._connection.channel(publisher_confirms=True)
+        return self._channel
+
+    async def _get_exchange(self, name: str) -> aio_pika.Exchange:
+        if name in self._exchange_cache:
+            return self._exchange_cache[name]
+        ch = await self._ensure_channel()
+        if self._declare_passive:
+            ex = await ch.declare_exchange(name, self._exchange_type, durable=True, passive=True)
+        else:
+            ex = await ch.declare_exchange(name, self._exchange_type, durable=True, passive=False)
+        self._exchange_cache[name] = ex
+        return ex
+
+    async def publish(self, *, exchange: str, routing_key: str, payload: Mapping[str, Any]) -> None:
+        ex = await self._get_exchange(exchange)
+        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        msg = Message(body=body, content_type="application/json", delivery_mode=aio_pika.DeliveryMode.PERSISTENT)
+        await ex.publish(msg, routing_key=routing_key)

nlbone/adapters/outbox/__init__.py

@@ -0,0 +1 @@
+from .outbox_consumer import outbox_stream, outbox_stream_sync, process_batch, process_message, process_message_sync

nlbone/adapters/outbox/outbox_consumer.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from contextlib import asynccontextmanager, contextmanager
+from datetime import timedelta
+from typing import AsyncIterator, Iterable, Iterator, Optional
+
+from nlbone.adapters.outbox.outbox_repo import AsyncOutboxRepository, OutboxRepository
+from nlbone.core.domain.models import Outbox
+from nlbone.core.ports import UnitOfWork
+
+
+async def outbox_stream(
+        repo: AsyncOutboxRepository,
+        *,
+        batch_size: int = 100,
+        idle_sleep: float = 1.0,
+        stop_event: Optional[asyncio.Event] = None,
+) -> AsyncIterator[Outbox]:
+    """
+    Yields Outbox one-by-one. If none available, waits (idle_sleep) and tries again.
+    Designed to run forever until stop_event is set.
+    """
+    while True:
+        if stop_event and stop_event.is_set():
+            return
+        batch: list[Outbox] = await repo.claim_batch(limit=batch_size)
+        if not batch:
+            await asyncio.sleep(idle_sleep)
+            continue
+        for msg in batch:
+            yield msg
+
+
+@asynccontextmanager
+async def process_message(
+        repo: AsyncOutboxRepository,
+        msg: Outbox,
+        *,
+        backoff: timedelta = timedelta(seconds=30),
+):
+    """
+    Usage:
+        async with process_message(repo, msg):
+            ... do work ...
+    On success -> mark_published
+    On exception -> mark_failed with backoff
+    """
+    try:
+        yield msg
+    except Exception as e:  # noqa: BLE001
+        await repo.mark_failed(msg.id, str(e), backoff=backoff)
+        raise
+    else:
+        await repo.mark_published([msg.id])
+
+
+async def process_batch(
+        repo: AsyncOutboxRepository,
+        messages: Iterable[Outbox],
+        *,
+        backoff: timedelta = timedelta(seconds=30),
+        concurrency: int = 1,
+        handler=None,
+):
+    """
+    Optional helper: run a handler concurrently on a batch.
+    handler: async callable(msg) -> None/… ; ack/nack handled via context manager.
+    """
+    sem = asyncio.Semaphore(concurrency)
+
+    async def _run(m: Outbox):
+        async with sem:
+            async with process_message(repo, m, backoff=backoff):
+                if handler:
+                    await handler(m)
+
+    await asyncio.gather(*(_run(m) for m in messages))
+
+
+def outbox_stream_sync(
+        repo: OutboxRepository,
+        *,
+        topics : list[str] = None,
+        batch_size: int = 100,
+        idle_sleep: float = 1.0,
+        stop_flag: Optional[callable] = None,
+) -> Iterator[Outbox]:
+    while True:
+        if stop_flag and stop_flag():
+            return
+        batch = repo.claim_batch(limit=batch_size, topics=topics)
+        if not batch:
+            time.sleep(idle_sleep)
+            continue
+        for msg in batch:
+            yield msg
+
+
+@contextmanager
+def process_message_sync(uow: UnitOfWork, msg: Outbox, *, backoff: timedelta = timedelta(seconds=30)):
+    try:
+        yield msg
+    except Exception as e:
+        uow.rollback()
+        msg.mark_failed(str(e), backoff=backoff)
+        uow.commit()
+        raise
+    else:
+        msg.mark_published()
+        uow.commit()