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_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": "******"}}
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 if searchQuery: if len(searchQuery) < 5: raise Exception('search query empty or too short') q = q.filter( Q(lane_id=parent.id), Q(title__contains=searchQuery) | Q(description__contains=searchQuery)) else:
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)
def test_attempt_bind_object_type_field_to_undefined_field_raises_error( schema): query = ObjectType("Query") query.set_alias("user", "_") with pytest.raises(ValueError): query.bind_to_schema(schema)
queryset = Object.objects.filter_for_user( request.user).filter(bucket__name=kwargs["bucketS3Name"]) if "parentS3Key" in kwargs: queryset = queryset.filter( parent_key=f"{kwargs['bucketS3Name']}/{kwargs['parentS3Key']}", ) else: queryset = queryset.filter(parent_key=f"{kwargs['bucketS3Name']}/", ) return result_page(queryset=queryset, page=kwargs["page"]) bucket = ObjectType("S3Bucket") bucket.set_field("tags", resolve_tags) bucket.set_alias("s3Name", "name") @bucket.field("icon") def resolve_icon(obj: Bucket, info): request: HttpRequest = info.context["request"] return request.build_absolute_uri(static("connector_s3/img/symbol.svg")) @bucket.field("contentType") def resolve_content_type(obj: Bucket, info): return trans("S3 Bucket") @bucket.field("objects") @convert_kwargs_to_snake_case
endsAt: String! } """ query = QueryType() mutation = MutationType() assignmentType = ObjectType('Assignment') @query.field('assignemnts') async def resolve_hello(_, _info): return await assignment.all() assignmentType.set_alias('id', '_id') assignmentType.set_alias('createdAt', 'created_at') assignmentType.set_alias('startsAt', 'starts_at') assignmentType.set_alias('endsAt', 'ends_at') @mutation.field("createAssignment") @convert_kwargs_to_snake_case async def resolve_create_assignment(_, _info, input): return await assignment.create(input) schema = make_executable_schema(type_defs, [query, mutation], assignmentType) app = FastAPI()
from ariadne import (ObjectType, convert_kwargs_to_snake_case) from api.static_api import StaticApi from api.live_api import LiveApi static_api = StaticApi() live_api = LiveApi() trip = ObjectType("Trip") trip.set_alias('from', 'trip_from') trip.set_alias('to', 'trip_to') @trip.field("scheduledBuses") @convert_kwargs_to_snake_case def resolve_scheduled_buses(obj, _, *, from_date=None, time_frame=None): try: return { 'results': static_api.get_coming_buses(obj, from_date, time_frame) } except ValueError as err: return {'error': str(err)} @trip.field("liveBuses") @convert_kwargs_to_snake_case def resolve_live_buses(obj, _, *, time_frame=None): try: return {'results': live_api.get_coming_buses(obj, time_frame)} except ValueError as err:
from ariadne import ObjectType route = ObjectType("Route") @route.field("code") def resolve_route_code(obj, _): return obj.route.name @route.field("name") def resolve_route_name(obj, _): return obj.route.description route.set_alias('from', 'route_from') route.set_alias('to', 'route_to')
return result_page(queryset, page, per_page) @catalog_query.field("search") @convert_kwargs_to_snake_case def resolve_search(_, info, page, query, per_page=None): request: HttpRequest = info.context["request"] queryset = Index.objects.filter_for_user(request.user).search(query)[:100] return result_page(queryset, page, per_page) # Catalog Index catalog_index = ObjectType("CatalogIndex") catalog_index.set_alias("type", "content_type_name") @catalog_index.field("icon") def resolve_icon(obj: Index, info): request: HttpRequest = info.context["request"] return request.build_absolute_uri( static(f"{obj.app_label}/img/symbol.svg")) @catalog_index.field("detailUrl") def resolve_detail_url(obj: Index, *_): # TODO: this is just a temporary workaround, we need to find a good way to handle index routing if ContentType.objects.get_for_model(Bucket) == obj.content_type: return f"s3/{obj.object.s3_name}"
from ariadne import QueryType, ObjectType from .user import resolve_get_all_users, \ resolve_find_user_by_email, \ resolve_me, \ resolve_get_users_permissions from .role import resolve_get_all_roles from .auth import resolve_logout from .permission import resolve_get_all_permissions query = QueryType() query.set_field("getAllUsers", resolve_get_all_users) query.set_field("findUserByEmail", resolve_find_user_by_email) query.set_field("me", resolve_me) query.set_field("getAllRoles", resolve_get_all_roles) query.set_field("getAllPermissions", resolve_get_all_permissions) query.set_field("getUsersPermissions", resolve_get_users_permissions) query.set_field("logout", resolve_logout) user = ObjectType("User") user.set_alias("accessToken", "access_token") role = ObjectType("Role") role.set_alias("permissionId", "permission_id") role.set_alias("roleId", "role_id")
from ariadne import ObjectType rocket = ObjectType("Rocket") rocket.set_alias("type", "rocket_type")