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

{matrx_orm-3.1.67 → matrx_orm-3.1.69}/.gitignore

@@ -277,3 +277,9 @@ credentials.json
 token*.pickle
 token*.json
 tests_trials/rag_tests/kg_export_output/
+
+# Pooler-contamination watch output (machine-local evidence, not source)
+db/evidence/
+
+# Pooler contamination evidence — machine-local forensic capture, not source
+db/evidence/

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

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

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from .catalog_sql import PG_CATALOG_COLUMNS_CTE, PG_CATALOG_TABLES_CTE
 from .core.async_db_manager import AsyncDatabaseManager
 
 __all__ = [
@@ -42,12 +43,18 @@ async def list_relations(
     kinds: tuple[str, ...] = ("BASE TABLE", "VIEW"),
     exclude_schemas: list[str] | None = None,
 ) -> list[dict[str, str]]:
-    """Return schema/name/kind rows from information_schema.tables."""
+    """Return schema/name/kind rows for application relations.
+
+    pg_catalog, not information_schema: audit callers treat this enumeration as
+    the complete relation set, so a privilege-filtered source silently drops live
+    tables and reports them missing. See matrx_orm/catalog_sql.py.
+    """
     return await _query(
         database,
-        """
+        f"""
+        WITH {PG_CATALOG_TABLES_CTE.strip()}
         SELECT table_schema, table_name, table_type
-        FROM information_schema.tables
+        FROM pg_catalog_tables
         WHERE ($1::text[] IS NULL OR table_schema = ANY($1::text[]))
           AND table_type = ANY($2::text[])
           AND ($3::text[] IS NULL OR table_schema <> ALL($3::text[]))
@@ -64,9 +71,9 @@ async def application_schemas(database: str, *, exclude_schemas: list[str]) -> l
     rows = await _query(
         database,
         """
-        SELECT schema_name
-        FROM information_schema.schemata
-        WHERE schema_name <> ALL($1::text[])
+        SELECT nspname AS schema_name
+        FROM pg_namespace
+        WHERE nspname <> ALL($1::text[])
         ORDER BY schema_name
         """,
         exclude_schemas,
@@ -79,10 +86,12 @@ async def relation_schemas(database: str, *, table: str, exclude_schemas: list[s
     rows = await _query(
         database,
         """
-        SELECT DISTINCT table_schema
-        FROM information_schema.tables
-        WHERE table_name = $1
-          AND table_schema <> ALL($2::text[])
+        SELECT DISTINCT n.nspname AS table_schema
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1
+          AND c.relkind = ANY ('{r,p,v,m,f}')
+          AND n.nspname <> ALL($2::text[])
         ORDER BY table_schema
         """,
         table,
@@ -105,16 +114,18 @@ async def describe_relation_columns(
           c.is_nullable,
           c.column_default,
           EXISTS (
+            -- pg_catalog: "is this column part of the primary key" is an
+            -- existence decision, and the information_schema constraint views are
+            -- privilege-filtered. See matrx_orm/catalog_sql.py.
             SELECT 1
-            FROM information_schema.table_constraints tc
-            JOIN information_schema.key_column_usage kcu
-              ON tc.constraint_name = kcu.constraint_name
-             AND tc.table_schema = kcu.table_schema
-             AND tc.table_name = kcu.table_name
-            WHERE tc.constraint_type = 'PRIMARY KEY'
-              AND tc.table_schema = c.table_schema
-              AND tc.table_name = c.table_name
-              AND kcu.column_name = c.column_name
+            FROM pg_index i
+            JOIN pg_class pc ON pc.oid = i.indrelid
+            JOIN pg_namespace pn ON pn.oid = pc.relnamespace
+            JOIN pg_attribute pa ON pa.attrelid = pc.oid AND pa.attnum = ANY (i.indkey)
+            WHERE i.indisprimary
+              AND pn.nspname = c.table_schema
+              AND pc.relname = c.table_name
+              AND pa.attname = c.column_name
           ) AS is_primary_key
         FROM information_schema.columns c
         WHERE c.table_schema = $1 AND c.table_name = $2
@@ -130,10 +141,15 @@ async def relation_column_counts(database: str) -> list[dict[str, Any]]:
     return await _query(
         database,
         """
-        SELECT table_schema, table_name, COUNT(*)::int AS column_count
-        FROM information_schema.columns
-        WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
-        GROUP BY table_schema, table_name
+        SELECT n.nspname AS table_schema, c.relname AS table_name,
+               COUNT(*)::int AS column_count
+        FROM pg_attribute a
+        JOIN pg_class c ON c.oid = a.attrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+          AND a.attnum > 0 AND NOT a.attisdropped
+          AND c.relkind = ANY ('{r,p,v,m,f}')
+        GROUP BY n.nspname, c.relname
         ORDER BY table_schema, table_name
         """,
     )
@@ -234,23 +250,31 @@ async def entity_capability_state(database: str) -> list[dict[str, Any]]:
           ) AS really_versioned,
           EXISTS (
             SELECT 1
-            FROM information_schema.columns col
-            WHERE col.table_schema = et.schema_name
-              AND col.table_name = et.table_name
-              AND col.column_name = 'deleted_at'
+            FROM pg_attribute a
+            JOIN pg_class pc ON pc.oid = a.attrelid
+            JOIN pg_namespace pn ON pn.oid = pc.relnamespace
+            WHERE pn.nspname = et.schema_name
+              AND pc.relname = et.table_name
+              AND a.attname = 'deleted_at'
+              AND a.attnum > 0 AND NOT a.attisdropped
           ) AS really_soft_delete,
           EXISTS (
             SELECT 1
-            FROM information_schema.columns col
-            WHERE col.table_schema = et.schema_name
-              AND col.table_name = et.table_name
-              AND col.column_name = 'version'
+            FROM pg_attribute a
+            JOIN pg_class pc ON pc.oid = a.attrelid
+            JOIN pg_namespace pn ON pn.oid = pc.relnamespace
+            WHERE pn.nspname = et.schema_name
+              AND pc.relname = et.table_name
+              AND a.attname = 'version'
+              AND a.attnum > 0 AND NOT a.attisdropped
           ) AS has_version_column,
           EXISTS (
             SELECT 1
-            FROM information_schema.tables tb
-            WHERE tb.table_schema = et.schema_name
-              AND tb.table_name = et.table_name
+            FROM pg_class pc2
+            JOIN pg_namespace pn2 ON pn2.oid = pc2.relnamespace
+            WHERE pn2.nspname = et.schema_name
+              AND pc2.relname = et.table_name
+              AND pc2.relkind = ANY ('{r,p,v,m,f}')
           ) AS table_exists
         FROM platform.entity_types et
         ORDER BY et.token
@@ -263,8 +287,10 @@ async def qualified_relation_names(database: str) -> set[str]:
     rows = await _query(
         database,
         """
-        SELECT DISTINCT table_schema, table_name
-        FROM information_schema.tables
+        SELECT DISTINCT n.nspname AS table_schema, c.relname AS table_name
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind = ANY ('{r,p,v,m,f}')
         ORDER BY table_schema, table_name
         """,
     )
@@ -414,9 +440,11 @@ async def org_backstop_coverage(database: str) -> list[dict[str, Any]]:
     """Return required org-id relations with owner/backstop booleans."""
     return await _query(
         database,
-        """
+        f"""
+        WITH {PG_CATALOG_COLUMNS_CTE.strip()},
+             {PG_CATALOG_TABLES_CTE.strip()}
         SELECT c.table_schema AS schema, c.table_name,
-          EXISTS (SELECT 1 FROM information_schema.columns o
+          EXISTS (SELECT 1 FROM pg_catalog_columns o
             WHERE o.table_schema=c.table_schema AND o.table_name=c.table_name
               AND o.column_name IN ('created_by','user_id','owner_id')) AS has_owner,
           EXISTS (SELECT 1 FROM pg_trigger t
@@ -424,8 +452,8 @@ async def org_backstop_coverage(database: str) -> list[dict[str, Any]]:
             JOIN pg_namespace n ON n.oid=cl.relnamespace
             WHERE n.nspname=c.table_schema AND cl.relname=c.table_name
               AND t.tgname='_stamp_org_default' AND NOT t.tgisinternal) AS has_backstop
-        FROM information_schema.columns c
-        JOIN information_schema.tables tb
+        FROM pg_catalog_columns c
+        JOIN pg_catalog_tables tb
           ON tb.table_schema=c.table_schema AND tb.table_name=c.table_name
           AND tb.table_type='BASE TABLE'
         WHERE c.column_name='organization_id' AND c.is_nullable='NO'
@@ -602,10 +630,15 @@ async def actor_stamp_column_drift(
         WHERE p.proname = $1
           AND NOT t.tgisinternal
           AND NOT EXISTS (
-            SELECT 1 FROM information_schema.columns c
-            WHERE c.table_schema = n.nspname
-              AND c.table_name = cl.relname
-              AND c.column_name = miss.col
+            -- pg_catalog, not information_schema: a privilege-filtered view here
+            -- manufactures "missing column" findings for columns that exist.
+            SELECT 1 FROM pg_attribute a2
+              JOIN pg_class c2 ON c2.oid = a2.attrelid
+              JOIN pg_namespace n2 ON n2.oid = c2.relnamespace
+            WHERE n2.nspname = n.nspname
+              AND c2.relname = cl.relname
+              AND a2.attname = miss.col
+              AND a2.attnum > 0 AND NOT a2.attisdropped
           )
         ORDER BY 1, 2, 4
         """,

matrx_orm-3.1.69/matrx_orm/catalog_sql.py

@@ -0,0 +1,115 @@
+"""Privilege-independent catalog SQL — the ONE source for "does this exist?".
+
+WHY THIS EXISTS (FOUND_DEFECTS, "Pooled connections intermittently run as
+`authenticated`, not `postgres`"):
+
+``information_schema.columns`` / ``.tables`` / ``.schemata`` are **privilege-
+filtered views**. They do not answer "does this object exist?" — they answer
+"does this object exist *and* does the current role hold some privilege on it?".
+Those two questions give the same answer right up until the session is not the
+role you assumed, and then the view reports EXISTING OBJECTS AS ABSENT with no
+error of any kind.
+
+That is not hypothetical here. It corrupted the migration ledger: a
+``fetch_db_state()`` that read ``information_schema`` while the pooler had handed
+back a session running as ``authenticated`` saw a smaller universe, so applied
+migrations were recorded as never applied (MIGRATIONS_STATUS.md APPLIED
+1200 -> 1171). The failure is silent and it is confidently wrong, which is the
+worst combination a guard can have.
+
+``pg_catalog`` (``pg_class`` / ``pg_attribute`` / ``pg_namespace``) is readable by
+PUBLIC and is **not** privilege-filtered, so it answers the existence question the
+same way regardless of which role the statement lands as.
+
+THE RULE: if the answer decides whether something EXISTS — an existence probe, a
+diff, a set subtraction, a "missing column" finding, a capability flag — it reads
+``pg_catalog``. ``information_schema`` is fine for *display* (browsing a schema,
+rendering a column list to a human) where a short answer is an acceptable answer.
+
+Note this is the same class of bug as reading a PostgREST list without paging and
+treating the first 1000 rows as the whole set: a partial answer, presented as
+complete, with nothing raised.
+"""
+
+from __future__ import annotations
+
+# Drop-in replacement for `information_schema.columns` for the columns our
+# existence checks actually use. Deliberately mirrors those column NAMES so a
+# query can be converted by swapping the FROM clause and nothing else.
+#
+#   is_nullable    'YES'/'NO'  — same domain as information_schema
+#   column_default text|NULL   — the expression, as information_schema renders it
+PG_CATALOG_COLUMNS_CTE = """
+pg_catalog_columns AS (
+    SELECT n.nspname                        AS table_schema,
+           c.relname                        AS table_name,
+           a.attname                        AS column_name,
+           a.attnum                         AS ordinal_position,
+           CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+           pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
+           format_type(a.atttypid, a.atttypmod) AS data_type
+      FROM pg_attribute a
+      JOIN pg_class     c  ON c.oid = a.attrelid
+      JOIN pg_namespace n  ON n.oid = c.relnamespace
+      LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
+     WHERE a.attnum > 0
+       AND NOT a.attisdropped
+       AND c.relkind = ANY ('{r,p,v,m,f}')
+)
+"""
+
+# Same idea for `information_schema.tables`. `table_type` mirrors the
+# information_schema spelling so callers can swap the FROM clause unchanged.
+PG_CATALOG_TABLES_CTE = """
+pg_catalog_tables AS (
+    SELECT n.nspname AS table_schema,
+           c.relname AS table_name,
+           CASE c.relkind
+                WHEN 'r' THEN 'BASE TABLE'
+                WHEN 'p' THEN 'BASE TABLE'
+                WHEN 'v' THEN 'VIEW'
+                WHEN 'm' THEN 'MATERIALIZED VIEW'
+                WHEN 'f' THEN 'FOREIGN TABLE'
+           END AS table_type
+      FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE c.relkind = ANY ('{r,p,v,m,f}')
+)
+"""
+
+# Standalone existence probes. Parameter-bound, never interpolated.
+SCHEMA_EXISTS_SQL = "SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = $1)"
+
+TABLE_EXISTS_SQL = """
+SELECT EXISTS (
+    SELECT 1 FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE n.nspname = $1 AND c.relname = $2
+       AND c.relkind = ANY ('{r,p,v,m,f}')
+)
+"""
+
+COLUMN_EXISTS_SQL = """
+SELECT EXISTS (
+    SELECT 1 FROM pg_attribute a
+      JOIN pg_class     c ON c.oid = a.attrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE n.nspname = $1 AND c.relname = $2 AND a.attname = $3
+       AND a.attnum > 0 AND NOT a.attisdropped
+)
+"""
+
+# Columns for a bounded set of tables in one schema — the shape used by the
+# schema-drift guards, where a privilege-shortened answer reads as "the code
+# claims a column the database does not have".
+COLUMNS_FOR_TABLES_SQL = """
+SELECT c.relname AS table_name, a.attname AS column_name
+  FROM pg_attribute a
+  JOIN pg_class     c ON c.oid = a.attrelid
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+ WHERE n.nspname = $1
+   AND c.relname = ANY ($2::text[])
+   AND a.attnum > 0
+   AND NOT a.attisdropped
+   AND c.relkind = ANY ('{r,p,v,m,f}')
+"""

{matrx_orm-3.1.67 → matrx_orm-3.1.69}/matrx_orm/core/introspection.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from matrx_orm.catalog_sql import COLUMNS_FOR_TABLES_SQL, SCHEMA_EXISTS_SQL
 from matrx_orm.core.async_db_manager import AsyncDatabaseManager
 from matrx_orm.core.transaction import get_active_connection
 
@@ -71,12 +72,11 @@ async def introspect_rls_policies(
     return [dict(r) for r in rows]
 
 
-_COLUMNS_SQL = """
-SELECT table_name, column_name
-FROM information_schema.columns
-WHERE table_schema = $1
-  AND table_name = ANY($2::text[])
-"""
+# pg_catalog, NOT information_schema: this decides whether a column EXISTS, and
+# information_schema is privilege-filtered — under a session that is not the role
+# we assume, present columns read as absent and the drift guard reports the code
+# as wrong about the schema. See matrx_orm/catalog_sql.py.
+_COLUMNS_SQL = COLUMNS_FOR_TABLES_SQL
 
 
 async def introspect_columns(database: str, schema: str, tables: list[str]) -> dict[str, list[str]]:
@@ -102,14 +102,17 @@ async def introspect_columns(database: str, schema: str, tables: list[str]) -> d
 
 async def schema_exists(database: str, schema: str) -> bool:
     """True if ``schema`` exists in ``database`` — a live
-    ``information_schema.schemata`` probe.
+    ``pg_catalog`` probe (privilege-independent).
 
     Another genuine no-Model-surface catalog question (same class as
     ``introspect_rls_policies`` above): "does this schema exist" is a fact
     about Postgres, not a row in an application table. ``schema`` is bound
     as a parameter (``$1``), never interpolated into the query text.
     """
-    sql = "SELECT EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = $1)"
+    # pg_catalog, not information_schema.schemata — the latter is privilege-
+    # filtered and answers "no such schema" for a schema that plainly exists
+    # whenever the session is not the role we assume.
+    sql = SCHEMA_EXISTS_SQL
 
     active_conn = get_active_connection()
     if active_conn is not None:

{matrx_orm-3.1.67 → matrx_orm-3.1.69}/matrx_orm/python_sql/table_detailed_relationships.py

@@ -10,6 +10,35 @@ def get_table_relationships(schema, database_project):
     """
     Executes the SQL query to fetch relationship information for all tables in the specified schema.
 
+    Reads `pg_catalog` (never `information_schema`) for three reasons:
+
+    1. CROSS-SCHEMA FKs. The old query enumerated constraints through
+       information_schema and joined `constraint_column_usage` with
+       `ccu.table_schema = tc.table_schema`, which silently DROPPED every FK
+       whose REFERENCED table lives in another schema. After the 2026 schema
+       reorg that is most of them — `created_by -> users.users.id`,
+       `organization_id -> iam.organizations.id`, and so on. Measured against
+       Matrx Main on 2026-08-15: platform 12 -> 36 FK rows, crm 32 -> 105,
+       chat 33 -> 117, with the pg_catalog set a strict superset every time.
+    2. COMPOSITE FKs. `key_column_usage` and `constraint_column_usage` were
+       joined on constraint name alone, with no pairing on ordinal position, so
+       a two-column FK cartesian-joined into four bogus column pairs. The
+       `unnest(...) WITH ORDINALITY` pairing below is exact.
+    3. PRIVILEGE FILTERING. information_schema answers "exists AND I hold a
+       privilege on it"; under an unexpected pooled role it reports existing
+       objects as absent (see scripts/check_existence_source.py). pg_catalog is
+       readable by PUBLIC and answers the same way whatever role we land as.
+
+    KEYS OF `foreign_keys`: the referenced table's BARE name when it lives in
+    this schema (unchanged from before, so nothing downstream renames), and
+    `schema.table` when it lives outside it. Both halves are also carried
+    explicitly in the value as `foreign_schema` / `foreign_table`, matching how
+    `analyze_junction_tables` and `db_objects.foreign_key_reference` already
+    report cross-schema references. Qualifying only the outsiders is what keeps
+    `json_object_agg` from collapsing a local `orders` table and a foreign
+    `billing.orders` onto one key. Keys of `referenced_by` are always in this
+    schema and stay bare.
+
     Parameters:
         schema (str): The schema name for which to fetch table relationships.
         database_project (str): The name of the database configuration to use for the connection
@@ -21,78 +50,74 @@ def get_table_relationships(schema, database_project):
     query = """
     WITH fk_info AS (
         SELECT
-            tc.table_schema,
-            tc.constraint_name,
-            tc.table_name,
-            kcu.column_name,
-            ccu.table_name AS foreign_table_name,
-            ccu.column_name AS foreign_column_name,
-            -- Check for unique constraints and primary keys
+            n.nspname AS table_schema,
+            con.conname AS constraint_name,
+            c.relname AS table_name,
+            a.attname AS column_name,
+            nf.nspname AS foreign_table_schema,
+            cf.relname AS foreign_table_name,
+            af.attname AS foreign_column_name,
+            -- Does the referencing column participate in a PK/UNIQUE constraint?
             EXISTS (
                 SELECT 1
-                FROM information_schema.table_constraints tc2
-                WHERE tc2.table_schema = tc.table_schema
-                  AND tc2.table_name = tc.table_name
-                  AND tc2.constraint_type IN ('PRIMARY KEY', 'UNIQUE')
-                  AND tc2.constraint_name IN (
-                      SELECT constraint_name
-                      FROM information_schema.key_column_usage
-                      WHERE table_schema = tc.table_schema
-                        AND table_name = tc.table_name
-                        AND column_name = kcu.column_name
-                  )
+                FROM pg_catalog.pg_constraint u
+                WHERE u.conrelid = con.conrelid
+                  AND u.contype IN ('p', 'u')
+                  AND a.attnum = ANY (u.conkey)
             ) AS has_unique_constraint,
+            -- ...and the referenced column?
             EXISTS (
                 SELECT 1
-                FROM information_schema.table_constraints tc2
-                WHERE tc2.table_schema = tc.table_schema
-                  AND tc2.table_name = ccu.table_name
-                  AND tc2.constraint_type IN ('PRIMARY KEY', 'UNIQUE')
-                  AND tc2.constraint_name IN (
-                      SELECT constraint_name
-                      FROM information_schema.key_column_usage
-                      WHERE table_schema = tc.table_schema
-                        AND table_name = ccu.table_name
-                        AND column_name = ccu.column_name
-                  )
+                FROM pg_catalog.pg_constraint u
+                WHERE u.conrelid = con.confrelid
+                  AND u.contype IN ('p', 'u')
+                  AND af.attnum = ANY (u.conkey)
             ) AS referenced_has_unique_constraint,
-            -- Check for junction tables (many-to-many)
+            -- More than one FK on the referencing table (junction candidate)
             (
-                SELECT COUNT(*)
-                FROM information_schema.table_constraints tc2
-                WHERE tc2.table_schema = tc.table_schema
-                  AND tc2.table_name = tc.table_name
-                  AND tc2.constraint_type = 'FOREIGN KEY'
+                SELECT count(*)
+                FROM pg_catalog.pg_constraint f2
+                WHERE f2.conrelid = con.conrelid
+                  AND f2.contype = 'f'
             ) > 1 AS is_junction_table
-        FROM 
-            information_schema.table_constraints AS tc 
-            JOIN information_schema.key_column_usage AS kcu
-              ON tc.constraint_name = kcu.constraint_name
-              AND tc.table_schema = kcu.table_schema
-            JOIN information_schema.constraint_column_usage AS ccu
-              ON ccu.constraint_name = tc.constraint_name
-              AND ccu.table_schema = tc.table_schema
-        WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = %s
+        FROM pg_catalog.pg_constraint con
+        JOIN pg_catalog.pg_class c ON c.oid = con.conrelid
+        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        JOIN pg_catalog.pg_class cf ON cf.oid = con.confrelid
+        JOIN pg_catalog.pg_namespace nf ON nf.oid = cf.relnamespace
+        JOIN unnest(con.conkey)  WITH ORDINALITY AS lk(attnum, ord) ON true
+        JOIN unnest(con.confkey) WITH ORDINALITY AS fk(attnum, ord) ON fk.ord = lk.ord
+        JOIN pg_catalog.pg_attribute a
+            ON a.attrelid = con.conrelid AND a.attnum = lk.attnum
+        JOIN pg_catalog.pg_attribute af
+            ON af.attrelid = con.confrelid AND af.attnum = fk.attnum
+        WHERE con.contype = 'f' AND n.nspname = %s
     ),
     all_tables AS (
-        SELECT table_name
-        FROM information_schema.tables
-        WHERE table_schema = %s AND table_type = 'BASE TABLE'
+        SELECT c.relname AS table_name
+        FROM pg_catalog.pg_class c
+        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = %s AND c.relkind = ANY (ARRAY['r', 'p'])
     )
     SELECT
         at.table_name,
         (SELECT json_object_agg(
-            CASE 
-                WHEN fk.foreign_table_name = at.table_name THEN 'self_reference'
-                ELSE fk.foreign_table_name 
+            CASE
+                WHEN fk.foreign_table_name = at.table_name
+                     AND fk.foreign_table_schema = fk.table_schema THEN 'self_reference'
+                WHEN fk.foreign_table_schema = fk.table_schema THEN fk.foreign_table_name
+                ELSE fk.foreign_table_schema || '.' || fk.foreign_table_name
             END,
             json_build_object(
                 'constraint_name', fk.constraint_name,
                 'column', fk.column_name,
                 'foreign_column', fk.foreign_column_name,
-                'relationship_type', 
-                CASE 
-                    WHEN fk.foreign_table_name = at.table_name THEN 'self-referential'
+                'foreign_schema', fk.foreign_table_schema,
+                'foreign_table', fk.foreign_table_name,
+                'relationship_type',
+                CASE
+                    WHEN fk.foreign_table_name = at.table_name
+                         AND fk.foreign_table_schema = fk.table_schema THEN 'self-referential'
                     WHEN fk.is_junction_table THEN 'many-to-many'
                     WHEN fk.has_unique_constraint AND fk.referenced_has_unique_constraint THEN 'one-to-one'
                     WHEN NOT fk.has_unique_constraint THEN 'many-to-one'
@@ -100,6 +125,7 @@ def get_table_relationships(schema, database_project):
                     ELSE 'undefined'
                 END
             )
+            ORDER BY fk.constraint_name, fk.column_name
         )
         FROM fk_info fk
         WHERE fk.table_name = at.table_name) AS foreign_keys,
@@ -108,11 +134,15 @@ def get_table_relationships(schema, database_project):
             json_build_object(
                 'constraint_name', fk2.constraint_name,
                 'column', fk2.column_name,
-                'foreign_column', fk2.foreign_column_name
+                'foreign_column', fk2.foreign_column_name,
+                'foreign_schema', fk2.foreign_table_schema,
+                'foreign_table', fk2.foreign_table_name
             )
+            ORDER BY fk2.constraint_name, fk2.column_name
         )
         FROM fk_info fk2
-        WHERE fk2.foreign_table_name = at.table_name) AS referenced_by
+        WHERE fk2.foreign_table_name = at.table_name
+          AND fk2.foreign_table_schema = fk2.table_schema) AS referenced_by
     FROM all_tables at;
     """
     return execute_sql_query(query, (schema, schema), database_project)

{matrx_orm-3.1.67 → matrx_orm-3.1.69}/matrx_orm/schema_builder/entity_capabilities.py

@@ -29,6 +29,10 @@ from matrx_utils import vcprint
 
 from matrx_orm.client.postgres_connection import execute_sql_query
 
+# Every EXISTS here decides a CAPABILITY that generated model code depends on,
+# so all of them read pg_catalog: information_schema is privilege-filtered and
+# would silently report every capability as absent under a contaminated pooler
+# session. See matrx_orm/catalog_sql.py.
 # One table = one entity. A table registered in platform.entity_types IS an entity
 # (that registration is the platform's own declaration); anything else is a plain table.
 _CAPABILITIES_SQL = """
@@ -53,31 +57,47 @@ SELECT
           AND NOT t.tgisinternal
     ) AS is_versioned,
     EXISTS (
-        SELECT 1 FROM information_schema.columns col
-        WHERE col.table_schema = et.schema_name
-          AND col.table_name  = et.table_name
-          AND col.column_name = 'deleted_at'
+        SELECT 1 FROM pg_attribute a
+          JOIN pg_class pc ON pc.oid = a.attrelid
+          JOIN pg_namespace pn ON pn.oid = pc.relnamespace
+        WHERE pn.nspname = et.schema_name
+          AND pc.relname = et.table_name
+          AND a.attname = 'deleted_at'
+          AND a.attnum > 0 AND NOT a.attisdropped
     ) AS has_soft_delete,
     EXISTS (
-        SELECT 1 FROM information_schema.columns col
-        WHERE col.table_schema = et.schema_name
-          AND col.table_name  = et.table_name
-          AND col.column_name = 'organization_id'
+        SELECT 1 FROM pg_attribute a
+          JOIN pg_class pc ON pc.oid = a.attrelid
+          JOIN pg_namespace pn ON pn.oid = pc.relnamespace
+        WHERE pn.nspname = et.schema_name
+          AND pc.relname = et.table_name
+          AND a.attname = 'organization_id'
+          AND a.attnum > 0 AND NOT a.attisdropped
     ) AS is_org_scoped,
     4 = (
         SELECT count(*)
-        FROM information_schema.columns col
-        WHERE col.table_schema = et.schema_name
-          AND col.table_name = et.table_name
-          AND col.column_name IN ('source_type', 'source_id', 'target_type', 'target_id')
+        FROM pg_attribute a
+        JOIN pg_class pc ON pc.oid = a.attrelid
+        JOIN pg_namespace pn ON pn.oid = pc.relnamespace
+        WHERE pn.nspname = et.schema_name
+          AND pc.relname = et.table_name
+          AND a.attname IN ('source_type', 'source_id', 'target_type', 'target_id')
+          AND a.attnum > 0 AND NOT a.attisdropped
     ) AS is_polymorphic_edge_table
 FROM platform.entity_types et
 """
 
 _HAS_ENTITY_TYPES_SQL = """
 SELECT EXISTS (
-    SELECT 1 FROM information_schema.tables
-    WHERE table_schema = 'platform' AND table_name = 'entity_types'
+    -- pg_catalog, not information_schema: this decides whether the entity
+    -- registry EXISTS. A privilege-filtered view answers "no" for a table that
+    -- is plainly there whenever the pooler hands back a session running as
+    -- another role, which would generate models with every capability flag
+    -- false. See matrx_orm/catalog_sql.py.
+    SELECT 1 FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = 'platform' AND c.relname = 'entity_types'
+      AND c.relkind = ANY ('{r,p,v,m,f}')
 ) AS present
 """