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 = {}