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
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
163
164
165
166
167
168
169
170

//! Polymorphic Relationship Types - Support for polymorphic associations
//!
//! Provides MorphOne and MorphMany relationship types that can associate
//! with multiple different model types through a polymorphic interface.

use super::super::metadata::RelationshipMetadata;
use super::core::{RelationshipContainer, TypeSafeRelationship};
use std::fmt::Debug;

/// MorphOne relationship - polymorphic one-to-one with type info
#[derive(Debug, Clone)]
pub struct MorphOne<T>
where
    T: Clone + Debug + Send + Sync,
{
    /// Core relationship container
    relationship: TypeSafeRelationship<Option<T>>,

    /// The morphable type (e.g., "Post", "User")
    morph_type: Option<String>,

    /// The morphable ID
    morph_id: Option<String>,
}

impl<T> MorphOne<T>
where
    T: Clone + Debug + Send + Sync,
{
    /// Create a new MorphOne relationship
    pub fn new(metadata: RelationshipMetadata) -> Self {
        Self {
            relationship: TypeSafeRelationship::new(metadata),
            morph_type: None,
            morph_id: None,
        }
    }

    /// Set the polymorphic type and ID information
    pub fn set_morph_info(&mut self, morph_type: String, morph_id: String) {
        self.morph_type = Some(morph_type);
        self.morph_id = Some(morph_id);
    }

    /// Get the polymorphic type
    pub fn morph_type(&self) -> Option<&str> {
        self.morph_type.as_deref()
    }

    /// Get the polymorphic ID
    pub fn morph_id(&self) -> Option<&str> {
        self.morph_id.as_deref()
    }

    /// Get the loaded data
    pub fn get(&self) -> Option<&Option<T>> {
        self.relationship.get_typed()
    }

    /// Check if the relationship is loaded
    pub fn is_loaded(&self) -> bool {
        self.relationship.is_loaded()
    }

    /// Set the loaded data
    pub fn set_loaded(&mut self, data: Option<T>) {
        self.relationship.set_loaded(data);
    }

    /// Mark as loading
    pub fn set_loading(&mut self) {
        self.relationship.set_loading();
    }

    /// Mark as failed with error
    pub fn set_failed(&mut self, error: String) {
        self.relationship.set_failed(error);
    }

    /// Get the relationship metadata
    pub fn metadata(&self) -> &RelationshipMetadata {
        self.relationship.metadata()
    }

    /// Get the relationship name
    pub fn name(&self) -> &str {
        self.relationship.name()
    }
}

/// MorphMany relationship - polymorphic one-to-many with type info
#[derive(Debug, Clone)]
pub struct MorphMany<T>
where
    T: Clone + Debug + Send + Sync,
{
    /// Core relationship container
    relationship: TypeSafeRelationship<Vec<T>>,

    /// The morphable type (e.g., "Post", "User")
    morph_type: Option<String>,
}

impl<T> MorphMany<T>
where
    T: Clone + Debug + Send + Sync,
{
    /// Create a new MorphMany relationship
    pub fn new(metadata: RelationshipMetadata) -> Self {
        Self {
            relationship: TypeSafeRelationship::new(metadata),
            morph_type: None,
        }
    }

    /// Set the polymorphic type
    pub fn set_morph_type(&mut self, morph_type: String) {
        self.morph_type = Some(morph_type);
    }

    /// Get the polymorphic type
    pub fn morph_type(&self) -> Option<&str> {
        self.morph_type.as_deref()
    }

    /// Get the loaded data
    pub fn get(&self) -> Option<&Vec<T>> {
        self.relationship.get_typed()
    }

    /// Check if the relationship is loaded
    pub fn is_loaded(&self) -> bool {
        self.relationship.is_loaded()
    }

    /// Set the loaded data
    pub fn set_loaded(&mut self, data: Vec<T>) {
        self.relationship.set_loaded(data);
    }

    /// Mark as loading
    pub fn set_loading(&mut self) {
        self.relationship.set_loading();
    }

    /// Mark as failed with error
    pub fn set_failed(&mut self, error: String) {
        self.relationship.set_failed(error);
    }

    /// Get the relationship metadata
    pub fn metadata(&self) -> &RelationshipMetadata {
        self.relationship.metadata()
    }

    /// Get the relationship name
    pub fn name(&self) -> &str {
        self.relationship.name()
    }

    /// Get the number of loaded items (0 if not loaded)
    pub fn len(&self) -> usize {
        self.get().map(|v| v.len()).unwrap_or(0)
    }

    /// Check if the collection is empty (true if not loaded)
    pub fn is_empty(&self) -> bool {
        self.get().map(|v| v.is_empty()).unwrap_or(true)
    }
}