toasty-core 0.10.0

Core types, schema representations, and driver interface for Toasty
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Schema representation for Toasty, split into three layers.
//!
//! - [`app`] -- Model-level definitions: fields, relations, constraints. This
//!   is what the generated Rust code sees.
//! - [`db`] -- Table/column-level definitions. This is what the database sees.
//! - [`mapping`] -- Connects app fields to database columns, supporting
//!   non-1:1 mappings such as embedded structs and enums.
//!
//! The top-level [`Schema`] struct ties all three layers together and is
//! constructed via [`Builder`].
//!
//! # Examples
//!
//! ```ignore
//! use toasty_core::schema::{Schema, Builder};
//!
//! let schema = Builder::new()
//!     .build(app_schema, &driver_capability)
//!     .expect("schema should be valid");
//!
//! // Look up the database table backing a model
//! let table = schema.table_for(model_id);
//! ```

/// Application-level (model-oriented) schema definitions.
pub mod app;

mod builder;
pub use builder::Builder;

/// Database-level (table/column-oriented) schema definitions.
pub mod db;

/// Schema-diff types: compare two schema versions and produce structural changes.
pub mod diff;

/// Mapping between the app layer and the database layer.
pub mod mapping;
use mapping::Mapping;

mod name;
pub use name::Name;

mod verify;

use crate::Result;
use app::ModelId;
use db::{Table, TableId};

/// The combined schema: app-level models, database-level tables, and the
/// mapping that connects them.
///
/// Constructed with [`Builder`] and validated on creation. Immutable at runtime.
///
/// # Examples
///
/// ```ignore
/// use toasty_core::Schema;
///
/// fn inspect(schema: &Schema) {
///     for (id, model) in &schema.app.models {
///         let table = schema.table_for(*id);
///         println!("{} -> {}", model.name().snake_case(), table.name);
///     }
/// }
/// ```
#[derive(Debug)]
pub struct Schema {
    /// Application-level schema.
    pub app: app::Schema,

    /// Database-level schema.
    pub db: db::Schema,

    /// Maps the app-level schema to the db-level schema.
    pub mapping: Mapping,
}

impl Schema {
    /// Returns the mapping for the given model.
    ///
    /// # Panics
    ///
    /// Panics if `id` does not correspond to a model in the schema.
    ///
    /// # Examples
    ///
    /// ```ignore
    /// use toasty_core::Schema;
    ///
    /// let mapping = schema.mapping_for(model_id);
    /// println!("table: {:?}", mapping.table);
    /// ```
    pub fn mapping_for(&self, id: impl Into<ModelId>) -> &mapping::Model {
        self.mapping.model(id)
    }

    /// Returns the database table that stores the given model.
    ///
    /// # Panics
    ///
    /// Panics if `id` does not correspond to a model in the schema.
    ///
    /// # Examples
    ///
    /// ```ignore
    /// let table = schema.table_for(model_id);
    /// println!("table name: {}", table.name);
    /// ```
    pub fn table_for(&self, id: impl Into<ModelId>) -> &Table {
        self.db.table(self.table_id_for(id))
    }

    /// Returns the [`TableId`] for the table that stores the given model.
    ///
    /// # Panics
    ///
    /// Panics if `id` does not correspond to a model in the schema.
    pub fn table_id_for(&self, id: impl Into<ModelId>) -> TableId {
        self.mapping.model(id).table
    }
}