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

nlbone/adapters/db/postgres/query_builder.py

@@ -340,7 +340,7 @@ def get_paginated_response(
     with_count: bool = True,
     output_cls: Optional[Type] = None,
     eager_options: Optional[Sequence[LoaderOption]] = None,
-    query = None
+    query=None,
 ) -> dict:
     if not query:
         query = session.query(entity)

nlbone/adapters/repositories/outbox_repo.py

@@ -1,20 +1,18 @@
 from typing import List
 
+
 class OutboxRecord(dict):
     pass
 
+
 class OutboxRepository:
     def __init__(self, engine):
         self._engine = engine
 
-    def add(self, msg) -> None:
-        ...
+    def add(self, msg) -> None: ...
 
-    def fetch_pending(self, limit: int = 100) -> List[OutboxRecord]:
-        ...
+    def fetch_pending(self, limit: int = 100) -> List[OutboxRecord]: ...
 
-    def mark_sent(self, msg_id: int) -> None:
-        ...
+    def mark_sent(self, msg_id: int) -> None: ...
 
-    def schedule_retry(self, msg_id: int, retries: int, backoff_base: int = 2) -> None:
-        ...
+    def schedule_retry(self, msg_id: int, retries: int, backoff_base: int = 2) -> None: ...

nlbone/config/settings.py

@@ -96,6 +96,11 @@ class Settings(BaseSettings):
     # ---------------------------
     PRICING_SERVICE_URL: AnyHttpUrl = Field(default="https://pricing.numberland.ir/v1")
 
