JavaScript is disabled, refresh for a better experience. ambee/giterated

ambee/giterated

Git repository hosting, collaboration, and discovery for the Fediverse.

no clue what this is

View files Patch

Amber - ⁨1⁩ year ago

parent: tbd commit: ⁨7889bf6⁩

⁨giterated-core/giterated-models/src/repository/operations.rs⁩ - ⁨13843⁩ bytes
Raw
1 use serde::{Deserialize, Serialize};
2
3 use crate::{
4 error::{OperationError, RepositoryError},
5 object::Object,
6 object_backend::ObjectBackend,
7 operation::{GiteratedOperation, OperationState},
8 };
9
10 use super::{
11 Commit, IssueLabel, Repository, RepositoryBranch, RepositoryDiff, RepositoryFile,
12 RepositoryIssue, RepositoryStatistics, RepositoryTreeEntry, RepositoryView,
13 };
14
15 /// A request to get a repository's information.
16 ///
17 /// # Authentication
18 /// - Instance Authentication
19 /// - Validate request against the `issued_for` public key
20 /// - Validate User token against the user's instance's public key
21 /// # Authorization
22 /// - User Authorization
23 /// - Potential User permissions checks
24 #[derive(Clone, Debug, Serialize, Deserialize)]
25 pub struct RepositoryInfoRequest {
26 pub extra_metadata: bool,
27 pub rev: Option<String>,
28 pub path: Option<String>,
29 }
30
31 impl GiteratedOperation<Repository> for RepositoryInfoRequest {
32 type Success = RepositoryView;
33 type Failure = RepositoryError;
34 }
35
36 /// A request to get a file from a repository using the given id.
37 ///
38 /// # Authentication
39 /// - Instance Authentication
40 /// - Validate request against the `issued_for` public key
41 /// - Validate User token against the user's instance's public key
42 /// # Authorization
43 /// - User Authorization
44 /// - Potential User permissions checks
45 #[derive(Clone, Debug, Serialize, Deserialize)]
46 pub struct RepositoryFileFromIdRequest(pub String);
47
48 impl GiteratedOperation<Repository> for RepositoryFileFromIdRequest {
49 type Success = RepositoryFile;
50 type Failure = RepositoryError;
51 }
52
53 /// A request to get a file from a repository using the given relative path.
54 /// Also returns the commit id of the rev.
55 ///
56 /// # Authentication
57 /// - Instance Authentication
58 /// - Validate request against the `issued_for` public key
59 /// - Validate User token against the user's instance's public key
60 /// # Authorization
61 /// - User Authorization
62 /// - Potential User permissions checks
63 #[derive(Clone, Debug, Serialize, Deserialize)]
64 pub struct RepositoryFileFromPathRequest {
65 pub rev: Option<String>,
66 pub path: String,
67 }
68
69 impl GiteratedOperation<Repository> for RepositoryFileFromPathRequest {
70 type Success = (RepositoryFile, String);
71 type Failure = RepositoryError;
72 }
73
74 /// A request to get the last commit made to a file, using a starting point and the path.
75 ///
76 /// # Authentication
77 /// - Instance Authentication
78 /// - Validate request against the `issued_for` public key
79 /// - Validate User token against the user's instance's public key
80 /// # Authorization
81 /// - User Authorization
82 /// - Potential User permissions checks
83 #[derive(Clone, Debug, Serialize, Deserialize)]
84 pub struct RepositoryLastCommitOfFileRequest {
85 /// ID of commit to start at
86 pub start_commit: String,
87 // Path of the file
88 pub path: String,
89 }
90
91 impl GiteratedOperation<Repository> for RepositoryLastCommitOfFileRequest {
92 type Success = Commit;
93 type Failure = RepositoryError;
94 }
95
96 /// A request to get the commit by the specified id.
97 ///
98 /// # Authentication
99 /// - Instance Authentication
100 /// - Validate request against the `issued_for` public key
101 /// - Validate User token against the user's instance's public key
102 /// # Authorization
103 /// - User Authorization
104 /// - Potential User permissions checks
105 #[derive(Clone, Debug, Serialize, Deserialize)]
106 pub struct RepositoryCommitFromIdRequest(pub String);
107
108 impl GiteratedOperation<Repository> for RepositoryCommitFromIdRequest {
109 type Success = Commit;
110 type Failure = RepositoryError;
111 }
112
113 /// A request to get the difference between two repository trees.
114 ///
115 /// # Authentication
116 /// - Instance Authentication
117 /// - Validate request against the `issued_for` public key
118 /// - Validate User token against the user's instance's public key
119 /// # Authorization
120 /// - User Authorization
121 /// - Potential User permissions checks
122 #[derive(Clone, Debug, Serialize, Deserialize)]
123 pub struct RepositoryDiffRequest {
124 pub old_id: String,
125 pub new_id: String,
126 }
127
128 impl GiteratedOperation<Repository> for RepositoryDiffRequest {
129 type Success = RepositoryDiff;
130 type Failure = RepositoryError;
131 }
132
133 /// A request to get the difference between two repository trees as a unified git patch.
134 ///
135 /// # Authentication
136 /// - Instance Authentication
137 /// - Validate request against the `issued_for` public key
138 /// - Validate User token against the user's instance's public key
139 /// # Authorization
140 /// - User Authorization
141 /// - Potential User permissions checks
142 #[derive(Clone, Debug, Serialize, Deserialize)]
143 pub struct RepositoryDiffPatchRequest {
144 pub old_id: String,
145 pub new_id: String,
146 }
147
148 impl GiteratedOperation<Repository> for RepositoryDiffPatchRequest {
149 type Success = String;
150 type Failure = RepositoryError;
151 }
152
153 /// A request to get the commit before the one with the passed id
154 ///
155 /// # Authentication
156 /// - Instance Authentication
157 /// - Validate request against the `issued_for` public key
158 /// - Validate User token against the user's instance's public key
159 /// # Authorization
160 /// - User Authorization
161 /// - Potential User permissions checks
162 #[derive(Clone, Debug, Serialize, Deserialize)]
163 pub struct RepositoryCommitBeforeRequest(pub String);
164
165 impl GiteratedOperation<Repository> for RepositoryCommitBeforeRequest {
166 type Success = Commit;
167 type Failure = RepositoryError;
168 }
169
170 #[derive(Clone, Debug, Serialize, Deserialize)]
171 pub struct RepositoryIssuesCountRequest;
172
173 impl GiteratedOperation<Repository> for RepositoryIssuesCountRequest {
174 type Success = u64;
175 type Failure = RepositoryError;
176 }
177
178 /// A request to get a repository's issues count.
179 ///
180 /// # Authentication
181 /// - Instance Authentication
182 /// - Validate request against the `issued_for` public key
183 /// - Validate User token against the user's instance's public key
184 /// # Authorization
185 /// - User Authorization
186 /// - Potential User permissions checks
187 #[derive(Clone, Debug, Serialize, Deserialize)]
188 pub struct RepositoryIssueLabelsRequest;
189
190 impl GiteratedOperation<Repository> for RepositoryIssueLabelsRequest {
191 type Success = Vec<IssueLabel>;
192 type Failure = RepositoryError;
193 }
194
195 /// A request to get a repository's issue labels.
196 ///
197 /// # Authentication
198 /// - Instance Authentication
199 /// - Validate request against the `issued_for` public key
200 /// - Validate User token against the user's instance's public key
201 /// # Authorization
202 /// - User Authorization
203 /// - Potential User permissions checks
204 #[derive(Clone, Debug, Serialize, Deserialize)]
205 pub struct RepositoryIssuesRequest;
206
207 impl GiteratedOperation<Repository> for RepositoryIssuesRequest {
208 type Success = Vec<RepositoryIssue>;
209 type Failure = RepositoryError;
210 }
211
212 /// A request to inspect the tree of a repository.
213 ///
214 /// # Authentication
215 /// - Instance Authentication
216 /// - Validate request against the `issued_for` public key
217 /// - Validate User token against the user's instance's public key
218 /// # Authorization
219 /// - User Authorization
220 /// - Potential User permissions checks
221 #[derive(Clone, Debug, Serialize, Deserialize)]
222 pub struct RepositoryFileInspectRequest {
223 /// Whether to get extra metadata for every entry (file mode, size and last commit made to it).
224 pub extra_metadata: bool,
225 /// Revision of the repository to get (branch, commit id).
226 pub rev: Option<String>,
227 /// If not given a path, it'll default to the base.
228 pub path: Option<String>,
229 }
230
231 impl GiteratedOperation<Repository> for RepositoryFileInspectRequest {
232 type Success = Vec<RepositoryTreeEntry>;
233 type Failure = RepositoryError;
234 }
235
236 /// A request to get the statistics of repository.
237 ///
238 /// # Authentication
239 /// - Instance Authentication
240 /// - Validate request against the `issued_for` public key
241 /// - Validate User token against the user's instance's public key
242 /// # Authorization
243 /// - User Authorization
244 /// - Potential User permissions checks
245 #[derive(Clone, Debug, Serialize, Deserialize)]
246 pub struct RepositoryStatisticsRequest {
247 /// Revision of the repository to get (branch, commit id).
248 pub rev: Option<String>,
249 }
250
251 impl GiteratedOperation<Repository> for RepositoryStatisticsRequest {
252 type Success = RepositoryStatistics;
253 type Failure = RepositoryError;
254 }
255
256 /// A request to get a list of branches in the repository.
257 /// Skips over references with invalid UTF-8 names.
258 ///
259 /// # Authentication
260 /// - Instance Authentication
261 /// - Validate request against the `issued_for` public key
262 /// - Validate User token against the user's instance's public key
263 /// # Authorization
264 /// - User Authorization
265 /// - Potential User permissions checks
266 #[derive(Clone, Debug, Serialize, Deserialize)]
267 pub struct RepositoryBranchesRequest;
268
269 impl GiteratedOperation<Repository> for RepositoryBranchesRequest {
270 type Success = Vec<RepositoryBranch>;
271 type Failure = RepositoryError;
272 }
273
274 impl<B: ObjectBackend<OS> + std::fmt::Debug, OS> Object<Repository, B, OS> {
275 pub async fn info(
276 &mut self,
277 extra_metadata: bool,
278 rev: Option<String>,
279 path: Option<String>,
280 operation_state: &mut OS,
281 ) -> Result<RepositoryView, OperationError<RepositoryError>> {
282 self.request::<RepositoryInfoRequest>(
283 RepositoryInfoRequest {
284 extra_metadata,
285 rev,
286 path,
287 },
288 operation_state,
289 )
290 .await
291 }
292
293 pub async fn file_from_id(
294 &mut self,
295 id: String,
296 operation_state: &mut OS,
297 ) -> Result<RepositoryFile, OperationError<RepositoryError>> {
298 self.request::<RepositoryFileFromIdRequest>(
299 RepositoryFileFromIdRequest(id),
300 operation_state,
301 )
302 .await
303 }
304
305 pub async fn file_from_path(
306 &mut self,
307 rev: Option<String>,
308 path: String,
309 operation_state: &mut OS,
310 ) -> Result<(RepositoryFile, String), OperationError<RepositoryError>> {
311 self.request::<RepositoryFileFromPathRequest>(
312 RepositoryFileFromPathRequest { rev, path },
313 operation_state,
314 )
315 .await
316 }
317
318 pub async fn last_commit_of_file(
319 &mut self,
320 start_commit: String,
321 path: String,
322 operation_state: &mut OS,
323 ) -> Result<Commit, OperationError<RepositoryError>> {
324 self.request::<RepositoryLastCommitOfFileRequest>(
325 RepositoryLastCommitOfFileRequest { start_commit, path },
326 operation_state,
327 )
328 .await
329 }
330
331 pub async fn commit_by_id(
332 &mut self,
333 id: String,
334 operation_state: &mut OS,
335 ) -> Result<Commit, OperationError<RepositoryError>> {
336 self.request::<RepositoryCommitFromIdRequest>(
337 RepositoryCommitFromIdRequest(id),
338 operation_state,
339 )
340 .await
341 }
342
343 pub async fn diff(
344 &mut self,
345 old_id: String,
346 new_id: String,
347 operation_state: &mut OS,
348 ) -> Result<RepositoryDiff, OperationError<RepositoryError>> {
349 self.request::<RepositoryDiffRequest>(
350 RepositoryDiffRequest { old_id, new_id },
351 operation_state,
352 )
353 .await
354 }
355
356 pub async fn diff_patch(
357 &mut self,
358 old_id: String,
359 new_id: String,
360 operation_state: &mut OS,
361 ) -> Result<String, OperationError<RepositoryError>> {
362 self.request::<RepositoryDiffPatchRequest>(
363 RepositoryDiffPatchRequest { old_id, new_id },
364 operation_state,
365 )
366 .await
367 }
368
369 pub async fn commit_before(
370 &mut self,
371 id: String,
372 operation_state: &mut OS,
373 ) -> Result<Commit, OperationError<RepositoryError>> {
374 self.request::<RepositoryCommitBeforeRequest>(
375 RepositoryCommitBeforeRequest(id),
376 operation_state,
377 )
378 .await
379 }
380
381 pub async fn statistics(
382 &mut self,
383 rev: Option<String>,
384 operation_state: &mut OS,
385 ) -> Result<RepositoryStatistics, OperationError<RepositoryError>> {
386 self.request::<RepositoryStatisticsRequest>(
387 RepositoryStatisticsRequest { rev },
388 operation_state,
389 )
390 .await
391 }
392
393 pub async fn branches(
394 &mut self,
395 operation_state: &mut OS,
396 ) -> Result<Vec<RepositoryBranch>, OperationError<RepositoryError>> {
397 self.request::<RepositoryBranchesRequest>(RepositoryBranchesRequest, operation_state)
398 .await
399 }
400
401 // pub async fn issues_count(&mut self) -> Result<u64, OperationError<RepositoryError>> {
402 // self.request::<RepositoryIssuesCountRequest>(RepositoryIssuesCountRequest)
403 // .await
404 // }
405
406 pub async fn issue_labels(
407 &mut self,
408 operation_state: &mut OS,
409 ) -> Result<Vec<IssueLabel>, OperationError<RepositoryError>> {
410 self.request::<RepositoryIssueLabelsRequest>(RepositoryIssueLabelsRequest, operation_state)
411 .await
412 }
413
414 pub async fn issues(
415 &mut self,
416 operation_state: &mut OS,
417 ) -> Result<Vec<RepositoryIssue>, OperationError<RepositoryError>> {
418 self.request::<RepositoryIssuesRequest>(RepositoryIssuesRequest, operation_state)
419 .await
420 }
421
422 pub async fn inspect_files(
423 &mut self,
424 extra_metadata: bool,
425 rev: Option<&str>,
426 path: Option<&str>,
427 operation_state: &mut OS,
428 ) -> Result<Vec<RepositoryTreeEntry>, OperationError<RepositoryError>> {
429 self.request::<RepositoryFileInspectRequest>(
430 RepositoryFileInspectRequest {
431 extra_metadata,
432 rev: rev.map(|r| r.to_string()),
433 path: path.map(|p| p.to_string()),
434 },
435 operation_state,
436 )
437 .await
438 }
439 }
440