python-ddd-framework 0.3.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

python_ddd_framework/unit_of_work/manager.py

@@ -3,17 +3,21 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator, Callable
+from contextlib import AsyncExitStack, asynccontextmanager
 from contextvars import ContextVar
+from functools import partial
 from typing import TYPE_CHECKING
 from uuid import uuid4
 
-from dishka import Scope
+from dishka import AsyncContainer, Scope
 
 from ..invocation import ApplicationInvocationContext
 from .contracts import UnitOfWork, _UnitOfWorkFactory, _UnitOfWorkParticipant
+from .errors import UnitOfWorkCompletionError
+from .lifecycle import UnitOfWorkLifecycleFactory
 from .options import (
+    _DEFAULT_CONNECTION_NAME,
     UnitOfWorkDeclaration,
     UnitOfWorkOptions,
     UnitOfWorkTransactionBehavior,
@@ -22,7 +26,6 @@ from .options import (
 
 if TYPE_CHECKING:
     from ..application_services.invocation import _InvocationRuntime
-    from ..events import LocalEventCatalog
 
 
 class UnitOfWorkManager:
@@ -31,12 +34,14 @@ class UnitOfWorkManager:
         runtime: _InvocationRuntime,
         factory: _UnitOfWorkFactory,
         options: UnitOfWorkOptions,
-        catalog: LocalEventCatalog,
+        lifecycles: tuple[UnitOfWorkLifecycleFactory, ...],
+        container: AsyncContainer,
     ) -> None:
         self._runtime = runtime
         self._factory = factory
         self._options = options
-        self._catalog = catalog
+        self._lifecycles = lifecycles
+        self._container = container
         self._ambient: ContextVar[UnitOfWork | None] = ContextVar(
             f"python_ddd_framework_uow_{runtime.application_id}", default=None
         )
@@ -60,7 +65,6 @@ class UnitOfWorkManager:
         self, connection_name: str | None, declaration: UnitOfWorkDeclaration, method_name: str
     ) -> _ResolvedUnitOfWorkOptions:
         from ..application_services.contracts import (
-            _DEFAULT_CONNECTION_NAME,
             _validate_connection_name,
         )
 
@@ -141,48 +145,78 @@ class UnitOfWorkManager:
                 participant._released = True
             return
         async with self._runtime.outer_lease():
-            async with self._own_work(options) as work:
-                yield work
+            owned: UnitOfWork | None = None
+            async with self._execution_scope(
+                options.connection_name, committed=lambda: owned is not None and owned.committed
+            ):
+                async with self._own_work(options) as work:
+                    owned = work
+                    yield work
+
+    @asynccontextmanager
+    async def _execution_scope(
+        self, connection_name: str, *, committed: Callable[[], bool] = lambda: False
+    ) -> AsyncIterator[AsyncContainer]:
+        from ..application_services.invocation import (
+            _InvocationState,
+            _managed_action,
+            _managed_request,
+        )
+
+        execution = self._runtime.current()
+        if execution is not None:
+            # 复用执行身份，不以新事务改写原生 ACTION context/cache。
+            if execution.owner_task is not asyncio.current_task():
+                from ..application_services.errors import CrossTaskInvocationError
+
+                raise CrossTaskInvocationError
+            yield execution.action_container
+            return
+        parent = self._runtime.current_call_scope() or self._container
+        async with AsyncExitStack() as stack:
+            if parent.scope is Scope.APP:
+                parent = await stack.enter_async_context(_managed_request(parent))
+            context = (
+                await parent.get(ApplicationInvocationContext)
+                if parent.scope is Scope.ACTION
+                else self._runtime._new_context(connection_name)
+            )
+            action = await stack.enter_async_context(
+                _managed_action(parent, context, committed=committed)
+            )
+            task = asyncio.current_task()
+            assert task is not None
+            token = self._runtime.bind(_InvocationState(context, task, action))
+            try:
+                yield action
+            finally:
+                self._runtime.reset(token)
 
     @asynccontextmanager
     async def _own_work(self, options: _ResolvedUnitOfWorkOptions) -> AsyncIterator[UnitOfWork]:
         from ..application_services.errors import ApplicationInvocationCleanupError
-        from ..events.runtime import _LocalEventQueue
 
         execution = self._runtime.current()
