welds 0.4.23

An async ORM for (postgres, mssql, mysql, sqlite)
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use super::types::{Index, OnDelete, Type};
use crate::Syntax;
use crate::migrations::MigrationWriter;
use crate::migrations::writers;
use crate::model_traits::TableIdent;

impl MigrationWriter for TableBuilder {
    fn down_sql(&self, syntax: Syntax) -> Vec<String> {
        let table = &self.ident;
        vec![writers::drop_table(syntax, table)]
    }

    fn up_sql(&self, syntax: Syntax) -> Vec<String> {
        writers::create_table::from_builder(syntax, self)
    }
}

/// Builds a new migration used to create a table
/// This migration can be passed to `migrations::up` to update your database
/// ```
/// use welds::errors::Result;
/// use welds::migrations::{create_table, types::Type, MigrationStep, TableState};
///
/// fn create_dog_table(_state: &TableState) -> Result<MigrationStep> {
///     let m = create_table("dogs")
///         .id(|c| c("id", Type::Uuid))
///         .column(|c| c("name", Type::String))
///         .column(|c| c("age", Type::Int).is_null());
///     // us what every naming convention you like to unique identify each of your migrations
///     Ok(MigrationStep::new("m20250126153703_create_table_dogs", m))
/// }
/// ```
///
pub fn create_table(name: impl Into<String>) -> TableBuilder {
    let name: String = name.into();
    let ident = TableIdent::parse(&name);
    TableBuilder {
        ident,
        pk: IdBuilder::default(),
        columns: Vec::default(),
    }
}

pub struct TableBuilder {
    pub(crate) ident: TableIdent,
    pub(crate) pk: IdBuilder,
    pub(crate) columns: Vec<ColumnBuilder>,
}

type ColumnLambda = fn(&str, Type) -> ColumnBuilder;
type TableLambda = fn(&str, Type) -> IdBuilder;

impl TableBuilder {
    /// Set the name and type of the primary_key column for the table.
    pub fn id(mut self, lam: fn(TableLambda) -> IdBuilder) -> Self {
        let builder = |name: &str, ty: Type| -> IdBuilder {
            IdBuilder {
                name: name.to_string(),
                ty,
            }
        };
        let col = lam(builder);
        self.pk = col;
        self
    }

    /// Add a column to the table
    pub fn column(mut self, lam: fn(ColumnLambda) -> ColumnBuilder) -> Self {
        let builder = |name: &str, ty: Type| -> ColumnBuilder {
            ColumnBuilder {
                name: name.to_string(),
                ty,
                nullable: false,
                index: None,
                index_name: None,
            }
        };
        let col = lam(builder);
        self.columns.push(col);
        self
    }
}

pub struct ColumnBuilder {
    pub(crate) name: String,
    pub(crate) ty: Type,
    pub(crate) nullable: bool,
    pub(crate) index: Option<Index>,
    pub(crate) index_name: Option<String>,
}

impl ColumnBuilder {
    /// Sets this column to be nullable when creating it in the database
    pub fn is_null(mut self) -> Self {
        self.nullable = true;
        self
    }

    /// Create an index for this column in the database with a given name
    pub fn with_index_name(mut self, name: impl Into<String>) -> Self {
        let name: String = name.into();
        self.index_name = Some(name);
        if self.index.is_none() {
            self.index = Some(Index::Default);
        }
        self
    }

    /// Create an index for this column in the database.
    pub fn create_index(mut self) -> Self {
        self.index = Some(Index::Default);
        self
    }

    /// Create an unique constraint for this column when creating it in the databse
    pub fn create_unique_index(mut self) -> Self {
        self.index = Some(Index::Unique);
        self
    }

    /// Automatically Add a foreign key to this column when creating it in the database
    pub fn create_foreign_key(
        mut self,
        table: impl Into<String>,
        column: impl Into<String>,
        on_delete: OnDelete,
    ) -> Self {
        self.index = Some(Index::ForeignKey((table.into(), column.into(), on_delete)));
        self
    }
}

pub struct IdBuilder {
    pub(crate) name: String,
    pub(crate) ty: Type,
}

impl Default for IdBuilder {
    fn default() -> Self {
        Self {
            name: "id".to_string(),
            ty: Type::Int,
        }
    }
}

#[cfg(test)]
mod tests;