elif-orm 0.7.1

Production-ready ORM with migrations, database services, connection pooling, and query builder
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

//! Primary Key System - Types and implementations for model primary keys
//!
//! Supports integer, UUID, and composite primary keys with proper serialization,
//! display formatting, and type conversion utilities.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use uuid::Uuid;

/// Primary key types supported by the ORM
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum PrimaryKey {
    /// Auto-incrementing integer primary key
    Integer(i64),
    /// UUID primary key
    Uuid(Uuid),
    /// Composite primary key (multiple fields)
    Composite(HashMap<String, String>),
}

impl std::fmt::Display for PrimaryKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PrimaryKey::Integer(id) => write!(f, "{}", id),
            PrimaryKey::Uuid(id) => write!(f, "{}", id),
            PrimaryKey::Composite(fields) => {
                let pairs: Vec<String> =
                    fields.iter().map(|(k, v)| format!("{}:{}", k, v)).collect();
                write!(f, "{}", pairs.join(","))
            }
        }
    }
}

impl Default for PrimaryKey {
    fn default() -> Self {
        PrimaryKey::Integer(0)
    }
}

impl PrimaryKey {
    /// Extract as i64 if this is an Integer primary key
    pub fn as_i64(&self) -> Option<i64> {
        match self {
            PrimaryKey::Integer(id) => Some(*id),
            _ => None,
        }
    }

    /// Extract as UUID if this is a UUID primary key
    pub fn as_uuid(&self) -> Option<Uuid> {
        match self {
            PrimaryKey::Uuid(id) => Some(*id),
            _ => None,
        }
    }

    /// Extract as composite fields if this is a Composite primary key
    pub fn as_composite(&self) -> Option<&HashMap<String, String>> {
        match self {
            PrimaryKey::Composite(fields) => Some(fields),
            _ => None,
        }
    }

    /// Check if this is a valid (non-default) primary key
    pub fn is_valid(&self) -> bool {
        match self {
            PrimaryKey::Integer(0) => false,
            PrimaryKey::Integer(_) => true,
            PrimaryKey::Uuid(uuid) => !uuid.is_nil(),
            PrimaryKey::Composite(fields) => !fields.is_empty(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_primary_key_display() {
        let int_key = PrimaryKey::Integer(123);
        assert_eq!(format!("{}", int_key), "123");

        let uuid_key =
            PrimaryKey::Uuid(Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap());
        assert_eq!(
            format!("{}", uuid_key),
            "550e8400-e29b-41d4-a716-446655440000"
        );

        let mut fields = HashMap::new();
        fields.insert("user_id".to_string(), "1".to_string());
        fields.insert("role_id".to_string(), "2".to_string());
        let composite_key = PrimaryKey::Composite(fields);
        let display_str = format!("{}", composite_key);
        assert!(display_str.contains("user_id:1") && display_str.contains("role_id:2"));
    }

    #[test]
    fn test_primary_key_validation() {
        assert!(!PrimaryKey::Integer(0).is_valid());
        assert!(PrimaryKey::Integer(1).is_valid());

        assert!(!PrimaryKey::Uuid(Uuid::nil()).is_valid());
        assert!(PrimaryKey::Uuid(Uuid::new_v4()).is_valid());

        assert!(!PrimaryKey::Composite(HashMap::new()).is_valid());
        let mut fields = HashMap::new();
        fields.insert("id".to_string(), "1".to_string());
        assert!(PrimaryKey::Composite(fields).is_valid());
    }
}