yaddd-sqlalchemy 0.1.0__py3-none-any.whl

yaddd_sqlalchemy/__init__.py

@@ -0,0 +1,8 @@
+"""SQLAlchemy integration for yaddd."""
+
+from yaddd_sqlalchemy.repositories import SqlCrudRepository
+from yaddd_sqlalchemy.uow import SqlUnitOfWork
+from yaddd_sqlalchemy.value_objects import VOTypeDecorator
+
+
+__all__ = ["SqlCrudRepository", "SqlUnitOfWork", "VOTypeDecorator"]

yaddd_sqlalchemy/repositories.py

@@ -0,0 +1,87 @@
+"""SQLAlchemy Core implementation of the ``CrudRepository`` port."""
+
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar
+
+from sqlalchemy import Column, Table, delete, insert, select, update
+from sqlalchemy.engine import Row
+from sqlalchemy.ext.asyncio import AsyncSession
+from yaddd.domain.entities import AggregateRoot, PrimaryKey
+from yaddd.domain.repositories import CrudRepository
+from yaddd.exceptions import EntityNotFoundError
+
+
+__all__ = ["SqlCrudRepository"]
+
+
+class SqlCrudRepository[T: AggregateRoot](CrudRepository[T], ABC):
+    """SQLAlchemy Core-based repository for a single aggregate type.
+
+    No ORM declarative opinions: the subclass declares a Core ``table`` and
+    the mapping between rows and aggregates. The repository never commits —
+    transaction boundaries belong to ``SqlUnitOfWork``.
+
+    Primary keys must be single-column, and ``pk`` values must be natively
+    bindable by the primary-key column type (use a ``TypeDecorator`` column
+    or string/integer primary keys otherwise).
+
+    Example:
+        class OrderRepository(SqlCrudRepository[Order]):
+            table = orders_table
+
+            def to_domain(self, row: Row[Any]) -> Order:
+                return Order(id=row.id, status=row.status, total=row.total)
+
+            def to_row(self, instance: Order) -> dict[str, Any]:
+                return {"id": instance.pk, "status": instance.status, "total": instance.total}
+    """
+
+    table: ClassVar[Table]
+
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    @abstractmethod
+    def to_domain(self, row: Row[Any]) -> T:
+        """Reconstitute the aggregate from a table row."""
+
+    @abstractmethod
+    def to_row(self, instance: T) -> dict[str, Any]:
+        """Map the aggregate to a dict of column values."""
+
+    @property
+    def _pk_column(self) -> Column[Any]:
+        columns = list(self.table.primary_key.columns)
+        if len(columns) != 1:
+            raise NotImplementedError("SqlCrudRepository supports single-column primary keys only")
+        return columns[0]
+
+    async def get(self, pk: PrimaryKey) -> T | None:
+        result = await self._session.execute(select(self.table).where(self._pk_column == pk))
+        row = result.first()
+        return None if row is None else self.to_domain(row)
+
+    async def read(self, filter: dict[str, Any] | None = None, *, slice: tuple[int, int] = (0, 0)) -> list[T]:
+        stmt = select(self.table)
+        for key, value in (filter or {}).items():
+            stmt = stmt.where(self.table.c[key] == value)
+        offset, limit = slice
+        stmt = stmt.offset(offset)
+        if limit:
+            stmt = stmt.limit(limit)
+        result = await self._session.execute(stmt)
+        return [self.to_domain(row) for row in result.all()]
+
+    async def create(self, instance: T) -> T:
+        await self._session.execute(insert(self.table).values(**self.to_row(instance)))
+        return instance
+
+    async def update(self, instance: T) -> T:
+        if await self.get(instance.pk) is None:
+            raise EntityNotFoundError(f"{type(instance).__name__}({instance.pk})")
+        stmt = update(self.table).where(self._pk_column == instance.pk).values(**self.to_row(instance))
+        await self._session.execute(stmt)
+        return instance
+
+    async def delete(self, pk: PrimaryKey) -> None:
+        await self._session.execute(delete(self.table).where(self._pk_column == pk))

yaddd_sqlalchemy/uow.py

