stately-arrow 0.5.0

Arrow backend utilities for viewing data over API
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
112
113
114
115
116
117
118
119
120

//! `OpenAPI` documentation for the stately-arrow API.
//!
//! This module provides the `OpenAPI` specification with conditional schema inclusion
//! based on enabled features (`database`, `object-store`, etc.).

use utoipa::openapi::tag::TagBuilder;
use utoipa::openapi::{ComponentsBuilder, InfoBuilder, OpenApiBuilder, PathsBuilder};

use crate::backend::{BackendMetadata, Capability, ConnectionKind, ConnectionMetadata};
use crate::context::SessionCapability;
use crate::request::{
    ConnectionDetailsRequest, ConnectionSearchQuery, ConnectionSearchTerm, QueryRequest,
};
use crate::response::{ConnectionDetailsResponse, ListSummary, TableSummary};

/// `OpenAPI` documentation struct for the stately-arrow API.
#[derive(Clone, Copy)]
pub struct OpenApiDoc;

impl utoipa::OpenApi for OpenApiDoc {
    #[allow(unused_mut)]
    fn openapi() -> utoipa::openapi::OpenApi {
        // Build components with base schemas
        let mut components = ComponentsBuilder::new()
            // Base schemas (always included)
            .schema_from::<QueryRequest>()
            .schema_from::<ConnectionSearchTerm>()
            .schema_from::<ConnectionSearchQuery>()
            .schema_from::<ConnectionDetailsRequest>()
            .schema_from::<ConnectionDetailsResponse>()
            .schema_from::<SessionCapability>()
            .schema_from::<Capability>()
            .schema_from::<ConnectionMetadata>()
            .schema_from::<BackendMetadata>()
            .schema_from::<ListSummary>()
            .schema_from::<TableSummary>()
            .schema_from::<ConnectionKind>()
            .schema_from::<stately::ApiError>()
            // Responses
            .response_from::<ConnectionDetailsResponse>()
            .response_from::<ListSummary>()
            .response_from::<TableSummary>();

        // Registry feature schemas
        #[cfg(feature = "registry")]
        {
            use crate::registry::generic::{Connector, RegistryOptions, Type};

            components = components
                .schema_from::<Connector>()
                .schema_from::<RegistryOptions>()
                .schema_from::<Type>();
        }

        // Database feature schemas
        #[cfg(feature = "database")]
        {
            use crate::database::{
                Config as DatabaseConfig, ConnectionOptions, Database, PoolOptions, Secret,
                TlsOptions,
            };
            components = components
                .schema_from::<DatabaseConfig>()
                .schema_from::<ConnectionOptions>()
                .schema_from::<Database>()
                .schema_from::<PoolOptions>()
                .schema_from::<Secret>()
                .schema_from::<TlsOptions>();

            // ClickHouse-specific schemas (nested under database feature)
            #[cfg(feature = "clickhouse")]
            {
                use crate::database::clickhouse::{ClickHouseCompression, ClickHouseConfig};
                components = components
                    .schema_from::<ClickHouseConfig>()
                    .schema_from::<ClickHouseCompression>();
            }
        }

        // Object store feature schemas
        #[cfg(feature = "object-store")]
        {
            use crate::object_store::{
                Config as ObjectStoreConfig, ObjectStore, ObjectStoreFormat, ObjectStoreOptions,
            };
            components = components
                .schema_from::<ObjectStoreConfig>()
                .schema_from::<ObjectStore>()
                .schema_from::<ObjectStoreOptions>()
                .schema_from::<ObjectStoreFormat>();
        }

        // Build paths from handler functions
        let paths = PathsBuilder::new()
            .path_from::<super::handlers::__path_list_connectors>()
            .path_from::<super::handlers::__path_list_catalogs>()
            .path_from::<super::handlers::__path_list_registered>()
            .path_from::<super::handlers::__path_connector_list>()
            .path_from::<super::handlers::__path_connector_list_many>()
            .path_from::<super::handlers::__path_execute_query>()
            .path_from::<super::handlers::__path_register>()
            .build();

        // Build the OpenAPI spec
        OpenApiBuilder::new()
            .info(
                InfoBuilder::new()
                    .title(env!("CARGO_PKG_NAME"))
                    .version(env!("CARGO_PKG_VERSION"))
                    .description(Some(env!("CARGO_PKG_DESCRIPTION")))
                    .build(),
            )
            .paths(paths)
            .components(Some(components.build()))
            .tags(Some(vec![
                TagBuilder::new().name("arrow").description(Some("Arrow data endpoints")).build(),
            ]))
            .build()
    }
}