backbone-bucket 0.6.0

Bucket Bounded Context: File Storage Module for Backbone Framework
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

//! Application service for UploadSession entities
//!
//! Generated by metaphor-schema. Do not edit manually.
//!
//! Type alias over `GenericCrudService` — all CRUD logic lives in backbone-core.
//! For custom behaviour, create `upload_session_service_custom.rs` (preserved on regen).

use backbone_core::GenericCrudService;

use crate::presentation::dto::{CreateUploadSessionDto, UpdateUploadSessionDto};
use crate::domain::entity::UploadSession;
use crate::infrastructure::persistence::UploadSessionRepository;

/// Application service for UploadSession entities.
///
/// All 12 standard CRUD operations (list, create, get, update, patch,
/// soft_delete, restore, empty_trash, bulk_create, upsert, find_by_id,
/// list_deleted) are provided by `GenericCrudService`.
///
/// Custom extensions go in `upload_session_service_custom.rs`:
///
/// ```rust,ignore
/// pub struct UploadSessionServiceCustom {
///     inner: Arc<UploadSessionService>,
///     // add domain-specific dependencies here
/// }
/// ```
pub type UploadSessionService = GenericCrudService<
    UploadSession,
    CreateUploadSessionDto,
    UpdateUploadSessionDto,
    UploadSessionRepository,
>;

/// The rules the schema declares for UploadSession, checked against the row a create or update
/// would store. The generated build attaches it to [`UploadSessionService`]. A refusing rule's
/// break answers 422; a rule in shadow is logged under `backbone::write_guard` and the
/// write goes ahead.
pub struct UploadSessionRowRules;

