flowfine 0.0.3

ScyllaDB and Cassandra migration tool
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

use crate::migration::version::MigrationVersionKey;
use crate::migration::MigrationParsingError::*;
use std::collections::BTreeMap;
use thiserror::Error;

pub mod lexer;
pub mod parser;
pub mod version;

#[derive(Debug, Error)]
pub enum FileError {
    #[error("Directory not loaded")]
    DirectoryNotLoadedError,

    #[error("File not loaded")]
    FileNotLoadedError,
}

#[derive(Debug, PartialEq, Eq, Hash, Error)]
pub enum MigrationParsingError {
    #[error("Duplicated migration.rs version for file: {0}")]
    DuplicatedMigrationError(String),

    #[error("Invalid migration.rs format for file: {0}")]
    InvalidMigrationFormatError(String),

    #[error("Invalid version format for file {0}")]
    InvalidVersionFormatError(String),

    #[error("Missing migration.rs content for file {0}")]
    MissingMigrationContentError(String),

    #[error("Missing semicolons in migration.rs content for file {0}")]
    NoSemicolonsFoundError(String),
}

#[derive(Clone, Debug)]
pub struct Migration {
    pub filename: String,
    pub version: String,
    pub version_key: MigrationVersionKey,
    pub name: String,
    pub content: String,
    pub queries: Vec<String>,
}

pub struct MigrationResult {
    errors: Vec<MigrationParsingError>,
    migrations: Vec<Migration>,
}

impl MigrationResult {
    pub fn into_result(self) -> Result<Vec<Migration>, Vec<MigrationParsingError>> {
        if self.errors.is_empty() {
            Ok(self.migrations)
        } else {
            Err(self.errors)
        }
    }
}

pub struct MigrationStack {
    migrations: BTreeMap<MigrationVersionKey, Migration>,
    errors: Vec<MigrationParsingError>,
}

impl MigrationStack {
    fn new() -> Self {
        MigrationStack {
            migrations: BTreeMap::new(),
            errors: Vec::new(),
        }
    }

    fn push_migration(&mut self, migration: Migration) {
        let filename = migration.filename.clone();
        let version_key = migration.version_key.clone();

        self.migrations
            .insert(version_key, migration)
            .map(|_| self.push_error(DuplicatedMigrationError(filename)));
    }

    fn push_error(&mut self, error: MigrationParsingError) {
        self.errors.push(error);
    }

    fn into_result(self) -> MigrationResult {
        MigrationResult {
            errors: self.errors,
            migrations: self.migrations.into_values().collect(),
        }
    }
}