icydb-core 0.67.1

IcyDB — A type-safe, embedded ORM and schema system for the Internet Computer
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

//! Module: relation::metadata
//! Responsibility: extract and expose strong-relation metadata descriptors from entity models.
//! Does not own: relation validation execution or reverse-index mutation application.
//! Boundary: defines lightweight relation metadata contracts consumed by relation validators.

use crate::{
    model::entity::EntityModel,
    model::field::{FieldKind, RelationStrength},
    traits::EntityKind,
    types::EntityTag,
};

///
/// StrongRelationInfo
///
/// Lightweight relation descriptor extracted from runtime field metadata.
///

#[derive(Clone, Copy)]
pub(super) struct StrongRelationInfo {
    pub(super) field_index: usize,
    pub(super) field_name: &'static str,
    pub(super) field_kind: FieldKind,
    pub(super) target_path: &'static str,
    pub(super) target_entity_name: &'static str,
    pub(super) target_entity_tag: EntityTag,
    pub(super) target_store_path: &'static str,
}

///
/// StrongRelationTargetInfo
///
/// Shared target descriptor for strong relation fields.
///

#[expect(clippy::struct_field_names)]
#[derive(Clone, Copy)]
pub(crate) struct StrongRelationTargetInfo {
    pub(in crate::db::relation) target_path: &'static str,
    pub(in crate::db::relation) target_entity_name: &'static str,
    pub(in crate::db::relation) target_entity_tag: EntityTag,
    pub(in crate::db::relation) target_store_path: &'static str,
}

/// Resolve a model field-kind into strong relation target metadata (if applicable).
pub(crate) const fn strong_relation_target_from_kind(
    kind: &FieldKind,
) -> Option<StrongRelationTargetInfo> {
    match kind {
        FieldKind::Relation {
            target_path,
            target_entity_name,
            target_entity_tag,
            target_store_path,
            strength: RelationStrength::Strong,
            ..
        }
        | FieldKind::List(FieldKind::Relation {
            target_path,
            target_entity_name,
            target_entity_tag,
            target_store_path,
            strength: RelationStrength::Strong,
            ..
        })
        | FieldKind::Set(FieldKind::Relation {
            target_path,
            target_entity_name,
            target_entity_tag,
            target_store_path,
            strength: RelationStrength::Strong,
            ..
        }) => Some(StrongRelationTargetInfo {
            target_path,
            target_entity_name,
            target_entity_tag: *target_entity_tag,
            target_store_path,
        }),
        _ => None,
    }
}

/// Resolve a model field into strong relation metadata (if applicable).
const fn strong_relation_from_field(
    field_index: usize,
    field_name: &'static str,
    kind: &FieldKind,
) -> Option<StrongRelationInfo> {
    let Some(target) = strong_relation_target_from_kind(kind) else {
        return None;
    };

    Some(StrongRelationInfo {
        field_index,
        field_name,
        field_kind: *kind,
        target_path: target.target_path,
        target_entity_name: target.target_entity_name,
        target_entity_tag: target.target_entity_tag,
        target_store_path: target.target_store_path,
    })
}

/// Resolve strong relation descriptors for a source entity, optionally filtered by target path.
pub(super) fn strong_relations_for_source<S>(
    target_path_filter: Option<&str>,
) -> Vec<StrongRelationInfo>
where
    S: EntityKind,
{
    strong_relations_for_model(S::MODEL, target_path_filter)
}

/// Resolve strong relation descriptors for one source model, optionally filtered by target path.
pub(super) fn strong_relations_for_model(
    model: &'static EntityModel,
    target_path_filter: Option<&str>,
) -> Vec<StrongRelationInfo> {
    model
        .fields
        .iter()
        .enumerate()
        .filter_map(|(field_index, field)| {
            strong_relation_from_field(field_index, field.name, &field.kind)
        })
        .filter(|relation| {
            target_path_filter.is_none_or(|target_path| relation.target_path == target_path)
        })
        .collect()
}