allsource-core 0.19.1

High-performance event store core built in Rust
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::domain::entities::{ArticleStats, ArticleStatus, PaywallArticle};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

/// DTO for creating a new article
#[derive(Debug, Deserialize)]
pub struct CreateArticleRequest {
    pub article_id: String,
    pub tenant_id: String,
    pub creator_id: String,
    pub title: String,
    pub url: String,
    pub price_cents: u64,
    pub description: Option<String>,
    pub estimated_reading_time_minutes: Option<u16>,
    pub preview_content: Option<String>,
    /// If true, create as draft (not immediately published)
    pub is_draft: Option<bool>,
}

/// DTO for article creation response
#[derive(Debug, Serialize)]
pub struct CreateArticleResponse {
    pub article: ArticleDto,
}

/// DTO for updating an article
#[derive(Debug, Deserialize)]
pub struct UpdateArticleRequest {
    pub title: Option<String>,
    pub url: Option<String>,
    pub price_cents: Option<u64>,
    pub description: Option<String>,
    pub estimated_reading_time_minutes: Option<u16>,
    pub preview_content: Option<String>,
}

/// DTO for article update response
#[derive(Debug, Serialize)]
pub struct UpdateArticleResponse {
    pub article: ArticleDto,
}

/// DTO for listing articles response
#[derive(Debug, Serialize)]
pub struct ListArticlesResponse {
    pub articles: Vec<ArticleDto>,
    pub count: usize,
}

/// DTO for article status
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum ArticleStatusDto {
    Draft,
    Active,
    Archived,
    Deleted,
}

impl From<ArticleStatus> for ArticleStatusDto {
    fn from(status: ArticleStatus) -> Self {
        match status {
            ArticleStatus::Draft => ArticleStatusDto::Draft,
            ArticleStatus::Active => ArticleStatusDto::Active,
            ArticleStatus::Archived => ArticleStatusDto::Archived,
            ArticleStatus::Deleted => ArticleStatusDto::Deleted,
        }
    }
}

/// DTO for article statistics
#[derive(Debug, Clone, Serialize)]
pub struct ArticleStatsDto {
    pub total_purchases: u64,
    pub total_revenue_cents: u64,
    pub unique_readers: u64,
    pub avg_read_duration_seconds: u64,
    pub avg_scroll_depth: u8,
    pub conversion_rate: f32,
}

impl From<&ArticleStats> for ArticleStatsDto {
    fn from(stats: &ArticleStats) -> Self {
        Self {
            total_purchases: stats.total_purchases,
            total_revenue_cents: stats.total_revenue_cents,
            unique_readers: stats.unique_readers,
            avg_read_duration_seconds: stats.avg_read_duration_seconds,
            avg_scroll_depth: stats.avg_scroll_depth,
            conversion_rate: stats.conversion_rate,
        }
    }
}

/// DTO for a paywall article in responses
#[derive(Debug, Clone, Serialize)]
pub struct ArticleDto {
    pub id: String,
    pub tenant_id: String,
    pub creator_id: String,
    pub title: String,
    pub url: String,
    pub price_cents: u64,
    pub description: Option<String>,
    pub estimated_reading_time_minutes: Option<u16>,
    pub preview_content: Option<String>,
    pub status: ArticleStatusDto,
    pub stats: ArticleStatsDto,
    pub is_purchasable: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub published_at: Option<DateTime<Utc>>,
}

impl From<&PaywallArticle> for ArticleDto {
    fn from(article: &PaywallArticle) -> Self {
        Self {
            id: article.id().to_string(),
            tenant_id: article.tenant_id().to_string(),
            creator_id: article.creator_id().as_uuid().to_string(),
            title: article.title().to_string(),
            url: article.url().to_string(),
            price_cents: article.price_cents(),
            description: article.description().map(std::string::ToString::to_string),
            estimated_reading_time_minutes: article.estimated_reading_time_minutes(),
            preview_content: article
                .preview_content()
                .map(std::string::ToString::to_string),
            status: article.status().into(),
            stats: article.stats().into(),
            is_purchasable: article.is_purchasable(),
            created_at: article.created_at(),
            updated_at: article.updated_at(),
            published_at: article.published_at(),
        }
    }
}

impl From<PaywallArticle> for ArticleDto {
    fn from(article: PaywallArticle) -> Self {
        ArticleDto::from(&article)
    }
}