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

use crate::domain::entities::{Tenant, TenantQuotas};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

/// DTO for creating a new tenant
#[derive(Debug, Deserialize)]
pub struct CreateTenantRequest {
    pub tenant_id: String,
    pub name: String,
    pub quotas: Option<TenantQuotasDto>,
}

/// DTO for updating a tenant
#[derive(Debug, Deserialize)]
pub struct UpdateTenantRequest {
    pub name: Option<String>,
    pub quotas: Option<TenantQuotasDto>,
}

/// DTO for tenant quotas
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TenantQuotasDto {
    pub max_events_per_day: Option<usize>,
    pub max_storage_bytes: Option<u64>,
    pub max_queries_per_hour: Option<usize>,
    pub max_api_keys: Option<usize>,
    pub max_projections: Option<usize>,
    pub max_pipelines: Option<usize>,
}

impl From<TenantQuotas> for TenantQuotasDto {
    fn from(quotas: TenantQuotas) -> Self {
        Self {
            max_events_per_day: if quotas.max_events_per_day() == 0 {
                None
            } else {
                Some(quotas.max_events_per_day() as usize)
            },
            max_storage_bytes: if quotas.max_storage_bytes() == 0 {
                None
            } else {
                Some(quotas.max_storage_bytes())
            },
            max_queries_per_hour: if quotas.max_queries_per_hour() == 0 {
                None
            } else {
                Some(quotas.max_queries_per_hour() as usize)
            },
            max_api_keys: if quotas.max_api_keys() == 0 {
                None
            } else {
                Some(quotas.max_api_keys() as usize)
            },
            max_projections: if quotas.max_projections() == 0 {
                None
            } else {
                Some(quotas.max_projections() as usize)
            },
            max_pipelines: if quotas.max_pipelines() == 0 {
                None
            } else {
                Some(quotas.max_pipelines() as usize)
            },
        }
    }
}

impl From<TenantQuotasDto> for TenantQuotas {
    fn from(dto: TenantQuotasDto) -> Self {
        TenantQuotas::new(
            dto.max_events_per_day.map_or(0, |v| v as u64),
            dto.max_storage_bytes.unwrap_or(0),
            dto.max_queries_per_hour.map_or(0, |v| v as u64),
            dto.max_api_keys.map_or(0, |v| v as u32),
            dto.max_projections.map_or(0, |v| v as u32),
            dto.max_pipelines.map_or(0, |v| v as u32),
        )
    }
}

/// DTO for tenant response
#[derive(Debug, Serialize)]
pub struct TenantDto {
    pub id: Uuid,
    pub tenant_id: String,
    pub name: String,
    pub is_active: bool,
    pub is_demo: bool,
    pub quotas: TenantQuotasDto,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

impl From<&Tenant> for TenantDto {
    fn from(tenant: &Tenant) -> Self {
        Self {
            id: Uuid::new_v4(), // Tenant uses TenantId as ID, not UUID
            tenant_id: tenant.id().to_string(),
            name: tenant.name().to_string(),
            is_active: tenant.is_active(),
            is_demo: tenant.is_demo(),
            quotas: tenant.quotas().clone().into(),
            created_at: tenant.created_at(),
            updated_at: tenant.updated_at(),
        }
    }
}

impl From<Tenant> for TenantDto {
    fn from(tenant: Tenant) -> Self {
        TenantDto::from(&tenant)
    }
}

/// Response for tenant creation
#[derive(Debug, Serialize)]
pub struct CreateTenantResponse {
    pub tenant: TenantDto,
}

/// Response for tenant update
#[derive(Debug, Serialize)]
pub struct UpdateTenantResponse {
    pub tenant: TenantDto,
}

/// Response for listing tenants
#[derive(Debug, Serialize)]
pub struct ListTenantsResponse {
    pub tenants: Vec<TenantDto>,
    pub count: usize,
}