matrx-orm 3.0.26__tar.gz → 3.0.28__tar.gz

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrx-orm
-Version: 3.0.26
+Version: 3.0.28
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching. Works with any PostgreSQL database.
 Project-URL: Homepage, https://github.com/armanisadeghi/matrx-orm
 Project-URL: Repository, https://github.com/armanisadeghi/matrx-orm
@@ -1838,6 +1838,8 @@ When you run the schema builder against a database that has `vector(n)` columns,
 
 | Version | Highlights |
 |---|---|
+| **v3.0.28** | Patch release |
+| **v3.0.27** | Patch release |
 | **v3.0.26** | Patch release |
 | **v3.0.25** | Patch release |
 | **v3.0.24** | Patch release |

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/README.md

@@ -1795,6 +1795,8 @@ When you run the schema builder against a database that has `vector(n)` columns,
 
 | Version | Highlights |
 |---|---|
+| **v3.0.28** | Patch release |
+| **v3.0.27** | Patch release |
 | **v3.0.26** | Patch release |
 | **v3.0.25** | Patch release |
 | **v3.0.24** | Patch release |

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/pyproject.toml

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

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/src/matrx_orm/__init__.py

@@ -151,6 +151,7 @@ from .core.signals import (
 from .core.transaction import transaction
 from .adapters import AdapterRegistry, BaseAdapter, AsyncPostgreSQLAdapter
 from .adapters.supabase_adapter import SupabaseAdapter
+from .adapters.postgrest_client_adapter import PostgRESTClientAdapter
 from .exceptions import (
     ORMException,
     ValidationError,
@@ -358,6 +359,7 @@ __all__ = [
     "BaseAdapter",
     "AsyncPostgreSQLAdapter",
     "SupabaseAdapter",
+    "PostgRESTClientAdapter",
     # ── Cache ──────────────────────────────────────────────────────────────────
     "CachePolicy",
     "StateManager",

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/src/matrx_orm/adapters/__init__.py

@@ -40,6 +40,7 @@ __all__ = [
     "BaseAdapter",
     "AsyncPostgreSQLAdapter",
     "SupabaseAdapter",
+    "PostgRESTClientAdapter",
     "AdapterRegistry",
 ]
 

matrx_orm-3.0.28/src/matrx_orm/adapters/postgrest_client_adapter.py

@@ -0,0 +1,392 @@
+"""PostgREST client adapter — routes all ORM queries through Supabase PostgREST.
+
+This adapter allows the full BaseManager / QueryBuilder / QueryExecutor stack
+to work transparently against a Supabase project using only the publishable
+anon key + the user's JWT.  No asyncpg connection is opened; every operation
+goes through the Supabase REST API, which enforces Row-Level Security
+automatically.
+
+Typical setup (called by matrx_ai.initialize(client_mode=True, ...))::
+
+    from matrx_orm.adapters import AdapterRegistry
+    from matrx_orm.adapters.postgrest_client_adapter import PostgRESTClientAdapter
+    from matrx_orm.client import SupabaseClientConfig, SupabaseAuth
+
+    config = SupabaseClientConfig(url="https://abc.supabase.co", anon_key="eyJ...")
+    auth   = SupabaseAuth(config)
+    AdapterRegistry.register("supabase_automation_matrix",
+                              PostgRESTClientAdapter(config, auth))
+
+After that, every ``Model.filter().all()``, ``BaseManager.load_items()``,
+``create_item()``, ``update_item()``, etc. routes through PostgREST.
+
+Limitations
+-----------
+- Raw SQL (``Model.raw()``, ``Model.raw_sql()``) is **not supported** — PostgREST
+  does not accept arbitrary SQL.  Those methods will raise ``NotImplementedError``
+  when this adapter is active.  Use ``SupabaseManager.rpc()`` for stored
+  procedures instead.
+- M2M junction-table writes (``Model.ensure_m2m_tables()``) are also not
+  supported in client mode — schema DDL cannot be issued via PostgREST.
+- Transactions (``get_connection()`` context manager) are not supported.  Each
+  PostgREST request is its own implicit transaction.
+- ``select_related`` (SQL JOINs) fall back to PostgREST embedded resource
+  notation when possible; complex JOINs will degrade gracefully to a
+  non-joined result.
+"""
+
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+from typing import Any, AsyncIterator
+
+from matrx_orm.adapters.base_adapter import BaseAdapter
+
+logger = logging.getLogger("matrx_orm.adapters.postgrest_client")
+
+
+class PostgRESTClientAdapter(BaseAdapter):
+    """BaseAdapter implementation that speaks to Supabase via PostgREST HTTP.
+
+    Two construction patterns are supported:
+
+    **Pattern 1 — with SupabaseAuth (standalone client-side use)**::
+
+        from matrx_orm.client import SupabaseClientConfig, SupabaseAuth
+        from matrx_orm.adapters.postgrest_client_adapter import PostgRESTClientAdapter
+
+        config = SupabaseClientConfig(url="https://abc.supabase.co", anon_key="eyJ...")
+        auth   = SupabaseAuth(config)
+        adapter = PostgRESTClientAdapter(config=config, auth=auth)
+
+    **Pattern 2 — with a get_jwt callable (matrx_ai client mode)**::
+
+        adapter = PostgRESTClientAdapter(
+            url="https://abc.supabase.co",
+            anon_key="eyJ...",
+            get_jwt=lambda: current_token,   # sync OR async callable
+        )
+
+    Parameters
+    ----------
+    config:
+        ``SupabaseClientConfig`` **or** ``None``.  When ``None``, ``url`` and
+        ``anon_key`` must be provided and a minimal config is built internally.
+    auth:
+        ``SupabaseAuth`` instance, **or** ``None`` when ``get_jwt`` is provided.
+    url:
+        Supabase project URL.  Only used when ``config`` is ``None``.
+    anon_key:
+        Supabase publishable anon key.  Only used when ``config`` is ``None``.
+    get_jwt:
+        Sync or async callable (no arguments) that returns the current user's
+        JWT string, or ``None`` / empty string when unauthenticated.  When
+        provided, ``auth`` is ignored for token resolution.  Falls back to
+        ``anon_key`` when the callable returns ``None`` or raises.
+    """
+
+    def __init__(
+        self,
+        config: Any = None,
+        auth: Any = None,
+        *,
+        url: str = "",
+        anon_key: str = "",
+        get_jwt: Any = None,
+    ) -> None:
+        from matrx_orm.client.postgrest import PostgRESTClient
+        from matrx_orm.client.supabase_config import SupabaseClientConfig
+
+        if config is None:
+            if not url or not anon_key:
+                raise ValueError(
+                    "Either a SupabaseClientConfig must be passed as 'config', "
+                    "or 'url' and 'anon_key' must both be provided."
+                )
+            config = SupabaseClientConfig(url=url, anon_key=anon_key)
+
+        self._config = config
+        self._auth = auth
+        self._get_jwt = get_jwt  # sync or async callable, or None
+        self._client = PostgRESTClient(config)
+
+    # ------------------------------------------------------------------
+    # Token helper
+    # ------------------------------------------------------------------
+
+    async def _token(self) -> str:
+        """Return a valid JWT.
+
+        Resolution order:
+        1. ``get_jwt`` callable if provided (sync or async).
+        2. ``SupabaseAuth.ensure_valid_session()`` if auth provided.
+        3. Anon key fallback (works for public / RLS-unrestricted tables).
+        """
+        import asyncio
+
+        if self._get_jwt is not None:
+            try:
+                result = self._get_jwt()
+                if asyncio.iscoroutine(result):
+                    result = await result
+                if result:
+                    return result
+            except Exception:
+                pass
+
+        if self._auth is not None:
+            try:
+                session = await self._auth.ensure_valid_session()
+                if session and session.access_token:
+                    return session.access_token
+            except Exception:
+                pass
+
+        return self._config.anon_key
+
+    # ------------------------------------------------------------------
+    # execute_query_dict — primary SELECT hook for QueryExecutor
+    # ------------------------------------------------------------------
+
+    async def execute_query_dict(
+        self,
+        query_dict: dict[str, Any],
+    ) -> list[dict[str, Any]] | type[NotImplemented]:
+        """Translate a QueryBuilder query dict to a PostgREST SELECT call.
+
+        This is called by ``QueryExecutor._execute()`` **before** the SQL path.
+        Returning a list (even empty) signals that PostgREST handled the query
+        and the executor should skip SQL entirely.
+        """
+        table: str = query_dict.get("table", "")
+        if not table:
+            return NotImplemented
+
+        token = await self._token()
+        filters = self._translate_filters(query_dict.get("filters", {}))
+        order = self._translate_order(query_dict.get("order_by", []))
+        limit: int | None = query_dict.get("limit")
+        offset: int | None = query_dict.get("offset")
+        select_cols: list[str] | None = query_dict.get("select")
+        columns = ", ".join(select_cols) if select_cols else "*"
+
+        logger.debug(
+            "[PostgRESTClientAdapter] SELECT %s filters=%s limit=%s",
+            table, filters, limit,
+        )
+
+        try:
+            result = await self._client.select(
+                table,
+                token,
+                columns=columns,
+                filters=filters if filters else None,
+                order=order if order else None,
+                limit=limit,
+                offset=offset,
+            )
+            if isinstance(result, list):
+                return result
+            # single-object response (shouldn't happen on list queries)
+            return [result] if result else []
+        except Exception as exc:
+            logger.error(
+                "[PostgRESTClientAdapter] SELECT failed for %s: %s", table, exc
+            )
+            raise
+
+    # ------------------------------------------------------------------
+    # execute_write_dict — write hook for QueryExecutor DML
+    # ------------------------------------------------------------------
+
+    async def execute_write_dict(
+        self,
+        query_dict: dict[str, Any],
+    ) -> list[dict[str, Any]] | type[NotImplemented]:
+        """Translate a write query dict to the appropriate PostgREST call.
+
+        Called by ``QueryExecutor`` for INSERT / UPDATE / DELETE / UPSERT
+        before it falls through to the SQL path.
+
+        query_dict keys used:
+        - ``operation``: "insert" | "update" | "delete" | "upsert" | "bulk_insert"
+          | "bulk_upsert"
+        - ``table``: table name
+        - ``data``: dict (single row) or list of dicts (bulk)
+        - ``filters``: ORM filter dict (for UPDATE / DELETE)
+        - ``conflict_fields``: list[str] (for UPSERT)
+        - ``update_fields``: list[str] (for UPSERT, optional)
+        """
+        operation: str = query_dict.get("operation", "")
+        table: str = query_dict.get("table", "")
+        if not table or not operation:
+            return NotImplemented
+
+        token = await self._token()
+        filters = self._translate_filters(query_dict.get("filters", {}))
+        data: dict | list = query_dict.get("data", {})
+
+        logger.debug(
+            "[PostgRESTClientAdapter] %s %s", operation.upper(), table
+        )
+
+        try:
+            if operation == "insert":
+                result = await self._client.insert(table, token, data)
+                return [result] if isinstance(result, dict) else (result or [])
+
+            if operation == "bulk_insert":
+                result = await self._client.insert(table, token, data)
+                return result if isinstance(result, list) else ([result] if result else [])
+
+            if operation == "upsert":
+                conflict_fields: list[str] = query_dict.get("conflict_fields", [])
+                on_conflict = ",".join(conflict_fields) if conflict_fields else "id"
+                result = await self._client.insert(
+                    table, token, data,
+                    on_conflict=on_conflict,
+                    upsert=True,
+                )
+                return [result] if isinstance(result, dict) else (result or [])
+
+            if operation == "bulk_upsert":
+                conflict_fields = query_dict.get("conflict_fields", [])
+                on_conflict = ",".join(conflict_fields) if conflict_fields else "id"
+                result = await self._client.insert(
+                    table, token, data,
+                    on_conflict=on_conflict,
+                    upsert=True,
+                )
+                return result if isinstance(result, list) else ([result] if result else [])
+
+            if operation == "update":
+                result = await self._client.update(
+                    table, token, data,
+                    filters=filters if filters else None,
+                )
+                return result if isinstance(result, list) else ([result] if result else [])
+
+            if operation == "delete":
+                if not filters:
+                    raise ValueError(
+                        "DELETE via PostgREST requires at least one filter. "
+                        "Use explicit filter kwargs to identify which rows to delete."
+                    )
+                result = await self._client.delete(
+                    table, token,
+                    filters=filters,
+                )
+                return result if isinstance(result, list) else ([result] if result else [])
+
+        except Exception as exc:
+            logger.error(
+                "[PostgRESTClientAdapter] %s failed for %s: %s",
+                operation.upper(), table, exc,
+            )
+            raise
+
+        return NotImplemented
+
+    # ------------------------------------------------------------------
+    # execute_query / execute_write — SQL fallbacks (not supported)
+    # ------------------------------------------------------------------
+
+    async def execute_query(
+        self,
+        sql: str,
+        *args: Any,
+        timeout: float = 10.0,
+    ) -> list[dict[str, Any]]:
+        """Raw SQL is not supported via PostgREST.
+
+        This is called only when ``execute_query_dict`` returns ``NotImplemented``
+        (which shouldn't happen for normal ORM queries).  If you reach this
+        method, the query uses a feature that PostgREST cannot represent —
+        complex CTEs, raw aggregations, pgvector similarity, etc.
+
+        Consider using ``SupabaseManager.rpc()`` with a PostgreSQL function
+        for these cases, or switch to a direct asyncpg adapter for server-side
+        deployments.
+        """
+        raise NotImplementedError(
+            "Raw SQL queries are not supported in PostgREST (client) mode.\n"
+            "This query requires a direct database connection (asyncpg).\n"
+            f"SQL attempted: {sql[:200]!r}"
+        )
+
+    async def execute_write(
+        self,
+        sql: str,
+        *args: Any,
+        timeout: float = 10.0,
+        max_retries: int = 2,
+    ) -> list[dict[str, Any]]:
+        """Raw SQL writes are not supported via PostgREST."""
+        raise NotImplementedError(
+            "Raw SQL writes are not supported in PostgREST (client) mode.\n"
+            "This write requires a direct database connection (asyncpg).\n"
+            f"SQL attempted: {sql[:200]!r}"
+        )
+
+    # ------------------------------------------------------------------
+    # Connection management — not supported in client mode
+    # ------------------------------------------------------------------
+
+    @asynccontextmanager
+    async def get_connection(self, timeout: float = 10.0) -> AsyncIterator[Any]:
+        """Transactions are not supported via PostgREST."""
+        raise NotImplementedError(
+            "Direct connections and transactions are not available in PostgREST "
+            "(client) mode.  Each PostgREST request is its own implicit transaction."
+        )
+        yield  # pragma: no cover
+
+    def get_active_connection(self) -> Any | None:
+        """No persistent connection in PostgREST mode."""
+        return None
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def close(self) -> None:
+        """Nothing to close — PostgREST uses stateless HTTP."""
+        pass
+
+    # ------------------------------------------------------------------
+    # Filter / order translation helpers
+    # ------------------------------------------------------------------
+
+    def _translate_filters(
+        self, filters: dict[str, Any] | None
+    ) -> dict[str, Any]:
+        """Pass ORM filter dicts straight through.
+
+        ``PostgRESTClient._build_query_params()`` already understands the ORM
+        ``field__operator`` convention, so no translation is needed here.
+        The executor hands us the same filter dict the query builder built.
+        """
+        if not filters:
+            return {}
+        cleaned: dict[str, Any] = {}
+        for key, value in filters.items():
+            # Skip None values — they mean "no filter"
+            if value is not None:
+                cleaned[key] = value
+        return cleaned
+
+    def _translate_order(self, order_by: list[str] | None) -> list[str] | None:
+        """Pass order_by list straight through — same format as PostgRESTClient."""
+        return order_by if order_by else None
+
+    # ------------------------------------------------------------------
+    # Repr
+    # ------------------------------------------------------------------
+
+    def __repr__(self) -> str:
+        return (
+            f"PostgRESTClientAdapter("
+            f"url={getattr(self._config, 'url', '?')!r}, "
+            f"auth={'get_jwt' if self._get_jwt else ('SupabaseAuth' if self._auth else 'anon_key')})"
+        )

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/src/matrx_orm/core/base.py

@@ -703,10 +703,12 @@ class Model(RuntimeMixin, metaclass=ModelMeta):
         Usage::
 
             users = await User.raw("SELECT * FROM users WHERE age > $1", 18)
-        """
-        from matrx_orm.core.async_db_manager import AsyncDatabaseManager
 
-        results = await AsyncDatabaseManager.execute_query(config_name=cls.get_database_name(), query=sql, *params)
+        Not supported in PostgREST (client) mode — raises ``NotImplementedError``.
+        """
+        from matrx_orm.adapters import AdapterRegistry
+        adapter = AdapterRegistry.get(cls.get_database_name())
+        results = await adapter.execute_query(sql, *params)
         instances = []
         for row in results:
             try:
@@ -724,10 +726,12 @@ class Model(RuntimeMixin, metaclass=ModelMeta):
         Usage::
 
             rows = await User.raw_sql("SELECT count(*) as cnt, role FROM users GROUP BY role")
-        """
-        from matrx_orm.core.async_db_manager import AsyncDatabaseManager
 
-        results = await AsyncDatabaseManager.execute_query(cls.get_database_name(), sql, *params)
+        Not supported in PostgREST (client) mode — raises ``NotImplementedError``.
+        """
+        from matrx_orm.adapters import AdapterRegistry
+        adapter = AdapterRegistry.get(cls.get_database_name())
+        results = await adapter.execute_query(sql, *params)
         return [dict(row) for row in results]
 
     @classmethod
@@ -1376,13 +1380,18 @@ class Model(RuntimeMixin, metaclass=ModelMeta):
 
     @classmethod
     async def ensure_m2m_tables(cls) -> None:
-        """Create any pending junction tables that don't yet exist in the database."""
+        """Create any pending junction tables that don't yet exist in the database.
+
+        Not supported in PostgREST (client) mode — DDL cannot be issued via the
+        REST API.  Schema migrations must be applied server-side.
+        """
         if not cls._pending_junction_tables:
             return
 
-        from matrx_orm.core.async_db_manager import AsyncDatabaseManager
+        from matrx_orm.adapters import AdapterRegistry
 
         db_name = cls.get_database_name()
+        adapter = AdapterRegistry.get(db_name)
         for jt in cls._pending_junction_tables:
             sql = (
                 f"CREATE TABLE IF NOT EXISTS {jt['junction_table']} ("
@@ -1391,7 +1400,7 @@ class Model(RuntimeMixin, metaclass=ModelMeta):
                 f"PRIMARY KEY ({jt['source_column']}, {jt['target_column']})"
                 f")"
             )
-            await AsyncDatabaseManager.execute_query(db_name, sql)
+            await adapter.execute_query(sql)
 
     @classmethod
     async def get_many(cls, **kwargs: Any) -> list[Self]:

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/src/matrx_orm/core/extended.py

@@ -57,25 +57,42 @@ class BaseManager(Generic[ModelT]):
     def _initialize_manager(self) -> None:
         """Initialize the manager and trigger auto-fetch if configured.
 
-        Auto-fetch now works correctly in all contexts thanks to automatic
-        event loop detection and pool recreation in AsyncDatabaseManager.
+        Auto-fetch is skipped when no database configuration or adapter has been
+        registered yet (e.g. in client/PostgREST mode where asyncpg is not used
+        and the adapter is registered asynchronously after module import).
         """
-        if int(self.fetch_on_init_limit) > 0:
-            try:
-                asyncio.get_running_loop()
-                asyncio.create_task(coro=self._auto_fetch_on_init_async())
-                vcprint(
-                    f"[{self.model.__name__}] Auto-fetching on init (async)",
-                    verbose=info,
-                    color="yellow",
-                )
-            except RuntimeError:
-                vcprint(
-                    f"[{self.model.__name__}] Auto-fetching on init (sync)",
-                    verbose=info,
-                    color="yellow",
-                )
-                self._auto_fetch_on_init_sync()
+        if int(self.fetch_on_init_limit) <= 0:
+            return
+
+        # Skip auto-fetch if no adapter/database config is registered — avoids
+        # DatabaseConfigError in client mode where asyncpg is not configured.
+        try:
+            from matrx_orm.adapters import AdapterRegistry
+            from matrx_orm.core.config import registry as _db_registry
+            db_name = self.model.get_database_name() if hasattr(self.model, "get_database_name") else None
+            if db_name:
+                adapter_exists = AdapterRegistry.get_or_none(db_name) is not None
+                config_exists = db_name in _db_registry._configs
+                if not adapter_exists and not config_exists:
+                    return
+        except Exception:
+            return
+
+        try:
+            asyncio.get_running_loop()
+            asyncio.create_task(coro=self._auto_fetch_on_init_async())
+            vcprint(
+                f"[{self.model.__name__}] Auto-fetching on init (async)",
+                verbose=info,
+                color="yellow",
+            )
+        except RuntimeError:
+            vcprint(
+                f"[{self.model.__name__}] Auto-fetching on init (sync)",
+                verbose=info,
+                color="yellow",
+            )
+            self._auto_fetch_on_init_sync()
 
     def _validate_input_data(
         self,

{matrx_orm-3.0.26 → matrx_orm-3.0.28}/src/matrx_orm/core/relations.py

@@ -335,7 +335,7 @@ class ManyToManyReference:
 
     async def fetch_related(self, instance: Model) -> list[Model]:
         """Single-query JOIN: junction table + target model in one round-trip."""
-        from matrx_orm.core.async_db_manager import AsyncDatabaseManager
+        from matrx_orm.adapters import AdapterRegistry
         from matrx_orm.exceptions import ORMException
 
         pk_field = instance._meta.primary_keys[0]
@@ -345,6 +345,7 @@ class ManyToManyReference:
 
         try:
             db_name = await self._get_db_name(instance)
+            adapter = AdapterRegistry.get(db_name)
             junction = self.qualified_junction_table
             target_model = self.resolved_model
             target_table = target_model._meta.qualified_table_name
@@ -357,7 +358,7 @@ class ManyToManyReference:
                 f"JOIN {junction} j ON j.{self.target_column} = t.{target_pk} "
                 f"WHERE j.{self.source_column} = $1"
             )
-            rows = await AsyncDatabaseManager.execute_query(db_name, sql, source_value)
+            rows = await adapter.execute_query(sql, source_value)
 
             if not rows:
                 return []
@@ -372,7 +373,7 @@ class ManyToManyReference:
         if not target_ids:
             return 0
 
-        from matrx_orm.core.async_db_manager import AsyncDatabaseManager
+        from matrx_orm.adapters import AdapterRegistry
         from matrx_orm.exceptions import ORMException
 
         pk_field = instance._meta.primary_keys[0]
@@ -380,6 +381,7 @@ class ManyToManyReference:
 
         try:
             db_name = await self._get_db_name(instance)
+            adapter = AdapterRegistry.get(db_name)
             junction = self.qualified_junction_table
 
             placeholders = ", ".join(
@@ -395,7 +397,7 @@ class ManyToManyReference:
             for tid in target_ids:
                 params.extend([source_value, tid])
 
-            rows = await AsyncDatabaseManager.execute_query(db_name, sql, *params)
+            rows = await adapter.execute_query(sql, *params)
             return len(rows) if rows else len(target_ids)
         except ORMException as e:
             e.enrich(model=instance.__class__, operation="add_m2m", **self._enrich_context())
@@ -406,7 +408,7 @@ class ManyToManyReference:
         if not target_ids:
             return 0
 
-        from matrx_orm.core.async_db_manager import AsyncDatabaseManager
+        from matrx_orm.adapters import AdapterRegistry
         from matrx_orm.exceptions import ORMException
 
         pk_field = instance._meta.primary_keys[0]
@@ -414,6 +416,7 @@ class ManyToManyReference:
 
         try:
             db_name = await self._get_db_name(instance)
+            adapter = AdapterRegistry.get(db_name)
             junction = self.qualified_junction_table
 
             sql = (
@@ -421,9 +424,7 @@ class ManyToManyReference:
                 f"WHERE {self.source_column} = $1 AND {self.target_column} = ANY($2) "
                 f"RETURNING *"
             )
-            rows = await AsyncDatabaseManager.execute_query(
-                db_name, sql, source_value, list(target_ids)
-            )
+            rows = await adapter.execute_query(sql, source_value, list(target_ids))
             return len(rows) if rows else 0
         except ORMException as e:
             e.enrich(model=instance.__class__, operation="remove_m2m", **self._enrich_context())
@@ -437,7 +438,7 @@ class ManyToManyReference:
 
     async def clear(self, instance: Model) -> int:
         """Remove all junction rows for this instance."""
-        from matrx_orm.core.async_db_manager import AsyncDatabaseManager
+        from matrx_orm.adapters import AdapterRegistry
         from matrx_orm.exceptions import ORMException
 
         pk_field = instance._meta.primary_keys[0]
@@ -445,10 +446,11 @@ class ManyToManyReference:
 
         try:
             db_name = await self._get_db_name(instance)
+            adapter = AdapterRegistry.get(db_name)
             junction = self.qualified_junction_table
 
             sql = f"DELETE FROM {junction} WHERE {self.source_column} = $1 RETURNING *"
-            rows = await AsyncDatabaseManager.execute_query(db_name, sql, source_value)
+            rows = await adapter.execute_query(sql, source_value)
             return len(rows) if rows else 0
         except ORMException as e:
             e.enrich(model=instance.__class__, operation="clear_m2m", **self._enrich_context())