matrx-orm 3.1.65__tar.gz → 3.1.67__tar.gz

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: matrx-orm
-Version: 3.1.65
+Version: 3.1.67
 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.65 → matrx_orm-3.1.67}/matrx_orm/__init__.py

@@ -317,10 +317,12 @@ from matrx_orm.session import (
     COORDINATOR_BYPASS_ACKNOWLEDGEMENT,
     allow_direct_coordinator_write,
     coordinator_policy_tables,
+    create_or_capture,
     current_session,
     declare_managed,
     drain_spilled_ops,
     is_in_session,
+    WritePreservedError,
     record_error,
     record_failures,
     register_coordinator_owned_model,
@@ -599,6 +601,8 @@ __all__ = [
     "record_error",
     "record_failures",
     "drain_spilled_ops",
+    "create_or_capture",
+    "WritePreservedError",
     "run_lifecycle_sweeper",
     "sweep_lifecycle_once",
     # ── Adapter layer ──────────────────────────────────────────────────────────

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/matrx_orm/associations.py

@@ -186,6 +186,7 @@ class Associations:
         target_id_field: str = "target_id",
         org_field: str = "org_id",
         role_field: str = "role",
+        soft_delete_field: str = "deleted_at",
     ) -> None:
         self._assoc = association_model
         self._reg = registry
@@ -196,6 +197,14 @@ class Associations:
         self._org = org_field
         self._role = role_field
         self._role_available = True  # refined by _validate_field_bindings when introspectable
+        # An edge table MAY tombstone edges rather than delete them: the host's
+        # entity soft-delete carries its edges down with it, and the entity's
+        # restore brings exactly those edges back. Where the column exists EVERY
+        # read here is live-only — a tombstoned edge conveys nothing, so handing
+        # one back is an access leak. A minimal host edge table without the
+        # column keeps the old unfiltered behaviour.
+        self._soft_delete = soft_delete_field
+        self._soft_delete_available = False  # refined by _validate_field_bindings
         # Optional edge-document columns (platform.associations carries them;
         # a minimal host edge table may not). Passing the kwarg against a
         # table without the column raises loudly at call time.
@@ -239,9 +248,14 @@ class Associations:
         # role is OPTIONAL on the edge table — engines over role-less edge
         # tables keep working; passing a role against one raises at call time.
         self._role_available = self._role in fields
+        self._soft_delete_available = self._soft_delete in fields
         for col in self._optional_cols:
             self._optional_cols[col] = col in fields
 
+    def _live_filter(self) -> dict[str, Any]:
+        """Restrict a read to non-tombstoned edges (no-op without the column)."""
+        return {self._soft_delete: None} if self._soft_delete_available else {}
+
     # ---- writes ----------------------------------------------------------
 
     def _role_filter(self, role: Any) -> dict[str, Any]:
@@ -332,6 +346,14 @@ class Associations:
                 for col, value in {"metadata": metadata, **extras}.items()
                 if value is not None and getattr(edge, col, None) != value
             }
+            # Re-attaching over a TOMBSTONE revives it. The lookup deliberately
+            # matches tombstoned edges (the DB's unique index does too), so
+            # without this the caller would get back an edge nothing can see.
+            if self._soft_delete_available and getattr(edge, self._soft_delete, None) is not None:
+                updates[self._soft_delete] = None
+                for stamp in ("deleted_via_type", "deleted_via_id"):
+                    if stamp in getattr(getattr(self._assoc, "_meta", None), "fields", ()):
+                        updates[stamp] = None
             if updates:
                 edge = await edge.update(**updates)
         return edge
@@ -352,6 +374,10 @@ class Associations:
                 self._ti: target.id,
                 self._org: org_id,
                 **self._role_filter(role),
+                # Never purge a tombstone: the user is detaching what they can
+                # SEE, and the tombstone must survive to be restored with its
+                # entity. A hard entity DELETE is what purges tombstones.
+                **self._live_filter(),
             }
         )
         for edge in edges:
@@ -374,6 +400,7 @@ class Associations:
         if target_type is not None:
             filters[self._tt] = target_type
         filters.update(self._role_filter(role))
