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

python_ddd_framework/sqlalchemy/alembic_runtime/env.py

@@ -23,6 +23,7 @@ context.configure(
     target_metadata=target_metadata,
     include_schemas=True,
     include_name=config.attributes.get("include_name"),
+    include_object=config.attributes.get("include_object"),
     **version_table_options,
 )
 with context.begin_transaction():

python_ddd_framework/sqlalchemy/auditing.py

@@ -39,7 +39,13 @@ def _apply_audit_fields(session: Session, flush_context: object, instances: obje
             entity.created_at = now
             entity.created_by = user_id
     for entity in tuple(session.dirty):
-        if isinstance(entity, AuditedEntityMixin) and entity not in session.new:
+        # merge 或相同值赋值也会标记 dirty；审计不能把无净变化的实体变成一次更新。
+        # 保留集合变化，和仓储更新事件使用相同的原生变更判定。
+        if (
+            isinstance(entity, AuditedEntityMixin)
+            and entity not in session.new
+            and session.is_modified(entity)
+        ):
             entity.updated_at = now
             entity.updated_by = user_id
 

python_ddd_framework/sqlalchemy/extensions.py

@@ -0,0 +1,186 @@
+"""扩展字段的原生列映射、应用私有 mapper 及持久化边界。"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Generic, TypeVar, get_args
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+from pydantic_core import to_json
+from sqlalchemy import Column, MetaData, Table, inspect
+from sqlalchemy.orm import registry
+from sqlalchemy.schema import SchemaItem
+
+from ..extensions import ExtensionCatalog, ExtensionProperties, ExtensionTarget, ModelExtension
+from ..modularity import ModuleDeclaration, ModuleKey, ModuleRef
+
+_T = TypeVar("_T")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionColumn:
+    """引用契约的原生字段身份；列工厂留在消费者 persistence Module。"""
+
+    field: FieldInfo
+    factory: Callable[[], SchemaItem]
+
+
+@dataclass(frozen=True, slots=True)
+class SqlAlchemyModelExtension(ModelExtension):
+    columns: tuple[ExtensionColumn, ...] = ()
+
+    @property
+    def required_module(self) -> ModuleRef:
+        return ModuleRef("python_ddd_framework.sqlalchemy.module:SqlAlchemyPersistenceModule")
+
+
+@dataclass(frozen=True, slots=True)
+class SqlAlchemyExtensionMapping:
+    target: ExtensionTarget
+    table: Table
+    model_base: type[object]
+
+
+@dataclass(frozen=True, slots=True)
+class SqlAlchemyExtensionMigrations(ModuleDeclaration):
+    migrations_package: str
+    branch_label: str
+    depends_on: tuple[str, ...]
+    connection_name: str = "default"
+
+    @property
+    def required_module(self) -> ModuleRef:
+        return ModuleRef("python_ddd_framework.sqlalchemy.module:SqlAlchemyPersistenceModule")
+
+
+@dataclass(frozen=True, slots=True)
+class _ExtensionColumn:
+    owner: ModuleKey
+    field_name: str
+    column: Column[object]
+
+
+class SqlAlchemyExtensionModel(Generic[_T]):
+    """一处有效 row 映射；模型、读写和迁移范围引用相同列对象。"""
+
+    def __init__(
+        self,
+        model: type[_T],
+        target: ExtensionTarget,
+        catalog: ExtensionCatalog,
+        columns: tuple[_ExtensionColumn, ...],
+    ) -> None:
+        self.model = model
+        self.target = target
+        self.columns = columns
+        self._catalog = catalog
+
+    def read(self, row: _T) -> ExtensionProperties:
+        if not isinstance(row, self.model):
+            raise TypeError("row belongs to a different Application's mapper")
+        stored = getattr(row, "extra_properties")  # noqa: B009 - 原生 mapper 的动态属性边界
+        if not isinstance(stored, dict):
+            raise TypeError("extra_properties must be a JSON object")
+        values = dict(stored)
+        for mapping in self.columns:
+            if mapping.field_name in values:
+                raise ValueError("mapped extension field cannot also be stored in JSON")
+            values[mapping.field_name] = getattr(row, mapping.column.key)
+        return self._catalog.property_model(self.target).model_validate_json(to_json(values))
+
+    def write(self, row: _T, properties: ExtensionProperties) -> None:
+        if not isinstance(row, self.model):
+            raise TypeError("row belongs to a different Application's mapper")
+        effective = self._catalog.properties(self.target, properties)
+        values = effective.model_dump(mode="json")
+        for mapping in self.columns:
+            setattr(row, mapping.column.key, getattr(effective, mapping.field_name))
+            del values[mapping.field_name]
+        setattr(row, "extra_properties", values)  # noqa: B010 - 原生 mapper 的动态属性边界
+
+
+def _map_extensions(
+    metadata: MetaData,
+    mappings: tuple[SqlAlchemyExtensionMapping, ...],
+    catalog: ExtensionCatalog,
+) -> tuple[MetaData, tuple[SqlAlchemyExtensionModel[object], ...]]:
+    # 这份 metadata 就是运行时和迁移共同消费的有效模型；不为差异过滤另复制表。
+    mapper_registry = registry(metadata=MetaData(naming_convention=metadata.naming_convention))
+    native_base = mapper_registry.generate_base()
+    for table in metadata.sorted_tables:
+        table.to_metadata(mapper_registry.metadata)
+    models: list[SqlAlchemyExtensionModel[object]] = []
+    for mapping in mappings:
+        catalog.property_model(mapping.target)
+        if any(model.target is mapping.target for model in models):
+            raise ValueError("an extension target has only one ORM mapping")
+        if mapping.table.metadata is not metadata or inspect(mapping.model_base, raiseerr=False):
+            raise ValueError("extension mapping requires an owned table and an unmapped model base")
+        table = mapper_registry.metadata.tables[mapping.table.key]
+        if "extra_properties" not in table.c:
+            raise ValueError("the base table must own its extra_properties JSON container")
+        columns = _columns_for_target(mapping.target, table, catalog)
+        model = type(
+            mapping.model_base.__name__, (mapping.model_base, native_base), {"__table__": table}
+        )
+        assert issubclass(model, mapping.model_base)
+        models.append(SqlAlchemyExtensionModel(model, mapping.target, catalog, columns))
+    return mapper_registry.metadata, tuple(models)
+
+
+def _columns_for_target(
+    target: ExtensionTarget,
+    table: Table,
+    catalog: ExtensionCatalog,
+) -> tuple[_ExtensionColumn, ...]:
+    columns: list[_ExtensionColumn] = []
+    for contribution in catalog.contributions:
+        if contribution.declaration.target is not target:
+            continue
+        declaration = contribution.declaration
+        if not isinstance(declaration, SqlAlchemyModelExtension):
+            continue
+        fields = {id(field): name for name, field in declaration.properties.model_fields.items()}
+        mapped: set[str] = set()
+        for storage in declaration.columns:
+            name = fields.get(id(storage.field))
+            if name is None or name in mapped:
+                raise ValueError(
+                    "column mapping must reference a unique field of its property schema"
+                )
+            mapped.add(name)
+            column = _validate_column(storage.factory(), name, storage.field.annotation, table)
+            table.append_column(column)
+            columns.append(_ExtensionColumn(contribution.owner, name, column))
+    return tuple(columns)
+
+
+def _validate_column(column: object, name: str, annotation: object, table: Table) -> Column[object]:
+    if not isinstance(column, Column) or getattr(column, "table", None) is not None:
+        raise TypeError("extension column factory must return a fresh unattached Column")
+    if (
+        column.primary_key
+        or column.foreign_keys
+        or (column.unique and not column.index)
+        or column.constraints
+    ):
+        raise ValueError("extension mapping only owns standalone columns and indexes")
+    column_name = column.name or name
+    if not column_name.isidentifier() or column_name in table.c:
+        raise ValueError(
+            "extension column conflicts with an existing column or has an invalid name"
+        )
+    if column.key and column.key != column_name:
+        raise ValueError("extension column key must match its name")
+    candidates = get_args(annotation) or (annotation,)
+    if column.type.python_type not in candidates:
+        raise TypeError("extension column Python type does not match the property schema")
+    if column.nullable and type(None) not in candidates:
+        raise ValueError("nullable extension columns require an optional property type")
+    if any(isinstance(item, type) and issubclass(item, BaseModel) for item in candidates):
+        raise TypeError("nested Pydantic properties use JSON storage")
+    column.name = column_name
+    column.key = column_name
+    return column

python_ddd_framework/sqlalchemy/metadata.py

@@ -4,18 +4,29 @@ from __future__ import annotations
 
 import importlib.util
 from collections.abc import Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
-from typing import TypeVar
+from typing import TypeVar, cast
 
 from sqlalchemy import Constraint, ForeignKey, MetaData, Table
 
+from ..extensions import ExtensionCatalog, ExtensionTarget
+from ..extensions.module import ExtensionsModule
 from ..modularity import AppModule, ModuleDescriptor, ModuleKey, ModuleRegistry
 from ..modularity.discovery import _import_package_modules
 from ..options import OptionsSnapshot
 from .errors import SqlAlchemyMetadataChangedError, SqlAlchemyModelRegistrationError
+from .extensions import (
+    SqlAlchemyExtensionMapping,
+    SqlAlchemyExtensionMigrations,
+    SqlAlchemyExtensionModel,
+    SqlAlchemyModelExtension,
+    _map_extensions,
+)
 from .options import _validate_connection_name
 
+_TRow = TypeVar("_TRow")
+
 _MODEL_REGISTRATIONS_ATTRIBUTE = "__python_ddd_framework_sqlalchemy_model_registrations__"
 _MIGRATION_REGISTRATIONS_ATTRIBUTE = "__python_ddd_framework_sqlalchemy_migration_registrations__"
 _TModule = TypeVar("_TModule", bound=type[AppModule])
@@ -27,6 +38,7 @@ class SqlAlchemyModelRegistration:
     migrations_package: str
     branch_label: str
     connection_name: str = "default"
+    extension_mappings: tuple[SqlAlchemyExtensionMapping, ...] = ()
     _declared_fingerprint: tuple[object, ...] = field(init=False, repr=False, compare=False)
 
     @classmethod
@@ -38,6 +50,7 @@ class SqlAlchemyModelRegistration:
         migrations_package: str,
         branch_label: str,
         connection_name: str = "default",
+        extension_mappings: tuple[SqlAlchemyExtensionMapping, ...] = (),
     ) -> SqlAlchemyModelRegistration:
         if not isinstance(models_package, str) or not models_package:
             raise ValueError("models_package must be a non-empty import path")
@@ -50,7 +63,7 @@ class SqlAlchemyModelRegistration:
             raise ValueError("models_package must identify a package")
         # Declarative class 导入会写入原生 MetaData，必须早于构造时的指纹冻结。
         _import_package_modules(models_package)
-        return cls(metadata, migrations_package, branch_label, connection_name)
+        return cls(metadata, migrations_package, branch_label, connection_name, extension_mappings)
 
     def __post_init__(self) -> None:
         if not isinstance(self.metadata, MetaData):
@@ -123,10 +136,17 @@ class _SqlAlchemyMigrationSource:
     migrations_package: str
     branch_label: str
     migration_path: Path
+    extension: SqlAlchemyExtensionMigrations | None = None
 
 
 class SqlAlchemyModelCatalog:
-    __slots__ = ("_contributions", "_migration_contributions", "_migration_declarations")
+    __slots__ = (
+        "_contributions",
+        "_migration_contributions",
+        "_migration_declarations",
+        "extension_models",
+        "extension_sources",
+    )
 
     def __init__(
         self,
@@ -139,6 +159,16 @@ class SqlAlchemyModelCatalog:
         self._contributions = contributions
         self._migration_contributions = migration_contributions
         self._migration_declarations = migration_declarations
+        self.extension_models: tuple[SqlAlchemyExtensionModel[object], ...] = ()
+        self.extension_sources: tuple[_SqlAlchemyMigrationSource, ...] = ()
+
+    def extension_model(
+        self, target: ExtensionTarget, model_base: type[_TRow]
+    ) -> SqlAlchemyExtensionModel[_TRow]:
+        for model in self.extension_models:
+            if model.target is target and issubclass(model.model, model_base):
+                return cast(SqlAlchemyExtensionModel[_TRow], model)
+        raise ValueError("extension persistence mapping is not registered")
 
     @property
     def contributions(self) -> tuple[SqlAlchemyModelContribution, ...]:
@@ -152,6 +182,9 @@ class SqlAlchemyModelCatalog:
     def connection_names(self) -> tuple[str, ...]:
         names = {item.registration.connection_name for item in self._contributions}
         names.update(item.registration.connection_name for item in self._migration_contributions)
+        names.update(
+            item.extension.connection_name for item in self.extension_sources if item.extension
+        )
         return tuple(name for name in ("default", *sorted(names - {"default"})) if name in names)
 
     def for_connection(
@@ -196,7 +229,15 @@ class SqlAlchemyModelCatalog:
             )
             for item in self.migrations_for_connection(connection_name)
         )
-        return (*model_sources, *external_sources)
+        return (
+            *model_sources,
+            *external_sources,
+            *(
+                item
+                for item in self.extension_sources
+                if item.extension and item.extension.connection_name == connection_name
+            ),
+        )
 
     def _assert_unchanged(self) -> None:
         for contribution in self._contributions:
@@ -257,7 +298,70 @@ def _build_model_catalog(
     builder = _SqlAlchemyModelCatalogBuilder(options)
     for descriptor in registry.dependency_order:
         builder.add_module(descriptor)
-    return builder.build()
+    catalog = builder.build()
+    effective: list[SqlAlchemyModelContribution] = []
+    extension_models: list[SqlAlchemyExtensionModel[object]] = []
+    for contribution in catalog.contributions:
+        registration = contribution.registration
+        if registration.extension_mappings:
+            metadata, models = _map_extensions(
+                registration.metadata,
+                registration.extension_mappings,
+                registry.instance(ExtensionsModule).catalog,
+            )
+            extension_models.extend(models)
+            registration = replace(registration, metadata=metadata)
+        effective.append(replace(contribution, registration=registration))
+    catalog._contributions = tuple(effective)
+    catalog.extension_models = tuple(extension_models)
+    sources: list[_SqlAlchemyMigrationSource] = []
+    for owner, declaration in registry.declarations(SqlAlchemyExtensionMigrations):
+        _validate_connection_name(declaration.connection_name)
+        if not declaration.depends_on or not all(
+            isinstance(item, str) and item.strip() == item and item
+            for item in declaration.depends_on
+        ):
+            raise ValueError("extension migrations require explicit base revision dependencies")
+        builder._claim_branch(declaration.branch_label, owner.key)
+        sources.append(
+            _SqlAlchemyMigrationSource(
+                owner.key,
+                declaration.migrations_package,
+                declaration.branch_label,
+                _migration_package_path(declaration.migrations_package, owner=owner.key),
+                declaration,
+            )
+        )
+    catalog.extension_sources = tuple(sources)
+    _validate_extension_models(catalog, registry.instance(ExtensionsModule).catalog)
+    return catalog
+
+
+def _validate_extension_models(
+    catalog: SqlAlchemyModelCatalog, extensions: ExtensionCatalog
+) -> None:
+    if len({model.target for model in catalog.extension_models}) != len(catalog.extension_models):
+        raise ValueError("an extension target has only one ORM mapping")
+    for item in extensions.contributions:
+        if isinstance(item.declaration, SqlAlchemyModelExtension) and not any(
+            model.target is item.declaration.target for model in catalog.extension_models
+        ):
+            raise ValueError("SQL extension requires exactly one registered ORM target")
+    for model in catalog.extension_models:
+        for column in model.columns:
+            source = next(
+                (item for item in catalog.extension_sources if item.owner == column.owner), None
+            )
+            if source is None:
+                raise ValueError("mapped extension columns require an owning migration declaration")
+            base = next(
+                item
+                for item in catalog.contributions
+                if column.column.table in item.registration.metadata.tables.values()
+            )
+            assert source.extension is not None
+            if source.extension.connection_name != base.registration.connection_name:
+                raise ValueError("extension migration and base table must share a connection")
 
 
 class _SqlAlchemyModelCatalogBuilder:

python_ddd_framework/sqlalchemy/migration.py

@@ -28,7 +28,7 @@ from .errors import (
     SqlAlchemyMigrationError,
     SqlAlchemyModelRegistrationError,
 )
-from .metadata import SqlAlchemyModelCatalog, _build_model_catalog
+from .metadata import SqlAlchemyModelCatalog, _SqlAlchemyMigrationSource
 from .migration_options import SqlAlchemyMigrationOptions
 from .module_migration import _ModuleMigration
 from .options import ConnectionStringsOptions
@@ -51,7 +51,9 @@ class SqlAlchemyMigrator:
                 "SqlAlchemyMigrator requires composed Application, "
                 f"got {self._application.state.value}"
             )
-        models = _build_model_catalog(self._application.modules, self._application.options)
+        from .module import SqlAlchemyPersistenceModule
+
+        models = self._application.modules.instance(SqlAlchemyPersistenceModule).catalog
         models._assert_unchanged()
         return models
 
@@ -88,8 +90,10 @@ class SqlAlchemyMigrator:
     ) -> tuple[str, ...]:
         models = self.model_catalog
         owner = ModuleKey(module.__module__, module.__qualname__) if module is not None else None
-        if module_operation is _ModuleMigration.revision and not any(
-            item.owner == owner for item in models.contributions
+        if (
+            module_operation is _ModuleMigration.revision
+            and not any(item.owner == owner for item in models.contributions)
+            and not any(item.owner == owner for item in models.extension_sources)
         ):
             raise SqlAlchemyModelRegistrationError(
                 owner=str(owner), reason="revision requires a Module with registered ORM models"
@@ -111,9 +115,11 @@ class SqlAlchemyMigrator:
                 completed.append(connection_name)
                 continue
             config = _alembic_config(models, connection_name, self._application.options)
-            execution_options = self._application.options.get(BackgroundExecutionOptions)
+            # 未选择后台能力就没有执行资源；不能为了迁移强制引入整个后台模块。
             config.attributes["background_execution_disabled"] = (
-                execution_options.profile is BackgroundExecutionProfile.DISABLED
+                BackgroundExecutionOptions not in self._application.options.values
+                or self._application.options.get(BackgroundExecutionOptions).profile
+                is BackgroundExecutionProfile.DISABLED
             )
             _validate_revision_graph(
                 models,
@@ -323,8 +329,11 @@ def _validate_revision_graph(
 ) -> None:
     migration_sources = models._migration_sources_for_connection(connection_name)
     # walk_revisions 强制 Alembic 在任何 engine 创建前加载并校验组合 graph/depends_on。
-    revisions = tuple(ScriptDirectory.from_config(config).walk_revisions())
+    script = ScriptDirectory.from_config(config)
+    revisions = tuple(script.walk_revisions())
     for source in migration_sources:
+        if source.extension is not None:
+            _validate_extension_prerequisites(models, connection_name, source, script)
         owned_revisions = tuple(
             revision
             for revision in revisions
@@ -352,6 +361,50 @@ def _validate_revision_graph(
                         f"{actual_labels!r}, expected {(source.branch_label,)!r}"
                     ),
                 )
+        if source.extension is not None and not (allow_empty and source.owner == owner):
+            # 声明约束当前分支的每个 head；历史 revision 保留当时的 depends_on。
+            # revision 命令允许在已应用新前置后，为所选 owner 追加满足新声明的 revision。
+            for head in script.get_revisions(f"{source.branch_label}@heads"):
+                ancestry = {
+                    item.revision
+                    for item in script.iterate_revisions(head.revision, "base", implicit_base=True)
+                }
+                if not set(source.extension.depends_on) <= ancestry:
+                    raise ValueError("extension revision is missing required Alembic depends_on")
+
+
+def _validate_extension_prerequisites(
+    models: SqlAlchemyModelCatalog,
+    connection_name: str,
+    source: _SqlAlchemyMigrationSource,
+    script: ScriptDirectory,
+) -> None:
+    assert source.extension is not None
+    prerequisites = tuple(script.get_revision(item) for item in source.extension.depends_on)
+    if any(
+        item is None or item.revision != requested
+        for item, requested in zip(prerequisites, source.extension.depends_on, strict=True)
+    ):
+        raise ValueError("extension depends_on must name exact existing base revisions")
+    # 必须覆盖被扩展表的真实基础迁移 owner；运行时 Module 图不参与判断。
+    base_paths = {
+        contribution.migration_path
+        for contribution in models.for_connection(connection_name)
+        if any(
+            column.owner == source.owner
+            and column.column.table in contribution.registration.metadata.tables.values()
+            for model in models.extension_models
+            for column in model.columns
+        )
+    }
+    ancestor_paths = {
+        Path(item.path).resolve().parent
+        for item in script.iterate_revisions(
+            source.extension.depends_on, "base", implicit_base=True
+        )
+    }
+    if not base_paths <= ancestor_paths:
+        raise ValueError("extension depends_on does not cover its base table migrations")
 
 
 def _upgrade_heads(connection: Connection, config: Config, connection_name: str) -> None:
@@ -369,7 +422,7 @@ def _check_current_heads(connection: Connection, config: Config, connection_name
             ).get_current_heads()
         )
     )
-    expected = tuple(sorted(script.get_heads()))
+    expected = tuple(sorted(script.get_heads(consider_depends_on=True)))
     if current != expected:
         raise MigrationHeadsMismatchError(
             connection_name=connection_name,

python_ddd_framework/sqlalchemy/migration_operations.py

@@ -0,0 +1,86 @@
+"""从正式扩展 metadata 推导 Alembic 操作的列／索引所有权。"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+from alembic.operations import ops
+from sqlalchemy import Column
+
+
+class _MigrationOperations:
+    def __init__(self, columns: Iterable[Column[Any]], *, extension: bool) -> None:
+        columns = tuple(columns)
+        self._columns = {
+            (column.table.schema, column.table.name, column.name)
+            for column in columns
+            if column.table is not None
+        }
+        self._indexes = {
+            (column.table.schema, column.table.name, index.name)
+            for column in columns
+            if column.table is not None
+            for index in column.table.indexes
+            if index.columns
+            and all(
+                (column.table.schema, column.table.name, item.name) in self._columns
+                for item in index.columns
+            )
+        }
+        self._extension = extension
+
+    def column(self, schema: str | None, table: str, name: str | None) -> bool:
+        selected = (schema, table, name) in self._columns
+        return selected if self._extension else not selected
+
+    def index(self, schema: str | None, table: str, name: str | None) -> bool:
+        selected = (schema, table, name) in self._indexes
+        return selected if self._extension else not selected
+
+    def restrict(self, container: ops.OpContainer) -> None:
+        retained: list[ops.MigrateOperation] = []
+        for operation in container.ops:
+            if isinstance(operation, ops.OpContainer):
+                self.restrict(operation)
+                if operation.ops:
+                    retained.append(operation)
+            else:
+                selected = self._operation(operation)
+                if selected is not None:
+                    retained.append(selected)
+        container.ops = retained
+
+    def _operation(self, operation: ops.MigrateOperation) -> ops.MigrateOperation | None:
+        if isinstance(operation, (ops.CreateTableOp, ops.DropTableOp)):
+            if self._extension:
+                raise ValueError("extension revisions cannot create or remove a base table")
+            return self._base_table(operation)
+        if isinstance(operation, (ops.AddColumnOp, ops.AlterColumnOp, ops.DropColumnOp)):
+            name = (
+                operation.column.name
+                if isinstance(operation, ops.AddColumnOp)
+                else operation.column_name
+            )
+            return operation if self.column(operation.schema, operation.table_name, name) else None
+        if isinstance(operation, (ops.CreateIndexOp, ops.DropIndexOp)):
+            return (
+                operation
+                if operation.table_name is not None
+                and self.index(operation.schema, operation.table_name, operation.index_name)
+                else None
+            )
+        # 表注释等 table comparator 不经过 include_object；扩展只有列和索引的权利。
+        return None if self._extension else operation
+
+    def _base_table(self, operation: ops.CreateTableOp | ops.DropTableOp) -> ops.MigrateOperation:
+        created = operation.reverse() if isinstance(operation, ops.DropTableOp) else operation
+        # 原生 CreateTableOp 包含内联列，不会逐列执行 include_object。只重写 operation，
+        # 不复制／改写作为迁移权威的 Table 或 MetaData。
+        created.columns = [
+            item
+            for item in created.columns
+            if not isinstance(item, Column)
+            or self.column(created.schema, created.table_name, item.name)
+        ]
+        return created.reverse() if isinstance(operation, ops.DropTableOp) else created

python_ddd_framework/sqlalchemy/module.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 from dishka import Provider, Scope
 
+from ..events.module import LocalEventsModule
+from ..extensions.module import ExtensionsModule
 from ..lifecycle import ConfigureContext, InitializeContext
-from ..modularity import AppModule, ModuleRegistry
-from ..options import OptionsSnapshot
+from ..modularity import AppModule
+from ..services.composition import ServiceBindingContext, ServiceComposition
 from ..unit_of_work.contracts import _UnitOfWorkFactory
 from .metadata import SqlAlchemyModelCatalog, _build_model_catalog
 from .migration_options import SqlAlchemyMigrationOptions
@@ -20,6 +22,9 @@ from .unit_of_work import _SqlAlchemyUnitOfWorkFactory
 
 
 class SqlAlchemyPersistenceModule(AppModule):
+    dependencies = (LocalEventsModule, ExtensionsModule)
+    catalog: SqlAlchemyModelCatalog
+
     def configure(self, context: ConfigureContext) -> None:
         context.configure(
             ConnectionStringsOptions,
@@ -28,11 +33,7 @@ class SqlAlchemyPersistenceModule(AppModule):
         )
         context.configure(SqlAlchemyMigrationOptions, section="sqlalchemy_migrations")
         provider = Provider()
-        provider.provide(
-            _model_catalog,
-            provides=SqlAlchemyModelCatalog,
-            scope=Scope.APP,
-        )
+        context.services.add_composition(ServiceComposition(bind=self._bind))
         provider.provide(
             _engine_registry,
             provides=_SqlAlchemyEngineRegistry,
@@ -42,10 +43,12 @@ class SqlAlchemyPersistenceModule(AppModule):
         provider.provide(SqlAlchemySessionProvider, scope=Scope.APP)
         context.services.contribute(provider, reason="SQLAlchemy PostgreSQL persistence boundary")
 
+    def _bind(self, context: ServiceBindingContext) -> None:
+        self.catalog = _build_model_catalog(context.modules, context.options)
+        provider = Provider()
+        provider.provide(lambda: self.catalog, provides=SqlAlchemyModelCatalog, scope=Scope.APP)
+        context.add_provider(provider)
+
     async def initialize(self, context: InitializeContext) -> None:
         engines = await context.container.get(_SqlAlchemyEngineRegistry)
         await engines.ping_all()
-
-
-def _model_catalog(registry: ModuleRegistry, options: OptionsSnapshot) -> SqlAlchemyModelCatalog:
-    return _build_model_catalog(registry, options)