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