apollo_client/open/
mod.rs1pub mod meta;
36pub mod requests;
37pub mod responses;
38
39use crate::{
40 errors::ApolloClientResult,
41 meta::{handle_url, validate_response, PerformResponse, DEFAULT_TIMEOUT},
42 open::{
43 requests::{
44 OpenAppRequest, OpenClusterRequest, OpenCreateItemRequest, OpenEnvClusterRequest,
45 OpenNamespaceRequest, OpenPublishNamespaceRequest, OpenUpdateItemRequest,
46 PerformOpenRequest,
47 },
48 responses::{
49 OpenAppResponse, OpenClusterResponse, OpenEnvClusterResponse, OpenItemResponse,
50 OpenNamespaceResponse, OpenPublishResponse,
51 },
52 },
53};
54use http::{header::AUTHORIZATION, HeaderMap, HeaderValue};
55use reqwest::{Client, ClientBuilder};
56use url::Url;
57
58pub struct OpenApiClientBuilder {
60 portal_url: Url,
61 token: String,
62 client_builder: ClientBuilder,
63}
64
65impl OpenApiClientBuilder {
66 pub fn new(portal_url: Url, token: impl ToString) -> ApolloClientResult<Self> {
68 let mut builder = Self {
69 portal_url,
70 token: token.to_string(),
71 client_builder: Default::default(),
72 };
73 let default_headers = builder.default_headers()?;
74 builder.client_builder = builder
75 .client_builder
76 .timeout(DEFAULT_TIMEOUT)
77 .default_headers(default_headers);
78 Ok(builder)
79 }
80
81 pub fn with_client_builder(mut self, f: impl FnOnce(ClientBuilder) -> ClientBuilder) -> Self {
97 self.client_builder = f(self.client_builder);
98 self
99 }
100
101 pub fn build(self) -> ApolloClientResult<OpenApiClient> {
103 Ok(OpenApiClient {
104 portal_url: self.portal_url,
105 client: self.client_builder.build()?,
106 })
107 }
108
109 fn default_headers(&self) -> Result<HeaderMap, http::Error> {
110 let mut map = HeaderMap::new();
111 map.insert(AUTHORIZATION, HeaderValue::from_str(&self.token)?);
112 Ok(map)
113 }
114}
115
116pub struct OpenApiClient {
118 portal_url: Url,
119 client: Client,
120}
121
122impl OpenApiClient {
123 pub async fn env_cluster(
127 &self,
128 request: OpenEnvClusterRequest,
129 ) -> ApolloClientResult<Vec<OpenEnvClusterResponse>> {
130 self.execute(request).await
131 }
132
133 pub async fn app(&self, request: OpenAppRequest) -> ApolloClientResult<Vec<OpenAppResponse>> {
137 self.execute(request).await
138 }
139
140 pub async fn cluster(
144 &self,
145 request: OpenClusterRequest,
146 ) -> ApolloClientResult<OpenClusterResponse> {
147 self.execute(request).await
148 }
149
150 pub async fn namespace(
154 &self,
155 request: OpenNamespaceRequest,
156 ) -> ApolloClientResult<Vec<OpenNamespaceResponse>> {
157 self.execute(request).await
158 }
159
160 pub async fn create_item(
164 &self,
165 request: OpenCreateItemRequest,
166 ) -> ApolloClientResult<OpenItemResponse> {
167 self.execute(request).await
168 }
169
170 pub async fn update_item(&self, request: OpenUpdateItemRequest) -> ApolloClientResult<()> {
174 self.execute(request).await
175 }
176
177 pub async fn publish_namespace(
181 &self,
182 request: OpenPublishNamespaceRequest,
183 ) -> ApolloClientResult<OpenPublishResponse> {
184 self.execute(request).await
185 }
186
187 async fn execute<R: PerformResponse>(
188 &self,
189 request: impl PerformOpenRequest<Response = R>,
190 ) -> ApolloClientResult<R> {
191 let url = handle_url(&request, self.portal_url.clone())?;
192 let mut request_builder = self.client.request(request.method(), url);
193 request_builder = request.request_builder(request_builder);
194 let response = request_builder.send().await?;
195 let response = validate_response(response).await?;
196 <R>::from_response(response).await
197 }
198}