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

use super::{
    check::{Check, Column, Table},
    database_inspection_results::DatabaseInspectionResults,
};

#[derive(Debug)]
pub(crate) enum UnexecutableStepCheck {
    AddedRequiredFieldToTable(Column),
    AddedRequiredFieldToTableWithPrismaLevelDefault(Column),
    MadeOptionalFieldRequired(Column),
    MadeScalarFieldIntoArrayField(Column),
    DropAndRecreateRequiredColumn(Column),
}

impl Check for UnexecutableStepCheck {
    fn needed_table_row_count(&self) -> Option<Table> {
        match self {
            UnexecutableStepCheck::AddedRequiredFieldToTableWithPrismaLevelDefault(column)
            | UnexecutableStepCheck::MadeOptionalFieldRequired(column)
            | UnexecutableStepCheck::MadeScalarFieldIntoArrayField(column)
            | UnexecutableStepCheck::AddedRequiredFieldToTable(column)
            | UnexecutableStepCheck::DropAndRecreateRequiredColumn(column) => Some(Table::from_column(column)),
        }
    }

    fn needed_column_value_count(&self) -> Option<Column> {
        match self {
            UnexecutableStepCheck::MadeOptionalFieldRequired(column)
            | UnexecutableStepCheck::MadeScalarFieldIntoArrayField(column) => Some(column.clone()),
            UnexecutableStepCheck::AddedRequiredFieldToTable { .. }
            | UnexecutableStepCheck::AddedRequiredFieldToTableWithPrismaLevelDefault { .. }
            | UnexecutableStepCheck::DropAndRecreateRequiredColumn { .. } => None,
        }
    }

    fn evaluate<'a>(&self, database_checks: &DatabaseInspectionResults) -> Option<String> {
        match self {
            UnexecutableStepCheck::AddedRequiredFieldToTable(column) => {
                let message = |details| {
                    format!(
                        "Added the required column `{column}` to the `{table}` table without a default value. {details}",
                        table = column.table,
                        column = column.column,
                        details = details,
                    )
                };

                let message = match database_checks.get_row_count(&Table::from_column(column)) {
                    Some(0) => return None, // Adding a required column is possible if there is no data
                    Some(row_count) => message(format_args!(
                        "There are {row_count} rows in this table, it is not possible to execute this step."
                    )),
                    None => message(format_args!("This is not possible if the table is not empty.")),
                };

                Some(message)
            }
            UnexecutableStepCheck::AddedRequiredFieldToTableWithPrismaLevelDefault(column) => {
                let message = |details| {
                    format!(
                        "The required column `{column}` was added to the `{table}` table with a prisma-level default value. {details} Please add this column as optional, then populate it before making it required.",
                        table = column.table,
                        column = column.column,
                        details = details,
                    )
                };

                let message = match database_checks.get_row_count(&Table::from_column(column)) {
                    Some(0) => return None, // Adding a required column is possible if there is no data
                    Some(row_count) => message(format_args!(
                        "There are {row_count} rows in this table, it is not possible to execute this step."
                    )),
                    None => message(format_args!("This is not possible if the table is not empty.")),
                };

                Some(message)
            }
            UnexecutableStepCheck::MadeOptionalFieldRequired(column) => {
                match database_checks.get_row_and_non_null_value_count(column) {
                    (Some(0), _) => None,
                    (Some(row_count), Some(value_count)) => {
                        let null_value_count = row_count - value_count;

                        if null_value_count == 0 {
                            return None
                        }

                        Some(format!(
                            "Made the column `{column}` on table `{table}` required, but there are {null_value_count} existing NULL values.",
                            column = column.column,
                            table = column.table,
                            null_value_count = null_value_count,
                        ))
                    },
                    (_, _) => Some(format!(
                        "Made the column `{column}` on table `{table}` required. This step will fail if there are existing NULL values in that column.",
                        column = column.column,
                        table = column.table
                    )),
                }
            }
            UnexecutableStepCheck::MadeScalarFieldIntoArrayField(column) => {
                let message = |details| {
                    format!("Changed the column `{column}` on the `{table}` table from a scalar field to a list field. {details}",
                            column = column.column,
                            table = column.table,
                            details = details)
                };

                match database_checks.get_row_and_non_null_value_count(column) {
                    (Some(0), _) => None,
                    (_, Some(0)) => None,
                    (_, Some(value_count)) => Some(message(format_args!(
                        "There are {value_count} existing non-null values in that column, this step cannot be executed."
                    ))),
                    (_, _) => Some(message(format_args!(
                        "If there are non-null values in that column, this step will fail."
                    ))),
                }
            }
            UnexecutableStepCheck::DropAndRecreateRequiredColumn(column) => {
                match database_checks.get_row_count(&Table::from_column(column)) {
                    None => Some(format!("Changed the type of `{column}` on the `{table}` table. No cast exists, the column would be dropped and recreated, which cannot be done if there is data, since the column is required.", column = column.column, table = column.table)),
                    Some(0) => None,
                    Some(_) => Some(format!("Changed the type of `{column}` on the `{table}` table. No cast exists, the column would be dropped and recreated, which cannot be done since the column is required and there is data in the table.", column = column.column, table = column.table)),
                }
            }
        }
    }
}