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
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

use serde::{Deserialize, Serialize};

use crate::{compiler::CompiledDocument, model::DocumentLink};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NotionPageArtifact {
    pub schema: String,
    pub producer: String,
    pub producer_version: String,
    pub document: NotionDocument,
    pub navigation: NotionNavigation,
    pub source: NotionSource,
    pub target: NotionTarget,
    pub web: Option<NotionWeb>,
    pub links: Vec<DocumentLink>,
    pub content: NotionContent,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NotionDocument {
    pub schema: String,
    pub id: String,
    pub title: String,
    pub description: String,
    pub kind: String,
    pub status: String,
    pub visibility: String,
    pub tags: Vec<String>,
}

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

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NotionSource {
    pub repository: String,
    pub path: String,
    pub commit: String,
    pub content_hash: String,
}

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

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

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NotionContent {
    pub format: String,
    pub markdown: String,
}

impl NotionPageArtifact {
    #[must_use]
    pub fn new(compiled: &CompiledDocument) -> Self {
        let metadata = &compiled.source.metadata;
        let notion = metadata
            .notion
            .as_ref()
            .expect("notion artifact requires notion target");

        Self {
            schema: "codexa.notion.page@2".into(),
            producer: "codexa".into(),
            producer_version: crate::VERSION.into(),
            document: NotionDocument {
                schema: metadata.schema.clone(),
                id: metadata.id.clone(),
                title: metadata.title.clone(),
                description: metadata.description.clone(),
                kind: metadata.kind.clone(),
                status: metadata.status.clone(),
                visibility: metadata.visibility.clone(),
                tags: metadata.tags.clone(),
            },
            navigation: NotionNavigation {
                root: metadata.navigation.root.clone(),
                product: metadata.navigation.product.clone(),
                section: metadata.navigation.section.clone(),
                order: metadata.navigation.order,
            },
            source: NotionSource {
                repository: compiled.repository.clone(),
                path: compiled.source_path.clone(),
                commit: compiled.commit.clone(),
                content_hash: compiled.content_hash.clone(),
            },
            target: NotionTarget {
                workspace: notion.workspace.clone(),
                root: metadata.navigation.root.clone(),
            },
            web: metadata.web.as_ref().map(|web| NotionWeb {
                slug: web.slug.clone(),
            }),
            links: compiled.links.clone(),
            content: NotionContent {
                format: "markdown".into(),
                markdown: compiled.source.body.clone(),
            },
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NotionManifest {
    pub schema: String,
    pub producer: String,
    pub producer_version: String,
    pub pages: Vec<NotionManifestPage>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NotionManifestPage {
    pub document_id: String,
    pub root: String,
    pub path: String,
}