+    # ---------------------------
+    # Crypto
+    # ---------------------------
+    FERNET_KEY: str = Field(default="")
+
     model_config = SettingsConfigDict(
         env_prefix="",
         env_file=None,

nlbone/core/application/bus.py

@@ -0,0 +1,169 @@
+import traceback
+from typing import Optional, List, Callable, Coroutine, Any, 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.interfaces.api.middleware.access_log import logger
+
+
+class SyncMiddleware(Protocol):
+    def __call__(self, message: Message, next_: Callable[[Message], None]) -> None:  # noqa: D401
+        ...
+
+
+class AsyncMiddleware(Protocol):
+    async def __call__(self, message: Message, next_: Callable[[Message], Coroutine[Any, Any, None]]) -> None: ...
+
+
+class SyncMessageBus:
+    def __init__(
+        self,
+        uow: UnitOfWork,
+        registry: HandlerRegistry,
+        middlewares: Optional[List[SyncMiddleware]] = None,
+        outbox: Optional[OutboxPublisher] = None,
+    ) -> None:
+        self.uow = uow
+        self.registry = registry
+        self.middlewares = middlewares or []
+        self.outbox = outbox
+        self._queue: List[Message] = []
+
+    def handle(self, message: Message) -> None:
+        self._queue.append(message)
+        while self._queue:
+            msg = self._queue.pop(0)
+            self._dispatch_with_pipeline(msg)
+
+    # pipeline that wraps dispatch
+    def _dispatch_with_pipeline(self, message: Message) -> None:
+        def terminal(m: Message) -> None:
+            self._dispatch(m)
+
+        # build chain right-to-left
+        next_callable = terminal
+        for mw in reversed(self.middlewares):
+            current_mw = mw
+
+            def make_next(nxt: Callable[[Message], None]):  # closure helper
+                def _mw_call(m: Message) -> None:
+                    return current_mw(m, nxt)
+
+                return _mw_call
+
+            next_callable = make_next(next_callable)
+        next_callable(message)
+
+    def _dispatch(self, message: Message) -> None:
+        if isinstance(message, DomainEvent):
+            self._handle_event(message)
+        elif isinstance(message, Command):
+            self._handle_command(message)
+        else:
+            raise TypeError(f"Unknown message type: {type(message)!r}")
+
+    def _handle_event(self, event: DomainEvent) -> None:
+        handlers = self.registry.for_event(type(event))
+        for handler in handlers:
+            try:
+                logger.debug("handling event %s with %s", event, handler)
+                produced = handler(event)
+                if produced:
+                    self._queue.extend(produced)
+                self._queue.extend(self.uow.collect_new_events())
+            except Exception:  # noqa: BLE001
+                logger.exception("Exception handling event %s\n%s", event, traceback.format_exc())
+                continue
+
+    def _handle_command(self, command: Command) -> None:
+        handler = self.registry.for_command(type(command))
+        try:
+            logger.debug("handling command %s with %s", command, handler)
+            produced = handler(command)
+            if produced:
+                self._queue.extend(produced)
+            # commit (and gather/emit domain events)
+            self._queue.extend(self.uow.collect_new_events())
+            if self.outbox:
+                self.outbox.publish(self._queue)  # best-effort; in real systems use a DB-backed outbox
+        except Exception:  # noqa: BLE001
+            logger.exception("Exception handling command %s\n%s", command, traceback.format_exc())
+            raise
+
+
+# ==========================
+# MessageBus (async)
+# ==========================
+class AsyncMessageBus:
+    def __init__(
+        self,
+        uow: AsyncUnitOfWork,
+        registry: AsyncHandlerRegistry,
+        middlewares: Optional[List[AsyncMiddleware]] = None,
+        outbox: Optional[AsyncOutboxPublisher] = None,
+    ) -> None:
+        self.uow = uow
+        self.registry = registry
+        self.middlewares = middlewares or []
+        self.outbox = outbox
+        self._queue: List[Message] = []
+
+    async def handle(self, message: Message) -> None:
+        self._queue.append(message)
+        while self._queue:
+            msg = self._queue.pop(0)
+            await self._dispatch_with_pipeline(msg)
+
+    async def _dispatch_with_pipeline(self, message: Message) -> None:
+        async def terminal(m: Message) -> None:
+            await self._dispatch(m)
+
+        next_callable = terminal
+        for mw in reversed(self.middlewares):
+            current_mw = mw
+
+            def make_next(nxt: Callable[[Message], Coroutine[Any, Any, None]]):
+                async def _mw_call(m: Message) -> None:
+                    return await current_mw(m, nxt)
+
+                return _mw_call
+
+            next_callable = make_next(next_callable)
+        await next_callable(message)
+
+    async def _dispatch(self, message: Message) -> None:
+        if isinstance(message, DomainEvent):
+            await self._handle_event(message)
+        elif isinstance(message, Command):
+            await self._handle_command(message)
+        else:
+            raise TypeError(f"Unknown message type: {type(message)!r}")
+
+    async def _handle_event(self, event: DomainEvent) -> None:
+        handlers = self.registry.for_event(type(event))
+        for handler in handlers:
+            try:
+                logger.debug("handling event %s with %s", event, handler)
+                produced = await handler(event)
+                if produced:
+                    self._queue.extend(produced)
+                self._queue.extend(self.uow.collect_new_events())
+            except Exception:  # noqa: BLE001
+                logger.exception("Exception handling event %s\n%s", event, traceback.format_exc())
+                continue
+
+    async def _handle_command(self, command: Command) -> None:
+        handler = self.registry.for_command(type(command))
+        try:
+            logger.debug("handling command %s with %s", command, handler)
+            produced = await handler(command)
+            if produced:
+                self._queue.extend(produced)
+            self._queue.extend(self.uow.collect_new_events())
+            if self.outbox:
+                await self.outbox.publish(self._queue)
+        except Exception:  # noqa: BLE001
+            logger.exception("Exception handling command %s\n%s", command, traceback.format_exc())
+            raise

nlbone/core/application/di.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+import inspect
+from typing import Any, Callable, Dict, Optional, Type, get_type_hints, get_origin, get_args
+
+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]] = {}
+
+    def register_instance(self, t: Type[Any], instance: Any) -> None:
+        self._instances[t] = instance
+
+    def register_factory(self, t: Type[Any], factory: Callable[[], Any]) -> None:
+        self._factories[t] = factory
+
+    def _providers(self):
+        for t, v in self._instances.items():
+            yield t, (lambda v=v: v)
+        for t, f in self._factories.items():
+            yield t, f
+
+    def _unwrap(self, ann: Any) -> tuple[list[Type[Any]], bool]:
+        if ann is inspect._empty:
+            return [], True
+        origin = get_origin(ann)
+        args = list(get_args(ann))
+        allow_none = False
+        if origin in (Optional, getattr(__import__("typing"), "Union")):
+            if type(None) in args:
+                allow_none = True
+                args = [a for a in args if a is not type(None)]
+            return [a for a in args if isinstance(a, type)], allow_none
+        if isinstance(ann, type):
+            return [ann], False
+        return [], True
+
+    def resolve(self, ann: Any) -> Any:
+        types, allow_none = self._unwrap(ann)
+        if not types:
+            if allow_none:
+                return None
+            raise LookupError(f"Cannot resolve {ann!r}")
+        for T in types:
+            # exact
+            for pt, make in self._providers():
+                if pt is T:
+                    return make()
+            # supertype/provider match
+            best = None
+            for pt, make in self._providers():
+                try:
+                    if issubclass(T, pt):
+                        dist = _mro_distance(T, pt)
+                        if best is None or dist < best[0]:
+                            best = (dist, make)
+                except TypeError:
+                    pass
+            if best:
+                return best[1]()
+        if allow_none:
+            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)
+    except ValueError:
+        return 10**6
+
+
+def bind_callable(fn: Callable[..., Any], c: TypeContainer) -> Callable[..., Any]:
+    sig = inspect.signature(fn)
+    hints = get_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)
+        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]
+        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
+        if not callable(instance):
+            raise TypeError(f"{handler!r} must implement __call__")
+        return instance
+    elif callable(handler):
+        return bind_callable(handler, c)
+    raise TypeError(f"Unsupported handler: {handler!r}")

