backbone-bucket 0.8.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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

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

use backbone_core::GenericCrudService;

use crate::presentation::dto::{CreateStoredFileDto, UpdateStoredFileDto};
use crate::domain::entity::StoredFile;
use crate::infrastructure::persistence::StoredFileRepository;

/// Application service for StoredFile 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 `stored_file_service_custom.rs`:
///
/// ```rust,ignore
/// pub struct StoredFileServiceCustom {
///     inner: Arc<StoredFileService>,
///     // add domain-specific dependencies here
/// }
/// ```
pub type StoredFileService = GenericCrudService<
    StoredFile,
    CreateStoredFileDto,
    UpdateStoredFileDto,
    StoredFileRepository,
>;

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

#[async_trait::async_trait]
impl backbone_core::write_guard::WriteGuard<StoredFile> for StoredFileRowRules {
    async fn check(
        &self,
        ctx: &backbone_core::write_guard::WriteCtx<'_, StoredFile>,
    ) -> 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 StoredFile.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"));
        }
        // `owner_id_required` (@required on StoredFile.owner_id)
        if (create || (update && r::changed(old.as_ref(), row, &["owner_id"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "owner_id")), r::not(r::is_empty(r::trim(r::field(row, "owner_id")))))) {
            refuse.push(Violation::new("owner_id", "required", "owner_id is required"));
        }
        // `path_required` (@required on StoredFile.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 StoredFile.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));
        }
        // `original_name_required` (@required on StoredFile.original_name)
        if (create || (update && r::changed(old.as_ref(), row, &["original_name"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "original_name")), r::not(r::is_empty(r::trim(r::field(row, "original_name")))))) {
            refuse.push(Violation::new("original_name", "required", "original_name is required"));
        }
        // `original_name_max_length` (@max(255) on StoredFile.original_name)
        if (create || (update && r::changed(old.as_ref(), row, &["original_name"]))) && !r::holds(&r::le(r::length(r::field(row, "original_name")), r::Val::Num(255.0_f64))) {
            refuse.push(Violation::new("original_name", "max_length", "original_name must be at most 255 characters").with_param("max", 255_i64));
        }
        // `size_bytes_non_negative` (@non_negative on StoredFile.size_bytes)
        if (create || (update && r::changed(old.as_ref(), row, &["size_bytes"]))) && !r::holds(&r::ge(r::field(row, "size_bytes"), r::Val::Num(0.0_f64))) {
            refuse.push(Violation::new("size_bytes", "non_negative", "size_bytes must not be negative"));
        }
        // `mime_type_required` (@required on StoredFile.mime_type)
        if (create || (update && r::changed(old.as_ref(), row, &["mime_type"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "mime_type")), r::not(r::is_empty(r::trim(r::field(row, "mime_type")))))) {
            refuse.push(Violation::new("mime_type", "required", "mime_type is required"));
        }
        // `mime_type_max_length` (@max(127) on StoredFile.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));
        }
        // `checksum_max_length` (@max(128) on StoredFile.checksum)
        if (create || (update && r::changed(old.as_ref(), row, &["checksum"]))) && !r::holds(&r::le(r::length(r::field(row, "checksum")), r::Val::Num(128.0_f64))) {
            refuse.push(Violation::new("checksum", "max_length", "checksum must be at most 128 characters").with_param("max", 128_i64));
        }
        // `owner_module_max_length` (@max(100) on StoredFile.owner_module)
        if (create || (update && r::changed(old.as_ref(), row, &["owner_module"]))) && !r::holds(&r::le(r::length(r::field(row, "owner_module")), r::Val::Num(100.0_f64))) {
            refuse.push(Violation::new("owner_module", "max_length", "owner_module must be at most 100 characters").with_param("max", 100_i64));
        }
        // `owner_entity_max_length` (@max(100) on StoredFile.owner_entity)
        if (create || (update && r::changed(old.as_ref(), row, &["owner_entity"]))) && !r::holds(&r::le(r::length(r::field(row, "owner_entity")), r::Val::Num(100.0_f64))) {
            refuse.push(Violation::new("owner_entity", "max_length", "owner_entity must be at most 100 characters").with_param("max", 100_i64));
        }
        // `field_name_max_length` (@max(100) on StoredFile.field_name)
        if (create || (update && r::changed(old.as_ref(), row, &["field_name"]))) && !r::holds(&r::le(r::length(r::field(row, "field_name")), r::Val::Num(100.0_f64))) {
            refuse.push(Violation::new("field_name", "max_length", "field_name must be at most 100 characters").with_param("max", 100_i64));
        }
        // `storage_key_required` (@required on StoredFile.storage_key)
        if (create || (update && r::changed(old.as_ref(), row, &["storage_key"]))) && !r::holds(&r::and(r::is_not_null(r::field(row, "storage_key")), r::not(r::is_empty(r::trim(r::field(row, "storage_key")))))) {
            refuse.push(Violation::new("storage_key", "required", "storage_key is required"));
        }
        // `storage_key_max_length` (@max(1024) on StoredFile.storage_key)
        if (create || (update && r::changed(old.as_ref(), row, &["storage_key"]))) && !r::holds(&r::le(r::length(r::field(row, "storage_key")), r::Val::Num(1024.0_f64))) {
            refuse.push(Violation::new("storage_key", "max_length", "storage_key must be at most 1024 characters").with_param("max", 1024_i64));
        }
        // `download_count_non_negative` (@non_negative on StoredFile.download_count)
        if (create || (update && r::changed(old.as_ref(), row, &["download_count"]))) && !r::holds(&r::ge(r::field(row, "download_count"), r::Val::Num(0.0_f64))) {
            refuse.push(Violation::new("download_count", "non_negative", "download_count must not be negative"));
        }
        // `path_length` (stored_file.hook.yaml:171)
        if (create || update) && !r::holds(&r::le(r::length(r::field(row, "path")), r::Val::Num(1024.0_f64))) {
            refuse.push(Violation::new("path", "path_too_long", "File path too long (max 1024 characters)"));
        }
        // `no_path_traversal` (stored_file.hook.yaml:177)
        if (create || update) && !r::holds(&r::not(r::contains(r::field(row, "path"), r::text("..")))) {
            refuse.push(Violation::new("path", "path_traversal", "Path traversal not allowed"));
        }
        // `filename_length` (stored_file.hook.yaml:183)
        if (create) && !r::holds(&r::le(r::length(r::field(row, "original_name")), r::Val::Num(255.0_f64))) {
            refuse.push(Violation::new("original_name", "filename_too_long", "File name too long (max 255 characters)"));
        }
        // `valid_mime_type` (stored_file.hook.yaml:189)
        if (create) && !r::holds(&r::matches(r::field(row, "mime_type"), "^[a-z]+/[a-z0-9.+-]+$")) {
            refuse.push(Violation::new("mime_type", "invalid_mime_type", "Invalid MIME type format"));
        }
        // `file_not_purged` (stored_file.hook.yaml:195)
        if (update) && !r::holds(&r::ne(r::field(row, "status"), r::text("purged"))) {
            refuse.push(Violation::new("status", "file_purged", "Cannot update purged files"));
        }
        // `quarantine_admin_only` (stored_file.hook.yaml:201)
        if (update) && !r::holds(&r::or(r::ne(r::field(row, "status"), r::text("quarantined")), r::has_role(ctx.actor.as_deref(), "admin").await)) {
            refuse.push(Violation::new("status", "quarantine_restricted", "Only admins can modify quarantined files"));
        }
        GuardOutcome { refuse, shadow }
    }
}