Struct GraphqlApi 

pub struct GraphqlApi { /* private fields */ }

GraphQL HTTP data source. Cheap to clone — the inner ResilientClient is Arc-wrapped.

dialect and filter_arg_name drive how the TableSource impl renders filter arguments — Hasura’s where: vs SpaceX-style find:, etc. Both default to the dialect’s natural choice (Generic + find).

Implementations

impl GraphqlApi

pub fn can_filter(&self) -> bool

Whether conditions may be pushed into the query. Defaults to true — most list fields take some filter argument.

pub fn can_order(&self) -> bool

Whether order_by: may be rendered. Only the Hasura dialect renders a sort, so Generic defaults to sorting client-side.

pub fn can_search(&self) -> bool

Whether a quicksearch renders as an OR of _ilikes. Same story as ordering: Hasura only. A search is a condition, so it also needs filter push-down to be on.

pub fn can_filter_operators(&self) -> bool

Whether operators richer than equality can be rendered. Generic rejects them at render time, so only Hasura qualifies.

pub fn can_paginate(&self) -> bool

Whether limit:/offset: may be rendered. Off by default: a schema that doesn’t take them turns every query into an error, and the cost of not paging is one extra round of rows.

pub fn can_page(&self) -> bool

Whether offset paging can be offered to a consumer: limit: and offset: render, and so do the conditions, so a page is not cut down by local filtering after the server has sized it.

pub fn response_path(&self) -> &[String]

Path walked into the root field’s value before rows are read — ["edges", "node"] for a Relay-style connection. Empty means the root field’s value is the row array itself.

pub fn root_args(&self) -> Option<&Value>

Literal arguments always passed to the root field.

impl GraphqlApi

pub fn new(endpoint: impl Into<String>) -> Self

Connect to a GraphQL endpoint at endpoint (e.g. https://api.spacex.land/graphql/). Uses the default reqwest client; for finer control go through GraphqlApi::builder.

pub fn builder(endpoint: impl Into<String>) -> GraphqlApiBuilder

Start configuring a GraphqlApi.

pub fn endpoint(&self) -> &str

Endpoint URL the client posts to.

pub fn dialect(&self) -> FilterDialect

Filter dialect — controls how where: / find: arguments are rendered. Defaults to FilterDialect::Generic.

pub fn breaker_state(&self) -> Option<BreakerState>

What the circuit breaker is doing right now. None when the underlying client has no breaker configured.

pub fn client(&self) -> &ResilientClient

The resilient client backing this API — the pool, breaker and observer a caller outside the read path (e.g. an outbox replaying a queued write) should share rather than build its own.

pub fn with_bearer_source(&self, source: BearerSource) -> Self

A clone whose requests carry the bearer token source gives at the moment each one goes out, in place of the configured auth. The clone shares this API’s client — connection pool, parallel cap, breaker and observer — so one clone per session costs no extra connections. See BearerSource.

The client adds an auth_refresher’s header itself, so a clone can’t withdraw it: build the shared API without a refresher when its clones bring their own tokens.

pub async fn post_graphql( &self, query: &str, variables: &Map<String, Value>, ) -> Result<Value>

Send a query document with variables. Returns the data payload from the GraphQL response, or an error if the request failed or the response carried a top-level errors array.

impl GraphqlApi

pub fn vista_factory(&self) -> GraphqlApiVistaFactory

Return a Vista factory bound to this GraphQL data source.

Trait Implementations

impl Clone for GraphqlApi

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DataSource for GraphqlApi

impl Debug for GraphqlApi

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

Formats the value using the given formatter.

impl ExprDataSource<AnyGraphqlType> for GraphqlApi

async fn execute( &self, _expr: &Expression<AnyGraphqlType>, ) -> Result<AnyGraphqlType>

fn defer(&self, expr: Expression<AnyGraphqlType>) -> DeferredFn<AnyGraphqlType>

fn associate<R>( &self, expr: Expression<T>, ) -> AssociatedExpression<'_, Self, T, R>

where Self: Sized,

Create an associated expression with type-safe return type

impl SelectableDataSource<AnyGraphqlType, GraphqlCondition> for GraphqlApi

type Select = GraphqlSelect

fn select(&self) -> Self::Select

A new, empty select query for this datasource.

fn add_select_column( &self, select: &mut Self::Select, _expression: Expression<AnyGraphqlType>, alias: Option<&str>, )

Add a column expression to a select query with optional alias. Backends must override this if they support aliases.

async fn execute_select( &self, select: &Self::Select, ) -> Result<Vec<AnyGraphqlType>>

Run a select query and return its rows.

impl TableSource for GraphqlApi

fn eq_condition(field: &str, value: &str) -> Result<Self::Condition>

Stringy field == value helper for callers that only have text on hand (CLI, generic UIs). The value lands as a JSON string.

fn eq_value_condition( &self, field: &str, value: Self::Value, ) -> Result<Self::Condition>

Typed-value sibling of eq_condition. Used by Reference::resolve_from_row to push a row-derived AnyGraphqlType join value onto a child table without a string round-trip.

fn search_table_condition<E>( &self, table: &Table<Self, E>, search_value: &str, ) -> Self::Condition

where E: Entity<Self::Value>, Self: Sized,

An OR of _ilike '%value%' over the searchable columns: those flagged searchable, or else the string-typed, non-id, undotted ones. Hasura speaks _ilike natively; Generic rejects it at render time, which is the right failure mode (search doesn’t translate to flat-arg schemas).

fn get_table_value<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, id: &'life2 Self::Id, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<Self::Value>>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Single-row fetch by id: the table’s own narrowing plus id = <id>. Without filter push-down the rows are listed and the id picked out locally.

fn get_table_count<'life0, 'life1, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Hasura counts server-side through its _aggregate field; every other schema lists the rows and counts them.

fn related_in_condition<SourceE: Entity<Self::Value> + 'static>( &self, target_field: &str, source_table: &Table<Self, SourceE>, source_column: &str, ) -> Self::Condition

where Self: Sized,

Build a child condition for with_many / with_one traversal.

Two paths, as in the REST adapter:

• Sync peek — if the parent already carries an eq-condition on source_column (the common with_many case where the source column is the parent’s id field narrowed via eq(<id>)), re-key the value onto target_field immediately so the child filter is fully concrete.
• Deferred fallback — otherwise (the with_one case where source_column is a foreign-key field that lives in the parent’s data, not its conditions), wrap resolution in a DeferredField that fetches the parent’s first row at fetch time and pulls source_column out of it.

Both paths render through FilterDialect, so Hasura schemas get { target_field: { _eq: v } } and Generic schemas get the flat { target_field: v } form.

The deferred path costs two round trips: one for the parent, one for the child. A nested selection could do it in one, but the Table trait surface has no way to express it.

fn column_table_values_expr<'a, E, Type: ColumnType>( &'a self, table: &Table<Self, E>, column: &Self::Column<Type>, ) -> AssociatedExpression<'a, Self, Self::Value, Vec<Type>>

