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 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("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
def test_executing_mutation_using_input_type(): type_defs = """ type Query { _: String } input StaffInput { name: String } type Staff { name: String } type Mutation { addStaff(data: StaffInput): Staff } """ mutation = MutationType() @mutation.field("addStaff") def resolve_add_staff(*_, data): # pylint: disable=unused-variable assert data == {"name": "Bob"} return data schema = make_executable_schema(type_defs, mutation) result = graphql_sync( schema, 'mutation { addStaff(data: { name: "Bob" }) { name } }') assert result.errors is None assert result.data == {"addStaff": {"name": "Bob"}}
def test_executing_mutation_takes_scalar_arg_and_returns_type(): type_defs = """ type Query { _: String } type Staff { name: String } type Mutation { addStaff(name: String): Staff } """ mutation = MutationType() @mutation.field("addStaff") def resolve_add_staff(*_, name): # pylint: disable=unused-variable assert name == "Bob" return {"name": name} schema = make_executable_schema(type_defs, mutation) result = graphql_sync(schema, 'mutation { addStaff(name: "Bob") { name } }') assert result.errors is None assert result.data == {"addStaff": {"name": "Bob"}}
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}
async def test_date(): schema = gql(""" scalar Date scalar DateTime scalar JSON type Query { event: Event! } type Mutation { createEvent(date: Date!): Boolean! } type Event { date: Date! } """) query_event = """ query { event { date } } """ mutation_event = """ mutation createEvent($date: Date!) { createEvent(date: $date) } """ query_type = QueryType() mutation_type = MutationType() @mutation_type.field("createEvent") async def createEvent(obj, parent, **kwargs): return True @query_type.field("event") async def event(obj, parent, **kwargs): return {"date": datetime.now()} schema = make_executable_schema(schema, query_type, base_scalars_resolvers, snake_case_fallback_resolvers) await graphql(schema=schema, data={"query": query_event}) await graphql( schema=schema, data={ "query": mutation_event, "variables": { "date": "1789-07-07T12:00:00+02:00" }, # ISO 8601 datetime string }, )
from ariadne.constants import PLAYGROUND_HTML 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
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 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)
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 ariadne import ( QueryType, MutationType ) from crud.permission import ( add_new_permission, update_permissions_by_id, get_all_permissions_count_in_db, get_all_permissions_in_db, get_permission_by_id ) permission_query = QueryType() permission_mutation = MutationType() @permission_mutation.field("create_permission") async def resolve_create_permission( _, info, current_user=None, **kwargs ): details = kwargs["details"] added_permission = await add_new_permission(details) return { "permission": dict(added_permission) } @permission_mutation.field("update_permission")
} type User { id : ID! status: Int! username : String! password : String! email : String! phone : String! } """ user_query = QueryType() user_mutation = MutationType() # QUERY @user_query.field('currentUser') async def get_current_user_by_id(ojb, info): request = info.context['request'] if request.user.is_authenticated: try: user = await User.get(pk=request.user.user_id) except DoesNotExist: return { 'error': 'user không tồn tại', } return {'user': user}
import os import os.path import pathlib import asyncio from graphql import parse from ariadne import MutationType, SubscriptionType, load_schema_from_path from nomine.models import Namer from nomine.models.folder_entry import FolderEntry, FILE_TYPE, DIRECTORY_TYPE mutation = MutationType() subscription = SubscriptionType() bindables = [mutation, subscription] schema_file = load_schema_from_path( pathlib.Path(__file__).parent.joinpath("schema.graphql").absolute()) schema = parse(schema_file) queue = asyncio.Queue() def get_or_create_entry(session, folder_id, dir_entry): if dir_entry.is_file(): entry_type = FILE_TYPE elif dir_entry.is_dir(): entry_type = DIRECTORY_TYPE else: return existing = (session.query(FolderEntry).filter( FolderEntry.path == dir_entry.path).first()) if existing:
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, 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 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 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])
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 import (MutationType, QueryType) from uuid import uuid4 from crud.author import (create_author, get_all_authors, get_all_authors_count, find_author_by_id, find_author_by_email) from crud.user import (create_new_user) author_mutation = MutationType() author_query = QueryType() @author_mutation.field("create_author") async def resolve_create_author(_, info, current_user=None, **kwargs): details = kwargs["details"] resp = {"author": None, "error": "Author was not created"} author_id = await create_new_user( obj_in={ "user_name": details["email"], "group": "author", "password": details["password"] }) author = await create_author(values={ "id": author_id, "email": details["email"], "phone": details["phone"] }) resp.update(author=dict(author), error="" if author else resp["error"]) return resp @author_query.field("authors") async def resolve_authors(_, info, current_user=None, **kwargs):
# GraphQL 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 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 secrets import token_bytes, token_hex from time import time from ariadne import MutationType from context import ARGON from classes.user import User MUTATION = MutationType() @MUTATION.field("createUser") async def r_create_user(*_, role: str = "USER") -> User: """create a new user and save to db""" # create api object password = token_hex(10) # save to db user = await User.create( key=token_bytes(32), username=token_hex(10), password_hash=ARGON.hash(password), role=role, created=time(), ) # set password field on user to pass them their password 1 time user.password = password # return api object to resolver return user
def mutations(): mutation = MutationType() mutation.set_field("upload", resolve_upload) return mutation
"""Contains mutation resolvers.""" from ariadne import MutationType from nautilus import utils from nautilus.validators import validate_profileinput, validate_discord mutation_type = MutationType() @mutation_type.field("createProfile") def resolve_create_profile(*_, discord, profile): """mutation createProfile""" utils.logger.debug(f"createProfile | discord={discord}") errors = [] if error := utils.errors.check_for([utils.errors.exists], discord): errors.append(error) profile, validation_errors = validate_profileinput(profile) if not validate_discord(discord): validation_errors.append({"msg": "Discord ID must be a valid snowflake.", "type": "value_error"}) if validation_errors: errors += validation_errors if not errors: return utils.dbh.insert_profile(discord, profile) return {"status": False, "errors": errors} @mutation_type.field("updateProfile") def resolve_update_profile(*_, discord, profile): """mutation updateProfile""" utils.logger.debug(f"updateProfile | discord={discord}") errors = []
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)
# 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)
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():
from ariadne import MutationType resolver_mutation = MutationType() from ..models.panel import Panel, PanelSize @resolver_mutation.field('addPanel') def resolve_addpanel(*_, embed_url: str, size: PanelSize = PanelSize.MEDIUM) -> bool: try: # size.value since Django only accepts the values of the enums p = Panel(embed_url=embed_url, size=size.value) p.save() except Exception as e: print('Error in addPanel mutation: ' + str(e)) return False return True @resolver_mutation.field('removePanel') def resolve_removepanel(*_, id: int) -> bool: qset = Panel.objects.filter(id=id) assert (len(qset) <= 1 ) # make sure that the id acquired is unique to one panel if len(qset) == 0:
from django.db import transaction from django.http import HttpRequest from django.utils.http import urlsafe_base64_decode from django_countries import countries from django_countries.fields import Country from hexa.core.graphql import result_page from hexa.core.templatetags.colors import hash_color from hexa.user_management.countries import get_who_info from hexa.user_management.models import Membership, Organization, Team, User identity_type_defs = load_schema_from_path( f"{pathlib.Path(__file__).parent.resolve()}/graphql/schema.graphql") identity_query = QueryType() identity_mutations = MutationType() @identity_query.field("me") def resolve_me(_, info): request = info.context["request"] principal = request.user return { "user": principal if principal.is_authenticated else None, "authorized_actions": filter( bool, [ "CREATE_TEAM"