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

use crate::domain::entities::{CompatibilityMode, Schema};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use uuid::Uuid;

/// DTO for registering a new schema
#[derive(Debug, Deserialize)]
pub struct RegisterSchemaRequest {
    pub subject: String,
    pub schema: Value,
    pub compatibility_mode: Option<CompatibilityModeDto>,
    pub description: Option<String>,
    pub tags: Option<Vec<String>>,
}

/// DTO for updating a schema
#[derive(Debug, Deserialize)]
pub struct UpdateSchemaRequest {
    pub description: Option<String>,
    pub tags: Option<Vec<String>>,
    pub compatibility_mode: Option<CompatibilityModeDto>,
}

/// DTO for compatibility mode
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum CompatibilityModeDto {
    None,
    Backward,
    Forward,
    Full,
}

impl From<CompatibilityMode> for CompatibilityModeDto {
    fn from(mode: CompatibilityMode) -> Self {
        match mode {
            CompatibilityMode::None => CompatibilityModeDto::None,
            CompatibilityMode::Backward => CompatibilityModeDto::Backward,
            CompatibilityMode::Forward => CompatibilityModeDto::Forward,
            CompatibilityMode::Full => CompatibilityModeDto::Full,
        }
    }
}

impl From<CompatibilityModeDto> for CompatibilityMode {
    fn from(dto: CompatibilityModeDto) -> Self {
        match dto {
            CompatibilityModeDto::None => CompatibilityMode::None,
            CompatibilityModeDto::Backward => CompatibilityMode::Backward,
            CompatibilityModeDto::Forward => CompatibilityMode::Forward,
            CompatibilityModeDto::Full => CompatibilityMode::Full,
        }
    }
}

/// DTO for schema response
#[derive(Debug, Serialize)]
pub struct SchemaDto {
    pub id: Uuid,
    pub subject: String,
    pub version: u32,
    pub schema: Value,
    pub compatibility_mode: CompatibilityModeDto,
    pub description: Option<String>,
    pub tags: Vec<String>,
    pub created_at: DateTime<Utc>,
}

impl From<&Schema> for SchemaDto {
    fn from(schema: &Schema) -> Self {
        Self {
            id: schema.id(),
            subject: schema.subject().to_string(),
            version: schema.version(),
            schema: schema.schema_definition().clone(),
            compatibility_mode: schema.compatibility_mode().into(),
            description: schema.description().map(String::from),
            tags: schema.tags().to_vec(),
            created_at: schema.created_at(),
        }
    }
}

impl From<Schema> for SchemaDto {
    fn from(schema: Schema) -> Self {
        SchemaDto::from(&schema)
    }
}

/// Response for schema registration
#[derive(Debug, Serialize)]
pub struct RegisterSchemaResponse {
    pub schema: SchemaDto,
}

/// Response for listing schemas
#[derive(Debug, Serialize)]
pub struct ListSchemasResponse {
    pub schemas: Vec<SchemaDto>,
    pub count: usize,
}

/// Request for validating an event against a schema
#[derive(Debug, Deserialize)]
pub struct ValidateEventRequest {
    pub subject: String,
    pub event: Value,
}

/// Response for event validation
#[derive(Debug, Serialize)]
pub struct ValidateEventResponse {
    pub valid: bool,
    pub errors: Option<Vec<String>>,
}