use std::{
sync::Arc,
time::{Duration, Instant},
};
use gql::{Name, TypeRef};
use indexmap::IndexMap;
use crate::field::property_resolver;
#[derive(Clone, Copy, Debug)]
pub struct FieldMeta<'a> {
pub type_name: &'a str,
pub field_name: &'a str,
pub return_type: &'a TypeRef,
pub args: &'a IndexMap<Name, gql::InputValue>,
pub is_root: bool,
pub is_subscription: bool,
}
impl FieldMeta<'_> {
#[must_use]
pub fn path(&self) -> String {
format!("{}.{}", self.type_name, self.field_name)
}
}
pub trait Plugin<Ctx: 'static>: Send + Sync + 'static {
fn field(&self, _meta: &FieldMeta<'_>, _field: &mut gql::Field) {}
fn wrap_resolve(&self, _meta: &FieldMeta<'_>, next: gql::ResolveFn) -> gql::ResolveFn {
next
}
fn wrap_subscribe(&self, _meta: &FieldMeta<'_>, next: gql::SubscribeFn) -> gql::SubscribeFn {
next
}
fn configure(&self, _builder: &mut gql::SchemaBuilder) {}
}
pub(crate) struct PluginTargets<'a> {
pub objects: &'a mut IndexMap<Name, gql::ObjectType>,
pub interfaces: &'a mut IndexMap<Name, gql::InterfaceType>,
pub query: &'a mut [gql::Field],
pub mutation: &'a mut [gql::Field],
pub subscription: &'a mut [gql::Field],
pub query_name: &'a str,
pub mutation_name: &'a str,
pub subscription_name: &'a str,
}
#[cfg_attr(
feature = "tracing",
tracing::instrument(
skip_all,
level = "debug",
name = "gurafi.schema.plugins",
fields(plugins = plugins.len(), fields_visited = tracing::field::Empty)
)
)]
pub(crate) fn apply_plugins<Ctx: 'static>(
plugins: &[Arc<dyn Plugin<Ctx>>],
targets: PluginTargets<'_>,
) {
if plugins.is_empty() {
return;
}
#[cfg(feature = "tracing")]
let fields_visited = {
let targets = &targets;
targets
.objects
.values()
.map(|object| object.fields.len())
.sum::<usize>()
+ targets
.interfaces
.values()
.map(|interface| interface.fields.len())
.sum::<usize>()
+ targets.query.len()
+ targets.mutation.len()
+ targets.subscription.len()
};
let PluginTargets {
objects,
interfaces,
query,
mutation,
subscription,
query_name,
mutation_name,
subscription_name,
} = targets;
for (name, object) in objects.iter_mut() {
for field in object.fields.values_mut() {
apply_to_field(plugins, name, field, false, false, true);
}
}
for (name, interface) in interfaces.iter_mut() {
for field in interface.fields.values_mut() {
apply_to_field(plugins, name, field, false, false, false);
}
}
for field in query.iter_mut() {
apply_to_field(plugins, query_name, field, true, false, true);
}
for field in mutation.iter_mut() {
apply_to_field(plugins, mutation_name, field, true, false, true);
}
for field in subscription.iter_mut() {
apply_to_field(plugins, subscription_name, field, true, true, true);
}
#[cfg(feature = "tracing")]
{
let span = tracing::Span::current();
if !span.is_disabled() {
span.record("fields_visited", fields_visited);
}
}
}
fn apply_to_field<Ctx: 'static>(
plugins: &[Arc<dyn Plugin<Ctx>>],
type_name: &str,
field: &mut gql::Field,
is_root: bool,
is_subscription: bool,
has_resolvers: bool,
) {
for plugin in plugins {
let field_name = field.name.clone();
let return_type = field.ty.clone();
let args = field.args.clone();
let meta = FieldMeta {
type_name,
field_name: &field_name,
return_type: &return_type,
args: &args,
is_root,
is_subscription,
};
plugin.field(&meta, field);
}
if !has_resolvers {
return;
}
let field_name = field.name.clone();
let return_type = field.ty.clone();
let args = field.args.clone();
let meta = FieldMeta {
type_name,
field_name: &field_name,
return_type: &return_type,
args: &args,
is_root,
is_subscription,
};
let had_resolver = field.resolve.is_some();
let base = field
.resolve
.take()
.unwrap_or_else(|| property_resolver(field.name.clone()));
let mut resolve = Arc::clone(&base);
for plugin in plugins.iter().rev() {
resolve = plugin.wrap_resolve(&meta, resolve);
}
if had_resolver || !Arc::ptr_eq(&resolve, &base) {
field.resolve = Some(resolve);
}
if let Some(mut subscribe) = field.subscribe.take() {
for plugin in plugins.iter().rev() {
subscribe = plugin.wrap_subscribe(&meta, subscribe);
}
field.subscribe = Some(subscribe);
}
}
#[derive(Clone, Copy, Debug)]
pub struct TraceEvent<'a> {
pub phase: TracePhase,
pub type_name: &'a str,
pub field_name: &'a str,
pub return_type: &'a TypeRef,
pub is_root: bool,
pub is_subscription: bool,
pub elapsed: Option<Duration>,
pub failed: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TracePhase {
Start,
Finish,
}
pub struct TracingPlugin {
observer: Arc<dyn Fn(&TraceEvent<'_>) + Send + Sync>,
}
impl TracingPlugin {
pub fn new(observer: impl Fn(&TraceEvent<'_>) + Send + Sync + 'static) -> Self {
Self {
observer: Arc::new(observer),
}
}
#[must_use]
pub fn stderr() -> Self {
Self::new(|event| match event.phase {
TracePhase::Start => eprintln!(
"graphql start {}.{} ({})",
event.type_name, event.field_name, event.return_type
),
TracePhase::Finish => eprintln!(
"graphql finish {}.{} in {:?}{}",
event.type_name,
event.field_name,
event.elapsed.unwrap_or_default(),
if event.failed { " (error)" } else { "" }
),
})
}
}
impl<Ctx: 'static> Plugin<Ctx> for TracingPlugin {
fn wrap_resolve(&self, meta: &FieldMeta<'_>, next: gql::ResolveFn) -> gql::ResolveFn {
let observer = Arc::clone(&self.observer);
let type_name: Arc<str> = Arc::from(meta.type_name);
let field_name: Arc<str> = Arc::from(meta.field_name);
let return_type = meta.return_type.clone();
let is_root = meta.is_root;
let is_subscription = meta.is_subscription;
Arc::new(move |context| {
let next = Arc::clone(&next);
let observer = Arc::clone(&observer);
let type_name = Arc::clone(&type_name);
let field_name = Arc::clone(&field_name);
let return_type = return_type.clone();
Box::pin(async move {
observer(&TraceEvent {
phase: TracePhase::Start,
type_name: &type_name,
field_name: &field_name,
return_type: &return_type,
is_root,
is_subscription,
elapsed: None,
failed: false,
});
let started = Instant::now();
let result = next(context).await;
observer(&TraceEvent {
phase: TracePhase::Finish,
type_name: &type_name,
field_name: &field_name,
return_type: &return_type,
is_root,
is_subscription,
elapsed: Some(started.elapsed()),
failed: result.is_err(),
});
result
})
})
}
fn wrap_subscribe(&self, meta: &FieldMeta<'_>, next: gql::SubscribeFn) -> gql::SubscribeFn {
let observer = Arc::clone(&self.observer);
let type_name: Arc<str> = Arc::from(meta.type_name);
let field_name: Arc<str> = Arc::from(meta.field_name);
let return_type = meta.return_type.clone();
let is_root = meta.is_root;
let is_subscription = meta.is_subscription;
Arc::new(move |context| {
let next = Arc::clone(&next);
let observer = Arc::clone(&observer);
let type_name = Arc::clone(&type_name);
let field_name = Arc::clone(&field_name);
let return_type = return_type.clone();
Box::pin(async move {
observer(&TraceEvent {
phase: TracePhase::Start,
type_name: &type_name,
field_name: &field_name,
return_type: &return_type,
is_root,
is_subscription,
elapsed: None,
failed: false,
});
let started = Instant::now();
let result = next(context).await;
observer(&TraceEvent {
phase: TracePhase::Finish,
type_name: &type_name,
field_name: &field_name,
return_type: &return_type,
is_root,
is_subscription,
elapsed: Some(started.elapsed()),
failed: result.is_err(),
});
result
})
})
}
fn configure(&self, _builder: &mut gql::SchemaBuilder) {}
}
impl std::fmt::Debug for TracingPlugin {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TracingPlugin").finish_non_exhaustive()
}
}
#[derive(Clone, Debug)]
pub struct ResponseExtensionPlugin {
key: Arc<str>,
value: gql::Value,
root_only: bool,
}
impl ResponseExtensionPlugin {
pub fn new(key: impl Into<Arc<str>>, value: impl Into<gql::Value>) -> Self {
Self {
key: key.into(),
value: value.into(),
root_only: false,
}
}
#[must_use]
pub fn root_only(mut self) -> Self {
self.root_only = true;
self
}
}
impl<Ctx: 'static> Plugin<Ctx> for ResponseExtensionPlugin {
fn wrap_resolve(&self, meta: &FieldMeta<'_>, next: gql::ResolveFn) -> gql::ResolveFn {
if self.root_only && !meta.is_root {
return next;
}
let key = Arc::clone(&self.key);
let value = self.value.clone();
Arc::new(move |context| {
context
.context
.set_extension(Arc::clone(&key), value.clone());
next(context)
})
}
}
#[derive(Clone, Debug, Default)]
pub struct MockPlugin {
mocks: IndexMap<(String, String), gql::Value>,
}
impl MockPlugin {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn mock(
mut self,
type_name: impl Into<String>,
field_name: impl Into<String>,
value: impl Into<gql::Value>,
) -> Self {
self.mocks
.insert((type_name.into(), field_name.into()), value.into());
self
}
#[must_use]
pub fn mock_path(self, path: &str, value: impl Into<gql::Value>) -> Self {
match path.split_once('.') {
Some((type_name, field_name)) => self.mock(type_name, field_name, value),
None => self,
}
}
}
impl<Ctx: 'static> Plugin<Ctx> for MockPlugin {
fn wrap_resolve(&self, meta: &FieldMeta<'_>, next: gql::ResolveFn) -> gql::ResolveFn {
if let Some(value) = self
.mocks
.get(&(meta.type_name.to_owned(), meta.field_name.to_owned()))
{
let value = value.clone();
return Arc::new(move |_context| {
let value = value.clone();
Box::pin(async move { Ok(value) })
});
}
next
}
}