tideway 0.1.0

A batteries-included Rust web framework built on Axum for building SaaS applications quickly
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

//! Form data extractors and helpers
//!
//! This module provides utilities for extracting and validating form data,
//! including multipart form data for file uploads.

use axum::extract::Form as AxumForm;

/// Form data extractor
///
/// This is a thin wrapper around Axum's `Form` extractor.
pub type Form<T> = AxumForm<T>;

/// Multipart form data extractor for file uploads
///
/// This is a thin wrapper around Axum's `Multipart` extractor.
/// Multipart support is enabled by default in Tideway's Axum dependency.
pub type Multipart = axum::extract::Multipart;

/// File upload configuration
#[derive(Debug, Clone)]
pub struct FileConfig {
    /// Maximum file size in bytes
    pub max_size: usize,

    /// Allowed MIME types
    pub allowed_types: Vec<String>,

    /// Allowed file extensions
    pub allowed_extensions: Vec<String>,
}

impl Default for FileConfig {
    fn default() -> Self {
        Self {
            max_size: 10 * 1024 * 1024, // 10MB default
            allowed_types: vec![],
            allowed_extensions: vec![],
        }
    }
}

impl FileConfig {
    /// Create a new file config with size limit
    pub fn with_max_size(max_size: usize) -> Self {
        Self {
            max_size,
            ..Default::default()
        }
    }

    /// Add allowed MIME type
    pub fn allow_type(mut self, mime_type: impl Into<String>) -> Self {
        self.allowed_types.push(mime_type.into());
        self
    }

    /// Add allowed file extension
    pub fn allow_extension(mut self, ext: impl Into<String>) -> Self {
        self.allowed_extensions.push(ext.into());
        self
    }

    /// Validate file size
    pub fn validate_size(&self, size: usize) -> Result<(), String> {
        if size > self.max_size {
            return Err(format!("File size {} exceeds maximum {}", size, self.max_size));
        }
        Ok(())
    }

    /// Validate MIME type
    pub fn validate_type(&self, mime_type: &str) -> Result<(), String> {
        if !self.allowed_types.is_empty() && !self.allowed_types.contains(&mime_type.to_string()) {
            return Err(format!("MIME type {} not allowed", mime_type));
        }
        Ok(())
    }

    /// Validate file extension
    pub fn validate_extension(&self, filename: &str) -> Result<(), String> {
        if !self.allowed_extensions.is_empty() {
            if let Some(ext) = filename.split('.').last() {
                if !self.allowed_extensions.contains(&ext.to_lowercase()) {
                    return Err(format!("File extension .{} not allowed", ext));
                }
            } else {
                return Err("File has no extension".to_string());
            }
        }
        Ok(())
    }
}