Struct RestApiTableShell 

pub struct RestApiTableShell { /* private fields */ }

The TableShell behind a REST-backed Vista: an erased Table<RestApi, EmptyEntity> plus the metadata, capabilities and YAML references the factory harvested. Built by RestApiVistaFactory; callers drive it through the Vista it is wrapped in.

Trait Implementations

impl Clone for RestApiTableShell

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl TableShell for RestApiTableShell

fn fetch_window_counted<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, offset: usize, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(Vec<(String, Record<CborValue>)>, Option<i64>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

A REST envelope reports total_key on every reply, so the window fetch already knows the grand total — handing it back here is what lets a grid size its scrollbar without a second limit=1 request.

fn add_order(&mut self, field: &str, dir: SortDirection) -> Result<()>

Replace-semantics: one sort at a time, rendered as the API’s ordering query param. Only reachable when the datasource declared one (can_order), since Vista::add_order gates on the column flag.

fn clone_shell(&self) -> Option<Box<dyn TableShell>>

Cheap: the RestApi behind the table shares its HTTP client, and the copy owns only query state (conditions, order), which is what a per-view ordered fetch narrows.

fn preview_query(&self, _vista: &Vista) -> Value

The HTTP GET a read would issue — path template filled in, conditions lowered to query params, pagination applied.

fn columns(&self) -> &IndexMap<String, VistaColumn>

fn references(&self) -> &IndexMap<String, VistaReference>

fn id_column(&self) -> Option<&str>

fn list_vista_values<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<String, Record<CborValue>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_vista_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _vista: &'life1 Vista, id: &'life2 String, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<CborValue>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_vista_some_value<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Record<CborValue>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_vista_count<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Default impl falls back to list_vista_values — drivers with native count (SELECT COUNT(*), etc.) override.

fn fetch_window<'life0, 'life1, 'async_trait>( &'life0 self, vista: &'life1 Vista, offset: usize, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Record<CborValue>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch the half-open row window [offset, offset + limit) in the source’s natural order. Offset-style like fetch_page but addressed by absolute row index rather than page number, so it maps directly onto a diorama on_load_chunk Range<usize> — which is not guaranteed page-aligned. This is the primitive a paged, lazily-loaded grid drives on scroll.

fn add_eq_condition(&mut self, field: &str, value: &CborValue) -> Result<()>

Translate field == value into the driver’s native condition type and apply it to the wrapped table. The default impl returns Unimplemented — every driver is expected to override.

fn get_ref(&self, relation: &str, row: &Record<CborValue>) -> Result<Vista>

Resolve a same-persistence relation using a known source row, returning the related table as a new Vista.

fn get_ref_target(&self, relation: &str) -> Result<Vista>

Build the bare target of a same-persistence relation as a Vista — the table a new related row would be inserted into, with no join condition applied. Used by Vista’s nested insert to reach a has-one / has-many child’s destination.

fn capabilities(&self) -> &VistaCapabilities

fn clear_orders(&mut self) -> Result<()>

Wipe every order clause. Default mirrors add_order.

fn driver_name(&self) -> &'static str

Short human label for the underlying driver (e.g. "csv", "sqlite", "postgres", "mongodb"). Used for diagnostics and CLI output. Drivers should override; the default is a placeholder.

fn get_vista_value_with_row<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, vista: &'life1 Vista, id: &'life2 String, _row: &'life3 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<Value>>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Fetch one record by id, with the caller’s existing (cheap) record available to drivers that can use it (e.g. a cmd detail script reading list-pass columns). The default ignores row and delegates to get_vista_value; only drivers that benefit override it.

fn stream_vista_values<'a>( &'a self, vista: &'a Vista, ) -> Pin<Box<dyn Stream<Item = Result<(String, Record<Value>), VantageError>> + Send + 'a>>

where Self: Sync,

Default implementation wraps list_vista_values. Drivers with native streaming (cursor-based queries, paginated REST APIs) override.

fn insert_vista_value<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _id: &'life2 String, _record: &'life3 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Value>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Every write method follows the write contract on vantage_dataset::WritableValueSet over this shell’s own narrowing: confined, idempotent, invariant-filling. A shell that implements them must advertise can_confine_writes; one that can’t confine leaves it false and Vista refuses narrowed writes.

fn replace_vista_value<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _id: &'life2 String, _record: &'life3 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Value>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Replace: a row in the set is replaced, a missing one created, both conformed to the set; an id held outside the set is Conflict.

fn upsert_vista_value<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, vista: &'life1 Vista, id: &'life2 String, record: &'life3 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Value>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Insert row id, or replace it if it exists. The default replaces and falls back to insert on NotFound; stores with a native upsert override it.

fn patch_vista_value<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _id: &'life2 String, _partial: &'life3 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<Record<Value>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Patch: applied to a row in the set; a row outside the set or missing is NotFound; a result that leaves the set is Conflict.

fn delete_vista_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _id: &'life2 String, ) -> Pin<Box<dyn Future<Output = Result<(), VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Delete: removes the row only when it is in the set; Ok(()) whether it was in the set, outside it, or missing.

fn delete_vista_all_values<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<(), VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Delete all: removes exactly the rows in the set.

fn insert_vista_return_id_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _record: &'life2 Record<Value>, ) -> Pin<Box<dyn Future<Output = Result<String, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Insert with a backend-made id: the record is conformed to the set like insert. Not retry-safe — a retry makes a second row.

fn import_vista_values<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _records: &'life2 IndexMap<String, Record<Value>>, ) -> Pin<Box<dyn Future<Output = Result<usize, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Store records (id → record) in one driver-native operation — SQL COPY, Surreal batch insert — and return how many were newly inserted. An id the table already held counts zero, whether the driver’s batch skips it or upserts it: the number travels to a user as “n records created”, and the per-record fallback in Dio::import_values counts the same way. A driver that cannot tell new from existing must not advertise can_import.

fn aggregate_vista( &self, _vista: &Vista, _spec: &AggregateSpec, ) -> Result<Option<Vista>, VantageError>

Derive a new vista that reduces this one — the driver’s equivalent of selecting from a subquery.

fn add_op_condition( &mut self, field: &str, op: FilterOp, value: &Value, ) -> Result<(), VantageError>

Translate field <op> value into the driver’s native condition and apply it. The default routes Eq to add_eq_condition (so every driver gets equality for free) and returns Unimplemented for every richer operator. Drivers whose query language expresses the operators (SQL, SurrealDB) override this and advertise can_filter_operators; consumers that see false skip the call and filter locally instead.

fn add_raw_condition( &mut self, _condition: Box<dyn Any + Sync + Send>, ) -> Result<(), VantageError>

Push a driver-native condition into the wrapped table. The caller boxes the condition as dyn Any and the driver downcasts to its own T::Condition. Used by YAML-driven relation traversal, where the factory constructs a DeferredFn-bearing condition outside the value-set surface (which only accepts scalar eq) and pushes it through this channel. Default is Unimplemented.

fn set_page_size(&mut self, _size: usize) -> Result<(), VantageError>

Declare how many records constitute one page. Used by both fetch_page and fetch_next. Default returns default_error("set_page_size", "can_set_page_size").

fn fetch_page<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _page: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Record<Value>)>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Fetch a specific page (1-based) using offset-style pagination. The per-page count comes from the most recent set_page_size.

