Struct NameOverrides 

pub struct NameOverrides { /* private fields */ }

Every name given, keyed by schema.table.

Implementations

impl NameOverrides

pub fn parse(value: &str) -> Result<Self, String>

Read from JSON: either the document itself, or a path to a file holding it.

Told apart by the first non-space character, because a JSON object cannot begin with anything but { and a path cannot begin with it. Both spellings exist because both places are natural: a handful of names belongs in the environment beside every other setting, and a migrated schema’s worth of them belongs in a file under review.

pub fn is_empty(&self) -> bool

Whether any name was given at all.

pub fn exposed_as(&self, schema: &str, function: &str) -> Option<&str>

Which root a function was placed on, if metadata said.

query or mutation. Reflection places a function by its volatility, which is the only thing the catalogue records; Hasura lets metadata override it – track_function with configuration: {exposed_as: query} puts a VOLATILE function on the query root, which is a thing a person decided and no schema remembers.

pub fn function_grants(&self, schema: &str, function: &str, role: &str) -> bool

Whether a role was granted this function by a function permission.

Only asked of a function exposed as a mutation – see FunctionNames for why the query side is inferred instead.

pub fn declared_relationships( &self, schema: &str, table: &str, ) -> Option<&[DeclaredRelationship]>

The relationships metadata declares for a table, where it declares any.

pub fn len(&self) -> usize

How many tables were named, for the line the server logs at startup.

pub fn placed_functions(&self) -> usize

How many functions were placed, for the same line.

pub fn permissions( &self, schema: &str, table: &str, role: &str, ) -> Option<&RolePermissions>

What one role may do with one table.

None means the role was named nothing about this table, which is not the same as being named an empty permission: the first has no access, the second has access to nothing. Both refuse, and only the second is a decision someone wrote down.

pub fn tables_with_permissions<'a>( &'a self, role: &'a str, ) -> impl Iterator<Item = &'a RolePermissions> + 'a

What one role was granted, across every table that grants it anything.

pub fn introspection_disabled(&self, role: &str) -> bool

Whether this role may read the schema as data.

__typename is not this question: it names the type of a row a client is already reading, every client library sends it, and Hasura answers it for a role introspection is disabled for. __schema and __type are the two that read the schema itself.

pub fn has_permissions(&self) -> bool

Whether the document says anything about permissions at all.

The switch for the whole layer. A document carrying only names leaves the server as it was: database roles and row level security, with nothing above them. One permission anywhere turns the layer on for every table, because a document that grants user a filtered view of article and says nothing about author is saying user cannot read author – not that author is open to everyone.

pub fn roles(&self) -> Vec<&str>

Every role the document names, sorted.

Sorted because a schema is built per role and the order they are built in should not depend on how a hash map felt. admin is not among them unless a permission names it: an administrator is not a role with permissions but a caller the permissions do not apply to.

pub fn granted(&self) -> usize

How many table-and-role pairs were granted something, for the line the server logs at startup.

pub fn is_enum(&self, schema: &str, table: &str) -> bool

Whether a table was marked as a set of allowed values.

pub fn enum_tables(&self) -> Vec<(String, String)>

Every table marked as one, as (schema, table).

pub fn base_name(&self, schema: &str, table: &str) -> Option<&str>

The base name given to a table, if one was.

pub fn relationship( &self, schema: &str, table: &str, source: &str, ) -> Option<&str>

The name given to a relationship, by its constraint, column or function.

Falls back to computed_fields because Hasura has one command for both: add_computed_field covers a function returning a value and a function returning rows, and which it is cannot be told from the metadata – only from the database. A converter should not have to connect to one to put an entry in the right map, so either map answers.

pub fn root(&self, schema: &str, table: &str, kind: &str) -> Option<&str>

The name given to one root field, if one was.

kind is Hasura’s own key – select, insert_one, delete_by_pk.

pub fn column(&self, schema: &str, table: &str, column: &str) -> Option<&str>

The field a column is exposed as, if it was renamed.

pub fn column_source( &self, schema: &str, table: &str, field: &str, ) -> Option<&str>

The column behind a field name, if that name is a rename.

The other direction, which is the one every resolver needs: it is handed a field name from the request and has to write a column. None means the name is already the column’s, which is the ordinary case.

pub fn renames_columns(&self, schema: &str, table: &str) -> bool

Whether any column of this table is exposed under another name.

Worth asking before building a projection: a table with no renames keeps the SELECT * it had, and only one that has them pays for a column list.

pub fn table_comment(&self, schema: &str, table: &str) -> Option<&str>

The description given to a table’s type, if one was.

Some("") is a description that was given and is empty, which means the type has none. None means nothing was said and the database’s own comment stands.

pub fn column_comment( &self, schema: &str, table: &str, column: &str, ) -> Option<&str>

The description given to a column, by the column.

pub fn computed_comment( &self, schema: &str, table: &str, function: &str, ) -> Option<&str>

The description given to a computed field, by its function.

pub fn root_comment( &self, schema: &str, table: &str, kind: &str, ) -> Option<&str>

The description given to one root field, by its kind.

pub fn computed_field( &self, schema: &str, table: &str, function: &str, ) -> Option<&str>

The name given to a computed field, by its function.

Reads both maps, for the reason Self::relationship gives.

pub fn computed_source( &self, schema: &str, table: &str, field: &str, ) -> Option<&str>

The function behind a computed field, given the name it is exposed under.

The resolver reads the other direction: it is handed a field name from the selection and has to write the call. Searched rather than indexed because a table has a handful of computed fields, not thousands, and a second map would be one more thing to keep in step.

Trait Implementations

impl Clone for NameOverrides

fn clone(&self) -> NameOverrides

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NameOverrides

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

Formats the value using the given formatter.

impl Default for NameOverrides

fn default() -> NameOverrides

Returns the “default value” for a type.

impl PartialEq for NameOverrides

fn eq(&self, other: &NameOverrides) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for NameOverrides