def __init__(self,
gateway,
schema_path=None,
data_gw_cache=None,
**kwargs):
self.__gateway = gateway
if schema_path:
with open(schema_path) as f:
source = f.read()
else:
self.__schema_source = create_gql_schema(gateway)
source = self.__schema_source
document = parse(source)
self.__schema = build_ast_schema(document)
abstract_types = filter(lambda x: hasattr(x, 'resolve_type'),
dict(self.__schema.get_type_map()).values())
for at in abstract_types:
at.resolve_type = self.__resolve_type
self.__executor = AgoraExecutor(gateway)
if not data_gw_cache:
data_gw_cache = {'max_age_seconds': 300, 'max_len': 1000000}
self.expiring_dict = ExpiringDict(**data_gw_cache)
middleware = AgoraMiddleware(gateway,
data_gw_cache=self.expiring_dict,
**kwargs)
self.__middleware = MiddlewareManager(middleware)
def __init__(self,
query=None,
mutation=None,
subscription=None,
directives=None,
types=None,
executor=None,
middlewares=None,
auto_camelcase=True):
self._query = query
self._mutation = mutation
self._subscription = subscription
self.types = types
self._executor = executor
self.auto_camelcase = auto_camelcase
if directives is None:
directives = [GraphQLIncludeDirective, GraphQLSkipDirective]
assert all(isinstance(d, GraphQLDirective) for d in directives), \
'Schema directives must be List[GraphQLDirective] if provided but got: {}.'.format(
directives
)
if middlewares:
self.middlewares = MiddlewareManager(*middlewares)
else:
self.middlewares = None
self._directives = directives
self.build_typemap()
def _test():
from graphql import MiddlewareManager
ok, response = graphql_run(
app, "{ hello }", middleware=MiddlewareManager(example_middleware))
assert ok and not response.get("errors")
assert "Hello!" in str(response["data"])
def get_graphql_params(self, connection_context, payload):
params = super().get_graphql_params(connection_context, payload)
middleware = graphene_settings.MIDDLEWARE
if middleware:
if not isinstance(middleware, MiddlewareManager):
middleware = MiddlewareManager(*middleware,
wrap_in_promise=False)
params["middleware"] = middleware
return params
def as_middleware_manager(self,
*additional_middlewares) -> MiddlewareManager:
middlewares = tuple(self.extensions) + additional_middlewares
return MiddlewareManager(*middlewares)
def execute(
schema, # type: GraphQLSchema
document_ast, # type: Document
root_value=None, # type: Any
context_value=None, # type: Optional[Any]
variable_values=None, # type: Optional[Any]
operation_name=None, # type: Optional[str]
executor=None, # type: Any
middleware=None, # type: Optional[Any]
allow_subscriptions=False, # type: bool
**options # type: Any
):
# type: (...) -> Awaitable[ExecutionResult]
if root_value is None and "root" in options:
warnings.warn(
"The 'root' alias has been deprecated. Please use 'root_value' instead.",
category=DeprecationWarning,
stacklevel=2,
)
root_value = options["root"]
if context_value is None and "context" in options:
warnings.warn(
"The 'context' alias has been deprecated. Please use 'context_value' instead.",
category=DeprecationWarning,
stacklevel=2,
)
context_value = options["context"]
if variable_values is None and "variables" in options:
warnings.warn(
"The 'variables' alias has been deprecated. Please use 'variable_values' instead.",
category=DeprecationWarning,
stacklevel=2,
)
variable_values = options["variables"]
assert schema, "Must provide schema"
assert isinstance(schema, GraphQLSchema), (
"Schema must be an instance of GraphQLSchema. Also ensure that there are "
+
"not multiple versions of GraphQL installed in your node_modules directory."
)
if middleware:
if not isinstance(middleware, MiddlewareManager):
middleware = MiddlewareManager(*middleware)
assert isinstance(middleware, MiddlewareManager), (
"middlewares have to be an instance"
' of MiddlewareManager. Received "{}".'.format(middleware))
# 只能采用协程执行器
if executor is None:
executor = AsyncioExecutor()
assert isinstance(executor, AsyncioExecutor)
# 初始化 context value 的结构
if context_value is None:
context_value = {}
context_value.setdefault("prefetch", defaultdict(list))
exe_context = ExecutionContext(
schema,
document_ast,
root_value,
context_value,
variable_values or {},
operation_name,
executor,
middleware,
allow_subscriptions,
)
def promise_executor(v):
# type: (Optional[Any]) -> Union[Dict, Promise[Dict], Observable]
return execute_operation(exe_context, exe_context.operation,
root_value)
def on_rejected(error):
# type: (Exception) -> None
exe_context.errors.append(error)
return None
def on_resolve(data):
# type: (Union[None, Dict, Observable]) -> Union[ExecutionResult, Observable]
if isinstance(data, Observable):
return data
if not exe_context.errors:
return ExecutionResult(data=data)
return ExecutionResult(data=data, errors=exe_context.errors)
def prefetch(data):
resolve_prefetch(exe_context, exe_context.operation, root_value)
return data
if exe_context.operation.operation == 'query':
promise = Promise.resolve(None).then(prefetch).then(
promise_executor).catch(on_rejected).then(on_resolve)
else:
promise = Promise.resolve(None).then(promise_executor).catch(
on_rejected).then(on_resolve)
# 类似于调用 executor.wait_until_finished
# 但是 executor.wait_until_finished 要求当前线程没有loop
async def wait_until_finished():
while executor.futures:
futures = executor.futures
executor.futures = []
await asyncio.gather(*tuple(futures))
return await promise
return wait_until_finished()
def _test():
from graphql import MiddlewareManager
_, response = graphql_run(
app, query, middleware=MiddlewareManager(error_middleware))
assert response["errors"]