Apply splat to schema sets and path aliases without explicit select. (#929)

Ensures a splat is applied in the following cases:
```py
default.User
default.User.filter(...)
default.User.groups
default.User.groups.filter(...)
default.User.filter(...).groups
default.User.filter(...).groups.filter(...)
```

Also ensures that splats are applied if such a case is used within another object's select.
```py
default.Group.select(
    users=default.Post.author  # splat applied here
)
```

Author: dnwpark

gel/_internal/_qb/_expressions.py

@@ -661,7 +661,7 @@ def wrap(
             kwargs = {}
             if isinstance(expr, ShapeOp):
                 kwargs["body_scope"] = expr.scope
-            elif isinstance(expr, SchemaSet):
+            elif isinstance(expr, (SchemaSet, Path)):
                 if splat_cb is not None:
                     shape = splat_cb()
                 else:

gel/_internal/_qb/_generics.py

@@ -45,7 +45,7 @@
     edgeql_qb_expr,
     is_exprmethod,
 )
-from ._reflection import GelTypeMetadata
+from ._reflection import GelObjectTypeMetadata, GelTypeMetadata
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -366,7 +366,10 @@ def __infix_op__(
 
     def __edgeql__(self) -> tuple[type, tuple[str, dict[str, object]]]:
         type_ = self.__gel_origin__
-        if issubclass(type_, GelTypeMetadata):
+        if issubclass(type_, GelObjectTypeMetadata) and issubclass(
+            type_.__gel_reflection__,
+            GelTypeMetadata.__gel_reflection__,
+        ):
             splat_cb = functools.partial(get_object_type_splat, type_)
         else:
             splat_cb = None

gel/_internal/_qbmodel/_abstract/_expressions.py

@@ -189,6 +189,23 @@ def select(
             shape_elements.append(shape_el)
         else:
             el_expr = _qb.edgeql_qb_expr(kwarg, var=prefix_alias)
+            if isinstance(el_expr, (_qb.SchemaSet, _qb.Path)):
+                # If the expression is a schema set or path without an explicit
+                # select, apply a splat.
+                if (
+                    el_type := (
+                        kwarg
+                        if isinstance(kwarg, type)
+                        else kwarg.__gel_origin__
+                        if isinstance(kwarg, _qb.BaseAlias)
+                        else None
+                    )
+                ) and issubclass(el_type, _qb.GelObjectTypeMetadata):
+                    el_expr = _qb.ShapeOp(
+                        iter_expr=el_expr,
+                        shape=_qb.get_object_type_splat(el_type),
+                    )
+
             shape_el = _qb.ShapeElement(
                 name=ptrname,
                 expr=el_expr,

gel/_internal/_testbase/_models.py

@@ -10,7 +10,7 @@
     TypeVar,
     TYPE_CHECKING,
 )
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Collection
 from typing_extensions import Self
 
 import argparse
@@ -76,6 +76,7 @@
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator, Mapping, Sequence
     import pydantic
+    from gel._internal._qbmodel._pydantic._models import GelModel
 
 
 _unset = object()
@@ -547,6 +548,83 @@ def assertPydanticPickles(
             getattr(model2, "__gel_changed_fields__", ...),
         )
 
+    def _assertObjectsWithFields(
+        self,
+        models: Collection[GelModel],
+        identifying_field: str,
+        expected_obj_fields: list[tuple[type[GelModel], dict[str, Any]]],
+    ) -> None:
+        """Test that models match the expected object fields.
+        Pairs models with their expected fields using the identifying field.
+        """
+        self.assertEqual(len(models), len(expected_obj_fields))
+
+        # Get models per identifier
+        for model in models:
+            self._assertHasFields(model, {identifying_field})
+
+        object_by_identifier = {
+            expected_fields[identifying_field]: next(
+                iter(
+                    m
+                    for m in models
+                    if getattr(m, identifying_field)
+                    == expected_fields[identifying_field]
+                ),
+                None,
+            )
+            for _, expected_fields in expected_obj_fields
+        }
+
+        # Check that models match obj_fields one to one
+        for identifier, obj in object_by_identifier.items():
+            self.assertIsNotNone(
+                obj, f"No model with identifier '{identifier}'"
+            )
+        self.assertEqual(
+            len(object_by_identifier),
+            len(expected_obj_fields),
+            "Duplicate identifier'",
+        )
+
+        # Check each model
+        for expected_type, expected_fields in expected_obj_fields:
+            identifier = expected_fields[identifying_field]
+            obj = object_by_identifier[identifier]
+            assert obj is not None
+            self.assertIsInstance(obj, expected_type)
+            self._assertHasFields(obj, expected_fields)
+
+    def _assertHasFields(
+        self,
+        model: GelModel,
+        expected_fields: dict[str, Any] | set[str],
+    ) -> None:
+        for field_name in expected_fields:
+            self.assertTrue(
+                field_name in model.__pydantic_fields_set__,
+                f"Model is missing field '{field_name}'",
+            )
+
+            if isinstance(expected_fields, dict):
+                expected = expected_fields[field_name]
+                actual = getattr(model, field_name)
+                self.assertEqual(
+                    expected,
+                    actual,
+                    f"Field '{field_name}' value ({actual}) different from "
+                    f"expected ({expected})",
+                )
+
+    def _assertNotHasFields(
+        self, model: GelModel, expected_fields: set[str]
+    ) -> None:
+        for field_name in expected_fields:
+            self.assertTrue(
+                field_name not in model.__pydantic_fields_set__,
+                f"Model has unexpected field '{field_name}'",
+            )
+
 
 class ModelTestCase(SyncQueryTestCase, BaseModelTestCase):  # pyright: ignore[reportIncompatibleVariableOverride, reportIncompatibleMethodOverride]
     pass