Add DSLSchema.__call__ shortcuts for DSLMetafield, DSLInlineFragment, and DSLFragment

Author: kasbaker

gql/dsl.py

@@ -334,25 +334,38 @@ def __call__(self, shortcut: Any) -> "DSLDirective": ...  # pragma: no cover
     def __call__(
         self, shortcut: str, name: Optional[str] = None
     ) -> Union["DSLMetaField", "DSLInlineFragment", "DSLFragment", "DSLDirective"]:
-        """Factory method for creating DSL objects.
+        """Factory method for creating DSL objects from a shortcut string.
 
-        Currently, supports creating DSLDirective instances when name starts with '@'.
-        Future support planned for meta-fields (__typename), inline fragments (...),
-        and fragment definitions (fragment).
+        The shortcut determines which DSL object is created:
 
-        :param shortcut: the name of the object to create
+          * "__typename", "__schema", "__type" -> :class:`DSLMetaField`
+          * "..." -> :class:`DSLInlineFragment`
+          * "fragment" -> :class:`DSLFragment` (requires ``name`` to be a string)
+          * "@<name>" -> :class:`DSLDirective`
+
+        :param shortcut: The shortcut string identifying the DSL object.
         :type shortcut: str
 
-        :return: :class:`DSLDirective` instance
+        :param name: The fragment name, required when ``shortcut == "fragment"``.
+        :type name: Optional[str]
+
+        :return: A DSL object corresponding to the given shortcut.
+        :rtype: DSLMetaField | DSLInlineFragment | DSLFragment | DSLDirective
 
-        :raises ValueError: if shortcut format is not supported
+        :raises ValueError: If the shortcut is not recognized,
+            or if ``name`` is missing for a fragment shortcut.
         """
+
+        if shortcut in ("__typename", "__schema", "__type"):
+            return DSLMetaField(name=shortcut)
+        if shortcut == "...":
+            return DSLInlineFragment()
+        if shortcut == "fragment":
+            if not isinstance(name, str):
+                raise ValueError(f"Missing name: {name} for fragment shortcut")
+            return DSLFragment(name=name)
         if shortcut.startswith("@"):
             return DSLDirective(name=shortcut[1:], dsl_schema=self)
-        # Future support:
-        # if name.startswith("__"): return DSLMetaField(name)
-        # if name == "...": return DSLInlineFragment()
-        # if name.startswith("fragment "): return DSLFragment(name[9:])
 
         raise ValueError(f"Unsupported shortcut: {shortcut}")
 

tests/starwars/test_dsl.py

@@ -23,6 +23,7 @@
 
 from gql import Client, gql
 from gql.dsl import (
+    DSLDirective,
     DSLField,
     DSLFragment,
     DSLFragmentSpread,
@@ -1297,9 +1298,35 @@ def test_legacy_fragment_with_variables(ds):
     assert print_ast(query.document) == expected
 
 
-def test_dsl_schema_call_validation(ds):
-    with pytest.raises(ValueError, match="(?i)unsupported shortcut"):
-        ds("foo")
+@pytest.mark.parametrize(
+    "shortcut,expected",
+    [
+        ("__typename", DSLMetaField("__typename")),
+        ("__schema", DSLMetaField("__schema")),
+        ("__type", DSLMetaField("__type")),
+        ("...", DSLInlineFragment()),
+        ("@skip", DSLDirective(name="skip", dsl_schema=DSLSchema(StarWarsSchema))),
+    ],
+)
+def test_dsl_schema_call_shortcuts(ds, shortcut, expected):
+    actual = ds(shortcut)
+    assert getattr(actual, "name", None) == getattr(expected, "name", None)
+    assert isinstance(actual, type(expected))
+
+
+def test_dsl_schema_call_fragment(ds):
+    fragment = ds("fragment", "foo")
+    assert fragment.name == "foo"
+    assert isinstance(fragment, DSLFragment)
+
+
+@pytest.mark.parametrize(
+    "shortcut,match",
+    [("foo", "(?i)unsupported shortcut"), ("fragment", "(?i)missing name")],
+)
+def test_dsl_schema_call_validation(ds, shortcut, match):
+    with pytest.raises(ValueError, match=match):
+        ds(shortcut)
 
 
 def test_executable_directives(ds, var):