ferro-hgvs 0.4.1

HGVS variant normalizer - part of the ferro bioinformatics toolkit
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

//! HGVS normalization endpoints

use axum::{extract::State, http::StatusCode, response::Json};

use crate::service::{
    server::AppState,
    types::{
        BatchRequest, BatchResponse, ErrorResponse, ServiceError, SingleRequest, SingleResponse,
    },
    validation::{validate_hgvs, validate_hgvs_batch, validate_optional_timeout},
};

/// Normalize a single HGVS variant
pub async fn normalize_single(
    State(state): State<AppState>,
    Json(request): Json<SingleRequest>,
) -> Result<Json<SingleResponse>, (StatusCode, Json<ErrorResponse>)> {
    // Comprehensive input validation for security
    if let Err(validation_error) = validate_hgvs(&request.hgvs) {
        let error = ServiceError::InvalidHgvs(validation_error.to_string());
        return Err((
            StatusCode::from_u16(error.status_code()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
            Json(error.to_response()),
        ));
    }

    // Validate timeout if provided
    if let Err(validation_error) = validate_optional_timeout(request.timeout_seconds) {
        let error = ServiceError::BadRequest(validation_error.to_string());
        return Err((
            StatusCode::from_u16(error.status_code()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
            Json(error.to_response()),
        ));
    }

    // Convert tools to vector of strings for ToolManager (which still expects strings)
    let tools_as_strings = request.tools.as_ref().map(|tools| {
        tools
            .iter()
            .map(|tool| tool.to_string())
            .collect::<Vec<String>>()
    });

    // Normalize using tool manager
    match state
        .tool_manager
        .normalize_single(
            &request.hgvs,
            tools_as_strings.as_deref(),
            request.timeout_seconds,
        )
        .await
    {
        Ok(response) => Ok(Json(response)),
        Err(e) => {
            let status_code =
                StatusCode::from_u16(e.status_code()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
            Err((status_code, Json(e.to_response())))
        }
    }
}

/// Normalize multiple HGVS variants
pub async fn normalize_batch(
    State(state): State<AppState>,
    Json(request): Json<BatchRequest>,
) -> Result<Json<BatchResponse>, (StatusCode, Json<ErrorResponse>)> {
    // Comprehensive batch validation for security
    if let Err(validation_error) = validate_hgvs_batch(&request.variants) {
        let error = ServiceError::BadRequest(validation_error.to_string());
        return Err((
            StatusCode::from_u16(error.status_code()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
            Json(error.to_response()),
        ));
    }

    // Validate timeout if provided
    if let Err(validation_error) = validate_optional_timeout(request.timeout_seconds) {
        let error = ServiceError::BadRequest(validation_error.to_string());
        return Err((
            StatusCode::from_u16(error.status_code()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
            Json(error.to_response()),
        ));
    }

    // Convert tools to vector of strings for ToolManager (which still expects strings)
    let tools_as_strings = request.tools.as_ref().map(|tools| {
        tools
            .iter()
            .map(|tool| tool.to_string())
            .collect::<Vec<String>>()
    });

    // Normalize using tool manager
    match state
        .tool_manager
        .normalize_batch(
            &request.variants,
            tools_as_strings.as_deref(),
            request.timeout_seconds,
        )
        .await
    {
        Ok(response) => Ok(Json(response)),
        Err(e) => {
            let status_code =
                StatusCode::from_u16(e.status_code()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
            Err((status_code, Json(e.to_response())))
        }
    }
}