+        filters.update(self._live_filter())
         return await self._assoc.filter_items(**filters)
 
     async def edges_to(
@@ -390,6 +417,7 @@ class Associations:
         if source_type is not None:
             filters[self._st] = source_type
         filters.update(self._role_filter(role))
+        filters.update(self._live_filter())
         return await self._assoc.filter_items(**filters)
 
     async def targets_from(

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/matrx_orm/core/FEATURE.md

@@ -13,6 +13,18 @@ columns present in the row as loaded.
 Pinned by `tests/level1/test_parameter_name_hydration.py` and
 `tests/level1/test_dirty_tracking.py`.
 
+## Relation identity
+
+**Every model renders an exact `schema.table` SQL target.** Models whose
+generated metadata omits `_db_schema` are public-schema models, so
+`ModelOptions.qualified_table_name` returns `public.<table>` rather than a bare
+name. This keeps ordinary public-model writes compatible with the managed-write
+guard and ensures diagnostic sinks such as `public.app_log` and
+`public.system_write_failure` remain writable after schema-identity hardening.
+
+Pinned by `tests/level1/test_model_meta.py` and
+`tests/level1/test_managed_write_guard.py`.
+
 ## Database execution errors
 
 `AsyncDatabaseManager.execute_query` must classify every PostgreSQL integrity
@@ -45,6 +57,8 @@ Verified against code: 2026-08-13.
 
 ## Change log
 
+- 2026-08-14: Public models now render `public.table` SQL targets; bare public
+  relation names can no longer disable application logs or write-failure capture.
 - 2026-08-13: Registry, admin, recovery, catalog, and diagnostic identities are now exact `schema.table`; bare names are accepted only as uncached discovery terms and ambiguity fails loudly.
 - 2026-08-13: Added atomic recovery from a pool left at zero connections after an upstream database restart.
 - 2026-08-09: Pinned positional-mapping hydration for parameter-shaped column names.

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/matrx_orm/core/base.py

@@ -176,9 +176,7 @@ class ModelOptions:
 
     @property
     def qualified_table_name(self) -> str:
-        if self.db_schema:
-            return f"{self.db_schema}.{self.table_name}"
-        return self.table_name
+        return f"{self.db_schema or 'public'}.{self.table_name}"
 
 
 class ModelMeta(type):

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/matrx_orm/session/README.md

@@ -231,6 +231,35 @@ matrx-ai/persistence module.
 See [docs/persistence/ORM_SESSION_VISION.md](../../../../docs/persistence/ORM_SESSION_VISION.md)
 for the full migration plan.
 
+## Keep-the-work: `create_or_capture` for DIRECT writes
+
+A Session-queued write that fails is captured to `system_write_failure` and
+replayed automatically. A **direct** write (`Model.create_item(...)`) had no
+such tier — when it raised, the payload evaporated. That destroyed a paid agent
+result in production (matrx-frontend FOUND_DEFECTS D183): the model had already
+answered, the user had already been billed, and a 10s statement timeout on the
+single INSERT deleted the only copy.
+
+`create_or_capture(model_cls, payload, ...)` closes it, in this order:
+
+1. **Mint the PK first**, so one id spans the attempt, the verification, and any
+   replay.
+2. **Fire** `create_item`.
+3. **Verify before declaring loss** — a statement timeout can fire *after* the
+   row committed, so re-read by PK; if it is there the write SUCCEEDED (logged
+   loudly: a client gave up on a landed write).
+4. **Preserve** — capture the intended INSERT to `system_write_failure` stamped
+   `DirectWritePreserved`, which `matrx_ai`'s auto-replay loop treats as
+   self-healing and re-applies with no human in the loop.
+5. **Raise `WritePreservedError`** carrying the op handle, so the caller's
+   failure record can say *your work survived* (`as_payload()` is the JSON-safe
+   shape for a run row's `error` column and for a stream event).
+
+**Reach for it only where a lost row means lost money or lost human effort** —
+an agent's structured output, a provider's response, a rendered document.
+Ordinary writes stay on the Session/Coordinator path, which already has this
+guarantee. Live proof: `scripts/_verify_keep_the_work_live.py`.
+
 ## Doctrine references
 
 - `docs/persistence/DOCTRINE.md` — the persistence rules

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/matrx_orm/session/__init__.py

@@ -56,7 +56,13 @@ from matrx_orm.session.errors import (
     SessionClosedError,
     SessionError,
 )
-from matrx_orm.session.fallback import drain_spilled_ops, record_error, record_failures
+from matrx_orm.session.fallback import (
+    WritePreservedError,
+    create_or_capture,
+    drain_spilled_ops,
+    record_error,
+    record_failures,
+)
 from matrx_orm.session.lifecycle import (
     SWEEP_INTERVAL_SECS_DEFAULT,
     SWEEP_LIMIT_DEFAULT,
@@ -131,6 +137,8 @@ __all__ = [
     "record_error",
     "record_failures",
     "drain_spilled_ops",
+    "create_or_capture",
+    "WritePreservedError",
     "merge_pending_with_db_one",
     "run_sweeper",
     "session_stack",

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/matrx_orm/session/fallback.py

@@ -50,6 +50,15 @@ _SPILL_PACKAGED_DEFAULT = "/var/lib/matrx/spill"
 # which is definitionally recoverable once the DB returns). matrx-ai's replay
 # loop adds this to its RECOVERABLE_RETRY_ERRORS set — keep the string in lockstep.
 DISK_SPILL_RECOVERED_MARKER = "DiskSpillRecovered"
+# Signature stamped into a row captured by :func:`create_or_capture` — a DIRECT
+# (non-Session) write that failed after work was already done and paid for. It
+# is stamped for the same reason as the disk-spill marker: the failure classes
+# that kill a direct write (statement timeout, connection reset, pool
+# exhaustion) are ENVIRONMENTAL and self-heal, so the auto-replay loop should
+# re-apply the row rather than leave a paid artifact sitting in a failure table.
+# matrx-ai's replay loop adds this to its RECOVERABLE_RETRY_ERRORS set — keep
+# the string in lockstep.
+DIRECT_WRITE_PRESERVED_MARKER = "DirectWritePreserved"
 # Resolved-writable spill dir, cached after first success so we don't re-probe
 # the cascade on every failure. None until first resolution.
 _spill_dir_cache: Path | None = None
@@ -300,19 +309,31 @@ async def record_failures(
     user_id: str | None = None,
     conversation_id: str | None = None,
     database: str | None = None,
-) -> None:
+    error_prefix: str | None = None,
+) -> list[str]:
     """Write every dropped op to ``system_write_failure`` on a fresh connection.
 
     Never raises. If the fresh-connection write itself fails, dumps every
     op to stdout in red and to the structured logger.
+
+    ``error_prefix`` stamps a recoverability marker onto ``error_text`` (the
+    same mechanism ``drain_spilled_ops`` uses for ``DISK_SPILL_RECOVERED_MARKER``)
+    so the auto-replay loop can classify this capture without pattern-matching
+    a driver message.
+
+    Returns the ``op_id`` of every op it captured — the handle a caller quotes
+    back to a human ("your work is preserved as <id>") and the key the admin
+    persistence surface replays by.
     """
     if not ops:
-        return
+        return []
 
     # Never blank: resolve the deepest driver error (SQLSTATE + message + diag)
     # so the system_write_failure row records WHY the write was dropped, even
     # when the exception stringifies to "".
     error_text = describe_db_exception(exc).as_text()
+    if error_prefix:
+        error_text = f"{error_prefix}: {error_text}"
     tb_text = "".join(_tb.format_exception(type(exc), exc, exc.__traceback__))
 
     # UUID-typed columns must never crash the capture itself (request_id is
@@ -351,7 +372,7 @@ async def record_failures(
             f"system_write_failure (flush exc: {error_text})",
             color="yellow",
         )
-        return
+        return [op.op_id for op in ops]
 
     # Anything that didn't reach the table is spilled to disk — last resort
     # before data loss. drain_spilled_ops() re-lands it when the DB returns.
@@ -376,6 +397,10 @@ async def record_failures(
             spilled=spilled,
             total=len(failed_rows),
         )
+    # A spilled op is still preserved (drain_spilled_ops re-lands it), so it
+    # counts as captured. Only ops that reached neither the table nor the disk
+    # are lost, and those already screamed above.
+    return [op.op_id for op in ops]
 
 
 async def _bulk_insert_failures(
@@ -657,3 +682,157 @@ def _scream_to_stdout(
             )
         except Exception:
             vcprint(f"  LOST OP {op.op_id} (could not serialize)", color="red")
+
+
+# ── Keep-the-work tier: DIRECT writes that must never lose their payload ─────
+
+
+class WritePreservedError(RuntimeError):
+    """A direct write failed, but its payload was PRESERVED for replay.
+
+    Raised by :func:`create_or_capture` so a caller can tell a human the truth
+    that matters: the expensive work is not gone. ``op_id`` is the
+    ``system_write_failure`` handle the auto-replay loop retries and the admin
+    persistence surface replays by.
+
+    ``captured=False`` means even the capture failed (the op was screamed to
+    stdout/structlog) — the ONLY case where a caller should say the work is
+    genuinely at risk.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        table: str,
+        pk_value: Any,
+        op_id: str | None,
+        captured: bool,
+        cause: BaseException,
+    ) -> None:
+        super().__init__(message)
+        self.table = table
+        self.pk_value = pk_value
+        self.op_id = op_id
+        self.captured = captured
+        self.cause = cause
+
+    def as_payload(self) -> dict[str, Any]:
+        """JSON-safe description for a run row's ``error`` column / a stream
+        event. Never a bare traceback — this is what a SURFACE renders."""
+        return {
+            "type": "WritePreservedError",
+            "message": str(self),
+            "work_preserved": self.captured,
+            "preserved_op_id": self.op_id,
+            "preserved_table": self.table,
+            "preserved_row_id": str(self.pk_value),
+            "user_message": (
+                "The result was generated successfully but could not be saved "
+                "to its final home. It has been preserved and will be recovered "
+                "automatically — you will not be charged to produce it again."
+                if self.captured
+                else "The result was generated but could not be saved, and the "
+                "preservation write also failed. Support has the full payload "
+                "in the server logs."
+            ),
+        }
+
+
+async def create_or_capture(
+    model_cls: type,
+    payload: dict[str, Any],
+    *,
+    pk_field: str = "id",
+    request_id: str | None = None,
+    user_id: str | None = None,
+    conversation_id: str | None = None,
+    database: str | None = None,
+) -> Any:
+    """Create ONE row, and never lose its payload if the write fails.
+
+    THE HOLE THIS CLOSES: a Session-queued write that fails is captured to
+    ``system_write_failure`` and replayed automatically. A DIRECT write
+    (``Model.create_item(...)``) had no such tier — when it raised, the payload
+    simply evaporated. That is fine for a row we can trivially recompute and
+    catastrophic for the ONE class of write this function exists for: **the
+    durable home of an artifact that was already generated and already paid
+    for** — an agent's structured output, a provider's response, a rendered
+    document. Losing that write does not just fail the request, it destroys
+    work the user was billed for and forces them to buy it again (D183).
+
+    The contract, in order:
+
+    1. **Stable identity first.** The PK is minted here when absent, so the
+       same id spans the attempt, the verification, and any later replay.
+    2. **Fire.** ``model_cls.create_item(**payload)``.
+    3. **Verify on failure.** A statement timeout can fire AFTER the row
+       committed, so a failed attempt is not proof of a missing row. Re-read by
+       PK on a fresh read before declaring anything lost; if it is there, the
+       write SUCCEEDED and we return it (loudly — a recovery firing means a
+       real defect got past the proactive layer).
+    4. **Preserve.** Otherwise capture the intended INSERT into
+       ``system_write_failure`` stamped ``DirectWritePreserved``, so the
+       existing auto-replay loop re-applies it with no human in the loop.
+    5. **Tell the truth.** Raise :class:`WritePreservedError` carrying the
+       handle, so the caller's failure record says "your work survived" instead
+       of only "it broke".
+
+    This is a KEEP-THE-WORK primitive, not a general write path: reach for it
+    where a lost row means lost money or lost human effort. Ordinary writes
+    stay on the Session/Coordinator path, which already has this guarantee.
+    """
+    from matrx_orm.session.op import make_insert
+
+    row = dict(payload)
+    if not row.get(pk_field):
+        row[pk_field] = str(_uuid.uuid4())
+    pk_value = row[pk_field]
+    table = f"{getattr(model_cls._meta, 'schema', 'public')}.{model_cls._meta.table_name}"
+
+    try:
+        return await model_cls.create_item(**row)
+    except Exception as exc:
+        # (3) The attempt failing is NOT proof the row is missing.
+        try:
+            landed = await model_cls.filter(**{pk_field: pk_value}).limit(1).all()
+        except Exception:
+            landed = []
+        if landed:
+            vcprint(
+                f"[matrx_orm.create_or_capture] {table} {pk_value} raised "
+                f"{type(exc).__name__} but the row IS committed — the write "
+                f"succeeded and the error was the acknowledgement, not the write. "
+                f"Investigate: this means a client gave up on a landed write.",
+                color="yellow",
+            )
+            logger.warning("create_or_capture_landed_despite_error", exc_info=exc)
+            return landed[0]
+
+        # (4) Preserve the payload where the replay loop will find it.
+        op = make_insert(model_cls, row, pk_value=pk_value)
+        op_ids = await record_failures(
+            [op],
+            exc,
+            request_id=request_id,
+            user_id=user_id,
+            conversation_id=conversation_id,
+            database=database,
+            error_prefix=DIRECT_WRITE_PRESERVED_MARKER,
+        )
+        op_id = op_ids[0] if op_ids else None
+        vcprint(
+            f"[matrx_orm.create_or_capture] {table} {pk_value} FAILED "
+            f"({type(exc).__name__}) — payload preserved as system_write_failure "
+            f"op {op_id}; the auto-replay loop will re-apply it.",
+            color="yellow",
+        )
+        raise WritePreservedError(
+            f"{table} write failed ({type(exc).__name__}: {exc}); the payload was "
+            f"preserved for automatic replay",
+            table=table,
+            pk_value=pk_value,
+            op_id=op_id,
+            captured=op_id is not None,
+            cause=exc,
+        ) from exc

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.65"
+version = "3.1.67"
 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" }

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_derived_table.py

@@ -86,7 +86,7 @@ def test_correlated_subquery_aggregate_params_shift_past_outer_params() -> None:
     sql, params = QueryExecutor(query._build_query())._build_query()
 
     assert "COALESCE(SUM(amount), $1)" in sql
-    assert "id = parents.id" in sql
+    assert "id = public.parents.id" in sql
     assert "kind = $2" in sql
     assert "WHERE kind = $3" in sql
     assert params == [0, "child", "parent"]

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_expression_primitives.py

@@ -137,7 +137,7 @@ def test_exists_in_filter_now_works_after_list_fix(_dummy_adapter):
         Site, Run = _models()
         # Before the fix this raised AttributeError (.items() on a list).
         sql = _sql(Site.filter(Exists(Run.filter(site_id=OuterRef("id")))))
-        assert "EXISTS (SELECT 1 FROM runs WHERE site_id = sites.id)" in sql
+        assert "EXISTS (SELECT 1 FROM public.runs WHERE site_id = public.sites.id)" in sql
     finally:
         ModelRegistry.clear()
 
@@ -151,7 +151,10 @@ def test_correlated_count_subquery_in_annotate(_dummy_adapter):
         inner = Run.filter(site_id=OuterRef("id")).annotate(c=Count())
         sql = _sql(Site.filter().annotate(run_count=Subquery(inner)))
         # The correlated scalar rollup: (SELECT COUNT(*) FROM runs WHERE ...) AS run_count
-        assert "(SELECT COUNT(*) FROM runs WHERE site_id = sites.id) AS run_count" in sql
+        assert (
+            "(SELECT COUNT(*) FROM public.runs WHERE site_id = public.sites.id) AS run_count"
+            in sql
+        )
     finally:
         ModelRegistry.clear()
 

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_join_and_aggregate.py

@@ -310,7 +310,7 @@ class TestBaseManagerAggregate:
         assert "SELECT *" not in sql.split(" FROM ")[0]
         assert "SUM(amount) AS total" in sql
         assert "COUNT(id) AS n" in sql
-        assert "FROM orders" in sql
+        assert "FROM public.orders" in sql
         assert "WHERE status = $1" in sql
         assert params == ["paid"]
 

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_managed_write_guard.py

@@ -95,6 +95,17 @@ class TestStrictGuard:
         M._STRICT_TABLES.add("public.cx_message")
         M.assert_managed_write_allowed("WITH t AS (...) UPDATE cx_message ...")  # no raise
 
+    def test_public_model_sql_is_schema_qualified_at_the_source(self):
+        model = _make_model(
+            "PublicDiagnostic",
+            {"id": UUIDField(primary_key=True), "_table_name": "diagnostic_sink"},
+        )
+        assert model._meta.qualified_table_name == "public.diagnostic_sink"
+        M._STRICT_TABLES.add("chat.message")
+        M.assert_managed_write_allowed(
+            f"INSERT INTO {model._meta.qualified_table_name} (id) VALUES ($1)"
+        )
+
 
 class TestDeclareManagedRegistersStrictTable:
     def test_strict_declaration_registers_table(self):

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_model_meta.py

@@ -32,7 +32,7 @@ class TestModelOptions:
             unique_together=[],
             constraints=[],
         )
-        assert opts.qualified_table_name == "my_table"
+        assert opts.qualified_table_name == "public.my_table"
 
     def test_qualified_table_name_with_schema(self):
         opts = ModelOptions(

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_query_builder.py

@@ -110,7 +110,7 @@ class TestBuildQuery:
         qb = QueryBuilder(M).filter(name="Alice").limit(10)
         q = qb._build_query()
         assert q["model"] is M
-        assert q["table"] == "qb_table"
+        assert q["table"] == "public.qb_table"
         # filters is now a list of dicts/Q objects — find the dict that contains "name"
         filter_items = q["filters"]
         combined = {}

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_relational_backfill.py

@@ -100,13 +100,13 @@ async def test_set_based_backfills_render_model_owned_statements(
     ) == 1
 
     assert "ensure_personal_organization(target.owner_id)" in statements[0]
-    assert "UPDATE mentions AS target" in statements[1]
-    assert "FROM chunks AS source" in statements[1]
+    assert "UPDATE public.mentions AS target" in statements[1]
+    assert "FROM public.chunks AS source" in statements[1]
     dominant = statements[2]
-    assert "JOIN chunks AS authority" in dominant
+    assert "JOIN public.chunks AS authority" in dominant
     assert "authority.organization_id AS value" in dominant
     assert "ORDER BY n DESC, value ASC" in dominant
-    assert "UPDATE entities AS target" in dominant
+    assert "UPDATE public.entities AS target" in dominant
 
 
 @pytest.mark.asyncio

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_typed_join_projection.py

@@ -79,7 +79,8 @@ def test_join_accepts_composed_typed_predicate() -> None:
     sql, params = executor.query, executor.params
 
     assert (
-        "JOIN joined ON (public.base.id = public.joined.base_id AND public.joined.active IS TRUE)"
+        "JOIN public.joined ON (public.base.id = public.joined.base_id "
+        "AND public.joined.active IS TRUE)"
     ) in sql
     assert params == []
 

{matrx_orm-3.1.65 → matrx_orm-3.1.67}/tests/level1/test_typed_predicates.py

@@ -104,7 +104,10 @@ def test_exists_is_composable_and_outer_ref_is_correlated() -> None:
     sql, params = _sql(Parent.filter(Is(F("enabled"), True) | ~child_exists))
 
     assert "enabled IS TRUE" in sql
-    assert "NOT (EXISTS (SELECT 1 FROM children WHERE parent_id = parents.id))" in sql
+    assert (
+        "NOT (EXISTS (SELECT 1 FROM public.children "
+        "WHERE parent_id = public.parents.id))"
+    ) in sql
     assert params == []
 
 
@@ -129,9 +132,9 @@ def test_nested_exists_correlates_to_immediately_enclosing_query() -> None:
 
     sql, _ = _sql(Parent.filter(nested))
 
-    assert "parent_id = parents.id" in sql
+    assert "parent_id = public.parents.id" in sql
     assert "child_id = c.id" in sql
-    assert "child_id = parents.id" not in sql
+    assert "child_id = public.parents.id" not in sql
 
 
 def test_nested_exists_shifts_parameters_at_every_query_level() -> None:
@@ -249,10 +252,10 @@ def test_outer_ref_is_preserved_through_cast_json_path_and_function() -> None:
 
     sql, params = _sql(Parent.filter(nested))
 
-    assert "CAST(parents.id AS text) = parent_id" in sql
-    assert "LOWER(parents.name) = LOWER(id)" in sql
-    assert "((parents.metadata -> $1) ->> $2) IS NOT NULL" in sql
-    assert "public.can_read_parent(parents.id, id) = $3" in sql
+    assert "CAST(public.parents.id AS text) = parent_id" in sql
+    assert "LOWER(public.parents.name) = LOWER(id)" in sql
+    assert "((public.parents.metadata -> $1) ->> $2) IS NOT NULL" in sql
+    assert "public.can_read_parent(public.parents.id, id) = $3" in sql
     assert params == ["source", "id", True]