Struct trustfall_core::schema::SchemaAdapter

pub struct SchemaAdapter<'a> { /* private fields */ }

A Trustfall adapter for querying Trustfall schemas.

The schema matching this adapter is in the adjacent schema.graphql file, and is also available via the SchemaAdapter::schema_text() function.

Example

Create the adapter for querying a given schema like so:

let schema_text = include_str!("./schema.graphql");
let schema = Schema::parse(schema_text).expect("not a valid schema");

// Create an adapter that queries
// the schema in the local `schema.graphql` file.
let adapter = SchemaAdapter::new(&schema);

// Run queries using the adapter, etc.

Then you can query the contents of that schema. For example, the following query asks for all vertex properties and their types:

query {
    VertexType {
        name @output

        property {
            property_name: name @output
            property_type: type @output
        }
    }
}

Implementations

impl<'a> SchemaAdapter<'a>

pub fn new(schema_to_query: &'a Schema) -> Self

Make an adapter for querying the given Trustfall schema.

pub fn schema_text() -> &'static str

A schema that describes Trustfall schemas.

Queries on this adapter must conform to this schema.

Trait Implementations

impl<'a> Adapter<'a> for SchemaAdapter<'a>

type Vertex = SchemaVertex<'a>

The type of vertices in the dataset this adapter queries. Unless your intended vertex type is cheap to clone, consider wrapping it an Rc or Arc to make cloning it cheaper since that’s a fairly common operation when queries are evaluated.

fn resolve_starting_vertices( &self, edge_name: &Arc<str>, _parameters: &EdgeParameters, resolve_info: &ResolveInfo ) -> VertexIterator<'a, Self::Vertex>

Produce an iterator of vertices for the specified starting edge.

fn resolve_property<V: AsVertex<Self::Vertex> + 'a>( &self, contexts: ContextIterator<'a, V>, type_name: &Arc<str>, property_name: &Arc<str>, _resolve_info: &ResolveInfo ) -> ContextOutcomeIterator<'a, V, FieldValue>

Resolve a property required by the query that’s being evaluated.

fn resolve_neighbors<V: AsVertex<Self::Vertex> + 'a>( &self, contexts: ContextIterator<'a, V>, type_name: &Arc<str>, edge_name: &Arc<str>, _parameters: &EdgeParameters, resolve_info: &ResolveEdgeInfo ) -> ContextOutcomeIterator<'a, V, VertexIterator<'a, Self::Vertex>>

Resolve the neighboring vertices across an edge.

fn resolve_coercion<V: AsVertex<Self::Vertex> + 'a>( &self, contexts: ContextIterator<'a, V>, type_name: &Arc<str>, coerce_to_type: &Arc<str>, resolve_info: &ResolveInfo ) -> ContextOutcomeIterator<'a, V, bool>

Attempt to coerce vertices to a subtype, as required by the query that’s being evaluated.

impl<'a> Debug for SchemaAdapter<'a>

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

Formats the value using the given formatter.