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

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/http_api/routers/order_files.py.jinja

@@ -1,76 +0,0 @@
-import asyncio
-import hashlib
-import logging
-from collections.abc import AsyncIterator
-from typing import Annotated
-from uuid import UUID
-
-from fastapi import File, Form, UploadFile
-from modules.{{ cookiecutter.module_name }}.application_contracts.inputs.create_order import CreateOrder
-from modules.{{ cookiecutter.module_name }}.application_contracts.services.order_management_service import (
-    {{ cookiecutter.class_prefix }}ManagementApplicationService,
-)
-from modules.{{ cookiecutter.module_name }}.application_contracts.services.order_query_service import (
-    {{ cookiecutter.class_prefix }}QueryApplicationService,
-)
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-from modules.{{ cookiecutter.module_name }}.domain_shared.permissions.order_permissions import (
-    ORDERS_READ,
-    ORDERS_WRITE,
-)
-from modules.{{ cookiecutter.module_name }}.http_api.filters.export_filter import ExportFilter
-from starlette.responses import Response, StreamingResponse
-
-from python_ddd_framework.authorization import authorize
-from python_ddd_framework.fastapi import HttpRouter, service_filter
-
-router = HttpRouter(use_api_prefix=True, prefix=f"/{MODULE_NAME}/files", permissions=(ORDERS_READ,))
-
-
-@router.post("/upload", status_code=201)
-@authorize(ORDERS_WRITE)
-async def upload(
-    service: {{ cookiecutter.class_prefix }}ManagementApplicationService,
-    title: Annotated[str, Form()],
-    file: Annotated[UploadFile, File()],
-) -> dict[str, object]:
-    # 接口扩展：在这里解析上传内容并组装业务命令，交给应用服务处理；当前只演示创建订单及计算摘要。
-    # File/Form 使用框架读取期限额及原生 parser；UploadFile 资源由 REQUEST 关闭。
-    content = await file.read()
-    order = await service.create(CreateOrder(title=title))
-    return {
-        "order": order.model_dump(mode="json"),
-        "bytes": len(content),
-        "sha256": hashlib.sha256(content).hexdigest(),
-    }
-
-
-@router.get("/{id}/download")
-@service_filter(ExportFilter)
-async def download(id: UUID, service: {{ cookiecutter.class_prefix }}QueryApplicationService) -> Response:
-    # 接口扩展：通过服务查询已授权的数据后，在这里转换为实际下载格式、文件名和媒体类型。
-    order = await service.get(id)
-    return Response(
-        order.model_dump_json(),
-        media_type="application/json",
-        headers={"Content-Disposition": f'attachment; filename="{id}.json"'},
-    )
-
-
-@router.get("/export/stream")
-@service_filter(ExportFilter)
-async def export(service: {{ cookiecutter.class_prefix }}QueryApplicationService) -> StreamingResponse:
-    # 接口扩展：这里准备导出数据，下面的 producer 负责编码输出；不要让业务事务跨越网络发送。
-    orders = await service.get_list()
-
-    async def produce() -> AsyncIterator[bytes]:
-        # 输出扩展：将 JSON 行替换为实际流格式；大数据分批读取须各自完成短 UoW 后再 yield。
-        try:
-            for order in orders:
-                yield (order.model_dump_json() + "\n").encode()
-                await asyncio.sleep(0)
-        finally:
-            # 此示例只持有不可变 DTO，无悬挂 Session／文件；扩展外部资源时在此 shield 异步关闭。
-            logging.getLogger(__name__).info("Order export producer closed")
-
-    return StreamingResponse(produce(), media_type="application/x-ndjson")

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/http_api/websockets/order_socket.py.jinja

