python-ddd-framework 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

python_ddd_framework/events/runtime.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections import deque
 from contextvars import ContextVar
 from dataclasses import dataclass, field
-from typing import Protocol
 from uuid import UUID, uuid4
 
 from dishka import AsyncContainer, Scope
@@ -29,10 +28,6 @@ class _EventEnvelope:
     handled: set[object] = field(default_factory=set)
 
 
-class _EventHandler(Protocol):
-    async def handle(self, event: object) -> None: ...
-
-
 class _LocalEventQueue:
     """队列只归一个具体 UoW；handler resolution 仍使用 Dishka 原生 scope。"""
 
@@ -76,7 +71,7 @@ class _LocalEventQueue:
         )
         assert request is not None
         # 每个 UoW 的 handler scope 独立；手动 UoW 的原调用 ACTION 可能已返回。
-        from ..application_services.invocation import _managed_action
+        from ..invocation.scopes import _managed_action
 
         async with _managed_action(request, self._context, committed=lambda: False) as action:
             await self._drain_domain(action)
@@ -176,8 +171,8 @@ class _LocalEventQueue:
         previous = self._current
         self._current = envelope
         try:
-            from ..application_services.invocation import _InvocationRuntime
             from ..invocation.interception import _EntryInterceptionCatalog
+            from ..invocation.runtime import _InvocationRuntime
 
             entries = await container.get(_EntryInterceptionCatalog)
             runtime = await container.get(_InvocationRuntime)

python_ddd_framework/events/unit_of_work.py

@@ -19,7 +19,4 @@ class _LocalEventLifecycleFactory:
 
 
 def _local_event_queue(work: UnitOfWork) -> _LocalEventQueue:
-    for lifecycle in work._lifecycles:
-        if isinstance(lifecycle, _LocalEventQueue):
-            return lifecycle
-    raise RuntimeError("Local event lifecycle is not configured for this UnitOfWork")
+    return work._lifecycle(_LocalEventQueue)

python_ddd_framework/fastapi/action.py

@@ -14,8 +14,9 @@ from anyio import CancelScope
 from dishka import AsyncContainer
 from starlette.requests import Request
 
-from ..application_services.invocation import _InvocationRuntime, _InvocationState, _managed_action
 from ..invocation import ApplicationInvocationContext
+from ..invocation.runtime import _InvocationRuntime, _InvocationState
+from ..invocation.scopes import _managed_action
 from ..unit_of_work import UnitOfWork, UnitOfWorkManager
 from ..unit_of_work.options import _DEFAULT_CONNECTION_NAME, UnitOfWorkDeclaration
 from .errors import FastApiAdapterError

python_ddd_framework/fastapi/adapter.py

@@ -2,19 +2,15 @@
 
 from __future__ import annotations
 
-import logging
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
-from typing import Any, cast, get_args
+from typing import Any
 
 from dishka.exceptions import NoFactoryError
 from fastapi import FastAPI
 from fastapi.exception_handlers import request_validation_exception_handler
 from fastapi.exceptions import RequestValidationError
-from pydantic_core.core_schema import ErrorType
 from starlette.middleware import Middleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse
 
 from ..application import Application
 from ..application_services import ApplicationServiceValidationError
@@ -22,6 +18,16 @@ from ..authorization import PermissionDeniedError, UnauthenticatedError
 from ..errors import BusinessError, FrameworkError, ResourceConflictError, ResourceNotFoundError
 from ..lifecycle import ApplicationState
 from .contracts import RouterCatalog
+from .error_handlers import (
+    _application_service_validation_handler,
+    _business_error_handler,
+    _framework_error_handler,
+    _permission_denied_handler,
+    _request_validation_handler,
+    _resource_conflict_handler,
+    _resource_not_found_handler,
+    _unauthenticated_handler,
+)
 from .errors import FastApiAdapterError
 from .filters import ServiceFilter, _validate_filters
 from .middleware import DiMiddleware, _compile_middlewares
