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
 https://graphene-python.org/sphinx_graphene_theme.zip

docs/types/schema.rst

@@ -92,3 +92,153 @@ 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
+* Scalar
+* ObjectType
+* InputType
+* Enum
+* Interface
+* Union
+
+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
+ }
+
+ scalar MyScalar
+
+ 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
+ }
+
+ scalar MyPrefixMyScalar
+
+ enum MyPrefixMyEnum {
+ FOO
+ BAR
+ }
+
+ type Mutation {
+ myPrefixCreateUser(name: String): MyPrefixCreateUser
+ }
+
+ type MyPrefixCreateUser {
+ name: String
+ }
+
+ type Subscription {
+ myPrefixCountToTen: Int
+ }
+
+You can override the prefix for a specific type by setting the ``type_name_prefix`` property on the ``Meta`` class:
+
+.. code:: python
+
+ from graphene import ObjectType
+
+ class MyGraphQlType(ObjectType):
+ class Meta:
+ type_name_prefix = ''
+
+This is useful when defining external types in a federated schema for example.

graphene/types/base.py

@@ -36,13 +36,14 @@ def create_type(cls, class_name, **options):
 
  @classmethod
  def __init_subclass_with_meta__(
- cls, name=None, description=None, _meta=None, **_kwargs
+ cls, name=None, description=None, type_name_prefix=None, _meta=None, **_kwargs
  ):
  assert "_meta" not in cls.__dict__, "Can't assign meta directly"
  if not _meta:
  return
  _meta.name = name or cls.__name__
  _meta.description = description or trim_docstring(cls.__doc__)
+ _meta.type_name_prefix = type_name_prefix
  _meta.freeze()
  cls._meta = _meta
  super(BaseType, cls).__init_subclass_with_meta__()

graphene/types/schema.py

@@ -49,7 +49,7 @@
 from .scalars import ID, Boolean, Float, Int, Scalar, String
 from .structures import List, NonNull
 from .union import Union
-from .utils import get_field_as
+from .utils import get_field_as, get_type_name
 
 introspection_query = get_introspection_query()
 IntrospectionSchema = introspection_types["__Schema"]
@@ -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
@@ -131,9 +141,9 @@ def add_type(self, graphene_type):
  elif issubclass(graphene_type, Interface):
  graphql_type = self.create_interface(graphene_type)
  elif issubclass(graphene_type, Scalar):
- graphql_type = self.create_scalar(graphene_type)
+ graphql_type = self.create_scalar(graphene_type, self.type_name_prefix)
  elif issubclass(graphene_type, Enum):
- graphql_type = self.create_enum(graphene_type)
+ graphql_type = self.create_enum(graphene_type, self.type_name_prefix)
  elif issubclass(graphene_type, Union):
  graphql_type = self.construct_union(graphene_type)
  else:
@@ -142,7 +152,10 @@ def add_type(self, graphene_type):
  return graphql_type
 
  @staticmethod
- def create_scalar(graphene_type):
+ def create_scalar(
+ graphene_type,
+ type_name_prefix=None,
+ ):
  # We have a mapping to the original GraphQL types
  # so there are no collisions.
  _scalars = {
@@ -157,15 +170,15 @@ def create_scalar(graphene_type):
 
  return GrapheneScalarType(
  graphene_type=graphene_type,
- name=graphene_type._meta.name,
+ name=get_type_name(graphene_type, type_name_prefix),
  description=graphene_type._meta.description,
  serialize=getattr(graphene_type, "serialize", None),
  parse_value=getattr(graphene_type, "parse_value", None),
  parse_literal=getattr(graphene_type, "parse_literal", None),
  )
 
  @staticmethod
- def create_enum(graphene_type):
+ def create_enum(graphene_type, type_name_prefix=None):
  values = {}
  for name, value in graphene_type._meta.enum.__members__.items():
  description = getattr(value, "description", None)
@@ -193,7 +206,7 @@ def create_enum(graphene_type):
  return GrapheneEnumType(
  graphene_type=graphene_type,
  values=values,
- name=graphene_type._meta.name,
+ name=get_type_name(graphene_type, type_name_prefix),
  description=type_description,
  )
 
@@ -215,9 +228,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.get_type_name(graphene_type)
+
  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 +261,7 @@ def interfaces():
 
  return GrapheneInterfaceType(
  graphene_type=graphene_type,
- name=graphene_type._meta.name,
+ name=self.get_type_name(graphene_type),
  description=graphene_type._meta.description,
  fields=partial(self.create_fields_for_type, graphene_type),
  interfaces=interfaces,
@@ -253,7 +271,7 @@ def interfaces():
  def create_inputobjecttype(self, graphene_type):
  return GrapheneInputObjectType(
  graphene_type=graphene_type,
- name=graphene_type._meta.name,
+ name=self.get_type_name(graphene_type),
  description=graphene_type._meta.description,
  out_type=graphene_type._meta.container,
  fields=partial(
@@ -282,7 +300,7 @@ def types():
 
  return GrapheneUnionType(
  graphene_type=graphene_type,
- name=graphene_type._meta.name,
+ name=self.get_type_name(graphene_type),
  description=graphene_type._meta.description,
  types=types,
  resolve_type=resolve_type,
@@ -357,7 +375,10 @@ 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:
+ field_name = self.get_field_name(graphene_type, name)
  fields[field_name] = _field
  return fields
 
@@ -391,6 +412,26 @@ 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 get_type_name(self, graphene_type):
+ return get_type_name(graphene_type, self.type_name_prefix)
+
+ def get_field_name(self, graphene_type, name):
+ if graphene_type._meta.name in self.root_type_names:
+ # We only add the prefix to the root types and types defined prefixes take precedence
+ # over schema defined prefix.
+ type_name_prefix = (
+ graphene_type._meta.type_name_prefix
+ if graphene_type._meta.type_name_prefix is not None
+ else self.type_name_prefix
+ )
+ if type_name_prefix:
+ if self.auto_camelcase:
+ return to_camel_case(
+ type_name_prefix[0].lower() + type_name_prefix[1:] + "_" + name
+ )
+ return type_name_prefix + name
+ return self.get_name(name)
+
 
 class Schema:
  """Schema Definition.
@@ -421,12 +462,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,