matrx-orm 3.1.80__tar.gz → 3.1.82__tar.gz

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: matrx-orm
-Version: 3.1.80
+Version: 3.1.82
 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.80 → matrx_orm-3.1.82}/matrx_orm/core/FEATURE.md

@@ -25,6 +25,15 @@ guard and ensures diagnostic sinks such as `public.app_log` and
 Pinned by `tests/level1/test_model_meta.py` and
 `tests/level1/test_managed_write_guard.py`.
 
+**Every registered model is discoverable by its resolved table identity.**
+`ModelRegistry` indexes `_meta.table_name`, including the snake-case default
+derived by `ModelMeta`; `_table_name` is only the compatibility fallback. A
+generated model therefore remains reachable through
+`get_model_by_table_name(schema, table)` even when its class does not repeat the
+resolved table name as a raw attribute.
+
+Pinned by `tests/level1/test_registry.py`.
+
 ## Database execution errors
 
 `AsyncDatabaseManager.execute_query` must classify every PostgreSQL integrity
@@ -119,6 +128,8 @@ Verified against code: 2026-08-17.
 
 ## Change log
 
+- 2026-08-18: Indexed ModelMeta-derived table names so generated models remain
+  discoverable by exact schema/table identity.
 - 2026-08-18: Preserved successful query results when asyncpg times out while
   resetting and discarding the released connection.
 - 2026-08-18: Let waiters reuse healthy connections released behind a slow

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/matrx_orm/core/expressions.py

@@ -810,28 +810,133 @@ class Exists(Predicate):
         return f"Exists({self.queryset!r})"
 
 
