fraiseql-server 2.0.0-alpha.1

HTTP server for FraiseQL v2 GraphQL engine
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

//! Testing seams for file operations

use std::{collections::HashMap, time::Duration};

use async_trait::async_trait;
use bytes::Bytes;

use crate::files::{
    config::{FileConfig, ProcessingConfig},
    error::{FileError, ProcessingError, ScanError, StorageError},
    processing::ProcessedImages,
};

/// Storage backend abstraction for testing
#[async_trait]
pub trait StorageBackend: Send + Sync {
    fn name(&self) -> &'static str;

    async fn upload(
        &self,
        key: &str,
        data: Bytes,
        content_type: &str,
        metadata: Option<&StorageMetadata>,
    ) -> Result<StorageResult, StorageError>;

    async fn download(&self, key: &str) -> Result<Bytes, StorageError>;
    async fn delete(&self, key: &str) -> Result<(), StorageError>;
    async fn exists(&self, key: &str) -> Result<bool, StorageError>;
    async fn metadata(&self, key: &str) -> Result<StorageMetadata, StorageError>;
    async fn signed_url(&self, key: &str, expiry: Duration) -> Result<String, StorageError>;
    fn public_url(&self, key: &str) -> String;
}

#[derive(Debug, Clone)]
pub struct StorageMetadata {
    pub content_type:   String,
    pub content_length: u64,
    pub etag:           Option<String>,
    pub last_modified:  Option<chrono::DateTime<chrono::Utc>>,
    pub custom:         HashMap<String, String>,
}

#[derive(Debug)]
pub struct StorageResult {
    pub key:  String,
    pub url:  String,
    pub etag: Option<String>,
    pub size: u64,
}

/// File validator abstraction for testing
pub trait FileValidator: Send + Sync {
    fn validate(
        &self,
        data: &Bytes,
        declared_type: &str,
        filename: &str,
        config: &FileConfig,
    ) -> Result<ValidatedFile, FileError>;
}

/// Image processor abstraction for testing
#[async_trait]
pub trait ImageProcessor: Send + Sync {
    async fn process(
        &self,
        data: &Bytes,
        config: &ProcessingConfig,
    ) -> Result<ProcessedImages, ProcessingError>;
}

/// Malware scanner abstraction (optional external service)
#[async_trait]
pub trait MalwareScanner: Send + Sync {
    async fn scan(&self, data: &Bytes) -> Result<ScanResult, ScanError>;
}

#[derive(Debug)]
pub struct ScanResult {
    pub clean:           bool,
    pub threat_name:     Option<String>,
    pub scanner_version: String,
}

#[derive(Debug)]
pub struct ValidatedFile {
    pub content_type:       String,
    pub sanitized_filename: String,
    pub size:               usize,
    pub detected_type:      Option<String>,
}