@@ -0,0 +1,47 @@
+"""``UnitOfWork`` implementation over a SQLAlchemy ``AsyncSession``."""
+
+from types import TracebackType
+from typing import Self
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from yaddd.application.uow import UnitOfWork
+
+
+__all__ = ["SqlUnitOfWork"]
+
+
+class SqlUnitOfWork(UnitOfWork):
+    """Transactional boundary over a single ``AsyncSession``.
+
+    ``commit()`` flushes and commits the session. Leaving the context without
+    a commit — or with an exception — rolls back; the session is always
+    closed on exit.
+    """
+
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+        self._committed = False
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        try:
+            if exc_type is not None or not self._committed:
+                await self.rollback()
+        finally:
+            await self._session.close()
+
+    async def commit(self) -> None:
+        """Persist all changes made within the unit of work."""
+        await self._session.commit()
+        self._committed = True
+
+    async def rollback(self) -> None:
+        """Discard all changes made within the unit of work."""
+        await self._session.rollback()

yaddd_sqlalchemy/value_objects.py

@@ -0,0 +1,33 @@
+"""SQLAlchemy type decorator persisting ``ValueObject`` instances."""
+
+from typing import Any, ClassVar
+
+from sqlalchemy.engine import Dialect
+from sqlalchemy.types import TypeDecorator
+from yaddd.domain.value_object import ValueObject
+
+
+__all__ = ["VOTypeDecorator"]
+
+
+class VOTypeDecorator(TypeDecorator[ValueObject[Any]]):
+    """Persist a ``ValueObject`` as its raw value and rebuild it on load.
+
+    Subclass, declare ``vo_class`` and pick the storage type via ``impl``::
+
+        class EmailType(VOTypeDecorator):
+            impl = String(255)
+            cache_ok = True
+            vo_class = Email
+
+    Binding unwraps ``value.value``; loading revalidates through
+    ``vo_class(value)``. ``None`` passes through untouched in both directions.
+    """
+
+    vo_class: ClassVar[type[ValueObject[Any]]]
+
+    def process_bind_param(self, value: ValueObject[Any] | None, dialect: Dialect) -> Any:
+        return None if value is None else value.value
+
+    def process_result_value(self, value: Any, dialect: Dialect) -> ValueObject[Any] | None:
+        return None if value is None else self.vo_class(value)

yaddd_sqlalchemy-0.1.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: yaddd-sqlalchemy
+Version: 0.1.0
+Summary: SQLAlchemy integration for yaddd: SqlCrudRepository, SqlUnitOfWork, VOTypeDecorator
+Project-URL: Homepage, https://github.com/netstuff/yaddd
+Author-email: Yuri Andreev <andreev.jr@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Dist: yaddd>=0.1
+Description-Content-Type: text/markdown
+
+# yaddd-sqlalchemy
+SQLAlchemy integration for [yaddd](https://github.com/pyDDD/yaddd).
+
+- `SqlCrudRepository` — SQLAlchemy Core-based implementation of the `CrudRepository` port;
+- `SqlUnitOfWork` — `UnitOfWork` over `AsyncSession`;
+- `VOTypeDecorator` — `TypeDecorator` persisting `ValueObject` instances as raw values.
+
+Wiring is explicit: instantiate in your composition root, no auto-discovery.
+Port conformance is proven by the contract suites in `yaddd.testing`.

yaddd_sqlalchemy-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+yaddd_sqlalchemy/__init__.py,sha256=if6Kyp_p9P6aLWVF5fqnUSE5dcbTcDYgsImYYqCfoZk,277
+yaddd_sqlalchemy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yaddd_sqlalchemy/repositories.py,sha256=tKlhzIEUxbLGZ_85MRT7lSkyOl1UVBKdZXnWdIqtEa0,3452
+yaddd_sqlalchemy/uow.py,sha256=GCcFfLkZICPMuxP8tLzIJEZ3Ph4_GDiENWTc3QmnqrE,1376
+yaddd_sqlalchemy/value_objects.py,sha256=X1M6yoJeylhcibzJ3t6lcNiDZRI7pPAsi90j4Y_n3t4,1112
+yaddd_sqlalchemy-0.1.0.dist-info/METADATA,sha256=euvzt9HtmCtarllZH5v9LmcSdLJTo2nOenfjsIZOn3k,1345
+yaddd_sqlalchemy-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+yaddd_sqlalchemy-0.1.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yaddd_sqlalchemy-0.1.0.dist-info/RECORD,,

yaddd_sqlalchemy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any