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

//! Using the frontmatter parser with custom types.
//!
//! The frontmatter module works with any Serialize/Deserialize type,
//! independent of the rest of mdstore.
//!
//! Run with: cargo run --example custom_frontmatter

use mdstore::{generate_frontmatter, parse_frontmatter};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct BlogPost {
    author: String,
    tags: Vec<String>,
    published: bool,
    read_time_minutes: u32,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse existing markdown with custom frontmatter
    let markdown = r"---
author: Alice
tags:
  - rust
  - storage
  - tutorial
published: true
readTimeMinutes: 5
---

# Building a File-Based Database in Rust

In this post, we explore how to use Markdown files as a structured data store...

## Why Markdown?

Markdown files are human-readable, version-control friendly, and work with
existing tooling like editors, linters, and static site generators.";

    let (meta, title, body): (BlogPost, String, String) = parse_frontmatter(markdown)?;

    println!("Title: {title}");
    println!("Author: {}", meta.author);
    println!("Tags: {:?}", meta.tags);
    println!("Published: {}", meta.published);
    println!("Read time: {} min", meta.read_time_minutes);
    println!("Body length: {} chars", body.len());

    // Generate markdown from structured data
    let new_post = BlogPost {
        author: "Bob".to_string(),
        tags: vec!["rust".to_string(), "async".to_string()],
        published: false,
        read_time_minutes: 3,
    };

    let generated = generate_frontmatter(
        &new_post,
        "Async I/O Patterns",
        "A deep dive into async file operations in Rust.",
        None,
    );

    println!("\n--- Generated markdown ---\n{generated}");

    // Round-trip: parse what we just generated
    let (parsed, parsed_title, parsed_body): (BlogPost, String, String) =
        parse_frontmatter(&generated)?;
    println!("Round-trip title: {parsed_title}");
    println!("Round-trip author: {}", parsed.author);
    println!("Round-trip body: {parsed_body}");

    Ok(())
}