Struct teo_runtime::model::model::Model

pub struct Model {

    pub path: Vec<String>,
    pub parser_path: Vec<usize>,
    pub comment: Option<Comment>,
    pub table_name: String,
    pub actions: Vec<Action>,
    pub generate_client: bool,
    pub generate_entity: bool,
    pub show_in_studio: bool,
    pub synthesize_shapes: bool,
    pub fields: IndexMap<String, Field>,
    pub relations: IndexMap<String, Relation>,
    pub properties: IndexMap<String, Property>,
    pub indexes: IndexMap<String, Index>,
    pub primary_index: String,
    pub before_save: Pipeline,
    pub after_save: Pipeline,
    pub before_delete: Pipeline,
    pub after_delete: Pipeline,
    pub can_read: Pipeline,
    pub can_mutate: Pipeline,
    pub migration: Migration,
    pub data: BTreeMap<String, Object>,
    pub cache: Cache,
    pub builtin_handlers: Vec<Action>,
}

Fields

path: Vec<String>

parser_path: Vec<usize>

comment: Option<Comment>

table_name: String

actions: Vec<Action>

generate_client: bool

generate_entity: bool

show_in_studio: bool

synthesize_shapes: bool

fields: IndexMap<String, Field>

relations: IndexMap<String, Relation>

properties: IndexMap<String, Property>

indexes: IndexMap<String, Index>

primary_index: String

before_save: Pipeline

after_save: Pipeline

before_delete: Pipeline

after_delete: Pipeline

can_read: Pipeline

can_mutate: Pipeline

migration: Migration

data: BTreeMap<String, Object>

cache: Cache

builtin_handlers: Vec<Action>

Implementations

impl Model

pub fn new() -> Self

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

pub fn table_name(&self) -> &str

pub fn field(&self, name: &str) -> Option<&Field>

pub fn dropped_field(&self, name: &str) -> Option<&Field>

pub fn relation(&self, name: &str) -> Option<&Relation>

pub fn property(&self, name: &str) -> Option<&Property>

pub fn field_with_column_name(&self, name: &str) -> Option<&Field>

pub fn property_with_column_name(&self, name: &str) -> Option<&Property>

pub fn indexes(&self) -> Vec<&Index>

pub fn fields(&self) -> Vec<&Field>

pub fn relations(&self) -> Vec<&Relation>

pub fn properties(&self) -> Vec<&Property>

pub fn collect_field_index<I>(&self, indexable: &I) -> Option<Index>

where I: Indexable,

pub fn allows_drop_when_migrate(&self) -> bool

pub fn primary_index(&self) -> Option<&Index>

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

pub fn finalize(&mut self) -> Result<()>

pub fn input_type_for_builtin_handler(&self, handler: Action) -> Type

pub fn output_type_for_builtin_handler( &self, handler: Action, namespace: &Namespace ) -> Type

Trait Implementations

impl Debug for Model

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

Formats the value using the given formatter.

impl Documentable for Model

fn comment(&self) -> Option<&Comment>

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

fn title(&self) -> String

fn title_word_case(&self) -> String

fn desc(&self) -> String

impl Named for Model

fn name(&self) -> &str

impl PartialEq for Model

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Model

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.