vl-convert-server 2.0.0-rc2

HTTP server for converting Vega-Lite and Vega specifications to static images
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use axum::extract::State;
use axum::http::{HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::Json;
use std::sync::Arc;

use vl_convert_rs::converter::{JpegOpts, PdfOpts, PngOpts};

use crate::config::AppState;
use crate::types::{ErrorResponse, SvgJpegRequest, SvgPdfRequest, SvgPngRequest};
use crate::util::{
    append_vlc_logs_header, attach_google_font_usage, conversion_error_response, format_log_entries,
};

#[utoipa::path(
    post,
    path = "/svg/png",
    request_body = SvgPngRequest,
    responses(
        (status = 200, content_type = "image/png", description = "PNG image"),
        (status = 400, body = ErrorResponse, description = "Invalid request"),
        (status = 422, body = ErrorResponse, description = "Conversion failed"),
    ),
    tag = "SVG"
)]
pub async fn svg_to_png(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SvgPngRequest>,
) -> Response {
    let snap = state.runtime.load_full();
    let png_opts = PngOpts {
        scale: req.scale,
        ppi: req.ppi,
    };

    match snap.converter.svg_to_png(&req.svg, png_opts).await {
        Ok(output) => {
            let mut headers = HeaderMap::new();
            append_vlc_logs_header(&mut headers, &format_log_entries(&output.logs));
            let mut response = (
                headers,
                [(axum::http::header::CONTENT_TYPE, "image/png")],
                output.data,
            )
                .into_response();
            attach_google_font_usage(&mut response, output.google_fonts);
            response
        }
        Err(e) => conversion_error_response(
            StatusCode::UNPROCESSABLE_ENTITY,
            "SVG to PNG conversion failed",
            &e,
            state.opaque_errors,
        ),
    }
}

#[utoipa::path(
    post,
    path = "/svg/jpeg",
    request_body = SvgJpegRequest,
    responses(
        (status = 200, content_type = "image/jpeg", description = "JPEG image"),
        (status = 400, body = ErrorResponse, description = "Invalid request"),
        (status = 422, body = ErrorResponse, description = "Conversion failed"),
    ),
    tag = "SVG"
)]
pub async fn svg_to_jpeg(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SvgJpegRequest>,
) -> Response {
    let snap = state.runtime.load_full();
    let jpeg_opts = JpegOpts {
        scale: req.scale,
        quality: req.quality,
    };

    match snap.converter.svg_to_jpeg(&req.svg, jpeg_opts).await {
        Ok(output) => {
            let mut headers = HeaderMap::new();
            append_vlc_logs_header(&mut headers, &format_log_entries(&output.logs));
            let mut response = (
                headers,
                [(axum::http::header::CONTENT_TYPE, "image/jpeg")],
                output.data,
            )
                .into_response();
            attach_google_font_usage(&mut response, output.google_fonts);
            response
        }
        Err(e) => conversion_error_response(
            StatusCode::UNPROCESSABLE_ENTITY,
            "SVG to JPEG conversion failed",
            &e,
            state.opaque_errors,
        ),
    }
}

#[utoipa::path(
    post,
    path = "/svg/pdf",
    request_body = SvgPdfRequest,
    responses(
        (status = 200, content_type = "application/pdf", description = "PDF document"),
        (status = 400, body = ErrorResponse, description = "Invalid request"),
        (status = 422, body = ErrorResponse, description = "Conversion failed"),
    ),
    tag = "SVG"
)]
pub async fn svg_to_pdf(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SvgPdfRequest>,
) -> Response {
    let snap = state.runtime.load_full();
    match snap
        .converter
        .svg_to_pdf(&req.svg, PdfOpts::default())
        .await
    {
        Ok(output) => {
            let mut headers = HeaderMap::new();
            append_vlc_logs_header(&mut headers, &format_log_entries(&output.logs));
            let mut response = (
                headers,
                [(axum::http::header::CONTENT_TYPE, "application/pdf")],
                output.data,
            )
                .into_response();
            attach_google_font_usage(&mut response, output.google_fonts);
            response
        }
        Err(e) => conversion_error_response(
            StatusCode::UNPROCESSABLE_ENTITY,
            "SVG to PDF conversion failed",
            &e,
            state.opaque_errors,
        ),
    }
}