backbone-bucket 0.2.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

//! Create Bucket use case
//!
//! Generated by backbone-schema. Do not edit manually.

use std::sync::Arc;

use anyhow::Result;
use async_trait::async_trait;

use super::UseCase;
use crate::domain::entity::Bucket;
use crate::infrastructure::persistence::BucketRepository;

/// Input for creating a Bucket
#[derive(Debug, Clone)]
pub struct CreateBucketInput {
    pub name: String,
    pub slug: String,
    pub description: Option<String>,
    pub owner_id: Uuid,
    pub bucket_type: BucketType,
    pub status: BucketStatus,
    pub storage_backend: StorageBackend,
    pub root_path: String,
    pub file_count: i32,
    pub total_size_bytes: i64,
    pub max_file_size: Option<i64>,
    pub allowed_mime_types: Vec<String>,
    pub auto_delete_after_days: Option<i32>,
    pub enable_cdn: bool,
    pub enable_versioning: bool,
    pub enable_deduplication: bool,
    pub metadata: serde_json::Value,
}

/// Output after creating a Bucket
#[derive(Debug, Clone)]
pub struct CreateBucketOutput {
    pub bucket: Bucket,
}

/// Use case for creating a new Bucket
pub struct CreateBucketUseCase {
    repository: Arc<BucketRepository>,
}

impl CreateBucketUseCase {
    /// Create a new use case instance
    pub fn new(repository: Arc<BucketRepository>) -> Self {
        Self { repository }
    }
}

#[async_trait]
impl UseCase for CreateBucketUseCase {
    type Input = CreateBucketInput;
    type Output = CreateBucketOutput;

    async fn execute(&self, input: Self::Input) -> Result<Self::Output> {
        // Create entity from input
        let entity = Bucket {
            id: None,
            name: input.name,
            slug: input.slug,
            description: input.description,
            owner_id: input.owner_id,
            bucket_type: input.bucket_type,
            status: input.status,
            storage_backend: input.storage_backend,
            root_path: input.root_path,
            file_count: input.file_count,
            total_size_bytes: input.total_size_bytes,
            max_file_size: input.max_file_size,
            allowed_mime_types: input.allowed_mime_types,
            auto_delete_after_days: input.auto_delete_after_days,
            enable_cdn: input.enable_cdn,
            enable_versioning: input.enable_versioning,
            enable_deduplication: input.enable_deduplication,
            metadata: input.metadata,
        };

        // <<< CUSTOM VALIDATION START >>>
        // Add custom validation logic here
        // <<< CUSTOM VALIDATION END >>>

        // Persist entity
        let created = self.repository.create(entity).await?;

        Ok(CreateBucketOutput { bucket: created })
    }
}