Add support to secondary tables relationships

RELEASE.md

@@ -0,0 +1,3 @@
+Release type: minor
+
+Add support for secondary table relationships in SQLAlchemy mapper, addressing a bug and enhancing the loader to handle these relationships efficiently.

src/strawberry_sqlalchemy_mapper/exc.py

@@ -35,3 +35,12 @@ def __init__(self, model):
             f"Model `{model}` is not polymorphic or is not the base model of its "
             "inheritance chain, and thus cannot be used as an interface."
         )
+
+
+class InvalidLocalRemotePairs(Exception):
+    def __init__(self, relationship_name):
+        super().__init__(
+            f"The `local_remote_pairs` for the relationship `{relationship_name}` is invalid or "
+            "missing. This is likely an issue with the library. "
+            "Please report this error to the maintainers."
+        )

src/strawberry_sqlalchemy_mapper/loader.py

@@ -18,6 +18,8 @@
 from sqlalchemy.orm import RelationshipProperty, Session
 from strawberry.dataloader import DataLoader
 
+from strawberry_sqlalchemy_mapper.exc import InvalidLocalRemotePairs
+
 
 class StrawberrySQLAlchemyLoader:
     """
@@ -45,13 +47,22 @@ def __init__(
                 "One of bind or async_bind_factory must be set for loader to function properly."
             )
 
-    async def _scalars_all(self, *args, **kwargs):
+    async def _scalars_all(self, *args, query_secondary_tables=False, **kwargs):
+        # query_secondary_tables explanation:
+        # We need to retrieve values from both the self_model and related_model.
+        # To achieve this, we must disable the default SQLAlchemy optimization
+        # that returns only related_model values.
+        # This is necessary because we use the keys variable
+        # to match both related_model and self_model.
         if self._async_bind_factory:
             async with self._async_bind_factory() as bind:
+                if query_secondary_tables:
+                    return (await bind.execute(*args, **kwargs)).all()
                 return (await bind.scalars(*args, **kwargs)).all()
-        else:
-            assert self._bind is not None
-            return self._bind.scalars(*args, **kwargs).all()
+        assert self._bind is not None
+        if query_secondary_tables:
+            return self._bind.execute(*args, **kwargs).all()
+        return self._bind.scalars(*args, **kwargs).all()
 
     def loader_for(self, relationship: RelationshipProperty) -> DataLoader:
         """
@@ -63,14 +74,72 @@ def loader_for(self, relationship: RelationshipProperty) -> DataLoader:
             related_model = relationship.entity.entity
 
             async def load_fn(keys: List[Tuple]) -> List[Any]:
