Struct async_graphql::context::QueryPathNode

pub struct QueryPathNode<'a> {
    pub parent: Option<&'a QueryPathNode<'a>>,
    pub segment: QueryPathSegment<'a>,
}

A path to the current query.

The path is stored as a kind of reverse linked list.

Fields

parent: Option<&'a QueryPathNode<'a>>

The parent node to this, if there is one.

segment: QueryPathSegment<'a>

The current path segment being resolved.

Implementations

impl<'a> QueryPathNode<'a>

pub fn field_name(&self) -> &str

Get the current field name.

This traverses all the parents of the node until it finds one that is a field name.

Examples found in repository

src/extensions/apollo_tracing.rs (line 110)

    async fn resolve(
        &self,
        ctx: &ExtensionContext<'_>,
        info: ResolveInfo<'_>,
        next: NextResolve<'_>,
    ) -> ServerResult<Option<Value>> {
        let path = info.path_node.to_string_vec();
        let field_name = info.path_node.field_name().to_string();
        let parent_type = info.parent_type.to_string();
        let return_type = info.return_type.to_string();
        let start_time = Utc::now();
        let start_offset = (start_time - self.inner.lock().await.start_time)
            .num_nanoseconds()
            .unwrap();

        let res = next.run(ctx, info).await;
        let end_time = Utc::now();

        self.inner.lock().await.resolves.push(ResolveState {
            path,
            field_name,
            parent_type,
            return_type,
            start_time,
            end_time,
            start_offset,
        });
        res
    }

pub fn to_string_vec(self) -> Vec<String>

Get the path represented by Vec<String>; numbers will be stringified.

Examples found in repository

src/extensions/apollo_tracing.rs (line 109)

    async fn resolve(
        &self,
        ctx: &ExtensionContext<'_>,
        info: ResolveInfo<'_>,
        next: NextResolve<'_>,
    ) -> ServerResult<Option<Value>> {
        let path = info.path_node.to_string_vec();
        let field_name = info.path_node.field_name().to_string();
        let parent_type = info.parent_type.to_string();
        let return_type = info.return_type.to_string();
        let start_time = Utc::now();
        let start_offset = (start_time - self.inner.lock().await.start_time)
            .num_nanoseconds()
            .unwrap();

        let res = next.run(ctx, info).await;
        let end_time = Utc::now();

        self.inner.lock().await.resolves.push(ResolveState {
            path,
            field_name,
            parent_type,
            return_type,
            start_time,
            end_time,
            start_offset,
        });
        res
    }

pub fn parents(&self) -> Parents<'_>

Iterate over the parents of the node.

Examples found in repository

src/context.rs (line 153)

    pub fn field_name(&self) -> &str {
        std::iter::once(self)
            .chain(self.parents())
            .find_map(|node| match node.segment {
                QueryPathSegment::Name(name) => Some(name),
                QueryPathSegment::Index(_) => None,
            })
            .unwrap()
    }

Trait Implementations

impl<'a> Clone for QueryPathNode<'a>

fn clone(&self) -> QueryPathNode<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for QueryPathNode<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Display for QueryPathNode<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Serialize for QueryPathNode<'a>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'a> Copy for QueryPathNode<'a>