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")
