rok-sqlc 0.1.0

Generate SQLx Rust database modules from SQL schema files
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

//! Conventions (ADR 0010): the configured column names, applied to the
//! tables being generated before any renderer runs.
//!
//! A convention is recorded on the schema model, so renderers ask a column
//! or table what it is (`Column::is_managed`, `Table::soft_delete_column`,
//! `Table::tenant_column`) instead of each taking the configuration. Only the tables generated in a
//! run are annotated; query files never see conventions.

use crate::Conventions;
use crate::schema::{Column, Table};

/// The search filter's switch for soft-deleted rows.
pub const INCLUDE_DELETED: &str = "include_deleted";

/// Marks, in each of `tables`, the columns `conventions` names.
///
/// The version column is recorded on the tables that have it, and is always
/// managed: the database advances it, so callers never write it.
pub fn apply(tables: &mut [Table], conventions: &Conventions) {
    let version = conventions.version_column.as_deref();
    for table in tables {
        table.version_column = version
            .filter(|name| table.columns.iter().any(|column| column.sql_name == *name))
            .map(str::to_owned);
        for column in &mut table.columns {
            column.is_managed = conventions.managed_columns.contains(&column.sql_name)
                || Some(column.sql_name.as_str()) == version;
        }
        let present = |name: &Option<String>| {
            name.as_ref()
                .filter(|name| table.columns.iter().any(|column| column.sql_name == **name))
                .cloned()
        };
        let soft_delete_column = present(&conventions.soft_delete_column);
        let tenant_column = present(&conventions.tenant_column);
        table.soft_delete_column = soft_delete_column;
        table.tenant_column = tenant_column;
    }
}

/// Checks that each of `tables` can follow `conventions`: a soft-delete
/// column must be a nullable `TIMESTAMP` or `TIMESTAMPTZ`, and no column may
/// collide with the `include_deleted` switch it adds to the search filter.
/// Returns the first problem, naming the table and column.
pub fn check(tables: &[Table], conventions: &Conventions) -> Result<(), String> {
    let Some(name) = conventions.soft_delete_column.as_deref() else {
        return Ok(());
    };
    for table in tables {
        let Some(column) = table.columns.iter().find(|column| column.sql_name == name) else {
            continue;
        };
        let subject = format!(
            "soft-delete column `{}` of `{}`",
            column.sql_name,
            table.display_name()
        );
        if !is_timestamp(column) {
            return Err(format!(
                "{subject} must be a nullable TIMESTAMP or TIMESTAMPTZ, but its type maps to `{}`",
                column.sqlx_type
            ));
        }
        if !column.nullable {
            return Err(format!(
                "{subject} must be a nullable TIMESTAMP or TIMESTAMPTZ, but it is NOT NULL"
            ));
        }
        let collision = table
            .columns
            .iter()
            .find(|other| other.rust_name == INCLUDE_DELETED);
        if let Some(other) = collision {
            return Err(format!(
                "column `{}` of `{}` collides with the search filter's `{INCLUDE_DELETED}` switch, which the {subject} adds",
                other.sql_name,
                table.display_name()
            ));
        }
    }
    Ok(())
}

fn is_timestamp(column: &Column) -> bool {
    column.base_type().is_timestamp()
}