nlbone/core/application/registry.py

@@ -0,0 +1,123 @@
+from typing import Dict, Type, List, Callable, TypeVar, Optional, Iterable, Coroutine, Any
+
+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
+
+TMsg = TypeVar("TMsg", bound=Message)
+SyncHandler = Callable[[TMsg], Optional[Iterable[Message]]]
+AsyncHandler = Callable[[TMsg], Coroutine[Any, Any, Optional[Iterable[Message]]]]
+
+
+class HandlerRegistry:
+    def __init__(self) -> None:
+        self._event_handlers: Dict[Type[DomainEvent], List[SyncHandler[Any]]] = {}
+        self._command_handlers: Dict[Type[Command], SyncHandler[Any]] = {}
+
+    def register_event(self, event_type: Type[DomainEvent], handler: SyncHandler[Any]) -> None:
+        self._event_handlers.setdefault(event_type, []).append(handler)
+
+    def register_command(self, cmd_type: Type[Command], handler: SyncHandler[Any]) -> None:
+        if cmd_type in self._command_handlers:
+            raise ValueError(f"Command handler already registered for {cmd_type!r}")
+        self._command_handlers[cmd_type] = handler
+
+    def for_event(self, event_type: Type[DomainEvent]) -> List[SyncHandler[Any]]:
+        return self._event_handlers.get(event_type, [])
+
+    def for_command(self, cmd_type: Type[Command]) -> SyncHandler[Any]:
+        try:
+            return self._command_handlers[cmd_type]
+        except KeyError as e:
+            raise KeyError(f"No handler for command {cmd_type.__name__}") from e
+
+
+class AsyncHandlerRegistry:
+    def __init__(self) -> None:
+        self._event_handlers: Dict[Type[DomainEvent], List[AsyncHandler[Any]]] = {}
+        self._command_handlers: Dict[Type[Command], AsyncHandler[Any]] = {}
+
+    def register_event(self, event_type: Type[DomainEvent], handler: AsyncHandler[Any]) -> None:
+        self._event_handlers.setdefault(event_type, []).append(handler)
+
+    def register_command(self, cmd_type: Type[Command], handler: AsyncHandler[Any]) -> None:
+        if cmd_type in self._command_handlers:
+            raise ValueError(f"Command handler already registered for {cmd_type!r}")
+        self._command_handlers[cmd_type] = handler
+
+    def for_event(self, event_type: Type[DomainEvent]) -> List[AsyncHandler[Any]]:
+        return self._event_handlers.get(event_type, [])
+
+    def for_command(self, cmd_type: Type[Command]) -> AsyncHandler[Any]:
+        try:
+            return self._command_handlers[cmd_type]
+        except KeyError as e:
+            raise KeyError(f"No handler for command {cmd_type.__name__}") from e
+
+
+def handles_event(event_type: Type[DomainEvent], registry: HandlerRegistry):
+    def deco(fn: SyncHandler[Any]) -> SyncHandler[Any]:
+        registry.register_event(event_type, fn)
+        return fn
+
+    return deco
+
+
+def handles_command(cmd_type: Type[Command], registry: HandlerRegistry):
+    def deco(fn: SyncHandler[Any]) -> SyncHandler[Any]:
+        registry.register_command(cmd_type, fn)
+        return fn
+
+    return deco
+
+
+def handles_event_async(event_type: Type[DomainEvent], registry: AsyncHandlerRegistry):
+    def deco(fn: AsyncHandler[Any]) -> AsyncHandler[Any]:
+        registry.register_event(event_type, fn)
+        return fn
+
+    return deco
+
+
+def handles_command_async(cmd_type: Type[Command], registry: AsyncHandlerRegistry):
+    def deco(fn: AsyncHandler[Any]) -> AsyncHandler[Any]:
+        registry.register_command(cmd_type, fn)
+        return fn
+
+    return deco
+
+
+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))
+            return h
+
+        return deco
+
+    def handles_event(evt_type: Type[Any]):
+        def deco(h: Any):
+            registry.register_event(evt_type, bind_handler(h, container))
+            return h
+
+        return deco
+
+    return handles_command, handles_event
+
+
+def make_async_decorators(registry: AsyncHandlerRegistry, container: TypeContainer):
+    def handles_command_async(cmd_type: Type[Any]):
+        def deco(h: Any):
+            registry.register_command(cmd_type, bind_handler(h, container))
+            return h
+
+        return deco
+
+    def handles_event_async(evt_type: Type[Any]):
+        def deco(h: Any):
+            registry.register_event(evt_type, bind_handler(h, container))
+            return h
+
+        return deco
+
+    return handles_command_async, handles_event_async

