async-graphql/src/schema.rs

286 lines
9.4 KiB
Rust
Raw Normal View History

2020-03-05 00:39:56 +00:00
use crate::context::Data;
2020-03-26 03:34:28 +00:00
use crate::extensions::{BoxExtension, Extension};
use crate::model::__DirectiveLocation;
use crate::parser::parse_query;
2020-03-17 09:26:59 +00:00
use crate::query::QueryBuilder;
use crate::registry::{Directive, InputValue, Registry};
use crate::subscription::{create_connection, create_subscription_stream, SubscriptionTransport};
2020-03-03 11:15:18 +00:00
use crate::types::QueryRoot;
2020-04-14 01:53:17 +00:00
use crate::validation::{check_rules, ValidationMode};
2020-03-29 12:02:52 +00:00
use crate::{
Environment, Error, ObjectType, Pos, QueryError, QueryResponse, Result, SubscriptionStream,
SubscriptionType, Type, Variables,
2020-03-29 12:02:52 +00:00
};
use bytes::Bytes;
2020-03-29 12:02:52 +00:00
use futures::channel::mpsc;
2020-04-14 01:53:17 +00:00
use futures::Stream;
use std::any::Any;
2020-03-05 07:50:57 +00:00
use std::collections::HashMap;
2020-03-29 12:02:52 +00:00
use std::sync::atomic::AtomicUsize;
use std::sync::Arc;
2020-03-01 10:54:34 +00:00
2020-03-29 12:02:52 +00:00
pub(crate) struct SchemaInner<Query, Mutation, Subscription> {
2020-04-06 11:57:21 +00:00
pub(crate) validation_mode: ValidationMode,
2020-03-25 07:07:16 +00:00
pub(crate) query: QueryRoot<Query>,
pub(crate) mutation: Mutation,
2020-03-17 09:26:59 +00:00
pub(crate) subscription: Subscription,
pub(crate) registry: Registry,
pub(crate) data: Data,
2020-03-25 07:07:16 +00:00
pub(crate) complexity: Option<usize>,
pub(crate) depth: Option<usize>,
2020-03-26 03:34:28 +00:00
pub(crate) extensions: Vec<Box<dyn Fn() -> BoxExtension + Send + Sync>>,
2020-03-01 10:54:34 +00:00
}
2020-03-29 12:02:52 +00:00
/// Schema builder
pub struct SchemaBuilder<Query, Mutation, Subscription>(SchemaInner<Query, Mutation, Subscription>);
2020-03-19 09:20:12 +00:00
impl<Query: ObjectType, Mutation: ObjectType, Subscription: SubscriptionType>
2020-03-29 12:02:52 +00:00
SchemaBuilder<Query, Mutation, Subscription>
2020-03-17 09:26:59 +00:00
{
/// You can use this function to register types that are not directly referenced.
pub fn register_type<T: Type>(mut self) -> Self {
T::create_type_info(&mut self.0.registry);
self
}
2020-03-29 12:02:52 +00:00
/// Disable introspection query
pub fn disable_introspection(mut self) -> Self {
self.0.query.disable_introspection = true;
self
}
/// Set limit complexity, Default no limit.
pub fn limit_complexity(mut self, complexity: usize) -> Self {
self.0.complexity = Some(complexity);
self
}
/// Set limit complexity, Default no limit.
pub fn limit_depth(mut self, depth: usize) -> Self {
self.0.depth = Some(depth);
self
}
/// Add an extension
pub fn extension<F: Fn() -> E + Send + Sync + 'static, E: Extension>(
mut self,
extension_factory: F,
) -> Self {
self.0
.extensions
.push(Box::new(move || Box::new(extension_factory())));
self
}
2020-03-31 03:19:18 +00:00
/// Add a global data that can be accessed in the `Schema`, you access it with `Context::data`.
2020-03-29 12:02:52 +00:00
pub fn data<D: Any + Send + Sync>(mut self, data: D) -> Self {
self.0.data.insert(data);
self
}
2020-04-06 11:57:21 +00:00
/// Set the validation mode, default is `ValidationMode::Strict`.
pub fn validation_mode(mut self, validation_mode: ValidationMode) -> Self {
self.0.validation_mode = validation_mode;
self
}
2020-03-29 12:02:52 +00:00
/// Build schema.
pub fn finish(self) -> Schema<Query, Mutation, Subscription> {
Schema(Arc::new(self.0))
}
}
/// GraphQL schema
pub struct Schema<Query, Mutation, Subscription>(
pub(crate) Arc<SchemaInner<Query, Mutation, Subscription>>,
);
impl<Query, Mutation, Subscription> Clone for Schema<Query, Mutation, Subscription> {
fn clone(&self) -> Self {
Schema(self.0.clone())
}
}
impl<Query, Mutation, Subscription> Schema<Query, Mutation, Subscription>
where
Query: ObjectType + Send + Sync + 'static,
Mutation: ObjectType + Send + Sync + 'static,
Subscription: SubscriptionType + Send + Sync + 'static,
{
/// Create a schema builder
2020-03-09 10:05:52 +00:00
///
/// The root object for the query and Mutation needs to be specified.
2020-03-19 09:20:12 +00:00
/// If there is no mutation, you can use `EmptyMutation`.
/// If there is no subscription, you can use `EmptySubscription`.
2020-03-29 12:02:52 +00:00
pub fn build(
query: Query,
mutation: Mutation,
subscription: Subscription,
) -> SchemaBuilder<Query, Mutation, Subscription> {
2020-03-08 12:35:36 +00:00
let mut registry = Registry {
types: Default::default(),
directives: Default::default(),
implements: Default::default(),
query_type: Query::type_name().to_string(),
mutation_type: if Mutation::is_empty() {
None
} else {
Some(Mutation::type_name().to_string())
},
2020-03-17 09:26:59 +00:00
subscription_type: if Subscription::is_empty() {
None
} else {
Some(Subscription::type_name().to_string())
},
2020-03-08 12:35:36 +00:00
};
registry.add_directive(Directive {
name: "include",
description: Some("Directs the executor to include this field or fragment only when the `if` argument is true."),
2020-03-05 13:34:31 +00:00
locations: vec![
__DirectiveLocation::FIELD,
__DirectiveLocation::FRAGMENT_SPREAD,
__DirectiveLocation::INLINE_FRAGMENT
],
2020-03-08 12:35:36 +00:00
args: {
let mut args = HashMap::new();
args.insert("if", InputValue {
name: "if",
description: Some("Included when true."),
ty: "Boolean!".to_string(),
2020-03-21 01:32:13 +00:00
default_value: None,
2020-03-22 01:34:32 +00:00
validator: None,
2020-03-08 12:35:36 +00:00
});
args
}
});
registry.add_directive(Directive {
name: "skip",
description: Some("Directs the executor to skip this field or fragment when the `if` argument is true."),
2020-03-05 13:34:31 +00:00
locations: vec![
__DirectiveLocation::FIELD,
__DirectiveLocation::FRAGMENT_SPREAD,
__DirectiveLocation::INLINE_FRAGMENT
],
2020-03-08 12:35:36 +00:00
args: {
let mut args = HashMap::new();
args.insert("if", InputValue {
name: "if",
description: Some("Skipped when true."),
ty: "Boolean!".to_string(),
2020-03-21 01:32:13 +00:00
default_value: None,
2020-03-22 01:34:32 +00:00
validator: None,
2020-03-08 12:35:36 +00:00
});
args
}
});
// register scalars
bool::create_type_info(&mut registry);
i32::create_type_info(&mut registry);
f32::create_type_info(&mut registry);
String::create_type_info(&mut registry);
2020-03-08 12:35:36 +00:00
QueryRoot::<Query>::create_type_info(&mut registry);
2020-03-05 09:06:14 +00:00
if !Mutation::is_empty() {
Mutation::create_type_info(&mut registry);
}
2020-03-17 09:26:59 +00:00
if !Subscription::is_empty() {
Subscription::create_type_info(&mut registry);
}
2020-04-09 14:03:09 +00:00
// federation
registry.create_federation_types();
2020-03-29 12:02:52 +00:00
SchemaBuilder(SchemaInner {
2020-04-06 11:57:21 +00:00
validation_mode: ValidationMode::Strict,
2020-03-25 07:07:16 +00:00
query: QueryRoot {
inner: query,
disable_introspection: false,
},
2020-03-01 10:54:34 +00:00
mutation,
2020-03-17 09:26:59 +00:00
subscription,
2020-03-05 00:39:56 +00:00
registry,
data: Default::default(),
2020-03-25 07:07:16 +00:00
complexity: None,
depth: None,
2020-03-26 03:34:28 +00:00
extensions: Default::default(),
2020-03-29 12:02:52 +00:00
})
2020-03-25 07:07:16 +00:00
}
2020-03-29 12:02:52 +00:00
/// Create a schema
pub fn new(
query: Query,
mutation: Mutation,
subscription: Subscription,
) -> Schema<Query, Mutation, Subscription> {
Self::build(query, mutation, subscription).finish()
2020-03-05 00:39:56 +00:00
}
#[doc(hidden)]
pub fn data(&self) -> &Data {
&self.0.data
}
#[doc(hidden)]
pub fn registry(&self) -> &Registry {
&self.0.registry
}
2020-04-02 04:53:53 +00:00
/// Execute query without create the `QueryBuilder`.
2020-04-14 01:53:17 +00:00
pub async fn execute(&self, query_source: &str) -> Result<QueryResponse> {
QueryBuilder::new(query_source).execute(self).await
2020-04-02 04:53:53 +00:00
}
/// Create subscription stream, typically called inside the `SubscriptionTransport::handle_request` method
2020-04-07 06:30:46 +00:00
pub async fn create_subscription_stream(
2020-03-29 12:02:52 +00:00
&self,
source: &str,
operation_name: Option<&str>,
variables: Variables,
ctx_data: Option<Arc<Data>>,
) -> Result<impl Stream<Item = Result<serde_json::Value>> + Send> {
let mut document = parse_query(source).map_err(Into::<Error>::into)?;
2020-04-06 11:57:21 +00:00
check_rules(&self.0.registry, &document, self.0.validation_mode)?;
2020-03-29 12:02:52 +00:00
if !document.retain_operation(operation_name) {
return if let Some(name) = operation_name {
Err(QueryError::UnknownOperationNamed {
name: name.to_string(),
}
.into_error(Pos::default()))
} else {
Err(QueryError::MissingOperation.into_error(Pos::default()))
};
}
2020-03-29 12:02:52 +00:00
let resolve_id = AtomicUsize::default();
let environment = Arc::new(Environment {
variables,
document: Box::new(document),
ctx_data: ctx_data.unwrap_or_default(),
});
let ctx = environment.create_context(
self,
None,
&environment.document.current_operation().selection_set,
&resolve_id,
);
let mut streams = Vec::new();
create_subscription_stream(self, environment.clone(), &ctx, &mut streams).await?;
2020-04-06 10:30:38 +00:00
Ok(futures::stream::select_all(streams))
2020-03-29 12:02:52 +00:00
}
/// Create subscription connection, returns `Sink` and `Stream`.
2020-03-31 03:19:18 +00:00
pub fn subscription_connection<T: SubscriptionTransport>(
2020-03-29 12:02:52 +00:00
&self,
transport: T,
) -> (
mpsc::Sender<Bytes>,
SubscriptionStream<Query, Mutation, Subscription, T>,
) {
create_connection(self.clone(), transport)
2020-03-29 12:02:52 +00:00
}
2020-03-01 10:54:34 +00:00
}