mdstore 1.2.0

A file-based storage engine that stores structured data as Markdown files with YAML frontmatter
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

//! Demonstrates optional comment support at the top of frontmatter blocks.
//!
//! Run with: cargo run --example frontmatter_comment

use mdstore::config::IdStrategy;
use mdstore::{CreateOptions, TypeConfig, TypeFeatures, UpdateOptions};
use std::collections::HashMap;
use std::path::{Path, PathBuf};

fn config() -> TypeConfig {
    TypeConfig {
        name: "Doc".to_string(),
        identifier: IdStrategy::Uuid,
        features: TypeFeatures {
            display_number: false,
            status: false,
            priority: false,
            assets: false,
            org_sync: false,
            move_item: false,
            duplicate: false,
        },
        statuses: Vec::new(),
        default_status: None,
        priority_levels: None,
        custom_fields: Vec::new(),
    }
}

fn output_dir() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/output/frontmatter_comment")
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let base = output_dir();
    if base.exists() {
        tokio::fs::remove_dir_all(&base).await?;
    }
    let type_dir = base.join("docs");
    let config = config();

    let comment = "# This file was auto-generated. Do not edit manually.";

    // --- File 1: comment is created and preserved ---

    let item1 = mdstore::create(
        &type_dir,
        &config,
        CreateOptions {
            title: "Getting Started".to_string(),
            body: "Welcome to the docs.".to_string(),
            id: None,
            status: None,
            priority: None,
            tags: None,
            projects: None,
            custom_fields: HashMap::new(),
            comment: Some(comment.to_string()),
        },
    )
    .await?;

    println!("Created '{}' (id: {})", item1.title, item1.id);
    println!("Comment: {:?}", item1.comment);

    // Update body — comment is preserved because UpdateOptions::comment is None
    let updated1 = mdstore::update(
        &type_dir,
        &config,
        &item1.id,
        UpdateOptions {
            body: Some("Updated body content.".to_string()),
            ..Default::default()
        },
    )
    .await?;
    println!("After update (comment preserved): {:?}", updated1.comment);

    let raw1 = tokio::fs::read_to_string(type_dir.join(format!("{}.md", item1.id))).await?;
    println!("\n--- File 1 (comment kept) ---\n{raw1}--- end ---\n");

    // --- File 2: comment is created then cleared ---

    let item2 = mdstore::create(
        &type_dir,
        &config,
        CreateOptions {
            title: "Reference".to_string(),
            body: "API reference docs.".to_string(),
            id: None,
            status: None,
            priority: None,
            tags: None,
            projects: None,
            custom_fields: HashMap::new(),
            comment: Some(comment.to_string()),
        },
    )
    .await?;

    println!("Created '{}' (id: {})", item2.title, item2.id);
    println!("Comment: {:?}", item2.comment);

    // Clear the comment by passing Some("")
    let cleared2 = mdstore::update(
        &type_dir,
        &config,
        &item2.id,
        UpdateOptions {
            comment: Some(String::new()),
            ..Default::default()
        },
    )
    .await?;
    println!("After comment clear: {:?}", cleared2.comment);

    let raw2 = tokio::fs::read_to_string(type_dir.join(format!("{}.md", item2.id))).await?;
    println!("\n--- File 2 (comment cleared) ---\n{raw2}--- end ---\n");

    Ok(())
}