mplib 0.1.2

mplib: Micropub Publisher Library | Publish text-only blog posts to Micropub endpoints.
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

use std::time::Duration;

use reqwest::ClientBuilder;
use serde::Deserialize;
use serde_json::from_str;
use thiserror::Error;

pub use crate::micropub_service::MicropubService;
use crate::post::Post;

pub use crate::post_result::PostResult;

const DEFAULT_TIMEOUT_SECS: u64 = 5;

/// Publish a Post via a Micropub service.
pub async fn publish_post(post: Post, service: &MicropubService) -> Result<PostResult, PostError> {
    if post.is_empty() {
        return Err(PostError::InvalidInput(
            "Post content cannot be empty".to_string(),
        ));
    }

    let client = build_client()?;
    let post_status = post.status.clone();
    let response = send_post_request(&client, post, service).await?;

    let status = response.status();
    let text: String = response.text().await?;

    if !status.is_success() {
        let api_error: ApiPostError = from_str(&text)?;
        return Err(PostError::Api {
            error: api_error.error,
            description: api_error.error_description,
        });
    }

    let api_response: ApiPostResponse = from_str(&text)?;
    Ok(PostResult {
        url: api_response.url,
        preview: api_response.preview,
        edit: api_response.edit,
        post_status,
    })
}

/// Build an HTTP client with a default timeout.
fn build_client() -> Result<reqwest::Client, PostError> {
    let timeout = Duration::from_secs(DEFAULT_TIMEOUT_SECS);
    ClientBuilder::new()
        .timeout(timeout)
        .build()
        .map_err(PostError::Network)
}

/// Send a POST request to the Micropub endpoint with the given post data.
async fn send_post_request(
    client: &reqwest::Client,
    post: Post,
    microblog_service: &MicropubService,
) -> Result<reqwest::Response, PostError> {
    // Prepare form parameters. If post has a title, include it. Otherwise, omit it.
    let params = [
        ("h", "entry"),
        ("content", post.body.as_str()),
        ("post-status", post.status.as_str()),
    ]
    .into_iter()
    .chain(post.title.as_ref().map(|t| ("name", t.as_str())))
    .collect::<Vec<_>>();

    // Send the POST request.
    client
        .post(&microblog_service.api_url)
        .form(&params)
        .bearer_auth(&microblog_service.auth_token)
        .send()
        .await
        .map_err(PostError::Network)
}

/// Represents errors that can occur while publishing a post.
#[derive(Error, Debug)]
pub enum PostError {
    #[error("Network error: {0}")]
    Network(#[from] reqwest::Error),
    #[error("API error: {error} - {description}")]
    Api { error: String, description: String },
    #[error("JSON parsing error: {0}")]
    Json(#[from] serde_json::Error),
    #[error("Invalid input: {0}")]
    InvalidInput(String),
}

/// Represents the expected response from the Micropub API upon successful post creation.
#[derive(Deserialize)]
struct ApiPostResponse {
    url: String,
    preview: String,
    edit: String,
}

/// Represents the expected error response from the Micropub API upon a failed post creation.
#[derive(Deserialize)]
struct ApiPostError {
    error: String,
    error_description: String,
}