Refactor types and add edit patch command — radicle-desktop

This commit touches a few things, but ended up too broad to split up into separate commits.

Improves the hierarchy of types into separate folders
Add edit_patch tauri command similar to edit_issue.
Improve the types generation making more structs and less serde_json
Adding more optional values to the tauri commands

👉 Workflow runs 👉 Branch on GitHub

  "radicle-surf",
  "serde",
  "serde_json",
  "thiserror",
  "ts-rs",
 ]

 [[package]]
 name = "thiserror"
 version = "1.0.64"
 version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 checksum = "5d11abd9594d9b38965ef50805c5e469ca9cc6f197f883f717e0269a3057b3d5"
 dependencies = [
  "thiserror-impl",
 ]
 [[package]]
 name = "thiserror-impl"
 version = "1.0.64"
 version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 checksum = "ae71770322cbd277e69d762a16c444af02aa0575ac0d174f0b9562d3b37f8602"
 dependencies = [
  "proc-macro2",
  "quote",

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { CodeRange } from "./CodeRange";
 export type CodeLocation = {
   commit: string;
   path: string;
   old: CodeRange | null;
   new: CodeRange | null;
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 export type CodeRange =
   | { type: "lines"; range: { start: number; end: number } }
   | { type: "chars"; line: number; range: { start: number; end: number } };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { Author } from "./Author";
 import type { Edit } from "./Edit";
 import type { Reaction } from "./Reaction";
 export type Comment<T> = {
   id: string;
   author: Author;
   edits: Array<Edit>;
   reactions: Array<Reaction>;
   replyTo?: string;
   location?: T;
   embeds: { name: string; content: string }[];
   resolved: boolean;
 };

-	`// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.`
-
-	`export type Author = { did: string; alias?: string };`

-	`// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.`
-
-	`export type CobOptions = { announce?: boolean };`

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 /**
  * Service configuration.
  */
 export type Config = {
   /**
    * Node Public Key in NID format.
    */
   publicKey: string;
   /**
    * Node alias.
    */
   alias: string;
   /**
    * Default seeding policy.
    */
   seedingPolicy:
     | { default: "allow"; scope: "followed" | "all" }
     | { default: "block" };
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { CodeLocation } from "./CodeLocation";
 export type CreateReviewComment = {
   reviewId: string;
   body: string;
   replyTo: string | null;
   location: CodeLocation | null;
   embeds: { name: string; content: string }[];
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { Author } from "./Author";
 import type { Comment } from "./Comment";
 import type { Never } from "./Never";
 export type Issue = {
   id: string;
   author: Author;
   title: string;
   state: { status: "closed"; reason: "other" | "solved" } | { status: "open" };
   assignees: Array<Author>;
   discussion: Array<Comment<Never>>;
   labels: Array<string>;
   timestamp: number;
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 export type IssueAction =
   | { type: "assign"; assignees: Array<string> }
   | { type: "edit"; title: string }
   | {
       type: "lifecycle";
       state:
         | { status: "closed"; reason: "other" | "solved" }
         | { status: "open" };
     }
   | { type: "label"; labels: Array<string> }
   | {
       type: "comment";
       /**
        * Comment body.
        */
       body: string;
       /**
        * Comment this is a reply to.
        * Should be [`None` | `null`] if it's the top-level comment.
        * Should be the root [`CommentId`] if it's a top-level comment.
        */
       replyTo: string | null;
       /**
        * Embeded content.
        */
       embeds: Array<string>;
     }
   | {
       type: "comment.edit";
       /**
        * Comment being edited.
        */
       id: string;
       /**
        * New value for the comment body.
        */
       body: string;
       /**
        * New value for the embeds list.
        */
       embeds: Array<string>;
     }
   | { type: "comment.redact"; id: string }
   | { type: "comment.react"; id: string; reaction: string; active: boolean };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 /**
  * The `Infallible` type does not have a `Serialize`/`Deserialize`
  * implementation. The `Never` type imitates `Infallible` and
  * provides the derived implementations.
  */
 export type Never = never;

-	`// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.`
-
-	`export type PaginatedQuery<T> = { cursor: number; more: boolean; content: T };`

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { Author } from "./Author";
 export type Patch = {
   id: string;
   author: Author;
   title: string;
   base: string;
   head: string;
   state:
     | {
         status: "draft";
       }
     | {
         status: "open";
         conflicts: [string, string][];
       }
     | {
         status: "archived";
       }
     | {
         status: "merged";
         revision: string;
         commit: string;
       };
   assignees: Array<Author>;
   labels: Array<string>;
   timestamp: number;
   revisionCount: number;
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { Author } from "./Author";
 import type { CodeLocation } from "./CodeLocation";
 export type Reaction = {
   emoji: string;
   authors: Array<Author>;
   location?: CodeLocation;
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { Author } from "./Author";
 import type { SupportedPayloads } from "./SupportedPayloads";
 /**
  * Repos info.
  */
 export type RepoInfo = {
   payloads: SupportedPayloads;
   delegates: Array<Author>;
   threshold: number;
   visibility: { type: "public" } | { type: "private"; allow?: string[] };
   rid: string;
   seeding: number;
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 export type Stats = {
   files_changed: number;
   insertions: number;
   deletions: number;
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 export type SupportedPayloads = {
   "xyz.radicle.project"?: {
     data: {
       defaultBranch: string;
       description: string;
       name: string;
     };
     meta: {
       head: string;
       issues: {
         open: number;
         closed: number;
       };
       patches: {
         open: number;
         draft: number;
         archived: number;
         merged: number;
       };
       lastCommit: number;
     };
   };
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 export type JsonValue =
   | number
   | string
   | Array<JsonValue>
   | { [key: string]: JsonValue };

 use radicle::identity;
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle_types as types;
 use radicle_types::cobs::IssueAction;
 use crate::{error, AppState};

 pub mod issue;
 pub mod patch;
 #[derive(serde::Serialize, ts_rs::TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 pub struct IssueOp {
     #[ts(as = "String")]
     pub entry_id: git::Oid,
     #[serde(flatten)]
     pub action: types::cobs::IssueAction,
     #[ts(type = "number")]
     pub timestamp: cob::Timestamp,
     pub author: types::cobs::Author,
 }
 #[tauri::command]
 pub async fn get_file_by_oid(
     ctx: tauri::State<'_, AppState>,

     rid: identity::RepoId,
     type_name: cob::TypeName,
     id: git::Oid,
 ) -> Result<Vec<IssueOp>, error::Error> {
 ) -> Result<Vec<types::cobs::issue::Operation>, error::Error> {
     let aliases = ctx.profile.aliases();
     let repo = ctx.profile.storage.repository(rid)?;
     let ops = cob::store::ops(&id.into(), &type_name, &repo).unwrap();
     let mut actions: Vec<IssueOp> = Vec::new();
     let mut actions: Vec<types::cobs::issue::Operation> = Vec::new();
     for op in ops.into_iter() {
         actions.extend(
             op.actions
                 .iter()
                 .filter_map(|action: &Vec<u8>| -> Option<IssueOp> {
                     let action: IssueAction = serde_json::from_slice(action).ok()?;
                     Some(IssueOp {
                         entry_id: op.id,
                         action,
                         author: types::cobs::Author::new(op.author.into(), &aliases),
                         timestamp: op.timestamp,
                     })
                 }),
         )
         actions.extend(op.actions.iter().filter_map(
             |action: &Vec<u8>| -> Option<types::cobs::issue::Operation> {
                 let action: types::cobs::issue::Action = serde_json::from_slice(action).ok()?;
                 Some(types::cobs::issue::Operation {
                     entry_id: op.id,
                     action,
                     author: types::cobs::Author::new(op.author.into(), &aliases),
                     timestamp: op.timestamp,
                 })
             },
         ))
     }
     Ok::<_, error::Error>(actions)

 use radicle::git;
 use radicle::identity::RepoId;
 use radicle::identity;
 use radicle::issue::cache::Issues;
 use radicle::node::Handle;
 use radicle::node::Node;
 use radicle::storage::ReadStorage;
 use radicle_types::cobs;
 use radicle_types as types;
 use crate::cob::query;
 use crate::error::Error;

 #[tauri::command]
 pub fn create_issue(
     ctx: tauri::State<AppState>,
     rid: RepoId,
     new: cobs::NewIssue,
     opts: cobs::CobOptions,
 ) -> Result<cobs::Issue, Error> {
     rid: identity::RepoId,
     new: types::cobs::issue::NewIssue,
     opts: types::cobs::CobOptions,
 ) -> Result<types::cobs::issue::Issue, Error> {
     let mut node = Node::new(ctx.profile.socket());
     let repo = ctx.profile.storage.repository(rid)?;
     let signer = ctx.profile.signer()?;

         new.description,
         &new.labels,
         &new.assignees,
         new.embeds,
         new.embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
         &signer,
     )?;

     let mut issue = issues.get_mut(&cob_id.into())?;
     match action {
         cobs::IssueAction::Lifecycle { state } => {
             issue.lifecycle(state, &signer)?;
         types::cobs::issue::Action::Lifecycle { state } => {
             issue.lifecycle(state.into(), &signer)?;
         }
         cobs::IssueAction::Assign { assignees } => {
         types::cobs::issue::Action::Assign { assignees } => {
             issue.assign(assignees, &signer)?;
         }
         cobs::IssueAction::Label { labels } => {
         types::cobs::issue::Action::Label { labels } => {
             issue.label(labels, &signer)?;
         }
         cobs::IssueAction::CommentReact {
         types::cobs::issue::Action::CommentReact {
             id,
             reaction,
             active,
         } => {
             issue.react(id, reaction, active, &signer)?;
         }
         cobs::IssueAction::CommentRedact { id } => {
         types::cobs::issue::Action::CommentRedact { id } => {
             issue.redact_comment(id, &signer)?;
         }
         cobs::IssueAction::Comment {
         types::cobs::issue::Action::Comment {
             body,
             reply_to,
             embeds,
         } => {
             issue.comment(body, reply_to.unwrap_or(cob_id), embeds, &signer)?;
             issue.comment(
                 body,
                 reply_to.unwrap_or(cob_id),
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         cobs::IssueAction::CommentEdit { id, body, embeds } => {
             issue.edit_comment(id, body, embeds, &signer)?;
         types::cobs::issue::Action::CommentEdit { id, body, embeds } => {
             issue.edit_comment(
                 id,
                 body,
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         cobs::IssueAction::Edit { title } => {
         types::cobs::issue::Action::Edit { title } => {
             issue.edit(title, &signer)?;
         }
     }

         node.announce_refs(rid)?;
     }
     Ok::<_, Error>(cobs::Issue::new(issue.id(), &issue, &aliases))
     Ok::<_, Error>(types::cobs::issue::Issue::new(issue.id(), &issue, &aliases))
 }
 #[tauri::command]
 pub fn list_issues(
     ctx: tauri::State<AppState>,
     rid: RepoId,
     rid: identity::RepoId,
     status: query::IssueStatus,
 ) -> Result<Vec<cobs::Issue>, Error> {
 ) -> Result<Vec<types::cobs::issue::Issue>, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let issues = ctx.profile.issues(&repo)?;
     let mut issues: Vec<_> = issues

     let aliases = &ctx.profile.aliases();
     let issues = issues
         .into_iter()
         .map(|(id, issue)| cobs::Issue::new(&id, &issue, aliases))
         .map(|(id, issue)| types::cobs::issue::Issue::new(&id, &issue, aliases))
         .collect::<Vec<_>>();
     Ok::<_, Error>(issues)

 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use radicle::cob;
 use radicle::git;
 use radicle::identity;
 use radicle::node::Handle;
 use radicle::node::Node;
 use radicle::patch;
 use radicle::patch::cache::Patches;
 use radicle::storage;
 use radicle::storage::ReadStorage;
 use radicle_types::cobs;
 use radicle_types::thread;
 use radicle_types as types;
 use crate::cob::query;
 use crate::error::Error;
 use crate::AppState;
 #[derive(Serialize, Deserialize, TS)]
 #[ts(export)]
 pub struct PaginatedQuery<T> {
     pub cursor: usize,
     pub more: bool,
     pub content: T,
 }
 #[tauri::command]
 pub async fn list_patches(
     ctx: tauri::State<'_, AppState>,

     status: Option<query::PatchStatus>,
     skip: Option<usize>,
     take: Option<usize>,
 ) -> Result<PaginatedQuery<Vec<cobs::Patch>>, Error> {
 ) -> Result<types::cobs::PaginatedQuery<Vec<types::cobs::patch::Patch>>, Error> {
     let cursor = skip.unwrap_or(0);
     let take = take.unwrap_or(20);
     let repo = ctx.profile.storage.repository(rid)?;

     let mut patches = patches
         .into_iter()
         .filter_map(|p| {
             p.map(|(id, patch)| cobs::Patch::new(id, patch, aliases))
             p.map(|(id, patch)| types::cobs::patch::Patch::new(id, &patch, aliases))
                 .ok()
         })
         .skip(cursor)

     patches.sort_by_key(|b| std::cmp::Reverse(b.timestamp()));
     Ok::<_, Error>(PaginatedQuery {
     Ok::<_, Error>(types::cobs::PaginatedQuery {
         cursor,
         more,
         content: patches,

     ctx: tauri::State<AppState>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Option<cobs::Patch>, Error> {
 ) -> Result<Option<types::cobs::patch::Patch>, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let patches = ctx.profile.patches(&repo)?;
     let patch = patches.get(&id.into())?;
     let aliases = &ctx.profile.aliases();
     let patches = patch.map(|patch| cobs::Patch::new(id.into(), patch, aliases));
     let patches = patch.map(|patch| types::cobs::patch::Patch::new(id.into(), &patch, aliases));
     Ok::<_, Error>(patches)
 }

         patch
             .revisions()
             .map(|(_, r)| cobs::Revision::new(r.clone(), aliases))
             .map(|(_, r)| types::cobs::patch::Revision::new(r.clone(), aliases))
             .collect::<Vec<_>>()
     });

         patch
             .revision(&revision_id.into())
             .map(|r| cobs::Revision::new(r.clone(), aliases))
             .map(|r| types::cobs::patch::Revision::new(r.clone(), aliases))
     });
     Ok::<_, Error>(revision)