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

use datamodel_renderer as renderer;
use mongodb_schema_describer::{IndexFieldProperty, IndexType, IndexWalker};
use psl::datamodel_connector::constraint_names::ConstraintNames;
use renderer::datamodel::{IndexDefinition, IndexFieldInput, Model};
use std::borrow::Cow;

pub(super) fn render<'a>(model: &mut Model<'a>, model_name: &str, indices: impl Iterator<Item = &'a IndexWalker<'a>>) {
    for index in indices {
        let fields = index.fields().map(|field| {
            let name = field
                .name()
                .split('.')
                .map(|part| {
                    super::sanitize_string(part)
                        .map(Cow::Owned)
                        .unwrap_or_else(|| Cow::Borrowed(part))
                })
                .collect::<Vec<_>>()
                .join(".");

            let mut rendered = IndexFieldInput::new(name);

            match field.property {
                IndexFieldProperty::Text => (),
                IndexFieldProperty::Ascending if index.r#type().is_fulltext() => {
                    rendered.sort_order("Asc");
                }
                IndexFieldProperty::Descending => {
                    rendered.sort_order("Desc");
                }
                IndexFieldProperty::Ascending => (),
            }

            rendered
        });

        let mut rendered = match index.r#type() {
            IndexType::Normal => IndexDefinition::index(fields),
            IndexType::Unique => IndexDefinition::unique(fields),
            IndexType::Fulltext => IndexDefinition::fulltext(fields),
        };

        let column_names = index.fields().flat_map(|f| f.name().split('.')).collect::<Vec<_>>();

        let default_name = match index.r#type() {
            IndexType::Unique => {
                ConstraintNames::unique_index_name(model_name, &column_names, psl::builtin_connectors::MONGODB)
            }
            _ => ConstraintNames::non_unique_index_name(model_name, &column_names, psl::builtin_connectors::MONGODB),
        };

        if index.name() != default_name {
            rendered.map(index.name());
        };

        model.push_index(rendered);
    }
}