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

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