def __init__(self, core: "Core"):
self.core = core
self.type_defs = load_schema_from_path(f"{core.location}/api/schema/")
# self.add_query("spotifyProgress: String!", self.type_defs)
self.query.set_field(CORE_VERSION, lambda *_: core.version)
self.query.set_field(PLUGIN_VERSION, lambda *_: VERSION)
self.query.set_field(PLUGINS, lambda *_: list(core.plugins.keys()))
self.query.set_field(VALUE, self.get_value)
self.query.set_field(AVAILABLE_COMPONENTS,
lambda *_: list(core.registry.components.keys()))
self.query.set_field(
AVAILABLE_FORMATTER,
lambda *_: list(map(lambda x: x.gql(), core.io.formatter)),
)
self.query.set_field(COMMIT_ID,
lambda *_: os.getenv("COMMIT", "unknown"))
self.query.set_field(ENTITY, self.get_entity)
self.query.set_field(ENTITIES, self.get_entities)
self.subscription.set_field(ENTITY, self.entity_subscription)
self.subscription.set_source(ENTITY, self.entity_subscription_source)
self.subscription.set_field(VALUE, self.value_subscription)
self.subscription.set_source(VALUE, self.value_subscription_source)
self.subscription.set_field(EVENT, self.event_subscription)
self.subscription.set_source(EVENT, self.event_subscription_source)
self.mutations.set_field(SET_COMPONENT, self.set_mutation)
self.mutations.set_field(ACTIVATE_SCENE, self.activate_scene)
def test_graphql():
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
building = ObjectType('Building')
resident = ObjectType('Resident')
# test dataset
rec = building_with_id(None, None, "1")
assert rec == {'id': '1', 'buildYear': 2009}
residents = resolve_residents_in_building(rec, None)
assert len(residents) > 0
# field holders
query.set_field('building_with_id', building_with_id)
building.set_field('residents', resolve_residents_in_building)
schema = make_executable_schema(type_defs, [building, resident, query])
q = """{
building_with_id(_id:"1"){
id
residents {
id
name
}
}
}
"""
result = graphql_sync(schema, q)
pprint(result.data)
assert result.data['building_with_id']['id'] == '1'
def load_schema(self, config):
try:
schema = load_schema_from_path(config.path)
if schema:
self.type_defs.append(schema)
logger.debug("found schema in %s!", config.name)
except FileNotFoundError:
pass
def load_schema(self):
"""Load GraphQL schema."""
if (self.package_path / self.schema_folder).is_dir() and self.schema is None:
type_defs = [
load_schema_from_path(self.package_path / f"{self.schema_folder}")
]
if type_defs:
self.schema = [*type_defs]
def __init__(self, debug=True):
type_defs = load_schema_from_path("graphql_server/schema/")
schema = make_executable_schema(type_defs, query, mutation, user)
self._server = CORSMiddleware(GraphQL(schema, debug=debug),
allow_origins=["*"],
allow_headers=["*"],
allow_methods=["*"])
def __init__(self):
from sagas.conf import resource_path
self.type_defs = load_schema_from_path(resource_path('schemas.graphql'))
query = QueryType()
bucket = ObjectType('Bucket')
behave = ObjectType('Behave')
desc = ObjectType('Desc')
query.set_field('bucket_behaves', bucket_behaves)
bucket.set_field('behaves', resolve_behaves)
self.schema = make_executable_schema(self.type_defs, [behave, bucket, query])
def create_graphql_asgi_wrapper(debug: bool = False) -> asgi.GraphQL:
"""Loads all schemas files and binds all resolvers to an ariadne ASGI's
wrapper that is be binded to Starlette's ASGI implementation"""
type_defs = [load_schema_from_path(schema) for schema in schemas]
schema = make_executable_schema(type_defs,
snake_case_fallback_resolvers,
*bindings,
directives=directives)
return asgi.GraphQL(
schema,
debug=debug,
middleware=middlewares,
)
def build_app():
if "PGCONN" not in os.environ:
raise Exception("Sorry, I need a connection string!")
else:
pgconn = psycopg2.connect(os.environ["PGCONN"])
schema = make_executable_schema(
load_schema_from_path("bogus_schema.graphql"),
query)
app = GraphQL(schema, debug=True,
context_value=dict(pgconn=pgconn))
return app
def get_app(db: DataBase = None):
db = resolve_db(db)
resolvers = get_resolvers(db)
types = [
resolvers[k] for k in [
'query', 'mutation', 'agent', 'flow', 'task', 'flowrun',
'uuid_scalar', 'timestamp_scalar', 'json_scalar'
]
]
type_defs = load_schema_from_path(SCHEMA_PATH)
schema = make_executable_schema(type_defs, *types)
graphql = asgi.GraphQL(schema, middleware=[logging_post_data], debug=True)
middleware = [
Middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"])
]
app = Starlette(debug=True, middleware=middleware)
app.mount("/graphql", graphql)
return app
def graphql_server():
type_defs = load_schema_from_path('schema.graphql')
query = QueryType()
continent = ObjectType('Continent')
country = ObjectType('Country')
query.set_field('continents', resolver.continents_resolver)
query.set_field('countries', resolver.countries_resolver)
query.set_field('country_by_name', resolver.country_by_name_resolver)
query.set_field('continent_by_name_resolver',
resolver.continent_by_name_resolver)
schema = make_executable_schema(type_defs, [continent, country, query])
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
from ariadne import graphql_sync, make_executable_schema, load_schema_from_path, ObjectType, QueryType
from ariadne.constants import PLAYGROUND_HTML
from flask import Flask, request, jsonify
import resolver as r
from database import init_db
app = Flask(__name__)
type_defs = load_schema_from_path('schema.graphql')
#query = QueryType()
query = ObjectType("Query")
mutation = ObjectType("Mutation")
vehicle = ObjectType("Vehicle")
booking = ObjectType("Booking")
#Set Query fields
query.set_field("vehicle", r.getVehicles)
query.set_field("booking", r.getBookings)
#Set Mutation fields
mutation.set_field("newBooking",r.addBooking)
schema = make_executable_schema(type_defs, [query, booking, vehicle, mutation])
@app.route('/graphql', methods=['GET'])
def playground():
return PLAYGROUND_HTML, 200
from ariadne import load_schema_from_path
from os import getcwd
from os.path import dirname, basename, isfile, join
import glob
modules = glob.glob(join(dirname(__file__), "*.py"))
__all__ = [
basename(f)[:-3] for f in modules
if isfile(f) and not f.endswith('__init__.py')
]
from backend.scraper.queries import *
# Get all the typedefs
scraper_query_schema = load_schema_from_path(
join(getcwd(), "backend/scraper/queries"))
def load_typedef_from_schema():
type_def = load_schema_from_path(join(dirname(dirname(__file__)), "./gql"))
type_defs = gql(type_def)
return type_defs
import uvicorn
from ariadne import load_schema_from_path, make_executable_schema
from ariadne.asgi import GraphQL
from starlette.applications import Starlette
from starlette.requests import Request
from starlette.responses import JSONResponse
import prefect_server
from prefect_server.utilities.graphql import mutation, query
from prefect_server.graphql import scalars
from prefect_server.utilities import context
from prefect_server.utilities.logging import get_logger
logger = get_logger("GraphQL Server")
sdl = load_schema_from_path(Path(__file__).parents[2] / "graphql" / "schema")
schema = make_executable_schema(sdl, query, mutation, *scalars.resolvers)
path = prefect_server.config.services.graphql.path or "/"
if not path.endswith("/"):
path += "/"
# The interaction of how Starlette mounts the GraphQL app appears to result in
# 404's when the path doesn't end in a trailing slash. This means GraphQL queries
# must have a trailing slash
if not path.endswith("/"):
raise ValueError("GraphQL path must end with '/'")
app = Starlette()
graphql_sync, snake_case_fallback_resolvers, ObjectType
from ariadne.constants import PLAYGROUND_HTML
from flask import request, jsonify
from api.queries import resolve_employees, resolve_emp
from api.mutations import resolve_create_employee
query = ObjectType("Query")
print(resolve_employees)
query.set_field("employees", resolve_employees)
query.set_field("employee", resolve_emp)
print(resolve_create_employee)
mutation = ObjectType("Mutation")
mutation.set_field("createEmployee", resolve_create_employee)
type_defs = load_schema_from_path("employee.graphql")
schema = make_executable_schema(type_defs, query,
snake_case_fallback_resolvers)
@app.route("/graphql", methods=["GET"])
def graphql_playground():
return PLAYGROUND_HTML, 200
@app.route("/graphql", methods=["POST"])
def graphql_server():
data = request.get_json()
print("data==>", data)
success, result = graphql_sync(schema,
data,
}
# 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)
from flask import Flask, json, request, jsonify
from ariadne import graphql_sync, make_executable_schema, gql, load_schema_from_path
from ariadne.constants import PLAYGROUND_HTML
from mongoengine import connect
type_defs = gql(load_schema_from_path("./dev/schema/"))
# schema = make_executable_schema(type_defs, query, mutation)
connect("blog")
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, world!'
@app.route('/graphql', methods=["GET"])
def graphql_playground():
return PLAYGROUND_HTML, 200
@app.route("/graphql", methods=["POST"])
def graphql_server():
data = request.get_json()
success, result = graphql_sync(schema,
data,
context_value=request,
debug=app.debug)
status_code = 200 if success else 400
return jsonify(result), status_code
#!/usr/bin/env python3
# server.py
from ariadne import gql, QueryType, make_executable_schema, ObjectType, load_schema_from_path
from ariadne.asgi import GraphQL
import uvicorn
type_defs = load_schema_from_path("ariadne_intro/schema/")
query = QueryType()
@query.field("hello")
def resolve_hello(_, info):
request = info.context["request"]
user_agent = request.headers.get("user-agent", "guest")
return f"Hello, {user_agent}"
class User():
def __init__(self, username, name):
self.username = username
self.name = name
self.type = ObjectType("User")
self.type.set_field("username", lambda _, info: self.username)
self.type.set_field("name", lambda _, info: self.name)
bob = User("bob", "Tomas Bouska")
query.set_field("user", lambda _, info: bob.type)
schema = make_executable_schema(type_defs, query, bob.type)
from ariadne import make_executable_schema, load_schema_from_path
from ariadne.asgi import GraphQL
from resolvers import query, skill, person
# import schema from GraphQL file
type_defs = load_schema_from_path("./schema.gql")
schema = make_executable_schema(type_defs, query, skill, person)
app = GraphQL(schema, debug=True)
from flask import Flask, request, jsonify
from ariadne import graphql_sync, make_executable_schema, gql, load_schema_from_path
from ariadne.constants import PLAYGROUND_HTML
# The model is where we'll define our resolvers
from model import query
# We'll create this schema soon
type_defs = gql(load_schema_from_path("./schema.graphql"))
schema = make_executable_schema(type_defs, query)
app = Flask(__name__)
@app.route("/graphql", methods=["GET"])
def graphql_playground():
"""Serve GraphiQL playground"""
return PLAYGROUND_HTML, 200
@app.route("/graphql", methods=["POST"])
def graphql_server():
data = request.get_json()
success, result = graphql_sync(
schema,
data,
context_value=request,
debug=app.debug
)
status_code = 200 if success else 400
return jsonify(result), status_code
from ariadne import load_schema_from_path
from os import getcwd
from os.path import dirname, basename, isfile, join
import glob
modules = glob.glob(join(dirname(__file__), "*.py"))
__all__ = [
basename(f)[:-3] for f in modules
if isfile(f) and not f.endswith('__init__.py')
]
from backend.scraper.subscriptions import *
# Get all the typedefs
scraper_subscription_schema = load_schema_from_path(
join(getcwd(), "backend/scraper/subscriptions"))
return None
@event.field("stateInsight")
async def resolve_event_id(obj, info):
def decode(key, value):
if isinstance(value, uuid.UUID):
return dict(key=key, text=str(value), uuid=value)
if isinstance(value, datetime.datetime):
return dict(key=key, text=str(value), datetime=value)
if key == "timestamp" and isinstance(value, decimal.Decimal):
dt = datetime.datetime.fromtimestamp(
value,
datetime.timezone.utc,
)
return dict(key=key, text=str(dt), datetime=dt)
try:
return dict(key=key, text=str(value), json=json.dumps(value))
except TypeError:
pass
return dict(key=key, text=str(value))
return [decode(key, value) for key, value in obj["event"].__dict__.items()]
type_defs = ariadne.load_schema_from_path("gqles/")
schema = ariadne.make_executable_schema(type_defs, *types)
registered_queries,
registered_subscriptions,
registered_types,
)
class RequestCacheMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request, call_next):
context["cache"] = dict()
context["cache_disabled"] = False
return await call_next(request)
MANAGER_ROUTER_INSTALLED_KEY = "pm/manager/installed"
type_defs = ariadne.load_schema_from_path("./schema")
query = ariadne.QueryType()
mutation = ariadne.MutationType()
subscription = ariadne.SubscriptionType()
for name, resolver in registered_queries.items():
query.set_field(name, resolver)
for name, resolver in registered_mutations.items():
mutation.set_field(name, resolver)
for name, resolver in registered_subscriptions.items():
subscription.set_source(name, resolver)
subscription.set_field(name, lambda f, *_, **__: f if f else None)
schema = ariadne.make_executable_schema(
from ariadne import load_schema_from_path
import os
scraper_type_schema = load_schema_from_path(
os.path.join(os.getcwd(), "backend/scraper/types"))
from ariadne import make_executable_schema, load_schema_from_path
from schemas.resolvers.user_resolvers import user_resolvers
from schemas.resolvers.transaction_resolvers import tranx_resolvers
resolvers = user_resolvers + tranx_resolvers
type_defs = load_schema_from_path("schemas")
schema = make_executable_schema(type_defs, resolvers)
if todo["id"] == todo_id:
del todos[i]
return {"success": True}
return {"success": False, "errors": ["Can't find todo"]}
query = ariadne.ObjectType("Query")
query.set_field("todos", resolve_todos)
query.set_field("todo", resolve_todo)
mutation = ariadne.ObjectType("Mutation")
mutation.set_field("createTodo", resolve_create_todo)
mutation.set_field("deleteTodo", resolve_delete_todo)
schema = ariadne.make_executable_schema(
ariadne.load_schema_from_path("schema.graphql"), query, mutation,
ariadne.snake_case_fallback_resolvers)
@app.route("/graphql", methods=["GET"])
def graphql_playground():
data = request.args.get("query")
if data:
success, result = ariadne.graphql_sync(schema, {"query": data},
context_value=request,
debug=app.debug)
status_code = 200 if success else 400
return jsonify(result), status_code
return ariadne.constants.PLAYGROUND_HTML, 200
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:
import os from ariadne import QueryType, load_schema_from_path, make_executable_schema from .analytics import analytics from .status import status from .versioncheck import version_check FILE_PATH = os.path.dirname(os.path.abspath(__file__)) SCHEMA_PATH = os.path.join(FILE_PATH, "schema.graphql") type_defs = load_schema_from_path(SCHEMA_PATH) schema = make_executable_schema(type_defs, [analytics, status, version_check])
from ariadne import load_schema_from_path
from ariadne.contrib.django.views import GraphQLView
from ariadne.contrib.federation import make_federated_schema
from parking_permits import admin_resolvers, resolvers
from parking_permits.error_formatter import error_formatter
from project.settings import BASE_DIR
type_defs = load_schema_from_path(BASE_DIR / "parking_permits" / "schema" /
"parking_permit.graphql")
schema = make_federated_schema(type_defs, resolvers.schema_bindables)
view = GraphQLView.as_view(schema=schema, error_formatter=error_formatter)
admin_type_defs = load_schema_from_path(
BASE_DIR / "parking_permits" / "schema" / "parking_permit_admin.graphql")
schema = make_federated_schema(admin_type_defs,
admin_resolvers.schema_bindables)
admin_view = GraphQLView.as_view(schema=schema,
error_formatter=error_formatter)
import os
from ariadne import make_executable_schema, load_schema_from_path
from client_api.mutations import mutation
from client_api.queries import query
type_defs = load_schema_from_path(os.path.abspath("client_api/schema.graphql"))
schema = make_executable_schema(type_defs, [query, mutation])
