1use chrono::{DateTime, Utc};
4use schemars::JsonSchema;
5use serde::{Deserialize, Serialize};
6use uuid::Uuid;
7
8use crate::{ArchiveStatus, DEFAULT_LIMIT, MAX_LIMIT};
9
10#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)]
16pub struct ObjectBacklinksParams {
17 pub limit: Option<i64>,
19 pub edge_cursor: Option<String>,
21 pub reference_cursor: Option<String>,
23 #[serde(default)]
25 pub include_archived: bool,
26}
27
28impl ObjectBacklinksParams {
29 pub fn checked_limit(&self) -> Result<i64, &'static str> {
35 match self.limit {
36 Some(limit) if limit < 1 => Err("limit must be at least 1"),
37 Some(limit) => Ok(limit.min(MAX_LIMIT)),
38 None => Ok(DEFAULT_LIMIT),
39 }
40 }
41}
42
43#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
45pub struct BacklinkSourceObject {
46 pub id: Uuid,
48 pub title: String,
50 pub status: ArchiveStatus,
52}
53
54#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
56pub struct ObjectBacklink {
57 pub edge_id: Uuid,
59 pub source_object: BacklinkSourceObject,
61 pub target_object_id: Uuid,
63 pub created_by: Option<Uuid>,
65 pub created_at: DateTime<Utc>,
67}
68
69#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
71pub struct ObjectBacklinkReference {
72 pub reference_id: Uuid,
74 pub reference_kind: String,
76 pub source_object: BacklinkSourceObject,
78 pub source_version_id: Uuid,
80 pub target_object_id: Uuid,
82 pub raw_target: String,
84 #[serde(skip_serializing_if = "Option::is_none")]
86 pub display_text: Option<String>,
87 pub span_start: i32,
89 pub span_end: i32,
91 pub created_at: DateTime<Utc>,
93}
94
95#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
97pub struct ObjectBacklinksResponse {
98 pub object_id: Uuid,
100 pub incoming_edges: Vec<ObjectBacklink>,
102 #[serde(skip_serializing_if = "Option::is_none")]
104 pub next_edge_cursor: Option<String>,
105 pub incoming_references: Vec<ObjectBacklinkReference>,
107 #[serde(skip_serializing_if = "Option::is_none")]
109 pub next_reference_cursor: Option<String>,
110}
111
112pub use kival_types::{GrantPrincipal, ObjectGraphDirection, ObjectRole};
113
114#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
116pub struct ObjectGraphParams {
117 pub depth: Option<i32>,
119 #[serde(default)]
121 pub direction: ObjectGraphDirection,
122 #[serde(alias = "limit_nodes")]
124 pub max_nodes: Option<i64>,
125 #[serde(alias = "limit_edges")]
127 pub max_edges: Option<i64>,
128 #[serde(default = "default_true")]
130 pub include_root: bool,
131}
132
133impl Default for ObjectGraphParams {
134 fn default() -> Self {
135 Self {
136 depth: None,
137 direction: ObjectGraphDirection::Both,
138 max_nodes: None,
139 max_edges: None,
140 include_root: true,
141 }
142 }
143}
144
145#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
147pub struct ObjectGraphNode {
148 pub id: Uuid,
150 pub workspace_id: Uuid,
152 pub current_version_id: Option<Uuid>,
154 pub title: String,
156 pub status: ArchiveStatus,
158 pub created_by: Option<Uuid>,
160 pub created_at: DateTime<Utc>,
162 pub updated_at: DateTime<Utc>,
164 pub distance: i32,
166 pub incoming_count: i64,
168 pub outgoing_count: i64,
170}
171
172#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
174#[serde(rename_all = "snake_case")]
175pub enum GraphEdgeKind {
176 Relationship,
178 Reference,
180 RelationshipAndReference,
182}
183
184#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
186pub struct ObjectGraphEdge {
187 pub id: Uuid,
189 pub workspace_id: Uuid,
191 pub source_object_id: Uuid,
193 pub target_object_id: Uuid,
195 pub kind: GraphEdgeKind,
197 pub created_by: Option<Uuid>,
199 pub created_at: DateTime<Utc>,
201 pub updated_at: DateTime<Utc>,
203}
204
205#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
207pub struct ObjectGraphTruncation {
208 pub nodes: bool,
210 pub edges: bool,
212}
213
214#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
216pub struct ObjectGraphResponse {
217 pub workspace_id: Uuid,
219 pub root_object_id: Uuid,
221 pub depth: i32,
223 pub direction: ObjectGraphDirection,
225 pub max_nodes: i64,
227 pub max_edges: i64,
229 pub truncated: bool,
231 pub truncation: ObjectGraphTruncation,
233 pub nodes: Vec<ObjectGraphNode>,
235 pub edges: Vec<ObjectGraphEdge>,
237}
238
239const fn default_true() -> bool {
241 true
242}
243
244#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)]
246pub struct WorkspaceGraphParams {
247 pub limit_nodes: Option<i64>,
249 pub limit_edges: Option<i64>,
251 #[serde(default)]
253 pub exclude_isolated: bool,
254}
255
256#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
258pub struct WorkspaceGraphNode {
259 pub id: Uuid,
261 pub workspace_id: Uuid,
263 pub current_version_id: Option<Uuid>,
265 pub title: String,
267 pub status: ArchiveStatus,
269 pub created_by: Option<Uuid>,
271 pub created_at: DateTime<Utc>,
273 pub updated_at: DateTime<Utc>,
275 pub in_degree: i64,
278 pub out_degree: i64,
281}
282
283#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
285pub struct WorkspaceGraphEdge {
286 pub id: Uuid,
288 pub workspace_id: Uuid,
290 pub source_object_id: Uuid,
292 pub target_object_id: Uuid,
294 pub kind: GraphEdgeKind,
296 pub created_by: Option<Uuid>,
298 pub created_at: DateTime<Utc>,
300 pub updated_at: DateTime<Utc>,
302}
303
304#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
306pub struct WorkspaceGraphLimits {
307 pub limit_nodes: i64,
309 pub limit_edges: i64,
311 pub has_more_nodes: bool,
313 pub has_more_edges: bool,
315}
316
317#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
319pub struct WorkspaceGraphResponse {
320 pub workspace_id: Uuid,
322 pub nodes: Vec<WorkspaceGraphNode>,
324 pub edges: Vec<WorkspaceGraphEdge>,
326 pub limits: WorkspaceGraphLimits,
328}
329
330#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
332pub struct CreateObjectEdgeRequest {
333 pub source_object_id: Uuid,
335
336 pub target_object_id: Uuid,
338}
339
340#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
342pub struct ObjectEdge {
343 pub id: Uuid,
345
346 pub workspace_id: Uuid,
348
349 pub source_object_id: Uuid,
351
352 pub target_object_id: Uuid,
354
355 pub created_by: Option<Uuid>,
357
358 pub revoked_by: Option<Uuid>,
360
361 pub created_at: DateTime<Utc>,
363
364 pub updated_at: DateTime<Utc>,
366
367 pub revoked_at: Option<DateTime<Utc>>,
369}
370
371#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
373pub struct ObjectEdgeResponse {
374 pub edge: ObjectEdge,
376}
377
378#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
380pub struct CreateObjectGrantRequest {
381 pub principal: GrantPrincipal,
383
384 pub object_role: ObjectRole,
386}
387
388#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
390pub struct UpdateObjectGrantRequest {
391 pub object_role: ObjectRole,
393}
394
395#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
397pub struct ObjectGrant {
398 pub id: Uuid,
400
401 pub workspace_id: Uuid,
403
404 pub object_id: Uuid,
406
407 pub principal_user_id: Option<Uuid>,
409
410 pub principal_group_id: Option<Uuid>,
412
413 pub object_role: ObjectRole,
415
416 pub created_by: Option<Uuid>,
418
419 pub revoked_by: Option<Uuid>,
421
422 pub created_at: DateTime<Utc>,
424
425 pub updated_at: DateTime<Utc>,
427
428 pub revoked_at: Option<DateTime<Utc>>,
430}
431
432#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
434pub struct ObjectGrantResponse {
435 pub grant: ObjectGrant,
437}
438
439#[cfg(test)]
440mod tests {
441 use uuid::Uuid;
442
443 use crate::{DEFAULT_LIMIT, MAX_LIMIT, ObjectBacklinksParams, ObjectBacklinksResponse};
444
445 #[test]
446 fn backlinks_response_serializes_empty_references() {
447 let response = ObjectBacklinksResponse {
448 object_id: Uuid::from_u128(1),
449 incoming_edges: Vec::new(),
450 next_edge_cursor: None,
451 incoming_references: Vec::new(),
452 next_reference_cursor: None,
453 };
454
455 let value = serde_json::to_value(response).unwrap();
456 assert_eq!(value["incoming_references"], serde_json::json!([]));
457 }
458
459 #[test]
460 fn backlinks_query_defaults_and_caps_limit() {
461 assert_eq!(ObjectBacklinksParams::default().checked_limit(), Ok(DEFAULT_LIMIT));
462 assert_eq!(
463 ObjectBacklinksParams {
464 limit: Some(MAX_LIMIT + 1),
465 ..ObjectBacklinksParams::default()
466 }
467 .checked_limit(),
468 Ok(MAX_LIMIT)
469 );
470 assert_eq!(
471 ObjectBacklinksParams { limit: Some(0), ..ObjectBacklinksParams::default() }
472 .checked_limit(),
473 Err("limit must be at least 1")
474 );
475 }
476}