feat: added object_type_name_prefix

docs/requirements.txt

@@ -1,5 +1,6 @@
 # Required library
 Sphinx==1.5.3
+jinja2<3.1.0
 sphinx-autobuild==0.7.1
 # Docs template
 http://graphene-python.org/sphinx_graphene_theme.zip

docs/types/schema.rst

@@ -92,3 +92,136 @@ To disable this behavior, set the ``auto_camelcase`` to ``False`` upon schema in
         query=MyRootQuery,
         auto_camelcase=False,
     )
+
+.. _SchemaTypeNamePrefix:
+
+Type name prefix
+--------------------------
+
+You can specify a prefix for all type names in the schema by setting the ``type_name_prefix`` argument upon schema instantiation:
+
+.. code:: python
+
+    my_schema = Schema(
+        query=MyRootQuery,
+        mutation=MyRootMutation,
+        subscription=MyRootSubscription
+        type_name_prefix='MyPrefix',
+    )
+
+This is useful in a micro-services architecture to prepend the service name to all types and avoid conflicts for example.
+
+The prefix will be added to the name of:
+
+* Query / Mutation / Subscription
+* ObjectType
+* InputType
+* Interface
+* Union
+* Enum
+
+While fields and arguments name will be left untouched.
+
+More specifically, the following schema:
+
+.. code::
+
+    type Query {
+        inner: MyType
+    }
+
+    type MyType {
+        field: String
+        myUnion: MyUnion
+        myBarType: MyBarType
+        myFooType: MyFooType
+    }
+
+    union MyUnion = MyBarType | MyFooType
+
+    type MyBarType {
+        field(input: MyInputObjectType): String
+        myInterface: MyInterface
+    }
+
+    input MyInputObjectType {
+        field: String
+    }
+
+    interface MyInterface {
+        field: String
+    }
+
+    type MyFooType {
+        field: String
+        myEnum: MyEnum
+    }
+
+    enum MyEnum {
+        FOO
+        BAR
+    }
+
+    type Mutation {
+        createUser(name: String): CreateUser
+    }
+
+    type CreateUser {
+        name: String
+    }
+
+    type Subscription {
+        countToTen: Int
+    }
+
+Will be transformed to:
+
+.. code::
+
+    type Query {
+        myPrefixInner: MyPrefixMyType
+    }
+
+    type MyPrefixMyType {
+        field: String
+        myUnion: MyPrefixMyUnion
+        myBarType: MyPrefixMyBarType
+        myFooType: MyPrefixMyFooType
+    }
+
+    union MyPrefixMyUnion = MyPrefixMyBarType | MyPrefixMyFooType
+
+    type MyPrefixMyBarType {
+        field(input: MyPrefixMyInputObjectType): String
+        myInterface: MyPrefixMyInterface
+    }
+
+    input MyPrefixMyInputObjectType {
+        field: String
+    }
+
+    interface MyPrefixMyInterface {
+        field: String
+    }
+
+    type MyPrefixMyFooType {
+        field: String
+        myEnum: MyPrefixMyEnum
+    }
+
+    enum MyPrefixMyEnum {
+        FOO
+        BAR
+    }
+
+    type Mutation {
+        myPrefixCreateUser(name: String): MyPrefixCreateUser
+    }
+
+    type MyPrefixCreateUser {
+        name: String
+    }
+
+    type Subscription {
+        myPrefixCountToTen: Int
+    }

graphene/types/schema.py

@@ -91,6 +91,7 @@ def __init__(
         subscription=None,
         types=None,
         auto_camelcase=True,
+        type_name_prefix=None,
     ):
         assert_valid_root_type(query)
         assert_valid_root_type(mutation)
@@ -101,9 +102,18 @@ def __init__(
             assert is_graphene_type(type_)
 
         self.auto_camelcase = auto_camelcase
+        self.type_name_prefix = type_name_prefix
 
         create_graphql_type = self.add_type
 
+        self.root_type_names = []
+        if query:
+            self.root_type_names.append(query._meta.name)
+        if mutation:
+            self.root_type_names.append(mutation._meta.name)
+        if subscription:
+            self.root_type_names.append(subscription._meta.name)
+
         self.query = create_graphql_type(query) if query else None
         self.mutation = create_graphql_type(mutation) if mutation else None
         self.subscription = create_graphql_type(subscription) if subscription else None
@@ -164,8 +174,7 @@ def create_scalar(graphene_type):
             parse_literal=getattr(graphene_type, "parse_literal", None),
         )
 
-    @staticmethod
-    def create_enum(graphene_type):
+    def create_enum(self, graphene_type):
         values = {}
         for name, value in graphene_type._meta.enum.__members__.items():
             description = getattr(value, "description", None)
@@ -193,7 +202,7 @@ def create_enum(graphene_type):
         return GrapheneEnumType(
             graphene_type=graphene_type,
             values=values,
-            name=graphene_type._meta.name,
+            name=self.add_prefix_to_type_name(graphene_type._meta.name),
             description=type_description,
         )
 
@@ -215,9 +224,14 @@ def interfaces():
         else:
             is_type_of = graphene_type.is_type_of
 