nlbone/core/ports/repository.py

@@ -0,0 +1,115 @@
+from abc import ABC, abstractmethod
+from typing import (
+    TypeVar,
+    Generic,
+    Optional,
+    Iterable,
+    Callable,
+    List,
+    ClassVar,
+    Type,
+    Any,
+)
+
+from nlbone.interfaces.api.exceptions import NotFoundException
+
+ID = TypeVar("ID")
+T = TypeVar("T", bound="HasId")
+
+
+class Repository(Generic[T, ID], ABC):
+    model: ClassVar[Type[Any]]
+
+    @abstractmethod
+    def get(self, id: ID) -> Optional[T]: ...
+
+    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
+
+    @abstractmethod
+    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]: ...
+
+    @abstractmethod
+    def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int: ...
+
+    @abstractmethod
+    def exists(self, id: ID) -> bool: ...
+
+    # --- Write ---
+    @abstractmethod
+    def add(self, entity: T) -> T: ...
+
+    @abstractmethod
+    def add_many(self, entities: Iterable[T]) -> List[T]: ...
+
+    @abstractmethod
+    def update(self, entity: T) -> T: ...
+
+    @abstractmethod
+    def delete(self, id: ID) -> bool: ...
+
+    @abstractmethod
+    def clear(self) -> None: ...
+
+
+# -----------------------------
+# Async Repository (Abstract)
+# -----------------------------
+class AsyncRepository(Generic[T, ID], ABC):
+    @property
+    @abstractmethod
+    def model(self) -> type[T]: ...
+
+    @abstractmethod
+    async def get(self, id: ID) -> Optional[T]: ...
+
+    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
+
+    @abstractmethod
+    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]: ...
+
+    @abstractmethod
+    async def count(self, *, where: Optional[Callable[[T], bool]] = None) -> int: ...
+
+    @abstractmethod
+    async def exists(self, id: ID) -> bool: ...
+
+    # --- Write ---
+    @abstractmethod
+    async def add(self, entity: T) -> T: ...
+
+    @abstractmethod
+    async def add_many(self, entities: Iterable[T]) -> List[T]: ...
+
+    @abstractmethod
+    async def update(self, entity: T) -> T: ...
+
+    @abstractmethod
+    async def delete(self, id: ID) -> bool: ...
+
+    @abstractmethod
+    async def clear(self) -> None: ...

nlbone/interfaces/cli/crypto.py

@@ -0,0 +1,22 @@
+import typer
+
+from nlbone.utils.crypto import decrypt_text, encrypt_text
+
+crypto_command = typer.Typer(help="Encryption / Decryption utilities")
+
+
+@crypto_command.command("encrypt")
+def encrypt_cmd(value: str):
+    """Encrypt a plain text string."""
+    encrypted = encrypt_text(value)
+    typer.secho(f"🔐 Encrypted:\n{encrypted}", fg=typer.colors.GREEN)
+
+
+@crypto_command.command("decrypt")
+def decrypt_cmd(value: str):
+    """Decrypt an encrypted token string."""
+    try:
+        decrypted = decrypt_text(value)
+        typer.secho(f"🔓 Decrypted:\n{decrypted}", fg=typer.colors.CYAN)
+    except Exception as e:
+        typer.secho(f"❌ Failed to decrypt: {e}", fg=typer.colors.RED)

