wexample-orm 1.3.3__tar.gz → 1.4.0__tar.gz

{wexample_orm-1.3.3 → wexample_orm-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-orm
-Version: 1.3.3
+Version: 1.4.0
 Summary: Provides SQLAlchemy ORM abstractions — base entity, repository, session factory, and repository manager — with PostgreSQL-first defaults via psycopg
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -12,7 +12,7 @@ Requires-Python: >=3.10
 Requires-Dist: attrs>=23.1.0
 Requires-Dist: psycopg[binary]>=3.2
 Requires-Dist: sqlalchemy<3,>=2
-Requires-Dist: wexample-helpers>=20.0.0
+Requires-Dist: wexample-helpers>=20.1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -20,7 +20,7 @@ Description-Content-Type: text/markdown
 
 # orm
 
-Version: 1.3.3
+Version: 1.4.0
 
 `wexample-orm` provides four SQLAlchemy base classes — `AbstractEntity`, `AbstractRepository`, `AbstractSessionFactory`, and `AbstractRepositoriesManager` — that impose a Doctrine-style repository pattern on top of SQLAlchemy 2. It targets Python developers in the Wexample stack who connect to PostgreSQL via psycopg and want a consistent, opinionated foundation without rewriting engine, session, and repository boilerplate for every project.
 
@@ -291,7 +291,7 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - attrs: >=23.1.0
 - psycopg: >=3.2
 - sqlalchemy: <3,>=2
-- wexample-helpers: >=20.0.0
+- wexample-helpers: >=20.1.0
 
 ## Versioning & Compatibility Policy
 

{wexample_orm-1.3.3 → wexample_orm-1.4.0}/README.md

@@ -1,6 +1,6 @@
 # orm
 
-Version: 1.3.3
+Version: 1.4.0
 
 `wexample-orm` provides four SQLAlchemy base classes — `AbstractEntity`, `AbstractRepository`, `AbstractSessionFactory`, and `AbstractRepositoriesManager` — that impose a Doctrine-style repository pattern on top of SQLAlchemy 2. It targets Python developers in the Wexample stack who connect to PostgreSQL via psycopg and want a consistent, opinionated foundation without rewriting engine, session, and repository boilerplate for every project.
 
@@ -271,7 +271,7 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - attrs: >=23.1.0
 - psycopg: >=3.2
 - sqlalchemy: <3,>=2
-- wexample-helpers: >=20.0.0
+- wexample-helpers: >=20.1.0
 
 ## Versioning & Compatibility Policy
 

{wexample_orm-1.3.3 → wexample_orm-1.4.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "wexample-orm"
-version = "1.3.3"
+version = "1.4.0"
 description = "Provides SQLAlchemy ORM abstractions — base entity, repository, session factory, and repository manager — with PostgreSQL-first defaults via psycopg"
 authors = [
     { name = "weeger", email = "contact@wexample.com" },
@@ -21,7 +21,7 @@ dependencies = [
     "attrs>=23.1.0",
     "psycopg[binary]>=3.2",
     "sqlalchemy>=2,<3",
-    "wexample-helpers>=20.0.0",
+    "wexample-helpers>=20.1.0",
 ]
 
 [project.readme]

wexample_orm-1.4.0/src/wexample_orm/const/generator.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+# Property names that clash with SQLAlchemy declarative attributes.
+GENERATOR_RESERVED_ATTRIBUTE_NAMES: dict[str, str] = {
+    "metadata": "entity_metadata",
+}

wexample_orm-1.4.0/src/wexample_orm/const/import_export.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+# Envelope of an exported document: {"version", "type", "entity", "data"}.
+IMPORT_EXPORT_KEY_DATA: str = "data"
+IMPORT_EXPORT_KEY_ENTITY: str = "entity"
+IMPORT_EXPORT_KEY_TYPE: str = "type"
+IMPORT_EXPORT_KEY_VERSION: str = "version"
+
+IMPORT_EXPORT_TYPE_COLLECTION: str = "collection"
+IMPORT_EXPORT_TYPE_SINGLE: str = "single"
+
+# Relation keys: "<relation>", "<relation>_id", "<relation>_ref" or
+# "<relation>_<unique field>" (e.g. "project_secureId").
+IMPORT_EXPORT_FIELD_SEPARATOR: str = "_"
+IMPORT_EXPORT_SUFFIX_ID: str = "id"
+IMPORT_EXPORT_SUFFIX_REF: str = "ref"
+IMPORT_EXPORT_REFERENCE_KEY: str = IMPORT_EXPORT_FIELD_SEPARATOR + IMPORT_EXPORT_SUFFIX_REF

wexample_orm-1.4.0/src/wexample_orm/exception/import_reference_not_found_exception.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from wexample_helpers.exception.undefined_exception import UndefinedException
+
+
+class ImportReferenceNotFoundException(UndefinedException):
+    error_code = "ORM_IMPORT_REFERENCE_NOT_FOUND"
+
+    @classmethod
+    def for_reference(
+        cls, reference: str, entity_name: str | None
+    ) -> ImportReferenceNotFoundException:
+        target = entity_name or "any entity"
+        return cls(
+            message=f"Import reference '{reference}' not found for {target}",
+            data={"reference": reference, "entity_name": entity_name},
+        )

wexample_orm-1.4.0/src/wexample_orm/exception/import_unknown_entity_exception.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from wexample_helpers.exception.undefined_exception import UndefinedException
+
+
+class ImportUnknownEntityException(UndefinedException):
+    error_code = "ORM_IMPORT_UNKNOWN_ENTITY"
+
+    @classmethod
+    def for_entity_name(cls, entity_name: str) -> ImportUnknownEntityException:
+        return cls(
+            message=f"No entity class registered for imported entity: {entity_name}",
+            data={"entity_name": entity_name},
+        )

wexample_orm-1.4.0/src/wexample_orm/generator/entity_generator.py

@@ -0,0 +1,354 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from wexample_helpers.classes.base_class import BaseClass
+from wexample_helpers.classes.field import public_field
+from wexample_helpers.decorator.base_class import base_class
+
+if TYPE_CHECKING:
+    from wexample_orm.generator.entity_schema import EntitySchema
+
+
+@base_class
+class EntityGenerator(BaseClass):
+    """Generate SQLAlchemy entities from the entity schemas of a registry export.
+
+    The package gets, per schema of its `data/entity` directory:
+    `entity/generated/<entity>_generated.py`, rewritten on every run, and
+    `entity/<entity>.py`, a wrapper created once, where custom code goes.
+    `common/generated_entities.py` lists the classes: `generated_entities`
+    for this package, `all_entities` with the external package's ones first.
+
+    An entity only sees its own package and the external one. A relation to
+    an entity out of sight keeps its id column, without foreign key. Both
+    sides of a relation are linked (`back_populates`) only within one
+    package; a collection over an external entity is read-only.
+
+    The relations the external entities have towards this package, which they
+    cannot see, are added to them by `common/generated_external_relations.py`,
+    imported with the manifest: loading this package completes the graph.
+    """
+
+    external_package_name: str | None = public_field(
+        description="Package whose entities this one's relations may target, e.g. "
+        "the public client for the internal one.",
+        default=None,
+    )
+    package_dir: Path = public_field(description="Directory of the generated package.")
+    package_name: str = public_field(description="Import name of the generated package.")
+
+    def generate(self) -> dict[str, int]:
+        from wexample_orm.generator.entity_schema import EntitySchema
+
+        own = EntitySchema.load_directory(self._data_dir(self.package_dir), self.package_name)
+        external = (
+            EntitySchema.load_directory(
+                self._data_dir(self._external_package_dir()), self.external_package_name
+            )
+            if self.external_package_name
+            else []
+        )
+        schemas = {schema.module_name: schema for schema in external + own}
+
+        generated_dir = self.package_dir / "entity" / "generated"
+        generated_dir.mkdir(parents=True, exist_ok=True)
+        (self.package_dir / "common").mkdir(parents=True, exist_ok=True)
+
+        counts = {"created": 0, "removed": 0, "unchanged": 0, "updated": 0, "wrappers": 0}
+        for schema in own:
+            path = generated_dir / f"{schema.module_name}_generated.py"
+            content = self._build_entity(schema, schemas)
+            if not path.exists():
+                counts["created"] += 1
+            elif path.read_text(encoding="utf-8") != content:
+                counts["updated"] += 1
+            else:
+                counts["unchanged"] += 1
+            path.write_text(content, encoding="utf-8")
+
+            wrapper = self.package_dir / "entity" / f"{schema.module_name}.py"
+            if not wrapper.exists():
+                wrapper.write_text(self._build_wrapper(schema), encoding="utf-8")
+                counts["wrappers"] += 1
+
+        expected = {f"{schema.module_name}_generated.py" for schema in own}
+        for path in generated_dir.glob("*_generated.py"):
+            if path.name not in expected:
+                path.unlink()
+                counts["removed"] += 1
+
+        (self.package_dir / "common" / "generated_entities.py").write_text(
+            self._build_manifest(own), encoding="utf-8"
+        )
+        if self.external_package_name:
+            (self.package_dir / "common" / "generated_external_relations.py").write_text(
+                self._build_external_relations(external, schemas), encoding="utf-8"
+            )
+        return counts
+
+    def _attribute(self, name: str, annotation: str, expression: str) -> str:
+        return (
+            f"    @declared_attr\n"
+            f"    def {name}(cls) -> Mapped[{annotation}]:\n"
+            f"        return {expression}"
+        )
+
+    def _build_association(
+        self,
+        schema: EntitySchema,
+        attribute: str,
+        orm: dict[str, Any],
+        schemas: dict[str, EntitySchema],
+        field_names: set[str],
+    ) -> tuple[list[str], set[str]]:
+        from wexample_orm.helper.doctrine import doctrine_join_column_attribute
+
+        association_type = str(orm.get("association_type") or "").lower()
+        target = schemas.get(self._target_module(orm, attribute))
+        lines: list[str] = []
+        imports: set[str] = set()
+
+        if association_type in {"many_to_one", "one_to_one"}:
+            foreign_key = doctrine_join_column_attribute(attribute, orm)
+            if foreign_key not in field_names:
+                join_column = (orm.get("join_columns") or [{}])[0]
+                nullable = bool(join_column.get("nullable", True))
+                constraint = ""
+                if target is not None:
+                    reference = join_column.get("referenced_column_name") or "id"
+                    constraint = f"ForeignKey({target.module_name + '.' + reference!r}), "
+                    imports.add("ForeignKey")
+                lines.append(
+                    self._attribute(
+                        foreign_key,
+                        "object",
+                        f"mapped_column(Integer, {constraint}nullable={nullable})",
+                    )
+                )
+                imports.add("Integer")
+                field_names.add(foreign_key)
+
+            if target is not None:
+                arguments = [
+                    repr(target.class_name),
+                    f"foreign_keys='{schema.class_name}.{foreign_key}'",
+                ]
+                mirror = self._find_mirror_collection(schema, attribute, target)
+                if mirror is not None:
+                    arguments.append(f"back_populates={mirror!r}")
+                    if target.module_name == schema.module_name:
+                        # A self reference must name its parent side, or both
+                        # ends read as one-to-many.
+                        arguments.append(f"remote_side='{schema.class_name}.id'")
+                lines.append(self._relationship(attribute, "object", arguments))
+            return lines, imports
+
+        if association_type == "one_to_many" and target is not None:
+            from wexample_orm.generator.entity_schema import EntitySchema
+
+            owner_attribute = EntitySchema.to_attribute_name(orm.get("mapped_by") or "")
+            owner_orm = dict(target.get_mappings("association")).get(owner_attribute)
+            if owner_orm is None:
+                return [], set()
+
+            owner_foreign_key = doctrine_join_column_attribute(owner_attribute, owner_orm)
+            if target.package_name == schema.package_name:
+                arguments = [
+                    repr(target.class_name),
+                    f"foreign_keys='{target.class_name}.{owner_foreign_key}'",
+                    f"back_populates={owner_attribute!r}",
+                ]
+            else:
+                # The owning side lives in another package, which does not see
+                # this entity: its column carries no foreign key to join on.
+                arguments = [
+                    repr(target.class_name),
+                    f"primaryjoin='{schema.class_name}.id == "
+                    f"foreign({target.class_name}.{owner_foreign_key})'",
+                    "viewonly=True",
+                ]
+            lines.append(
+                self._relationship(attribute, f"list[{target.class_name!r}]", arguments)
+            )
+
+        return lines, imports
+
+    def _build_entity(self, schema: EntitySchema, schemas: dict[str, EntitySchema]) -> str:
+        from wexample_orm.helper.doctrine import doctrine_type_to_sqlalchemy
+
+        sqlalchemy_imports: set[str] = set()
+        field_lines = []
+        field_names = {"id"}
+        for attribute, orm in schema.get_mappings("field"):
+            if orm.get("id"):
+                continue
+            column_type, imports = doctrine_type_to_sqlalchemy(orm)
+            sqlalchemy_imports |= imports
+            arguments = []
+            column = orm.get("column")
+            if isinstance(column, str) and column and column != attribute:
+                arguments.append(repr(column))
+            arguments += [column_type, f"nullable={bool(orm.get('nullable', False))}"]
+            if orm.get("unique"):
+                arguments.append("unique=True")
+            field_lines.append(
+                self._attribute(attribute, "object", f"mapped_column({', '.join(arguments)})")
+            )
+            field_names.add(attribute)
+
+        association_lines = []
+        for attribute, orm in schema.get_mappings("association"):
+            lines, imports = self._build_association(
+                schema, attribute, orm, schemas, field_names
+            )
+            association_lines += lines
+            sqlalchemy_imports |= imports
+
+        orm_imports = {"Mapped", "declared_attr", "mapped_column"}
+        if any("relationship(" in line for line in association_lines):
+            orm_imports.add("relationship")
+
+        header = []
+        if sqlalchemy_imports:
+            header.append(f"from sqlalchemy import {', '.join(sorted(sqlalchemy_imports))}")
+        header.append(f"from sqlalchemy.orm import {', '.join(sorted(orm_imports))}")
+
+        body = [
+            f"class {schema.class_name}Generated:",
+            "    @classmethod",
+            "    def get_entity_name(cls) -> str:",
+            f"        return {schema.module_name!r}",
+        ]
+        for section in (field_lines, association_lines):
+            if section:
+                body += [""] + section
+
+        return "\n".join(header + ["", ""] + body) + "\n"
+
+    def _build_external_relations(
+        self, external: list[EntitySchema], schemas: dict[str, EntitySchema]
+    ) -> str:
+        """Assignments adding to the external entities their relations towards
+        this package. Joins are explicit: the external columns carry no foreign
+        key towards entities they cannot see."""
+        from wexample_orm.generator.entity_schema import EntitySchema
+        from wexample_orm.helper.doctrine import doctrine_join_column_attribute
+
+        imports = {"from sqlalchemy.orm import relationship"}
+        assignments = []
+        for schema in external:
+            for attribute, orm in schema.get_mappings("association"):
+                target = schemas.get(self._target_module(orm, attribute))
+                if target is None or target.package_name != self.package_name:
+                    continue
+
+                association_type = str(orm.get("association_type") or "").lower()
+                if association_type in {"many_to_one", "one_to_one"}:
+                    foreign_key = doctrine_join_column_attribute(attribute, orm)
+                    arguments = (
+                        f"{target.class_name!r}, primaryjoin='foreign({schema.class_name}."
+                        f"{foreign_key}) == {target.class_name}.id'"
+                    )
+                elif association_type == "one_to_many":
+                    owner_attribute = EntitySchema.to_attribute_name(orm.get("mapped_by") or "")
+                    owner_orm = dict(target.get_mappings("association")).get(owner_attribute)
+                    if owner_orm is None:
+                        continue
+                    owner_foreign_key = doctrine_join_column_attribute(owner_attribute, owner_orm)
+                    arguments = (
+                        f"{target.class_name!r}, primaryjoin='{schema.class_name}.id == "
+                        f"foreign({target.class_name}.{owner_foreign_key})', viewonly=True"
+                    )
+                else:
+                    continue
+
+                imports.add(
+                    f"from {schema.package_name}.entity.{schema.module_name} import {schema.class_name}"
+                )
+                assignments.append(
+                    f"{schema.class_name}.{attribute} = relationship({arguments}, lazy='select')"
+                )
+
+        return "\n".join(
+            ["from __future__ import annotations", "", *sorted(imports), "", "", *assignments]
+        ) + "\n"
+
+    def _build_manifest(self, own: list[EntitySchema]) -> str:
+        imports = [
+            f"from {schema.package_name}.entity.{schema.module_name} import {schema.class_name}"
+            for schema in own
+        ]
+        classes = "".join(f"    {schema.class_name},\n" for schema in own)
+        lines = ["from __future__ import annotations", ""]
+        if self.external_package_name:
+            lines.append(
+                f"from {self.external_package_name}.common.generated_entities import (\n"
+                f"    generated_entities as external_generated_entities,\n)"
+            )
+        lines += imports
+        if self.external_package_name:
+            lines.append(f"from {self.package_name}.common import generated_external_relations  # noqa: F401")
+        lines += ["", ""]
+        lines.append(f"generated_entities = [\n{classes}]")
+        lines.append(
+            "all_entities = [*external_generated_entities, *generated_entities]"
+            if self.external_package_name
+            else "all_entities = list(generated_entities)"
+        )
+        return "\n".join(lines) + "\n"
+
+    def _build_wrapper(self, schema: EntitySchema) -> str:
+        return (
+            "from __future__ import annotations\n\n"
+            "from wexample_orm.entity.abstract_entity import AbstractEntity\n\n"
+            f"from {schema.package_name}.entity.generated.{schema.module_name}_generated import (\n"
+            f"    {schema.class_name}Generated,\n)\n\n"
+            f'__all__ = ["{schema.class_name}", "{schema.class_name}Generated"]\n\n\n'
+            f"class {schema.class_name}({schema.class_name}Generated, AbstractEntity):\n"
+            "    pass\n"
+        )
+
+    def _data_dir(self, package_dir: Path) -> Path:
+        return package_dir / "data" / "entity"
+
+    def _external_package_dir(self) -> Path:
+        import importlib.util
+
+        spec = importlib.util.find_spec(self.external_package_name)
+        return Path(next(iter(spec.submodule_search_locations)))
+
+    def _find_mirror_collection(
+        self, schema: EntitySchema, attribute: str, target: EntitySchema
+    ) -> str | None:
+        """The collection of the target mapped by this many-to-one, when both
+        are generated in the same package."""
+        from wexample_orm.generator.entity_schema import EntitySchema
+
+        if target.package_name != schema.package_name:
+            return None
+        for name, orm in target.get_mappings("association"):
+            if (
+                str(orm.get("association_type") or "").lower() == "one_to_many"
+                and self._target_module(orm, name) == schema.module_name
+                and EntitySchema.to_attribute_name(orm.get("mapped_by") or "") == attribute
+            ):
+                return name
+        return None
+
+    def _relationship(self, name: str, annotation: str, arguments: list[str]) -> str:
+        arguments = ", ".join([*arguments, "lazy='select'"])
+        return self._attribute(name, annotation, f"relationship({arguments})")
+
+    def _target_module(self, orm: dict[str, Any], attribute: str) -> str:
+        from wexample_helpers.helper.string import string_to_snake_case
+
+        target = orm.get("target")
+        if isinstance(target, str) and target:
+            return target
+        target_entity = orm.get("target_entity")
+        if isinstance(target_entity, str) and target_entity:
+            return string_to_snake_case(target_entity.split("\\")[-1])
+        return string_to_snake_case(attribute)
+

wexample_orm-1.4.0/src/wexample_orm/generator/entity_schema.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from wexample_helpers.classes.base_class import BaseClass
+from wexample_helpers.classes.field import public_field
+from wexample_helpers.decorator.base_class import base_class
+
+
+@base_class
+class EntitySchema(BaseClass):
+    """One entity of a registry export: its Doctrine-flavored properties, and
+    the Python package its class is generated in."""
+
+    module_name: str = public_field(description="Snake case entity name, also its table.")
+    package_name: str = public_field(description="Package the entity class lives in.")
+    properties: list[dict[str, Any]] = public_field(
+        description="Properties as exported, each with its `orm` mapping.",
+        factory=list,
+    )
+
+    @classmethod
+    def from_file(cls, path: Path, package_name: str) -> EntitySchema:
+        import json
+
+        from wexample_helpers.helper.string import string_to_snake_case
+
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return cls(
+            module_name=string_to_snake_case(str(data.get("name") or path.stem)),
+            package_name=package_name,
+            properties=[
+                item for item in data.get("properties") or [] if isinstance(item, dict)
+            ],
+        )
+
+    @classmethod
+    def load_directory(cls, directory: Path, package_name: str) -> list[EntitySchema]:
+        return [
+            cls.from_file(path, package_name)
+            for path in sorted(directory.iterdir())
+            if path.suffix == ".json"
+        ]
+
+    @staticmethod
+    def to_attribute_name(property_name: str) -> str:
+        import keyword
+
+        from wexample_orm.const.generator import GENERATOR_RESERVED_ATTRIBUTE_NAMES
+
+        if property_name in GENERATOR_RESERVED_ATTRIBUTE_NAMES:
+            return GENERATOR_RESERVED_ATTRIBUTE_NAMES[property_name]
+        if keyword.iskeyword(property_name):
+            return f"{property_name}_"
+        return property_name
+
+    @property
+    def class_name(self) -> str:
+        from wexample_helpers.helper.string import string_to_pascal_case
+
+        return string_to_pascal_case(self.module_name)
+
+    def get_mappings(self, kind: str) -> list[tuple[str, dict[str, Any]]]:
+        """(attribute name, orm mapping) of the properties of that kind:
+        "field" or "association"."""
+        return [
+            (self.to_attribute_name(item["name"]), item["orm"])
+            for item in self.properties
+            if isinstance(item.get("name"), str)
+            and isinstance(item.get("orm"), dict)
+            and item["orm"].get("kind") == kind
+        ]

wexample_orm-1.4.0/src/wexample_orm/generator/repository_generator.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from wexample_helpers.classes.base_class import BaseClass
+from wexample_helpers.classes.field import public_field
+from wexample_helpers.decorator.base_class import base_class
+
+if TYPE_CHECKING:
+    from wexample_orm.generator.entity_schema import EntitySchema
+
+
+@base_class
+class RepositoryGenerator(BaseClass):
+    """Generate one database repository per entity of the given packages, in
+    `database/repository/`: `generated/<entity>_repository_generated.py`,
+    rewritten on every run, and a wrapper created once for custom queries.
+    `database/generated_repositories.py` lists them."""
+
+    entity_package_names: list[str] = public_field(
+        description="Packages whose entities get a repository, e.g. the public "
+        "then the internal client.",
+    )
+    package_dir: Path = public_field(description="Directory of the package receiving them.")
+    package_name: str = public_field(description="Import name of that package.")
+
+    def generate(self) -> dict[str, int]:
+        from wexample_orm.generator.entity_schema import EntitySchema
+
+        repository_dir = self.package_dir / "database" / "repository"
+        generated_dir = repository_dir / "generated"
+        generated_dir.mkdir(parents=True, exist_ok=True)
+        for directory in (self.package_dir / "database", repository_dir, generated_dir):
+            (directory / "__init__.py").touch()
+
+        schemas = [
+            schema
+            for package_name in self.entity_package_names
+            for schema in EntitySchema.load_directory(
+                self._package_dir(package_name) / "data" / "entity", package_name
+            )
+        ]
+
+        counts = {"removed": 0, "repositories": 0, "wrappers": 0}
+        for schema in schemas:
+            (generated_dir / f"{schema.module_name}_repository_generated.py").write_text(
+                self._build_repository(schema), encoding="utf-8"
+            )
+            counts["repositories"] += 1
+
+            wrapper = repository_dir / f"{schema.module_name}_repository.py"
+            if not wrapper.exists():
+                wrapper.write_text(self._build_wrapper(schema), encoding="utf-8")
+                counts["wrappers"] += 1
+
+        expected = {f"{schema.module_name}_repository_generated.py" for schema in schemas}
+        for path in generated_dir.glob("*_repository_generated.py"):
+            if path.name not in expected:
+                path.unlink()
+                counts["removed"] += 1
+
+        (self.package_dir / "database" / "generated_repositories.py").write_text(
+            self._build_manifest(schemas), encoding="utf-8"
+        )
+        return counts
+
+    def _build_manifest(self, schemas: list[EntitySchema]) -> str:
+        imports = "".join(
+            f"from {self.package_name}.database.repository.{schema.module_name}_repository "
+            f"import {schema.class_name}Repository\n"
+            for schema in schemas
+        )
+        classes = "".join(f"    {schema.class_name}Repository,\n" for schema in schemas)
+        return (
+            "from __future__ import annotations\n\n"
+            f"{imports}\n\n"
+            f"generated_repositories = [\n{classes}]\n"
+        )
+
+    def _build_repository(self, schema: EntitySchema) -> str:
+        return (
+            "from __future__ import annotations\n\n"
+            "from wexample_orm.repository.abstract_repository import AbstractRepository\n\n"
+            f"from {schema.package_name}.entity.{schema.module_name} import {schema.class_name}\n\n\n"
+            f"class {schema.class_name}RepositoryGenerated(AbstractRepository):\n"
+            "    @classmethod\n"
+            f"    def get_entity_type(cls) -> type[{schema.class_name}]:\n"
+            f"        return {schema.class_name}\n"
+        )
+
+    def _build_wrapper(self, schema: EntitySchema) -> str:
+        module = f"{schema.module_name}_repository"
+        return (
+            "from __future__ import annotations\n\n"
+            f"from {self.package_name}.database.repository.generated.{module}_generated import (\n"
+            f"    {schema.class_name}RepositoryGenerated,\n)\n\n"
+            f'__all__ = ["{schema.class_name}Repository"]\n\n\n'
+            f"class {schema.class_name}Repository({schema.class_name}RepositoryGenerated):\n"
+            "    pass\n"
+        )
+
+    def _package_dir(self, package_name: str) -> Path:
+        if package_name == self.package_name:
+            return self.package_dir
+
+        import importlib.util
+
+        spec = importlib.util.find_spec(package_name)
+        return Path(next(iter(spec.submodule_search_locations)))