+        if graphene_type._meta.name in self.root_type_names:
+            name = graphene_type._meta.name
+        else:
+            name = self.add_prefix_to_type_name(graphene_type._meta.name)
+
         return GrapheneObjectType(
             graphene_type=graphene_type,
-            name=graphene_type._meta.name,
+            name=name,
             description=graphene_type._meta.description,
             fields=partial(self.create_fields_for_type, graphene_type),
             is_type_of=is_type_of,
@@ -243,7 +257,7 @@ def interfaces():
 
         return GrapheneInterfaceType(
             graphene_type=graphene_type,
-            name=graphene_type._meta.name,
+            name=self.add_prefix_to_type_name(graphene_type._meta.name),
             description=graphene_type._meta.description,
             fields=partial(self.create_fields_for_type, graphene_type),
             interfaces=interfaces,
@@ -253,7 +267,7 @@ def interfaces():
     def create_inputobjecttype(self, graphene_type):
         return GrapheneInputObjectType(
             graphene_type=graphene_type,
-            name=graphene_type._meta.name,
+            name=self.add_prefix_to_type_name(graphene_type._meta.name),
             description=graphene_type._meta.description,
             out_type=graphene_type._meta.container,
             fields=partial(
@@ -282,7 +296,7 @@ def types():
 
         return GrapheneUnionType(
             graphene_type=graphene_type,
-            name=graphene_type._meta.name,
+            name=self.add_prefix_to_type_name(graphene_type._meta.name),
             description=graphene_type._meta.description,
             types=types,
             resolve_type=resolve_type,
@@ -357,7 +371,13 @@ def create_fields_for_type(self, graphene_type, is_input_type=False):
                     deprecation_reason=field.deprecation_reason,
                     description=field.description,
                 )
-            field_name = field.name or self.get_name(name)
+            if field.name:
+                field_name = field.name
+            else:
+                if graphene_type._meta.name in self.root_type_names:
+                    field_name = self.add_prefix_to_field_name(name)
+                else:
+                    field_name = self.get_name(name)
             fields[field_name] = _field
         return fields
 
@@ -391,6 +411,23 @@ def resolve_type(self, resolve_type_func, type_name, root, info, _type):
         return_type = self[type_name]
         return default_type_resolver(root, info, return_type)
 
+    def add_prefix_to_type_name(self, name):
+        if self.type_name_prefix:
+            return self.type_name_prefix[0].upper() + self.type_name_prefix[1:] + name
+        return name
+
+    def add_prefix_to_field_name(self, name):
+        if self.type_name_prefix:
+            if self.auto_camelcase:
+                return self.get_name(
+                    self.type_name_prefix[0].lower()
+                    + self.type_name_prefix[1:]
+                    + "_"
+                    + name
+                )
+            return self.get_name(self.type_name_prefix + name)
+        return self.get_name(name)
+
 
 class Schema:
     """Schema Definition.
@@ -421,12 +458,18 @@ def __init__(
         types=None,
         directives=None,
         auto_camelcase=True,
+        type_name_prefix=None,
     ):
         self.query = query
         self.mutation = mutation
         self.subscription = subscription
         type_map = TypeMap(
-            query, mutation, subscription, types, auto_camelcase=auto_camelcase
+            query,
+            mutation,
+            subscription,
+            types,
+            auto_camelcase=auto_camelcase,
+            type_name_prefix=type_name_prefix,
         )
         self.graphql_schema = GraphQLSchema(
             type_map.query,

graphene/types/tests/test_mutation.py

@@ -218,3 +218,48 @@ class Query(ObjectType):
     )
     assert not result.errors
     assert result.data == {"createUserWithPlanet": {"name": "Peter", "planet": "earth"}}
+
+
+def test_type_name_prefix():
+    class BaseCreateUser(Mutation):
+        class Arguments:
+            name = String()
+
+        name = String()
+
+        def mutate(self, info, **args):
+            return args
+
+    class CreateUserWithPlanet(BaseCreateUser):
+        class Arguments(BaseCreateUser.Arguments):
+            planet = String()
+
+        planet = String()
+
+        def mutate(self, info, **args):
+            return CreateUserWithPlanet(**args)
+
+    class MyMutation(ObjectType):
+        create_user_with_planet = CreateUserWithPlanet.Field()
+
+    class Query(ObjectType):
+        a = String()
+
+    schema = Schema(
+        query=Query,
+        mutation=MyMutation,
+        type_name_prefix="MyPrefix",
+    )
+    result = schema.execute(
+        """ mutation mymutation {
+        myPrefixCreateUserWithPlanet(name:"Peter", planet: "earth") {
+            name
+            planet
+        }
+    }
+    """
+    )
+    assert not result.errors
+    assert result.data == {
+        "myPrefixCreateUserWithPlanet": {"name": "Peter", "planet": "earth"}
+    }

graphene/types/tests/test_query.py

@@ -497,3 +497,28 @@ def resolve_user(self, *args, **kwargs):
 
     assert not result.errors
     assert result.data == expected
+
+
+def test_type_name_prefix():
+    class Cat(ObjectType):
+        name = String()
+
+    class User(ObjectType):
+        name = String()
+        cat = Field(Cat)
+
+        def resolve_cat(self, *args, **kwargs):
+            return Cat(name="bar")
+
+    class Query(ObjectType):
+        user = Field(User)
+
+        def resolve_user(self, *args, **kwargs):
+            return User(name="foo")
+
+    schema = Schema(query=Query, type_name_prefix="MyPrefix")
+    expected = {"myPrefixUser": {"name": "foo", "cat": {"name": "bar"}}}
+    result = schema.execute("{ myPrefixUser { name cat { name } } }")
+
+    assert not result.errors
+    assert result.data == expected