nominal_api/conjure/endpoints/upload/api/
upload_service.rs

1use conjure_http::endpoint;
2/// The Upload Service manages file uploads to object storage.
3#[conjure_http::conjure_endpoints(
4    name = "UploadService",
5    use_legacy_error_serialization
6)]
7pub trait UploadService<#[request_body] I> {
8    /// Initiates a multipart upload to object storage.
9    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
10    #[endpoint(
11        method = POST,
12        path = "/upload/v1/multipart-upload",
13        name = "initiateMultipartUpload",
14        produces = conjure_http::server::StdResponseSerializer
15    )]
16    fn initiate_multipart_upload(
17        &self,
18        #[auth]
19        auth_: conjure_object::BearerToken,
20        #[body(
21            deserializer = conjure_http::server::StdRequestDeserializer,
22            log_as = "uploadRequest"
23        )]
24        upload_request: super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
25    ) -> Result<
26        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
27        conjure_http::private::Error,
28    >;
29    /// Lists the parts that have been uploaded for a given uploadId.
30    #[endpoint(
31        method = GET,
32        path = "/upload/v1/multipart-upload/{uploadId}",
33        name = "listParts",
34        produces = conjure_http::server::conjure::CollectionResponseSerializer
35    )]
36    fn list_parts(
37        &self,
38        #[auth]
39        auth_: conjure_object::BearerToken,
40        #[path(
41            name = "uploadId",
42            decoder = conjure_http::server::conjure::FromPlainDecoder,
43            log_as = "uploadId"
44        )]
45        upload_id: String,
46        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
47        key: String,
48    ) -> Result<
49        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
50        conjure_http::private::Error,
51    >;
52    /// Signs an upload request for a single part.
53    /// Returns a URL that will execute the upload without further authentication.
54    #[endpoint(
55        method = POST,
56        path = "/upload/v1/multipart-upload/{uploadId}",
57        name = "signPart",
58        produces = conjure_http::server::StdResponseSerializer
59    )]
60    fn sign_part(
61        &self,
62        #[auth]
63        auth_: conjure_object::BearerToken,
64        #[path(
65            name = "uploadId",
66            decoder = conjure_http::server::conjure::FromPlainDecoder,
67            log_as = "uploadId"
68        )]
69        upload_id: String,
70        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
71        key: String,
72        #[query(
73            name = "partNumber",
74            decoder = conjure_http::server::conjure::FromPlainDecoder,
75            log_as = "partNumber"
76        )]
77        part_number: i32,
78    ) -> Result<
79        super::super::super::super::objects::ingest::api::SignPartResponse,
80        conjure_http::private::Error,
81    >;
82    /// Completes a multipart upload to object storage.
83    /// This should be called after all parts have been uploaded.
84    /// Will throw EmptyMultipartUpload if there are 0 parts.
85    #[endpoint(
86        method = POST,
87        path = "/upload/v1/multipart-upload/{uploadId}/complete",
88        name = "completeMultipartUpload",
89        produces = conjure_http::server::StdResponseSerializer
90    )]
91    fn complete_multipart_upload(
92        &self,
93        #[auth]
94        auth_: conjure_object::BearerToken,
95        #[path(
96            name = "uploadId",
97            decoder = conjure_http::server::conjure::FromPlainDecoder,
98            log_as = "uploadId"
99        )]
100        upload_id: String,
101        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
102        key: String,
103        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
104        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
105    ) -> Result<
106        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
107        conjure_http::private::Error,
108    >;
109    /// Aborts a multipart upload to S3.
110    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
111    #[endpoint(
112        method = POST,
113        path = "/upload/v1/multipart-upload/{uploadId}/abort",
114        name = "abortMultipartUpload"
115    )]
116    fn abort_multipart_upload(
117        &self,
118        #[auth]
119        auth_: conjure_object::BearerToken,
120        #[path(
121            name = "uploadId",
122            decoder = conjure_http::server::conjure::FromPlainDecoder,
123            log_as = "uploadId"
124        )]
125        upload_id: String,
126        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
127        key: String,
128    ) -> Result<(), conjure_http::private::Error>;
129    /// Uploads a file to S3. Intended for smaller files.
130    #[endpoint(
131        method = POST,
132        path = "/upload/v1/upload-file",
133        name = "uploadFile",
134        produces = conjure_http::server::StdResponseSerializer
135    )]
136    fn upload_file(
137        &self,
138        #[auth]
139        auth_: conjure_object::BearerToken,
140        #[query(
141            name = "fileName",
142            decoder = conjure_http::server::conjure::FromPlainDecoder,
143            log_as = "fileName"
144        )]
145        file_name: String,
146        #[query(
147            name = "sizeBytes",
148            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
149            log_as = "sizeBytes"
150        )]
151        size_bytes: Option<conjure_object::SafeLong>,
152        #[query(
153            name = "workspace",
154            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
155            safe
156        )]
157        workspace: Option<super::super::super::super::objects::api::rids::WorkspaceRid>,
158        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
159        body: I,
160    ) -> Result<
161        super::super::super::super::objects::api::S3Path,
162        conjure_http::private::Error,
163    >;
164}
165/// The Upload Service manages file uploads to object storage.
166#[conjure_http::conjure_endpoints(
167    name = "UploadService",
168    use_legacy_error_serialization
169)]
170pub trait AsyncUploadService<#[request_body] I> {
171    /// Initiates a multipart upload to object storage.
172    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
173    #[endpoint(
174        method = POST,
175        path = "/upload/v1/multipart-upload",
176        name = "initiateMultipartUpload",
177        produces = conjure_http::server::StdResponseSerializer
178    )]
179    async fn initiate_multipart_upload(
180        &self,
181        #[auth]
182        auth_: conjure_object::BearerToken,
183        #[body(
184            deserializer = conjure_http::server::StdRequestDeserializer,
185            log_as = "uploadRequest"
186        )]
187        upload_request: super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
188    ) -> Result<
189        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
190        conjure_http::private::Error,
191    >;
192    /// Lists the parts that have been uploaded for a given uploadId.
193    #[endpoint(
194        method = GET,
195        path = "/upload/v1/multipart-upload/{uploadId}",
196        name = "listParts",
197        produces = conjure_http::server::conjure::CollectionResponseSerializer
198    )]
199    async fn list_parts(
200        &self,
201        #[auth]
202        auth_: conjure_object::BearerToken,
203        #[path(
204            name = "uploadId",
205            decoder = conjure_http::server::conjure::FromPlainDecoder,
206            log_as = "uploadId"
207        )]
208        upload_id: String,
209        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
210        key: String,
211    ) -> Result<
212        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
213        conjure_http::private::Error,
214    >;
215    /// Signs an upload request for a single part.
216    /// Returns a URL that will execute the upload without further authentication.
217    #[endpoint(
218        method = POST,
219        path = "/upload/v1/multipart-upload/{uploadId}",
220        name = "signPart",
221        produces = conjure_http::server::StdResponseSerializer
222    )]
223    async fn sign_part(
224        &self,
225        #[auth]
226        auth_: conjure_object::BearerToken,
227        #[path(
228            name = "uploadId",
229            decoder = conjure_http::server::conjure::FromPlainDecoder,
230            log_as = "uploadId"
231        )]
232        upload_id: String,
233        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
234        key: String,
235        #[query(
236            name = "partNumber",
237            decoder = conjure_http::server::conjure::FromPlainDecoder,
238            log_as = "partNumber"
239        )]
240        part_number: i32,
241    ) -> Result<
242        super::super::super::super::objects::ingest::api::SignPartResponse,
243        conjure_http::private::Error,
244    >;
245    /// Completes a multipart upload to object storage.
246    /// This should be called after all parts have been uploaded.
247    /// Will throw EmptyMultipartUpload if there are 0 parts.
248    #[endpoint(
249        method = POST,
250        path = "/upload/v1/multipart-upload/{uploadId}/complete",
251        name = "completeMultipartUpload",
252        produces = conjure_http::server::StdResponseSerializer
253    )]
254    async fn complete_multipart_upload(
255        &self,
256        #[auth]
257        auth_: conjure_object::BearerToken,
258        #[path(
259            name = "uploadId",
260            decoder = conjure_http::server::conjure::FromPlainDecoder,
261            log_as = "uploadId"
262        )]
263        upload_id: String,
264        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
265        key: String,
266        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
267        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
268    ) -> Result<
269        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
270        conjure_http::private::Error,
271    >;
272    /// Aborts a multipart upload to S3.
273    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
274    #[endpoint(
275        method = POST,
276        path = "/upload/v1/multipart-upload/{uploadId}/abort",
277        name = "abortMultipartUpload"
278    )]
279    async fn abort_multipart_upload(
280        &self,
281        #[auth]
282        auth_: conjure_object::BearerToken,
283        #[path(
284            name = "uploadId",
285            decoder = conjure_http::server::conjure::FromPlainDecoder,
286            log_as = "uploadId"
287        )]
288        upload_id: String,
289        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
290        key: String,
291    ) -> Result<(), conjure_http::private::Error>;
292    /// Uploads a file to S3. Intended for smaller files.
293    #[endpoint(
294        method = POST,
295        path = "/upload/v1/upload-file",
296        name = "uploadFile",
297        produces = conjure_http::server::StdResponseSerializer
298    )]
299    async fn upload_file(
300        &self,
301        #[auth]
302        auth_: conjure_object::BearerToken,
303        #[query(
304            name = "fileName",
305            decoder = conjure_http::server::conjure::FromPlainDecoder,
306            log_as = "fileName"
307        )]
308        file_name: String,
309        #[query(
310            name = "sizeBytes",
311            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
312            log_as = "sizeBytes"
313        )]
314        size_bytes: Option<conjure_object::SafeLong>,
315        #[query(
316            name = "workspace",
317            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
318            safe
319        )]
320        workspace: Option<super::super::super::super::objects::api::rids::WorkspaceRid>,
321        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
322        body: I,
323    ) -> Result<
324        super::super::super::super::objects::api::S3Path,
325        conjure_http::private::Error,
326    >;
327}
328/// The Upload Service manages file uploads to object storage.
329#[conjure_http::conjure_endpoints(
330    name = "UploadService",
331    use_legacy_error_serialization,
332    local
333)]
334pub trait LocalAsyncUploadService<#[request_body] I> {
335    /// Initiates a multipart upload to object storage.
336    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
337    #[endpoint(
338        method = POST,
339        path = "/upload/v1/multipart-upload",
340        name = "initiateMultipartUpload",
341        produces = conjure_http::server::StdResponseSerializer
342    )]
343    async fn initiate_multipart_upload(
344        &self,
345        #[auth]
346        auth_: conjure_object::BearerToken,
347        #[body(
348            deserializer = conjure_http::server::StdRequestDeserializer,
349            log_as = "uploadRequest"
350        )]
351        upload_request: super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
352    ) -> Result<
353        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
354        conjure_http::private::Error,
355    >;
356    /// Lists the parts that have been uploaded for a given uploadId.
357    #[endpoint(
358        method = GET,
359        path = "/upload/v1/multipart-upload/{uploadId}",
360        name = "listParts",
361        produces = conjure_http::server::conjure::CollectionResponseSerializer
362    )]
363    async fn list_parts(
364        &self,
365        #[auth]
366        auth_: conjure_object::BearerToken,
367        #[path(
368            name = "uploadId",
369            decoder = conjure_http::server::conjure::FromPlainDecoder,
370            log_as = "uploadId"
371        )]
372        upload_id: String,
373        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
374        key: String,
375    ) -> Result<
376        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
377        conjure_http::private::Error,
378    >;
379    /// Signs an upload request for a single part.
380    /// Returns a URL that will execute the upload without further authentication.
381    #[endpoint(
382        method = POST,
383        path = "/upload/v1/multipart-upload/{uploadId}",
384        name = "signPart",
385        produces = conjure_http::server::StdResponseSerializer
386    )]
387    async fn sign_part(
388        &self,
389        #[auth]
390        auth_: conjure_object::BearerToken,
391        #[path(
392            name = "uploadId",
393            decoder = conjure_http::server::conjure::FromPlainDecoder,
394            log_as = "uploadId"
395        )]
396        upload_id: String,
397        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
398        key: String,
399        #[query(
400            name = "partNumber",
401            decoder = conjure_http::server::conjure::FromPlainDecoder,
402            log_as = "partNumber"
403        )]
404        part_number: i32,
405    ) -> Result<
406        super::super::super::super::objects::ingest::api::SignPartResponse,
407        conjure_http::private::Error,
408    >;
409    /// Completes a multipart upload to object storage.
410    /// This should be called after all parts have been uploaded.
411    /// Will throw EmptyMultipartUpload if there are 0 parts.
412    #[endpoint(
413        method = POST,
414        path = "/upload/v1/multipart-upload/{uploadId}/complete",
415        name = "completeMultipartUpload",
416        produces = conjure_http::server::StdResponseSerializer
417    )]
418    async fn complete_multipart_upload(
419        &self,
420        #[auth]
421        auth_: conjure_object::BearerToken,
422        #[path(
423            name = "uploadId",
424            decoder = conjure_http::server::conjure::FromPlainDecoder,
425            log_as = "uploadId"
426        )]
427        upload_id: String,
428        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
429        key: String,
430        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
431        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
432    ) -> Result<
433        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
434        conjure_http::private::Error,
435    >;
436    /// Aborts a multipart upload to S3.
437    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
438    #[endpoint(
439        method = POST,
440        path = "/upload/v1/multipart-upload/{uploadId}/abort",
441        name = "abortMultipartUpload"
442    )]
443    async fn abort_multipart_upload(
444        &self,
445        #[auth]
446        auth_: conjure_object::BearerToken,
447        #[path(
448            name = "uploadId",
449            decoder = conjure_http::server::conjure::FromPlainDecoder,
450            log_as = "uploadId"
451        )]
452        upload_id: String,
453        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
454        key: String,
455    ) -> Result<(), conjure_http::private::Error>;
456    /// Uploads a file to S3. Intended for smaller files.
457    #[endpoint(
458        method = POST,
459        path = "/upload/v1/upload-file",
460        name = "uploadFile",
461        produces = conjure_http::server::StdResponseSerializer
462    )]
463    async fn upload_file(
464        &self,
465        #[auth]
466        auth_: conjure_object::BearerToken,
467        #[query(
468            name = "fileName",
469            decoder = conjure_http::server::conjure::FromPlainDecoder,
470            log_as = "fileName"
471        )]
472        file_name: String,
473        #[query(
474            name = "sizeBytes",
475            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
476            log_as = "sizeBytes"
477        )]
478        size_bytes: Option<conjure_object::SafeLong>,
479        #[query(
480            name = "workspace",
481            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
482            safe
483        )]
484        workspace: Option<super::super::super::super::objects::api::rids::WorkspaceRid>,
485        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
486        body: I,
487    ) -> Result<
488        super::super::super::super::objects::api::S3Path,
489        conjure_http::private::Error,
490    >;
491}
nominal_api/conjure/endpoints/upload/api/upload_service.rs

nominal_api/conjure/endpoints/upload/api/
upload_service.rs
