thisversion 0.1.0

Keep persisted schema history explicit while your application uses a single current model.
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
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

#![no_std]

use thisversion::traits::{IntoModel, IntoSchema, TryIntoModel};
use thisversion::{VersionBoundary, VersionFamily};

pub struct Application {
    pub value: u32,
}

#[derive(VersionBoundary)]
#[thisversion(model = Application)]
pub struct Snapshot {
    pub value: u32,
}

#[derive(VersionFamily)]
pub enum ModelVersions {
    V1(u16),
    Current(Snapshot),
}

impl From<u16> for Snapshot {
    fn from(value: u16) -> Self {
        Self {
            value: u32::from(value),
        }
    }
}

pub fn migrate_model(value: u16) -> Application {
    ModelVersions::V1(value).into_model()
}

pub fn wrap_model(value: Application) -> ModelVersions {
    value.into_schema()
}

#[test]
fn optional_models_convert_without_alloc() {
    let model = Some(ModelVersions::V1(7)).into_model();
    let stored: Option<ModelVersions> = model.into_schema();

    // Check Option composes the family conversions without allocation:
    assert!(matches!(
        stored,
        Some(ModelVersions::Current(Snapshot { value: 7 }))
    ));

    let absent: Option<ModelVersions> = None::<Application>.into_schema();

    // Check missing values survive conversion in both directions:
    assert!(absent.into_model().is_none());
}

pub struct Old(u64);
pub struct FallibleApplication {
    pub value: u32,
}
pub struct MigrationError;

impl From<core::convert::Infallible> for MigrationError {
    fn from(error: core::convert::Infallible) -> Self {
        match error {}
    }
}

impl From<core::num::TryFromIntError> for MigrationError {
    fn from(_: core::num::TryFromIntError) -> Self {
        Self
    }
}

#[derive(VersionBoundary)]
#[thisversion(model = FallibleApplication, error = MigrationError)]
pub struct FallibleSnapshotModel {
    pub value: u32,
}

impl TryFrom<Old> for FallibleSnapshotModel {
    type Error = MigrationError;

    fn try_from(old: Old) -> Result<Self, Self::Error> {
        let value = u32::try_from(old.0).map_err(MigrationError::from)?;
        Ok(Self { value })
    }
}

pub enum FallibleVersions {
    Old(Old),
    Current(FallibleSnapshotModel),
}

impl From<FallibleSnapshotModel> for FallibleVersions {
    fn from(value: FallibleSnapshotModel) -> Self {
        Self::Current(value)
    }
}

impl TryIntoModel for FallibleVersions {
    type Model = FallibleApplication;
    type Error = MigrationError;

    fn try_into_model(self) -> Result<Self::Model, Self::Error> {
        match self {
            Self::Old(old) => FallibleSnapshotModel::try_from(old)?.try_into_model(),
            Self::Current(current) => current.try_into_model(),
        }
    }
}

pub fn migrate_fallible(value: u64) -> Result<FallibleApplication, MigrationError> {
    FallibleVersions::Old(Old(value)).try_into_model()
}

#[test]
fn optional_fallible_migrations_work_without_alloc() {
    let valid = Some(FallibleVersions::Old(Old(7))).try_into_model();

    // Check successful optional migrations produce the application model:
    assert!(matches!(valid, Ok(Some(FallibleApplication { value: 7 }))));

    let invalid = Some(FallibleVersions::Old(Old(u64::MAX))).try_into_model();

    // Check migration errors pass through Option unchanged:
    assert!(matches!(invalid, Err(MigrationError)));

    // Check absent values require no migration:
    assert!(matches!(
        None::<FallibleVersions>.try_into_model(),
        Ok(None)
    ));
}