def enter_field(self, node, *_): name = node.alias.value if node.alias else node.name.value graphql_type = self.type_info.get_type() python_type, nullable, underlying_graphql_type = self.__scalar_type_to_python(graphql_type) parsed_field = ParsedField( name=name, type=python_type, nullable=nullable, ) self.current.fields.append(parsed_field) # TODO: nullables should go to the end if not is_scalar_type(underlying_graphql_type): if is_enum_type(underlying_graphql_type): enum_type = cast(GraphQLEnumType, self.schema.type_map[underlying_graphql_type.name]) name = enum_type.name if not any(e.name == name for e in self.parsed.enums): # pylint:disable=not-an-iterable parsed_enum = ParsedEnum( name=enum_type.name, values={name: value.value or name for name, value in enum_type.values.items()} ) self.parsed.enums.append(parsed_enum) # pylint:disable=no-member else: obj = ParsedObject( name=str(underlying_graphql_type) ) self.current.children.append(obj) self.push(obj) return node
def type(ctx, typ: str, kind: str, optional: bool, enum: str): """Generate one type""" generator = TypeGenerator(kind, optional=optional) type_map = ctx.obj['schema'].type_map for t in typ: if t not in type_map: print(f"No '{t}' type.") return type_ = type_map[t] type_def = '' if is_enum_type(type_): if enum == 'str': type_def = generator.str_enum_type(cast( GraphQLEnumType, type_)) elif enum == 'number': type_def = generator.number_enum_type( cast(GraphQLEnumType, type_)) elif is_object_type(type_): type_def = generator.object_type(cast(GraphQLObjectType, type_)) elif is_interface_type(type_): type_def = generator.interface_type( cast(GraphQLInterfaceType, type_)) elif is_input_object_type(type_): type_def = generator.input_type(cast(GraphQLInputObjectType, type_)) print(type_def)
def __parse_field(self, name, graphql_type): python_type, nullable, underlying_graphql_type = self.__scalar_type_to_python( graphql_type ) parsed_field = ParsedField(name=name, type=python_type, nullable=nullable) parsed_enum = None if not is_scalar_type(underlying_graphql_type): if is_enum_type(underlying_graphql_type): enum_type = cast( GraphQLEnumType, self.schema.type_map[underlying_graphql_type.name] ) name = enum_type.name if not any(e.name == name for e in self.parsed.enums): parsed_enum = ParsedEnum( name=enum_type.name, values={ name: value.value or name for name, value in enum_type.values.items() }, ) else: return parsed_field, underlying_graphql_type, parsed_enum return parsed_field, None, parsed_enum
def enter_field(self, node, *_): name = node.alias.value if node.alias else node.name.value graphql_type = self.type_info.get_type() python_type, nullable, underlying_graphql_type = self.__scalar_type_to_python(graphql_type) parsed_field = ParsedField( name=name, type=python_type, nullable=nullable, ) self.current.fields.append(parsed_field) # TODO: nullables should go to the end if not is_scalar_type(underlying_graphql_type): if is_enum_type(underlying_graphql_type): enum_type = cast(GraphQLEnumType, self.schema.type_map[underlying_graphql_type.name]) name = enum_type.name if not any(e.name == name for e in self.parsed.enums): # pylint:disable=not-an-iterable parsed_enum = ParsedEnum( name=enum_type.name, values={name: value.value or name for name, value in enum_type.values.items()} ) self.parsed.enums.append(parsed_enum) # pylint:disable=no-member else: obj = ParsedObject( name=str(underlying_graphql_type) ) self.current.children.append(obj) self.push(obj) return node
def all(ctx, kind: str): """Generate all schema types""" if kind not in ['none', 'dataclass', 'pydantic']: print('KIND must be none, dataclass or pydantic') return generator = TypeGenerator(kind) enum_types, interface_types, object_types, input_types = [], [], [], [] type_map = ctx.obj['schema'].type_map for name, type_ in type_map.items(): if name in ['Query', 'Mutation'] or name.startswith('__'): continue elif is_enum_type(type_): enum_types.append( generator.str_enum_type(cast(GraphQLEnumType, type_))) elif is_object_type(type_): object_types.append( generator.object_type(cast(GraphQLObjectType, type_))) elif is_interface_type(type_): interface_types.append( generator.interface_type(cast(GraphQLInterfaceType, type_))) elif is_input_object_type(type_): input_types.append( generator.input_type(cast(GraphQLInputObjectType, type_))) type_resolvers = TypeResolverGenerator(type_map).all_type_resolvers() imports, body = '', '' if enum_types: body += '\n'.join(enum_types) + '\n' if interface_types: body += '\n'.join(interface_types) + '\n' if object_types: body += '\n'.join(object_types) + '\n' if input_types: body += '\n'.join(input_types) if type_resolvers: body += '\n'.join(type_resolvers) if kind == 'dataclass': imports += 'from dataclasses import dataclass\n' if enum_types: imports += 'from enum import Enum\n' imports += 'from typing import Any, Dict, List, NewType, Optional, Union\n\n' imports += 'from gql import enum_type, type_resolver\n' if kind == 'pydantic': imports += 'from pydantic import BaseModel\n' imports += '\n' print(imports + body)
def map_schema_types(schema, ignore=['Query', 'Mutation']): """Iterate over a graphQl schema to get the schema types and its relations The process ignores the root types like Query and Mutation and the Scalar types""" objects = dict() enums = dict() for type_name, type_obj in schema.type_map.items(): # Iterating over all the items of the schema # Ignore internal types and root types if (type_name[:2] != '__') and (type_name not in ignore): # ENUM types if is_enum_type(type_obj): enums[type_name] = [] # values # Graphql Types elif is_object_type(type_obj): #Create the type obj obj = _get_object(objects, type_name) # Iterate over all fields of the graphql type for field_name, field_obj in type_obj.fields.items(): field = get_named_type( field_obj.type) # Returns a scalar or an object # setting non null nullable = True if contains_non_null_type(field_obj.type): nullable = False if is_scalar_type(field): obj['field'][field_name] = { 'type': field.name, 'nullable': nullable } elif is_object_type(field): # if it's a list of types, that means that I'm the parent in a one to many relationship list_ = False if contains_list_type(field_obj.type): list_ = True obj['relationship'][field_name] = { 'type': field.name, 'nullable': nullable, 'list': list_ } return {'objects': objects, 'enums': enums}
def compare_types(old_type, new_type): changes = [] if old_type.description != new_type.description: changes.append(TypeDescriptionChanged(new_type.name, old_type.description, new_type.description)) if type_kind(old_type) != type_kind(new_type): changes.append(TypeKindChanged(new_type, type_kind(old_type), type_kind(new_type))) else: if is_enum_type(old_type): changes += EnumDiff(old_type, new_type).diff() elif is_union_type(old_type): changes += UnionType(old_type, new_type).diff() elif is_input_object_type(old_type): changes += InputObjectType(old_type, new_type).diff() elif is_object_type(old_type): changes += ObjectType(old_type, new_type).diff() elif is_interface_type(old_type): changes += InterfaceType(old_type, new_type).diff() return changes