def test_scalar_serializer_can_be_set_on_initialization(): schema = build_schema(type_defs) scalar = ScalarType("DateInput", serializer=serialize_date) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateInput") assert schema_scalar.serialize is serialize_date
def test_scalar_literal_parser_can_be_set_on_initialization(): schema = build_schema(type_defs) scalar = ScalarType("DateInput", literal_parser=parse_date_literal) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateInput") assert schema_scalar.parse_literal is parse_date_literal
def test_scalar_value_parser_can_be_set_on_initialization(): schema = build_schema(type_defs) scalar = ScalarType("DateReadOnly", value_parser=parse_date_str) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateReadOnly") assert schema_scalar.parse_value is parse_date_str
def test_default_literal_parser_is_used_to_extract_value_str_from_ast_node(): dateinput = ScalarType("DateInput") dateinput.set_value_parser(parse_date_value) schema = make_executable_schema(type_defs, query, dateinput) result = graphql_sync( schema, """{ testInput(value: "%s") }""" % TEST_DATE_SERIALIZED) assert result.errors is None assert result.data == {"testInput": True}
def test_setting_scalar_value_parser_doesnt_override_already_set_literal_parser( ): schema = build_schema(type_defs) scalar = ScalarType("DateInput") scalar.set_literal_parser(parse_date_literal) scalar.set_value_parser(parse_date_str) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateInput") assert schema_scalar.parse_value is parse_date_str assert schema_scalar.parse_literal is parse_date_literal
class SchemaCreator: data = DataStorage() query = QueryType() account = FederatedObjectType("Account") bundle = FederatedObjectType("Bundle") patient = FederatedObjectType("Patient") text = FederatedObjectType("Narrative") human_name = ScalarType("HumanName") def __init__(self): self.ds = DataStorage() def getSchema(self): manager = FederatedManager( schema_sdl_file='schema/fhir_schema_4_0_0.graphql', query=self.query, ) @self.human_name.serializer def serialize_datetime(value): return HumanName(value) @self.query.field("Patient") def resolve_patient(obj, info, **kwargs): return Patient(obj, info=self.data.getPatient(**kwargs)[0]) @self.query.field("Account") def resolve_account(*_, **kwargs): return Account(**kwargs) @self.query.field("ActivityDefinition") def resolve_account(*_, **kwargs): return Account(**kwargs) @self.query.field("AccountList") def resolve_account_list(obj, info): alist = AccountList(obj, info) return [alist,] @self.account.resolve_references def resolve_accounts(obj, info): return AccountList(name="test") @self.patient.resolve_reference def resolve_patient(obj, info): return Patient(obj, info) manager.add_types(self.account, self.bundle, self.patient, self.text) manager.add_types(bundle_enum_schema) manager.add_types(snake_case_fallback_resolvers, fallback_resolvers) return manager.get_schema()
def test_scalar_value_parser_can_be_set_with_setter(): schema = build_schema(type_defs) scalar = ScalarType("DateReadOnly") scalar.set_value_parser(parse_date_str) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateReadOnly") assert schema_scalar.parse_value is parse_date_str
def test_scalar_serializer_can_be_set_with_setter(): schema = build_schema(type_defs) scalar = ScalarType("DateInput") scalar.set_serializer(serialize_date) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateInput") assert schema_scalar.serialize is serialize_date
def test_scalar_literal_parser_can_be_set_with_setter(): schema = build_schema(type_defs) scalar = ScalarType("DateInput") scalar.set_literal_parser(parse_date_literal) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateInput") assert schema_scalar.parse_literal is parse_date_literal
def test_setting_scalar_value_parser_sets_default_literal_parsers_if_none_is_set( ): schema = build_schema(type_defs) scalar = ScalarType("DateInput") scalar.set_value_parser(parse_date_value) scalar.bind_to_schema(schema) schema_scalar = schema.type_map.get("DateInput") assert schema_scalar.parse_value is parse_date_value assert schema_scalar.parse_literal
from datetime import datetime from ariadne import ScalarType datetime_scalar = ScalarType("Datetime") @datetime_scalar.serializer def serialize_datetime(value): if isinstance(value, datetime): return value.timestamp() elif isinstance(value, str): return datetime.fromisoformat(value).timestamp() @datetime_scalar.value_parser def parse_datetime_value(value): assert value is not None, "There was a null value passed into a datetime creator" return datetime.utcfromtimestamp(value) @datetime_scalar.literal_parser def parse_datetime_literal(ast): value = float(ast.value) return parse_datetime_value(value)
from dateutil import parser from ariadne import ScalarType from graph.graphql import Resolver def serialize_datetime(value): return value.isoformat() def parse_datetime_value(value): if value: return parser.parse(value) datetime_scalar = ScalarType("Datetime", serializer=serialize_datetime, value_parser=parse_datetime_value) Resolver(datetime_scalar)
} type Query { allTodos: [Todo]! } type Mutation { login(username: String!, password: String!): Login refreshToken(token: String!): Login createTodo(title: String!): Todo! updateTodo(uuid: String!, completed: Boolean!): Todo! deleteTodo(uuid: String!): Todo! } """ + todo_type_defs) uuid_scalar = ScalarType("Uuid") @uuid_scalar.serializer def serialize_uuid(value): return str(value.hex) mutation = MutationType() @mutation.field("login") def resolve_login(_, info, username, password): user = None user = authenticate(username=username, password=password) if user:
# pylint: disable=import-error from graphql.language.ast import (StringValueNode, BooleanValueNode, IntValueNode, FloatValueNode, ListValueNode, ObjectValueNode) from ariadne import ScalarType GENERIC_SCALAR = ScalarType('GenericScalar') @GENERIC_SCALAR.serializer def serialize_genericscalar(value): return value @GENERIC_SCALAR.value_parser def parse_genericscalar_value(value): return value @GENERIC_SCALAR.literal_parser def parse_genericscalar_literal(ast): if isinstance(ast, (StringValueNode, BooleanValueNode)): return ast.value if isinstance(ast, IntValueNode): return int(ast.value) if isinstance(ast, FloatValueNode): return float(ast.value) if isinstance(ast, ListValueNode): return [parse_genericscalar_literal(value) for value in ast.values] if isinstance(ast, ObjectValueNode):
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) # --- ASGI app # Create an ASGI app using the schema, running in debug mode # Set context with authenticated graphql client. app = GraphQL(schema, debug=True, context_value={})
def resolve_test_serialize(*_): return TEST_DATE @query.field("testInput") def resolve_test_input(*_, value): assert value == TEST_DATE return True @query.field("testInputValueType") def resolve_test_input_type(*_, value): return value datereadonly = ScalarType("DateReadOnly") @datereadonly.serializer def serialize_date(date): return date.strftime("%Y-%m-%d") dateinput = ScalarType("DateInput") @dateinput.value_parser def parse_date_value(formatted_date): parsed_datetime = datetime.strptime(formatted_date, "%Y-%m-%d") return parsed_datetime.date()
from ariadne import (QueryType, ScalarType) from crud.user import (get_all_users, find_user_by_id, get_all_users_count, find_user_by_email) user_query = QueryType() UUID_scalar = ScalarType("UUID") datetime_scalar = ScalarType("Datetime") @datetime_scalar.serializer def serialize_datetime(value): return value.isoformat() @UUID_scalar.serializer def serialize_uuid(value): return str(value) @user_query.field("users") async def resolve_users(_, info, current_user=None, **kwargs): users = await get_all_users(**kwargs) total_count = await get_all_users_count() users = [dict(user) for user in users] return {"users": users, "total_count": total_count} @user_query.field("user") async def resolve_user(_, info, current_user=None, **kwargs): email = kwargs.get("email", None) user_id = kwargs.get("id", None)
def create_app(): app = Flask(__name__) mongo = MongoClient(os.environ["MONGO_URI"]) type_defs = load_schema_from_path('app/graphql/schema.graphql') query = ObjectType("Query") mutation = ObjectType("Mutation") user = ObjectType("User") registered = ObjectType("Registered") dateScalar = ScalarType("Datetime") bindables = [query, mutation, user, registered, dateScalar] @dateScalar.serializer def serialize_dateScalar(value): """Serialize custom DateScalar scalar for graphql-schema.""" return value.isoformat() @query.field("user") def resolve_user(_, info, _id): #TODO: maybe this can be a decorator? status = False error = {"message": "could not get users"} payload = {"status": status, "error": error} with mongo: try: user = map(ex.prepare, mongo.db.users.find({"_id": ObjectId(_id)})) payload["user"] = user payload["status"] = True payload["error"] = None return payload except Exception as e: print(e) payload["error"]["message"] = "could not get user" return payload @query.field("getUsers") def resolve_get_users(_, info): status = False error = {"message": "could not get users"} payload = {"status": status, "error": error} with mongo: try: users = [] if mongo.db.users.count_documents({}) >= 1: for user in mongo.db.users.find({}): ex.prepare(user) users.append(user) payload["error"] = None payload["status"] = True else: payload["error"]["message"] = "No users in database" payload["status"] = False payload["user"] = users except Exception as e: print(e) payload["error"]["message"] = "Could not get users" return payload #TODO: Implement lambda functions in method @mutation.field("registerLunch") def resolve_register_lunch(_, info, nickname, email, _id): """Adds timestamp for registration to the database""" new_timestamp = datetime.datetime.utcnow() if new_timestamp.isoweekday() < 6: new_timestamp = new_timestamp.strftime("%Y-%m-%d") registered = {"_id": ObjectId(), "timestamp": new_timestamp} user = { "_id": ObjectId(_id), "nickname": nickname, "email": email, "registered": registered } if ex.get_user(nickname, email, mongo): return ex.register_lunch(user, mongo, True) else: return ex.register_lunch(user, mongo) return { 'status': False, 'error': { 'message': 'lunch is only available on weekdays' } } @mutation.field("deleteUser") def resolve_deleteUser(_, info, _id): """Deletes specified entry Args: _id (str): document id of user to delete. """ return ex.delete_user(_id, mongo) @mutation.field("deleteTimestamp") def resolve_deleteTimestamp(_, info, user_id, timestamp_id): """Deletes specified timestamp for a user Args: user_id (str): document id of user. timestamp_id (str): id of date to delete. """ return ex.delete_timestamp(user_id, timestamp_id, mongo) @user.field("registered") def resolve_registered(payload, info): registered = [] for timestamp in payload["registered"]: registered.append(timestamp) return registered schema = make_executable_schema(type_defs, bindables) @app.errorhandler(AuthError) def handle_auth_error(exception): """Returns response from authorization error.""" response = jsonify(exception.error) response.status_code = exception.status_code return response @app.route("/graphql", methods=["GET"]) #@cross_origin(send_wildcard=True, headers=["Content-type", "Authorization"]) @cross_origin() #@requires_auth() #@requires_scope('developer') def graphql_playground(): return PLAYGROUND_HTML, 200 @app.route("/graphql", methods=["POST"]) #@cross_origin(send_wildcard=True, headers=["Content-type", "Authorization"]) @cross_origin() #@requires_auth() def graphql_server(): data = request.get_json() success, result = graphql_sync(schema, data, context_value=None, debug=app.debug) status_code = 200 if success else 400 return jsonify(result), status_code return app
from ariadne import ScalarType rank_value = ScalarType("RankValue") @rank_value.serializer def serialize_rank(rank): return str(rank) @rank_value.value_parser def parse_rank_value(rank): if "." in rank: return float(rank) return int(rank) bindables = [rank_value]
import json from ariadne import ScalarType json_scalar = ScalarType("JSON") datetime_scalar = ScalarType("DateTime") @datetime_scalar.serializer def serialize_datetime(value): # pendulum instance return value.isoformat() @json_scalar.serializer def serialize_json(value): if value is None: return None return json.dumps(value) @json_scalar.value_parser def parse_json(value): if value is None: return None return json.loads(value) scalar_types = [datetime_scalar, json_scalar]
from datetime import time from typing import Any from django.utils import formats from django.utils.translation import gettext_lazy as _ from ariadne import ScalarType from ariadne_django.scalars.utils.parsers import parse_value time_input_formats = formats.get_format_lazy("TIME_INPUT_FORMATS") time_scalar = ScalarType("Time") @time_scalar.serializer def serialize_time(value: time) -> str: return value.isoformat() @time_scalar.value_parser def parse_time_value(value: Any) -> time: parsed_value = parse_value(value, time_input_formats) if not parsed_value: raise ValueError(_("Enter a valid time.")) return parsed_value.time()
def test_attempt_bind_scalar_to_undefined_type_raises_error(): schema = build_schema(type_defs) scalar = ScalarType("Test") with pytest.raises(ValueError): scalar.bind_to_schema(schema)
from decimal import Decimal, InvalidOperation from django.utils.formats import number_format, sanitize_separators from ariadne import ScalarType decimal_scalar = ScalarType("Decimal") @decimal_scalar.serializer def serialize_decimal(value: Decimal) -> str: return number_format(value) @decimal_scalar.value_parser def parse_decimal_value(value: str) -> Decimal: if not isinstance(value, str): raise InvalidOperation("Decimal must be a string") return Decimal(sanitize_separators(value))
"""GraphQL resolvers.""" import asyncio from ariadne import QueryType, ObjectType, make_executable_schema, ScalarType, upload_scalar, MutationType, SubscriptionType from aocrecs.logic import (search, metaladder, report, search_options, events, matches, stats as stat, maps, civilizations, users, odds, playback, market) from aocrecs.schema import TYPE_DEFS from aocrecs.upload import add_rec # Unhelpful rules for resolver boilerplate. # pylint: disable=unused-argument, missing-function-docstring, invalid-name, redefined-builtin datetime_ = ScalarType('Datetime') dict_ = ScalarType('Dict') @datetime_.serializer def serialize_datetime(value): """Serialize a datetime value.""" return str(value) query = QueryType() mutation = MutationType() map_ = ObjectType('Map') civilization = ObjectType('Civilization') stats = ObjectType('Stats') match = ObjectType('Match') player = ObjectType('Player') research = ObjectType('Research')
def test_attempt_bind_scalar_to_invalid_schema_type_raises_error(): schema = build_schema(type_defs) scalar = ScalarType("Query") with pytest.raises(ValueError): scalar.bind_to_schema(schema)
import calendar from datetime import datetime from ariadne import ScalarType posix_time_scalar = ScalarType("PosixTime") @posix_time_scalar.serializer def serialize_posix_time(value: datetime) -> int: return calendar.timegm(value.timetuple())
# middleware middleware = [ Middleware(AuthenticationMiddleware, backend=TokenAuthenticationBackend()) ] # 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(
from datetime import date from ariadne import ScalarType date_scalar = ScalarType("Date") @date_scalar.serializer def serialize_date(value: str): return date.fromisoformat(value).isoformat() if value != "" else None
import copy from datetime import datetime from ariadne import UnionType, ScalarType, InterfaceType, ObjectType from web.data import ingredients, suppliers, products product_interface = InterfaceType('ProductInterface') product_type = UnionType('Product') ingredient_type = ObjectType('Ingredient') supplier_type = ObjectType('Supplier') datetime_scalar = ScalarType('Datetime') @datetime_scalar.serializer def serialize_datetime_scalar(date): return date.isoformat() @datetime_scalar.value_parser def parse_datetime_scalar(date): return datetime.fromisoformat(date) @product_type.type_resolver def resolve_product_type(obj, *_): if 'hasFilling' in obj: return 'Cake' return 'Beverage'
# pylint: disable=import-error import json from ariadne import ScalarType JSON_STRING_SCALAR = ScalarType('JSONString') @JSON_STRING_SCALAR.serializer def serialize_jsonstring(value): return json.dumps(value) @JSON_STRING_SCALAR.value_parser def parse_jsonstring_value(value): return json.loads(value) @JSON_STRING_SCALAR.literal_parser def parse_jsonstring_literal(ast): value = str(ast.value) return json.loads(value)