kellnr-migration 5.10.0

Kellnr is a self-hosted registry for Rust crates with support for rustdocs and crates.io caching.
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

use kellnr_settings::{Settings, get_settings};
use sea_orm::{ModelTrait, Related};
use sea_orm_migration::prelude::*;
use tracing::{debug, error};

use crate::sea_orm::ActiveValue::Set;
use crate::sea_orm::{ActiveModelTrait, EntityTrait};

#[derive(DeriveMigrationName)]
pub struct Migration;

#[async_trait::async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        if !manager.has_column("cratesio_crate", "max_version").await? {
            debug!("Column cratesio_crate.max_version does not exist. Creating...");
            manager
                .alter_table(
                    Table::alter()
                        .table(CratesIoIden::Table)
                        .add_column_if_not_exists(
                            ColumnDef::new(CratesIoIden::MaxVersion)
                                .text()
                                .not_null()
                                .default("0.0.0"),
                        )
                        .to_owned(),
                )
                .await?;

            fill_max_version(manager.get_connection()).await?;
        }

        if !manager.has_column("cratesio_meta", "documentation").await? {
            debug!("Column cratesio_meta.documentation does not exist. Creating...");
            manager
                .alter_table(
                    Table::alter()
                        .table(CratesIoMetaIden::Table)
                        .add_column_if_not_exists(
                            ColumnDef::new(CratesIoMetaIden::Documentation).text(),
                        )
                        .to_owned(),
                )
                .await?;

            fill_documentation(manager.get_connection()).await?;
        }
        Ok(())
    }

    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .alter_table(
                Table::alter()
                    .table(CratesIoIden::Table)
                    .drop_column(CratesIoIden::MaxVersion)
                    .to_owned(),
            )
            .await?;

        manager
            .alter_table(
                Table::alter()
                    .table(CratesIoMetaIden::Table)
                    .drop_column(CratesIoMetaIden::Documentation)
                    .to_owned(),
            )
            .await?;

        Ok(())
    }
}

async fn fill_max_version(db: &SchemaManagerConnection<'_>) -> Result<(), DbErr> {
    use crate::m20220101_0000010_create_table_entities::{cratesio_crate, cratesio_index};

    let crates = cratesio_index::Entity::find()
        .find_also_related(cratesio_crate::Entity)
        .all(db)
        .await?;

    for (ci, c) in crates {
        if c.is_none() {
            error!("No Crate found for index with id {}", ci.id);
            continue;
        }

        let version = ci.vers.clone();
        let mut m: cratesio_crate::ActiveModel = c.unwrap().into();
        m.max_version = Set(version);
        m.update(db).await?;
    }

    Ok(())
}

async fn fill_documentation(db: &SchemaManagerConnection<'_>) -> Result<(), DbErr> {
    use crate::m20220101_0000010_create_table_entities::{cratesio_crate, cratesio_meta};

    let crates = cratesio_meta::Entity::find()
        .find_also_related(cratesio_crate::Entity)
        .all(db)
        .await?;

    for (cm, c) in crates {
        if c.is_none() {
            error!("No Crate found for metadata with id {}", cm.id);
            continue;
        }

        let name = c.unwrap().name;
        let version = cm.version.clone();
        let mut m: cratesio_meta::ActiveModel = cm.into();
        m.documentation = Set(Some(format!("https://docs.rs/{name}/{version}")));
        m.update(db).await?;
    }
    Ok(())
}

#[derive(Iden)]
pub enum CratesIoIden {
    #[iden = "cratesio_crate"]
    Table,
    MaxVersion,
}

#[derive(Iden)]
pub enum CratesIoMetaIden {
    #[iden = "cratesio_meta"]
    Table,
    Documentation,
}