where E: Entity<Self::Value> + 'static, Self: Sized,

Defer to a query that selects just column. Used by the Table::with_one / Table::with_many plumbing when it wants a list of values from another table (e.g. all FK ids).

At fetch time the table’s rows are listed through list_table_values and column is read from each. A Generic schema has no sub-select to push this into, so every dialect lists.

type Column<Type> = Column<Type> where Type: ColumnType

type AnyType = AnyGraphqlType

type Value = AnyGraphqlType

type Id = String

type Condition = GraphqlCondition

The condition type stored by Table. SQL/SurrealDB backends use Expression<Self::Value>; document-oriented backends like MongoDB can use a native filter type (e.g. bson::Document).

type Source = String

How this backend names its source. Most backends use String; SQL/SurrealDB backends use SelectSource<Self::Select> so a table can be sourced from an arbitrary sub-SELECT. See crate::source.

fn in_values_condition( &self, field: &str, values: Vec<Self::Value>, ) -> Result<Self::Condition>

Build a field IN (values) condition from native-typed values: the list-valued sibling of Self::eq_value_condition. Self::condition_column names field for it. An empty values matches no row. The default returns an error.

fn describe_condition(&self, condition: &Self::Condition) -> String

condition as text for people, e.g. client_id = 7: what a log entry records for a bulk delete. Not for parsing; use Self::condition_column / Self::condition_equality in code. A part resolved only at query time renders as a placeholder.

fn condition_column(&self, condition: &Self::Condition) -> Option<String>

The column condition narrows to values, for the shapes this backend can read (col = v, col IN (…), comparisons, LIKE), with a value — not a column or an arbitrary expression — on the right. None when it can’t tell — a raw expression, a combination, a negation (!=, NOT IN, NOT LIKE), col = other_col — so a check that requires a condition on some column fails safe.

fn create_column<Type: ColumnType>(&self, name: &str) -> Self::Column<Type>

Create a new column with the given name

fn to_any_column<Type: ColumnType>( &self, column: Self::Column<Type>, ) -> Self::Column<Self::AnyType>

Convert a typed column to type-erased column

fn convert_any_column<Type: ColumnType>( &self, any_column: Self::Column<Self::AnyType>, ) -> Option<Self::Column<Type>>

Attempt to convert a type-erased column back to typed column

fn expr( &self, template: impl Into<String>, parameters: Vec<ExpressiveEnum<Self::Value>>, ) -> Expression<Self::Value>