@@ -1,44 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends
-from modules.{{ cookiecutter.module_name }}.application_contracts.services.order_query_service import (
-    {{ cookiecutter.class_prefix }}QueryApplicationService,
-)
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-from modules.{{ cookiecutter.module_name }}.domain_shared.messages.order_messages import (
-    OrderSnapshotItem,
-    OrderSnapshotMessage,
-)
-from modules.{{ cookiecutter.module_name }}.http_api.models.refresh_orders import RefreshOrders
-from starlette.websockets import WebSocketDisconnect
-
-from python_ddd_framework import FrameworkError
-from python_ddd_framework.fastapi import WebSocketConnection, websocket_connection
-
-router = APIRouter()
-
-
-@router.websocket(f"/ws/{MODULE_NAME}")
-async def orders_socket(
-    connection: Annotated[WebSocketConnection, Depends(websocket_connection)],
-) -> None:
-    # 接口扩展：这里定义“查询快照 → 发送消息 → 接收下一条命令”的交互，替换消息 DTO 和业务调用。
-    # 每次业务操作仍经 connection.invoke 进入授权/事务管线，不在连接期间保留 Session 或聚合实例。
-    try:
-        while True:
-            orders = await connection.invoke({{ cookiecutter.class_prefix }}QueryApplicationService.get_list)
-            await connection.send(
-                OrderSnapshotMessage(
-                    orders=tuple(
-                        OrderSnapshotItem(
-                            id=item.id, title=item.title, status=item.status, version=item.version
-                        )
-                        for item in orders
-                    )
-                ),
-            )
-            await connection.receive(RefreshOrders)
-    except WebSocketDisconnect:
-        return
-    except FrameworkError as error:
-        await connection.send_problem(error)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/sqlalchemy/models/order_model.py.jinja

@@ -1,29 +0,0 @@
-"""修改模型后显式生成并审查迁移，不在 Host 启动时建表。"""
-
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import (
-    MODULE_NAME,
-    TITLE_MAX_LENGTH,
-)
-from modules.{{ cookiecutter.module_name }}.domain_shared.enums.order_status import OrderStatus
-from modules.{{ cookiecutter.module_name }}.sqlalchemy.models.base import {{ cookiecutter.class_prefix }}Base
-from sqlalchemy import Integer, String, Uuid
-from sqlalchemy.orm import Mapped, mapped_column
-
-from python_ddd_framework.sqlalchemy import AuditedEntityMixin
-
-
-class OrderRow(AuditedEntityMixin, {{ cookiecutter.class_prefix }}Base):
-    __tablename__ = MODULE_NAME
-    id: Mapped[UUID] = mapped_column(Uuid, primary_key=True)
-    title: Mapped[str] = mapped_column(String(TITLE_MAX_LENGTH), nullable=False)
-    status: Mapped[str] = mapped_column(
-        String(max(len(item.value) for item in OrderStatus)), nullable=False
-    )
-    version: Mapped[int] = mapped_column(Integer, nullable=False)
-    # SQLAlchemy 以行版本检查并发；聚合暂存版本与数据库提交版本保持一致。
-    __mapper_args__ = {  # noqa: RUF012 -- SQLAlchemy 原生声明属性，基类不允许 ClassVar。
-        "version_id_col": version,
-        "version_id_generator": False,
-    }

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/sqlalchemy/repositories/order_repository.py.jinja