-def _iter_subquery_conditions(filters: Any):
-    """Flatten a ``_build_query()`` filters LIST into (key, value) pairs.
+_SUBQUERY_COMPARISON_OPERATORS = {
+    "eq": "=",
+    "ne": "<>",
+    "gt": ">",
+    "gte": ">=",
+    "lt": "<",
+    "lte": "<=",
+}
+
 
-    Handles dict items and leaf Q items (the correlated-subquery case). A
-    compound or negated Q in a subquery raises ``NotImplementedError`` — better a
-    clear error than silently-wrong SQL.
+def _render_subquery_condition(
+    field_name: str,
+    operator: str,
+    value: Any,
+    *,
+    current_table: str,
+    outer_table: str,
+    params: list[Any],
+    sub_params: list[Any],
+) -> str:
+    """Render ONE ``WHERE`` condition INSIDE a subquery, expression values included.
+
+    The inner query of a Subquery/Exists is a real query: its own filters may
+    carry a nested ``Subquery``/``Exists``/``Func`` value, exactly like the
+    outer builder's ``_build_condition_with_expr`` handles. Before this, the
+    inner renderer fell through to ``_build_condition``, which emitted
+    ``field = ANY($n)`` and bound the *expression object itself* as a
+    parameter — asyncpg then failed to encode it at execute time (the
+    aidream ``conversations`` search+provider failure).
+
+    Placeholder numbering: expression values render against ``params +
+    sub_params`` so their ``$n`` are already absolute, and the params they
+    append are folded back into ``sub_params`` in order.
     """
-    for item in filters:
-        if isinstance(item, dict):
-            yield from item.items()
-            continue
-        kwargs = getattr(item, "kwargs", None)
-        children = getattr(item, "children", None)
-        if kwargs is not None and children is not None:  # a Q node
-            if children or getattr(item, "negated", False):
-                raise NotImplementedError(
-                    "Subquery/Exists supports only simple keyword filters in the "
-                    "inner query (compound/negated Q is not yet supported)."
+    from matrx_orm.query.executor import _SKIP_PARAM, QueryExecutor
+
+    if isinstance(value, OuterRef):
+        return f"{field_name} = {outer_table}.{value.field_name}"
+
+    if isinstance(value, Subquery | Exists | Func):
+        combined = [*params, *sub_params]
+        already_bound = len(combined)
+        if isinstance(value, Func):
+            expr_sql = value.as_sql(combined)
+            sql_operator = _SUBQUERY_COMPARISON_OPERATORS.get(operator)
+            if sql_operator is None:
+                raise ValueError(
+                    f"Lookup {operator!r} is not supported with a database expression"
                 )
-            yield from kwargs.items()
-            continue
-        raise TypeError(f"Unexpected subquery filter item: {type(item)!r}")
+            condition = f"{field_name} {sql_operator} {expr_sql}"
+        elif isinstance(value, Exists):
+            condition = value.as_sql(
+                combined,
+                current_table=current_table,
+                outer_table=outer_table,
+            )
+        else:
+            sub_sql = value.as_sql(current_table, combined)
+            condition = (
+                f"{field_name} IN {sub_sql}"
+                if operator == "in"
+                else f"{field_name} = {sub_sql}"
+            )
+        sub_params.extend(combined[already_bound:])
+        return condition
+
+    cond, param = QueryExecutor._build_condition(
+        field_name, operator, value, len(params) + len(sub_params) + 1
+    )
+    if param is not _SKIP_PARAM:
+        # json_key with (key, expected) maps to two placeholders.
+        if isinstance(param, tuple):
+            sub_params.extend(param)
+        else:
+            sub_params.append(param)
+    return cond
+
+
+def _render_subquery_q(
+    q: Any,
+    *,
+    current_table: str,
+    outer_table: str,
+    params: list[Any],
+    sub_params: list[Any],
+) -> str:
+    """Render a Q tree (compound / negated included) inside a subquery."""
+    if q.is_leaf:
+        conditions = []
+        for key, value in q.kwargs.items():
+            field_name, operator = _parse_lookup_simple(key)
+            conditions.append(
+                _render_subquery_condition(
+                    F(field_name).field_name,
+                    operator,
+                    value,
+                    current_table=current_table,
+                    outer_table=outer_table,
+                    params=params,
+                    sub_params=sub_params,
+                )
+            )
+        sql = " AND ".join(c for c in conditions if c)
+    else:
+        child_sqls = [
+            _render_subquery_q(
+                child,
+                current_table=current_table,
+                outer_table=outer_table,
+                params=params,
+                sub_params=sub_params,
+            )
+            for child in q.children
+        ]
+        child_sqls = [c for c in child_sqls if c]
+        if not child_sqls:
+            return ""
+        if q.connector not in {"AND", "OR"}:
+            raise ValueError(f"Unsupported Q connector: {q.connector!r}")
+        sql = (
+            child_sqls[0]
+            if len(child_sqls) == 1
+            else "(" + f" {q.connector} ".join(child_sqls) + ")"
+        )
+    if sql and q.negated:
+        sql = f"NOT ({sql})"
+    return sql
 
 
 def _render_subquery(
@@ -875,10 +980,11 @@ def _render_subquery(
 
     # ``_build_query()`` returns ``filters`` as a LIST of dict / Q items (never a
     # dict) — iterating it as a dict silently broke every correlated Subquery/
-    # Exists. Flatten the simple-keyword items (the correlated-subquery case);
-    # compound/negated Q in a subquery raises rather than emit wrong SQL.
+    # Exists. Each item is rendered IN ORDER so placeholder numbers and the
+    # params appended to ``sub_params`` stay in lockstep. The inner query is a
+    # real query: compound/negated Q and nested Subquery/Exists/Func values all
+    # render here, rather than raising or binding an expression as a parameter.
     filter_items = query_dict.get("filters", [])
-    ordinary_filter_items: list[Any] = []
     current_table = query_dict.get("from_alias") or table
     outer_param_count = len(params)
     for item in filter_items:
@@ -889,25 +995,34 @@ def _render_subquery(
                 outer_table=outer_table,
             )
             where_conditions.append(_shift_param_refs(predicate_sql, outer_param_count))
-        else:
-            ordinary_filter_items.append(item)
-
-    for key, value in _iter_subquery_conditions(ordinary_filter_items):
-        field_name, operator = _parse_lookup_simple(key)
-        field_name = F(field_name).field_name
-        # Resolve OuterRef → outer_table.field
-        if isinstance(value, OuterRef):
-            condition = f"{field_name} = {outer_table}.{value.field_name}"
-            where_conditions.append(condition)
             continue
-        from matrx_orm.query.executor import _SKIP_PARAM, QueryExecutor
-
-        cond, param = QueryExecutor._build_condition(
-            field_name, operator, value, len(params) + len(sub_params) + 1
-        )
-        where_conditions.append(cond)
-        if param is not _SKIP_PARAM:
-            sub_params.append(param)
+        if isinstance(item, dict):
+            for key, value in item.items():
+                field_name, operator = _parse_lookup_simple(key)
+                where_conditions.append(
+                    _render_subquery_condition(
+                        F(field_name).field_name,
+                        operator,
+                        value,
+                        current_table=current_table,
+                        outer_table=outer_table,
+                        params=params,
+                        sub_params=sub_params,
+                    )
+                )
+            continue
+        if isinstance(item, Q):
+            rendered = _render_subquery_q(
+                item,
+                current_table=current_table,
+                outer_table=outer_table,
+                params=params,
+                sub_params=sub_params,
+            )
+            if rendered:
+                where_conditions.append(rendered)
+            continue
+        raise TypeError(f"Unexpected subquery filter item: {type(item)!r}")
 
     # Explicit JOINs (``.join()`` on the INNER queryset) — the correlated-rollup
     # pattern often needs to count/aggregate through a join (e.g. "how many of

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/matrx_orm/core/registry.py

@@ -48,6 +48,15 @@ def _database_of(model_class: type[Model]) -> str:
         return raw
 
 
+def _table_of(model_class: type[Model]) -> str | None:
+    """The canonical table name, including ModelMeta-derived defaults."""
+    meta = getattr(model_class, "_meta", None)
+    table = getattr(meta, "table_name", None) if meta is not None else None
+    if not table:
+        table = getattr(model_class, "_table_name", None)
+    return table or None
+
+
 class ModelRegistry:
     """Global model registry keyed on ``(database, schema, class_name)``.
 
