cf-file-parser 0.1.23

File Parser module
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

use modkit_canonical_errors::{CanonicalError, Problem, resource_error};

use crate::domain::error::DomainError;

#[resource_error("gts.cf.file_parser.parser.file.v1~")]
pub struct FileParserError;

/// Convert domain errors to HTTP Problem responses
#[must_use]
pub fn domain_error_to_problem(err: DomainError) -> Problem {
    match err {
        DomainError::FileNotFound { path } => FileParserError::not_found("File not found")
            .with_resource(path)
            .create()
            .into(),

        DomainError::UnsupportedFileType { extension } => FileParserError::invalid_argument()
            .with_field_violation(
                "content_type",
                format!("Unsupported file type: {extension}"),
                "UNSUPPORTED_CONTENT_TYPE",
            )
            .create()
            .into(),

        DomainError::NoParserAvailable { extension } => FileParserError::invalid_argument()
            .with_field_violation(
                "content_type",
                format!("No parser available for extension: {extension}"),
                "UNSUPPORTED_CONTENT_TYPE",
            )
            .create()
            .into(),

        DomainError::ParseError { message } => FileParserError::invalid_argument()
            .with_field_violation("body", message, "PARSE_ERROR")
            .create()
            .into(),

        DomainError::IoError { message } => {
            tracing::error!(error = %message, "file-parser I/O error");
            CanonicalError::internal(message).create().into()
        }

        DomainError::InvalidRequest { message } => FileParserError::invalid_argument()
            .with_constraint(message)
            .create()
            .into(),

        DomainError::PathTraversalBlocked { message } => {
            tracing::warn!(error = %message, "path traversal blocked");
            FileParserError::permission_denied()
                .with_reason("PATH_TRAVERSAL_BLOCKED")
                .create()
                .into()
        }
    }
}

/// Implement Into<Problem> for `DomainError` so `?` works in handlers
impl From<DomainError> for Problem {
    fn from(e: DomainError) -> Self {
        domain_error_to_problem(e)
    }
}