@@ -1,81 +0,0 @@
-"""仓储参与当前 UoW，成功暂存后由 operation 收集聚合事件。"""
-
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.domain.entities.order import Order
-from modules.{{ cookiecutter.module_name }}.domain.repositories.order_repository import OrderRepository
-from modules.{{ cookiecutter.module_name }}.domain.value_objects.order_title import OrderTitle
-from modules.{{ cookiecutter.module_name }}.domain_shared.enums.order_status import OrderStatus
-from modules.{{ cookiecutter.module_name }}.sqlalchemy.models.order_model import OrderRow
-
-from python_ddd_framework import (
-    OptimisticConcurrencyError, ResourceNotFoundError, EntityCreatedEvent, EntityUpdatedEvent,
-)
-from python_ddd_framework.sqlalchemy import SqlAlchemyRepository, SqlAlchemySessionProvider
-
-
-class _OrderRows(SqlAlchemyRepository[OrderRow, UUID]):
-    def _default_sorting(self) -> str:
-        return "created_at"
-
-
-class SqlAlchemyOrderRepository(OrderRepository):
-    def __init__(self, provider: SqlAlchemySessionProvider) -> None:
-        self._provider = provider
-        self._rows = _OrderRows(provider, OrderRow)
-
-    async def find(self, id: UUID, include_details: bool = True) -> Order | None:
-        # 持久化扩展：这里查询本模块的表，再通过显式映射重建聚合；业务判断留给聚合/应用服务。
-        async with self._provider.operation("get"):
-            row = await self._rows.find(id, include_details)
-            return None if row is None else _order(row)
-
-    async def get(self, id: UUID, include_details: bool = True) -> Order:
-        order = await self.find(id, include_details)
-        if order is None:
-            raise ResourceNotFoundError("Order not found")
-        return order
-
-    async def get_list(self, include_details: bool = False) -> list[Order]:
-        async with self._provider.operation("get_list"):
-            return [_order(row) for row in await self._rows.get_list(include_details)]
-
-    async def get_count(self) -> int:
-        return await self._rows.get_count()
-
-    async def get_paged_list(self, skip_count: int, max_result_count: int,
-                             sorting: str | None = None, include_details: bool = False) -> list[Order]:
-        async with self._provider.operation("get_paged_list"):
-            rows = await self._rows.get_paged_list(
-                skip_count, max_result_count, sorting, include_details
-            )
-            return [_order(row) for row in rows]
-
-    async def save(self, order: Order) -> None:
-        # 持久化扩展：把自己的聚合字段/子实体映射到 ORM；下面的版本核对和事件收集边界要保留。
-        # 这里只暂存改动，不自行 commit，避免绕开调用者的工作单元。
-        async with self._provider.operation(
-            "save", aggregate=order,
-            entity_event=EntityCreatedEvent(order) if order.version == 0 else EntityUpdatedEvent(order),
-        ):
-            session = await self._provider.get_session()
-            row = await session.get(OrderRow, order.id)
-            if row is None:
-                if order.version:
-                    raise OptimisticConcurrencyError
-                row = OrderRow(id=order.id)
-                session.add(row)
-            elif row.version != order.version:
-                raise OptimisticConcurrencyError
-            order.stage_next_version(order.version)
-            # 新增持久字段的赋值写在这里，同时修改模型、下方读取映射并生成迁移。
-            row.title, row.status, row.version = order.title, order.status.value, order.version
-
-
-def _order(row: OrderRow) -> Order:
-    # 映射扩展：在这里把数据库字段恢复成领域实体/值对象，不调用会再次产生创建事件的工厂。
-    # 驱动的 UUID 子类在边界恢复为原生 UUID，聚合事件只持有稳定领域值。
-    return Order(
-        UUID(bytes=row.id.bytes), OrderTitle(value=row.title),
-        status=OrderStatus(row.status), version=row.version
-    )

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/tests/test_domain.py.jinja

@@ -1,19 +0,0 @@
-"""模块内领域验收，不随生产 wheel 打包或参与服务扫描。"""
-
-from uuid import uuid4
-
-import pytest
-from modules.{{ cookiecutter.module_name }}.domain.entities.order import Order
-from modules.{{ cookiecutter.module_name }}.domain.value_objects.order_title import OrderTitle
-from modules.{{ cookiecutter.module_name }}.domain_shared.enums.order_status import OrderStatus
-
-from python_ddd_framework.errors import BusinessError
-
-
-def test_order_approval_rejects_repeat():
-    order = Order.create(uuid4(), OrderTitle(value="Example order"))
-    order.approve()
-    assert order.status is OrderStatus.APPROVED
-    assert len(order.release_local_events()) == 2
-    with pytest.raises(BusinessError):
-        order.approve()