@@ -88,7 +97,7 @@ class ModelRegistry:
             )
         cls._models[key] = model_class
         cls._by_name.setdefault(name, {})[(database, schema)] = model_class
-        table_name = getattr(model_class, "_table_name", None)
+        table_name = _table_of(model_class)
         if table_name:
             table_key = (database, schema, table_name)
             table_existing = cls._by_table.get(table_key)

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/matrx_orm/secrets_battery/FEATURE.md

@@ -174,6 +174,8 @@ A restricted secret is readable only by a user holding a `can_use` row in
 flag the host computes and passes down. Since Phase 1/2 the ITEM is the sharing
 unit: grants carry `credential_item_id` (field-level `user_secret_id` grants
 remain readable during migration; a CHECK requires at least one target).
+Bulk restricted-org resolution accepts either the canonical item-level grant
+or a legacy field-level grant; new writers create item-level grants only.
 `set_item_grants` takes per-grantee `ItemGrantSpec {user_id, can_use,
 can_manage}` — `can_manage` = edit + reveal-revealable, never
 share/transfer/delete — and writes ITEM-level rows only (exactly one target
@@ -213,8 +215,9 @@ losing the trail must not also lose the work.
 
 ## Key rotation
 
-`scripts/rotate_credentials_key.py` (aidream) re-encrypts every row from an OLD
-key to a NEW one: batched keyset pagination, per-row verify-before-commit,
+`scripts/rotate_credentials_key.py` (aidream) re-encrypts every field and
+protected-file attachment from an OLD key to a NEW one: batched keyset
+pagination, per-row verify-before-commit,
 naturally resumable (already-under-new-key rows are skipped), state-file
 checkpoints with key-fingerprint guards, `--dry-run`, and symmetric rollback
 (re-run with the keys swapped). It builds its Fernets ONLY through this
@@ -248,7 +251,8 @@ contributed org copies show `out_of_sync` afterward (cosmetic).
   resolution — a broken row must not deny every other key.
 
 Drift guard: `scripts/validate_secrets_decrypt.py` (loud, non-blocking, in
-`release.sh`) asserts every active row still decrypts with the configured key.
+`release.sh`) asserts every active field and attachment still decrypts with the
+configured key.
 
 Verified against live code + the live `users.user_secrets` /
 `users.credential_items` schema 2026-07-23 (item-layer smoke run live: bundle
@@ -256,6 +260,10 @@ create, reveal, sealed denial, editable gate, rotate, item grants, soft delete).
 
 ## Change Log
 
