postrust_core/schema_cache/
relationship.rs

1//! Relationship types for resource embedding.
2
3use crate::api_request::QualifiedIdentifier;
4use serde::{Deserialize, Serialize};
5use std::collections::HashMap;
6
7/// A relationship between tables.
8#[derive(Clone, Debug, Serialize, Deserialize)]
9pub enum Relationship {
10    /// Foreign key relationship
11    ForeignKey {
12        /// Source table
13        table: QualifiedIdentifier,
14        /// Target table
15        foreign_table: QualifiedIdentifier,
16        /// Whether this is a self-referential relationship
17        is_self: bool,
18        /// Relationship cardinality
19        cardinality: Cardinality,
20        /// Whether the source is a view
21        table_is_view: bool,
22        /// Whether the target is a view
23        foreign_table_is_view: bool,
24        /// FK constraint name
25        constraint_name: String,
26    },
27    /// Computed relationship (from a function)
28    Computed {
29        /// Function that computes the relationship
30        function: QualifiedIdentifier,
31        /// Source table
32        table: QualifiedIdentifier,
33        /// Target table
34        foreign_table: QualifiedIdentifier,
35        /// Alias for the relationship
36        table_alias: QualifiedIdentifier,
37        /// Whether this returns a single row
38        to_one: bool,
39        /// Whether this is self-referential
40        is_self: bool,
41    },
42}
43
44impl Relationship {
45    /// Get the foreign table for this relationship.
46    pub fn foreign_table(&self) -> &QualifiedIdentifier {
47        match self {
48            Self::ForeignKey { foreign_table, .. } => foreign_table,
49            Self::Computed { foreign_table, .. } => foreign_table,
50        }
51    }
52
53    /// Check if this relationship returns a single row.
54    pub fn is_to_one(&self) -> bool {
55        match self {
56            Self::ForeignKey { cardinality, .. } => matches!(
57                cardinality,
58                Cardinality::M2O { .. } | Cardinality::O2O { .. }
59            ),
60            Self::Computed { to_one, .. } => *to_one,
61        }
62    }
63
64    /// Get the join columns for this relationship.
65    pub fn join_columns(&self) -> Vec<(String, String)> {
66        match self {
67            Self::ForeignKey { cardinality, .. } => cardinality.columns(),
68            Self::Computed { .. } => vec![],
69        }
70    }
71}
72
73/// Relationship cardinality.
74#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
75pub enum Cardinality {
76    /// One-to-Many: parent has many children
77    O2M {
78        constraint: String,
79        columns: Vec<(String, String)>,
80    },
81    /// Many-to-One: child has one parent
82    M2O {
83        constraint: String,
84        columns: Vec<(String, String)>,
85    },
86    /// One-to-One
87    O2O {
88        constraint: String,
89        columns: Vec<(String, String)>,
90        /// Whether this table is the parent in the relationship
91        is_parent: bool,
92    },
93    /// Many-to-Many (via junction table)
94    M2M(Junction),
95}
96
97impl Cardinality {
98    /// Get the join columns as `(local column, foreign column)` pairs.
99    ///
100    /// "Local" is the table the relationship is stored under, so a pair can be
101    /// used directly to join from the local table to the foreign one without
102    /// having to know the cardinality.
103    pub fn columns(&self) -> Vec<(String, String)> {
104        match self {
105            Self::O2M { columns, .. } => columns.clone(),
106            Self::M2O { columns, .. } => columns.clone(),
107            Self::O2O { columns, .. } => columns.clone(),
108            Self::M2M(junction) => junction.source_columns(),
109        }
110    }
111
112    /// Get the constraint name.
113    pub fn constraint_name(&self) -> &str {
114        match self {
115            Self::O2M { constraint, .. } => constraint,
116            Self::M2O { constraint, .. } => constraint,
117            Self::O2O { constraint, .. } => constraint,
118            Self::M2M(junction) => &junction.constraint1,
119        }
120    }
121}
122
123/// Junction table for M2M relationships.
124#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
125pub struct Junction {
126    /// The junction table
127    pub table: QualifiedIdentifier,
128    /// FK constraint from junction to source
129    pub constraint1: String,
130    /// FK constraint from junction to target
131    pub constraint2: String,
132    /// Columns linking source to junction
133    pub source_columns: Vec<(String, String)>,
134    /// Columns linking junction to target
135    pub target_columns: Vec<(String, String)>,
136}
137
138impl Junction {
139    /// Get the source-side join columns.
140    pub fn source_columns(&self) -> Vec<(String, String)> {
141        self.source_columns.clone()
142    }
143
144    /// Get the target-side join columns.
145    pub fn target_columns(&self) -> Vec<(String, String)> {
146        self.target_columns.clone()
147    }
148}
149
150/// Map of (table, schema) to relationships.
151pub type RelationshipsMap = HashMap<(QualifiedIdentifier, String), Vec<Relationship>>;
152
153#[cfg(test)]
154mod tests {
155    use super::*;
156
157    #[test]
158    fn test_relationship_foreign_table() {
159        let rel = Relationship::ForeignKey {
160            table: QualifiedIdentifier::new("public", "orders"),
161            foreign_table: QualifiedIdentifier::new("public", "users"),
162            is_self: false,
163            cardinality: Cardinality::M2O {
164                constraint: "orders_user_id_fkey".into(),
165                columns: vec![("user_id".into(), "id".into())],
166            },
167            table_is_view: false,
168            foreign_table_is_view: false,
169            constraint_name: "orders_user_id_fkey".into(),
170        };
171
172        assert_eq!(rel.foreign_table().name, "users");
173        assert!(rel.is_to_one());
174    }
175
176    #[test]
177    fn test_cardinality_columns() {
178        let card = Cardinality::O2M {
179            constraint: "users_id_fkey".into(),
180            columns: vec![("id".into(), "user_id".into())],
181        };
182
183        let cols = card.columns();
184        assert_eq!(cols.len(), 1);
185        assert_eq!(cols[0], ("id".into(), "user_id".into()));
186    }
187}
postrust_core/schema_cache/relationship.rs

postrust_core/schema_cache/
relationship.rs