Create an expression from a template and parameters, similar to Expression::new

fn list_table_values<'life0, 'life1, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<Self::Id, Record<Self::Value>>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all data from a table as Record values with IDs (for ReadableValueSet implementation)

fn get_table_some_value<'life0, 'life1, 'async_trait, E>( &'life0 self, table: &'life1 Table<Self, E>, ) -> Pin<Box<dyn Future<Output = Result<Option<(Self::Id, Record<Self::Value>)>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get some data from a table as Record value with ID (for ReadableValueSet implementation)

fn get_table_sum<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _column: &'life2 Self::Column<Self::AnyType>, ) -> Pin<Box<dyn Future<Output = Result<Self::Value>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get sum of a column in the table (returns native value type)

fn get_table_max<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _column: &'life2 Self::Column<Self::AnyType>, ) -> Pin<Box<dyn Future<Output = Result<Self::Value>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get maximum value of a column in the table (returns native value type)

fn get_table_min<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _column: &'life2 Self::Column<Self::AnyType>, ) -> Pin<Box<dyn Future<Output = Result<Self::Value>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get minimum value of a column in the table (returns native value type)

fn insert_table_value<'life0, 'life1, 'life2, 'life3, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, _record: &'life3 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::Value>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Insert a record by ID. Confined and idempotent: when the id is already stored in table.conditions(), return the stored row unchanged; when it is held by a row outside the set, fail with Conflict; a new row must fit the conditions, else Conflict and nothing is stored. Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

fn replace_table_value<'life0, 'life1, 'life2, 'life3, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, _record: &'life3 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::Value>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Replace a record by ID, creating it when missing. Confined and idempotent: an id held by a row outside table.conditions() fails with Conflict; the written row must fit the conditions, else Conflict and nothing changes. Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

fn patch_table_value<'life0, 'life1, 'life2, 'life3, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, _partial: &'life3 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Self::Value>>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Merge partial into the row with this ID. Confined: a missing row or one outside table.conditions() is NotFound (marked); the merged row must still fit the conditions, else Conflict and nothing changes. Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

fn delete_table_value<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _id: &'life2 Self::Id, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a record by ID. Confined and idempotent: delete only when the row is in table.conditions(); a missing row or a row outside the set is Ok(()) (no lookup is needed — SQL: DELETE … WHERE id = ? AND <conditions>). Refuse with Unsupported when a condition can be neither applied nor evaluated. See WritableValueSet for the table.

fn delete_table_all_values<'life0, 'life1, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete every record the table represents (for WritableValueSet).

fn insert_table_return_id_value<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 self, _table: &'life1 Table<Self, E>, _record: &'life2 Record<Self::Value>, ) -> Pin<Box<dyn Future<Output = Result<Self::Id>> + Send + 'async_trait>>

where E: Entity<Self::Value> + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert a record under a generated ID and return it. Confined, not retry-safe: the record must fit table.conditions(), else Conflict and nothing is stored; a retry after a lost reply stores a second row. Refuse with Unsupported when a condition can be neither applied nor evaluated.

fn condition_equality( &self, condition: &Self::Condition, ) -> Option<(String, Self::Value)>

When condition is a literal column = value, return the pair.

fn can_confine_writes(&self) -> bool

Whether every by-id write (insert_table_value, replace_table_value, patch_table_value, delete_table_value, insert_table_return_id_value) honours the write contract over table.conditions(): it only touches rows in the set, and only leaves rows that still belong to it. A source that returns false is refused any by-id write through a conditioned table: Table refuses it with Unsupported before reaching the source. Default false.

fn coerce_reference_value(&self, value: Self::Value) -> Self::Value

Coerce a reference join value into the backend’s native id form.

fn stream_table_values<'a, E>( &'a self, table: &Table<Self, E>, ) -> Pin<Box<dyn Stream<Item = Result<(Self::Id, Record<Self::Value>), VantageError>> + Send + 'a>>

where E: Entity<Self::Value> + 'a, Self: Sized,

Stream all records from a table as (Id, Record) pairs.

fn related_correlated_condition( &self, target_table: &str, target_field: &str, source_table: &str, source_column: &str, ) -> Self::Condition

Build a correlated condition: target_table.target_field = source_table.source_column.

fn supports_traversal(&self) -> bool

Whether this backend can lower a dotted active column ("country.name") into its own query — a nested correlated subquery for SQL, a native idiom path for SurrealDB, $lookup stages for MongoDB. Backends that can build none of these (e.g. CSV, REST) leave the default false, and Table::with_active_columns rejects dotted names against them at build time rather than at fetch time.

fn traversal_path_expr( &self, hops: &[&str], column: &str, ) -> Option<Expression<Self::Value>>

Build a backend-native path expression for a dotted active column, tried before the generic correlated-subquery chain.