kivis 0.5.1

Type-safe database schema generation for Rust with support for custom storage backends, automatic indexing, and layered cache architectures
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

/// Declarative macro to implement the Scope trait for multiple structs with a named manifest.
/// Each struct gets its position in the array as its SCOPE value.
/// Also generates an empty manifest struct and assigns it as the Manifest type.
///
/// # Example
///
/// ```rust
/// use kivis::{manifest, Scope, Record};
/// use serde::{Serialize, Deserialize};
///
/// #[derive(Record, Debug, Serialize, Deserialize)]
/// struct User {
///     id: u64,
/// }
///
/// #[derive(Record, Debug, Serialize, Deserialize)]
/// struct Post {
///     id: u64,
/// }
///
/// #[derive(Record, Debug, Serialize, Deserialize)]
/// struct Comment {
///     id: u64,
/// }
///
/// #[derive(Record, Debug, Serialize, Deserialize)]
/// struct Tag {
///     id: u64,
/// }
///
/// manifest![MyDatabase: User, Post, Comment, Tag];
///
/// // Verify the generated implementations
/// assert_eq!(User::SCOPE, 0);
/// assert_eq!(Post::SCOPE, 1);
/// assert_eq!(Comment::SCOPE, 2);
/// assert_eq!(Tag::SCOPE, 3);
/// ```
///
/// # Compilation Errors
///
/// The macro requires a manifest name followed by a colon. Using the old syntax will fail:
///
/// ```compile_fail
/// use kivis::manifest;
///
/// struct User;
/// struct Post;
///
/// // This will fail to compile with the error:
/// // "manifest! macro requires a manifest name followed by a colon. Use: manifest![ManifestName: Type1, Type2, ...]"
/// manifest![User, Post];
/// ```
///
/// Single type without colon also fails:
///
/// ```compile_fail
/// use kivis::manifest;
///
/// struct User;
///
/// // This will fail to compile with the same error:
/// // "manifest! macro requires a manifest name followed by a colon. Use: manifest![ManifestName: Type1, Type2, ...]"
/// manifest![M: User];
/// ```
#[macro_export]
macro_rules! manifest {
    // Base case: empty list with manifest name
    ($manifest_name:ident:) => {
        #[derive(Default)]
        pub struct $manifest_name;
    };

    // Multiple items case with manifest name - generate implementations with incrementing indices
    ($manifest_name:ident: $($ty:ty),+ $(,)?) => {
                $crate::paste! {
                    #[derive(Default)]
                    pub struct $manifest_name {
                        $(
                            [<last_ $ty:snake>]: ::core::option::Option<<$ty as $crate::DatabaseEntry>::Key>,
                        )*
                    }
                }

        $crate::scope_impl_with_index!($manifest_name, 0; $($ty),+);

        impl $crate::Manifest for $manifest_name {
            fn members() -> &'static [u8] {
                &$crate::generate_member_scopes!(0; $($ty),+)
            }

            fn load<S: $crate::Storage>(&mut self, db: &mut $crate::Database<S, Self>) -> ::core::result::Result<(), $crate::DatabaseError<S>> {
                $crate::paste! {
                    $(
                        self.[<last_ $ty:snake>] = ::core::option::Option::Some(db.last_id()?);
                    )*
                }
                ::core::result::Result::Ok(())
            }
        }
    };

    // Error case: catch patterns without the required colon delimiter
    ($($ty:ty),+ $(,)?) => {
        compile_error!("manifest! macro requires a manifest name followed by a colon. Use: manifest![ManifestName: Type1, Type2, ...]");
    };

    // Error case: single type without colon
    ($ty:ty) => {
        compile_error!("manifest! macro requires a manifest name followed by a colon. Use: manifest![ManifestName: Type1, Type2, ...]");
    };
}

/// Helper macro to generate member scope list
#[macro_export]
macro_rules! generate_member_scopes {
    ($index:expr; $($ty:ty),+) => {
        {
            [
                $(<$ty as $crate::Scope>::SCOPE),+
            ]
        }
    };
}

/// Helper macro for `scope_impl` that tracks the current index and manifest name
#[macro_export]
macro_rules! scope_impl_with_index {
    // Base case: no more types
    ($manifest_name:ident, $index:expr;) => {};

    // Single type remaining
    ($manifest_name:ident, $index:expr; $ty:ty) => {
        impl $crate::Scope for $ty {
            const SCOPE: u8 = $index;
            type Manifest = $manifest_name;
        }
        impl $crate::Manifests<$ty> for $manifest_name {
            fn last(&mut self) -> &mut ::core::option::Option<<$ty as $crate::DatabaseEntry>::Key> {
                $crate::paste! {
                    &mut self.[<last_ $ty:snake>]
                }
            }
        }
    };

    // Multiple types remaining - implement for first and recurse
    ($manifest_name:ident, $index:expr; $ty:ty, $($rest:ty),+) => {
        impl $crate::Scope for $ty {
            const SCOPE: u8 = $index;
            type Manifest = $manifest_name;
        }
        impl $crate::Manifests<$ty> for $manifest_name {
            fn last(&mut self) -> &mut ::core::option::Option<<$ty as $crate::DatabaseEntry>::Key> {
                $crate::paste! {
                    &mut self.[<last_ $ty:snake>]
                }
            }
        }
        $crate::scope_impl_with_index!($manifest_name, $index + 1; $($rest),+);
    };
}