oxirs-fuseki 0.2.4

SPARQL 1.1/1.2 HTTP protocol server with Fuseki-compatible configuration
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

//! Server-specific GSP handlers that work with AppState

use super::{read, types::GspParams, write};
use crate::server::AppState;
use axum::{
    body::Bytes,
    extract::{Query, State},
    http::HeaderMap,
    response::{IntoResponse, Response},
};
use std::sync::Arc;

/// GET handler for AppState
pub async fn handle_gsp_get_server(
    Query(params): Query<GspParams>,
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
) -> Response {
    match read::handle_gsp_get(Query(params), State(Arc::new(state.store.clone())), headers).await {
        Ok(resp) => resp,
        Err(err) => err.into_response(),
    }
}

/// HEAD handler for AppState
pub async fn handle_gsp_head_server(
    Query(params): Query<GspParams>,
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
) -> Response {
    match read::handle_gsp_head(Query(params), State(Arc::new(state.store.clone())), headers).await
    {
        Ok(resp) => resp,
        Err(err) => err.into_response(),
    }
}

/// OPTIONS handler for AppState
pub async fn handle_gsp_options_server() -> Response {
    read::handle_gsp_options().await.into_response()
}

/// PUT handler for AppState
pub async fn handle_gsp_put_server(
    Query(params): Query<GspParams>,
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
    body: Bytes,
) -> Response {
    match write::handle_gsp_put(
        Query(params),
        State(Arc::new(state.store.clone())),
        headers,
        body,
    )
    .await
    {
        Ok(resp) => resp,
        Err(err) => err.into_response(),
    }
}

/// POST handler for AppState
pub async fn handle_gsp_post_server(
    Query(params): Query<GspParams>,
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
    body: Bytes,
) -> Response {
    match write::handle_gsp_post(
        Query(params),
        State(Arc::new(state.store.clone())),
        headers,
        body,
    )
    .await
    {
        Ok(resp) => resp,
        Err(err) => err.into_response(),
    }
}

/// DELETE handler for AppState
pub async fn handle_gsp_delete_server(
    Query(params): Query<GspParams>,
    State(state): State<Arc<AppState>>,
) -> Response {
    match write::handle_gsp_delete(Query(params), State(Arc::new(state.store.clone()))).await {
        Ok(resp) => resp,
        Err(err) => err.into_response(),
    }
}