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 __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 graphql_server():
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
continent = ObjectType('Continent')
country = ObjectType('Country')
query.set_field('continents', resolver.continents_resolver)
query.set_field('countries', resolver.countries_resolver)
query.set_field('country_by_name', resolver.country_by_name_resolver)
query.set_field('continent_by_name_resolver',
resolver.continent_by_name_resolver)
schema = make_executable_schema(type_defs, [continent, country, query])
data = request.get_json()
success, result = graphql_sync(schema,
data,
context_value=None,
debug=app.debug)
status_code = 200 if success else 400
return jsonify(result), status_code
def test_directive_can_be_defined_without_being_used():
type_defs = """
directive @customdirective on OBJECT | INTERFACE
union UnionTest = Type1 | Type2
type Query {
hello: String
}
type Type1 {
foo: String
}
type Type2 {
bar: String
}
"""
class CustomDirective(SchemaDirectiveVisitor):
def visit_object(self, object_):
pass
def visit_interface(self, interface):
pass
type_1 = ObjectType("Type1")
type_2 = ObjectType("Type2")
def resolve_union_test_type(*_):
return "AccessError" # noop type resolver for test
query = QueryType()
union_test = UnionType("UnionTest", resolve_union_test_type)
make_executable_schema(
type_defs,
[query, union_test, type_1, type_2],
directives={"customdirective": CustomDirective},
)
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_different_types_resolver_maps_are_merged_into_executable_schema():
type_defs = """
type Query {
user: User
}
type User {
username: String
}
"""
query = QueryType()
query.set_field("user", lambda *_: Mock(first_name="Joe"))
user = ObjectType("User")
user.set_alias("username", "first_name")
schema = make_executable_schema(type_defs, [query, user])
result = graphql_sync(schema, "{ user { username } }")
assert result.errors is None
assert result.data == {"user": {"username": "******"}}
def test_multiple_bindables_can_be_passed_as_separate_args():
type_defs = """
type Query {
user: User
}
type User {
username: String
}
"""
query = QueryType()
query.set_field("user", lambda *_: Mock(first_name="Joe"))
user = ObjectType("User")
user.set_alias("username", "first_name")
schema = make_executable_schema(type_defs, query, user)
result = graphql_sync(schema, "{ user { username } }")
assert result.errors is None
assert result.data == {"user": {"username": "******"}}
def test_set_alias_method_creates_resolver_for_specified_attribute(schema):
query = ObjectType("Query")
query.set_alias("hello", "test")
query.bind_to_schema(schema)
result = graphql_sync(schema, "{ hello }", root_value={"test": "World"})
assert result.errors is None
assert result.data == {"hello": "World"}
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 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"}}
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_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 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 init_graph(query):
substance = ObjectType('Substance')
@query.field('substances')
@inject
def resolve_substances(obj, info, pantry: Pantry, *_, nature='Unknown'):
substances = pantry.find_substances_by_nature(nature)
return substances
@substance.field('nature')
def resolve_nature(obj, *_):
return obj.nature
@substance.field('state')
def resolve_state(obj, *_):
return obj.state
return [substance]
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
from ariadne import ObjectType
advertisement = ObjectType("Advertisement")
# vim: set expandtab ts=4 sw=4 filetype=python fileencoding=utf8:
import os
import textwrap
import psycopg2
from ariadne import load_schema_from_path
from ariadne import ObjectType
from ariadne.wsgi import GraphQL
from ariadne import make_executable_schema
query = ObjectType("Query")
@query.field("demo")
def resolve_demo_query(_, info):
return dict(
current_timestamp="placeholder current_timestamp...",
bogus_field_a="AAA",
bogus_field_b="BBB")
@query.field("current_timestamp")
def resolve_current_timestamp(_, info):
pgconn = info.context["pgconn"]
cursor = pgconn.cursor()
cursor.execute("select current_timestamp")
return cursor.fetchone()[0]
@query.field("upcoming_shows")
def resolve_upcoming_shows(_, info):
}
type Person {
firstName: String
lastName: String
age: Int
fullName: String
}
""")
# Map resolver functions to Query fields using QueryType
query = QueryType()
# Resolvers are simple python functions
@query.field("people")
def resolve_people(*_):
return [
Person(first_name="John", last_name="Doe", age=21),
Person(first_name="Bob", last_name="Boberson", age=24),
]
# Map resolver functions to custom type fields using ObjectType
person = ObjectType("Person")
# Create executable GraphQL schema
schema = make_executable_schema(type_defs, query, person, snake_case_fallback_resolvers)
# Create an ASGI app using the schema, running in debug mode
app = GraphQL(schema, debug=True)
from ariadne import ObjectType
from graphql import GraphQLResolveInfo
from movies.core.dataloaders.company_loader import CompanyLoader
from movies.core.entities.company import Company
companies = ObjectType("Companies")
@companies.field("company")
async def resolve_company(_, info: GraphQLResolveInfo, id: int) -> Company:
company_loader = CompanyLoader.for_context(info.context)
company = await company_loader.load(id)
return company
from ariadne import graphql_sync, make_executable_schema, load_schema_from_path, ObjectType, QueryType
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
import resolver as r
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
def _register_object_type(name):
object_type = ObjectType(name)
object_types.append(object_type)
return object_type
from ariadne import ObjectType, graphql_sync, make_executable_schema, load_schema_from_path
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
#load_schema
type_defs = load_schema_from_path('./schema.graphql')
#sample data
myStudent = [{'id': 1, 'name': "fay"}]
myClass = [{'id': 1, 'name': "CMPE273", 'students': []}]
#define query filed
query = ObjectType("Query")
@query.field("hello")
def hello(_, info):
request = info.context
user_agent = request.headers.get("User-Agent", "Guest")
return "Hello, %s!" % user_agent
@query.field("students")
def students(obj, info):
return myStudent
@query.field("student")
def student(obj, info, id):
for s in myStudent:
import datetime
from ariadne import ObjectType
from bson.objectid import ObjectId
from api.mongo import db
post = ObjectType('Post')
query = ObjectType('Query')
mutation = ObjectType('Mutation')
@query.field('posts')
def resolve_post(obj, info, _id=None):
if _id:
return [db.posts.find_one({'_id': ObjectId(_id)})]
else:
return db.posts.find()
@post.field('author')
def resolve_author(obj, info):
return db.users.find_one({'_id': ObjectId(obj.get('author'))})
@mutation.field('createPost')
def create_post(obj, info, input):
try:
post_id = db.posts.insert_one({
'author': ObjectId(input['author']),
'created': datetime.datetime.utcnow(),
'title': input['title'],
'body': input['body'],
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()
from typing import Literal, Optional
from ariadne import ObjectType
from core.graphql import GraphQLResolveInfo
from core.models import Mission
PatchSize = Literal["SMALL", "LARGE"]
mission = ObjectType("Mission")
@mission.field("mission_patch")
def resolve_mission_mission_patch(obj: Mission,
info: GraphQLResolveInfo,
size: PatchSize = "LARGE") -> Optional[str]:
mission_patch: Optional[str] = obj.links["mission_patch_small" if size ==
"SMALL" else "mission_patch"]
return mission_patch
from ariadne import QueryType, graphql_sync, make_executable_schema, MutationType, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify, Response
# from schema import schema
students = {}
classes = {}
studentID = 200
classID = 300
query = QueryType()
mut = MutationType()
student = ObjectType("Student")
classs = ObjectType("Class")
type_defs = """
type Query {
hello: String!
students(id:Int!): Student!
classes(id: Int!): Class!
}
type Mutation {
createStudent(name: String!): Student!
createClass(name: String!): Class!
addStudent(studentID: Int!, classID: Int!): Class!
}
type Student {
id: Int!
name: String!
}
type Class {
id: Int!
from ariadne import QueryType, ObjectType, EnumType
from random import randint
from models import Skill, Person
from data import session
from datetime import datetime
query = QueryType()
# Type definitions
skill = ObjectType("Skill")
person = ObjectType("Person")
eye_color = EnumType(
"EyeColor",
{
'BLUE': 'blue',
'GREEN': 'green',
'BROWN': 'brown',
'BLACK': 'black',
},
)
# Top level resolvers
@query.field("randomSkill")
def resolve_random_skill(_, info):
records = session.query(Skill).count()
random_id = str(randint(1, records))
return session.query(Skill).get(random_id)
@query.field("randomPerson")
import copy
from datetime import datetime
from ariadne import UnionType, ScalarType, InterfaceType, ObjectType
from web.data import ingredients, suppliers, products
product_interface = InterfaceType('ProductInterface')
product_type = UnionType('Product')
ingredient_type = ObjectType('Ingredient')
supplier_type = ObjectType('Supplier')
datetime_scalar = ScalarType('Datetime')
@datetime_scalar.serializer
def serialize_datetime_scalar(date):
return date.isoformat()
@datetime_scalar.value_parser
def parse_datetime_scalar(date):
return datetime.fromisoformat(date)
@product_type.type_resolver
def resolve_product_type(obj, *_):
if 'hasFilling' in obj:
return 'Cake'
return 'Beverage'
return [Task.objects.get(id=id)]
q = Task.objects
if title:
q = q.filter(title__contains=title)
if forUser:
q = q.filter(assigned_to=forUser)
if board:
q = q.filter(board_id=board)
if lane:
q = q.filter(lane_id=lane)
return q.order_by('order')
board = ObjectType('Board')
@board.field('lanes')
def resolve_board_lanes(parent, *_):
return TaskLane.objects.filter(board_id=parent.id).order_by('order')
taskLane = ObjectType('TaskLane')
taskLane.set_alias('board', 'board_id')
@taskLane.field('tasks')
def resolve_tasklane_board(parent, *_, searchQuery=None):
q = Task.objects
