fastapi-modular 0.1.0__py3-none-any.whl

pymodular/infrastructure/database/base.py

@@ -0,0 +1,228 @@
+"""Hợp đồng chung cho mọi backend database, và phần ánh xạ entity <-> bản ghi.
+
+Ba backend (memory / SQL / MongoDB) đều cài đúng bộ method dưới đây, nên tầng
+`Repository` ở core không cần biết đang chạy trên cái nào.
+
+Ánh xạ dựa hoàn toàn vào dataclass entity: tên trường thành tên cột hoặc khoá
+document, kiểu Python thành kiểu cột. Entity vì vậy vẫn là dataclass thuần,
+không dính ORM.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import hashlib
+from collections.abc import Callable, Sequence
+from datetime import datetime
+from enum import Enum
+from functools import cache
+from typing import Any, Protocol, TypeVar, get_args, get_type_hints
+
+from pymodular.core.compat import UTC, TimeoutErrors
+
+E = TypeVar("E")
+
+Filters = dict[str, Any]
+Match = Callable[[Any], bool] | None
+
+
+MAX_INDEX_NAME = 63  # PostgreSQL cắt tên định danh ở 63 ký tự
+
+
+def index_name(prefix: str, storage: str, columns: Sequence[str]) -> str:
+    """Tên index ổn định, không vượt giới hạn độ dài của PostgreSQL."""
+    name = f"{prefix}_{storage}_{'_'.join(columns)}"
+    if len(name) <= MAX_INDEX_NAME:
+        return name
+    digest = hashlib.sha1("_".join(columns).encode()).hexdigest()[:8]
+    return f"{prefix}_{storage[:40]}_{digest}"
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class EntityMapping:
+    entity: type
+    storage: str                 # tên bảng (SQL) hoặc collection (Mongo)
+    fields: dict[str, type]      # tên trường -> kiểu đã giải
+    unique: tuple[tuple[str, ...], ...]   # mỗi phần tử là một cột hoặc một cụm cột
+    indexes: tuple[tuple[str, ...], ...]
+
+    def index_specs(self) -> list[tuple[str, tuple[str, ...], bool]]:
+        """[(tên index, các cột, có unique không)] cho mọi index đã khai báo."""
+        return [
+            *((index_name("uq", self.storage, cols), cols, True) for cols in self.unique),
+            *((index_name("ix", self.storage, cols), cols, False) for cols in self.indexes),
+        ]
+
+
+@cache
+def mapping_for(entity: type) -> EntityMapping:
+    if not dataclasses.is_dataclass(entity):
+        raise TypeError(f"{entity.__name__} phải là dataclass mới ánh xạ được")
+
+    hints = get_type_hints(entity)
+    fields = {f.name: hints.get(f.name, str) for f in dataclasses.fields(entity)}
+    return EntityMapping(
+        entity=entity,
+        storage=getattr(entity, "__storage_name__", f"{entity.__name__.lower()}s"),
+        fields=fields,
+        unique=tuple(getattr(entity, "__storage_unique__", ())),
+        indexes=tuple(getattr(entity, "__storage_indexes__", ())),
+    )
+
+
+def to_document(obj: Any) -> dict[str, Any]:
+    """Entity -> dict thuần (Enum thành giá trị, datetime giữ nguyên)."""
+    doc: dict[str, Any] = {}
+    for field in dataclasses.fields(obj):
+        value = getattr(obj, field.name)
+        doc[field.name] = value.value if isinstance(value, Enum) else value
+    return doc
+
+
+def _allows_none(declared: Any) -> bool:
+    """Kiểu có chấp nhận None không (Optional[X] hoặc X | None)."""
+    return declared is Any or type(None) in get_args(declared)
+
+
+@cache
+def _defaults_of(entity: type) -> dict[str, Callable[[], Any]]:
+    """Hàm sinh giá trị mặc định cho từng trường có khai báo default."""
+    out: dict[str, Callable[[], Any]] = {}
+    for f in dataclasses.fields(entity):
+        if f.default is not dataclasses.MISSING:
+            out[f.name] = lambda value=f.default: value
+        elif f.default_factory is not dataclasses.MISSING:  # type: ignore[misc]
+            out[f.name] = f.default_factory  # type: ignore[assignment]
+    return out
+
+
+def from_document(entity: type[E], doc: dict[str, Any]) -> E:
+    """dict -> entity, ép lại Enum/datetime và bù giá trị mặc định.
+
+    Bù mặc định là chỗ quan trọng khi schema tiến hoá: thêm một trường vào
+    entity thì bản ghi cũ chưa có giá trị (SQL trả NULL, Mongo thiếu hẳn khoá).
+    Nếu kiểu khai báo không nhận None mà entity có default, ta dùng default —
+    nhờ vậy dữ liệu cũ đọc ra vẫn hợp lệ thay vì mang None trái kiểu.
+    """
+    mapping = mapping_for(entity)
+    defaults = _defaults_of(entity)
+    kwargs: dict[str, Any] = {}
+
+    for name, declared in mapping.fields.items():
+        value = doc.get(name)
+
+        if value is None and not _allows_none(declared) and name in defaults:
+            value = defaults[name]()
+        elif value is not None:
+            if isinstance(declared, type) and issubclass(declared, Enum):
+                value = declared(value)
+            elif declared is datetime:
+                if isinstance(value, str):
+                    value = datetime.fromisoformat(value)
+                if isinstance(value, datetime) and value.tzinfo is None:
+                    # SQLite và MongoDB trả datetime KHÔNG mang múi giờ (cả hai
+                    # lưu theo UTC nhưng không kèm tzinfo). Gắn lại UTC ở đây để
+                    # ba driver cho ra cùng một dạng, và để một response không
+                    # lẫn lộn "có Z" với "không Z".
+                    value = value.replace(tzinfo=UTC)
+
+        kwargs[name] = value
+
+    return entity(**kwargs)  # type: ignore[call-arg]
+
+
+def matches(obj: Any, filters: Filters, match: Match) -> bool:
+    """Lọc trong Python — dùng cho backend memory và cho tham số `match=`."""
+    for key, value in filters.items():
+        if getattr(obj, key, None) != value:
+            return False
+    return match is None or match(obj)
+
+
+def active_filters(filters: Filters) -> Filters:
+    """Bỏ mọi điều kiện có giá trị None (quy ước: None = không lọc)."""
+    return {k: v for k, v in filters.items() if v is not None}
+
+
+class DuplicateKeyViolation(Exception):
+    """Vi phạm ràng buộc duy nhất, do backend không có sẵn kiểu lỗi riêng.
+
+    SQL ném IntegrityError, Mongo ném DuplicateKeyError; backend memory dùng
+    lớp này để ba đường đi cho ra cùng một kết quả HTTP 409.
+    """
+
+    def __init__(self, storage: str, columns: Sequence[str], values: Sequence[Any]) -> None:
+        self.storage = storage
+        self.columns = tuple(columns)
+        self.values = tuple(values)
+        pairs = ", ".join(f"{c}={v!r}" for c, v in zip(self.columns, self.values, strict=True))
+        super().__init__(f"{storage}: đã tồn tại bản ghi với {pairs}")
+
+
+# Tên lớp lỗi "tạm thời" của các driver. Dùng tên thay vì import để file này
+# không phụ thuộc vào thư viện của driver nào.
+_TRANSIENT_NAMES = frozenset({
+    "ServerSelectionTimeoutError",   # pymongo: chưa chọn được server
+    "AutoReconnect",                 # pymongo: mất kết nối, sẽ tự nối lại
+    "NetworkTimeout",                # pymongo
+    "ConnectionFailure",             # pymongo (lớp cha)
+    "CannotConnectNowError",         # asyncpg: database đang khởi động
+    "TooManyConnectionsError",       # asyncpg: hết slot, chờ chút sẽ có
+})
+
+
+def is_transient_error(exc: BaseException) -> bool:
+    """Lỗi này có khả năng tự hết nếu thử lại không?
+
+    Phân biệt "database chưa kịp lên" (đáng thử lại) với "sai mật khẩu / sai
+    tên database" (thử lại bao nhiêu lần cũng vậy, chỉ làm chậm lúc phát hiện
+    cấu hình sai). Duyệt cả chuỗi __cause__ vì driver hay bọc lỗi gốc lại.
+    """
+    seen: set[int] = set()
+    current: BaseException | None = exc
+
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        if isinstance(current, (ConnectionError, *TimeoutErrors)):
+            return True
+        if type(current).__name__ in _TRANSIENT_NAMES:
+            return True
+        # OSError chung (host chưa phân giải được, mạng chưa lên...)
+        if isinstance(current, OSError) and not isinstance(current, (IsADirectoryError, NotADirectoryError, PermissionError)):
+            return True
+        current = current.__cause__ or current.__context__
+
+    return False
+
+
+class DatabaseBackend(Protocol):
+    """Bộ method mà mọi backend phải có."""
+
+    name: str
+
+    async def startup(self) -> None: ...
+    async def shutdown(self) -> None: ...
+    async def ping(self) -> bool: ...
+
+    async def get(self, entity: type[E], id_: str) -> E | None: ...
+    async def find(
+        self,
+        entity: type[E],
+        *,
+        filters: Filters,
+        match: Match = None,
+        order_by: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list[E]: ...
+    async def find_one(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> E | None: ...
+    async def count(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> int: ...
+    async def save(self, entity: type[E], obj: E) -> E: ...
+    async def delete(self, entity: type[E], id_: str) -> bool: ...
+    async def delete_where(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> int: ...

pymodular/infrastructure/database/circuit.py

@@ -0,0 +1,207 @@
+"""Circuit breaker + hạn thời gian cho database.
+
+Vấn đề khi không có nó: database chết, mỗi request vẫn đi tới tận nơi, chờ hết
+`connect_timeout` rồi mới nhận 503. Với timeout 10 giây và 100 request/giây,
+toàn bộ worker bị giữ chỗ chờ vô ích, và API chết theo database.
+
+Cách chữa: đếm số lần hỏng liên tiếp. Quá ngưỡng thì "ngắt mạch" — mọi request
+trả 503 NGAY, không chạm database. Sau `reset_seconds` cho đúng MỘT request đi
+thử; thành công thì đóng mạch lại, hỏng thì mở tiếp.
+
+Lớp bọc này còn áp một hạn thời gian cứng cho mọi lời gọi. Cần thiết vì
+timeout của từng driver không phủ hết mọi tình huống: database bị đóng băng
+giữa lúc đang trả lời thì connection vẫn "mở", `connect_timeout` không cứu
+được, và request treo cho tới khi client bỏ cuộc. `asyncio.wait_for` ở đây chặn
+được mọi trường hợp, bất kể driver nào bên dưới.
+
+Ba trạng thái:
+
+    closed  --(hỏng liên tiếp >= ngưỡng)-->  open
+    open    --(hết reset_seconds)--------->  half_open
+    half_open --(1 request thành công)---->  closed
+              --(1 request hỏng)----------->  open
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, TypeVar
+
+from pymodular.core.compat import StrEnum, TimeoutErrors
+from pymodular.core.logging import get_logger
+from pymodular.infrastructure.database.base import (
+    DatabaseBackend,
+    Filters,
+    Match,
+    is_transient_error,
+)
+
+log = get_logger(__name__)
+
+E = TypeVar("E")
+
+
+class CircuitState(StrEnum):
+    CLOSED = "closed"
+    OPEN = "open"
+    HALF_OPEN = "half_open"
+
+
+class CircuitOpenError(Exception):
+    """Mạch đang ngắt — không thử database nữa cho tới khi hết thời gian nghỉ."""
+
+    def __init__(self, backend: str, retry_after: float) -> None:
+        self.backend = backend
+        self.retry_after = retry_after
+        super().__init__(
+            f"Database '{backend}' đang bị ngắt mạch, thử lại sau {retry_after:.0f}s"
+        )
+
+
+class CircuitBreakerBackend(DatabaseBackend):
+    """Bọc quanh một backend thật, đếm hỏng và ngắt mạch khi cần.
+
+    Chỉ tính lỗi KẾT NỐI (`is_transient_error`). Lỗi nghiệp vụ như trùng khoá
+    không được làm mạch ngắt — đó là database đang hoạt động tốt.
+    """
+
+    def __init__(
+        self,
+        inner: DatabaseBackend,
+        *,
+        failure_threshold: int = 5,
+        reset_seconds: float = 10.0,
+        call_timeout_seconds: float = 15.0,
+        breaker_enabled: bool = True,
+    ) -> None:
+        self._inner = inner
+        self._threshold = failure_threshold
+        self._reset_seconds = reset_seconds
+        self._call_timeout = call_timeout_seconds
+        # Tắt breaker chỉ tắt phần ngắt mạch; HẠN THỜI GIAN vẫn áp dụng, vì
+        # thiếu nó thì một database bị treo sẽ giữ chỗ mọi worker vô thời hạn.
+        self._breaker_enabled = breaker_enabled
+
+        self._state = CircuitState.CLOSED
+        self._failures = 0
+        self._opened_at = 0.0
+
+    # ------------------------------------------------------------------ trạng thái
+    @property
+    def name(self) -> str:
+        return self._inner.name
+
+    @property
+    def state(self) -> CircuitState:
+        return self._state
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        return {
+            "enabled": self._breaker_enabled,
+            "state": self._state.value,
+            "failures": self._failures,
+            "threshold": self._threshold,
+            "call_timeout": self._call_timeout,
+        }
+
+    def _before_call(self) -> None:
+        if not self._breaker_enabled or self._state is CircuitState.CLOSED:
+            return
+
+        waited = time.monotonic() - self._opened_at
+        if self._state is CircuitState.OPEN:
+            if waited < self._reset_seconds:
+                raise CircuitOpenError(self.name, self._reset_seconds - waited)
+            self._state = CircuitState.HALF_OPEN
+            log.warning("db.circuit_half_open", backend=self.name)
+
+    def _on_success(self) -> None:
+        if self._state is not CircuitState.CLOSED:
+            log.info("db.circuit_closed", backend=self.name)
+        self._state = CircuitState.CLOSED
+        self._failures = 0
+
+    def _on_failure(self, exc: BaseException) -> None:
+        if not self._breaker_enabled or not is_transient_error(exc):
+            return  # lỗi nghiệp vụ: database vẫn khoẻ, không tính
+
+        self._failures += 1
+        if self._failures >= self._threshold or self._state is CircuitState.HALF_OPEN:
+            if self._state is not CircuitState.OPEN:
+                log.error(
+                    "db.circuit_open",
+                    backend=self.name,
+                    failures=self._failures,
+                    reset_in=self._reset_seconds,
+                )
+            self._state = CircuitState.OPEN
+            self._opened_at = time.monotonic()
+
+    async def _call(self, method: str, *args: Any, **kwargs: Any) -> Any:
+        self._before_call()
+        try:
+            result = await asyncio.wait_for(
+                getattr(self._inner, method)(*args, **kwargs), self._call_timeout
+            )
+        except TimeoutErrors as exc:
+            # TimeoutError là lỗi tạm thời, nên nó tính vào số lần hỏng và sẽ
+            # làm mạch ngắt nếu lặp lại — đúng ý đồ.
+            log.warning("db.call_timeout", backend=self.name, method=method,
+                        timeout=self._call_timeout)
+            self._on_failure(exc)
+            # Ném lại bằng TimeoutError DỰNG SẴN, không phải asyncio.TimeoutError:
+            # trên 3.10 hai lớp đó khác nhau, nên `except TimeoutError` ở code
+            # người dùng sẽ trượt trên 3.10 và trúng trên 3.11. Lỗi phụ thuộc
+            # phiên bản là thứ tệ nhất một thư viện có thể để lọt ra ngoài.
+            raise TimeoutError(
+                f"{self.name}.{method} quá {self._call_timeout}s"
+            ) from exc
+        except Exception as exc:
+            self._on_failure(exc)
+            raise
+        self._on_success()
+        return result
+
+    # ------------------------------------------------------------------ vòng đời
+    async def startup(self) -> None:
+        await self._inner.startup()
+
+    async def shutdown(self) -> None:
+        await self._inner.shutdown()
+
+    async def ping(self) -> bool:
+        return await self._call("ping")
+
+    def __getattr__(self, item: str) -> Any:
+        # create_schema và các method riêng của backend cụ thể đi thẳng.
+        return getattr(self._inner, item)
+
+    # ------------------------------------------------------------------ truy vấn
+    async def get(self, entity: type[E], id_: str) -> E | None:
+        return await self._call("get", entity, id_)
+
+    async def find(self, entity: type[E], **kwargs: Any) -> list[E]:
+        return await self._call("find", entity, **kwargs)
+
+    async def find_one(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> E | None:
+        return await self._call("find_one", entity, filters=filters, match=match)
+
+    async def count(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> int:
+        return await self._call("count", entity, filters=filters, match=match)
+
+    async def save(self, entity: type[E], obj: E) -> E:
+        return await self._call("save", entity, obj)
+
+    async def delete(self, entity: type[E], id_: str) -> bool:
+        return await self._call("delete", entity, id_)
+
+    async def delete_where(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> int:
+        return await self._call("delete_where", entity, filters=filters, match=match)

pymodular/infrastructure/database/factory.py

@@ -0,0 +1,88 @@
+"""Chọn backend theo cấu hình, và chỉ import thư viện của driver được chọn.
+
+Đây là điểm mấu chốt cho yêu cầu "dùng Postgres thì không cần cài thư viện của
+SQLite/Mongo": mọi `import sqlalchemy` / `import motor` đều nằm TRONG hàm, nên
+chúng chỉ chạy khi driver tương ứng được chọn. Thiếu thư viện sẽ báo lỗi nói rõ
+cần chạy lệnh make nào, thay vì ImportError lúc khởi động.
+"""
+
+from __future__ import annotations
+
+from pymodular.core.config import DatabaseSettings
+from pymodular.infrastructure.database.base import DatabaseBackend
+
+_INSTALL_HINT = {
+    "sqlite": "pip install \'fastapi-modular[sqlite]\'",
+    "postgres": "pip install \'fastapi-modular[postgres]\'",
+    "mongodb": "pip install \'fastapi-modular[mongodb]\'",
+}
+
+
+def _missing(driver: str, package: str) -> RuntimeError:
+    cach_cai = _INSTALL_HINT.get(driver, "pip install 'fastapi-modular[<driver>]'")
+    return RuntimeError(
+        f"Driver database '{driver}' cần thư viện '{package}' nhưng chưa cài. "
+        f"Chạy: {cach_cai}"
+    )
+
+
+def _wrap(settings: DatabaseSettings, backend: DatabaseBackend) -> DatabaseBackend:
+    """Bọc backend bằng lớp hạn-thời-gian + circuit breaker.
+
+    Luôn bọc, kể cả khi tắt circuit breaker: phần hạn thời gian là bắt buộc,
+    vì timeout của từng driver không phủ được trường hợp database treo giữa
+    chừng, và khi đó request sẽ giữ chỗ worker vô thời hạn.
+    """
+    from pymodular.infrastructure.database.circuit import CircuitBreakerBackend
+
+    return CircuitBreakerBackend(
+        backend,
+        failure_threshold=settings.circuit_failure_threshold,
+        reset_seconds=settings.circuit_reset_seconds,
+        call_timeout_seconds=settings.query_timeout_seconds,
+        breaker_enabled=settings.circuit_breaker,
+    )
+
+
+def create_backend(settings: DatabaseSettings) -> DatabaseBackend:
+    driver = settings.driver
+
+    if driver == "memory":
+        from pymodular.infrastructure.database.memory import MemoryBackend
+
+        # Backend memory không đi qua mạng nên không có gì để ngắt.
+        return MemoryBackend()
+
+    if driver in ("sqlite", "postgres"):
+        try:
+            from pymodular.infrastructure.database.sql import SqlBackend
+        except ModuleNotFoundError as exc:
+            raise _missing(driver, exc.name or "sqlalchemy") from exc
+
+        return _wrap(settings, SqlBackend(
+            settings.resolved_dsn,
+            echo=settings.echo,
+            schema_mode=settings.schema_mode,
+            drop_columns=settings.drop_columns,
+            pool_pre_ping=settings.pool_pre_ping,
+            pool_size=settings.pool_size,
+            max_overflow=settings.max_overflow,
+            pool_recycle_seconds=settings.pool_recycle_seconds,
+            connect_timeout_seconds=settings.connect_timeout_seconds,
+            query_timeout_seconds=settings.query_timeout_seconds,
+        ))
+
+    if driver == "mongodb":
+        try:
+            from pymodular.infrastructure.database.mongo import MongoBackend
+        except ModuleNotFoundError as exc:
+            raise _missing(driver, exc.name or "motor") from exc
+
+        return _wrap(settings, MongoBackend(
+            settings.resolved_dsn,
+            database=settings.name,
+            connect_timeout_seconds=settings.connect_timeout_seconds,
+            query_timeout_seconds=settings.query_timeout_seconds,
+        ))
+
+    raise RuntimeError(f"Driver database không hỗ trợ: {driver!r}")

pymodular/infrastructure/database/memory.py

@@ -0,0 +1,112 @@
+"""Backend lưu trong RAM — mặc định của template, không cần cài gì thêm.
+
+Chỉ hợp cho phát triển và test: dữ liệu mất khi restart, và mỗi worker giữ
+một bản riêng nên KHÔNG được chạy nhiều worker với backend này.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any, TypeVar
+
+from pymodular.infrastructure.database.base import (
+    DatabaseBackend,
+    DuplicateKeyViolation,
+    Filters,
+    Match,
+    active_filters,
+    mapping_for,
+    matches,
+)
+
+E = TypeVar("E")
+
+
+class MemoryBackend(DatabaseBackend):
+    name = "memory"
+
+    def __init__(self) -> None:
+        self._tables: dict[str, dict[str, Any]] = {}
+
+    async def startup(self) -> None:
+        return None
+
+    async def shutdown(self) -> None:
+        self._tables.clear()
+
+    async def ping(self) -> bool:
+        return True
+
+    def _table(self, entity: type) -> dict[str, Any]:
+        return self._tables.setdefault(mapping_for(entity).storage, {})
+
+    def _select(self, entity: type, filters: Filters, match: Match) -> list[Any]:
+        active = active_filters(filters)
+        return [o for o in self._table(entity).values() if matches(o, active, match)]
+
+    async def get(self, entity: type[E], id_: str) -> E | None:
+        return self._table(entity).get(id_)
+
+    async def find(
+        self,
+        entity: type[E],
+        *,
+        filters: Filters,
+        match: Match = None,
+        order_by: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list[E]:
+        rows = self._select(entity, filters, match)
+        if order_by:
+            rows.sort(key=lambda o: getattr(o, order_by, 0))
+        rows = rows[offset:]
+        return rows[:limit] if limit is not None else rows
+
+    async def find_one(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> E | None:
+        return next(iter(self._select(entity, filters, match)), None)
+
+    async def count(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> int:
+        return len(self._select(entity, filters, match))
+
+    async def save(self, entity: type[E], obj: E) -> E:
+        self._check_unique(entity, obj)
+        if not getattr(obj, "id", None):
+            obj.id = uuid.uuid4().hex  # type: ignore[attr-defined]
+        self._table(entity)[obj.id] = obj  # type: ignore[attr-defined]
+        return obj
+
+    def _check_unique(self, entity: type, obj: Any) -> None:
+        """Bắt chước ràng buộc unique của database thật.
+
+        Không có phần này thì backend memory sẽ cho ghi trùng, và test chạy
+        trên memory sẽ không bắt được lỗi mà production gặp phải.
+        """
+        mapping = mapping_for(entity)
+        if not mapping.unique:
+            return
+
+        own_id = getattr(obj, "id", None)
+        for columns in mapping.unique:
+            values = tuple(getattr(obj, column, None) for column in columns)
+            for other in self._table(entity).values():
+                if getattr(other, "id", None) == own_id:
+                    continue
+                if tuple(getattr(other, c, None) for c in columns) == values:
+                    raise DuplicateKeyViolation(mapping.storage, columns, values)
+
+    async def delete(self, entity: type[E], id_: str) -> bool:
+        return self._table(entity).pop(id_, None) is not None
+
+    async def delete_where(
+        self, entity: type[E], *, filters: Filters, match: Match = None
+    ) -> int:
+        table = self._table(entity)
+        ids = [o.id for o in self._select(entity, filters, match)]
+        for id_ in ids:
+            del table[id_]
+        return len(ids)