nlbone/interfaces/cli/main.py

@@ -4,11 +4,13 @@ import typer
 
 from nlbone.adapters.db import init_sync_engine
 from nlbone.config.settings import get_settings
+from nlbone.interfaces.cli.crypto import crypto_command
 from nlbone.interfaces.cli.init_db import init_db_command
 
 app = typer.Typer(help="NLBone CLI")
 
 app.add_typer(init_db_command, name="db")
+app.add_typer(crypto_command, name="crypto")
 
 
 @app.callback()

nlbone/interfaces/jobs/dispatch_outbox.py

@@ -1,6 +1,7 @@
 from nlbone.adapters.messaging.internal_router import internal_router
 from nlbone.core.ports.event_bus import IntegrationPublisher
 
+
 def run_dispatch_outbox(outbox_repo, publisher: IntegrationPublisher):
     batch = outbox_repo.fetch_pending(limit=200)
     for rec in batch:

nlbone/utils/crypto.py

@@ -0,0 +1,29 @@
+import base64
+import hashlib
+
+from cryptography.fernet import Fernet
+
+from nlbone.config.settings import get_settings
+
+
+def _get_fernet_key() -> Fernet:
+    settings = get_settings()
+    fernet_key = settings.FERNET_KEY
+
+    if not fernet_key or not fernet_key.strip():
+        raise Exception("❌ FERNET_KEY is required in .env")
+
+    digest = hashlib.sha256(fernet_key.encode()).digest()
+
+    return base64.urlsafe_b64encode(digest)
+
+
+fernet = Fernet(_get_fernet_key())
+
+
+def encrypt_text(plaintext: str) -> str:
+    return fernet.encrypt(plaintext.encode()).decode()
+
+
+def decrypt_text(token: str) -> str:
+    return fernet.decrypt(token.encode()).decode()

nlbone/utils/normalize_mobile.py

@@ -0,0 +1,33 @@
+import re
+from typing import List
+
+
+def normalize_mobile(mobile, strip_zero=True, add_country_code=True):
+    if not mobile:
+        return ""
+
+    mobile = re.sub(r"\D", "", str(mobile))
+
+    if mobile.startswith("0098"):
+        mobile = mobile[4:]
+    elif mobile.startswith("98") and len(mobile) > 10:
+        mobile = mobile[2:]
+
+    if strip_zero and mobile.startswith("0"):
+        mobile = mobile[1:]
+
+    if add_country_code:
+        if not mobile.startswith("98"):
+            mobile = f"98{mobile}"
+
+    return mobile
+
+
+def remove_duplicates(items: List[str]) -> List[str]:
+    seen = set()
+    out = []
+    for x in items:
+        if x and x not in seen:
+            seen.add(x)
+            out.append(x)
+    return out