+- **2026-08-18** — Extended key rotation and decrypt-drift validation across
+  protected-file attachment ciphertext, with field-and-file regression proof.
+- **2026-08-18** — Made restricted organization bulk resolution honor canonical
+  item-level grants while retaining legacy field-grant reads.
 - **2026-08-11** — Added first-class encrypted credential-file attachments with
   parent-owned access/lifecycle, a 25 MiB cap, one-way sealing, audited human
   download, trusted execution resolution, and fork/delete inheritance.

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/matrx_orm/secrets_battery/org_service.py

@@ -524,25 +524,44 @@ async def resolve_org_secrets(
         filters["key__isnull"] = False
     if keys:
         filters["key__in"] = keys
-    rows = await UserSecret.filter(**filters).values("id", "key", "value_encrypted", "access_mode")
+    rows = await UserSecret.filter(**filters).values(
+        "id", "credential_item_id", "key", "value_encrypted", "access_mode"
+    )
     if for_sandbox:
         rows = _keyed_for_sandbox(rows, scope=f"organization {organization_id}")
     if not rows:
         return {}
 
-    restricted_ids = [str(r["id"]) for r in rows if r.get("access_mode") == "restricted"]
-    granted: set[str] = set()
+    restricted_rows = [r for r in rows if r.get("access_mode") == "restricted"]
+    restricted_ids = [str(r["id"]) for r in restricted_rows]
+    restricted_item_ids = sorted(
+        {str(r["credential_item_id"]) for r in restricted_rows if r.get("credential_item_id")}
+    )
+    granted_field_ids: set[str] = set()
+    granted_item_ids: set[str] = set()
     if restricted_ids and user_id and not is_org_admin:
-        grant_rows = await UserSecretGrant.filter(
+        field_grants = await UserSecretGrant.filter(
             user_secret_id__in=restricted_ids, user_id=user_id, can_use=True
         ).values("user_secret_id")
-        granted = {str(g["user_secret_id"]) for g in grant_rows}
+        granted_field_ids = {str(g["user_secret_id"]) for g in field_grants}
+        if restricted_item_ids:
+            item_grants = await UserSecretGrant.filter(
+                credential_item_id__in=restricted_item_ids,
+                user_id=user_id,
+                can_use=True,
+            ).values("credential_item_id")
+            granted_item_ids = {str(g["credential_item_id"]) for g in item_grants}
 
     resolved: dict[str, str] = {}
     used_ids: list[str] = []
     for row in rows:
         if row.get("access_mode") == "restricted" and not is_org_admin:
-            if str(row["id"]) not in granted:
+            field_granted = str(row["id"]) in granted_field_ids
+            item_granted = (
+                bool(row.get("credential_item_id"))
+                and str(row["credential_item_id"]) in granted_item_ids
+            )
+            if not field_granted and not item_granted:
                 continue
         try:
             resolved[str(row["key"])] = decrypt_value(row["value_encrypted"])

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.80"
+version = "3.1.82"
 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.80 → matrx_orm-3.1.82}/tests/level1/test_expression_primitives.py

@@ -21,7 +21,6 @@ from matrx_orm.core.expressions import (
     Q,
     Subquery,
     TsRank,
-    _iter_subquery_conditions,
 )
 from matrx_orm.query.executor import QueryExecutor, _render_update_expression
 
@@ -78,22 +77,24 @@ def test_ts_rank_allows_alternate_config():
     assert "to_tsvector('spanish', body)" in sql
 
 
-# ── _iter_subquery_conditions (the filters-LIST flattener) ──────────────────
+# ── Inner-query filter rendering (dict / leaf Q / compound Q / negated Q) ───
+# The flattener that raised on compound/negated Q was replaced by
+# _render_subquery_q; see test_subquery_nested_expressions.py for the tree
+# cases. These pin the flat shapes at the SQL-text level.
 
 
-def test_iter_subquery_conditions_dicts_and_leaf_q():
-    items = [{"a": 1}, Q(b=2)]
-    assert list(_iter_subquery_conditions(items)) == [("a", 1), ("b", 2)]
-
-
-def test_iter_subquery_conditions_rejects_compound_q():
-    with pytest.raises(NotImplementedError, match="simple keyword"):
-        list(_iter_subquery_conditions([Q(a=1) | Q(b=2)]))
-
+def test_subquery_renders_dict_and_leaf_q_filters():
+    from matrx_orm.core.registry import ModelRegistry
 
-def test_iter_subquery_conditions_rejects_negated_q():
-    with pytest.raises(NotImplementedError):
-        list(_iter_subquery_conditions([~Q(a=1)]))
+    ModelRegistry.clear()
+    _parent, child = _models()
+    params: list = []
+    sql = Subquery(child.filter(n=1).filter(Q(site_id="s")).select("id")).as_sql(
+        "public.sites", params
+    )
+    assert "WHERE n = $1 AND site_id = $2" in sql
+    assert params == [1, "s"]
+    ModelRegistry.clear()
 
 
 # ── End-to-end SQL (pattern B — dummy adapter) ──────────────────────────────

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/tests/level1/test_registry.py

@@ -91,12 +91,10 @@ class TestGetModelByTable:
         ModelRegistry.register(M)
         assert ModelRegistry.get_model_by_table("public", "table_test_2") is M
 
-    def test_model_without_table_name_not_indexed(self):
+    def test_modelmeta_derived_table_name_is_indexed(self):
         M = _make_model("NoTableName")
         ModelRegistry.register(M)
-        # No _table_name set -> nothing to look up by table; must not crash
-        # and must not accidentally satisfy an unrelated lookup.
-        assert ModelRegistry.get_model_by_table("public", "") is None
+        assert ModelRegistry.get_model_by_table("public", "no_table_name") is M
 
     def test_wrong_schema_returns_none(self):
         M = _make_model("TableTest3", table_name="table_test_3", schema="widgets")

matrx_orm-3.1.82/tests/level1/test_subquery_nested_expressions.py

@@ -0,0 +1,167 @@
+"""Level 1: a Subquery whose INNER queryset itself carries an expression filter.
+
+Grown from a live production failure in aidream's ``conversations`` tool
+("search my Claude Code conversations"): the search path scopes a message-text
+lookup to the caller's conversations with
+``Message.filter(conversation_id__in=Subquery(summaries))`` — and ``summaries``
+was itself already filtered with ``id__in=Subquery(coding_sessions)`` for the
+provider filter. The OUTER builder understands an expression value
+(``_build_condition_with_expr``); ``_render_subquery`` did not — it fell
+through to ``_build_condition``, emitting ``id = ANY($n)`` and BINDING THE
+``Subquery`` OBJECT AS A PARAMETER. asyncpg then failed to encode it, so
+search+provider died while search-alone and list+provider both worked.
+
+The same renderer also rejected a compound/negated ``Q`` in an inner queryset
+(``origin_class='unknown'`` renders ``Q(...) | Q(...)``), which is the same
+"the inner query is a real query too" gap.
+
+Pure SQL-text assertions — no DB needed.
+"""
+
+from __future__ import annotations
+
+import pytest
+from matrx_orm.core.base import Model, ModelMeta
+from matrx_orm.core.expressions import Now, OuterRef, Q, Subquery
+from matrx_orm.core.fields import BooleanField, DateTimeField, TextField, UUIDField
+from matrx_orm.core.registry import ModelRegistry
+
+
+@pytest.fixture(autouse=True)
+def _clean_registry():
+    ModelRegistry.clear()
+    yield
+    ModelRegistry.clear()
+
+
+def _models():
+    Summary = ModelMeta(
+        "SummaryM",
+        (Model,),
+        {
+            "id": UUIDField(primary_key=True),
+            "user_id": TextField(null=True),
+            "origin_class": TextField(null=True),
+            "updated_at": DateTimeField(null=True),
+            "_database": "test_db",
+            "_table_name": "conversation_summary",
+            "_db_schema": "chat",
+        },
+    )
+    Session = ModelMeta(
+        "SessionM",
+        (Model,),
+        {
+            "id": UUIDField(primary_key=True),
+            "conversation_id": UUIDField(null=True),
+            "provider": TextField(null=True),
+            "created_by": TextField(null=True),
+            "_database": "test_db",
+            "_table_name": "coding_session",
+            "_db_schema": "chat",
+        },
+    )
+    Message = ModelMeta(
+        "MessageM",
+        (Model,),
+        {
+            "id": UUIDField(primary_key=True),
+            "conversation_id": UUIDField(null=True),
+            "is_visible_to_user": BooleanField(default=True),
+            "_database": "test_db",
+            "_table_name": "message",
+            "_db_schema": "chat",
+        },
+    )
+    return Summary, Session, Message
+
+
+class TestNestedSubqueryValue:
+    def test_inner_subquery_renders_as_sql_not_a_bound_parameter(self):
+        Summary, Session, Message = _models()
+        sessions = Session.filter(created_by="u1", provider="claude_code").select("conversation_id")
+        summaries = Summary.filter(user_id="u1").filter(id__in=Subquery(sessions)).select("id")
+
+        qb = Message.filter(conversation_id__in=Subquery(summaries))
+        executor = qb._get_executor()
+        params: list = []
+        cond, _ = executor._build_condition_with_expr(
+            "conversation_id", "in", Subquery(summaries), params
+        )
+
+        # The nested provider filter must be SQL, never a bind parameter.
+        assert "id IN (SELECT conversation_id FROM chat.coding_session" in cond
+        assert "ANY(" not in cond
+        assert all(not isinstance(p, Subquery) for p in params)
+        # Every placeholder in the rendered condition must have a real param.
+        assert params == ["u1", "u1", "claude_code"]
+        assert "$1" in cond and "$2" in cond and "$3" in cond
+        assert "$4" not in cond
+
+    def test_placeholder_numbering_is_contiguous_with_outer_params(self):
+        Summary, Session, Message = _models()
+        sessions = Session.filter(provider="codex").select("conversation_id")
+        summaries = Summary.filter(user_id="u9").filter(id__in=Subquery(sessions)).select("id")
+
+        qb = Message.filter(conversation_id__in=Subquery(summaries))
+        executor = qb._get_executor()
+        params: list = ["already-bound"]
+        cond, _ = executor._build_condition_with_expr(
+            "conversation_id", "in", Subquery(summaries), params
+        )
+
+        assert params == ["already-bound", "u9", "codex"]
+        assert "$2" in cond and "$3" in cond
+        assert "$1" not in cond
+
+    def test_compound_q_in_inner_queryset_renders(self):
+        Summary, _Session, Message = _models()
+        summaries = (
+            Summary.filter(user_id="u1")
+            .filter(Q(origin_class="unknown") | Q(origin_class__isnull=True))
+            .select("id")
+        )
+        params: list = []
+        sql = Subquery(summaries).as_sql("chat.message", params)
+
+        assert "(origin_class = $2 OR origin_class IS NULL)" in sql
+        assert params == ["u1", "unknown"]
+
+    def test_negated_q_in_inner_queryset_renders(self):
+        Summary, _Session, _Message = _models()
+        summaries = Summary.filter(user_id="u1").filter(~Q(origin_class="human")).select("id")
+        params: list = []
+        sql = Subquery(summaries).as_sql("chat.message", params)
+
+        assert "NOT (origin_class = $2)" in sql
+        assert params == ["u1", "human"]
+
+    def test_outer_ref_still_correlates_through_a_q(self):
+        Summary, Session, _Message = _models()
+        inner = Session.filter(Q(conversation_id=OuterRef("id"))).select("conversation_id")
+        params: list = []
+        sql = Subquery(inner).as_sql("chat.conversation_summary", params)
+
+        assert "conversation_id = chat.conversation_summary.id" in sql
+        assert params == []
+
+    def test_database_function_value_inside_inner_queryset(self):
+        Summary, Session, _Message = _models()
+        Session_ = ModelMeta(
+            "SessionTimeM",
+            (Model,),
+            {
+                "id": UUIDField(primary_key=True),
+                "conversation_id": UUIDField(null=True),
+                "last_seen_at": DateTimeField(null=True),
+                "_database": "test_db",
+                "_table_name": "coding_session",
+                "_db_schema": "chat",
+            },
+        )
+        inner = Session_.filter(last_seen_at__lt=Now()).select("conversation_id")
+        params: list = []
+        sql = Subquery(inner).as_sql("chat.conversation_summary", params)
+
+        assert "last_seen_at < NOW()" in sql
+        assert params == []

{matrx_orm-3.1.80 → matrx_orm-3.1.82}/tests/test_secrets_battery.py

@@ -459,6 +459,47 @@ async def test_non_sandbox_resolution_still_drops_keyless_rows_silently(monkeypa
     assert not [r for r in caplog.records if r.levelno >= logging.ERROR]
 
 
+@pytest.mark.asyncio
+async def test_restricted_org_resolution_honors_item_level_grants(monkeypatch):
+    from matrx_orm.secrets_battery import org_service
+
+    rows = [
+        {
+            "id": "field-1",
+            "credential_item_id": "item-1",
+            "key": "APPLE_PRIVATE_KEY",
+            "value_encrypted": b"ciphertext",
+            "access_mode": "restricted",
+        }
+    ]
+    secret_filters: list[dict] = []
+    grant_filters: list[dict] = []
+    monkeypatch.setattr(org_service, "UserSecret", _fake_user_secret(rows, secret_filters))
+    monkeypatch.setattr(org_service, "decrypt_value", lambda _ciphertext: "private-key")
+
+    class _FakeGrant:
+        @classmethod
+        def filter(cls, **filters):
+            grant_filters.append(filters)
+            if "credential_item_id__in" in filters:
+                return _FakeQB([{"credential_item_id": "item-1"}])
+            return _FakeQB([])
+
+    monkeypatch.setattr(org_service, "UserSecretGrant", _FakeGrant)
+
+    resolved = await org_service.resolve_org_secrets("org-1", user_id="user-1")
+
+    assert resolved == {"APPLE_PRIVATE_KEY": "private-key"}
+    assert grant_filters == [
+        {"user_secret_id__in": ["field-1"], "user_id": "user-1", "can_use": True},
+        {
+            "credential_item_id__in": ["item-1"],
+            "user_id": "user-1",
+            "can_use": True,
+        },
+    ]
+
+
 # ── Sealed reveal refusal + liveness filters ──────────────────────────────