def test_graphql():
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
building = ObjectType('Building')
resident = ObjectType('Resident')
# test dataset
rec = building_with_id(None, None, "1")
assert rec == {'id': '1', 'buildYear': 2009}
residents = resolve_residents_in_building(rec, None)
assert len(residents) > 0
# field holders
query.set_field('building_with_id', building_with_id)
building.set_field('residents', resolve_residents_in_building)
schema = make_executable_schema(type_defs, [building, resident, query])
q = """{
building_with_id(_id:"1"){
id
residents {
id
name
}
}
}
"""
result = graphql_sync(schema, q)
pprint(result.data)
assert result.data['building_with_id']['id'] == '1'
class User():
def __init__(self, username, name):
self.username = username
self.name = name
self.type = ObjectType("User")
self.type.set_field("username", lambda _, info: self.username)
self.type.set_field("name", lambda _, info: self.name)
def test_field_resolver_can_be_set_using_setter(schema):
query = ObjectType("Query")
query.set_field("hello", lambda *_: "World")
query.bind_to_schema(schema)
result = graphql_sync(schema, "{ hello }")
assert result.errors is None
assert result.data == {"hello": "World"}
def __init__(self):
from sagas.conf import resource_path
self.type_defs = load_schema_from_path(resource_path('schemas.graphql'))
query = QueryType()
bucket = ObjectType('Bucket')
behave = ObjectType('Behave')
desc = ObjectType('Desc')
query.set_field('bucket_behaves', bucket_behaves)
bucket.set_field('behaves', resolve_behaves)
self.schema = make_executable_schema(self.type_defs, [behave, bucket, query])
def test_interface_resolver_doesnt_override_existing_resolver(schema, interface):
user = ObjectType("User")
user.set_field("summary", test_resolver)
user.bind_to_schema(schema)
def interface_resolver(*_):
pass # pragma: no cover
interface.set_field("summary", interface_resolver)
interface.bind_to_schema(schema)
field = schema.type_map.get("User").fields["summary"]
assert field.resolve is test_resolver
def test_default_fallback_is_not_replacing_already_set_resolvers(schema):
resolvers_map = ObjectType("Query")
resolvers_map.set_field("hello", lambda *_: False)
resolvers_map.set_field("snake_case", lambda *_: False)
resolvers_map.bind_to_schema(schema)
fallback_resolvers.bind_to_schema(schema)
query_root = {
"hello": True,
"snake_case": True,
"camel": True,
"camel_case": True
}
result = graphql_sync(schema, query, root_value=query_root)
assert result.data == {
"hello": False,
"snake_case": False,
"Camel": None,
"camelCase": None,
}
def test_custom_resolver_is_called_to_resolve_custom_type_field_value():
type_defs = """
type Query {
test: Custom
}
type Custom {
node: String
}
"""
query = QueryType()
query.set_field("test", lambda *_: {"node": "custom"})
custom = ObjectType("Custom")
custom.set_field("node", lambda *_: "deep")
schema = make_executable_schema(type_defs, [query, custom])
result = graphql_sync(schema, "{ test { node } }")
assert result.errors is None
assert result.data == {"test": {"node": "deep"}}
def test_custom_and_default_resolvers_are_combined_to_resolve_custom_type_fields(
):
type_defs = """
type Query {
test: Custom
}
type Custom {
node: String
default: String
}
"""
query = QueryType()
query.set_field("test", lambda *_: {"node": "custom", "default": "ok"})
custom = ObjectType("Custom")
custom.set_field("node", lambda *_: "deep")
schema = make_executable_schema(type_defs, [query, custom])
result = graphql_sync(schema, "{ test { node default } }")
assert result.errors is None
assert result.data == {"test": {"node": "deep", "default": "ok"}}
from api import app, db
from ariadne import load_schema_from_path, make_executable_schema, \
graphql_sync, snake_case_fallback_resolvers, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import request, jsonify
from api.mutations import resolve_create_todo, resolve_mark_done, \
resolve_delete_todo, resolve_update_due_date
from api.queries import resolve_todos, resolve_todo
query = ObjectType("Query")
mutation = ObjectType("Mutation")
query.set_field("todos", resolve_todos)
query.set_field("todo", resolve_todo)
mutation.set_field("createTodo", resolve_create_todo)
mutation.set_field("markDone", resolve_mark_done)
mutation.set_field("deleteTodo", resolve_delete_todo)
mutation.set_field("updateDueDate", resolve_update_due_date)
type_defs = load_schema_from_path("schema.graphql")
schema = make_executable_schema(type_defs, query, mutation,
snake_case_fallback_resolvers)
@app.route("/graphql", methods=["GET"])
def graphql_playground():
return PLAYGROUND_HTML, 200
import resolver as r
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
students = ObjectType('Students')
classes = ObjectType('Classes')
mutation = ObjectType('Mutation')
query.set_field('student_with_id', r.student_with_id)
query.set_field('class_with_id', r.class_with_id)
query.set_field('all_students', r.all_students)
query.set_field('all_classes', r.all_classes)
mutation.set_field('add_student', r.add_student)
mutation.set_field('add_class', r.add_class)
mutation.set_field('add_student_to_class', r.add_student_to_class)
schema = make_executable_schema(type_defs, [students, classes, query, mutation])
@app.route('/graphql', methods=['GET'])
def playground():
return PLAYGROUND_HTML, 200
@app.route('/graphql', methods=['POST'])
def graphql_server():
data = request.get_json()
from ariadne import load_schema_from_path, ObjectType, QueryType, MutationType
from features.Composers.composer import resolve_composer
from features.Songs.song import resolve_song, create_song, update_song, get_songs
songQueries = QueryType()
songMutations = MutationType()
songTypes = load_schema_from_path("./features/Songs/song.gql")
songObjectType = ObjectType('FBSong')
songObjectType.set_field("composer", resolve_composer)
songQueries.set_field('getSong', resolve_song)
songQueries.set_field('getSongs', get_songs)
songMutations.set_field('createSong', create_song)
songMutations.set_field('updateSong', update_song)
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
import resolver as r
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
#query = QueryType()
query = ObjectType("Query")
mutation = ObjectType("Mutation")
student = ObjectType('Student')
classes = ObjectType('Classes')
#Set Query fields
query.set_field("student", r.getStudents)
query.set_field("class", r.getClasses)
#Set Mutation fields
mutation.set_field("newStudent", r.addStudent)
mutation.set_field("newClass", r.addClass)
mutation.set_field("updateClass", r.updateClass)
schema = make_executable_schema(type_defs, [query, student, classes, mutation])
@app.route('/graphql', methods=['GET'])
def playground():
return PLAYGROUND_HTML, 200
from ariadne import ObjectType
from . import auth
from . import user
from . import forum
from . import thread
query = ObjectType("Query")
query.set_field("user", auth.resolve_login)
query.set_field("pubkey", auth.resolve_pubkey)
query.set_field("isAuthenticated", auth.resolve_isAuthenticated)
query.set_field("isAuthenticated1", auth.resolve_isAuthenticated1)
query.set_field("updateToken", auth.resolve_updateToken)
query.set_field("userProfile", user.resolve_userProfile)
query.set_field("isSuper", user.resolve_isSuper)
query.set_field("sections", forum.resolve_sections)
query.set_field("threads", thread.resolve_threads)
query.set_field("thread", thread.resolve_thread)
# Type
query = ObjectType("Query")
mutation = ObjectType("Mutation")
vehicle = ObjectType("Vehicle")
vehicle_type = ObjectType("VehicleType")
location = ObjectType("Location")
membership = ObjectType("Membership")
creditcardinfo = ObjectType("CreditCardInfo")
user = ObjectType("User")
token = ObjectType("Token")
Available_interval = ObjectType("Available_interval")
comment = ObjectType("Comment")
# Set Query fields
query.set_field("vehicles", r.getVehicles)
query.set_field("vehicle", r.getVehicle)
query.set_field("vehicle_types", r.getVehicleTypes)
query.set_field("vehicle_type", r.getVehicleType)
query.set_field("searchLocations", r.searchLocations)
query.set_field("location", r.getLocation)
query.set_field("membership", r.getMembership)
query.set_field("creditcardinfo", r.getCreditCardInfo)
query.set_field("user", r.getUser)
query.set_field("userbytoken", r.tokenGetUser)
query.set_field("searchUsers", r.searchUsers)
query.set_field("login", r.login)
query.set_field("get_available_time", r.get_available_time)
query.set_field("reservation", r.get_reservation)
query.set_field("reservations", r.search_reservations)
query.set_field("search_user_reservations", r.search_user_reservations)
from api import app, db
from api import models
from ariadne import load_schema_from_path, make_executable_schema, \
graphql_sync, snake_case_fallback_resolvers, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import request, jsonify
from api.queries import resolve_employees, resolve_emp
from api.mutations import resolve_create_employee
query = ObjectType("Query")
print(resolve_employees)
query.set_field("employees", resolve_employees)
query.set_field("employee", resolve_emp)
print(resolve_create_employee)
mutation = ObjectType("Mutation")
mutation.set_field("createEmployee", resolve_create_employee)
type_defs = load_schema_from_path("employee.graphql")
schema = make_executable_schema(type_defs, query,
snake_case_fallback_resolvers)
@app.route("/graphql", methods=["GET"])
def graphql_playground():
return PLAYGROUND_HTML, 200
@app.route("/graphql", methods=["POST"])
def graphql_server():
data = request.get_json()
graphql_sync, snake_case_fallback_resolvers, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import request, jsonify
from api.queries import resolve_match_phrases, resolve_match_tokens, resolve_match_skill, resolve_spacy_meta, \
resolve_is_english, \
resolve_language, resolve_analysis, resolve_wolfram_query, resolve_wolfram_voice, resolve_wolfram_check, \
resolve_wolfram_conversation
from api.mutations import resolve_register_skill, resolve_register_domain
# The queries
query = ObjectType("Query")
mutation = ObjectType("Mutation")
query.set_field("match_skill", resolve_match_skill)
query.set_field("match_phrases", resolve_match_phrases)
query.set_field("match_tokens", resolve_match_tokens)
query.set_field("spacy_meta", resolve_spacy_meta)
query.set_field("english", resolve_is_english)
query.set_field("language", resolve_language)
query.set_field("analysis", resolve_analysis)
query.set_field("wolfram_query", resolve_wolfram_query)
query.set_field("wolfram_voice", resolve_wolfram_voice)
query.set_field("wolfram_check", resolve_wolfram_check)
query.set_field("wolfram_conversation", resolve_wolfram_conversation)
# Mutations
mutation.set_field("register_skill", resolve_register_skill)
mutation.set_field("register_domain", resolve_register_domain)
def create_entity(name, key_resolvers, key_name):
object_type = ObjectType(name)
setattr(object_type, "key_resolver", key_resolvers)
object_type.set_field(key_name, key_resolvers)
return object_type
mtmPnl=mtmPnl,
buySell=buySell,
)
db.session.add(trade)
db.session.commit()
payload = {"success": True, "trade": trade.to_dict()}
except Exception as e:
payload = {"success": False, "errors": [str(e)]}
return payload
def resolve_trades(obj, info, symbol: str = "") -> Dict:
try:
trades = [x.to_dict() for x in Trade.query.all()]
payload = {"success": True, "trades": trades}
except Exception as e:
payload = {"success": False, "errors": [str(e)]}
return payload
query = ObjectType("Query")
query.set_field("trades", resolve_trades)
mutation = ObjectType("Mutation")
mutation.set_field("createTrade", resolve_create_trade)
type_defs = load_schema_from_path("api/schema.graphql")
schema = make_executable_schema(type_defs, query, mutation,
snake_case_fallback_resolvers)
all_resolvers = []
# Map resolver functions to Query fields using QueryType
if 'Query' in resolvers and len(resolvers['Query']) > 0:
query = QueryType()
for q in resolvers['Query']:
query.set_field(q, resolvers['Query'][q])
all_resolvers.append(query)
# Map resolver functions to custom type fields using ObjectType
if 'Object' in resolvers and len(resolvers['Object']) > 0:
for obj in resolvers['Object']:
objType = ObjectType(obj)
for fld in resolvers['Object'][obj]:
objType.set_field(fld, resolvers['Object'][obj][fld])
all_resolvers.append(objType)
# Map resolver functions to Mutation fields using MutationType
if 'Mutation' in resolvers and len(resolvers['Mutation']) > 0:
mutation = MutationType()
for m in resolvers['Mutation']:
mutation.set_field(m, resolvers['Mutation'][m])
all_resolvers.append(mutation)
# Map resolver functions to custom scalars using ScalarType
if 'Scalar' in resolvers and len(resolvers['Scalar']) > 0:
for scalar in resolvers['Scalar']:
scalarType = ScalarType(scalar)
scalarType.set_serializer(resolvers['Scalar'][scalar]['serializer'])
scalarType.set_literal_parser(
class Service:
def __init__(self, service_name, schema, query):
self.gql_type = ObjectType("_Service")
self.service_name = service_name
self.query = query
self.directives = {
"key": KeyDirective,
"requires": RequiresDirective,
"provides": ProvidesDirective,
"external": ExternalDirective,
"extends": ExtendsDirective
}
self.sdl = schema
self.entities = {}
self.federation_types = [self.gql_type]
self.query.set_field("_service", self.resolve_service)
self.gql_type.set_field("sdl", self.resolve_sdl)
self.gql_type.set_field("name", self.resolve_name)
def resolve_name(self, info, context):
return self.service_name
def resolve_service(self, info, context):
return self.gql_type
def resolve_sdl(self, info, context):
return self.sdl
def resolve_entities(self, obj, *_):
return obj["__typename"]
def _entities(self, *_, representations=None):
rv = []
for representation in representations:
entity_type = self.entities[representation["__typename"]]
key = {
k: v
for (k, v) in representation.items() if k != "__typename"
}
entity = entity_type.key_resolver(key)
entity["__typename"] = representation["__typename"]
rv.append(entity)
return rv
def create_schema_from_template(self):
template = SERVICE_TEMPLATE
entity_union_str = self._make_entity_str()
entity_query_str = ""
if entity_union_str != "":
entity_union = UnionType("_Entity")
entity_union.set_type_resolver(self.resolve_entities)
self.query.set_field("_entities", self._entities)
entity_query_str = ENTITY_QUERY
self.federation_types.append(entity_union)
template = template.format(union_entities=entity_union_str,
entity_query=entity_query_str,
query_str=self.sdl)
return make_executable_schema(
template, [self.query, _Any, _FieldSet] +
[ObjectType(entity_name)
for entity_name in self.entities.keys()] + self.federation_types,
directives=self.directives)
def _make_entity_str(self):
if len(self.entities) <= 0:
return ""
entity_names = list(self.entities.keys())
union_str = "union _Entity = " + entity_names[0]
for entity_name in entity_names[1:]:
union_str += " | "
union_str += entity_name
return union_str
def add_entity(self, entity_type):
self.entities[entity_type.name] = entity_type
from scoreboardapi import app, db
from ariadne import load_schema_from_path, make_executable_schema, \
graphql_sync, snake_case_fallback_resolvers, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import request, jsonify
from scoreboardapi.mutations import resolve_create_player, \
resolve_delete_player, resolve_update_score
from scoreboardapi.queries import resolve_players, resolve_player
query = ObjectType("Query")
mutation = ObjectType("Mutation")
query.set_field("players", resolve_players)
query.set_field("player", resolve_player)
mutation.set_field("createPlayer", resolve_create_player)
mutation.set_field("deletePlayer", resolve_delete_player)
mutation.set_field("updateScore", resolve_update_score)
type_defs = load_schema_from_path("schema.graphql")
schema = make_executable_schema(
type_defs, query, mutation, snake_case_fallback_resolvers
)
# access to the main dashboard
@app.route("/graphql", methods=["GET"])
@convert_kwargs_to_snake_case
def resolve_update_courses(obj, info, courses):
courseIdList = []
for i in range(NO_OF_OBJECTS):
if courseList[i]["id"] == courses[i]["id"]:
courseList[i]["course_name"] = courses[i]["course_name"]
courseList[i]["avg_marks"] = courses[i]["avg_marks"]
courseIdList.append({"id": courseList[i]["id"]})
return courseIdList
query = ObjectType("Query")
query.set_field("getCourses", resolve_get_courses)
query.set_field("getCourse", resolve_get_course)
mutation = ObjectType("Mutation")
mutation.set_field("updateCourse", resolve_update_course)
mutation.set_field("updateCourses", resolve_update_courses)
type_defs = load_schema_from_path("course.graphql")
schema = make_executable_schema(type_defs, query, mutation,
snake_case_fallback_resolvers)
if __name__ == "__main__":
populate()
app.run(debug=True)
"""
query {
mutation_query_graphql = MutationType()
mutation_query_graphql.set_field('add_student', r.resolve_student_create)
mutation_query_graphql.set_field('add_class', r.resolve_class_create)
mutation_query_graphql.set_field('add_student_to_class', r.resolve_add_student_to_class)
query_graphql = QueryType()
student_type = ObjectType('Student')
class_type = ObjectType('Class')
query_graphql.set_field('student_by_id', r.resolve_student_by_id)
query_graphql.set_field('class_by_id', r.resolve_class_by_id)
query_graphql.set_field('students', r.resolve_students)
query_graphql.set_field('classes', r.resolve_classes)
class_type.set_field('students', r.resolve_students_in_classes)
schema = make_executable_schema(type_defs, [student_type, class_type, query_graphql, mutation_query_graphql])
@app.route('/graphql', methods=['GET'])
def playground():
return PLAYGROUND_HTML, 200
@app.route('/graphql', methods=['POST'])
def graphql_server():
data = request.get_json()
success, result = graphql_sync(
schema,
data,
request: HttpRequest = info.context["request"]
queryset = Object.objects.filter_for_user(
request.user).filter(bucket__name=kwargs["bucketS3Name"])
if "parentS3Key" in kwargs:
queryset = queryset.filter(
parent_key=f"{kwargs['bucketS3Name']}/{kwargs['parentS3Key']}", )
else:
queryset = queryset.filter(parent_key=f"{kwargs['bucketS3Name']}/", )
return result_page(queryset=queryset, page=kwargs["page"])
bucket = ObjectType("S3Bucket")
bucket.set_field("tags", resolve_tags)
bucket.set_alias("s3Name", "name")
@bucket.field("icon")
def resolve_icon(obj: Bucket, info):
request: HttpRequest = info.context["request"]
return request.build_absolute_uri(static("connector_s3/img/symbol.svg"))
@bucket.field("contentType")
def resolve_content_type(obj: Bucket, info):
return trans("S3 Bucket")
@bucket.field("objects")
from database import init_db
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
#query = QueryType()
query = ObjectType("Query")
mutation = ObjectType("Mutation")
vehicle = ObjectType("Vehicle")
booking = ObjectType("Booking")
#Set Query fields
query.set_field("vehicle", r.getVehicles)
query.set_field("booking", r.getBookings)
#Set Mutation fields
mutation.set_field("newBooking",r.addBooking)
schema = make_executable_schema(type_defs, [query, booking, vehicle, mutation])
@app.route('/graphql', methods=['GET'])
def playground():
return PLAYGROUND_HTML, 200
@app.route('/graphql', methods=['POST'])
def graphql_server():
data = request.get_json()
resolved_instance = Instance.objects.filter_for_user(
request.user).get(pk=kwargs["id"])
return resolved_instance
instance = ObjectType("Dhis2Instance")
@instance.field("icon")
def resolve_icon(obj: Instance, info):
request: HttpRequest = info.context["request"]
return request.build_absolute_uri(static("connector_dhis2/img/symbol.svg"))
instance.set_field("tags", resolve_tags)
@instance.field("contentType")
def resolve_content_type(obj: Instance, info):
return _("DHIS2 Instance")
dhis2_mutation = MutationType()
@dhis2_mutation.field("dhis2InstanceUpdate")
def resolve_dhis2_instance_update(_, info, **kwargs):
updated_instance = Instance.objects.get(id=kwargs["id"])
instance_data = kwargs["input"]
from ariadne import QueryType, graphql_sync, make_executable_schema, load_schema_from_path, ObjectType
import resolver as r
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
mutation = ObjectType('Mutation')
student = ObjectType('student')
classes = ObjectType('classes')
app = Flask(__name__)
#GET method
query.set_field('get_student', r.get_student)
query.set_field('get_class', r.get_class)
#POST method
mutation.set_field('create_student', r.create_student)
mutation.set_field('create_class', r.create_class)
#PATCH method
mutation.set_field('update_stu_class', r.update_stu_class)
schema = make_executable_schema(type_defs, [student, classes, query, mutation])
@app.route('/')
def hello():
name = request.args.get("name", "World")
return f'Hello, {escape(name)}!'
@app.route("/graphql", methods=["GET"])
from ariadne import ObjectType
from . import auth
from . import user
from . import forum
from . import thread
from . import post
mutation = ObjectType("Mutation")
mutation.set_field("login", auth.resolve_login)
mutation.set_field("register", auth.resolve_register)
mutation.set_field("resetPassword", auth.resolve_resetPassword)
mutation.set_field("updateSetting", user.resolve_updateSetting)
mutation.set_field("sectionAct", forum.resolve_sectionAct)
mutation.set_field("threadAct", thread.resolve_threadAct)
mutation.set_field("postAct", post.resolve_postAct)
from ariadne import load_schema_from_path, ObjectType, QueryType, MutationType
from features.Composers.composer import resolve_composer, create_composer, update_composer, get_composers
from features.Songs.song import resolve_songs
from features.Songs.songTypes import songQueries
composerQueries = QueryType()
composerMutations = MutationType()
composerTypes = load_schema_from_path("./features/Composers/composer.gql")
composerObjectType = ObjectType('FBComposer')
composerObjectType.set_field("songs", resolve_songs)
composerQueries.set_field('getComposer', resolve_composer)
songQueries.set_field('getComposers', get_composers)
composerMutations.set_field('createComposer', create_composer)
composerMutations.set_field('updateComposer', update_composer)
from api import app, db
from ariadne import load_schema_from_path, make_executable_schema, \
graphql_sync, snake_case_fallback_resolvers, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import request, jsonify
from api.queries import fetch_wallets, fetch_one_wallet
from api.mutations import create_wallet, delete_wallet, add_coin_to_wallet
query = ObjectType("Query")
mutation = ObjectType("Mutation")
query.set_field("wallets", fetch_wallets)
query.set_field("wallet", fetch_one_wallet)
mutation.set_field("createWallet", create_wallet)
mutation.set_field("deleteWallet", delete_wallet)
mutation.set_field("addNewCoinToWallet", add_coin_to_wallet)
type_defs = load_schema_from_path("schema.graphql")
schema = make_executable_schema(type_defs, query, mutation,
snake_case_fallback_resolvers)
@app.route("/graphql", methods=["GET"])
def graphql_playground():
return PLAYGROUND_HTML, 200
@app.route("/graphql", methods=["POST"])
def graphql_server():