@@ -41,11 +47,8 @@ from .routing import (
 from .tracing import _install_tracing, _tracing_rollback
 from .upload_limits import UploadLimits
 
-_LOGGER = logging.getLogger(__name__)
 _INSTALLATION_MARKER = "_python_ddd_framework_fastapi_installed"
 _DISHKA_CONTAINER_BRIDGE = "dishka_container"
-_SAFE_REQUEST_LOCATION_ROOTS = frozenset({"body", "cookie", "header", "path", "query"})
-_TRUSTED_VALIDATION_ERROR_TYPES = frozenset(get_args(ErrorType))
 
 
 class FastApiAdapter:
@@ -296,112 +299,3 @@ def _installation_state(app: FastAPI) -> Iterator[None]:
             namespace.clear()
             namespace.update(snapshot)
         raise
-
-
-async def _business_error_handler(request: Request, error: Exception) -> JSONResponse:
-    business_error = cast(BusinessError, error)
-    return JSONResponse(
-        status_code=400,
-        content={
-            "error": {
-                "code": business_error.definition.code,
-                "message": business_error.definition.message,
-                "fields": [field.name for field in business_error.fields],
-                **(
-                    {
-                        "data": business_error.data.model_dump(
-                            mode="json", by_alias=True, warnings="error"
-                        )
-                    }
-                    if business_error.data is not None
-                    else {}
-                ),
-            }
-        },
-    )
-
-
-async def _framework_error_handler(request: Request, error: Exception) -> JSONResponse:
-    framework_error = cast(FrameworkError, error)
-    _LOGGER.error(
-        "Unhandled FrameworkError for %s %s",
-        request.method,
-        request.url.path,
-        exc_info=(type(framework_error), framework_error, framework_error.__traceback__),
-    )
-    return JSONResponse(status_code=500, content={"detail": "Internal Server Error"})
-
-
-async def _application_service_validation_handler(
-    request: Request,
-    error: Exception,
-) -> JSONResponse:
-    validation_error = cast(ApplicationServiceValidationError, error)
-    return JSONResponse(
-        status_code=422,
-        content={
-            "detail": [
-                {
-                    "loc": list(issue.location),
-                    "msg": issue.message,
-                    "type": issue.error_type,
-                }
-                for issue in validation_error.issues
-            ]
-        },
-    )
-
-
-async def _request_validation_handler(request: Request, error: Exception) -> JSONResponse:
-    validation_error = cast(RequestValidationError, error)
-    return JSONResponse(
-        status_code=422,
-        content={
-            "detail": [
-                {
-                    "loc": list(_safe_request_validation_location(detail.get("loc"))),
-                    "msg": "Input validation failed",
-                    "type": _trusted_request_validation_error_type(detail.get("type")),
-                }
-                for detail in validation_error.errors()
-            ]
-        },
-    )
-
-
-def _safe_request_validation_location(location: object) -> tuple[str, ...]:
-    if (
-        isinstance(location, tuple)
-        and location
-        and isinstance(location[0], str)
-        and location[0] in _SAFE_REQUEST_LOCATION_ROOTS
-    ):
-        # 后续 segment 可能来自用户控制的 mapping key；只发布 FastAPI 自有位置类别。
-        return (location[0],)
-    return ()
-
-
-def _trusted_request_validation_error_type(error_type: object) -> str:
-    if isinstance(error_type, str) and error_type in _TRUSTED_VALIDATION_ERROR_TYPES:
-        return error_type
-    return "value_error"
-
-
-async def _unauthenticated_handler(request: Request, error: Exception) -> JSONResponse:
-    return JSONResponse(
-        status_code=401,
-        content={"detail": "Not authenticated"},
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-
-
-async def _permission_denied_handler(request: Request, error: Exception) -> JSONResponse:
-    return JSONResponse(status_code=403, content={"detail": "Forbidden"})
-
-
-async def _resource_conflict_handler(request: Request, error: Exception) -> JSONResponse:
-    return JSONResponse(status_code=409, content={"detail": "Resource conflict"})
-
-
-async def _resource_not_found_handler(request: Request, error: Exception) -> JSONResponse:
-    return JSONResponse(status_code=404, content={"detail": "Resource not found"})

python_ddd_framework/fastapi/application_services.py

@@ -1,76 +1,39 @@
-"""ApplicationServiceCatalog 驱动的约定式 FastAPI route 生成。"""
+"""按正式 Module 暴露声明组装约定服务 Router。"""
 
 from __future__ import annotations
 
-import inspect
-import re
-import types
-from collections.abc import Awaitable, Callable, Coroutine, Mapping
-from dataclasses import dataclass, is_dataclass
-from datetime import date, datetime, time
-from decimal import Decimal
-from enum import Enum
-from typing import Annotated, Any, Literal, Union, cast, get_args, get_origin
-from uuid import UUID
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass
+from typing import Any, cast
 
-from dishka import AsyncContainer
-from dishka.integrations.base import default_parse_dependency
-from dishka.integrations.fastapi import DishkaRoute, FromDishka
 from fastapi import APIRouter, Depends
-from fastapi.params import Body, Param, Path, Query
-from fastapi.params import Depends as DependsParameter
 from fastapi.security import HTTPBearer
-from pydantic import BaseModel
-from pydantic.fields import FieldInfo
-from starlette.requests import Request
-from starlette.responses import Response
 from starlette.routing import compile_path
 
 from ..application import Application
-from ..application_services import (
-    ApplicationServiceRegistration,
-)
-from ..application_services.catalog import _CompiledApplicationService
-from ..application_services.dispatcher import _ApplicationServiceDispatcher
+from ..application_services import ApplicationServiceRegistration
 from ..application_services.module import ApplicationServicesModule
-from ..diagnostics import SourceLocation
-from ..invocation.methods import _CompiledMethod
 from ..modularity import AppModule, ModuleDescriptor, ModuleKey
-from .action import _HttpActionOwner, _request_parameter
 from .contracts import (
     ApplicationServiceRouteOverride,
     _application_service_exposure_for,
     _ApplicationServiceExposure,
 )
 from .errors import FastApiAdapterError
-from .filters import _filters_for, _ordered_filters, _validate_filters
-from .http import _metadata, _remote, _service_segment
+from .filters import _filters_for, _validate_filters
+from .http import _remote, _service_segment
 from .http_router import _compile_parameter
-from .parameters import _HttpParameterValidator
-from .transfer import _manage_stream
-from .uploads import _prepare_upload
-
-_APPLICATION_SERVICE_SUFFIX = "ApplicationService"
-_PATH_PARAMETER = re.compile(r"\{(?P<name>[^{}:]+)(?::[^{}]+)?\}")
-_WORD_BOUNDARY_1 = re.compile(r"(.)([A-Z][a-z]+)")
-_WORD_BOUNDARY_2 = re.compile(r"([a-z0-9])([A-Z])")
-_ROUTE_SOURCE_ATTRIBUTE = "__python_ddd_framework_fastapi_route_source__"
-_INVOCATION_IDENTITY_ATTRIBUTE = "__python_ddd_framework_fastapi_invocation_identity__"
-_VERB_PREFIXES: tuple[tuple[str, str], ...] = (
-    ("get_list", "GET"),
-    ("get_all", "GET"),
-    ("get", "GET"),
-    ("create", "POST"),
-    ("add", "POST"),
-    ("insert", "POST"),
-    ("post", "POST"),
-    ("update", "PUT"),
-    ("put", "PUT"),
-    ("delete", "DELETE"),
-    ("remove", "DELETE"),
-    ("patch", "PATCH"),
+from .service_endpoints import _ApplicationServiceRoute, _create_endpoint
+from .service_routes import (
+    _conventional_verb,
+    _inspect_route_method,
+    _operation_id,
+    _query_model_parameter,
+    _route_path,
+    _route_projection,
+    _RouteMethod,
+    _service_path,
 )
-_SCALAR_TYPES = (str, int, float, bool, UUID, Decimal, date, datetime, time)
 
 
 @dataclass(frozen=True, slots=True)
@@ -79,78 +42,6 @@ class _GeneratedApplicationServiceRouter:
     router: APIRouter
 
 
-@dataclass(frozen=True, slots=True)
-class _RouteMethod:
-    signature: inspect.Signature
-    parameters: tuple[inspect.Parameter, ...]
-
-
-@dataclass(frozen=True, slots=True)
-class _ApplicationServiceRouteIdentity:
-    service: _CompiledApplicationService
-    method: _CompiledMethod
-
-
-class _ApplicationServiceRoute(DishkaRoute):
-    """在 native FastAPI binding 前建立 catalog-identity invocation boundary。"""
-
-    __slots__ = ("_compiled_method", "_compiled_service")
-
-    def __init__(
-        self,
-        path: str,
-        endpoint: Callable[..., Any],
-        **kwargs: Any,
-    ) -> None:
-        identity = getattr(endpoint, _INVOCATION_IDENTITY_ATTRIBUTE, None)
-        if not isinstance(identity, _ApplicationServiceRouteIdentity):
-            raise FastApiAdapterError("generated Application Service route lost its identity")
-        self._compiled_service = identity.service
-        self._compiled_method = identity.method
-        sources = getattr(endpoint, "__python_ddd_framework_http_sources__", None)
-        super().__init__(path, endpoint, **kwargs)
-        cast(Any, self.endpoint).__python_ddd_framework_http_sources__ = sources
-        # include_router 会以已注入 endpoint 重建 route；显式把 identity 传递给下一次构造。
-        setattr(self.endpoint, _INVOCATION_IDENTITY_ATTRIBUTE, identity)
-
-    def get_route_handler(
-        self,
-    ) -> Callable[[Request], Coroutine[Any, Any, Response]]:
-        native_handler = super().get_route_handler()
-        service = self._compiled_service
-        method = self._compiled_method
-
-        async def route_handler(request: Request) -> Response:
-            owner = await _HttpActionOwner.install(request)
-            container = cast(AsyncContainer, request.state.dishka_container)
-            dispatcher = await container.get(_ApplicationServiceDispatcher)
-
-            async def bind() -> Response:
-                await _prepare_upload(request, method.implementation_method, self)
-                return await native_handler(request)
-
-            try:
-                result = await dispatcher.invoke_http_request(
-                    service,
-                    method,
-                    bind,
-                    is_short_circuited=lambda: owner.short_circuited,
-                    defer_audit=owner.audits.append,
-                )
-                owner.response_ready = isinstance(result, Response)
-            except BaseException as error:
-                owner.failure = error
-                raise
-            if not isinstance(result, Response):
-                raise FastApiAdapterError(
-                    "an interceptor outside HTTP binding must return a native Response"
-                )
-            _manage_stream(request, result)
-            return result
-
-        return route_handler
-
-
 def _application_service_routers(
     application: Application,
 ) -> tuple[_GeneratedApplicationServiceRouter, ...]:
@@ -373,282 +264,6 @@ def _index_overrides(
     return indexed
 
 
-def _inspect_route_method(
-    contract: type[object],
-    method_name: str,
-    signature: inspect.Signature,
-) -> _RouteMethod:
-    """在真实 FastAPI app 变更前解析并收窄动态 typing boundary。"""
-
-    # 共享方法编译已解释本 Application 的扩展 DTO；HTTP 不另建字段权威。
-    resolved_parameters = tuple(signature.parameters.values())
-    parameters = resolved_parameters[1:]
-    for parameter in parameters:
-        if parameter.kind in (
-            inspect.Parameter.POSITIONAL_ONLY,
-            inspect.Parameter.VAR_POSITIONAL,
-            inspect.Parameter.VAR_KEYWORD,
-        ):
-            raise FastApiAdapterError(
-                f"HTTP method {contract.__module__}.{contract.__qualname__}.{method_name} "
-                "cannot use positional-only, *args, or **kwargs parameters"
-            )
-        if parameter.annotation is inspect.Signature.empty:
-            raise FastApiAdapterError(
-                f"HTTP method {contract.__module__}.{contract.__qualname__}.{method_name} "
-                f"parameter {parameter.name!r} requires a type annotation"
-            )
-    if signature.return_annotation is inspect.Signature.empty:
-        raise FastApiAdapterError(
-            f"HTTP method {contract.__module__}.{contract.__qualname__}.{method_name} "
-            "requires a return type annotation"
-        )
-    return _RouteMethod(signature=signature, parameters=parameters)
-
-
-def _query_model_parameter(parameter: inspect.Parameter, verb: str) -> inspect.Parameter:
-    hint = parameter.annotation
-    metadata = get_args(hint)[1:] if get_origin(hint) is Annotated else ()
-    model = get_args(hint)[0] if metadata else hint
-    if (
-        verb == "GET"
-        and isinstance(model, type)
-        and issubclass(model, BaseModel)
-        and not any(
-            isinstance(value, (FieldInfo, DependsParameter))
-            for value in (*metadata, parameter.default)
-        )
-        and default_parse_dependency(parameter, hint) is None
-    ):
-        # 仅补原生 Query 元数据；字段展开、校验和 OpenAPI 均交给 FastAPI/Pydantic。
-        return parameter.replace(annotation=Annotated[hint, Query()])
-    return parameter
-
-
-def _uses_non_path_binding(parameter: inspect.Parameter) -> bool:
-    metadata = (
-        get_args(parameter.annotation)[1:] if get_origin(parameter.annotation) is Annotated else ()
-    )
-    return any(
-        isinstance(item, (Param, Body)) and not isinstance(item, Path)
-        for item in (*metadata, parameter.default)
-    )
-
-
-def _route_path(
-    service_path: str,
-    parameters: tuple[inspect.Parameter, ...],
-    override_path: str | None,
-    *,
-    contract: type[object],
-    method_name: str,
-) -> str:
-    # 只有唯一 required scalar id 才能无歧义进入 convention path；
-    # 其余情况保持 query 或要求 override。
-    id_candidates = tuple(
-        parameter
-        for parameter in parameters
-        if _is_required_path_parameter(parameter)
-        and (parameter.name == "id" or parameter.name.endswith("_id"))
-        and _is_scalar_annotation(parameter.annotation)
-        and not _uses_non_path_binding(parameter)
-    )
-    if override_path is None:
-        if len(id_candidates) > 1:
-            raise FastApiAdapterError(
-                f"HTTP method {contract.__module__}.{contract.__qualname__}.{method_name} "
-                "has ambiguous required id parameters and requires an explicit path override"
-            )
-        path = service_path
-        if len(id_candidates) == 1:
-            path = f"{path}/{{{id_candidates[0].name}}}"
-        # 只有集中定义的 CRUD 名称省略动作；审批/取消等领域动作保持其 contract 名称。
-        if method_name not in {prefix for prefix, _ in _VERB_PREFIXES}:
-            path = f"{path}/{method_name.replace('_', '-')}"
-        return path
-
-    if "?" in override_path or "#" in override_path or "//" in override_path:
-        raise FastApiAdapterError("route override path cannot contain query or fragment syntax")
-    rendered_parameters = tuple(
-        match.group("name") for match in _PATH_PARAMETER.finditer(override_path)
-    )
-    if override_path.count("{") != len(rendered_parameters) or override_path.count("}") != len(
-        rendered_parameters
-    ):
-        raise FastApiAdapterError(f"route override path {override_path!r} is malformed")
-    parameters_by_name = {parameter.name: parameter for parameter in parameters}
-    for name in rendered_parameters:
-        parameter = parameters_by_name.get(name)
-        if (
-            parameter is None
-            or not _is_required_path_parameter(parameter)
-            or not _is_scalar_annotation(parameter.annotation)
-            or _uses_non_path_binding(parameter)
-        ):
-            raise FastApiAdapterError(
-                f"route override path parameter {name!r} must name a required scalar "
-                f"Protocol parameter on {contract.__qualname__}.{method_name}"
-            )
-    if len(set(rendered_parameters)) != len(rendered_parameters):
-        raise FastApiAdapterError(f"route override path {override_path!r} repeats a path parameter")
-    return override_path
-
-
-def _is_required_path_parameter(parameter: inspect.Parameter) -> bool:
-    return parameter.default is inspect.Signature.empty or isinstance(parameter.default, Path)
-
-
-def _is_scalar_annotation(annotation: object) -> bool:
-    current = annotation
-    if get_origin(current) is Annotated:
-        current = get_args(current)[0]
-    origin = get_origin(current)
-    if origin in (types.UnionType, Union):
-        members = tuple(item for item in get_args(current) if item is not type(None))
-        return len(members) == 1 and _is_scalar_annotation(members[0])
-    if origin is Literal:
-        return all(isinstance(item, (str, int, float, bool)) for item in get_args(current))
-    if not isinstance(current, type):
-        return False
-    if issubclass(current, BaseModel) or is_dataclass(current):
-        return False
-    return issubclass(current, (*_SCALAR_TYPES, Enum))
-
-
-def _service_path(root_path: str, contract: type[object], segment: str | None = None) -> str:
-    service_name = contract.__name__
-    if service_name.endswith(_APPLICATION_SERVICE_SUFFIX):
-        service_name = service_name[: -len(_APPLICATION_SERVICE_SUFFIX)]
-    if not service_name:
-        raise FastApiAdapterError("application service contract has no routable name")
-    return "/" + "/".join(
-        part for part in (root_path, segment or _kebab_case(service_name)) if part
-    )
-
-
-def _operation_id(contract: type[object], method_name: str) -> str:
-    service_path = _service_path("", contract).rsplit("/", maxsplit=1)[-1]
-    return f"{service_path.replace('-', '_')}_{method_name}"
-
-
-def _kebab_case(value: str) -> str:
-    first_pass = _WORD_BOUNDARY_1.sub(r"\1-\2", value)
-    return _WORD_BOUNDARY_2.sub(r"\1-\2", first_pass).lower().replace("_", "-")
-
-
-def _conventional_verb(method_name: str) -> str:
-    for prefix, verb in _VERB_PREFIXES:
-        if method_name == prefix or method_name.startswith(f"{prefix}_"):
-            return verb
-    return "POST"
-
-
-def _create_endpoint(
-    service: _CompiledApplicationService,
-    method: _CompiledMethod,
-    route_method: _RouteMethod,
-    source: SourceLocation,
-) -> Callable[..., Awaitable[object]]:
-    """保留 Protocol 原签名供 FastAPI binding，并注入同一 REQUEST dispatcher。"""
-
-    contract = service.registration.contract
-    method_name = method.name
-    parameter_names = {parameter.name for parameter in route_method.parameters}
-    dispatcher_parameter_name = "_python_ddd_framework_application_service_dispatcher"
-    while dispatcher_parameter_name in parameter_names:
-        dispatcher_parameter_name = f"_{dispatcher_parameter_name}"
-
-    declared_filters = _ordered_filters(
-        _filters_for(*reversed(service.registration.implementation.__mro__)),
-        _filters_for(method.implementation_method),
-    )
-    validator = _HttpParameterValidator(
-        route_method.signature.replace(parameters=route_method.parameters)
-    )
-
-    async def endpoint(**values: object) -> object:
-        dispatcher = cast(_ApplicationServiceDispatcher, values.pop(dispatcher_parameter_name))
-        request = cast(
-            Request,
-            values.pop(request_parameter_name)
-            if injected_request
-            else values[request_parameter_name],
-        )
-        owner: _HttpActionOwner = request.state.python_ddd_framework_action
-        await owner.activate(
-            method.descriptor.unit_of_work, method.name, service.registration.connection_name
-        )
-        filters = _ordered_filters(
-            getattr(request.app.state, "python_ddd_framework_filters", ()), declared_filters
-        )
-        snapshots = validator.capture(values)
-
-        async def invoke(actual: dict[str, object]) -> object:
-            if filters:
-                validator.validate_changes(actual, snapshots)
-            return await dispatcher.invoke_http(service, method, actual)
-
-        return await owner.invoke(
-            method.implementation_method,
-            values,
-            filters,
-            invoke,
-        )
-
-    request_parameter, injected_request = _request_parameter(route_method.parameters)
-    request_parameter_name = request_parameter.name
-    http_parameters = (
-        (*route_method.parameters, request_parameter)
-        if injected_request
-        else route_method.parameters
-    )
-
-    dispatcher_parameter = inspect.Parameter(
-        dispatcher_parameter_name,
-        kind=inspect.Parameter.KEYWORD_ONLY,
-        annotation=cast(Any, FromDishka)[_ApplicationServiceDispatcher],
-    )
-    # 动态 endpoint 的 signature/annotations 同时发布，兼容 FastAPI 与 postponed annotations。
-    signature = route_method.signature.replace(parameters=(*http_parameters, dispatcher_parameter))
-    endpoint_name = f"{contract.__name__}_{method_name}"
-    endpoint.__name__ = endpoint_name
-    endpoint.__qualname__ = endpoint_name
-    endpoint.__module__ = contract.__module__
-    cast(Any, endpoint).__signature__ = signature
-    endpoint.__annotations__ = {
-        **{
-            parameter.name: parameter.annotation
-            for parameter in (*http_parameters, dispatcher_parameter)
-        },
-        "return": signature.return_annotation,
-    }
-    setattr(endpoint, _ROUTE_SOURCE_ATTRIBUTE, source)
-    setattr(
-        endpoint,
-        _INVOCATION_IDENTITY_ATTRIBUTE,
-        _ApplicationServiceRouteIdentity(service, method),
-    )
-    return endpoint
-
-
-def _route_projection(
-    method: object, override: ApplicationServiceRouteOverride | None
-) -> tuple[dict[str, Any], dict[str, str]]:
-    projection = dict(_metadata(method))
-    provenance = {key: "method" for key in projection}
-    if override is not None:
-        from dataclasses import fields
-
-        for field in fields(override):
-            if field.name in ("service", "method", "enabled"):
-                continue
-            value = getattr(override, field.name)
-            if value is not None:
-                projection[field.name] = value
-                provenance[field.name] = "module_override"
-    return projection, provenance
-
-
 def _exposure_targets(
     http_descriptor: ModuleDescriptor,
     exposure: _ApplicationServiceExposure,