-        container = (
-            execution.action_container
-            if execution is not None
-            else self._runtime.current_call_scope()
-        )
-        if container is None:
-            raise RuntimeError("UnitOfWork.begin requires a managed execution scope")
+        assert execution is not None
+        container = execution.action_container
         context = ApplicationInvocationContext(
             application_id=self._runtime.application_id,
             invocation_id=uuid4(),
-            parent_invocation_id=execution.context.invocation_id if execution else None,
+            parent_invocation_id=execution.context.invocation_id,
             connection_name=options.connection_name,
         )
         work = self._factory.create()
         work._options = options
-        work._event_queue = _LocalEventQueue(container, context, self._catalog)
-
-        async def after_commit() -> None:
-            # 新服务调用既不能复用旧事务，也不能落入旧 ACTION 的对象缓存。
-            token = self._ambient.set(None)
-            parent = container.parent_container if container.scope is Scope.ACTION else container
-            assert parent is not None
-            try:
-                with self._runtime.detached_execution(parent):
-                    assert work._event_queue is not None
-                    await work._event_queue._dispatch_after_commit()
-            finally:
-                self._ambient.reset(token)
 
-        work._after_commit = after_commit
+        work._after_commit = partial(self._after_commit, work, container)
         token = self._ambient.set(work)
         primary: BaseException | None = None
         try:
+            # 创建参与者也属于事务 ownership：构造失败仍须回滚、关闭并恢复外层上下文。
+            # 加入外层的调用不会走这里，因而复用外层的参与者和完成顺序。
+            work._lifecycles = tuple(
+                factory.create(container, context) for factory in self._lifecycles
+            )
             yield work
         except BaseException as error:
             primary = error
@@ -208,3 +242,23 @@ class UnitOfWorkManager:
             raise failure from (primary or work.cleanup_failures[0])
         if primary is not None:
             raise primary
+
+    async def _after_commit(self, work: UnitOfWork, container: AsyncContainer) -> None:
+        # 新服务调用既不能复用旧事务，也不能落入旧 ACTION 的对象缓存。
+        token = self._ambient.set(None)
+        parent = container.parent_container if container.scope is Scope.ACTION else container
+        assert parent is not None
+        failures: list[Exception] = []
+        try:
+            with self._runtime.detached_execution(parent):
+                for lifecycle in work._lifecycles:
+                    try:
+                        await lifecycle.after_commit()
+                    except Exception as error:
+                        failures.append(error)
+        finally:
+            self._ambient.reset(token)
+        if len(failures) == 1 and getattr(failures[0], "committed", False):
+            raise failures[0]
+        if failures:
+            raise UnitOfWorkCompletionError(tuple(failures)) from failures[0]

python_ddd_framework/unit_of_work/module.py

@@ -0,0 +1,61 @@
+"""UoW 默认实现、选项和完成参与者的组装 owner。"""
+
+from dishka import DEFAULT_COMPONENT, AsyncContainer, DependencyKey, Provider, Scope
+
+from ..application_services.invocation import _InvocationRuntime
+from ..invocation.module import InvocationModule
+from ..lifecycle import ConfigureContext
+from ..modularity import AppModule
+from ..options import Options
+from ..services.composition import ServiceBindingContext, ServiceComposition
+from ..services.registration import RegistrationDecision, RegistrationKind
+from .contracts import UnitOfWork, _UnitOfWorkFactory
+from .lifecycle import UnitOfWorkLifecycleFactory
+from .manager import UnitOfWorkManager
+from .options import UnitOfWorkOptions
+
+
+class UnitOfWorkModule(AppModule):
+    dependencies = (InvocationModule,)
+
+    def configure(self, context: ConfigureContext) -> None:
+        context.configure.default(UnitOfWorkOptions, section="unit_of_work")
+        provider = Provider()
+        provider.provide(_UnitOfWorkFactory, scope=Scope.APP)
+        context.services.contribute(
+            provider,
+            kind=RegistrationKind.DEFAULT,
+            reason="UnitOfWork without persistence",
+        )
+        context.services.add_composition(ServiceComposition(bind=self._bind))
+
+    def _bind(self, context: ServiceBindingContext) -> None:
+        provider = Provider()
+        # 完成参与者可由事件等能力通过正式 multi binding 贡献；未选能力时使用空集合。
+        if not any(
+            draft.key == DependencyKey(list[UnitOfWorkLifecycleFactory], DEFAULT_COMPONENT)
+            and draft.decision is RegistrationDecision.ACCEPTED
+            for draft in context.arbitration.drafts
+        ):
+            provider.provide(
+                lambda: [],
+                provides=list[UnitOfWorkLifecycleFactory],
+                scope=Scope.APP,
+            )
+        provider.provide(_manager, provides=UnitOfWorkManager, scope=Scope.APP)
+        provider.provide(_current, provides=UnitOfWork, scope=Scope.ACTION, cache=False)
+        context.add_provider(provider)
+
+
+def _manager(
+    container: AsyncContainer,
+    runtime: _InvocationRuntime,
+    factory: _UnitOfWorkFactory,
+    options: Options[UnitOfWorkOptions],
+    lifecycles: list[UnitOfWorkLifecycleFactory],
+) -> UnitOfWorkManager:
+    return UnitOfWorkManager(runtime, factory, options.value, tuple(lifecycles), container)
+
+
+def _current(manager: UnitOfWorkManager) -> UnitOfWork:
+    return manager.require_current()

