1use std::sync::Arc;
10
11use async_trait::async_trait;
12use reqwest;
13use serde::{Deserialize, Serialize};
14
15use super::{configuration, Error};
16use crate::apis::ResponseContent;
17use crate::models;
18
19#[async_trait]
20pub trait CollectionsApi: Send + Sync {
21 async fn create_collection(
22 &self,
23 params: CreateCollectionParams,
24 ) -> Result<models::CollectionResponse, Error<CreateCollectionError>>;
25 async fn delete_alias(&self, params: DeleteAliasParams) -> Result<models::CollectionAlias, Error<DeleteAliasError>>;
26 async fn delete_collection(
27 &self,
28 params: DeleteCollectionParams,
29 ) -> Result<models::CollectionResponse, Error<DeleteCollectionError>>;
30 async fn get_alias(&self, params: GetAliasParams) -> Result<models::CollectionAlias, Error<GetAliasError>>;
31 async fn get_aliases(&self) -> Result<models::CollectionAliasesResponse, Error<GetAliasesError>>;
32 async fn get_collection(
33 &self,
34 params: GetCollectionParams,
35 ) -> Result<models::CollectionResponse, Error<GetCollectionError>>;
36 async fn get_collections(&self) -> Result<Vec<models::CollectionResponse>, Error<GetCollectionsError>>;
37 async fn update_collection(
38 &self,
39 params: UpdateCollectionParams,
40 ) -> Result<models::CollectionUpdateSchema, Error<UpdateCollectionError>>;
41 async fn upsert_alias(&self, params: UpsertAliasParams) -> Result<models::CollectionAlias, Error<UpsertAliasError>>;
42}
43
44pub struct CollectionsApiClient {
45 configuration: Arc<configuration::Configuration>,
46}
47
48impl CollectionsApiClient {
49 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
50 Self { configuration }
51 }
52}
53
54#[derive(Clone, Debug)]
56#[cfg_attr(feature = "bon", derive(::bon::Builder))]
57pub struct CreateCollectionParams {
58 pub collection_schema: models::CollectionSchema,
60}
61
62#[derive(Clone, Debug)]
64#[cfg_attr(feature = "bon", derive(::bon::Builder))]
65pub struct DeleteAliasParams {
66 pub alias_name: String,
68}
69
70#[derive(Clone, Debug)]
72#[cfg_attr(feature = "bon", derive(::bon::Builder))]
73pub struct DeleteCollectionParams {
74 pub collection_name: String,
76}
77
78#[derive(Clone, Debug)]
80#[cfg_attr(feature = "bon", derive(::bon::Builder))]
81pub struct GetAliasParams {
82 pub alias_name: String,
84}
85
86#[derive(Clone, Debug)]
88#[cfg_attr(feature = "bon", derive(::bon::Builder))]
89pub struct GetCollectionParams {
90 pub collection_name: String,
92}
93
94#[derive(Clone, Debug)]
96#[cfg_attr(feature = "bon", derive(::bon::Builder))]
97pub struct UpdateCollectionParams {
98 pub collection_name: String,
100 pub collection_update_schema: models::CollectionUpdateSchema,
102}
103
104#[derive(Clone, Debug)]
106#[cfg_attr(feature = "bon", derive(::bon::Builder))]
107pub struct UpsertAliasParams {
108 pub alias_name: String,
110 pub collection_alias_schema: Option<models::CollectionAliasSchema>,
112}
113
114#[async_trait]
115impl CollectionsApi for CollectionsApiClient {
116 async fn create_collection(
119 &self,
120 params: CreateCollectionParams,
121 ) -> Result<models::CollectionResponse, Error<CreateCollectionError>> {
122 let CreateCollectionParams { collection_schema } = params;
123
124 let local_var_configuration = &self.configuration;
125
126 let local_var_client = &local_var_configuration.client;
127
128 let local_var_uri_str = format!("{}/collections", local_var_configuration.base_path);
129 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
130
131 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
132 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
133 }
134 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
135 let local_var_key = local_var_apikey.key.clone();
136 let local_var_value = match local_var_apikey.prefix {
137 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
138 None => local_var_key,
139 };
140 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
141 };
142 local_var_req_builder = local_var_req_builder.json(&collection_schema);
143
144 let local_var_req = local_var_req_builder.build()?;
145 let local_var_resp = local_var_client.execute(local_var_req).await?;
146
147 let local_var_status = local_var_resp.status();
148 let local_var_content = local_var_resp.text().await?;
149
150 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
151 serde_json::from_str(&local_var_content).map_err(Error::from)
152 } else {
153 let local_var_entity: Option<CreateCollectionError> = serde_json::from_str(&local_var_content).ok();
154 let local_var_error = ResponseContent {
155 status: local_var_status,
156 content: local_var_content,
157 entity: local_var_entity,
158 };
159 Err(Error::ResponseError(local_var_error))
160 }
161 }
162
163 async fn delete_alias(&self, params: DeleteAliasParams) -> Result<models::CollectionAlias, Error<DeleteAliasError>> {
164 let DeleteAliasParams { alias_name } = params;
165
166 let local_var_configuration = &self.configuration;
167
168 let local_var_client = &local_var_configuration.client;
169
170 let local_var_uri_str = format!(
171 "{}/aliases/{aliasName}",
172 local_var_configuration.base_path,
173 aliasName = crate::apis::urlencode(alias_name)
174 );
175 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
176
177 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
178 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
179 }
180 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
181 let local_var_key = local_var_apikey.key.clone();
182 let local_var_value = match local_var_apikey.prefix {
183 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
184 None => local_var_key,
185 };
186 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
187 };
188
189 let local_var_req = local_var_req_builder.build()?;
190 let local_var_resp = local_var_client.execute(local_var_req).await?;
191
192 let local_var_status = local_var_resp.status();
193 let local_var_content = local_var_resp.text().await?;
194
195 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
196 serde_json::from_str(&local_var_content).map_err(Error::from)
197 } else {
198 let local_var_entity: Option<DeleteAliasError> = serde_json::from_str(&local_var_content).ok();
199 let local_var_error = ResponseContent {
200 status: local_var_status,
201 content: local_var_content,
202 entity: local_var_entity,
203 };
204 Err(Error::ResponseError(local_var_error))
205 }
206 }
207
208 async fn delete_collection(
211 &self,
212 params: DeleteCollectionParams,
213 ) -> Result<models::CollectionResponse, Error<DeleteCollectionError>> {
214 let DeleteCollectionParams { collection_name } = params;
215
216 let local_var_configuration = &self.configuration;
217
218 let local_var_client = &local_var_configuration.client;
219
220 let local_var_uri_str = format!(
221 "{}/collections/{collectionName}",
222 local_var_configuration.base_path,
223 collectionName = crate::apis::urlencode(collection_name)
224 );
225 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
226
227 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
228 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
229 }
230 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
231 let local_var_key = local_var_apikey.key.clone();
232 let local_var_value = match local_var_apikey.prefix {
233 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
234 None => local_var_key,
235 };
236 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
237 };
238
239 let local_var_req = local_var_req_builder.build()?;
240 let local_var_resp = local_var_client.execute(local_var_req).await?;
241
242 let local_var_status = local_var_resp.status();
243 let local_var_content = local_var_resp.text().await?;
244
245 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
246 serde_json::from_str(&local_var_content).map_err(Error::from)
247 } else {
248 let local_var_entity: Option<DeleteCollectionError> = serde_json::from_str(&local_var_content).ok();
249 let local_var_error = ResponseContent {
250 status: local_var_status,
251 content: local_var_content,
252 entity: local_var_entity,
253 };
254 Err(Error::ResponseError(local_var_error))
255 }
256 }
257
258 async fn get_alias(&self, params: GetAliasParams) -> Result<models::CollectionAlias, Error<GetAliasError>> {
260 let GetAliasParams { alias_name } = params;
261
262 let local_var_configuration = &self.configuration;
263
264 let local_var_client = &local_var_configuration.client;
265
266 let local_var_uri_str = format!(
267 "{}/aliases/{aliasName}",
268 local_var_configuration.base_path,
269 aliasName = crate::apis::urlencode(alias_name)
270 );
271 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
272
273 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
274 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
275 }
276 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
277 let local_var_key = local_var_apikey.key.clone();
278 let local_var_value = match local_var_apikey.prefix {
279 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
280 None => local_var_key,
281 };
282 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
283 };
284
285 let local_var_req = local_var_req_builder.build()?;
286 let local_var_resp = local_var_client.execute(local_var_req).await?;
287
288 let local_var_status = local_var_resp.status();
289 let local_var_content = local_var_resp.text().await?;
290
291 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
292 serde_json::from_str(&local_var_content).map_err(Error::from)
293 } else {
294 let local_var_entity: Option<GetAliasError> = serde_json::from_str(&local_var_content).ok();
295 let local_var_error = ResponseContent {
296 status: local_var_status,
297 content: local_var_content,
298 entity: local_var_entity,
299 };
300 Err(Error::ResponseError(local_var_error))
301 }
302 }
303
304 async fn get_aliases(&self) -> Result<models::CollectionAliasesResponse, Error<GetAliasesError>> {
306 let local_var_configuration = &self.configuration;
307
308 let local_var_client = &local_var_configuration.client;
309
310 let local_var_uri_str = format!("{}/aliases", local_var_configuration.base_path);
311 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
312
313 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
314 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
315 }
316 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
317 let local_var_key = local_var_apikey.key.clone();
318 let local_var_value = match local_var_apikey.prefix {
319 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
320 None => local_var_key,
321 };
322 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
323 };
324
325 let local_var_req = local_var_req_builder.build()?;
326 let local_var_resp = local_var_client.execute(local_var_req).await?;
327
328 let local_var_status = local_var_resp.status();
329 let local_var_content = local_var_resp.text().await?;
330
331 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
332 serde_json::from_str(&local_var_content).map_err(Error::from)
333 } else {
334 let local_var_entity: Option<GetAliasesError> = serde_json::from_str(&local_var_content).ok();
335 let local_var_error = ResponseContent {
336 status: local_var_status,
337 content: local_var_content,
338 entity: local_var_entity,
339 };
340 Err(Error::ResponseError(local_var_error))
341 }
342 }
343
344 async fn get_collection(
346 &self,
347 params: GetCollectionParams,
348 ) -> Result<models::CollectionResponse, Error<GetCollectionError>> {
349 let GetCollectionParams { collection_name } = params;
350
351 let local_var_configuration = &self.configuration;
352
353 let local_var_client = &local_var_configuration.client;
354
355 let local_var_uri_str = format!(
356 "{}/collections/{collectionName}",
357 local_var_configuration.base_path,
358 collectionName = crate::apis::urlencode(collection_name)
359 );
360 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
361
362 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
363 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
364 }
365 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
366 let local_var_key = local_var_apikey.key.clone();
367 let local_var_value = match local_var_apikey.prefix {
368 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
369 None => local_var_key,
370 };
371 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
372 };
373
374 let local_var_req = local_var_req_builder.build()?;
375 let local_var_resp = local_var_client.execute(local_var_req).await?;
376
377 let local_var_status = local_var_resp.status();
378 let local_var_content = local_var_resp.text().await?;
379
380 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
381 serde_json::from_str(&local_var_content).map_err(Error::from)
382 } else {
383 let local_var_entity: Option<GetCollectionError> = serde_json::from_str(&local_var_content).ok();
384 let local_var_error = ResponseContent {
385 status: local_var_status,
386 content: local_var_content,
387 entity: local_var_entity,
388 };
389 Err(Error::ResponseError(local_var_error))
390 }
391 }
392
393 async fn get_collections(&self) -> Result<Vec<models::CollectionResponse>, Error<GetCollectionsError>> {
397 let local_var_configuration = &self.configuration;
398
399 let local_var_client = &local_var_configuration.client;
400
401 let local_var_uri_str = format!("{}/collections", local_var_configuration.base_path);
402 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
403
404 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
405 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
406 }
407 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
408 let local_var_key = local_var_apikey.key.clone();
409 let local_var_value = match local_var_apikey.prefix {
410 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
411 None => local_var_key,
412 };
413 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
414 };
415
416 let local_var_req = local_var_req_builder.build()?;
417 let local_var_resp = local_var_client.execute(local_var_req).await?;
418
419 let local_var_status = local_var_resp.status();
420 let local_var_content = local_var_resp.text().await?;
421
422 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
423 serde_json::from_str(&local_var_content).map_err(Error::from)
424 } else {
425 let local_var_entity: Option<GetCollectionsError> = serde_json::from_str(&local_var_content).ok();
426 let local_var_error = ResponseContent {
427 status: local_var_status,
428 content: local_var_content,
429 entity: local_var_entity,
430 };
431 Err(Error::ResponseError(local_var_error))
432 }
433 }
434
435 async fn update_collection(
437 &self,
438 params: UpdateCollectionParams,
439 ) -> Result<models::CollectionUpdateSchema, Error<UpdateCollectionError>> {
440 let UpdateCollectionParams {
441 collection_name,
442 collection_update_schema,
443 } = params;
444
445 let local_var_configuration = &self.configuration;
446
447 let local_var_client = &local_var_configuration.client;
448
449 let local_var_uri_str = format!(
450 "{}/collections/{collectionName}",
451 local_var_configuration.base_path,
452 collectionName = crate::apis::urlencode(collection_name)
453 );
454 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
455
456 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
457 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
458 }
459 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
460 let local_var_key = local_var_apikey.key.clone();
461 let local_var_value = match local_var_apikey.prefix {
462 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
463 None => local_var_key,
464 };
465 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
466 };
467 local_var_req_builder = local_var_req_builder.json(&collection_update_schema);
468
469 let local_var_req = local_var_req_builder.build()?;
470 let local_var_resp = local_var_client.execute(local_var_req).await?;
471
472 let local_var_status = local_var_resp.status();
473 let local_var_content = local_var_resp.text().await?;
474
475 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
476 serde_json::from_str(&local_var_content).map_err(Error::from)
477 } else {
478 let local_var_entity: Option<UpdateCollectionError> = serde_json::from_str(&local_var_content).ok();
479 let local_var_error = ResponseContent {
480 status: local_var_status,
481 content: local_var_content,
482 entity: local_var_entity,
483 };
484 Err(Error::ResponseError(local_var_error))
485 }
486 }
487
488 async fn upsert_alias(&self, params: UpsertAliasParams) -> Result<models::CollectionAlias, Error<UpsertAliasError>> {
494 let UpsertAliasParams {
495 alias_name,
496 collection_alias_schema,
497 } = params;
498
499 let local_var_configuration = &self.configuration;
500
501 let local_var_client = &local_var_configuration.client;
502
503 let local_var_uri_str = format!(
504 "{}/aliases/{aliasName}",
505 local_var_configuration.base_path,
506 aliasName = crate::apis::urlencode(alias_name)
507 );
508 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
509
510 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
511 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
512 }
513 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
514 let local_var_key = local_var_apikey.key.clone();
515 let local_var_value = match local_var_apikey.prefix {
516 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
517 None => local_var_key,
518 };
519 local_var_req_builder = local_var_req_builder.header("X-TYPESENSE-API-KEY", local_var_value);
520 };
521 local_var_req_builder = local_var_req_builder.json(&collection_alias_schema);
522
523 let local_var_req = local_var_req_builder.build()?;
524 let local_var_resp = local_var_client.execute(local_var_req).await?;
525
526 let local_var_status = local_var_resp.status();
527 let local_var_content = local_var_resp.text().await?;
528
529 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
530 serde_json::from_str(&local_var_content).map_err(Error::from)
531 } else {
532 let local_var_entity: Option<UpsertAliasError> = serde_json::from_str(&local_var_content).ok();
533 let local_var_error = ResponseContent {
534 status: local_var_status,
535 content: local_var_content,
536 entity: local_var_entity,
537 };
538 Err(Error::ResponseError(local_var_error))
539 }
540 }
541}
542
543#[derive(Debug, Clone, Serialize, Deserialize)]
545#[serde(untagged)]
546pub enum CreateCollectionError {
547 Status400(models::ApiResponse),
548 Status409(models::ApiResponse),
549 UnknownValue(serde_json::Value),
550}
551
552#[derive(Debug, Clone, Serialize, Deserialize)]
554#[serde(untagged)]
555pub enum DeleteAliasError {
556 Status404(models::ApiResponse),
557 UnknownValue(serde_json::Value),
558}
559
560#[derive(Debug, Clone, Serialize, Deserialize)]
562#[serde(untagged)]
563pub enum DeleteCollectionError {
564 Status404(models::ApiResponse),
565 UnknownValue(serde_json::Value),
566}
567
568#[derive(Debug, Clone, Serialize, Deserialize)]
570#[serde(untagged)]
571pub enum GetAliasError {
572 Status404(models::ApiResponse),
573 UnknownValue(serde_json::Value),
574}
575
576#[derive(Debug, Clone, Serialize, Deserialize)]
578#[serde(untagged)]
579pub enum GetAliasesError {
580 UnknownValue(serde_json::Value),
581}
582
583#[derive(Debug, Clone, Serialize, Deserialize)]
585#[serde(untagged)]
586pub enum GetCollectionError {
587 Status404(models::ApiResponse),
588 UnknownValue(serde_json::Value),
589}
590
591#[derive(Debug, Clone, Serialize, Deserialize)]
593#[serde(untagged)]
594pub enum GetCollectionsError {
595 UnknownValue(serde_json::Value),
596}
597
598#[derive(Debug, Clone, Serialize, Deserialize)]
600#[serde(untagged)]
601pub enum UpdateCollectionError {
602 Status400(models::ApiResponse),
603 Status404(models::ApiResponse),
604 UnknownValue(serde_json::Value),
605}
606
607#[derive(Debug, Clone, Serialize, Deserialize)]
609#[serde(untagged)]
610pub enum UpsertAliasError {
611 Status400(models::ApiResponse),
612 Status404(models::ApiResponse),
613 UnknownValue(serde_json::Value),
614}