nominal_api_conjure/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        #[query(
49            name = "bucket",
50            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
51        )]
52        bucket: Option<String>,
53    ) -> Result<
54        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
55        conjure_http::private::Error,
56    >;
57    /// Signs an upload request for a single part.
58    /// Returns a URL that will execute the upload without further authentication.
59    #[endpoint(
60        method = POST,
61        path = "/upload/v1/multipart-upload/{uploadId}",
62        name = "signPart",
63        produces = conjure_http::server::StdResponseSerializer
64    )]
65    fn sign_part(
66        &self,
67        #[auth]
68        auth_: conjure_object::BearerToken,
69        #[path(
70            name = "uploadId",
71            decoder = conjure_http::server::conjure::FromPlainDecoder,
72            log_as = "uploadId"
73        )]
74        upload_id: String,
75        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
76        key: String,
77        #[query(
78            name = "partNumber",
79            decoder = conjure_http::server::conjure::FromPlainDecoder,
80            log_as = "partNumber"
81        )]
82        part_number: i32,
83        #[query(
84            name = "bucket",
85            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
86        )]
87        bucket: Option<String>,
88    ) -> Result<
89        super::super::super::super::objects::ingest::api::SignPartResponse,
90        conjure_http::private::Error,
91    >;
92    /// Completes a multipart upload to object storage.
93    /// This should be called after all parts have been uploaded.
94    /// Will throw EmptyMultipartUpload if there are 0 parts.
95    #[endpoint(
96        method = POST,
97        path = "/upload/v1/multipart-upload/{uploadId}/complete",
98        name = "completeMultipartUpload",
99        produces = conjure_http::server::StdResponseSerializer
100    )]
101    fn complete_multipart_upload(
102        &self,
103        #[auth]
104        auth_: conjure_object::BearerToken,
105        #[path(
106            name = "uploadId",
107            decoder = conjure_http::server::conjure::FromPlainDecoder,
108            log_as = "uploadId"
109        )]
110        upload_id: String,
111        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
112        key: String,
113        #[query(
114            name = "bucket",
115            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
116        )]
117        bucket: Option<String>,
118        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
119        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
120    ) -> Result<
121        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
122        conjure_http::private::Error,
123    >;
124    /// Aborts a multipart upload to S3.
125    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
126    #[endpoint(
127        method = POST,
128        path = "/upload/v1/multipart-upload/{uploadId}/abort",
129        name = "abortMultipartUpload"
130    )]
131    fn abort_multipart_upload(
132        &self,
133        #[auth]
134        auth_: conjure_object::BearerToken,
135        #[path(
136            name = "uploadId",
137            decoder = conjure_http::server::conjure::FromPlainDecoder,
138            log_as = "uploadId"
139        )]
140        upload_id: String,
141        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
142        key: String,
143        #[query(
144            name = "bucket",
145            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
146        )]
147        bucket: Option<String>,
148    ) -> Result<(), conjure_http::private::Error>;
149    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
150    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
151    /// without giving that service any Scout credentials. The caller must be authorized to
152    /// read the workspace that owns the path (encoded as the first segment of the object key).
153    #[endpoint(
154        method = POST,
155        path = "/upload/v1/sign-download",
156        name = "signDownload",
157        produces = conjure_http::server::StdResponseSerializer
158    )]
159    fn sign_download(
160        &self,
161        #[auth]
162        auth_: conjure_object::BearerToken,
163        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
164        request: super::super::super::super::objects::ingest::api::SignDownloadRequest,
165    ) -> Result<
166        super::super::super::super::objects::ingest::api::SignDownloadResponse,
167        conjure_http::private::Error,
168    >;
169    /// Uploads a file to S3. Intended for smaller files.
170    #[endpoint(
171        method = POST,
172        path = "/upload/v1/upload-file",
173        name = "uploadFile",
174        produces = conjure_http::server::StdResponseSerializer
175    )]
176    fn upload_file(
177        &self,
178        #[auth]
179        auth_: conjure_object::BearerToken,
180        #[query(
181            name = "fileName",
182            decoder = conjure_http::server::conjure::FromPlainDecoder,
183            log_as = "fileName"
184        )]
185        file_name: String,
186        #[query(
187            name = "sizeBytes",
188            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
189            log_as = "sizeBytes"
190        )]
191        size_bytes: Option<conjure_object::SafeLong>,
192        #[query(
193            name = "workspace",
194            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
195        )]
196        workspace: Option<conjure_object::ResourceIdentifier>,
197        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
198        body: I,
199    ) -> Result<String, conjure_http::private::Error>;
200}
201/// The Upload Service manages file uploads to object storage.
202#[conjure_http::conjure_endpoints(
203    name = "UploadService",
204    use_legacy_error_serialization
205)]
206pub trait AsyncUploadService<#[request_body] I> {
207    /// Initiates a multipart upload to object storage.
208    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
209    #[endpoint(
210        method = POST,
211        path = "/upload/v1/multipart-upload",
212        name = "initiateMultipartUpload",
213        produces = conjure_http::server::StdResponseSerializer
214    )]
215    async fn initiate_multipart_upload(
216        &self,
217        #[auth]
218        auth_: conjure_object::BearerToken,
219        #[body(
220            deserializer = conjure_http::server::StdRequestDeserializer,
221            log_as = "uploadRequest"
222        )]
223        upload_request: super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
224    ) -> Result<
225        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
226        conjure_http::private::Error,
227    >;
228    /// Lists the parts that have been uploaded for a given uploadId.
229    #[endpoint(
230        method = GET,
231        path = "/upload/v1/multipart-upload/{uploadId}",
232        name = "listParts",
233        produces = conjure_http::server::conjure::CollectionResponseSerializer
234    )]
235    async fn list_parts(
236        &self,
237        #[auth]
238        auth_: conjure_object::BearerToken,
239        #[path(
240            name = "uploadId",
241            decoder = conjure_http::server::conjure::FromPlainDecoder,
242            log_as = "uploadId"
243        )]
244        upload_id: String,
245        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
246        key: String,
247        #[query(
248            name = "bucket",
249            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
250        )]
251        bucket: Option<String>,
252    ) -> Result<
253        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
254        conjure_http::private::Error,
255    >;
256    /// Signs an upload request for a single part.
257    /// Returns a URL that will execute the upload without further authentication.
258    #[endpoint(
259        method = POST,
260        path = "/upload/v1/multipart-upload/{uploadId}",
261        name = "signPart",
262        produces = conjure_http::server::StdResponseSerializer
263    )]
264    async fn sign_part(
265        &self,
266        #[auth]
267        auth_: conjure_object::BearerToken,
268        #[path(
269            name = "uploadId",
270            decoder = conjure_http::server::conjure::FromPlainDecoder,
271            log_as = "uploadId"
272        )]
273        upload_id: String,
274        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
275        key: String,
276        #[query(
277            name = "partNumber",
278            decoder = conjure_http::server::conjure::FromPlainDecoder,
279            log_as = "partNumber"
280        )]
281        part_number: i32,
282        #[query(
283            name = "bucket",
284            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
285        )]
286        bucket: Option<String>,
287    ) -> Result<
288        super::super::super::super::objects::ingest::api::SignPartResponse,
289        conjure_http::private::Error,
290    >;
291    /// Completes a multipart upload to object storage.
292    /// This should be called after all parts have been uploaded.
293    /// Will throw EmptyMultipartUpload if there are 0 parts.
294    #[endpoint(
295        method = POST,
296        path = "/upload/v1/multipart-upload/{uploadId}/complete",
297        name = "completeMultipartUpload",
298        produces = conjure_http::server::StdResponseSerializer
299    )]
300    async fn complete_multipart_upload(
301        &self,
302        #[auth]
303        auth_: conjure_object::BearerToken,
304        #[path(
305            name = "uploadId",
306            decoder = conjure_http::server::conjure::FromPlainDecoder,
307            log_as = "uploadId"
308        )]
309        upload_id: String,
310        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
311        key: String,
312        #[query(
313            name = "bucket",
314            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
315        )]
316        bucket: Option<String>,
317        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
318        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
319    ) -> Result<
320        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
321        conjure_http::private::Error,
322    >;
323    /// Aborts a multipart upload to S3.
324    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
325    #[endpoint(
326        method = POST,
327        path = "/upload/v1/multipart-upload/{uploadId}/abort",
328        name = "abortMultipartUpload"
329    )]
330    async fn abort_multipart_upload(
331        &self,
332        #[auth]
333        auth_: conjure_object::BearerToken,
334        #[path(
335            name = "uploadId",
336            decoder = conjure_http::server::conjure::FromPlainDecoder,
337            log_as = "uploadId"
338        )]
339        upload_id: String,
340        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
341        key: String,
342        #[query(
343            name = "bucket",
344            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
345        )]
346        bucket: Option<String>,
347    ) -> Result<(), conjure_http::private::Error>;
348    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
349    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
350    /// without giving that service any Scout credentials. The caller must be authorized to
351    /// read the workspace that owns the path (encoded as the first segment of the object key).
352    #[endpoint(
353        method = POST,
354        path = "/upload/v1/sign-download",
355        name = "signDownload",
356        produces = conjure_http::server::StdResponseSerializer
357    )]
358    async fn sign_download(
359        &self,
360        #[auth]
361        auth_: conjure_object::BearerToken,
362        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
363        request: super::super::super::super::objects::ingest::api::SignDownloadRequest,
364    ) -> Result<
365        super::super::super::super::objects::ingest::api::SignDownloadResponse,
366        conjure_http::private::Error,
367    >;
368    /// Uploads a file to S3. Intended for smaller files.
369    #[endpoint(
370        method = POST,
371        path = "/upload/v1/upload-file",
372        name = "uploadFile",
373        produces = conjure_http::server::StdResponseSerializer
374    )]
375    async fn upload_file(
376        &self,
377        #[auth]
378        auth_: conjure_object::BearerToken,
379        #[query(
380            name = "fileName",
381            decoder = conjure_http::server::conjure::FromPlainDecoder,
382            log_as = "fileName"
383        )]
384        file_name: String,
385        #[query(
386            name = "sizeBytes",
387            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
388            log_as = "sizeBytes"
389        )]
390        size_bytes: Option<conjure_object::SafeLong>,
391        #[query(
392            name = "workspace",
393            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
394        )]
395        workspace: Option<conjure_object::ResourceIdentifier>,
396        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
397        body: I,
398    ) -> Result<String, conjure_http::private::Error>;
399}
400/// The Upload Service manages file uploads to object storage.
401#[conjure_http::conjure_endpoints(
402    name = "UploadService",
403    use_legacy_error_serialization,
404    local
405)]
406pub trait LocalAsyncUploadService<#[request_body] I> {
407    /// Initiates a multipart upload to object storage.
408    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
409    #[endpoint(
410        method = POST,
411        path = "/upload/v1/multipart-upload",
412        name = "initiateMultipartUpload",
413        produces = conjure_http::server::StdResponseSerializer
414    )]
415    async fn initiate_multipart_upload(
416        &self,
417        #[auth]
418        auth_: conjure_object::BearerToken,
419        #[body(
420            deserializer = conjure_http::server::StdRequestDeserializer,
421            log_as = "uploadRequest"
422        )]
423        upload_request: super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
424    ) -> Result<
425        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
426        conjure_http::private::Error,
427    >;
428    /// Lists the parts that have been uploaded for a given uploadId.
429    #[endpoint(
430        method = GET,
431        path = "/upload/v1/multipart-upload/{uploadId}",
432        name = "listParts",
433        produces = conjure_http::server::conjure::CollectionResponseSerializer
434    )]
435    async fn list_parts(
436        &self,
437        #[auth]
438        auth_: conjure_object::BearerToken,
439        #[path(
440            name = "uploadId",
441            decoder = conjure_http::server::conjure::FromPlainDecoder,
442            log_as = "uploadId"
443        )]
444        upload_id: String,
445        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
446        key: String,
447        #[query(
448            name = "bucket",
449            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
450        )]
451        bucket: Option<String>,
452    ) -> Result<
453        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
454        conjure_http::private::Error,
455    >;
456    /// Signs an upload request for a single part.
457    /// Returns a URL that will execute the upload without further authentication.
458    #[endpoint(
459        method = POST,
460        path = "/upload/v1/multipart-upload/{uploadId}",
461        name = "signPart",
462        produces = conjure_http::server::StdResponseSerializer
463    )]
464    async fn sign_part(
465        &self,
466        #[auth]
467        auth_: conjure_object::BearerToken,
468        #[path(
469            name = "uploadId",
470            decoder = conjure_http::server::conjure::FromPlainDecoder,
471            log_as = "uploadId"
472        )]
473        upload_id: String,
474        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
475        key: String,
476        #[query(
477            name = "partNumber",
478            decoder = conjure_http::server::conjure::FromPlainDecoder,
479            log_as = "partNumber"
480        )]
481        part_number: i32,
482        #[query(
483            name = "bucket",
484            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
485        )]
486        bucket: Option<String>,
487    ) -> Result<
488        super::super::super::super::objects::ingest::api::SignPartResponse,
489        conjure_http::private::Error,
490    >;
491    /// Completes a multipart upload to object storage.
492    /// This should be called after all parts have been uploaded.
493    /// Will throw EmptyMultipartUpload if there are 0 parts.
494    #[endpoint(
495        method = POST,
496        path = "/upload/v1/multipart-upload/{uploadId}/complete",
497        name = "completeMultipartUpload",
498        produces = conjure_http::server::StdResponseSerializer
499    )]
500    async fn complete_multipart_upload(
501        &self,
502        #[auth]
503        auth_: conjure_object::BearerToken,
504        #[path(
505            name = "uploadId",
506            decoder = conjure_http::server::conjure::FromPlainDecoder,
507            log_as = "uploadId"
508        )]
509        upload_id: String,
510        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
511        key: String,
512        #[query(
513            name = "bucket",
514            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
515        )]
516        bucket: Option<String>,
517        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
518        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
519    ) -> Result<
520        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
521        conjure_http::private::Error,
522    >;
523    /// Aborts a multipart upload to S3.
524    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
525    #[endpoint(
526        method = POST,
527        path = "/upload/v1/multipart-upload/{uploadId}/abort",
528        name = "abortMultipartUpload"
529    )]
530    async fn abort_multipart_upload(
531        &self,
532        #[auth]
533        auth_: conjure_object::BearerToken,
534        #[path(
535            name = "uploadId",
536            decoder = conjure_http::server::conjure::FromPlainDecoder,
537            log_as = "uploadId"
538        )]
539        upload_id: String,
540        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
541        key: String,
542        #[query(
543            name = "bucket",
544            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
545        )]
546        bucket: Option<String>,
547    ) -> Result<(), conjure_http::private::Error>;
548    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
549    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
550    /// without giving that service any Scout credentials. The caller must be authorized to
551    /// read the workspace that owns the path (encoded as the first segment of the object key).
552    #[endpoint(
553        method = POST,
554        path = "/upload/v1/sign-download",
555        name = "signDownload",
556        produces = conjure_http::server::StdResponseSerializer
557    )]
558    async fn sign_download(
559        &self,
560        #[auth]
561        auth_: conjure_object::BearerToken,
562        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
563        request: super::super::super::super::objects::ingest::api::SignDownloadRequest,
564    ) -> Result<
565        super::super::super::super::objects::ingest::api::SignDownloadResponse,
566        conjure_http::private::Error,
567    >;
568    /// Uploads a file to S3. Intended for smaller files.
569    #[endpoint(
570        method = POST,
571        path = "/upload/v1/upload-file",
572        name = "uploadFile",
573        produces = conjure_http::server::StdResponseSerializer
574    )]
575    async fn upload_file(
576        &self,
577        #[auth]
578        auth_: conjure_object::BearerToken,
579        #[query(
580            name = "fileName",
581            decoder = conjure_http::server::conjure::FromPlainDecoder,
582            log_as = "fileName"
583        )]
584        file_name: String,
585        #[query(
586            name = "sizeBytes",
587            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
588            log_as = "sizeBytes"
589        )]
590        size_bytes: Option<conjure_object::SafeLong>,
591        #[query(
592            name = "workspace",
593            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
594        )]
595        workspace: Option<conjure_object::ResourceIdentifier>,
596        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
597        body: I,
598    ) -> Result<String, conjure_http::private::Error>;
599}
nominal_api_conjure/conjure/endpoints/upload/api/upload_service.rs

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