fn fetch_next<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _token: Option<Value>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<(String, Record<Value>)>, Option<Value>), VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Cursor-style chain fetch. Pass None on the first call; pass the previous call’s returned token on subsequent calls. Returned token is None when the result set is exhausted.

fn add_search(&mut self, _text: &str) -> Result<(), VantageError>

Apply a quicksearch filter — a single string the driver fans out across the columns it considers searchable (typically those flagged SEARCHABLE, but each driver decides).

fn clear_search(&mut self) -> Result<(), VantageError>

Drop the search filter previously applied via add_search. Default mirrors add_search.

fn contained(&self) -> &IndexMap<String, ContainedSpec>

Contained (embedded-in-row) relations this shell exposes, keyed by name. Default empty — only shells that model embedded objects/arrays override.

fn get_contained_ref( &self, relation: &str, _row: &Record<Value>, ) -> Result<Vista, VantageError>

Resolve a contained relation against a known parent row, returning the embedded records as a sub-Vista. Writes to that sub-Vista patch the host column of row’s record back through the shell. Default returns Unimplemented; shells override to seed crate::build_contained_vista with a writeback that patches the parent.

fn get_ref_kinds(&self) -> Vec<(String, ReferenceKind)>

Names + cardinalities of the shell’s same-persistence references. Derived from references by default; impls should rarely need to override.

fn watch_vista<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<VistaChange, VantageError>> + Send>>, VantageError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Subscribe to changes on the set and stream them as VistaChanges.

fn capability_flag(&self, name: &str) -> bool

Look up a capability flag by name. Used by default_error to decide between Unsupported and Unimplemented. Drivers don’t normally need to override this.

fn default_error(&self, method: &str, capability: &str) -> VantageError

Build the standard error returned by default trait method impls.