Skip to main content

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            safe
196        )]
197        workspace: Option<super::super::super::super::objects::api::rids::WorkspaceRid>,
198        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
199        body: I,
200    ) -> Result<
201        super::super::super::super::objects::api::S3Path,
202        conjure_http::private::Error,
203    >;
204}
205/// The Upload Service manages file uploads to object storage.
206#[conjure_http::conjure_endpoints(
207    name = "UploadService",
208    use_legacy_error_serialization
209)]
210pub trait AsyncUploadService<#[request_body] I> {
211    /// Initiates a multipart upload to object storage.
212    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
213    #[endpoint(
214        method = POST,
215        path = "/upload/v1/multipart-upload",
216        name = "initiateMultipartUpload",
217        produces = conjure_http::server::StdResponseSerializer
218    )]
219    async fn initiate_multipart_upload(
220        &self,
221        #[auth]
222        auth_: conjure_object::BearerToken,
223        #[body(
224            deserializer = conjure_http::server::StdRequestDeserializer,
225            log_as = "uploadRequest"
226        )]
227        upload_request: super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
228    ) -> Result<
229        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
230        conjure_http::private::Error,
231    >;
232    /// Lists the parts that have been uploaded for a given uploadId.
233    #[endpoint(
234        method = GET,
235        path = "/upload/v1/multipart-upload/{uploadId}",
236        name = "listParts",
237        produces = conjure_http::server::conjure::CollectionResponseSerializer
238    )]
239    async fn list_parts(
240        &self,
241        #[auth]
242        auth_: conjure_object::BearerToken,
243        #[path(
244            name = "uploadId",
245            decoder = conjure_http::server::conjure::FromPlainDecoder,
246            log_as = "uploadId"
247        )]
248        upload_id: String,
249        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
250        key: String,
251        #[query(
252            name = "bucket",
253            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
254        )]
255        bucket: Option<String>,
256    ) -> Result<
257        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
258        conjure_http::private::Error,
259    >;
260    /// Signs an upload request for a single part.
261    /// Returns a URL that will execute the upload without further authentication.
262    #[endpoint(
263        method = POST,
264        path = "/upload/v1/multipart-upload/{uploadId}",
265        name = "signPart",
266        produces = conjure_http::server::StdResponseSerializer
267    )]
268    async fn sign_part(
269        &self,
270        #[auth]
271        auth_: conjure_object::BearerToken,
272        #[path(
273            name = "uploadId",
274            decoder = conjure_http::server::conjure::FromPlainDecoder,
275            log_as = "uploadId"
276        )]
277        upload_id: String,
278        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
279        key: String,
280        #[query(
281            name = "partNumber",
282            decoder = conjure_http::server::conjure::FromPlainDecoder,
283            log_as = "partNumber"
284        )]
285        part_number: i32,
286        #[query(
287            name = "bucket",
288            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
289        )]
290        bucket: Option<String>,
291    ) -> Result<
292        super::super::super::super::objects::ingest::api::SignPartResponse,
293        conjure_http::private::Error,
294    >;
295    /// Completes a multipart upload to object storage.
296    /// This should be called after all parts have been uploaded.
297    /// Will throw EmptyMultipartUpload if there are 0 parts.
298    #[endpoint(
299        method = POST,
300        path = "/upload/v1/multipart-upload/{uploadId}/complete",
301        name = "completeMultipartUpload",
302        produces = conjure_http::server::StdResponseSerializer
303    )]
304    async fn complete_multipart_upload(
305        &self,
306        #[auth]
307        auth_: conjure_object::BearerToken,
308        #[path(
309            name = "uploadId",
310            decoder = conjure_http::server::conjure::FromPlainDecoder,
311            log_as = "uploadId"
312        )]
313        upload_id: String,
314        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
315        key: String,
316        #[query(
317            name = "bucket",
318            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
319        )]
320        bucket: Option<String>,
321        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
322        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
323    ) -> Result<
324        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
325        conjure_http::private::Error,
326    >;
327    /// Aborts a multipart upload to S3.
328    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
329    #[endpoint(
330        method = POST,
331        path = "/upload/v1/multipart-upload/{uploadId}/abort",
332        name = "abortMultipartUpload"
333    )]
334    async fn abort_multipart_upload(
335        &self,
336        #[auth]
337        auth_: conjure_object::BearerToken,
338        #[path(
339            name = "uploadId",
340            decoder = conjure_http::server::conjure::FromPlainDecoder,
341            log_as = "uploadId"
342        )]
343        upload_id: String,
344        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
345        key: String,
346        #[query(
347            name = "bucket",
348            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
349        )]
350        bucket: Option<String>,
351    ) -> Result<(), conjure_http::private::Error>;
352    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
353    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
354    /// without giving that service any Scout credentials. The caller must be authorized to
355    /// read the workspace that owns the path (encoded as the first segment of the object key).
356    #[endpoint(
357        method = POST,
358        path = "/upload/v1/sign-download",
359        name = "signDownload",
360        produces = conjure_http::server::StdResponseSerializer
361    )]
362    async fn sign_download(
363        &self,
364        #[auth]
365        auth_: conjure_object::BearerToken,
366        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
367        request: super::super::super::super::objects::ingest::api::SignDownloadRequest,
368    ) -> Result<
369        super::super::super::super::objects::ingest::api::SignDownloadResponse,
370        conjure_http::private::Error,
371    >;
372    /// Uploads a file to S3. Intended for smaller files.
373    #[endpoint(
374        method = POST,
375        path = "/upload/v1/upload-file",
376        name = "uploadFile",
377        produces = conjure_http::server::StdResponseSerializer
378    )]
379    async fn upload_file(
380        &self,
381        #[auth]
382        auth_: conjure_object::BearerToken,
383        #[query(
384            name = "fileName",
385            decoder = conjure_http::server::conjure::FromPlainDecoder,
386            log_as = "fileName"
387        )]
388        file_name: String,
389        #[query(
390            name = "sizeBytes",
391            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
392            log_as = "sizeBytes"
393        )]
394        size_bytes: Option<conjure_object::SafeLong>,
395        #[query(
396            name = "workspace",
397            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
398            safe
399        )]
400        workspace: Option<super::super::super::super::objects::api::rids::WorkspaceRid>,
401        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
402        body: I,
403    ) -> Result<
404        super::super::super::super::objects::api::S3Path,
405        conjure_http::private::Error,
406    >;
407}
408/// The Upload Service manages file uploads to object storage.
409#[conjure_http::conjure_endpoints(
410    name = "UploadService",
411    use_legacy_error_serialization,
412    local
413)]
414pub trait LocalAsyncUploadService<#[request_body] I> {
415    /// Initiates a multipart upload to object storage.
416    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
417    #[endpoint(
418        method = POST,
419        path = "/upload/v1/multipart-upload",
420        name = "initiateMultipartUpload",
421        produces = conjure_http::server::StdResponseSerializer
422    )]
423    async fn initiate_multipart_upload(
424        &self,
425        #[auth]
426        auth_: conjure_object::BearerToken,
427        #[body(
428            deserializer = conjure_http::server::StdRequestDeserializer,
429            log_as = "uploadRequest"
430        )]
431        upload_request: super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
432    ) -> Result<
433        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
434        conjure_http::private::Error,
435    >;
436    /// Lists the parts that have been uploaded for a given uploadId.
437    #[endpoint(
438        method = GET,
439        path = "/upload/v1/multipart-upload/{uploadId}",
440        name = "listParts",
441        produces = conjure_http::server::conjure::CollectionResponseSerializer
442    )]
443    async fn list_parts(
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        #[query(
456            name = "bucket",
457            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
458        )]
459        bucket: Option<String>,
460    ) -> Result<
461        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
462        conjure_http::private::Error,
463    >;
464    /// Signs an upload request for a single part.
465    /// Returns a URL that will execute the upload without further authentication.
466    #[endpoint(
467        method = POST,
468        path = "/upload/v1/multipart-upload/{uploadId}",
469        name = "signPart",
470        produces = conjure_http::server::StdResponseSerializer
471    )]
472    async fn sign_part(
473        &self,
474        #[auth]
475        auth_: conjure_object::BearerToken,
476        #[path(
477            name = "uploadId",
478            decoder = conjure_http::server::conjure::FromPlainDecoder,
479            log_as = "uploadId"
480        )]
481        upload_id: String,
482        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
483        key: String,
484        #[query(
485            name = "partNumber",
486            decoder = conjure_http::server::conjure::FromPlainDecoder,
487            log_as = "partNumber"
488        )]
489        part_number: i32,
490        #[query(
491            name = "bucket",
492            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
493        )]
494        bucket: Option<String>,
495    ) -> Result<
496        super::super::super::super::objects::ingest::api::SignPartResponse,
497        conjure_http::private::Error,
498    >;
499    /// Completes a multipart upload to object storage.
500    /// This should be called after all parts have been uploaded.
501    /// Will throw EmptyMultipartUpload if there are 0 parts.
502    #[endpoint(
503        method = POST,
504        path = "/upload/v1/multipart-upload/{uploadId}/complete",
505        name = "completeMultipartUpload",
506        produces = conjure_http::server::StdResponseSerializer
507    )]
508    async fn complete_multipart_upload(
509        &self,
510        #[auth]
511        auth_: conjure_object::BearerToken,
512        #[path(
513            name = "uploadId",
514            decoder = conjure_http::server::conjure::FromPlainDecoder,
515            log_as = "uploadId"
516        )]
517        upload_id: String,
518        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
519        key: String,
520        #[query(
521            name = "bucket",
522            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
523        )]
524        bucket: Option<String>,
525        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
526        parts: Vec<super::super::super::super::objects::ingest::api::Part>,
527    ) -> Result<
528        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
529        conjure_http::private::Error,
530    >;
531    /// Aborts a multipart upload to S3.
532    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
533    #[endpoint(
534        method = POST,
535        path = "/upload/v1/multipart-upload/{uploadId}/abort",
536        name = "abortMultipartUpload"
537    )]
538    async fn abort_multipart_upload(
539        &self,
540        #[auth]
541        auth_: conjure_object::BearerToken,
542        #[path(
543            name = "uploadId",
544            decoder = conjure_http::server::conjure::FromPlainDecoder,
545            log_as = "uploadId"
546        )]
547        upload_id: String,
548        #[query(name = "key", decoder = conjure_http::server::conjure::FromPlainDecoder)]
549        key: String,
550        #[query(
551            name = "bucket",
552            decoder = conjure_http::server::conjure::FromPlainOptionDecoder
553        )]
554        bucket: Option<String>,
555    ) -> Result<(), conjure_http::private::Error>;
556    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
557    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
558    /// without giving that service any Scout credentials. The caller must be authorized to
559    /// read the workspace that owns the path (encoded as the first segment of the object key).
560    #[endpoint(
561        method = POST,
562        path = "/upload/v1/sign-download",
563        name = "signDownload",
564        produces = conjure_http::server::StdResponseSerializer
565    )]
566    async fn sign_download(
567        &self,
568        #[auth]
569        auth_: conjure_object::BearerToken,
570        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
571        request: super::super::super::super::objects::ingest::api::SignDownloadRequest,
572    ) -> Result<
573        super::super::super::super::objects::ingest::api::SignDownloadResponse,
574        conjure_http::private::Error,
575    >;
576    /// Uploads a file to S3. Intended for smaller files.
577    #[endpoint(
578        method = POST,
579        path = "/upload/v1/upload-file",
580        name = "uploadFile",
581        produces = conjure_http::server::StdResponseSerializer
582    )]
583    async fn upload_file(
584        &self,
585        #[auth]
586        auth_: conjure_object::BearerToken,
587        #[query(
588            name = "fileName",
589            decoder = conjure_http::server::conjure::FromPlainDecoder,
590            log_as = "fileName"
591        )]
592        file_name: String,
593        #[query(
594            name = "sizeBytes",
595            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
596            log_as = "sizeBytes"
597        )]
598        size_bytes: Option<conjure_object::SafeLong>,
599        #[query(
600            name = "workspace",
601            decoder = conjure_http::server::conjure::FromPlainOptionDecoder,
602            safe
603        )]
604        workspace: Option<super::super::super::super::objects::api::rids::WorkspaceRid>,
605        #[body(deserializer = conjure_http::server::conjure::BinaryRequestDeserializer)]
606        body: I,
607    ) -> Result<
608        super::super::super::super::objects::api::S3Path,
609        conjure_http::private::Error,
610    >;
611}