#[async_trait::async_trait]
impl backbone_core::write_guard::WriteGuard<UploadSession> for UploadSessionRowRules {
    async fn check(
        &self,
        ctx: &backbone_core::write_guard::WriteCtx<'_, UploadSession>,
    ) -> backbone_core::write_guard::GuardOutcome {
        use backbone_core::row_rule as r;
        use backbone_core::violation::Violation;
        use backbone_core::write_guard::{GuardOutcome, WriteKind};
        let (create, update) = (ctx.kind == WriteKind::Create, ctx.kind == WriteKind::Update);
        let Some(after) = ctx.after.filter(|_| create || update) else {
            return GuardOutcome::allow();
        };
        let Ok(row) = serde_json::to_value(after) else {
            return GuardOutcome::allow();
        };
        let row = &row;
        let old = ctx.before.and_then(|b| serde_json::to_value(b).ok());
        let mut shadow = Vec::new();
        let mut refuse = Vec::new();
        // `status` belongs to a state machine: only its verbs move it
        if update && ctx.transition.is_none() && r::changed(old.as_ref(), row, &["status"]) {
            shadow.push(Violation::new("status", "state_field_verbs_only", "the state field moves only through its verbs"));
        }
        // `bucket_id_required` (@required on UploadSession.bucket_id)
        if (create || (update && r::changed(old.as_ref(), row, &["bucket_id"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "bucket_id")), r::not(r::is_empty(r::trim(r::field(row, "bucket_id")))))) {
            refuse.push(Violation::new("bucket_id", "required", "bucket_id is required"));
        }
        // `user_id_required` (@required on UploadSession.user_id)
        if (create || (update && r::changed(old.as_ref(), row, &["user_id"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "user_id")), r::not(r::is_empty(r::trim(r::field(row, "user_id")))))) {
            refuse.push(Violation::new("user_id", "required", "user_id is required"));
        }
        // `path_required` (@required on UploadSession.path)
        if (create || (update && r::changed(old.as_ref(), row, &["path"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "path")), r::not(r::is_empty(r::trim(r::field(row, "path")))))) {
            refuse.push(Violation::new("path", "required", "path is required"));
        }
        // `path_max_length` (@max(1024) on UploadSession.path)
        if (create || (update && r::changed(old.as_ref(), row, &["path"]))) && !r::holds(&r::le(r::length(r::field(row, "path")), r::Val::Num(1024.0_f64))) {
            refuse.push(Violation::new("path", "max_length", "path must be at most 1024 characters").with_param("max", 1024_i64));
        }
        // `filename_required` (@required on UploadSession.filename)
        if (create || (update && r::changed(old.as_ref(), row, &["filename"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "filename")), r::not(r::is_empty(r::trim(r::field(row, "filename")))))) {
            refuse.push(Violation::new("filename", "required", "filename is required"));
        }
        // `filename_max_length` (@max(255) on UploadSession.filename)
        if (create || (update && r::changed(old.as_ref(), row, &["filename"]))) && !r::holds(&r::le(r::length(r::field(row, "filename")), r::Val::Num(255.0_f64))) {
            refuse.push(Violation::new("filename", "max_length", "filename must be at most 255 characters").with_param("max", 255_i64));
        }
        // `mime_type_max_length` (@max(127) on UploadSession.mime_type)
        if (create || (update && r::changed(old.as_ref(), row, &["mime_type"]))) && !r::holds(&r::le(r::length(r::field(row, "mime_type")), r::Val::Num(127.0_f64))) {
            refuse.push(Violation::new("mime_type", "max_length", "mime_type must be at most 127 characters").with_param("max", 127_i64));
        }
        // `file_size_positive` (@positive on UploadSession.file_size)
        if (create || (update && r::changed(old.as_ref(), row, &["file_size"]))) && !r::holds(&r::gt(r::field(row, "file_size"), r::Val::Num(0.0_f64))) {
            refuse.push(Violation::new("file_size", "positive", "file_size must be positive"));
        }
        // `chunk_size_positive` (@positive on UploadSession.chunk_size)
        if (create || (update && r::changed(old.as_ref(), row, &["chunk_size"]))) && !r::holds(&r::gt(r::field(row, "chunk_size"), r::Val::Num(0.0_f64))) {
            refuse.push(Violation::new("chunk_size", "positive", "chunk_size must be positive"));
        }
        // `total_chunks_positive` (@positive on UploadSession.total_chunks)
        if (create || (update && r::changed(old.as_ref(), row, &["total_chunks"]))) && !r::holds(&r::gt(r::field(row, "total_chunks"), r::Val::Num(0.0_f64))) {
            refuse.push(Violation::new("total_chunks", "positive", "total_chunks must be positive"));
        }
        // `uploaded_chunks_non_negative` (@non_negative on UploadSession.uploaded_chunks)
        if (create || (update && r::changed(old.as_ref(), row, &["uploaded_chunks"]))) && !r::holds(&r::ge(r::field(row, "uploaded_chunks"), r::Val::Num(0.0_f64))) {
            refuse.push(Violation::new("uploaded_chunks", "non_negative", "uploaded_chunks must not be negative"));
        }
        // `valid_file_size` (upload_session.hook.yaml:135)
        if (create) && !r::holds(&r::gt(r::field(row, "file_size"), r::Val::Num(0.0_f64))) {
            refuse.push(Violation::new("file_size", "invalid_file_size", "File size must be positive"));
        }
        // `minimum_chunk_size` (upload_session.hook.yaml:141)
        if (create) && !r::holds(&r::ge(r::field(row, "chunk_size"), r::Val::Num(5242880.0_f64))) {
            refuse.push(Violation::new("chunk_size", "chunk_too_small", "Chunk size must be at least 5MB"));
        }
        // `reasonable_chunk_size` (upload_session.hook.yaml:147)
        if (create) && !r::holds(&r::le(r::field(row, "chunk_size"), r::Val::Num(5368709120.0_f64))) {
            refuse.push(Violation::new("chunk_size", "chunk_too_large", "Chunk size must not exceed 5GB"));
        }
        // `valid_chunk_count` (upload_session.hook.yaml:153)
        if (create) && !r::holds(&r::eq(r::field(row, "total_chunks"), r::ceil(r::div(r::field(row, "file_size"), r::field(row, "chunk_size"))))) {
            refuse.push(Violation::new("total_chunks", "invalid_chunk_count", "Total chunks must match file size and chunk size"));
        }
        // `valid_path` (upload_session.hook.yaml:159)
        if (create) && !r::holds(&r::and(r::and(r::is_not_null(r::field(row, "path")), r::not(r::contains(r::field(row, "path"), r::text("..")))), r::le(r::length(r::field(row, "path")), r::Val::Num(1024.0_f64)))) {
            refuse.push(Violation::new("path", "invalid_path", "Path must be valid and not contain traversal"));
        }
        // `valid_expiration` (upload_session.hook.yaml:165)
        if (create) && !r::holds(&r::gt(r::field(row, "expires_at"), r::at(ctx.at))) {
            refuse.push(Violation::new("expires_at", "invalid_expiration", "Expiration must be in future"));
        }
        GuardOutcome { refuse, shadow }
    }
}