codexa 0.0.3

A Git-native content compiler for building typed public and private knowledge artifacts.
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DocumentMetadata {
    pub schema: String,
    pub id: String,
    pub title: String,
    pub description: String,
    pub kind: String,
    pub status: String,
    pub visibility: String,
    #[serde(default)]
    pub tags: Vec<String>,
    pub navigation: Navigation,
    pub distribution: Distribution,
    pub notion: Option<NotionTarget>,
    pub web: Option<WebTarget>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Navigation {
    pub root: String,
    pub product: String,
    pub section: String,
    pub order: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Distribution {
    pub notion: bool,
    pub web: String,
    pub obsidian: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NotionTarget {
    pub workspace: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct WebTarget {
    pub slug: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SourceDocument {
    pub metadata: DocumentMetadata,
    pub body: String,
}

impl DocumentMetadata {
    pub fn validate_schema(&self) -> Result<(), String> {
        if self.schema != "codexa.document@2" {
            return Err(format!("unsupported document schema `{}`", self.schema));
        }

        for (name, value) in [
            ("id", self.id.as_str()),
            ("title", self.title.as_str()),
            ("description", self.description.as_str()),
            ("kind", self.kind.as_str()),
            ("status", self.status.as_str()),
            ("visibility", self.visibility.as_str()),
            ("navigation.root", self.navigation.root.as_str()),
            ("navigation.product", self.navigation.product.as_str()),
            ("navigation.section", self.navigation.section.as_str()),
        ] {
            if value.trim().is_empty() {
                return Err(format!("{name} must not be empty"));
            }
        }

        if self.distribution.notion {
            let notion = self.notion.as_ref().ok_or_else(|| {
                "notion target is required when distribution.notion is true".to_string()
            })?;
            if notion.workspace.trim().is_empty() {
                return Err("notion.workspace must not be empty".into());
            }
        }

        if self.distribution.web != "off" {
            let web = self.web.as_ref().ok_or_else(|| {
                "web target is required when distribution.web is not `off`".to_string()
            })?;
            if !web.slug.starts_with('/') {
                return Err("web.slug must start with `/`".into());
            }
        }

        Ok(())
    }
}