zilliz 1.0.0

TUI and CLI tool for managing Zilliz Cloud clusters and Milvus operations
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use std::collections::HashMap;

use indexmap::IndexMap;
use serde::Deserialize;

/// Top-level CLI model, parsed from control-plane.json or data-plane.json.
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(dead_code)]
pub struct CliModel {
    #[serde(default)]
    pub version: String,
    #[serde(default)]
    pub min_cli_version: String,
    pub endpoint: Option<String>,
    pub auth: Option<AuthConfig>,
    #[serde(default)]
    pub resources: IndexMap<String, Resource>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct AuthConfig {
    #[serde(default, alias = "auth0Domain")]
    pub auth0_domain: String,
    #[serde(default, alias = "clientId")]
    pub client_id: String,
    #[serde(default, alias = "loginApi")]
    pub login_api: String,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Resource {
    pub description: Option<String>,
    #[serde(default)]
    pub dedicated_only: bool,
    #[serde(default)]
    pub operations: IndexMap<String, Operation>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(dead_code)]
pub struct Operation {
    #[serde(default)]
    pub http: HttpConfig,
    #[serde(default)]
    pub params: Vec<Param>,
    pub body_param: Option<String>,
    #[serde(default)]
    pub output: OutputConfig,
    pub pagination: Option<Pagination>,
    pub description: Option<String>,
    #[serde(default)]
    pub examples: Vec<String>,
    #[serde(default)]
    pub dedicated_only: bool,
    pub body_transform: Option<serde_json::Value>,
    #[serde(default)]
    pub body_defaults: serde_json::Map<String, serde_json::Value>,
}

impl Operation {
    pub fn method(&self) -> &str {
        &self.http.method
    }

    pub fn path(&self) -> &str {
        &self.http.path
    }
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HttpConfig {
    #[serde(default = "default_method")]
    pub method: String,
    #[serde(default)]
    pub path: String,
}

fn default_method() -> String {
    "GET".to_string()
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(dead_code)]
pub struct OutputConfig {
    pub data_field: Option<String>,
    #[serde(default)]
    pub columns: Option<Vec<String>>,
    #[serde(default)]
    pub color_map: Option<HashMap<String, HashMap<String, String>>>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(dead_code)]
pub struct Param {
    pub name: String,
    #[serde(default = "default_type")]
    #[serde(rename = "type")]
    pub param_type: String,
    #[serde(rename = "cli")]
    pub cli_name: Option<String>,
    #[serde(default)]
    pub required: bool,
    pub default: Option<serde_json::Value>,
    pub position: Option<String>,
    pub required_unless: Option<String>,
    pub required_when: Option<serde_json::Value>,
    pub description: Option<String>,
    pub choices: Option<Vec<String>>,
    pub transform: Option<serde_json::Value>,
}

fn default_type() -> String {
    "string".to_string()
}

impl Param {
    /// Get the CLI flag name (e.g., "--cluster-id").
    pub fn cli_flag(&self) -> String {
        self.cli_name
            .clone()
            .unwrap_or_else(|| format!("--{}", self.name))
    }

    /// Whether this param goes in the URL path vs query/body.
    pub fn is_path_param(&self) -> bool {
        self.position.as_deref() == Some("path")
    }
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(dead_code)]
pub struct Pagination {
    #[serde(default = "default_page_size_param")]
    pub page_size_param: String,
    #[serde(default = "default_page_param")]
    pub page_param: String,
    #[serde(default = "default_count_field")]
    pub count_field: String,
    #[serde(default = "default_data_field")]
    pub data_field: String,
    #[serde(default = "default_page_size")]
    pub default_page_size: u32,
}

fn default_page_size_param() -> String {
    "pageSize".to_string()
}
fn default_page_param() -> String {
    "currentPage".to_string()
}
fn default_count_field() -> String {
    "count".to_string()
}
fn default_data_field() -> String {
    "data".to_string()
}
fn default_page_size() -> u32 {
    100
}