{nlbone-0.6.19.dist-info → nlbone-0.6.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.6.19
+Version: 0.6.20
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
@@ -8,6 +8,7 @@ License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: anyio>=4.0
 Requires-Dist: cachetools>=6.2.0
+Requires-Dist: cryptography~=45.0.4
 Requires-Dist: dependency-injector>=4.48.1
 Requires-Dist: elasticsearch==8.14.0
 Requires-Dist: fastapi>=0.116

{nlbone-0.6.19.dist-info → nlbone-0.6.20.dist-info}/RECORD

@@ -15,7 +15,7 @@ nlbone/adapters/db/postgres/__init__.py,sha256=6JYJH0xZs3aR-zuyMpRhsdzFugmqz8npr
 nlbone/adapters/db/postgres/audit.py,sha256=IuWkPitr70UyQ6-GkAedckp8U-Z4cTgzFbdt_bQv1VQ,4800
 nlbone/adapters/db/postgres/base.py,sha256=kha9xmklzhuQAK8QEkNBn-mAHq8dUKbOM-3abaBpWmQ,71
 nlbone/adapters/db/postgres/engine.py,sha256=UCegauVB1gvo42ThytYnn5VIcQBwR-5xhcXYFApRFNk,3448
-nlbone/adapters/db/postgres/query_builder.py,sha256=wtOIsUJ3iM5-vFxIUfbkM6I13WE4fSw8pJKdVi4jgXY,12544
+nlbone/adapters/db/postgres/query_builder.py,sha256=Qv_2oZ5OxZwtN3Ts-jaAX_8sLBzb1mpGBhlNF7aR6Wk,12543
 nlbone/adapters/db/postgres/repository.py,sha256=J_DBE73JhHPYCk90c5-O7lQtZbxDgqjjN9OcWy4Omvs,1660
 nlbone/adapters/db/postgres/schema.py,sha256=NlE7Rr8uXypsw4oWkdZhZwcIBHQEPIpoHLxcUo98i6s,1039
 nlbone/adapters/db/postgres/uow.py,sha256=nRxNpY-WoWHpym-XeZ8VHm0MYvtB9wuopOeNdV_ebk8,2088
@@ -33,15 +33,17 @@ nlbone/adapters/messaging/redis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 nlbone/adapters/percolation/__init__.py,sha256=0h1Bw7FzxgkDIHxeoyQXSfegrhP6VbpYV4QC8njYdRE,38
 nlbone/adapters/percolation/connection.py,sha256=1iJISSwMEh4r_6nJI7mYf_v64Q0eeU1eSI0wLIfOK14,415
 nlbone/adapters/repositories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/repositories/outbox_repo.py,sha256=UdvAsasMOMA7M6fV8nEnxh7HXUWg_32ITNTZLIrUXug,433
+nlbone/adapters/repositories/outbox_repo.py,sha256=AgZ5BIL6UXAsXO7BlrId6XKGdsznDWsz1Jg9wK2Klww,404
 nlbone/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/config/logging.py,sha256=Ot6Ctf7EQZlW8YNB-uBdleqI6wixn5fH0Eo6QRgNkQk,4358
-nlbone/config/settings.py,sha256=S4Uw7oOmTQSbSDvNBzrpq0arEdhCxF9aZE1Cit2UXmM,3951
+nlbone/config/settings.py,sha256=jmpMeQ6IG_BXv6onwYIvYEauGIlHbEYaf8k6k_Owc9k,4073
 nlbone/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/base_worker.py,sha256=5brIToSd-vi6tw0ukhHnUZGZhOLq1SQ-NRRy-kp6D24,1193
-nlbone/core/application/command_bus.py,sha256=MxjlV5vbhxADB0xtifhPpTAytmLZHjKvEnnaaVbG520,705
+nlbone/core/application/bus.py,sha256=i-pcIb28lwtkoDwitmXEXxXaf6FSH_jllid0O9QdhX0,6420
+nlbone/core/application/di.py,sha256=95BG1LadZvptXI-kMpwqXpQqkXobVfkzirfBTBirRLs,3603
 nlbone/core/application/events.py,sha256=eQGLE0aZHuWJsy9J-qRse4CMXOtweH9-2rQ7AIPRMEQ,614
+nlbone/core/application/registry.py,sha256=Kvxozb_Z99q4WqP6xRtKoESeQyV9gJFm2olSGNAar08,4474
 nlbone/core/application/services.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/use_case.py,sha256=3GMQZ3CFK5cbLoBNBgohPft6GBq2j9_wr8iKRq_osQA,247
 nlbone/core/application/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,6 +58,7 @@ nlbone/core/ports/event_bus.py,sha256=_Om1GOOT-F325oV6_LJXtLdx4vu5i7KrpTDD3qPJXU
 nlbone/core/ports/files.py,sha256=7Ov2ITYRpPwwDTZGCeNVISg8e3A9l08jbOgpTImgfK8,1863
 nlbone/core/ports/messaging.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/ports/repo.py,sha256=zOw8CTMAu5DKKy2wZpT3_6JWWjaJCDt7q4dOiJYrCOQ,651
+nlbone/core/ports/repository.py,sha256=2IfyGOERhWQGYkVk3pHswtUQ7_bGxfXZCTu3o29OhWU,2752
 nlbone/core/ports/uow.py,sha256=SmBdRf0NvSdIjQ3Le1QGz8kNGBk7jgNHtNguvXRwmgs,557
 nlbone/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -84,21 +87,24 @@ nlbone/interfaces/api/schema/__init__.py,sha256=LAqgynfupeqOQ6u0I5ucrcYnojRMZUg9
 nlbone/interfaces/api/schema/adaptive_schema.py,sha256=bdWBNpP2NfOJ_in4btXn0lrZOK70x-OqfmZ-NpIJdoQ,3347
 nlbone/interfaces/api/schema/base_response_model.py,sha256=lkBs7k0IcQiSQdJ3KvqDQPr_zwqKNbwaQjcwAE_chnU,599
 nlbone/interfaces/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/interfaces/cli/crypto.py,sha256=lh2uUbSYKT6XxAt9uP1-VksopqAgdxiSKoKgXwXB0aE,692
 nlbone/interfaces/cli/init_db.py,sha256=C67n2MsJ1vzkJxC8zfUYOxFdd6mEB_vT9agxN6jWoG8,790
-nlbone/interfaces/cli/main.py,sha256=pNldsTgplVyXa-Hx96dySO2I9gFRi49nDXv7J_dO73s,686
+nlbone/interfaces/cli/main.py,sha256=0SxjiJlEB0xd8gobxSCg8mzsDx_ZIzUvRn9DWYi8Vw8,787
 nlbone/interfaces/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/interfaces/jobs/dispatch_outbox.py,sha256=Hke-DsCqE3ixtTbvCQfh0IB6nqm9XZGIu-qNcApnoA4,804
+nlbone/interfaces/jobs/dispatch_outbox.py,sha256=C6KWo17SXSETIrlYcGrNzh0SfI_gzfBcj0xp5mr8iXo,805
 nlbone/interfaces/jobs/sync_tokens.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/utils/cache.py,sha256=hVfkR62o5vllDrE_nY4At10wK0It6qpZ45K1xoj10cQ,5931
 nlbone/utils/cache_keys.py,sha256=Y2YSellHTbUOcoaNbl1jaD4r485VU_e4KXsfBWhYTBo,1075
 nlbone/utils/cache_registry.py,sha256=w28sEfUQZAhzCCqVH5TflWQY3nyDXyEcFWt8hkuHRHw,823
 nlbone/utils/context.py,sha256=MmclJ24BG2uvSTg1IK7J-Da9BhVFDQ5ag4Ggs2FF1_w,1600
+nlbone/utils/crypto.py,sha256=UOxjjyc1B868_R_k2js83bYRIBoo7c0txD8gXLgavDY,661
 nlbone/utils/http.py,sha256=UXUoXgQdTRNT08ho8zl-C5ekfDsD8uf-JiMQ323ooqw,872
+nlbone/utils/normalize_mobile.py,sha256=sGH4tV9gX-6eVKozviNWJhm1DN1J28Nj-ERldCYkS_E,732
 nlbone/utils/redactor.py,sha256=-V4HrHmHwPi3Kez587Ek1uJlgK35qGSrwBOvcbw8Jas,1279
 nlbone/utils/time.py,sha256=DjjyQ9GLsfXoT6NK8RDW2rOlJg3e6sF04Jw6PBUrSvg,1268
-nlbone-0.6.19.dist-info/METADATA,sha256=v185nm1R92gj7OAhj7HYUYlWJc3Dmn5b_mk1Hoxb8IM,2228
-nlbone-0.6.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nlbone-0.6.19.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
-nlbone-0.6.19.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.6.19.dist-info/RECORD,,
+nlbone-0.6.20.dist-info/METADATA,sha256=y5qyXUYRp1IImMd3Y9X4HxrwcFzR6QsBHMu-Q150tho,2264
+nlbone-0.6.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nlbone-0.6.20.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
+nlbone-0.6.20.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone-0.6.20.dist-info/RECORD,,

nlbone/core/application/command_bus.py

@@ -1,25 +0,0 @@
-from dataclasses import dataclass
-from typing import Protocol, Type, Any, Dict
-
-
-@dataclass(frozen=True)
-class Command:
-    pass
-
-
-class CommandHandler(Protocol):
-    def __call__(self, command: Command) -> Any: ...
-
-
-class CommandBus:
-    def __init__(self) -> None:
-        self._handlers: Dict[Type[Command], CommandHandler] = {}
-
-    def register(self, cmd_type: Type[Command], handler: CommandHandler) -> None:
-        self._handlers[cmd_type] = handler
-
-    def dispatch(self, command: Command) -> Any:
-        handler = self._handlers.get(type(command))
-        if handler is None:
-            raise LookupError(f"No handler registered for {type(command).__name__}")
-        return handler(command)