-                query = select(related_model).filter(
-                    tuple_(*[remote for _, remote in relationship.local_remote_pairs or []]).in_(
-                        keys
+                def _build_normal_relationship_query(related_model, relationship, keys):
+                    return select(related_model).filter(
+                        tuple_(
+                            *[remote for _, remote in relationship.local_remote_pairs or []]
+                        ).in_(keys)
+                    )
+
+                def _build_relationship_with_secondary_table_query(
+                    related_model, relationship, keys
+                ):
+                    # Use another query when relationship uses a secondary table
+                    self_model = relationship.parent.entity
+
+                    if not relationship.local_remote_pairs:
+                        raise InvalidLocalRemotePairs(
+                            f"{related_model.__name__} -- {self_model.__name__}"
+                        )
+
+                    self_model_key_label = str(relationship.local_remote_pairs[0][1].key)
+                    related_model_key_label = str(relationship.local_remote_pairs[1][1].key)
+
+                    self_model_key = str(relationship.local_remote_pairs[0][0].key)
+                    related_model_key = str(relationship.local_remote_pairs[1][0].key)
+
+                    remote_to_use = relationship.local_remote_pairs[0][1]
+                    query_keys = tuple([item[0] for item in keys])
+
+                    # This query returns rows in this format -> (self_model.key, related_model)
+                    return (
+                        select(
+                            getattr(self_model, self_model_key).label(self_model_key_label),
+                            related_model,
+                        )
+                        .join(
+                            relationship.secondary,
+                            getattr(relationship.secondary.c, related_model_key_label)
+                            == getattr(related_model, related_model_key),
+                        )
+                        .join(
+                            self_model,
+                            getattr(relationship.secondary.c, self_model_key_label)
+                            == getattr(self_model, self_model_key),
+                        )
+                        .filter(remote_to_use.in_(query_keys))
+                    )
+
+                query = (
+                    _build_normal_relationship_query(related_model, relationship, keys)
+                    if relationship.secondary is None
+                    else _build_relationship_with_secondary_table_query(
+                        related_model, relationship, keys
                     )
                 )
+
                 if relationship.order_by:
                     query = query.order_by(*relationship.order_by)
-                rows = await self._scalars_all(query)
+
+                if relationship.secondary is not None:
+                    # We need to retrieve values from both the self_model and related_model.
+                    # To achieve this, we must disable the default SQLAlchemy optimization
+                    # that returns only related_model values.
+                    # This is necessary because we use the keys variable
+                    # to match both related_model and self_model.
+                    rows = await self._scalars_all(query, query_secondary_tables=True)
+                else:
+                    rows = await self._scalars_all(query)
 
                 def group_by_remote_key(row: Any) -> Tuple:
                     return tuple(
@@ -82,8 +151,13 @@ def group_by_remote_key(row: Any) -> Tuple:
                     )
 
                 grouped_keys: Mapping[Tuple, List[Any]] = defaultdict(list)
-                for row in rows:
-                    grouped_keys[group_by_remote_key(row)].append(row)
+                if relationship.secondary is None:
+                    for row in rows:
+                        grouped_keys[group_by_remote_key(row)].append(row)
+                else:
+                    for row in rows:
+                        grouped_keys[(row[0],)].append(row[1])
+
                 if relationship.uselist:
                     return [grouped_keys[key] for key in keys]
                 else:

src/strawberry_sqlalchemy_mapper/mapper.py

@@ -81,6 +81,7 @@
 from strawberry_sqlalchemy_mapper.exc import (
     HybridPropertyNotAnnotated,
     InterfaceModelNotPolymorphic,
+    InvalidLocalRemotePairs,
     UnsupportedAssociationProxyTarget,
     UnsupportedColumnType,
     UnsupportedDescriptorType,
@@ -493,13 +494,28 @@
             if relationship.key not in instance_state.unloaded:
                 related_objects = getattr(self, relationship.key)
             else:
-                relationship_key = tuple(
-                    [
+                if relationship.secondary is None:
+                    relationship_key = tuple(
                         getattr(self, local.key)
                         for local, _ in relationship.local_remote_pairs or []
                         if local.key
-                    ]
-                )
+                    )
+                else:
+                    # If has a secondary table, gets only the first ID
+                    # as additional IDs require a separate query
+                    if not relationship.local_remote_pairs:
+                        raise InvalidLocalRemotePairs(
+                            f"{relationship.entity.entity.__name__} -"
+                            f"- {relationship.parent.entity.__name__}"
+                        )
+
+                    local_remote_pairs_secondary_table_local = relationship.local_remote_pairs[0][0]
+                    relationship_key = tuple(
+                        [
+                            getattr(self, str(local_remote_pairs_secondary_table_local.key)),
+                        ]
+                    )
+
                 if any(item is None for item in relationship_key):
                     if relationship.uselist:
                         return []
@@ -527,7 +543,9 @@
         if relationship.uselist and not use_list:
             return self.make_connection_wrapper_resolver(
                 relationship_resolver,
-                self.model_to_type_or_interface_name(relationship.entity.entity),  # type: ignore[arg-type]
+                self.model_to_type_or_interface_name(
+                    relationship.entity.entity  # type: ignore[arg-type]
+                ),
             )
         else:
             return relationship_resolver