python_ddd_framework/unit_of_work/options.py

@@ -9,9 +9,11 @@ from typing import TypeVar
 
 from pydantic import ConfigDict, Field, field_validator
 
+from ..modularity import ModuleDeclaration, ModuleRef
 from ..options import BaseOptions
 
 _UNIT_OF_WORK_ATTRIBUTE = "__python_ddd_framework_unit_of_work__"
+_DEFAULT_CONNECTION_NAME = "default"
 _T = TypeVar("_T")
 
 
@@ -40,12 +42,16 @@ class UnitOfWorkOptions(BaseOptions):
 
 
 @dataclass(frozen=True, slots=True)
-class UnitOfWorkDeclaration:
+class UnitOfWorkDeclaration(ModuleDeclaration):
     disabled: bool = False
     is_transactional: bool | None = None
     isolation_level: str | None = None
     command_timeout_ms: int | None = None
 
+    @property
+    def required_module(self) -> ModuleRef:
+        return ModuleRef("python_ddd_framework.unit_of_work.module:UnitOfWorkModule")
+
     def __post_init__(self) -> None:
         if not isinstance(self.disabled, bool):
             raise TypeError("disabled must be bool")

python_ddd_framework/validation/__init__.py

@@ -0,0 +1 @@
+"""框架内部的原生值校验边界；不拥有业务规则、调用管线或应用状态。"""

python_ddd_framework/validation/models.py

@@ -0,0 +1,37 @@
+"""Pydantic 实例重验边界；保留业务 schema，不拥有传输或应用状态。"""
+
+from typing import Any, TypeVar, cast
+
+from pydantic import BaseModel, TypeAdapter
+from pydantic_core import CoreSchema, SchemaValidator
+
+_TModel = TypeVar("_TModel", bound=BaseModel)
+
+
+def _revalidation_schema(value: Any) -> Any:
+    # 只复制 schema 容器；业务 class、默认值与配置保持原身份且不被改写。
+    # 嵌套 model/dataclass 也必须重验，不能复用它们默认跳过实例校验的 validator。
+    if isinstance(value, dict):
+        # 仅 schema 节点的 metadata/config/default 是非结构值；同名业务字段仍须遍历。
+        preserved = ("default", "metadata", "config") if isinstance(value.get("type"), str) else ()
+        result = {
+            key: item if key in preserved else _revalidation_schema(item)
+            for key, item in value.items()
+        }
+        if result.get("type") in ("model", "dataclass"):
+            result["revalidate_instances"] = "always"
+        return result
+    if isinstance(value, list):
+        return [_revalidation_schema(item) for item in value]
+    return value
+
+
+def _revalidate_model(model_type: type[_TModel], value: _TModel) -> _TModel:
+    adapter = TypeAdapter(model_type)
+    validator = SchemaValidator(
+        cast(CoreSchema, _revalidation_schema(adapter.core_schema)), _use_prebuilt=False
+    )
+    # 原生深复制隔离调用者的可变值；dataclass/Secret 等仍以真实实例形态接受重验。
+    # 序列化输出不是 strict Python 校验输入，不能先 dump 再重建模型。
+    snapshot = value.model_copy(deep=True)
+    return cast(_TModel, validator.validate_python(snapshot, strict=True, by_name=True))