def create_input_field(field_name,
field_type,
required=False) -> GraphQLInputField:
if not required:
return GraphQLInputField(field_type, out_name=field_name)
else:
return GraphQLInputField(GraphQLNonNull(field_type),
out_name=field_name)
def get_fields() -> GraphQLInputFieldMap:
fields = {}
for column in get_table(model).columns:
fields[column.name] = GraphQLInputField(ORDER_BY_ENUM)
for name, relationship in get_relationships(model):
fields[name] = GraphQLInputField(
inputs[get_model_order_by_input_name(
relationship.mapper.entity)])
return fields
def get_fields() -> GraphQLInputFieldMap:
""" initial field population """
input_field1 = {
"where": {
"_and": GraphQLInputField(GraphQLList(inputs[type_name])),
"_or": GraphQLInputField(GraphQLList(inputs[type_name])),
"_not": GraphQLInputField(inputs[type_name]),
},
"on_conflict": {
"merge": GraphQLInputField(GraphQLNonNull(GraphQLBoolean)),
},
}
if input_type in input_field1.keys():
fields = input_field1[input_type]
else:
fields = get_empty_dict()
""" per column population """
for column in get_table(model).columns:
graphql_type = get_graphql_type_from_column(column.type)
column_type = GraphQLInputField(graphql_type)
input_field2 = {
"where":
GraphQLInputField(
get_type_comparison_fields(
graphql_type, inputs,
get_field_name(graphql_type, "comparison"))),
"order_by":
GraphQLInputField(ORDER_BY_ENUM),
"insert_input":
column_type,
"inc_input":
column_type if isinstance(column.type,
(Integer, Float)) else None,
"set_input":
column_type,
}
if input_type in input_field2.keys() and input_field2[input_type]:
fields[column.name] = cast(GraphQLInputField,
input_field2[input_type])
""" relationship population """
for name, relationship in get_relationships(model):
input_field3 = {
"where":
GraphQLInputField(inputs[get_field_name(
relationship.mapper.entity, "where")]),
"order_by":
GraphQLInputField(inputs[get_field_name(
relationship.mapper.entity, "order_by")]),
}
if input_type in input_field3.keys():
fields[name] = input_field3[input_type]
return fields
def get_conflict_type(model: DeclarativeMeta, inputs: Inputs) -> GraphQLInputObjectType:
type_name = get_field_name(model, "on_conflict")
if type_name in inputs:
return inputs[type_name]
fields = {
"constraint": GraphQLInputField(GraphQLNonNull(get_constraint_enum(model))),
"update_columns": GraphQLInputField(GraphQLNonNull(GraphQLList(GraphQLNonNull(get_update_column_enums(model))))),
"where": GraphQLInputField(get_input_type(model, inputs, "where")),
}
input_type = GraphQLInputObjectType(type_name, fields)
inputs[type_name] = input_type
return input_type
def get_base_comparison_fields(graphql_type: Union[GraphQLScalarType, GraphQLList]) -> Dict[str, GraphQLInputField]:
return {
"_eq": GraphQLInputField(graphql_type),
"_neq": GraphQLInputField(graphql_type),
"_in": GraphQLInputField(GraphQLList(GraphQLNonNull(graphql_type))),
"_nin": GraphQLInputField(GraphQLList(GraphQLNonNull(graphql_type))),
"_lt": GraphQLInputField(graphql_type),
"_gt": GraphQLInputField(graphql_type),
"_gte": GraphQLInputField(graphql_type),
"_lte": GraphQLInputField(graphql_type),
"_is_null": GraphQLInputField(GraphQLBoolean),
}
def get_fields() -> GraphQLInputFieldMap:
fields = {
"_and": GraphQLInputField(GraphQLList(inputs[type_name])),
"_or": GraphQLInputField(GraphQLList(inputs[type_name])),
"_not": GraphQLInputField(inputs[type_name]),
}
for column in get_table(model).columns:
fields[column.name] = GraphQLInputField(
get_comparison_input_type(column, inputs))
for name, relationship in get_relationships(model):
fields[name] = GraphQLInputField(inputs[get_model_where_input_name(
relationship.mapper.entity)])
return fields
def supports_thunks_as_input_and_output_fields():
some_mutation = mutation_with_client_mutation_id(
"SomeMutation",
{"inputData": GraphQLInputField(GraphQLInt)},
{"result": GraphQLField(GraphQLInt)},
dummy_resolve,
)
schema = wrap_in_schema({"someMutation": some_mutation})
source = """
mutation {
someMutation(input: {inputData: 1234, clientMutationId: "abc"}) {
result
clientMutationId
}
}
"""
assert graphql_sync(schema, source) == (
{
"someMutation": {
"result": 1234,
"clientMutationId": "abc",
}
},
None,
)
def make_model_fields_input_type(model: DeclarativeMeta,
type_name: str) -> GraphQLInputObjectType:
fields = {}
for column in get_table(model).columns:
fields[column.name] = GraphQLInputField(
get_graphql_type_from_column(column.type))
return GraphQLInputObjectType(type_name, fields)
def compile_input_field(self, field: InputField) -> GraphQLInputField:
assert isinstance(field, InputField)
return GraphQLInputField(
type_=self.get_graphql_type(field.type),
default_value=field.default_value,
description=field.description,
out_name=field.out_name,
)
def graphql_type(self):
type_ = self.type_()
if self.many:
type_ = GraphQLList(type_)
if self.required:
type_ = GraphQLNonNull(type_)
return GraphQLInputField(type_=type_,
default_value=self.default_value,
description=self.description)
def get_pk_columns_input(model: DeclarativeMeta) -> GraphQLInputObjectType:
type_name = get_model_pk_columns_input_type_name(model)
primary_key = get_table(model).primary_key
fields = {}
for column in primary_key.columns:
fields[column.name] = GraphQLInputField(
GraphQLNonNull(get_graphql_type_from_column(column.type)))
return GraphQLInputObjectType(type_name, fields)
def from_input_field(self, field: FieldDefinition) -> GraphQLInputField:
if field.default_value in [undefined, UNSET]:
default_value = Undefined
else:
default_value = field.default_value
field_type = self.get_graphql_type_field(field)
field_type = cast(GraphQLInputType, field_type)
return GraphQLInputField(type_=field_type,
default_value=default_value,
description=field.description)
def create_fields_for_type(self, graphene_type, is_input_type=False):
create_graphql_type = self.add_type
fields = {}
for name, field in graphene_type._meta.fields.items():
if isinstance(field, Dynamic):
field = get_field_as(field.get_type(self), _as=Field)
if not field:
continue
field_type = create_graphql_type(field.type)
if is_input_type:
_field = GraphQLInputField(
field_type,
default_value=field.default_value,
out_name=name,
description=field.description,
)
else:
args = {}
for arg_name, arg in field.args.items():
arg_type = create_graphql_type(arg.type)
processed_arg_name = arg.name or self.get_name(arg_name)
args[processed_arg_name] = GraphQLArgument(
arg_type,
out_name=arg_name,
description=arg.description,
default_value=Undefined
if isinstance(arg.type, NonNull)
else arg.default_value,
)
_field = GraphQLField(
field_type,
args=args,
resolve=field.get_resolver(
self.get_resolver_for_type(
graphene_type, f"resolve_{name}", name, field.default_value
)
),
subscribe=field.get_resolver(
self.get_resolver_for_type(
graphene_type,
f"subscribe_{name}",
name,
field.default_value,
)
),
deprecation_reason=field.deprecation_reason,
description=field.description,
)
field_name = field.name or self.get_name(name)
fields[field_name] = _field
return fields
def get_inc_input_type(model: DeclarativeMeta,
inputs: Inputs) -> GraphQLInputObjectType:
type_name = get_model_inc_input_type_name(model)
if type_name in inputs:
return inputs[type_name]
fields = {}
for column in get_table(model).columns:
if isinstance(column.type, (Integer, Float)):
fields[column.name] = GraphQLInputField(
get_graphql_type_from_column(column.type))
inputs[type_name] = GraphQLInputObjectType(type_name, fields)
return inputs[type_name]
def convert(self, type_map: t.Mapping[str, GraphQLType]) -> GraphQLInputField:
if self.type_name in type_map:
field_type = type_map[self.type_name]
else:
field_type = self.type_name.convert(type_map)
return GraphQLInputField(
t.cast(
t.Union[
GraphQLScalarType,
GraphQLEnumType,
GraphQLInputObjectType,
GraphQLWrappingType,
],
field_type,
)
)
def input_fields(self, source: Type[Any]) -> GraphQLInputFieldMap:
result: GraphQLInputFieldMap = {}
for build_type in self.build_type(source):
if build_type.metadata.get("readonly") is True:
continue
field_name = self.field_name(build_type.field)
description = build_type.metadata.get("description", "")
mapped_type = self.map_input(build_type.source)
if is_required(build_type.field):
mapped_type = GraphQLNonNull(mapped_type)
result[field_name] = GraphQLInputField(mapped_type,
description=description)
return result
def from_input_field(self, field: StrawberryField) -> GraphQLInputField:
field_type: GraphQLType
if isinstance(field.type, StrawberryOptional):
field_type = self.from_optional(field.type)
else:
field_type = self.from_non_optional(field.type)
default_value: object
if is_unset(field.default_value):
default_value = Undefined
else:
default_value = field.default_value
return GraphQLInputField(
type_=field_type,
default_value=default_value,
description=field.description,
)
def construct_fields_for_type(self, map_, type_, is_input_type=False):
fields = {}
for name, field in type_._meta.fields.items():
if isinstance(field, Dynamic):
field = get_field_as(field.get_type(self), _as=Field)
if not field:
continue
map_ = self.type_map_reducer(map_, field.type)
field_type = self.get_field_type(map_, field.type)
if is_input_type:
_field = GraphQLInputField(
field_type,
default_value=field.default_value,
out_name=name,
description=field.description,
)
else:
args = {}
for arg_name, arg in field.args.items():
map_ = self.type_map_reducer(map_, arg.type)
arg_type = self.get_field_type(map_, arg.type)
processed_arg_name = arg.name or self.get_name(arg_name)
args[processed_arg_name] = GraphQLArgument(
arg_type,
out_name=arg_name,
description=arg.description,
default_value=INVALID if isinstance(arg.type, NonNull)
else arg.default_value,
)
_field = GraphQLField(
field_type,
args=args,
resolve=field.get_resolver(
self.get_resolver_for_type(type_, name,
field.default_value)),
deprecation_reason=field.deprecation_reason,
description=field.description,
)
field_name = field.name or self.get_name(name)
fields[field_name] = _field
return fields
def __init__(self, session):
self.type_map = {
"Test":
GraphQLObjectType("Test",
GraphQLField(GraphQLList(GraphQLString))),
"TestEmptyObject":
GraphQLObjectType("TestEmptyObject", {}),
"TestNestedObjects":
GraphQLObjectType(
"TestNestedObjects",
{
"EnumField":
GraphQLField(
GraphQLEnumType("TestEnum", {
"RED": 0,
"GREEN": 1,
"BLUE": 2
})),
"InputField":
GraphQLInputField(GraphQLNonNull(GraphQLInt)),
"List":
GraphQLList(GraphQLString),
"InputObjectType":
GraphQLInputObjectType(
"TestInputObject",
GraphQLNonNull(
GraphQLUnionType("TestUnion",
[GraphQLString, GraphQLID])),
),
"ArgumentType":
GraphQLArgument(GraphQLBoolean),
"Float":
GraphQLFloat,
},
),
}
self.context = session
def get_string_comparison_fields() -> Dict[str, GraphQLInputField]:
return {"_like": GraphQLInputField(GraphQLString), "_nlike": GraphQLInputField(GraphQLString)}
def __init__(self):
super(ParamSchema, self).__init__(self)
self.parameter_data = {}
self.parameter_meta = {}
# the trick with parameters is that they are either floats or ints
# a custom type is required...
GraphQLParamValue = GraphQLScalarType(
name="ParamValue",
description="",
serialize=serialize_param_value,
parse_value=coerce_param_value,
parse_literal=parse_param_value_literal,
)
self.parameter_meta_input = GraphQLInputObjectType(
"MetaInput",
lambda: {
"humanName": GraphQLInputField(GraphQLString),
"humanGroup": GraphQLInputField(GraphQLString),
"documentation": GraphQLInputField(GraphQLString),
"group": GraphQLInputField(GraphQLString),
"increment": GraphQLInputField(GraphQLParamValue),
"min": GraphQLInputField(GraphQLParamValue),
"max": GraphQLInputField(GraphQLParamValue),
"decimal": GraphQLInputField(GraphQLParamValue),
"rebootRequired": GraphQLInputField(GraphQLBoolean),
"unitText": GraphQLInputField(GraphQLString),
"units": GraphQLInputField(GraphQLString),
"bitmask": GraphQLInputField(GraphQLString),
"values": GraphQLInputField(GraphQLString),
"type": GraphQLInputField(GraphQLString),
},
)
self.parameter_meta_type = GraphQLObjectType(
"Meta",
lambda: {
"humanName": GraphQLField(GraphQLString, description=""),
"humanGroup": GraphQLField(GraphQLString, description=""),
"documentation": GraphQLField(GraphQLString, description=""),
"group": GraphQLField(GraphQLString, description=""),
"increment": GraphQLField(GraphQLParamValue, description=""),
"min": GraphQLField(GraphQLParamValue, description=""),
"max": GraphQLField(GraphQLParamValue, description=""),
"decimal": GraphQLField(GraphQLParamValue, description=""),
"rebootRequired": GraphQLField(GraphQLBoolean, description=""),
"unitText": GraphQLField(GraphQLString, description=""),
"units": GraphQLField(GraphQLString, description=""),
"bitmask": GraphQLField(GraphQLString, description=""),
"values": GraphQLField(GraphQLString, description=""),
"type": GraphQLField(GraphQLString, description=""),
},
)
self.parameter_type = GraphQLObjectType(
"Parameter",
lambda: {
"id":
GraphQLField(GraphQLString,
description="The id of the parameter"),
"value":
GraphQLField(GraphQLParamValue,
description="The value of the parameter"),
"meta":
GraphQLField(self.parameter_meta_type),
},
description="Parameter item",
)
self.parameter_list_type = GraphQLObjectType(
"ParameterList",
lambda:
{"parameters": GraphQLField(GraphQLList(self.parameter_type))},
)
self.parameter_input_type = GraphQLInputObjectType(
"ParameterInput",
{
"id": GraphQLInputField(GraphQLNonNull(GraphQLString)),
"value": GraphQLInputField(GraphQLNonNull(GraphQLParamValue)),
},
)
self.q = {
"Parameter":
GraphQLField(
self.parameter_type,
args={
"id":
GraphQLArgument(
GraphQLNonNull(GraphQLString),
description="The id of the desired parameter.",
)
},
resolve=self.get_parameter,
),
"ParameterList":
GraphQLField(
self.parameter_list_type,
args={
"query":
GraphQLArgument(
GraphQLNonNull(GraphQLString),
description=
"The query used to match desired parameters. * can be used as a wildcard.",
)
},
resolve=self.get_parameter_list,
),
}
self.m = {
"Parameter":
GraphQLField(
self.parameter_type,
args={
"id": GraphQLArgument(GraphQLNonNull(GraphQLString)),
"value":
GraphQLArgument(GraphQLNonNull(GraphQLParamValue)),
"meta": GraphQLArgument(self.parameter_meta_input),
},
resolve=self.update_parameter,
),
"ParameterList":
GraphQLField(
self.parameter_list_type,
args={
"parameters":
GraphQLArgument(
GraphQLNonNull(GraphQLList(self.parameter_input_type)))
},
resolve=self.update_parameter_list,
),
}
self.s = {
"Parameter":
GraphQLField(self.parameter_type,
subscribe=self.sub_parameter,
resolve=None)
}
from .names import (
get_graphql_type_comparison_name,
get_model_inc_input_type_name,
get_model_insert_input_name,
get_model_order_by_input_name,
get_model_pk_columns_input_type_name,
get_model_set_input_type_name,
get_model_where_input_name,
)
from .types import Inputs
ORDER_BY_ENUM = GraphQLEnumType("order_by", {"desc": "desc", "asc": "asc"})
ON_CONFLICT_INPUT = GraphQLInputObjectType(
"on_conflict_input",
{
"merge": GraphQLInputField(GraphQLNonNull(GraphQLBoolean)),
},
)
def get_comparison_input_type(column: Column,
inputs: Inputs) -> GraphQLInputObjectType:
graphql_type = get_graphql_type_from_column(column.type)
type_name = get_graphql_type_comparison_name(graphql_type)
if type_name in inputs:
return inputs[type_name]
fields = get_base_comparison_fields(graphql_type)
if graphql_type == GraphQLString:
user_type = GraphQLObjectType(
"UserType",
{
"id": GraphQLField(GraphQLNonNull(GraphQLID)),
"firstName": GraphQLField(GraphQLNonNull(GraphQLString)),
"lastName": GraphQLField(GraphQLNonNull(GraphQLString)),
"tweets": GraphQLField(GraphQLInt),
"verified": GraphQLField(GraphQLNonNull(GraphQLBoolean)),
},
)
user_input_type = GraphQLInputObjectType(
"UserInputType",
{
"firstName": GraphQLInputField(GraphQLNonNull(GraphQLString)),
"lastName": GraphQLInputField(GraphQLNonNull(GraphQLString)),
"tweets": GraphQLInputField(GraphQLInt),
"verified": GraphQLInputField(GraphQLBoolean),
},
)
subscription_user_type = GraphQLObjectType(
"SubscriptionUserType",
{
"mutation": GraphQLField(mutation_type),
"user": GraphQLField(user_type)
},
)
def create_fields_for_type(self, graphene_type, is_input_type=False):
create_graphql_type = self.add_type
fields = {}
for name, field in graphene_type._meta.fields.items():
if isinstance(field, Dynamic):
field = get_field_as(field.get_type(self), _as=Field)
if not field:
continue
field_type = create_graphql_type(field.type)
if is_input_type:
_field = GraphQLInputField(
field_type,
default_value=field.default_value,
out_name=name,
description=field.description,
)
else:
args = {}
for arg_name, arg in field.args.items():
arg_type = create_graphql_type(arg.type)
processed_arg_name = arg.name or self.get_name(arg_name)
args[processed_arg_name] = GraphQLArgument(
arg_type,
out_name=arg_name,
description=arg.description,
default_value=arg.default_value,
)
subscribe = field.wrap_subscribe(
self.get_function_for_type(graphene_type,
f"subscribe_{name}", name,
field.default_value))
# If we are in a subscription, we use (by default) an
# identity-based resolver for the root, rather than the
# default resolver for objects/dicts.
if subscribe:
field_default_resolver = identity_resolve
elif issubclass(graphene_type, ObjectType):
default_resolver = (graphene_type._meta.default_resolver
or get_default_resolver())
field_default_resolver = partial(default_resolver, name,
field.default_value)
else:
field_default_resolver = None
resolve = field.wrap_resolve(
self.get_function_for_type(
graphene_type, f"resolve_{name}", name,
field.default_value) or field_default_resolver)
_field = GraphQLField(
field_type,
args=args,
resolve=resolve,
subscribe=subscribe,
deprecation_reason=field.deprecation_reason,
description=field.description,
)
field_name = field.name or self.get_name(name)
fields[field_name] = _field
return fields
"episode": GraphQLField(episode_enum, description="The movie"),
"stars": GraphQLField(
GraphQLNonNull(GraphQLInt),
description="The number of stars this review gave, 1-5",
),
"commentary": GraphQLField(
GraphQLString, description="Comment about the movie"
),
},
description="Represents a review for a movie",
)
review_input_type = GraphQLInputObjectType(
"ReviewInput",
lambda: {
"stars": GraphQLInputField(GraphQLInt, description="0-5 stars"),
"commentary": GraphQLInputField(
GraphQLString, description="Comment about the movie, optional"
),
},
description="The input object sent when someone is creating a new review",
)
query_type = GraphQLObjectType(
"Query",
lambda: {
"hero": GraphQLField(
character_interface,
args={
"episode": GraphQLArgument(
episode_enum,
def __init__(self):
super().__init__()
# create a mission database dir
self.mission_database_dir = Path(options.datadir).joinpath("missions")
# make the path if it does not exist
mkdirs(self.mission_database_dir)
self.mission_data = {}
self.mission_meta = {
"meta": {
"total": 0,
"updateTime": int(time.time())
}
}
self.mission_type = GraphQLObjectType(
"Mission",
lambda: {
"seq":
GraphQLField(GraphQLInt,
description=
"The sequence number of the mission item."),
"isCurrent":
GraphQLField(
GraphQLBoolean,
description=
"True if this mission item is the active target",
),
"autocontinue":
GraphQLField(
GraphQLBoolean,
description="Continue mission after this mission item",
),
"frame":
GraphQLField(GraphQLInt, description=""),
"command":
GraphQLField(GraphQLInt, description=""),
"param1":
GraphQLField(GraphQLFloat, description=""),
"param2":
GraphQLField(GraphQLFloat, description=""),
"param3":
GraphQLField(GraphQLFloat, description=""),
"param4":
GraphQLField(GraphQLFloat, description=""),
"latitude":
GraphQLField(GraphQLFloat, description=""),
"longitude":
GraphQLField(GraphQLFloat, description=""),
"altitude":
GraphQLField(GraphQLFloat, description=""),
},
description="Mission item",
)
self.mission_input_type = GraphQLInputObjectType(
"MissionInput",
{
"seq":
GraphQLInputField(
GraphQLNonNull(GraphQLInt),
description="The sequence number of the mission item.",
),
"isCurrent":
GraphQLInputField(
GraphQLNonNull(GraphQLBoolean),
description=
"True if this mission item is the active target",
),
"autocontinue":
GraphQLInputField(
GraphQLNonNull(GraphQLBoolean),
description="Continue mission after this mission item",
),
"frame":
GraphQLInputField(GraphQLNonNull(GraphQLInt), description=""),
"command":
GraphQLInputField(GraphQLNonNull(GraphQLInt), description=""),
"param1":
GraphQLInputField(GraphQLNonNull(GraphQLFloat),
description=""),
"param2":
GraphQLInputField(GraphQLNonNull(GraphQLFloat),
description=""),
"param3":
GraphQLInputField(GraphQLNonNull(GraphQLFloat),
description=""),
"param4":
GraphQLInputField(GraphQLNonNull(GraphQLFloat),
description=""),
"latitude":
GraphQLInputField(GraphQLNonNull(GraphQLFloat),
description=""),
"longitude":
GraphQLInputField(GraphQLNonNull(GraphQLFloat),
description=""),
"altitude":
GraphQLInputField(GraphQLNonNull(GraphQLFloat),
description=""),
},
)
self.mission_list_type = GraphQLObjectType(
"MissionList",
lambda: {
"id":
GraphQLField(GraphQLString,
description="The id of the mission."),
"mission":
GraphQLField(GraphQLList(self.mission_type)),
"total":
GraphQLField(GraphQLInt,
description="Total number of mission items"),
"updateTime":
GraphQLField(GraphQLInt, description=""),
},
description="Mission",
)
self.mission_database_type = GraphQLObjectType(
"MissionDatabase",
lambda: {
"id":
GraphQLField(
GraphQLString,
description=
"The id of the database use the wildcard '*' to access all avalable databases.",
),
"missions":
GraphQLField(GraphQLList(self.mission_list_type)),
"total":
GraphQLField(GraphQLInt,
description="Total number of missions in database"
),
"updateTime":
GraphQLField(GraphQLInt, description=""),
},
description="Collection of missions",
)
self.q = {
"Mission":
GraphQLField(
self.mission_type,
args={
"seq":
GraphQLArgument(
GraphQLNonNull(GraphQLInt),
description=
"The sequence number of desired mission item",
)
},
resolve=self.get_mission,
),
"MissionList":
GraphQLField(
self.mission_list_type,
args={
"id":
GraphQLArgument(
GraphQLNonNull(GraphQLString),
description="The id of the desired mission",
)
},
resolve=self.get_mission_list,
),
"MissionDatabase":
GraphQLField(
self.mission_database_type,
args={
"id":
GraphQLArgument(
GraphQLNonNull(GraphQLString),
description="The id of the database",
)
},
resolve=self.get_mission_database,
),
}
self.m = {
"Mission":
GraphQLField(
self.mission_type,
args=self.get_mutation_args(self.mission_type),
resolve=self.update_mission,
),
"MissionList":
GraphQLField(
self.mission_list_type,
args={
"id":
GraphQLArgument(GraphQLNonNull(GraphQLString)),
"mission":
GraphQLArgument(
GraphQLNonNull(GraphQLList(self.mission_input_type))),
},
resolve=self.update_mission_list,
),
}
self.s = {
"Mission":
GraphQLField(self.mission_type,
subscribe=self.sub_mission,
resolve=None),
"MissionList":
GraphQLField(self.mission_list_type,
subscribe=self.sub_mission_list,
resolve=None),
"MissionDatabase":
GraphQLField(
self.mission_database_type,
subscribe=self.sub_mission_database,
resolve=None,
),
}
from graphql import (
GraphQLArgument,
GraphQLField,
GraphQLInputField,
GraphQLInputObjectType,
GraphQLInt,
GraphQLObjectType,
GraphQLSchema,
GraphQLString,
)
nestedInput = GraphQLInputObjectType(
"Nested",
description="The input object that has a field pointing to itself",
fields={"foo": GraphQLInputField(GraphQLInt, description="foo")},
)
nestedInput.fields["child"] = GraphQLInputField(nestedInput, description="child")
queryType = GraphQLObjectType(
"Query",
fields=lambda: {
"echo": GraphQLField(
args={"nested": GraphQLArgument(type_=nestedInput)},
resolve=lambda *args, **kwargs: json.dumps(kwargs["nested"]),
type_=GraphQLString,
),
},
)
from graphql import GraphQLObjectType, GraphQLField, GraphQLString, GraphQLInt, GraphQLList, GraphQLScalarType, \
GraphQLNonNull, GraphQLInputObjectType, GraphQLInputField
from .query.service import ServiceType, resolve_services
PortsType = GraphQLObjectType(name="Ports",
fields={
"internal":
GraphQLField(GraphQLString,
resolve=lambda x, i: x[1]),
"external":
GraphQLField(GraphQLString,
resolve=lambda x, i: x[0])
})
VarsType = GraphQLScalarType(name="Vars", serialize=lambda x: x)
VarInputType = GraphQLInputObjectType(name="StackVar",
fields={
"name":
GraphQLInputField(
GraphQLNonNull(GraphQLString)),
"value":
GraphQLInputField(GraphQLString),
})
def __init__(self, shipId, factionId, clientMutationId=None):
self.shipId = shipId
self.factionId = factionId
self.clientMutationId = clientMutationId
# noinspection PyPep8Naming
def mutate_and_get_payload(_info, shipName, factionId, **_input):
new_ship = create_ship(shipName, factionId)
return IntroduceShipMutation(shipId=new_ship.id, factionId=factionId)
shipMutation = mutation_with_client_mutation_id(
"IntroduceShip",
input_fields={
"shipName": GraphQLInputField(GraphQLNonNull(GraphQLString)),
"factionId": GraphQLInputField(GraphQLNonNull(GraphQLID)),
},
output_fields={
"ship": GraphQLField(
shipType, resolve=lambda payload, _info: get_ship(payload.shipId)
),
"faction": GraphQLField(
factionType, resolve=lambda payload, _info: get_faction(payload.factionId)
),
},
mutate_and_get_payload=mutate_and_get_payload,
)
# This is the type that will be the root of our mutations, and the
# entry point into performing writes in our schema.
def get_type_comparison_fields(graphql_type: Union[GraphQLScalarType,
GraphQLList],
inputs: Inputs,
type_name: str) -> GraphQLInputObjectType:
if type_name in inputs:
return inputs[type_name]
fields = {
"_eq": GraphQLInputField(graphql_type),
"_neq": GraphQLInputField(graphql_type),
"_in": GraphQLInputField(GraphQLList(GraphQLNonNull(graphql_type))),
"_nin": GraphQLInputField(GraphQLList(GraphQLNonNull(graphql_type))),
"_lt": GraphQLInputField(graphql_type),
"_gt": GraphQLInputField(graphql_type),
"_gte": GraphQLInputField(graphql_type),
"_lte": GraphQLInputField(graphql_type),
"_is_null": GraphQLInputField(GraphQLBoolean),
}
fields_string = {
"_like": GraphQLInputField(GraphQLString),
"_nlike": GraphQLInputField(GraphQLString),
}
if graphql_type == GraphQLString:
fields.update(fields_string)
inputs[type_name] = GraphQLInputObjectType(type_name, fields)
return inputs[type_name]
