def load_introspection_from_server(url):
query = get_introspection_query()
request = requests.post(url, json={'query': query})
if request.status_code == 200:
return request.json()['data']
raise Exception(f'Query failed to run by returning code of {request.status_code}. {query}')
def create_app():
app = Flask(__name__, static_folder='static')
# Serve Graphiql IDE at /
graphiql = GraphQLAPI.as_view("graphiql",
schema=schema,
use_playground=False)
app.add_url_rule("/", view_func=graphiql)
# Serve Graphiql IDE at /dark
graphiql = GraphQLAPI.as_view("playground",
schema=schema,
use_playground=True)
app.add_url_rule("/dark", view_func=graphiql)
# Serve Explorer at /explorer
introspection = schema.execute_sync(get_introspection_query())
explorer = APIExplorer.as_view("voyager",
introspection=json.dumps(
{'data': introspection.data}))
app.add_url_rule("/explorer", view_func=explorer)
# Handle database connections per request
@app.before_request
def before_request():
db.connect()
@app.after_request
def after_request(response):
db.close()
return response
return app
def make_remote_executable_schema(url: str) -> graphql.GraphQLSchema:
"""
Creates an executable GraphQL schema from a remote endpoint.
"""
client = GraphQLClient(url=url)
introspection_result = client.execute(graphql.get_introspection_query())
schema = graphql.build_client_schema(introspection_result.data)
def root_resolver(obj, info, **inputs):
query = graphql.print_ast(info.operation)
# TODO: add graphql context
delegated_result = client.execute(query=query,
variables=info.variable_values)
return delegated_result.data[info.field_name]
# apply root resolver to any field on query or mutation roots
resolvers = {
schema.query_type.name:
{q: root_resolver
for q in schema.query_type.fields},
schema.mutation_type.name:
{q: root_resolver
for q in schema.mutation_type.fields},
}
ariadne.resolvers.add_resolve_functions_to_schema(schema, resolvers)
return schema
def __init__(
self,
schema: Optional[GraphQLSchema] = None,
introspection: Optional[Dict[str, Any]] = None,
type_def: Optional[str] = None,
transport: Optional[Transport] = None,
fetch_schema_from_transport: bool = False,
retries: int = 0,
) -> None:
assert not (
type_def and introspection
), "Cant provide introspection type definition at the same time"
if transport and fetch_schema_from_transport:
assert (
not schema
), "Cant fetch the schema from transport if is already provided"
introspection = transport.execute(
parse(get_introspection_query(descriptions=True))).data
if introspection:
assert not schema, "Cant provide introspection and schema at the same time"
schema = build_client_schema(introspection)
elif type_def:
assert (
not schema
), "Cant provide Type definition and schema at the same time"
type_def_ast = parse(type_def)
schema = build_ast_schema(type_def_ast)
elif schema and not transport:
transport = LocalSchemaTransport(schema)
self.schema = schema
self.introspection = introspection
self.transport = cast(Transport, transport)
self.retries = retries
def load_introspection_from_server(url):
query = get_introspection_query()
request = requests.post(url, json={'query': query})
if request.status_code == 200:
return request.json()['data']
raise Exception('Query failed to run by returning code of '
f'{request.status_code}. {query}')
async def schema(self):
return await fetch(
self.url,
headers={
'Accept': 'application/json',
'Content-Type': 'application/json',
},
params={'query': get_introspection_query(descriptions=False)})
async def introspection(self):
status, result = await self.execute(get_introspection_query())
if status != 200:
raise ValueError(
f"Error in schema introspection. {status} - {result}")
schema = build_client_schema(result.data)
self.dsl = DSLSchema(schema, camelcase=self.camelcase)
return schema
def fetch_schema(self) -> None:
"""Fetch the GraphQL schema explicitely using introspection.
Don't use this function and instead set the fetch_schema_from_transport
attribute to True"""
execution_result = self.transport.execute(parse(get_introspection_query()))
self.client._build_schema_from_introspection(execution_result)
def load_introspection_from_server(url):
query = get_introspection_query()
request = requests.post(url, json={"query": query})
if request.status_code == 200:
return request.json()["data"]
raise Exception(
f"Request failure with {request.status_code} status code for query {query}"
)
def main():
pp = PrettyPrinter(indent=4)
client = GraphQLClient('http://swapi.graph.cool/')
query_intros = get_introspection_query(descriptions=True)
intros_result = client.execute(query_intros,
variables=None,
operationName=None)
client_schema = build_client_schema(intros_result.get('data', None))
sdl = print_schema(client_schema)
print(sdl)
pp.pprint(sdl)
def introspect(self) -> Dict[str, Any]:
"""Return the introspection query result for the current schema
Raises:
ValueError: If the introspection query fails due to an invalid schema
"""
introspection = self.execute_sync(get_introspection_query())
if introspection.errors or not introspection.data:
raise ValueError(f"Invalid Schema. Errors {introspection.errors!r}")
return introspection.data
def handle(self, *args, **options):
query = get_introspection_query(descriptions=False)
result = graphql_sync(schema, query)
output = {"data": result.data}
with open("schema.json", "w") as f:
json.dump(output, f, indent=4, sort_keys=True)
self.stdout.write(
self.style.SUCCESS(
"Successfully dumped GraphQL schema to schema.json"))
def test_executable_schema_can_be_introspected():
schema = make_executable_schema(type_defs)
introspection_query = get_introspection_query(descriptions=True)
result = graphql_sync(schema, introspection_query)
assert result.errors is None
assert result.data is not None
assert "__schema" in result.data
type_names = [
schema_type["name"] for schema_type in result.data["__schema"]["types"]
]
assert "User" in type_names
assert "Query" in type_names
assert "Date" in type_names
def query_for_schema(provider):
"""
Asks the given provider for its schema
"""
prov = get_provider(provider)
if hasattr(prov, 'get_schema_str'):
data = prov.get_schema_str()
schema = graphql.build_schema(data)
else:
query = graphql.get_introspection_query(descriptions=True)
data = exec_query_sync(provider, query)
schema = graphql.build_client_schema(data)
schema = insert_builtins(schema)
return schema
def _resolve_url(ctx, url: str) -> Optional[GraphQLSchema]:
query = get_introspection_query(descriptions=True)
try:
response = requests.post(url,
data={"query": query},
headers={"Accept": "application/json"})
response.raise_for_status()
except requests.RequestException:
raise ValueError("Could not download schema")
try:
data = response.json()
except json.decoder.JSONDecodeError:
raise ValueError("Received invalid JSON from GraphQL endpoint")
try:
return build_client_schema(data["data"])
except Exception:
raise ValueError("Could not decode schema")
def initialize(self):
loop = tornado.ioloop.IOLoop.current()
generate_schema()
api_schema = get_api_schema()
module_schema = get_module_schema()
if options.generate_schema_and_exit:
query = get_introspection_query(descriptions=False)
introspection_query_result = graphql_sync(api_schema, query)
client_schema = build_client_schema(introspection_query_result.data)
sdl = print_schema(client_schema)
with open(
Path(options.basedir).joinpath("..", "schema.graphql").resolve(), "w+"
) as fid:
fid.write(sdl)
sys.exit(0)
start_all_modules()
self.database = None # MavDatabase()
application = TornadoQL()
# Start Non-SSL server
server = tornado.httpserver.HTTPServer(application)
server.listen(port=options.server_port_nonssl, address=options.server_interface)
application_log.info(
f"Starting Maverick API server: {options.server_interface}:{options.server_port_nonssl}/{options.app_prefix}"
)
# Start SSL server, unless disabled
if not options.disable_ssl:
ssl_options = self.get_ssl_options()
server = tornado.httpserver.HTTPServer(application, ssl_options=ssl_options)
server.listen(
port=options.server_port_ssl, address=options.server_interface
)
application_log.info(
f"Starting Maverick API server - SSL: {options.server_interface}:{options.server_port_ssl}/{options.app_prefix}"
)
async def introspect(
self, headers: Optional[Dict[str, str]] = None
) -> graphql.GraphQLSchema:
"""
Introspect the GraphQL endpoint specified for this client and return a `graphql.GraphQLSchema` object
specifying the schema associated with this endpoint.
:return: GraphQL schema for the configured endpoint
"""
request = GraphQLRequest(
query=graphql.get_introspection_query(descriptions=False),
validate=False,
headers=headers,
)
introspection = await self.query(request)
try:
return graphql.build_client_schema(introspection=introspection.data)
except TypeError:
raise GraphQLIntrospectionException(
f"Failed to build schema from introspection data: {introspection.errors}"
)
def main():
pp = PrettyPrinter(indent=4)
# query over the network
query_intros = get_introspection_query(descriptions=True)
#introspection_query_result = graphql_sync(schema, query)
intros_result = client.execute(query_intros,
variables=None,
operationName=None)
client_schema = build_client_schema(intros_result.get('data', None))
sdl = print_schema(client_schema)
print(sdl)
pp.pprint(sdl)
print("\n")
# query again using the graphql_sync()
from graphql import graphql_sync
introspection_query_result = graphql_sync(client_schema, query_intros)
client_schema = build_client_schema(introspection_query_result.data)
sdl = print_schema(client_schema)
print(sdl)
pp.pprint(sdl)
print("\n")
def introspection_query():
return get_introspection_query()
GrapheneScalarType,
GrapheneUnionType,
)
from .dynamic import Dynamic
from .enum import Enum
from .field import Field
from .inputobjecttype import InputObjectType
from .interface import Interface
from .objecttype import ObjectType
from .resolver import get_default_resolver
from .scalars import ID, Boolean, Float, Int, Scalar, String
from .structures import List, NonNull
from .union import Union
from .utils import get_field_as
introspection_query = get_introspection_query()
IntrospectionSchema = introspection_types["__Schema"]
def assert_valid_root_type(type_):
if type_ is None:
return
is_graphene_objecttype = inspect.isclass(type_) and issubclass(
type_, ObjectType)
is_graphql_objecttype = isinstance(type_, GraphQLObjectType)
assert is_graphene_objecttype or is_graphql_objecttype, (
"Type {} is not a valid ObjectType.").format(type_)
def is_graphene_type(type_):
if isinstance(type_, (List, NonNull)):
def test_should_ignore_the_introspection_query():
errors, result = run_query(get_introspection_query(), 10)
assert not errors
assert result == {"IntrospectionQuery": 0}
def test_opentracing_extension_doesnt_break_introspection(schema):
introspection_query = get_introspection_query(descriptions=True)
_, result = graphql(schema, {"query": introspection_query},
extensions=[OpenTracingExtension])
assert "errors" not in result
import graphql
import requests
from graphql import ExecutionResult
from starlette.applications import Starlette
from starlette.testclient import TestClient as ASGIClient
from werkzeug import Client
from yarl import URL
from ...constants import DEFAULT_DATA_GENERATION_METHODS, CodeSampleStyle
from ...exceptions import HTTPError
from ...hooks import HookContext, dispatch
from ...types import DataGenerationMethodInput, PathLike
from ...utils import WSGIResponse, prepare_data_generation_methods, require_relative_url, setup_headers
from .schemas import GraphQLSchema
INTROSPECTION_QUERY = graphql.get_introspection_query()
INTROSPECTION_QUERY_AST = graphql.parse(INTROSPECTION_QUERY)
def from_path(
path: PathLike,
*,
app: Any = None,
base_url: Optional[str] = None,
data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
code_sample_style: str = CodeSampleStyle.default().name,
encoding: str = "utf8",
) -> GraphQLSchema:
"""Load GraphQL schema via a file from an OS path.
:param path: A path to the schema file.
def test_executable_schema_can_be_introspected(snapshot):
schema = make_executable_schema(type_defs)
introspection_query = get_introspection_query(descriptions=True)
result = graphql_sync(schema, introspection_query)
assert result.errors is None
snapshot.assert_match(result.data)
async def fetch_schema(self) -> None:
execution_result = await self.transport.execute(
parse(get_introspection_query())
)
self.client.introspection = execution_result.data
self.client.schema = build_client_schema(self.client.introspection)
subscription_type = GraphQLObjectType(
"Subscription",
lambda: {
"reviewAdded": GraphQLField(
review_type,
args={
"episode": GraphQLArgument(
episode_enum,
description="Episode to review",
)
},
subscribe=subscribe_reviews,
resolve=resolve_review,
)
},
)
StarWarsSchema = GraphQLSchema(
query=query_type,
mutation=mutation_type,
subscription=subscription_type,
types=[human_type, droid_type, review_type, review_input_type],
)
StarWarsIntrospection = graphql_sync(StarWarsSchema, get_introspection_query()).data
StarWarsTypeDef = print_schema(StarWarsSchema)
subscriptionType = GraphQLObjectType(
"Subscription",
fields=lambda: {
"reviewAdded":
GraphQLField(
reviewType,
args={
"episode":
GraphQLArgument(
description="Episode to review",
type_=episodeEnum,
)
},
subscribe=subscribe_reviews,
resolve=resolve_review,
)
},
)
StarWarsSchema = GraphQLSchema(
query=queryType,
mutation=mutationType,
subscription=subscriptionType,
types=[humanType, droidType, reviewType, reviewInputType],
)
StarWarsIntrospection = graphql_sync(StarWarsSchema,
get_introspection_query()).data
StarWarsTypeDef = print_schema(StarWarsSchema)
async def test_apollotracing_extension_doesnt_break_introspection(schema):
introspection_query = get_introspection_query(descriptions=True)
_, result = await graphql(schema, {"query": introspection_query},
extensions=[ApolloTracingExtension])
assert "errors" not in result
async def get(self):
query = get_introspection_query(descriptions=True)
introspection_query_result = await graphql(api_schema, query)
introspection_dict = introspection_query_result.data
self.write(json.dumps(introspection_dict, indent=4, sort_keys=True))
self.finish()
