matrx-orm 3.1.8__tar.gz → 3.1.10__tar.gz

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrx-orm
-Version: 3.1.8
+Version: 3.1.10
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching
 Project-URL: Homepage, https://github.com/AI-Matrix-Engine/aidream-current
 Project-URL: Repository, https://github.com/AI-Matrix-Engine/aidream-current

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/__init__.py

@@ -270,6 +270,7 @@ def _lazy_api():
 # ordering, coalescing, pending-aware reads, managed-write enforcement,
 # transactional flush, watchdog integration. See matrx_orm/session/.
 from matrx_orm.session import (
+    CoordinatorWriteViolation,
     DependencyCycleError,
     FlushError,
     FlushReport,
@@ -281,6 +282,7 @@ from matrx_orm.session import (
     SessionPhase,
     WatchedLifecycleConfig,
     WatchedLifecycleRegistry,
+    allow_direct_managed_write,
     current_session,
     declare_managed,
     drain_spilled_ops,
@@ -296,6 +298,8 @@ from matrx_orm.session import (
 )
 
 __all__ = [
+    "CoordinatorWriteViolation",
+    "allow_direct_managed_write",
     # ── Configuration ──────────────────────────────────────────────────────────
     "DatabaseProjectConfig",
     "register_database",

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/core/async_db_manager.py

@@ -36,6 +36,20 @@ from matrx_orm.exceptions import (
 
 logger = logging.getLogger("matrx_orm.async_db_manager")
 
+
+def _resolve_ssl(value: Any) -> Any:
+    """Normalize DatabaseProjectConfig.ssl for asyncpg's ``ssl=`` kwarg.
+
+    ``False`` / ``"disable"`` / ``"off"`` → no TLS (Coolify / local Postgres).
+    Everything else is passed through (default ``"require"`` for Supabase).
+    """
+    if value is False or value is None:
+        return False
+    if isinstance(value, str) and value.strip().lower() in {"disable", "off", "false", "0"}:
+        return False
+    return value
+
+
 # asyncpg SQLSTATE class 42 "undefined …" — the SQL named something the live DB
 # does not have. All siblings of SyntaxOrAccessError; PostgresSyntaxError is
 # caught separately (it's an ORM-bug shape, not a schema-drift shape). These map
@@ -409,7 +423,7 @@ class AsyncDatabaseManager:
                             max_size=config.get("pool_max", 30),
                             command_timeout=config.get("command_timeout", 10),
                             max_inactive_connection_lifetime=max_inactive_connection_lifetime,
-                            ssl="require",
+                            ssl=_resolve_ssl(config.get("ssl", "require")),
                             statement_cache_size=statement_cache_size,
                             server_settings=server_settings,
                             init=init_callback,

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/core/config.py

@@ -83,6 +83,14 @@ class DatabaseProjectConfig:
     # Supabase compute can spike first-query latency on cold connections).
     server_settings: dict[str, str] = field(default_factory=dict)
 
+    # TLS for the asyncpg pool. Default ``"require"`` matches Supabase /
+    # managed Postgres (which reject plaintext). Direct Coolify / local
+    # Postgres images typically have ``ssl=off`` — set ``ssl=False`` (or
+    # ``"disable"``) for those. Accepted values are whatever asyncpg accepts
+    # for its ``ssl=`` kwarg (``False``, ``True``, ``"require"``, an
+    # ``ssl.SSLContext``, …).
+    ssl: Any = "require"
+
     # Write queue — gates write operations behind an async queue so they wait in
     # order instead of racing for pool connections and timing out under load.
     write_queue_enabled: bool = True
@@ -242,6 +250,7 @@ class DatabaseRegistry:
             "command_timeout": config.command_timeout,
             "session_init_sql": list(config.session_init_sql),
             "server_settings": dict(config.server_settings),
+            "ssl": config.ssl,
             "write_queue_enabled": config.write_queue_enabled,
             "write_concurrency": config.write_concurrency,
             "write_queue_size": config.write_queue_size,
@@ -408,6 +417,7 @@ def register_database_from_env(
     command_timeout: int | None = None,
     session_init_sql: list[str] | None = None,
     server_settings: dict[str, str] | None = None,
+    ssl: Any = None,
     write_queue_enabled: bool | None = None,
     write_concurrency: int | None = None,
     write_queue_size: int | None = None,
@@ -562,6 +572,13 @@ def register_database_from_env(
         supabase_secret_key or os.environ.get(_supabase_secret_env, "").strip()
     )
 
+    _ssl_env = _overrides.get("SSL", f"{env_prefix}_SSL")
+    if ssl is not None:
+        _resolved_ssl: Any = ssl
+    else:
+        _ssl_raw = os.environ.get(_ssl_env, "").strip()
+        _resolved_ssl = _ssl_raw if _ssl_raw else "require"
+
     try:
         config = DatabaseProjectConfig(
             name=name,
@@ -582,6 +599,7 @@ def register_database_from_env(
             supabase_secret_key=_resolved_supabase_secret_key,
             session_init_sql=list(session_init_sql or []),
             server_settings=dict(server_settings or {}),
+            ssl=_resolved_ssl,
             **pool_kwargs,
         )
         registry.register(config)

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/exceptions.py

@@ -1472,8 +1472,13 @@ class MigrationError(ORMException):
         return f"{_RED}{body}{_RESET}"
 
 
-class ParameterError(ORMException):
-    """Raised when query parameters are invalid or malformed."""
+class ParameterError(ORMException, ValueError):
+    """Raised when query parameters are invalid or malformed.
+
+    Subclasses ValueError: a malformed query parameter (e.g. a non-UUID
+    string for a UUID column) IS an invalid value, so consumers that map
+    ``ValueError`` to a 400/invalid-request response catch it correctly
+    instead of surfacing an unmapped 500."""
 
     def __init__(
         self,

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/session/__init__.py

@@ -50,6 +50,7 @@ Usage:
 from matrx_orm.session.coalesce import coalesce_ops, summarize
 from matrx_orm.session.dag import DependencyCycleError, tier_ops, tier_summary
 from matrx_orm.session.errors import (
+    CoordinatorWriteViolation,
     FlushError,
     ManagedWriteViolation,
     SessionClosedError,
@@ -65,7 +66,11 @@ from matrx_orm.session.lifecycle import (
     run_sweeper,
     sweep_once,
 )
-from matrx_orm.session.managed import declare_managed, install_managed_writes
+from matrx_orm.session.managed import (
+    allow_direct_managed_write,
+    declare_managed,
+    install_managed_writes,
+)
 from matrx_orm.session.op import (
     OpType,
     SessionOp,
@@ -90,6 +95,7 @@ from matrx_orm.session.session import (
 
 __all__ = [
     "DependencyCycleError",
+    "CoordinatorWriteViolation",
     "FlushError",
     "FlushReport",
     "ManagedWriteViolation",
@@ -106,6 +112,7 @@ __all__ = [
     "coalesce_ops",
     "config_from_meta",
     "current_session",
+    "allow_direct_managed_write",
     "declare_managed",
     "has_pending_in_stack",
     "install_managed_writes",

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/session/errors.py

@@ -48,6 +48,32 @@ class ManagedWriteViolation(SessionError):
         self.op_kind = op_kind
 
 
+class CoordinatorWriteViolation(ManagedWriteViolation):
+    """Raised when a coordinator-owned Model is written by another path."""
+
+    def __init__(
+        self,
+        model_name: str,
+        op_kind: str,
+        *,
+        required_scope: str,
+        actual_scope: str | None,
+    ) -> None:
+        SessionError.__init__(
+            self,
+            f"{model_name} is coordinator-owned (required write scope: "
+            f"{required_scope!r}). Direct {op_kind} is forbidden; the active "
+            f"Session scope is {actual_scope!r}. Queue this write through its "
+            "Coordinator so parent and child rows share one transactional DAG. "
+            "For a genuine out-of-request maintenance operation, use "
+            "allow_direct_managed_write(model, reason='...') explicitly.",
+        )
+        self.model_name = model_name
+        self.op_kind = op_kind
+        self.required_scope = required_scope
+        self.actual_scope = actual_scope
+
+
 class SessionClosedError(SessionError):
     """Raised when an op is queued onto a Session that has already flushed
     or errored. Generally callers should use ``async with Session():`` so

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/session/managed.py

@@ -1,8 +1,8 @@
 """Managed Model write interception — the runtime enforcement layer.
 
 A Model opts into Session-aware writes by declaring
-``Meta.managed_writes`` as either ``"elevate"`` (default behavior when
-``True``) or ``"strict"``::
+``Meta.managed_writes`` as ``"elevate"`` (default behavior when ``True``),
+``"strict"``, or ``"coordinator"``::
 
     class Conversation(Model):
         ...
@@ -10,6 +10,8 @@ A Model opts into Session-aware writes by declaring
             managed_writes = "elevate"   # auto-open one-shot if no Session
             # OR
             managed_writes = "strict"    # raise ManagedWriteViolation if no Session
+            # OR
+            managed_writes = "coordinator"  # require a named owner Session
 
 When the Model's ``create`` / ``update`` / ``delete`` / ``bulk_*`` /
 ``upsert`` methods are called:
@@ -49,12 +51,19 @@ from __future__ import annotations
 import functools
 import logging
 import re
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from collections.abc import Iterator
 from typing import Any
 
 from matrx_utils import vcprint
 
-from matrx_orm.session.errors import MANAGED_WRITE_SKILL_HINT, ManagedWriteViolation
+from matrx_orm.session.errors import (
+    MANAGED_WRITE_SKILL_HINT,
+    CoordinatorWriteViolation,
+    ManagedWriteViolation,
+)
 from matrx_orm.session.session import Session, SessionPhase, session_stack
 
 logger = logging.getLogger("matrx_orm.session.managed")
@@ -82,6 +91,49 @@ logger = logging.getLogger("matrx_orm.session.managed")
 
 _STRICT_TABLES: set[str] = set()
 
+# table token -> required Session.write_scope. This is stronger than strict:
+# merely opening a Session/transaction is not authority to write the table.
+_COORDINATOR_TABLES: dict[str, str] = {}
+
+
+@dataclass(frozen=True, slots=True)
+class DirectWriteException:
+    model_name: str
+    reason: str
+
+
+_direct_write_exceptions: ContextVar[tuple[DirectWriteException, ...]] = ContextVar(
+    "matrx_orm_direct_write_exceptions",
+    default=(),
+)
+
+
+@contextmanager
+def allow_direct_managed_write(model_cls: type, *, reason: str) -> Iterator[None]:
+    """Explicit, scoped escape hatch for coordinator-owned maintenance writes.
+
+    ``reason`` is mandatory and appears in logs. This is intentionally not a
+    boolean flag: exceptional code must state why it cannot use the owner.
+    """
+    cleaned = reason.strip()
+    if not cleaned:
+        raise ValueError("allow_direct_managed_write requires a non-empty reason")
+    exception = DirectWriteException(model_cls.__name__, cleaned)
+    token = _direct_write_exceptions.set(_direct_write_exceptions.get() + (exception,))
+    logger.warning(
+        "DIRECT WRITE EXCEPTION entered for %s: %s",
+        model_cls.__name__,
+        cleaned,
+    )
+    try:
+        yield
+    finally:
+        _direct_write_exceptions.reset(token)
+
+
+def _has_direct_exception(model_cls: type) -> bool:
+    return any(item.model_name == model_cls.__name__ for item in _direct_write_exceptions.get())
+
 # Leading INSERT INTO / UPDATE / DELETE FROM target — ORM-generated SQL only.
 _WRITE_TARGET_RE = re.compile(
     r"^\s*(?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+([^\s(]+)",
@@ -101,6 +153,63 @@ def _register_strict_table(model_cls: type) -> None:
             _STRICT_TABLES.add(str(name).strip('"'))
 
 
+def _register_coordinator_table(model_cls: type, required_scope: str) -> None:
+    meta = getattr(model_cls, "_meta", None)
+    if meta is None:
+        return
+    for name in (
+        getattr(meta, "qualified_table_name", None),
+        getattr(meta, "table_name", None),
+    ):
+        if name:
+            _COORDINATOR_TABLES[str(name).strip('"')] = required_scope
+
+
+def _coordinator_scope_for_model(model_cls: type) -> str | None:
+    meta = getattr(model_cls, "_meta", None)
+    if meta is None:
+        return None
+    for name in (
+        getattr(meta, "qualified_table_name", None),
+        getattr(meta, "table_name", None),
+    ):
+        if name and (scope := _COORDINATOR_TABLES.get(str(name).strip('"'))):
+            return scope
+    return None
+
+
+def assert_model_write_allowed(
+    model_cls: type,
+    op_kind: str,
+    *,
+    session: Session | None = None,
+) -> None:
+    """Reject a coordinator-owned Model write without its owner Session."""
+    required_scope = _coordinator_scope_for_model(model_cls)
+    if required_scope is None or _has_direct_exception(model_cls):
+        return
+    active = session
+    if active is None:
+        for candidate in reversed(session_stack()):
+            if candidate.phase is SessionPhase.OPEN:
+                active = candidate
+                break
+    actual_scope = active.write_scope if active is not None else None
+    if actual_scope == required_scope:
+        return
+    banner = _format_coordinator_banner(
+        model_cls.__name__, op_kind, required_scope, actual_scope
+    )
+    vcprint(banner, color="red")
+    logger.error("CoordinatorWriteViolation: %s", banner)
+    raise CoordinatorWriteViolation(
+        model_cls.__name__,
+        op_kind,
+        required_scope=required_scope,
+        actual_scope=actual_scope,
+    )
+
+
 def _has_active_open_session() -> bool:
     for candidate in reversed(session_stack()):
         if candidate.phase is SessionPhase.OPEN:
@@ -116,12 +225,35 @@ def assert_managed_write_allowed(query: str) -> None:
     — when no strict table exists. Best-effort table parsing: ORM-generated DML
     only; a query we can't parse is allowed through (the wrappers + the strict
     create path remain the first line of defense)."""
-    if not _STRICT_TABLES:
+    if not _STRICT_TABLES and not _COORDINATOR_TABLES:
         return
-    # Governed contexts — always allowed:
+    # Session.defer_* is authority-checked before an op can enter a flush.
+    # The flush may run in a deliberately detached context where its Session
+    # stack is absent, so the internal execution phase is trusted here.
     from matrx_orm.session.flush import is_flushing
 
-    if is_flushing() or _has_active_open_session():
+    if is_flushing():
+        return
+    m = _WRITE_TARGET_RE.match(query)
+    if not m:
+        return
+    token = m.group(1).strip().strip('"')
+    bare_token = token.split(".")[-1].strip('"')
+
+    required_scope = _COORDINATOR_TABLES.get(token) or _COORDINATOR_TABLES.get(bare_token)
+    if required_scope is not None:
+        model_cls = _model_for_coordinator_table(token, bare_token)
+        if model_cls is not None:
+            assert_model_write_allowed(model_cls, "write")
+        else:
+            actual = _active_write_scope()
+            if actual != required_scope:
+                raise CoordinatorWriteViolation(
+                    token, "write", required_scope=required_scope, actual_scope=actual
+                )
+        return
+    # Governed contexts — always allowed:
+    if _has_active_open_session():
         return
     try:
         from matrx_orm.core.transaction import get_active_connection
@@ -131,10 +263,6 @@ def assert_managed_write_allowed(query: str) -> None:
     except ImportError:
         pass
 
-    m = _WRITE_TARGET_RE.match(query)
-    if not m:
-        return
-    token = m.group(1).strip().strip('"')
     if token in _STRICT_TABLES or token.split(".")[-1].strip('"') in _STRICT_TABLES:
         banner = _format_chokepoint_banner(token)
         vcprint(banner, color="red")
@@ -146,6 +274,33 @@ def assert_managed_write_allowed(query: str) -> None:
         raise ManagedWriteViolation(token, "write (ungoverned)")
 
 
+def _active_write_scope() -> str | None:
+    for candidate in reversed(session_stack()):
+        if candidate.phase is SessionPhase.OPEN:
+            return candidate.write_scope
+    return None
+
+
+def _model_for_coordinator_table(token: str, bare_token: str) -> type | None:
+    from matrx_orm.core.registry import ModelRegistry
+
+    for model_cls in ModelRegistry.all_models().values():
+        meta = getattr(model_cls, "_meta", None)
+        if meta is None:
+            continue
+        names = {
+            str(name).strip('"')
+            for name in (
+                getattr(meta, "qualified_table_name", None),
+                getattr(meta, "table_name", None),
+            )
+            if name
+        }
+        if token in names or bare_token in names:
+            return model_cls
+    return None
+
+
 def is_strict_table(model_cls: type) -> bool:
     """True if ``model_cls``'s table is registered ``strict`` (execute_write-guarded).
 
@@ -235,6 +390,13 @@ def _apply_wrapping(model_cls: type, mode: str) -> None:
         # Register for the universal execute_write guard so update/delete/
         # QueryBuilder/raw-SQL paths are enforced too, not just create/bulk_*.
         _register_strict_table(model_cls)
+    elif mode == "coordinator":
+        required_scope = getattr(
+            getattr(model_cls, "_meta", None),
+            "managed_write_scope",
+            "coordinator",
+        )
+        _register_coordinator_table(model_cls, str(required_scope))
     for method_name in _WRITE_METHODS:
         original = getattr(model_cls, method_name, None)
         if original is None:
@@ -251,6 +413,7 @@ def declare_managed(
     model_cls: type,
     *,
     mode: str = "elevate",
+    write_scope: str = "coordinator",
     watched_lifecycle: dict | None = None,
 ) -> None:
     """Programmatic equivalent of declaring ``Meta.managed_writes`` /
@@ -281,15 +444,19 @@ def declare_managed(
 
     Args:
         model_cls: a matrx-orm Model class.
-        mode: ``"elevate"`` (default — auto-open one-shot Session if
-            none is active) or ``"strict"`` (raise
-            ``ManagedWriteViolation`` outside any Session).
+        mode: ``"elevate"`` (auto-open a one-shot), ``"strict"`` (require
+            any governed Session), or ``"coordinator"`` (require the named
+            owner Session and reject ordinary Session-of-one writes).
+        write_scope: authority required by coordinator mode.
         watched_lifecycle: optional dict matching the
             :class:`WatchedLifecycleConfig` fields (``predicate``,
             ``max_age_secs``, ``transition_to_on_timeout``, etc.).
     """
-    if mode not in ("strict", "elevate"):
-        raise ValueError(f"declare_managed: mode must be 'strict' or 'elevate', got {mode!r}")
+    if mode not in ("strict", "elevate", "coordinator"):
+        raise ValueError(
+            "declare_managed: mode must be 'strict', 'elevate', or "
+            f"'coordinator', got {mode!r}"
+        )
     meta = getattr(model_cls, "_meta", None)
     if meta is None:
         raise ValueError(
@@ -304,6 +471,10 @@ def declare_managed(
         object.__setattr__(meta, "managed_writes", mode)
 
     _apply_wrapping(model_cls, mode)
+    if mode == "coordinator":
+        if not write_scope.strip():
+            raise ValueError("declare_managed coordinator mode requires write_scope")
+        _register_coordinator_table(model_cls, write_scope.strip())
 
     if watched_lifecycle is not None:
         try:
@@ -337,7 +508,7 @@ def _managed_mode(model_cls: type) -> str | None:
         return None
     if declared is True:
         return "elevate"
-    if isinstance(declared, str) and declared in ("strict", "elevate"):
+    if isinstance(declared, str) and declared in ("strict", "elevate", "coordinator"):
         return declared
     logger.warning(
         "managed_writes on %s must be True | 'strict' | 'elevate' — got %r. Treating as 'elevate'.",
@@ -381,6 +552,8 @@ def _wrap_classmethod(model_cls: type, method_name: str, original: Any, mode: st
                 session = candidate
                 break
         if session is not None:
+            if mode == "coordinator":
+                assert_model_write_allowed(cls, method_name, session=session)
             # Defer to the active Session.
             return await _defer_to_session(
                 session,
@@ -392,6 +565,9 @@ def _wrap_classmethod(model_cls: type, method_name: str, original: Any, mode: st
             )
 
         # No active Session.
+        if mode == "coordinator":
+            assert_model_write_allowed(cls, method_name)
+
         if mode == "strict":
             banner = _format_violation_banner(cls.__name__, method_name)
             vcprint(banner, color="red")
@@ -565,6 +741,28 @@ def _format_chokepoint_banner(table: str) -> str:
     )
 
 
+def _format_coordinator_banner(
+    model_name: str,
+    op_kind: str,
+    required_scope: str,
+    actual_scope: str | None,
+) -> str:
+    return (
+        "\n"
+        "████████████████████████████████████████████████████████████████████\n"
+        "██  COORDINATOR-OWNED TABLE — DIRECT WRITE FORBIDDEN              ██\n"
+        "████████████████████████████████████████████████████████████████████\n"
+        f"  Model       : {model_name}\n"
+        f"  Operation   : {op_kind}\n"
+        f"  Required    : Session(write_scope={required_scope!r})\n"
+        f"  Actual      : Session(write_scope={actual_scope!r})\n"
+        "  Fix         : queue this write through the registered Coordinator.\n"
+        "  Exception   : allow_direct_managed_write(Model, reason='...')\n"
+        "                is reserved for genuine out-of-request maintenance.\n"
+        "████████████████████████████████████████████████████████████████████\n"
+    )
+
+
 def _format_violation_banner(model_name: str, op_kind: str) -> str:
     return (
         "\n"

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/matrx_orm/session/session.py

@@ -232,6 +232,7 @@ class Session:
         "_max_age_secs",
         "_opened_at",
         "_stack_token",
+        "_write_scope",
     )
 
     def __init__(
@@ -241,6 +242,7 @@ class Session:
         autoflush_on_exception: bool = True,
         expected_writes: int | None = None,
         max_age_secs: int | None = None,
+        write_scope: str | None = None,
     ) -> None:
         self._id = str(uuid.uuid4())
         self._database = database
@@ -253,6 +255,7 @@ class Session:
         self._max_age_secs = max_age_secs
         self._opened_at = datetime.now(UTC)
         self._stack_token: Any = None
+        self._write_scope = write_scope
 
     # ---------------------- properties / introspection -------------------
 
@@ -272,6 +275,16 @@ class Session:
     def database(self) -> str | None:
         return self._database
 
+    @property
+    def write_scope(self) -> str | None:
+        """Named authority carried by this Unit of Work.
+
+        Models declared with ``managed_writes='coordinator'`` accept writes
+        only from a Session whose scope matches their registered owner.
+        Ordinary ``Session()`` instances deliberately carry no authority.
+        """
+        return self._write_scope
+
     @property
     def report(self) -> FlushReport | None:
         return self._report
@@ -322,6 +335,9 @@ class Session:
         """Queue an INSERT op. Returns the op_id. Never raises (except on
         a closed Session, which is a programmer error)."""
         self._guard_open(op_kind="insert", model_name=model_cls.__name__)
+        from matrx_orm.session.managed import assert_model_write_allowed
+
+        assert_model_write_allowed(model_cls, "insert", session=self)
         op = make_insert(model_cls, payload, pk_value=pk_value)
         self._ops.append(op)
         return op.op_id
@@ -334,6 +350,9 @@ class Session:
     ) -> str:
         """Queue an UPDATE op. Returns the op_id."""
         self._guard_open(op_kind="update", model_name=model_cls.__name__)
+        from matrx_orm.session.managed import assert_model_write_allowed
+
+        assert_model_write_allowed(model_cls, "update", session=self)
         op = make_update(model_cls, pk_value, fields)
         self._ops.append(op)
         return op.op_id
@@ -345,6 +364,9 @@ class Session:
     ) -> str:
         """Queue a DELETE op. Returns the op_id."""
         self._guard_open(op_kind="delete", model_name=model_cls.__name__)
+        from matrx_orm.session.managed import assert_model_write_allowed
+
+        assert_model_write_allowed(model_cls, "delete", session=self)
         op = make_delete(model_cls, pk_value)
         self._ops.append(op)
         return op.op_id

{matrx_orm-3.1.8 → matrx_orm-3.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.8"
+version = "3.1.10"
 description = "Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching"
 readme = "README.md"
 license = { text = "MIT" }