def setUp(self):
super().setUp()
mutation = MutationType()
mutation.set_field('refreshToken', resolve_refresh)
mutation.set_field('verifyToken', resolve_verify)
mutation.set_field('tokenAuth', resolve_token_auth)
mutation.set_field('revokeToken', resolve_revoke)
self.client.schema(self.type_defs, mutation, GenericScalar)
def bind_mutation_type_to_resolvers():
mutation = MutationType()
mutation.set_field("createPatient", PatientsMutations.create)
mutation.set_field("updatePatient", PatientsMutations.update)
mutation.set_field("deletePatient", PatientsMutations.soft_delete)
mutation.set_field("activatePatient", PatientsMutations.activate)
mutation.set_field("deactivatePatient", PatientsMutations.deactivate)
return mutation
def test_executing_mutation_takes_scalar_args_and_returns_scalar_sum():
type_defs = """
type Query {
_: String
}
type Mutation {
sum(a: Int, b: Int): Int
}
"""
mutation = MutationType()
mutation.set_field("sum", lambda *_, a, b: a + b)
schema = make_executable_schema(type_defs, mutation)
result = graphql_sync(schema, "mutation { sum(a: 1, b: 2) }")
assert result.errors is None
assert result.data == {"sum": 3}
def bind_mutation_type_to_resolvers():
mutation = MutationType()
mutation.set_field("createDiagnosis", DiagnosisMutations.create)
mutation.set_field("updateDiagnosis", DiagnosisMutations.update)
mutation.set_field("deleteDiagnosis", DiagnosisMutations.soft_delete)
mutation.set_field("unarchiveDiagnosis", DiagnosisMutations.activate)
mutation.set_field("archiveDiagnosis", DiagnosisMutations.deactivate)
return mutation
from ariadne.asgi import GraphQL
from ariadne import (load_schema_from_path,
make_executable_schema, MutationType, QueryType)
from ariadne.contrib.federation import (
FederatedObjectType, make_federated_schema)
from . import resolvers
# load schema file
type_defs = load_schema_from_path("riderequests/schema.graphql")
mutation = MutationType()
query = QueryType()
riderequest = FederatedObjectType("RideRequest")
mutation.set_field("requestRide", resolvers.resolve_request_ride)
query.set_field("allRideRequests", resolvers.resolve_all_ride_request)
query.set_field("request", resolvers.resolve_ride_request)
riderequest.set_field("passenger", resolvers.resolve_riderequest_passenger)
riderequest.set_field("ride", resolvers.resolve_riderequest_ride)
# bind schema(queries and mutation) to the respective resolvers
schema = make_federated_schema(type_defs, [riderequest, query, mutation])
application = GraphQL(schema, debug=True)
from ariadne import graphql_sync, make_executable_schema, load_schema_from_path, ObjectType, QueryType, MutationType
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
import resolvers as r
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
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():
def mutations():
mutation = MutationType()
mutation.set_field("upload", resolve_upload)
return mutation
from ariadne import MutationType
from djangocities.pages import mutation as page_mutations
from djangocities.sites import mutation as site_mutations
from djangocities.user import mutation as user_mutations
mutation = MutationType()
# User Mutations
mutation.set_field("login", user_mutations.resolve_login)
mutation.set_field("register", user_mutations.resolve_register)
# Page Mutations
mutation.set_field("createPage", page_mutations.resolve_create_page)
mutation.set_field("updatePage", page_mutations.resolve_update_page)
# Site Mutations
mutation.set_field("createSite", site_mutations.resolve_create_site)
mutation.set_field("updateSite", site_mutations.resolve_update_site)
from os.path import dirname, join
from ariadne import (MutationType, QueryType, make_executable_schema,
ObjectType, snake_case_fallback_resolvers,
load_schema_from_path)
from .resolvers import resolve_create_user, resolve_get_users
from ariadne_extensions import federation
# type_defs = load_schema_from_path("./account/schema.graphql")
query_type = QueryType()
mutation = MutationType()
manager = federation.FederatedManager(schema_sdl_file=join(
dirname(__file__), 'schema.graphql'),
query=query_type)
user_type = ObjectType("User")
query_type.set_field("users", resolve_get_users)
mutation.set_field("createUser", resolve_create_user)
manager.add_types(user_type, mutation, query_type)
manager.add_types(snake_case_fallback_resolvers)
schema = manager.get_schema()
# schema = make_executable_schema(type_defs, [query, mutation])
from ariadne import MutationType, QueryType, convert_kwargs_to_snake_case
from ariadne_token_auth.api import resolvers
from ariadne_token_auth.decorators import login_required
from django.contrib.auth import get_user_model, password_validation
from django.core.exceptions import ValidationError
from utils.general import get_user
from utils.handlers.errors import ErrorContainer
CUSTOM_USER = get_user_model()
auth_type_definitions = [resolvers.type_defs]
auth_mutation = MutationType()
auth_mutation.set_field("getAuthToken", resolvers.get_auth_token)
auth_mutation.set_field("deleteAuthToken", resolvers.delete_auth_token)
accounts_query = QueryType()
accounts_mutation = MutationType()
@accounts_query.field("userProfileDetails")
@convert_kwargs_to_snake_case
def user_profile_details(*_, username_slug, **kwargs):
""" returns basic user data about the user having the specified `username_slug` """
error = None
try:
username = CUSTOM_USER.objects.get(username_slug=username_slug).username
except CUSTOM_USER.DoesNotExist:
username = None
error = "The requested user does not exist"
return {"username": username, "error": error}
from ariadne import QueryType, make_executable_schema, load_schema_from_path, MutationType
from ariadne_jwt import resolve_verify, resolve_refresh, resolve_token_auth, jwt_schema, GenericScalar
from ariadne_jwt.decorators import login_required
from api.models.user import User
from api.models.audit import Audit
from api.marvel.client import MarvelClient
type_defs = [
load_schema_from_path("api/graphql/schema.graphql"),
load_schema_from_path("api/graphql/jwt.graphql")
]
query = QueryType()
mutation = MutationType()
mutation.set_field('verifyToken', resolve_verify)
mutation.set_field('refreshToken', resolve_refresh)
mutation.set_field('tokenAuth', resolve_token_auth)
@query.field('characters')
@login_required
def resolve_characters(_, info, name):
client = MarvelClient()
result = client.get_characters(name=name)
return result['characters']
@query.field('comics')
@login_required
def resolve_comics(_, info, name, limit=None):
from flask import Flask, request, jsonify
import resolvers as r
from ariadne import MutationType
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
student = ObjectType('Student')
queryClass = QueryType()
classs = ObjectType('Classs')
mutation = MutationType()
mutation.set_field('create_Student', r.resolver_createStudent)
mutationClass = MutationType()
mutationClass.set_field('create_Class', r.resolver_createClass)
mutationAddStudentToClass = MutationType()
mutationAddStudentToClass.set_field('add_Student_to_Class',
r.resolver_add_student_to_class)
query.set_field('student_with_id', r.student_with_id)
queryClass.set_field('class_with_id', r.class_with_id)
schema = make_executable_schema(type_defs, [
student, mutation, query, classs, mutationClass, queryClass,
mutationAddStudentToClass
])
schema_path = (
pathlib.Path(__file__).parent.absolute().joinpath("graphql", "schema.graphql")
)
type_defs = load_schema_from_path("saltapi/graphql/schema.graphql")
datetime_scalar = ScalarType("Datetime")
datetime_scalar.set_serializer(scalars.serialize_datetime)
datetime_scalar.set_value_parser(scalars.parse_datetime)
proposal_code_scalar = ScalarType("ProposalCode")
proposal_code_scalar.set_serializer(scalars.serialize_proposal_code)
proposal_code_scalar.set_value_parser(scalars.parse_proposal_code)
mutation = MutationType()
mutation.set_field("submitProposal", resolvers.resolve_submit_proposal)
subscription = SubscriptionType()
subscription.set_field("submissionProgress", resolvers.resolve_submission_progress)
subscription.set_source("submissionProgress", resolvers.submission_progress_generator)
schema = make_executable_schema(
type_defs,
datetime_scalar,
proposal_code_scalar,
mutation,
subscription,
directives={"permittedFor": PermittedForDirective},
)
from os.path import dirname, join
from ariadne import (MutationType, QueryType, make_executable_schema,
load_schema_from_path, ObjectType,
snake_case_fallback_resolvers)
from .resolvers import resolve_create_product, resolve_get_products
from ariadne_extensions import federation
# type_defs = load_schema_from_path("./product/schema.graphql")
query_type = QueryType()
mutation = MutationType()
manager = federation.FederatedManager(schema_sdl_file=join(
dirname(__file__), 'schema.graphql'),
query=query_type)
product_type = ObjectType("Product")
query_type.set_field("products", resolve_get_products)
mutation.set_field("createProduct", resolve_create_product)
manager.add_types(product_type, mutation, query_type)
manager.add_types(snake_case_fallback_resolvers)
schema = manager.get_schema()
# schema = make_executable_schema(type_defs, [query, mutation])
from ariadne import MutationType
from .auth import resolve_register_user, \
resolve_login
from .role import resolve_add_permission_to_role, \
resolve_create_new_role
from .user import resolve_update_email, \
resolve_add_blacklist_to_user, \
resolve_add_whitelist_to_user, \
resolve_delete_blacklist_from_user, \
resolve_delete_whitelist_from_user, \
resolve_add_role_to_user, \
resolve_update_users_active_status
from .permission import resolve_create_new_permission
mutation = MutationType()
mutation.set_field("registerUser", resolve_register_user)
mutation.set_field("login", resolve_login)
mutation.set_field("addPermissionToRole", resolve_add_permission_to_role)
mutation.set_field("addRoleToUser", resolve_add_role_to_user)
mutation.set_field("createNewRole", resolve_create_new_role)
mutation.set_field("createNewPermission", resolve_create_new_permission)
mutation.set_field("updateEmail", resolve_update_email)
mutation.set_field("addWhitelistToUser", resolve_add_whitelist_to_user)
mutation.set_field("addBlacklistToUser", resolve_add_blacklist_to_user)
mutation.set_field("deleteBlacklistFromUser",
resolve_delete_blacklist_from_user)
mutation.set_field("deleteWhitelistFromUser",
resolve_delete_whitelist_from_user)
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(
resolvers['Scalar'][scalar]['literal_parser'])
scalarType.set_value_parser(
resolvers['Scalar'][scalar]['value_parser'])
all_resolvers.append(scalarType)
# Create executable GraphQL schema
schema = make_executable_schema(type_defs, all_resolvers)
from ariadne import load_schema_from_path, ObjectType, QueryType, MutationType
from features.Users.user import verify_user, send_verification, get_me
userQueries = QueryType()
userMutations = MutationType()
userTypes = load_schema_from_path("./features/Users/user.gql")
userObjectType = ObjectType('TAUser')
userQueries.set_field('getMe', get_me)
userMutations.set_field('sendVerification', send_verification)
userMutations.set_field('verifyUser', verify_user)
from ariadne import load_schema_from_path, ObjectType, QueryType, MutationType
from features.Hangs.hang import resolve_hang, create_hang, update_hang
hangQueries = QueryType()
hangMutations = MutationType()
hangTypes = load_schema_from_path("./features/Hangs/hang.gql")
hangObjectType = ObjectType('HTHang')
hangQueries.set_field('getHang', resolve_hang)
hangMutations.set_field('createHang', create_hang)
hangMutations.set_field('updateHang', update_hang)
from ariadne import QueryType, MutationType, load_schema_from_path, make_executable_schema, ObjectType
from apps.accounts import resolvers as acc_res
#Test Query Field
def resolve_test(_, info, name=None):
return "Hello I am working!" if name == None else f"Hello {name}, I am working!"
#Base Query Object
query = QueryType() #ObjectType("Query")
query.set_field("test", resolve_test)
query.set_field("patient", acc_res.resolve_patient)
#Base Mutation Object
mutation = MutationType() #ObjectType("Mutation")
mutation.set_field("login", acc_res.resolve_login)
# Type Defs from Schems.graphql Files
type_defs = load_schema_from_path('apps/api/schema.graphql')
accounts_def = load_schema_from_path('apps/accounts/schema.graphql')
#Schema Object
schema = make_executable_schema(
[type_defs, accounts_def],
[query, mutation, acc_res.patient, acc_res.patient_data, acc_res.address])
def resolve_default(handler: Callable, response: Dict):
@convert_kwargs_to_snake_case
async def resolve(*_, command):
try:
handler(**command, uow=uow)
except Exception as error:
return resolve_error(error, ERROR_RESOLVER)
return response
return resolve
mutation.set_field(
"createUser",
resolve_default(
handlers.create_user,
dict(status="USER_CREATED", message="User successfully created"),
),
)
mutation.set_field(
"changePassword",
resolve_default(
handlers.change_password,
dict(status="PWD_CHANGED", message="Password changed successfully"),
),
)
mutation.set_field(
"createRole",
resolve_default(
handlers.create_role,
dict(status="ROLE_CREATED", message="Role successfully created"),
def get_schema(tmdb, database):
# Setup queries
query = QueryType()
register_query_resolvers(query, tmdb)
# Setup mutations
mutation = MutationType()
resolve_favorite, resolve_rating, resolve_number_of_watched_episodes, resolve_watch_status, resolve_country, resolve_language = register_mutation_resolvers(
mutation, tmdb, database)
# Register aliases for mutations
favorite = MutationType()
favorite.set_field("favorite", resolve_favorite)
rating = MutationType()
rating.set_field("rating", resolve_rating)
number_of_watched_episodes = MutationType()
# TODO: Alias
number_of_watched_episodes.set_field("numberOfWatchedEpisodes",
resolve_number_of_watched_episodes)
watch_status = MutationType()
# TODO: Alias
watch_status.set_field("watchStatus", resolve_watch_status)
country = MutationType()
country.set_field("country", resolve_country)
language = MutationType()
language.set_field("language", resolve_language)
# Register aliases for objects
movie = ObjectType("Movie")
movie.set_alias("ratingAverage", "rating_average")
movie.set_alias("ratingCount", "rating_count")
movie.set_alias("releaseInitial", "release_date")
movie.set_alias("backdropPath", "backdrop_path")
movie.set_alias("posterPath", "poster_path")
movie.set_alias("tmdbUrl", "tmdb_url")
movie.set_alias("watchStatus", "watch_status")
movie.set_alias("ratingUser", "rating_user")
tv = ObjectType("TV")
tv.set_alias("ratingAverage", "rating_average")
tv.set_alias("ratingCount", "rating_count")
tv.set_alias("releaseInitial", "first_air_date")
tv.set_alias("releaseFinal", "last_air_date")
tv.set_alias("backdropPath", "backdrop_path")
tv.set_alias("posterPath", "poster_path")
tv.set_alias("numberOfEpisodes", "number_of_episodes")
tv.set_alias("numberOfSeasons", "number_of_seasons")
tv.set_alias("tmdbUrl", "tmdb_url")
tv.set_alias("watchStatus", "watch_status")
tv.set_alias("ratingUser", "rating_user")
tv.set_alias("directors", "creators")
season = ObjectType("Season")
season.set_alias("tvCode", "tv_code")
season.set_alias("seasonNumber", "season_number")
season.set_alias("posterPath", "poster_path")
season.set_alias("numberOfEpisodes", "number_of_episodes")
season.set_alias("airDate", "air_date")
season.set_alias("numberOfWatchedEpisodes", "number_of_watched_episodes")
episode = ObjectType("Episode")
episode.set_alias("episodeNumber", "episode_number")
episode.set_alias("seasonNumber", "season_number")
episode.set_alias("airDate", "air_date")
episode.set_alias("ratingAverage", "rating_average")
episode.set_alias("stillPath", "still_path")
media_page = ObjectType("MediaPage")
media_page.set_alias("totalPages", "total_pages")
director = ObjectType("Director")
director.set_alias("imagePath", "image_path")
cast = ObjectType("Cast")
cast.set_alias("imagePath", "image_path")
searchResult = UnionType("Media")
# Read the GraphQL schema
type_defs = load_schema_from_path(
os.path.join(os.path.dirname(__file__), "api.graphql"))
# Connect the schema to the resolvers
return make_executable_schema(type_defs, query, mutation, rating,
watch_status, movie, tv, season, episode,
media_page, director, cast,
number_of_watched_episodes, favorite)
from flask import Flask, escape, request
from ariadne import QueryType, ObjectType, graphql_sync, make_executable_schema, MutationType, load_schema_from_path
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
from ariadne import gql
import resolvers as r
type_defs = load_schema_from_path('schema.py')
query = QueryType()
query.set_field('students', r.get_student)
query.set_field('classes',r.get_class)
mutation = MutationType()
mutation.set_field('create_student', r.create_student)
mutation.set_field('create_class', r.create_class)
mutation.set_field('update_class', r.update_class)
# @query.field("hello")
# def resolve_hello(_, info):
# request = info.context
# user_agent = request.headers.get("User-Agent", "Guest")
# return "Hello, %s!" % user_agent
schema = make_executable_schema(type_defs, query,mutation)
app = Flask(__name__)
@app.route("/graphql", methods=["GET"])
def graphql_playgroud():
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 os.path import dirname, join
from ariadne import (MutationType, QueryType,
make_executable_schema, ObjectType,
snake_case_fallback_resolvers, load_schema_from_path)
from .resolvers import resolve_create_review, resolve_get_reviews
from ariadne_extensions import federation
# type_defs = load_schema_from_path("./review/schema.graphql")
query_type = QueryType()
mutation = MutationType()
manager = federation.FederatedManager(
schema_sdl_file=join(dirname(__file__), 'schema.graphql'),
query=query_type)
user_type = federation.FederatedObjectType('User')
product_type = federation.FederatedObjectType('Product')
review_type = ObjectType('Review')
query_type.set_field("reviews", resolve_get_reviews)
mutation.set_field("createReview", resolve_create_review)
manager.add_types(user_type, product_type, review_type, mutation, query_type)
manager.add_types(snake_case_fallback_resolvers)
schema = manager.get_schema()
# schema = make_executable_schema(type_defs, [query, mutation])
def start(self):
query = QueryType()
query.set_field('echo', self._echo_resolver())
mutation = MutationType()
mutation.set_field('createTable', self._create_table_resolver())
mutation.set_field('addPlayer', self._add_player_resolver())
mutation.set_field('takeAction', self._take_action_resolver())
mutation.set_field('startGame', self._start_game_resolver())
mutation.set_field('stopGame', self._stop_game_resolver())
mutation.set_field('reset', self._reset_resolver())
subscription = SubscriptionType()
subscription.set_field('subscribe', self._subscribe_resolver())
subscription.set_source('subscribe', self._subscribe_generator())
resolvers = [query, mutation, subscription]
executable_schema = make_executable_schema(self._schema_str, resolvers)
self._app = GraphQL(executable_schema, debug=True)
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)
# pylint: disable=import-error
from backend.api.resolvers import alert, cache, event, me, user, resource
from ariadne import MutationType
MUTATION = MutationType()
MUTATION.set_field('setAlert', alert.resolve_set_alert)
MUTATION.set_field('invalidateCache', cache.resolve_invalidate_cache)
MUTATION.set_field('updateEvent', event.resolve_update_event)
MUTATION.set_field('createEvent', event.resolve_create_event)
MUTATION.set_field('solveEvent', event.resolve_solve_event)
MUTATION.set_field('addEventComment', event.resolve_add_event_comment)
MUTATION.set_field('updateEventEvidence', event.resolve_update_event_evidence)
MUTATION.set_field('downloadEventFile', event.resolve_download_event_file)
MUTATION.set_field('removeEventEvidence', event.resolve_remove_event_evidence)
MUTATION.set_field('signIn', me.resolve_sign_in)
MUTATION.set_field('updateAccessToken', me.resolve_update_access_token)
MUTATION.set_field('invalidateAccessToken', me.resolve_invalidate_access_token)
MUTATION.set_field('acceptLegal', me.resolve_accept_legal)
MUTATION.set_field('addUser', user.resolve_add_user)
MUTATION.set_field('grantUserAccess', user.resolve_grant_user_access)
MUTATION.set_field('removeUserAccess', user.resolve_remove_user_access)
MUTATION.set_field('editUser', user.resolve_edit_user)
MUTATION.set_field('addRepositories', resource.resolve_add_repositories)
MUTATION.set_field('addEnvironments', resource.resolve_add_environments)
enroll(sid:Int!, cid:Int!):String!
}
""")
student_id = 1238125
student_list = {}
def resolve_students(_, info, name):
global student_id
global student_list
student_list[str(student_id)] = name
student_id =+ 1
return name
mutation = MutationType()
mutation.set_field("students", resolve_students)
query = QueryType()
def resolve_student(_, info, sid):
global student_list
return{"id": sid, "name": student_list.get(str(sid))}
query.set_field("students", resolve_student)
class class_info:
def __init__(self, course_name):
self.course_name = course_name
self.student_list = []
class_id = 1122334
class_list = {}